# "Konfigurierbare Schrittkette" - wie macht man so etwas?



## on69 (30 Juli 2009)

Hallo zusammen,
ich hab folgende "Herausforderung": Ich programmiere eine Maschine, die mit einer S7300 gesteuert und einer WinCC flexible Runtime bedient wird.
Der Ablauf ist eine typische Ablaufsteuerung. Der Kunde hat aber folgenden Wunsch: Es soll ein Editor vorhanden sein, mit welchem der Bediener sich die Abläufe selber konfigurieren kann.
Ich versuche es an einem Beispiel zu erklären:
Es gibt die Funktionen A, B, C und D dazu die Bedingungen x, y und z.
Der Bediener stellt folgende Abläufe zusammen:

Ablauf 1:
Start
Wenn y dann führe B aus, danach
wenn z führe A und C aus, danach
wenn wieder y fürhe D aus
Ende

Ablauf 2:
Start
Wenn z dann führe A aus, danach
wenn x fürhe D aus, danach
wenn y führe B aus
Ende

Der Bediener soll die Kombination aus Funtkionen und Bedingungen beliebig zusammenstellen und als Datei abspeichern können. (Für einen "sinnvollen" Ablauf ist er selbst verantwortlich).
Dazu soll es z. B. Buttons mit den o. g. Funktionen und Bedingungen geben, die - wenn in entsprechender Reihenfolge angeklickt - eine Datei mit dem gewünschten Ablauf erzeugen.

Ich hab zwar einige Erfahrung mit Step7, SCL und GRAPH7, rel. wenig Erfahrung mit VB-Scripten in WinCCflexible. Ich weiß allerdings nicht wie man das genannte Problem angeht.

Für Lösungsansätze (mit der prinzipiellen Vorgehensweise) bin ich sehr dankbar!


----------



## Larry Laffer (30 Juli 2009)

Hallo,
ich würde sagen, das du da eher eine Art Interpreter programmieren mußt.
So wie ich dich verstanden habe willst du dir die Ablaufschritte, deren Reihenfolge und ggf. Unterbedingungen merken.

Du machst dazu eine Teach-Modus auf der Visu.
Jede gedrückte Taste schreibt in den Programm-DB eine Code (den du dann hinterher entsprechend auswerten mußt). Gelcihzeitig erhöhst du den Befehls-Pointer (für den nächsten Schreib-Vorgang). Wenn du Teach-Ende drückst, dann wird der DB abgeschlossen.

Wenn das Programm dann laufen soll, dann fragst du den ersten Befehl des DB ab, führst den aus und setzt nach Ausführung den Lese-Pointer für den DB um 1 höher, liest dann diesen Befehl usw.
Findest du die Markierung "Ende" ist der Ablauf komplett und du verhälst dich entsprechend - also auf jeden Fall den Lese-Pointer zurücksetzen und ggf. den Ablauf erneut starten ...

Habe ich deine Anfrage richtig verstanden ?

Gruß
L


----------



## rostiger Nagel (30 Juli 2009)

Hallo on69,
für mich bittet sich der Sprungverteiler als Variable Schrittkette an.
Du erstellst für jeden Schritt eine Variable wo der folgende Schritt für
den Aktiven Schritt eingetragen wird. Diese Schritte kannst du dann
sehr einfach in der HMI editieren, siehe Beispiel.


```
STEP: L     #STEP.Nr
      SPL   SE
      SPA   S0                          
      SPA   S1                     
      SPA   S2                        
      SPA   S3                       
      SPA   S4                       
      SPA   S5                       
      ..usw..
      SPA   SEND                        
SE:   NOP   0
      SPA   work


S0:  ..was immer
       ausgeführt
       werden soll..
       L STEP._1
       T STEP.Nr
       SPA  work

S1:  ..was immer
       ausgeführt 
       werden soll..
       L STEP._2
       T STEP.Nr
       SPA work
      
      ...usw...

work: NOP 0
```
gruß helmut


----------



## jabba (30 Juli 2009)

So in der Art könnte ich mir das auch vorstellen.

Aber , als erstes solltest du mal  angeben in welchem Bereich der Benutzer sich bewegen können soll. Denn ohne Grenzen festzulegen wird dies schwierig sein.

Grenzen könnten z.B. sein
Maximale Anzahl aller Schritte
Maximale Anzahl an Aktoren pro Schritt
Maximale Anzahl an transitionen pro Schritt.

