# Eine Frage zur Schrittkette in SCL



## schnecke (2 März 2012)

Hi ihr,
ich soll eine Schrittkette in SCL programmieren – finde aber irgendwie den Einstig nicht.

Bei einer Schrittkette in AWL setzt doch der vorhergehende Schrittmerker zusammen mit einer oder mehreren Bedingungen den nachfolgenden Schritt. Und dieser nachfolgende Schritt setzt dann den vorhergehenden Schritt wieder zurück. Dabei geschieht das Rücksetzen des vorhergehenden Schrittes ja immer erst im *nächsten *Zyklus.

So, in SCL hätte ich das jetzt mit der Anweisung "Case … of" gemacht. Hier stellt sich mir aber folgendes Problem:

Angenommen ich programmiere  Schritt 0 und an dessen Ende, dass (bei Erfüllung best. Bedingungen) in den nächsten Schritt, also Schritt 1, gesprungen werden soll.

*An welcher Stelle* sage ich nun, dass der Schrittmerker von Schritt0 wieder rückgesetzt wird? Denn es ist ja nicht gesagt, dass im nächsten Zyklus über die Case-Auswahl zwingend wieder in Schritt0 oder Schritt1 gesprungen wird, während in AWL ja automatisch im nächsten Zyklus wieder alles durchlaufen wird…

Lieben Dank für eine gute Idee…


----------



## MasterOhh (2 März 2012)

Bah Merker...

Du hast doch schon die Schrittvariable im case..of. Wenn du die auf eine bestimmte Schrittnummer setzt, springt das Programm auch dort hin. 
Da muss dann nichts gesetzt oder rückgesetzt werden....


----------



## Larry Laffer (2 März 2012)

Hallo,
wenn du in SCL mittels CASE eine Schrittkette machen willst (der Befehl bietet sich ja geradezu dafür an) dann arbeitest du nicht mit Merkern sondern mit einem INT.
Das könnte dann z.B. so aussehen :
	
	



```
CASE Schritt of
   0 :
   // tue hier irgendwas
   if Bedingung_1 then Schritt := 1 ; end_if ;
   1 :
   // tue hier irgendwas
   if Bedingung_2 then Schritt := 2 ; end_if ;
   2 :
   // tue hier irgendwas
   if Bedingung_3 then Schritt := 0 ; end_if ;
END_CASE ;
```
Gruß
Larry


----------



## schnecke (3 März 2012)

Ok, vielen Dank euch Beiden!

Dann kann ich also in SCL die Schrittmerker vergessen. Nur, wie bewerkstellige ich dann z.B. die Initialisierung der Schrittkette nach dem Einschalten der Anlage, bzw. nach Reset? Dazu habe ich in AWL einfach die Schrittmerker rückgesetzt.

Muss man dazu in SCL* jeden einzelnen *Aktor rücksetzen, oder geht das irgendwie einfacher?


----------



## Deltal (3 März 2012)

Du kannst z.B. im Schritt 0 alle Aktoren abschalten.

Über einen Taster kannst du die Variable "Schritt" auf 0 setzen um die Kette neu zu Initialisieren. (Anfang oder Ende, nie innerhalb der CASE-Schleife!)

```
IF Taster=true THEN
 Schritt := 0;
END_IF;
```
Ich nutze diese Reset Funktion eigentlich bei allen Schrittketten. Manchmal muss man ein kleines Zusatzprogramm schreiben, damit erst alles wieder in die Ausgangsstellung zurückfährt.

Außerdem trenne ich immer die Schrittkette und das Ansteuern der Aktoren. Also die Schrittkette in SCL und das Ansteuern der Aktoren über AWL/FUP. Man kann halt in SCL schlecht "beobachten" und die meisten Instanthalter verdrehen auch die Augen, wenn man ihnen ST vorsetzt..


----------



## bike (3 März 2012)

schnecke schrieb:


