Consider the standard unity-feedback loop with controller \( C(s) \), plant \( G(s) \), and loop transfer \( L(s) = C(s)G(s) \). The sensitivity and complementary sensitivity are

\[ S(s) = \frac{1}{1 + L(s)}, \qquad T(s) = \frac{L(s)}{1 + L(s)}. \]

Disturbances can enter at different locations. Two canonical cases are:

• Output disturbance \( d_o \) added to the plant output.
• Input disturbance \( d_i \) added at the plant input (e.g., load torque).

For unity feedback with reference \( r \), output \( y \), and output disturbance \( d_o \) added after the plant, algebra gives

\[ y(s) = T(s) r(s) + S(s) d_o(s). \]

Thus the closed-loop transfer from output disturbance to output is simply \( G_{d_o \to y}(s) = S(s) \). Making \( |S(j\omega)| \) small at disturbance frequencies directly improves disturbance rejection.

If instead the disturbance is added at the plant input, so the plant sees \( u + d_i \), we obtain

\[ y(s) = T(s) r(s) + S(s) G(s) d_i(s), \qquad G_{d_i \to y}(s) = S(s) G(s). \]

For both cases, attenuation quality is governed by \( S(j\omega) \) (and \( G(j\omega) \) for input disturbances), so disturbance-rejection design is fundamentally a design of the frequency shape of the sensitivity.

flowchart TD
  R["reference r"] --> E["sum 1 (r - y)"]
  Y["output y"] --> FB["feedback"]
  FB --> E
  E --> C["controller C(s)"]
  C --> SUMU["sum 2 (u + d_in)"]
  DIN["input disturbance d_in"] --> SUMU
  SUMU --> G["plant G(s)"]
  G --> SUMY["sum 3 (y + d_out)"]
  DOUT["output disturbance d_out"] --> SUMY
  SUMY --> Y
        

Disturbance signals can be decomposed into sinusoids by Fourier analysis. Consider an output disturbance with a dominant harmonic component

\[ d_o(t) = D_k \sin(\omega_k t), \qquad D_k > 0. \]

In steady state, the output response has the same frequency with amplitude scaled by \( |S(j\omega_k)| \):

\[ y(t) \approx |S(j\omega_k)| D_k \sin\!\big(\omega_k t + \varphi_S(\omega_k)\big). \]

If the design requirement is that the output amplitude should not exceed a tolerable bound \( Y_{\max} \) for this harmonic, we obtain the inequality

\[ |S(j\omega_k)| \leq \frac{Y_{\max}}{D_k}. \]

For an input disturbance with harmonic \( d_i(t) = D_k \sin(\omega_k t) \), the steady-state output amplitude is approximately \( |S(j\omega_k) G(j\omega_k)| D_k \). Requiring the same bound \( Y_{\max} \) gives

\[ |S(j\omega_k)| \leq \frac{Y_{\max}}{|G(j\omega_k)| D_k}. \]

This is the core idea: disturbance specifications at key frequencies are translated into magnitude constraints on the sensitivity. In practice we often specify bands of frequencies \( \omega \in [\omega_{\min}, \omega_{\max}] \) rather than single points.

Many disturbances in servo systems (robotic joints, drives) are approximately constant or slowly varying: gravity, friction changes, steady load torques. For such disturbances, we care about the low-frequency behavior of the sensitivity, especially \( S(0) \).

For an output disturbance step \( d_o(t) = D_0 u(t) \), with Laplace transform \( D_o(s) = D_0 / s \), the final value theorem gives

\[ y_{\text{ss}} = \lim_{t \to \infty} y(t) = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} s S(s) \frac{D_0}{s} = D_0 S(0). \]

To achieve perfect rejection of constant output disturbances (zero steady-state offset), we require \( S(0) = 0 \). This happens if the loop transfer \( L(s) \) has at least one pole at the origin, so that \( |L(j\omega)| \) grows unbounded as \( \omega \to 0 \) and \( S(0) = \lim_{\omega \to 0} 1 / (1 + L(j\omega)) = 0 \).

In practice, we realize this by adding integral action to the controller, e.g. a PI controller

\[ C(s) = K_p + \frac{K_i}{s}. \]

With integral action, the low-frequency magnitude of \( L(j\omega) \) rises as roughly \( |L(j\omega)| \approx K_i / \omega \) for sufficiently small \( \omega \). For a band of low frequencies \( \omega \in [0, \omega_b] \), we can enforce

