Consider a single-input single-output (SISO) control system whose true output is \( y(t) \) (e.g., position of a robot joint). The sensor provides a measured signal \( y_m(t) \) that is corrupted by noise. A standard model is

\[ y_m(t) = y(t) + n(t), \]

where \( n(t) \) is an additive noise process (often modeled as zero-mean and “high-frequency” relative to the dynamics of interest). Taking Laplace transforms, we obtain

\[ Y_m(s) = Y(s) + N(s). \]

A linear time-invariant (LTI) filter with transfer function \( F(s) \) is used to process the sensor signal, producing a filtered measurement \( y_f(t) \):

\[ Y_f(s) = F(s)Y_m(s) = F(s)\bigl(Y(s) + N(s)\bigr) = F(s)Y(s) + F(s)N(s). \]

The goal of sensor noise reduction is to choose \( F(s) \) such that:

• For frequencies where the useful signal \( y(t) \) lives, \( |F(j\omega)| \approx 1 \), so signal distortion is small.
• For frequencies dominated by noise, \( |F(j\omega)| \ll 1 \), so noise is attenuated.

In closed-loop control, \( y_f(t) \) is often used as the feedback signal. Filtering therefore affects both the noise and the feedback dynamics. We will focus in this lesson on the noise-shaping aspect, and later lessons in this chapter analyze where to place filters inside the loop.

flowchart TD
  T["True physical variable y(t)"] --> SENS["Sensor + electronics"]
  SENS --> NADD["Additive noise n(t)"]
  NADD --> YM["Measured signal y_m(t) = y(t) + n(t)"]
  YM --> FILT["Linear filter F(s)"]
  FILT --> YF["Filtered measurement y_f(t)"]
  YF --> CTRL["Controller C(s) or estimator"]
        

The simplest and most commonly used continuous-time noise filter is the first-order low-pass filter. Its transfer function can be parameterized either by a time constant \( \tau > 0 \) or by a cutoff frequency \( \omega_c > 0 \):

\[ F(s) = \frac{1}{\tau s + 1} = \frac{\omega_c}{s + \omega_c}, \quad \omega_c = \frac{1}{\tau}. \]

The differential equation relating the input \( y_m(t) \) and output \( y_f(t) \) is obtained by multiplying both sides of \( Y_f(s) = F(s)Y_m(s) \) by \( \tau s + 1 \):

\[ (\tau s + 1)Y_f(s) = Y_m(s) \;\Longleftrightarrow\; \tau sY_f(s) + Y_f(s) = Y_m(s). \]

Taking the inverse Laplace transform and using linearity and the property that multiplication by \( s \) corresponds to differentiation, we obtain

\[ \tau \frac{d y_f(t)}{dt} + y_f(t) = y_m(t). \]

This ODE clearly exhibits the low-pass behavior:

• If \( y_m(t) \) changes slowly compared to \( \tau \), then \( \frac{d y_f}{dt} \) is small and \( y_f(t) \approx y_m(t) \).
• If \( y_m(t) \) oscillates rapidly, the derivative term dominates and the filter output changes much more slowly than the input, smoothing out fast fluctuations.

In frequency domain, substituting \( s = j\omega \) yields the frequency response

\[ F(j\omega) = \frac{\omega_c}{j\omega + \omega_c}. \]

Its magnitude and phase are

\[ \bigl|F(j\omega)\bigr| = \frac{\omega_c}{\sqrt{\omega^2 + \omega_c^2}}, \qquad \angle F(j\omega) = -\arctan\!\left(\frac{\omega}{\omega_c}\right). \]

At the cutoff frequency \( \omega = \omega_c \), we have \( |F(j\omega_c)| = \frac{1}{\sqrt{2}} \), corresponding to attenuation of approximately 3 dB, a standard design marker for low-pass filters.

To quantify noise reduction, we use a frequency-domain description of the noise process. Assume the sensor noise \( n(t) \) is a zero-mean, wide-sense stationary process with (two-sided) power spectral density (PSD) \( S_n(\omega) \). For an LTI filter \( F(s) \), the PSD of the filtered noise \( n_f(t) \), with Laplace transform \( N_f(s) = F(s)N(s) \), is

\[ S_{n_f}(\omega) = \bigl|F(j\omega)\bigr|^2 S_n(\omega). \]

This follows from the Fourier transform of the convolution \( n_f(t) = (h_f * n)(t) \), where \( h_f(t) \) is the impulse response of the filter: multiplication in frequency corresponds to convolution in time, and the PSD of the output is the input PSD multiplied by the squared magnitude of the frequency response.

The variance of the filtered noise is obtained by integrating the PSD:

\[ \sigma_{n_f}^2 = \mathbb{E}\bigl[n_f^2(t)\bigr] = \frac{1}{2\pi}\int_{-\infty}^{\infty} S_{n_f}(\omega)\,d\omega = \frac{1}{2\pi}\int_{-\infty}^{\infty} \bigl|F(j\omega)\bigr|^2 S_n(\omega)\,d\omega. \]

As a concrete example, suppose the sensor noise is approximately white over the frequency range of interest, with constant PSD \( S_n(\omega) = S_0 \). For the first-order low-pass filter, we have

\[ \sigma_{n_f}^2 = \frac{S_0}{2\pi} \int_{-\infty}^{\infty} \frac{\omega_c^2}{\omega^2 + \omega_c^2}\,d\omega. \]

We now compute this integral explicitly. Using the identity \( \int \frac{1}{\omega^2 + a^2}\,d\omega = \frac{1}{a}\arctan\!\left(\frac{\omega}{a}\right) \), with \( a = \omega_c \), we obtain

\[ \int_{-\infty}^{\infty} \frac{\omega_c^2}{\omega^2 + \omega_c^2}\,d\omega = \omega_c^2 \left[ \frac{1}{\omega_c}\arctan\!\left(\frac{\omega}{\omega_c}\right) \right]_{-\infty}^{\infty} = \omega_c \bigl(\tfrac{\pi}{2} - (-\tfrac{\pi}{2})\bigr) = \pi\omega_c. \]

Substituting this into the variance expression gives

\[ \sigma_{n_f}^2 = \frac{S_0}{2\pi}\cdot \pi\omega_c = \frac{S_0 \omega_c}{2}. \]

Conclusion: under the white-noise approximation, the noise variance after filtering is proportional to the cutoff frequency \( \omega_c \). Decreasing \( \omega_c \) reduces noise variance linearly, but, as we will see in the next section, it also increases phase lag and slows the apparent response of the measurement.

In sensor noise reduction for feedback control, we cannot select \( \omega_c \) arbitrarily small: although this reduces noise variance, it also introduces additional phase lag that may degrade stability margins and slow tracking.

Suppose the closed-loop controller and plant, without the sensor filter, are designed to have a desired bandwidth \( \omega_b \) and sufficient phase margin. In a unity-feedback configuration, the complementary sensitivity function is

\[ T(s) = \frac{C(s)G(s)}{1 + C(s)G(s)}, \]

where \( C(s) \) is the controller and \( G(s) \) is the plant. If a filter \( F(s) \) is inserted in the measurement path (details are studied in Lesson 4), the noise transfer function from sensor noise \( N(s) \) to output \( Y(s) \) becomes approximately \( -T(s)F(s) \). Thus, high-frequency noise is shaped by both \( T(j\omega) \) and \( F(j\omega) \).

From Section 3, the magnitude of \( F(j\omega) \) is

\[ \bigl|F(j\omega)\bigr| = \frac{\omega_c}{\sqrt{\omega^2 + \omega_c^2}}, \qquad \angle F(j\omega) = -\arctan\!\left(\frac{\omega}{\omega_c}\right). \]

Around the closed-loop bandwidth \( \omega_b \), the additional phase lag due to the filter is approximately \( -\arctan\!\left(\frac{\omega_b}{\omega_c}\right) \). Suppose we can only tolerate an additional phase lag of at most \( \varphi_{\max} \) (in radians) at \( \omega_b \). Then we must choose \( \omega_c \) to satisfy

\[ \arctan\!\left(\frac{\omega_b}{\omega_c}\right) \le \varphi_{\max}. \]

Since \( \arctan(\cdot) \) is monotone increasing, this is equivalent to