> Ok, vielen Dank euch Beiden!
> 
> Dann kann ich also in SCL die Schrittmerker vergessen. Nur, wie bewerkstellige ich dann z.B. die Initialisierung der Schrittkette nach dem Einschalten der Anlage, bzw. nach Reset? Dazu habe ich in AWL einfach die Schrittmerker rückgesetzt.
> 
> Muss man dazu in SCL* jeden einzelnen *Aktor rücksetzen, oder geht das irgendwie einfacher?



Innerhalb einer Schrittkette würde ich nie einen Aktor zuweisen.
Das gehört nach außerhalb.
Denn wenn du eine Automatik und eine Handschrittkette hast, was dann?


bike


----------



## schnecke (3 März 2012)

Lieben Dank!

@Deltal: Und in diesem Schritt 0 muss dann jeder Aktor *einzeln* auf 0 gesetzt werden?

A0.0 := 0;
            A0.1 := 0;
            usw.

@bike: Stimmt, habe ich nicht bedacht. D.h., innerhalb der Schrittkette *nur mit Merkern* arbeiten?

IF "Bedingung" THEN
         M10.0 := 1;
      END_IF;

Und dann außerhalb der Kette:

A0.0 := M10.0;


----------



## bike (3 März 2012)

So kannst du dies machen.
Und wenn du die Schrittkette wegwerfen musst, dann das MW 10 mit 0 füllen.

Du musst dir auch Gedanken machen, wie du die Merker in der Kette zurücksetzen willst.
Eine Möglichkeit ist, dass du zu Beginn, vor Eingang Schrittkette, das MW auf Null schreibst, und dann nach deiner Bedingung (Schrittnummer) in der Kette den entsprechenden Merker wieder zuweisen. 
Dann umgehst du, dass ggF mehr als ein Merker 1 ist, wenn dies so gewollt ist.


bike

bike


----------



## Deltal (3 März 2012)

Da du im SCL eigentlich nur mit Setzen und Rücksetzen arbeitest, musst du natürlich alles Rücksetzen wenn du "aus der Scheife springst".
Die Case Schleife ist ja nix anderes als ein Vergleicher mit einem Sprungbefehl. Also er vergleicht ob die "Schritt" variable = 1 ist, sonst springt er zum nächsten Vergleicher usw.

Im SCL beschreibe ich nur Merker bzw. Bits in einem DB und verknüpfe sie dann in einem AWL/KOP/FUP Programm auf die Ausgänge.


----------



## schnecke (3 März 2012)

Danke bike,

also das Zurücksetzen der Schrittkette könnte ich ja dann nach der Idee von Deltal machen:


IF "Reset" THEN  
Schritt := 0; 
END_IF;

Und dann eben in Schritt 0:

MW10 := 0;

In den einzelnen Schritten werden dann den Merkern aus MW10 wieder eine 1 zugewiesen...

Wäre das so eine Möglichkeit?


----------



## schnecke (3 März 2012)

Deltal schrieb:


> Im SCL beschreibe ich nur Merker bzw. Bits in einem DB und verknüpfe sie dann in einem AWL/KOP/FUP Programm auf die Ausgänge.



... also du weist z.B. in FUP einem Merker aus der Schrittkette einen Ausgang zu, oder?

Aber das könntest du doch auch noch in SCL tun, oder nicht?


----------



## bike (3 März 2012)

schnecke schrieb:


> Danke bike,
> 
> also das Zurücksetzen der Schrittkette könnte ich ja dann nach der Idee von Deltal machen:
> 
> ...



Ja klar, wenn du den Schritt 0 als deine INIT Schritt machen willst gut.

Doch was macht du wenn du, wieder in die Kette an einer bestimmten Stelle einspringen willst?
Wenn du vor der Kette das MW auf null setzt, kann du wenn deine Kette weiterlaufen kann, in den richtigen Schritt springen, den du vorgibst.
Wenn z.B. Störung in Schritt 5 war, kann es sinnvoll sein nach beheben der Störung, mit Schritt 6 weiter zumachen.
Wenn du dann aber zuerst in den INIT musst, weiß ich nicht, ob das so echt sinnvoll ist.
Bei mir werden im INIT die Startbedingungen der Kette und ähnliches geprüft.

bike


----------



