Resolving Orange Multiplexer Tag Warnings in WinCC Faceplates

Problem Summary

Engineers using WinCC Flexible 2008 SP2 Update 12 who bind a multiplexer tag to the tag interface of a custom faceplate instance observe that the tag icon in the project tree renders in orange even though the project compiles without errors and the runtime simulator behaves correctly. Status fields update, control bits written from inside the faceplate are processed by the controller, and the multiplexed instance addresses switch as expected when the index word changes. Despite this apparently correct behavior, the orange marker is a Siemens qualification warning: the configuration uses an internal code path that has not been released as supported product behavior in WinCC Flexible and that is carried forward into TIA Portal WinCC Professional V11+ and WinCC Unified without an official fix.

This article documents the root cause confirmed by Siemens technical support, the officially supported workaround using a pointer tag, the step-by-step conversion procedure, the verification checklist, and the migration path to current TIA Portal versions.

Technical Background: Faceplate Tag Architecture

A WinCC Flexible faceplate is a reusable HMI screen object defined once in the project library and instanced multiple times across process screens. Each instance exposes a tag interface that maps internal placeholder tags to real controller addresses at the call site. The tag interface is the contract between the faceplate template and the underlying STEP 7 PLC program.

Interface Element	Direction	Purpose
Process tags	Bidirectional	Live process values read from and written to the PLC
Internal tags	Local	Helper variables used only inside the faceplate body
Pointer / indirect addressing	Configuration	Specifies which controller address each instance binds to at compile time
Tag selection toggle	Runtime	Optional on-the-fly switch between two alternative tag sources for the same faceplate instance

When an instance is dropped onto a process screen, every interface tag must be bound to either a fixed absolute address or to an indirect mechanism. Two indirect mechanisms are available in WinCC Flexible 2008 SP2: multiplexer tags and pointer tags. Both reduce engineering effort when one faceplate template represents dozens or hundreds of similar drives, valves, or motors.

Multiplex Tag vs Pointer Tag

Property	Multiplex Tag	Pointer Tag
Index source	Separate index word updated at runtime	Full destination address baked into tag definition
Compile-time resolvability	Index is dynamic; address resolved by RT	Statically resolved by the ES compiler
Project-tree icon	Black under normal use; orange when bound to faceplate interface	Black when destination resolves; red when destination is invalid
Use inside faceplate interface	Not released as supported	Documented pattern; recommended for faceplate bindings
Sample use case	Dynamic bar-graph pointer in a single screen object	Multi-instance popup faceplate for 40 identical motors

The functional difference at runtime is small, but the qualification difference is large. Siemens documentation and example projects for dynamic positioning and multiple addressed blocks explicitly recommend the pointer-tag pattern for faceplate use; the multiplexer-tag pattern is intended for screen-level dynamic addressing on direct screen objects (IO fields, bar graphs, text lists), not for faceplate interface bindings.

What the Orange Tag Icon Means

WinCC Flexible uses a small color-coded icon next to every tag entry in the project tree. Engineers familiar with TIA Portal will recognize the same scheme. The interpretation is:

Color	Status	Action Required
Black (default)	Tag is correctly configured and bound to a valid controller address	None
Red	Compile error, broken link, or address outside the configured PLC area	Fix binding before transfer
Orange	Warning: configuration is not officially supported; tag will compile and run but Siemens does not guarantee behavior or future compatibility	Replace with a supported binding
Gray	Tag is disabled, not yet linked, or excluded from the current compile scope	Re-enable if intended

An orange marker therefore is not a hard fault. WinCC Flexible produces a compiled RT file and the faceplate runs correctly in the RT simulator. The marker is a heads-up that the project relies on an internal code path that Siemens has not qualified for faceplate use. This is why the same restriction carries forward into TIA Portal WinCC V11 and remains in place in WinCC Unified V17 / V20.

Root Cause Confirmed by Siemens

