# Schrittketten Editor & SCL-Code Generator



## jaco (25 März 2014)

Hallo zusammen!

Ich hoff mal ich bin hier im richtigen Unterforum gelandet (bin neu im Forum ).

Ich darf momentan im Rahmen der Uni ein Tool zum Erstellen von Schrittketten schreiben. 
Dieses Tool soll dann die graphisch dargestellte Kette interpretieren und daraus SCL Code generieren.
Bis jetzt stehen "eindimensionale Schrittketten" und ein Grundgerüst aus Case Anweisungen.

Meine Frage ist nun wie ich weiter vorgehen soll.
Ich habe mir vorgestellt, dass man bei Klick auf einen Schritt diesen editieren kann (in einem neuen Fenster).
Graph7 gibt ja die Möglichkeit innerhalb der Schritte bestimmte Aktionen auszuführen.
Wie würdet ihr eine solche "Auswahl" in SCL realisieren? Macht es Sinn bestimmte Funktionen (Setze, Rücksetze, Einschaltverzögerung, etc.)
als Rahmen vorzugeben oder sollte man beliebig seinen SCL-Code einfügen können?

Dazu bin ich mir noch nicht sicher wie ich mit dem Einfügen von zusätzlichen Variablen verfahren soll (bzw. ob dies dann nur Step7/TIA geschehen soll) und ob die Logik zu den Transitionen auch außerhalb des eigenen Codes stattfinden soll.

Für ein paar Gedankenanstöße und Input wäre ich sehr dankbar 

Viele Grüße,
Jaco


----------



## ducati (25 März 2014)

jaco schrieb:


> Ich darf momentan im Rahmen der Uni ein Tool zum Erstellen von Schrittketten schreiben.
> Dieses Tool soll dann die graphisch dargestellte Kette interpretieren und daraus SCL Code generieren.



Dieses Tool gibt es schon und nennt sich SFC (Sequential Function Chart) unter PCS7, wenn es denn um Siemens geht. Also einfach mal danach Googlen, oder in ner VM ne Demo installieren.

Gruß.


----------



## marlob (25 März 2014)

Mal jetzt nicht Siemens. Aber TwinCat 3 verfolgt einen ähnlichen Ansatz. Das könntest du dir mal downloaden und angucken was die da alles machen.
Wie sieht dein Tool denn aus? Benutzt du ein fertiges Programm wie Visio, sfcedit, Enterprise Architect usw. und zeichnest darin deine Abläufe und generierst dann daraus deinen Code? Oder wird das eine komplett eigenständige Software?


----------



## jaco (25 März 2014)

Vielen Dank schonmal für eure Vorschläge!
SFC und TwinCat hatte ich bis jetzt noch nicht auf dem Schirm.

Mein Tool soll eine komplett eigenständige Software werden. Funktioniert bis jetzt soweit, dass ich graphisch eine Schrittkette (momentan noch ohne Parallelzweige) anlegen kann mit Schritten/Transitionen und diese dann als .scl File übersetzt wird (case of...).

Da ich allerdings noch nicht genügend praktische Erfahrungen sammeln konnte (bin noch im Studium), war ich mir nicht ganz sicher inwiefern es Sinn macht die Steps dann manuell im Tool noch editieren zu können bzw. welche Funktionen vielleicht praktisch wären.
In Bezug auf Graph7 hätte ich mir gedacht evtl. Codesnippets wie Setzen, Rücksetzen von Output-Variablen oder auch Timer, etc. für die Steps einfügen zu können, allerdings wäre vielleicht eine komplett freie Möglichkeit Code einzufügen auch nicht schlecht?

VG, Jaco


----------



## ducati (25 März 2014)

- Naja, wer soll das Tool denn anwenden? Oder ist das nur ne "akademische" Aufgabe?

- Ist es für S7-300/400 oder wofür?

- Wie erfolgt denn die Anbindung an die SPS-Variablen?

- Greifst du auf die Symboltabelle zu? Was passiert bei Änderungen der Symbolik?

