S7-1200 PID_Compact Runtime Parameter Switching with SCL

Switching PID_Compact gain, integral time, and derivative time on a Siemens S7-1200 during a live process is a common requirement when one controller must serve multiple load conditions (fan stages, heater banks, valve positions, product recipes). A typical field symptom is the PWM output locking at 100 % the instant a parameter is written, which is not a defect in the CPU 1212C, the SM 1231 RTD module, or the SM 1232 analog output module - it is a misuse of the PID_Compact technology object. This reference walks through the correct runtime structure, the SCL pattern that avoids PWM latch-up, the differences between Config and Retain data, and a PID_Temp fallback for pure temperature loops.

1. Problem Definition

Engineers routinely build systems where one physical actuator must be driven from one PID controller whose tuning depends on which loads are active. A 4-fan / 8-stage heater matrix is a canonical example:

The naïve implementation writes the new Gain, Ti, and Td into the PID_Compact instance DB from an SCL CASE block. The block then either:

• Locks its PWM output ON (100 % duty cycle) and never recovers, or
• Responds as if it has just been commissioned and briefly restarts the pretune / fine-tune sequence,

Both behaviors come from the same root cause: the wrong sub-structure of the technology object DB is being modified, or the controller is being switched between Mode values without sequencing the I-part.

2. Prerequisites

• CPU 1212C DC/DC/DC (6ES7212-1AE40-0XB0 or later -0XB0 variant). The four onboard outputs Q0.0 - Q0.3 source 24 V at 0.5 A and are TTL-compatible, suitable for the PWM signal into an SSR or solid-state relay.
• SM 1231 RTD module (6ES7231-5PD32-0XB0 or -5PF32-0XB0) for PT100/PT1000 feedback.
• SM 1232 analog output (6ES7232-4HD32-0XB0) if a continuous 4 - 20 mA or 0 - 10 V control signal is also required (optional when PWM is the sole actuator).
• TIA Portal V14 SP1 or later. V18 / V19 / V21 added additional PID_Compact help; the runtime structure described here is compatible across all of them because the technology object schema is firmware-defined, not project-defined.
• CPU firmware 4.2 or higher (PID_Compact became a technology object instead of a plain FB starting at firmware 4.0).
• One instance DB of type PID_Compact added to Technology objects > PID_Compact in the project tree.

Reference documentation:

• Technology object PID_Compact (S7-1200, S7-1500, S7-1200 G2) - the canonical reference for the PID_Compact DB schema and runtime behavior.

3. PID_Compact Data Structure (What You Can and Cannot Write at Runtime)

The PID_Compact instance DB is structured into these primary regions:

The single most common failure mode observed in the field is the following SCL fragment:

// INCORRECT - writes the engineering view, not the Retain area
"PID_Compact_1".Gain := 2.5;
"PID_Compact_1".Ti   := 30.0;
"PID_Compact_1".Td   := 0.0;

Those tags exist in the data view of the DB for engineering convenience, but they are aliases that only mirror the values loaded into Retain.CtrlParams at the end of each cycle. Writing them has no effect on the controller until the next cold restart, and during the cycle the integrator keeps the previous Gain active - producing the perceived "PWM stuck ON" symptom because the I-part saturates while the user thinks the P-only value has been applied.

The correct path is:

// CORRECT - writes directly to the runtime Retain area
"PID_Compact_1".Retain.CtrlParams.Gain := 2.5;
"PID_Compact_1".Retain.CtrlParams.Ti   := 30.0;
"PID_Compact_1".Retain.CtrlParams.Td   := 0.0;

4. Why the PWM Output Locks at 100 %

There are four distinct mechanisms that all manifest as "PWM output stuck ON" when parameters are modified at runtime. Diagnose in this order:

4.1 Integrator wind-up from a stale setpoint during a write

If the process value is far from the new setpoint when the controller is re-tuned with a smaller Ti, the integral action accumulates error faster than the plant can respond. The I-part saturates at OutputScaling.UpperPointOut (typically 100 %), and the PWM duty cycle is driven to its maximum. The user observes a "stuck ON" condition until the integrator drains. The fix is to clear the integrator on every parameter set transition:

// Reset integrator before loading new parameters
"PID_Compact_1".Mode := 4;   // mode 4 = "inactive with reset"
"PID_Compact_1".Retain.CtrlParams.Gain := NewGain;
"PID_Compact_1".Retain.CtrlParams.Ti   := NewTi;
"PID_Compact_1".Retain.CtrlParams.Td   := NewTd;
"PID_Compact_1".Mode := 3;   // mode 3 = "automatic"

4.2 Mode = 0 leaves the output at the last value

