# Schrittkette in SCL



## Tmbiz (5 Dezember 2017)

Hallo, ich habe eine Schrittkette in AWL. Das ganze habe ich schon ca 100 genutzt und die Vorlage immer kopiert. Ich muss nun aber auf SCL umsteigen. Hat jemand eine Schrittkette in SCL die er mit gehen kann. 

Meine Kette ist in einem FB geschrieben und ich habe ein Interface. An dem Interface kann ich die Kette zurücksetzen, Starten, eine Freigabebedingung definieren und mit die Schrittnummer anzeigen lassen. 






Ich kann auch denn gesamten Inhalt der Kette hier hoch stellen. Aber ich denke ihr wisst was ich meine. Ich habe keine Erfahrung mit SCL aber schon C usw. programmiert. Ich bin mir sicher das ich das hin bekomme. Schön wäre es wenn jemand mit eine Kette in SCL geben könne. Dann kann ich das anpassen oder habe zumindest schon mal eine Übersicht wie ich das aufbauen kann.


----------



## rostiger Nagel (5 Dezember 2017)

Schrittkette in SCL würde ich Sinnvollerweise mit CASE lösen,
das ähnelt dann sehr einen Sprungverteiler in AWL.


----------



## Tmbiz (6 Dezember 2017)

rostiger Nagel schrieb:


> Schrittkette in SCL würde ich Sinnvollerweise mit CASE lösen,
> das ähnelt dann sehr einen Sprungverteiler in AWL.



Das bedeutet, ich kann grundsätzlich die Struktur der Kette übernehmen und so zu sagen in SCL übersetzen?


----------



## Larry Laffer (6 Dezember 2017)

Da aus SCL nach dem Übersetzen dann AWL wird kannst du das Allermeißte, dass du aus AWL kennst in SCL recht gut, manchmal sogar komfortabler, nachbilden.

Wenn du jetzt mit SCL startest dann wirst du sicherlich noch so einige Fragen haben. Wenn du damit hier im Forum weiterkommen willst dann ist es sehr oft hilfreicher die Fragen zu bereits erstelltem Code zu stellen an Stelle von pauschalen Fragen. Stellst du Code-Schnipsel hier ein wirst du möglicherweise auch Anregungen bekommen, wie man dieses oder jenes besser oder einfacher umsetzen kann ...

Gruß
Larry


----------



## ADS_0x1 (6 Dezember 2017)

```
CASE nStep OF		
	cSchritt_XYZ:
		IF 			TRANSITIONSBEDINGUNG THEN
					nStep  := cSchritt_YZA;
		END_IF
        cSchritt_YZA:
		IF 			TRANSITIONSBEDINGUNG THEN
					nStep  := cSchritt_ZAB;
		END_IF

(...)
END_CASE

IF nStep = cSchritt_XYZ THEN
         SCHRITTKETTENAKTION
END_IF
```

So (mal grob aus dem Kopf) sehen unsere Schrittketten sinngemäß aus


----------



## Tmbiz (6 Dezember 2017)

Hier mal eine erste Frage: in AWL ist das was ich schreiben möchte so gemacht


```
U #I_Reset_x
      SPB   s999
```

Nach dem SPB s999 kommt das Ende der Kette. 



```
/
/ ----------Reset der Schrittkette ----------------------------------
    IF #I_Reset_x THEN
    // Sprung zum Ende der Schrittkette und dann zum Ausgang
    END_IF;
```

Wie muss ich das machen wenn ich das jetzt auf Case umbaue?
Wär denn GoTo nicht besser?


----------



## weißnix_ (6 Dezember 2017)

Machst Du in Case genauso:


```
/ ----------Reset der Schrittkette ----------------------------------
    IF #I_Reset_x THEN
    // Sprung zum Ende der Schrittkette und dann zum Ausgang
i:=999;
    END_IF;
...
999: //Code für Schrittkettenende
```


----------



## rostiger Nagel (6 Dezember 2017)

Tmbiz schrieb:


