WinCC v7.0 C-Script: Push Button Pulse Output Programming

1. Overview: Generating a One-Cycle Pulse from a WinCC v7.0 Button

WinCC v7.0 graphics designers frequently need a single-scan (or fixed-duration) pulse on a boolean tag whenever an operator presses a screen button. The classic use cases are manual machine start commands, momentary jog requests, acknowledge bits, and recipe-step triggers. The runtime does not provide a native "pulse" button object, so the behavior must be synthesized through C-scripting.

There are three production-ready methods, each with a different trade-off between PLC load, HMI load, and script complexity:

• Method A — Mouse Down / Mouse Up edge: Set Tag = 1 on left mouse down and Tag = 0 on left mouse up. The pulse width equals the physical key-hold time.
• Method B — Internal pulse tag with global cyclic reset: Set the tag to 1 on click; a global C-script running on a cyclic trigger clears it back to 0 on the next cycle.
• Method C — PLC-side pulse: Use the HMI only to write a 1; have the PLC program generate the pulse in OB1 / a cyclic OB. Recommended when scaling to hundreds of tags.

2. Prerequisites

Before configuring the pulse logic, verify the following:

• WinCC V7.0 SP3 or later installed (project tested on V7.0 SP3 Update 6, V7.0 SP4, and V7.4 for backward compatibility).
• WinCC Explorer with an active project and a connected AS (PLC) — either SIMATIC S7-300/400/1200/1500 via TCP/IP (RFC1006) or a non-Siemens PLC via OPC.
• WinCC Tag Management configured with:
  • An internal boolean tag pulse (data type Binary Tag, length 1, internal — used by Method B only).
  • A process tag of type BOOL representing the output bit on the PLC (used by all methods as the actual command bit).
• WinCC Graphics Designer open with a screen containing a button object.
• User rights enabling C-script execution (default in WinCC V7.0; verify under Computer Properties > Runtime > Scripts).

Refer to the SIMATIC HMI WinCC V7.0 SP3 - Working with WinCC manual for the canonical tag-creation workflow.

3. Method A — Mouse Down / Mouse Up Edge Pulse

This is the simplest and most deterministic single-button implementation. The pulse duration is exactly the time the operator physically holds the key down. It is ideal for jog / inching commands where the operator expects the output to follow the key.

3.1 Configure the Down-Event Script

Right-click the button in Graphics Designer and open Properties > Events > Mouse > Left Mouse Down. Add a C-action with the body:

// Set output bit on press
SetTagBit("PLC_OutputBit", (BOOL)1);

3.2 Configure the Up-Event Script

On Left Mouse Up add:

// Clear output bit on release
SetTagBit("PLC_OutputBit", (BOOL)0);

3.3 Timing Behavior

Verification reading: pulse width in seconds ≈ operator's physical key-hold time. Cyclic load: zero — the C-action runs only on user input events.

4. Method B — Internal Pulse Tag with Global Cyclic Reset

This pattern was the original ask in the field report. The runtime guarantees a deterministic 1-cycle pulse independent of operator behaviour.

4.1 Create the Internal Tag

In WinCC Explorer > Tag Management > Internal Tags, add a new binary tag named pulse with length 1 and type Binary Tag.

4.2 Write the Global Reset C-Action

Open the Global Script editor (right-click on "Global Scripts" in WinCC Explorer and choose "C-Editor"). Create a new project-level action named pulse_reset with the body:

// Global cyclic pulse reset
if (GetTagBit("pulse"))
{
    SetTagBit("pulse", (BOOL)0);
}

Assign a cyclic trigger through Properties > Trigger > Standard Cycle or a 250 ms cyclic trigger. The shorter the trigger period, the shorter the effective pulse width seen by the PLC.

4.3 Wire the Button Click

On the button's Mouse > Left Mouse Click event, add a C-action:

// Generate pulse
SetTagBit("pulse", (BOOL)1);

4.4 Timing Behavior

If the cyclic trigger is configured at 250 ms and the PLC acquisition rate matches, the PLC will see one scan of TRUE per click. If the PLC OB1 period is shorter than the trigger, the pulse may appear multiple cycles — verify your PLC's edge-detection works on the first FALSE-to-TRUE transition only.

5. Method C — PLC-Side Pulse (Recommended)

For applications with tens to hundreds of momentary commands, generate the pulse on the PLC. The HMI only writes a static 1; the PLC resets the bit after one OB1 cycle, or holds it for a configured TON duration.

5.1 S7-1200 / S7-1500 STL Snippet

