Triggering WinCC 7.4 Alarm Sounds from Word Tags via C-Script

WinCC 7.4 SCADA systems frequently require acoustic notification when an alarm is raised, a process value crosses a threshold, or an operator event occurs. The Horn Editor shipped with WinCC 7.4 accepts only binary tags for horn triggering, which presents a direct limitation: a 16-bit or 32-bit WORD/DWORD tag — the most common structure for alarm status words, error registers, or device fault codes coming out of a PLC — cannot be wired directly into the Horn tab. This article provides a complete procedure to detect changes or value thresholds in a WORD tag and trigger a WAV playback through a WinCC Global Script C action, including handling multi-bit alarm words, debouncing, and assigning different sounds per bit position.

1. Why the Horn Editor Rejects WORD Tags

The Horn Editor is part of the WinCC Explorer (right-click your computer → Properties → Horn) and is bound to message classes in Alarm Logging. The trigger objects available in the trigger list are restricted to:

• Binary internal tags (channel: Internal)
• Binary process tags (channel: e.g. SIMATIC S7-PLC, MODBUS TCP, OPC)
• Tag bits accessible via the GetTagBit interface (e.g. MyWord_0 for bit 0 of the WORD tag MyWord)

Selecting a raw WORD tag is rejected because the horn evaluation is a Boolean signal path; it expects a single bit transition to start or stop playback. A 16-bit value is treated as a numeric data object that must be decomposed into individual bits before the horn can react. The same restriction applies to DWORD, INT, and REAL tags — they must be reduced to binary representations upstream of the Horn Editor.

2. Two Engineering Approaches

Approach A is the simplest when the WORD is purely an aggregation of single-bit alarms. Approach B is required when:

• The same WORD carries encoded alarm classes (e.g. bits 0–3 = severity, bits 4–7 = subsystem).
• You need to play different WAV files per bit position without creating 16 horn entries.
• The horn must react to value transitions (e.g. counter > 100) rather than discrete bits.

3. Prerequisites

1. WinCC 7.4 SP3 or later installed (the project structure described is verified against the WinCC V7.4 SP3 release notes).
2. The WORD tag (e.g. AlarmWord) is configured in the WinCC Tag Management with the correct channel driver, data type WORD (unsigned 16-bit), and a sensible update cycle (250–1000 ms typical for alarms).
3. WAV files are placed in a directory the WinCC Runtime can access. The project subfolder <Project>\GraCS\ is the conventional location; the runtime automatically searches \GraCS, the project root, and \ssm.
4. Sound device enabled on the operator station (Windows Audio Service running, default audio device selected).
5. Editor access to Global Script C (requires the WinCC Configuration Studio and the Global Script Runtime right on the user).

4. Approach A: Bit Alias Tags (No Scripting)

This method exposes every bit of the source WORD as a virtual internal tag using WinCC's built-in tag bit addressing.

4.1. Create the Internal Bit Aliases

1. Open WinCC Explorer → Tag Management.
2. Select the connection (or create an Internal connection if the bit mapping should remain in WinCC).
3. Right-click → New Tag and create 16 tags named AlarmWord_0 through AlarmWord_15 with data type Binary Tag.
4. In the tag properties, set the Address field to reference the source WORD plus bit offset. The syntax depends on the channel driver; for an S7-1500 connection using the symbol name "AlarmWord" the addressing would remain a single tag — the bit extraction is performed at tag-creation time using the PLC's bit-access syntax "AlarmWord".X0 only for S7-PLCSIM symbolic access. For MODBUS, the equivalent is 40001.0 through 40001.15 (function code 03, address+bit).

For internal-only evaluation, the simplest reliable method is:

1. Create 16 internal binary tags.
2. Create a Global Script Action with a 1 s trigger that reads the source WORD, masks each bit, and writes the result into the internal binary tag:

// Global C action — scheduled every 1000 ms
#include "apdefap.h"
int gscAction(void)
{
    DWORD raw = 0;
    raw = GetTagWord("AlarmWord");  // returns unsigned 16-bit value
    int i;
    for (i = 0; i < 16; i++)
    {
        char tagname[32];
        sprintf(tagname, "AlarmWord_%d", i);
        SetTagBit(tagname, (raw >> i) & 0x0001);
    }
    return 0;
}

The 16 internal tags are then bound to the Horn Editor as ordinary binary triggers.

4.2. Configure the Horn

1. In WinCC Explorer, right-click your computer → Properties → Horn.
2. Click Add…. For each bit, pick the message class (e.g. Alarm, Warning) and select the corresponding internal tag (e.g. AlarmWord_3) in the trigger column.
3. Assign the WAV file. Click the Sound cell and browse to the WAV in \GraCS\Sound.
4. Configure the acknowledge behaviour: On acknowledge (sound stops only when the operator clicks Acknowledge) vs. On reset (sound stops as soon as the bit clears).

5. Approach B: C-Script Global Action for Direct WAV Playback

When the Horn Editor is too rigid (custom mapping, conditional horn, runtime sound selection), a Global Script C action drives the audio subsystem directly. The official Siemens FAQ "How do you output a sound via C script in WinCC V7?" is the canonical reference for this technique. The implementation below extends that FAQ with WORD-tag evaluation, latching, and per-bit sound selection.

