Triggern und warten in Schritten

jokey

Level-1
Beiträge
80
Reaktionspunkte
5
Zuviel Werbung?
-> Hier kostenlos registrieren
Moin moin,

hab hier ein fremdgeschriebenes Programm vor mir von einer Maschine, die nen Haufen "Handfunktionen" hat. Das ganze ist so realisiert, dass es innerhalb eines Funktionsbausteins programmiert ist, wann die Freigabe da ist, wann eine Anforderung gestellt werden darf und die Anforderung wird zurückgesetzt, wenn der Endzustand erreicht ist oder eben das Freigabebit wegfällt.

So nach und nach hat sich bei den Bedienern ein gewisser automatischer Ablauf herauskristallisiert und nun soll das als Schrittkette umgesetzt werden.
Dafür müsste ich also die Freigabe überwachen, das Anforderungsbit einmal setzen und dann auf das Rücksetzen durch den Baustein entsprechend warten.
Wie realisiere ich sowas am intelligentesten ohne viele Flankenmerker benutzen zu müssen?
Nachbilden lassen sich die Rücksetzbedingungen zwar, sind manchmal jedoch etwas komplex, so dass ich gern wirklich nur die "Taste" drücken würde und das erlöschen selbiger abwarten würde.
 
Hallo,
versuch doch mal für dein Vorhaben einen Ablaufplan oder besser noch eine Schrittkette zu entwerfen. Dann wird schon mal vieles klarer und man kann auch Anderen (z.B. dem Forum) viel leichter die Problemstellung übermitteln ...

Gruß
LL
 
Naja die klassische Schrittkette ist für mich nichts neues. (Dafür programmiere ich schon 3 jahre S7)

Mir geht es darum:

Code:
NW1
            Schritt1
             -----
Startimpuls--|S  |     Flankenmerker
             |   |   -----------------
Schritt2   --|R Q|---|      P        |---- Anforderung1
             -----   -----------------

NW2
             Schritt2
              -----
Anforderung1-o|S  |     Flankenmerker
              |   |   -----------------
Schritt3    --|R Q|---|      P        |---- Anforderung2
              -----   -----------------

NW3
             Schritt3
              -----
Anforderung2-o|S  |     Flankenmerker
              |   |   -----------------
Schritt4    --|R Q|---|      P        |---- Anforderung3
              -----   -----------------

[...]
Die Anforderungen werden in einem anderen Baustein jeweils zurückgesetzt, wenn die gewünschte Endstellung / Position erreicht ist.

Gibt es für sowas eine elegantere Lösung oder muss ich wirklich so viele Flankenmerker wie Schritte benutzen, damit es so funktioniert, wie ich es erwarte?
(Darf auch gerne SCL sein, wenns dort einfacher geht)
 
Darum sagte ich ja, es gib einige Ansätze und gerade bei S7 wäre dort die Sprungleiste (SPL) eine ganz gute Variante. Das Schrittsystem, das du da beschreibst finde ich etwas, na ja, sagen wir eigenartig ;), aber sowas ist nunmal eine Frage der persönlichen Vorlieben und Kenntnisse beim Programmieren. Vor allem kommt es mir vor, als ob da jemand seine S5-Programme in die Step7-Zeit gerettet hat, so war das oft in den Step7-Anfängen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Naja wir ham bisher keinen Bedarf für übermäßig komplexe Programme gehabt ;) Und wenn es doch mal anders war, gab es dafür gleich fertige Kompaktsysteme und man musste nicht selbst entwickeln.
An dezentraler Peripherie und Visualisierung haben wir einiges, jedoch so manches, was ich hier im Forum so an Programmstrukturen gelesen hab, war gewaltig über dem, was ich bisher als nötig erachtet hab.

Deswegen wenn du Tips/Hinweise hast, immer her damit :p
 
Darum sagte ich ja, es gib einige Ansätze und gerade bei S7 wäre dort die Sprungleiste (SPL) eine ganz gute Variante.

Hmm hab das grad mal ein wenig gegoogelt(sp?) und das ist wirklich deutlich handlicher als die Schrittkette mit Merkern. Werd ich Montag inner Firma mal angehen. :cool:

Danke
 
Sollte gehen

