# Schrittketten Struktur



## MatMer (18 Juli 2006)

Hallo an Alle,
ich hätte mal ne relativ "dumme" Frage zu Schrittketten in AWL.
Ich hab leider nur ein wenig SPS in der Schule gehabt und da alles in FUP gemacht, mitlerweile habe ich mir einiges durchs Forum und durch Probieren selbst beigebracht.

Nun zur Frage,
wenn ich eine Schrittkette in AWL mache, habe ich es bisher so gemacht das ich die Schritte mit den Bedingungen Setze, das Rücksetzen habe ich dann immer extra noch geschrieben, z.B
U Schritt2
R Schritt1

Ist es Sinnvoll die Schritte direkt nach dem Setzen zurück zu setzen, also ich meine

U Schritt
U Bedingung1
U Bedingung2
S Schritt2
R Schritt1

Oder halt nochmal ne extra Abfrage auf Schritt2 zu machen, weil dadurch wird das Programm ja doch ein wenig Kleiner wie ich mir gerade so mal meine Schrittkette angeguckt habe.


----------



## plc_tippser (18 Juli 2006)

Ich bin der Meinung, dass das Geschmackssache ist, ich zum Bsp. nutze meistens die Sprungleiste, dann brauche ich mich um so etwas nicht zu kümmern.

pt


----------



## MSB (18 Juli 2006)

Ob es so sinnvoll ist, weiß ich nicht, es ist geringfügig Codesparend.

Was auf keinen Fall passieren sollte, das 2 Schritte gleichzeitig aktiv sind (außer dies ist explizit so gewollt),
also muss du den Schritt sowieso unmittelbar danach rücksetzen.

Dann würde ich persönlich Variante 2 das direkte rücksetzen nach dem setzen bevorzugen.


----------



## volker (18 Juli 2006)

also ich machs so.

u bed1
u s1
s s2
u s3
r s2

u bed2
u s2
s s3
u s4
r s3

hierbei sind für 1 zyklus 2 schritte aktiv. hat aber auch einen vorteil.
zenario
bed1 und bed2 sind erfüllt.
würde man nun mit setzen von s3 s2 direkt zurücknehmen wäre s2 nur für wenige anweisungen high. wir s2 aber im nachfolgenden prog verwendet hast du ein problem. bei meiner variante hast du das nicht.


----------



## Unregistrierter gast (18 Juli 2006)

Sinnvoll ist, sicherzustellen, dass ein Schritt MINDESTENS einen ganzen Zyklus high ist und NIEMALS zwei Schritte gleichzeitig high sind.

Ich bewerkstellige dass so, das bei mir der letzte Schritt im ersten Netzwerk steht, und der erste Schritt im letzten Netzwerk.

Das ist zwar etwas ungewöhnlich, aber man spart ne menge Tipparbeit und die Ablaufketten funtkionieren einwandfrei.

Es gibt natürlich noch  S7Graph, damit lassen sich Schrittketten sehr einfach bauen, es verbraucht nur viel Resourcen (Speicherplatz und Zykluszeit).


----------



## volker (18 Juli 2006)

> der letzte Schritt im ersten Netzwerk steht, und der erste Schritt im letzten Netzwerk


kein blöde lösung:-D 

ich hatte bisher noch nie probleme mit meiner variante. gibt aber sicherlich anlagen wo das ein problem sein kann.


----------



## Ralle (18 Juli 2006)

Bei S5 haben wir das genauso wie unreg.Gast gehandhabt, bei S7 arbeiten wir mit der Sprungliste.


----------



## martin3885 (19 Juli 2006)

Hi Ralle,
was ist eine Sprungliste in S7?


----------



## Ralle (19 Juli 2006)

@martin3885

Tschuldige, heißt Sprungleiste bzw. Sprunverteiler

der Befehl dazu lautet SPL, die Hilfe des s7-Managers dazu mal hier als Zitat:



> Format
> SPL <Sprungmarke>
> Operand Beschreibung
> <Sprungmarke> Symbolischer Name des Sprungziels.
> ...


 
Vorteil ist, daß du deine Schritte numerisch hochzählen kannst und der Sprungverteiler dann an die entsprechende Marke springt.
Ein Schritt weiter geht dann einfach über MB0 + 1.


----------



## martin3885 (19 Juli 2006)

Hi Ralle,
danke fuer die Antwort. Ich habe schon gedacht, dass ich viel ueber S7 weiss, und nun etwas neues was ich nicht kenne. SPL habe ich noch nie benutzt 