5.1. Project Layout

• <Project>\GraCS\Horn\Fault1.wav
• <Project>\GraCS\Horn\Fault2.wav
• <Project>\GraCS\Horn\Critical.wav
• Global Script action WordHornAction — scheduled, trigger = 500 ms.

5.2. The C Action

// Global C action — WordHornAction.prg
// Polls the WORD tag "AlarmWord" and plays a WAV when a bit rises.
// Uses mciSendString from winmm.dll to play the file.

#include "apdefap.h"
#include <windows.h>
#include <mmsystem.h>
#pragma comment(lib, "winmm.lib")

int gscAction(void)
{
    static DWORD sLastValue = 0xFFFF;   // sentinel: triggers on first call
    DWORD raw = GetTagWord("AlarmWord");
    if (raw == sLastValue) return 0;    // no change → no horn

    DWORD rising = raw & ~sLastValue;  // bits that just turned ON
    sLastValue = raw;

    char cmd[512];
    char file[256];

    // Bit 0  → critical alarm (highest priority)
    if (rising & 0x0001)
    {
        sprintf(file, "%s\\GraCS\\Horn\\Critical.wav", GetProjectPath());
        sprintf(cmd,  "open \"%s\" type waveaudio alias crit", file);
        mciSendString(cmd, NULL, 0, NULL);
        mciSendString("play crit", NULL, 0, NULL);
    }

    // Bit 3  → Fault1
    if (rising & 0x0008)
    {
        sprintf(file, "%s\\GraCS\\Horn\\Fault1.wav", GetProjectPath());
        sprintf(cmd,  "open \"%s\" type waveaudio alias f1", file);
        mciSendString(cmd, NULL, 0, NULL);
        mciSendString("play f1 from 0", NULL, 0, NULL);
    }

    // Bit 7  → Fault2 (loops until bit clears)
    if (rising & 0x0080)
    {
        sprintf(file, "%s\\GraCS\\Horn\\Fault2.wav", GetProjectPath());
        sprintf(cmd,  "open \"%s\" type waveaudio alias f2", file);
        mciSendString(cmd, NULL, 0, NULL);
        mciSendString("play f2 repeat", NULL, 0, NULL);
    }

    // Stop the looping Fault2 when bit 7 clears
    if (!(raw & 0x0080))
        mciSendString("stop f2", NULL, 0, NULL);

    return 0;
}

5.3. Triggering the Action

1. In WinCC Explorer → Global Script → C-Editor, open the file above.
2. Right-click the action function gscAction → Information/Trigger → Add.
3. Configure a cyclic trigger of 500 ms (do not go below 250 ms on a large project; the action will be a load on the script engine).
4. Save, then compile (File → Compile or Ctrl+F7). Errors appear in the output window — fix missing #include paths or typos before starting Runtime.

6. Verification Procedure

1. Force the source WORD from the PLC (or simulate via an internal tag) to 0x0001 → Critical.wav must play once and stop.
2. Set the WORD to 0x0080 → Fault2.wav must loop continuously.
3. Set the WORD to 0x0000 → looping must stop within one trigger interval (≤ 500 ms).
4. Set the WORD to 0xFFFF on startup → all mapped WAVs play once, no double-fire, no missed bit.
5. Restart WinCC Runtime (simulate power-cycle) with the WORD already at 0x0001 in the PLC. Because the action uses a sentinel 0xFFFF, the first poll detects the rising edge and fires the horn exactly once.

7. Alternative: Beep Instead of WAV

For a one-channel operator-station buzzer you can call the Win32 API directly without a WAV file:

// inside gscAction, instead of mciSendString
if (rising & 0x0001) MessageBeep(MB_ICONHAND);   // critical
if (rising & 0x0008) MessageBeep(MB_ICONEXCLAMATION);

The advantage is zero asset management; the disadvantage is the sound cannot be customized per project and is tied to the Windows sound scheme.

8. Troubleshooting Matrix

9. Performance and Reliability Considerations

• Keep the cyclic trigger ≥ 250 ms. Each poll performs a tag read and a small amount of bitwise logic; the cost is negligible, but the MCI open/close per WAV is heavier — 50 ms or more on Windows 10/11.
• Use GetTagWord / SetTagBit as the synchronous API only for low-frequency polling. For high-frequency updates (> 5 Hz) prefer the asynchronous variant or use Alarm Logging as the data source.
• Localize the WAV file paths with GetProjectPath(). Hard-coded paths break the moment the project is moved or activated on a different machine.
• For redundant servers, copy the WAV files in both server projects, or store them on a shared drive and reference the UNC path.
• Do not put a for-loop over 16 calls to mciSendString — instead precompute the rising mask and branch only on the bits that actually changed, as shown in §5.2.

10. Relationship to Alarm Logging

If the goal is to play a sound on every alarm message of a given class, the recommended route is to let Alarm Logging drive the horn — not the C action. The C action is the correct tool only when the alarm state is encoded in a non-binary tag, or when the WAV must be selected dynamically. To convert Alarm Logging messages to horn triggers, configure the message class's Acknowledgement and Horn properties in WinCC Explorer → Alarm Logging and select the appropriate internal binary or process bit. Detailed step-by-step procedure is in the WinCC Information System under Alarm Logging → Configuring the Horn.

FAQ