# S7-300… - Schrittketten automatisch erstellen



## holgero (25 April 2011)

Hallo Step7 – Users  

  Ich hab ein kleines Werkzeug für Step7  programmiert:

http://reither.ohost.de/tool4s7.htm

 Speziell den enthaltenen Symbolgenerator nutze ich ständig selbst und möchte ihn nicht mehr missen.

  Nun habe ich einen „AWL-Schrittkettengenerator“ hinzugefügt.

  Die Frage ist: Wird außer mir selbst jemand ein damit erzeugtes Schrittgerüst als Grundlage für seine Programme verwenden?

  Im beruflichen Leben muss ich häufig Spannvorrichtungen für ältere Maschinen programmieren. S7Graf kommt dann meistens wegen seines hohen Speicherbedarfes nicht in Frage. 

  Nun habe ich dieses Teil programmiert. 
  Der erzeugte Code ist vielleicht etwas unübersichtlich. Dafür werden aber viele Eventualitäten mit wenig Speicherplatz erschlagen.
  Evtl. kommt noch ein Grafischer Editor hinzu, um individuelle Verzweigungen, Zeiten ... anzuordnen.

  Z.Z. gibt’s nur diese Vorgabemöglichkeiten:








 Nun bin ich mal auf paar Meinungen gespannt.
   Beste Grüße
Holger













  Hier noch ein Stück Beispielcode:
	
	



```
DATA_BLOCK "DB_Schrittkette"
TITLE =
VERSION : 0.1
  STRUCT
   Step : ARRAY  [0 .. 31 ] OF BOOL ;
   Transition : ARRAY  [0 .. 31 ] OF BOOL ;
  END_STRUCT ;
BEGIN
END_DATA_BLOCK

FUNCTION "FC_Schrittkette" : VOID
TITLE =
VERSION : 0.1


VAR_INPUT
  Init : BOOL ;
  Auto : BOOL ;
  Freigabe : BOOL ;
END_VAR
VAR_TEMP
  n : INT ;
  DwPointer : DWORD ;
  Eins : BOOL ;
  Null : BOOL ;
END_VAR
BEGIN
NETWORK
TITLE =Info

      NOP   0;

// #####################################################
//                                                     #
// Das Grundgerüst dieses Bausteines wurde erzeugt mit #
//                                                     #
//                 Tool4S7 Ver.: 02.10                 #
//             (c) 01.10.2008 - 24.04.2011             #
//                                                     #
//               ( holger.reither@web.de               #
//                  reither.ohost.de                   #
//               olbnet.dyndns.org/hps )               #
//                                                     #
//                                                     #
// #####################################################
//                                                     #
//                                                     #
// Dieser Baustein gliedert sich in 3 Hauptabschnitte  #
// 1. Initialisierung                                  #
//    Ist der Bausteineingang Init = True dann werden  #
//    hier alle Schritte deaktiviert und der/ die      #
//    Initialschritt(e) aktiviert.                     #
//                                                     #
// 2. Schritte + Transitionen                          #
//    Dieser Abschnitt beinhaltet die eigentliche      #
//    Schrittkette.                                    #
//    An den markierten Stellen muss der               #
//    Anwendungsspeziefische Code ergaenzt werden.     #
//                                                     #
// 3. Weiterschaltung                                  #
//    hier erfolgt die Weiterschaltung der Schritte.   #
//    Pro SPS-Zyklus erfolgt maximal eine              #
//    Weiterschaltung.                                 #
//    Damit ist auch garantiert, dass jeder Schritt    #
//    fuer mindestens einen SPS-Zyklus aktiv ist.      #
//    Anpassungen sind hier nur notwendig, wenn        #
//    Alternativ- oder/ und Simutanverzweigungen       #
//    programmiert werden sollen.                      #
//                                                     #
//                                                     #
// Labels:                                             #
//    S... Schritt                                     #
//    T... Transition                                  #
//    F... Weiterschaltung (<F>orward)                 #
//                                                     #
// #####################################################
//                                                     #
// Die Generatoreinstellungen                          #
// f. diesen Bausteinwaren:                            #
//    FC-Nummer:                                       #
//           FC 80                                     #
//    FC-Name:                                         #
//           FC_Schrittkette                           #
//    DB-Nummer:                                       #
//           DB 80                                     #
//    DB-Name:                                         #
//           DB_Schrittkette                           #
//    Erzeuge interne Timer:                           #
//           Off                                       #
//    Max.Anzahl Schritte:                             #
//           32                                        #
//    Nr. 1. Schritt:                                  #
//           0                                         #
//    Nr. Initialschritt:                              #
//           0                                         #
//    Anzahl Schritte:                                 #
//           3                                         #
//    Schrittabstand:                                  #
//           1                                         #
//    Erzeuge Rueckwaertstransitionen:                 #
//           Off                                       #
//    In-Variable Freig. 1:                            #
//           Auto                                      #
//    In-Variable Freig. 2:                            #
//           Freigabe                                  #
//    In-Variable Freig. 3:                            #
//                                                     #
//    In-Variable Freig. 4:                            #
//                                                     #
//                                                     #
// #####################################################

NETWORK
TITLE =Initialisierung Schrittkette

// Erzeuge Konstanten Null und Eins
      O     #Eins;
      ON    #Eins;
      =     #Eins;
      UN    #Eins;
      =     #Null;

// Initialisieren
      U     #Init;
      SPBN  In_X; 

// Ruecksetzen aller (Zeiten,) Schritte und Transitionen
      AUF   "DB_Schrittkette";
      L     2;
In_1: T     #n;
      L     1;
      -I    ;
      L     4;
      *I    ; // Nummer des zu loeschenden DWord
      SLW   3; // erzege Pointerformat
      T     #DwPointer;
      L     DW#16#0;
      T     DBD [#DwPointer]; // loesche aktuelles DWord
      L     #n;
      LOOP  In_1;

      SET   ;
// #####################################################
//                                                     #
// Aktiviere Initialschritt(e)                         #
//                                                     #
      S     "DB_Schrittkette".Step[0];
//                                                     #
// #####################################################

In_X: CLR   ;

NETWORK
TITLE =Info Abschnitt 2

      NOP   0;

// #####################################################
//                                                     #
//  A b    h i e r    f o l g e n    d i e             #
//  e i n z e l n e n    S c h r i t t e    u n d      #
//  T r a n s i t i o n e n                            #
//                                                     #
// #####################################################

NETWORK
TITLE =Schritt 000

      CLR   ;
      U     "DB_Schrittkette".Step[0];
      SPBN  T000;
// #####################################################
// Aktionen Schritt 000                                #
      SET   ;

//                                                     #
//                                                     #
// #####################################################
T000: CLR   ;
// #####################################################
// Transition / Weiterschaltbedingung                  #
      U     #Auto;
      U     #Freigabe;
//                                                     #
//                                                     #
// #####################################################
      =     "DB_Schrittkette".Transition[0];

NETWORK
TITLE =Schritt 001

      CLR   ;
      U     "DB_Schrittkette".Step[1];
      SPBN  T001;
// #####################################################
// Aktionen Schritt 001                                #
      SET   ;

//                                                     #
//                                                     #
// #####################################################
T001: CLR   ;
// #####################################################
// Transition / Weiterschaltbedingung                  #
      U     #Auto;
      U     #Freigabe;
//                                                     #
//                                                     #
// #####################################################
      =     "DB_Schrittkette".Transition[1];
```


