Counting Array Value Occurrences in S7 SCL: TIA Portal Tutorial

This tutorial shows how to count how many times a specific value appears inside a Siemens SIMATIC S7 array (PLC tag of type Array[0..50] of Int) using Structured Control Language (SCL) in TIA Portal. A working SCL function, a pure ladder (LAD) alternative, edge-case handling, and a commissioning verification procedure are provided.

1. Problem Definition

Given a PLC tag of the form:

Array1 : Array[0..50] of Int;  // 51 elements, indexes 0..50

with arbitrary values such as:

you must determine, for a given search value (for example, the integer 3), how many elements of Array1 are equal to that value. The expected result for the example above is 2.

2. Prerequisites

• Siemens TIA Portal V15.1 or later (tested with V16, V17, V18, V19). The SCL syntax used is valid back to V13 SP1.
• CPU family: S7-1200 (firmware V4.2+) or S7-1500 (firmware V1.8+). The SCL FOR loop with TO / BY / DO is supported on both. Reference: Siemens S7-1200/1500 SCL programming guideline.
• A defined PLC data block (DB) or local tag of array type, for example Array[0..50] of Int or, for variable-length cases, an array with explicit upper bound such as Array[0..n] of Int where n is a constant in the same block.
• An empty function (FC) or function block (FB) into which the search logic will be placed. For SCL, the block must be created with the language set to SCL (right-click the FC/FB in the project tree → Properties → General → Language: SCL).

3. Solution: SCL FOR Loop

Create a new FC, for example FC_CountValueInArray, with the following interface:

3.1 SCL Source Code

// FC_CountValueInArray - count occurrences of i_searchValue in i_array
// Compatible with S7-1200/1500, TIA Portal V15.1+

#o_count := 0;
#o_error := FALSE;

// Range validation
IF #i_startIdx < LOWER_BOUND(#i_array) OR #i_endIdx > UPPER_BOUND(#i_array) THEN
    #o_error := TRUE;
    RETURN;
END_IF;

FOR #i_idx := #i_startIdx TO #i_endIdx BY 1 DO
    IF #i_array[#i_idx] = #i_searchValue THEN
        #o_count := #o_count + 1;
    END_IF;
END_FOR;

Where #i_idx is a local DInt tag (Temp section) declared as i_idx : DInt;. The hash (#) prefix is automatic block-local addressing in TIA Portal; it is optional but recommended for readability.

3.2 SCL Construct Breakdown

4. Step-by-Step Procedure in TIA Portal

1. In the project tree, expand Program blocks and click Add new block.
2. Choose Function (FC), name it FC_CountValueInArray, set the language to SCL, and confirm.
3. Open the FC, switch to the SCL editor, and declare the interface per the table in section 3.
4. Paste the SCL source from section 3.1.
5. Compile the block (Project tree → right-click the FC → Compile → Software (only)). Look for warnings about implicit type conversions in the Info tab.
6. From the calling block (OB1, FB, or another FC), invoke the FC and wire the inputs/outputs. Example call from OB1 in SCL:

   "FC_CountValueInArray"(
       i_array       := "DataBlock_1".Array1,
       i_searchValue := 3,
       i_startIdx    := 0,
       i_endIdx      := 50,
       o_count       => "DataBlock_1".resultCount,
       o_error       => "DataBlock_1".resultError
   );

7. Download the project to the CPU and go online.

5. Alternative: Pure Ladder (LAD) Implementation

If your project standard mandates LAD (no SCL), implement the loop with a counter and an indexed access using a pointer-incremented DB. On S7-1200/1500, the cleanest pure-LAD approach uses the PEEK/POKE box and a dedicated loop counter, but in practice LAD is impractical for arbitrary-length integer scans. The recommended approach is therefore an FB written in LAD that increments a loop index on each scan:

This emulates the FOR loop in LAD but loses the deterministic single-scan execution that SCL provides. For any non-trivial array, prefer the SCL version.

6. Edge Cases and Safety Checks

7. Performance and Cycle Time

Approximate execution time per element on representative CPUs (SCL, optimized DB access):

For arrays above ~20,000 elements on S7-1200, split the scan across OB35 cycles by passing the current index as an in/out static on the FB; otherwise the main OB1 watchdog (default 150 ms) will trip.

8. Generic Reusable FB Variant

For project-wide reuse, promote the FC to an FB and store the count, the running index, and a busy/done state in the static section. Example header (SCL):

FUNCTION_BLOCK "FB_CountValueInArray"
TITLE = 'Generic array value counter (multi-call safe)'
{ S7_Optimized_Access := 'TRUE' }
VERSION : '1.0'

VAR_INPUT
    i_trigger   : Bool;     // edge-triggered start
    i_searchValue : Int;
    i_startIdx  : DInt;
    i_endIdx    : DInt;
END_VAR

VAR_OUTPUT
    o_busy      : Bool;
    o_done      : Bool;
    o_count     : DInt;
    o_error     : Bool;
END_VAR

VAR
    s_state     : Int;      // 0=idle, 1=running
    s_idx       : DInt;
END_VAR

VAR_TEMP
    t_arrLow    : DInt;
    t_arrHigh   : DInt;
END_VAR

This pattern allows safe multi-cycle execution. See Siemens SCL programming style guide for further conventions on state machines and FB design.

9. Verification Procedure

1. Create a watch table in TIA Portal (Project tree → Watch and force tables → Add new watch table).
2. Add the array tag and pre-load it with a known pattern using the Modify column. For the original problem statement, set indices 1 and 4 to 3, all others to 0.
3. Trigger the FC call by setting the OB1 call conditions (or, in the watch table, manually toggling a one-shot).
4. Observe o_count: it must become 2 for search value 3.
5. Repeat for the following cases to validate boundary behavior:
   • search value that occurs zero times → expect o_count = 0, o_error = FALSE.
   • search value equal to every element (pre-load entire array with the same value) → expect o_count = array length.
   • i_startIdx = 5, i_endIdx = 4 (inverted) → expect o_error = TRUE, o_count = 0.
   • i_endIdx = 1000 when array upper bound is 50 → expect o_error = TRUE, o_count = 0.
6. Force a one-shot in the watch table, force a transition from o_busy = FALSE to o_busy = TRUE, and confirm o_done rises exactly one OB1 cycle after the last index is processed.
7. Check the diagnostic buffer for any access-violation entries during the test (Online → Diagnostics → Diagnostic buffer). The buffer must be clean.

10. Comparison of Approaches

11. Field-Proven Notes

• Always validate bounds. A single out-of-range index in optimized-block SCL produces a CPU STOP (SF LED) on S7-1200 with diagnostic buffer entry "Area length error" (event ID 16#8001 in some cases). The range check in section 3.1 prevents this.
• Avoid comparing REAL with =. Floating-point values from analog inputs almost never match a literal exactly. Use a tolerance window.
• Use the right type for the count. Int (16-bit) overflows at 32,767. If the array can hold more than 32 k matches, use DInt (32-bit) for the counter.
• Symbolic access only in optimized blocks. Absolute (DBW, DBD) access to optimized DBs is blocked by the compiler.
• KNOW_HOW_PROTECT: if you protect the FC, you cannot view the SCL online. Document the algorithm in the block header comment so that future maintainers can re-derive it.