Multiplex tags in WinCC Flexible are designed for screen-level dynamic addressing, where a separate index register is updated at runtime to swap the active DB number or offset for one tag reference. They are intended for direct screen objects, not for faceplate interface bindings. Binding a faceplate instance's tag interface to a multiplex tag extends the feature into territory that has not been released as supported product behavior.

The same limitation exists in TIA Portal WinCC Professional V11 onward. WinCC Professional exposes the same faceplate model with tag interface bindings; multiplex tags bound to faceplate interfaces are similarly marked as unsupported. The behavior was therefore not a bug fixed in V11 but a deliberate qualification boundary carried forward into every subsequent release.

Solution: Switch to a Pointer Tag

The officially supported alternative is a pointer tag that directly references the wanted data block. A pointer tag differs from a multiplex tag in three ways:

1. The index is part of the tag definition itself, not a separate index word driven by the runtime.
2. The binding is statically resolvable by the compiler, so the project tree shows a normal (black) tag icon.
3. The pointer tag is documented in Siemens' official examples for dynamic positioning and multiple addressed blocks (Siemens support entry 36435784) and is the path Siemens technical support recommends for popup-faceplate use cases.

The pointer tag holds a fully qualified address (for example DB1200.DBX0.0) as its value. The faceplate reads that address string and binds to the underlying data block at compile time. The end result is functionally similar to a multiplexed faceplate but does not trip the unreleased-code-path warning.

Step-by-Step Implementation

The following procedure assumes WinCC Flexible 2008 SP2 Update 12 and an S7-300 / S7-400 PLC project with one data block per motor (DB1000, DB1001, DB1002, ...). Adjust offsets and DB numbers to match your project layout.

Prerequisites

• WinCC Flexible 2008 SP2 Update 12 installed and licensed.
• STEP 7 V5.5 project with the controller program already compiled.
• One data block per equipment instance (motor, valve, etc.) using a consistent offset map, ideally based on a STEP 7 UDT (User Defined Data type).
• Faceplate template created in the WinCC Flexible library with placeholder tags for status, control, fault, and command.

Step 1 - Define the Pointer Tags

Open the WinCC Flexible project and navigate to Tags > New Tag. For every instance you want to address, create a tag of type Pointer. Use a naming scheme that ties the tag to the equipment:

Motor_Ptr_01    Type: Pointer    Points to: DB1000.DBX0.0
Motor_Ptr_02    Type: Pointer    Points to: DB1001.DBX0.0
Motor_Ptr_03    Type: Pointer    Points to: DB1002.DBX0.0
Motor_Ptr_04    Type: Pointer    Points to: DB1003.DBX0.0

The pointer tag's destination is the absolute address of the data block you want the faceplate instance to bind to. Using a UDT in STEP 7 ensures all DBs share the same layout, so any one of them is acceptable as a binding target.

Step 2 - Bind Faceplate Instances to Pointer Tags

Insert the faceplate on the process screen. In the faceplate configuration dialog, map each interface tag to the appropriate pointer tag instance. Example for Motor_03:

Faceplate Interface Tag	Direction	Bound Pointer Tag
Status_Word	Read	Motor_Ptr_03.Status
Control_Word	Write	Motor_Ptr_03.Control
Fault_Code	Read	Motor_Ptr_03.Fault
Cmd_Start	Write	Motor_Ptr_03.Start
Cmd_Stop	Write	Motor_Ptr_03.Stop
Cmd_Reset	Write	Motor_Ptr_03.Reset
Actual_Speed	Read	Motor_Ptr_03.Speed

After the binding, verify the tag icons in the project tree are all black. An orange pointer tag would indicate that the destination DB is offline, missing from the STEP 7 connection, or that the offset is outside the configured area.

Step 3 - Implement the "Popup Feel" Trigger

