Step 7 Einstellbarer FIFO für eine Versorgung

[.Neueinsteiger.]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo zusammen,

Bin neu hier und habe auch die SuFu genutzt leider aber nichts passendes für mich gefunden.

In Programmieren bin ich noch nicht so bewandert und habe daher nur wenig Erfahrung damit. Habe meine Umschulung letztes Jahr zum Mechatroniker angefangen. Daher wende ich mich an euch und hoffe auf Hilfe.

Ich suche nach einem FIFO Regal welches die eingelesene Signale (bis zu 20 Anliegende Signale) nach FIFO Sortiert. Und ein Signal über eine Zeit X (einstellbar) ausgibt. Nach der Ausgabe soll eine Zeit X (einstellbar) gewartet werden bis das nächste Signal Ausgegeben wird.

Wenn Intern im Baustein ein Signal verarbeitet wurde soll das Signal aus dem Speicher gelöscht werden.

Ich möchte mit dem Baustein mein erstes größeres Projekt realisieren. (Materialversorung für bis zu 20 Clienten über EIN Vacuum System) Bis auf dem FIFO hätte ich auch die Steuerung fertig.

Programmiert hatte ich bisher nur kleine Steuerungen in FUP. SCL Codes in FUP ist mir geläufig. Aber selber SCL Codes erstellen fehlt mir einfach die Erfahrung.


Danke schonmal vorab für die Mühe und Hilfe.

Euer .Neueinsteiger.

 

[codemonkey]

Bin mir nicht sicher, ob ich deine Aufgabe verstanden habe. Bei FIFO und Regal denke ich an Gegenstände, die eingelagert werden. Nun dann das, was als erstes eingelagert wurde, dann auch als erstes ausgegeben wird.

Deine Beschreibung hingegen deutet eher auf eine Art Warteliste hin. In der jeder "Client" mit je einem Signal meldet, dass er bedient werden möchte und diese Clienten möchtest du der Reihenfolge nach bedienen, richtig? Als Zusatz lese ich da noch, dass zwischen der Ausgabe noch gewartet werden soll.
Schöne Aufgabe, kannst du uns noch verraten, mit welchem System du arbeitest? TIA-Portal/S7-classic?

 

[codemonkey]

Zuviel Werbung?
-> Hier kostenlos registrieren

So mal ganz grob als Idee:

FUNCTION_BLOCK "VacClient_FB"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT
      Duration : Time;
      Delay : Time;
      Request_01 : Bool;
      Request_02 : Bool;
      Request_03 : Bool;
      Request_04 : Bool;
      Request_05 : Bool;
      Request_06 : Bool;
      Request_07 : Bool;
      Request_08 : Bool;
      Request_09 : Bool;
      Request_10 : Bool;
      Request_11 : Bool;
      Request_12 : Bool;
      Request_13 : Bool;
      Request_14 : Bool;
      Request_15 : Bool;
      Request_16 : Bool;
      Request_17 : Bool;
      Request_18 : Bool;
      Request_19 : Bool;
      Request_20 : Bool;
   END_VAR

   VAR_OUTPUT
      Output_01 : Bool;
      Output_02 : Bool;
      Output_03 : Bool;
      Output_04 : Bool;
      Output_05 : Bool;
      Output_06 : Bool;
      Output_07 : Bool;
      Output_08 : Bool;
      Output_09 : Bool;
      Output_10 : Bool;
      Output_11 : Bool;
      Output_12 : Bool;
      Output_13 : Bool;
      Output_14 : Bool;
      Output_15 : Bool;
      Output_16 : Bool;
      Output_17 : Bool;
      Output_18 : Bool;
      Output_19 : Bool;
      Output_20 : Bool;
   END_VAR

   VAR
      Request : Array[1..20] of Bool;
      Output : Array[1..20] of Bool;
   END_VAR
   VAR RETAIN
      TonClient {InstructionName := 'TON_TIME'; LibVersion := '1.0'; S7_SetPoint := 'False'} : Array[1..20] of TON_TIME;
   END_VAR
   VAR
      TpDuration {InstructionName := 'TP_TIME'; LibVersion := '1.0'} : TP_TIME;
   END_VAR
   VAR RETAIN
      TonDelay {InstructionName := 'TON_TIME'; LibVersion := '1.0'} : TON_TIME;
   END_VAR
   VAR
      Signal { S7_SetPoint := 'True'} : Bool;
      ReadyNext : Bool;
      NextClient { S7_SetPoint := 'True'} : Int;
      MaxWait : Time;
      ET : Time;
   END_VAR

   VAR_TEMP
      i : Int;
   END_VAR


