Consider a standard single-input single-output (SISO) unity-feedback loop with controller \( C(s) \), plant \( P(s) \), and loop transfer function \( L(s) = C(s)P(s) \). We assume negative feedback.

The sensitivity function is defined as

\[ S(s) \equiv \frac{1}{1 + L(s)}. \]

Intuitively, \( S(s) \) measures how strongly closed-loop behavior (error, output, response to disturbances) reacts to imperfections: disturbances, modelling errors, parameter variations, and reference changes. Small \( \lvert S(j\omega) \rvert \) at a frequency \( \omega \) means the closed loop is insensitive at that frequency.

flowchart TD
  R["Reference r"] --> SUMe["e = r - y"]
  Y["Output y"] --> SUMe
  SUMe --> C["Controller C(s)"]
  C --> U["Control input u"]
  D["Disturbance d"] --> SUMd["Add at plant input"]
  U --> SUMd
  SUMd --> P["Plant P(s)"]
  P --> Y
  Y --> OUT["Measured output"]
  L["Loop L(s) = C(s)P(s)"] --- P
  Sblk["'Sensitivity S(s) = 1/(1+L(s))'"] --- OUT
        

In robotic servo systems (e.g., a joint driven by a motor), disturbances correspond to external torques or forces, friction changes, or supply voltage variations. Designing a loop gain \( L(s) \) that makes \( S(s) \) small at low frequencies is crucial for accurate regulation under such disturbances.

We start from the basic equations of a unity-feedback loop without disturbances. Let \( R(s) \) be the reference, \( Y(s) \) the output, \( E(s) \) the error, and \( U(s) \) the control input:

\[ \begin{aligned} E(s) &= R(s) - Y(s), \\ U(s) &= C(s) E(s), \\ Y(s) &= P(s) U(s). \end{aligned} \]

Eliminating \( E(s) \) and \( U(s) \), we obtain

\[ Y(s) = P(s) C(s) \big(R(s) - Y(s)\big) = L(s)\big(R(s) - Y(s)\big), \quad L(s) = C(s)P(s). \]

Rearranging terms:

\[ \big(1 + L(s)\big) Y(s) = L(s) R(s) \quad \Longrightarrow \quad \frac{Y(s)}{R(s)} = \frac{L(s)}{1 + L(s)}. \]

The error signal is

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

Therefore,

\[ \frac{E(s)}{R(s)} = \frac{1}{1 + L(s)} \equiv S(s). \]

So \( S(s) \) is exactly the transfer function from reference \( R(s) \) to tracking error \( E(s) \). This connects sensitivity directly to steady-state error concepts studied earlier.

Now we include disturbances. There are several standard disturbance locations; here we focus on two in a unity-feedback loop:

1. Disturbance added at the plant input (e.g., load torque).
2. Disturbance added at the plant output (e.g., external force on the output).

3.1 Disturbance at Plant Input

Let \( D_u(s) \) be an additive disturbance at the plant input. The plant input becomes \( U(s) + D_u(s) \), and the plant output is

\[ Y(s) = P(s)\big(U(s) + D_u(s)\big) = P(s) C(s) E(s) + P(s) D_u(s). \]

Using \( E(s) = R(s) - Y(s) \), we obtain

\[ Y(s) = L(s)\big(R(s) - Y(s)\big) + P(s) D_u(s), \]

which rearranges to

\[ \big(1 + L(s)\big) Y(s) = L(s) R(s) + P(s) D_u(s). \]

Thus the disturbance-to-output transfer function is

\[ \frac{Y(s)}{D_u(s)} = \frac{P(s)}{1 + L(s)} = P(s) S(s). \]

In regulation (set-point held at zero, \( R(s) = 0 \)), the closed-loop response to disturbances at the plant input is fully determined by \( P(s) S(s) \).

3.2 Disturbance at Plant Output

Now let \( D_y(s) \) be an additive disturbance at the plant output:

\[ \tilde{Y}(s) = P(s) U(s) + D_y(s), \]

