WinCC Address Multiplexing: Faceplates and Indirect Tags

Overview

WinCC address multiplexing is the technique of binding a single HMI tag to a selectable subset of PLC memory locations. Instead of authoring 30, 50, or 200 individual screen objects (one per pump, filter, valve, or motor), the engineer defines one tag and one visualization object and varies the underlying address at runtime through an index, a selection widget, or a structured-tag pointer.

Three mechanisms exist across the Siemens HMI portfolio:

1. Address multiplexing on Comfort Panels, Unified Comfort Panels, and WinCC Unified RT (TIA Portal V17 onward, current branch V20). The multiplex index is part of the tag configuration itself, so the same HMI tag can point at many DB or I/O addresses.
2. Indirect tags on classic WinCC (WinCC V7, WinCC Professional, and PCS 7 OS). An internal tag holds the value, and a script or selection mechanism copies the desired external tag into the internal tag.
3. Faceplates on PCS 7 and on TIA Portal WinCC Unified / Professional. A faceplate is a reusable screen window with its own tag interface; one faceplate instance is placed on each faceplate container and re-indexed per object.

For 30+ identical objects (pumps, filters, dosing units, valves), the recommended path in a greenfield project is a faceplate driven by address-multiplexed tags backed by an array-style DB in the S7 PLC. The remainder of this reference walks through each method, the wiring rules, and the verification procedure.

When Address Multiplexing Is the Right Tool

Use address multiplexing when:

• The number of objects exceeds ~8 and is fixed or slowly growing (10 to 500 instances is the sweet spot).
• All instances share the same data layout (current, speed, status word, setpoint, fault code, run-hours).
• The PLC stores instance data in arrays (DB with ARRAY[1..n] OF STRUCT) or in equally sized, equally named data blocks.
• The HMI side must follow array semantics: index 1 maps to instance 1, index 2 to instance 2, and so on.

Avoid address multiplexing when:

• Each object has a unique, non-scalar data layout (mixed types, mixed DB owners).
• The HMI must address process tags by symbolic name rather than by index (the PCS 7 APL faceplate model assumes this; do not mix the two paradigms).
• The number of objects is below ~6 and unlikely to grow. In that case a small handful of dedicated faceplate instances is faster to commission than a generic multiplexing infrastructure.

Faceplates in WinCC and PCS 7

A faceplate is a reusable graphic window with a defined tag interface. The PCS 7 Advanced Process Library (APL) ships with a complete set: @MOT_SPEED, @MOT_STD, @VALVE_AN, @CTRL_PID, @DOSE, and so on. Each faceplate exposes an interface (for example, INPUT: IF_INPUT, OUTPUT: IF_OUTPUT) that is wired to one motor block (FB) in the AS.

On TIA Portal WinCC Professional and Unified, you create user-defined faceplates with the Faceplate Editor. Each faceplate has its own tag interface (interface tags). You instantiate the faceplate on a screen as a faceplate container, set the container properties, and bind the instance to the correct PLC address.

PCS 7 faceplates do not expose address multiplexing directly. Instead, they rely on the underlying CFC chart or SFC assigning the same symbolic block type to each instance. The OS compiles the symbol resolution at compile time. In contrast, WinCC Unified and Comfort Panel faceplates can carry an index that drives an address-multiplexed tag inside the faceplate.

Indirect Tag Method (Classic WinCC V7 / Professional)

The classic WinCC pattern for dynamic tag selection uses one internal HMI tag as the displayed value and a small ladder of external tags as the source pool. The example below implements a 10-motor current overview.

1. Create 10 external tags that mirror the PLC tags: MOTOR1_CURRENT, MOTOR2_CURRENT, ... MOTOR10_CURRENT. Each points to the same DB block but with a different byte offset, or each points to its own data word.
2. Create one internal tag, for example DISPLAYED_CURRENT (data type Real or Float, default value 0.0).
3. On the screen, place an I/O field or Bar bound to DISPLAYED_CURRENT.
4. Place a Selection widget (radio buttons, drop-down list, or index input field) with values 1..10. The selection writes its current value into a second internal tag, for example MOTOR_SELECT (data type Word or Int).
5. On change of MOTOR_SELECT, run a C or VBS script that reads the corresponding MOTORn_CURRENT external tag and writes it to DISPLAYED_CURRENT.

Sample VBS in classic WinCC:

Sub OnSelect_Change(ByVal Item)
    Dim iMotor, sTag
    iMotor = SmartTags("MOTOR_SELECT")
    If iMotor < 1 Or iMotor > 10 Then Exit Sub
    sTag = "MOTOR" & iMotor & "_CURRENT"
    SmartTags("DISPLAYED_CURRENT") = SmartTags(sTag)
End Sub

This approach is portable across WinCC V7, WinCC Professional, and WinCC Flex (with the syntax adjusted). It is also the only approach that works on legacy panels that do not support address multiplexing (Basic Panels 1st generation and OP 73 / TP 177A class).

Address Multiplexing (WinCC Unified and Comfort Panels)

Per the official Siemens documentation, address multiplexing is configured at the HMI tag level. You define one HMI tag, point it at a base PLC address (DB number, byte offset, bit offset), and add one or more index tags that the runtime uses to compute the actual address.

Reference: Address multiplexing (RT Unified) - WinCC Unified V20.

Reference: Address multiplexing (Basic Panels, Panels, Comfort Panels, RT Professional).

Multiplex Index Sizing

The index tag is typically a Word or Int with a configured minimum and maximum value. Address multiplexing in TIA Portal supports up to two index tags per HMI tag, allowing a 2-D array layout. The runtime computes:

where Element_size is the byte width of the HMI tag's data type, and Row_size is the byte width of one full row of the underlying array. For a tag of type Real, Element_size = 4. For DWord, Element_size = 4. For Bool packed at the bit level, the calculation also includes a bit-offset contribution.

Configuration Steps in TIA Portal (Unified)

1. In the project tree, open HMI Tags on the Unified device.
2. Create a new tag, for example Motor_Current, type Real, connection to the S7-1500 PLC.
3. In the tag properties, set the PLC address: DB20 with base offset, for example DB20.DBX0.0.
4. Enable Multiplexing and add an index tag. Point it at an internal HMI tag of type Int, for example Motor_Index (range 1..30).
5. Set Factor to 4 (the byte width of Real).
6. Compile the HMI and download.

At runtime, write 5 to Motor_Index. The HMI reads from DB20.DBD(0 + (5-1) * 4) = DB20.DBD16 if the index is 1-based and the array starts at offset 0.

Structured Tags and Array Backing in the PLC

The PLC side should mirror the HMI array layout. For S7-1500 with optimized block access, define a DB as follows:

DATA_BLOCK "MotorData"
  STRUCT
    Motor : ARRAY[1..30] OF STRUCT
      Current   : REAL;          // Ampere, scaling 0..63 A
      Speed     : REAL;          // RPM, scaling 0..3600
      Status    : WORD;          // bit-coded status word
      FaultCode : UINT;          // 0 = OK, nonzero = fault number
      RunHours  : DINT;          // accumulated run hours, seconds / 3600
    END_STRUCT;
  END_STRUCT;
END_DATA_BLOCK

Address map (1-based, optimized access):

The HMI multiplex factor for each tag type is therefore:

Row stride is 16 bytes per motor instance. The base offset is 0, so for instance n:

Faceplate with Multiplexed Interface Tags

For 30 motors the typical screen layout is:

1. A screen-level index stored in an internal HMI tag, e.g. Overview_Index (range 1..30).
2. One faceplate container displaying the motor faceplate for the indexed instance. The container's interface tags are address-multiplexed tags: Motor_Current, Motor_Speed, Motor_Status, Motor_FaultCode.
3. A navigation widget (next / previous buttons, or a slider 1..30) that increments / decrements Overview_Index.
4. An optional overview grid with 30 small status indicators (one per motor) wired to the same multiplexed Motor_Status tag with a per-cell constant index. With 30 cells and 30 distinct index values, you need either 30 separate HMI tags (one per cell) or a script-driven loop that updates one index at a time. The latter is preferred on smaller panels.

Comparison: Method Selection Matrix

Step-by-Step: Building a 30-Motor Overview Screen

Prerequisites

• TIA Portal V18 or later (V20 recommended for the latest WinCC Unified multiplexing documentation).
• S7-1500 CPU with firmware V2.9 or later, project containing DB20 "MotorData" as shown above.
• Comfort Panel TP1500 Comfort or Unified Comfort Panel TP1900.
• HMI connection configured (PROFINET or PROFIBUS), DB20 set as accessible from HMI.