// Detect rising edge on HMI command
A     "HMI_Start_Cmd";          // HMI tag (BOOL)
FP    "HMI_Start_Edge";         // Edge memory bit (BOOL)
=     "HMI_Start_Pulse";         // 1-cycle pulse to machine
// Auto-clear the HMI bit after one scan
A     "HMI_Start_Edge";
R     "HMI_Start_Cmd";

5.2 S7-300/400 STL Equivalent

U     "HMI_Start_Cmd";
FP    M 100.0;
S     "HMI_Start_Pulse";
U     M 100.0;
R     "HMI_Start_Cmd";

5.3 WinCC Button Configuration

With Method C the button only needs one event:

// Left Mouse Click — write static 1
SetTagBit("HMI_Start_Cmd", (BOOL)1);

The PLC consumes the rising edge and clears the bit. This pattern is recommended in the SIMATIC WinCC V7.0 Communication Manual for all HMI-to-PLC command bits.

6. C-Script Function Reference

The following C-script runtime functions are the only ones required for pulse generation in WinCC v7.0. Full signatures are documented in the WinCC V7.0 Scripting Reference.

Always cast the second argument of SetTagBit explicitly to (BOOL) to avoid a compile warning in the global C-editor.

7. Multiple Buttons with Different Tags

The same three methods scale across buttons by parameterising the tag name. Two production patterns are common:

7.1 Hard-Coded Per-Button Scripts

Each button gets its own down/up event with the tag name embedded. Cleanest, easiest to maintain, but produces N C-actions.

// Button "Start_Motor1" → Left Mouse Down
SetTagBit("Cmd_Start_M1", (BOOL)1);

// Button "Start_Motor1" → Left Mouse Up
SetTagBit("Cmd_Start_M1", (BOOL)0);

// Button "Start_Motor2" → Left Mouse Down
SetTagBit("Cmd_Start_M2", (BOOL)1);

// Button "Start_Motor2" → Left Mouse Up
SetTagBit("Cmd_Start_M2", (BOOL)0);

7.2 Reusable Function Called from Each Button

Define a project function PulseTag in the C-editor's Project Functions node:

void PulseTag(char* tagname)
{
    SetTagBit(tagname, (BOOL)1);
}

Bind each button's Left Mouse Down to a C-action that calls PulseTag with the appropriate string literal:

// Button "Start_Motor1" → Left Mouse Down
PulseTag("Cmd_Start_M1");

For the matching reset on Left Mouse Up create a paired UnpulseTag or use SetTagBit(tagname, 0) inline.

8. Performance and Cyclic Load Analysis

The field report correctly highlights that adding an internal pulse tag and a global cyclic C-action for every button creates a measurable HMI load. Use the following decision matrix to select the right method.

If Method B is required and you have many tags, do NOT create one global C-action per pulse bit. Instead, iterate a tag-prefix pattern:

// Single global action handling N pulse tags
int i;
char name[32];
for (i = 0; i < 100; i++)
{
    sprintf(name, "Pulse_%03d", i);
    if (GetTagBit(name))
        SetTagBit(name, (BOOL)0);
}

This keeps the cyclic load constant regardless of tag count, at the cost of one loop scan per trigger cycle.

9. Step-by-Step Configuration Walkthrough

1. In WinCC Explorer, expand Tag Management and confirm your process tag (e.g. Cmd_Start_Pump, BOOL) is online and showing good quality.
2. Open Graphics Designer and either edit an existing button or insert one from the standard library.
3. Select the button, then open Properties > Events.
4. Choose Mouse > Left Mouse Click (or Down/Up if using Method A).
5. Click the lightning-bolt icon and select C-Action.
6. Paste the script body for your chosen method. Validate with F7.
7. For Method B, open Global Scripts > Project Functions / Actions, create the cyclic reset action, and set its trigger to Standard cycle 250 ms.
8. Compile and save the project.
9. Activate WinCC Runtime and open the screen containing the button.
10. Test the pulse with a PLC-side edge-detection or an HMI tag-trace.

10. Verification and Testing

Verify the implementation in three layers:

1. WinCC Tag Trace: Open WinCC Tag Logging and configure a 1 s archive for the pulse tag. Press the button. Confirm the trace shows one sample at TRUE followed immediately by a FALSE.
2. PLC Online Watch: In TIA Portal or STEP 7, open the online watch table for the process tag. Press the button. Confirm the bit transitions to TRUE for one OB1 cycle and then FALSE.
3. Logic Test: Bind the pulse tag to a counter in the PLC (e.g. CTU). Each button press must increment the counter by exactly 1. If the counter increments by more, the pulse width is too long for your PLC scan.

If the PLC counter increments by 2 or more per click, shorten the WinCC cyclic trigger from 250 ms to 100 ms, or move the pulse generation into the PLC (Method C).

11. Troubleshooting Matrix

12. Frequently Asked Questions