WinCC VBS Object Flashing: Configure Indirect Tag Triggers

Flashing graphic objects in Siemens WinCC Runtime (Comfort Panels, TIA Portal HMI, WinCC Professional / WinCC RT Advanced / WinCC RT Enterprise) is normally a property-driven animation that the runtime engine evaluates on a fixed internal cycle. When the trigger tag is delivered through indirect addressing (multiplexing) or when the trigger source is itself a VBS expression, the runtime continues to evaluate the VBS even when the underlying Boolean state has not changed. On large screens with many flashing objects this can result in a visible 2-second system tick, callback saturation, and a perceptible slowdown of the entire HMI process image.

This reference explains the mechanics of the Flashing Background Active property, the FlashBackColor, FlashForeColor, FlashRate, and Flashing object attributes, the role of HMIRuntime.Tags and the ScreenItems collection, and—most importantly—how to reconfigure the default trigger so that the VBS function only fires upon change instead of being polled on a fixed acquisition cycle.

1. Problem Definition

You want a circle (or any HMI object) on a WinCC screen to flash while a Boolean tag is 1 and remain steady when the Boolean is 0. The tag is reached through an indirect address (a multiplexer / index-based pointer), so it cannot be wired to the standard Flashing property dialog directly. You place a VBScript on the Flashing Background Active event of the object, and the flashing visually works, but:

• The VBS is invoked approximately every 2 seconds regardless of the trigger tag state.
• Runtime performance degrades when the screen contains many flashing objects (cascading callbacks, increased tag polling).
• You cannot simply bind the indirect tag to the standard Flash variable field of the property dialog because the field expects a static tag name, not a pointer.

2. Prerequisites

• Siemens TIA Portal V16 or later (V17 / V18 / V19 supported) with WinCC Comfort / WinCC Professional configured.
• Target runtime: SIMATIC Comfort Panel (TP/KTP series), IPC with WinCC RT Advanced, or WinCC RT Professional.
• A defined Boolean trigger tag (e.g. Sel_A, address area DB / Merker / Process tag, data type Bool).
• A screen object of type Circle (or any object that exposes the Flashing group: Rectangle, Ellipse, Polygon, Symbolic IO field, Button, Text field).
• Indirect address configured either as a multiplex tag in the HMI tag table, or a manual pointer built from a base tag + index in VBS.
• Engineering access to the runtime security settings (VBS execution must be allowed; default in TIA Portal projects).

3. Default Flashing Behavior in WinCC

Every screen object that supports visual feedback has a Flashing property group in the Properties pane:

When the dialog-driven flow is used (static Flash variable + Flash rate), the runtime swaps the configured FlashColorOn / FlashColorOff on its own internal timer, and there is no VBS overhead. The VBS events only exist to override the colors dynamically.

4. VBS Implementation: Flashing via HMIRuntime.Tags and ScreenItems

When the trigger tag is reached through an indirect address, the only practical way to evaluate the pointer in script is to use the HMIRuntime.Tags collection, read the pointed-to value with the .Read method, and push it into the object's FlashBackColor property. The minimum working snippet is:

' --- Place on Flashing Background Active of object CircleX ---
Dim objCircFlashTrig, objCirc
Set objCircFlashTrig = HMIRuntime.Tags("Sel_A")  ' Bool variable for trigger
Set objCirc = ScreenItems("CircleX")              ' Circle object

objCirc.FlashBackColor = objCircFlashTrig.Read()

What this does line by line:

1. HMIRuntime.Tags("Sel_A") returns a Tag object reference. The Tag is a wrapper that caches the read value in the local runtime buffer; it does not re-fetch from the PLC on every property access.
2. objCircFlashTrig.Read() returns the current Boolean state of Sel_A as a Variant.
3. objCirc.FlashBackColor is the dynamic color used by the flasher. Assigning a non-zero value enables the alternate background; assigning 0 disables the swap. WinCC converts the Boolean to a numeric color index in this single property write.

5. The Indirect Address Problem

Indirect addressing in WinCC takes two common forms:

1. Multiplex tag: declared in the HMI tag table as Pointer type, where a source tag is read at runtime and a target tag is exposed. The HMI only sees the target; the pointer is resolved server-side.
2. Manual index lookup: VBS reads an index tag, builds a string tag name such as "DB100.DBB" & (idx * 2), and calls HMIRuntime.Tags(name).Read directly.

The Flashing Background Active event is a VBS slot. Whatever you write in it is executed on the configured acquisition tick. The default acquisition for events tied to a property is the project's Update cycle (commonly 2 s for HMI tags). That is why the script appears to fire every 2 seconds. It is not the flash rate (which is purely visual); it is the data update rate of the property the VBS is bound to.

