Multiplexing UDTs on Siemens Comfort HMI Panels in TIA Portal

Overview

Engineers building complex HMI screens on SIMATIC HMI Comfort Panels (TP700, TP900, TP1200, TP1500, TP1900, TP2200) frequently need to operate on dozens of identical process objects - analog inputs, valves, drives, sensors - that all share the same data structure. Creating a dedicated popup screen per object quickly becomes unmanageable: a 200-tag I/O system means 200 faceplates, 200 event chains, and 200 places to fix a bug.

The official TIA Portal Help (V15 / V16) supports two multiplexing modes for Comfort Panels:

• Address multiplexing - the index tag is bound to a configured bit/byte/word offset that the runtime uses to resolve the symbolic tag at display time.
• Symbolic multiplexing - the index tag is bound directly to a symbolic PLC tag (for example an element of an array of UDT); the runtime substitutes the full tag name.

The well-known limitation: symbolic multiplexing does not support PLC UDTs that contain BOOL members used as commands from HMI to PLC. Displaying values is fine; toggling or setting individual bits inside a UDT through the multiplexed pointer is not. This article shows three field-proven workarounds that stay inside the TIA Portal V15/V16 Comfort Panel runtime, validated against the SIMATIC S7-1500 / ET 200MP Manual Collection (TIA Portal V15.1) and the Comfort Panel product catalog (e.g. 6AV2124-0GC01-0AX0 TP700 Comfort).

Prerequisites

Why Symbolic Multiplexing Fails on BOOL Members

The WinCC Comfort runtime resolves a multiplexed tag by replacing a placeholder in the configured tag name with the value of the index tag. The HMI-to-PLC write path for a BOOL field expects a single-bit address, not a bit extracted from a larger structure. When the index points to "MyDB".Analog[7].Value, the runtime can format the value, but it cannot decompose "MyDB".Analog[7].Reset into a writable one-bit command. The dialog box for the connection remains empty and the property disappears from the IntelliSense.

Two structural rules follow from this:

1. You can multiplex REAL, INT, DINT, WORD, DWORD members for display and for numeric input.
2. You cannot multiplex a BOOL member that must be written from the HMI. The only writable symbols that the runtime can substitute are sized to one whole data word (BOOL buttons that are wired to absolute bit addresses still work because they are not multiplexed).

Method 1 - Array of UDT with Symbolic Multiplexing (Display Only)

This is the cleanest method for projects where the operator only needs to read analog values and additional INT/WORD status fields.

PLC side

1. Create a UDT typeAI with members Value : REAL, Raw : INT, HighLimit : REAL, LowLimit : REAL, Status : WORD.
2. Create a global DB DB_AI and add ArrayAna : ARRAY[1..64] OF "typeAI".
3. Add an INT tag iIndex in the same DB (or any DB accessible from HMI).

HMI side

1. Open the HMI tag table. Create one external tag of PLC UDT type for each field you want to display (for example HMI_AI_Value of type REAL, HMI_AI_Raw of type INT). Leave the PLC address empty for now.
2. Open the HMI screen, drop an IO field and open Properties > General > Tag.
3. Switch the tag selection to Multiplex. In Index Tag select the HMI tag that is mapped to the PLC tag "DB_AI".iIndex.
4. Click Multiplexed Tag. In V15.1+ the dialog accepts an array element selector. Use the syntax:

   "DB_AI".ArrayAna[iIndex].Value

   where iIndex is the runtime index HMI tag (must be declared on the HMI side first).
5. Repeat for each member you want to display. Each IO field can use a different multiplexed tag, all driven by the same index.

Driving the index

Bind a "Select" button, a slider, or a screen number to the index tag. Operators then select channel 1..64 and the screen repaints without a popup.

Method 2 - Single Faceplate with Calculated Offset (Mixed Read/Write)

When you must also push commands (start calibration, acknowledge, reset) into the same object, build a single faceplate type, expose every UDT member as a faceplate tag, and call the faceplate with a calculated instance index from a surrounding screen.

Step 1 - Create the faceplate

1. Right-click Faceplates > Add new faceplate. Name it FP_AI.
2. Add faceplate tags of PLC UDT type: FP_AI_Value : REAL, FP_AI_Raw : INT, FP_AI_Ack : BOOL, FP_AI_Reset : BOOL.
3. Place IO fields, bars and buttons on the faceplate. For the two BOOL buttons, leave the Tag field empty - you will wire them through the instance interface.

Step 2 - Provide the instance in the calling screen

1. Create internal HMI tags FP_AI_Value_i, FP_AI_Raw_i, FP_AI_Ack_i, FP_AI_Reset_i of the matching types.
2. In a global script or on the Loaded event of the surrounding screen, compute the address from iIndex and assign it. In V15.1 you can use Tag multiplexing bound to the faceplate tag, with a symbolic index pointing to the same array element as in Method 1.
3. Drop one or more FP_AI instances on the screen. For each instance, set the Tag property of FP_AI_Value to the multiplexed tag "DB_AI".ArrayAna[iIndex].Value, and so on for the other members.