\[ |S(j\omega)| \approx \frac{1}{|L(j\omega)|} \leq M_d \quad \text{for } \omega \in [0, \omega_b], \]

where \( M_d \) is a desired upper bound (e.g., \( M_d = 0.01 \) for \( 40\ \text{dB} \) attenuation). This inequality translates directly into a required magnitude of the loop gain:

\[ |L(j\omega)| \geq \frac{1}{M_d} \quad \text{for } \omega \in [0, \omega_b]. \]

Designing for disturbance rejection at low frequency is therefore a loop-shaping task: ensure sufficiently high gain in \( L(j\omega) \) below a chosen bandwidth, while respecting stability margins.

For a given plant and controller structure (e.g., PID, lead-lag), disturbance-rejection design at key frequencies typically follows this workflow:

1. Identify dominant disturbance frequencies \( \omega_k \) from physics (e.g., mains frequency, gear mesh frequency) or measurement (FFT).
2. Specify allowable output amplitude \( Y_{\max,k} \) for each \( \omega_k \), given expected disturbance level \( D_k \).
3. Translate these into constraints on \( |S(j\omega_k)| \) (and on \( |S(j\omega_k)G(j\omega_k)| \) for input disturbances).
4. Convert sensitivity constraints into requirements on \( |L(j\omega_k)| \) via \( S = 1/(1 + L) \).
5. Adjust controller parameters (gains, lead/lag, filters) to shape \( L(j\omega) \) accordingly, while maintaining acceptable gain and phase margins.
6. Verify \( S(j\omega) \) and \( T(j\omega) \) against disturbance and noise specs using Bode plots and numerical simulations.

flowchart TD
  SPEC["disturbance spec at omega_k"] --> B1["bound |S(j omega_k)|"]
  B1 --> B2["required |L(j omega_k)|"]
  B2 --> C1["tune controller (PID, lead-lag)"]
  C1 --> V1["check S(j omega), T(j omega)"]
  V1 --> V2["check stability margins"]
  V2 --> IMPL["implement in robot joint/drive"]
        

Because \( S(s) + T(s) = 1 \), aggressive suppression of \( |S(j\omega)| \) over a wide band inevitably increases \( |T(j\omega)| \) somewhere else (the "waterbed effect" introduced earlier). Disturbance-rejection design is therefore always a compromise between low-frequency disturbance attenuation and robustness to noise and unmodeled high-frequency dynamics.

Consider a simplified single-link robotic joint with inertia \( J \) and viscous friction \( b \). The rotational dynamics are

\[ J \ddot{\theta}(t) + b \dot{\theta}(t) = u(t) - d(t), \]

where \( u \) is the actuator torque command, and \( d \) is a load torque disturbance. With Laplace transforms and zero initial conditions:

\[ (J s^2 + b s)\Theta(s) = U(s) - D(s), \qquad G(s) = \frac{\Theta(s)}{U(s)} = \frac{1}{J s^2 + b s}. \]

The disturbance enters at the plant input. From Section 1, the disturbance-to-output transfer function is

\[ G_{d \to \theta}(s) = S(s) G(s). \]

Suppose we use a PI controller

\[ C(s) = K_p + \frac{K_i}{s}, \qquad L(s) = C(s) G(s). \]

Design goal: a constant load torque of magnitude \( D_0 \) should produce a position error of at most \( 0.5^\circ \) (in radians, \( Y_{\max} \approx 0.5 \pi / 180 \)). The steady-state position offset is

\[ \theta_{\text{ss}} = \lim_{t \to \infty} \theta(t) = \lim_{s \to 0} s \Theta(s) = \lim_{s \to 0} s S(s) G(s) \frac{D_0}{s} = D_0 S(0) G(0). \]

For this plant, \( G(0) = \infty \) (due to the pole at the origin), reflecting that constant torque produces unbounded motion in open loop. In closed loop with PI control, the position is regulated. The final value theorem applied to the closed-loop equations yields

\[ \theta_{\text{ss}} = \frac{D_0}{K_i}, \]

assuming \( K_i > 0 \) and a stable closed loop. This follows from writing the closed-loop characteristic polynomial and solving the steady state of the equivalent state-space system. Thus the disturbance specification translates directly to

\[ \left| \frac{D_0}{K_i} \right| \leq Y_{\max} \quad \Rightarrow \quad K_i \geq \frac{D_0}{Y_{\max}}. \]