Gruss.
Martin


----------



## SPS-Manager (28 Juli 2006)

*Sfb32  - Drum*

Hallo ins Forum -

an Schrittketten gibt es doch auch diesen Baustein SFB32 - DRUM 
von Siemens mit 16 Takten.

Habe gerade eine Anlage wo dieses " Ding " mehrfach eingebaut ist.

Scheint mir aber nicht so einfach zu sein es zu verstehen.

Was sagt Ihr als Profis ?


Chris


----------



## MatMer (6 November 2006)

Hallo,
da ich derzeit ein kleineres Zeitproblem mit meine Schrittketten Baustein habe, wollte ich nochmal nach der SPL Fragen.

Eigentlich geht die Frage vorallem an Ralle.

Wenn ich vorher folgende Schritte hatte:

   U     "M_Schritt1"
   U     "T_Mischung_OK"
   U     "M_STM"
   UN    "M_StopD"
   UN    "M_Mischung7"
   S     "M_Schritt2"
   R     "M_Schritt1"
   R     "M_Wahl"


   U     "M_Schritt2"
   U(    
   ON    "DE_SensorT1_Unten"
   O     "M_SensorT3_Oben"
   O     "M_MischungLE"
   )     
   S     "M_Schritt3"
   R     "M_Schritt2"
   R     "DA_LED_Pumpe1"
   R     "M_Wahl"

das dann später:
   U     "M_Schritt2"
   L     S5T#1S
   SE    "T_Schritt2"
   S     "DA_LED_Pumpe1"

   U     "T_Schritt2"
   UN    "M_StopD"
   UN    "M_Mischung7"
   =     "DA_Pumpe1"

würde ich das dann so in SPL machen:



SEG2: UN    "M_StopD"
         L     S5T#1S
         SE    "T_Schritt2"
         S     "DA_LED_Pumpe1"

         U     "T_Schritt2"
         UN    "M_StopD"
         =     "DA_Pumpe1"

         U(    
         ON    "DE_SensorT1_Unten"
         O     "M_SensorT3_Oben"
         O     "M_MischungLE"
         )     
         SPBN  COMM
         SET   
         R     "DA_LED_Pumpe1"
         L     MB     0
         L     1
         +I    
         T     MB     0
         SPA   COMM

oder wie? Weil da stehe ich gerade ein wenig auf dem schlauch


----------



## Ralle (6 November 2006)

Ich erklär das mal allgemein, zum besseren Verständniss an einem Beispiel:

Die SPL:


```
L     "DATA_STATION_24".STEPNUMBER
      SPL   ENDE
      SPA   LEER                        //Schritt 00 - Leerschritt
      SPA   STRT                        //Schritt 01 - Start, Teilekontrolle
      SPA   HOVL                        //Schritt 02 - Start Horizontal 1+2 Vorlauf
      SPA   VENL                        //Schritt 03 - Start Vertikal 1+2 senken
      SPA   VEHL                        //Schritt 04 - Start Vertikal 1+2 heben
      SPA   HORL                        //Schritt 05 - Start Horizontal 1+2 Rücklauf
      SPA   SKEN                        //Schritt 06 - letzter Schritt
ENDE: SPA   LEER
```
 
Die Schritte:


