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

Seite 1 von 4 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 32

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

  1. #1
    Registriert seit
    03.09.2011
    Beiträge
    13
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    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 !
    Zitieren Zitieren Hilfe bei einem FB (SCL) bin ich hier richtig? Sorry, bin neu hier...  

  2. #2
    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

    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;

    // ------------------------------------------------------------------------------------------------------------------------------//
    // ( 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

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

    Standard

    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.
    Meine Motivation läuft nackig mit einem Cocktail über eine Wiese.

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

    Standard

    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.

  5. #5
    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

    @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;

  6. #6
    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

    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!

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

    Standard

    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!
    Geändert von Deltal (03.09.2011 um 16:00 Uhr)

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

    Standard

    Ahhh.. das muss natürlich eine statische Variable sein, die in der For-Schleife genutzt wird.. *schnell änder*

  9. #9
    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

    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

    Ich dank Dir für die Info........

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

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    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.

Ä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
  •