## Deltal (3 März 2012)

bike schrieb:


> Ja klar, wenn du den Schritt 0 als deine INIT Schritt machen willst gut.
> 
> Doch was macht du wenn du, wieder in die Kette an einer bestimmten Stelle einspringen willst?
> Wenn du vor der Kette das MW auf null setzt, kann du wenn deine Kette weiterlaufen kann, in den richtigen Schritt springen, den du vorgibst.
> ...



Wenn eine Störung ist sollte die Kette ehe erstmal "stehen bleiben". Ob man danach einen Reset durchführen muss, ist ja von der Situation abhängig.
Ich habe idr. einen extra Schritt für den Reset, meistens halt mit einem extra Fahrprogramm etc.
Nach dem Reset springt er also erstmal in z.B. Schitt 99. Dort werden alle Antriebe abschaltet etc. Vom Schritt 99 springt er in den initialschritt und die Kette fängt von vorne an. 

Ein Typischer Baustein zum Anteuerung des Antiebes sieht dann so aus:

```
U "BIT aus dem SCL Programm
U "Automatikbetrieb"
O
U "Taster für Tippbetrieb"
U "Handbetrieb"
= "Ausgang für Aktor"
```


----------



## schnecke (3 März 2012)

bike schrieb:


> Wenn z.B. Störung in Schritt 5 war, kann es sinnvoll sein nach beheben der Störung, mit Schritt 6 weiter zumachen.
> Wenn du dann aber zuerst in den INIT musst, weiß ich nicht, ob das so echt sinnvoll ist.
> Bei mir werden im INIT die Startbedingungen der Kette und ähnliches geprüft.
> 
> bike



Ja, danke bike für deine guten Überlegungen...  Daran habe ich nicht gedacht.

Andererseits kann man ja sagen, dass der INIT-Schritt* nur* dann aktiv wird, wenn z.B. "Reset" gedrückt wird, oder wenn nach Anlage AUS einmalig die Taste "Bereitschaft" gedrückt wird. Wenn nun in Schritt 5 eine Störung war, kann man diese ja beheben - und wenn jetzt nicht "Reset" gedrückt wird, so wird ja auch nicht in den INIT-Schritt gesprungen; d.h., es könnte ja jetzt mit Schritt 6 weitergehen, oder?

Was meinst du mit "Prüfen der Startbedingungen der Schrittkette"?


----------



## schnecke (3 März 2012)

Deltal schrieb:


> Nach dem Reset springt er also erstmal in z.B. Schitt 99. Dort werden alle Antriebe abschaltet etc. Vom Schritt 99 springt er in den initialschritt und die Kette fängt von vorne an.



Danke Deltal!

Glaube, langsam komme ich der Sache dank eurer Hilfe immer näher... denke nur noch nicht an jede  _Individualität!

_Wo liegt bei dir eigentlich der Unterschied zwischen Reset und Initialisierung der Schrittkette?


----------



## Deltal (3 März 2012)

Einen richtigen Initialschritt benutze ich meistens nicht. Ich habe halt einen "Start" Schritt, welcher immer nach beendigung der Schrittkette angewählt wird. Und ich habe eine Reset-Prozedur, welche nach Anforderung durchlaufen wird, alle Antriebe kontrolliert in die Ausgangsposition bringt und dann wieder den Startschritt springt.
Der Init wäre also so eine Mischung aus dem Startschritt und dem Ende der Reset-Prozdeur.


----------



## bike (3 März 2012)

schnecke schrieb:


> Ja, danke bike für deine guten Überlegungen...  Daran habe ich nicht gedacht.
> 
> Andererseits kann man ja sagen, dass der INIT-Schritt* nur* dann aktiv wird, wenn z.B. "Reset" gedrückt wird, oder wenn nach Anlage AUS einmalig die Taste "Bereitschaft" gedrückt wird. Wenn nun in Schritt 5 eine Störung war, kann man diese ja beheben - und wenn jetzt nicht "Reset" gedrückt wird, so wird ja auch nicht in den INIT-Schritt gesprungen; d.h., es könnte ja jetzt mit Schritt 6 weitergehen, oder?
> 
> Was meinst du mit "Prüfen der Startbedingungen der Schrittkette"?