BEGIN
    REGION Eingänge umkopieren
        #Request[1] := #Request_01;
        #Request[2] := #Request_02;
        #Request[3] := #Request_03;
        #Request[4] := #Request_04;
        #Request[5] := #Request_05;
        #Request[6] := #Request_06;
        #Request[7] := #Request_07;
        #Request[8] := #Request_08;
        #Request[9] := #Request_09;
        #Request[10] := #Request_10;
        #Request[11] := #Request_11;
        #Request[12] := #Request_12;
        #Request[13] := #Request_13;
        #Request[14] := #Request_14;
        #Request[15] := #Request_15;
        #Request[16] := #Request_16;
        #Request[17] := #Request_17;
        #Request[18] := #Request_18;
        #Request[19] := #Request_19;
        #Request[20] := #Request_20;
    END_REGION
    
    REGION Wartezeit
        #TonDelay(IN := NOT #Signal,
                 PT := #Delay,
                 Q=>#ReadyNext);
    END_REGION
    
    
    REGION Zeiten erfassen
        FOR #i := 1 TO 20 DO
            #TonClient[#i](IN := #Request[#i] AND NOT #Output[#i],
                           PT := t#2d,
                           ET => #ET);
            //Die AND NOT Output verknüpfung setzt die Zeit zurück wenn der Client bedient wurde.
            //Die ET Abfrage ist an der Stelle nicht wirklich relevant.
        END_FOR;
    END_REGION
    
    REGION Nächster Client ermitteln
        IF #ReadyNext THEN
            #NextClient := 0; //Index für den nächten Clienten
            #MaxWait := t#50ms;
            //Client ermitteln
            FOR #i := 1 TO 20 DO
                IF #TonClient[#i].ET > #MaxWait THEN
                    #MaxWait := #TonClient[#i].ET;
                    #NextClient := #i;
                END_IF;
            END_FOR;
        END_IF;
    END_REGION
    
    REGION Impuls Signal bilden
        #TpDuration(IN := #ReadyNext AND #NextClient > 0,
                    PT := #Duration,
                    Q => #Signal);
        
        FOR #i := 1 TO 20 DO
            IF #i = #NextClient THEN
                #Output[#i] := #Signal;
            ELSE
                #Output[#i] := False;
            END_IF;
        END_FOR;
    END_REGION
    
    
    
    REGION Ausgänge umkopieren
        #Output_01 := #Output[1];
        #Output_02 := #Output[2];
        #Output_03 := #Output[3];
        #Output_04 := #Output[4];
        #Output_05 := #Output[5];
        #Output_06 := #Output[6];
        #Output_07 := #Output[7];
        #Output_08 := #Output[8];
        #Output_09 := #Output[9];
        #Output_10 := #Output[10];
        #Output_11 := #Output[11];
        #Output_12 := #Output[12];
        #Output_13 := #Output[13];
        #Output_14 := #Output[14];
        #Output_15 := #Output[15];
        #Output_16 := #Output[16];
        #Output_17 := #Output[17];
        #Output_18 := #Output[18];
        #Output_19 := #Output[19];
        #Output_20 := #Output[20];
    END_REGION
    
    
    
END_FUNCTION_BLOCK

 

[PN/DP]

@codemonkey
Müsste ein FIFO sich nicht die Reihenfolge merken, in der Signale kommen? (Damit er sie später auch in dieser Reihenfolge weitergibt)

@.Neueinsteiger.
Was ist ein "Signal", das da zwischengespeichert werden soll? Ein Bit oder ein Zahlenwert oder was...?
Können mehrere Anforderungen gleichzeitig im selben Zyklus kommen? Soll es da einen Vorrang geben?
Was soll passieren (kann das passieren?), wenn ein Signal ein weiteres Mal anfordert, bevor es bedient wurde? Oder falls die Anforderung normal stehenbleibt, bis sie bedient wird: was soll passieren wenn sie (unerwartet) wieder wegfällt?
Sind die Zeiten X (Aktiv-Zeit und Nach-Wartezeit) immer gleich lang? Oder wonach richten die sich?

Und wie immer die erforderlichen Grundangaben: welche SPS programmierst Du mit welcher Software?

Harald

 

[.Neueinsteiger.]

@codemonkey
Tia Portal: Step 7(müsste es sein) V15 und V15.1 CPU: 1212C
Ist eine Warteschlange nicht "das gleiche" wie ein FIFO? Wo einer nach dem anderen abgearbeitet wird, wer zuerst kommt wird zuerst bedient. Ich werde nachher den Code mal ausprobieren sobald ich wieder zuhause bin.
Danke schonmal.

@PN/DP
Ein Signal wäre Bit: 1 oder 0, oder ich könnte auch denen feste Nummern vergeben zb. 1.bis.20 wäre etwas mehr an Bausteinen die, die Übersicht etwas einschränken.
Wenn das gleiche Signal eine Anforderung ein zweites mal schickt bevor es bedient wurde soll es ignoriert werden. (Es kann in der Theorie nicht ein zweites Mal Anfordern, das Signal liegt solange an bis es Abgearbeitet wurde)

Die Aktiv-Zeit und die Warte-Zeit müssen unabhängig von einander einzustellen sein.

Warte-Zeit zum warten bis der passende Vacuum Aufgebaut ist (Erfahrungswerte) um das Material (unterschiedliche Materialien und gewichte, was eben benötigt wird) ansaugen zu können. Aktiv-Zeit zum Einstellen der Menge die gefördert werden soll.

Hoffe ich konnte die noch offenen Fragen passend beantworten.

Danke dir ebenfalls schonmal