WinCC Flexible Text List Alarm History: Script-Based Log Method

Problem Statement

WinCC Flexible 2008 / WinCC Flexible 2008 SP3 (and earlier TIA Portal WinCC Comfort/Advanced predecessors) display alarm text via two distinct mechanisms: Alarm lists (driven by bit/discrete triggers or limit-value monitoring) and Text lists (driven by tag value change). When a project uses a Text list tied to a single WORD tag (for example a DBW on an S7-300/400 PLC), the visible alarm text reflects the current value of that tag. As soon as the tag value changes, the prior notification text is overwritten and disappears from the HMI screen. The engineer cannot migrate to a standard alarm list because the trigger source is itself a numeric WORD coming from the PLC, and WinCC Flexible's built-in alarm logging cannot be conditioned on "equals specific value" without a script.

The net symptom: only the last text-list message is ever visible. The previous nine — required by the operator's spec — are lost. This article documents the script-based workaround using the AlarmLog object and a cyclic VBScript routine that reads the current text list index, resolves it to a string, and pushes the entry into a user archive that can be displayed on a custom alarm view.

Root Cause: Text List vs. Alarm List Trigger Semantics

Understanding the limitation requires looking at the underlying trigger model in WinCC Flexible's runtime:

WinCC Flexible's OnValueChanged event for a tag is the only built-in mechanism that fires when a WORD transitions to a new value. The text list is bound to that event, so it is a stateless renderer — it always shows what the tag currently equals. There is no concept of a "history" within a text list itself.

The built-in alarm system, by contrast, generates a discrete AlarmEvent object every time a configured bit goes high or an analog goes out of limit. Each event is timestamped, queued, and can be acknowledged. But you cannot configure a discrete trigger that says "fire an alarm when tag X equals 5." You can only say "fire when tag X exceeds limit L." Hence the engineering deadlock: the PLC provides a code number, not a bit pattern, and the HMI must decode it into a human-readable string.

Solution Architecture: Text List → Script → User Archive → Custom View

The script-based method reproduces alarm-list behavior on top of a text list. The data path is:

1. PLC tag (DBW) writes a numeric code into the HMI tag.
2. Text list is bound to that HMI tag and resolves the code to a string at display time.
3. VBScript scheduled task runs on a 500–1000 ms cycle. It reads the current text-list index, compares it to the previously stored index, and when a change is detected, writes a new record into a User Archive (CSV-backed) or into an internal tag array.
4. Custom alarm view on the HMI screen is configured as an Alarm Control with a filter that displays only the user-archive records, ordered newest-first, with scrollable history.

Components required on the HMI project side:

• One HMI tag of type WORD or INT mirroring the PLC DBW.
• One Text list with N entries mapping each code (0..N-1) to its display string.
• One internal tag of type WORD named LastIndex to remember the previously displayed value.
• One User Archive (CSV file) named AlarmArchive with columns: TimeStamp (STRING 20), Code (WORD), Message (STRING 50), State (STRING 10).
• One scheduled VBScript task running every 500 ms.
• One screen with an Alarm Control object bound to the User Archive via ODBC or direct CSV reference.

Step-by-Step Implementation

1. Create the text list

In the WinCC Flexible project tree, right-click Text and Graphic Lists → Text Lists and create a list named AlarmTexts. Add one entry per alarm code, for example:

Bind the text list to a screen IO field or Symbolic IO field with output mode Text list and selection AlarmTexts. Confirm in RT that the displayed string updates when the HMI tag value changes.

2. Create the user archive

Open Archives → User Archives and create AlarmArchive with the columns above. The archive is a CSV file stored on the HMI panel's flash or under \Storage Card\Logs\ on PC-based runtime. Configure the archive to be a limited ring buffer; 1000 records is a reasonable default for a single shift and consumes roughly 80 KB.

3. Configure internal tags

