In feedback control, sensor measurements are corrupted by high-frequency noise arising from quantization, electromagnetic interference, encoder imperfections, etc. For a unity feedback loop with controller \( C(s) \) and plant \( G(s) \), the open-loop transfer function is \( L(s) = C(s)G(s) \). We already know that the closed-loop transfer function from reference \( R(s) \) to output \( Y(s) \) is:

\[ G_r(s) \;=\; \frac{Y(s)}{R(s)} \;=\; \frac{L(s)}{1 + L(s)} . \]

Now introduce additive measurement noise \( N(s) \) at the sensor output, so that the measured signal is \( Y_m(s) = Y(s) + N(s) \). In many mechatronic and robotic applications (e.g., joint encoders, IMUs), this noise is approximately high-frequency: most of its energy is concentrated at frequencies much higher than the closed-loop bandwidth. Our design goal is to shape \( L(j\omega) \) and the associated transfer function from \( N \) to \( Y \) so that:

• Low-frequency performance (tracking, disturbance rejection) remains good.
• High-frequency noise is strongly attenuated at the output and, preferably, at the control input.
• The closed-loop remains stable with adequate gain and phase margins.

These goals naturally lead to requirements on the high-frequency roll-off of the open-loop and closed-loop frequency responses.

flowchart TD
  R["Reference r"] --> SUM["+ -"]
  SUM --> C["Controller C(j*omega)"]
  C --> G["Plant G(j*omega)"]
  G --> Y["Output y"]
  Y --> NADD["+ at sensor"]
  N["Measurement noise n"] --> NADD
  NADD --> YM["Measured y_m"]
  YM -->|feedback| SUM
        

To analyze noise performance, we treat noise as a random process \( n(t) \) with (wide-sense) stationary statistics and power spectral density (PSD) \( S_n(\omega) \). For a linear time-invariant system with transfer function \( G_n(s) \) from noise input to output \( y(t) \), the output PSD is:

\[ S_y(\omega) \;=\; \bigl|G_n(j\omega)\bigr|^2\,S_n(\omega) . \]

The output variance is therefore:

\[ \sigma_y^2 \;=\; \frac{1}{2\pi} \int_{-\infty}^{\infty} S_y(\omega)\,\mathrm{d}\omega \;=\; \frac{1}{2\pi} \int_{-\infty}^{\infty} \bigl|G_n(j\omega)\bigr|^2 S_n(\omega)\,\mathrm{d}\omega . \]

If the noise is approximately white with intensity \( S_n(\omega) \approx S_0 \) over a broad frequency band, the integral shows that the decay of \( \lvert G_n(j\omega)\rvert \) at high frequencies is decisive for bounding \( \sigma_y^2 \). This motivates specifying high-frequency roll-off for noise attenuation.

Consider again the unity feedback loop with additive measurement noise. Let \( R(s) \) be the Laplace transform of the reference, \( N(s) \) the noise, and \( Y(s) \) the output. The measured signal is:

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

The error, control input, and plant output are:

\[ E(s) = R(s) - Y_m(s) = R(s) - Y(s) - N(s), \]

\[ U(s) = C(s)E(s), \qquad Y(s) = G(s)U(s) = G(s)C(s)\bigl(R(s) - Y(s) - N(s)\bigr). \]

Denoting \( L(s) = C(s)G(s) \), we obtain:

\[ Y(s) = L(s)\bigl(R(s) - Y(s) - N(s)\bigr) \;\Rightarrow\; Y(s) + L(s)Y(s) = L(s)\bigl(R(s) - N(s)\bigr). \]

\[ Y(s)\bigl(1 + L(s)\bigr) = L(s)\bigl(R(s) - N(s)\bigr), \quad\Rightarrow\quad \frac{Y(s)}{R(s)} = \frac{L(s)}{1+L(s)},\quad \frac{Y(s)}{N(s)} = -\,\frac{L(s)}{1+L(s)}. \]

The transfer function from measurement noise to output is thus:

\[ G_n(s) \;=\; \frac{Y(s)}{N(s)} \;=\; -\,\frac{L(s)}{1+L(s)}. \]

Its magnitude at frequency \( \omega \) is:

\[ \bigl|G_n(j\omega)\bigr| \;=\; \frac{\lvert L(j\omega)\rvert}{\bigl|1+L(j\omega)\bigr|}. \]

Two regimes are important:

