Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 19

Thema: Matlab Code auf S7 implementieren

  1. #1
    Registriert seit
    08.11.2011
    Beiträge
    11
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo Leute

    Ich bin gerade dabei eine Art Detektionsalgorithmus für Instabilitäten zu entwickeln. Dieser wurde zunächst in MATLAB geschrieben und getestet nun soll er noch auf eine SPS implementieren werden. Hatte zwar vor einigen Jahren ein wenig in FUP, KOP und AWL gelernt aber das hab ich seit dem nie wieder gebraucht und somit auch das meiste vergessen. Da ich aber case Anweisungen benötige muss ich hier auf scl zurückgreifen was für mich totales Neuland ist.

    Dabei geht es um Folgendes, eine Prozessgröße soll gemessen werden und hinsichtlich ihrer Stabilität überwacht werden, dh. die Einhaltung einer oberen und unteren Grenze wird überwacht. Werden obere und untere Grenze innerhalb eines bestimmten Zeitintervalls verletzt, ist das ein Zeichen für die Instabilität der Prozessgröße. Die Grenzwerte sollen darüber hinaus der Prozessgröße folgen, dh. wird zB. die untere Grenze unterschritten, wird die neue untere Grenze (also für den nächsten Messwert) auf den aktuellen Wert gesetzt und die obere Grenze entsprechend dazu angepasst.

    Wenn ein Grenzwert mehrmals hintereinander verletzt wird soll die Zeit immer wieder neu gestartet werden. Je nach Zustand werden dann verschiedene Anweisungen durchgeführt und ein neuer Zustand gesetzt.

    Dabei stellen sich mir ein paar Fragen:
    Was für Bausteine brauche ich dafür, und was gehört wo rein?

    Wie muss ich die Zeit/Intervallüberprüfung implementieren?
    Hab mich da schon mal umgeschaut, was es denn für Zeitfunktionen gibt und ich denke ein verlängerter Impuls sollte der richtige für meine Anwendung sein. Wie kann ich dann in meiner case Anweisung prüfen ob die Zeit bereits abgelaufen ist oder nicht?

    Hier mal der Code-Auszug aus Matlab:

    Code:
    % Variablen & Signale
    % oG_alarm = Merker/Alarm das obere Grenze verletzt
    % uG_alarm = Merker/Alarm das untere Grenze verletzt
    % Bd = halbe Bandbreite = halbe Differenz zwischen oberer und unterer Grenze (fester Wert)
    % oberer_Grenzwert = obere Grenze (Gleitkomma)
    % unterer_Grenzwert = untere Grenze (Gleitkomma)
    % Messwert = aktueller Messwert der Prozessgröße (Gleitkomma)
    % Zustand = Zustand (0...4) normaler Betrieb, obere Grenze wurde verletzt, untere Grenze wurde verletzt, Instabilität 
    % time = Zeit
    % time_end = Intervallgrenze der Zeit = max. Zeit zwischen 2 Verletzungen der Grenzen.
    
    oG_alarm = 0;
    uG_alarm = 0;
    
    % Grenzwertnachfuehrung
    If Messwert < unterer_Grenzwert
        unterer_Grenzwert = Messwert;
        oberer_Grenzwert = unterer_Grenzwert + 2*Bd;
        uG_alarm = 1;
        oG_alarm = 0;
    
    elseif Messwert > oberer_Grenzwert
        oberer_Grenzwert = Messwert;
        unterer_Grenzwert = oberer_Grenzwert - 2*Bd;
        uG_alarm = 0;
        oG_alarm = 1;
    end
    
    if (time > time_end)
        time= 0;
        Zustand= 0;
    elseif Zustand==1 || Zustand==2 || Zustand==3 || % Zustand ist 1 oder 2 oder 3
        time=time +1
    end
    
    switch Zustand
    case 0 
        if oG_alarm == 1
            Zustand =1;
        elseif uG_alarm ==1
            Zustand == 2;
        elseif Zustand == 1
            Zustand = 1;
        elseif Zustand == 2
            Zustand = 2;
        elseif Zustand == 3
            Zustand = 3;
        end
    
    case 1 
        if oG_alarm == 1     % wenn erneut Alarm (oben) ausgelöst wird bleibe in Zustand 1 und starte Intervall neu
            Zustand = 1;
            time = 0;
        elseif uG_alarm ==1    % wenn Alarm (unten) ausgelöst wird, wechsle in Zustand 3 
            time = 0;           
            Zustand == 3;
        elseif time > time_end   % wenn Zeit abgelaufen ist gehe zurück in (normalen) Zustand 0
            time = 0;
            Zustand = 0;
        elseif oG_alarm == 0 && time< time_end     % solange kein neuer Alarm (oben) ausgelöst wurde und die Zeit noch nicht abgelaufen ist bleibe in % Zustand 1
            Zustand = 1;         
        else 
            Zustand = 0;
        end
    
    case 2 
        if uG_alarm == 1
            Zustand = 2;
            time = 0;
        elseif oG_alarm ==1
            time = 0;
            Zustand = 3;
        elseif time > time_end
            time = 0;
            Zustand = 0; 
        elseif uG_alarm == 0 && time < time_end
            Zustand = 2;
        else 
            Zustand = 0;
        end
    
    case 3
        if time < time_end;
            Zustand = 3;
        else 
            time = 0;
            Zustand = 0;
        end
    end
    Zitieren Zitieren Matlab Code auf S7 implementieren  

  2. #2
    T-Rex22 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.11.2011
    Beiträge
    11
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hier mal noch der Zustandsgraph.
    Zustand.PNG
    Ich hoffe ihr könnt mir die richtigen Denkanstöße geben.
    Vielen Dank schon mal im Voraus.

  3. #3
    Registriert seit
    17.05.2010
    Ort
    Paderborn
    Beiträge
    824
    Danke
    84
    Erhielt 125 Danke für 94 Beiträge

    Standard

    ... scl zurückgreifen was für mich totales Neuland ist
    Nimm ruhig das Optionspaket S7-SCL, denn Deinen jetzigen Code musst Du nur geringfügig umschreiben, da SCL bereits hochsprachenorientiert ist!
    Wenn Du SCL hast, dann schau auch mal in die Hilfe, dort gibt es einen Punkt "Erste Schritte".

    Was für Kenntnisse bezüglich der Programmierung hast Du überhaupt?

    Welchen Typ von SPS setzt Du ein?

    Wie muss ich die Zeit/Intervallüberprüfung implementieren? Hab mich da schon mal umgeschaut, was es denn für Zeitfunktionen gibt und ich denke ein verlängerter Impuls sollte der richtige für meine Anwendung sein. Wie kann ich dann in meiner case Anweisung prüfen ob die Zeit bereits abgelaufen ist oder nicht?
    vermutlich würde ich das mit einer Einschaltverzögerung lösen, kommt es innerhalb der Überwachungszeit zu keinem Fehler so wird der Timer am Ende "WAHR"
    Geändert von MCerv (09.11.2011 um 14:17 Uhr)
    Grüße
    Michael

    1001101110110100... Das ist meine Welt

  4. #4
    Registriert seit
    21.05.2008
    Beiträge
    98
    Danke
    8
    Erhielt 9 Danke für 8 Beiträge

    Standard

    Was steckt dahinter?

    Soll einfach nur ein zeitkontinuierliches Signal auf Grenzwerte geprüft werden oder soll beispielsweise die Instabilität eines Regelkreises detektiert werden?

  5. #5
    T-Rex22 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.11.2011
    Beiträge
    11
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo erst mal,
    konnte leider nicht früher antworten, da ich krank war.

    Zitat Zitat von LT Smash Beitrag anzeigen
    Soll einfach nur ein zeitkontinuierliches Signal auf Grenzwerte geprüft werden oder soll beispielsweise die Instabilität eines Regelkreises detektiert werden?
    Prinzipiell wird ein zeitkontinuierliches Signal überwacht. Wird z.B. der untere Grenzwert verletzt so ist das an sich noch nicht weiter schlimm. Wird aber zB. innerhalb von 20s auch der obere Grenzwert verletzt, verhält sich die Größe instabil. Dieses Verhalten soll erkannt werden, und anschließend sollen weitere Maßnahmen ergriffen werden.

    Zitat Zitat von MCerv Beitrag anzeigen
    Was für Kenntnisse bezüglich der Programmierung hast Du überhaupt?
    Was die SPS-Programmierung angeht, hab ich im Studium ein paar praktische Versuche gehabt, in denen meist nur ein paar Eingänge miteinander zu verknüpfen waren und dann entsprechend die Ausgangssignale gesetzt wurden.


    Zitat Zitat von MCerv Beitrag anzeigen
    Welchen Typ von SPS setzt Du ein?
    Siemens S7 CPU 315-2 DP

    Habe mein MATLAB Code jetzt als FB programmiert:
    Code:
    FUNCTION_BLOCK FB1    
        (* Konstanten *)
        CONST
        Bd := 100;  
        END_CONST
    
        (* Eingangsparameter *)
        VAR_INPUT
            messwert: REAL; 
        END_VAR
        
        (* Ausgangsparameter *)
        VAR_OUTPUT
        
        END_VAR
    
        VAR_IN_OUT
            Zustand: INT:=0;        (* Zustand 
                                           0: Normal, 
                                           1: obere Grenze ueberschritten 
                                           2: untere Grenze unterrschritten
                                           3: Instabiles Verhalten entdeckt *)    
        END_VAR
    
        VAR
            oG_alarm: BOOL;              // Merker obere Grenze verletzt
            uG_alarm: BOOL;              // Merker untere Grenze verletzt
            unterer_Grenzwert: REAL;     // untere Grenze
            oberer_Grenzwert: REAL;      // obere Grenze
            zeit: S5TIME;        
        END_VAR
        
        BEGIN
            zeit:=S_PEXT (T_NO:=1, S:= M0.0, TV:= t#20s, R:= M0.1, Q:= M0.2); 
            
            // Merker zuruecksetzen
            uG_alarm := False ;
            oG_alarm := False;
            
            // Grenzwertnachfuehrung
            IF Messwert < unterer_Grenzwert THEN          
                unterer_Grenzwert := Messwert;                 // Setze neue untere Grenze auf aktuellen Messwert
                oberer_Grenzwert := unterer_Grenzwert + 2*Bd;  // Setze neue obere Grenze ausgehend von der neuen unteren Grenze
                uG_alarm := True;                    
                oG_alarm := False;                  
            ELSIF Messwert > oberer_Grenzwert THEN 
                oberer_Grenzwert := Messwert;                   // Setze neue obere Grenze auf aktuellen Messwert
                unterer_Grenzwert := oberer_Grenzwert - 2*Bd;  // Setze neue untere Grenze ausgehend von der neuen oberen Grenze
                uG_alarm := False;                             
                oG_alarm :=True;                    
            END_IF;
                
    
            //Zustandsautomat
            CASE Zustand OF
                // Normaler Zustand
                0:  IF oG_alarm = True THEN      // Wenn obere Grenze verletzt wird
                        Zustand := 1;            // Wechsle in Zustand 1
                         
                    ELSIF uG_alarm = True THEN   // Wenn untere Grenze verletzt wird dann
                        Zustand := 2;            // Wechsle in Zustand 2
                        
                    ELSIF Zustand = 1 THEN
                        Zustand := 1;                    
                    ELSIF Zustand = 2 THEN
                        Zustand := 2;
                    ELSIF Zustand = 3 THEN
                        Zustand := 3;               
                    END_IF;
                ;
                // obere Grenze wurde verletzt
                1 : IF oG_alarm = True THEN     // Wenn obere Grenze erneut verletzt wird dann
                        Zustand := 1;           // bleibe in Zustand 1 und
                        M0.0 := False;              
                        M0.0 := True;           // starte Zeit erneut.
                        
                    ELSIF uG_alarm = True THEN  // wenn untere Grenze verletzt wird dann
                        M0.0 :=False;           // starte Zeit und
                        M0.0 :=True;
                        Zustand := 3;           // wechsle in Zustand 3.
                        
                    ELSIF M0.2 = True THEN      // Wenn Zeitintervall zur Detektion abgelaufen ist dann
                        M0.1 := True;           // setze Zeit zurück und
                        M0.1 := False;
                        Zustand := 0;           // wechsle in Zustand 0.
                        
                    ELSIF oG_alarm = False AND M0.2 = 0 THEN // Wenn obere Grenze nicht erneut verletzt wird und das Intervall nicht abgelaufen ist dann
                        Zustand := 1;                        // bleibe in Zustand 1.
                    ELSE
                        Zustand := 0;           // Sonst gehe zurück zu Zustand 0.                    
                    END_IF;
                ;
                // untere Grenze wurde verletzt
                2 : IF uG_alarm = True THEN      // Wenn untere Grenze erneut verletzt wird dann
                        Zustand := 2;            // bleibe in Zustand 2 und
                        M0.0 := False;              
                        M0.0 := True;            // starte Zeit erneut.
                        
                    ELSIF oG_alarm = True THEN   // Wenn obere Grenze verletzt wird dann
                        M0.0 :=False;            // starte Zeit und
                        M0.0 :=True;
                        Zustand := 3;            // wechsle in Zustand 3.
                        
                    ELSIF M0.2 = True THEN       // Wenn Zeitintervall zur Detektion abgelaufen ist dann
                        M0.1 := True;            // setze Zeit zurück und
                        M0.1 := False;
                        Zustand := 0;            // wechsle in Zustand 0.
                        
                    ELSIF uG_alarm = False AND M0.2 = False THEN // Wenn untere Grenze nicht erneut verletzt wird und das Intervall nicht abgelaufen ist dann
                        Zustand := 2;                            // bleibe in Zustand 2. 
                    ELSE
                        Zustand := 0;            // Sonst gehe zurück zu Zustand 0. 
                    END_IF;
                ;           
                // Instabilität erkannt            
                3 : IF M0.2 = False  THEN
                        Zustand := 3;
                    ELSE
                        M0.1 := True;           // Setze Zeit zurück und
                        M0.1 := False;
                        Zustand := 0;           // wechsle in Zustand 0       
                    END_IF;
                ;
             END_CASE;
    END_FUNCTION_BLOCK
    Hab jetzt noch ein paar Probleme bei denen ich nicht ganz weiter komme:

    Wie rufe ich den FB1 im OB auf, das ich dann quasi den Zustand ausgegeben bekomme?

    Bei meiner Symboltabelle bin ich mir auch nicht ganz sicher ob das alles so hinhaut oder nicht.
    Muss ich z.B. die Merker für Starten und Rücksetzen der Zeit dort noch eintragen oder ist das alles mit dem Timer T 1 schon abgehandelt?
    Wie sieht das mit den ganzen Merkern wegen der unterschiedlichen Speicherbedarfs (Für BOOL, BYTE und DWORD) aus, macht das S7 automatisch das sich am Ende nichts überlappt oder muss ich da selber entsprechend Platz lassen?

    Symboltabelle:
    Symbol Adresse Datentyp
    Alarm_S SFC 18 SFC 18
    Alarm_SQ SFC 17 SFC 17
    Bd MD 4 DWORD
    Cycle Execution OB 1 OB 1
    messwert ED 0 DWORD
    oberer_Grenzwert MD 3 DWORD
    oG_alarm M0.0 BOOL
    TIME_TCK SFC 64 SFC 64
    uG_alarm M0.1 BOOL
    unterer_Grenzwert MD 2 DWORD
    WR_USMSG SFC 52 SFC 52
    zeit T 1 TIMER
    Zustand MB 1 BYTE
    Geändert von T-Rex22 (14.11.2011 um 13:42 Uhr)

  6. #6
    Registriert seit
    17.05.2010
    Ort
    Paderborn
    Beiträge
    824
    Danke
    84
    Erhielt 125 Danke für 94 Beiträge

    Standard

    Code:
    FUNCTION_BLOCK FB1    
        (* Konstanten *)
        CONST
        Bd := 100;  
        END_CONST
    
        (* Eingangsparameter *)
        VAR_INPUT
            messwert: REAL; 
        END_VAR
        
        (* Ausgangsparameter *)
        VAR_OUTPUT
        
        END_VAR
    
        VAR_IN_OUT
            Zustand: INT:=0;        (* Zustand 
                                           0: Normal, 
                                           1: obere Grenze ueberschritten 
                                           2: untere Grenze unterrschritten
                                           3: Instabiles Verhalten entdeckt *)    
        END_VAR
    
        VAR
            oG_alarm: BOOL;              // Merker obere Grenze verletzt
            uG_alarm: BOOL;              // Merker untere Grenze verletzt
            unterer_Grenzwert: REAL;     // untere Grenze
            oberer_Grenzwert: REAL;      // obere Grenze
            zeit: S5TIME;        
        END_VAR
        
        BEGIN
            zeit:=S_PEXT (T_NO:=1, S:= M0.0, TV:= t#20s, R:= M0.1, Q:= M0.2); // wenn Du die nur intern benötigst, dann kannst Du auch STAT-BOOL-Variablen deklarieren
            
            // Merker zuruecksetzen
            uG_alarm := False ;
            oG_alarm := False;
            
            // Grenzwertnachfuehrung
            IF Messwert < unterer_Grenzwert THEN          
                unterer_Grenzwert := Messwert;                 // Setze neue untere Grenze auf aktuellen Messwert
                oberer_Grenzwert := unterer_Grenzwert + 2*Bd;  // Setze neue obere Grenze ausgehend von der neuen unteren Grenze
                uG_alarm := True;                    
                oG_alarm := False;                  
            ELSIF Messwert > oberer_Grenzwert THEN 
                oberer_Grenzwert := Messwert;                   // Setze neue obere Grenze auf aktuellen Messwert
                unterer_Grenzwert := oberer_Grenzwert - 2*Bd;  // Setze neue untere Grenze ausgehend von der neuen oberen Grenze
                uG_alarm := False;                             
                oG_alarm :=True;                    
            END_IF;
                
    
            //Zustandsautomat
            CASE Zustand OF
                // Normaler Zustand
                0:  IF oG_alarm = True THEN      // Wenn obere Grenze verletzt wird
                        Zustand := 1;            // Wechsle in Zustand 1
                         
                    ELSIF uG_alarm = True THEN   // Wenn untere Grenze verletzt wird dann
                        Zustand := 2;            // Wechsle in Zustand 2
                        
                    ELSIF Zustand = 1 THEN  // wozu? CASE Zustand OF 1, 2, 3?
                        Zustand := 1;            // Du änderst doch nur den Zustand von 0 auf 1 oder 2        
                    ELSIF Zustand = 2 THEN  // Zustand 1, 2 oder 3 haben an dieser Stelle keinen Einfluss
                        Zustand := 2;
                    ELSIF Zustand = 3 THEN
                        Zustand := 3;               
                    END_IF;
                ;
                // obere Grenze wurde verletzt
                1 : IF oG_alarm = True THEN     // Wenn obere Grenze erneut verletzt wird dann // wirst Du nie auf "1" abfragen können, da die CASE-Anweisung
                                                                                                                            // mit Zustand 1 erst beim 2. Zyklus abgefragt wird, jedoch der
                                                                                                                            // Merker zuvor (oben) zurückgesetzt wird
                        Zustand := 1;           // bleibe in Zustand 1 und
                        M0.0 := False;          // den Merker setzt Du doch nachfolgend, wozu zurücksetzen, das bekommt kein weiterer Code mit!    
                        M0.0 := True;           // starte Zeit erneut.
                        
                    ELSIF uG_alarm = True THEN  // wenn untere Grenze verletzt wird dann
                        M0.0 :=False;           // starte Zeit und siehe oben
                        M0.0 :=True;
                        Zustand := 3;           // wechsle in Zustand 3.
                        
                    ELSIF M0.2 = True THEN      // Wenn Zeitintervall zur Detektion abgelaufen ist dann
                        M0.1 := True;           // setze Zeit zurück und siehe oben
                        M0.1 := False;
                        Zustand := 0;           // wechsle in Zustand 0.
                        
                    ELSIF oG_alarm = False AND M0.2 = 0 THEN // Wenn obere Grenze nicht erneut verletzt wird und das Intervall nicht abgelaufen ist dann
                        Zustand := 1;                        // bleibe in Zustand 1.
                    ELSE
                        Zustand := 0;           // Sonst gehe zurück zu Zustand 0.                    
                    END_IF;
                ;
                // untere Grenze wurde verletzt
                2 : IF uG_alarm = True THEN      // Wenn untere Grenze erneut verletzt wird dann
                        Zustand := 2;            // bleibe in Zustand 2 und
                        M0.0 := False;           // siehe oben   
                        M0.0 := True;            // starte Zeit erneut.
                        
                    ELSIF oG_alarm = True THEN   // Wenn obere Grenze verletzt wird dann
                        M0.0 :=False;            // starte Zeit und siehe oben
                        M0.0 :=True;
                        Zustand := 3;            // wechsle in Zustand 3.
                        
                    ELSIF M0.2 = True THEN       // Wenn Zeitintervall zur Detektion abgelaufen ist dann
                        M0.1 := True;            // setze Zeit zurück und siehe oben
                        M0.1 := False;
                        Zustand := 0;            // wechsle in Zustand 0.
                        
                    ELSIF uG_alarm = False AND M0.2 = False THEN // Wenn untere Grenze nicht erneut verletzt wird und das Intervall nicht abgelaufen ist dann
                        Zustand := 2;                            // bleibe in Zustand 2. 
                    ELSE
                        Zustand := 0;            // Sonst gehe zurück zu Zustand 0. 
                    END_IF;
                ;           
                // Instabilität erkannt            
                3 : IF M0.2 = False  THEN
                        Zustand := 3;
                    ELSE
                        M0.1 := True;           // Setze Zeit zurück und siehe oben
                        M0.1 := False;
                        Zustand := 0;           // wechsle in Zustand 0       
                    END_IF;
                ;
             END_CASE;
    END_FUNCTION_BLOCK
    Wie rufe ich den FB1 im OB auf, das ich dann quasi den Zustand ausgegeben bekomme?

    Die Quelle übersetzen, es wird der FB1 im Bausteinordner generiert und dann im OB1 einfügen.
    Grüße
    Michael

    1001101110110100... Das ist meine Welt

  7. #7
    T-Rex22 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.11.2011
    Beiträge
    11
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo Michael,

    Zitat Zitat von MCerv Beitrag anzeigen
    Code:
                    ELSIF Zustand = 1 THEN  // wozu? CASE Zustand OF 1, 2, 3?
                        Zustand := 1;            // Du änderst doch nur den Zustand von 0 auf 1 oder 2        
                    ELSIF Zustand = 2 THEN  // Zustand 1, 2 oder 3 haben an dieser Stelle keinen Einfluss
                        Zustand := 2;
                    ELSIF Zustand = 3 THEN
                        Zustand := 3;
    Oh ja richtig das hatte ich vergessen rauszunehmen.

    Zitat Zitat von MCerv Beitrag anzeigen
    Code:
                1 : IF oG_alarm = True THEN     // Wenn obere Grenze erneut verletzt wird dann 
    // wirst Du nie auf "1" abfragen können, da die CASE-Anweisung
    // mit Zustand 1 erst  beim 2. Zyklus abgefragt wird, jedoch der
    // Merker zuvor (oben)  zurückgesetzt wird
    Im ersten Zyklus wird der obere Grenzwert verletzt, daraufhin setze ich neue Grenzwerte (oben & unten).
    Bei der Case Anweisung soll nun Zustand von 0 (muss glaub ich noch als Startwert initialisiert werden) auf 1 gesetzt werden.
    Dann ist der 1. Zyklus zu Ende.

    Im nächsten Zyklus setze ich erst die Merker für die Grenzwerte zurück, jetzt prüfe ich erneut ob mein Messwert innerhalb der (neuen) Grenzen liegt. Wird der "neue" obere Grenzwert verletzt setze ich den Merker oG_alarm = True. Da Zustand 1 aus dem vorherigen Zyklus noch gesetzt ist gehe ich dorthin und führe die Aktion bei IF oG_alarm = True.

    Zitat Zitat von MCerv Beitrag anzeigen
    Code:
    zeit:=S_PEXT (T_NO:=1, S:= M0.0, TV:= t#20s, R:= M0.1, Q:= M0.2); 
    // wenn Du die nur intern benötigst, dann kannst Du auch STAT-BOOL-Variablen deklarieren
    Also soll ich dann in der Variablendeklaration einfach schreiben:
    Code:
    S: BOOL;
    R: BOOL;
    Q: BOOL;
    und dann später die entsprechenden Signale setzen und abfragen?

    Ich werd mir das mit der Zeit nochmal genau anschauen müssen, hab nämlich auch die falschen Merker genutzt M0.0 und M0.1 sind ja schon für die Alarme der Grenzwerte reserviert.

    Grüße Christian

  8. #8
    Registriert seit
    17.05.2010
    Ort
    Paderborn
    Beiträge
    824
    Danke
    84
    Erhielt 125 Danke für 94 Beiträge

    Standard

    Hi Christian,

    Code:
            1 : IF oG_alarm = True THEN     // Wenn obere Grenze erneut verletzt wird dann  // wirst Du nie auf "1" abfragen können, da die CASE-Anweisung // mit Zustand 1 erst  beim 2. Zyklus abgefragt wird, jedoch der // Merker zuvor (oben)  zurückgesetzt wird
    ja stimmt, da hatte ich mich vertan, sorry.

    Also soll ich dann in der Variablendeklaration einfach schreiben:
    Code:
    S: BOOL;
    R: BOOL;
    Q: BOOL;
    Ja z. B. vielleicht mit ner aussagekräftigeren Bezeichnung und wenn Du die Variablen nicht außerhalb des Bausteins brauchst.

    Ach ja, wenn Du 'nen IEC-Timer nehmen würdest und alles Parameter über die IN / OUT-Schnittstelle laufen lässt, dann wär der Baustein auch Multi-Instanzfähig.
    Grüße
    Michael

    1001101110110100... Das ist meine Welt

  9. Folgender Benutzer sagt Danke zu MCerv für den nützlichen Beitrag:

    T-Rex22 (15.11.2011)

  10. #9
    T-Rex22 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.11.2011
    Beiträge
    11
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Wo lege ich die Variablen für den IEC-Timer fest? Ich hab das jetzt so gemacht:
    Code:
        VAR
            state: INT:=0;               (* Zustand 
                                           0: Normal, 
                                           1: obere Grenze ueberschritten 
                                           2: untere Grenze unterrschritten
                                           3: Instabiles Verhalten entdeckt *)
                                         
            same_low: BOOL;             // Merker obere Grenze verletzt
            same_up: BOOL;              // Merker untere Grenze verletzt
            lower_limit: REAL;          // untere Grenze
            upper_limit: REAL;          // obere Grenze
    
            zeit: SFB4;                 // IEC Timer TON (Einschaltverzögerung)
            Zeit_Start: BOOL;           // Timer starten
            Zeit_Wert: TIME := t#20s;   // Intervalllänge zur Detektion        
            Zeit_Status: BOOL;          // Wenn Status = True dann Zeit_Wert abgelaufen
        END_VAR    
        BEGIN
            zeit(IN:= Zeit_Start, PT:= Zeit_Wert, Q:=Zeit_Status );
    Oder muss ich die jeweils als VAR_INPUT bzw VAR_OUTPUT deklarieren?


    Und die Sache mit dem Merker rücksetzen und setzen brauche ich weil der "TIMER als Einschaltverzögerung" auf eine positive Flanke reagiert um die Zeit zu starten/neuzustarten. Wie z.B. an der Stelle.

    Code:
               1 : IF oG_alarm = True THEN     // Wenn obere Grenze erneut verletzt wird dann 
                        Zustand := 1;           // bleibe in Zustand 1 und                     
                        M0.0 := False;          // den Merker setzt Du doch nachfolgend, wozu zurücksetzen, das bekommt kein weiterer Code mit!             
                        M0.0 := True;           // starte Zeit erneut.
    Bei Zustand 1 läuft der Timer bereits, (Beim Wechsel von Zustand 0 auf Zustand 1 oder 2 muss ich den Timer starten, das hatte ich vergessen).
    Wenn der obere Grenzwert wieder verletzt wird, soll der Timer neustarten. Also muss ich doch den Eingang erst zurücksetzen und dann wieder setzen oder nicht?

    Die Sache mit dem Rücksetzen werd ich jetzt einfach realisieren in dem ich den Eingangswert des Timers auf False setze.

  11. #10
    Registriert seit
    17.05.2010
    Ort
    Paderborn
    Beiträge
    824
    Danke
    84
    Erhielt 125 Danke für 94 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Oder muss ich die jeweils als VAR_INPUT bzw VAR_OUTPUT deklarieren?
    Nein, genau das ist ja das schöne! Der IEC-Timer brauch keine Nummer, sondern läuft als Instanz. Die Steuersignale können wahlweise intern bzw. über IN / OUT deklariert werden, je nach Anwendung.

    Die Einschaltverzögerung (der Timer) läuft solange, wie das Eingangssignal anliegt. Fällt das Eingangssignal vorzeitig weg, wird auch der Timer gestoppt. Mit neuem "1" Signal startet der Timer wieder von vorn.

    Wenn der obere Grenzwert wieder verletzt wird, soll der Timer neustarten. Also muss ich doch den Eingang erst zurücksetzen und dann wieder setzen oder nicht?
    Ja, jedoch läuft das Programm immer zeilenweise von oben nach unten durch und beginnt dann wieder von oben.

    Code:
    Besispiel := M0.0 // Die Variable "Beispiel" wird nur im 1. Programmzyklus "0" sein, danach ist die Variable M0.0 bereits "1"
    
    M0.0 := False;  // Dieses Zurücksetzen ist nur in dieser Zeile wirksam, da in der Nächsten M0.0 wieder auf "1" gesetzt wird!
    M0.0 := True;
    Grüße
    Michael

    1001101110110100... Das ist meine Welt

  12. Folgender Benutzer sagt Danke zu MCerv für den nützlichen Beitrag:

    T-Rex22 (17.11.2011)

Ähnliche Themen

  1. Mit S7 werte von MATLAB auslesen und verarbeiten
    Von Freakadelle im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 02.02.2009, 13:56
  2. S7-PLCSIM & MATLAB/Simulink
    Von sse im Forum Simatic
    Antworten: 0
    Letzter Beitrag: 28.01.2009, 21:48
  3. SM331 implementieren HILFE
    Von BOBZ im Forum Simatic
    Antworten: 6
    Letzter Beitrag: 18.01.2007, 13:52
  4. OPC Kommunikation mit Matlab/Simulink
    Von farforward im Forum Simatic
    Antworten: 3
    Letzter Beitrag: 25.01.2006, 21:13
  5. Antworten: 0
    Letzter Beitrag: 23.01.2006, 16:52

Stichworte

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •