A linear filter in control is an LTI system with transfer function \( H(s) \) that maps an input signal \( U(s) \) to an output signal \( Y(s) \):

\[ H(s) = \frac{Y(s)}{U(s)}, \qquad s = \sigma + j\omega. \]

The frequency response is obtained by evaluating on the imaginary axis:

\[ H(j\omega) = H(s)\big\rvert_{s=j\omega}, \qquad |H(j\omega)|,\ \angle H(j\omega) \]

Filters are classified by which frequency band has large gain:

• Low-pass: passes low frequencies, attenuates high frequencies.
• High-pass: passes high frequencies, attenuates low frequencies.
• Band-pass: passes a finite band around a center frequency.
• Notch (band-stop): attenuates a narrow band; passes others.

In control systems and robotics, these filters appear in:

• Sensor conditioning (e.g., encoder, IMU, force-torque sensors).
• Shaping controller transfer functions (e.g., filtered derivative, notch for resonance).
• Loop-shaping for noise attenuation and disturbance rejection.

flowchart LR
  A["Filter design \nfor control"] --> B["Low-pass"]
  A --> C["High-pass"]
  A --> D["Band-pass"]
  A --> E["Notch (band-stop)"]

  B --> B1["Use: remove measurement \nnoise at high freq"]
  C --> C1["Use: remove bias/drift, \nkeep fast dynamics"]
  D --> D1["Use: isolate resonance / \nvibration band"]
  E --> E1["Use: suppress known \nresonance frequency"]

  B1 --> R1["Robotics example: \nsmooth encoder velocity"]
  C1 --> R2["Robotics example: \nremove gyro bias"]
  D1 --> R3["Robotics example: \nmonitor vibration band"]
  E1 --> R4["Robotics example: \nnotch flexible joint mode"]
        

The standard first-order low-pass filter has transfer function

\[ H_{\text{LP}}(s) = \frac{1}{1 + \tau s} = \frac{\omega_c}{s + \omega_c}, \qquad \omega_c = \frac{1}{\tau}, \]

where \( \tau > 0 \) is the time constant and \( \omega_c \) is the cutoff (corner) frequency in rad/s.

2.1 Frequency response and cutoff

Evaluate at \( s = j\omega \):

\[ H_{\text{LP}}(j\omega) = \frac{1}{1 + j\omega \tau}. \]

The magnitude-squared is

\[ |H_{\text{LP}}(j\omega)|^2 = \frac{1}{1 + (\omega \tau)^2}. \]

The cutoff frequency is defined by \( |H_{\text{LP}}(j\omega_c)| = 1/\sqrt{2} \) (i.e. \( -3 \) dB). Solving:

\[ \frac{1}{1 + (\omega_c \tau)^2} = \frac{1}{2} \quad \Longrightarrow \quad (\omega_c \tau)^2 = 1 \quad \Longrightarrow \quad \omega_c = \frac{1}{\tau}. \]

2.2 Time-domain interpretation

The impulse response is

\[ h_{\text{LP}}(t) = \frac{1}{\tau} e^{-t/\tau} u(t), \]

and the step response for a unit step \( u(t) = 1\cdot u(t) \) is

\[ y(t) = \left( 1 - e^{-t/\tau} \right) u(t), \]

so \( \tau \) controls how fast the filter output tracks slow changes while smoothing high-frequency components. For \( \omega \ll \omega_c \), \( |H_{\text{LP}}(j\omega)| \approx 1 \), while for \( \omega \gg \omega_c \) we obtain strong attenuation \( |H_{\text{LP}}(j\omega)| \approx 1/(\omega \tau) \).

A complementary first-order high-pass filter is obtained by placing the zero at the origin:

\[ H_{\text{HP}}(s) = \frac{\tau s}{1 + \tau s} = \frac{s}{s + \omega_c}, \qquad \omega_c = \frac{1}{\tau}. \]

3.1 Frequency response

At \( s = j\omega \), the magnitude-squared is

\[ |H_{\text{HP}}(j\omega)|^2 = \frac{(\omega \tau)^2}{1 + (\omega \tau)^2}. \]

