Flankenauswertung in Step7

**PN/DP** · 06.09.2009, 19:10

Frage:
Ich will in Step7 eine Flankenauswertung für ein Eingangswort realisieren. Muß ich
das für jedes Bit einzeln machen oder geht das auch für alle Bits gleichzeitig?

Wenn man eine Aufgabenstellung klar in Umgangsprache ausdrücken kann,
dann findet sich auch leicht der passende Algorithmus zur Lösung.

positive Flanke:
Ist ein Bit jetzt 1 und war im Zyklus vorher 0 ?

Code:

Positive Flanke
Einzelbit             16 Bit auf einmal      16 Bit Beispiel
//Flankenerkennung
U  #Bit_jetzt         L  #Bits_jetzt         L  EW 12
UN #Bit_vorher        L  #Bits_vorher        L  MW 12
                      INVI                   INVI
                      UW                     UW
=  #Flanke_Pos        T  #Flanken_Pos        T  MW 14
//jetzt-Zustand für nächsten Zyklus merken
U  #Bit_jetzt         L  #Bits_jetzt         L  EW 12
=  #Bit_vorher        T  #Bits_vorher        T  MW 12

negative Flanke:
Ist ein Bit jetzt 0 und war im Zyklus vorher 1 ?

Code:

Negative Flanke
Einzelbit             16 Bit auf einmal      16 Bit Beispiel
//Flankenerkennung
UN #Bit_jetzt         L  #Bits_jetzt         L  EW 16
                      INVI                   INVI
U  #Bit_vorher        L  #Bits_vorher        L  MW 16
                      UW                     UW
=  #Flanke_Neg        T  #Flanken_Neg        T  MW 18
//jetzt-Zustand für nächsten Zyklus merken
U  #Bit_jetzt         L  #Bits_jetzt         L  EW 16
=  #Bit_vorher        T  #Bits_vorher        T  MW 16

Für Einzelbits gibt es die speziellen Operationen FP und FN, die machen das genau so,
inklusive merken des Zustands "vorher". Deshalb benötigen diese Operationen einen
Hilfsmerker, der den Zustand "Bit_vorher" speichert.

Code:

Positive Flanke       Negative Flanke
U  #Bit_jetzt         U  #Bit_jetzt
FP #Bit_vorher        FN #Bit_vorher
=  #Flanke_Pos        =  #Flanke_Neg

INVI negiert die unteren 16 Bits im AKKU1 ("dreht" alle Bits um)
einen Befehl "LN Word" (Lade Not Word) analog "UN Bit" gibt es nicht,
als Ersatz dafür nimmt man "L Word" und anschließend "INVI"
UW verknüpft die unteren 16 Bits in AKKU1 mit den unteren 16 Bits im AKKU2 "UND".
Das "UND"-Verknüpungsergebnis für jedes Bit liegt danach in den unteren 16 Bits im AKKU1.
für 32 Bit auf einmal sind die Operationen INVI und UW durch INVD und UD zu ersetzen

Gruß
PN/DP

**PN/DP** · 06.09.2009, 19:12

Ja, das kann man auch in FUP programmieren. Das produziert aber viel zusätzlichen
Code für die FUP-Darstellbarkeit, wenn es in 1 Netzwerk passen soll.
Man kann den Code natürlich auch auf 3 Netzwerke aufteilen.
(wegen der Typprüfung INT <> WORD wird hier INVI durch XOW ersetzt)

Code:

positive Flankenerkennung 16 Bit
          +--------+
          | WXOR_W |
      ...-|EN      |
          |        |
     MW12-|IN1  OUT|-#Temp_Word   +--------+
          |        |              | WAND_W |
W#16#FFFF-|IN2  ENO|--------------|EN      |
          +--------+              |        |
                             EW12-|IN1  OUT|-MW14         +--------+
                                  |        |              |  MOVE  |
                       #Temp_Word-|IN2  ENO|--------------|EN   OUT|-MW12
                                  +--------+              |        |
                                                     EW12-|IN   ENO|-
                                                          +--------+

Code:

positive Flankenerkennung 16 Bit, etwas kürzer
          +--------+              +--------+
   M0.1   |   &    |              | WXOR_W |
 "IMMER1"-|        |-+------------|EN      |
          +--------+ |            |        |
                     |       MW12-|IN1  OUT|-#Temp_Word
                     |            |        |
                     |  W#16#FFFF-|IN2  ENO|-
                     |            +--------+
                     |
                     |            +--------+
                     |            | WAND_W |
                     +------------|EN      |
                     |            |        |
                     |       EW12-|IN1  OUT|-MW14
                     |            |        |
                     | #Temp_Word-|IN2  ENO|-
                     |            +--------+
                     |
                     |            +--------+
                     |            |  MOVE  |
                     +------------|EN   OUT|-MW12
                                  |        |
                             EW12-|IN   ENO|-
                                  +--------+

Code:

negative Flankenerkennung 16 Bit
          +--------+
          | WXOR_W |
      ...-|EN      |
          |        |
     EW16-|IN1  OUT|-#Temp_Word   +--------+
          |        |              | WAND_W |
W#16#FFFF-|IN2  ENO|--------------|EN      |
          +--------+              |        |
                       #Temp_Word-|IN1  OUT|-MW18         +--------+
                                  |        |              |  MOVE  |
                             MW16-|IN2  ENO|--------------|EN   OUT|-MW16
                                  +--------+              |        |
                                                     EW16-|IN   ENO|-
                                                          +--------+

Code:

negative Flankenerkennung 16 Bit, etwas kürzer
          +--------+              +--------+
   M0.1   |   &    |              | WXOR_W |
 "IMMER1"-|        |-+------------|EN      |
          +--------+ |            |        |
                     |       MW12-|IN1  OUT|-#Temp_Word
                     |            |        |
                     |  W#16#FFFF-|IN2  ENO|-
                     |            +--------+
                     |
                     |            +--------+
                     |            | WAND_W |
                     +------------|EN      |
                     |            |        |
                     |       EW12-|IN1  OUT|-MW14
                     |            |        |
                     | #Temp_Word-|IN2  ENO|-
                     |            +--------+
                     |
                     |            +--------+
                     |            |  MOVE  |
                     +------------|EN   OUT|-MW12
                                  |        |
                             EW12-|IN   ENO|-
                                  +--------+

Schöner und kompakter sieht die Darstellung in FUP aus, wenn man für die Flankenerkennung
extra FC schreibt.

FC101 für positive Flankenerkennung 16 Bit

Code:

FUNCTION "P_FLANKE_W" : VOID
TITLE =positive Flankenerkennung 16 Bit
AUTHOR : PN_DP
VERSION : 0.1

VAR_INPUT
  IN : WORD ;   //zu untersuchendes Word
END_VAR
VAR_OUTPUT
  OUT : WORD ;  //Ergebnisword mit den Flanken-Bits
END_VAR
VAR_IN_OUT
  HM : WORD ;   //Hilfsmerker: IN vorher
END_VAR
BEGIN
NETWORK
      L     #IN; 
      L     #HM; 
      INVI  ; 
      UW    ; 
      T     #OUT; 

      L     #IN; 
      T     #HM; 
END_FUNCTION

Code:

positive Flankenerkennung 16 Bit mit FC101 in FUP
     +--------------+
     |    FC101     |
     | "P_FLANKE_W" |
 ...-|EN            |
     |              |
EW12-|IN         OUT|-MW14
     |              |
MW12-|HM         ENO|-
     +--------------+

FC102 für negative Flankenerkennung 16 Bit

Code:

FUNCTION "N_FLANKE_W" : VOID
TITLE =negative Flankenerkennung 16 Bit
AUTHOR : PN_DP
VERSION : 0.1

VAR_INPUT
  IN : WORD ;   //zu untersuchendes Word
END_VAR
VAR_OUTPUT
  OUT : WORD ;  //Ergebnisword mit den Flanken-Bits
END_VAR
VAR_IN_OUT
  HM : WORD ;   //Hilfsmerker: IN vorher
END_VAR
BEGIN
NETWORK
      L     #IN; 
      INVI  ; 
      L     #HM; 
      UW    ; 
      T     #OUT; 

      L     #IN; 
      T     #HM; 
END_FUNCTION

Code:

negative Flankenerkennung 16 Bit mit FC102 in FUP
     +--------------+
     |    FC102     |
     | "N_FLANKE_W" |
 ...-|EN            |
     |              |
EW16-|IN         OUT|-MW18
     |              |
MW16-|HM         ENO|-
     +--------------+

**PN/DP** · 28.01.2021, 19:01

Unterbrechungsfeste Variante für 32 Bit mit Sammelanzeige in AWL:

Code:

FUNCTION "P_FLANKE_D" : DWORD
TITLE =positive Flankenerkennung 32 Bit mit Sammelanzeige
AUTHOR : PN_DP
VERSION : 0.1

VAR_INPUT
  IN : DWORD ;   //zu untersuchendes DWord
END_VAR
VAR_OUTPUT
  OUTX : BOOL ;   //Sammelanzeige irgendein Bit hat eine Flanke
END_VAR
VAR_IN_OUT
  HM : DWORD ;   //Hilfsmerker: IN vorher
END_VAR
BEGIN
NETWORK
      L     #HM;
      L     #IN;
      T     #HM;
      TAK   ;
      INVD  ;
      UD    ;
      T     #RET_VAL; //ErgebnisDword mit den Flanken-Bits
      U     <>0;
      =     #OUTX;    //Sammelanzeige irgendein Bit hat eine Flanke
      SAVE  ;         //Sammelanzeige auch an ENO

END_FUNCTION

... und in TIA SCL:

Code:

FUNCTION "P_FLANKE_D" : DWord
TITLE = positive Flankenerkennung 32 Bit mit Sammelanzeige
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : PN_DP
VERSION : 0.1

   VAR_INPUT
      IN : DWord;   // zu untersuchendes DWord
   END_VAR
   VAR_OUTPUT
      OUTX : Bool;   // Sammelanzeige irgendein Bit hat eine Flanke
   END_VAR
   VAR_IN_OUT
      HM : DWord;   // Hilfsmerker: IN vorher
   END_VAR
   VAR_TEMP
      temp_IN : DWord;
      temp_OUTD : DWord;
   END_VAR

BEGIN

    // im Ergebnis-DWord sind die Bits = 1, deren zugehöriges IN-Bit eine steigende Flanke hat
    // Sammelanzeige an OUTX und ENO: irgendein IN-Bit hat eine steigende Flanke

    #temp_IN := #IN;
    #temp_OUTD := #temp_IN AND NOT (#HM);  //Ermittlung positive Flanken
    #HM := #temp_IN;

    #P_FLANKE_D := #temp_OUTD;        //ErgebnisDword mit den Flanken-Bits
    ENO := #OUTX := #temp_OUTD <> 0;  //Sammelanzeige irgendein Bit hat eine Flanke

END_FUNCTION