Calculating a 5-Second Moving Average in STEP 7 S7-300

Overview: 5-Second Moving Average on S7-300 / S7-400

A 5-second moving average is one of the most common signal-conditioning primitives in STEP 7 programming. It is requested whenever a noisy analog input — a flow transmitter on a pulsating pump, a pressure transducer near a reciprocating compressor, a weighing signal on a vibratory feeder — must be stabilized before it is logged, displayed, or fed into a closed-loop controller. STEP 7 V5.x does not ship a dedicated "average" function block in the standard library, which is why the question of how to compute a moving average recurs in nearly every S7-300 and S7-400 project. The block most engineers reach for first is FC90, the standard-library shift register, but FC90 only shifts values through a buffer; it never adds, divides, or outputs a mean. The arithmetic mean has to be assembled by a summation FB or by indexing a ring buffer inside a cyclic interrupt OB.

This reference covers four field-proven implementations and the engineering trade-offs between them:

1. FC90 shift register + chained summation FB — the classic STEP 7 V5.x pattern when the project already owns FC90 instances
2. OB35 cyclic interrupt with an indexed ring buffer and a running sum — lowest scan-time jitter, scales to 500+ samples without measurable CPU load
3. PT1-style exponential smoothing — single REAL of state, ideal for very long windows where an exact arithmetic mean is not required
4. TIA Portal V18 / V19 implementation using the IEC COUNT, ADD, and DIV blocks from the global library, following the canonical pattern in Siemens Support entry 1021364

Choose based on three criteria: whether the process is fast or slow, whether the application needs the exact arithmetic mean or only a smoothed signal, and whether you are maintaining legacy STEP 7 V5.7 code or migrating to TIA Portal.

Prerequisites: Software, Catalog Numbers, and CPU Constraints

Sampling Time and Window Size Selection

The 5-second window has two degrees of freedom: the sample period T_s and the buffer length N. They are linked by

T_window = T_s × N

For a 5-second average the most common choices are:

The OB35 default of 100 ms with N = 50 is the most common combination on S7-300 because it fits within the smallest work-memory envelope and still gives a smooth result for the majority of analog inputs. On S7-400, OB35 can be reconfigured to any multiple of the basic 1 ms clock up to 60 s via HW Config → CPU Properties → Cyclic Interrupts.

OB35 Cycle Configuration in HW Config

Configure OB35 once per CPU and never change it without re-validating N. The procedure:

1. Open the S7 project in STEP 7 Manager and double-click Hardware to launch HW Config.
2. Open the CPU object and select the Cyclic Interrupts tab.
3. Set OB35 priority to a value above OB1 (priority 12 by default; raise to 13 if PID_SCP runs in OB35 as well).
4. Set the Execution interval to the desired T_s in milliseconds.
5. Download the hardware configuration. The CPU will start OB35 on the next STOP→RUN transition.

Method 1 — FC90 Shift Register with Summation Chain

FC90 is the standard-library shift-register block (catalog name Shift Register). It shifts a value of width 1, 8, 16, or 32 bits through an ANY-pointer array each time its EN input receives a rising edge. It does not compute a sum or a mean — its only output is the value shifted out of the last slot of the array.

To convert FC90 into an averaging primitive, three additional pieces of logic are required:

1. A trigger pulse once per sample period T_s — typically the OB35 cycle flag or a clock-bit generated from a timer.
2. A summation loop that walks the shift array and adds every REAL slot into an accumulator.
3. A divider that divides the accumulator by N to produce the mean.

Trigger generation

The simplest trigger is the OB35 cycle itself: every time OB35 fires, call FC90 once. There is no need for an external comparator, clock-bit, or timer.

Summation with chained ADD_R

The STEP 7 standard library only provides ADD_R, which accepts exactly two REAL operands. To sum N samples you have two options:

FC90 pitfalls encountered in practice

• Edge-triggered shift. FC90 shifts only when EN transitions from 0 to 1. If you call FC90 from OB1 with EN tied to a clock-bit that is already 1, the shift fires exactly once and then stops. Always call FC90 from a cyclic OB (OB35 / OB32 / OB38) so the EN is re-armed each cycle.
• Shift width must match the data type. The S7 data type REAL is 32 bits. Use FC90's DWORD mode (shift width B#16#04) so the IEEE-754 bit pattern is preserved end-to-end.
• Static vs global array. The shift array must be declared STATIC inside an FB-instance DB, not as a global DB, because the ANY pointer into a global DB can collide with other FB instances during runtime re-mapping.

