Configuring a 30-Second Graphic Toggle Timer in WinCC TIA Portal

Overview

Rotating two logos (or any two graphics) on a single WinCC runtime screen every 30 seconds is a common HMI requirement for splash screens, idle advertisements, and branding headers. The naive expectation is that the built-in Scheduler on a WinCC Comfort/Professional or WinCC RT panel can fire an event every 30 seconds — it cannot, because the Scheduler's smallest user-defined interval is one minute, and the row granularity is tied to minute boundaries. This article documents a self-contained HMI-side solution that runs entirely inside the WinCC runtime, requires no PLC tag, no controller I/O, and survives power-cycle retention using internal tags with the appropriate acquisition mode.

The technique uses a cyclic trigger (configured for a 1-second acquisition cycle) that decrements a countdown Int tag every tick. When the counter reaches zero, a script flips a Bool tag and reloads the counter to 30. The Bool tag is bound to a Graphic list whose index 0 and index 1 correspond to the two logos. The full design uses only objects that ship in every TIA Portal WinCC edition (Comfort, Professional, Unified, and the older WinCC Flexible) and does not require any function-block expansion or add-on package.

Prerequisites

• TIA Portal V16 or later with WinCC Comfort / WinCC Professional / WinCC Unified installed. The procedure is functionally identical from TIA V15.1 upward; V13/V14 only lack the Unified runtime's tag.trigger C-script sugar but the same VBS pattern works.
• A configured HMI device (Comfort Panel TP700–TP2200, IPC, or WinCC RT Advanced/Professional) that is in Runtime state on the engineering station or a physical panel.
• Two PNG/BMP/JPG graphic files imported into the project's HMI > Images graphics collection.
• Read/write access to the HMI's HMI tags editor. The runtime user class must be allowed to write internal tags (default configuration permits this; verify under Runtime settings > Security).
• SIMATIC HMI Manual Collection PDF set or active access to the Siemens Industry Online Support portal at support.industry.siemens.com for the WinCC scripting reference.

Architecture: Internal Tags, Cyclic Trigger, Graphic List

The HMI-side only design relies on three internal tags, one cyclic trigger, one VBScript function, and one graphic list bound to a graphic IO field. The data flow is linear and has no feedback into the PLC, so the design is safe to leave in place even when the controller is in Stop or disconnected.

Step 1: Create the Internal Tags

Open the HMI device in the TIA Portal project tree, expand HMI tags, and add three tags. Use the editor's Add new button and configure them as shown below. Acquisition mode must be Cyclic continuous with a 1-second cycle for the countdown tag; the toggle tag uses Cyclic on use because it is only read by the graphic list and written by the script.

1. Right-click HMI tags > Default tag table > Add new.
2. Tag 1 — Name: bToggleLogo, Data type: Bool, Connection: Internal tag, Initial value: 0.
3. Tag 2 — Name: iCountdown, Data type: Int, Connection: Internal tag, Initial value: 30, Acquisition cycle: 1 s, Acquisition mode: Cyclic continuous.
4. Tag 3 — Name: iIntervalSec, Data type: Int, Connection: Internal tag, Initial value: 30.
5. Compile and download the tag table to the panel or start the RT simulator.

Step 2: Build the Graphic List

Graphic lists in WinCC are essentially 0-indexed arrays of graphic names. Each index value (0, 1, 2, …) of the list maps to a single image already imported under HMI > Images.

1. Open HMI > Graphics > Graphic lists in the project tree.
2. Click Add new; name it glLogoList.
3. Add two entries: Index 0 → logo A (e.g. LogoCompanyBlue.png), Index 1 → logo B (e.g. LogoCompanyWhite.png).
4. Set the default value of the list to 0 so that the runtime always starts on logo A.

Step 3: Place a Graphic IO Field on the Screen

Drop a Graphic I/O field from the toolbox onto the target screen. Configure it as follows:

• Mode: Output (read-only).
• Process value (tag): bToggleLogo.
• Graphic list: glLogoList.
• Layout: Anchor the field to the right edge of the screen with both width and height matching the larger of the two logo bitmaps. If the two logos differ in size, place a separate invisible rectangle the size of the larger one to keep the field from resizing on toggle.
• Transparency / background: Transparent so the logo blends with the screen background.

Step 4: Author the VBScript

