Validating Numeric Pad Input on Siemens HMI in TIA Portal

Siemens HMI panels (Basic, Comfort, and Unified) present a built-in numeric pad widget for operator entry. The pad has no native list validation, so any value within the configured data type range is accepted. When the application requires membership in a discrete set - recipe numbers, job IDs, machine constants, alarm codes - the validation must be implemented in PLC code. This article builds a three-layer validator: HMI tag limits, PLC membership check, and operator feedback, optimized for the S7-1200 CPU in TIA Portal V16 or later.

1. The Validation Problem in Operator Entry

The numeric pad on a KTP400, KTP700, KTP1200, or Comfort Panel is a text-entry widget: it accepts any character that maps to a valid integer or float. The widget has no list picker, no dropdown, no autocomplete. Range limits are the only built-in control. Common failure modes observed in field deployments include:

• Operator enters 10 instead of 100 on a 3-digit recipe number.
• Operator enters 0 when the minimum valid value is 4.
• Operator enters 255 when the maximum is 250.
• Operator scrolls the input spinner past the valid range and the panel accepts it.
• Operator types on a resistive-touch panel while wearing gloves and the value is misread.

A common field application requires the operator to select one of approximately 30 specific valid values - for example, recipe numbers that match an internal product catalog. The naive approach of building 30 individual comparators in ladder is unmaintainable, and the S7-1200 lacks a built-in in-list instruction. The robust solution distributes validation across three layers:

1. HMI-side tag limits - clamp gross range errors (e.g., below 1 or above 255) on the panel itself.
2. PLC-side lookup - check membership in the valid set inside the S7-1200 CPU.
3. Operator feedback - visual and audible indication of accept/reject so the operator can correct immediately.

2. Prerequisites

Before starting, confirm the project meets the following requirements:

• SIMATIC S7-1200 CPU with firmware V4.2 or later (V4.4 recommended). Earlier firmware supports most features but not all SCL optimizations. See the S7-1200 Programmable Controller System Manual for firmware-to-feature mapping.
• STEP 7 Basic (for S7-1200) or Professional (for S7-1500 and S7-1200) in TIA Portal V16 or later. V18 is the current long-term release at time of writing; V19 is the most recent.
• HMI panel: KTP400 Basic, KTP700 Basic, KTP1200 Basic, or any Comfort Panel (TP700 Comfort through TP1900 Comfort).
• Configured HMI connection in the Devices & Networks editor.
• Defined set of 1-30 valid integer values for the application, ideally exported to a CSV for data-driven import.
• Familiarity with SCL (Structured Control Language) syntax. SCL is required for the lookup patterns; pure ladder is supported for small sets only.

3. HMI-Side Tag Limits (Layer 1)

Layer 1 catches out-of-range values before they reach the application logic. Configure limits on the HMI tag, not the PLC tag, so the entry is rejected on the panel.

3.1 Configuring the HMI Tag Range

1. In the TIA Portal project tree, expand HMI tags and double-click the tag table (default name: Default tag table).
2. Add a new tag or select the existing tag that drives the numeric input field, e.g., "RecipeNumber".
3. Set the data type to Int (or DInt if the application requires values outside the Int range).
4. Open the Properties pane at the bottom of the editor.
5. Switch to the Range section.
6. Tick the Lower limit checkbox and enter the minimum acceptable value (e.g., 1).
7. Tick the Upper limit checkbox and enter the maximum acceptable value (e.g., 255).
8. Compile the HMI station and download to the panel.

3.2 Wiring the Out-of-Range Event

The Range property alone is silent; the panel rejects the value but gives no feedback. To make the rejection visible, wire the I/O field's Events tab:

1. Select the I/O field widget on the screen.
2. Open Properties > Events.
3. Locate the "Value out of range" event.
4. Add a system function or script:
   • Status text: select the "Set" action on a status text element. Text: "Entry outside [1..255]. Re-enter."
   • Auto-revert: add a second system function SetValue("RecipeNumber", 0) to clear the invalid entry.
   • Logging: on Comfort Panels, call Trace or Logging to record the violation for audit.
5. Compile and download.

3.3 HMI Tag Configuration Table

For more details on tag configuration in WinCC (TIA Portal), consult the TIA Portal help under Configuring tags > Configuring HMI tags > Range, available through Siemens Industry Online Support.

4. PLC Lookup Logic (Layer 2)

Layer 2 runs in the S7-1200 CPU and decides whether the entered value is in the valid set. The implementation choice depends on the size of the valid set, the frequency of changes, and the maintenance workflow.

4.1 SCL CASE Statement (5-20 Discrete Values)

