# Schrittkettenprogrammierung



## michaelg (10 November 2008)

Hallo alle zusammen!
Bin seit geraumer Zeit begeisterter Leser dieses Forum und mein Respekt an die jenigen die dieses Thema so gut beherrschen, im Gegensatz zu mir.

Ich beschäftige mich nur in meiner Freizeit mit der SPS und besitze auch keine Hardware sondern nur Software.
Ich lese sehr viel zu dem Thema und erhoffe mir dadurch die Grundzüge der SPS zu verstehen.

Jetzt bin ich bei einem Punkt angekommen wo ich nicht mehr weiter komme.

Wie zerlegt man eine Schrittkettensteuerung in die einzelnen Schritte???

Gibt es ein "Standard"? Wie man es machen muß?

Ich finde einfach nie den richtigen Anfang.

Bin über jeden "Gedankenanstoß" dankbar.

mfg
Michael

P.S.: Gruß an vl. Bin über deine Beiträge begeistert.


----------



## diabolo150973 (10 November 2008)

Hallo,

was verstehst Du unter "einzelne Schritte" ?

Zum Planen hilft Dir vielleicht das hier:

http://de.wikipedia.org/wiki/Ablaufsteuerung

Ich hoffe, dass ich Dich richtig verstanden habe...
Ansonsten einfach nochmal nachhaken!!!

Gruß,

dia


----------



## Perfektionist (10 November 2008)

michaelg schrieb:


> ...
> Gibt es ein "Standard"? Wie man es machen muß?
> ...


Standard: S7 Graph
kann, muss man aber nicht ...


----------



## vierlagig (10 November 2008)

eine möglichkeit eine schrittkette aufzubauen, ist die sprungleiste ... viele finden sie nicht schön, ich find sie praktikabel


```
*
      L     #iSchrittZaehler
      SPL   err                         //Sprungziel, wenn #iSchrittZaehler > 4 ist
      SPA   st0                         //Sprungziel, wenn #iSchrittZaehler = 0 ist
      SPA   st1                         //Sprungziel, wenn #iSchrittZaehler = 1 ist
      SPA   st2                         //Sprungziel, wenn #iSchrittZaehler = 2 ist
      SPA   st3                         //Sprungziel, wenn #iSchrittZaehler = 3 ist
      SPA   st4                         //Sprungziel, wenn #iSchrittZaehler = 4 ist

err:  SPA   end

st0:  //zulässige operationen
      *
      SPA   end

st1:  //zulässige operationen
      *
      SPA   end

st2:  //zulässige operationen
      *
      SPA   end

st3:  //zulässige operationen
      *
      SPA   end

st4:  //zulässige operationen
      *
      SPA   end

end:  //fehlerbehandlung wenn notwendig
```
in den einzelnen sprungzielen kannst du dann die schrittaktionen ausformulieren oder bausteinaufrufe anlegen, je nachdem wie umfangreich deine schrittkette ist. wenn die bedingung zum weiterschalten erfüllt ist den schrittzähler um eins erhöhen und schon wird der nächste schritt abgearbeitet ...

es gibt auch schrittketten konstrukte, die vor der implementierung der schrittaktionen den schrittzähler vergleichen ...

aber ich bin der meinung, im forum gibt es zum suchbegriff schrittkette sehr viel zu lesen ... trag doch mal deine fragen zusammen ...


----------



## Gerhard K (10 November 2008)

> viele finden sie nicht schön, ich find sie praktikabel


 
ich auch
*ACK*


----------



## Kai (10 November 2008)

Eine weitere Möglichkeit ist die Programmierung von Schrittketten mit SR-Gliedern:

http://www.sps-forum.de/showpost.php?p=120722&postcount=1

http://www.sps-forum.de/showpost.php?p=121127&postcount=15

http://www.sps-forum.de/showpost.php?p=121128&postcount=16

Gruß Kai


----------



## HeizDuese (10 November 2008)

Kai schrieb:


> Eine weitere Möglichkeit ist die Programmierung von Schrittketten mit SR-Gliedern...
> 
> Gruß Kai




Die Methode, die ich immer meide !


----------



## Steve81 (10 November 2008)

HeizDuese schrieb:


> Die Methode, die ich immer meide !


 
Aber auch die, die meiner Erfahrung nach am häufigsten verbreitet ist und auch in der Aus- und Weiterbildung gerne gelehrt wird.

