OP73 Dynamic Text Lists with Tag Variables in WinCC Flexible

Overview

Text lists are a fundamental feature in WinCC Flexible that map an integer tag value to a textual description. On panels that support dynamic text lists, individual entries can contain tag references such as <tag Tag_name>, allowing the runtime text to be composed from live process values at the moment the entry is rendered. The Siemens OP73, configured with WinCC Flexible 2008, does not support dynamic text lists. Engineers who need to display multiple variable values on a single line of the OP73 display must use static text lists driven by an integer index tag and place the variable values in adjacent I/O fields, or push string composition back to the S7 controller.

This reference documents the OP73 hardware and software baseline, the <tag> insertion procedure (for panels that do support it), three field-proven workarounds for the OP73 limitation, a step-by-step build of the three-column "Name | Value | Value" status display that motivated the original question, the commissioning checks that confirm a multi-variable display works at runtime, and the migration path to a panel that supports the feature natively.

OP73 Hardware and Software Baseline

The OP73 belongs to the SIMATIC 70-series HMI family, programmed with WinCC Flexible 2008 (SP2 through SP5 depending on the panel firmware and the host Windows version). The panel connects to a SIMATIC S7-200, S7-300, or S7-400 controller over PPI, MPI, or PROFIBUS DP. For the configuration workstation, engineers use the WinCC Flexible Engineering Station on Windows XP SP3 or Windows 7 SP1. WinCC Flexible was the engineering environment before TIA Portal; the last service pack that includes the OP73 device catalog is WinCC Flexible 2008 SP5.

Text List Concepts in WinCC Flexible

WinCC Flexible distinguishes two text list scopes that govern how the list is rendered at runtime:

• Static range - The list contains a fixed set of entries configured offline. The runtime simply selects an entry by index, no list-composition logic is executed on the panel side. This is the only mode the OP73 supports.
• Dynamic range - Entries can be supplied by the controller or recomposed at runtime. Dynamic text lists permit tag references inside the list text (the <tag Tag_name> notation), so a single entry can include the value of a tag at the moment the entry is rendered.

The index that selects the entry is always a separate integer tag. The list itself is a resource on the panel; the tag is the pointer into the list. For a list with five entries, valid index values are 0 through 4. If the index is out of range at runtime, the panel shows the entry configured for index 0 (or an empty cell, depending on the firmware).

Why OP73 Cannot Use Dynamic Text Lists

Dynamic text lists require runtime text-composition logic in the panel firmware: the runtime must parse the <tag Tag_name> placeholder, look up the live tag value, format the value as a string, and substitute it into the list entry. The OP73 firmware does not implement this composition engine. The panel runtime only supports the fixed index-to-entry mapping of static lists. The panel compiler enforces this by disabling the "Range" selection in the text list properties and rejecting the project if a list is configured with a dynamic range and a tag reference, but the target device is OP73.

This is the root cause behind the outcome reported in field deployments ("I created a dynamic text list in TP270 but couldn't do it in OP73"). The solution is to use a static list indexed by an integer tag, and place any variable content in adjacent I/O fields rather than inside the list entry itself.

Procedure: Embedding a Tag into a Text List Entry (TP270 / Comfort Panels)

When working on a panel that does support dynamic text lists (TP270, MP270, MP370, Comfort Panels), the procedure to embed a tag reference inside a text list entry is:

1. In the WinCC Flexible project tree, expand the panel node and open "Text and Graphic Lists" then "Text Lists".
2. Create a new text list or open an existing one.
3. In the list properties, set the "Selection" or "Range" field to "Dynamic".
4. Add a list entry. In the "Text" cell, right-click to open the context menu and choose the "Insert" > "Tag" item (in German WinCC Flexible: "Einfügen" > "Variable"). The editor inserts a <tag Tag_name> placeholder at the cursor position.
5. Replace the placeholder text "Tag_name" with the name of the desired tag (e.g., Tag1). The final entry text reads <tag Tag1>.
6. Compile and download the project. At runtime, the panel substitutes the live value of the tag into the rendered list entry.

The right-click insertion detail is a frequent stumbling block; the placeholder syntax <tag ...> looks ordinary enough that engineers type it manually and find that the editor refuses it as plain text. Always use the context menu. The same applies to multilingual projects: the menu label changes but the right-click path is identical.

You can embed more than one tag reference in a single list entry. For example, the entry text Mode: <tag ModeWord> Step: <tag StepNumber> renders at runtime as a single line that mixes literal text with the live values of ModeWord and StepNumber.

Workaround 1: Indexed Static Text List on OP73

The most common OP73 substitute for a dynamic text list is a static text list driven by an integer "index" tag, with the variable values drawn from separate I/O fields placed adjacent to the list output field on the screen. The pattern below is field-proven on OP73 with WinCC Flexible 2008 SP5.

