FUNCTION "FifoReset" : Void
TITLE = Fifo-Modul
{ S7_Optimized_Access := 'FALSE' }
AUTHOR : IBAE
FAMILY : FIFO
NAME : FifoIn
VERSION : 0.1
//COPYRIGHT by Ingenieurbüro A.Emmert
//Ortsstr.33, D-869925 Fuchstal (Germany)
//Tel.: 0049(0)8243-1254
//Version: ILS2100 / 06.11.2009
//
//Fifo resetten
//SSDB:    FIFO-DB
//SSDW:    FIFO-1.DW
//PARA:    Aufrufparameter 00XX:
//     XX:  00 = Normaler FIFO (alles löschen)
//          D0 = Durchlaufspeicher (alles mit Nullen füllen)
//          D1 = Durchlaufspeicher (alles mit FFFF füllen)
// Rückmeldungen:
//   Bit0: Kein Fifobereich / falscher Kopfinhalt / Endekennung
//   Bit1: SFC20-Aufruf mit Fehler
//   Bit2: Frei
//   Bit3: Frei
//   Bit4: Frei
//   Bit5: Frei
//   Bit6: Frei
//   Bit7: Frei
//
   VAR_INPUT 
      SSDB : Int;   // Schnittstellen-DB
      SSDW : Int;   // Schnittstellen-1.DW
      PARA : Word;   // Aufrufparameter (Durchlaufspeicher?)
   END_VAR

   VAR_OUTPUT 
      RE_VAL : Byte;   // Rückmeldung
   END_VAR

   VAR_TEMP 
      Quelle : Any;   // Zeiger, wo Rein-Daten sind
      Kopf : Byte;   // Fifo-Kennung (FF)
      Datensatzlaenge : Byte;   // Datensatzlänge in Word (1 - 128)
      FifoLaenge : Int;   // Länge des Fifo (maximale Anzahl der Datensätze)
      Bringzeiger : Int;   // Zeiger, wohin nächster Eintrag gespeichert wird
      Holzeiger : Int;   // Zeiger, woher nächste Daten geholt werden
      Anzahl : Int;   // Anzahl der Datensätze (eingetragene)
      Status : Word;   // Status des Fifo
      DBFifo : Word;   // FIFO-DB
      SFC_RET_VAL : Int;   // Rückmeldung SFC-Aufruf
      SFC_DB_LENGTH : Word;   // Rückmeldung SFC-Aufruf
      Fifo_Ende : Word;   // Ende des Fifo
      Schleife : Word;   // Loopzähler
      SFC_WRITE_PROT : Bool;   // Rückmeldung SFC-Aufruf
   END_VAR


BEGIN
NETWORK
TITLE = Schnittstellen-DB sinnvoll ?
      L #SSDB;
      T #DBFifo;

//      CALL  TEST_DB
//         DB_NUMBER  :=#DBFifo
//         RET_VAL    :=#SFC_RET_VAL
//         DB_LENGTH  :=#SFC_DB_LENGTH
//         WRITE_PROT :=#SFC_WRITE_PROT

      CALL "TEST_DB_TO_ATTR_DB"
      (  DB_Number                   := #DBFifo , 
         RetVal                      := #SFC_RET_VAL , 
         DB_Length                   := #SFC_DB_LENGTH , 
         Write_Prot                  := #SFC_WRITE_PROT
      );

      L #SFC_RET_VAL;
      L 2#0000_0000_0000_0000;
      <>I;
      O #SFC_WRITE_PROT;
      SPB Err0;//kein Fifobereich

NETWORK
TITLE = Fifokopfdaten holen
//Quelle-Pointer erzeugen:
      L 16#1004;//Kennung 10 + Word=04
      T %LW0;//Any-Kennung, Datentyp
      L 16#0006;//6 Dw´s holen
      T %LW2;//Wiederholungen
      L #SSDB;
      T %LW4;//DB_Nummer
      L #SSDW;//Adresse
      SLD 3;
      L 16#8400_0000;//Kennung: Daten
      OD;
      T %LD6;//Kennung, Adresse

      CALL BLKMOV//1.-6.DW FIFO holen
      {blk_type := 'Variant'}
      (  SRCBLK                      := #Quelle , 
         RET_VAL                     := #SFC_RET_VAL , 
         DSTBLK                      := P#L10.0 WORD 6
      );

      L #SFC_RET_VAL;
      L 2#0000_0000_0000_0000;
      <>I;
      SPB Err1;