Thus \( |H_{\text{HP}}(j\omega)| \approx 1 \) for \( \omega \gg \omega_c \) and \( |H_{\text{HP}}(j\omega)| \approx \omega \tau \) for \( \omega \ll \omega_c \), so low-frequency components (including bias and drift) are strongly attenuated.

3.2 Complementarity with low-pass

Using the low-pass and high-pass pair \( H_{\text{LP}}(s) = \frac{1}{1 + \tau s} \) and \( H_{\text{HP}}(s) = \frac{\tau s}{1 + \tau s} \), we have

\[ H_{\text{LP}}(s) + H_{\text{HP}}(s) = \frac{1}{1 + \tau s} + \frac{\tau s}{1 + \tau s} = \frac{1 + \tau s}{1 + \tau s} = 1. \]

Hence they form a complementary filter pair that exactly splits the signal into slow and fast components. This idea is widely used in robotics sensor fusion (e.g., combining accelerometer and gyroscope data).

A standard continuous-time band-pass filter is a second-order LTI system whose gain is large near a center frequency \( \omega_0 \) and small outside that band. The canonical transfer function in terms of the natural frequency \( \omega_0 \) and damping ratio \( \zeta \) is

\[ H_{\text{BP}}(s) = \frac{2\zeta \omega_0 s}{s^2 + 2\zeta \omega_0 s + \omega_0^2}, \qquad 0 < \zeta < 1. \]

4.1 Magnitude and bandwidth

The frequency response is

\[ H_{\text{BP}}(j\omega) = \frac{2\zeta \omega_0 j\omega} {-\omega^2 + j\,2\zeta \omega_0 \omega + \omega_0^2 }. \]

Thus

\[ |H_{\text{BP}}(j\omega)|^2 = \frac{\left(2\zeta \omega_0 \omega\right)^2} {\left(\omega_0^2 - \omega^2\right)^2 + \left(2\zeta \omega_0 \omega\right)^2}. \]

For moderately small damping \( \zeta \ll 1 \), the peak of the magnitude occurs near

\[ \omega_r \approx \omega_0 \sqrt{1 - 2\zeta^2}, \]

and the 3 dB bandwidth is \( B = \omega_2 - \omega_1 \), where \( \omega_1 < \omega_r < \omega_2 \) satisfy \( |H_{\text{BP}}(j\omega_k)|^2 = \frac{1}{2}|H_{\text{BP}}(j\omega_r)|^2 \). For small \( \zeta \),

\[ B \approx 2\zeta \omega_0. \]

4.2 Quality factor

The quality factor \( Q \) is defined as

\[ Q = \frac{\omega_0}{B} \approx \frac{1}{2\zeta} \quad \Longleftrightarrow \quad \zeta \approx \frac{1}{2Q}. \]

A high \( Q \) means a narrow band (sharp resonance), which is useful for isolating structural vibration bands in robotics manipulators, but can also make the filter sensitive to model uncertainties in the resonance frequency.

A notch filter strongly attenuates a narrow frequency band around \( \omega_0 \) while leaving other frequencies almost unaffected. A convenient form is

\[ H_{\text{N}}(s) = \frac{s^2 + \omega_0^2}{s^2 + \frac{\omega_0}{Q} s + \omega_0^2}, \qquad Q > 0. \]

5.1 Exact notch at \( \omega_0 \)

Evaluate at \( s = j\omega_0 \):

\[ H_{\text{N}}(j\omega_0) = \frac{(j\omega_0)^2 + \omega_0^2} {(j\omega_0)^2 + \frac{\omega_0}{Q} j\omega_0 + \omega_0^2} = \frac{-\omega_0^2 + \omega_0^2} {-\omega_0^2 + j\frac{\omega_0^2}{Q} + \omega_0^2} = 0. \]

Thus the gain is exactly zero at the design frequency \( \omega_0 \), giving a perfect notch in the ideal continuous-time model.

5.2 Bandwidth and quality factor

For small damping (large \( Q \)), the stop-band is narrow; the approximate 3 dB bandwidth is

\[ B \approx \frac{\omega_0}{Q}, \]