Configuration steps:

1. Create a static text list named, for example, TL_Mode with fixed entries "Auto", "Manual", "Service", "Fault", "Setup" (5 entries for indices 0 through 4). Do not switch the list to the dynamic range; the editor will not allow it on an OP73 target.
2. Create an integer tag MW10 mapped to a data word in the S7 controller (for S7-200, this would be VW10 in the variable area; for S7-300, this is a data word in a configured DB). The controller writes the index 0 through 4 to MW10 based on the current mode.
3. On the screen, place a "Text" object linked to the TL_Mode list. Set the text object's "Tag" property to MW10. The list will display "Auto" / "Manual" / "Service" / "Fault" / "Setup" according to the value of MW10.
4. Place separate "Output Field" objects for the variable values (e.g., Variable1, Variable2, Variable3) next to the text object. Format the I/O fields to match the desired column width. For decimal integer display with leading zeros, configure the format string to "999" (3-digit zero-padded) or "99" (2-digit) as appropriate.
5. For the "Name 1 / Name 2 / Name 3" header row, place a static text object with the labels separated by spaces. The OP73 micro's 160 x 48 pixel display accommodates approximately 20 characters per line at the default font; plan column widths carefully.
6. Compile, simulate offline, and transfer the project to the panel.

Workaround 2: Multi-Field I/O Display

If the project does not need a textual "mode" but only needs three variable values laid out as "Variable1 Variable2 Variable3", drop the text list entirely and use three I/O fields placed on the same line. WinCC Flexible will left-align each field and the visual result matches a dynamic text list without invoking the unsupported feature.

1. Drop three "Output Field" objects onto the screen, sized for the desired character width (e.g., 6 characters each, which on the OP73 micro is approximately 48 pixels per field at the 8-pixel character cell).
2. Configure each field to display the corresponding tag (Variable1, Variable2, Variable3) in decimal string format with the right number of leading zeros.
3. Insert a leading static text object for the column header "Name1 Name2 Name3" if the design requires it.

This approach has the advantage of requiring no list resource on the OP73 and supports 1-second polling for sub-second updates, depending on the configured acquisition cycle. The CPU load on the panel is also lower than with a list-based display because there is no per-frame list-lookup logic.

Workaround 3: PLC-Indexed String Composition

For sites that must keep the visual layout of a "dynamic" list (single line of mixed text and numbers) on an OP73, push the composition to the S7 controller and use a single string tag that the panel displays directly.

1. In the S7-300 (or S7-400), allocate a string tag in a data block, e.g., DB10.DBB0 as a 20-character STRING[20]. In the S7-200, allocate a byte array of length 22 in the variable area (2-byte header + 20 bytes of character data), and use the Siemens "STRING" library to set and concatenate strings.
2. In the controller logic, concatenate the literal labels and the integer-to-ASCII conversions of the three variables into the string on each scan, or on a change event (rising edge of any of the three source values).
3. On the OP73, place a single Output Field bound to that string tag, formatted as a string. The panel displays the controller-built line directly without using any text list.

Sample S7-300 STL fragment (assumes DB10.DBB0 is the STRING[20] destination and MW100, MW102, MW104 are the three integer variables):

// Initialize the destination string header to length 0
L 0
T DB10.DBB0        // current length
T DB10.DBB1        // max length (left at 20)

// Build "V1= V2= V3=" using CONCAT + I_STRNG
CALL FC30  // or use built-in CONCAT / I_STRNG
  IN1 := 'V1='
  IN2 := MW100  // integer source 1
  RET_VAL := DB10.DBB20  // intermediate

This method is the closest behavior to a dynamic text list, but it consumes string-handling CPU on the controller. For an S7-200 with limited native string support, the Siemens "STRING" library is required. The S7-300 / S7-400 platform has native CONCAT and DI_STRNG / I_STRNG instructions that make this straightforward.

Building a Three-Column Status Display on OP73

The original problem statement was: Name 1 Name 2 Name 3 / "Variable1" "Variable2" "Variable3" where the text is selected by a binary-coded integer (e.g., MW10 = 7 means "Text7"). A full implementation on OP73 using Workaround 1 follows.

The runtime behavior matches the TP270 dynamic list visually: changing MW10 swaps the label, and the three I/O fields update independently as their tags change. The state machine below illustrates the controller-side logic that writes MW10 in response to mode changes.

Verification and Commissioning

