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

My implementation of circular FIFO based on example from help. It will work with any datatype.

This very basic code but i hope this gives you idea how its works

For more details look on screenshots in attached file

IF NOT #getBufSize THEN
#buffer_size := CountOfElements(#Buffer);
#getBufSize := TRUE;
END_IF;


IF #FlushBuf THEN
#tail := 0;
#head := 0;
#count := 0;
#FlushBuf := FALSE;
END_IF;

IF #Enqueue THEN
IF #count < #buffer_size THEN
#internalError :=
MOVE_BLK_VARIANT(SRC := #Enqueue_Data,
COUNT := 1,
SRC_INDEX := 0,
DEST_INDEX := #tail,
DEST => #Buffer);
#count := #count + 1;
#tail := #tail + 1;
IF #tail = #buffer_size THEN
#tail := 0;
END_IF;
END_IF;
END_IF;

IF #Dequeue THEN
IF #count > 0 THEN
#internalError := MOVE_BLK_VARIANT(SRC := #Buffer,
COUNT := 1,
SRC_INDEX := #head,
DEST_INDEX := 0,
DEST => #Dequeue_Data);
#count := #count - 1;
#head := #head + 1;
IF #head = #buffer_size THEN
#head := 0;
END_IF;
END_IF;
END_IF;

In the Library of General Funtions LGF you will find a FIFO. It's an open block if you want to see how it could be done.

You will find the Libtrary here: https://support.industry.siemens.com/cs/us/en/view/109479728

BR Sven

Hi

You can use method from mine moving average calculation:

1. data block  - array with length as Your FIFO

2. on new data:

a. Buffer[Pointer]-->Output;

b. Buffer[Pointer]:=New_Data;

c. Pointer++;

d. if (Pointer>=FIFO_Len)  Pointer:=0;

e. Sum:=Sum+New_Data-Output;

f. Average:=Sum/FIFO_Len;

in this example Buffer is Array[0..FIFO_LEN-1]

the e. and f. are required if you want to use FIFO for calculating average over FIFO_Len entries.

if you have it as Integer and are using CALCULATE function choose DINT under Calculate

to prevent arithmetic overflow.

UPDATE: New method of implementing circular buffer using modulo operator

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);

 It can be rewritten in the form of arbitrary buffer lenghth using modulo operation, to get rid of AND masking the buffer length of 2^N.

CONST
BuffLen:=20;
END_CONST

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


IF WriteCmd THEN //write cmd
FIFO[WR_Pointer]:=SomethingInput;
WR_Pointer:=(WR_Pointer+1) % 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
SomethingOutput:= FIFO[RD_Pointer];
RD_Pointer:=(RD_Pointer+1) % BuffLen);
END_IF;

BuffSize:=(WR_Pointer-RD_Pointer + BuffLen) % BuffLen); //using modulo to calculate fill size

I am attaching my implementation of a circular queue (or FIFO). Is very simple and if you want different size buffer just change the array size of the queue datatype and update the MaxSize tag. 

Ask if you have any question using this queue.

Attachment extension: .zap14

New question published by Muralimohan is split to a separate thread with the subject Programm for tanks that had to be shifted.

Best regards
Jen_Moderator