NETWORK
TITLE = Zeigerüberprüfung
      L #Kopf;//Fifo-Kopf
      L 16#FF;//= Fifokennung ?
      <>I;//Nein !
      SPB Err0;//kein Fifobereich

      L 1;
      L #Datensatzlaenge;//Datenblocklänge
      >I;
      SPB Err0;//kein Fifobereich

      L 128;
      >I;
      SPB Err0;//kein Fifobereich

      L 1;
      L #FifoLaenge;//Max.Anzahl von Datenblöcken
      >I;
      SPB Err0;//kein Fifobereich

      L #FifoLaenge;//Länge FIFO (in Word)
      L #Datensatzlaenge;//Datenblocklänge
      *I;
      L 2;//DB byteorientiert
      *I;
      + 40;//Speichern ab 20.DW
      L #SSDW;
      +I;
      T #Fifo_Ende;
      SLW 3;//Pointer erzeugen
      LAR1;

      AUF DB[ #DBFifo];

      L #Fifo_Ende;
      L #SFC_DB_LENGTH;
      >I;//Fifo-DB ist zu kurz!
      SPB Err0;//kein Fifo-Bereich

      L DBW[ AR1, P#0.0];
      L 16#FFEE;//Fifo-Endekennung ?
      <>I;//Nein !
      SPB Err0;//kein Fifobereich

NETWORK
TITLE = Fifo-Daten löschen
      L #SSDW;
      + 4;//Ab 2.Dw
      SLW 3;//Pointer erzeugen
      LAR1;

      AUF DB[ #DBFifo];

      L #Datensatzlaenge;
      L #FifoLaenge;
      *I;
      + 18;//18 Datenwörter (wortorientiert)
L400:      T #Schleife;

      L 0;
      T DBW[ AR1, P#0.0];

      +AR1 P#2.0;

      L #Schleife;
      LOOP L400;


NETWORK
TITLE = Durchlaufspeicher ?
      L #PARA;//Aufrufparameter 
      SRW 4;
      L 16#000D;//Durchlaufspeicher ?
      <>I;//Nein !
      SPB N006;

      L #SSDW;
      + 4;//Speichern ab 4.DW
      SLW 3;//Pointer erzeugen
      LAR1;

      AUF DB[ #DBFifo];

      L #SSDW;
      + 40;//1.Speicherzelle
      T DBW[ AR1, P#0.0];//Bringzeiger
      T DBW[ AR1, P#2.0];//Holzeiger

      L #FifoLaenge;//Fifo ist voll
      T DBW[ AR1, P#4.0];//Anzahl

      L #PARA;//Aufrufparameter 
      L 16#00D1;//Durchlaufspeicher mit FFFF füllen
      <>I;//Nein !
      SPB N006;

      L #FifoLaenge;//Fifo ist voll
      T DBW[ AR1, P#8.0];//1.Zusatz-Dw (Anzahl der Daten)

      L 2#0000_0000_0000_0011;//Daten vorhanden/kommen raus
      T DBW[ AR1, P#14.0];//4.Zusatz-Dw (Status)

      L #SSDW;
      + 40;//Ab 20.Dw
      SLW 3;//Pointer erzeugen
      LAR1;

      AUF DB[ #DBFifo];

      L #Datensatzlaenge;
      L #FifoLaenge;
      *I;
L500:      T #Schleife;

      L 16#FFFF;
      T DBW[ AR1, P#0.0];

      +AR1 P#2.0;

      L #Schleife;
      LOOP L500;

NETWORK
TITLE = Fehlerausgabe / RET_VAL
N006:      SET;//VKE = 1 ohne Fehler !!!
      L 2#0000_0000_0000_0000;
      SPA Ok;
Err0:      L 2#0000_0000_0000_0001;//Kein Fifobereich
      SPA Err;
Err1:      L 2#0000_0000_0000_0010;//SFC20-Aufruf mit Fehler

Err:      CLR;//VKE = 0 bei Fehler !!!
Ok:      T #RE_VAL;

      SAVE;//VKE in BIE-Bit speichern  

END_FUNCTION

