S7-1200 SCL: Implementing Moving Average Filter for AI Inputs

Analog inputs on Siemens S7-1200 CPUs (SM 1231, SB 1231, and the onboard AI of CPU 121xC / 121xFC / 151xC variants) routinely pick up coupled noise from variable-frequency drives, contactor coils, thermocouple reference-junction drift, and shared 24 V supply returns. While the analog module offers a configurable hardware integration time, software filtering is required when the noise frequency overlaps the process bandwidth, when several channels must share one filter behavior, or when the filtered value feeds a downstream calculation (PID set-point derivation, energy computation) that needs a deterministic, repeatable algorithm.

This reference builds a complete, production-grade moving-average filter (MAV) as an SCL function block for the S7-1200, with O(1) update cost, first-scan buffer priming via OB100, a ring-buffer pointer that prevents array shifting, and a pulse trigger that decouples acquisition from the OB1 scan time. The implementation deliberately avoids the legacy FILL intrinsic (SFC21), which is not callable on S7-1200 firmware, and uses the SCL FILL_BLK standard extension instead.

1. Filter Selection: When to Choose Moving Average

Three digital filter classes are routinely applied to PLC analog inputs:

For the use case in the field report — thermocouple noise from a dirty workpiece in a heating application — the moving average is a strong default: the TC drifts slowly when contact is good but bursts with high-frequency noise while contact is intermittent. The MAV suppresses white noise proportional to 1/√N while preserving the slow contact-quality drift.

2. Prerequisites

Reference documentation: the Siemens Industry Online Support portal hosts the current S7-1200 product catalog and system manuals, and the S7-1200 programming and SCL reference.

3. Discrete-Time Moving Average Math

The simple MAV of length N for a sample acquired at index n:

Naively this requires N additions and N-1 reads of the buffer every cycle. The running-sum form keeps the work O(1):

where S is the maintained sum and x[n-N] is the oldest sample, evicted from the ring buffer when the write pointer wraps. This is the form implemented below. Stability conditions:

• S must be wide enough to avoid overflow. For REAL on S7-1200, S is sufficient for typical analog ranges; promote to LREAL only when the input range combined with N exceeds ±10⁷.
• Sample acquisition must be at a fixed period; jitter on the trigger shifts the effective -3 dB cutoff frequency. A cyclic interrupt OB (e.g. OB30) is preferred over an OB1 flag-driven trigger for any closed loop.
• The signal must be stationary: large step changes during the first N samples after Init will be biased toward the primed value until the buffer fully rolls over.

4. SCL Function Block Implementation

The block below is MAV_Filter. Add it as a new FB with optimized access in your TIA Portal project. The instance DB stores the ring buffer, pointer, and persistent state across scans.

// MAV_Filter - Simple Moving Average with O(1) running sum
// Target: S7-1200 / TIA Portal V17+
FUNCTION_BLOCK "MAV_Filter"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1

VAR_INPUT
  AI_Raw           : Real;    // scaled AI value (engineering units)
  AI_Buffer_Length : USInt;   // N: 1..64 samples, validated at run time
  Acquire          : Bool;    // capture one sample per TRUE scan
  Init             : Bool;    // TRUE for one scan to re-prime the buffer
END_VAR

VAR_OUTPUT
  AI_Average  : Real;
  Buffer_Full : Bool;         // TRUE once N samples have been processed
  Error       : Word;         // 0 = OK; see error codes below
END_VAR

VAR
  AI_Buffer  : Array[0..63] of Real;  // ring storage, max 64 entries
  Sum        : Real;                  // running sum S[n]
  AI_Pointer : USInt;                 // next write index, 0..N-1
  Samples    : USInt;                 // count of valid samples seen
END_VAR

VAR_TEMP
  TempVal : Real;
  N       : USInt;
END_VAR

BEGIN
  // ---- Parameter validation ---------------------------------
  IF (AI_Buffer_Length = 0) OR (AI_Buffer_Length > 64) THEN
    Error := 16#0001;       // invalid length
    RETURN;
  END_IF;
  N := AI_Buffer_Length;

  // ---- Init / Re-prime --------------------------------------
  IF Init THEN
    FILL_BLK(IN := AI_Raw,
             COUNT := USINT_TO_DINT(N),
             OUT => AI_Buffer);
    Sum := AI_Raw * USINT_TO_REAL(N);
    AI_Average := AI_Raw;
    AI_Pointer := 0;
    Samples := 0;
    Buffer_Full := FALSE;
    Error := 0;
    RETURN;
  END_IF;

  // ---- Idle: no acquisition this scan -----------------------
  IF NOT Acquire THEN
    Error := 0;
    RETURN;
  END_IF;

  // ---- Acquisition & ring-buffer update ---------------------
  TempVal := AI_Buffer[AI_Pointer];
  AI_Buffer[AI_Pointer] := AI_Raw;
  Sum := Sum + AI_Raw - TempVal;
  AI_Average := Sum / USINT_TO_REAL(N);

  // Advance pointer, wrapping at N-1
  IF AI_Pointer >= (N - 1) THEN
    AI_Pointer := 0;
  ELSE
    AI_Pointer := AI_Pointer + 1;
  END_IF;

  // Track sample count until the buffer is full
  IF Samples < N THEN
    Samples := Samples + 1;
    IF Samples = N THEN Buffer_Full := TRUE; END_IF;
  END_IF;

  Error := 0;
END_FUNCTION_BLOCK

Key design points:

