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

Seite 2 von 4 ErsteErste 1234 LetzteLetzte
Ergebnis 11 bis 20 von 32

Thema: Hilfe bei einem FB (SCL) bin ich hier richtig? Sorry, bin neu hier...

  1. #11
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.718
    Danke
    398
    Erhielt 2.400 Danke für 2.000 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo Marcel,
    Ich würde erstmal im Ansatz schon etwas ändern.
    Das, was du da machen willst, ist eine Schrittkette :
    Code:
    Vorgabe_Blinktakte := 0
    if Fehler_1 then Vorgabe_Blinktakte := 1 ;
    elsif Fehler_2 then Vorgabe_Blinktakte := 2 ;
    elsif Fehler_3 then Vorgabe_Blinktakte := 3 ;
    etc
    
    Schritt 0:
       if Fehler_vorhanden then 
          lösche BlinktaktZähler
          Schritt := 1
    Schritt 1:
       Freigabe BlinktaktZähler
       Blinktakte werden (auch an den Ausgang des FB weiter gegeben
       if BlinktaktZähler >= Vorgabe_Blinktakte then 
          Schritt := 2
    Schritt 2:
       WarteZeit ablaufen lassen
       if Wartezeit_abgelaufen then
          Schritt := 0
    Das Gaze ist jetzt natürlich kein richtiger SCL-Code - sollte dir aber als Hilfestellung für so einen FB trotzdem nützlich sein.

    Gruß
    Larry

  2. #12
    Registriert seit
    29.03.2004
    Beiträge
    5.735
    Danke
    143
    Erhielt 1.685 Danke für 1.225 Beiträge

    Standard

    @Larry
    Mit deiner If-Then-Kette wird aber immer nur eine Blinksequenz ausgegeben. Wenn zwei oder mehr Fehler anliegen wird immer nur der mit der niedrigeren Blinkanzahl angezeigt.

    Die Lösung mit einer Schleife war hier ja schon angedacht, ich würde das prinzipiell so machen:

    Code:
        // Auf Fehler prüfen und Blink-Job eintragen
        IF T_PAUSE.Q THEN   // Kein Blinkauftrag aktiv und Pausenzeit abgelaufen
            FOR i := LAST_JOB TO ANZ DO
                IF Fehler[i] = true THEN    // Fehler steht an, dann
                    BLINK_JOB := i + 1;     // Nummer als "Blink-Job" eintragen = Anzahl Blinken
                    LAST_JOB := BLINK_JOB;  // damit bei nächstem Schleifendurchlauf mit nächstem Fehler fortgesetzt wird.
                    IF LAST_JOB > ANZ THEN
                        LAST_JOB := 0;
                    END_IF;
                    EXIT;                   // Schleife verlassen und Blink-Job abarbeiten
                END_IF;
            END_FOR;
            IF i > ANZ THEN                 // Wenn kein Blink-Job eingetragen (Schleife ist durchgelaufen)
                LAST_JOB := 0;              // dann beim nächsten mal bei 0 beginnen
            END_IF;
        END_IF;
    Fehlen nur noch die Blink-Timer und eine Flankenauswertung welche den BLINK_JOB-Zähler herunterzählt.

  3. #13
    Registriert seit
    21.07.2008
    Beiträge
    1.066
    Danke
    51
    Erhielt 140 Danke für 136 Beiträge

    Standard

    Code:
    FUNCTION_BLOCK FB2
    
    VAR_TEMP
    temp_int: INT;
    END_VAR
    
    VAR
     FehlerNr : INT;
     ausgabe_flanke: BOOL;
     ausgabe_zaehler: INT;
     stat_int: INT;
    END_VAR
    
    VAR_INPUT
     Fehler : ARRAY[1..10] OF BOOL;
     Takt : BOOL;
    END_VAR
    
    VAR_OUTPUT
     LED: BOOL;
    END_VAR   
    
    BEGIN
    
        fehlernr :=0;
        FOR stat_int := 1 TO 10 DO
            IF Fehler[stat_int] THEN
                FehlerNr := stat_int;
            END_IF;        
        END_FOR;
    
    IF ausgabe_zaehler > 0 THEN
      IF Takt AND NOT ausgabe_flanke  THEN
           ausgabe_zaehler := ausgabe_zaehler -1;
           ausgabe_flanke := true;   
      END_IF;
      IF NOT Takt THEN
         ausgabe_flanke := false;  
      END_IF;
      IF ausgabe_zaehler >= 6 THEN   
         LED := Takt;
      ELSE
         LED := false;      
      END_IF;        
    ELSE
      IF FehlerNR > 0 AND FehlerNR < 11 THEN
        ausgabe_zaehler := fehlerNr +5;
      END_IF;      
    END_IF;            
    
    
    END_FUNCTION_BLOCK
    Das hatte ich gestern mal aus Langeweile geschrieben und getestet.. Jedoch ist der Code praktisch sinnlos, da man in der Praxis nie "nur einen Fehler" hat.
    Man müsste noch soetwas wie einen Puffer (Last in, First out) bauen, der jeden Fehler abspeichert und der dann vom Blinkprogramm wieder gelöscht/abgearbeitet wird.

  4. #14
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.718
    Danke
    398
    Erhielt 2.400 Danke für 2.000 Beiträge

    Standard

    @Thomas:
    ja ... da hast du Recht. Aber die Auswertung "welcher Fehler ist wann gekommen" und "gab es den Fehler schon" ist die Lösung mit dem Array und einer entsprechenden Verriegelung, damit auch hier nicht immer der gleiche Fehler ausgegeben wird, ganz praktisch.

    Gruß
    Larry

  5. #15
    Registriert seit
    06.10.2009
    Ort
    NRW
    Beiträge
    1.572
    Danke
    63
    Erhielt 259 Danke für 219 Beiträge

    Standard

    Zitat Zitat von Deltal Beitrag anzeigen
    Man müsste noch soetwas wie einen Puffer (Last in, First out) bauen, der jeden Fehler abspeichert und der dann vom Blinkprogramm wieder gelöscht/abgearbeitet wird.
    Ich denke der LIFO-Puffer ist hier gar nicht notwendig. Bei Fehler muss die Schleife verlassen werden, um nach der Blinkausgabe wieder fortgesetzt zu werden. Ich habe mal nachgelesen und denke, dass "CONTINUE" das Richtige dafür sein könnte. Andernfalls kann man ja auch den Index selbst inkrementieren und auf die Schleife verzichten.

    Z.B.:

    Code:
    Index := Index + 1;
    
    IF Index > 10 THEN
    Index := 1;
    END_IF;
    Das Ganze kann man dann wie von Larry vorgeschlagen in einer Schrittkette lösen.
    Schritt 0: Index hochzählen (wie oben)
    Schritt 1: Fehlerauswertung
    a) kein Fehler -> Schritt 0
    b) Fehler -> Schritt 2 (Pulszähler := Index, Keine_Stoerung := FALSE)
    Schritt 2: Auf die nächste Flanke warten
    Schritt 3: Mit jeder Flanke des Taktes den Pulszähler runterzählen bis 0 (LED_Stoerung := Taktmerker)
    Schritt 4: Pause -> zurück zu Schritt 0 (Keine_Stoerung := TRUE)
    Meine Motivation läuft nackig mit einem Cocktail über eine Wiese.

  6. #16
    Registriert seit
    29.03.2004
    Beiträge
    5.735
    Danke
    143
    Erhielt 1.685 Danke für 1.225 Beiträge

    Standard

    Zitat Zitat von Tigerente1974 Beitrag anzeigen
    Ich habe mal nachgelesen und denke, dass "CONTINUE" das Richtige dafür sein könnte. Andernfalls kann man ja auch den Index selbst inkrementieren und auf die Schleife verzichten.
    CONTINUTE ist nicht passend, da damit die Schleife nicht verlassen wird. Mit EXIT aber (siehe mein Programmbeispiel oben).

    Bzw. komplett sähe es so aus:
    Code:
    FUNCTION_BLOCK FB800
    
    CONST
        ANZ := 9;
    END_CONST
        
    VAR_INPUT
        Fehler_1 : BOOL;
        Fehler_2 : BOOL;
        Fehler_3 : BOOL;
        Fehler_4 : BOOL;
        Fehler_5 : BOOL;
        Fehler_6 : BOOL;
        Fehler_7 : BOOL;
        Fehler_8 : BOOL;
        Fehler_9 : BOOL;
        Fehler_10: BOOL;
    END_VAR
    
    VAR_OUTPUT
        LED : BOOL;
    END_VAR
    
    VAR_TEMP
        Fehler : ARRAY[0..9] OF BOOL;
        i : INT;
    END_VAR
    
    VAR
        T_BLINK_E : TON;
        T_BLINK_P : TON;
        T_PAUSE : TON;
        BLINK_JOB : INT;
        LAST_JOB : INT;
        HM_P : BOOL;
    END_VAR
    
    (***********************************************)
    BEGIN
        Fehler[0] := Fehler_1;
        Fehler[1] := Fehler_2;
        Fehler[2] := Fehler_3;
        Fehler[3] := Fehler_4;
        Fehler[4] := Fehler_5;
        Fehler[5] := Fehler_6;
        Fehler[6] := Fehler_7;
        Fehler[7] := Fehler_8;
        Fehler[8] := Fehler_9;
        Fehler[9] := Fehler_10;
        
        // Auf Fehler prüfen und Blink-Job eintragen
        IF T_PAUSE.Q THEN   // Kein Blinkauftrag aktiv und Pausenzeit abgelaufen
            FOR i := LAST_JOB TO ANZ DO
                IF Fehler[i] = true THEN    // Fehler steht an, dann
                    BLINK_JOB := i + 1;     // Nummer als "Blink-Job" eintragen = Anzahl Blinken
                    LAST_JOB := BLINK_JOB;  // damit bei nächstem Schleifendurchlauf mit nächstem Fehler fortgesetzt wird.
                    IF LAST_JOB > ANZ THEN
                        LAST_JOB := 0;
                    END_IF;
                    EXIT;                   // Schleife verlassen und Blink-Job abarbeiten
                END_IF;
            END_FOR;
            IF i > ANZ THEN                 // Wenn kein Blink-Job eingetragen (Schleife ist durchgelaufen)
                LAST_JOB := 0;              // dann beim nächsten mal bei 0 beginnen
            END_IF;
        END_IF;
                
        // Blink-Job abarbeiten
        // Timer Einschaltdauer LED
        T_BLINK_E(
            IN :=  NOT T_BLINK_P.Q AND BLINK_JOB > 0,
            PT :=  T#300ms
        ); 
        // Timer Ausschaltdauer LED
        T_BLINK_P(
            IN :=  T_BLINK_E.Q,
            PT :=  T#300ms
        ); 
        // Timer Pausenzeit zwischen Blinkjobs
        T_PAUSE(
            IN :=  BLINK_JOB = 0,
            PT :=  T#2s
        ); 
        // Anzahl blinken zählen
        IF NOT T_BLINK_E.Q AND HM_P THEN
            BLINK_JOB := BLINK_JOB - 1;
        END_IF;  
        HM_P := T_BLINK_E.Q;
        
        LED := NOT T_BLINK_E.Q AND BLINK_JOB > 0;
            
    END_FUNCTION_BLOCK

  7. #17
    Registriert seit
    21.07.2008
    Beiträge
    1.066
    Danke
    51
    Erhielt 140 Danke für 136 Beiträge

    Standard

    Gut, würde ich mit der Schleife stoppen und dann nach dem Anzeigen weitermachen, würde ich jeden Fehler anzeigen. Dafür müsste aber jeder Fehler statisch sein..

    Praktisch muss vor dem Aufruf des FBs gewährleistet sein, dass zu jeder Zeit immer nur ein Fehler aktiv ist..

    Für alles andere wäre das mindeste ne BCD Anzeige oder ein kleines OP/TP.

  8. #18
    Marcel9824 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    03.09.2011
    Beiträge
    13
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    OK, Index sagt mir jetzt nicht wirklich was!

    Die Länge des FBs iste erstmal egal aber dass mit mehreren Fehlern ist super, man weiß ja nie, ruckzuck kommt noch einer mit dazu

    Das mit dem InstanzDB ist nicht so praktisch da ich den Baustein eigentlich mehrfach als Multiinstanz verwenden will!
    Da wär es doch besser die Fehlereingänge direkt am Multi.. einzulesen!

    Gruß

  9. #19
    Marcel9824 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    03.09.2011
    Beiträge
    13
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Aber mal ehrlich, ihr seid echt der Hammer........ wenn ich die Posts durchlese versteh ich nur noch Bahnhof *heul*

    aber ich bin Euch trotzdem sehr sehr dankbar dafür.........(auch wenn ichs nicht wirklich kappier)

    Aber eins hab ich festgestellt : MIT EURER HILFE SCHAFF ICH DASS

    (Und versteh es hoffentlich auch

    Der Sonntag ging zwar drauf dafür und geklappt hat nix........

    Aber ich bin zuversichtlich......!!!

    Also nochmal die Funktion beschrieben wie ichs am liebsten hätte (nach den guten Tipps von Euch)

    Wenn nur ein Fehler ansteht soll er per Blinktakt (je 1-10 Blinktakte -> 1Hz) ausgegeben werden (5sec Pause dazwischen)

    Wenn mehrere Fehler anstehen soll einer nach dem anderen dargestellt werden..... (Blinktakte mit je 5sec Pause dazwischen)

    Steht kein Fehler an soll der Ausgang (keine_Stoerung) gesetzt werden

    Der Baustein soll mehrfach als Multiinstanz verwendet werden.......

    Vielen Dank an Euch Alle und einen guten Wochenstart wünsch ich Euch......

    Gruß

    Marcel

  10. #20
    Marcel9824 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    03.09.2011
    Beiträge
    13
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Vielen Dank erstmals an Thomas v2.1

    Ich hatte dummerweise den TON nicht drin....... jetzt funzt es juhuuuu
    Vieeeeeelen Dank

    Natürlich auch vieeeelen Dank an die Anderen, ich finde das Forum suuuuper! Ich hab mich dumm und dämlich versucht mit Zählern und Zeitgliedern.......

    Aber noch eins @Thomas: kannst Du mir vielleicht noch ein wenig genauer erklären was da genau passiert?
    Ich bin super froh das es funktioniert aber ich kann nicht ganz nachvolziehen wie das genau abläuft.......

    Am Ende hab ich noch den Ausgang angehängt und hier nochmal der komplette Code:

    FUNCTION_BLOCK FB804 // FB für Fehlerauswertung
    CONST
    ANZ := 9;
    END_CONST
    VAR_INPUT
    Fehler1: BOOL; // Fehlerzustand1 = 1x blinken (1Hz) und 5sec Pause
    Fehler2: BOOL; // Fehlerzustand2 = 2x blinken (1Hz) und 5sec Pause
    Fehler3: BOOL; // Fehlerzustand3 = 3x blinken (1Hz) und 5sec Pause
    Fehler4: BOOL; // Fehlerzustand4 = 4x blinken (1Hz) und 5sec Pause
    Fehler5: BOOL; // Fehlerzustand5 = 5x blinken (1Hz) und 5sec Pause
    Fehler6: BOOL; // Fehlerzustand6 = 6x blinken (1Hz) und 5sec Pause
    Fehler7: BOOL; // Fehlerzustand7 = 7x blinken (1Hz) und 5sec Pause
    Fehler8: BOOL; // Fehlerzustand8 = 8x blinken (1Hz) und 5sec Pause
    Fehler9: BOOL; // Fehlerzustand9 = 9x blinken (1Hz) und 5sec Pause
    Fehler10: BOOL; // Fehlerzustand10 = 10x blinken (1Hz) und 5sec Pause
    END_VAR
    VAR_OUTPUT
    Keine_Stoerung: BOOL; // Stoerungsfreier Ausgang
    LED: BOOL; // Blinkauswertung des anstehenden Fehler (eine LED)
    END_VAR

    VAR
    T_Blink_E: TON;
    T_Blink_P: TON;
    T_PAUSE: TON;
    BLINK_JOB: INT;
    LAST_JOB: INT;
    HM_P: BOOL;
    END_VAR
    VAR_TEMP
    Fehler: ARRAY[0..10]OF BOOL;
    i: INT;
    BEGIN;
    Fehler[0] := Fehler1;
    Fehler[1] := Fehler2;
    Fehler[2] := Fehler3;
    Fehler[3] := Fehler4;
    Fehler[4] := Fehler5;
    Fehler[5] := Fehler6;
    Fehler[6] := Fehler7;
    Fehler[7] := Fehler8;
    Fehler[8] := Fehler9;
    Fehler[9] := Fehler10;

    // Auf Fehler prüfen und Blink-Job eintragen
    IF T_PAUSE.Q THEN // Kein Blinkauftrag aktiv und Pausenzeit abgelaufen
    FOR i := LAST_JOB TO ANZ DO
    IF Fehler[i] = true THEN // Fehler steht an, dann
    BLINK_JOB := i + 1; // Nummer als "Blink-Job" eintragen = Anzahl Blinken
    LAST_JOB := BLINK_JOB; // damit bei nächstem Schleifendurchlauf mit nächstem Fehler fortgesetzt wird.
    IF LAST_JOB > ANZ THEN
    LAST_JOB := 0;
    END_IF;
    EXIT; // Schleife verlassen und Blink-Job abarbeiten
    END_IF;
    END_FOR;
    IF i > ANZ THEN // Wenn kein Blink-Job eingetragen (Schleife ist durchgelaufen)
    LAST_JOB := 0; // dann beim nächsten mal bei 0 beginnen
    END_IF;
    END_IF;

    // Blink-Job abarbeiten
    // Timer Einschaltdauer LED
    T_BLINK_E(
    IN := NOT T_BLINK_P.Q AND BLINK_JOB > 0,
    PT := T#300ms
    );
    // Timer Ausschaltdauer LED
    T_BLINK_P(
    IN := T_BLINK_E.Q,
    PT := T#300ms
    );
    // Timer Pausenzeit zwischen Blinkjobs
    T_PAUSE(
    IN := BLINK_JOB = 0,
    PT := T#2s
    );
    // Anzahl blinken zählen
    IF NOT T_BLINK_E.Q AND HM_P THEN
    BLINK_JOB := BLINK_JOB - 1;
    END_IF;
    HM_P := T_BLINK_E.Q;

    LED := NOT T_BLINK_E.Q AND BLINK_JOB > 0;
    IF NOT Fehler1 AND NOT Fehler2 AND NOT Fehler3 AND NOT Fehler4 AND NOT Fehler5 AND NOT Fehler6 AND NOT Fehler7 AND NOT Fehler8 AND NOT Fehler8 AND NOT Fehler9 AND NOT Fehler10 THEN Keine_Stoerung :=true;
    ELSE Keine_Stoerung :=false;
    END_IF;

    END_FUNCTION_BLOCK

Ähnliche Themen

  1. Neu hier
    Von Halbwissen im Forum Stammtisch
    Antworten: 7
    Letzter Beitrag: 11.03.2010, 15:31
  2. Bin neu hier...
    Von Pro² im Forum Stammtisch
    Antworten: 10
    Letzter Beitrag: 11.10.2009, 22:26
  3. neu hier
    Von SPS-Mirk im Forum Stammtisch
    Antworten: 18
    Letzter Beitrag: 24.10.2007, 21:04
  4. Hi bin neu hier
    Von woodimweb im Forum Stammtisch
    Antworten: 4
    Letzter Beitrag: 05.09.2006, 14:28
  5. Antworten: 15
    Letzter Beitrag: 01.03.2005, 22:25

Lesezeichen

Berechtigungen

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