Parameterizing the Siemens LGF_FIFO Function Block in TIA Portal for S7-1200/S7-1500

The Library of General Functions (LGF) for STEP 7 (TIA Portal) and S7-1200/S7-1500 provides a curated set of type-licensed function blocks that implement common automation primitives. Among them, the LGF_FIFO family delivers a complete first-in / first-out buffer without requiring the engineer to manually maintain head/tail pointers, ring indices, overflow/underflow checks, or shift logic. The full LGF reference, with the FIFO description starting on page 46, is published by Siemens as support entry 109479728.

This article covers the end-to-end parameterization of LGF_FIFO: library installation, selection of the correct typed variant, interface pinning, mode selection, status/error handling, sample SCL call, and verification with PLCSIM. A typical application - a queue of floor requests in a multi-floor elevator - is used as the recurring example because it is the canonical reason engineers reach for a FIFO: the order in which events arrive must drive the order in which they are processed.

1. Overview of the LGF_FIFO Family

A FIFO buffer is a queue that releases elements in the same order they were inserted. In STEP 7 (TIA Portal) the LGF implements it as a function block that owns a typed ARRAY in its Static section, exposes mode, execute, and entry inputs on the block interface, and returns a count plus status on the output side. Because the storage is part of the FB instance, calling the FB with two different instance DBs creates two independent queues that share no data - this is the standard mechanism for parallel buffers in S7-1200/S7-1500 user programs.

The LGF offers one FIFO block per elementary data type, plus a generic AnyDB variant. The full list visible in the LGF master copy library is shown below.

Use the typed variants whenever the queued payload is a single elementary type. Reach for LGF_FIFO_AnyDB only when the payload is a STRUCT, UDT, or has a non-uniform length - AnyDB requires a DB handle, an offset, and a length, which adds parameterization complexity.

2. Prerequisites

Before parameterizing the block, confirm that the engineering environment satisfies the requirements below. Mismatched firmware / TIA Portal versions are the most common cause of type-version conflict compiler errors when pulling in a library master copy.

3. Installing the LGF Library

1. Open the project in TIA Portal and switch to the Libraries task card on the right side of the project view.
2. Click Open global library and browse to the downloaded .al1x file (LGF for STEP 7 TIA Portal Vxx).
3. Once the library opens, expand Types > LGF (Library of General Functions) > FIFO & LIFO to expose all LGF_FIFO_* and LGF_LIFO_* master copies.
4. Select the variant that matches the desired payload type. For a queue of integer floor numbers (elevator example), use LGF_FIFO_Int. Drag and drop it into the Program blocks folder of the S7-1200/S7-1500 CPU in your project tree.
5. Confirm the dialog Insert FB / Instance. TIA Portal prompts to create the instance DB automatically; accept with the default name (e.g. LGF_FIFO_Int_DB) or rename per naming convention.
6. Compile the program blocks (Hardware > Compile > Software). The master copy is referenced symbolically through the instance DB.

After installation, the project tree will contain:

• Program blocks > LGF_FIFO_Int [FBxxxx] - the master copy, type-licensed.
• Program blocks > LGF_FIFO_Int_DB [DBxxxx] - the instance DB, holds the actual ARRAY storage and any FB-static tags.

4. FB LGF_FIFO Interface Architecture

Every typed variant follows the same interface layout. The differences are limited to the data type of the entry input and the buffer static. The table below summarizes the public interface of the typed variants (e.g. LGF_FIFO_Int); verify exact names against the LGF documentation page referenced at the top of this article.

5. Selecting and Resizing the Buffer

The buffer size is governed by the array bound declared in the FB's Static section. The LGF master copy ships with a default of ARRAY[0..100] for the typed variants, which equals 101 elements. The exact default is visible in the project tree when the FB is expanded.

To resize the buffer:

1. Open the instance DB (e.g. LGF_FIFO_Int_DB). With Optimized block access enabled, switch to the data view to see the symbolic buffer.
2. Open the master copy FB (right-click the FB > Open), navigate to the Static section, and locate the buffer array declaration. Change the upper bound (for example from 100 to 49 for a 50-element queue).
3. Save and recompile. The instance DB inherits the new array bound on the next Compile.
4. Verify the change in the instance DB: the symbol should now show the new dimension, and the DB's overall byte size must grow/shrink accordingly.

For an elevator with eight floors plus basement, a 50-element buffer is ample for a typical cabin request queue; a 16-element buffer is sufficient for single-elevator control. The LGF itself does not enforce a hard upper limit, but instance DB size is bounded by the CPU's work memory. The S7-1500 manual confirms work memory limits per CPU; consult the relevant Siemens product support entry for your specific CPU order number before sizing the buffer to thousands of elements.

6. Operating Modes (mode parameter)

The mode input selects the operation. The LGF documents a numeric set of mode constants. Always pass the symbolic name where possible (e.g. LGF_FIFO_MODE_INSERT) rather than raw integers, because the underlying numeric value can change between LGF revisions. The table below lists the canonical modes as documented for the typed FIFO blocks.