Im Display könnte man dann diesen "DB" editieren, gefüllt wird der aus Integerwerten eine Symbolikliste .

Z.b  Ein Bild pro Schritt im Display
Nun kann man Ausfüllen welche Aktion ausgeführt werden soll.
Z.B. Zylinder 1 nach AS  /Auswahlwert =1
Zweite Aktion "Keine " / Auswahlwert =0

Dann Transitionen abfragen
z.B. "Zylinder 1 in AS" / Auswahlwert = 1
Zweite Transition
z.B. "Lichtschranke teil vorhanden" / Auswahlwert =80

Die Schrittkett wird nun einmal fest programmiert , mit allen möglich Funktionen.

Die Eingänge werden nun aufgrund der Integerzahl übder indirekte Adressierung (Adressen aus einem Konfigurations-DB) gelesen.
Bei den Ausgängen andersherum.

Genauso könnt man dann noch ein Feld für einen Sprung definieren.

Aber: irgendwann kommt man hier an eine Grenze. Was sollen die benutzer alles können ? Irgendwann könnte man denen auch ein Panel-PC mit Graph hinstellen .
In wesentlich einfacherer Form hab ich das schon gemacht , da mussten die Leute nur festlegen können welche Zylinder wann fahren sollen.


----------



## on69 (30 Juli 2009)

Hallo nochmal,
@Larry: Du hast mich richtig verstanden. Ich muss mich allerdings erst mal schlau machen, wie man in WinCC flexible den besagten Teach-Modus realisiert (meine SPS-Künste halten sich offenbar doch sehr in Grenzen).
@Helmut: Danke für Deinen Vorschlag. Kannst Du mir aber bitte noch einen Tipp geben WIE ich die Schritte in der HMI editieren kann? Das Variieren der Schrittabfolge (bzw. Transitionen) ist gerade mein Problem.
@jabba: Es werden ca. 30 Schritte notwendig sein mit etwa 3 Aktionen bzw. 3 Transitionen pro Schritt. Ich werd mir auch Deinen Vorschlag zu Gemüte führen, muss vorher allerdings nochmal nachsehen, wie die Sache mit dem KonfiguraitonsDB funktioniert.
Vorerst BESTEN DANK für Eure schnellen Antworten!!!


----------



## Larry Laffer (30 Juli 2009)

Hallo On,
der "besagte Teach-Modus" ist keine Funktion von Flex, sondern der Modus, in den du dein SPS-Programm versetzt. D.h. : bist du im Teach-Modus wird aufgezeichnet - sonst nicht ...