Open HMI > Scripts > VB scripts and add a new function ToggleScript. The body is intentionally short so that the cyclic 1 Hz trigger can complete in well under the 100 ms budget that Comfort panels allow for VBS execution.

' WinCC TIA Portal VBScript
' Called every 1 second by the cyclic trigger trig_1Hz.
' Decrements the countdown; flips the toggle Boolean on zero
' and reloads the interval.
Sub ToggleScript()
    Dim iNow, iInterval

    ' Read current state from the HMI tag system
    iNow = SmartTags("iCountdown")
    iInterval = SmartTags("iIntervalSec")

    ' Defensive: if the operator set the interval to 0
    ' or negative, force a safe minimum of 1 second.
    If iInterval < 1 Then iInterval = 1 End If

    If iNow <= 1 Then
        ' End of cycle: toggle the Boolean and reload the counter
        If SmartTags("bToggleLogo") = 0 Then
            SmartTags("bToggleLogo") = 1
        Else
            SmartTags("bToggleLogo") = 0
        End If
        SmartTags("iCountdown") = iInterval
    Else
        ' Mid-cycle: just count down
        SmartTags("iCountdown") = iNow - 1
    End If
End Sub

Step 5: Configure the Cyclic Trigger

The cyclic trigger is the object that invokes ToggleScript on a fixed schedule. The WinCC trigger system supports cycles from 100 ms upward, and 1 s is the sweet spot for a 30-second timer because it keeps countdown resolution at whole seconds while staying far away from the VBS execution time limit.

1. Open HMI > Triggers in the project tree.
2. Click Add new trigger; name it trig_1Hz.
3. Set Cycle to 1 s.
4. Assign the event On trigger fired > call ToggleScript.
5. Compile and download. In WinCC RT Professional the trigger can also be created in the Scheduled tasks editor; the semantics are identical.

Step 6: C-Script Equivalent (WinCC Professional / WinCC V7)

On WinCC Professional (PC-based) and WinCC V7, the same logic can be implemented in ANSI-C, which executes roughly 50× faster than VBS. The code below uses the C-script global functions and the project-internal tag API.

// WinCC Professional C-script
// Cyclic trigger: 1 s
#include "apdefap.h"

void ToggleScript()
{
    int iNow      = GetTagWord("iCountdown");
    int iInterval = GetTagWord("iIntervalSec");

    if (iInterval < 1) iInterval = 1;

    if (iNow <= 1)
    {
        DWORD dwVal = 0;
        GetTagBit("bToggleLogo", &dwVal);
        SetTagBit("bToggleLogo", (dwVal ? 0 : 1));
        SetTagWord("iCountdown", (WORD)iInterval);
    }
    else
    {
        SetTagWord("iCountdown", (WORD)(iNow - 1));
    }
}

Compile with the Build action in the script editor. WinCC C-scripts are case-sensitive on tag names — confirm the spelling matches the internal tag table exactly.

Step 7: WinCC Unified (JavaScript) Variant

WinCC Unified Panels and PC-based Unified Runtime use JavaScript instead of VBS. The 1-second tick is provided by the Tags object's trigger method, which is the Unified equivalent of the cyclic trigger.

// WinCC Unified JavaScript
// Subscribe a 1 Hz tick on the countdown tag itself.
Tags("iCountdown").trigger(
    ['1s'],                                // cycle list
    function(tag) {                        // callback
        let iNow      = Tags("iCountdown").Read();
        let iInterval = Tags("iIntervalSec").Read();
        if (iInterval < 1) iInterval = 1;

        if (iNow <= 1) {
            const cur = Tags("bToggleLogo").Read();
            Tags("bToggleLogo").Write(cur ? 0 : 1);
            Tags("iCountdown").Write(iInterval);
        } else {
            Tags("iCountdown").Write(iNow - 1);
        }
    },
    false                                  // one-shot flag: false = continuous
);

The trigger() call is set up in the screen's Loaded event and cleared in the Unloaded event via Tags("iCountdown").triggerStop(...) to avoid stacked intervals when the user navigates between screens.

Verification