so again \( Q \) measures how selective the notch is. In control and robotics, notch filters are used to suppress flexible modes of robot links or gearboxes without overly reducing bandwidth at other frequencies.

Let \( G_p(s) \) be the plant, \( C(s) \) the controller, and \( F(s) \) a filter (e.g., low-pass or notch). A few standard configurations are:

• Measurement filter: sensor output \( y_m(s) = F(s) y(s) \) is fed back, so the loop gain becomes \( L(s) = C(s)F(s)G_p(s) \).
• Controller filter: filter inside the controller, e.g., filtered derivative in a PID:

\[ C(s) = K_p + \frac{K_i}{s} + \frac{K_d s}{1 + \tau_f s}, \]

where the derivative term uses a first-order low-pass filter \( \frac{s}{1 + \tau_f s} \) to limit high-frequency noise amplification.

• Resonance suppression: a notch filter \( H_{\text{N}}(s) \) is cascaded with the controller: \( C_{\text{new}}(s) = H_{\text{N}}(s) C(s) \) to remove a critical flexible mode.

The design trade-off is always between desired attenuation in a target band (noise or resonance) and acceptable distortion (phase lag, gain reduction) in the frequency band important for closed-loop performance.

Using python-control or scipy.signal, we can construct the continuous-time transfer functions and evaluate Bode plots for all four filters. For robotics, these filters often appear in ROS nodes that pre-process sensor data.

import numpy as np
import control as ctrl  # python-control
import matplotlib.pyplot as plt

# Design parameters
tau = 0.05          # s, time constant
wc = 1.0 / tau      # rad/s
w0 = 50.0           # rad/s, center frequency
zeta = 0.05         # damping for band-pass
Q_notch = 10.0      # quality factor for notch

# Low-pass and high-pass (first-order)
LP = ctrl.TransferFunction([wc], [1.0, wc])        # wc / (s + wc)
HP = ctrl.TransferFunction([1.0, 0.0], [1.0, wc])  # s / (s + wc)

# Band-pass (second-order): 2 zeta w0 s / (s^2 + 2 zeta w0 s + w0^2)
BP = ctrl.TransferFunction([2.0 * zeta * w0, 0.0],
                           [1.0, 2.0 * zeta * w0, w0 ** 2])

# Notch: (s^2 + w0^2) / (s^2 + (w0/Q) s + w0^2)
Notch = ctrl.TransferFunction([1.0, 0.0, w0 ** 2],
                              [1.0, w0 / Q_notch, w0 ** 2])

w = np.logspace(-1, 3, 600)  # frequency grid

plt.figure()
for sys, label in [(LP, "LP"), (HP, "HP"), (BP, "BP"), (Notch, "Notch")]:
    mag, phase, w_out = ctrl.bode(sys, w, Plot=False)
    plt.loglog(w_out, mag, label=label)

plt.xlabel("omega [rad/s]")
plt.ylabel("|H(j omega)|")
plt.grid(True, which="both")
plt.legend()
plt.title("Magnitude responses of LP/HP/BP/Notch filters")
plt.show()
      