> Hier mal eine erste Frage: in AWL ist das was ich schreiben möchte so gemacht
> 
> 
> ```
> ...



Mit einen Case kannst du auch ans Ende springen oder mit einen ELSE im Case.


----------



## Tmbiz (6 Dezember 2017)

Nur das mit dem 

i:=999


verstehe ich nicht. Wo ist denn die 999 definiert? Das muss ja eine bestimmter Teil des CASE sein oder nicht?


----------



## Tmbiz (6 Dezember 2017)

```
CASE #stepNr OF
        1:  // Statement section case 1
            ;
        2..4:  // Statement section case 2 to 4
            ;
        ELSE  // Statement section ELSE
            ;
    END_CASE;
```

Kann ich das so erstellen, dass ich je nach dem wie die stepNr ist immer in den entsprechenden Teil springe. Müsste ich dann über GOTO zu dem entsprechenden Teil gehen? Das CASE wäre dann so zusagen meine Sprungverteiler...

Unter GOTO 1, 2, 3, 4, 5, sind dann meine Funktionen und unter 999 ist das Exit aus der Kette...


----------



## Larry Laffer (6 Dezember 2017)

siehe meine Anmerkungen im Zitat :


Tmbiz schrieb:


> ```
> CASE #stepNr OF
> 1:  // Statement section case 1
> ;  // <- hier geschieht deine Aktion von Schritt = 1
> ...



Das mit dem GOTO solltest du dir verkneifen. Alles was du im Schritt machen möchtest kannst an der jeweiligen Schrittnummer programmieren.
... wobei das Beispiel, wie im Beitrag #5 von ADS definitiv schöner ist ...

Gruß
Larry


----------



## Tmbiz (6 Dezember 2017)

Ich denke das habe ich verstanden. 

Es ist als so Case stepNr

Unter dem CASE gibt es so viele Möglichkeiten wie ich Schritte brauche. Die Var StepNr ist bei mir im Format Byte. Wie kann ich denn nun abhängig von der Zahl die in stepNr steht in die verschiedenen Fälle springen..


----------



## rostiger Nagel (6 Dezember 2017)

Die Nr die du für jeden Case Fall nutzt ist dann dein Sprungziel, elegant wird
es wenn du Constanten dazu verwendest.


----------



## StructuredTrash (6 Dezember 2017)

Tmbiz schrieb:


> Ich denke das habe ich verstanden.
> 
> Es ist als so Case stepNr
> 
> Unter dem CASE gibt es so viele Möglichkeiten wie ich Schritte brauche. Die Var StepNr ist bei mir im Format Byte. Wie kann ich denn nun abhängig von der Zahl die in stepNr steht in die verschiedenen Fälle springen..



Du brauchst nirgendwo hin springen, denn Du bist schon da.

```
CASE stepNr OF
   1: // Was hier steht, wird ausgeführt, solange stepNr=1 ist
   2: // Was hier steht, wird ausgeführt, solange stepNr=2 ist
   ELSE
      // Was hier steht, wird ausgeführt, wenn stepNr <1 oder >2  ist    
END_CASE
```
Für eine Schrittkette könnte das so aussehen:

```
CASE stepNr OF
   1: // Alles was ausgeführt werden muss, solange Schritt 1 aktiv ist
       IF Schritt 1 erledigt THEN   // Schritt weiterschalten
          // Alles, was beim Schrittwechsel von 1 nach 2 zu tun ist
          stepNr:=2;   // Nächster Schritt
       END_IF
   // usw.
END_CASE
```
Wenn Du noch, wie RN vorschlägt, statt Zahlen Konstanten oder Enumerationswerte als Case-Selektoren nimmst, um den Schritten Namen zu geben, wird das schon recht übersichtlich. Wenn Du es von Deiner bisherigen AWL-Programmierung gewohnt bist, Schrittwechsel und Schritt-Aktionen voneinander zu trennen, kannst Du auch zwei CASE-Blöcke schreiben, und das ist noch lange nicht die letzte Variante.


----------