and assume the sensor directly measures \( \tilde{Y}(s) \), so we write \( Y(s) = \tilde{Y}(s) \) for the output. Then

\[ E(s) = R(s) - Y(s) = R(s) - \big(P(s) C(s) E(s) + D_y(s)\big). \]

Solving for \( E(s) \):

\[ \big(1 + L(s)\big) E(s) = R(s) - D_y(s) \quad \Longrightarrow \quad E(s) = \frac{R(s) - D_y(s)}{1 + L(s)}. \]

Using \( Y(s) = P(s) C(s) E(s) + D_y(s) = L(s) E(s) + D_y(s) \), we obtain after substitution

\[ Y(s) = \frac{L(s)}{1 + L(s)} R(s) + \frac{1}{1 + L(s)} D_y(s) = T(s) R(s) + S(s) D_y(s), \]

where \( T(s) = \frac{L(s)}{1 + L(s)} \) is the complementary sensitivity (studied in the next lesson). For disturbance rejection, the important relation is

\[ \frac{Y(s)}{D_y(s)} = S(s). \]

Thus, for output disturbances, \( S(s) \) itself is the disturbance-to-output transfer function.

In robotic positioning, \( D_y(s) \) could represent an external force pushing on the end-effector; making \( \lvert S(j\omega) \rvert \) small at low frequencies ensures effective rejection of such slow disturbances.

Evaluating \( S(s) \) on the imaginary axis \( s = j\omega \) gives \( S(j\omega) = 1/\big(1 + L(j\omega)\big) \). The Bode magnitude of \( S \) encodes disturbance rejection and tracking performance.

4.1 Approximation for Large Loop Gain

When the loop gain is large, \( \lvert L(j\omega) \rvert \gg 1 \), we have

\[ S(j\omega) = \frac{1}{1 + L(j\omega)} \approx \frac{1}{L(j\omega)}. \]

Therefore,

\[ \lvert S(j\omega) \rvert \approx \frac{1}{\lvert L(j\omega) \rvert}, \quad 20 \log_{10} \lvert S(j\omega) \rvert \approx - 20 \log_{10} \lvert L(j\omega) \rvert. \]

High loop gain at low frequency implies small \( \lvert S(j\omega) \rvert \) and hence strong disturbance rejection and small tracking error in that frequency band.

4.2 DC Sensitivity and Steady-State Error

For a step reference input \( r(t) = 1(t) \), we have \( R(s) = 1/s \) and \( E(s) = S(s) R(s) \). By the final-value theorem:

\[ e_{\mathrm{ss}} = \lim_{t \to \infty} e(t) = \lim_{s \to 0} s E(s) = \lim_{s \to 0} s S(s) \frac{1}{s} = S(0). \]

Thus the steady-state error to a unit step is exactly \( S(0) \). This unifies the earlier concept of static error constants with the sensitivity function.

For a constant disturbance at the plant output with transfer \( Y(s)/D_y(s) = S(s) \), the steady-state output deviation is proportional to \( S(0) \) as well. In many regulation tasks, one aims for \( S(0) \approx 0 \) (integrator in the loop) so that constant disturbances are fully rejected.

Another interpretation of \( S(s) \) comes from small-perturbation analysis. Suppose the plant is uncertain and can be written as a nominal model \( P(s) \) times a multiplicative perturbation:

\[ \tilde{P}(s) = P(s) \big(1 + \Delta(s)\big), \quad \lvert \Delta(s) \rvert \ll 1. \]

The loop transfer function becomes \( \tilde{L}(s) = C(s)\tilde{P}(s) = L(s)\big(1 + \Delta(s)\big) \). Let \( T(s) = \frac{L(s)}{1 + L(s)} \) denote the nominal closed-loop transfer from reference to output.

View \( T \) as a function of \( L \):

\[ T(L) = \frac{L}{1 + L}. \]

Its derivative with respect to \( L \) is

\[ \frac{\partial T}{\partial L} = \frac{(1 + L) - L}{(1 + L)^2} = \frac{1}{\big(1 + L\big)^2} = S^2. \]