\[ \frac{\omega_b}{\omega_c} \le \tan(\varphi_{\max}) \quad\Longrightarrow\quad \omega_c \ge \frac{\omega_b}{\tan(\varphi_{\max})}. \]

Combined with the noise-variance relation \( \sigma_{n_f}^2 = \frac{S_0\omega_c}{2} \), we see that:

• Reducing \( \omega_c \) lowers noise variance but increases phase lag.
• Increasing \( \omega_c \) improves phase margin but increases noise variance.

Filter design for sensor noise is therefore an explicit trade-off between noise attenuation and dynamic performance. In robotics and mechatronic systems, typical practice is to choose \( \omega_c \) several times larger than the closed-loop bandwidth \( \omega_b \), ensuring modest phase lag while still reducing very high-frequency noise.

flowchart TD
  ST["Start design"] --> SPEC["Specify closed-loop bandwidth omega_b and allowed extra phase lag phi_max"]
  SPEC --> VAR["Compute minimum cutoff: omega_c_min = omega_b / tan(phi_max)"]
  VAR --> NOISE["Estimate noise PSD level S_0"]
  NOISE --> CHOOSE["Choose omega_c >= omega_c_min balancing noise variance ~ (S_0 * omega_c / 2) and phase lag"]
  CHOOSE --> VERIFY["Verify closed-loop margins and time response with filter included"]
        

We now implement a discrete-time approximation of the first-order low-pass filter in Python. For a sampling interval \( \Delta t \) and time constant \( \tau \), a common discretization (exact for zero-order-hold sampling of the continuous filter) is

\[ \alpha = e^{-\frac{\Delta t}{\tau}}, \qquad y_f[k] = \alpha\,y_f[k-1] + (1 - \alpha)\,y_m[k]. \]

This recursion is easy to implement in embedded code and inside robotics frameworks such as ROS. Below, we simulate a noisy position sensor and filter it:

import numpy as np

# Parameters
dt   = 0.001          # sampling period [s]
T    = 2.0            # total simulation time [s]
tau  = 0.02           # filter time constant [s]
omega_signal = 2.0    # rad/s (slow motion)
noise_std    = 0.05   # sensor noise standard deviation

# Discrete-time filter coefficient (ZOH-discretized first-order LPF)
alpha = np.exp(-dt / tau)

# Time vector
t = np.arange(0.0, T, dt)
N = len(t)

# True signal: smooth sinusoidal motion (e.g., joint angle)
y_true = 1.0 * np.sin(omega_signal * t)

# Noisy measurement (white Gaussian noise)
rng = np.random.default_rng(seed=0)
noise = noise_std * rng.standard_normal(N)
y_meas = y_true + noise

# Filtered measurement
y_filt = np.zeros_like(y_meas)
y_filt[0] = y_meas[0]
for k in range(1, N):
    y_filt[k] = alpha * y_filt[k - 1] + (1.0 - alpha) * y_meas[k]

# Example: compute RMS of noise before and after filtering
noise_meas = y_meas - y_true
noise_filt = y_filt - y_true
rms_meas = np.sqrt(np.mean(noise_meas**2))
rms_filt = np.sqrt(np.mean(noise_filt**2))
print("RMS noise before filter:", rms_meas)
print("RMS noise after  filter:", rms_filt)

# In a ROS2 node (rclpy), this recursion can be applied inside the callback
# that receives sensor messages, publishing y_filt instead of raw y_meas.
      

In robotic applications, the same recursion can be embedded inside a ROS subscriber callback (Python or C++) to pre-filter encoder, IMU, or range sensor readings before passing them to the control law.

C++ is frequently used for low-level robot controllers (e.g., in ROS, ROS 2, or proprietary real-time frameworks). The same discrete-time recursion can be implemented as a small class:

#include <cmath>
#include <vector>
#include <iostream>

class FirstOrderLowPassFilter {
public:
    FirstOrderLowPassFilter(double tau, double dt)
    : tau_(tau), dt_(dt), y_(0.0)
    {
        alpha_ = std::exp(-dt_ / tau_);
    }

