Configuring Indexed Symbolic I/O Fields on Siemens KTP700 Basic

Overview - The Index Tag Pattern

Welding cells commonly require operators to switch between several stored welding schedules (pre-flow, pilot arc, up-slope, weld, down-slope, post-flow) and to edit each schedule's 20 or more parameters. Repeating every parameter as an individual Symbolic I/O field bound to 200 fixed tags is wasteful and forces the developer to keep 200 Mode configurations in sync.

The cleanest pattern on a KTP700 Basic paired with a CPU 1215C is to keep the parameters in a PLC array of structures (ARRAY[0..9] OF STRUCT) and to expose each parameter's first array element through a single HMI tag that carries an Index tag. When the operator changes the cycle number on a selector, the index tag is updated, and every Symbolic I/O field that uses the same index jumps to the matching element of the array. No temporary tags, no mirror bits, and no SCL counter logic are required.

This article walks through the exact configuration, shows the elementary-type vs UDT boundary, and provides a recipe-based alternative for shops that already use the Basic Panel recipe viewer.

Prerequisites

PLC Array Configuration (CPU 1215C)

Build a data block that holds the 10 welding cycles and their 20 parameters. A typical declaration in the WeldingDB global DB looks like:

DATA_BLOCK "WeldingDB"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
  STRUCT
    WeldingParameters : ARRAY [0..9] OF STRUCT
      Current      : REAL;   // Weld current (A)
      Voltage      : REAL;   // Arc voltage (V)
      Time         : REAL;   // Weld time (s)
      CoolTime     : REAL;   // Cool time (s)
      WireSpeed    : REAL;   // Wire feed speed (m/min)
      GasFlow      : REAL;   // Shielding gas (l/min)
      PreFlow      : REAL;   // Pre-flow time (s)
      PostFlow     : REAL;   // Post-flow time (s)
      UpSlope      : REAL;   // Up-slope time (s)
      DownSlope    : REAL;   // Down-slope time (s)
      PulseOn      : REAL;   // Pulse on time (ms)
      PulseOff     : REAL;   // Pulse off time (ms)
      PulseCurrent : REAL;   // Pulse current (A)
      PulseVoltage : REAL;   // Pulse voltage (V)
      HoldPressure : REAL;   // Electrode pressure (bar)
      TipDressCnt  : DINT;   // Tip-dress counter
      ElectrodeLife: DINT;   // Remaining electrode life (cycles)
      ProgramLock  : BOOL;   // 1 = locked from HMI write
      Reserved1    : BOOL;
      Valid        : BOOL;   // 1 = cycle valid
    END_STRUCT;
    ActiveIndex : INT;       // 0..9 currently displayed on HMI
  END_STRUCT;
END_DATA_BLOCK

The PLC tag for the Symbolic I/O field is built from this block. Because each WeldingParameters element is a STRUCT, you cannot bind a single tag to the entire cycle; instead you bind 20 HMI tags, one for each parameter, and let the index tag step through the array.

HMI Tag Configuration with Index Variable

1. Open the HMI device configuration in TIA Portal and select HMI Tags on the KTP700 Basic.
2. Create one HMI tag per parameter. For the first parameter (Current):
   • Name: weldCurrent
   • Connection: S7-1200_1 (PROFINET to 1215C)
   • PLC tag (Address): navigate symbolically to "WeldingDB".WeldingParameters[0].Current. The trailing [0] is mandatory - it defines the base element that the index will offset from.
   • Index tag: select weldIndex (created below) from the dropdown.
3. Repeat for the other 19 parameters, each pointing at the corresponding field of WeldingParameters[0], all sharing the same index tag weldIndex.
4. Create the index tag:
   • Name: weldIndex
   • Connection: S7-1200_1
   • PLC tag (Address): "WeldingDB".ActiveIndex (symbolic)
   • Data type: Int, length 2 bytes

After configuration, the index tag updates the array offset at runtime. When weldIndex = 4, every weldCurrent, weldVoltage, weldTime... reads element 4 of the array.

Symbolic I/O Field Setup

Drag a Symbolic I/O field onto the screen (Controls » Elements » Symbolic I/O field). Configure the key properties:

For operator feedback, set the Appearance » Background color on a "Value changed" animation. The animation's trigger tag is the same weldCurrent tag, so when the panel reads a new element, the field flashes a different color for 250 ms.

Bind the index selector as a Symbolic I/O field too with Mode = Output only and Process value = weldIndex, or use a Text list for a friendly "Cycle 0 - Steel 1.2 mm", "Cycle 1 - Steel 1.5 mm" look. The text list consumes a separate HMI tag of type Int or DInt and references a text list in the HMI dictionary.

Wiring Multiple Parameters Across the Array

Welding parameters typically come in groups that must move together (e.g., current, voltage and time form the primary set). Configure them as a single PLC array to keep the index logic consistent:

// 20 Symbolic I/O fields on screen "Weld_Setup"
// Each field points to "WeldingParameters[0].<field>" with index tag weldIndex
weldCurrent      -> "WeldingParameters".Current
weldVoltage      -> "WeldingParameters".Voltage
weldTime         -> "WeldingParameters".Time
weldCoolTime     -> "WeldingParameters".CoolTime
weldWireSpeed    -> "WeldingParameters".WireSpeed
weldGasFlow      -> "WeldingParameters".GasFlow
... (14 more) ...
weldValid        -> "WeldingParameters".Valid        // BOOL displayed as bit lamp

The PLC never has to know which index the HMI is showing; it always reads/writes WeldingParameters[weldIndex] through the same tag list. To use a parameter in ladder logic, the SCL snippet is:

// Example: write the active index back to a separate "running" cycle
"RunningDB".ActiveCycle := "WeldingDB".ActiveIndex;   // DINT cast
"RunningDB".TargetCurrent := "WeldingDB".WeldingParameters["WeldingDB".ActiveIndex].Current;

This pattern keeps the data flow one-way (HMI writes the index into the PLC; PLC moves the data into the running DB) and avoids hand-shaking bits between the panel and the controller.

Elementary Types vs UDT / STRUCT Arrays

The Basic Panels (KTP400 Basic, KTP700 Basic, KTP900 Basic, KTP1200 Basic) implement symbolic indexed access at the tag level, but only the first-level array offset is honored. The configuration in TIA Portal is:\p>

HMI tag: "weldCurrent"
PLC tag: "WeldingDB".WeldingParameters[0].Current      // symbolic, first element
Index tag: "weldIndex"                                 // updates to offset

When the structure is replaced by a UDT, e.g.:

TYPE UDT_WeldParam
  STRUCT
    Current   : REAL;
    Voltage   : REAL;
    Time      : REAL;
    ...
  END_STRUCT;
END_TYPE

WeldingDB.WeldingParameters : ARRAY[0..9] OF "UDT_WeldParam";

the index tag still moves through the array elements; the field inside the UDT must be referenced symbolically. Some TIA Portal versions (V13 SP1, V14 SP1) produced a compile error when the index variable was combined with a UDT member path. Workarounds:

1. Elementary types only: keep each element as a flat REAL/INT/BOOL (as shown in the WeldingDB sample above). This is the most reliable configuration on the Basic line.
2. PLC-side mirror: create a flat non-UDT buffer MirrorParameters : ARRAY[0..9,0..19] OF REAL and copy each cycle from the UDT into the mirror on demand. Bind the panel to the mirror.
3. Move to a Comfort Panel: KTP700 Comfort / TP700 Comfort handles symbolic UDT arrays transparently when the index variable is configured on the tag.

Recipe Alternative (Built-In)

Basic Panels ship with an integrated recipe viewer. For welding cells, the recipe view is often the lowest-effort solution because:

• Recipe elements can be bound directly to UDT members.
• Data records can be exported to USB or to the PLC, eliminating manual parameter entry.
• Operators can save, load, and delete recipes from the front panel without any PLC code.

Configuration:

1. In the HMI project tree, open Recipes » Recipe_1.
2. Add 20 elements named Current, Voltage, Time...
3. Map each element to the PLC tag "WeldingDB".WeldingParameters[0].<field> with the index tag weldIndex set in the Tag column.
4. Insert a Recipe view control on the screen.

Recipe view shows the active data record and a list of saved records. The index tag becomes implicit; the recipe record's "active record number" supplies the array offset, so the pattern is the same as the Symbolic I/O field approach but with free storage and built-in save/load UI.

Verification and Commissioning

1. Compile the project (TIA Portal » Compile » Software [with all blocks]). The output window must show no "Inconsistent PLC tag" warnings.
2. Download to the 1215C and to the KTP700 Basic. For the panel, use either Ethernet (Project » Download to device » Software) or TIA Portal's HMI simulation (RT) for desk testing.
3. On the panel, touch the Index selector and set value = 3. Confirm:
   • The 20 I/O fields update to the values of WeldingParameters[3].
   • Watch table on the PLC side shows ActiveIndex = 3.
   • Edit a field (e.g., Current = 245.7) and verify the change appears in the watch table at WeldingParameters[3].Current = 245.7.
4. Toggle the index back to 0 and confirm the previous values are intact (no stray writes).
5. Disconnect the PROFINET cable. The panel should display a system error banner with the IO device ID. Reconnect and confirm automatic recovery within ~10 s.

Troubleshooting Matrix

Best-Practice Checklist

• Keep weldIndex clamped between 0 and 9 inside the PLC to protect the array from operator typos.
• Use the Valid BOOL in each array element and bind a green/red lamp on the screen to surface corrupted data records.
• Reserve a fixed HMI tag of type Int (e.g., controlWord) for "WriteEnable" to suppress accidental writes from maintenance sessions.
• Keep the recipe view as a fallback for shop-floor technicians who prefer record-based editing.
• Set the PROFINET update time for the HMI connection to 100 ms (default 1 s) if the operator complains about sluggish response when stepping through cycles.

Frequently Asked Questions

References: SIMATIC HMI WinCC Unified V18 - Symbolic IO field | WinCC Unified - IO field (RT Unified) | Siemens Industry Online Support