For small perturbations, we have the first-order variation

\[ \delta T(s) \approx \frac{\partial T}{\partial L} \, \delta L(s) = S(s)^2 \, L(s) \Delta(s) = S(s) T(s) \Delta(s). \]

Dividing by \( T(s) \), the relative change in closed-loop transfer is approximately

\[ \frac{\delta T(s)}{T(s)} \approx S(s) \Delta(s). \]

In other words, \( S(s) \) is the factor that scales multiplicative plant uncertainty into relative closed-loop uncertainty. To keep the closed loop robust against model errors at frequency \( \omega \), we must keep \( \lvert S(j\omega) \rvert \) small wherever \( \lvert \Delta(j\omega) \rvert \) may be significant.

In classical loop shaping, one typically specifies target bounds for \( \lvert S(j\omega) \rvert \) in frequency ranges of interest:

• Low frequencies, where references and disturbances are concentrated, require \( \lvert S(j\omega) \rvert \) as small as feasible.
• Higher frequencies, where model uncertainty and measurement noise dominate, cannot tolerate arbitrarily small sensitivity (this trade-off is studied in later lessons).

A simple design flow is illustrated below.

flowchart TD
  A["Start: specify reference & disturbance spectra"] --> B["Choose target bandwidth (omega_b)"]
  B --> C["Set low-frequency goal: |S(jw)| <= S_max for w <= omega_b"]
  C --> D["Shape loop L(s) = C(s)P(s) using integrators and gain"]
  D --> E["Compute S(s) = 1/(1+L(s))"]
  E --> F["Check Bode magnitude of S(jw) vs goals"]
  F --> G["Iterate controller design until constraints met"]
        

For a robot joint servo, disturbances (load torques, gravity terms) are typically slow. We therefore push the closed-loop bandwidth high enough so that \( \lvert S(j\omega) \rvert \) is small throughout the disturbance frequency range, but not so high as to violate actuator limits or excite unmodelled flexible dynamics.

We model a simplified DC-motor-driven robotic joint as a first-order plant \( P(s) = \frac{K}{Js + B} \), where \( J \) is the reflected inertia and \( B \) is viscous friction. The controller is a PI controller \( C(s) = K_p + \frac{K_i}{s} \). We compute \( S(s) \), the disturbance transfer \( P(s)S(s) \), and visualize their frequency responses.

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

# Simple DC-motor-like joint model: P(s) = K / (J s + B)
J = 0.01    # kg m^2
B = 0.1     # N m s/rad
K = 1.0     # gain (N m per unit control)
P = ctrl.tf([K], [J, B])

# PI controller: C(s) = Kp + Ki/s
Kp = 5.0
Ki = 10.0
C = ctrl.tf([Kp, Ki], [1, 0])  # (Kp s + Ki) / s

L = C * P               # loop transfer
S = ctrl.feedback(1, L) # S(s) = 1 / (1 + L(s))
Gd = P * S              # disturbance -> output at plant input

# Frequency grid
w = np.logspace(-1, 3, 500)

magS, phaseS, wS = ctrl.bode(S, w, Plot=False)
magGd, phaseGd, wGd = ctrl.bode(Gd, w, Plot=False)

plt.figure()
plt.semilogx(wS, 20 * np.log10(magS))
plt.xlabel("Frequency [rad/s]")
plt.ylabel("|S(jw)| [dB]")

plt.figure()
plt.semilogx(wGd, 20 * np.log10(magGd))
plt.xlabel("Frequency [rad/s]")
plt.ylabel("|P(jw) S(jw)| [dB]  (disturbance -> output)")
plt.show()

# Time-domain disturbance step response (R(s) = 0, Du(s) = 1/s)
t = np.linspace(0, 5, 1000)
t_out, y_out = ctrl.step_response(Gd, T=t)
plt.figure()
plt.plot(t_out, y_out)
plt.xlabel("Time [s]")
plt.ylabel("Output y(t) due to unit disturbance")
plt.grid(True)
plt.show()
      