- Das ganze ist sicherlich eine schöne und auf den ersten Blick nützliche Anwendung, aber der praktische Nutzen entsteht erst durch eine Integration in das SPS-Programmiersystem mit Anbindung an die gemeinsame Datenbank.

- Was das Tool mindestens können sollte, siehst Du, wenn Du Dir SFC anschaust.

Gruß.


----------



## Larry Laffer (25 März 2014)

... ich würde die Idee trotzdem nicht gleich zerreden.
Es ist schon aus viel viel schlechteren Ansätzen etwas Tolles entstanden.

@Jaco:
Zu deiner Frage:  als Bedingung für die Weiterschaltung kann im Grunde alles in Frage kommen - von einer einfachen binären Verknüpfung, eine komplexe binäre Verknüpfung, ein Vergleich bis hin zu einem Misch-Masch aus alledem ...

Gruß
Larry


----------



## ducati (25 März 2014)

Ja nee, zerreden wollt ich's nicht. Ich seh halt immer nur überall Probleme  Wenn man die dann auch löst, kommt oft was gutes raus.

Meine Erfahrungen zu Schrittketten basieren auf SFC und auf einem selbst geschriebenen wiederverwendbaren Schrittkettenbaustein. Von daher hat ich jetzt keine Lust hier nochmal die Doku vom SFC abzuschreiben. Viele Dinge die im SFC gemacht werden sind so sinnvoll, auch wenn die Kopplung zu CFC natürlich in dem Fall hier nicht relevant ist. Aber genau dort sehe ich das Problem, wie kann man sinnvoll die Kopplung zum SPS-Software realisieren?
Man kann natürlich in dem Tool symbolisch oder absolut arbeiten, aber beides basiert dann auf einer separaten, von Step7 unabhängigen Basis. Dies ist doch nicht mehr zeitgemäß. Das Minimum wäre eine Importfunktion für die Step7-Symboltabelle, aber ne ordentliche Nachführung von Änderungen in Step7 ist dann von nöten... Mit der Überlegung bin ich jetzt vermutlich schon 5 Schritte weiter, als der TE grad.

hier der Link zu dem SFC-Handbuch: http://support.automation.siemens.com/WW/view/de/57265603

Gruß.


----------



## Thomas_v2.1 (25 März 2014)

Bei SFC gibt es aber auch zwei Typen von Bausteinen die daraus erzeugt werden: SFC-Typ und SFC-Plan.
Bei einem von beiden werden alle Ein- und Ausgänge über die Bausteinschnittstelle, und Parameter über die CFC-Typische Instanz festgelegt, bzw. sind natürlich auch Parameter möglich.

So etwas könnte man auch problemlos mit einem eigenen Schrittkettentool realisieren, ohne dass man Zugriff auf die SPS-Symbolik haben muss. Zur Visualisierung einer Schrittkette greift man dann auf den Instanz-DB des erzeugten Schrittketten-FB zu.


----------



## jaco (25 März 2014)

Nochmals herzlichen Dank für eure Unterstützung!

@ducati: der Hintergrund für die Entwicklung dieses Tools war der, dass die neue 1200er CPU von Siemens kein Graph7 unterstützt. Für kleine Anwendungen/Prozesse und vielleicht auch für Leute (kommt in der Uni oft vor), die nicht viel Erfahrung mit der eigenständigen Entwicklung von Schrittketten haben, soll damit ein Rahmen in SCL geliefert werden. Das ganze soll am Ende eine .scl Datei (als FB) liefern, die durch die Importfunktion von Step7 TIA recht einfach in ein bestehendes TIA-Projekt integriert werden kann. 

@Larry: Ich dachte mir, dass ich die Transitionen als InputVariablen deklarier und die Logik dann in Step7 realisiert wird. 
Allgemein wollte ich auch nur symbolisch programmieren und alles weitere wie Adressierung soll dann vom Anwender in Step7 gemacht werden.

Der Hauptpunkt an dem ich gerade arbeite ist vor allem die Editierung der Schritte bzw welche Funktionen diese enthalten soll. Für Anregungen in dem Punkt bin ich sehr dankbar!

