Fifo S7

FUNCTION_BLOCK FB 100
TITLE =FIFO
VERSION : 0.1

VAR_INPUT
  Reset : BOOL ; 
  Write_Into : BOOL ; 
  Read_From : BOOL ; 
  Write_Val : INT ; 
END_VAR
VAR_OUTPUT
  Error : BOOL ; 
  Reset_OK : BOOL ; 
  Write_OK : BOOL ; 
  Read_OK : BOOL ; 
  Read_Val : INT ; 
END_VAR
VAR
  int_Read_OK : BOOL ; 
  int_Write_OK : BOOL ; 
  Read_Index : INT ; 
  Write_Index : INT ; 
  Daten_Puffer : ARRAY  [1 .. 100 ] OF INT ; 
END_VAR
VAR_TEMP
  hPointer : DWORD ; 
END_VAR

BEGIN
NETWORK
TITLE = 
      SET   ; 
      R     #Error; 
NETWORK
TITLE =Reset
      U     #Reset; 
      SPBN  nRes; 
      L     0; 
      T     #Read_Index; 
      T     #Write_Index; 
nRes: U     #Reset; 
      =     #Reset_OK; 
NETWORK
TITLE =Wert eintragen
      U     #Write_Into; 
      UN    #int_Write_OK; 
      SPBN  nWri; 
// Zeiger erhöhen
      L     #Write_Index; 
      L     1; 
      +I    ; 
      T     #Write_Index; 
// Zeiger > max ?
      L     #Write_Index; 
      L     100; 
      <I    ; 
      SPB   Wri1; 
      L     1; 
      T     #Write_Index; 
Wri1: L     #Write_Index; 
      L     #Read_Index; 
      >=I   ; 
      SPB   Err; 
      L     #Write_Index; 
      L     1; 
      -I    ; 
      SLD   4; 
      L     P##Daten_Puffer; 
      +D    ; 
      T     #hPointer; 
      L     #Write_Val; 
      T     DIW [#hPointer]; 
nWri: U     #Write_Into; 
      =     #int_Write_OK; 
      =     #Write_OK; 
NETWORK
TITLE =Wert auslesen
      U     #Read_From; 
      UN    #int_Read_OK; 
      SPBN  nRea; 
// Zeiger erhöhen
      L     #Read_Index; 
      L     1; 
      +I    ; 
      T     #Read_Index; 
// Zeiger > max ?
      L     #Read_Index; 
      L     100; 
      <I    ; 
      SPB   Rea1; 
      L     1; 
      T     #Read_Index; 
Rea1: L     #Read_Index; 
      L     #Write_Index; 
      >=I   ; 
      SPB   Err; 
      L     #Read_Index; 
      L     1; 
      -I    ; 
      SLD   4; 
      L     P##Daten_Puffer; 
      +D    ; 
      T     #hPointer; 
      L     DIW [#hPointer]; 
      T     #Read_Val; 
nRea: U     #Read_From; 
      =     #int_Read_OK; 
      =     #Read_OK; 
      BEA   ; 
NETWORK
TITLE =---
Err:  SET   ; 
      S     #Error; 
END_FUNCTION_BLOCK

FUNCTION_BLOCK FB50
VAR_INPUT
  // Eingangs Variablen
  xWrite       :BOOL;   (* Es wird ein Wert in dem FIFO-Speicher geschrieben  *)
  XRead        :BOOL;   (* Es wird ein Wert aus dem FIFO-Speicher gelesen     *)
  wStore       :WORD;   (* Wert der in dem FIFO-Speicher abgelegt werden soll *)
  xReset       :BOOL;   (* Der FIFO-Speicher wird Resetet  *)
END_VAR

VAR_OUTPUT
  // Ausgangs Variablen
  wValue       :WORD;  (* Wert, der aus dem FIFO-Speicher gelsesen wurde      *) 
  iCount       :INT;   (* Anzahl der gespeicherten Werte                      *)
  xOverflow    :BOOL;  (* FIFO-Überlauf *)
  xUnderflow   :BOOL;  (* FIFO-Unterlauf *)
END_VAR

VAR
  // statische Variablen
  myData        :ARRAY[0..199] OF WORD; (* Der FIFO-Speicher                  *)
  myWriteIndex  :INT:=0; (* Index zum Schreiben der neuen Daten               *)
  myReadIndex   :INT:=0; (* Index zum Lesen der gespeicherten Daten           *)
  myFPWrite     :BOOL;   (* Flanken erkennung zum schreiben von Daten         *)
  myFPRead      :BOOL;   (* Flanken erkennung zum lesen von Daten             *)
END_VAR
  // Anweisungsteil  
  IF xWrite AND NOT myFPWrite THEN           (* Flankenerkennung neue Daten schreiben *)
    IF iCount < 199 THEN                     (* Ist Platz im FIFO-Speicher ? *)
      myData[myWriteIndex] := wStore;        (* Speichern des neuen Werts *)
      myWriteIndex := myWriteIndex + 1;      (* "Zeiger" auf die nächste Speicherzelle schieben *)
      iCount := iCount + 1;                  (* Anzahl der gespeicherten Werte erhöhen *)
      IF myWriteIndex > 199 THEN             (* "Zeiger" überlauf wieder bei 0 beginnen *)
        myWriteIndex := 0;
      END_IF;    
    ELSE
      xOverflow := TRUE;                     (* FIFO-Überlauf melden *)
    END_IF;
  END_IF;
  myFPWrite := xWrite;                       (* Speicher für die Flanken erkennung *)
  IF xOverflow THEN                          (* FIFO-Überlauf Meldung rücksetzen *)
    xOverflow := xWrite;                 
  END_IF;
  
  
  IF xRead AND NOT myFPRead THEN             (* Flankenerkennung Daten lesen *)      
    IF iCount > 0 THEN                       (* Sind Daten im FIFO-Speicher ? *)
      wValue := myData[myReadIndex];         (* Wert aus Speicher an den Ausgang legen *)
      myReadIndex := myReadIndex + 1;        (* "Zeiger" auf die nächste Speicherzelle schieben *)
      iCount := iCount - 1;                  (* Anzahl der gespeicherten Werte reduzieren *)
      IF myReadIndex > 199 THEN              (* "Zeiger" überlauf wieder bei 0 beginnen *)
        myReadIndex := 0;
      END_IF;      
    ELSE
      wValue := 0;                           (* Wenn keine Daten vorhanden immer 0 ausgeben *)
      xUnderflow := TRUE;                    (* FIFO-Unterlauf melden *)
    END_IF;
  END_IF;    
  myFPRead   := xRead;                       (* Speicher für die Flanken erkennung *)
  IF xUnderflow THEN                         (* FIFO-Unterlauf Meldung rücksetzen *)
    xUnderflow := xRead;                 
  END_IF;
 
  
  IF xReset THEN                             (* FIFO Reseten *)
    myWriteIndex         := 0;
    myReadIndex          := 0;
    iCount               := 0;
  END_IF;
 
END_FUNCTION_BLOCK