Ich möchte jetzt allerdings nicht darüber urteilen ob es auch die beste Methode ist.


----------



## diabolo150973 (10 November 2008)

HeizDuese schrieb:


> Die Methode, die ich immer meide !



:-?*schäm*

Ich kenne es gar nicht anders... Die von 4l oben sieht interessant aus.

Ich habe irgendwo noch ein Schulprojekt rumliegen. Falls Interesse besteht, kann ich ja mal gucken, wo es geblieben ist und das Ding hochladen.
Dann hat man was zum Nachmachen. Ist nix dolles (alles mit SR), aber zum üben reicht es vielleicht.


Gruß,

dia


----------



## vierlagig (10 November 2008)

Steve81 schrieb:


> Ich möchte jetzt allerdings nicht darüber urteilen ob es auch die beste Methode ist.



auf jeden fall ist es die speicherintensivste. kann ich mit der SPL 255 schritte mit einem word abdecken, brauch ich für die selbe schrittanzahl beim S/R 32 worte 

dazu kommt, dass der eindeutige schrittzähler schneller und einfacher interpretiert werden kann, auch von nicht so fähigen programmierern ...


----------



## Perfektionist (10 November 2008)

häng ich also meinen auch noch hinzu:
http://www.sps-forum.de/showthread.php?p=102873#post102873


----------



## Steve81 (10 November 2008)

vierlagig schrieb:


> auf jeden fall ist es die speicherintensivste. kann ich mit der SPL 255 schritte mit einem word abdecken, brauch ich für die selbe schrittanzahl beim S/R 32 worte  ...


Auf jeden Fall ein Argument, dass für die von dir vorgestellte Methode mit den Sprüngen spricht.



vierlagig schrieb:


> dazu kommt, dass der eindeutige schrittzähler schneller und einfacher interpretiert werden kann, auch von nicht so fähigen programmierern ...


Das mit der Interpretation hängt wohl davon ab, was der "Programmierer" in seiner Ausbildung vermittelt bekommen hat. Bei mir Persönlich wurde die Schrittkettenprogrammierung mit SR Gliedern unterrichtet. In der gewerblichen Ausbildung und in der Technikerschule. 
Eigentlich sollten aber beide Methoden von jemandem der in unserem Bereich arbeitet ohne größere Probleme Interprtierbar sein.


----------



## vierlagig (10 November 2008)

Steve81 schrieb:


> Eigentlich sollten ...



ja, ja, der böse böse konjunktiv 

aber natürlich hast du recht und für die, die es nicht verstehen, sind wir ja hier 

bevor die diskussion ausartet in "was sollte einer können, der in eine steuerung gucken oder gar schreiben darf?" möchte ich für diese diskussion auf den neuen faden was sollte einer können, der in eine steuerung gucken oder gar schreiben darf? verweisen ...


----------



## diabolo150973 (10 November 2008)

Ich habe mal in meinem Archiv (unsortierter Papierstapel) gewühlt und 2 Aufgaben gefunden, die geradezu nach einer Schrittkette schreien.

Das eine hieß "Die Bohrmaschine" und das andere "Handhabungsgerät"

Ich würde Aufgabenstellung und Funktionsplan/-diagramm rausrücken.
Nur die Lösung bleibt hier... Vielleicht wäre das was für den Lehrgangsthread?

Wenn es jemand haben möchte, scanne ich das ein und stelle es ins Forum.
---------------------------------------------------------------------------------
Nachtrag: Bohrmaschine ist drin

http://www.sps-forum.de/showpost.php?p=165935&postcount=242

Handhabungsgerät:

http://www.sps-forum.de/showpost.php?p=166101&postcount=243




Gruß,

dia


----------



## moneybrother (13 November 2008)

Hey, das wäre günstig. Ich bin ohnehin gerade dabei Ausbildungsunterlagen für unsere Azubis zu erstellen und das wäre vielleicht mal was, das noch nicht 10 Mal in der Berufsschule durchgenommen würde.


----------



## diabolo150973 (13 November 2008)

moneybrother schrieb:


> Hey, das wäre günstig. Ich bin ohnehin gerade dabei Ausbildungsunterlagen für unsere Azubis zu erstellen und das wäre vielleicht mal was, das noch nicht 10 Mal in der Berufsschule durchgenommen würde.




