Displaying UDT Tagname in WinCC Faceplates (TIA V14 SP1)

Problem Overview and Engineering Context

When you instantiate a faceplate in WinCC Advanced V14 SP1 from a UDT (user-defined data type) array in an S7-1500 data block, the faceplate instance inherits the entire UDT structure through its interface tag. The PLC tag that contains the UDT - for example XV131, XV167, or XV192 in DB_Motors - is bound to the faceplate container as a single multi-instance handle. The data fields such as value, description, and unit flow into the faceplate through the interface tag members, but the actual symbol name of the PLC tag (XV131) does not automatically appear on the runtime screen.

Engineers typically want three pieces of operator-facing information on each faceplate instance: the loop tag name (the P&ID or loop number identifier), the engineering description ("pressure tank 1"), and the live process value with its unit ("34.7 bar"). The value and unit are direct numeric or string members of the UDT and bind trivially. The tagname is more difficult because TIA Portal V14 SP1 does not expose a direct symbolic-name property of an HMI tag inside a faceplate container. The tagname must be transferred into the faceplate explicitly through a configuration mechanism - either through a paired text list, a faceplate property of type WString, or a VB script that reads the Name property of the source HMI tag at runtime.

This article documents the three engineering patterns that solve this problem in TIA Portal V14 SP1 with WinCC Advanced RT, and contrasts them with the WinCC Unified V21 method that uses a PLC user data type directly as a faceplate type interface. The V14 SP1 patterns remain relevant for installed-base systems and continue to ship in current TIA Portal releases; the Unified pattern is the recommended path forward for new projects.

Prerequisites and Software Configuration

Before starting the faceplate engineering, verify the following software and project configuration. Each item maps to a specific menu or device property; failing any one of them produces the most common error conditions in this scenario.

• TIA Portal V14 SP1 (product version 6.0.3) or later, including Update 4 (V14 SP1 Update 4 - product version 6.0.4) for the issues fixed in Entry ID 68014632 - Faceplates Engineering Examples.
• WinCC Advanced V14 SP1 Runtime on the HMI device, license WinCC RT Advanced (6AV2104-0...) 2048 PowerTags minimum for faceplate use.
• PLC: SIMATIC S7-1500 with firmware V2.0 or higher. UDT-based symbolic HMI access requires CPU firmware V1.8 or higher for PUT/GET with optimized block access.
• HMI tags must be configured for symbolic access: in the HMI tag table, the Access mode column for each tag must be set to Symbolic access, not Absolute access. Tags pointing to UDT members should be bound to the symbolic DB member, e.g. "DB_Motors".XV131.value rather than %DB10.DBX0.0.
• Faceplates require that the WinCC Advanced project be on the same TIA Portal installation and that the HMI device support faceplates; Comfort Panels, RT Advanced, and PC RT all support faceplates from V14 SP1 onward.

The Siemens PDF manual Faceplates Engineering Examples walks through Example 1 (page 63) which is the same case used in the field report and is the recommended companion to this article.

UDT Design in the S7-1500 Project

Define a UDT with the structure shown below. The UDT name must be unambiguous across the PLC program because it is referenced both in the DB and in the HMI tag table.

// UDT "udtAnalogTag" - version 1.0
TYPE "udtAnalogTag" :
VERSION : 0.1
  STRUCT
    value : REAL;            // process value, REAL engineering units
    description : STRING;    // operator text, 32 chars incl. terminator
    unit : STRING;           // unit string, 16 chars incl. terminator
    id : INT;                // text list index for tagname display
    limitLow : REAL;         // low alarm limit
    limitHigh : REAL;        // high alarm limit
    quality : BYTE;          // quality code 0..255
  END_STRUCT;
END_TYPE

Reserve the description field at 32 characters and the unit field at 16 characters. The default STRING length in TIA Portal is 254 characters, but each character costs two bytes in optimized blocks. Sizing the strings to the maximum expected loop text keeps the data block footprint under the S7-1500 work-memory limit and reduces the HMI tag update time.