• For frequencies where \( \lvert L(j\omega)\rvert \gg 1 \), \( \bigl|G_n(j\omega)\bigr| \approx 1 \): noise is almost fully transmitted to the output.
• For frequencies where \( \lvert L(j\omega)\rvert \ll 1 \), \( \bigl|G_n(j\omega)\bigr| \approx \lvert L(j\omega)\rvert \): noise is strongly attenuated if the open-loop gain is small.

Since measurement noise is typically high-frequency, we want \( \lvert L(j\omega)\rvert \) to be small in the noise band, which requires sufficient high-frequency roll-off of the open-loop.

Let the open-loop transfer function \( L(s) \) be a proper rational function with relative degree \( \nu \) (number of poles minus number of zeros). As \( \omega \) becomes large, we have the asymptotic behavior:

\[ L(j\omega) \;\approx\; K\,\bigl(j\omega\bigr)^{-\nu}, \quad\Rightarrow\quad \lvert L(j\omega)\rvert \;\approx\; \lvert K\rvert\,\omega^{-\nu}. \]

If \( \nu \geq 2 \), the magnitude decays at least as \( 40\,\text{dB/dec} \), providing strong attenuation at high frequency. For the noise-to-output transfer function:

\[ \bigl|G_n(j\omega)\bigr| = \frac{\lvert L(j\omega)\rvert}{\bigl|1+L(j\omega)\bigr|} \;\approx\; \lvert L(j\omega)\rvert \;\approx\; \lvert K\rvert\,\omega^{-\nu}, \quad \text{when } \lvert L(j\omega)\rvert \ll 1. \]

Thus, a larger relative degree leads to faster high-frequency decay of \( \lvert G_n(j\omega)\rvert \), improving noise attenuation. However, adding high-frequency roll-off (e.g., extra poles in the controller) also reduces the phase margin and may slow down the closed-loop response. Frequency-domain specifications must balance:

• low-frequency gain for tracking and disturbance rejection,
• bandwidth for speed of response,
• high-frequency roll-off for noise attenuation and robustness.

A typical specification for measurement-noise attenuation focuses on the frequency band where the noise is dominant. Suppose measurement noise is concentrated around frequencies \( \omega \geq \omega_n \). We can specify:

\[ \bigl|G_n(j\omega)\bigr| \;=\; \left|\frac{L(j\omega)}{1+L(j\omega)}\right| \;\leq\; M_n, \quad \text{for all } \omega \geq \omega_n, \]

where \( M_n \) is an upper bound (e.g. \( M_n = 0.1 \) corresponding to \( -20\;\text{dB} \)). Because for high frequencies we typically have \( \lvert L(j\omega)\rvert \ll 1 \), the condition is approximately:

\[ \lvert L(j\omega)\rvert \;\leq\; M_n, \quad \text{for all } \omega \geq \omega_n. \]

An equivalent requirement for a white-noise input with PSD \( S_0 \) is an upper bound on the output variance:

\[ \sigma_y^2 \;=\; \frac{S_0}{2\pi} \int_{-\infty}^{\infty} \bigl|G_n(j\omega)\bigr|^2\,\mathrm{d}\omega \;\leq\; \sigma_{y,\max}^2. \]

This form is closer to stochastic process theory, but in classical design we usually enforce simpler magnitude bounds on \( \bigl|G_n(j\omega)\bigr| \) in the noise band.

flowchart TD
  A["Noise characteristics (PSD, band)"] --> B["Choose omega_n (noise band start)"]
  B --> C["Specify max |Y/N| = M_n for omega >= omega_n"]
  C --> D["Relate |Y/N| to |L| using Y/N = L/(1+L)"]
  D --> E["Shape L(j*omega): adjust controller poles/zeros"]
  E --> F["Check Bode plot: verify spec and margins"]
        

A common technique for improving measurement-noise attenuation is to introduce a low-pass filter in the measurement path. Let the filter be:

\[ F(s) \;=\; \frac{1}{1 + \frac{s}{\omega_f}} \;=\; \frac{\omega_f}{s + \omega_f}, \]

where \( \omega_f = 1/\tau_f \) is the filter bandwidth. The filtered measurement is:

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

and the controller uses \( Y_f \) in the feedback path. The error becomes:

\[ E(s) = R(s) - Y_f(s) = R(s) - F(s)\bigl(Y(s) + N(s)\bigr), \quad U(s) = C(s)E(s), \quad Y(s) = G(s)U(s). \]

Substituting, with \( L(s) = C(s)G(s) \), yields:

\[ Y(s) = L(s)\Bigl(R(s) - F(s)\bigl(Y(s) + N(s)\bigr)\Bigr) \;\Rightarrow\; Y(s)\bigl(1 + L(s)F(s)\bigr) = L(s)F(s)\bigl(R(s) - N(s)\bigr). \]

Therefore:

\[ \frac{Y(s)}{R(s)} = \frac{L(s)F(s)}{1 + L(s)F(s)}, \qquad \frac{Y(s)}{N(s)} = -\,\frac{L(s)F(s)}{1 + L(s)F(s)}. \]

For high frequencies with \( \omega \gg \omega_f \), the filter behaves as:

\[ F(j\omega) \approx \frac{\omega_f}{j\omega}, \quad\Rightarrow\quad \lvert F(j\omega)\rvert \approx \frac{\omega_f}{\omega}. \]

Thus the effective loop gain is \( L(s)F(s) \), which decays an extra \( 20\,\text{dB/dec} \) beyond \( \omega_f \). The noise-to-output magnitude behaves as:

\[ \bigl|G_{n,f}(j\omega)\bigr| \;=\; \left|\frac{L(j\omega)F(j\omega)}{1 + L(j\omega)F(j\omega)}\right| \;\approx\; \lvert L(j\omega)\rvert \frac{\omega_f}{\omega}, \quad \text{for large } \omega. \]

Choosing \( \omega_f \) small increases noise attenuation but also increases phase lag near the closed-loop bandwidth, potentially degrading stability and tracking. The design task is to place \( \omega_f \) somewhat above the closed-loop bandwidth, but well below the main noise frequencies.

We now illustrate noise attenuation and high-frequency roll-off using Python and the python-control library, which is commonly used in robotics research for linear control design and analysis. We model, for instance, a single-link robotic joint approximated by a second-order plant and a simple PD controller, with an optional measurement low-pass filter.

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

# Plant: second-order joint dynamics, J*s^2 + b*s + k (simplified)
J = 0.01   # inertia
b = 0.1    # damping
k = 0.0    # stiffness (assume gravity-compensated, small k)

numG = [1.0]
denG = [J, b, k]
G = ct.TransferFunction(numG, denG)

# PD controller (in practice used in robot joint controllers)
Kp = 20.0
Kd = 0.5
C = Kd * ct.TransferFunction([1, 0], [1]) + Kp

L = C * G  # open-loop

# Measurement low-pass filter: F(s) = wf / (s + wf)
wf = 50.0  # rad/s, choose relative to closed-loop bandwidth
F = ct.TransferFunction([wf], [1.0, wf])

# Closed-loop from noise at measurement to output:
# without filter: Gn0(s) = -L / (1 + L)
Gn0 = -L / (1 + L)

# with filter: GnF(s) = -L*F / (1 + L*F)
GnF = -(L * F) / (1 + L * F)

omega = np.logspace(0, 3, 400)  # 1 to 1000 rad/s

mag0, phase0, w0 = ct.bode(Gn0, omega, Plot=False)
magF, phaseF, wF = ct.bode(GnF, omega, Plot=False)

plt.figure()
plt.loglog(w0, mag0, label="no filter")
plt.loglog(wF, magF, linestyle="--", label="with measurement LPF")
plt.xlabel("omega [rad/s]")
plt.ylabel("|Y/N|")
plt.grid(True, which="both")
plt.legend()
plt.title("Noise-to-output magnitude with and without low-pass filtering")
plt.show()
      

The plot reveals how the measurement low-pass filter improves high-frequency roll-off of \( \bigl|Y/N\bigr| \), at the cost of extra phase lag near the bandwidth. Such plots are routinely used for robotic joint controllers to ensure encoder noise and IMU noise are sufficiently attenuated.

In real-time robotic control (e.g., using ROS or custom embedded code), we often implement a discrete-time approximation of a first-order low-pass filter to reduce measurement noise before feeding it to a PID loop. A standard implementation is:

\[ y_f[k] = \alpha\,y_f[k-1] + (1-\alpha)\,y[k], \quad 0 < \alpha < 1, \]

which is a first-order IIR filter. The parameter \( \alpha \) is related to the continuous-time time constant \( \tau_f \) and sampling period \( T_s \) by:

\[ \alpha = \mathrm{e}^{-T_s/\tau_f}. \]

A simple C++ implementation that could be embedded in a robotic joint controller is:

#include <cmath>