Ja könnte im 6.Schritt weitergehen.
Wer setzt dir  bzw wie setzt du den Schritt 5 zurück, wenn du im nächsten oder ggF im vorherigen Schritt weiter machst?
Oder gar zwei bis drei Schritte  weiter oder zurück musst?

Startbedingungen sind bei mir alle Medien  störungsfrei und ein und alle Teile in Grundstellung.


bike


----------



## schnecke (3 März 2012)

Deltal schrieb:


> Ich habe halt einen "Start" Schritt, welcher immer nach beendigung der Schrittkette angewählt wird. Und ich habe eine Reset-Prozedur, welche nach Anforderung durchlaufen wird, alle Antriebe kontrolliert in die Ausgangsposition bringt und dann wieder den Startschritt springt.



Ok Deltal, 

verstehe ich das so richtig, wenn also der *letzte* Schritt der Kette durchlaufen wurde, dann wird* automatisch* wieder in den Startschritt gesprungen? 

Nur, *was *passiert im Startschritt - geht es von hier aus, bei erfüllter Bedingung, gleich wieder in den nächsten Schritt der Kette?

@bike: 
Nun, der Merker aus Schritt 5 würde durch den Nachfolgeschritt, also Schritt 6 rückgesetzt werden. Ein Problem wäre es nur, wenn man nach einer Störung im vorhergehenden Schritt weitermachen würde - aber das kann doch eigentlich nicht passieren, denn im Speicher der SPS ist doch noch Schritt 5 gespeichert, so dass nach einer Störung eigentlich wieder dorthin gesprungen wird... oder irre ich mich?


----------



## Deltal (3 März 2012)

schnecke schrieb:


> verstehe ich das so richtig, wenn also der *letzte* Schritt der Kette durchlaufen wurde, dann wird* automatisch* wieder in den Startschritt gesprungen?
> Nur, *was *passiert im Startschritt - geht es von hier aus, bei erfüllter Bedingung, gleich wieder in den nächsten Schritt der Kette?


Der erste Punkt ist soweit richtig.
Im Startschritt werden kaum Aktionen ausgeführt. Dafür werden alle Bedinungen geprüft, welche zu einem neuen Durchlauf voraussetzung sind. 
Automatikbetrieb ein, Fremdmaschinen sind aus dem Weg oder ein neues Produkt wurde angewählt und soll aus dem Lager geholt werden.
Wenn alles ok ist, startet der Ablauf.

Der Hauptgrund, warum der Schritt 0 der Startschritt ist, liegt einfach darin, das die Defaultbelegung von Variablen idR. 0 ist.


----------



## schnecke (3 März 2012)

Deltal schrieb:


> Der Hauptgrund, warum der Schritt 0 der Startschritt ist, liegt einfach darin, das die Defaultbelegung von Variablen idR. 0 ist.



Lieben Dank für deine Hilfe Deltal!

Aber die Variablen, bzw. Merker sind doch auch im Schritt 0 nur dann Null, wenn diese im Verlauf der nachfolgenden Schritte nach und nach rückgesetzt werden, oder nicht? Oder wird das an einer best. Stelle *explizit* gemacht?  Was ich meine, wenn die Schrittkette z.B. 15 Schritte hat, dann sollte ja im Schritt 15 wieder alles auf Null sein, so dass dann beim Sprung in Schritt 0 die Variablen automatisch den Status Null haben - stimmt das so?


----------



## Larry Laffer (3 März 2012)

bike schrieb:


> Innerhalb einer Schrittkette würde ich nie einen Aktor zuweisen.
> Das gehört nach außerhalb.



Diesen Satz würde ich voll unterstützen.
Wenn man aber in einer Schrittkette keinen Aktor zuweist, dann auch keinen Merker. Das macht es dann auch nicht besser.
Wenn der Ausgang A10.0 von Schritt 1 oder Schritt 5 oder Schritt 7 geschaltet werden soll dann würde ich es in der Zuweisung des Ausgangs auch so umsetzen. Alles andere wäre dann inkonsequent ...