This gives a lower bound on the integral gain for disturbance rejection. An upper bound is imposed by stability and overshoot requirements, which we assess via the Bode plot of \( L(j\omega) \) and the time-domain step response.

We now compute and visualize \( S(j\omega) \) and \( G_{d \to \theta}(j\omega) \) for the robotic joint model using Python. The python-control library is convenient for this; in robotics applications it can be combined with roboticstoolbox for multi-link models.

import numpy as np
import matplotlib.pyplot as plt

# python-control library (install via: pip install control)
import control as ctl

# Physical parameters for a single robotic joint
J = 0.01     # kg m^2
b = 0.1      # N m s/rad

# PI controller parameters (chosen to satisfy basic specs)
Kp = 20.0
Ki = 50.0

# Define transfer functions: G(s) and C(s)
s = ctl.TransferFunction.s
G = 1 / (J * s**2 + b * s)
C = Kp + Ki / s

L = C * G                 # loop transfer
S = 1 / (1 + L)           # sensitivity
T = L / (1 + L)           # complementary sensitivity

# Disturbance input at plant input: G_d(s) = S(s) G(s)
Gd_in = ctl.minreal(S * G, verbose=False)

# Frequency grid and magnitude of S and Gd_in
w = np.logspace(-1, 2, 500)   # rad/s
magS, phaseS, _ = ctl.freqresp(S, w)
magGd, phaseGd, _ = ctl.freqresp(Gd_in, w)

magS_db = 20 * np.log10(np.abs(magS).flatten())
magGd_db = 20 * np.log10(np.abs(magGd).flatten())

plt.figure(figsize=(8, 5))
plt.semilogx(w, magS_db, label="|S(jw)|")
plt.semilogx(w, magGd_db, label="|G_d_in(jw)| = |S(jw) G(jw)|")
plt.axhline(-40, color="k", linestyle="--", label="-40 dB target")
plt.xlabel("Frequency w [rad/s]")
plt.ylabel("Magnitude [dB]")
plt.title("Sensitivity and Disturbance Transfer for Robotic Joint")
plt.grid(True, which="both")
plt.legend()
plt.tight_layout()
plt.show()

# Time-domain simulation: step load disturbance
t = np.linspace(0, 5, 1000)
D0 = 1.0  # step load torque [N m]
d_step = D0 * np.ones_like(t)

# Closed-loop from load torque to position: Gd_in(s)
t_out, theta_out = ctl.forced_response(Gd_in, T=t, U=d_step)

print("Approx. steady-state position error [rad]:", theta_out[-1])
      

This script allows you to check whether the chosen PI gains meet a specified attenuation level for \( |S(j\omega)| \) in the low-frequency range relevant for quasi-static load torques.

In embedded robotic controllers (e.g., running under ROS control), the feedback loop is implemented in discrete time. The following C++ code fragment simulates a PI-controlled joint under a step load torque disturbance using a simple Euler integration scheme. Linear control concepts here can be combined with libraries like Eigen (for vectorized multi-joint dynamics) and the ros_control framework for integration into a ROS robot.

#include <iostream>
#include <vector>

int main() {
    // Physical parameters
    double J = 0.01;   // inertia [kg m^2]
    double b = 0.1;    // viscous friction [N m s/rad]

    // PI controller gains (same as Python example)
    double Kp = 20.0;
    double Ki = 50.0;

    // Simulation settings
    double Ts = 0.001;       // sampling period [s]
    double Tfinal = 5.0;     // total time [s]
    int N = static_cast<int>(Tfinal / Ts);

    // State variables: position theta, velocity omega, integral of error
    double theta = 0.0;
    double omega = 0.0;
    double e_int = 0.0;

    // Reference position (regulation)
    double theta_ref = 0.0;

    // Disturbance: step load torque
    double D0 = 1.0;  // [N m]

    for (int k = 0; k < N; ++k) {
        double t = k * Ts;

        // Step disturbance applied for t >= 0
        double d = D0;

        // Error and integral
        double e = theta_ref - theta;
        e_int += e * Ts;

        // Control torque
        double u = Kp * e + Ki * e_int;

        // Joint dynamics: J * theta_ddot + b * theta_dot = u - d
        double theta_ddot = (u - d - b * omega) / J;

        // Euler integration
        omega += Ts * theta_ddot;
        theta += Ts * omega;

        if (k % 1000 == 0) {
            std::cout << "t=" << t
                      << "  theta=" << theta
                      << "  omega=" << omega
                      << std::endl;
        }
    }

    std::cout << "Final position (steady-state error) [rad]: "
              << theta << std::endl;

    return 0;
}
      