class LowPassFilter {
public:
    LowPassFilter(double tau_f, double Ts)
    {
        setParameters(tau_f, Ts);
        y_prev_ = 0.0;
    }

    void setParameters(double tau_f, double Ts)
    {
        tau_f_ = tau_f;
        Ts_ = Ts;
        alpha_ = std::exp(-Ts_ / tau_f_);
    }

    double filter(double y_meas)
    {
        // y_f[k] = alpha * y_f[k-1] + (1 - alpha) * y[k]
        double y_f = alpha_ * y_prev_ + (1.0 - alpha_) * y_meas;
        y_prev_ = y_f;
        return y_f;
    }

private:
    double tau_f_;
    double Ts_;
    double alpha_;
    double y_prev_;
};

// Example usage in a robot joint control loop:
// double y_meas = readEncoder();
// double y_filtered = lpf.filter(y_meas);
// double error = q_ref - y_filtered;
// double u = Kp * error + Kd * (error - error_prev) / Ts;
      

Here the high-frequency roll-off of the filter translates directly into reduced encoder noise in the feedback loop, improving torque smoothness and reducing actuator chatter.

Java is used in some robotic frameworks (e.g., FIRST robotics with WPILib). A typical structure is to integrate a low-pass filter into the measurement processing pipeline before the PID controller. The same discrete-time filter as above can be implemented in Java:

public class LowPassFilter {
    private double alpha;
    private double yPrev;

    public LowPassFilter(double tauF, double Ts) {
        setParameters(tauF, Ts);
        this.yPrev = 0.0;
    }

    public void setParameters(double tauF, double Ts) {
        this.alpha = Math.exp(-Ts / tauF);
    }

    public double filter(double yMeas) {
        double yF = alpha * yPrev + (1.0 - alpha) * yMeas;
        yPrev = yF;
        return yF;
    }
}

// Example of integrating into a PID-based joint controller
public class JointController {
    private double Kp;
    private double Kd;
    private double Ts;
    private LowPassFilter measFilter;
    private double prevError;

    public JointController(double Kp, double Kd, double Ts,
                           double tauF) {
        this.Kp = Kp;
        this.Kd = Kd;
        this.Ts = Ts;
        this.prevError = 0.0;
        this.measFilter = new LowPassFilter(tauF, Ts);
    }

    public double computeControl(double qRef, double qMeasRaw) {
        double qMeas = measFilter.filter(qMeasRaw);
        double error = qRef - qMeas;
        double dError = (error - prevError) / Ts;
        prevError = error;
        return Kp * error + Kd * dError;
    }
}
      

The choice of tauF determines the effective high-frequency roll-off in the loop. Too small tauF (very aggressive filtering) can introduce noticeable lag, reducing stability margins; too large tauF has little effect on noise.

MATLAB and Simulink are widely used for control design in robotics. We now demonstrate how to construct the noise-to-output transfer function and inspect its Bode magnitude, with and without measurement filtering.

% Plant (same as in Python example)
J = 0.01; b = 0.1; k = 0.0;
G = tf(1, [J b k]);

% PD controller
Kp = 20; Kd = 0.5;
C = Kd * tf([1 0], 1) + Kp;

L = C * G;  % open-loop

% Measurement low-pass filter
wf = 50;   % rad/s
F = tf(wf, [1 wf]);

% Noise-to-output transfer functions
Gn0 = -L / (1 + L);        % no filter
GnF = -(L * F) / (1 + L * F);  % with filter

omega = logspace(0, 3, 400);
figure;
bodemag(Gn0, GnF, omega);
legend("no filter", "with measurement LPF");
grid on;
title("Noise-to-output frequency response");

% Simulink implementation:
%  - Use blocks: Sum, Transfer Fcn (G), PID Controller, Transfer Fcn (F),
%    Band-Limited White Noise for measurement noise.
%  - Connect noise source at sensor summing junction, place F in feedback path,
%    and scope the output to see the effect of filtering.
      

In Simulink, robotic joint models (including link inertias) can be built using Simscape Multibody or Robotics System Toolbox, and the same frequency-domain principles for noise attenuation and roll-off apply after linearization around an operating point.

Wolfram Mathematica can handle symbolic transfer functions and Bode plots, which is useful for exploring how parameters influence high-frequency roll-off analytically.

(* Define symbolic variables and transfer functions *)
Clear["Global`*"];
J = 0.01; b = 0.1; k = 0.0;
Kp = 20.0; Kd = 0.5;
wf = 50.0;

