Configuring S7-417 Alarms with SCL ALARM_8P and WinCC Integration

Overview

Alarm Architecture and Block Selection

An alarm flow on an S7-417 is end-to-end from a Boolean or threshold condition in the PLC scan to a discrete message row in WinCC Runtime. The principal components are:

• Source condition: a bit in I/O area, a flag, or a calculated comparison (analog threshold).
• Trigger FB: an SCL-coded Function Block (FB) that detects the condition, performs edge detection, and calls a message system function (SFC).
• Message system function: SFC 17 ALARM_S, SFC 18 ALARM_SQ, SFC 107 ALARM_8P, or SFC 108 ALARM_8. The SFC writes the event to the CPU diagnostic buffer and pushes it onto the AS-OS communication path.
• EV_ID: a 32-bit message number (DWORD at the FB input) that uniquely identifies the message text in the STEP 7 message configuration dialog.
• Associated values: up to 10 process values (SFC 17/18) or 8 (SFC 107) attached as raw 32-bit words to the message; WinCC formats them into the visible message text using @n%...@ placeholders.
• WinCC message database: receives events via the S7 protocol suite (WinCC channel "SIMATIC S7 PROTOCOL SUITE"), mapping each EV_ID to a message class, severity, and tag format.

For the limit-switch case (200 individual signals, edge-triggered), the cleanest pattern is to instantiate one limit-switch FB per switch and call SFC 17 (ALARM_S) inside it. SFC 107 (ALARM_8P) only helps if you can guarantee at most eight events fire in a single OB1 scan — impractical for a 200-point array. For the analog case (100 inputs, warning plus alarm), the same instance strategy applies but with two EV_IDs per analog point.

EV_ID Numbering Strategy for 300+ Tags

Every configured message in STEP 7 has a unique EV_ID. STEP 7 reserves certain ranges for system messages; user-defined message numbers typically start at 1 within each message class. For 200 limit-switch messages plus 200 analog threshold messages (100 warning + 100 alarm) the total is 500 EV_IDs. Lay them out in contiguous blocks for clarity in the message dialog and in any imported WinCC CSV exports:

Designing the Limit-Switch FB in SCL

The following FB assumes a Boolean input i_bSignal, a configured EV_ID input i_dwEvId, an acknowledgment-expected flag i_bAckExpected, and an instance-level edge-memory bit s_bTrigMem. The FB calls SFC 17 (ALARM_S) on a rising edge of i_bSignal and supplies associated values describing the event.

FUNCTION_BLOCK FB_LimitSwitchAlarm
VAR_INPUT
    i_bSignal      : BOOL;     // raw limit-switch bit
    i_dwEvId       : DWORD;    // configured EV_ID for this point
    i_bAckExpected : BOOL := TRUE;
    i_wSigState    : WORD;     // associated value: 0=ok, 1=alarm
    i_dwPointId    : DWORD;    // associated value: tag identifier
END_VAR
VAR
    s_bTrigMem     : BOOL;     // edge memory
END_VAR
VAR_TEMP
    tAssocValues   : ARRAY[1..10] OF DWORD;
    tRetVal        : INT;
END_VAR
BEGIN
    // Edge detection: fire once per rising edge
    IF i_bSignal AND NOT s_bTrigMem THEN
        s_bTrigMem := TRUE;
        tAssocValues[1] := WORD_TO_DWORD(i_wSigState);
        tAssocValues[2] := i_dwPointId;
        tAssocValues[3] := DWORD#0;  // pad remaining slots
        tAssocValues[4] := DWORD#0;
        tAssocValues[5] := DWORD#0;
        tAssocValues[6] := DWORD#0;
        tAssocValues[7] := DWORD#0;
        tAssocValues[8] := DWORD#0;
        tAssocValues[9] := DWORD#0;
        tAssocValues[10] := DWORD#0;

        tRetVal := ALARM_S(
            SIG         := TRUE,
            ID          := W#16#0,
            EV_ID       := i_dwEvId,
            SEVERITY    := W#16#0001,
            ACK_STATE   := i_bAckExpected,
            MSG_FILTER  := FALSE,
            ASSOC_VAL   := tAssocValues
        );
        // tRetVal holds the SFC return code; W#16#0000 = OK
    END_IF;

    // Reset trigger memory on signal clear
    IF NOT i_bSignal THEN
        s_bTrigMem := FALSE;
    END_IF;