Some LGF revisions also expose MODE_INSERT_MULTI and MODE_REMOVE_MULTI for batched operations, accepting a count on a separate input. Where these are not present, batching is implemented by repeatedly calling the FB in a loop from the caller's SCL code.

7. Status and Error Codes

The status output carries a 16-bit code. Success is reported as 16#0000 and done = TRUE. The error output is the binary OR of any non-success condition. Standard error categories documented in the LGF include:

8. Step-by-Step Parameterization Procedure

The following procedure produces a working LGF_FIFO_Int instance, inserts a tag, retrieves it, and verifies the result with a watch table. It assumes an S7-1500 CPU but applies identically to S7-1200.

8.1 Declare the project-side data

1. Create a global DB Data_FIFO with optimized block access. Add the following tags:
   • iqFloorRequest   INT   - in-tag: floor number requested from the cabin panel.
   • qServicedFloor   INT   - out-tag: floor number to be serviced next.
   • iEnableInsert   BOOL   - rising edge triggers an insert.
   • iEnableRemove   BOOL   - rising edge triggers a remove.
   • qFifoDone   BOOL
   • qFifoError   BOOL
   • qwFifoStatus   WORD
   • qdFifoCount   DINT
2. Compile Data_FIFO.

8.2 Place the FB and wire the instance

1. Drag LGF_FIFO_Int from the LGF global library into Program blocks. Accept the prompt to create LGF_FIFO_Int_DB as the instance DB.
2. Open OB1 (or the cyclic OB where elevator logic runs) and drop a new instance call. TIA Portal will show the FB interface; the field boxes accept symbolic tags or absolute addresses.
3. Wire the inputs/outputs as shown in the call mapping below.

Two separate calls in the same OB are acceptable because the LGF uses execute as an edge; they will not collide if iEnableInsert and iEnableRemove are mutually exclusive. If simultaneous insert and remove is required, the caller must arbitrate using count and the empty/full boundary checks described in Section 7.

8.3 SCL implementation snippet

The following SCL block shows a clean parameterized call from inside an FB or OB. It demonstrates a single call with the mode selected at runtime, which is a common pattern when the caller wants to economize on multi-instance data.

// SCL example - single parameterized FIFO call
#iTempMode := LGF_FIFO_MODE_REMOVE; // or LGF_FIFO_MODE_INSERT