```
//Schritt 01 - Start, Grundstellungskontrolle, Teilekontrolle
STRT: SET   
//++++   Startwerte  ++++
//++++   Sprung zum Ende wenn kein Teil in Pos. oder NIO  ++++
      U(    
      U     "DATA_STATION_24".Stat_Auto
      U(    
      ON    "DATA_Part_INFO".INFO_HDL2_Boerdeln.V_Spur_Teil_IO
      ON    "DATA_Part_INFO".INFO_HDL2_Boerdeln.V_Spur_Teil_vorhanden
      ON    "DATA_Part_INFO".INFO_HDL2_Boerdeln.H_Spur_Teil_IO
      ON    "DATA_Part_INFO".INFO_HDL2_Boerdeln.H_Spur_Teil_vorhanden
      ON    "DATA_GLOBAL_TECHNOLOGIE".Typ_Prod.Aktivieren.ST_24
      )     
      )     
      S     "DATA_STATION_24".K_LAST_STEP
      SPB   LEER
//++++   wenn Teil v.h. und IO -->nächster Schritt  ++++
      U     "DATA_Part_INFO".INFO_HDL2_Boerdeln.V_Spur_Teil_IO
      U     "DATA_Part_INFO".INFO_HDL2_Boerdeln.V_Spur_Teil_vorhanden
      U     "DATA_Part_INFO".INFO_HDL2_Boerdeln.H_Spur_Teil_IO
      U     "DATA_Part_INFO".INFO_HDL2_Boerdeln.H_Spur_Teil_vorhanden
      U     "DATA_GLOBAL_TECHNOLOGIE".Typ_Prod.Aktivieren.ST_24
      O     
      U     "DATA_STATION_24".Step_angewaehlt //auch ohne Teile bei Hand !!!
      S     "DATA_STATION_24".SK_NEXT_STEP_AUTO
      SPA   LEER
 
 
//Schritt 02 - Start Horizontal 1+2 Vorlauf
HOVL: SET   
      S     "DATA_STATION_24".MSG_OUT_04_SET    //Horizontal 1 Vorlauf
      S     "DATA_STATION_24".MSG_OUT_05_SET    //Horizontal 2 Vorlauf
 
      U     "E_s24_Horizontal_1_AS"
      UN    "E_s24_Horizontal_1_GS"
      U     "E_s24_Horizontal_2_AS"
      UN    "E_s24_Horizontal_2_GS"
      S     "DATA_STATION_24".SK_NEXT_STEP_AUTO
      SPA   LEER
 
...
 
//Schritt 06 - letzter Schritt
SKEN: SET   
      S     "DATA_STATION_24".K_LAST_STEP
 
// Ende
LEER: NOP   0
```
 
Dazu gibt es allerdings noch einen Schrittbaustein, der für folgendes sorgt:

wenn "DATA_STATION_24".SK_FORCE_STEP (Schritt ohne Stop im HAndbetrieb) oder "DATA_STATION_24".SK_NEXT_STEP_AUTO (im HAndbetrieb erst weiter, wenn Step+ betätigt) gesetzt werden, dann wird der nächste Schritt aktiviert. Das geht bei der SPL ganz einfach, 
"DATA_STATION_24".STEPNUMBER wird um 1 erhöht.
"DATA_STATION_24".K_LAST_STEP zeigt an, daß die Schrittkette zu Ende ist, "DATA_STATION_24".STEPNUMBER wir auf Null gesetzt, Ein Merker für Schrittkette fertig wird gesetzt.

Der Schrittbaustein übernimmt noch einige Aufgaben:

- Schrittweiterschaltung für Automatik oder Handbetrieb
- Grundstellungskontrolle
- Einsprungbedingungen für den 1. Schritt (Start von einer anderen Schrittkette, von der Grundstellung aus starten)
- Ende der Schrittkette anzeigen, Neustart verhindern, bis Endemerker gelöschr wurde.
- Aufbereitung der Schrittkettendaten für die Visualisierung.

In einem Schritt passier normalerweise folgendes:

1. Ausgänge ansteuern (nicht direkt, sondern über Koppelmerker bzw. Datenbits)
2. Kontrolle, ob die entsprechende Endlage erreichtwurde, wenn ja
Bit für Next-Step ("DATA_STATION_24".SK_NEXT_STEP_AUTO oder "DATA_STATION_24".SK_FORCE_STEP) setzen.

Das Weiterschalten übernimmt der Schritt-FC, das könnte man auch in jedem Schritt machen, wenn man den Schritt-FC einsparen möchte.


----------



## MatMer (6 November 2006)

Hallo Ralle,
besten Dank für dein Beispiel werde mal versuchen meinen Baustein mal abzuändern.


----------



## MatMer (11 Juni 2007)

Hallo Ralle,
ich habe jetzt versucht die Schrittkette in SPL aufzubauen, habe aber jetzt das Problem mit dem Schritt weiterschalten:



> U     "M_Naechster_Schritt"
> FP    M      2.1
> L     S5T#5S
> SS    T     32
> ...


Im Schrittketten FC wird in jedem Schritt mit den entsprechenden Bedingungen der M_Naechster_Schritt gesetzt, in einem anderen FC steht der Code hier. Der Wechsel von Schritt 1 auf 2 klappt, aber dann nicht mehr.

Ich kriege das gerade nicht hin, dass nach 5s (später 1-2) der nächste Schritt erst weitergeschaltet wird. Derzeit hänge ich im 2. Schritt, da M_Naechster_Schritt nicht wirklich zurückgesetzt wird.

Irgendwie wird der Timer nicht erneut angestoßen.