Create a global data block, for example DB_Motors, in the PLC program blocks. Declare each instance as a member of the UDT. Do not declare individual members - declaring XV131.value, XV131.description, and so on, defeats the point of the UDT and produces a flat tag list in the HMI that is impossible to bind as a faceplate container.

DATA_BLOCK "DB_Motors"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
  STRUCT
    XV131 : "udtAnalogTag";    // pump 1 speed
    XV167 : "udtAnalogTag";    // pump 2 speed
    XV192 : "udtAnalogTag";    // pump 3 speed
    TT351 : "udtAnalogTag";    // tank 1 temperature
    PT350 : "udtAnalogTag";    // tank 1 pressure
  END_STRUCT;
END_DATA_BLOCK

Open the block properties of DB_Motors and confirm that the Optimized block access checkbox is set. Optimized access is required for symbolic HMI access; if you clear it, every HMI tag that points to a UDT member resolves to absolute addressing and the faceplate container binding fails.

Configuring HMI Tags for Symbolic UDT Access

Open the HMI tag table in TIA Portal and add a tag for each UDT instance. The tag name should match the PLC tag name so that the operator can correlate the HMI faceplate with the PLC program. The connection must point to the S7-1500 PLC and the access mode must be Symbolic.

Do not create individual tags for each UDT member (XV131.value, XV131.description, and so on). One tag per UDT instance is sufficient. The faceplate will dereference the UDT members internally through the interface tag.

WinCC Advanced V14 SP1 Faceplate Architecture

A WinCC faceplate is a reusable HMI screen object built from a faceplate type. The type defines an interface with one or more interface tags; each container instance on a process screen binds its interface tag to a specific HMI tag of the matching data type. For UDT instances, the interface tag must have the same UDT data type as the source HMI tag, e.g. udtAnalogTag.

Open the HMI device folder in the project tree, right-click Faceplates, and select Add new faceplate type. Rename the type to fp_AnalogTag. In the Tag interface tab, add a new interface tag named tagData with the data type udtAnalogTag. The faceplate engine uses the data type to enforce that only compatible HMI tags can be bound to the container.

Add the following interface properties for the values that cannot be extracted from the UDT data type alone:

• propTagname - WString[32] - operator-facing loop identifier, passed in by container
• propDescription - WString[64] - long text passed in by container (optional - if description is short, the UDT string can be used directly)

These two properties are passed into the faceplate from each container instance. They are parameters that the HMI cannot infer automatically: the loop identifier is not stored in the PLC and the description, while stored in the UDT, may be replaced for translation purposes.

Configuring the Text List for Tagname Display

A text list is the most direct method for mapping a numeric value to a display string. Create one text list per UDT instance family; do not create a global text list with hundreds of entries, because the HMI loads the entire list into runtime memory and a 500-entry list on a Comfort Panel consumes noticeable flash space.

Open the HMI project, right-click Text and graphic lists, and add a new text list. Configure the settings as follows:

For each faceplate container instance, add one entry to the text list. The Value column holds an integer that you assign in the program - typically the index of the instance in the DB. The Text column holds the loop identifier that the operator sees on the screen.

To make the value range portable, define a constant block in the PLC program and initialize the id member of each UDT instance with the corresponding constant value at startup. The faceplate reads tagData.id and uses it as the input to the symbolic I/O field that selects the text list entry.

Binding the Symbolic I/O Field in the Faceplate

Open fp_AnalogTag in the faceplate editor. Add a Symbolic I/O field to the faceplate layout. Configure the following properties under Properties > General:

• Mode: Output
• Tag: Click the input field, navigate to Faceplate interface > tagData > id
• Text list: tl_LoopTagNames
• Display mode: Text

When the faceplate is compiled, the symbolic I/O field reads tagData.id from the UDT, looks up the matching entry in tl_LoopTagNames, and renders the loop tag name. The operator sees "XV131" on the screen, even though the value that drives the lookup is a plain integer.

For the value field, add a regular I/O field bound to tagData.value with Mode: Output and a numeric format string of 999.9 (one decimal place for pressure and temperature in this project). For the unit, add a text field bound to tagData.unit with Mode: Output. If you want the operator to be able to change the unit dynamically, store the unit in the UDT as designed; if the unit is fixed, omit the unit field from the UDT and set it as a static property of the faceplate type instead.

