Overview
WinCC V7 (SIMATIC WinCC, formerly known as PCS 7 HMI) supports several mechanisms for conditional screen display driven by the state of an internal WinCC tag, a PLC tag, or a derived expression. The two most common production patterns are: (1) embedding a Picture Window object on the process screen and binding its Display property to a binary tag, and (2) placing the pop-up PDL (Process Picture, *.pdl) on a dedicated screen layer and toggling the layer's visibility through the layer object or a direct tag connection. A third, more flexible method uses VBScript actions or global C scripts invoked on tag-change events to call HMIRuntime.BaseScreenName, HMIRuntime.Screens, or SSMOpenScreen / SSMCloseScreen from the WinCC Screen Object Model.
This reference targets the configuration described in the original project context: WinCC V7.0 SP2 with Update 9 running on a Windows SCADA station, with an overview.pdl main picture and a secondary maintenance screen hosting a Picture Window object whose visibility is bound to a Boolean tag. The methods below are equally valid for WinCC V7.2, V7.3, V7.4, V7.5, and the TIA Portal WinCC Runtime Advanced / Professional variants where the underlying property model is preserved.
Prerequisites
- WinCC V7.0 SP2 or higher (Update 9 or later recommended). The Graphics Designer is part of the WinCC Configuration Studio install.
- An active WinCC project with at least one process picture (e.g.,
overview.pdl). - The pop-up picture must exist as a separate PDL file in the project GraCS directory (e.g.,
popup_detail.pdl). - An internal binary tag (e.g.,
ShowPopup, data type Binary tag) or a tag whose Boolean evaluation drives the display. For PLC-driven triggers, configure the tag as a External tag on the required channel/unit (e.g., SIMATIC S7-1200/S7-1500 over TCP/IP, see SIMATIC HMI WinCC V7.5 - Communication manual). - For VBScript actions, the WinCC Scripting environment must be enabled (default for V7.0 SP2+). The Global Script Runtime is required for cyclic or tag-change triggered scripts.
- For Runtime testing, the WinCC Runtime must be licensed for the configured number of PowerTags and the picture must be part of the Runtime start sequence.
Signal Flow: Tag → Object Property → Picture Visibility
The display chain in WinCC Runtime follows this hierarchy:
- Tag acquisition: WinCC polls the PLC (or evaluates an internal tag) at the configured acquisition cycle (default 1 s, adjustable per tag).
- Property dispatch: The tag change event triggers a re-evaluation of any object property connected to that tag. Direct connections (configured in Graphics Designer under Properties → Display → Display) update the property value with a single operator; dynamic dialogs, VBScript, and C actions allow transformation.
- Visibility logic: The Display property of a Picture Window, or the layer visibility flag of a layer object, determines whether the object participates in the screen draw list.
- Composite rendering: When Display = TRUE, the embedded PDL is instantiated in the Picture Window's bounding box; its internal objects (buttons, I/O fields, status displays) inherit the parent process screen's authorization level.
Method 1: Picture Window with Binary Tag (Recommended)
This is the most efficient production-grade approach for the maintenance-screen scenario described in the source. The Picture Window is a container object that loads a configured PDL at Runtime and respects the visibility of its parent object.
Step-by-Step Configuration
- Open the main process picture (e.g.,
overview.pdl) in the Graphics Designer. - From the Standard object palette, select Smart Objects → Picture Window and draw the container at the desired coordinates on the maintenance page.
- Double-click the Picture Window to open its Configuration dialog.
- Under Picture Name (German: Bildname), browse to and select the pop-up PDL (e.g.,
popup_detail.pdl). This PDL becomes the embedded process picture. - Click OK to close the Configuration dialog. The pop-up layout is now visible in the Graphics Designer as a static preview.
- Right-click the Picture Window and select Properties (German: Eigenschaften).
- Navigate to Properties → Display → Display (the Boolean visibility flag).
- Click the small lightning-bolt icon next to the Dynamic column. The dynamic selection dialog opens.
- Select Tag as the dynamic type, then choose the configured binary tag (e.g.,
ShowPopup). - Set the update cycle. For most binary status flags, 1 s is appropriate; for sub-second response, drop to 250 ms (note the increased system load).
- Apply with OK. The connection appears in the property list as a green tag-icon.
At Runtime, the Picture Window is rendered (and the pop-up PDL is instantiated) when the tag is TRUE; it is fully removed from the draw list when the tag is FALSE. No button press is required.
Property Reference
| Property | Type | Purpose |
|---|---|---|
| Picture Name (Bildname) | String | PDL file to instantiate in the window. |
| Display | Boolean | Master visibility flag. Tag-driven in this method. |
| Position X / Y | Integer | Top-left of the window in pixels. |
| Width / Height | Integer | Window size. Often matches pop-up dialog dimensions. |
| Adapt Picture (Bildanpassung) | Boolean | Auto-scale embedded PDL to window size (lossy; disable for fixed layouts). |
| Independent Window (Eigenständiges Fenster) | Boolean | If TRUE, the window floats independently of the parent and can be moved outside the main screen. |
| Window Border / Caption | Boolean | Display Windows-style frame around the pop-up. |
| Close Button | Boolean | If TRUE, the user can dismiss the pop-up via the [X] button. Bind this to a reset tag if operator dismissal should clear the trigger. |
Method 2: Layer-Based Visibility Control
Layers (German: Ebenen) are logical z-orders within a PDL. WinCC reserves Layer 0 for the base process picture; additional layers (1–31 by default) can be assigned to objects via the Layer property. The Layer object exposes runtime methods to show/hide all objects assigned to a given layer.
Configuration Steps
- In the Graphics Designer, open the pop-up PDL (
popup_detail.pdl). - Select all graphical objects that compose the pop-up (Edit → Select All).
- In the Properties pane, change the Layer property from 0 to a free layer index (e.g., Layer 10). All selected objects now belong to that layer.
- Switch back to
overview.pdl. - Open the Layer object (right-click in the picture → Layer, or drag the Layer object onto the picture).
- In the Layer object's properties, find Configuration → Layers. Set Layer 10 to Inactive at Runtime = unchecked; Layer 0 remains active.
- Create a button or Picture Window on
overview.pdlthat invokes a VBScript action callingHMIRuntime.BaseScreenNamewith the layer parameter, or use a direct tag connection on the Layer object's Display property for binary visibility.
VBScript — Show / Hide Layer by Tag
The cleanest method to bind layer visibility to a tag is via the Layer object's Display property connection, identical to Method 1. However, if multiple layers must change in coordination (e.g., Layer 10 + Layer 11 for a compound dialog), use VBScript:
' Triggered on tag change of "ShowPopup"
Sub OnClick(ByVal Item)
Dim bShow
bShow = HMIRuntime.Tags("ShowPopup").Read
If bShow = True Then
HMIRuntime.Screens("overview.pdl").Layers(10).Visible = True
HMIRuntime.Screens("overview.pdl").Layers(11).Visible = True
Else
HMIRuntime.Screens("overview.pdl").Layers(10).Visible = False
HMIRuntime.Screens("overview.pdl").Layers(11).Visible = False
End If
End Sub
Method 3: VBScript Action on Tag-Change Event (Advanced)
When the pop-up must be conditionally rendered, parameterised, or coordinate with a third party (logging, alarming, multiple pop-ups), bind a VBScript action to the tag's OnChange event in the Global Script editor.
Configuration
- In the WinCC Explorer, open Global Script → C-Editor / VBS-Editor.
- Create a new Action and select the trigger Tag → choose the binary trigger tag (e.g.,
ShowPopup). - Select trigger type On change (rising, falling, or both).
- Insert the VBScript body below.
' Global action triggered on change of "ShowPopup"
Dim oScreen, sPopup, bState
bState = HMIRuntime.Tags("ShowPopup").Read
If bState = True Then
' Open the pop-up as an independent modal-style window
sPopup = "popup_detail.pdl"
HMIRuntime.Screens("overview.pdl").ScreenItems("MyPictureWindow").Visible = True
HMIRuntime.Screens("overview.pdl").ScreenItems("MyPictureWindow").PictureName = sPopup
Else
HMIRuntime.Screens("overview.pdl").ScreenItems("MyPictureWindow").Visible = False
End If
Field-Proven Caveat: Reentrancy
If the action writes back to the same tag that triggered it (e.g., a reset), WinCC prevents recursive firing by default. The global action's Lock / Unlock API:
HMIRuntime.Tags("ShowPopup").Write False ' direct write
' or, to bypass locking:
HMIRuntime.Tags("ShowPopup").Write False, 1 ' hmWriteModeForce = 1
Method 4: ANSI-C Action (Legacy / High-Performance)
For projects migrating from WinCC V6 where C actions were the standard, an equivalent C action is possible. The C runtime exposes SetTagBit, GetTagBit, and the Picture Window API via the WinCC ODK. Most new projects prefer VBScript for maintainability. See the WinCC V7.5 Communication manual and the WinCC ODK documentation for C-API references.
Configuration Comparison
| Criterion | Picture Window (Method 1) | Layer Toggle (Method 2) | VBScript Action (Method 3) |
|---|---|---|---|
| Implementation effort | Low | Low–Medium | Medium |
| Runtime CPU cost | Very low | Low | Low–Medium (depends on cycle) |
| Conditional logic (debounce, hysteresis) | No (raw tag) | No (raw tag) | Yes (full VBScript) |
| Parameter passing into pop-up | Yes (tag connections on pop-up objects) | Yes | Yes (script-controlled) |
| Multi-window pop-ups | One per Picture Window | All objects on layer | Multiple, with logic |
| Operator dismissal via [X] | Built-in (if configured) | Requires custom button | Custom logic |
| Indirection (PDL selected at runtime) | No (static Picture Name) | No | Yes (PictureName = variable) |
| Best use case | Single boolean trigger; cleanest production pattern | Group of related objects toggled together | Multi-condition, alarm-driven, parameterised pop-ups |
Tag Configuration Detail
For the project context, the trigger tag should be created in the WinCC Tag Management as follows:
| Property | Recommended value |
|---|---|
| Name |
ShowPopup (or Maintenance_Popup_Active) |
| Type | Binary tag (1 bit) |
| Internal / External | External (driven by PLC) for production; Internal for test |
| PLC connection (if external) | SIMATIC S7-1200/1500 Channel – TCP/IP; e.g., DB10.DBX0.0 |
| Acquisition cycle | 1 s default; 500 ms for near-real-time alarms |
| Update on | Cyclic continuous (default); or Cyclic on use (cheaper, but slower response) |
| Initial value | 0 (FALSE) |
| Limit values / linear scaling | Not applicable for Boolean |
Layer Object Behavior in WinCC V7.0 SP2
WinCC V7.0 SP2 introduced several stability fixes for the Layer object that affect pop-up behavior. The relevant updates from the Update 9 changelog (Esclusion list of resolved issues) include fixes to layer visibility persistence across screen changes, and to the order in which the Graphics Designer re-instantiates Picture Windows after a project reactivation. Confirm that the project's OS Project Editor is configured with Layer concept = standard (32 layers). For PCS 7 projects, this is the default; for standalone WinCC V7 projects, verify in WinCC Explorer → Computer → Properties → Graphics Runtime.
Common Configuration Errors and Fixes
| Symptom | Likely root cause | Resolution |
|---|---|---|
| Pop-up does not appear despite tag=TRUE | Picture Name missing or PDL not in GraCS folder | Verify the PDL is saved under Project root\GraCS\; re-select via Configuration dialog. |
| Pop-up flickers | Tag acquisition cycle shorter than screen redraw; dynamic dialog set to cyclic on every change | Set acquisition to 500 ms–1 s; in the Dynamic dialog, set Result of the formula evaluation cycle explicitly. |
| Tag icon shows red (broken connection) | Tag was renamed after connection | Re-select the tag in the connection dialog; recompile the Runtime. |
| Picture Window shows error frame in Runtime | Tag is set to Cyclic on use and the window was never shown before | Change update to Cyclic continuous; or trigger a one-time read in the start-up script. |
| Layer toggle has no effect | Objects were placed on Layer 0 by default and not reassigned | Confirm in the Object properties → Layer field for each object in the pop-up. |
| VBScript error "Object required: ScreenItems(...)" | Picture Window object name mismatch (case sensitive) | Open the object's Properties → Name field; ensure VBScript references the same string. |
| Pop-up persists after tag=FALSE | Tag reset not propagated to the connection | Confirm the PLC resets the same bit; check Tag Logging / Connection diagnostics for stale data. |
| Picture Window appears on the wrong screen | Hard-coded screen name in script | Use HMIRuntime.BaseScreenName or parameterise the script trigger. |
Verification Procedure
- Save the Graphics Designer project. The modified flag in the title bar must clear.
- Activate the project in WinCC Runtime (WinCC Explorer → Activate).
- Open the main process picture (
overview.pdl). - Force the trigger tag to TRUE in the WinCC Tag Simulator or via the connected PLC.
- Confirm the Picture Window (or layer) becomes visible within one acquisition cycle. The pop-up PDL should be fully drawn, including any tag connections internal to the pop-up.
- Force the trigger tag to FALSE. Confirm the pop-up disappears without residual artefacts (e.g., no frozen controls, no orphaned alarms).
- Stress test: toggle the tag 50–100 times in a PLC watch table or simulated test rig. Observe for memory leaks in the WinCC Runtime (Task Manager → CCEServer.exe, PDLRT.exe working set should stabilise).
- Verify tag-change logging: if Tag Logging is configured, the trigger should appear in the archive with the configured acquisition timestamps.
Performance and Architectural Notes
Each Picture Window instantiation in WinCC V7.0 SP2 holds a memory footprint proportional to the number of objects in the embedded PDL, scaled by the configured authorization level and the number of active connections. For a typical pop-up with 30 graphical objects and 20 tag connections, the resident memory is in the order of 200–400 kB. In Runtime environments with hundreds of alarms driving pop-ups, the cumulative footprint should be benchmarked on the target hardware (industrial PC, WinCC Industrial Data Bridge, etc.). Siemens provides sizing guidance in the WinCC V7.5 Performance manual.
For alarm-driven pop-ups (where each alarm entry should pop its own window), prefer the WinCC Alarm Control with the Loop-in-Alarm function rather than a Picture Window per alarm. The Alarm Control opens the assigned loop screen via Open Picture with parameter passing, and is significantly more efficient.
Cross-Version Compatibility
| WinCC Version | Picture Window | Layer API | VBScript on tag change |
|---|---|---|---|
| V7.0 SP2 (Update 9) | ✓ | ✓ (32 layers) | ✓ |
| V7.2 | ✓ | ✓ | ✓ |
| V7.3 | ✓ | ✓ | ✓ (improved event model) |
| V7.4 | ✓ | ✓ | ✓ |
| V7.5 | ✓ | ✓ | ✓ (64-bit Runtime support) |
| TIA Portal WinCC RT Professional | ✓ (named "Screen Window") | Layer concept present, VBScript model identical | ✓ (JavaScript also available) |
| TIA Portal WinCC RT Advanced | ✓ (limited; panels/comfort panels) | Limited | Limited |
HMIRuntime object model. JavaScript is also available in TIA V17+ for new development.Field-Proven Tips
- For the maintenance scenario described, place the Picture Window with Independent Window = FALSE so the pop-up is locked to the main screen and cannot be dragged off-screen. This is the standard production behavior.
- Bind the Close Button of the Picture Window to a tag that is also written by the operator's acknowledge logic, so dismissing the pop-up clears the trigger and prevents a stale display on the next tag pulse.
- Use the Adapt Picture option only when the embedded PDL is intentionally resolution-independent. For fixed-size pop-ups, disable it to prevent scaling artefacts at 4K monitor resolutions.
- For multi-language deployments, ensure the pop-up PDL is included in the language-switching picture set (WinCC Explorer → Language & Font). Picture Windows inherit the language context of the parent process screen.
- Document the trigger tag name in the project's Tag Naming Convention document. A common pattern is
<Area>_<Screen>_Popup_<State>, e.g.,Line1_Overview_Popup_Active.
Related WinCC Documentation
- SIMATIC HMI WinCC V7.5 – Communication manual
- SIMATIC HMI WinCC V7.5 – WinCC Information System (online help)
- WinCC V7.0 SP2 – Graphics Designer manual
- Siemens SIMATIC WinCC product page
Frequently Asked Questions
Which WinCC V7 method is best for a tag-driven pop-up: Picture Window or Layer?
For a single Boolean trigger, the Picture Window (Method 1) is the cleanest production pattern. It uses a direct tag connection on the Display property, has the lowest Runtime CPU cost, and supports an optional operator close button. Use Layer visibility only when you need to toggle a group of objects together as a single visual unit.
Why does my Picture Window not appear even when the trigger tag is TRUE?
Most often the Picture Name is empty or the pop-up PDL is not located in the GraCS folder of the WinCC project. Open the Picture Window's Configuration dialog and re-select the PDL. Also confirm the tag is configured as Cyclic continuous (not Cyclic on use), and that the connection icon next to the Display property is green (not red, which indicates a broken tag reference).
Can I pass a parameter into the pop-up PDL from the trigger tag?
Yes. In VBScript (Method 3), set the Picture Window's PictureName to a string built from tag values, e.g., "popup_" & HMIRuntime.Tags("MachineID").Read & ".pdl". The embedded PDL can then use its own tag connections to render machine-specific content. This indirection is not possible with a static Picture Name in Method 1.
What acquisition cycle should I use for a Boolean trigger tag?
1 second is the typical default for SCADA status tags. For alarm pop-ups that must appear within half a second, drop to 500 ms; below 250 ms, expect noticeable load on the WinCC communication channel and a higher CPU footprint in Runtime. The cycle is configured per tag in WinCC Tag Management.
Does the Picture Window approach work on TIA Portal WinCC Runtime Professional?
Yes. The object is renamed Screen Window in the TIA Portal toolbox, but the Display property, the tag-connection mechanism, and the VBScript HMIRuntime object model are preserved. Code written for WinCC V7 VBScript can be ported with minimal changes; in TIA V17 and later, JavaScript is also supported as a modern alternative.