----------



## Ralle (11 Juni 2007)

Die Zeit T32 braucht eine Flanke zum Starten. Wenn in Schritt 2 auch sofort "M_Naechster_Schritt" auf 1 gesetzt wird, dann erkennt die Zeit keinen Flankenwechsel. Schreibe


```
SET
      U     T     32
      S     M      2.0

      U     M      2.0
      SPBN  Last
      L     1
      L     "MB_Schrittnummer"
      +I    
      T     "MB_Schrittnummer"
      SET   
      R     M      2.0
      R     T     32
      R     "M_Naechster_Schritt"

U "M_Naechster_Schritt"
       FP    M      2.1
       L     S5T#5S
       SS    T     32
```
deinen Code mal so herum.


----------



## MatMer (11 Juni 2007)

Hi,

danke das funktioniert, musste nur Last noch umsetzten.

Jetzt hab ich allerdings festgestellt das ich das so gar nicht machen kann.
Ich wollte im jedem Schritt die Ausgänge so setzte wie ich sie brauche,

also 
Tan1: s pumpe1
r pumpe 2
...

u de_sensor_tank1_leer
s m_nextstep
spa nop

Tan2: r pumpe1
s pumpe2


....


aber dann läuft die ja 5 s zu lange, heißt wieder alles umbauen


----------



## mariob (23 Juni 2007)

Hallo,
also ich habe meine Schrittketten bis jetzt immer "zu Fuß" geschrieben, das Prinzip eignet sich für Step 5 wie Step 7 gleichermaßen - ist halt überhaupt Geschmackssache. Hier mal ein Beispiel in Microwin:

Netzwerk xx
LDB<>  Autoschaltwerk, 0           //Schritt 0?
JMP    1                           //nein, zum Schritt1
//Programmtext Schritt 0
LD     MLichtschranke
S      Teil2, 1                    //50cm Papiervorschub
R      MLichtschranke, 1
S      AM1Kupplung, 1              //Kupplung Vorschub Unterbogen
INCB   Autoschaltwerk              //Schritt ist zuende, nächster Schritt

Netzwerk xx+1
LBL    1
LDB<>  Autoschaltwerk, 1           //Schritt 1?
JMP    2                           //nein, zum Schritt2
//Programmtext Schritt 1
LD     T33
R      AM1Kupplung, 1              //Zeit abgelaufen, auskuppeln
R      Teil2, 1

LD     T33
INCB   Autoschaltwerk              //Schritt ist zuende, nächster Schritt

usw.
Flexibel ist man damit allemal, auf Timer und sonstige Besonderheiten im Zyklus muß man halt aufpassen....

Mario


----------



## vladi (23 Juni 2007)

*Sk*

Hi,
-Schrittketten mittels SPL: finde ich unübersichtlich. Mit Merkern ist es viel
besser das Ganze nachzuvollziehen. Denn :was ist mit Zurückspringen bzw.
Schleifen fahren? Da gibt es aber Salat ohne ende..

-SK "Drum" (ein FB aus der TI Bibliothek) ist für bis 16 Schritte super, fast
kein Aufwand für eine schnelle Programmierung. Aber: Sprünge oder Schleifen fehlen.

-SK mit Graph: besser kann man es nicht machen. Gut, die Option muss man haben, aber es lohnt sich echt. Mit SK *gut* programmierte Anlagen, die auch ausgiebig getestet wurden, laufen Jahren ohne irgendwelche
Störungen oder komische Aufhänger usw., 24 Std. am Tag. Und ich meine
komplizierte, verschachtelte Prozesse mit viel Parameter, Regler usw.


Gruss: Vladi


----------



## Ralle (23 Juni 2007)

vladi schrieb:


> Hi,
> -Schrittketten mittels SPL: finde ich unübersichtlich. Mit Merkern ist es viel
> besser das Ganze nachzuvollziehen. Denn :was ist mit Zurückspringen bzw.
> Schleifen fahren? Da gibt es aber Salat ohne ende..
> ...



Jeder findes etwas anderes gut und jeder findet gut, was er am Besten kann, das sollte langsam mal klar sein, oder? Der Programmierer ist doch die entscheidende Komponente dabei.

Schleifen und Rücksprünge bei SPL sind gar kein Problem. SPL sind wesentlich übersichtlicher als Merkerschrittketten, ich hab früher auch so geredet wie du, aber das kannst du gerne halten wie du willst.