For the description, add a text field bound to tagData.description. The HMI engine supports STRING binding from UDT members directly; no scripting is required.

Scripted Fallback: Reading the HMI Tag Name Property

When the text list approach is impractical (for example, when the loop identifier list is built dynamically and cannot be pre-loaded), use a VB script in the faceplate to read the Name property of the HMI tag. Place the script on the Loaded event of the faceplate container or on a Value change trigger of the interface tag.

' VB script on faceplate container - Loaded event
Dim sTagName
sTagName = SmartTags("tagData").Name
SmartTags("propTagname") = sTagName

Note that SmartTags("tagData").Name returns the HMI tag's name property, which - when the HMI tag is configured with the same symbolic name as the PLC tag - is "XV131". If the HMI tag is named differently, the script returns the HMI tag name, not the PLC tag name. To keep the two synchronized, use the procedure in the "Configuring HMI Tags for Symbolic UDT Access" section where each HMI tag name matches the PLC tag name.

WinCC Unified V21 Approach: PLC User Data Type Binding

WinCC Unified (TIA Portal V17 and later, with V21 the current documented release) introduces a direct method for using a PLC UDT as the faceplate tag interface. Instead of declaring individual interface members and passing the tagname as a property, you assign the entire PLC UDT type to one faceplate interface tag and the engine exposes the UDT members automatically.

Navigate to Faceplate types > <your type> > Tag interface. In the Name column, add a tag named tagData. In the Data type column, select PLC user data type from the drop-down. The Select PLC UDT dialog opens, showing every UDT declared in the connected PLC device. Select udtAnalogTag. The faceplate type is now bound to the PLC UDT directly, and every member declared in the UDT becomes accessible inside the faceplate as tagData.value, tagData.description, and so on. Reference documentation for the procedure: Using a PLC user data type (RT Unified) - WinCC Unified V21.

To expose the loop identifier in Unified, add a second interface tag of type WString[32] named propTagname and bind it on each container. The PLC UDT does not carry a "tagname" field; the identifier remains a faceplate-level property. The advantage of Unified is that the UDT members no longer need to be declared manually on the faceplate - they are inherited from the PLC UDT, eliminating duplication between the PLC type and the HMI type.

Comparison of V14 SP1 Advanced vs. Unified Approaches

Verification, Commissioning and Live Testing

After the faceplate type is compiled and the HMI tag table is consistent, perform the following verification steps before going live on the plant floor.

1. Compile the PLC program first. The PLC UDT must be known to the HMI tag table before the faceplate can resolve the data type. Compile errors in the PLC block propagate to the HMI and produce 1904: Data type inconsistency at the HMI compile pass.
2. Compile the HMI project. The HMI compiler produces a build log under Project > Documentation > Compile log. Search the log for any Error line - the most common is 1900: Tag "<name>" is not a structure, indicating that an HMI tag bound to a faceplate container is not of the UDT data type.
3. Download to the HMI runtime. Use either the device's SD card, Ethernet, or a USB stick. Confirm the faceplate type files were transferred by browsing \Storage Card SD\Simatic.HMI\RT_Advanced\Faceplates on the Comfort Panel.
4. Online test with watch table. Open the PLC online watch table on DB_Motors, set XV131.value to a known test value (for example 42.0), and confirm that the corresponding faceplate on the HMI updates within one update cycle. The cycle was set to 500 ms in the HMI tag configuration, so allow 1 second for the change to propagate through the HMI buffer.
5. Operator simulation. Trigger a tagname change by switching the text list entry in the PLC (write to DB_Motors.XV131.id) and confirm that the displayed loop tag name follows. A fault in this path usually indicates that the text list Selection mode was set to Bit instead of Value.
6. Audit the file size. The compiled HMI runtime file should not balloon by more than 1 MB per faceplate type. If it grows by more, you have inadvertently created a large number of text list entries or per-instance interface tags.

Common Pitfalls and Troubleshooting Matrix