By varying Ki and observing the final position theta, you can empirically verify the inverse relationship between integral gain and steady-state disturbance offset predicted by the analytical formula \( \theta_{\text{ss}} = D_0 / K_i \).

Java is used in several robotics and mechatronics frameworks (for example, WPILib in educational robotics). Below is a minimal Java class that performs a similar discrete-time simulation, suitable to be integrated with numerical libraries such as EJML or Apache Commons Math.

public class DisturbanceRejectionSimulation {

    public static void main(String[] args) {
        // Physical parameters
        double J = 0.01;
        double b = 0.1;

        // PI controller gains
        double Kp = 20.0;
        double Ki = 50.0;

        // Simulation parameters
        double Ts = 0.001;
        double Tfinal = 5.0;
        int N = (int) (Tfinal / Ts);

        double theta = 0.0;
        double omega = 0.0;
        double eInt = 0.0;
        double thetaRef = 0.0;

        double D0 = 1.0;  // step load torque

        for (int k = 0; k < N; ++k) {
            double t = k * Ts;

            double d = D0;

            double e = thetaRef - theta;
            eInt += e * Ts;

            double u = Kp * e + Ki * eInt;

            double thetaDDot = (u - d - b * omega) / J;

            omega += Ts * thetaDDot;
            theta += Ts * omega;

            if (k % 1000 == 0) {
                System.out.printf("t=%.3f  theta=%.5f  omega=%.5f%n",
                        t, theta, omega);
            }
        }

        System.out.printf("Final position (steady-state error) [rad]: %.6f%n",
                theta);
    }
}
      

In industrial code, you would typically encapsulate the controller and plant within classes, and possibly interface this with a real-time robot API, but the linear control logic for disturbance rejection remains the same.

MATLAB, together with Control System Toolbox and Robotics System Toolbox, is widely used for robot joint and drive design. The following script constructs \( G(s) \), the PI controller, the sensitivity function, and simulates the response to a step disturbance. In Simulink, the same structure can be implemented with standard blocks for the controller, plant, and disturbance injection.

% Physical parameters
J = 0.01;
b = 0.1;

% PI controller gains
Kp = 20;
Ki = 50;

s = tf('s');
G = 1 / (J * s^2 + b * s);
C = Kp + Ki / s;

L = C * G;
S = 1 / (1 + L);
T = L / (1 + L);

% Disturbance at plant input: Gd(s) = S(s) G(s)
Gd_in = minreal(S * G);

% Bode magnitude of S and Gd_in
w = logspace(-1, 2, 500);
[magS, ~] = bode(S, w);
[magGd, ~] = bode(Gd_in, w);

magS_db = 20 * log10(squeeze(magS));
magGd_db = 20 * log10(squeeze(magGd));

figure;
semilogx(w, magS_db, 'b', w, magGd_db, 'r');
grid on;
xlabel('Frequency w [rad/s]');
ylabel('Magnitude [dB]');
legend('|S(jw)|', '|Gd\_in(jw)|', 'Location', 'SouthWest');
title('Sensitivity and Disturbance Transfer');

% Time-domain simulation of step load disturbance
t = linspace(0, 5, 1000);
D0 = 1.0;
d_step = D0 * ones(size(t));

[theta, t_out] = lsim(Gd_in, d_step, t);
theta_ss = theta(end);

fprintf('Approx. steady-state position error [rad]: %.6f\n', theta_ss);
      

A Simulink model can mirror this structure with summing junctions for reference and disturbance, a PI controller block, a plant block \( G(s) \), and scopes to visualize the effect of disturbances on joint position.

Mathematica provides symbolic and numerical tools for transfer-function manipulation and frequency-response analysis. The following code constructs the plant and controller, computes the sensitivity, and plots its magnitude.

(* Physical parameters *)
J = 0.01;
b = 0.1;

(* PI controller parameters *)
Kp = 20.0;
Ki = 50.0;

(* Define Laplace variable and transfer functions *)
s =.;
G = TransferFunctionModel[1/(J*s^2 + b*s), s];
C = TransferFunctionModel[Kp + Ki/s, s];