PS: Ich durfte vor kurzem eine Graph7-Anlage entsorgen und die Software komplett neu schreiben. Der Kunde will nie wieder Graph sehen, seine Leute konnten nichts damit anfangen und nichts finden, es wurden Daten von Instanz-DB zu Instanz-DB bzw. von Rezepten in Instanz-DB kopiert ohne Ende. Das OP war mit ActiveX-Komponenten vollgesemmelt, Fehlermeldungen über PDIAG. Das war praktisch HITEC, leider hats schlecht funktioniert, warum auch immer. Die Analyse hab ich mir erspart, da ja klar war, daß kein Graph mehr genommen werden soll. Auf den ersten Blick sah das ganze gar nicht so schlecht aus, bis auf das Instanz-DB-Desaster.


----------



## vladi (25 Juni 2007)

*SK usw.*

Hi,


Ralle schrieb:


> SPL sind wesentlich übersichtlicher als Merkerschrittketten, ich hab früher auch so geredet wie du, aber das kannst du gerne halten wie du willst.
> 
> PS: Ich durfte vor kurzem eine Graph7-Anlage entsorgen und die Software komplett neu schreiben. Der Kunde will nie wieder Graph sehen, seine Leute konnten nichts damit anfangen und nichts finden, es wurden Daten von Instanz-DB zu Instanz-DB bzw. von Rezepten in Instanz-DB kopiert ohne Ende.


 
1)Tja, später wirst Du dann so reden wie ich..
2)Graph SK: ich sprach über gut programmierte und getestete Anlagen.
Das ist das A und O immer; meine Systeme laufen, der Kunde hat kein
Grund da irgendetwas zu suchen oder verstehen.. Ausserdem sind Komplexe Softwaremodule in der heutigen Zeit kaum zu vermeiden, und da braucht mir keiner kommen und erzählen, das Zeug soll jeder
überblicken können, der das Wort "SPS" aussprechen kann . 

Aber das ist richtig:wir sollten gute Programmierer sein, und stabile
Anlagen machen, da hat jeder was davon. Und hier im Forum sind eine
ganze Menge gute dabei, das merkt man relativ schnell.

Gruss: Vladi


----------



## kiestumpe (25 Juni 2007)

Ralle schrieb:


> PS: Ich durfte vor kurzem eine Graph7-Anlage entsorgen und die Software komplett neu schreiben. Der Kunde will nie wieder Graph sehen, seine Leute konnten nichts damit anfangen und nichts finden, es wurden Daten von Instanz-DB zu Instanz-DB bzw. von Rezepten in Instanz-DB kopiert ohne Ende. Das OP war mit ActiveX-Komponenten vollgesemmelt, Fehlermeldungen über PDIAG. Das war praktisch HITEC, leider hats schlecht funktioniert, warum auch immer. Die Analyse hab ich mir erspart, da ja klar war, daß kein Graph mehr genommen werden soll. Auf den ersten Blick sah das ganze gar nicht so schlecht aus, bis auf das Instanz-DB-Desaster.


 
Naja, da lag das Problem aber eher nicht bei S7-Graph sondern an der chaotischen und ungekapselten Datenstruktur-dann hat man wohl das Kind mit dem Bad ausgeschüttet.
Mir persönlich gefallen die Sprunglisten auch nicht sonderlich, bzw. bevorzuge dann eher die "CASE" Anweisungen und ST-Darstellung.

cheers


----------



## Ralle (25 Juni 2007)

kiestumpe schrieb:


> Naja, da lag das Problem aber eher nicht bei S7-Graph sondern an der chaotischen und ungekapselten Datenstruktur-dann hat man wohl das Kind mit dem Bad ausgeschüttet.
> Mir persönlich gefallen die Sprunglisten auch nicht sonderlich, bzw. bevorzuge dann eher die "CASE" Anweisungen und ST-Darstellung.
> 
> cheers



Da hast du schon Recht, aber da diese ganze Datenstruktur auch noch bis in die Graph7-Bausteine hineinreichte und der Kunde wohl nicht mit Graph7 zurechtkam, lief es dann auf eine neue Software hinaus. 

Es ging auch gar nicht um Graph7 oder die SPL oder die Merkerschrittketten, sondern darum, daß jeder das so machen soll, wie er es am Besten kann. Diese Diskussionen, was ist Besser, was ist Schlechter kann ich langsam nicht mehr hören, das ist ohnehin Unsinn.


----------



## HaSchi (5 Juli 2007)