In a robotics context, these continuous-time models are often discretized (e.g., via Tustin's method) and implemented inside a ROS 2 node, while the same prototype transfer functions are used to reason about continuous-time loop shaping.

Robotics-related ecosystems (e.g., ROS filters and control_toolbox packages) provide built-in low-pass and notch filter implementations whose parameters correspond directly to \( \omega_c \), \( \omega_0 \), and \( Q \).

Below is a simple from-scratch C++ routine that evaluates the frequency response of a continuous-time transfer function with numerator and denominator coefficients in powers of \( s \). This is useful for offline analysis or custom tools.

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

using Vec = std::vector<double>;
using cd  = std::complex<double>;

cd evalPoly(const Vec& coeffs, cd s) {
    cd result(0.0, 0.0);
    for (size_t i = 0; i < coeffs.size(); ++i) {
        size_t power = coeffs.size() - 1 - i;
        result += coeffs[i] * std::pow(s, static_cast<int>(power));
    }
    return result;
}

double magResponse(const Vec& num, const Vec& den, double omega) {
    cd s(0.0, omega); // s = j omega
    cd H = evalPoly(num, s) / evalPoly(den, s);
    return std::abs(H);
}

int main() {
    // Example: notch filter H(s) = (s^2 + w0^2) / (s^2 + (w0/Q) s + w0^2)
    double w0 = 50.0;
    double Q  = 10.0;

    Vec num{1.0, 0.0, w0 * w0};
    Vec den{1.0, w0 / Q, w0 * w0};

    for (double w = 10.0; w <= 1000.0; w *= 1.5) {
        double mag = magResponse(num, den, w);
        std::cout << "omega = " << w
                  << ", |H(j omega)| = " << mag << std::endl;
    }
    return 0;
}
      

In ROS-based robotics, similar filters can be used directly via packages such as control_toolbox and filters, e.g., constructing a low-pass filter in C++ that internally implements a discretized version of \( H_{\text{LP}}(s) \). The continuous-time prototype guides the selection of \( \omega_c \), while the implementation is discrete-time.

For embedded Java-based robotics (e.g., FIRST/WPILib), filters are usually implemented as discrete-time recursions that approximate continuous-time prototypes. A simple first-order low-pass discretization of \( H_{\text{LP}}(s) = 1/(1 + \tau s) \) with sampling period \( T_s \) can be written as

\[ y[k] = y[k-1] + \alpha \left( u[k] - y[k-1] \right), \qquad \alpha = \frac{T_s}{\tau + T_s}, \]

which corresponds to a bilinear-like approximation of the analog filter.

public class FirstOrderLowPass {
    private final double alpha;
    private double yPrev = 0.0;

    /**
     * Continuous-time prototype: H(s) = 1 / (1 + tau s).
     * Discretized with sampling time Ts using simple first-order recursion.
     */
    public FirstOrderLowPass(double tau, double Ts) {
        this.alpha = Ts / (tau + Ts);
    }

    public double filter(double u) {
        yPrev = yPrev + alpha * (u - yPrev);
        return yPrev;
    }
}
      

Java robotics libraries (e.g., WPILib's LinearFilter) provide similar abstractions, where parameters such as cutoff frequency are used to construct the underlying difference equations corresponding to continuous-time low-pass or high-pass filters.

MATLAB's Control System Toolbox represents filters as transfer function objects. This is directly aligned with the analytical forms derived above and integrates well with robotics toolboxes and Simulink models.

% Parameters
tau = 0.05;
wc  = 1 / tau;
w0  = 50;
zeta = 0.05;
Q_notch = 10;

s = tf('s');

% Low-pass and high-pass
H_LP = wc / (s + wc);
H_HP = s / (s + wc);

% Band-pass
H_BP = 2*zeta*w0*s / (s^2 + 2*zeta*w0*s + w0^2);

% Notch
H_N  = (s^2 + w0^2) / (s^2 + (w0/Q_notch)*s + w0^2);

% Bode plots
w = logspace(-1, 3, 600);
bode(H_LP, H_HP, H_BP, H_N, w);
legend('LP','HP','BP','Notch');
grid on;

% Robotics context: filter noisy joint-velocity estimate
% Suppose Gp is a joint plant model and C is a PID controller:
% L = C * H_LP * Gp;  % loop transfer function including measurement low-pass
      

In Simulink, the same filters can be realized by:

• Dragging a Transfer Fcn block and setting numerator/denominator coefficients.
• Using dedicated Low-Pass, High-Pass, or Notch filter blocks where available, with parameters \( \omega_c \), \( \omega_0 \), and \( Q \).
• In robotics applications, integrating these blocks in the sensor signal path or in the controller subsystem, possibly using Robotics System Toolbox models of the robot.

Mathematica provides symbolic and numeric tools for transfer functions, frequency responses, and filter analysis. The prototype filters can be encoded as transfer function models and visualized with Bode plots.

(* Parameters *)
tau   = 0.05;
wc    = 1/tau;
w0    = 50.0;
zeta  = 0.05;
Qnotch = 10.0;

s = ComplexExpand[I*ω]; (* symbolic frequency variable is represented via I*ω *)

(* Continuous-time transfer functions encoded via s symbolic substitution *)
HLP[ω_] := wc/(I*ω + wc);
HHP[ω_] := (I*ω)/(I*ω + wc);
HBP[ω_] := (2 zeta w0 I*ω)/((I*ω)^2 + 2 zeta w0 I*ω + w0^2);
HNotch[ω_] := ((I*ω)^2 + w0^2)/((I*ω)^2 + (w0/Qnotch) I*ω + w0^2);

LogLogPlot[
  {
    Abs[HLP[ω]], Abs[HHP[ω]], Abs[HBP[ω]], Abs[HNotch[ω]]
  },
  {ω, 0.1, 1000},
  PlotLegends -> {"LP", "HP", "BP", "Notch"},
  AxesLabel -> {"omega", "|H(j omega)|"},
  PlotRange -> All
]
      

For more advanced work, the same transfer functions can be encoded using TransferFunctionModel and analyzed with BodePlot, allowing symbolic manipulation (e.g., exact expressions for cutoff frequency, bandwidth, and sensitivities with respect to parameters \( \omega_0 \), \( \zeta \), and \( Q \)).

Problem 1 (Cutoff of a First-Order Low-Pass): Consider \( H_{\text{LP}}(s) = \frac{1}{1 + \tau s} \). Derive the cutoff frequency \( \omega_c \) defined by \( |H_{\text{LP}}(j\omega_c)| = 1/\sqrt{2} \), and relate \( \omega_c \) to \( \tau \).

Solution:

\[ |H_{\text{LP}}(j\omega)|^2 = \frac{1}{1 + (\omega \tau)^2}. \]

Setting \( |H_{\text{LP}}(j\omega_c)|^2 = 1/2 \) yields

\[ \frac{1}{1 + (\omega_c \tau)^2} = \frac{1}{2} \quad \Longrightarrow \quad 1 + (\omega_c \tau)^2 = 2 \quad \Longrightarrow \quad (\omega_c \tau)^2 = 1. \]

Thus \( \omega_c \tau = 1 \), so \( \omega_c = 1/\tau \). The time constant and cutoff frequency are reciprocals.

Problem 2 (Step Response of High-Pass Filter): For the high-pass filter \( H_{\text{HP}}(s) = \frac{\tau s}{1 + \tau s} \), compute the output \( y(t) \) for a unit step input \( u(t) = 1\cdot u(t) \). What are the initial and final values of \( y(t) \)?

Solution:

In the Laplace domain, a unit step is \( U(s) = 1/s \). Thus

\[ Y(s) = H_{\text{HP}}(s) U(s) = \frac{\tau s}{1 + \tau s} \cdot \frac{1}{s} = \frac{\tau}{1 + \tau s}. \]

The inverse Laplace transform yields

\[ y(t) = \tau \cdot \frac{1}{\tau} e^{-t/\tau} u(t) = e^{-t/\tau} u(t). \]

Therefore \( y(0^+) = 1 \) and \( \lim_{t \to \infty} y(t) = 0 \). The high-pass filter responds strongly to the change at \( t=0 \) and then decays to zero, rejecting the steady component.

Problem 3 (Bandwidth and Q for Band-Pass): For the band-pass filter \( H_{\text{BP}}(s) = \frac{2\zeta \omega_0 s}{s^2 + 2\zeta \omega_0 s + \omega_0^2} \) with \( \zeta \ll 1 \), show that the 3 dB bandwidth \( B \approx 2\zeta \omega_0 \), and hence \( Q \approx 1/(2\zeta) \).

Solution (outline):

The peak occurs near \( \omega \approx \omega_0 \), so we approximate the magnitude near \( \omega_0 \) by expanding \( |H_{\text{BP}}(j\omega)|^2 \) around \( \omega = \omega_0 \) and retaining dominant terms. Let \( \Delta\omega = \omega - \omega_0 \) with \( |\Delta\omega| \ll \omega_0 \). The denominator simplifies to

\[ \left(\omega_0^2 - \omega^2\right)^2 + \left(2\zeta \omega_0 \omega\right)^2 \approx 4\omega_0^2 (\Delta\omega)^2 + 4\zeta^2 \omega_0^4, \]

and the numerator to \( 4\zeta^2 \omega_0^4 \). Thus

\[ |H_{\text{BP}}(j\omega)|^2 \approx \frac{4\zeta^2 \omega_0^4} {4\omega_0^2 (\Delta\omega)^2 + 4\zeta^2 \omega_0^4} = \frac{1}{1 + \left( \frac{\Delta\omega}{\zeta \omega_0} \right)^2 }. \]

The half-power points satisfy \( |H_{\text{BP}}(j\omega)|^2 = \frac{1}{2} \), which yields \( \left( \frac{\Delta\omega}{\zeta \omega_0} \right)^2 = 1 \), so \( |\Delta\omega| = \zeta \omega_0 \). There are two such frequencies: \( \omega_{1,2} \approx \omega_0 \mp \zeta \omega_0 \) giving

\[ B = \omega_2 - \omega_1 \approx 2\zeta \omega_0, \qquad Q = \frac{\omega_0}{B} \approx \frac{1}{2\zeta}. \]

Problem 4 (Design of a Band-Pass Filter): Design a band-pass filter with center frequency \( \omega_0 = 100\,\text{rad/s} \) and quality factor \( Q = 5 \) using the canonical form \( H_{\text{BP}}(s) = \frac{\omega_0}{Q} s / (s^2 + \frac{\omega_0}{Q} s + \omega_0^2) \). Give the numerator and denominator polynomials.

Solution:

We have \( \omega_0 = 100 \) and \( Q = 5 \), so \( \omega_0/Q = 20 \). Therefore

\[ H_{\text{BP}}(s) = \frac{20 s}{s^2 + 20 s + 100^2} = \frac{20 s}{s^2 + 20 s + 10000}. \]

Numerator: \( 20 s \) (coefficients \( [20, 0] \)). Denominator: \( s^2 + 20 s + 10000 \) (coefficients \( [1, 20, 10000] \)).

Problem 5 (Notch Filter for a Flexible Mode): A robot joint exhibits a problematic resonance at \( \omega_r = 60\,\text{rad/s} \). Design a notch filter with \( \omega_0 = \omega_r \) and \( Q = 10 \) using \( H_{\text{N}}(s) = (s^2 + \omega_0^2)/(s^2 + (\omega_0/Q) s + \omega_0^2) \). Compute the denominator and comment qualitatively on how increasing \( Q \) changes the filter.

Solution:

With \( \omega_0 = 60 \) and \( Q = 10 \) we obtain \( \omega_0/Q = 6 \), so

\[ H_{\text{N}}(s) = \frac{s^2 + 60^2}{s^2 + 6 s + 60^2} = \frac{s^2 + 3600}{s^2 + 6 s + 3600}. \]

The denominator is \( s^2 + 6 s + 3600 \). A larger \( Q \) would reduce the coefficient of \( s \), narrowing the stop-band around \( 60\,\text{rad/s} \) and making the notch sharper; a smaller \( Q \) broadens the stop-band but also distorts useful dynamics near the resonance.

The design decision flow can be sketched as:

flowchart TD
  ST["Start filter design"] --> R["Is there a known resonance?"]
  R -->|yes| N["Design notch: choose omega0, Q"]
  R -->|no| T["Target is noise attenuation?"]
  T -->|low freq important| LP["Use low-pass (choose tau or wc)"]
  T -->|high freq important| HP["Use high-pass"]
  N --> IMP["Implement in controller or sensor path"]
  LP --> IMP
  HP --> IMP
        

In this lesson we formalized the continuous-time prototypes of low-pass, high-pass, band-pass, and notch filters as rational transfer functions in the \( s \)-plane. We related their parameters (time constant, cutoff frequency, damping, bandwidth, and quality factor) to frequency responses and step responses, and showed how these filters are incorporated into control loops and robotics applications. Implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how the same mathematical structures appear in software tools used for analysis, simulation, and deployment.