WinCC Flexible does not include a native modal popup system. The accepted pattern is to stack the faceplate as a graphic object above the process screen, drive its Visible property from a discrete tag (for example Popup_Active), and position it over a darkened background rectangle. Wire Visible of the popup faceplate to the tag via an animation or a direct property linkage. The user then clicks the underlying motor icon on the screen to set Popup_Active = TRUE, which brings the popup faceplate into view.

Optional: a VBScript in the faceplate body can compute the popup position relative to the clicked icon, so the popup appears next to the originating motor rather than in a fixed screen location.

Step 4 - Compile and Stage

Compile the project with Project > Compiler > All. The output should report zero errors and zero warnings relating to tag binding. Transfer the compiled RT to the target panel (or run the simulator) and click each motor icon to confirm:

1. The popup faceplate appears at the correct screen position.
2. Status fields reflect the live value of the bound DB.
3. Control buttons write back to the correct DB and the controller responds.
4. Closing the popup clears Popup_Active and hides the faceplate cleanly.
5. Two popups opened simultaneously (on dual-touch panels) do not cross-bind data.

Verification Checklist

Check	Method	Expected Result
No orange tag icons in project tree	Expand the Tags node and visually scan	All tags show black or red icons only
Compile is clean	Project > Compiler > All	Zero errors, zero warnings
Simulator reflects live values	RT simulation with PLCSIM	Status fields change when DB values change
Control writes round-trip	Click Start / Stop in popup	DB bits toggle in PLCSIM VAT table
Pointer tag destinations valid	Right-click pointer tag > Properties	Destination address resolves to a configured PLC area
Multiple instances independent	Open popup for motor A and motor B	Each popup binds to its own DB; no cross-talk
Touch behavior on real panel	Physical finger taps on each button	Every tap registers, no double-fire, no missed taps

Migration Path to TIA Portal and WinCC Unified

Engineers maintaining a WinCC Flexible 2008 project on a long-running line should plan a migration to TIA Portal WinCC Professional or WinCC Unified. Faceplate architecture in both targets is more mature than the WinCC Flexible implementation, with first-class support for tag interfaces, multi-instance faceplates, and dynamic instantiation. However, the multiplex-tag-in-faceplate restriction carries forward, so the pointer-tag pattern you implement now is also valid in the new environment.

WinCC Professional (TIA Portal V11+)

In TIA Portal WinCC Professional, faceplate interfaces expose the same binding pattern. Multiplex tags can still be defined at the HMI tag level but should not be bound to a faceplate instance interface. Use a pointer tag, a fixed DB number per faceplate instance, or the faceplate's built-in interface tag with a fixed connection. The orange diagnostic still appears if you attempt the unreleased configuration.

WinCC Unified (TIA Portal V17+)

WinCC Unified introduces a redesigned faceplate concept with explicit tag interface properties exposed under the Miscellaneous > Interface division in the faceplate properties. Tags declared in the tag interface are surfaced as bindable properties in the called faceplate. Address multiplexing is supported at the tag level for RT (Runtime) tags in WinCC Unified, with one HMI tag addressing a large number of memory locations in the PLC. The official configuration is documented at Address multiplexing (RT Unified) in the TIA Portal V20 documentation set. Multiplexing in WinCC Unified is a tag-level feature; it is still not the recommended path for faceplate interface binding. Continue using pointer-style bindings or fixed DB numbers.

Troubleshooting Matrix