    double update(double y_meas) {
        y_ = alpha_ * y_ + (1.0 - alpha_) * y_meas;
        return y_;
    }

    void reset(double y_init) {
        y_ = y_init;
    }

private:
    double tau_;
    double dt_;
    double alpha_;
    double y_;
};

int main() {
    double dt   = 0.001;
    double tau  = 0.02;
    FirstOrderLowPassFilter filter(tau, dt);

    // Example: filter a simulated noisy signal
    std::vector<double> y_meas = {0.0, 0.1, 0.2, 0.15, 0.18, 0.19};
    for (double ym : y_meas) {
        double yf = filter.update(ym);
        std::cout << "y_meas = " << ym
                  << ", y_filt = " << yf << std::endl;
    }

    return 0;
}
      

In a ROS or ROS 2 controller node, the update method can be called each control cycle (e.g., inside a joint state callback), providing a filtered position or velocity to the control law. Libraries such as Eigen can be used to apply the same recursion element-wise to vector-valued sensor measurements.

Java is common in educational and competition robotics (e.g., FRC WPILib). The same discrete-time first-order filter can be expressed as a class:

public class LowPassFilter {
    private final double tau;
    private final double dt;
    private final double alpha;
    private double y;

    public LowPassFilter(double tau, double dt, double initialValue) {
        this.tau = tau;
        this.dt = dt;
        this.alpha = Math.exp(-dt / tau);
        this.y = initialValue;
    }

    public double update(double yMeas) {
        y = alpha * y + (1.0 - alpha) * yMeas;
        return y;
    }

    public void reset(double initialValue) {
        y = initialValue;
    }

    public static void main(String[] args) {
        double dt = 0.02;   // 50 Hz control loop
        double tau = 0.1;   // filter time constant
        LowPassFilter filter = new LowPassFilter(tau, dt, 0.0);

        double[] yMeas = {0.0, 0.8, 1.2, 0.9, 1.1};
        for (int k = 0; k < yMeas.length; ++k) {
            double yf = filter.update(yMeas[k]);
            System.out.println("k=" + k
                + " y_meas=" + yMeas[k]
                + " y_filt=" + yf);
        }
    }
}
      

In WPILib-based robots, this filter can be wrapped around encoder, gyro, or accelerometer readings before using them in PID controllers or model-based control algorithms.

MATLAB and Simulink provide convenient tools for constructing and simulating filters. A continuous-time first-order low-pass filter can be defined using transfer functions:

% Parameters
tau  = 0.02;          % time constant [s]
omega_c = 1 / tau;

% Continuous-time transfer function F(s) = omega_c / (s + omega_c)
s = tf('s');
F = omega_c / (s + omega_c);

% Example: true signal and noisy measurement
dt   = 0.001;
t    = 0:dt:2;
omega_signal = 2.0;
y_true = sin(omega_signal * t);
noise  = 0.05 * randn(size(t));
y_meas = y_true + noise;

% Filtered measurement via lsim
y_filt = lsim(F, y_meas, t);

% Plot for inspection
figure;
subplot(3,1,1); plot(t, y_true); ylabel('y true');
subplot(3,1,2); plot(t, y_meas); ylabel('y meas');
subplot(3,1,3); plot(t, y_filt); ylabel('y filt'); xlabel('t [s]');

% Simulink:
%  - Place a Transfer Fcn block with numerator [omega_c] and denominator [1 omega_c].
%  - Feed the sensor signal into the block; use the block output as the filtered measurement.
      

In Simulink-based control designs, sensor noise filtering is often realized directly in the measurement subsystem, and its effect on closed-loop stability and performance can be examined via Bode, Nyquist, and time-response analysis.

Wolfram Mathematica offers symbolic and numeric tools for analyzing LTI filters. The first-order low-pass filter can be represented as a transfer function model:

(* Parameters *)
tau = 0.02;
omegaC = 1/tau;

(* Continuous-time transfer function F(s) = omegaC / (s + omegaC) *)
F = TransferFunctionModel[omegaC/(s + omegaC), s];

(* Time vector and signals *)
dt = 0.001;
tMax = 2.0;
t = Range[0, tMax, dt];

omegaSignal = 2.0;
yTrue = Sin[omegaSignal * t];