• FILL_BLK is the SCL intrinsic for SFC21 FILL semantics. The legacy two-argument FILL(value, target) form is rejected by S7-1200 firmware; the three-argument FILL_BLK(IN, COUNT, OUT) form is the documented standard-extension alternative. The COUNT parameter expects a DINT on S7-1200, hence the explicit USINT_TO_DINT cast.
• The Sum variable is maintained as REAL to match typical AI scaling; if the analog range and N together can exceed REAL precision (≥10⁷), promote Sum to LREAL and the divisor accordingly.
• The Samples counter guards against an under-read during the first N cycles after Init — without it, AI_Average would be biased low until the buffer fully rolls over.
• Optimized block access is mandatory if the instance DB will be exposed to OPC UA Server or the Web API; legacy absolute access breaks symbolic binding on those interfaces.

5. First-Scan Initialization Pattern

The Init input of MAV_Filter must be pulsed TRUE on the first scan after the CPU goes from STOP to RUN, and again after any warm restart that re-initializes non-retentive process image bits. The canonical Siemens pattern uses OB100 (Startup) for the set and the last network of OB1 for the reset:

// OB100 - Startup (executed once on STOP -> RUN)
"DB_MAV".Init := TRUE;

// OB1 - last network
"DB_MAV".Init := FALSE;

6. Acquisition Trigger and Timing

For the highest noise rejection, drive Acquire from a cyclic interrupt OB rather than from OB1. A 100 ms OB30 (configured in CPU Properties → Cyclic Interrupts) yields a 10 Hz sample rate; with N = 16 this gives a 1.6 s window and a -3 dB cutoff near 1/(πN·T) ≈ 0.020 Hz.

A one-shot pulse can be generated inside OB30 by detecting a rising edge on a clock bit or by latching a new sample flag set in the AI module's "Conversion Finished" interrupt.

7. Multiple-Pass and Cascade Filters

A two-pass moving average (cascade of two MAV_Filter instances) yields a triangular-window MAV with sharper roll-off and lower sidelobe level. Per Smith, "The Scientist and Engineer's Guide to Digital Signal Processing", Chapter 15, a k-pass MAV of length N is mathematically equivalent to a single-pass MAV of length N + (k-1)·(N-1), but is computationally cheaper because each pass reuses the same small buffer. For the S7-1200, two passes of N = 8 are typically cheaper than one pass of N = 15, and they yield a smoother time-domain response. Cascade two instances and feed AI_Average of the first into AI_Raw of the second; remember to invoke Init on both blocks together from OB100.

8. Hardware Filtering on the SM 1231

The SM 1231 / SB 1231 / onboard AI provide integration-time selection in TIA Portal under Device Configuration → AI channel → Inputs → Integration. This is a sinc-weighted average performed in the module's sigma-delta modulator. Always enable the longest integration time that still meets your bandwidth requirement; the block-level software MAV then removes residual noise that the integration time cannot, because of mains-cycle pickup at the AI channel.

Combining 100 ms hardware integration with a 16-sample software MAV on a 100 ms cycle yields 80 dB+ mains-noise rejection for thermocouple inputs without any external RC network.

9. Exponential Smoothing Alternative

If buffer memory is at a premium (for example, on the S7-1211C with 50 KB of work memory) and α must be tuned live from the HMI, replace MAV_Filter with an EMA block:

// EMA_Filter - Single-pole IIR, no buffer required
FUNCTION_BLOCK "EMA_Filter"
{ S7_Optimized_Access := 'TRUE' }

VAR_INPUT
  AI_Raw : Real;
  Alpha  : Real;   // 0 < Alpha ≤ 1, e.g. 0.1 for slow tracking
  Init   : Bool;
END_VAR

VAR_OUTPUT
  AI_Average : Real;
END_VAR

VAR
  Y : Real;        // filtered output, persisted
END_VAR

BEGIN
  IF Init THEN
    Y := AI_Raw;
  ELSE
    Y := (Alpha * AI_Raw) + ((1.0 - Alpha) * Y);
  END_IF;
  AI_Average := Y;
END_FUNCTION_BLOCK

EMA is a discrete-time equivalent of a single-pole RC filter with time constant τ = T·(1-α)/α, where T is the sampling period. It is the recommended choice when:

• Memory cost must stay O(1) (no ring buffer).
• α needs to be live-tuned without losing historical samples.
• The noise is pink (1/f) rather than white — EMA's first-order low-pass character handles this better than a uniform MAV.

10. Commissioning and Verification

1. Watch-table step injection. In TIA Portal, open the instance DB and force AI_Raw = 100.0, then cycle the CPU. Watch Sum settle to 100.0 · N after N samples, and AI_Average equal 100.0 once Buffer_Full goes TRUE.
2. Step response test. Switch AI_Raw from 0.0 to 100.0 mid-cycle. The output AI_Average must ramp linearly to 100.0 over N sample periods — a flat output indicates the pointer or sum update is broken.
3. Noise rejection. Apply ±5 LSB Gaussian noise on AI_Raw from a function-generator block. With N = 16 the standard deviation of AI_Average should drop by approximately √16 = 4×.
4. Cycle-time impact. Profile OB1 with the Time Measurement trace; one MAV_Filter execution must consume < 0.05 ms on a CPU 1214C at N = 32. A much larger value indicates the compiler emitted an index-loop instead of an inlined pointer access, often caused by a non-optimized DB.
5. Long-term drift test. Run for ≥ 24 h on a constant DC input and compare the running Sum against the expected value N · AI_Raw. Drift larger than 0.1% means promote Sum to LREAL or schedule periodic Init pulses.

11. Troubleshooting Matrix

FAQ