1.
Wir programmieren die Schrittketten auch nicht mehr mit Merkern sondern
mit Sprungmarken und Auscodierung am Ende des Schrittkettenbaustein.
Wir können dabei auch zurückspringen und verzweigen.
Die Beschreibung bzw. Entwicklung der Schrittkette erstellen wir nicht mehr graphisch sondern über Tabellen. An Hand dieser Tabellen erzeugen wir einen Quellcode für den Schrittkettenrahmen - spart Zeit.

2. Graph oder andere Zusatzprogramme versuchen wir zu vermeiden.
Dadurch können wir laufende Kosten z.B. für Updates sparen.

3. Ich stimme Ralle zu, das jeder es so machen, wir er es am Besten kann.


----------



## Mathias (6 Juli 2007)

hallo zusammen

ich arbeite meist mir Schrittketten, unten ein Beispiel:
L 5
L "MW_Schrittkette_Lift2"
<>I 
SPB b102
UN "LS_L2"
U "Tür_L2"
S "L2_auf"
U "HM_Schritt_Lift2"
L S5T#50MS
SE "Schritt Timer Lift2"
U "Merker true"
S "HM_Schritt_Lift2"
UN "Schritt Timer Lift2"
SPB b102
R "HM_Schritt_Lift2"
L 10
T "MW_Schrittkette_Lift2"
b102: NOP 0

gruss mathias


----------



## MatMer (18 September 2007)

Hallo,

nach erfolgter Umsetzung meiner Schritkette in SPL hätte ich jetzt mal die Frage wie ich das jetzt darstellen soll.

Mein erster Versuch wäre jetzt die Grafik im Anhang

Allerdings stell ich mir jetzt selber schon die Frage ob das so stimmt, weil der Merker M_Naechster_Schritt nicht gesetzt, sondern nur bedingt gesetzt wird. 
Ich füge mal lieber auch zwei Netzwerke ein damit ihr seht was ich meine


```
T5VL: O(    
      U     "M_Hand"
      U     "DE_Ventil1"
      )     
      O     "M_Lauf"
      S     "Ausgaenge".DB_DA_Ventil1   //Pumpe1 an
      S     "M_Wiederanlauf_Hand"

      U     "M_1Hz"
      O     "Ausgaenge".DB_DA_Ventil1
      =     "Ausgaenge".DB_DA_L_Ventil1

      ON    "DE_SensorT1_Oben"
      ON    "DE_SensorT5_Unten"
      S     "M_Naechster_Schritt"

      U     "M_Startbedingungen"
      S     "M_Laststep"

      U     "DE_SensorT1_Oben"          //1 nicht voll
      U     "M_SensorT3_Unten"          //Tank 3 leer
      UN    "DE_SensorT4_Unten"         //Tank 4 leer
      UN    "DE_SensorT5_Unten"         //Tank 5 leer
      SPBN  nop
      L     9                           //Befuellung
      T     "MB_Schrittnummer"
      SET   
      S     "M_Naechster_Schritt"
      BEA
```


```
T5VR: O(    
      U     "M_Hand"
      U     "DE_Ventil2"
      )     
      O     "M_Lauf"
      S     "Ausgaenge".DB_DA_Ventil2   //Pumpe1 an
      S     "M_Wiederanlauf_Hand"

      U     "M_1Hz"
      O     "Ausgaenge".DB_DA_Ventil2
      =     "Ausgaenge".DB_DA_L_Ventil2

      U     "M_Startbedingungen"
      S     "M_Laststep"
      S     "M_Naechster_Schritt"

      UN    "M_Startbedingungen"        //1 oder 2 nicht voll
      U     "M_SensorT3_Unten"          //Tank 3 leer
      UN    "DE_SensorT4_Unten"         //Tank 4 leer
      UN    "DE_SensorT5_Unten"         //Tank 5 leer
      S     "M_Naechster_Schritt"       //=>Befüllungs Anzeige

      U     "DE_SensorT2_Oben"          //Tank 2 nicht voll    
      UN    "DE_SensorT5_Unten"         //Tank 5 leer
      U(    
      ON    "M_SensorT3_Unten"          //Tank 3 nicht leer
      O     "DE_SensorT4_Unten"         //Tank 4 nicht leer
      )     
      SPBN  nop                         //=> Verteiler
      L     6
      T     "MB_Schrittnummer"
      SET   
      S     "M_Naechster_Schritt"
      BEA
```

ist ein wenig lang, dafür schonmal sorry


----------