noiseStd = 0.05;
noise = RandomVariate[NormalDistribution[0, noiseStd], Length[t]];
yMeas = yTrue + noise;

(* Filter noisy measurement *)
yFilt = OutputResponse[F, yMeas, t];

(* Compute RMS of noise before and after filtering *)
noiseMeas = yMeas - yTrue;
noiseFilt = yFilt - yTrue;
rmsMeas = Sqrt[Mean[noiseMeas^2]];
rmsFilt = Sqrt[Mean[noiseFilt^2]];

{rmsMeas, rmsFilt}
      

Symbolic manipulation can also be used to derive the noise variance and phase expressions shown earlier, and to explore alternative filter structures (higher-order Butterworth, Chebyshev, etc.) before implementation.

Problem 1 (Noise Variance Through First-Order Low-Pass Filter). A zero-mean white noise process \( n(t) \) with PSD \( S_n(\omega) = S_0 \) passes through a first-order low-pass filter with transfer function \( F(s) = \frac{\omega_c}{s + \omega_c} \). Derive the variance of the filtered noise \( n_f(t) \) and show that \( \sigma_{n_f}^2 = \frac{S_0\omega_c}{2} \).

Solution: From Section 3, the PSD of the filtered noise is \( S_{n_f}(\omega) = |F(j\omega)|^2 S_n(\omega) \). For the given filter and white noise, we have

\[ S_{n_f}(\omega) = \frac{\omega_c^2}{\omega^2 + \omega_c^2} S_0. \]

The variance is

\[ \sigma_{n_f}^2 = \frac{1}{2\pi}\int_{-\infty}^{\infty} S_{n_f}(\omega)\,d\omega = \frac{S_0}{2\pi}\int_{-\infty}^{\infty} \frac{\omega_c^2}{\omega^2 + \omega_c^2}\,d\omega. \]

Using the integral \( \int \frac{1}{\omega^2 + a^2}\,d\omega = \frac{1}{a}\arctan\!\left(\frac{\omega}{a}\right) \) with \( a = \omega_c \), we obtain

\[ \int_{-\infty}^{\infty} \frac{\omega_c^2}{\omega^2 + \omega_c^2}\,d\omega = \omega_c \bigl(\tfrac{\pi}{2} - (-\tfrac{\pi}{2})\bigr) = \pi\omega_c. \]

Therefore,

\[ \sigma_{n_f}^2 = \frac{S_0}{2\pi}\cdot \pi\omega_c = \frac{S_0\omega_c}{2}. \]

This confirms the linear dependence of filtered noise variance on the cutoff frequency.

Problem 2 (Sinusoidal Noise Attenuation). A position sensor measures \( y_m(t) = y(t) + A_n\sin(\omega_n t) \), where \( y(t) \) is the true slow motion and \( A_n\sin(\omega_n t) \) is a sinusoidal interference at frequency \( \omega_n \). This signal is passed through a first-order low-pass filter with cutoff frequency \( \omega_c \). Compute the amplitude of the sinusoidal component at the filter output, and derive the attenuation ratio \( \frac{A_{\text{out}}}{A_n} \).

Solution: For an LTI system, each sinusoidal component is scaled by the magnitude of the frequency response at its frequency. The interference component has Laplace transform \( \frac{A_n\omega_n}{s^2 + \omega_n^2} \), but we only need its steady-state frequency. At the filter output, the sinusoid becomes

\[ A_{\text{out}}\sin\bigl(\omega_n t + \phi\bigr), \]

where

\[ A_{\text{out}} = \bigl|F(j\omega_n)\bigr| A_n = \frac{\omega_c}{\sqrt{\omega_n^2 + \omega_c^2}}A_n, \]

and

\[ \phi = \angle F(j\omega_n) = -\arctan\!\left(\frac{\omega_n}{\omega_c}\right). \]

Thus the attenuation ratio is

\[ \frac{A_{\text{out}}}{A_n} = \frac{\omega_c}{\sqrt{\omega_n^2 + \omega_c^2}}. \]

For \( \omega_n \gg \omega_c \), this ratio behaves like \( \frac{\omega_c}{\omega_n} \), indicating strong attenuation of high-frequency interference.