In a robotics context, such code can be integrated with higher-level frameworks (e.g., ROS) for off-line controller design, then deployed with the same \( C(s) \) parameters to embedded hardware.

The following C++ example uses the standard <complex> library to sample the magnitude of \( S(j\omega) \) for a simple plant \( P(s) = \frac{1}{s + 1} \) and proportional controller \( C(s) = K \). Such computations can be embedded into a robotics control node (e.g., in ROS) to verify disturbance rejection properties offline.

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

int main() {
    using std::complex;
    using std::cout;
    using std::endl;

    double K = 10.0;               // proportional gain
    complex<double> j(0.0, 1.0);   // imaginary unit

    // logarithmic frequency grid
    std::vector<double> w;
    for (int k = 0; k <= 40; ++k) {
        double wk = std::pow(10.0, -1.0 + 0.1 * k); // 10^(-1) ... 10^3
        w.push_back(wk);
    }

    for (double wk : w) {
        complex<double> s = j * wk;
        complex<double> P = 1.0 / (s + 1.0);   // P(s) = 1 / (s + 1)
        complex<double> C = K;                 // C(s) = K
        complex<double> L = C * P;             // loop transfer
        complex<double> S = 1.0 / (1.0 + L);   // sensitivity

        double magS = std::abs(S);
        double magS_dB = 20.0 * std::log10(magS);

        cout << "w = " << wk
             << ", |S(jw)| = " << magS
             << " (" << magS_dB << " dB)" << endl;
    }

    return 0;
}
      

In a robotic joint controller, the plant P could be replaced by a more detailed model (including motor constants and gear ratios), while K could be tuned iteratively to meet a target bound on \( \lvert S(j\omega) \rvert \) in the disturbance frequency range.

The next example uses Java with the Apache Commons Math Complex class to compute \( \lvert S(j\omega) \rvert \) for a PI-controlled first-order plant, which could represent a velocity controller in a mobile robot or actuator.

import org.apache.commons.math3.complex.Complex;

public class SensitivityPiExample {
    public static void main(String[] args) {
        double Kp = 5.0;
        double Ki = 10.0;
        double J  = 0.01;
        double B  = 0.1;

        Complex j = new Complex(0.0, 1.0);

        for (int k = 0; k <= 40; ++k) {
            double w = Math.pow(10.0, -1.0 + 0.1 * k); // 10^(-1) ... 10^3
            Complex s = j.multiply(w);

            // Plant P(s) = 1 / (J s + B)
            Complex P = new Complex(1.0, 0.0).divide(
                s.multiply(J).add(B)
            );

            // PI controller C(s) = Kp + Ki/s
            Complex C = new Complex(Kp, 0.0).add(
                new Complex(Ki, 0.0).divide(s)
            );

            Complex L = C.multiply(P);
            Complex S = new Complex(1.0, 0.0).divide(
                new Complex(1.0, 0.0).add(L)
            );

            double magS = S.abs();
            double magSdB = 20.0 * Math.log10(magS);

            System.out.printf("w = %.4f, |S(jw)| = %.4f (%.2f dB)%n",
                              w, magS, magSdB);
        }
    }
}
      

Such Java-based analysis is useful when control algorithms are deployed in JVM-based robotic platforms or when using Java interfaces to simulation environments.

10.1 MATLAB/Simulink (Control System Toolbox and Robotics-Related Use)

In MATLAB, we can work with transfer functions using the Control System Toolbox. For a robotic joint plant \( P(s) = \frac{K}{Js + B} \) and PI controller, we compute \( S(s) \) and the disturbance map \( P(s)S(s) \) and visualize them. These models can be connected to Simulink diagrams for time-domain simulation of robot joints with disturbance torques.

% Parameters for a DC-motor-driven joint
J = 0.01;  % inertia
B = 0.1;   % viscous friction
K = 1.0;   % motor gain

s = tf('s');
P = K / (J*s + B);

Kp = 5.0;
Ki = 10.0;
C = Kp + Ki/s;           % PI controller

