Building a Lookup Table in Siemens S7 STEP 7 and TIA Portal

Overview

A lookup table maps an input value (in this case a temperature) to a pre-computed output value (a corresponding setpoint, density, viscosity, pH compensation, or similar process constant). On a Siemens SIMATIC S7-300, S7-400, S7-1200, or S7-1500 controller you implement this as either:

• An SCL array indexed by a fixed index range, with linear or binary search logic in a function block.
• A STEP 7 data block of REAL values accessed by pointer arithmetic in LAD/FBD/STL (classic STEP 7 V5.x).
• The TBL_FIND instruction from the S7-300/S7-400 extended instruction set, which searches a source range for a pattern match.
• The POLYGON function from the Siemens application examples, which linearly interpolates between adjacent table points when the input value falls between two tabulated keys.

This article covers all four approaches for a 40-point temperature table. The first three return an exact match (or no match); the fourth is the correct choice when the process variable can fall between two tabulated values and you need an interpolated output.

Prerequisites

• STEP 7 V5.7 (classic) or TIA Portal V16/V17/V18/V19/V20/V21 with S7-300, S7-400, S7-1200, or S7-1500 CPU firmware compatible with the installed TIA Portal version. See the Siemens TIA Portal version compatibility list.
• S7-SCL compiler license installed (S7-SCL V5.7 for STEP 7 V5.x, or the SCL option integrated in TIA Portal).
• For S7-300/S7-400: the Extended Instructions package containing the table functions (TBL_FIND, Table instructions). The catalog is part of the standard STEP 7 installation; no separate license is required.
• An S7 program in which the analog input is already normalized to engineering units (REAL) and the output is wired to a destination tag that can receive the looked-up REAL value.
• Optional: the OSCAT open-source library (free, no Siemens license) for a pre-built X-Y curve block. Verify the license terms before production deployment.

Method Comparison

Method 1: SCL Array Lookup (TIA Portal)

This is the most maintainable solution on S7-1200 and S7-1500. Define a global data block with two parallel arrays (or one array of a user-defined struct) of length 40, and search by index.

Step 1: Create the data block

In TIA Portal, add a new global DB named DB_Lookup. Inside, declare a structure that holds the input keys (temperatures) and the output values:

DATA_BLOCK "DB_Lookup"
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : EngAuto
FAMILY : Lookup
VERSION : 0.1
  STRUCT
    Key   : ARRAY[1..40] OF REAL;   // Temperature in °C
    Value : ARRAY[1..40] OF REAL;   // Lookup result (engineering units)
  END_STRUCT;
END_DATA_BLOCK

Step 2: Populate the table in a startup OB

Use OB100 (warm restart) or OB101 (hot restart) to load the 40 pairs from the project or from a recipe DB. For fixed tables, hard-code them in OB100:

"DB_Lookup".Key[1]   :=   0.0;  "DB_Lookup".Value[1]  :=   1.000;
"DB_Lookup".Key[2]   :=   5.0;  "DB_Lookup".Value[2]  :=   0.998;
"DB_Lookup".Key[3]   :=  10.0;  "DB_Lookup".Value[3]  :=   0.996;
// ... continue for all 40 points ...
"DB_Lookup".Key[40]  := 195.0;  "DB_Lookup".Value[40] :=   0.879;

Step 3: Implement the lookup function block in SCL

FUNCTION_BLOCK FB_Lookup_Exact
{ S7_Optimized_Access := 'TRUE' }
VAR_INPUT
    iSearchValue : REAL;       // Temperature in °C
END_VAR
VAR_OUTPUT
    oResult      : REAL;       // Value from table
    oIndex       : INT;        // Index of the match (0 = no match)
    oFound       : BOOL;       // TRUE if exact match
END_VAR
VAR
    i            : INT;
END_VAR
BEGIN
    oFound := FALSE;
    oIndex := 0;
    oResult := 0.0;
    // Linear scan; switch to FOR loop with EXIT for early termination
    FOR i := 1 TO 40 DO
        IF "DB_Lookup".Key[i] = iSearchValue THEN
            oResult := "DB_Lookup".Value[i];
            oIndex  := i;
            oFound  := TRUE;
            RETURN;
        END_IF;
    END_FOR;
END_FUNCTION_BLOCK

Step 4: Use a tolerance for noisy analog inputs

If the temperature comes from an RTD or thermocouple module, exact equality is rare. Wrap the comparison in a ±0.5 °C window:

IF ABS("DB_Lookup".Key[i] - iSearchValue) <= 0.5 THEN

For better noise immunity, average the AI input in the analog input driver block (e.g., 16-sample moving average) before calling the lookup.

Method 2: Classic STEP 7 DB Lookup (S7-300/S7-400, V5.x)

On STEP 7 V5.7 with an S7-300 or S7-400, you can build the table in a shared DB and use pointer arithmetic in STL to walk the entries.

Data block

DATA_BLOCK DB 100
TITLE = Temperature Lookup
STRUCT
    Key   : ARRAY[1..40] OF REAL;
    Value : ARRAY[1..40] OF REAL;
END_STRUCT;
BEGIN
    Key[1]   := 0.0;    Value[1]   := 1.000;
    // ... populate all 40 entries ...
END

STL scan

// In OB1, searchKey = MD100 (REAL), result -> MD104
      L     40
      T     LW 0                  // Loop counter
      L     P#DBX 0.0             // Pointer to Key[1]
      T     LD 2