The SCL CASE statement compiles to a fast branch table in the S7-1200 firmware. It is the cleanest solution for sparse sets where most values are not valid. Example with eight valid recipe numbers:

// FB_RecipeCheck - validates recipe number against allowed set
FUNCTION_BLOCK "FB_RecipeCheck"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT
      i_Entered : Int;          // Recipe number from HMI
   END_VAR
   VAR_OUTPUT
      o_Valid   : Bool;         // TRUE if value is in valid set
      o_Code    : Int;          // 0 = valid, 1 = invalid
   END_VAR
BEGIN
   o_Valid := FALSE;
   o_Code  := 0;

   CASE i_Entered OF
      10, 25, 40, 55, 78, 102, 150, 200:
         o_Valid := TRUE;
         o_Code  := 0;
      ELSE
         o_Valid := FALSE;
         o_Code  := 1;
   END_CASE;
END_FUNCTION_BLOCK

Call this FB once per scan in OB1 (or in a cyclic interrupt OB if you need deterministic timing). Wire the output o_Valid to a status indicator on the HMI screen. The SCL CASE statement is documented in the STEP 7 (TIA Portal) programming reference available through Siemens Industry Online Support.

4.2 Range Clusters Inside CASE

When several consecutive numbers are all valid (e.g., 69..85 all acceptable), use the range syntax inside the CASE label. This avoids spelling out 17 individual labels.

CASE i_Entered OF
   40:                  o_Valid := TRUE;
   55:                  o_Valid := TRUE;
   69..85:              o_Valid := TRUE;     // 17 contiguous values
   100, 200:            o_Valid := TRUE;
   1000..1100:          o_Valid := TRUE;     // 101 contiguous values
ELSE
   o_Valid := FALSE;
END_CASE;

The 69..85 form expands at compile time but produces a tighter, more readable block. The S7-1200 firmware compiles a CASE statement with N labels into a balanced binary search internally, so adding range labels does not increase execution time linearly.

4.3 Ladder Network (Small Sets, No SCL)

If the project is restricted to pure ladder (FBD/LAD) - for example, in a vendor-locked legacy environment - build a comparator network. For n valid values, you need n EQ comparators and an n-input OR word. Example for three valid values (10, 55, 200):

// Network 1 - ladder form
      LD     i_Entered
      EQ     10              // TRUE if i_Entered = 10
      OR(
      LD     i_Entered
      EQ     55
      OR(
      LD     i_Entered
      EQ     200
      )
      )
      ST     o_Valid

For sets larger than ~8 values the ladder becomes unmaintainable. Each branch adds 3-4 ladder elements and the visual tree grows fast. Switch to SCL as soon as the set exceeds 6-8 values.

4.4 Array Lookup with Linear Search (Up to 30 Values)

For maintainable, data-driven validation, store the valid set in a sorted ARRAY and walk it. This is the recommended pattern when the list can change between project revisions without recompiling the logic - the array is loaded from a recipe DB or operator-edited list.

// FB_LookupValidator - 30-value integer membership test
FUNCTION_BLOCK "FB_LookupValidator"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT
      i_Entered : Int;
   END_VAR
   VAR_OUTPUT
      o_Valid       : Bool;
      o_Position    : Int;    // 0 if not found, else 1..30
   END_VAR
   VAR CONST
      // Sorted ascending; required for binary search
      c_ValidList : ARRAY[1..30] OF Int :=
         (4, 12, 25, 40, 55, 69, 72, 85, 90, 100,
          110, 125, 140, 150, 178, 200, 205, 220, 240, 250,
          255, 260, 275, 290, 300, 310, 325, 340, 355, 360);
   END_VAR
   VAR
      n : Int;
   END_VAR
BEGIN
   o_Valid    := FALSE;
   o_Position := 0;

   // Linear search - O(n), fine for n <= 30 on S7-1200
   FOR n := 1 TO 30 DO
      IF i_Entered = c_ValidList[n] THEN
         o_Valid    := TRUE;
         o_Position := n;
         RETURN;     // exit early on first hit
      END_IF;
   END_FOR;
END_FUNCTION_BLOCK

Worst-case scan: 30 comparisons. At a 10 ms OB1 cycle on an S7-1214C, this consumes under 50 microseconds. For 30 values the linear search is always fast enough; do not add complexity you do not need. The RETURN statement is supported in SCL FB bodies; see the SCL manual.

4.5 Binary Search (50-256 Values, Sorted Array)

If the valid set grows past 50 entries, switch to a binary search to keep the worst case under log2(n) + 1 comparisons. The array must be sorted ascending.