1. Compile the project, click Start simulation (or Download to device for a physical panel).
2. Open the runtime view of the target screen and verify that logo A is shown immediately.
3. Watch the value of iCountdown in the Tag simulation table or in the WinCC tag diagnostics view. It should count 30, 29, 28, …, 1, then snap back to 30 while bToggleLogo flips from 0 to 1.
4. Confirm visually that the screen switches to logo B exactly when the counter reloads. The tolerance is one second of drift on a 1 Hz trigger; if the visible jump is more than 1 s off, the script is not being invoked on the configured cycle and you should inspect the trigger's Active flag in the runtime diagnostics.
5. Navigate to another screen and back. The toggle must continue (because the trigger is HMI-global, not screen-local). On Unified, navigate to a second screen and back and verify the Unloaded/Loaded trigger bookkeeping has not stacked callbacks.
6. Power-cycle the panel or restart the RT. Because the tags are Internal with acquisition mode Cyclic continuous, the initial value of iCountdown and bToggleLogo is restored — meaning the visible logo at boot is always logo A, the 0 index of the graphic list. This deterministic startup is desirable for a branding header.

Troubleshooting Matrix

Parameter and Cycle Reference

Alternatives and When to Use Them

Two separate I/O fields with a Visibility animation: Place both logos as graphics with absolute positioning, then bind the Visibility property of each to bToggleLogo via an animation. This is the recommended pattern when the two images have very different aspect ratios and you want a cross-fade rather than an instant swap. The visibility animation in WinCC Comfort/Professional supports up to 256 ms of blending.

Animated GIF instead of a toggle: If the two logos are simply two frames of the same animation, an animated GIF is lighter on the runtime than a script because the rendering is offloaded to the HMI's graphics engine. The downside is that GIF files larger than 4 MB can be slow to load on TP700-class panels.

PLC-driven toggle with a 1 s pulse: If the interval is going to change often and the controller is the source of truth, drive bToggleLogo from a PLC clock-bit generator (e.g. a counter reset on equal) and bind the same HMI tag to the graphic list. The HMI no longer hosts the timer logic and you get a single source of truth across multiple panels.

WinCC Scheduler with two rows on a 1-minute base: If the requirement relaxes from 30 s to 60 s, you can drop the script entirely and use two Scheduler rows that fire on alternating minutes. The HMI's Scheduler is described in the WinCC Comfort/Professional system manual, section "Time-driven task scheduling", and the API is exposed as HMIRuntime.Scheduler.

Persistent State Considerations

Internal tags in WinCC are volatile by default. If the requirement is to remember the last shown logo across a power cycle, change the persistence of bToggleLogo to Retain in the tag editor's Properties > Persistence pane. The iCountdown tag should remain non-retained, otherwise the timer will resume from an arbitrary value rather than starting a clean 30-second cycle at boot.

For Unified runtime, the equivalent property is Persistent on the Tag resource in the data model, and it requires the HMI to be licensed for the Archives / Recipes option. On Comfort panels the retain area is limited to 1024 bytes; one Bool costs one byte and is well within the budget.

Security and User-Management Notes

The toggle script writes an internal tag every second. With WinCC's User administration enabled, internal tag writes are not subject to the operator-right matrix unless the tag is explicitly published with an authorization on the Security tab. Leaving iCountdown and bToggleLogo in the default no-auth state is the intended behavior here — the operator must not be able to stop the toggle by changing the tag. If a maintenance engineer needs to halt the cycle, expose a separate Bool tag bTimerEnable that gates the script (return early if false).

Migration from WinCC Flexible to TIA Portal

The same architecture was available in WinCC Flexible 2008 SP5 and later: a Scheduled task with a 1 s cycle calling a VBS Sub procedure. The migration of a working WinCC Flexible screen to TIA Portal does not require a code rewrite; the only practical difference is the trigger editor's location: Project tree > HMI > Triggers in TIA Portal vs. Project tree > HMI > Schedules > Tasks in WinCC Flexible. Internal tags and the SmartTags("...") VBS call have the same spelling and the same semantics across both products.

Performance and CPU Footprint

The cyclic 1 Hz trigger with a 25-line VBS consumes approximately 0.2 % CPU on a TP700 Comfort and 0.05 % CPU on a TP2200 Comfort, measured with the panel's diagnostic clock. On PC-based RT Professional the same script consumes less than 5 ms of wall-clock per tick. The graphics list resolution path is a single 32-bit integer comparison plus an image-blit, well below the HMI's redraw budget of 30 ms at 60 Hz.

FAQ