END_FUNCTION_BLOCK

For 200 limit switches, instantiate the FB once per switch by manually dropping 200 FB calls in OB1, or by using a multi-instance DB approach. The cleaner alternative is to call the FB inside a FOR loop over a typed array of input points:

// OB1 - cyclic
FOR i := 1 TO 200 DO
    iFB_Limit[i] (                  // multi-instance array of FB_LimitSwitchAlarm
        i_bSignal := "DB_I".ixLimit[i],
        i_dwEvId  := DWORD#16#00000001 + DINT_TO_DWORD(i - 1),
        i_wSigState := "DB_I".iwState[i],
        i_dwPointId := DWORD#16#000A0000 + DINT_TO_DWORD(i)
    );
END_FOR;

The i_dwEvId expression maps instance 1 to EV_ID 1, instance 200 to EV_ID 200. STEP 7 message configuration must declare exactly those message numbers, or the CPU rejects the SFC 17 call with return code W#16#8081 (EV_ID not configured).

Analog Threshold Monitoring with Hysteresis

For the 100 analog inputs, define a parallel FB that does its own scaling, threshold comparison, and message generation. The associated values carry both the live reading and the threshold so the HMI can display the self-documenting alarm text without further tag reads.

FUNCTION_BLOCK FB_AnalogAlarm
VAR_INPUT
    i_rRawValue    : REAL;       // engineering-units reading
    i_rWarnLimit   : REAL;       // warning threshold (e.g., 80% of span)
    i_rAlarmLimit  : REAL;       // alarm threshold (e.g., 95% of span)
    i_dwEvIdWarn   : DWORD;      // 201..300
    i_dwEvIdAlm    : DWORD;      // 301..400
    i_dwPointId    : DWORD;      // tag identifier
    i_bEnable      : BOOL := TRUE;
END_VAR
VAR
    s_rLastValue   : REAL;
    s_bWarnMem     : BOOL;
    s_bAlmMem      : BOOL;
END_VAR
VAR_TEMP
    tAssocValues   : ARRAY[1..10] OF DWORD;
    tRetVal        : INT;
    t_dwValue      : DWORD;
    t_dwLimit      : DWORD;