Gruß
Larry


----------



## bike (3 März 2012)

schnecke schrieb:


> Ein Problem wäre es nur, wenn man nach einer Störung im vorhergehenden Schritt weitermachen würde - aber das kann doch eigentlich nicht passieren, denn im Speicher der SPS ist doch noch Schritt 5 gespeichert, so dass nach einer Störung eigentlich wieder dorthin gesprungen wird... oder irre ich mich?



Dass liegt Auge des Betrachters.
Wenn z.B. ein Teil aufgepresst werden soll und dieses ist verklemmt.
Dann Störung quittieren und Teil entnehmen.
Dann Fehler quit und wenn erkannt wird, dass Teil nicht aufgepresst wird, geht meine Schrittekette autoamtisch zurück zu dem Schritt in dem das Teil vorbereitet wird.
Und der Prozess wird fortgesetzt.

So kann es geschehen, doch es ist halt die Aufgabenstellung, die die Art der Programmierung bestimmt.


bike


----------



## bike (3 März 2012)

Larry Laffer schrieb:


> Diesen Satz würde ich voll unterstützen.
> Wenn man aber in einer Schrittkette keinen Aktor zuweist, dann auch keinen Merker. Das macht es dann auch nicht besser.
> Wenn der Ausgang A10.0 von Schritt 1 oder Schritt 5 oder Schritt 7 geschaltet werden soll dann würde ich es in der Zuweisung des Ausgangs auch so umsetzen. Alles andere wäre dann inkonsequent ...
> 
> ...



Schrittketten sind eine Philosophie 
Wenn zuerst Ausgangsmerker auf null gesetzt werden, dann der Schritt angesprungen wird ist nur der aktuelle Merker 1.
Bei einer Störung nach dem Nullsetzen wegspringen und kein Aktor ist aktiv.

Aber jeder so wie er denkt oder will.


bike


----------



## Larry Laffer (3 März 2012)

OK ... aber dann kannst du auch genausogut die Ausgänge innerhalb der CASE-Struktur schalten. Die lassen sich dann ja auch bei einem Reset gezielt rücksetzen (oder setzen).
Der Charme, es nicht in der Struktur zu machen ist ja, das man sich um den Kram nicht kümmern muss weil es ja am Ende passiert. Vom Programmcode wir das dann natürlich "etwas" umfangreicher. Aber wie du schon schreibst :


> jeder so wie er denkt oder will.



Gruß
Larry


----------



## schnecke (3 März 2012)

Larry Laffer schrieb:


> Wenn man aber in einer Schrittkette keinen Aktor zuweist, dann auch keinen Merker.
> Wenn der Ausgang A10.0 von Schritt 1 oder Schritt 5 oder Schritt 7 geschaltet werden soll dann würde ich es in der Zuweisung des Ausgangs auch so umsetzen.
> Gruß
> Larry



Ähm, sorry Larry - aber ich muss doch irgendetwas in der Schrittkette aktiv setzen, damit ich dann am Ende den Ausgang A10.0 zuweisen kann. Das verstehe ich jetzt nicht; wenn es auch keine Merker sein sollen, was denn dann?


----------



## Deltal (3 März 2012)

schnecke schrieb:


> Aber die Variablen, bzw. Merker sind doch auch im Schritt 0 nur dann Null, wenn diese im Verlauf der nachfolgenden Schritte nach und nach rückgesetzt werden, oder nicht? Oder wird das an einer best. Stelle *explizit* gemacht?  Was ich meine, wenn die Schrittkette z.B. 15 Schritte hat, dann sollte ja im Schritt 15 wieder alles auf Null sein, so dass dann beim Sprung in Schritt 0 die Variablen automatisch den Status Null haben - stimmt das so?



