# Schrittketten mit case



## Bensen83 (4 September 2011)

Hallo Leute, will/muss vielleicht bald beruflich mein erstes Projekt mit Codesys machen. 
Hatte mir gedacht, alles in ST zu Programmieren. Hierzu dachte ich, dass
ich Schrittketten in einer case struktur aufbaue.

also dann gibt es einmal die reine schrittkette, welche in case läuft und des weiteren ein paar signales des programmteils, die eigentlich immer aufbereitet werden müssen.

Würdet ihr für diese geschichte 2 funktionen machen. die erste (die case struktur) dann an verschiedenen programmteilen einfach mit call aufrufen und den anderen allgemeinen teil immer callen?
oder sollte ich beides in eine funktion packen und dann mit sk.start die case struktur freischalten?

Oder vielleicht doch nen anderen weg gehen und die sk in AS Programmieren?
Das hätte den Vorteil, dass man bei hinmzufügen eines schrittes (in der mitte) nicht immer die nummern des case ändern müsste.

Hier kann man ja einfach die entsprechende transition ändern um in andere schritte zu gelangen. ist allerdings nicht ganz so flexible wie case, aber man kann eigentlich direkt lesen, wo die sk nach  jedem schritt weiter geht.


Was meint ihr?


----------



## Matze001 (4 September 2011)

Ich würde AS nutzen.

Wenn deine Schritte komplexer werden kannst du diese ja in ST-Ausprogrammieren.

Wenn du umgedingt nur ST nutzen willst dann nimm bei den Schrittnummern genug abstände, um dazwischen noch Schritte einfügen zu können.

Grüße

Marcel


----------



## Bensen83 (4 September 2011)

*Ok*

Ja, finde AS auch ganz praktisch, kann ich da aber auch irgendwie abfragen, ob ein schritt schon durchlaufen wurde?
also im moment (S7 spl LIST) kann ich einfach vergleichen, ob meine schrittnummer größer  xy ist. wenn man in as den schritten namen gibt, geht das ja nicht mehr so einfach, oder?


----------



## drfunfrock (4 September 2011)

Matze001 schrieb:


> Ich würde AS nutzen.
> 
> Wenn deine Schritte komplexer werden kannst du diese ja in ST-Ausprogrammieren.
> 
> ...




Da nimmt man keine Nummern, sondern Enumerates (Konstanten). Die werden entweder automatisch nummeriert oder per Hand. Symbolische Namen sind wirklich leichter zu lesen


----------



## Bensen83 (4 September 2011)

*Ok*

Klingt gut, aber wenn ich dann einen Schritt hinzufügen möchte, muss ich ja immer die enummeration ändern.


Weis hier jemand die genauen Vor und Nachteile von AS und CASE?


----------



## Larry Laffer (4 September 2011)

Nein ... du mußt dann nur die Enumeration entsprechend erweitern und deine Schrittkette anpassen ...

Es gibt keine Vorteil von einer IF-Struktur gegenüber einer CASE-Struktur, es sein denn das Eine oder das Andere ist für dich selbst besser oder schlechter lesbar. Vom Code bzw. vom Ablauf sollte es zu identischen Ergebnissen führen - das ist mehr ein philosophisches Thema ...


----------



## gloeru (4 September 2011)

Larry Laffer schrieb:


> Es gibt keine Vorteil von einer IF-Struktur gegenüber einer CASE-Struktur



Das sehe ich anders. Wenn du einen (komplexen Ablauf hast) musst du nur auf diese Schrittnummer achten die aktuell gilt, der ganze restliche Code wird gar nicht abgearbeitet. Wenn du mit IF arbeitest werden die "AND NOT xxx AND NOT yyy" immer länger ...
Wenn du die Case-Struktur mit Zahlen machst, kann du immer auf die Variable zugreiffen und weisst genau wo dein Programm gerade steht. - Ist insbesondere für grosse Projekte nützlich, wenn mal was nicht läuft weisst du sofort welcher Codeteil abgearbeitet wird...


----------



## Larry Laffer (4 September 2011)

... dann kannst du auch die IF-Abfrage verschachteln ...
Aber wie ich schon sagte - das ist mehr ein philosophisches Thema. Ich selbst würde hier auch auf jeden Fall mit CASE arbeiten (weil ich das hierbei schöner finde) ...


----------



## Matze001 (4 September 2011)

IF Schrittnummer == XYZ THEN
...

wär natürlich zu einfach.. IF oder Case macht hier wenig unterschied. Case sparrt ein wenig Code.

Grüße

Marcel


----------



## gloeru (4 September 2011)

Klar kannst du das, aber zeige mir bei >1000 Schritten, wo jetzt was in welcher IF-Struktur abgearbeitet wird. Meiner Meinung nach wird viel zu wenig CASE verwendet....


----------



## gloeru (4 September 2011)

Matze001 schrieb:


> IF Schrittnummer == XYZ THEN
> wär natürlich zu einfach.. IF oder Case macht hier wenig unterschied. Case sparrt ein wenig Code.



Doch, ein grosser Unterschied gibts:


```
20, 30, 40..100, 400..600: 
Anweisung....
```
Viel Spass sowas mit IF zu erstellen...
Deshalb nimm Case, mache genügend grosse Schritte am Anfang (Du hast mind. 32000 Stück zur Verfügung)


----------



## Matze001 (4 September 2011)

Meiner Meinung nach sollte ein Schritt nur eine Anweisung beinhalten.

Mit diesem Case-Konstrukt könntest du ganz schön Probleme bekommen.
Aber das muss man ja selbst wissen.

Grüße

Marcel

P.S: Ich selbst würde auch CASE nutzen...


----------



## Bensen83 (4 September 2011)

*Ok*

Danke für eure Beiträge, aber ich meinte die vor und nachteile von

AS zu CASE

NICHT von If

;-)


----------



## Larry Laffer (4 September 2011)

Bensen83 schrieb:


> Danke für eure Beiträge, aber ich meinte die vor und nachteile von
> 
> AS zu CASE ;-)


auch das ist mehr etwas Philosophisches - ich würde hier aber dennoch CASE bevorzugen ...


----------



## Bensen83 (4 September 2011)

*Ok*

Danke, gibt es dadurch auch noch vorteile? 
Was halten den andere von der Idee mit der Enumeration?
Also Prizipiell finde ich es eine Gute Idee, aber erstens muss ich dann eine enum für jede SK haben, diese jedesmal, wenn ich was ändern möchte auch ändern und ich sage mal so, wenn ich lese, dass ich im schritt 28 bin (bspw.), dann finde ich den doch besser in der SK, wenn ich nach 28: oder so suche, als wenn da die enum steht, oder?

fand es halt bei AS irgendwie vorteilhaft, dass wenn man einen schritt mitten drin einfügen will (und beispielsweise in case keine reserve mehr hat), muss man ja auch die "sprünge" der anderen schritte anpassen, die bspw. vorher auf den case 30 gingn, denn die gehen ja jetzt auf 31. das wäre ja bei as nicht notwendig.
is klar, bei ner enum wäre das auch nicht notwendig, weil man ja dann die enum ändern könnte. Allerdings unm es sauber zu halten, müsste man dann immer alles verschieben.
bin im moment etwas im zwiespalt.


----------



## StructuredTrash (4 September 2011)

Bensen83 schrieb:


> fand es halt bei AS irgendwie vorteilhaft, dass wenn man einen schritt mitten drin einfügen will (und beispielsweise in case keine reserve mehr hat), muss man ja auch die "sprünge" der anderen schritte anpassen, die bspw. vorher auf den case 30 gingn, denn die gehen ja jetzt auf 31. das wäre ja bei as nicht notwendig.
> is klar, bei ner enum wäre das auch nicht notwendig, weil man ja dann die enum ändern könnte. Allerdings unm es sauber zu halten, müsste man dann immer alles verschieben.
> bin im moment etwas im zwiespalt.


Die Enums kannst Du doch automatisch durchnumerieren lassen. Eine Zeile mit einem weiteren Enumerationswert in die Typdeklaration einzufügen, ist dann doch kein grosser Aufwand.


----------



## Bensen83 (4 September 2011)

*Ok*

Also beispielsweise die enum in 10er schritten erstellen und dann wenn noch was benötigt wird einfach dazwischen einfügen?
Also rei theoretisch ist es ja egal, ob der ablauf auch wirklich in der richtigen reihenfolge (1..2..3..4..5 usw.) ist, aber es ist eben schöner.  
aber dank einer enum könnte man es auch durcheinander laufen lassen (den neuen schritt hinten an der enum anfügen. und wenn man ihn zwischen drin einfügt, bzw schritte tauscht, muss man ja dann nur noch die enum anpassen und nicht in der case nachsehen, wo überall der case verwendet wurde, weil das ja dann wiederum über die veränderte enum indirekt mitverändert wurde. stimmts? ;-) 
man müsste hat bei veränderungen wirklich nur die enum und vielleicht ne stringtable in der visu anpassen.

abeer vom Prinziep her Case mit enum sollte ein gutes Kozept sein, oder?


----------



## StructuredTrash (4 September 2011)

Einfach die Enumeration ohne eigene Numerierung erstellen. Wenn Du später ein weiteres Element in die Enumeration einfügst, werden die Zahlen werte für die folgenden Elemente automatisch um 1 erhöht. Wenn Du im Programm konsequent mit den Namen der Enum-Elemente arbeitest und nicht mit Zahlenwerten, brauchst Du daran nichts ändern.


----------



## El Cattivo (8 September 2014)