END_VAR
BEGIN
    IF NOT i_bEnable THEN
        RETURN;
    END_IF;

    // ---- Warning (rising edge only, with hysteresis) ----
    IF i_rRawValue >= i_rWarnLimit AND NOT s_bWarnMem THEN
        s_bWarnMem := TRUE;
        t_dwValue  := REAL_TO_DWORD(i_rRawValue);
        t_dwLimit  := REAL_TO_DWORD(i_rWarnLimit);
        tAssocValues[1] := t_dwValue;
        tAssocValues[2] := t_dwLimit;
        tAssocValues[3] := i_dwPointId;
        tAssocValues[4] := DWORD#0;
        tAssocValues[5] := DWORD#0;
        tAssocValues[6] := DWORD#0;
        tAssocValues[7] := DWORD#0;
        tAssocValues[8] := DWORD#0;
        tAssocValues[9] := DWORD#0;
        tAssocValues[10] := DWORD#0;

        tRetVal := ALARM_S(
            SIG       := TRUE,
            ID        := W#16#0,
            EV_ID     := i_dwEvIdWarn,
            SEVERITY  := W#16#0010,    // 16 = warning class
            ACK_STATE := FALSE,
            MSG_FILTER := FALSE,
            ASSOC_VAL := tAssocValues
        );
    ELSIF i_rRawValue < (i_rWarnLimit - 0.5) THEN
        s_bWarnMem := FALSE;          // clear with 0.5 EU hysteresis
    END_IF;

    // ---- Alarm (rising edge only, with hysteresis) ----
    IF i_rRawValue >= i_rAlarmLimit AND NOT s_bAlmMem THEN
        s_bAlmMem := TRUE;
        t_dwValue  := REAL_TO_DWORD(i_rRawValue);
        t_dwLimit  := REAL_TO_DWORD(i_rAlarmLimit);
        tAssocValues[1] := t_dwValue;
        tAssocValues[2] := t_dwLimit;
        tAssocValues[3] := i_dwPointId;
        tAssocValues[4] := DWORD#0;
        tAssocValues[5] := DWORD#0;
        tAssocValues[6] := DWORD#0;
        tAssocValues[7] := DWORD#0;
        tAssocValues[8] := DWORD#0;
        tAssocValues[9] := DWORD#0;
        tAssocValues[10] := DWORD#0;

        tRetVal := ALARM_S(
            SIG       := TRUE,
            ID        := W#16#0,
            EV_ID     := i_dwEvIdAlm,
            SEVERITY  := W#16#0001,    // 1 = highest severity
            ACK_STATE := TRUE,
            MSG_FILTER := FALSE,
            ASSOC_VAL := tAssocValues
        );
    ELSIF i_rRawValue < (i_rAlarmLimit - 0.5) THEN
        s_bAlmMem := FALSE;
    END_IF;

    s_rLastValue := i_rRawValue;
END_FUNCTION_BLOCK

Notice the hysteresis bands (0.5 engineering units) on the "clear" side. Without hysteresis, a noisy signal hovering at the threshold will chatter the alarm on every scan and flood the message buffer. STEP 7 message buffers in the S7-417 are sized for sustained bursts but alarm flooding remains a common commissioning defect. See the STEP 7 V5.x documentation index on the Siemens Industry Online Support portal for the complete ALARM_S parameter reference.

Programmatic Message Text Generation

The original question asked whether the message text can be set in the SCL code rather than per EV_ID in the message configuration dialog. The honest answer is: only the message number (EV_ID) is fixed in code; the message text is set in the configuration dialog. However, you can pass up to 10 associated values per alarm, and WinCC can format them into the visible message text using tag-formatting placeholders.

Configure the message text once with placeholders:

"Analog input <TagName> value = @1%6.2f@ exceeds warning limit @2%6.2f@"

When the alarm fires, associated value [1] (cast of the current reading as REAL, then DWORD) and associated value [2] (the warning limit) are substituted at runtime. The TagName placeholder cannot be passed as an associated value because STRINGs are not valid associated-value types — the name is fixed by which EV_ID fires. Practical consequence: you cannot have a single "generic" alarm with a dynamic tag name coming from inside the PLC. You must configure one message row per analog point.

STEP 7 Message Configuration

With the FBs compiled and downloaded, open the message configuration dialog in SIMATIC Manager:

1. Right-click the FB (or the symbol) and select Special Object Properties > Message.
2. In the message configuration dialog, click New to add a message row.
3. Set the Message Number to match the EV_ID used in the FB call. The first message row you add gets message number 1 by default; subsequent rows increment automatically.
4. Choose the message class (Alarm, Warning, Fault) and acknowledge behavior.
5. Define up to 10 associated values; for the limit-switch FB, set values 1, 2, and 3 to ixLimit[i] (state), i_dwPointId (tag ID), and a pad.
6. Enter the message text in the format-string field. Use the @1%...@ placeholder syntax for associated-value formatting.
7. Save and download to the PLC. Without a download, the CPU does not know the message text.

For projects with 500 messages, consider using the STEP 7 Message Configuration CSV import/export. Export the dialog after manually configuring the first row, edit the CSV in Excel for the remaining 499 rows, and re-import. This reduces configuration time from hours to minutes.