s = ComplexExpand[I*omega]; (* for symbolic reasoning we can also use LaplaceTransformVariable *)

G = TransferFunctionModel[{1}, {J, b, k}, s];
C = TransferFunctionModel[{Kd, Kp}, {1}, s];  (* Kd*s + Kp *)

L = SystemsModelSeriesConnect[C, G];

F = TransferFunctionModel[{wf}, {1, wf}, s];

Gn0 = -SystemsModelFeedback[L, 1];             (* -L / (1 + L) *)
GnF = -SystemsModelFeedback[SystemsModelSeriesConnect[L, F], 1];

(* Bode magnitude plot for numerical frequency grid *)
BodePlot[{Gn0, GnF}, {omega, 1, 1000},
 PlotLegends -> {"no filter", "with measurement LPF"},
 GridLines -> Automatic,
 PlotLayout -> "Magnitude"]
      

Symbolic manipulation can also be used to extract the asymptotic high-frequency behavior of \( \bigl|G_n(j\omega)\bigr| \) and express it explicitly as a power of \( \omega \), confirming the \( 20\,\text{dB/dec} \), \( 40\,\text{dB/dec} \), etc., roll-off rates.

Problem 1 (Derivation of Noise-to-Output Transfer Function):
Consider a unity feedback system with controller \( C(s) \) and plant \( G(s) \). Measurement noise \( N(s) \) is added at the sensor output. Derive the closed-loop transfer function from \( N(s) \) to \( Y(s) \) and show that \( Y(s)/N(s) = -L(s)/(1+L(s)) \) with \( L(s) = C(s)G(s) \).

Solution:

The measured output is \( Y_m(s) = Y(s) + N(s) \). The error is \( E(s) = R(s) - Y_m(s) = R(s) - Y(s) - N(s) \), the control input is \( U(s) = C(s)E(s) \), and the plant output is \( Y(s) = G(s)U(s) \). Substituting, we get:

\[ Y(s) = G(s)C(s)\bigl(R(s) - Y(s) - N(s)\bigr) = L(s)\bigl(R(s) - Y(s) - N(s)\bigr). \]

Rearranging:

\[ Y(s) + L(s)Y(s) = L(s)\bigl(R(s) - N(s)\bigr) \;\Rightarrow\; Y(s)\bigl(1 + L(s)\bigr) = L(s)\bigl(R(s) - N(s)\bigr). \]

Setting \( R(s) = 0 \) to isolate the effect of noise:

\[ Y(s)\bigl(1 + L(s)\bigr) = -L(s)N(s) \;\Rightarrow\; \frac{Y(s)}{N(s)} = -\,\frac{L(s)}{1+L(s)}. \]

This is the desired noise-to-output transfer function.

Problem 2 (Asymptotic Noise Attenuation for High Relative Degree):
Assume the open-loop transfer function \( L(s) \) has relative degree \( \nu \geq 2 \) and behaves as \( L(j\omega) \approx K(j\omega)^{-\nu} \) for large \( \omega \). Show that for high frequencies where \( \lvert L(j\omega)\rvert \ll 1 \), the noise-to-output transfer function satisfies \( \bigl|Y/N\bigr| \approx \lvert K\rvert\,\omega^{-\nu} \).

Solution:

The noise-to-output transfer function is \( G_n(s) = -L(s)/(1+L(s)) \). At high frequencies, the magnitude is:

\[ \bigl|G_n(j\omega)\bigr| = \frac{\lvert L(j\omega)\rvert}{\bigl|1+L(j\omega)\bigr|}. \]

For frequencies where \( \lvert L(j\omega)\rvert \ll 1 \), \( \bigl|1+L(j\omega)\bigr| \approx 1 \), hence:

\[ \bigl|G_n(j\omega)\bigr| \approx \lvert L(j\omega)\rvert. \]

Using the assumed asymptotic behavior \( L(j\omega) \approx K(j\omega)^{-\nu} \), we have:

\[ \lvert L(j\omega)\rvert \approx \lvert K\rvert\,\omega^{-\nu}, \quad\Rightarrow\quad \bigl|G_n(j\omega)\bigr| \approx \lvert K\rvert\,\omega^{-\nu}. \]

Therefore, the noise attenuation improves as the relative degree increases.