----------



## Ralle (25 April 2011)

Da ich ein völlig anderes System nutze (SPL) und einen extra Baustein, welcher die Weiterschaltung macht, kommt das für mich eher nicht in Betracht. Es wird ja auch nur der Rumpf erzeugt, wenn ich nicht irre, der ist bei Verwendung meines derzeitigen (auch renovierungsbedürftigen Systems) eh immer nahezu gleich, die Schrittanzahl ist nur durch die Sprungweite der SPL begrenzt. Jeder hat halt seine Vorlieben...

Mich würde prinzipiell mal interessieren, ob du unter Rückwärtstransitionen, Rückwärtsschritte im Sinne von "Umkehr des Prozesses" verstehst, denn die Realisierung interessiert mich dann doch, ich verzichte i.d.R. darauf, der Programmieraufwand ist noch einmal so hoch, wie für den Ablauf vorwärts. Das soll aber in meinem nächsten "Standard" möglich sein, zumindest 1 Schritt zurück ist oft wünschenswert. 

Ein Programm zur Erzeugung der Schrittkette wäre für mich nur interessant, wenn ich für jeden Schritt die Inhalte (Transitionen, Aktionen) tabellarisch angeben kann und dann der gesamte Ablauf erzeugt wird.

Noch ein kleiner Hinweis: Nimm SLD 3 statt SLW 3 fürs Pointerformat, das ging bei mit mal in die Hose, als die Adressen zu groß wurden!!! Der Pointer ist ein DWord!


----------



## holgero (26 April 2011)

Hallo Ralle,

  danke für deine Hinweise.

  Du hast schon richtig erkannt was das Tool4S7 kann und was es nicht kann.

  Mit der Einstellung „Erzeuge Rückwärts- Transitionen“, wird für jeden Schritt zusätzlich eine Rückwärts- Transition generiert. Die Rückwärts- Transition des ersten Schrittes führt zum letzten Schritt der Kette.

  SLW 3 hab ich aus einer Dokumentation, und ist eindeutig Falsch. Auch wenn es in diesem Falle wahrscheinlich nie Probleme gemacht hätte. Für die kommende Version hab ich es geändert.

  Ich werde bald noch ein paar Verbesserungen/ Erweiterungen einbauen.

  Gerade habe ich noch ein paar Unschönheiten in den Funktionen „Quellengenerator…DB“ und „Quellengenerator…DB-Abbild von Datei“ gefunden. 
  Dort schreibe ich z.Z. Daten in die Aktualwerte statt in die Initialwerte. Das blöde ist nur, das man Arrayvariablen nicht mit Initialwerten versehen kann.

  Bis demnächst
  Gruß
  Holger


