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

Seite 3 von 3 ErsteErste 123
Ergebnis 21 bis 29 von 29

Thema: DI's entprellen

  1. #21
    Registriert seit
    24.05.2006
    Beiträge
    234
    Danke
    14
    Erhielt 77 Danke für 57 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Also wenn ihr wirklich nur vom Entprellen des 0 -> 1 Übergangs sprecht, dann ist die Lösung mit dem SFB 5 ja ganz ok. Aber wo steht bitte in der ursprünglichen Fragestellung, dass es nur um 0 -> 1 geht?? Wenn es darum geht, generell kurze Störungen zu unterdrücken, dann sollte doch wohl auch der 1 -> 0 Übergang entsprechend behandelt werden.
    Mir ist schon klar, dass der angesprochene Taster normalerweise nur beim Schließen prellt, aber geht's hier wirklich um die klassische Tastaturentprellung?

  2. #22
    Registriert seit
    21.09.2004
    Beiträge
    92
    Danke
    6
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Zitat Zitat von hovonlo Beitrag anzeigen
    Also wenn ihr wirklich nur vom Entprellen des 0 -> 1 Übergangs sprecht, dann ist die Lösung mit dem SFB 5 ja ganz ok. Aber wo steht bitte in der ursprünglichen Fragestellung, dass es nur um 0 -> 1 geht?? Wenn es darum geht, generell kurze Störungen zu unterdrücken, dann sollte doch wohl auch der 1 -> 0 Übergang entsprechend behandelt werden.
    Mir ist schon klar, dass der angesprochene Taster normalerweise nur beim Schließen prellt, aber geht's hier wirklich um die klassische Tastaturentprellung?
    Mir geht es nur um den Übergang 0-->1 und SFB4!

  3. #23
    Registriert seit
    03.01.2006
    Ort
    Im sonnigen Süden von Österreich!
    Beiträge
    1.377
    Danke
    227
    Erhielt 183 Danke für 168 Beiträge

    Standard

    Zitat Zitat von Küffel Beitrag anzeigen
    Hallo godi,

    leider habe ich noch nichts viel (eigentlich nicht mit SCL) gemacht. Aber ich denke ich werde mich einlesen, dein Beispiel sieht schön strukturiert aus. Ich habe es auch mal versucht in eine SCL Quelle einzufügen. Leider ohne Erfolg. Erstmal gehe ich davon aus, du meintest SFB4 nicht 5, richtig?

    Die Variablen Deklaration verstehe ich noch nicht so richtig: du legst eine Variable "Entprellung_DI_0_0" an, die vom TYP SFB4 ist, richtig?

    Diese werden dann in den Lokaldaten von FB1 gespeichert, richtig? Damit braucht man dann nicht mehr für jeden SFB4 aufruf einen eigenen Instanzdatenbaustein, oder?

    Meine SCL Version meckert schon über den Titelbezeichner vom Netzwerk. Verison 5.3.1, mit welcher version hast du programmiert?


    Was ich danach nicht verstehe ist der CALL. Du rufst eine Funktion, wo ich dachte es sei eine Variable, hmmm, hier gebe ich erst mal auf und warte auf weitere Tipps...

    Danke schon mal vorab!

    Gruß
    Küffel
    Hallo!

    Ja sorry, meinte natürlich SFB 4!

    Variablendekleration:
    Ja habe eine Variable im Statischen Bereich des FB's angelegt vom Typ SFB (4) Das ist dann eine Multiinstanz!
    Also alle Statischen Variablen vom SFB 4 werden dann zugleich die Statischen Variablen vom FB wo die Variable deklariert ist und somit braucht man nur mehr einen Instanzdatenbaustein für den übergeordneten FB.

    Call #Variablennamen:
    Ja hier rufe ich den SFB über den Variablennamen auf weil es ja eine Multiinstanz ist.
    Also durch den Variablennamen weiß dann die CPU wo sich der Speicherbereich des SFB im übergeordneten Instanzdatenbaustein befindet.
    Natürlich kannst du bei Multiinstanzen den Variablennamen nur einmal aufrufen sonst würde es nicht funktionieren weil sich die Speicherbereiche im IDB selbst überschreiben würden.
    Wenn du jetzt 2 mal den SFB benötigst dann musst du auch 2 mal eine Variable deklarieren mit dem SFB!

    godi

  4. Folgender Benutzer sagt Danke zu godi für den nützlichen Beitrag:

    Küffel (16.08.2007)

  5. #24
    Registriert seit
    03.01.2006
    Ort
    Im sonnigen Süden von Österreich!
    Beiträge
    1.377
    Danke
    227
    Erhielt 183 Danke für 168 Beiträge

    Standard

    So und weil hier auch immer das Gespräch von SCL ist/war habe ich mal einen Baustein in SCL geschrieben (SCL muss ich eh lernen) wo als Input ein Byte angegeben werden kann und als Output kommt das Entprellte Byte heraus. Natürlich kann man auch die Verzögerungszeit einstellen!

    Ich hoffe es stimmt halbwegs was ich programmiert habe aber die SCL Profis werden mich schon korrigieren!
    Funktionieren tuts auf jeden Fall mal!

    Code:
     
    FUNCTION_BLOCK FB2
    VERSION : '0.1'
    AUTHOR  : godi
    NAME    : Byte_Entprellen
    FAMILY  : Byte_Entprellen
     
    VAR_INPUT
        Unentprelltes_Byte : BYTE;  //Eingangsbyte wo die einzelnen Bits Einschaltverzögert ausgegeben werden
        Entprellzeit : TIME;        //Zeit für Einschaltverzögerung
    END_VAR
     
    VAR_OUTPUT
        Entprelltes_Byte : BYTE;    //Ausgangsbyte -> alle Bits sind schon entprellt
    END_VAR
     
    VAR_TEMP
        Unentprelltes_Word : WORD;
        Entprelltes_Word : WORD;
        IN_Bit_Timer AT Unentprelltes_Word : ARRAY [0..15] OF BOOL;
        OUT_Bit_Timer AT Entprelltes_Word : ARRAY [0..15] OF BOOL;
        Entprelltes_Byte_Array AT Entprelltes_Word : ARRAY [0..1] OF BYTE;
        Bit_Index : INT;
    END_VAR
     
    VAR    
      Entprellung_Bit_0 : SFB4;    
      Entprellung_Bit_1 : SFB4; 
      Entprellung_Bit_2 : SFB4; 
      Entprellung_Bit_3 : SFB4; 
      Entprellung_Bit_4 : SFB4; 
      Entprellung_Bit_5 : SFB4; 
      Entprellung_Bit_6 : SFB4; 
      Entprellung_Bit_7 : SFB4;   
    END_VAR
     
    BEGIN
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Wandle Byte in Word wegen AT Befehl
    Unentprelltes_Word := BYTE_TO_WORD(Unentprelltes_Byte);
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 0
    Bit_Index := 0 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_0(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     //Bit_Index := 0         
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_0.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
    //Entprellung Bit 1
    Bit_Index := 1 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_1(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_1.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 2
    Bit_Index := 2 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_2(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_2.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 3
    Bit_Index := 3 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_3(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_3.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 4
    Bit_Index := 4 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_4(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_4.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 5
    Bit_Index := 5 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_5(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_5.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 6
    Bit_Index := 6 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_6(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_6.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 7
    Bit_Index := 7 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_7(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_7.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Schreibe Entprelltes Byte
    Entprelltes_Byte := Entprelltes_Byte_Array[1];
     
    END_FUNCTION_BLOCK
    godi

  6. #25
    Registriert seit
    21.09.2004
    Beiträge
    92
    Danke
    6
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Zitat Zitat von godi Beitrag anzeigen
    So und weil hier auch immer das Gespräch von SCL ist/war habe ich mal einen Baustein in SCL geschrieben (SCL muss ich eh lernen) wo als Input ein Byte angegeben werden kann und als Output kommt das Entprellte Byte heraus. Natürlich kann man auch die Verzögerungszeit einstellen!

    Ich hoffe es stimmt halbwegs was ich programmiert habe aber die SCL Profis werden mich schon korrigieren!
    Funktionieren tuts auf jeden Fall mal!

    Code:
     
    FUNCTION_BLOCK FB2
    VERSION : '0.1'
    AUTHOR  : godi
    NAME    : Byte_Entprellen
    FAMILY  : Byte_Entprellen
     
    VAR_INPUT
        Unentprelltes_Byte : BYTE;  //Eingangsbyte wo die einzelnen Bits Einschaltverzögert ausgegeben werden
        Entprellzeit : TIME;        //Zeit für Einschaltverzögerung
    END_VAR
     
    VAR_OUTPUT
        Entprelltes_Byte : BYTE;    //Ausgangsbyte -> alle Bits sind schon entprellt
    END_VAR
     
    VAR_TEMP
        Unentprelltes_Word : WORD;
        Entprelltes_Word : WORD;
        IN_Bit_Timer AT Unentprelltes_Word : ARRAY [0..15] OF BOOL;
        OUT_Bit_Timer AT Entprelltes_Word : ARRAY [0..15] OF BOOL;
        Entprelltes_Byte_Array AT Entprelltes_Word : ARRAY [0..1] OF BYTE;
        Bit_Index : INT;
    END_VAR
     
    VAR    
      Entprellung_Bit_0 : SFB4;    
      Entprellung_Bit_1 : SFB4; 
      Entprellung_Bit_2 : SFB4; 
      Entprellung_Bit_3 : SFB4; 
      Entprellung_Bit_4 : SFB4; 
      Entprellung_Bit_5 : SFB4; 
      Entprellung_Bit_6 : SFB4; 
      Entprellung_Bit_7 : SFB4;   
    END_VAR
     
    BEGIN
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Wandle Byte in Word wegen AT Befehl
    Unentprelltes_Word := BYTE_TO_WORD(Unentprelltes_Byte);
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 0
    Bit_Index := 0 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_0(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     //Bit_Index := 0         
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_0.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
    //Entprellung Bit 1
    Bit_Index := 1 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_1(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_1.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 2
    Bit_Index := 2 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_2(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_2.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 3
    Bit_Index := 3 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_3(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_3.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 4
    Bit_Index := 4 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_4(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_4.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 5
    Bit_Index := 5 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_5(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_5.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 6
    Bit_Index := 6 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_6(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_6.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Entprellung Bit 7
    Bit_Index := 7 + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_7(IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_7.Q; // OUT: BOOL
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Schreibe Entprelltes Byte
    Entprelltes_Byte := Entprelltes_Byte_Array[1];
     
    END_FUNCTION_BLOCK
    godi
    Sehr schön, ich habe es natürlich sofort ausprobiert und es scheint tatsächlich zu funktionieren!!!!! Ich habe zwar deine Lösung 1 bereits umgesetzt (für insgesamt 50! Eingänge), allerdings bereitet mir der Speicher ein kleines Problem. Diese Lösung hier ist wesentlich kleiner.

    Ich versuche das Progrämmchen zu verstehen, und werde noch versuchen eine Maske als Eingang einzubauen, da ich häufig nur 7 Bit eines Bytes Filtern will! Oder hast du auf die schnelle noch eine Idee?

    Auf jeden Fall ein großes Danke an die Hilfsbereitschaft, auch wenns nicht ganz Uneigennützig ist und du was lernen möchtest

    Gruß
    Küffel
    Geändert von Küffel (18.08.2007 um 07:47 Uhr)

  7. #26
    Registriert seit
    21.09.2004
    Beiträge
    92
    Danke
    6
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Noch eine Frage, eigentlich sieht es so aus, als könnte man das ganze schön durch eine FOR schleife laufen lassen:
    Code:
    VAR_INPUT
        Unentprelltes_Byte : BYTE;  //Eingangsbyte wo die einzelnen Bits Einschaltverzögert ausgegeben werden
        Entprellzeit : TIME;        //Zeit für Einschaltverzögerung
    END_VAR
     
    VAR_OUTPUT
        Entprelltes_Byte : BYTE;    //Ausgangsbyte -> alle Bits sind schon entprellt
    END_VAR
     
    VAR_TEMP
        Unentprelltes_Word : WORD;
        Entprelltes_Word : WORD;
        IN_Bit_Timer AT Unentprelltes_Word : ARRAY [0..15] OF BOOL;
        OUT_Bit_Timer AT Entprelltes_Word : ARRAY [0..15] OF BOOL;
        Entprelltes_Byte_Array AT Entprelltes_Word : ARRAY [0..1] OF BYTE;
        Bit_Index : INT;
        Loop_Index : INT ;
    
    END_VAR
     
    VAR      
        Entprellung_Bit_X : ARRAY[0..7] OF SFB4; 
    END_VAR
     
    BEGIN
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Wandle Byte in Word wegen AT Befehl
    Unentprelltes_Word := BYTE_TO_WORD(Unentprelltes_Byte);
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    FOR Loop_Index:=0 TO 7 DO
    //Entprellung Bit 0
    Bit_Index := #Loop_Index + 8; // + 8 für niederwertiges Byte wegen Wandlung zu Word
    Entprellung_Bit_X[Loop_Index](IN := IN_Bit_Timer[Bit_Index] // IN: BOOL
              ,PT := Entprellzeit // IN: TIME
              ); 
     //Bit_Index := 0         
     OUT_Bit_Timer[Bit_Index] := Entprellung_Bit_X[Loop_Index].Q; // OUT: BOOL
    EXIT
     
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //Schreibe Entprelltes Byte
    Entprelltes_Byte := Entprelltes_Byte_Array[1];
     
    END_FUNCTION_BLOCK
    Leider funktioniert die Variablendeklaration von SFB4 in einem Array nicht. Gibts eine Chance?

  8. #27
    Registriert seit
    03.01.2006
    Ort
    Im sonnigen Süden von Österreich!
    Beiträge
    1.377
    Danke
    227
    Erhielt 183 Danke für 168 Beiträge

    Standard

    Zitat Zitat von Küffel Beitrag anzeigen
    Leider funktioniert die Variablendeklaration von SFB4 in einem Array nicht. Gibts eine Chance?
    Hallo!

    Ja leider funktioniert in SCL ein Array of SFB (generell mit Bausteinen) nicht!
    Ich glaube aber das es mit ST von Codesys möglich ist. Zotos weiß das bestimmt.
    @Siemens: Hängt euch rein und ändert das!

    godi

  9. #28
    Registriert seit
    21.09.2004
    Beiträge
    92
    Danke
    6
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Guten Morgen godi,

    wenn du schon so früh da bist:

    Warum wandelst du erst alles in WORD? Warum kann man nicht auf Byte Ebene arbeiten?

    Echt mist, dass das mit dem Array auf SFB4 Type nicht geht. Man könnte ein struct erstellen, das dem type von SFB4 entspricht, oder?

  10. #29
    Registriert seit
    03.01.2006
    Ort
    Im sonnigen Süden von Österreich!
    Beiträge
    1.377
    Danke
    227
    Erhielt 183 Danke für 168 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Wegen den AT Befehl wandle ich alles in Word.
    lese hier http://www.sps-forum.de/showthread.php?t=15026

    Ja Vielleicht kommst ja noch auf ne bessere Lösung mit dem SFB 4! Wie gesagt bin selbst noch am herumprobieren mit SCL.

Lesezeichen

Berechtigungen

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