Filters, PID and Signal Code

Signals, samples and sample rate

Real signals are noisy and arrive as samples at fixed times. Every filter and controller assumes equal time steps Δt, so drive the code from a timer, not from a loop that runs “as fast as it can” (see Embedded Systems: Timers). The sample rate must be more than twice the highest frequency in the signal (the Nyquist rate), or higher frequencies fold back as false lower ones (aliasing).

The exponential filter

The simplest useful filter is the exponential moving average (a first-order low-pass), which needs only one stored value:

y_new = y + α × (x − y)    α = Δt ÷ (τ + Δt)

x is the new reading, y the filtered value, Δt the time between samples and τ the filter time constant.

class Ema:
    def __init__(self, dt, tau):
        self.alpha = dt / (tau + dt)
        self.y = None
    def update(self, x):
        self.y = x if self.y is None else self.y + self.alpha * (x - self.y)
        return self.y

/* C, integers: alpha = 1/8, y kept with 4 extra fractional bits */
y16 += ((int32_t)x * 16 - y16) >> 3;

Moving average and median filters

Filter	What it does	Cost	Use
Moving average of N	Mean of the last N samples; noise falls as 1 ÷ √N; delay of (N − 1) ÷ 2 samples	N values of memory	Steady signals with random noise; averaging over whole mains cycles removes hum
Exponential	The filter above	One variable	The default for sensors and displays
Median of 3 or 5	The middle value of the last readings	A small sort	Removes single-sample spikes without blurring edges
Median, then average	Reject outliers, then smooth	Both	Noisy industrial signals
Rate limiter	Limits how fast the output may change	One variable	Soft starts; ignoring impossible jumps
Butterworth / FIR (SciPy)	Designed responses with a defined cut-off and roll-off	Coefficients, state	Offline or demanding signal work; scipy.signal.butter, filtfilt

A discrete PID controller

A PID controller computes an output u from the error e = setpoint − measurement: a term proportional to the error (P), one to its accumulated sum (I, which removes steady-state error), and one to its rate of change (D, which damps the response). Called at a fixed interval Δt:

u = K_p e + K_i Σ e Δt + K_d (e − e_prev) ÷ Δt

class Pid:
    def __init__(self, kp, ki, kd, dt, out_min=-10.0, out_max=10.0):
        self.kp, self.ki, self.kd, self.dt = kp, ki, kd, dt
        self.out_min, self.out_max = out_min, out_max
        self.integral = 0.0
        self.prev_meas = None

    def update(self, setpoint, measurement):
        error = setpoint - measurement
        # derivative on the measurement, not the error: no kick when the setpoint changes
        d = 0.0 if self.prev_meas is None else -(measurement - self.prev_meas) / self.dt
        self.prev_meas = measurement
        self.integral += error * self.dt
        u = self.kp * error + self.ki * self.integral + self.kd * d
        u_sat = min(max(u, self.out_min), self.out_max)
        if u != u_sat and self.ki and error * (u - u_sat) > 0:     # anti-windup: stop integrating while saturated
            self.integral -= error * self.dt
        return u_sat

Anti-windup, limits and derivative filtering

Real actuators saturate: a valve is fully open, a motor at maximum voltage. While the output is stuck at its limit the error stays large, and the integral keeps growing (windup); when the setpoint finally comes within reach, the huge stored integral drives the output far past the target.

• Clamp the integral or stop integrating while the output is saturated (as in the code above); more elaborate schemes back-calculate it.
• Limit the output to what the actuator can do, and the rate of change if it should not slam.
• Derivative on the measurement, not the error, so a step in the setpoint does not produce a huge spike (“derivative kick”).
• Filter the derivative with a first-order low-pass (an exponential filter with a time constant of Kd ÷ (N × Kp), N = 5 to 20), or leave K_d at zero (a PI controller is enough for most processes).
• Bumpless transfer: when switching between manual and automatic, set the integral so that the output starts where it was.
• Dead-band and noise: a small dead-band around the setpoint stops an actuator chattering on noise.
• Units and scaling: keep the gains in physical units (volts per degree) so that you can reason about them; set sample time Δt explicitly.

Tuning a loop

The classic Ziegler-Nichols closed-loop method: with only P control, raise K_p until the output oscillates steadily; call that gain K_u (the ultimate gain) and the oscillation period T_u. The rules give starting values:

Type	Kp	Ki = Kp ÷ Ti	Kd = Kp Td
P	4.00	–	–
PI	3.60	3.60	–
PID	4.80	8.00	0.72

The table shows the values for K_u = 8 and T_u = 1.2 s (PID: K_p = 0.6 K_u, T_i = T_u ÷ 2, T_d = T_u ÷ 8). These give a fast but oscillatory response (about 25 % overshoot): treat them as a starting point, then reduce K_p by a third or more for a gentler loop.