Method 2 — OB35 Cyclic Interrupt with Indexed Ring Buffer

This is the canonical production pattern on S7-300. A single FB owns a STATIC array of REAL samples, an index, and a running sum. Each time OB35 fires:

1. The oldest sample is subtracted from the running sum.
2. The new sample overwrites that slot.
3. The index is incremented modulo N.
4. The mean is computed as sum / N.

Because the running sum is maintained incrementally, only one subtraction and one addition per cycle are required, regardless of N. This makes the method scale to windows of 500+ samples without measurable CPU load on a CPU 315-2 PN/DP.

Method 3 — PT1-Style Exponential Smoothing

If an exact arithmetic mean is not required — for example, when the moving average is used as a low-pass filter on the input of a PID controller — exponential smoothing gives a much smaller memory footprint and a smoother frequency response:

y(k) = α · x(k) + (1 − α) · y(k−1)

where

α = T_s / (T_window + T_s)

For T_s = 100 ms and T_window = 5 s the resulting α is approximately 0.0196. Only one REAL of state is required.

The downside is that y(k) is not a true mean; it is a weighted average that gives more weight to recent samples. For most slow process loops this difference is invisible, but if your application requires the average of exactly the last 5 seconds of data — for example, a regulatory emission report — stick with Methods 1 or 2.

Method 4 — TIA Portal Alternative Using IEC Blocks

In TIA Portal V18 / V19, the standard "average value" calculation pattern published in Siemens Support entry 1021364 uses the following blocks from the global IEC library:

• COUNT — counts samples up to a configurable maximum
• ADD — sums REAL values across a tag array
• DIV — REAL division

Siemens' reference example computes the average of five values (5.0 + 3.0 + 1.0 + 7.0 + 14.0) / 5 = 6.0; the same pattern scales linearly to 50 or 500 samples. TIA Portal's SCL compiler makes the summation loop trivial:

#sum := 0.0;
FOR #i := 0 TO #N - 1 DO
    #sum := #sum + #samples[#i];
END_FOR;
#avg := #sum / INT_TO_REAL(#N);

For migration from STEP 7 V5.x to TIA Portal, the FC90-based project can be lifted into TIA Portal V18 as-is: the S7 Programmable Functions library is still installed, and FC90 behaves identically. The shift-width selection (BIT / BYTE / WORD / DWORD) maps directly to the new input field in the FC90 instance dialog. New code should still prefer the IEC pattern from entry 1021364 because it is portable across CPU families (S7-300, S7-400, S7-1200, S7-1500) and survives any future library change.

Method Comparison: CPU Load, Memory, and Latency

Method 2 is the best general-purpose choice on STEP 7 V5.x. Method 3 wins whenever the window is longer than ~50 s because the memory savings dominate. Method 1 is reserved for projects with an existing FC90 dependency. Method 4 is the only choice on TIA Portal S7-1200 / S7-1500 if you want a portable IEC implementation.

Working Code: FB100 in STL

The following FB100 ("FB_AVG_5S") implements Method 2 in STL. It is intended for STEP 7 V5.7 and assumes OB35 is configured for a 100 ms cycle, giving N = 50 samples over 5 seconds. The complete declaration and code section are shown so the FB can be pasted directly into a STEP 7 source file.

FUNCTION_BLOCK FB100
TITLE   = '5-Second Moving Average (OB35-driven)'
VERSION : '1.0'
VAR_INPUT
  i_raw   : REAL;     // scaled input, e.g. 0.0..100.0 after FC105
  i_reset : BOOL;     // rising-edge clear of buffer and sum
END_VAR
VAR_OUTPUT
  o_avg   : REAL;     // arithmetic mean of the last 5 s
  o_full  : BOOL;     // TRUE once the buffer holds N valid samples
END_VAR
VAR
  arr      : ARRAY[0..49] OF REAL;  // ring buffer
  sum      : REAL;                  // running sum of arr
  idx      : INT;                   // next write slot, 0..49
  cnt      : INT;                   // sample counter up to N
  N        : INT := 50;             // window length
  iv_reset : BOOL;                  // edge memory for i_reset