## Tmbiz (7 Dezember 2017)

StructuredTrash schrieb:


> Du brauchst nirgendwo hin springen, denn Du bist schon da.
> 
> ```
> CASE stepNr OF
> ...




Ich bin es gewöhnt mit einem Sprungverteiler zu abreiten. Allerdings ist es dann manchmal etwas schwierig wenn man in einer Kette eine Verzweigung einbauen möchte. Also wenn XY = 1 überspring einen Teil oder wähle eine alternative... Ist XY = 2 geh denn normalen Weg. Ich überlege gerade ob es dann nicht doch einfacher ist die Schritte nicht mir einem Sprungverteiler zu machen sondern alle im CASE zu vereinen.


----------



## Larry Laffer (7 Dezember 2017)

Tmbiz schrieb:


> ... Ich überlege gerade ob es dann nicht doch einfacher ist die Schritte nicht mir einem Sprungverteiler zu machen sondern alle im CASE zu vereinen.



Das ist das, was dir hier die ganze Zeit vorgeschlagen wird. Ich muss aber zugeben, dass wenn man da von Null hereinrutscht es schon im ersten Moment etwas viel sein könnte.
Vielleicht noch einmal von Anfang an :
- der CASE ist im Grunde der Sprungverteiler
- das Wechseln der einzelnen Fälle geschieht durch das einfache Zuweisen einer neuen Schrittnummer - immer dran denken : das Programm wird zyklisch bearbeitet
- du mußt aber beachten, dass ein Schrittwechsel im Grunde sofort mit der Zuweisung einer neuen Schrittnummer erfolgt. Eventuell ist die neue Schrittnummer ja an eine Bedingung geknüpft (Transition) - das mußt du hier dann ggf. mit IF ... THEN umsetzen (im jeweiligen CASE)

Gruß
Larry


----------



## Tmbiz (7 Dezember 2017)

Larry Laffer schrieb:


> Das ist das, was dir hier die ganze Zeit vorgeschlagen wird. Ich muss aber zugeben, dass wenn man da von Null hereinrutscht es schon im ersten Moment etwas viel sein könnte.
> Vielleicht noch einmal von Anfang an :
> - der CASE ist im Grunde der Sprungverteiler
> - das Wechseln der einzelnen Fälle geschieht durch das einfache Zuweisen einer neuen Schrittnummer - immer dran denken : das Programm wird zyklisch bearbeitet
> ...




So ganz langsam lüftet sich der Schleier... In meiner AWL Kette ist es so, dass ich mit dem "next" in einen Bereich springe in dem die stepNr um 1 erhört wird. Denn Befehl Next würde dann in SCL in einer IF Funktion stehen die dann am Ende von meine CASE Fall ist? Richtig?


----------



## Larry Laffer (7 Dezember 2017)

Ja ...!
Schreib mal einen Code und stell den hier ein. Du kannst dich dafür ganz gut an den schon gegebenen Beispielen orientieren ...

Gruß
Larry


----------



## Tmbiz (7 Dezember 2017)

Larry Laffer schrieb:


> Ja ...!
> Schreib mal einen Code und stell den hier ein. Du kannst dich dafür ganz gut an den schon gegebenen Beispielen orientieren ...
> 
> Gruß
> Larry



Welche Datentypen kann man bei CASE verwenden? Ich meine stepNr ist Byte und das mag TIA nicht.


----------



## ADS_0x1 (7 Dezember 2017)

... das kommt darauf an, wieviele Schritte du hast. INT wäre erst einmal ziemlich gut geeignet dafür.


----------



## PN/DP (7 Dezember 2017)

Tmbiz schrieb:


> Welche Datentypen kann man bei CASE verwenden? Ich meine stepNr ist Byte und das mag TIA nicht.


Hilfe > Index > CASE : der Ausdruck muß einen Ganzzahl-Datentyp (xINT) liefern
Siehe auch > Übersicht über die gültigen Datentypen

Versuche mal "CASE BYTE_TO_UINT(stepNr) OF"

Harald


----------