Problem 3 (Cutoff Frequency From Phase-Lag Constraint). A feedback loop is designed with closed-loop bandwidth \( \omega_b \). A first-order low-pass filter with cutoff frequency \( \omega_c \) is to be inserted in the measurement path for sensor noise reduction. The additional phase lag introduced by the filter at \( \omega_b \) must not exceed \( \varphi_{\max} \) (in radians). Derive a lower bound on \( \omega_c \) in terms of \( \omega_b \) and \( \varphi_{\max} \).

Solution: From Section 4, the phase of the filter is \( \angle F(j\omega) = -\arctan\!\left(\frac{\omega}{\omega_c}\right) \). The magnitude of the phase lag at \( \omega_b \) is

\[ \left|\angle F(j\omega_b)\right| = \arctan\!\left(\frac{\omega_b}{\omega_c}\right). \]

The requirement \( \left|\angle F(j\omega_b)\right| \le \varphi_{\max} \) becomes

\[ \arctan\!\left(\frac{\omega_b}{\omega_c}\right) \le \varphi_{\max}, \]

which, by monotonicity of \( \arctan(\cdot) \), is equivalent to

\[ \frac{\omega_b}{\omega_c} \le \tan(\varphi_{\max}) \quad\Longrightarrow\quad \omega_c \ge \frac{\omega_b}{\tan(\varphi_{\max})}. \]

This gives the desired lower bound on the cutoff frequency to ensure the phase-lag constraint is satisfied.

Problem 4 (Balancing Noise Variance and Phase-Lag Constraint). Assume the same setting as Problem 3, with white sensor noise of level \( S_0 \). You require both:

• Phase-lag constraint: \( \omega_c \ge \frac{\omega_b}{\tan(\varphi_{\max})} \),
• Noise-variance constraint: \( \sigma_{n_f}^2 \le \sigma_{\max}^2 \),

where \( \sigma_{\max}^2 \) is the maximum acceptable noise variance after filtering. Express the feasible range of \( \omega_c \) and derive a consistency condition for the design requirements.

Solution: From Problem 1, the noise variance is \( \sigma_{n_f}^2 = \frac{S_0\omega_c}{2} \). The noise-variance requirement \( \sigma_{n_f}^2 \le \sigma_{\max}^2 \) implies

\[ \frac{S_0\omega_c}{2} \le \sigma_{\max}^2 \quad\Longrightarrow\quad \omega_c \le \frac{2\sigma_{\max}^2}{S_0}. \]

Therefore, the cutoff frequency must satisfy both

\[ \frac{\omega_b}{\tan(\varphi_{\max})} \le \omega_c \le \frac{2\sigma_{\max}^2}{S_0}. \]

A feasible design exists only if the lower bound does not exceed the upper bound, that is,

\[ \frac{\omega_b}{\tan(\varphi_{\max})} \le \frac{2\sigma_{\max}^2}{S_0}. \]

If this inequality is violated, the simultaneous phase and noise requirements are incompatible for a first-order low-pass filter, and one of the specifications must be relaxed (e.g., allow larger noise variance or larger phase lag).

In this lesson we developed a rigorous framework for sensor noise reduction using linear filters in continuous and discrete time. We:

• Modeled sensor measurements as \( y_m(t) = y(t) + n(t) \) and studied the effect of LTI filters on both signal and noise.
• Derived the first-order low-pass filter model in time and frequency domains, including its differential equation and Bode characteristics.
• Showed how noise PSD is shaped by \( |F(j\omega)|^2 \) and computed the variance of filtered white noise, obtaining \( \sigma_{n_f}^2 = \frac{S_0\omega_c}{2} \).
• Analyzed the trade-off between noise attenuation and phase lag at the closed-loop bandwidth, obtaining design inequalities linking \( \omega_c \), \( \omega_b \), and the allowed phase lag.
• Implemented first-order low-pass filters in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, with emphasis on real-time robotics applications.

Subsequent lessons in this chapter will discuss higher-order filter structures, and, crucially, the effect of placing filters in different locations (measurement vs controller paths) within the feedback loop.