Step 3 - Toggle the BOOL members

Because the BOOL faceplate tags are not multiplexable, expose them as single-bit tags bound to absolute addresses. A clean way is to pack all command bits of all 64 objects into a single data block:

// In PLC DB_AI
CmdBits : ARRAY[1..64] OF WORD;   // 16 command bits per object
// layout: bit 0 = Ack, bit 1 = Reset, bit 2 = Hold, ...

On the HMI, each faceplate instance receives:

FP_AI_Ack   := "DB_AI".CmdBits[iIndex].X0
FP_AI_Reset := "DB_AI".CmdBits[iIndex].X1

Because the entire WORD member CmdBits[iIndex] is multiplexed symbolically, the bit slices .X0 and .X1 can be written from the HMI through the standard BOOL button. The runtime accepts a bit slice of a multiplexed word as a writable target.

Method 3 - Absolute Multiplexing with VB Script (Legacy Style)

Engineers who maintain V13/V14 projects or need to control which physical DB the runtime writes to can use a VB script on the faceplate's Event > Click action. The script manipulates the multiplexed tag's address before it is sent to the PLC.

Configure the multiplex tag

1. Create an HMI tag MV_Ack of type BOOL with Address multiplexing enabled.
2. Configure the offset to one byte, starting at %DB20.DBX0.0. The runtime will substitute DBX0.0 with DBX(n).0 where n = iIndex.

VB script on a button

' SmartTag "MV_Ack" is a faceplate tag
' Index tag is bound at the faceplate instance level
Sub OnClick(ByVal Item)
    Dim i
    i = SmartTag("iIndex")                ' read current object index 1..64
    SmartTag("MV_Ack").Offset = i - 1      ' byte offset into DB20
    SmartTag("MV_Ack").Value = True        ' set the bit
    ' Pulse the command - many PLC programs need a rising edge only
    SmartTag("MV_Ack").Value = False
End Sub

This pattern works because absolute multiplexing on Comfort Panels permits the runtime to resolve a single-bit address at the substituted location. The trade-off is that the script must be reachable on the screen, which forces you to use a faceplate-based event - dropping the script directly on a screen button does not let you change the address at runtime.

Configuration Step-by-Step (Recommended: Method 2)

1. Define the UDT in PLC data types. Keep BOOL commands out of the displayed tag set - put them in a parallel command DB.
2. Instantiate the array in a global DB: Ana : ARRAY[1..64] OF "typeAI" and CmdBits : ARRAY[1..64] OF WORD.
3. Add the index: iIndex : INT in the same DB.
4. Create faceplate tags in the Comfort Panel project for every UDT member you want to show, plus a faceplate tag of type INT for the index.
5. Build FP_AI with IO fields linked to the numeric faceplate tags and two buttons linked to the BOOL tags.
6. Place one FP_AI instance on the screen. Wire each faceplate tag to a multiplexed HMI tag using the syntax "DB_AI".Ana[iIndex].Value, etc.
7. Wire the BOOL buttons to "DB_AI".CmdBits[iIndex].X0 and "DB_AI".CmdBits[iIndex].X1.
8. Bind the index to a numeric input or a screen-selector.
9. Compile and download both the S7-1500 project and the Comfort Panel image.
10. Runtime test by changing iIndex and confirming that all 64 objects display their own values and that the buttons write to the correct CmdBits word.

Verification and Commissioning

Limitations and Edge Cases

• Array bounds - S7-1500 supports up to 65535 elements per array; Comfort Panel symbol resolution degrades above about 200 multiplexed instances in a single screen. Split the array into two screens if you need more.
• String members in UDTs are multiplexable for display only; the HMI cannot write to a STRING member of a multiplexed UDT.
• Nested UDTs (UDT that contains another UDT) are supported as display tags but the multiplexer syntax becomes verbose: "DB_AI".Ana[iIndex].Sub.Value.
• Data blocks optimized for access - if the S7-1500 DB uses the "Optimized block access" attribute (the default for new DBs), the symbolic multiplexer still works; if the DB is set to "Standard" access, the syntax must use absolute addresses inside the array element.
• TP700 memory - 6AV2124-0GC01-0AX0 ships with 12 MB of project memory. A faceplate-heavy project with 50 instances typically consumes 2-4 MB. Plan for 100 instances max per project without an SD card upgrade.

Troubleshooting Matrix

Performance Notes for Large Projects

For a Comfort Panel running 50+ faceplate instances, three settings dominate the perceived responsiveness:

1. HMI acquisition cycle - reduce from the default 1 s to 200 ms for faceplate-relevant tags. This is the single biggest factor.
2. Update of the screen - in the screen properties, raise the "Number of tags to be updated per cycle" to the maximum your panel supports (TP700 = 50, TP1200 = 100, TP1900 = 200). Above these values the runtime queues updates and the multiplex lag becomes visible.
3. PLC cycle time - the S7-1500 OB1 must run below 10 ms for a 64-element array. The PLCSIM simulator in TIA Portal defaults to 100 ms; test on a real CPU before commissioning.

FAQ