L = C*P;
S = feedback(1, L);      % S(s) = 1 / (1 + L)
Gd = P*S;                % disturbance at plant input -> output

figure;
bodemag(S);
grid on;
title('Sensitivity S(s)');

figure;
bodemag(Gd);
grid on;
title('Disturbance-to-output P(s) S(s)');

% Time-domain disturbance rejection: step disturbance at plant input
t = 0:0.001:5;
[y_d, t_d] = step(Gd, t);
figure;
plot(t_d, y_d);
xlabel('Time [s]');
ylabel('Output y(t) due to unit disturbance');
grid on;

% For Simulink:
% - Use Transfer Fcn blocks for P(s) and C(s),
% - connect them in a feedback loop,
% - inject a Step block as an additive disturbance at the plant input,
% - log the output to compare with the MATLAB response above.
      

10.2 Wolfram Mathematica

In Wolfram Mathematica, we can use transfer function models and frequency-response plotting to analyze \( S(s) \).

(* Define Laplace variable and plant/controller *)
s = ComplexExpand[I*ω] /. ω -> s; (* symbolic s *)

J = 0.01; B = 0.1; K = 1.0;
Kp = 5.0; Ki = 10.0;

P[s_] := K/(J*s + B);
C[s_] := Kp + Ki/s;
L[s_] := C[s]*P[s];
S[s_] := 1/(1 + L[s]);
Gd[s_] := P[s]*S[s];

(* TransferFunctionModel representation *)
sysS  = TransferFunctionModel[S[s], s];
sysGd = TransferFunctionModel[Gd[s], s];

(* Bode magnitude of S and P*S *)
freqRange = {0.1, 100};
FrequencyResponsePlot[
  {sysS, sysGd},
  freqRange,
  PlotLayout -> "Magnitude",
  PlotLegends -> {"S(jw)", "P(jw) S(jw)"},
  GridLines -> Automatic
]

(* Time response to unit disturbance step (plant input) *)
sysGdTime = StateSpaceModel[sysGd];
stepResp = OutputResponse[sysGdTime, UnitStep[t], {t, 0, 5}];
Plot[Evaluate[stepResp], {t, 0, 5},
     AxesLabel -> {"t", "y(t)"},
     PlotLabel -> "Output due to unit disturbance"]
      

These symbolic and numeric tools make it straightforward to explore how different controller designs reshape \( S(s) \) and improve disturbance rejection for robotic actuators and mechanisms.

Problem 1 (Deriving Disturbance Transfer Function): Consider a unity-feedback system with plant \( P(s) \) and controller \( C(s) \). An additive disturbance \( D_u(s) \) is injected at the plant input (as in Section 3.1). Derive the transfer function from \( D_u(s) \) to output \( Y(s) \) in terms of \( P(s) \) and \( S(s) \).

Solution:

We have \( Y(s) = P(s)\big(U(s) + D_u(s)\big) = P(s) C(s) E(s) + P(s) D_u(s) \) and \( E(s) = R(s) - Y(s) \). Substituting:

\[ Y(s) = L(s)\big(R(s) - Y(s)\big) + P(s) D_u(s), \]

so

\[ \big(1 + L(s)\big) Y(s) = L(s) R(s) + P(s) D_u(s). \]

Setting \( R(s) = 0 \) for pure regulation,

\[ Y(s) = \frac{P(s)}{1 + L(s)} D_u(s) = P(s) S(s) D_u(s). \]

Hence \( Y(s)/D_u(s) = P(s) S(s) \).

Problem 2 (Steady-State Effect of a Constant Disturbance): For the plant \( P(s) = \frac{1}{s + 1} \) and a proportional controller \( C(s) = K \), consider a unit step disturbance at the plant input with \( R(s) = 0 \). Compute the steady-state output \( y_{\mathrm{ss}} \) as a function of \( K \).

Solution:

The loop transfer is \( L(s) = K/(s + 1) \). The disturbance-to-output transfer function is

\[ G_{dy}(s) = \frac{Y(s)}{D_u(s)} = \frac{P(s)}{1 + L(s)} = \frac{1}{s + 1 + K}. \]