Step 1 - Configure PLC DB

1. Add DB20 with the array layout above.
2. Set DB attribute Optimized block access = OFF if you must address by absolute offset, or leave ON and use the symbolic access mode for HMI tag pointers.
3. Compile the S7 program and download to the CPU.

Step 2 - Create HMI Tags

1. Open the HMI device, navigate to HMI Tags.
2. Create internal tag Overview_Index (type Int, range 1..30, start value 1).
3. Create external tags Motor_Current, Motor_Speed, Motor_Status, Motor_FaultCode. Connection: the S7-1500 PLC; DB20; for each, configure the address range and enable multiplexing with index tag Overview_Index.

Step 3 - Build the Faceplate

1. Open the Faceplate Editor, create a new faceplate Motor_Faceplate.
2. Add interface tags: IF_Current (Real), IF_Speed (Real), IF_Status (Word), IF_FaultCode (UInt).
3. Place visualization elements (bar, I/O field, status icon) and bind them to the interface tags.
4. Compile and release the faceplate.

Step 4 - Place the Faceplate Container

1. Open the screen Motor_Overview.
2. Insert a faceplate container, choose Motor_Faceplate as the type.
3. Bind the container's interface to the multiplexed tags Motor_Current, Motor_Speed, etc.
4. Insert Next and Previous buttons with events that increment / decrement Overview_Index (clamp at 1 and 30).

Step 5 - Build the Status Grid

1. Insert a grid of 30 small color indicators (rectangles or status icons).
2. For each cell, wire the color animation to Motor_Status with a per-cell constant index using a separate internal tag (e.g. Cell_01_Index ... Cell_30_Index) each pre-loaded with the cell number. The multiplexed Motor_Status tag evaluates each cell independently.
3. Alternatively, use a VBS loop on screen start that rotates one multiplex index and writes 30 status values into an internal array; this avoids the constant-index tag overhead but introduces a small startup delay.

Verification Procedure

1. Compile the HMI project. Resolve any "multiplex index out of range" warnings.
2. Download to the panel. Start runtime.
3. Open the trace / tag monitor on the panel (Tools → Diagnostics → Tags). Confirm that Overview_Index updates and that Motor_Current shows the value of the selected motor.
4. Force a value in the PLC for motor 5 (DB20.DBD64 if stride 16, motor 5 = offset 64). Verify the HMI displays it after setting Overview_Index = 5.
5. Use the navigation buttons to step 1..30. Verify faceplate values change accordingly.
6. Run the panel for 24 hours under nominal load. Inspect the diagnostic buffer for "tag update failed" entries. None should appear.
7. Check CPU cycle time: address multiplexing adds no CPU load, but the HMI connection cycle must be sized for the tag count. A Comfort Panel default acquisition cycle of 1 s for ~200 multiplexed tags is typical.

Troubleshooting Matrix

Engineering Best Practices

• One block type per object class on the PLC side. Wrap each motor or filter in its own FB; place all instances in a cyclic OB (OB1 or OB35). This decouples the HMI from absolute addresses and makes the FB reusable.
• Symbolic PLC tag pointers for Unified Comfort Panels. When you use symbolic addressing, the HMI multiplex factor becomes symbolic and is immune to optimization reshuffles.
• Keep one DB per object class. Mixing motors, valves, and PID blocks into one DB makes address multiplexing fragile; one DB per class with a consistent stride is easier to scale.
• Document the multiplex factor in the tag comment. Example comment: "Multiplex factor 4 (REAL stride), index tag Overview_Index, base offset 0, array Motor[1..30]".
• Set the HMI acquisition cycle to the process cycle. For motors, 1 s is usually adequate. For dosing or fast valves, drop to 100 ms but verify CPU load.
• Use a faceplate release cycle. When you change a faceplate, all instances update on next HMI compile / download. Avoid mid-shift changes if the process is running.

Migration Notes: WinCC Flex → TIA Portal

Older WinCC Flex projects (TP177, MP277, Comfort Panels) can be migrated to TIA Portal WinCC Professional or Unified. Address multiplexing is supported on Comfort Panels in TIA Portal V14 SP1 onward. The classic WinCC Flex projects that used the indirect-tag-and-script pattern continue to work after migration, but should be progressively converted to address multiplexing for performance reasons. The migration tool is launched via Project → Migrate project. After migration, validate all multiplexed tags with the procedure above.

FAQ