WinCC Message Configuration

WinCC receives alarm events over the S7 protocol suite. Configure the channel and message mapping as follows:

1. In WinCC Explorer, open Tag Management > SIMATIC S7 PROTOCOL SUITE.
2. Add a connection to the S7-417. Use the MPI / PROFIBUS / Industrial Ethernet driver depending on the physical layer. For S7-417H redundant pairs, select the H-CPU-specific driver profile.
3. Open Alarm Logging. The wizard prompts to import the message configuration from STEP 7; this imports all configured messages, classes, and associated-value formats.
4. Confirm the import shows 500 rows (200 limit switches + 100 warnings + 100 alarms + any system messages). If the row count is short, STEP 7 did not download the full message configuration, or WinCC lost the connection mid-import.
5. Configure the message view in the WinCC graphics designer. The default Alarm Control displays columns for Date, Time, Status, Class, Tag, Message Text, and Acknowledgment. The associated values render into the Message Text column at runtime via the placeholder substitution defined in STEP 7.
6. Set the user authorization level required to acknowledge. STEP 7 default is Operator (level 2); change to Maintenance (level 5) if operators should not silence production-critical alarms.

The WinCC V7.x manual is the canonical reference for alarm configuration; specifically chapter 7 ("Configuring the Alarm Logging") and chapter 11 ("Operating the Alarm Control in Runtime"). See the SIMATIC WinCC V7.x manual set.

Alternative: HMI-Side Alarm Handling

The original poster asked whether alarm logic could live entirely on the HMI side. Partial answer:

• Yes, WinCC can be configured to generate an alarm when a polled tag crosses a configured limit, using the Alarm Logging limits on the tag itself. This avoids the EV_ID configuration in the PLC entirely.
• No, WinCC-side limits do not write to the PLC diagnostic buffer, do not appear in the CPU's Web server / diagnostic overview, and cannot be acknowledged back to the PLC. They are display-only.

For most industrial applications, the PLC-side alarm architecture is required for compliance with standards such as ISA-18.2 ("Management of Alarm Systems for the Process Industries") and IEC 62682, which prescribe that the alarm source of authority is the control system, not the operator interface. The PLC-side SFC path is therefore preferred.

Step-by-Step Commissioning Procedure

1. Compile all blocks in STEP 7. Resolve any SCL warnings — pay attention to "uninitialized variable" warnings because SFC 17/18 will silently reject calls with garbage in associated values.
2. Download hardware configuration first, then blocks, then message configuration as a separate download. The message configuration is a system data object that lives outside the S7 program.
3. Verify CPU version: SFC 107 (ALARM_8P) and SFC 108 (ALARM_8) require S7-400 CPU firmware V3.0 or later. SFC 17/18 require V2.0 or later. The S7-417-4 (6ES7417-4XT05-0AB0) ships with V4.x firmware and supports all four SFCs. Confirm in PLC > Module Information.
4. Test one message: hardwire one EV_ID in OB1 with a toggle, fire it, and confirm WinCC receives the event. Once one message works, scale up.
5. Run a soak test: cycle all 200 limit switches and verify all 200 messages appear. Do the same for analog inputs across the operating range, including both warning and alarm thresholds.
6. Load test: force all 200 switches to alarm at once. Observe CPU scan time and message buffer occupancy in PLC > Diagnostic Buffer. The S7-417 buffers up to 1000 pending messages; sustained over-run indicates you are calling SFC 17 more than your event rate allows.
7. Acknowledge round-trip: from WinCC, acknowledge the message. Confirm the ACK_STATE flag returns to zero in the PLC diagnostic buffer.
8. Power-cycle test: restart the CPU. The retained message buffer should replay pending unacknowledged alarms in WinCC on reconnect.

Verification Checklist

Troubleshooting Matrix

FAQ