"Konfigurierbare Schrittkette" - wie macht man so etwas?

on69

Level-1
Beiträge
15
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
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!
 
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
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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.

Code:
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
 
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.
 
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!!!
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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
 
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.
 
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.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
@Ralle:
Warum so kompliziert ?
Code:
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
 
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.
 
Zuletzt bearbeitet:
@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.
 
... 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
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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.

Code:
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
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:
Code:
- Ü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
 
Zuletzt bearbeitet:
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

Code:
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
 
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

Code:
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
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 :ROFLMAO: )


Mfg
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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
 
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:
Code:
        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.
 
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.
 

Anhänge

  • 3.jpg
    3.jpg
    75,7 KB · Aufrufe: 111
Zurück
Oben