6. Switching the Default Trigger to On-Change

The runtime offers two acquisition modes for any property / event:

To make the VBS fire only when the indirect trigger actually flips:

1. Open the Properties of object CircleX.
2. Navigate to Properties > Flashing > Flashing Background Active.
3. In the right-hand editor, click the small cycle / trigger icon (often a clock symbol) that opens the acquisition dialog.
4. Switch from Cyclic to On change.
5. Bind the trigger to the real (non-multiplexed) Boolean tag that the indirect pointer ultimately resolves to.

7. Working Code: Complete Reference

7.1 Simplest pattern – static tag, on-change trigger

' Place on Flashing Background Active of CircleX
' Trigger: HMIRuntime.Tags("Sel_A") configured as On change in the property dialog
Dim oTrig, oCirc
Set oTrig = HMIRuntime.Tags("Sel_A")
Set oCirc = ScreenItems("CircleX")
oCirc.FlashBackColor = oTrig.Read

7.2 Multiplex / pointer pattern

' Index = HMI tag (Int) selecting which element of array to monitor
' The PLC holds an array DB100.DBB[0..99]
Dim idx, sTag, oVal, oCirc

idx = HMIRuntime.Tags("Index").Read
sTag = "DB100.DBB" & (idx * 2)         ' build pointer name

Set oVal  = HMIRuntime.Tags(sTag)
Set oCirc = ScreenItems("CircleX")

If oVal.Read = 1 Then
    oCirc.FlashBackColor = RGB(255, 0, 0)   ' red while tag = 1
Else
    oCirc.FlashBackColor = 0                ' steady while tag = 0
End If

7.3 Synthetic trigger pattern (recommended for large screens)

' PLC toggles "Trig_Pulse" each time the pointed-to value mutates.
' Bind Flashing Background Active of CircleX to Trig_Pulse, mode = On change.

Dim oTrig, oCirc
Set oTrig = HMIRuntime.Tags("Trig_Pulse")
Set oCirc = ScreenItems("CircleX")

' Toggle the flash each edge so the visible rhythm is independent of PLC rate
If oCirc.FlashBackColor = 0 Then
    oCirc.FlashBackColor = RGB(0, 255, 0)
Else
    oCirc.FlashBackColor = 0
End If

7.4 Optional: setting both colors inside the same VBS

If you want the foreground (text / border) to swap as well, repeat the assignment for FlashForeColor:

oCirc.FlashBackColor = RGB(255, 255, 0)   ' yellow background on flash
oCirc.FlashForeColor = RGB(0, 0, 0)       ' black foreground on flash

If you do not write either property, the runtime falls back to the values configured in FlashColorOn / FlashColorOff in the property dialog.

8. Property Reference

9. Performance Optimization Strategy

The original 2-second callback is the data update cycle of the HMI tag, not the visual flash period. To eliminate the constant polling load, apply the following in order:

1. Switch the trigger to On change on the Flashing Background Active event. This is the single highest-impact change.
2. Cache the Tag and ScreenItems references outside the VBS using module-level variables, or read them once on the Open screen event and store them on a global dictionary. Every HMIRuntime.Tags(name) call performs a name lookup in the tag collection.
3. Prefer the static Flash variable where possible. If the indirect tag is one of a known small set (e.g. 8 alarms), declare 8 real Boolean tags at project compile time, point the flash property at the right one from a value-driven dynamic dialog, and drop the VBS entirely.
4. Group multiple flashes under a single common parent that owns a master Flashing = 0 disable. Disabling Flashing on a parent group stops the engine from invoking the event on children.
5. Reduce acquisition rate only as a last resort; lowering the project update cycle degrades the whole HMI, not just the flashing objects.

10. Verification Procedure

1. Compile and download the project to the panel or PC runtime.
2. Open the screen containing CircleX. Start the runtime tag simulation (Tools > Tag simulation in TIA Portal) and force Sel_A to 1.
3. Confirm the circle begins flashing at the configured Flash rate. Color should be the value written to FlashBackColor.
4. Force Sel_A to 0. Flashing should stop within one tick.
5. Open the runtime diagnostics (Control Panel > System > Runtime diagnostics or the Performance indicator in WinCC RT Professional). The VBS invocation count for the object's event should drop from one call every acquisition cycle to one call per actual state change.
6. Watch the CPU load of the HMI process. On a representative screen with 20 flashing objects, the typical reduction is 15–40 % of the scripting thread's CPU when switching from cyclic to on-change triggering.

11. Troubleshooting Matrix

12. Frequently Asked Questions