• Tune on a simulation first when you can: the code on this page, a model of the plant and a few seconds of simulated time show the effect of each gain safely.
• Step-response (open-loop) method: record how the process responds to a step in the output; fit a gain, a time constant and a dead time; use tuning rules such as Cohen-Coon or lambda tuning.
• Change one gain at a time, increase K_p until the response is quick without much overshoot, add K_i to remove the offset, and add K_d only if you need more damping.
• Autotune functions in controllers and libraries (relay feedback) automate the Ziegler-Nichols test, safely limited.
• Limit the test: a loop at its stability limit can damage equipment; use small steps and output limits (see Motion Control and Robotics Tools).

Finding frequencies: the Fourier transform

The discrete Fourier transform (DFT) splits a sampled signal into sine waves of different frequencies and reports how big each is; the FFT is the fast algorithm that computes it in N log N steps. It finds vibration frequencies, mains hum, motor speeds and the dominant frequency of a noisy signal.

import numpy as np
fs = 1000.0
x = np.sin(2*np.pi*50*t) + 0.5*np.sin(2*np.pi*120*t) + noise      # t = np.arange(100) / fs
X = np.fft.rfft(x * np.hanning(len(x)))                            # real-input FFT with a Hann window
freq = np.fft.rfftfreq(len(x), 1 / fs)                             # 0, 10, 20 ... 500 Hz
amp = 2 * np.abs(X) / np.sum(np.hanning(len(x)))                   # scale to amplitude
peak = freq[np.argmax(amp)]                                        # the dominant frequency: 50 Hz

Timing: fixed rate and jitter

• On a microcontroller run the loop from a timer interrupt or an RTOS task with a fixed period, so Δt is exact (see Embedded Systems: Architecture).
• On a PC or Raspberry Pi, the operating system is not real-time: expect jitter of a millisecond or more. Schedule from a fixed start time (next += period) and sleep until then, rather than sleeping a fixed time each pass, and measure the actual Δt you got.
• Use the measured Δt in the math when it varies (integral += error × dt_actual), and log it to see the jitter.
• Hard real-time loops (a servo at 10 kHz) belong in a microcontroller or a real-time OS, with the PC sending setpoints only.
• Latency counts: filter delay, communication delay and actuator lag all reduce the gain at which the loop stays stable.

import time
PERIOD = 0.01                         # 100 Hz
next_t = time.monotonic()
while running:
    now = time.monotonic()
    out = pid.update(setpoint, read_sensor())
    write_actuator(out)
    next_t += PERIOD                  # fixed schedule: no drift
    time.sleep(max(0.0, next_t - time.monotonic()))

A checklist for loop code

Check	Why
Fixed, known sample time Δt	Filters and PID assume it
Anti-aliasing before the ADC; sample rate 5 to 10 times the signal	Aliases cannot be removed later
Filter initialized with the first reading	No start-up ramp
Output, rate and integral limited	Actuators saturate; windup
Derivative on the measurement, filtered	No kick; less noise
Sensor plausibility checks and a fail-safe output	A dead sensor must not drive the actuator to a limit
Manual override and a hardware stop	Safety does not depend on the software
Tested in simulation, then on the plant with small steps	Find mistakes safely
Logging of setpoint, measurement, output and Δt	You cannot tune what you cannot see

Related

• Programming Languages: the overview of this guide.
• Numerical Methods: simulating the plant (ODE solvers) to tune against.
• Python for Engineers: SciPy signal tools.
• Robotics Tools, Motion Control and Actuators and Embedded Systems: loops on real hardware.
• Data Logging: sampling and storing signals.

FAQ

Do I need the D term?

Often not. Many processes (temperature, level, flow) work well with PI. D helps with fast, lightly damped systems such as motion axes, if the measurement is clean or the derivative is filtered.

Why does my controller oscillate?

The gain is too high for the delay in the loop, the integral is too strong, or the sample time is too slow. Lower K_p, reduce K_i, and check the sample time and any filter delay.

What filter should I use for a sensor?

An exponential filter with a time constant matched to how fast the quantity really changes; add a median for spikes. Keep the delay below what the control loop can tolerate.

What is the difference between FFT and DFT?

They give the same result: the FFT is the fast way to compute the DFT, in N log N steps instead of N².

References

• Åström, K. J. and Murray, R. M., Feedback Systems; Åström, K. J. and Hägglund, T., PID Controllers: Theory, Design, and Tuning.
• Ziegler, J. G. and Nichols, N. B., “Optimum settings for automatic controllers”, Transactions of the ASME, 1942.
• Oppenheim, A. V. and Schafer, R. W., Discrete-Time Signal Processing; Smith, S. W., The Scientist and Engineer’s Guide to Digital Signal Processing (free online).

Last reviewed: October 2026. Simulation results are computed in the page builder; real plants differ, so tune carefully with limits in place.