DI's entprellen

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?
 
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!
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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
 
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! :rolleyes:

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
 
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! :rolleyes:

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:-D

Gruß
Küffel
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
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?
 
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! :twisted:
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
 
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?
 
Zurück
Oben