If the controller is being driven with Mode = 0 (inactive) during parameter writes, the PWM holds its last computed duty cycle. Users frequently interpret this as "stuck ON" when in fact the controller is simply not running. Verify with the online watch table that "PID_Compact_1".Mode is 3.

4.3 Pretune / fine-tune was triggered by an erroneous Mode write

Setting Mode to 1 or 2 starts pretune or fine-tune. These modes drive the actuator through a controlled excitation sequence to identify the plant. They will hold the output at extremes (0 % and 100 %) by design and will look exactly like a "stuck" output. Never write to Mode from user code while performing parameter switching.

4.4 Output scaling upper limit set to 100 with no headroom

If Config.OutputScaling.UpperPointOut is 100 and LowerPointOut is 0, the controller cannot produce negative correction - which is fine for heating. But if a downstream contactor or SSR has a minimum-on time longer than the PWM period (default 1.0 s), the output may appear latched. Use Config.PWM.MinimumOnTime / MinimumOffTime to enforce SSR-friendly switching.

5. The Correct Runtime Switching Method

The recommended pattern uses a single PID_Compact instance, an SCL function that owns the parameter bank, and an edge-triggered load to avoid writes on every cycle.

5.1 Define a parameter bank DB

Create a global DB (e.g. DB_PID_ParamSets) with eight parameter sets, one per process state:

TYPE "UDT_PID_ParamSet"
VERSION : 0.1
   STRUCT
      Gain     : REAL;   // proportional gain (Kp)
      Ti       : REAL;   // integral action time in seconds (0 = off)
      Td       : REAL;   // derivative action time in seconds (0 = off)
      TdFilt   : REAL;   // derivative filter time constant in seconds
      Setpoint : REAL;   // engineering-units setpoint
      PZone    : REAL;   // proportional band / deadband width
   END_STRUCT;
END_TYPE

DATA_BLOCK "DB_PID_ParamSets"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
NON_RETAIN
   STRUCT
      ActiveSet : INT;                       // 1..8, mirrored from mode selector
      ParamSet  : ARRAY[1..8] OF "UDT_PID_ParamSet";
   END_STRUCT;
END_DATA_BLOCK

5.2 Write the parameter-loading FC in SCL

The function executes once per OB1 cycle, but it only touches the technology object on a rising edge of ActiveSet:

FUNCTION "FC_PID_LoadParams" : VOID
VAR_INPUT
    ModeBits : DWORD;   // FAN1..FAN3 etc. packed here
END_VAR
VAR_TEMP
    tSelectedSet : INT;
    tOldSet      : INT;
    tParams      : "UDT_PID_ParamSet";
END_VAR
BEGIN
    // Determine selected set from mode bits
    tSelectedSet := "FC_BitsToSetId"(ModeBits);  // user function returning 1..8

    tOldSet := "DB_PID_ParamSets".ActiveSet;

    IF tSelectedSet <> tOldSet THEN
        // Read selected parameter set into temp
        tParams := "DB_PID_ParamSets".ParamSet[tSelectedSet];

        // Place controller in inactive-with-reset to drain integrator
        "PID_Compact_1".Mode := 4;

        // Write the Retain.CtrlParams values - this is the only path that takes effect
        "PID_Compact_1".Retain.CtrlParams.Gain  := tParams.Gain;
        "PID_Compact_1".Retain.CtrlParams.Ti    := tParams.Ti;
        "PID_Compact_1".Retain.CtrlParams.Td    := tParams.Td;
        "PID_Compact_1".Retain.CtrlParams.TdFilt:= tParams.TdFilt;
        "PID_Compact_1".Retain.CtrlParams.PZone := tParams.PZone;

        // Update setpoint in the same transition to avoid re-tune on stale SP
        "PID_Compact_1".Setpoint := tParams.Setpoint;

        // Return to automatic mode
        "PID_Compact_1".Mode := 3;

        "DB_PID_ParamSets".ActiveSet := tSelectedSet;
    END_IF;
END_FUNCTION

5.3 OB1 invocation

// In OB1 (or a higher-priority OB if you want deterministic switching)
"FC_PID_LoadParams"(ModeBits := "DB_ModeBits".Word0);
"PID_Compact_1"(Setpoint       := "DB_PID_ParamSets".ParamSet["DB_PID_ParamSets".ActiveSet].Setpoint,
                Input          := "DB_Process".PV_Engineering,
                Input_PER      := 0,                     // 0 = disabled when using Input
                ManualEnable   := FALSE,
                ManualValue    := 0.0,
                // The following are read-only outputs, do NOT assign
                Output         => "DB_Process".Output_Pct,
                Output_PWM     => "Q0.0");

Three points make this pattern reliable:

1. Edge-triggered writes to Retain.CtrlParams prevent the integrator from being repeatedly disturbed each cycle.
2. Mode 4 reset drains the I-part before new parameters are applied, eliminating the wind-up saturation that produces 100 % PWM.
3. Setpoint update in the same transaction prevents a brief PV-vs-SP excursion that would otherwise trigger an apparent fine-tune response.

6. PWM Output Configuration on the CPU 1212C

On the CPU 1212C, Output_PWM is a Boolean (0/1) signal wired directly to the bit address of a digital output. The PID_Compact block internally computes the duty cycle and toggles the bit during the configured PWM period. Configuration values live in the technology object editor under Configuration > Output > PWM:

7. PID_Temp Alternative for Heating Loops

When the controlled variable is strictly temperature and the actuator is a heating element, Siemens recommends PID_Temp rather than PID_Compact. PID_Temp:

• Provides built-in ramp limiting on the output (limits heater thermal shock).
• Supports a true derivative action on the PV rather than on the error (less setpoint-induced derivative kick).
• Exposes Config.HeatPid.Gain and Config.CoolPid.Gain directly, allowing two completely independent parameter sets - one for heating and one for cooling - without runtime switching.

For the FAN-driven heating scenario in the source problem, where one heating element sees eight different cooling loads, PID_Compact with runtime switching remains the right choice. For a single heating/cooling valve pair, switch to PID_Temp.

8. Step-by-Step Implementation Procedure

1. Add the technology object. In the project tree: Technology objects > Add new > PID > PID_Compact. Name it PID_Compact_1. The wizard creates the instance DB.
2. Configure input and output scaling. Under Configuration > Basic settings set InputScaling to match the RTD range (e.g. -50 to +400 °C for PT100) and OutputScaling to 0 - 100 %.
3. Configure PWM. Under Configuration > Output > PWM, set the period, minimum on/off times, and select Output_PWM as the active output.
4. Create the parameter UDT and DB. Use the snippets from §5.1.
5. Create the loader FC. Use the snippet from §5.2. Mark the FC as SCL in the block properties.
6. Wire the FC in OB1. Place the call before the PID_Compact call so the mode transition completes before the controller runs.
7. Populate parameter sets. Either via the parameter view or by writing initial values into the DB; commissioning can also be done by exporting the DB to a CSV and re-importing per recipe.
8. Compile and download. Include the technology object in the download set.

9. Commissioning and Verification

Use a watch table on the PID_Compact instance DB to confirm each transition:

For step-response validation per parameter set:

1. Force the load to the configuration for Set 1 (FAN1 ON, FAN2 OFF).
2. Apply a 10 % setpoint step.
3. Log PV, SP, Output_PWM for 3 × the longest Ti of any set.
4. Compute ITAE and overshoot for the recorded trace.
5. Repeat for Sets 2 - 8.

10. Troubleshooting Matrix

11. Common Pitfalls Beyond the PWM Issue

11.1 Optimized block access

With S7-1200 firmware 4.2 and later, all new data blocks default to optimized (symbolic) access. The Retain.CtrlParams absolute path is still valid as long as the block was generated by the technology object wizard. If you hand-create the DB or import from a CSV, the path will not exist and the write will fail silently.

11.2 Cycle time vs OB1 priority

If the loader FC runs in OB1 (priority 1) and the PID_Compact is also called in OB1, the parameter write and the controller execute in the same cycle - acceptable. If the loader runs in a higher-priority OB (e.g. OB35 cyclic interrupt at priority 16), the controller may read partially written values. Always run them in the same OB or insert a Mode = 4 fence for at least one full PID cycle before resuming automatic.

11.3 Retain after power cycle

Retain.CtrlParams persists across power cycles because it is backed by the CPU's retentive storage. The ActiveSet integer in DB_PID_ParamSets must be declared RETAIN or it will reset to 0 after power-down, causing the controller to start with the wrong parameter set on the next boot.

11.4 Firmware 4.0 vs 4.2 PID_Compact schema

CPU firmware 4.0 introduced PID_Compact as a technology object. Firmware 4.2 renamed Retain.CtrlParams from the original CtrlParams path and added TdFilt. If you upgrade an older project, the TIA Portal compiler will normally rewrite the path, but manual DB symbol renames after a failed migration can leave Retain empty.

12. Field-Proven Parameter Set Recommendations

For a heating system with 8 fan states (binary combinations of three fans), a typical starting point after one autotune run on each state is:

These are starting points only. Always run a per-set pretune (Mode = 1) on the actual plant to derive the real Gain and Ti; the table above gives a monotonic trend (more airflow → less gain, faster integration) that is useful for sanity-checking your autotune results.

13. Frequently Asked Questions