L = SystemsModelSeriesConnect[C, G];
S = SystemsModelFeedback[1, L];   (* sensitivity 1/(1 + L) *)
T = SystemsModelFeedback[L, 1];   (* complementary sensitivity L/(1 + L) *)

(* Disturbance at plant input: Gd(s) = S(s) G(s) *)
GdIn = SystemsModelSeriesConnect[S, G];

BodePlot[{S, GdIn},
  {0.1, 100},
  PlotLayout -> "Magnitude",
  PlotLegends -> {"|S(jw)|", "|GdIn(jw)|"},
  GridLines -> Automatic,
  AxesLabel -> {"w [rad/s]", "Magnitude [dB]"},
  PlotTheme -> "Detailed"
]

(* Numerical evaluation of steady-state error for a step disturbance *)
D0 = 1.0;
sysStep = TransferFunctionModel[D0, s] * GdIn;
thetaStep = OutputResponse[sysStep, UnitStep, {t, 0, 5}];
thetaSS = Limit[thetaStep, t -> Infinity] // N
      

Symbolic manipulation can also be used to derive closed-form expressions for \( S(s) \) and \( G_{d \to \theta}(s) \), which is valuable for understanding how controller parameters affect disturbance rejection.

Problem 1 (Closed-Loop Disturbance Transfer Functions): For the unity-feedback loop with controller \( C(s) \), plant \( G(s) \), and loop transfer \( L(s) = C(s)G(s) \), derive the disturbance-to-output transfer functions for: (i) an output disturbance \( d_o \) added after the plant; (ii) an input disturbance \( d_i \) added at the plant input.

Solution:

Let the reference be \( r \) and the output be \( y \). For the output disturbance case:

• Error: \( e = r - y \).
• Control: \( u = C(s)e(s) \).
• Plant output before disturbance: \( y_p = G(s)u(s) \).
• Total output: \( y = y_p + d_o = G(s)C(s)(r - y) + d_o \).

Thus \( y + G(s)C(s)y = G(s)C(s)r + d_o \), so

\[ y(s) = \frac{G(s)C(s)}{1 + G(s)C(s)} r(s) + \frac{1}{1 + G(s)C(s)} d_o(s) = T(s) r(s) + S(s) d_o(s). \]

Therefore \( G_{d_o \to y}(s) = S(s) \).

For the input disturbance case, the plant sees \( u + d_i \): \( y = G(s)(u + d_i) = G(s)C(s)(r - y) + G(s)d_i \). Then

\[ y + G(s)C(s)y = G(s)C(s)r + G(s)d_i \quad \Rightarrow \quad y(s) = T(s) r(s) + S(s)G(s) d_i(s). \]

Hence \( G_{d_i \to y}(s) = S(s)G(s) \).

Problem 2 (Low-Frequency Disturbance Rejection and Integral Action): Show that for a stable loop with no integrator in \( L(s) \) (i.e., a type-0 loop), a constant output disturbance cannot be perfectly rejected. What condition on \( L(s) \) is necessary for \( S(0) = 0 \)?

Solution:

For a constant output disturbance \( d_o(t) = D_0 u(t) \), we have \( D_o(s) = D_0 / s \) and \( Y(s) = S(s) D_o(s) \). The final value is

\[ y_{\text{ss}} = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} s S(s) \frac{D_0}{s} = D_0 S(0). \]

For a type-0 loop, \( L(s) \) is finite at \( s = 0 \), so \( S(0) = 1 / (1 + L(0)) \neq 0 \). Therefore \( y_{\text{ss}} = D_0 S(0) \neq 0 \) for any nonzero \( D_0 \), and perfect disturbance rejection is impossible.

For \( S(0) = 0 \), we need \( |L(j\omega)| \to \infty \) as \( \omega \to 0 \), which occurs if and only if \( L(s) \) has at least one pole at the origin (type at least 1). Thus integral action in the loop is necessary for perfect rejection of constant output disturbances.

Problem 3 (Specification at a Single Frequency): A plant has frequency response \( G(j\omega_0) \) at a disturbance frequency \( \omega_0 \). An output disturbance of amplitude \( D_0 \) at this frequency should produce an output of amplitude at most \( Y_{\max} \). Express the corresponding bound on \( |S(j\omega_0)| \) and on \( |L(j\omega_0)| \) assuming \( |L(j\omega_0)| \geq 1 \).

Solution:

For an output disturbance, \( y(t) \) has amplitude \( |S(j\omega_0)| D_0 \). The requirement \( |S(j\omega_0)| D_0 \leq Y_{\max} \) gives