Falls anderweitige Vorschläge oder Ideen bin ich natürlich offen.
Die Importfunktion der Symboltabelle wäre auf jeden Fall ein guter Ansatz! Vielen Dank für den Tipp


----------



## jaco (25 März 2014)

Nochmals herzlichen Dank für eure Unterstützung!

@ducati: der Hintergrund für die Entwicklung dieses Tools war der, dass die neue 1200er CPU von Siemens kein Graph7 unterstützt. Für kleine Anwendungen und vielleicht auch für Leute (kommt in der Uni oft vor), die nicht viel Erfahrung mit der eigenständigen Entwicklung von Schrittketten haben, soll damit ein Rahmen in SCL geliefert werden. Das ganze soll am Ende eine .scl Datei (als FB) liefern, die durch die Importfunktion von Step7 TIA recht einfach in ein bestehendes TIA-Projekt integriert werden kann. 

@Larry: Ich dachte mir, dass ich die Transitionen als InputVariablen deklarier und die Logik dann in Step7 realisiert wird. 
Allgemein wollte ich auch nur symbolisch programmieren und alles weitere wie Adressierung soll dann vom Anwender in Step7 gemacht werden.

Der Hauptpunkt an dem ich gerade arbeite ist vor allem die Editierung der Schritte bzw welche Funktionen diese enthalten soll. Für Anregungen in dem Punkt bin ich sehr dankbar!

Falls anderweitige Vorschläge oder Ideen bin ich natürlich offen.
Die Importfunktion der Symboltabelle wäre auf jeden Fall ein guter Ansatz! Vielen Dank für den Tipp


----------



## BoxHead (26 März 2014)

Wenn man sich die Quelle von einer S7 Graph Kette mit einem Texteditor ansieht, merkt man recht schnell das die keine Case verwendet haben. Einer der Gründe wird wahrscheinlich der sein das eine Simultanverzweigung schwer mit einer Case umzusetzen ist.

In der Quelle sind alle Schritte aufgeführt mit deren Aktionen und wie diese wirken (Speichern oder nicht speichernd, verzögert usw.) danach kommen die Trantionen mit Quelle und Ziel(en) und der Bedingung.

Ich würde mich wohl an dieser Umsetzung orientieren. Einen FB mit der Kette und je einen Schritt und Transitions FB die je Schritt und Transition im statischen Bereich des Ketten FBs angelegt werden.


----------



## ducati (26 März 2014)

jaco schrieb:


> @Larry: Ich dachte mir, dass ich die Transitionen als InputVariablen deklarier und die Logik dann in Step7 realisiert wird.
> Allgemein wollte ich auch nur symbolisch programmieren und alles weitere wie Adressierung soll dann vom Anwender in Step7 gemacht werden.



OK kann man so machen, dann macht das ganze aber nur Sinn, wenn auch Verzweigungen, Sprünge etc. möglich sind. Für eine einfache lineare Schrittkette kannst Du auch einfach einen Schrittkettenbaustein mit variabler Schrittanzahl schreiben und fertig.

Der Vorteil der graphischen Darstellung ist m.M. auch nur gegeben, wenn ich sehe, welche Zustände eigentlich abgefragt werden und welche Ausgänge gesetzt werden. Aber gut, da es für die Uni ist, kann man das schon so machen.

@Thomas SFC-Typen hab ich noch nie verwendet, macht ja nur Sinn, wenn sehr aufwändige Schrittketten mehrfach identisch im Programm vorkommen. Und das hatte ich bisher noch nie. 

Gruß.


----------



## jaco (26 März 2014)

@BoxHead: wo werden denn die Graph Quellen gespeichert? Hab bisher nichts sinnvolles finden können

Stimmt, graphisch macht das ganze echt nur Sinn wenn Verzweigungen möglich sind. Ist auch so geplant.
Zwecks Coderealisierung von Verzweigungen: angenommen man ist an einem Knotenpunkt angelangt und es folgt ein Alternativzweig. Wäre doch mit:
IF T11 --> Schritt = 11 ; ELSEIF T21 --> Schritt = 21 (also ganz normal mit case)
Oder seh ich das falsch?

Vielen Dank!


----------



## ducati (26 März 2014)

mit Simultanverzweigung meint Boxhead sicherlich einen Parallelzweig, also es laufen mehrere Zweige gleichzeitig ab...


----------



## BoxHead (26 März 2014)

Ja eine Simultanverzweigung ist eion Parallelzweig (in S7 Clasic Sim-Verzweigung genannt).

Mit der Graph Quelle meinte ich ebenfalls eine S7 Clasic Quelle (da konnte man Graphketten noch exportieren).


----------



## BoxHead (26 März 2014)

Hier mal ein einfacher Codeschnippsel (OHNE Parallelverzweigung) nur um den Denkansatz zu verdeutlichen:


```
FUNCTION_BLOCK FB10
(*$_COM Bausteinkommentar*)
CMPSET
         S7Graph-Version: 4000
         WarningLevel: All
         FBInterface: Standard
         SSBLevel: Array
         ASMsgLevel: No
         TargetMachine: AS300StdBlock
         RuntimeBlock: FC 72
         CritAvail: F
         SSkipOn: F
         AckReq: T
         SyncAvail: F
         PermILMan: F
END_CMPSET
(*$_SETTINGS
         ProgLang: LAD
*)
INITIAL_STEP Init (*$_NUM 1*):
(*$_COM Schrittkommentar*)
END_STEP
STEP WarteAufStart (*$_NUM 2*):
(*$_COM Schrittkommentar*)
A0.0   (N)
END_STEP
STEP LinksRechts (*$_NUM 3*):
(*$_COM Schrittkommentar*)
END_STEP
STEP Links (*$_NUM 4*):
(*$_COM Schrittkommentar*)
END_STEP
STEP Fertig (*$_NUM 6*):
(*$_COM Schrittkommentar*)
END_STEP
STEP Rechts (*$_NUM 5*):
(*$_COM Schrittkommentar*)
END_STEP
TRANSITION T_Init (*$_NUM 1*)
  FROM Init
  TO WarteAufStart
CONDITION := E0.0 
END_TRANSITION
TRANSITION T_WarteAufStart (*$_NUM 2*)
  FROM WarteAufStart
  TO LinksRechts
CONDITION := E0.1 
END_TRANSITION
TRANSITION T_Rechts (*$_NUM 4*)
  FROM LinksRechts
  TO Rechts
CONDITION := E0.4 
END_TRANSITION
TRANSITION T_RechtsFertig (*$_NUM 6*)
  FROM Rechts
  TO Fertig
CONDITION := E0.6 
END_TRANSITION
TRANSITION T_Links (*$_NUM 3*)
  FROM LinksRechts
  TO Links
CONDITION := E0.3 
END_TRANSITION
TRANSITION T_LinksFertig (*$_NUM 5*)
  FROM Links
  TO Fertig
CONDITION := E0.5 
END_TRANSITION
TRANSITION T_Fertig (*$_NUM 7*)
  FROM Fertig
  TO Init (*$_JUMP*)
CONDITION := NOT E0.0 
END_TRANSITION
END_FUNCTION_BLOCK
```


----------



## jaco (27 März 2014)

@BoxhHead: dankeschön für den Codeauszug! Hab leider kein Classic zur Verfügung momentan. Ich werd mir den Aufbau mal genauer anschauen!
Für Simultanzweige ist Case wohl echt nicht allzu praktisch. Hab ich nicht dran gedacht.
Dann werd ich mal versuchen eure Tips mal in die Tat umzusetzen


----------



## ducati (31 März 2014)

jaco schrieb:


> der Hintergrund für die Entwicklung dieses Tools war der, dass die neue 1200er CPU von Siemens kein Graph7 unterstützt.



Dazu fällt mir ergänzend noch ein: es wird allzu oft davon ausgegangen, dass die S7-1200 ne S7-300 ersetzen könnte. M.M. kann die S7-1200 i.d.R. ne S7-200 ersetzen. Für mehr sollte man schon über ne S7-1500 nachdenken...

Halt uns mal auf dem Laufenden über das Tool.

Gruß.


----------