Da würde ich lieber nicht drauf wetten... Wenn ich das richtig mitbekommen habe, stecken die Lehrer/Ausbilder sich diese Art von Aufgaben irgendwie gegenseitig zu (das spart 'ne Menge an Vorbereitung)... Hier im Forum sind schon mindestens zwei Leute, die aus einer ganz anderen Ecke kommen und die gleichen Aufgaben hatten. 
Aber Du kannst ja Deine Aufgaben auch gerne hier zur Verfügung stellen!
Ich persönlich finde es besser, wenn man ein Projekt hat, an dem man arbeiten kann, als irgendwelche Dinge aus Handbüchern abzuarbeiten...

Gruß,
dia


----------



## moneybrother (14 November 2008)

Ich persönlich finde es auch besser wenn die Azubis konkrete Projekte lösen müssen. Leider sind unsere Projekte ziehmlich aufwendig und nicht so gut geeignet um Grundlagen bei der Programmierung zu vermitteln.

Die Sachen, die ich bereits habe, kann ich Anfang nächster Woche mal reinstellen.


----------



## dodo (14 November 2008)

Wenn die Berufschullehrer sich die Projekte gegenseitig zustecken, warum machen wir das dann eigentlich nicht auch so?
Ich bin auch gerade dabei, ein Projekt für unsere Azubis zusammenzustellen.
Warum wird das Rad immer wieder neu erfunden...?


Zum Thema Schrittketten mit RS Gliedern:
Wenn überhaupt, sollte man das aber mit Setz- und Rücksetzanweisungen machen!


Wenn ich so was sehe wie:
(Ich schreib das mal ganz vereinfacht in AWL, meine aber eine FUP Programmierung mit RS Gliedern)

...
U Schritt2
R Schritt 1

U Schritt 1
U Bedingung 
S Schritt 2 
U Schritt 3
R Schritt 2
...

dann sträuben sich mir die Haare! :sm14:
In einer Schrittkette ist EIN (in Worten EIN) Schritt gleichzeitig aktiv 
(Parallelverzweigungen ausgenommen).
Bei der Programmierung mit RS-Gliedern wie hier angedeutet sind für einen Zyklus lang  2 Schritte aktiv! Iiiiiih! :sm11:


----------



## sps_newbee (12 Mai 2017)

vierlagig schrieb:


> eine möglichkeit eine schrittkette aufzubauen, ist die sprungleiste ... viele finden sie nicht schön, ich find sie praktikabel
> 
> 
> ```
> ...



Da muss aber in den jeweiligen Schritten noch gesprungen werden, wenn die Bedingung noch nicht erfüllt ist, oder???

könnte so aussehen, oder?

UN   #Sprungbedingung
SPB   end
U    #Sprungbedingung
L    #iSchrittZaehler
L     1
+ I
T    #iSchrittZaehler

Und am Ende müsste noch das stehen, oder?

end:   nop 0

Bitte bestätigen oder korrigieren.
LG,
Robert


----------



## Fabpicard (12 Mai 2017)

Ähm fast...

```
L     #iSchrittZaehler

      SPL   err                         //Sprungziel, wenn #iSchrittZaehler > 4 ist
      SPA   st0                         //Sprungziel, wenn #iSchrittZaehler = 0 ist
      SPA   st1                         //Sprungziel, wenn #iSchrittZaehler = 1 ist
      SPA   st2                         //Sprungziel, wenn #iSchrittZaehler = 2 ist
      SPA   st3                         //Sprungziel, wenn #iSchrittZaehler = 3 ist
      SPA   st4                         //Sprungziel, wenn #iSchrittZaehler = 4 ist

err:  SPA   end

st0:  U #Sprungbedingung
      SPBN  end
      // was man halt in dem Sprung machen will, wenn Bedingung erfüllt
      L     #iSchrittZaehler
      INC   1
      T     #iSchrittZaehler
      SPA   end

st1:  //zulässige operationen
      *
      SPA   end

st2:  //zulässige operationen
      *
      SPA   end

st3:  //zulässige operationen
      *
      SPA   end

st4:  //zulässige operationen
      *
      SPA   end

end:  //fehlerbehandlung wenn notwendig
```

Nimm lieber SPBN, denn du willst ja in dem Schritt "hängen bleiben" bis eben deine Vorgabe für diesen Schritt erfüllt ist.
Erst wenn deine Vorgabe erfüllt ist, wird nicht zum Ende gesprungen, sondern der Schritt abgearbeitet und der Schrittzähler
um 1 erhöht, damit beim nächsten Programmdurchlauf mit dem nächsten Schritt weiter gemacht wird 

MfG Fabsi


----------



## sps_newbee (13 Mai 2017)

Fabpicard schrieb:


> Ähm fast...
> 
> ```
> L     #iSchrittZaehler
> ...


Lieber Fabsi,

es ist doch egal, ob ich sage und nicht springe bedingt oder ob ich sage und springe bedingt nicht, oder? Jedenfalls muss doch der Teil übersprungen werden, wo der Schrittzähler erhöht wird.

Also
UN #Sprungbedingung
SPB

Ist gleich

U #Sprungbedingung
SPBN

Für mich war es nur logischer zu sagen, wenn die Sprungbedingung nicht erfüllt ist, springe bedingt.

Gesprungen wird bei beiden ans Ende des Bausteines und weil die SPS den OB1, in den die Sprungleiste gehört, immer zyklisch abarbeitet, springt das Programm wieder in den jeweils aktiven Schritt. Die Bearbeitung bleibt also eigentlich nicht in dem Schritt hängen, denn das wär fatal. Deswegen führen Endlosschleifen zb. In SCL ja zu Abstürzen.

Ich heisse zwar newbee, aber ein wenig Ahnunng hab ich nach den Jahren, in denen ich dabei bin schon.

Lg, Robsi

Gesendet von meinem T1-A21L mit Tapatalk


----------



## PN/DP (13 Mai 2017)

sps_newbee schrieb:


> Lieber Fabsi,
> 
> es ist doch egal, ob ich sage und nicht springe bedingt oder ob ich sage und springe bedingt nicht, oder? Jedenfalls muss doch der Teil übersprungen werden, wo der Schrittzähler erhöht wird.


Hochsprachen(SCL, ST)-Programmierer sind es gewöhnt die Bedingungen so zu formulieren, wann ein Code ausgeführt werden soll (IF ... THEN do ..), und nicht wann er nicht ausgeführt (also übersprungen) werden soll - die kriegen Knoten im Hirn, wenn sie es andersrum formulieren sollen. 

In AWL ist es aber tatsächlich egal wie'rum die Bedingung formuliert wird (weil es SPB und SPBN gibt) und es ist in der Tat oft verständlicher, zu formulieren, wann gesprungen/übersprungen werden soll.


```
st01: U    Weiterschaltbedingung
      SPB  next
      SPA  end

st02: UN   Weiterschaltbedingung
      SPBN next
      SPA  end

st03: U    Weiterschaltbedingung
      SPBN end
      //tue noch was vor dem Weiterschalten
      SPA  next

st04: UN   Weiterschaltbedingung
      SPB  end
      //tue noch was vor dem Weiterschalten
      L    2     //nächster Schritt: Schritt 2
      SPA  Tnex


next: L    #iSchrittZaehler
      +    1
Tnex: T    #iSchrittZaehler

end:  NOP  0
```

Harald


----------



## Fabpicard (13 Mai 2017)

Lieber Robsi,
danke das du direkt interpretierst, das ich dich als newbie ansehe...

Ich bezog mich lediglich auf deinen Vorschlag:

UN   #Sprungbedingung
SPB   end
U    #Sprungbedingung
L    #iSchrittZaehler

---
Sprungbedingung abfragen ob nicht erfüllt und danach wieder Abfragen ob erfüllt, wenn er das nicht übersprungen hat?

Klar kannst du beides machen und es ist Wurst egal. Jeder so, wie er besser damit klar kommt 

@Harald:
Ich bekomm da regelmäßig den Knoten, wenn ich zwischen dem einen Italiener, dem anderen Italiener oder dem Spanier hin und her wechseln darf 
Ob man jetzt lieber:
If nicht erfüllt, then springe, else arbeite den Schritt ab
oder:
If erfüllt, then arbeite den Schritt ab *dazwischen else überspringe den Schritt
programmiert/liest ist vermutlich Geschmacksache

Wenn aber später der doofe Instandhalter einen Fehler darin sucht, findet er ihn fast schneller, wenn er gleich liest Was die Bedingung für den jeweiligen Schritt ist und nicht, was sie nicht ist 
(Das ist meine Meinung, darf jeder seine eigene haben)

MfG Fabsi


----------