// Binary search over sorted ARRAY (ascending)
FUNCTION_BLOCK "FB_BinarySearch"
   VAR_INPUT
      i_Target : Int;
   END_VAR
   VAR_OUTPUT
      o_Found  : Bool;
   END_OUTPUT
   VAR CONST
      c_ValidList : ARRAY[1..30] OF Int :=
         (4, 12, 25, 40, 55, 69, 72, 85, 90, 100,
          110, 125, 140, 150, 178, 200, 205, 220, 240, 250,
          255, 260, 275, 290, 300, 310, 325, 340, 355, 360);
   END_VAR
   VAR
      lo  : Int := 1;
      hi  : Int := 30;
      mid : Int;
   END_VAR
BEGIN
   o_Found := FALSE;
   WHILE lo <= hi DO
      mid := (lo + hi) / 2;     // integer division
      IF c_ValidList[mid] = i_Target THEN
         o_Found := TRUE;
         RETURN;
      ELSIF i_Target < c_ValidList[mid] THEN
         hi := mid - 1;
      ELSE
         lo := mid + 1;
      END_IF;
   END_WHILE;
END_FUNCTION_BLOCK

For 100 values: max 7 comparisons. For 256 values: max 8 comparisons. The S7-1200 executes each comparison in roughly 1 microsecond, so the block stays under 10 microseconds even in the worst case. The WHILE loop with mid-point division is documented in the STEP 7 SCL reference manual.

4.6 SCL PEEK and POKE for Legacy Data Blocks

