Displaying the Loaded Parameter Set in WinCC Unified HMI

Tracking which parameter set (recipe) is currently active in the PLC is a recurring requirement on SIMATIC WinCC Unified panels. The built-in properties of the Parameter Control (PACO) do not expose a reliable "last loaded ID", so engineers typically combine PACO events, custom load buttons, system functions, and JavaScript to surface the active set on screen. This reference documents a field-proven pattern for TIA Portal V19 with a CPU 1511-1 PN and a MTP1500 Unified Comfort Panel.

1. Problem Statement

The configuration compiles, the parameter sets are written to the panel, and recipes can be loaded to the controller. What does not work out of the box is the operator display: an IO field, symbolic IO field, or text field that shows the identifier (and ideally the human-readable name) of the parameter set that was most recently transferred to the PLC.

Two naive approaches fail in production:

• Binding a tag to PACO's Current parameter set ID property. This value updates every time the operator browses the recipe list (scroll, search, selection highlight) regardless of whether a load action was issued. The panel reports a different ID than the PLC is actually running on.
• Subscribing to the Command fired event of the Parameter Control. This event fires on any button press inside PACO — navigation, filter, sort, cancel, rename — not exclusively on the load action. A naive subscriber will store a parameter set ID every time the operator touches the screen.

The fix is to capture and store the parameter set ID yourself, in a tag that the PLC and the HMI both trust, and refresh it on the right trigger using the ReadParameterSetName system function.

2. Reference Architecture

The minimal hardware/software stack required by the pattern:

Refer to the official hardware manuals for the wiring and the supported firmware combinations:

• CPU 1511-1 PN device manual: SIMATIC S7-1500 CPU 1511-1 PN (6ES7511-1AK02-0AB0)
• MTP1500 Unified Comfort device manual: SIMATIC HMI MTP1500 Unified Comfort
• TIA Portal V19 release notes: What's new in TIA Portal V19

3. Why the Built-In PACO Properties Are Not Sufficient

The Parameter Control object in WinCC Unified exposes a number of useful state properties, but they are browse properties, not load properties. The relevant fields are:

Consequence: any UI that binds directly to Current parameter set ID will display the operator's selection, not the controller's active set. The two diverge the moment the operator opens the recipe dialog without committing a load.

4. Solution A — Custom Load Button with ReadParameterSetName

The first pattern replaces the PACO's built-in "Load to PLC" button with your own screen button. This gives you full control over when the ID is captured.

4.1 Wiring the configuration interface

1. Open the Parameter Control's configuration dialog in the HMI screen.
2. Under Parameter set type, select the parameter-set type that should be loaded from this control.
3. Wire the following configuration tags:
   • Parameter set ID → HMI tag HMI_ParamSetID_Select (DInt)
   • Job ID → HMI tag HMI_JobID (DInt)
4. Wire the state side:
   • Current parameter set ID → HMI tag HMI_ParamSetID_Display (DInt) — used by PACO internally; the screen does not bind to it.
   • Status → HMI tag HMI_LoadStatus (DWord)

4.2 Build the custom load button

Place a screen button next to the PACO. Wire its Press event to LoadParameterSet with the configured parameter-set type and the desired parameter set ID. Wire its Release event to a JavaScript action that calls ReadParameterSetName and writes the result into a persistent HMI tag.

4.3 Persist the result

Create two HMI tags that survive navigation, with retentive behaviour if your runtime supports it (Unified panels persist across screen changes, but the tag values are RAM-only by default):

• HMI_LoadedParamSetID (DInt) — last ID successfully transferred to the PLC.
• HMI_LoadedParamSetName (WString[64]) — the human-readable name of that set.

5. Solution B — PACO "Command fired" Event with ID Filter

If you prefer to keep the standard PACO toolbar visible (so operators can use the integrated load/save/delete buttons), use the Command fired event as a trigger and filter the command ID to isolate the actual Load action.

5.1 The Command fired event