For a unit step disturbance \( d_u(t) = 1(t) \), we have \( D_u(s) = 1/s \), so \( Y(s) = G_{dy}(s) D_u(s) = \frac{1}{(s + 1 + K)s} \). By the final-value theorem:

\[ y_{\mathrm{ss}} = \lim_{t \to \infty} y(t) = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} \frac{1}{s + 1 + K} = \frac{1}{1 + K}. \]

As \( K \) increases, \( y_{\mathrm{ss}} \) decreases and tends to zero, illustrating how increasing loop gain improves disturbance rejection at DC, but at the cost of potential degradation elsewhere (topic of later lessons).

Problem 3 (PI Control and Disturbance Rejection): For the same plant \( P(s) = \frac{1}{s + 1} \), use a PI controller \( C(s) = K_p + \frac{K_i}{s} \) with \( K_p > 0 \) and \( K_i > 0 \). Consider a unit step disturbance at the plant input with \( R(s) = 0 \). Show that the steady-state output is zero (assuming stability).

Solution:

The loop transfer function is \( L(s) = C(s) P(s) = \frac{K_p s + K_i}{s(s + 1)} \). Then

\[ S(s) = \frac{1}{1 + L(s)} = \frac{s(s + 1)}{s(s + 1) + K_p s + K_i}. \]

The disturbance-to-output transfer function is

\[ G_{dy}(s) = P(s) S(s) = \frac{1}{s + 1} \cdot \frac{s(s + 1)}{s(s + 1) + K_p s + K_i} = \frac{s}{s(s + 1) + K_p s + K_i}. \]

For a unit step disturbance, \( D_u(s) = 1/s \), so \( Y(s) = G_{dy}(s) D_u(s) = 1/[s(s + 1) + K_p s + K_i] \). Applying the final-value theorem:

\[ y_{\mathrm{ss}} = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} \frac{s}{s(s + 1) + K_p s + K_i} = \frac{0}{K_i} = 0. \]

Hence the PI controller achieves perfect rejection of a constant disturbance at the plant input (and, similarly, zero steady-state error to a step reference), provided the closed loop is stable.

Problem 4 (Frequency-Domain Disturbance Rejection Spec): For a unity-feedback system with loop transfer \( L(j\omega) \), suppose we require that for all \( \omega \) in a given low-frequency band the response to a unit output disturbance satisfies \( \lvert Y(j\omega)/D_y(j\omega) \rvert \leq 0.1 \). Assuming \( L(j\omega) \) is real and positive in that band, derive a condition on \( L(j\omega) \).

Solution:

For an output disturbance, we have \( Y(s)/D_y(s) = S(s) = 1/(1 + L(s)) \), so the requirement reads

\[ \left\lvert \frac{1}{1 + L(j\omega)} \right\rvert \leq 0.1. \]

If \( L(j\omega) \) is real and nonnegative, then \( \lvert 1 + L(j\omega) \rvert = 1 + L(j\omega) \). The condition becomes

\[ 1 + L(j\omega) \geq 10 \quad \Longrightarrow \quad L(j\omega) \geq 9 \]

in that frequency band. Thus, a loop gain of at least 9 (about \( 19.1 \) dB) is required under this simplified real and positive assumption.

In this lesson we introduced the sensitivity function \( S(s) = 1/(1 + L(s)) \) and showed that it is the transfer function from reference to error \( E(s)/R(s) \), from output disturbances \( D_y(s) \) to output, and (together with the plant) from input disturbances \( D_u(s) \) to output. We connected \( S(0) \) to steady-state error, interpreted \( \lvert S(j\omega) \rvert \) as a key design target in loop shaping, and showed that \( \delta T/T \approx S \Delta \) for multiplicative plant perturbations. Practical implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how to compute and analyze \( S(s) \) for simple robotic servo models. In the next lesson we will introduce the complementary sensitivity \( T(s) \) and study its interplay with \( S(s) \) and fundamental trade-offs.