If the project predates TIA Portal V14 and uses absolute DBs, you can use PEEK and POKE for indirect access. The performance penalty is roughly 30% over a typed ARRAY, so prefer typed arrays for new code. The PEEK syntax in SCL is PEEK(area := 16#84, byteOffset := n) for reading a byte from DB2 at offset n.

4.7 Pattern Selection Guide

5. Operator Feedback (Layer 3)

Validation without feedback is invisible. Use a status tag and HMI animations to make the result obvious to the operator.

5.1 Status Tag Codes

Add an HMI tag "RecipeStatus" of type Int. Update it from the PLC after each entry. The code table is the contract between the PLC and the HMI:

5.2 HMI Animation Setup

1. Select the I/O field that holds the entry.
2. Open Properties > Animations.
3. Add an Appearance animation: if RecipeStatus = 0 then background = green, if RecipeStatus = 3 then background = red, else default.
4. Add a Visibility animation on a status text element: visible when RecipeStatus <> 0.
5. Set the status text content to use a text list with multi-language support.
6. Compile and download.

5.3 Audible Feedback (Comfort Panels)

Comfort Panels support PlaySound as a system function. Wire it to the RecipeStatus change event so the operator hears a click on accept and a buzz on reject. This is highly recommended for noisy plant floors. Comfort Panels accept .wav files up to 16-bit, 44.1 kHz, mono. The system function is documented in the WinCC (TIA Portal) Comfort Panels manual.

5.4 Logging the Validation Result

For audit or recipe-history requirements, log each validation event. On Comfort Panels, configure a Logging tag with the following columns:

Trigger the log entry on the rising edge of the validation-done flag. On Basic Panels, log to a CSV file on a USB stick; on Comfort Panels, use the built-in Logging database.

6. Numeric Pad Configuration Best Practices

7. Cycle Time and Performance

Each SCL comparison takes approximately 1 microsecond on an S7-1214C. A 30-element linear search therefore adds under 50 microseconds to the OB1 cycle. For S7-1200 with default 10 ms cycle, the overhead is below 0.5% and well within the recommended headroom.

Do not call the validator inside a fast cyclic interrupt (e.g., OB35 at 1 ms) without checking the cycle time. For deterministic execution, place the call in OB1 and use a "validation done" tag to confirm execution before allowing another entry.

For S7-1200 cycle-time monitoring, the S7-1200 Diagnostics Manual documents the standard methods: S7-1200 Diagnostics Manual (DAsl_0211_en.pdf). The manual also describes how to read the cycle time on the CPU display or via the Web server.

7.1 Watchdog Safety Margin

The S7-1200 watchdog trips at 150 ms by default. A 30-element linear search adds 50 microseconds; even a 100-element binary search adds 10 microseconds. Both are safe. If you later add a 1000-element validation (with an external database lookup), re-check the watchdog by writing the cycle time to a tag and alarming on overage. The standard approach is to add a hardware interrupt OB that monitors the cycle time and raises a non-fatal diagnostic if the cycle exceeds 80% of the watchdog limit.

8. Recipe Data Management

When the valid list is more than a handful of values, store it in a recipe DB so the application can change the list without recompiling the PLC. Recipe management on the HMI also lets the operator extend the list at runtime.

8.1 Recipe DB Structure

Create a global DB with an ARRAY of valid values plus a count field:

DATA_BLOCK "DB_ValidRecipes"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR
      i_Count      : Int;                  // Number of valid values
      a_Values     : ARRAY[1..100] OF Int; // Sorted ascending
      b_SortError  : Bool;                 // Set by OB100 sort check
   END_VAR
BEGIN
   i_Count := 30;
   a_Values[1]  := 4;
   a_Values[2]  := 12;
   a_Values[3]  := 25;
   a_Values[4]  := 40;
   a_Values[5]  := 55;
   a_Values[6]  := 69;
   a_Values[7]  := 72;
   a_Values[8]  := 85;
   a_Values[9]  := 90;
   a_Values[10] := 100;
   a_Values[11] := 110;
   a_Values[12] := 125;
   a_Values[13] := 140;
   a_Values[14] := 150;
   a_Values[15] := 178;
   a_Values[16] := 200;
   a_Values[17] := 205;
   a_Values[18] := 220;
   a_Values[19] := 240;
   a_Values[20] := 250;
   a_Values[21] := 255;
   a_Values[22] := 260;
   a_Values[23] := 275;
   a_Values[24] := 290;
   a_Values[25] := 300;
   a_Values[26] := 310;
   a_Values[27] := 325;
   a_Values[28] := 340;
   a_Values[29] := 355;
   a_Values[30] := 360;
END_DATA_BLOCK

8.2 Loading Recipes from CSV

For recipes that change frequently, import them from a CSV file generated by the engineering team. TIA Portal's recipe import is documented in the WinCC (TIA Portal) manual.

1. Generate a CSV file with one recipe value per row.
2. In TIA Portal, open Recipes under the HMI station.
3. Define a new recipe with one element of type Int.
4. Import the CSV to populate the recipe entries.
5. In runtime, the operator selects a recipe on the panel and the PLC reads the value via the recipe data record tags.

8.3 Sort Verification at Startup

Binary search requires a sorted array. Add a one-time check in OB100 (warm restart) that walks the array and flags any out-of-order pair. On error, set a status bit the HMI can display.

// OB100 - Startup sort verification
FOR n := 1 TO "DB_ValidRecipes".i_Count - 1 DO
   IF "DB_ValidRecipes".a_Values[n] > "DB_ValidRecipes".a_Values[n+1] THEN
      "DB_ValidRecipes".b_SortError := TRUE;
      "RecipeStatus" := 6;     // Code 6 = recipe data corrupt
      "RecipeNumber" := 0;
      RETURN;
   END_IF;
END_FOR;
"DB_ValidRecipes".b_SortError := FALSE;

8.4 Multi-Language Text Lists

For multi-language deployments, define a text list in TIA Portal with entries for each status code. The HMI runtime resolves the text based on the operator's selected language.

Configure the text list under HMI > Text and graphics lists > Text lists in TIA Portal, then reference the list in the status text element's text property.

9. Verification and Commissioning

Before releasing the panel to production, run a structured verification. The test plan below covers static, boundary, mid-range, and negative cases.

1. Static test: With the PLC in STOP, force the input tag to each of the 30 valid values. Confirm o_Valid = TRUE for each.
2. Boundary test: Force the tag to valid_list[1] - 1, valid_list[30] + 1, and 32767. Confirm reject.
3. Mid-range test: Force a value clearly between two valid entries (e.g., 11 if 10 and 12 are valid). Confirm reject.
4. Negative test: Force -1 and 0 if the valid set starts at 4. Confirm reject.
5. HMI test: On the panel, enter each of the 30 values through the numeric pad. Confirm color change and status text update.
6. Reset test: Press Cancel on the HMI. Confirm the tag is not overwritten by the validator.
7. Cycle test: Trigger OB1 cycle time display in TIA Portal online > diagnostics. Confirm no cycle time warning.
8. Power-cycle test: Power down and up the panel. Confirm the tag retains its last valid value (or is initialized as expected).
9. Concurrent operator test: Have two operators enter values on the same screen. Confirm no race condition corrupts the tag.
10. Spam test: Tap the OK button rapidly. Confirm the validator runs once per edge, not 10 times per second.
11. Language test: Switch the panel language to German, Spanish, and French. Confirm the status text list resolves correctly.
12. Recipe load test: Modify the recipe DB on the HMI, save, and re-validate. Confirm the new set is enforced.

10. Troubleshooting Matrix

11. Frequently Asked Questions