The event signature exposes the originating command ID. In V19, the load-recipe command is delivered as a numeric command ID; navigation, search, and sort commands have different IDs. A typical pattern is to keep a small dispatch table:

// Dispatch table for Parameter Control "Command fired" event
// 1 = Load parameter set, 2 = Save parameter set, 3 = Delete,
// 4 = Rename, 10..99 = navigation/filter/sort (ignore for our purpose)
const CMD_LOAD_PARAM_SET = 1;

5.2 Filter and capture

1. Add a JavaScript function on the screen, for example OnPacoCommandFired(params).
2. Read params.CommandId. If it equals CMD_LOAD_PARAM_SET, copy the current value of HMI_ParamSetID_Select (the Parameter set ID configuration tag) into HMI_LoadedParamSetID and call HMIRuntime.Recipe.ReadParameterSetName(...) to populate HMI_LoadedParamSetName.
3. For every other command ID, do nothing. This is what makes the difference between "any button" and "the load button".

6. Step-by-Step Implementation in TIA Portal V19

1. Create the parameter-set type. In the project tree, expand Recipes / Parameter sets, add one parameter-set type (e.g. PT_Process) with the elements you want to expose. Configure the storage location to point to the panel (default) or to a network share.
2. Add parameter sets. Create five parameter sets under PT_Process with descriptive names such as PS_LineA_Default, PS_LineA_HighSpeed, PS_LineA_LowTemp, PS_LineA_Cleaning, PS_LineA_Test.
3. Place the Parameter Control on the screen. Drag the Parameter Control object from the toolbox onto your main screen. In its properties, bind the parameter-set type to PT_Process.
4. Wire the configuration tags. As described in section 4.1.
5. Add the persistent display tags. In the HMI tag table, create HMI_LoadedParamSetID (DInt) and HMI_LoadedParamSetName (WString[64]).
6. Add the IO field(s) for display. Place an IO field on the screen. Mode = Output. Process value = HMI_LoadedParamSetID. For the name, place a Symbolic IO field or a text field with process tag = HMI_LoadedParamSetName.
7. Attach the load capture logic. Either use Solution A (custom button) or Solution B (PACO event filter). Use a JavaScript action for the event handler; see section 7 for the snippet.
8. Compile and download. Compile the HMI and the PLC, download both targets, and restart the panel when prompted.

7. JavaScript Implementation

The following snippet illustrates the runtime side of both solutions. Adapt the tag and command-ID values to your project.

// --------------------------------------------------------------
// WinCC Unified V19 — capture the loaded parameter set ID
// --------------------------------------------------------------
// Persistent HMI tags:
//   HMI_LoadedParamSetID   (DInt)
//   HMI_LoadedParamSetName (WString[64])
// Configuration tags of the Parameter Control:
//   HMI_ParamSetID_Select  (DInt)  — "Parameter set ID" input
//   HMI_JobID              (DInt)  — "Job ID" input
//   HMI_LoadStatus         (DWord) — status output
// --------------------------------------------------------------

// Numeric command ID emitted by PACO for "Load to PLC".
// Determine this by tracing the runtime; do not assume.
var CMD_LOAD_PARAM_SET = 1;

// PACO "Command fired" event handler (Solution B).
function OnPacoCommandFired(params) {
    try {
        if (!params || params.CommandId !== CMD_LOAD_PARAM_SET) {
            return; // ignore navigation, sort, filter, etc.
        }
        var selected = Tags("HMI_ParamSetID_Select").Read();
        Tags("HMI_LoadedParamSetID").Write(selected);

        // Resolve the human-readable name.
        // ReadParameterSetName returns the name of the parameter set
        // currently identified by ParameterSetID in the given type.
        var pst = "PT_Process";
        var psid = selected;
        var lang = UI.Language;
        var name = HMIRuntime.Recipe.ReadParameterSetName(pst, psid, lang);
        if (name !== null && name !== undefined) {
            Tags("HMI_LoadedParamSetName").Write(String(name));
        }
    } catch (e) {
        // Log to the HMI diagnostics; never throw to the panel UI.
        HMIRuntime.Trace("OnPacoCommandFired error: " + e.message);
    }
}