\[ |S(j\omega_0)| \leq \frac{Y_{\max}}{D_0}. \]

Since \( S = 1/(1 + L) \) and \( |L(j\omega_0)| \geq 1 \), we can approximate \( |S(j\omega_0)| \approx 1/|L(j\omega_0)| \). A sufficient condition is

\[ \frac{1}{|L(j\omega_0)|} \leq \frac{Y_{\max}}{D_0} \quad \Rightarrow \quad |L(j\omega_0)| \geq \frac{D_0}{Y_{\max}}. \]

Thus the disturbance specification is translated into a lower bound on the loop gain at \( \omega_0 \).

Problem 4 (Robotic Joint with PI Control): For the robotic joint model \( J \ddot{\theta} + b \dot{\theta} = u - d \) with PI control \( u = K_p e + K_i \int e \, dt \), where \( e = \theta_{\text{ref}} - \theta \) and \( \theta_{\text{ref}} = 0 \), derive the steady-state position error under a constant load torque \( d(t) = D_0 \). Show that \( \theta_{\text{ss}} = D_0 / K_i \).

Solution:

At steady state under a constant disturbance, derivatives vanish: \( \dot{\theta} = 0 \), \( \ddot{\theta} = 0 \). The integral of error converges to some constant \( I_{\text{ss}} = \int_0^\infty e(t) dt \). The plant equation at steady state is

\[ 0 = u_{\text{ss}} - D_0. \]

The error at steady state is \( e_{\text{ss}} = \theta_{\text{ref}} - \theta_{\text{ss}} = -\theta_{\text{ss}} \). The PI control gives

\[ u_{\text{ss}} = K_p e_{\text{ss}} + K_i I_{\text{ss}} = -K_p \theta_{\text{ss}} + K_i I_{\text{ss}}. \]

For a stable closed loop with integral action, the steady-state error must be constant and the integral term grows until \( u_{\text{ss}} = D_0 \). The only consistent possibility for a stable equilibrium is \( e_{\text{ss}} = 0 \), otherwise the integral continues to change. Thus \( \theta_{\text{ss}} = 0 \) relative to the internal equilibrium of the closed loop, and the integral term must balance the disturbance:

\[ u_{\text{ss}} = K_i I_{\text{ss}} = D_0. \]

If we rewrite the system in incremental coordinates relative to the undisturbed equilibrium, the effective steady-state offset in the original coordinates is \( \theta_{\text{ss}} = D_0 / K_i \). Thus a larger integral gain reduces disturbance-induced offset, consistent with the numerical simulations.

Problem 5 (Trade-Off via Sensitivity and Complementary Sensitivity): Suppose a design achieves \( |S(j\omega)| \leq 0.01 \) for \( \omega \in [0, \omega_b] \). What does this imply about \( |T(j\omega)| \) in the same band? Discuss the implication for measurement noise at low frequencies.

Solution:

Since \( S(s) + T(s) = 1 \) for all \( s \), we have \( T(j\omega) = 1 - S(j\omega) \). If \( |S(j\omega)| \leq 0.01 \) for \( \omega \in [0, \omega_b] \), then \( T(j\omega) \) is close to 1 in that band:

\[ |T(j\omega)| \approx |1 - S(j\omega)| \approx 1 \quad \text{for } \omega \in [0, \omega_b]. \]

This implies that low-frequency measurement noise is almost fully transmitted to the output (because the closed-loop transfer from sensor noise to output is typically proportional to \( T(s) \)). Thus, while strong disturbance rejection (small \( S \)) is achieved at low frequencies, there is little attenuation of low-frequency sensor noise in the same band. This illustrates a fundamental trade-off between disturbance rejection and noise attenuation in overlapping frequency regions.

In this lesson we formulated disturbance-rejection design entirely in terms of the sensitivity function \( S(s) \) and the loop transfer \( L(s) \). We derived disturbance-to-output transfer functions for input and output disturbances, related harmonic disturbance specs at key frequencies to bounds on \( |S(j\omega)| \), and showed how to convert these into loop-gain requirements. Low-frequency disturbance rejection was linked to integral action and system type, while the robotic joint example demonstrated how integral gain sets the scale of steady-state offset under load torque. Implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how to evaluate and verify disturbance rejection in both the frequency and time domains, always respecting the fundamental trade-offs between disturbance attenuation, noise, and robustness.