Hallo,
ich muss den alten Thread noch einmal aufmachen.
Gibt es bei der Schrittketten programierung mit CASE auch die möglichkeit eines Paralellzweig, ein Alternativzweig ist ja recht einfach. Aber bei zwei paralell laufenden Schrittketten kann es schnell unübersichtlich werden.


----------



## Larry Laffer (8 September 2014)

Hallo,
ein Parallelzweig macht die Sache immer unübersichtlich (und ist mit Case m.E. gar nicht sinnvoll machbar). Das würde ich in der gleichen Schrittkette gar nicht lösen sondern dafür eine separate Schrittkette aufziehen, der du einen Start gibst und deren Status du dann an passender Stelle in deinem Hauptstrang abfragst - im Prinzip also ein Art Unterprogramm starten.

Gruß
Larry


----------



## MasterOhh (8 September 2014)

Wenn man mehrere parallel laufende Schrittketten hat, wäre meiner Meinung nach dann doch AS die Sprache der Wahl.


----------



## Gordrin (8 September 2014)

Man könnte das auch sehr gut mit CASE machen. Man muss dazu eine Hauptschrittkette haben und dann einen Schritt in dem die Parallelschritten sind. Diese Parallelablaufenden Schritte werden in zwei weitere Schrittketten (mit eigenen Schrittenumerationen) ausgeführt. Sobald man dann wieder zum Hauptzweig kommen soll, springt man in diesem Weiter.

Bsp:


```
case iHauptschrittkette of
  Hauptschrittkette_Schritt1: //Irgendwelche aktionen
    iHauptschrittkette := Hauptschrittkette_ParallelSchritt;

  Hauptschrittkette_Schritt2: // Parallele Schrittketten sind hier enthalten
     case iParallelSchrittkette1 of
        ParallelSchrittkette1_Schritt1: 
            //Irgendwelche Aktionen
            iParallelSchrittkette1 := ParallelSchrittkette1_Schritt2;

        ParallelSchrittkette1_Schritt2: 
            //Irgendwelche Aktionen
    End_Case
    
    case iParallelSchrittkette2 of
        ParallelSchrittkette2_Schritt1: 
             //Irgendwelche Aktionen
            iParallelSchrittkette1 := ParallelSchrittkette2_Schritt2;

        ParallelSchrittkette2_Schritt2: 
            //Irgendwelche Aktionen
    End_Case
    
    if iParallelSchrittkette1 = ParallelSchrittkette1_Schritt2
        And iParallelSchrittkette2 = ParallelSchrittkette1_Schritt2 then
        iHauptschrittkette := Hauptschrittkette_Schritt2;
    END_IF
  
  Hauptschrittkette_Schritt3: 
    //Irgendwelche aktionen
    iHauptschrittkette := Hauptschrittkette_ParallelSchritt;

END_CASE
```

Natürlich könnte man die beiden Parallelschrittketten in Funktionen auslagern der Übersichtlichkeit halber und nur den Funktionsaufruf in dem Schritt "Hauptschrittkette_Schritt2" aufrufen.

Ist schnell heruntergeschrieben ohne gewährleistung der Funktion .

Gruß Stefan


----------



## StructuredTrash (8 September 2014)

Ich schliesse mich Larry Laffer an. Für jeden Ablauf ein eigenes CASE-Konstrukt. Starten von Ablauf 2 mit einem Schritt aus Ablauf 1, dann in Ablauf 1 auf Ende von Ablauf 2 warten. Am besten mit einem eigenen Warteschritt in Ablauf 1, der nicht zusätzlich auch ein Weiterschaltereignis des eigenen Ablaufs erfasst. Dann kriegt man parallele Abläufe auch mit CASE sauber hin.


----------



## tengels (10 September 2014)

Hallo,

grundsätzlich kann dir keiner eine Antwort darauf geben ob  du AS oder CASE nehmen sollst das entscheidet immer der Programmierer  und der entscheidet was er am besten kann oder was im Pflichtenheft  steht.

Grundsätzlich wird eine Case Schrittkette immer mit  Enumerationen sinnvoller weise gemacht. Frag mal einen Informatiker zum  Thema Magic Numbers.

Denn grundsätzlich steht bei größeren  Projekten in deiner Shrittkette nicht nur 5 schritte sondern schnell mal  ein paar mehr und da wäre es sinnvoll zu wissen wie der Schritt heißt  was da passiert damit du auch nach einer Woche, Monat oder Jahr direkt  weißt was da passiert bzw. nicht passiert.

Und jetzt komm mir nicht mit die Nummer finde ich schneller oder so nem driss.

Ausserdem  Wartest du an bestimmten stellen in der schrittkette eh auf Signalen  (Sensoren) aus dem Feld oder auf Rückmeldungen vom Aktor das etwas in  Position ist.

Jedoch kanns du das auch machen wie du willst. DU  entscheidest in der Regel und es kommt ganz darauf an was du  programmieren willst.


----------