1. Compile check - In WinCC Flexible, run "Project > Compiler > All". The compiler must report zero errors and zero warnings for the OP73 target. A warning such as "Dynamic text list on device without dynamic support" indicates a project violation; revert the list to static range.
2. Offline simulation - Use "Project > Start Runtime Simulation". Set the index tag (e.g., MW10) to 0, 1, 2, 3, 4, 5, 6, 7 in the simulator's tag table and confirm that the text list updates accordingly. The I/O fields should also update when their tags are forced to test values.
3. Online download - Transfer the project to the OP73 via PPI/MPI or via Ethernet (for OP73 variants with the Ethernet option). Use WinCC Flexible's "Transfer" mode. The panel will restart automatically; allow 30-60 seconds for the project to be written to flash and the runtime to start.
4. Live tag test - From the controller's programming software (STEP 7 Micro/WIN for S7-200 or STEP 7 / TIA Portal for S7-300), force the index tag to each valid value and verify the panel display. Force each variable to a known value and verify the I/O fields update.
5. Polling cycle check - In WinCC Flexible, the acquisition cycle for tags is configured in the connection properties. The default is 1 second. If a sub-second update is required, switch the variable tags to "Cyclic Continuous" with the desired update rate; be aware that high update rates on PPI/MPI can saturate the bus.
6. Display boundary test - At runtime, set each variable to its maximum expected value and confirm the displayed string does not overflow the I/O field width. Truncation on the OP73 silently clips the right side of the field; consider widening the field or using leading-zero suppression to fit typical values.
7. Power-cycle test - Power the panel off, wait 10 seconds, and power it back on. The OP73 should retain the project in flash and restart the runtime automatically. Confirm the index tag and variable tags display the latest values within one polling cycle after restart.

Field Notes and Caveats

• Tag case sensitivity - WinCC Flexible preserves the tag name as written in the project tree. The <tag Tag_name> placeholder in a text list entry (on panels that support dynamic lists) is matched case-sensitively against the tag database. <tag MW10> will not match a tag named mw10.
• Right-click vs menu insertion - The context menu item is labeled differently in localized versions of WinCC Flexible (German: "Einfügen > Variable"; English: "Insert > Tag"). When the item is missing, the project tree's "Tags" node has not been compiled, the panel device is wrong, or the list is on a device that does not permit the dynamic range.
• OP73 vs OP73 micro - The OP73 (5.7-inch) and the OP73 micro (3-inch) share firmware family but have different per-device limits on tags, lists, and screens. Always check the device manual in the WinCC Flexible catalog for the exact variant you are commissioning.
• Migration path - Projects that need dynamic text lists should consider migrating the HMI to a Comfort Panel (TP700 / TP900 / TP1200 Comfort) configured in TIA Portal V13 or later. TIA Portal supports dynamic text lists with tag references, including the same conceptual substitution in the newer editor. The Comfort Panel uses {Tagname} syntax in some text list entry contexts, or the dedicated "Insert Tag" function. Plan the migration as a controlled project: convert the WinCC Flexible project with the TIA Portal migration tool, re-validate the text list logic on the simulator before commissioning on-site.
• RS-485 bus load - The OP73 typically runs on PPI/MPI at 187.5 kbit/s or 1.5 Mbit/s. Adding multiple high-update-rate tags can slow bus response for other nodes; profile the tag acquisition cycles to keep the bus healthy. If the bus is shared with a third-party device, drop the OP73 polling rate to 2 seconds.
• String tag length - When using Workaround 3 (PLC string composition), the destination string length must include the literal labels plus the maximum expanded value. A 20-character string with the layout V1=999 V2=999 V3=999 consumes exactly 20 characters at the max value. Add a 2-character margin to allow for negative signs or decimal points.
• Empty list entries - If the index tag is initialized to a value that has no corresponding entry in the list, the OP73 will render a blank cell, not a fallback. Always pre-initialize the index tag to a valid value (typically 0) in the controller startup OB / first-scan flag.

OP73 vs TP270 vs Comfort Panel: Feature Comparison

Migration to a Panel That Supports Dynamic Text Lists

When the application cannot be reformulated with static lists and adjacent I/O fields, the practical path is to replace the OP73 with a current-generation Comfort Panel. The substitution is not a like-for-like hardware swap: the Comfort Panel uses a different image, more power, and a TIA Portal project. The migration steps are:

1. Export the WinCC Flexible project to a TIA Portal-compatible format using the TIA Portal migration tool. The tool translates text lists, tags, and screens; dynamic text lists configured in WinCC Flexible are converted to TIA Portal's equivalent.
2. Re-validate the converted project in the TIA Portal PLCSIM + HMI simulator. Confirm that the <tag ...> entries in text lists render correctly in the simulator before commissioning on-site.
3. Replace the OP73 panel with the Comfort Panel at the cutover. Re-wire the PPI/MPI cable to the Comfort Panel's PROFINET port (via a PROFIBUS-to-PROFINET gateway if the controller is still PROFIBUS-only) or to a PN/PN coupler if both ends are PROFINET.
4. Download the TIA Portal project to the Comfort Panel, perform a full commissioning check using the same tag-forcing procedure as for the OP73.

Common WinCC Flexible Compiler Messages on OP73

FAQ