Ja von selbst wird da nichts zurückgesetzt. Der Start-Schritt ist nur 0, damit nichts passieren kann, wenn man einer Urlöschen durchführt.
Ob die Variablen alle wieder 0 sein müssen kann man nicht Pauschal sagen. Aktoren wird man idr. immer dann abschalten wenn es gerade notwenig ist. Variablen will ich eventuell auch über mehere Schrittkettenabläufe behalten. z.B. wenn ich 6 Teile entnehmen muss, lasse ich die Kette 6 mal durchlaufen und inkrementiere die Teileanzahl. 
Dardurch, dass du innerhalb der Ketten mit Speichern und Rücksetzen arbeitest musst du halt auf deine Variablen aufpassen. Springe ich aus der Kette muss ich natürlich derbe aufpassen das ich auch wirklich alle wichtigen Variablen zurücksetze.

Alternativ dazu das System von Larry, wo der Aktor eine bedingte Zuweisung abhängig vom Wert der "Schritt" Variable hat. 
Also

```
IF Schritt = 1 OR Schritt = 2 THEN
Antrieb := true;
ELSE
Antrieb := false;
END_IF;

(Soetwas sollte man auch in AWL/FUP/KOP machen)
```

Hier musst du _nicht _aufpassen ob alles "zurückgesetzt" worden ist. Jedoch ist man mit diesem System eingeschränkt und hat viel Ärger wenn man "mal einen Schritt einfügen" muss.


----------



## Thomas_v2.1 (3 März 2012)

Deltal schrieb:


> Hier musst du _nicht _aufpassen ob alles "zurückgesetzt" worden ist. Jedoch ist man mit diesem System eingeschränkt und hat viel Ärger wenn man "mal einen Schritt einfügen" muss.



Das ist aber ein Mangel beim Siemens SCL. In anderen besser ausgestatteten Programmiersprachen nimmt man für die Schrittzustände eine Enumeration. Wenn ich dann meine Schrittkette erweitern will füge ich dort einfach einen Schritt ein. Außerdem kann ich diese Enumeration in der Schrittkette und in der Zuweisung je nach Schritt verwenden. Bei Codesys bekomme ich im Online-Zustand beim Beobachten sogar den Namen des Enumerationswertes angezeigt, und nicht nur eine nichtssagende Nummer.

Beispiel Codesys ST:

```
TYPE eSCHRITTKETTE1 :
(
	INIT := 0,
	AUSFAHREN,
	EINFAHREN,
	ENDE
);
END_TYPE


VAR
	STEP : eSCHRITTKETTE1;
END_VAR

CASE STEP OF
	INIT:
		IF (BEDINGUNG1) THEN
			STEP := AUSFAHREN;
		END_IF
	AUSFAHREN:
		IF (BEDINGUNG2) THEN
			STEP := EINFAHREN;
		END_IF
	EINFAHREN:
		IF (BEDINGUNG3) THEN
			STEP := ENDE;
		END_IF
	ENDE:
		IF (BEDINGUNG4) THEN
			STEP := INIT;
		END_IF
END_CASE
```

Bei SCL könnte man das Problem eigentlich halbwegs über Konstanten umschiffen. Leider kennt SCL keine global gültigen Konstanten oder Dateien die man einbinden könnte. Somit muss man bei Erweiterung der Schrittkette die Konstanten per Copy/Paste in alle anderen Programmteile einkopieren.
SCL hat so viele Beschränkungen dass es kein richtigen Spaß macht. Wobei es wirklich nur Kleinigkeiten sind die fehlen, die einen aber schon enorm weiterbringen würden.


----------



## schnecke (4 März 2012)

Dank' euch für die super Unterstützung!


Eine Frage ist bei der Umsetzung noch aufgetaucht:

Worin besteht eigentlich der Unterschied, ob ich nun Variante a) oder Variante b) programmiere? In *beiden* Fällen müssen ja E0.0 UND M10.0 TRUE sein!

a) 
	
	



```
IF E0.0 THEN
                IF M10.0 THEN
                  A0.0 := 1;
                END_IF;
              END_IF;
```

b) 
	
	



```
IF E0.0 AND M10.0 THEN
                A0.0 := 1;
              END_IF;
```


----------



## Deltal (4 März 2012)

