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

Marcel9824

Level-1
Beiträge
16
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

ich habe mich eben angemeldet und hoffe doch hier richtig zu sein!

Ich bin Neuling in Sache SCL und verzweifle gerade an einem (für Euch bestimmt sehr einfachen) FB :-(

Mit Boolean, Zeiten, und Zählern komm ich eigentlich ganz gut zurecht :)
allerdings häng ich jetzt an einem Baustein wo ich nicht wirklich weiß wie ich dass realisieren kann :-(

Ich möchte (in SCL) einen Störmeldebaustein erstellen der mir per Ausgang (LED) in Taktfrequenz sagt welcher Fehlerzustand ansteht.......

Ich habe 10 Eingänge und die sollen verschieden definiert sein.....

Wie gesagt , ich bin ganz neu hier und muss mich erstmal zurechtfinden!

Wie poste ich jetzt den angefangenen Quelltext?

Ich habe schon sovieeeeel mit Takten und Zählern versucht aber komm einfach auf kein grünen Zweig :-( *heul*
Ich find aber auch bei google irgendwie nix wirkliches :-(
Ich wäre Euch wirklich soooo dankbar wenn ihr mir helfen könntet aber eine kleine Bitte hab ich noch : Ich möchte SCL lernen und wäre sehr dankbar wenn die einzelnen Schritte auch dokumentiert sind das ich es nachvollziehen kann....... Ich Danke Euch !
 
Also ich poste den Quellcode jetzt mal hier im Textfeld:


//--------------------------------------------------------------------------------------------------------//
// Beschreibung FB804: Fehlerauswertung //
// //
// Erstellt : Schmidt M. am 02.09.11 - Code dokumentiert //
// //
//--------------------------------------------------------------------------------------------------------//
// //
// INHALTSVERZEICHNIS: 0) = Störungsfreigabebedingungen der Anlage //
// 1) = //
// 2) = usw..... //
//--------------------------------------------------------------------------------------------------------//

{SCL_OverwriteBlocks := 'y' ; SCL_CreateDebugInfo := 'y'}
{SetOKFlag := 'y' ; OptimizeObjectCode := 'y'}

FUNCTION_BLOCK FB804 // FB für Fehlerauswertung
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
Taktmerker_1Hz: BOOL; // Einlesen des Sekundentaktes durch Taktmerker der CPU
END_VAR

VAR_OUTPUT
Keine_Stoerung: BOOL; // Stoerungsfreier Ausgang
LED_Steuerung: BOOL; // Blinkauswertung des anstehenden Fehler (eine LED)
END_VAR

VAR
Mehrere_Fehler: BOOL; // wenn mehr als einer der Fehlereingänge ansteht soll der Ausgang der LED (VAR_OUT : LED_Steuerung) konstant leuchten

Fehler1_besteht: BOOL; // Die Variablen zur Weiterverarbeitung........
Fehler2_besteht: BOOL; //
Fehler3_besteht: BOOL; //
Fehler4_besteht: BOOL; //
Fehler5_besteht: BOOL; //
Fehler6_besteht: BOOL; //
Fehler7_besteht: BOOL; //
Fehler8_besteht: BOOL; //
Fehler9_besteht: BOOL; //
Fehler10_besteht: BOOL; //
END_VAR

BEGIN;
// ------------------------------------------------------------------------------------------------------------------------------//
// (0) Störungsfreigabebedingungen der Anlage //
// ------------------------------------------------------------------------------------------------------------------------------//
IF Fehler1 AND Fehler2 AND Fehler3 AND Fehler4 AND Fehler5 AND Fehler6 AND Fehler7 AND Fehler7 AND Fehler8 AND Fehler9 AND Fehler10 THEN Keine_Stoerung:=true;
ELSE Keine_Stoerung:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (1) Fehlerauswertung Eingang 1 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler1 THEN Fehler1_besteht:=true;
ELSE Fehler1_besteht:=false;
END_IF;
// ------------------------------------------------------------------------------------------------------------------------------//
// (2) Fehlerauswertung Eingang 2 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler2 THEN Fehler2_besteht:=true;
ELSE Fehler2_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (3) Fehlerauswertung Eingang 3 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler3 THEN Fehler3_besteht:=true;
ELSE Fehler3_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (4) Fehlerauswertung Eingang 4 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler4 THEN Fehler4_besteht:=true;
ELSE Fehler4_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (5) Fehlerauswertung Eingang 5 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler5 THEN Fehler5_besteht:=true;
ELSE Fehler5_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (6) Fehlerauswertung Eingang 6 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler6 THEN Fehler6_besteht:=true;
ELSE Fehler6_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (7) Fehlerauswertung Eingang 7 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler7 THEN Fehler7_besteht:=true;
ELSE Fehler7_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (8) Fehlerauswertung Eingang 8 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler8 THEN Fehler8_besteht:=true;
ELSE Fehler8_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (9) Fehlerauswertung Eingang 9 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler9 THEN Fehler9_besteht:=true;
ELSE Fehler9_besteht:=false;
END_IF;

// ------------------------------------------------------------------------------------------------------------------------------//
// (10) Fehlerauswertung Eingang 10 //
// ------------------------------------------------------------------------------------------------------------------------------//
IF NOT Fehler10 THEN Fehler10_besteht:=true;
ELSE Fehler10_besteht:=false;
END_IF;

// Also mit takten und Zählern bekomm ich dass nie richtig hin :-(grrrrrrrrrrr

END_FUNCTION_BLOCK
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hier mal ein Ansatz, wie ich das lösen würde:

Anlegen einer Variable "Fehler" Array[1..10] of BOOL.
Umkopieren der Eingänge in die Arraystruktur.

In einer Schleife das Fehler-Array abfragen und bei Fehler den Schleifenzähler in einem "Pulszähler" merken. Die Schleife anhalten und die Fehler pulsen. (So kannst Du dann auch gleich erreichen, dass bei mehreren Fehlern die Fehler nacheinander ausgegeben werden, anstatt ein Dauersignal auszugeben.)

Bei Fehler auf den nächsten Taktimpuls warten und mit jeder Flanke vom Taktimpuls den Pulszähler bis auf 0 runterzählen lassen.

Anschließend die Schleife fortsetzen.
 
Was sollst du den machen wenn mal zwei Fehler gleichzeitig anstehen?

Bei dem Fehler 10 würdest du fast 15sek brauchen um die Geschichte darzustellen.. was ist wenn in der Zeit ein neuer Fehler kommt?

Für das Blinken brauchst du eine Variable. Die erhöhst du jedes mal wenn die LED angesteuert wird (über eine Flanke). Hast du die richtige Anzahl erreicht, machst du die LED aus und zählst noch fünf weitere sekunden für deine Pause. Danach "schaust" du wieder welchen Fehler du anzeigen kannst..

In deinem Fall würde ich weder eine Zeit noch einen Zählerbaustein benutzen.
 
@Tigerente: Wow ja, das ist super wenn ich die Fehler (mehrere Fehler stehen an) sogar hintereinander darstellen kann!

@Deltal: Das macht nix das es solange geht wenn nicht könnt ich ja die Blinkfrequenz höher nehmen.....

Mit Arrays und Schleifen hab ich noch nie was gemacht und ich hab hier schon im Ansatz Probleme da er immer meckert : Ungültiger Datentyp?

Code:
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
Taktmerker_1Hz: BOOL; // Einlesen des Sekundentaktes durch Taktmerker der CPU
END_VAR

VAR_OUTPUT
Keine_Stoerung: BOOL; // Stoerungsfreier Ausgang
LED_Steuerung: BOOL; // Blinkauswertung des anstehenden Fehler (eine LED)
END_VAR

VAR
Fehlerzustand: ARRAY[1..10]OF BOOL; // Fehlerzustand
END_VAR

BEGIN;
IF Fehler1 THEN Fehlerzustand:=1;
ELSIF Fehler2 THEN Fehlerzustand:=2;
ELSIF Fehler3 THEN Fehlerzustand:=3;
ELSIF Fehler4 THEN Fehlerzustand:=4;
ELSIF Fehler5 THEN Fehlerzustand:=5;
ELSIF Fehler6 THEN Fehlerzustand:=6;
ELSIF Fehler7 THEN Fehlerzustand:=7;
ELSIF Fehler8 THEN Fehlerzustand:=8;
ELSIF Fehler9 THEN Fehlerzustand:=9;
ELSIF Fehler10 THEN Fehlerzustand:=10;
ELSE Fehlerzustand:=0;
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Sorry, also so gehts :

VAR
Fehlerzustand: ARRAY[1..10]OF BOOL; // Fehlerzustand
END_VAR

BEGIN;
Fehler1:= Fehlerzustand[1];
Fehler2:= Fehlerzustand[2];
Fehler3:= Fehlerzustand[3];
Fehler4:= Fehlerzustand[4];
Fehler5:= Fehlerzustand[5];
Fehler6:= Fehlerzustand[6];
Fehler7:= Fehlerzustand[7];
Fehler8:= Fehlerzustand[8];
Fehler9:= Fehlerzustand[9];
Fehler10:= Fehlerzustand[10];

aber wie jetzt weiter? Schleife? Blinken? warten? ohje, ich seh schon es ist garnicht so einfach wie ich gedacht habe........ EGAL! Ich will das hinbekommen ;-)
Danke Euch und freu mich auf Antworten!
 
Mach gleich die IN-Variable als Array.

VAR_INPUT
Fehler: ARRAY[1..10]OF BOOL;
END_VAR

Den Aktuellen Fehler würde ich gleich in einer Variable speichern.

VAR
FehlerNR: INT;
End_VAR

Dann kannst du das bit mit einer for-schleife auslesen. Die variable "stat_int" ist eine statische integer variable.
Code:
for stat_int:= 1 to 10 DO
  if fehler[stat_int] THEN
     FehlerNR := stat_int;
  END_IF;
END_FOR;
So wird jedoch bei zwei Fehlerbits immer das letzte bit ausgewertet!
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich setz mich gleich dran, vielen dank aber mhhhhhh was ich nicht verstehe:
Wieso soll ich das Array als Eingangsvariable definieren? Dann hab ich doch nur einen Eingang??? Ich brauch doch 10 Eingänge! Sorry dass ichs nicht gleich blick wie es gemeint ist........

oder das Array als Eingangsvariable UND die 10 Eingänge?

Oh mann, SCL....... krass aber ich liebe es und schreib viel lieber StructText als so blöde Bausteinchen im FUP :-D

Ich dank Dir für die Info........
 
Ob du jetzt 10x Bool übergibst oder ein Array mit 10xBool Variablen ist erstmal egal.. innerhalb von SCL ist es aber um einiges praktischer weil du mit Scheifen und dem Index arbeiten kannst. So kannst du deine Fehlerauswertung die du im ersten Beitrag geposted hast auf 6 Zeilen kürzen!

Must du z.B. deine Fehlerauswertung auf 100 Nummern erhöhen, dann sind das immernoch 6 Zeilen!

Um die In-Variable zu beschreiben musst du etwas ungewohnt auf die InstanzDB der Funktion schreiben, kannst also kein "bit an den Baustein hängen".

Es würde dann eher so aussehen:

L Fehlereingangirgendwas
= Instanz_DB.Fehler[1]

L Fehler2einganghastenichtgesehen
= Instanz_DB.Fehler[2]

usw.
 
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
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@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.
 
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.
 
@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
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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)
 
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
 
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.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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ß
 
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
 
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 = 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
 
Zurück
Oben