• AlarmTag — type WORD, sourced from PLC DBW (e.g. DB100.DBW0). Connected to the text list.
• LastIndex — type WORD, internal, persisted to retain value across screen changes. Used by the script to detect transitions.
• LastState — type STRING, internal, 10 chars. Used to remember if the previous record was ACTIVE or CLEARED so that returning to code 0 emits a CLEARED event.

4. Write the scheduled VBScript

Open Schedules → Tasks and create a task with trigger Cyclic, 500 ms. Paste the following into the VBScript editor:

'------------------------------------------------------------------
' Archive text-list alarm transitions into a User Archive.
' Runs every 500 ms in WinCC Flexible RT.
'------------------------------------------------------------------
Option Explicit

Dim curCode, prevCode, curText, curState, prevState
Dim archiveName, oArchive, oRecordset
Dim timeStr

archiveName = "AlarmArchive"

curCode  = SmartTags("AlarmTag").Value
prevCode = SmartTags("LastIndex").Value
prevState = SmartTags("LastState").Value

' Resolve text list entry by index
curText = ""
Select Case curCode
    Case 0  : curText = "No active alarm"
    Case 1  : curText = "Motor overload trip"
    Case 2  : curText = "Coolant pressure low"
    Case 3  : curText = "Spindle temperature high"
    Case 4  : curText = "Door interlock open"
    Case 5  : curText = "Hydraulic filter dirty"
    Case 10 : curText = "E-Stop pressed"
    Case 20 : curText = "Servo drive fault"
    Case Else : curText = "Unknown code " & CStr(curCode)
End Select

' Determine state
If curCode = 0 Then
    curState = "CLEARED"
Else
    curState = "ACTIVE"
End If

' Only act on transition
If curCode <> prevCode Or curState <> prevState Then
    timeStr = Year(Now) & "-" & _
              Right("0" & Month(Now), 2) & "-" & _
              Right("0" & Day(Now), 2) & " " & _
              Right("0" & Hour(Now), 2) & ":" & _
              Right("0" & Minute(Now), 2) & ":" & _
              Right("0" & Second(Now), 2)

    Set oArchive = HMIRuntime.BaseScreenName.Parent.Parent.GetObject(archiveName)
    If IsNull(oArchive) Then
        HMIRuntime.Trace "Archive not found: " & archiveName & vbCrLf
        Exit Sub
    End If

    ' Append a record at the head of the user archive
    oArchive.MoveFirst
    oArchive.Add
    oArchive.SetFieldValue "TimeStamp", timeStr
    oArchive.SetFieldValue "Code",      curCode
    oArchive.SetFieldValue "Message",   curText
    oArchive.SetFieldValue "State",     curState
    oArchive.Update

    SmartTags("LastIndex") = curCode
    SmartTags("LastState") = curState
End If

5. Display the archive in an Alarm Control

On the alarm screen, drop an Alarm Control object. Configure its source as User Archive → AlarmArchive. Enable the columns TimeStamp, Code, Message, State. Set sort order to TimeStamp descending. Set visible row count to 10 to match the operator's "show last 10 alarms" requirement. Tick Auto-scroll off so the operator can scroll the history without losing their place.

6. Optional: clear-on-acknowledge workflow

For an operator-acknowledge workflow, add a button on the alarm screen with the OnClick event:

Sub AcknowledgeSelected()
    Dim oView, oRow, oCol
    Set oView = ScreenItems("AlarmControl1").GetRowCollection()
    For Each oRow In oView
        oRow.SetFieldValue "State", "ACK"
    Next
End Sub

The state column becomes ACK and a visual flag can be added in the Alarm Control's column formatting.

Alternative: Internal Tag Array (No User Archive)

For panel-based runtimes (KP / KTP / TP panels with limited flash write endurance), avoid the CSV archive and store the last 10 entries in an array of internal tags. The trade-off is no persistent log across power-cycle:

' Shift registers of length 10
Dim i, tagName
For i = 9 To 1 Step -1
    tagName = "Hist_" & CStr(i)
    SmartTags(tagName).Value = SmartTags("Hist_" & CStr(i-1)).Value