// Press / Release handlers for the custom load button (Solution A).
function OnCustomLoadPress() {
    // Issue the load using the standard system function call.
    // Tag values were already written by the IO field bound to
    // HMI_ParamSetID_Select before this press event.
    HMIRuntime.Recipe.LoadParameterSet("PT_Process",
        Tags("HMI_ParamSetID_Select").Read(),
        Tags("HMI_JobID").Read(),
        /* overwrite */ true);
}

function OnCustomLoadRelease() {
    // On release — fetch the name and persist ID + name.
    var psid = Tags("HMI_ParamSetID_Select").Read();
    Tags("HMI_LoadedParamSetID").Write(psid);
    var name = HMIRuntime.Recipe.ReadParameterSetName(
        "PT_Process", psid, UI.Language);
    if (name) {
        Tags("HMI_LoadedParamSetName").Write(String(name));
    }
}

8. HMI Tag Wiring and PLC Considerations

The PLC side of the pattern is minimal but should not be skipped. Two points matter:

1. Read-back from the PLC. Even when the HMI reports a successful load, the PLC may not have applied the values if a permissive bit is missing (for example, the machine must be in Ready state). Mirror the parameter set's element tags to the controller and have the PLC acknowledge by writing a 1 to DB_RecipeAck. The HMI can read this bit and only update HMI_LoadedParamSetID when the bit transitions to 1.
2. Cycle-time budgeting. Loading a parameter set triggers a burst of writes to PLC tags. For large recipes (> 50 elements) on a CPU 1511-1 PN, the load can take 200–600 ms over a standard PROFINET connection. The HMI display should therefore show a transient Loading… state while HMI_LoadStatus reports busy. Use the V19 system function GetParameterSetStatus to drive this animation.

9. Verification and Commissioning Procedure

1. Open the screen in the HMI runtime (RT on the engineering PC or the panel itself).
2. Browse the parameter set list. Confirm that HMI_LoadedParamSetID and the on-screen IO field do not change.
3. Select parameter set 2 and press Load. The IO field should update to 2 and the symbolic IO field should show PS_LineA_HighSpeed (or whichever name set 2 carries).
4. Open the PLC's online view on the parameter set elements. Confirm that the values match the file (compare byte by byte for the first record).
5. Browse the list again, scroll, apply a filter, and press Cancel. The IO field must continue to show the last loaded set — not the currently selected row.
6. Force a PLC stop / run transition. The displayed value should persist; the HMI tag values are stored in the panel's image, not the PLC.
7. Switch the panel language. ReadParameterSetName honours UI.Language; verify the name updates accordingly.

10. Troubleshooting Matrix

11. Best Practices and Caveats

• Never rely on PACO's Current parameter set ID as the source of truth for the PLC's active recipe. It reflects the operator's selection, not the load state.
• Always filter on the command ID inside the Command fired event. A handler that runs on every button press is a correctness bug, not a performance issue.
• Treat the persistent HMI tags (HMI_LoadedParamSetID / HMI_LoadedParamSetName) as a cache. Re-validate against the PLC on critical transitions (cold start, screen change to a recipe-bound screen, language change).
• If you have multiple parameter-set types, scope the ReadParameterSetName call by type and ID; the function will not resolve names across types.
• In V19, the parameter-set-type name is case-sensitive in the runtime API. Match the spelling of the engineering view exactly.
• For multi-record parameter sets, add a Record ID tag in parallel to the Parameter set ID tag and persist both.
• Keep all parameter set names ASCII-safe where possible; the WString tag will accept Unicode, but PLC-side tools that consume the name may not.
• If the panel loses the connection to the CPU 1511-1 PN, the IO field will hold its last value. Add a connection-status indicator and clear the field on lost connection to avoid operator confusion.

FAQ