Symptom	Likely Cause	Corrective Action
Tag icon orange, compile clean, RT works	Multiplex tag bound to faceplate interface	Replace with pointer tag bound to a specific DB
Tag icon red, compile error on address	Pointer tag destination outside PLC area	Re-point to a configured DB; check connection and rack / slot
Tag icon orange after migration to TIA Portal	Multiplex tag carried over from WinCC Flexible	Re-bind to pointer tag or to a fixed DB number in V11 / V16 / V20
Popup faceplate shows the same DB for every motor	All instances bound to the same pointer tag	Verify each instance has its own pointer tag; check the faceplate instance number
Control write does not reach the PLC	Pointer tag acquisition mode is read-only or polling cycle too long	Set acquisition to On demand / cyclic on write; reduce cycle to 1 s or less
Compile error: tag not found in connection	STEP 7 connection not synchronized	Run Update connection from WinCC Flexible; rebuild the S7 connection
Orange icon only after SP / HF update	Behavior change in ES version	Re-validate each faceplate binding; convert any multiplex-in-faceplate to pointer
Popup closes but Popup_Active stays TRUE	No reset event wired on the close button	Add an event-driven tag assignment on the close button to clear Popup_Active
Pointer tag shows black in ES but red after transfer	PLC not online at compile time; rack / slot mismatch	Bring PLC online; verify S7 connection parameters; re-compile

Faceplate Scripting Considerations

Faceplates in WinCC Flexible 2008 SP2 support VBScript inside the faceplate body and on tag-change events. When migrating from a multiplex-in-faceplate implementation to a pointer-tag implementation, audit every VBScript function inside the faceplate for the following patterns:

• SmartTag("Multiplex_Index") references that update the index word at runtime - these become unnecessary once a pointer tag binds the address statically.
• Direct HMIRuntime.Tags(...).Write calls that bypass the tag interface and write to a raw address - replace with SmartTag("Cmd_Start") to keep the indirection centralized.
• Cross-references to a tag name that exists only on the multiplex tag object - rename or alias after the conversion.

A simple helper to detect remaining multiplex-in-faceplate references after the conversion is the following ES-side search pattern:

Find:    "Multiplex" in tag name
Scope:   All faceplate interfaces in the project
Expect:  Zero matches after conversion

Field-Commissioning Notes

When rolling out a faceplate-heavy project to a panel on the plant floor, do the following in addition to the engineering steps above:

• Document every pointer tag and its destination DB in a tag list (CSV or Excel) so the maintenance crew can trace an instance back to the PLC data block.
• Export the WinCC Flexible project source and store a copy alongside the STEP 7 project source.
• Test every faceplate instance from the actual panel, not only the simulator. Differences in touch behavior, screen latency, and pointer-tag refresh rate can surface issues that the simulator hides.
• If the panel supports a firmware update in the future, plan a regression test for every popup-driven faceplate. Pointer-tag bindings are stable across ES patches; multiplex-in-faceplate bindings have historically been the first thing to break after a WinCC Flexible patch.
• Enable the change-log on the panel so every operator action is timestamped; this helps correlate popup writes with controller events during commissioning.

Safety and Operational Considerations

A popup faceplate for manual motor control is a write path into the controller. Treat the binding conversion from multiplex to pointer tag as a functional-safety-relevant change and document it in the change log. Validate the following before energizing any motor under manual control:

• The pointer tag destination DB matches the DB number printed on the motor drawing, not the DB number used in the simulation only.
• Permission levels on the faceplate Start / Stop buttons enforce the operator role defined in the safety plan.
• An independent hardware interlock (E-stop, contactor) backs up the software write path; the popup must never be the only barrier to motion.
• The write is acknowledged by the controller before the faceplate clears; a non-acknowledged write must surface as a fault on the popup, not as a silent failure.

Summary

An orange tag icon next to a multiplex tag bound to a WinCC Flexible faceplate interface is not a fault but a qualification warning. Siemens has confirmed that multiplex tags inside faceplates are not released as supported behavior in WinCC Flexible 2008 SP2 Update 12 or in TIA Portal WinCC V11 onward. The supported workaround is to bind each faceplate instance to a pointer tag that directly addresses the target data block. The pattern migrates cleanly into TIA Portal WinCC Professional and WinCC Unified, and remains the recommended path for popup-style multi-instance faceplates. Document the conversion, validate the destination DBs against the motor drawings, and verify every instance from the real panel before commissioning.