Ablaufsteuerung mit variabelen Schrittanzeigen und freier Zuordnung von Aktoren.

B

buffi4711

Level-2
Beiträge
301
Reaktionspunkte
3
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

wir sollen Software für eine Prüfgerät entwickeln. (TIA-Portal V13 auf S7-1200 + KTP 600 bzw neu KTP700)
Hier werden von 2 bis 8 Zylinder in unterschiedlicher Reihenfolge beim Spannen zugefahren und beim Entspannen zurück gefahren.
Das Vor und Rückfahren kann in unterschiedlicher Reihenfolge notwendig sein. Weiterhin können bis zu drei frei wählbare Zylinder einem Handlingsystem zu geordnet werden, welche dan in einer separten Schrittkette ablaufen.
Die Auswahl der Zylinder un deren Reihenfolge soll aus einem Rezept ausgewählt werden können.
Hintergrund ist, das eine universelle Steuerung mit Ventilinsel für unterschiedliche Prüftische verwendet werden soll.

Habt ihr eine Idee wie man das angehen kann?
Ich habe schon mal darüber nachgedacht, eine Kette fürs Schließen und eine fürs öffnen zu programmieren in der bis zu acht Schritte möglich sind und in einem weitern Baustein die Aktoren über Nummern an den jeweiligen Schritt angebunden werden.
Im Rezept würde ich dan die Positionen in den Schritketten mit einer Nummer versehen und im Aktorbaustein an den Schritt anbinden.
Wenn im Rezept für den Zylinder ein Null steht würde dieser garnicht angesteuert.

Was schon selbstevertändlich ist, ist das jeder Zylinder im handmodus auch einzen gefahren werden soll, aber ohnen Verriegelung zu einander, das soll der Einrichter dann selber überwachen.

Ebenfalls sollen alle Zylinder ein Laufzeitüberwachung mit Meldung erhalten.
 
Hallo,
ich würde so etwas wie folgt angehen :
Du baust dir eine Bildschirmmaske, die alle dir sinnvoll erscheinenden Aktionen als Tasten beinhaltet.
Jede der Tasten weißt z.B. du einen Code zu - vielleicht einen Bytewert.
Willst du nun ein neues Prüf-Programm erstellen dann speicherst du die Bytewerte der Tasten in der Reihenfolge deren Betätigung in einen Pufferspeicher.
Soll dieses auf diese Weise erstellte Programm nun ablaufen so lädst du dir den Codewert an der ersten Index-Position des Pufferspeichers und führst die Aktion aus, für die der Bytewert steht.
Anschließend erhöhst du den Pufferzeiger und führst die nächste Aktion aus. Usw. Irgendwann stößt du dann auf den "Programm Ende"-Code und weißt so, dass dein Zyklus fertig ist.
Dieses Verfahren läßt sich natürlich nun auch noch mit Zeiten und allen möglichen anderen "würzen".

Konntest du meiner Beschreibung soweit folgen bzw. etwas damit anfangen ?

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Larry,

wenn ich erhrlich bin nicht ganz.
Ich hatte daran gedacht, in einem Rezept jedem Zylinder eine Reihenfolgeplatz in der Schrittkette zuzuweiesen. Z.B. Zylinder A = Pos 1 in der Schritkette schließen aber 4 in der Schritkette öffnen. Wenn der Zylinder A nicht mitspielen darf bekommt er eine 0 Einetragen.
Wenn Zylinder A im Handlin als Zylinedr Horizontal laufen soll bekmmt er den Eintrag Handling Horizontal. In einem andern Rezepteintga würde ich dann angeben mit oder ohne Handyling.
Usw.
 
Beide Verfahren funktionieren.

Persönlich mache ich es auch so wie Larry.
Zuerst definiere ich mir eine UDT:

Code: 
Aktion : int;
XPos : dint;
YPos : dint;
ZPos : dint;
Subcode1 : word;
Subcode2 : word;
Delay : time;

Daraus gibt es dann einen DB mit einem Array

Code: 
Akt : Aktion;
Ablaufdaten : Array [1..99] of Aktion;

In der Schrittkette kopiere ich mir dann mit Blockmove aus dem Array die entsprechenden Daten nach Akt und führe dann die entsprechenden Bewegungen aus.
Das ganze ist angelehnt an NC-Verfahrsätze und funktioniert Problemlos.
Und wie Larry schreibt kannst du das Verfahren noch mit Zeiten oder sogar Sprüngen erweitern.
Bei komplexen Anlagen arbeite ich sogar noch mit Vor- und / oder Nachlaufzeigern.

Gruß
Dieter
 
Hallo,
na ... dann führe ich das noch ein wenig mehr aus ...

So, wie ich dich verstanden habe, willst du es dem Bediener ermöglichen, sich seinen Ablauf selbst zu erstellen. Dabei kann die Reihenfolge der Aktionen komplett variieren.
Das ist dann eigentlich die Aufgabe eines eigenen Programms. Im Grunde machst du also etwas wie einen eigenen Programm-Interpreter erstellen. Hierfür legst du die Befehle fest und der Interpreter weiss dann, was damit zu tun ist, wenn er sie im "Programm-Code", also deinem DB-Array_of_Byte, findet.
Das könnte dann z.B. so aussehen :
Byte-Wert Aktion
$00 : Programm-Ende

$01 : Zylinder 1 ausfahren
$02 : Zylinder 2 ausfahren
...
$08 : Zylinder 8 ausfahren

$11 : Zylinder 1 einfahren
$12 : Zylinder 2 einfahren
...
$18 : Zylinder 8 einfahren

$21 : warte 0,25 s
$22 : warte 0,5 s
$23 : warte 0,75 s
$24 : warte 1 s
Zum Vergrößern anklicken....
Deine Tasten in der Visu und ein entsprechendes Begleit-Programm dazu (das man natürlich erstellen müßte) erzeugen daraus dann z.B. das in einem DB :
Code: 
$01  :  Zylinder 1 ausfahren
$02  :  Zylinder 2 ausfahren
$22  :  warte 0,5 s
$12  :  Zylinder 2 einfahren
$07  :  Zylinder 7 ausfahren
$08  :  Zylinder 8 ausfahren
$22  :  warte 0,5 s
$18  :  Zylinder 8 einfahren
$17  :  Zylinder 7 einfahren
$18  :  Zylinder 1 einfahren
$00  :  Programm-Ende
... was in aufeinanderfolgenden Bytes deines Byte-Arrays abgelegt ist.
Das könntest du natürlich, wenn deine Visu das hergibt, auch als "Rezept" oder "Fahr-Programm" abspeichern und wieder-herholbar verwalten.

Ich denke, aus diesem Beispiel kannst du besser ersehen, was ich gemeint habe.
Das so von Null aus zu entwickeln ist natürlich nicht ganz trivial - aber ich denke, der Aufwand wird sich am Ende für dich lohnen. Es steckt dann ja auch noch viiiiiiiel mehr darin, was man noch so machen kann ...

Schreib mal, wie du darüber denkst ...

Gruß
Larry
 
Zurück
Oben