LOOP: L     DBD [LD 2]            // Load Key[i]
      L     MD 100                // Load searchKey
      ==R
      JC    FOUND
      L     P#8.0                 // Increment pointer by 8 bytes (REAL)
      +D
      T     LD 2
      L     LW 0
      LOOP LOOP
      L     0.0
      T     MD 104                // No match -> 0.0
      JU    DONE
FOUND: L     DBD [LD 2]
      L     P#320.0               // Offset from Key[1] to Value[1] = 40*8
      +D
      LAR1
      L     DBD [AR1,P#0.0]       // Load Value[i]
      T     MD 104
DONE: NOP 0

Method 3: TBL_FIND Instruction (S7-300/S7-400)

TBL_FIND (Find value in table) is in the Extended Instructions catalog under Table functions. It scans a source range (SRC) for entries that match a comparison pattern defined by CMD (1=EQ, 2=NE, 3=GT, 4=GE, 5=LT, 6=LE). The block returns the index of the first match, the number of matches, and the source/destination ranges used.

TBL_FIND interface

Wiring TBL_FIND in FBD

      +-------+--------+
      |       |  POSITION      |
      |       +--------+
      |       |  COUNT  |
      |       +--------+
REQ ---| TBL_  | BUSY  |
SRC ---| FIND  | ERROR |
PATTERN -- |       | STATUS|
CMD ------|       +--------+
      +-------+

Drive REQ with a one-shot pulse (use a rising-edge contact of your scan enable), set CMD = 1 (equal), and read POSITION. The returned index is zero-based, so add 1 to map it onto your 1..40 DB array.

Error handling checklist

Method 4: Polygon Interpolation for Non-Exact Values

When the process variable can fall between two tabulated keys, exact-match lookup will frequently return "no match." Use linear interpolation between the bracketing points. The Siemens application example 8803015 provides the standard POLYGON function block.

SCL implementation of linear interpolation

FUNCTION_BLOCK FB_Lookup_Interp
{ S7_Optimized_Access := 'TRUE' }
VAR_INPUT
    iX : REAL;                 // Input (e.g., temperature)
END_VAR
VAR_OUTPUT
    oY  : REAL;                // Interpolated value
    oOK : BOOL;                // TRUE if iX is inside table range
END_VAR
VAR
    i   : INT;
    x1, x2, y1, y2 : REAL;
END_VAR
BEGIN
    oOK := FALSE;
    oY  := 0.0;
    // Clamp below first key
    IF iX <= "DB_Lookup".Key[1] THEN
        oY  := "DB_Lookup".Value[1];
        oOK := TRUE;
        RETURN;
    END_IF;
    // Clamp above last key
    IF iX >= "DB_Lookup".Key[40] THEN
        oY  := "DB_Lookup".Value[40];
        oOK := TRUE;
        RETURN;
    END_IF;
    // Find bracketing pair (Key array is assumed ascending)
    FOR i := 1 TO 39 DO
        IF (iX >= "DB_Lookup".Key[i]) AND (iX < "DB_Lookup".Key[i+1]) THEN
            x1 := "DB_Lookup".Key[i];
            x2 := "DB_Lookup".Key[i+1];
            y1 := "DB_Lookup".Value[i];
            y2 := "DB_Lookup".Value[i+1];
            // y = y1 + (y2 - y1) * (x - x1) / (x2 - x1)
            oY  := y1 + (y2 - y1) * (iX - x1) / (x2 - x1);
            oOK := TRUE;
            RETURN;
        END_IF;
    END_FOR;
END_FUNCTION_BLOCK

Performance and Memory Footprint

For 40 REAL pairs you need 40 × 8 bytes × 2 = 640 bytes of load memory. S7-1500 CPUs and S7-1200 CPUs from firmware V4.4 onward have ample work memory; on the S7-300 CPU 312 (work memory 32 KB) or the S7-400 CPU 412-1 (144 KB), 640 bytes is negligible. Watch out for:

• Optimized vs. non-optimized access: TIA Portal defaults to optimized symbolic access on S7-1200/S7-1500, which costs a few extra cycles for array indexing versus a direct DB number. This is the correct tradeoff for maintainability.
• Volatile vs. retentive: Mark the table DB as retentive only if you intend to modify it from the HMI at runtime. Hard-coded engineering tables should be non-retentive so a CPU restart reinitializes from OB100.
• Cyclic load: Calling a 40-point linear scan every 1 ms on an S7-1516 is fine. On an S7-314 with 0.1 ms OB1 period, it consumes a measurable share of cycle time. Use a slower OB (e.g., OB35 at 100 ms) for the lookup call if your process allows it.

Step-by-Step Commissioning (40-Point Temperature Table)

1. Decide whether the application needs exact match or interpolation. For setpoint conversion (e.g., RTD to density), use interpolation. For discrete process steps (e.g., recipe stage selection), use exact match.
2. Build the source data. Export your engineering values from Excel as CSV; in TIA Portal use Tools > Data Block Generator with the CSV import to auto-fill the DB. In STEP 7 V5.x, paste values directly into the DB initial values view.
3. Create DB_Lookup with the 40 keys and 40 values.
4. Implement the lookup FB in SCL (exact or interpolated) and compile the SCL source.
5. In OB100, populate the DB with your engineering values. Compile and download.
6. In OB1 (or OB35), call the FB and wire the analog-input REAL to iSearchValue / iX.
7. Connect a watch table to monitor oIndex, oFound, and oResult during commissioning.

Verification

Troubleshooting Matrix

FAQ