END_VAR
BEGIN
  // ---- reset (rising edge) ----
  IF i_reset AND NOT iv_reset THEN
      idx := 0;
      cnt := 0;
      sum := 0.0;
  END_IF;
  iv_reset := i_reset;

  // ---- incremental sum update ----
  sum := sum - arr[idx] + i_raw;
  arr[idx] := i_raw;

  // ---- advance index modulo N ----
  idx := idx + 1;
  IF idx >= N THEN
      idx := 0;
  END_IF;

  // ---- counter ----
  IF cnt < N THEN
      cnt := cnt + 1;
  END_IF;

  // ---- average output ----
  IF cnt > 0 THEN
      o_avg := sum / INT_TO_REAL(cnt);  // partial-window average until N is reached
  ELSE
      o_avg := 0.0;
  END_IF;

  o_full := (cnt = N);
END_FUNCTION_BLOCK

Call the FB once from OB35 with:

CALL FB100, DB100
      i_raw   := "scale_flow".out_value   // REAL from FC105
      i_reset := "first_scan"              // BOOL, TRUE on first OB35 cycle
      o_avg   := "avg_flow_5s"             // REAL, writeable from HMI
      o_full  := "avg_flow_5s_ready";      // BOOL

The partial-window average (o_avg = sum / cnt) is intentional: while the buffer is filling up after a reset or first scan, the output reflects the mean of the samples actually present, which is the physically correct interpretation. Once o_full is TRUE the denominator locks to N.

Parameter Reference and Instance DB Layout

The instance DB occupies 232 bytes (200 for the array + 32 for scalars). This is well within the work-memory limits of every S7-300 CPU and is regenerated cleanly by STEP 7 after a download because no initial values other than N := 50 are required.

Analog Input Pre-Processing Before Averaging

Feed FB100 with a value that has already been scaled into engineering units. The canonical pre-processing chain on an S7-300 SM 331 (6ES7331-7KF02-0AB0) is:

1. L PIW 304 — read the analog input word (12-bit + sign, 0..27648 for ±10 V / 4..20 mA)
2. FC105 SCALE — convert to engineering units (REAL)
3. FB100 — compute the 5-second mean
4. L "avg_flow_5s" — feed the averaged value to the PID controller or to the HMI tag

Common Faults and Troubleshooting Matrix

Verification and Commissioning Procedure

Before sign-off, validate the average FB with the following three-step commissioning procedure:

1. Step-response check. Inject a known step change (e.g., 0.0 → 50.0) at the input and confirm in the VAT table that the output reaches 50.0 × (1 − 1/e) ≈ 31.6 within one time-constant (~5 s for Method 3, exactly at sample N for Methods 1 and 2). For Methods 1 and 2 the partial-window fill will produce a straight-line ramp from 0 to 50 over the first 5 s.
2. Nyquist attenuation check. Inject a sine wave at the Nyquist limit (period = 2 × T_s) and confirm that the output amplitude is attenuated to roughly 0.6 of the input. This validates that the window is in fact 5 s and not 10 s, and that N is correct.
3. Cycle-time sanity check. Force the OB35 cycle to 200 ms in the hardware configuration, restart the CPU, and confirm that the average step response now takes 10 s instead of 5 s. This is the cleanest way to catch mis-sized buffers in the field — a buffer of 50 samples with a 200 ms cycle gives a 10-second mean, not a 5-second mean, and this single test exposes the miscalculation immediately.

Migration Considerations: STEP 7 V5.x to TIA Portal

When migrating an FC90-based averaging project from STEP 7 V5.7 to TIA Portal V18 or V19, observe the following:

• The S7 Programmable Functions library ships with every TIA Portal install. FC90 is identical in behaviour and interface to its V5.x counterpart.
• The shift-width field that was a BYTE constant B#16#04 in V5.x becomes an INT constant 4 in TIA Portal. Migrating this value requires manual confirmation; do not rely on the auto-migrator.
• The ANY pointer in V5.x becomes a VARIANT pointer in TIA Portal. The semantics are identical but the syntax differs: replace SRCBLK := P#DB100.DBX0.0 BYTE 200 with SRCBLK := "DB100".arr.
• For new code, prefer the IEC averaging pattern from Siemens Support entry 1021364. It uses COUNT, ADD, and DIV from the global IEC library, is portable across S7-300 / S7-400 / S7-1200 / S7-1500, and survives any future FC90 deprecation.

Frequently Asked Questions