TIA Steuerbit Verriegelung

[SPS'ler]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

Ich habe folgendes Problem bei einer Verwiegungsanlage:

Ich bekomme von einer Prozessleitschnittstelle folgende Datenstruktur:

Produktionsbit_W_1 (TRUE oder FALSE)
Produktionsbit_W_2 (TRUE oder FALSE)
Produktionsbit_W_3 (TRUE oder FALSE)
Produktionsbit_W_4 (TRUE oder FALSE)
Produktionsbit_W_5 (TRUE oder FALSE)

Das Bit steht für eine Komponente, die abgewogen werden soll. Nun gibt die Schrittkette vor, das eine Komponente nach der anderen verwogen werden muss.

Mein Problem ist die Unterscheidung, welche Komponente schon abgewogen wurde bzw. welche noch gewogen werden muss zu ermitteln.

Beispiel:

Step01
// Verwiegung Produktionsbit 1
Produktionsbit_W_1

Step 02
// Verwiegung Produktionsbit 3
Produktionsbit_W_3

Es können diese Kombinationen auftreten:
Keine Komponente
Eine Komponente
Zwei Komponenten

Gibt es eine Funktion oder ähnliches um zu ermitteln welche Komponenten benötigt werden und miteinader zu verriegeln um diese nacheinander abzuarbeiten?

 

[Peter Wahlen]

Sind das jetzt 5 oder 31 Produkte
1 Bit je Produkt
oder
ist das eine Produktnummer (0-31)?

Wenn mehrere Bits gleichzeitig anstehen, kann das eine Produktnummer sein oder mehrere nacheinander abzuarbeitende Produkte, im letzten Fall einfach der Reihe nach abarbeiten und merken, welche schon bearbeitet sind. Diese dann sperren.

 

[Ingmar64]

Zuviel Werbung?
-> Hier kostenlos registrieren

In der Schrittkette nacheinander die Verwiegungen abarbeiten, nicht benötigte eben überspringen.

 

[Salli1991]

Ohne jetzt deine Software zu kennen würde ich die Schrittkette so verkleinern, dass sie EINEN Abwiegevorgang beinhaltet. Und dann, je nachdem, was deine Auswertung der Bits ergibt, diese eben so oft ausführen, wie Teile abgewogen werden müssen. Sollten diese Teile jeweils mit unterschiedlichen Parametern abgewogen werden müssen bietet sich dafür ein Array an, welches du mit einem Pointer steuerst.
Dann vergleichst du nur noch, was du alles abgewogen hast, und sollte alles erledigt sein kannst du wieder von vorne beginnen.

 

[SPS'ler]

5 Produkte

Genau es sind mehrere nacheinander abzuarbeitende Produkte, meinst du so?

// Step 1 Erstes Produkt

(*Kein Produkt*)

IF Kein_Produkt
THEN
Ueberspringen := TRUE;
END_IF;

(* 1 Produkt *)

IF 1_Produkt
THEN

IF Produktionsbit_W_1
THEN
Aktion1 := TRUE;

ELSIF
Produktionsbit_W_2
THEN
Aktion2 := TRUE;

ELSIF
Produktionsbit_W_3
THEN
Aktion3 := TRUE;

ELSIF
Produktionsbit_W_4
THEN
Aktion4 := TRUE;

ELSIF
Produktionsbit_W_5
THEN
Aktion5 := TRUE;

END_IF;
END_IF;

(*2 Produkte*)

IF 2_Produkte
THEN

IF
Produktionsbit_W_1
THEN
Aktion1 := TRUE;
Gesperrt1 := TRUE;

ELSIF
Produktionsbit_W_2
THEN
Aktion2 := TRUE;
Gesperrt2 := TRUE;

ELSIF
Produktionsbit_W_3
THEN
Aktion3 := TRUE;
Gesperrt3 := TRUE;

ELSIF
Produktionsbit_W_4
THEN
Aktion4 := TRUE;
Gesperrt4 := TRUE;

ELSIF
Produktionsbit_W_5
THEN
Aktion5 := TRUE;
Gesperrt5 := TRUE;

END_IF;
END_IF;

// Step 2 Zweites Produkt

IF 2_Produkte AND Step1_Ende
THEN

IF
Produktionsbit_W_1 AND NOT Gesperrt1
THEN
Aktion1 := TRUE;


ELSIF
Produktionsbit_W_2 AND NOT Gesperrt2
THEN
Aktion2 := TRUE;


ELSIF
Produktionsbit_W_3 AND NOT Gesperrt3
THEN
Aktion3 := TRUE;

ELSIF
Produktionsbit_W_4 AND NOT Gesperrt4
THEN
Aktion4 := TRUE;

ELSIF
Produktionsbit_W_5 AND NOT Gesperrt5
THEN
Aktion5 := TRUE;

END_IF;
END_IF;

 

[Salli1991]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich würd es in etwa so machen

//Vorverarbeitung zur Auswahl des Abwiegeprodukts
IF Starte_Abwiegen THEN               //Prozessleitwerte nur dann neu Einlesen, wenn alle Aufträge Abgearbeitet sind
 Abwiegeprodukt[1] := Produktionsbit_W_1;  //Abwiegeprodukt -> Array of Bool
 Abwiegeprodukt[2] := Produktionsbit_W_2;  //Zwischenspeicher Array um mit die Werte auf false setzen zu können, sobald die Schrittkette durch ist
 Abwiegeprodukt[3] := Produktionsbit_W_3;
 Abwiegeprodukt[4] := Produktionsbit_W_4;
 Abwiegeprodukt[5] := Produktionsbit_W_5;
END_IF
IF NOT Schrittkette_Aktiv THEN         //Solange Schrittkette aktiv ist, wird das aktuelle Produkt nicht überschrieben
 FOR i:= 1 TO 5 BY 1 DO             // So hat Produkt 1 Vorrang. Soll von Oben nach Unten gezählt werden muss "BY 1" zu "By -1" geändert werden
  IF Abwiegeprodukt[i] THEN           //True sofern von Leitsystem angewählt
   Aktuelles_Produkt := i;            //Speicher aktuelles Produkt als Array Pointer
   EXIT;
  END_IF;
 END_FOR;
END_IF;
Starte_Abwiegen := NOT Abwiegeprodukt[1] AND NOT Abwiegeprodukt[2] AND NOT Abwiegeprodukt[3] AND NOT Abwiegeprodukt[4] AND NOT Abwiegeprodukt[5];

//Schrittkette

Startschritt                                                             //Bedingung für Startschritt ist mindestens ein aktives Produkt
->Setze Schrittkette_Aktiv := true     
Nächster Schritt
->Tu irgendwas mit Rezeptur[Aktuelles_Produkt]  //Kann alles mögliche sein. Qualitätsdaten, Positionsvorgaben für Antriebe etc. etc.
Vorletzter Schritt
->Setze Abwiegeprodukt[Aktuelles_Produkt] := false //Beim nächsten Durchgang der FOR-Schleife wird das Produkt nicht mehr ausgewählt
Letzter Schritt
->Setze Schrittkette_Aktiv := false //Gibt die FOR-Schleife frei

 

[Salli1991]

Das hat den Vorteil, dass dein Prozess mit ein und der selben Schrittkette um x Produkte erweiterbar ist, ohne das du einen großen Aufwand betreiben musst.
Sollte sich jedoch der Abwiegeprozess der einzelnen Produkte in der Schrittkette unterscheiden, kommst du um die Lösung von Imgmar64 nicht drum herum. Oder du musst deine allgemeine Schrittkette so sehr erweitern und durch externe Parameter einstellbar machen, dass sie alle Produkte abdeckt.