LGF_FIFO_Int_DB(
    execute := #bExecute,
    mode    := #iTempMode,
    entry   := #iPayload,
    done    => #bDone,
    error   => #bError,
    status  => #wStatus,
    count   => #diCount);

IF #bError THEN
    // Persistent log; do not just clear
    "HmiLog".FifoLastStatus := #wStatus;
END_IF;

When the LGF is used inside a multi-instance parent FB, drop LGF_FIFO_Int_DB as a multi-instance under the parent's Static section. TIA Portal will create a STAT instance of type LGF_FIFO_Int that shares the parent's instance DB - this is the recommended pattern for libraries of queues (one queue per axis, per channel, per machine module).

8.4 LAD / FBD implementation

For ladder logic, place the FB call box, then click the small Instance DB drop-down to choose LGF_FIFO_Int_DB. Tag the inputs and outputs as in the table. The mode input can be wired to a constant or to an INT tag controlled by a selector contact network (e.g. MOVE box loaded with the symbolic constant when a particular path is active).

9. Verification with PLCSIM

PLCSIM (V15.1 or later, matching the TIA Portal version) lets the engineer exercise the FIFO offline before downloading to a real CPU. The verification sequence below is sufficient to catch the most common parameterization mistakes (wrong mode, array bound out of range, instance DB not generated).

1. Start PLCSIM and load the project. Run the simulation to RUN.
2. Open Data_FIFO in the watch table and force iEnableInsert := FALSE, iEnableRemove := FALSE, iqFloorRequest := 3.
3. Set iEnableInsert := TRUE for one scan. Confirm qFifoDone = TRUE, qFifoError = FALSE, qwFifoStatus = 16#0000, qdFifoCount = 1.
4. Insert two more values (e.g. 5, 2) the same way. Confirm qdFifoCount = 3 after each insert.
5. Set iEnableInsert := FALSE; set iEnableRemove := TRUE for one scan. Confirm qServicedFloor = 3 (oldest first) and qdFifoCount = 2.
6. Repeat remove until empty; on the next remove with empty queue, confirm qFifoError = TRUE and qwFifoStatus matches the empty-buffer code from Section 7.
7. Force insert past the array bound (repeat the previous test more times than the buffer size). Confirm buffer-full status code is reported and qdFifoCount caps at the configured size.
8. Set iEnableRemove := FALSE, mode to LGF_FIFO_MODE_RESET, drive execute once. Confirm qdFifoCount = 0 and no error.

If any step fails, jump to Section 11 to identify the parameterization mistake.

10. Performance and Resource Considerations

The LGF FIFO is implemented in SCL. Insert and remove are O(1) operations: a single head/tail index update plus one assignment. The execution time is dominated by the array bound check the FB performs internally. On a representative S7-1500 CPU (CPU 1515-2 PN, firmware V2.9) the typical call-time for a 100-element LGF_FIFO_Int is in the low microsecond range; on S7-1200 (CPU 1215C, firmware V4.4) it is in the tens of microseconds. The exact value depends on the firmware revision and the number of user programs competing for OB1 time - measure it with the Runtime measurement in the TIA Portal online view if deterministic cycle time is required.

Memory cost is dominated by the array. A LGF_FIFO_Real with 1,000 elements consumes approximately 4 KB of instance DB memory; the same for LGF_FIFO_String with STRING[254] consumes roughly 256 KB. Plan the work-memory budget accordingly and consider LGF_FIFO_AnyDB for very large or variable-length payloads - the AnyDB variant stores elements contiguously in a caller-supplied DB and can be sized without recompiling the FB.

11. Common Parameterization Errors and Edge Cases

12. Special Topic: LGF_FIFO_AnyDB

For STRUCT or UDT payloads - for example, a queue of "typeFloorRequest" with fields floor : INT, priority : INT, timestamp : DINT - the typed variants are insufficient. LGF_FIFO_AnyDB stores elements of arbitrary type in a caller-provided DB. The parameterization differs:

• handle   DWORD   - the DB handle returned by DB_ANY_TO_VARIANT or by the SCL DB reference operator.
• offset   DINT   - byte offset of the storage region within the target DB.
• length   DINT   - number of elements in the region.
• elementSize   DINT   - size of one element in bytes (SCL SIZEOF).
• entry   VARIANT   - typed view onto the element being inserted or retrieved.

When the target DB is optimized, the offset and size must still be expressed in bytes from the start of the DB's data view. Symbolic offsets cannot be passed directly to the FB; the caller computes them in the OB1 cyclic code using SIZEOF and a base-offset constant. Misalignment between elementSize and the actual UDT size is the single largest source of AnyDB parameterization bugs - always log both to the HMI for the first 100 cycles of commissioning.

13. Integration Patterns

13.1 Multi-instance for repeating equipment

When one PLC controls multiple elevators, conveyors, or machines, declare a parent FB typeElevatorControl with a static instance of LGF_FIFO_Int. Each instance DB of typeElevatorControl then carries its own private queue. Memory overhead per instance is small (the array bound dominates), and the call site becomes a single multi-instance call instead of N global DBs.

13.2 HMI mirroring

Mirror count and status to the HMI for diagnostics. Do not mirror the entire buffer array to the HMI on a polling tag list - the cyclic load will degrade OB1 performance. Use a recipe-style HMI read on demand, or expose only the head/tail of the queue.

13.3 Restart / cold-start behavior

Instance DBs with optimized block access have a configurable retain property. The buffer is normally non-retain because a stale floor request is unsafe after a CPU restart; clear the Set in IDB retain bit on the buffer static and on the index tags. After a power-on, the FB will report an empty queue and the elevator will wait for new requests - which is the desired behavior.

13.4 Safety / F-CPU considerations

The LGF itself is not F-certified. In a safety-related elevator application, the FIFO may be used for standard floor request arbitration, while the safety chain (door lock, overspeed, level stop) runs in the F-runtime and is implemented with F-typed blocks. Do not pass a non-safety FIFO output to a safety tag without an F-capable input filter.

14. Field-Proven Checklist

Before signing off a parameterized LGF_FIFO application, confirm each item below. The checklist is intentionally short - each line represents a category of failure observed in field commissioning.

• Master copy version recorded in the project change log.
• Instance DB Optimized block access setting matches the rest of the program.
• buffer upper bound verified to match the application requirement.
• mode input wired to symbolic constants, not raw integers.
• Caller latches done, error, and status on the same scan and resets execute only after observing them.
• Buffer-full and buffer-empty conditions are handled in the calling OB - the application does not silently ignore them.
• Watch-table dry run executed in PLCSIM, with the worst-case sequence (insert beyond capacity, remove from empty).
• Retain attributes on buffer and on the index tags are cleared for non-retain semantics.
• HMI diagnostic shows count and status on a dedicated diagnostics screen.
• Fallback behavior on power-on is documented in the operating manual (empty queue, no movement until new request).

15. Summary

The LGF LGF_FIFO blocks remove a large amount of boilerplate from PLC programs that need queued data. By selecting the typed variant that matches the payload, wiring the public interface to symbolic project tags, and verifying the edge-triggered behavior in PLCSIM, the engineer gains a queue that is documented, type-licensed, and supported through the Siemens support channel. For STRUCT/UDT payloads, the LGF_FIFO_AnyDB variant covers the same use case at the cost of additional parameterization around the DB handle, offset, length, and element size. The official reference for the family is Siemens support entry 109479728 and should be consulted for the exact status code values, mode constants, and library revision notes of the LGF currently deployed in your engineering environment.

FAQ