Wenn ich es richtig sehe, sind in Graph doch die hier benötigten Flankentrigger bereits enthalten:
In der Aktion vor den auszuführenden Befehl S1 (ausgeführt bei Erreichen des Schrittes) bzw. S0 (ausgeführt bei Verlassen des Schrittes) setzen, z.B. S1 S | M1.0. Ich nutze sowas u.a. beim Zählen von Ereignissen/Teilen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wenn ich es richtig sehe, sind in Graph doch die hier benötigten Flankentrigger bereits enthalten:
In der Aktion vor den auszuführenden Befehl S1 (ausgeführt bei Erreichen des Schrittes) bzw. S0 (ausgeführt bei Verlassen des Schrittes) setzen, z.B. S1 S | M1.0. Ich nutze sowas u.a. beim Zählen von Ereignissen/Teilen.

Wenn man Graph einsetzen will. Das scheint mir hier nicht der Fall zu sein.
 
Ich bin ja stinkefaul und lese möglichst ungern AWL. Vor allem wenn's nur um eine schnöde Testroutine geht. Hier also ein Bleistift für eine Schrittkette in SCL.

Code:
FUNCTION_BLOCK FB199
TITLE = 'SCHABL'
VERSION : '1.0'
AUTHOR  : kai
NAME    : Schabl
FAMILY  : worm
 
VAR
  Schritt : INT;
  Ebene : INT;
  Start : BOOL;
  Fehler : BOOL;
  Rauf : BOOL;
END_VAR
 
BEGIN
    IF NOT Start THEN
        RETURN;
    END_IF;
 
 
    IF Schritt = 1 THEN
          Rauf := TRUE;
          Ebene := 2;
          "DB_Pos_Antr_7M1".Ebene := Ebene;
          "DB_Pos_Antr_7M1".Uebernahme := TRUE;
          "DB_Pos_Antr_7M1".UnterOffset := TRUE;
          "DB_Pos_Antr_7M1".UeberOffset := FALSE;
          Schritt := 2;
    END_IF;
 
    IF Schritt = 2 THEN
        IF  "DB_Pos_Antr_7M1".Uebernahme = FALSE THEN;
            "DB_Pos_Antr_7M1".AnfPosHand := TRUE;
            Schritt := 3;
        END_IF;
    END_IF;
 
    IF Schritt = 3 THEN
        IF "DB_Pos_Antr_7M1".PosUnter AND NOT "DB_Pos_Antr_7M1".AnfPosHand THEN
            IF NOT "E_Turm1-16K8" THEN
                Fehler := TRUE;
            ELSIF Fehler = TRUE THEN
                ;
            ELSE
                "DB_Pos_Antr_7M1".Ebene := Ebene;
                "DB_Pos_Antr_7M1".Uebernahme := TRUE;
                "DB_Pos_Antr_7M1".UeberOffset := TRUE;
                "DB_Pos_Antr_7M1".UnterOffset := FALSE;
                Schritt := 4;
             END_IF;
        END_IF;
    END_IF;
 
    IF Schritt = 4 THEN
        IF  "DB_Pos_Antr_7M1".Uebernahme = FALSE THEN;
            "DB_Pos_Antr_7M1".AnfPosHand := TRUE;
            Schritt := 5;
        END_IF;
    END_IF;
    IF Schritt = 5 THEN
        IF "DB_Pos_Antr_7M1".PosUeber AND NOT "DB_Pos_Antr_7M1".AnfPosHand THEN
            IF NOT "E_Turm1-16K8" THEN
                Fehler := TRUE;
            ELSIF Fehler = TRUE THEN
                ;
            ELSE
                IF Ebene = 40 THEN 
                    Rauf := FALSE;
                ELSIF Ebene = 2 THEN
                    Rauf := TRUE;
                END_IF;
                IF Ebene < 40 AND Rauf THEN
                    Ebene := Ebene +1;
                ELSIF Ebene > 2 AND NOT Rauf THEN
                    Ebene := Ebene - 1;
                END_IF;
                "DB_Pos_Antr_7M1".Ebene := Ebene;
                "DB_Pos_Antr_7M1".Uebernahme := TRUE;
                "DB_Pos_Antr_7M1".UnterOffset := TRUE;
                "DB_Pos_Antr_7M1".UeberOffset := FALSE;
                Schritt := 2;
             END_IF;
        END_IF;
    END_IF;
 
END_FUNCTION_BLOCK
 
Ich vergaß den Flankentrigger:
So würde ich das in SCL lösen:

Code:
IF Schritt = x THEN
   IF NOT Steptrigx THEN
        Dowhateveryouwanthere; //Dummyzeile, klar oder?
        StepTrig := TRUE;
   END_IF;
 
   Alles was in dem Schritt noch so passiert;
   IF Watwetick THEN
       Schritt := x + 1;
       StepTrig := FALSE;
   END_IF;
END_IF;
 
Zurück
Oben