Next
SmartTags("Hist_0").Value = curCode & "|" & curText

Create 10 string tags named Hist_0 through Hist_9 and display them in 10 symbolic IO fields on the screen, ordered with Hist_0 at top.

Verification and Acceptance Test

After the project is compiled and downloaded, perform this validation sequence on the live HMI before sign-off:

1. Force AlarmTag = 1 from the PLC or via the HMI's tag simulation table. Confirm the text list shows Motor overload trip and a new row appears in the Alarm Control with code 1, state ACTIVE, current timestamp.
2. Change AlarmTag to 3. Confirm row 2 appears with code 3 and row 1 (code 1) is still present above it in descending timestamp order.
3. Continue cycling through codes 0, 5, 10, 20, 0. Confirm 7 rows are present and the most recent CLEARED event (code 0) is at the top.
4. Return to AlarmTag = 1. Confirm an ACTIVE row is added again, not a duplicate of the original.
5. Power-cycle the panel. On panels with persistent user archives, confirm all rows are still present after reboot. On panels with the array-only variant, confirm rows 1–10 are reset to empty strings.
6. Disconnect the PLC connection while the script is running. Confirm the script does not write garbage to the archive; trace log should show the script exiting cleanly via Exit Sub in the catch block.
7. Inject a code value not in the text list (e.g. 77). Confirm the row Unknown code 77 is added so unknown PLC states are still observable.

Performance, Footprint and Lifecycle Considerations

• CPU load: A 500 ms cycle on a TP 177B / OP 177B consumes roughly 1–2 % CPU on the script alone. The User Archive CSV write is the dominant cost; if the panel is resource-constrained, raise the cycle to 1000 ms or switch to the internal-tag array method.
• Flash wear: CSV user archives write a full file rewrite on each append on most panels. Limit the archive to 1000 records and accept that the file will eventually be cycled. For long-life applications (24/7, multi-year), export the CSV to a USB stick daily via a scheduled task instead of relying on the on-board flash.
• Time stamp source: WinCC Flexible can use either the panel's local clock or the PLC's clock. For a multi-HMI cell, set all panels to use the PLC clock via Time Synchronization in the project settings; otherwise event ordering between panels is meaningless.
• Language switching: The hard-coded Select Case strings above are language-specific. For multilingual deployments, read the current language ID from HMIRuntime.Language and select the matching text-list column. Alternatively, bind the script's curText to SmartTags("AlarmTag") and use the built-in text-list multilanguage feature by reading the appropriate index from the user-archive column.

When NOT to Use This Workaround

This script-based archive is appropriate when the PLC code is fixed and a discrete-bit alarm interface is impossible. It is not appropriate when:

• The PLC can be modified to expose a bit per alarm state. Always prefer this option for new projects.
• You are migrating to TIA Portal with WinCC Unified. Use the native Multiplexing tag feature and PLC alarm text lists introduced in WinCC V17 / TIA V17 — they solve this exact problem without scripts. Reference the SIMATIC WinCC Unified Engineering V18 Manual for the multiplex configuration path.
• The HMI runtime is WinCC (PC-based, not Flexible). PC-based WinCC has direct WinCC AlarmControl + TagMultiplex and does not require this workaround.
• SIL / safety-relevant alarms are involved. Use a Safety-Integrated alarm path; do not retrofit SIL events through a text list.

Troubleshooting Matrix

Migration Path: TIA Portal WinCC Unified

If a project is being modernized, the script-based workaround can be retired. In TIA Portal V17 and later, configure a Multiplexed tag on a WinCC Unified Comfort Panel. The multiplex tag accepts a WORD value and indexes into a text list, just like the old text list, but each transition also generates a discrete alarm event in the unified alarm system with a timestamp, state, and acknowledgement — exactly the behavior the operator originally requested. The configuration is under HMI Tags → [tag] → Properties → Multiplexing. Reference the SIMATIC WinCC Unified System Manual for the procedure.