Problem 3 (Specification on Noise Attenuation):
Suppose measurement noise is significant for \( \omega \geq 100 \) rad/s. You require that \( \bigl|Y/N\bigr| \leq 0.1 \) for all \( \omega \geq 100 \) rad/s. Assuming \( \lvert L(j\omega)\rvert \ll 1 \) in this band, express the equivalent requirement on \( \lvert L(j\omega)\rvert \).

Solution:

Under the assumption \( \lvert L(j\omega)\rvert \ll 1 \), we have \( \bigl|Y/N\bigr| \approx \lvert L(j\omega)\rvert \) for frequencies in the noise band. The specification \( \bigl|Y/N\bigr| \leq 0.1 \) thus becomes:

\[ \lvert L(j\omega)\rvert \leq 0.1, \quad \text{for all } \omega \geq 100 \;\text{rad/s}. \]

In decibels, this is \( 20\log_{10}\lvert L(j\omega)\rvert \leq -20\;\text{dB} \) for \( \omega \geq 100 \) rad/s.

Problem 4 (Effect of Measurement Low-Pass Filter):
Consider again the measurement low-pass filter \( F(s) = \omega_f/(s+\omega_f) \). Show that for high frequencies \( \omega \gg \omega_f \), the magnitude of the noise-to-output transfer function with filtering behaves approximately as:

\[ \bigl|Y/N\bigr| \approx \lvert L(j\omega)\rvert \frac{\omega_f}{\omega}. \]

Solution:

With filtering, the effective loop transfer function is \( L(s)F(s) \), and the noise-to-output transfer function is:

\[ G_{n,f}(s) = -\,\frac{L(s)F(s)}{1 + L(s)F(s)}. \]

For high frequencies \( \omega \gg \omega_f \), we approximate:

\[ F(j\omega) \approx \frac{\omega_f}{j\omega}, \quad\Rightarrow\quad \lvert F(j\omega)\rvert \approx \frac{\omega_f}{\omega}. \]

Assuming again that \( \lvert L(j\omega)F(j\omega)\rvert \ll 1 \) in this band, the denominator is approximately \( 1 \), giving:

\[ \bigl|G_{n,f}(j\omega)\bigr| \approx \lvert L(j\omega)\rvert \lvert F(j\omega)\rvert \approx \lvert L(j\omega)\rvert \frac{\omega_f}{\omega}. \]

Thus the filter provides an additional \( 20\,\text{dB/dec} \) roll-off in the noise band.

Problem 5 (Trade-Off Between Bandwidth and Noise):
A controller for a robotic joint is tuned to achieve a closed-loop bandwidth of \( \omega_b \) (rad/s). You consider decreasing the measurement filter time constant \( \tau_f \) to better attenuate encoder noise. Explain, using frequency-domain reasoning, why choosing \( \omega_f \) too close to \( \omega_b \) can cause a significant reduction in phase margin and potentially destabilize the loop.

Solution:

The measurement filter \( F(s) = \omega_f/(s+\omega_f) \) introduces a pole at \( -\omega_f \). In the frequency domain, this contributes an additional \( -90^\circ \) of phase lag asymptotically, with roughly \( -45^\circ \) phase lag around \( \omega \approx \omega_f \).

The effective loop transfer function is \( L(s)F(s) \). If \( \omega_f \) is chosen near the desired bandwidth \( \omega_b \), the additional lag at the gain crossover frequency reduces the phase margin. In Bode terms, the phase curve is shifted downward near crossover, potentially making the phase margin too small and risking oscillations or instability. To avoid this, \( \omega_f \) is usually chosen significantly above \( \omega_b \), so that the extra phase lag at crossover is moderate while the filter still attenuates high-frequency noise.

In this lesson, we introduced measurement-noise attenuation and high-frequency roll-off as key aspects of frequency-domain performance specifications. Starting from the unity feedback structure, we derived the noise-to-output transfer function \( Y/N = -L/(1+L) \) and showed how its magnitude is governed by the high-frequency behavior of the open-loop transfer function \( L(s) \).

We analyzed how relative degree and additional poles (e.g., measurement low-pass filters) increase high-frequency decay, thereby reducing the variance of the output in the presence of high-frequency measurement noise. On the other hand, these modifications introduce additional phase lag and can degrade stability margins, illustrating a fundamental trade-off between noise attenuation and closed-loop responsiveness.

Finally, we implemented representative noise filtering schemes in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, emphasizing their use in robotic control systems where encoder and IMU noise are significant. In subsequent lessons we will further connect these frequency-domain specifications with time-domain metrics and more global trade-offs in loop-shaping design.