Im Detail würde mein Vorschlag so aussehen :
Du hast auf der Visu Tasten, denen du feste Funktionen zuordnest.
Wird die erste Taste gedrückt, so schreibst du deren Funktionscode (z.B. w#16#01) in den DB und erhöhst den Befehlszeiger. Das gilt dann für jede weitere Taste.

Beim Abarbeiten sähe das dann so aus, das du den DB abfragst, wie der nächste Befehl lautet, den auswertest und ausführst. 

Im Vorfeld solltest du dir aber zunächst eine Liste mit den möglichen Einzelfunktionen erstellen und denen Code-Nummern zuordnen. Das erhöht die Übersicht beim Erstellen des Ganzen.

Die Aufschlüsselung und Umsetzung würde ich wegen der Komplexität der Angelegenheit mit SCL realisieren. Ich könnte mir gut vorstellen, dass die Angelegenheit in AWL ganz schön unübersichtlich werden kann ..

Gruß
LL


----------



## jabba (30 Juli 2009)

Egal für welchen Lösungsansatz du dich entscheiden wirst, es wird keine leichte  Aufgabe werden. Die fordert auch einem geübten Programmierer einiges ab.


----------



## Ralle (30 Juli 2009)

on69 schrieb:


> Es werden ca. 30 Schritte notwendig sein mit etwa 3 Aktionen bzw. 3 Transitionen pro Schritt.



Wenn auch die Aktionen und Transitionen im Schritt noch unterschiedlich sein können, dann wird das ein Megaaufwand, denn alle möglichen Varianten müssen dann entweder in Schrittvorlagen vorgehalten werden oder aber man programmiert das in einen Schritt, in dem die Aktionen und Transitionen mit "Schaltern" deaktivert werden können. 

Wenn ich das so lese hätte ich folgenden Ansatz.

Jede Aktion und jede Transition wird einzeln programmiert, so daß sie per Sprungleiste angesprungen werden kann. 2x3 Sprungleisten, drei für Aktionen, drei für Transitionen. Dann wird eine Schrittkette erstellt, ebenfalls eine Sprungleiste, in der fest, z.Bsp. 50 Schritte, programmiert werden. Dabei sind in jedem Schritt 3 Aktionen und 3 Transitionen variabel angelegt (je nach Anwahl der Aktion-Sprungleiste 1-3 und der Transition-Sprungleiste 1-3). Die Zuordnung zu den Aktionen und Transitionen erfolgt über einen DB. In diesem werden die je 3 Aktionen und Transitionen als Nummer hinterlegt, das passiert z.Bsp über WinCCFlex.

Zusatz: Die je 3 Sprungleisten können identisch sein, müssen aber jeweils alle möglichen Aktionen bzw. Transitionen enthalten. Nur die SPL-Variable und die Ergebnisvariable (Transition erfüllt) muß natürlich unterschiedlich sein.


----------



## Larry Laffer (30 Juli 2009)

@Ralle:
Warum so kompliziert ?

```
Aktion := Befehls_Liste [Befehls_Counter] ;
 
if Aktion = 11 then   // fahre Handling nach vorn
   Handling_vorfahren := true ;
   Handling_zurückfahren := false ;
   if Handling_vorn then 
      Befehls_Counter := Befehls_Counter +1 ;
      goto Ende_Abfrage ;
   end_if ;
 
els_if Aktion = 12 then   // fahre Handling zurück
   Handling_vorfahren := false ;
   Handling_zurückfahren := true ;
   if Handling_hinten then 
      Befehls_Counter := Befehls_Counter +1 ;
      goto Ende_Abfrage ;
   end_if ;
 
end_if ;
 
Ende_Abfrage: ;
```
... so würde ich mir das im Prinzip in SCL vorstellen ... (am Beispiel eines Handlings)

Gruß
LL


----------



## zotos (30 Juli 2009)

Larry Laffer schrieb:


> @Ralle:
> Warum so kompliziert ?
> 
> ... so würde ich mir das im Prinzip in SCL vorstellen ... (am Beispiel eines Handlings)
> ...



Dann bitte aber mit einer CASE-Verzweigung und ohne GOTO.


----------



## Grubba (30 Juli 2009)

Würde mich dem Vorschlag von Larry anschliessen.

Will mal einen kleinen Vorschlag grob aufreissen. Zur Programmierung würde ich, wie Larry schon sagte, in SCL machen. Das erleichtert den Zugriff auf den Array und die Struktur.

Erstell Dir zuerst mal eine Struktur.
Die beinhaltet:
- die nächste Schrittnummer, zu der weitergesprungen werden soll
- ein paar Bits, die UND-verknüpft werden 
- ein paar Bits, die ODER-verknüpft werden
- alles was Dir noch so einfällt

Also ungefähr so:

TYPE MyStepstruct
NextStep: INT;
AndBit_1: BOOL;
AndBit_2: BOOL;
AndBit_3: BOOL;
AndBit_4: BOOL;
OrBit_1 : BOOL;
OrBit_2 : BOOL;
OrBit_3 : BOOL;
OrBit_4 : BOOL;
ActOut_1 : BOOL;
ActOut_2 : BOOL;
ActOut_3 : BOOL;
ActOut_4 : BOOL;
END_TYPE 

Mit einem Array dieser Struktur füllst Du Dir einen DB. Den Array mindestens so gross wählen, dass alle Schritte reinpassen.

Die UND und ODER Bits werden in der SPS fest verknüpft. Ist zwar nicht die grenzenlose Freiheit, aber besser als nichts. Die Verknüpfungsweise legst Du selber fest. Vielleicht ist an dieser Anlage ja eine bestimmte Kombination sinnvoll.

Am WinCCFlex könnte der Benutzer dann eine Zahl eingeben, die seine Schrittnummer darstellt und in Deinem Programm den Array-Index.
Du zeigst ihm dann den Inhalt dieses Feldes, bzw. Struktur an. Also die nächste Schrittnummer und die einzelnen Bits. Die kann er dann nach belieben ändern und per Button wieder in den DB zurückschreiben.

Wenn Dein Programm dann den Ablauf startet, springt es in den ersten Schritt. Dort stehen einerseits die Ausgänge oder was auch immer, und auch die Bits, die die Weiterschaltbedingung bilden. Ist die Bedingung erfüllt, setzt Du den Array-Index auf die Ziel-Schrittnummer. Im nächsten Zyklus greifst Du dann auf dieses (Ziel)-Feld zu  und das Spiel geht wieder von vorne los. Auf diese Art kannst Du auch Endlosketten programmieren lassen.

Was Du in Deine Struktur einbaust, ist relativ frei wählbar. Denkbar wären auch Zeitwerte für Timer usw. usf.


----------



## Larry Laffer (30 Juli 2009)

zotos schrieb:


> Dann bitte aber mit einer CASE-Verzweigung und ohne GOTO.


... oder mit CASE ... der war mir aber nun "auf die Schnelle" nicht eingefallen ...

...


----------



## rostiger Nagel (30 Juli 2009)

on69 schrieb:


> @Helmut: Danke für Deinen Vorschlag. Kannst Du mir aber bitte noch einen Tipp geben WIE ich die Schritte in der HMI editieren kann? Das Variieren der Schrittabfolge (bzw. Transitionen) ist gerade mein Problem.



Das einfachste Editieren in der HMI ist es für mich die Variablen in ein Rezept zu schieben, einfach die Werte eintragen und als Datensatz speichern.


----------



## Larry Laffer (30 Juli 2009)

... da hätte ich auch noch einen Vorschlag dazu :
Du baust dir passend beschriftete Tasten auf die Oberfläche deiner Visu. Jede dieser Tasten setzt ein Bit in der Steuerung (wenn Teach-Betrieb angewählt ist). Ist eines dieser Bits gesetzt, dann sperrst du alle anderen Tasten auf der Oberfläche (keine Freigabe). Das würde z.B. so gehen, dass du die Tastenbits noch einmal als DWORD (oder ähnlich) einliest und für die Freigabe auf 0 vergleichst. Ist ein Tasten-Bit gesetzt, dann ist das DWORD <> 0 ...

In deinem SPS-Programm hast du nun eine Sequenz, die auf das Tasten-Bit wartet. Ist ein Bit da, so wird in die Befehls_Liste ein entsprechender Code hineingeschrieben und der Pointer für den nächsten Array-Index um 1 erhöht (auch sehr schön in SCL zu machen). Nun wird das Bit gelöscht (weil ja bearbeitet) und damit die Visu wieder für neue Eingaben freigegeben ...
Betätigst du die Taste "Programm fertig", so wird eine Ende-Markierung in die Liste geschrieben.

Gruß
LL


----------



## mega_ohm (19 September 2009)

Helmut_von_der_Reparatur schrieb:


> Hallo on69,
> für mich bittet sich der Sprungverteiler als Variable Schrittkette an.
> Du erstellst für jeden Schritt eine Variable wo der folgende Schritt für
> den Aktiven Schritt eingetragen wird. Diese Schritte kannst du dann
> ...


*Hallo "Helmut von der Reparatur",*


Ich fand Deine "Bedienungsanleitung für Sprunglisten" so gut beschrieben, daß ich dachte.... >>> DAS ist es, was ich gesucht und bisher nie gefunden habe !!

Für's Erste hatte ich gedacht, daß ich Deine Anleitung zum Thema "Sprungliste" verstanden hätte...
Aber nach einer 1zu1- Umsetzung auf mein Projekt kamen ca. 1000 Fragen...

Ich bin gerade dabei, eine mehrstufige Absaug- und Entstaubungsanlage zu proggen. Ich hatte früher schonmal Fragen zu Absauganlagen... aber es ist tatsächlich eine neue, andere Anlage... [größer, weiter, höher, schneller....]    


Für sämtliche "Zeiten" ( Normalbetrieb [Automatik], Räumbetrieb [Automatik], Filterreinigung während Normalbetrieb, Filterreinigung während Räumbetrieb, Ventil-Ansteuerung etc... würde ich gern einen Taktmerker verwenden... und diesen Takt mittels eines FB's und "eigenen Zählern" [ als MB oder MW ] "verwursten".

Ich habe mir das so vorgestellt:

```
- Übergabe an den FB =>  "Job_ID_No" // eine Dez.Zahl als  BYTE, IN-Var
 
- den Taktmerker kann ich direkt im FB vergleichen
 
- Taktmerker (mit pos. Flanke) "hochzählen" (TEMP-Var= #Takt)
- Laden des für diesen Job in DB1 hinterlegten Taktes ( z.B. DB1.DBW0)
Vergleich, ob  #Takt > DB1.DBW0
Wenn ja, dann setze ...  Cnt_OK  ( OUT-Var= BOOL)
```
Mir hat diese "SPL" soooo gut gefallen, das wär's... wenn es funktionieren würde.

Die "Job_ID_No" wird *online* getaktet angezeigt... 
Bei Job_ID_No= 1 wird genau die 1. Sprungmarke ( SPA M1 ) übersprungen, alle anderen Sprungmarken werden ausgeführt.

Oder muß es doch ein bedingter Sprung sein ???


( eigentlich wird nur der Sprung am Ende der SPL abgearbeitet )

Ich würde mich freuen, wenn Du einem s7-Greenhorn etwas "Nachhilfe" -Unterricht geben könntest.

Mfg


----------



## rostiger Nagel (19 September 2009)

Hallo mega_ohm,
es gibt viele gestaltungsmöglichkeiten für einen Sprungverteiler,
in meinen beispiel ist es so das genau der Schritt (Marke) angesprungen
wird der in der Variablen "STEP.Nr" steht und nur der Schritt alle anderen
werden durch anweisung "spa work" übersprungen.

Wenn ich dich richtig verstehe möchtest du alle Marken durchlaufen und
nur geziehlt ein paar anweisungen vor dieser Marke nicht bearbeiten.
Das geht auch, du läst bei einfach die anweisung "spa work" fehlen.
Wie die STEP.Nr bzw. deine Job_ID bearbeitet werden soll müsesen wir
dann noch ermitteln


```
STEP: L     #STEP.Nr
      SPL   SE
      SPA   S0                          
      SPA   S1                     
      SPA   S2                        
      SPA   S3                       
      SPA   S4                       
      SPA   S5                       
      ..usw..
      SPA   SEND                        
SE:   NOP   0
      SPA   work
 
 
S0:  ..was immer
       ausgeführt
       werden soll..
 
 
 
S1:  ..was immer
       ausgeführt 
       werden soll..
 
 
 
      ...usw...
 
work:
```
 
Das kann erst nur mal zur annäherung angenommen werden, weil ich
noch nicht so richtig verstanden habe wo du hin möchtest.

gruß helmut


----------



## mega_ohm (20 September 2009)

Helmut_von_der_Reparatur schrieb:


> Hallo mega_ohm,
> es gibt viele gestaltungsmöglichkeiten für einen Sprungverteiler,
> in meinen beispiel ist es so das genau der Schritt (Marke) angesprungen
> wird der in der Variablen "STEP.Nr" steht und nur der Schritt alle anderen
> ...


Ich bin noch in der Lern-Phase für die Sprungliste...
was bedeutet, daß ich sicher noch einige Fragen haben werde, z.Zt. aber erst mal schaue, wie weit ich selbst komme.

Die TEMP- Var  #Step.No  ist eine normale Variable oder ein Pointer oder so'n Zeug ???

Mit dem Punkt im Namen...  da habe ich ein Verständigungsproblem.

Bei TPascal oder BPascal  wurden Zeiger immer mit *^ *gekennzeichnet.
Ich meine... dieser Punkt bei _#Step_*.*_No_ hat in irgendeiner, von mir gesichteten Prg.-Sprache irgendwo eine besondere Bedeutung.... ich komme nur eben grad' nicht drauf, ob ich da bei s7 einfach was verwechsle...

(z.Zt. komme ich jedenfalls mit dem SPL- Befehl noch gar nicht klar      )


Mfg


----------



## Paule (20 September 2009)

mega_ohm schrieb:


> Die TEMP- Var #Step.No ist eine normale Variable oder ein Pointer oder so'n Zeug ???
> 
> Mit dem Punkt im Namen... da habe ich ein Verständigungsproblem.


Hallo Mega_ohm,

der Punkt entsteht z.B. durch die Structurierte Schreibweise in einem Datenbaustein.

L "DB_005".Prozesswerte.Sollwerte.Motordaten.Geschwindigkeit


----------



## rostiger Nagel (20 September 2009)

Hallo mega_ohm,
STEP.Nr ist eine normale Variable, sollte aber Statisch sein nicht Temponär,
wie Merker oder Statische Datenbaustein-Variable. Hier im beispiel ist sie
nur Symbolisch dargestellt.
Der Punkt im namen zeigt das diese Variable ein Teil eines Struct ist, mein
Struct enthält alle Variablen die ich für den Sprungverteiler verwende.

Mal etwas allgemeines zum Sprungverteiler. Der Sprungverteiler SPL gestattet
das gezielte (berechnen) Springen zu einm Programmteil im Baustein ab-
hängig von eine Sprungnummer, die in unseren Beispiel in der Variablen
"STEP.Nr" steht.
SPL arbietet mit einer Liste aus SPA-Sprungfunktionen zusammen. Diese Liste
steht unmittlebar nach SPL und kann maximal 255 Einträge lang sein. Bei SPL
steht eine Sprungmarke die auf das Ende der Liste (auf die erset An-
weisung nach der Liste) zeigt.
Einen Sprungverteiler programmiert man nach folgenden Schema:

```
L     STEP.Nr
        SPL  ENDE
        SPA  M0
        SPA  M1
         ...
        SPA  Mx
ENDE: ...
```
Im Beispiel lädt die Variable STEP.Nr eine Nummer in den Akkumulator 1.
Anschließend steht der Sprungverteiler SPL mit der Sprungmarke ans 
Ende der Liste aus SPA-Anweisungen.
Die Nummer des auszuführenden Sprungs steht im rechten Byte des 
Akkumulator 1. Steht "0" im Akku 1 wird die erste Sprunganweisung ,
bei "1" die zweite usw. Ist die Nummer größer als die Länge der Liste
verzweigt SPL zum Ende der Liste (zur Anweisung, die nach dem letzten
Sprung steht).
SPL ist unabhängig vom Bedingungen und verändert die Statusbits nicht.
In der Liste dürfen nur SPA-Anweisungen lückenlos stehen. Die
Bezeichnungen der Sprungmarken können im Rahmen der der allgemeinen
Bestimmungen beliebig vergeben werden.


----------



## Markus (20 September 2009)

habe sowas schon häufiger gemacht...

also ich mache das in etwa so:

als erstes gibt es einen udt mit einem bit für jeden aktor der von der schrittkette manipuliert werden soll, dann noch sollweerrte für geschwindigkeiten, positionen,... im jeweile benötigten zahlenformat.

dann gibt es noch einen int für die weiterschaltbedingung, je nach art der möglichen weiterschaltbedinungen gibt es noch mehr variablen.

dieser udt wird als array in einem db so oft aufgerufen wie du maximal schritte haben willst.

in deiner visu hast du bouttons, dropdownfelder,... die indirekt abhängig von der schrittnummer auf das entsprechende arrayfeld zugreifen.

jetzt kannst du für jede schrittnummer sagen welcher aktor wie wohin fahren soll.

dann mus noch ne weiterschaltbedinung gewählt werden, auswahl zb über dropdownfeld das einen entsprechende zahl in den int schreibt.

weiterschaltbediungenen z.b.
1 = ber zeit (zeitwert in einen weitere variable
2 = anzahl zyklen (wenn du in einem schritt irgendwas toggeln lässt)
3 = strecke (wenn eine achse einen bestimmten weg gefahren ist
4 = sensor (wenn ein bestimmtes signal kommt)
...


wenn nun alle nötigen schritte parametriert sind, dann muss die maximale schrittnummer noch angepasst werden, wenn du also maximal 30 schritte ermöglichst, aber der bediener für seine aufgabe nur 13 braucht, dann muss die schrittnummer maximal (int) auf 13 geschreiben werden, damit die steuerung weiß wann sie die schrittnummer nach erfolgter weiterschaltbedinung nicht mehr erhöhen muss, sondern der ablauf beendet ist...
alternativ zur maximalen schrittnummer kannst du auch ein weiteres bit in den schritdatensatz machen, wenn das in einem schrit gesaetzt ist, dann ist das das ende der schrittkette.

wenn das aber einer vergisst, und ein schrittdatensatz aufgerufen wird der "müll" enthält ist das vermutlich nicht gut...

im anahng noch ein screen von einer visu.


----------



## mega_ohm (20 September 2009)

Ich übergebe an den FB die Job-Nummer... [Byte]

- ich will im FB mittels der Nummer in der Sprungliste
"rumspringen"....

Für Testzwecke habe ich mir einen FB mit 3 Sprungmarken "gebastelt"

```
[SIZE=1]JobN: L #Job_No // Job- Nummer laden[/SIZE]
[SIZE=1]SPL SEnd // SPrungListe definieren[/SIZE]
[SIZE=1]SPA SLM1 // Verzweigung zu Sprungliste_Marke_1[/SIZE]
[SIZE=1]SPA SLM2 // Verzweigung zu Sprungliste_Marke_2[/SIZE]
[SIZE=1]SPA SLM3 // Verzweigung zu Sprungliste_Marke_3[/SIZE]
[SIZE=1]SEnd: NOP 0[/SIZE]
[SIZE=1]SPA FEnd // springe zu FB- Ende[/SIZE]
 
[SIZE=1]
[SIZE=1]// Sprungliste => Verzweigung 1[/SIZE]
[SIZE=1]// FB-Init, Löschen des aufgerufenen DB10.DBW0[/SIZE]
[SIZE=1]SLM1: UN #InWork // FB ist fertig, Reset[/SIZE]
[SIZE=1]SPB SM11 // Marke Sprungliste M1.1[/SIZE]
[SIZE=1]L 0[/SIZE]
[SIZE=1]T DB 10.DBW 0 // Reset DB10.DBW 0[/SIZE]
[SIZE=1]SM11: U "Takt" // Taktmerker ( Global- Var )[/SIZE]
[SIZE=1]UN #Takt_FM // Flanke pos. von Taktmerker = Temp.-Var[/SIZE]
[SIZE=1]SPBN FEnd[/SIZE]
[SIZE=1]L DB 1.Ventil_T1[/SIZE]
[SIZE=1]L DB 10.DBW 0[/SIZE]
[SIZE=1]>I [/SIZE]
[SIZE=1]SPB SM12 // Marke Sprungliste M1.2[/SIZE]
[SIZE=1]L DB 10.DBW 0[/SIZE]
[SIZE=1]L 1[/SIZE]
[SIZE=1]+I [/SIZE]
[SIZE=1]T DB 10.DBW 0[/SIZE]
[SIZE=1]SPA FEnd[/SIZE]
[SIZE=1]SM12: = #Cnt_Temp // Ergebnis basteln[/SIZE]
[SIZE=1]= "FB10_Rdy" // FB10 ist fertig[/SIZE]
 
[SIZE=1]
[SIZE=1]// Sprungliste => Verzweigung 2 [/SIZE]
[SIZE=1]SLM2: NOP 0[/SIZE]
 
[SIZE=1]// Sprungliste => Verzweigung 3 [/SIZE]
[SIZE=1]SLM3: NOP 0[/SIZE]
 
 
[SIZE=1]FEnd: U #Cnt_Temp[/SIZE]
[SIZE=1]= #Event_OK_Return // FB- Ende[/SIZE]
 
 
[SIZE=1]// Flankenmerker setzen [/SIZE]
[SIZE=1]U "Takt"[/SIZE]
[SIZE=1]= #Takt_FM[/SIZE]
[/SIZE][/SIZE]
```
 
Ich habe mal den FB ( ist nur erstmal dafür da, zu verstehen, wie das Ganze funktioniert.... über den Sinn der Sprungmarke 1 möchte ich nicht diskutieren... das ist nicht mein Problem)

=> Ich übergebe als Job-Nr eine = 1, es wird genau die erste Sprungmarke 
( z.b. SPA M1 ) übersprungen.

=> Ich übergebe als Job-Nr eine = 2, es wird die 1. und 2. Sprungmarke 
(SPA M1, SPA M2 ) übersprungen.

Die Sprungmarken, die größer dem übergebenen Wert sind, werden abgearbeitet...
=> das ist doch "verkehrte Welt" ???

Mfg


----------



## rostiger Nagel (21 September 2009)

Lese bitte noch einmal meinen Beitrag #19, die erste sprungmarke beginnt bei 
"0" egal wie die Marke heist.


----------



## mega_ohm (24 September 2009)

Helmut_von_der_Reparatur schrieb:


> Lese bitte noch einmal meinen Beitrag #19, die erste sprungmarke beginnt bei
> "0" egal wie die Marke heist.


Die 1. Erfolge konnte ich nach dieser sehr guten :s12: Erklärung von allen, die auf meine Frage geantwortet haben, schon verbuchen.

Ich muß mich aber noch tiefer "hinein arbeiten". Mit dem Überspringen komme ich noch nicht so ganz klar... ( das ist eigentlich immer noch, wie schon beschrieben )
Bei dem ganzen "Probieren" kam ich aber zu der Erkenntnis, daß für meinen Anwendungsfall ein FB mit IDB's viel schneller zum Erfolg führt. ( Das habe ich schonmal gemacht und weiß... wie ich tun muß  )

Aber ich werde auf jeden Fall das Ganze auch mit SPL nochmal proggen...
alleine schon, um den Vergleich zwischen Aufwand, Nutzen und Lesbarkeit zu bekommen.
_______________________________________________________________

Mal so ganz nebenbei noch eine Frage zu IDB's ... gab es die auch schon bei s5 ?
Die Steuerung, die ich proggen will, ist für eine relativ größere Feinstaub-Absaugung gedacht. Für eine kleine Anlage [ 1 Lüfter.Mot. in Y-3eck- Anlauf + 6 Filterbänke+ 2 Schieber für Simu Zellradschleuse ] habe ich eine KM-easy genommen... funzt perfekt.
Diese Anlage ist aber bedeutend größer... und bei uns "im Keller" schlummert noch eine s5-100U CPU 95 mit diversen DI-/ DO und AI (!).
Die AI könnte ich z.B. für die Diff-Druckmessung nehmen.

Sollte es bei s5 keine IDB geben.... gibt es dann in s5 Alternativen ?
Wenn das zu umständlich ( ich bin nicht der geübteste s5- Programmierer )
werden sollte, würde ich eine s7-3xx nehmen. ( Oder kann das auch dieser viel diskutierte Ersatz für die s7-2xx [s7-1200 heißt der wohl ??? ]
=> Dann wäre aber Voraussetzung, daß ich mit meinen MicroWin- Kenntnissen das "1200-er- Teil" zum Laufen bringe...   ein "Studium auf die Schnelle" habe ich nicht vor !

Ganz wichtig z.Zt. in der Firma, in der ich angestellt bin, ist: "SPAREN beim Investieren !"
Es wird investiert, neue Maschinen werden aufgebaut, die älteren generalüberholt... aber es wird auf jeden €ent geachtet und man muß jeden €ent begründen... *da wäre mir die s5 "aus'm Keller" sehr lieb*... die ist schon lange nicht mehr in der Inventarliste existent.

MFG


----------



## rostiger Nagel (24 September 2009)

also ich mache das nur mit fb und Instanzen, ich wollte
es nur leicht halten.
Bei S5 und die 200er Reihe geht das nicht. Wenn ihr
sparen müsst spart nicht am Material, das rechnet sich
nicht. Am Schluss macht die mehr aufgewendete arbeits
Zeit alles wieder zu Nichte. 
Mit einer 300er kommst du schneller ans Ziel, somit sparst
du!


----------



## mega_ohm (24 September 2009)

Helmut_von_der_Reparatur schrieb:


> also ich mache das nur mit fb und Instanzen, ich wollte
> es nur leicht halten.


*ggg  mit der Sprungliste...  entweder klemmen da bei mir geistig ein paar Relais ... oder es ist erst dann "ganz einfach", wenn man's verstanden hat...  


> Bei S5 und die 200er Reihe geht das nicht. Wenn ihr
> sparen müsst spart nicht am Material, das rechnet sich
> nicht. Am Schluss macht die mehr aufgewendete arbeits
> Zeit alles wieder zu Nichte.
> ...


Die "Ersparnis für mich" ist...  ich kann in step7 die s7-3xx proggen... da habe ich schon einiges  gemacht.

Bei s5 und MicroWin ( für die s7-2xx ) müßte ich mich echt auf den Hosenboden setzen, lesen und lernen.

*Für mich ist gerade eine Entscheidung gefallen*...  es wird eine s7-3xx ( welche konkret... muß ich noch herausfinden... BUS und Angehängsel ist schonmal nicht )
Außer einer "kleinen" HMI.
Ich dachte so an ein OP3 oder in der Größe... nur ein paar Betriebseingaben machen können ( voraussichtlich ca. 35 Parameter- Einstellungen, davon 33 im Bereich WORD, 2 in BYTE )   und Fehler in Klartext- Anzeige....  ( und wenn wir so'n Teil schon mal da haben... noch ein paar Betriebszustands- Meldungen )

Ich danke Dir für Deine superschnelle Info.


Mfg


----------

