S7-1200 TIA Portal FIFO implementation

I don't know the actual possibility of S7-1200 about arrays, but I can give you a sample in scl for S7-300/400 how I implement FIFO:

CONST
   BuffLen:=15; //must be 2^N-1 in order to work
END_CONST

VAR
   FIFO[0..BuffLen] OF DINT;
   RD_Pointer:DINT;
   WR_Pointer:DINT;
END_VAR


IF WriteCmd THEN //write cmd
   FIFO[WR_Pointer]:=Something;
   WR_Pointer:=DWORD_TO_DINT(DINT_TO_DWORD(WR_Pointer+1) AND BuffLen);//increment write pointer
   IF (WR_Pointer=RD_Pointer) THEN
       BuffOverrun:=true;
   END_IF;
END_IF;

IF ReadCmd AND (WR_Pointer<>RD_Pointer) THEN // read cmd
   Something:= FIFO[RD_Pointer];
   RD_Pointer:=DWORD_TO_DINT(DINT_TO_DWORD(RD_Pointer+1) AND BuffLen);
END_IF;

BuffSize:=DWORD_TO_DINT(DINT_TO_DWORD(WR_Pointer-RD_Pointer) AND BuffLen);

Hello.

Here i managed to write my own SCL code to implement a FIFO pop function (get the first element from the pile). To get the first element you just have to get the first index of the array, but the hard part was to move the entire pile once you get that element. Here is my code (FC function) with a previos description of the variables:

Variables used:

- Some Data Block (this could be any DB in order to create an array inside)

- FIFO (an array of N element, could be ints, strings, or whatever needed to manage the FIFO)

- N (auxiliar variable to keep reading the array)

- WR_Pointer (saves the actual free position of the array, so you know where to save the next element)

- FirstElement (aux variable to catch the first element in the pile)

IF "Some Data Block".FIFO[0] <> 0 THEN    // if you have something in the first element
   
    IF "Some Data Block".FIFO[1] <> 0 THEN // if you have something in the second element
       
        "Some Data Block".N := 1;  // initializes the auxiliar counter from 1
        "Some Data Block".FirstElement := "Some Data Block".FIFO[0];  // catchs the first element
       
        WHILE "Some Data Block".FIFO["Some Data Block".N] <> 0 DO //  while you have elements in the pile
           
            "Some Data Block".FIFO["Some Data Block".N - 1] := "Some Data Block".FIFO["Some Data Block".N];   // takes the actual value to the previous position
            "Some Data Block".N := "Some Data Block".N + 1; //  increment counter
           
        END_WHILE;
       
        "Some Data Block".FIFO["Some Data Block".N - 1] := 0; // when you finish reading the array, resets the last position
        "Some Data Block".WR_Pointer :"Some Data Block".WR_Pointer - 1;  // moves one position backward the pointer, as you poped an element... now the free position to push new data changed in one unit.
       
       
    ELSE  //  if there is only one element in the pile
       
        "Some Data Block".FIrstElement := "Some Data Block".FIFO[0];  // catchs the first element
        "Some Data Block".FIFO[0] := 0; // resets the first element, as is the only one in the pile
        "Some Data Block".WR_Pointer := 0; // resets the pointer as the pile is empty now
       
        END_IF;
       
       
       
    ELSE // if there is nothing in the pile
       
        "Some Data Block".FirstElement := 0; // the pile is empty, so you catch nothing
       
       
       
       
   
   
    END_IF;

That was the POP function. Now the Push function is a lot easier (add an element in the pile):

"Some Data Block".FIFO[WR_Pointer] := ElementToAdd; // adds the element in the first free position

WR_Pointer := WR_Pointer + 1; // increment the pointer in one unit, so the next push happens in order.

And thats all, you just have to call the FC's when required to save info. Its important to call them with positive rise of a bit value, If not,  its called in repeat mode.. and of course you don't want that to happen.

Please try

----------------Start Function---------------------------------------------------------------------

FOR #CountIndex := 0 TO 50 DO

    IF #InputInterger[#CountIndex] = 0 THEN

        #FillToStack  := #CountIndex ;

        #CountIndex := 50;

    END_IF;

END_FOR;

FOR #CountIndex := 1 TO #FillToStack DO

    #OutputInteger[#CountIndex-1] := #InputInterger[#CountIndex];

END_FOR;

#OutputInteger[#FillToStack] := #DataToAdd;

----------------Finish Function---------------------------------------------------------------------

Of course it's an static solution. If the array is full and you push an element, the code breaks I guess. It worked for me if you make sure that you keeping popping elements and the array never gets full.

 I cant believe Siemens hasn't a dynamic solution for this. Even the Allen Bradley's PLC's have a FIFO block, which are the shit. 

Hello,

You can find some information here. https://support.industry.siemens.com/cs/ww/en/view/109479728

Freddy