Beide Varianten haben die selbe Funktion. Variante b erzeugt jedoch 4Byte weniger Programmcode.


----------



## schnecke (4 März 2012)

Lieben Dank Deltal,

 wobei evtl. die Absicht hinter der Programmierung anders sein könnte, oder?

In Variante a) wird die "Merkerzeile" ja *nur* dann ausgeführt, wenn der Eingang 0.0 TRUE ist. Bei FALSE wird die Zeile mit dem Merker ja gar nicht beachtet...

Ich suche einfach nur den Grund, warum ein ehem. Kollege in seinem Programm ausschließlich die Variante a) und nicht b) verwendet haben könnte?


----------



## Deltal (4 März 2012)

Richtig.. aus der Variante a wird der Compiler wohl ein AWL Programm mit zwei Sprüngen erstellen. Wie so oft gibt es halt mehrere Wege ein Ziel zu erreichen.
Die IF-THEN-Bäume sind imho etwas besser lesbar, erzeugen aber auch mehr Programcode.

Wobei man die Bitabfragen möglichst nicht im SCL durchführen sollte.. das geht wesendlich effektiver in FUP/AWL..


----------



## bike (4 März 2012)

Das Ergebnis ist in diesem Fall das selbe.
Wenn aber die Konstruktion mit den 2 Schleifen verwendet wird, ist es manchesmal einfacher bei der IBN, da Änderungen und Ergänzungen leichter rein und raus zu programmieren sind.
Außerdem wird die zweite ggF. Schleife, wenn die Bedingung nicht erfüllt ist, übersprungen, macht(e) vielleicht Sinn wegen Zykluszeit, früher.  

Wobei ich die Verschachtlung von mehreren IF Schleifen nicht so gern mache, es wird schwerer beim Verstehen und Debbugen.

bike


----------



## schnecke (4 März 2012)

Deltal schrieb:


> Wie so oft gibt es halt mehrere Wege ein Ziel zu erreichen.



Ja, das stimmt wohl! Tue mich halt oftmals noch schwer den Sinn in den versch. möglichen Programmiervarianten zu sehen - sicherlich auch deshalb, weil mir noch Erfahrung fehlt...  :-x

Aber dank eurer Hilfe und Geduld wird's schon werden... ist ja noch keine Meisterin vom Himmel gefallen, gell...


----------



## KarlOtto (5 März 2012)

das war echt sehr lehrreich. danke euch allen. ich hab schon oft mit schrittketten zu tun gehabt, sei es nun zu schulungszwecken oder in der praxis. programmiert hab ich sie aber immer in awl. wenn ich mir das so in ST angucke ist das aber wesentlich einfacher und überschaubarer und scriptsprache ist mir nicht fremd... warum ich da nur nicht früher drauf gekommen bin...??? danke!

eine sache noch: es stimmt NICHT!, dass bei einer schrittkette in FUP/AWL teilweise 2 schritte in einem zyklus aktiv sind, ist das der fall, hat man einen fehler gemacht.
hierzu ein beispiel:

NETWORK
TITLE =Schritt 1
//
U #bedingung1;
U #schritt0;
S #schritt1;
ON #aus;
O #schritt2;
R #schritt1;

so ist es falsch, da erst im nächsten zyklus (nachdem schritt1 aktiviert wurde, dann auch schritt0 zurückgesetz wird. es ist also ein zyklus lang 0 und 1 aktiv.

viel besser ist:

NETWORK
TITLE =Schritt1
//
U #bedingung;
S #schritt1;
R #schritt0;

kann man auch in FUP konvertieren.


----------



## bike (5 März 2012)

KarlOtto schrieb:


> NETWORK
> TITLE =Schritt1
> //
> U #bedingung;
> ...




Also bei mir für der nächste Schritt der vorherige Schritt noch aktiv sein.
Nur einen Bedingung ist mir zu wenig.

Es gibt viele Möglichkeiten eine Schrittkette zu programmieren und was richtig und falsch mag ich nicht beurteilen.
Wenn das Programm seine Aufgabe richtig erfüllt, ist es ein gutes Programm.


bike


----------