----------



## Thomas_v2.1 (26 April 2011)

holgero schrieb:


> Dort schreibe ich z.Z. Daten in die Aktualwerte statt in die Initialwerte. Das blöde ist nur, das man Arrayvariablen nicht mit Initialwerten versehen kann.


Aber mit gewünschten Aktualwerten kannst du die Array-Variablen im Datenbaustein versehen:

```
DATA_BLOCK "DB_Schrittkette"
TITLE =
VERSION : 0.1
  STRUCT
   Step : ARRAY  [0 .. 31 ] OF BOOL ;
   Transition : ARRAY  [0 .. 31 ] OF BOOL ;
  END_STRUCT ;
BEGIN
   Step [0] := false;
   Step [1] := true;
   Transition[0] := true;
   Transition[1] := false;
END_DATA_BLOCK
```


----------



## holgero (26 April 2011)

Das Problem gibts im Tool4S7 -> Quellengenerator -> DB-Abbild von Datei.

Initialisiert man den fertigen Baustein irgendwann einmal, gehen alle Daten verloren. Nicht schlimm aber unschön 
Ich werde dort ne auswahlmöglichkeit einbauen. Array oder fortlaufend nummerierte Variablen oder Strings[n].


----------



## Proxy (26 April 2011)

Wie setzt du die Schritte zurück? 
Also ich kann bei meiner Schrittkette >=32000 Schritte machen und das ohne den DB zu ändern wo die Schrittkette aufgerufen wird.


----------



## rostiger Nagel (26 April 2011)

Proxy schrieb:


> Wie setzt du die Schritte zurück?
> Also ich kann bei meiner Schrittkette >=32000 Schritte machen und das ohne den DB zu ändern wo die Schrittkette aufgerufen wird.



Ähm, 32000 Schritte, die brauchst du doch nicht wirklich?


----------



## Ralle (27 April 2011)

Helmut_von_der_Reparatur schrieb:


> Ähm, 32000 Schritte, die brauchst du doch nicht wirklich?



Nein, er braucht nur 29999! 
Der Wert sagt sicher nur etwas über die theortisch mögliche Länge aus!


----------



## Proxy (27 April 2011)

Ralle schrieb:


> Nein, er braucht nur 29999!
> Der Wert sagt sicher nur etwas über die theortisch mögliche Länge aus!



Genau... 
Mach gerne 100 Schritte bzw. Verzweigungen mit höheren Zahlen das wenn ich was vergessen habe es einfach einfügen kann ohne gleich alles zu schieben.


----------



## cosmomaster (10 Juni 2011)

Ralle schrieb:


> Da ich ein völlig anderes System nutze (SPL) und einen extra Baustein, welcher die Weiterschaltung macht,...
> 
> ...meines derzeitigen (auch renovierungsbedürftigen Systems) eh immer nahezu gleich, die Schrittanzahl ist nur durch die Sprungweite der SPL begrenzt.



Welche Features hat denn Dein SK - ORGA - Baustein in SPL?


----------



## Ralle (10 Juni 2011)

cosmomaster schrieb:


> Welche Features hat denn Dein SK - ORGA - Baustein in SPL?



Oha, du stellst fragen, ich setzen den seit langem ein und mache mir eigentlich kaum noch Gedanken was da im Hintergrund so läuft.

Mal ganz kurz:
SPL (AWL) ist nur die reine Schrittkette. 
In den Schritten wird ein Bit gesetzt, wenn man die Schrittweiterschaltung wünscht, das kann man abhängig machen, ob man sich im Automatikmodus oder im Stepbetrieb befindet. Den Rest macht komplett der Baustein, er  organisiert auch den Start, den Ablauf und das Ende der Schrittkette, wertet Startbedingungen aus, setzt ein Endebit, überwacht die Laufzeit der Kette, kann diese Laufzeitüberwachung anhalten, Schritte bei Erfüllen der Transitionsbedingung noch verzögern und noch so einiges mehr. Aber das Ganze ist sehr speziell auf mein gesamtes System zugeschnitten und daher wäre es mit viel Mühe verbunden, das auf andere Systeme zu adaptieren.


----------



## holgero (17 Januar 2012)

Ich hab gerade mal eine neue Tool4S7 (V2.11) ins Netz gestellt. 
Unter anderem kann man nun in den Einstellungen wählen, ob der erzeugte Code in englischer oder deutscher Mnemonik erscheinen soll. 

Gruß
Holgero


----------



## holgero (23 Dezember 2012)

Tool4S7  ist nun Freeware:

http://reither.ohost.de/tool4s7.htm

Frohe Weihnachten :grin:


----------

