We consider a standard single-input single-output (SISO) linear time-invariant (LTI) feedback loop with plant transfer function \( G(s) \) and controller transfer function \( C(s) \). The main signals are:

• \( r(t) \): reference (command or set-point),
• \( y(t) \): measured output,
• \( u(t) \): control input to the plant,
• \( d(t) \): disturbance affecting the plant output (load disturbance),
• \( e(t) = r(t) - y(t) \): tracking error.

In the Laplace domain, for zero initial conditions, we denote \( R(s), Y(s), U(s), D(s), E(s) \) as the transforms of \( r, y, u, d, e \). The unity-feedback interconnection is

\[ E(s) = R(s) - Y(s), \qquad U(s) = C(s)E(s), \qquad Y(s) = G(s)U(s) + D(s). \]

Eliminating \( U(s) \) and \( E(s) \) yields

\[ Y(s)\bigl(1 + C(s)G(s)\bigr) = C(s)G(s)R(s) + D(s). \]

Define the loop transfer function \( L(s) = C(s)G(s) \). Then

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

This decomposition exposes two central closed-loop transfer functions, previously introduced in Chapter 22:

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

Thus

\[ Y(s) = T(s)R(s) + S(s)D(s), \qquad E(s) = R(s) - Y(s) = S(s)\bigl(R(s) - D(s)\bigr). \]

The identity \( S(s) + T(s) = 1 \) holds for all \( s \) where \( 1+L(s) \neq 0 \). This simple algebraic relation is the source of fundamental trade-offs: we cannot make both \( S \) and \( T \) small at the same frequencies.

flowchart TD
  R["Reference r(t)"] --> SUM["Error e(t) = r(t) - y(t)"]
  Y["Output y(t)"] --> SUM
  SUM --> C["Controller C(s)"]
  C --> U["Actuator signal u(t)"]
  U --> G["Plant G(s)"]
  D["Disturbance d(t)"] --> ADD["Add at plant output"]
  G --> ADD
  ADD --> Y
        

We now distinguish two prototypical control tasks for the same feedback loop.

2.1 Reference Tracking (Servo Problem)

In tracking, the goal is to make the output follow a possibly time-varying reference \( r(t) \) despite disturbances. Typical examples in robotics and mechatronics include:

• Robot joint position following a trajectory.
• Vehicle speed following a commanded profile.
• Motor shaft angle tracking a reference step or ramp.

Mathematically, for given reference \( r(t) \) we want

\[ e(t) = r(t) - y(t) \quad \text{small in an appropriate sense} \]

where “small” can mean:

• Small peak error: \( \sup_{t \ge 0} |e(t)| \) is bounded by a prescribed value.
• Small energy: \( \int_0^{\infty} e^2(t)\,dt \) is small.
• Small steady-state error: \( \lim_{t \to \infty} e(t) \) is zero or within a small band.

For step tracking with \( r(t) = r_0 u(t) \) and \( d(t) = 0 \), the final value theorem (from Chapter 5) gives

\[ \lim_{t \to \infty} y(t) = \lim_{s \to 0} sY(s) = \lim_{s \to 0} s T(s)\frac{r_0}{s} = r_0 T(0). \]

Hence zero steady-state tracking error for step inputs requires \( T(0) = 1 \), equivalently \( S(0) = 0 \).

2.2 Regulation (Disturbance Rejection Problem)

In regulation, the reference is typically constant, often \( r(t) \equiv 0 \) or a fixed operating point, and the objective is to keep \( y(t) \) close to this value in the presence of disturbances \( d(t) \). Examples:

• Force regulation at a robot end-effector in contact with an environment.
• Voltage regulation in a power converter.
• Temperature regulation around a fixed set-point despite heat load changes.

For regulation with \( r(t) \equiv 0 \) and a disturbance \( d(t) \), we require

\[ y(t) \approx 0 \quad \text{(or a fixed operating value)}. \]

For a step load disturbance \( d(t) = d_0 u(t) \), with \( R(s)=0 \), we have

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

The steady-state output is

\[ \lim_{t \to \infty} y(t) = \lim_{s \to 0} sY(s) = \lim_{s \to 0} s S(s)\frac{d_0}{s} = d_0 S(0). \]

Thus zero steady-state regulation error against step load disturbances again requires \( S(0) = 0 \). This links tracking and regulation requirements at low frequency, but their transient and frequency-selective requirements may differ substantially.

In previous chapters we introduced classical time-domain metrics for step responses of stable systems: rise time, overshoot, settling time, and steady-state error. We now organize these metrics according to tracking vs regulation objectives.

3.1 Tracking-Oriented Metrics

For a step reference \( r(t) = r_0 u(t) \) with \( d(t)=0 \):

• Normalized overshoot

  \[ M_p = \frac{\max_{t \ge 0} y(t) - r_0}{r_0}. \]

• Rise time \( t_r \): time to go from, e.g., 10% to 90% of \( r_0 \).
• Settling time \( t_s \): time after which \( |y(t) - r_0| \) remains within a specified band, e.g. 2% of \( r_0 \).
• Integral error measures, such as

  \[ J_{\text{ITAE}} = \int_0^{\infty} t\,|e(t)|\,dt, \qquad J_{\text{ISE}} = \int_0^{\infty} e^2(t)\,dt. \]

3.2 Regulation-Oriented Metrics

For a disturbance \( d(t) \) and constant reference \( r(t) \equiv r_0 \) (often \( r_0 = 0 \)):

• Disturbance rejection ratio

  \[ \text{DRR} = \frac{\sup_{t \ge 0} |y_{\text{open}}(t)|} {\sup_{t \ge 0} |y_{\text{closed}}(t)|}, \]

  where \( y_{\text{open}} \) and \( y_{\text{closed}} \) are the outputs with and without feedback.
• Settling time after disturbance: time for \( y(t) \) to return to a specified band.
• Variance of output under stochastic disturbances (e.g. white noise) over long time.

In design, we typically translate informal performance statements such as “good tracking with little overshoot but strong rejection of low-frequency disturbances” into quantitative inequalities on these indices and on the frequency-domain functions \( S(s) \) and \( T(s) \).

Using the sensitivity functions from Chapter 22, we interpret tracking and regulation objectives in the frequency domain. Let \( \omega \in \mathbb{R} \) and \( s = j\omega \) with \( j^2 = -1 \). For a sinusoidal reference \( r(t) = \Re\{ \hat{r} e^{j\omega t} \} \) and disturbance \( d(t) = \Re\{ \hat{d} e^{j\omega t} \} \), linearity gives

\[ \hat{y}(\omega) = T(j\omega)\hat{r}(\omega) + S(j\omega)\hat{d}(\omega). \]

4.1 Tracking in Frequency Domain

For tracking, we want \( y(t) \) to follow \( r(t) \). For low-frequency references (slowly varying commands), this requires

\[ |T(j\omega)| \approx 1 \quad \text{and} \quad \angle T(j\omega) \approx 0 \quad \text{for } |\omega| \text{ in a low-frequency band}. \]

Equivalently, since \( S(j\omega) + T(j\omega) = 1 \),

\[ |S(j\omega)| \approx 0 \quad \text{for tracking-relevant frequencies}. \]

4.2 Regulation in Frequency Domain

Suppose disturbances \( d(t) \) have most of their spectral energy in a band \( \Omega_d \subset \mathbb{R} \). For example, low-frequency torque disturbances in a robot joint or slowly varying load torques in a motor. Then from \( \hat{y}(\omega) = S(j\omega)\hat{d}(\omega) \), effective regulation requires

\[ |S(j\omega)| \ll 1 \quad \text{for } \omega \in \Omega_d. \]

For measurement noise entering at the sensor, the relevant transfer function from noise \( n(t) \) to output is often close to \( T(s) \), so noise attenuation demands

\[ |T(j\omega)| \ll 1 \quad \text{for noise-dominated high frequencies}. \]

Therefore:

• Low-frequency tracking and disturbance rejection: make \( |S(j\omega)| \) small.
• High-frequency noise attenuation: make \( |T(j\omega)| \) small.

Because \( S + T = 1 \), we cannot make both small at all frequencies. This is the frequency-domain manifestation of the fundamental trade-off between fast tracking, strong disturbance rejection, and noise attenuation.

The identity \( S(s) + T(s) = 1 \) implies that improving tracking (making \( T \) close to 1) inevitably affects regulation and noise behavior (through \( S \) and \( T \) at other frequencies).

5.1 Low-Frequency Integral Action

Previous chapters showed that including an integrator in \( C(s) \) can enforce \( S(0) = 0 \) for appropriate system types, ensuring zero steady-state error for step references and step disturbances. For instance, for a Type 1 system with \( L(s) = \frac{k}{s}\tilde{L}(s) \) and \( \tilde{L}(0) \neq 0 \),

\[ S(s) = \frac{1}{1+L(s)} = \frac{1}{1 + \frac{k}{s}\tilde{L}(s)}. \]

As \( s \to 0 \), the term \( \frac{k}{s}\tilde{L}(s) \) dominates and \( S(s) \to 0 \), so \( T(0) = 1 \). Thus a single integrator helps both tracking and regulation at low frequencies but may degrade robustness (reduced phase margin) if not carefully tuned.

5.2 The “Waterbed” Effect Revisited

In Chapter 22 we discussed the “waterbed effect”: reducing \( |S(j\omega)| \) in some frequency ranges tends to increase it elsewhere, under mild assumptions on \( L(s) \) (e.g. minimum-phase, stable). For tracking vs regulation:

• Aggressive bandwidth increase improves tracking of higher-frequency references but may amplify measurement noise and reduce robustness.
• Strong low-frequency disturbance rejection usually implies high loop gain at low frequencies, which can cause actuator saturation or slow recovery from large disturbances.

Choosing control objectives thus means specifying acceptable compromises: e.g., prioritize low-frequency disturbance rejection over very fast tracking, or vice versa, depending on the robotic or mechatronic task.

flowchart TD
  START["Specify task: tracking, regulation, or mixed?"] --> OBJ["Quantify specs: rise time, overshoot, steady-state error, disturbance band"]
  OBJ --> BAND["Select desired bandwidth"]
  BAND --> LF["Low freq: make |S(jw)| small \n(tracking & regulation)"]
  BAND --> HF["High freq: keep |T(jw)| small \n(noise, robustness)"]
  LF --> TRADE["Adjust controller C(s) until trade-offs acceptable"]
  HF --> TRADE
  TRADE --> ITER["Iterate via analysis & simulation"]
        

In robotics and motion control, the same mathematical structures appear in slightly different physical roles:

• Servo (tracking) loops: joint position or velocity control, end-effector trajectory tracking, camera pan-tilt control.
• Regulator loops: force/torque control at contact, current or voltage regulation, platform stabilization against disturbances.

In many systems, both objectives coexist: e.g., a robot arm that must track a trajectory while rejecting load torque disturbances and sensor noise. Software frameworks such as python-control and roboticstoolbox-python in Python, ros_control and Orocos in C++, and control-oriented libraries in MATLAB/Simulink (e.g., Control System Toolbox, Simscape) provide tools to analyze these loops using the \( S \) and \( T \) framework developed here.

Consider a first-order plant \( G(s) = \frac{1}{\tau s + 1} \) with \( \tau > 0 \), controlled by a proportional-integral (PI) controller

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

We simulate:

1. Reference tracking: step in \( r(t) \), no disturbance.
2. Regulation: step disturbance at plant output, constant reference.

In Python we can use python-control (widely used in robotics) for convenience. Below is a script illustrating both tasks.

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

# Plant and controller parameters
tau = 0.5
G = ctl.tf([1.0], [tau, 1.0])   # G(s) = 1 / (tau s + 1)
Kp = 4.0
Ki = 5.0
C = ctl.tf([Kp, Ki], [1.0, 0.0])  # Kp + Ki / s

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

# 1) Tracking: step in reference, no disturbance
t = np.linspace(0, 5, 500)
t1, y_track = ctl.step_response(T, T=t)  # y(t) for r(t) = 1

# 2) Regulation: step disturbance at plant output, r(t) = 0
# For output disturbance d(t), transfer from d to y is S(s).
t2, y_reg = ctl.step_response(S, T=t)

plt.figure()
plt.plot(t1, y_track, label="Tracking: y(t) for step r(t)")
plt.plot(t2, y_reg, label="Regulation: y(t) for step d(t)")
plt.axhline(1.0, linestyle="--", label="Reference level r(t) = 1")
plt.axhline(0.0, linestyle=":", label="Regulation target y(t) = 0")
plt.xlabel("Time [s]")
plt.ylabel("Output y(t)")
plt.legend()
plt.grid(True)
plt.title("Tracking vs Regulation on First-Order Plant")
plt.show()
      

In a robotics context, G(s) might represent a simple joint actuator model and C(s) a PI position or velocity loop. Disturbances include unmodeled load torques or friction effects. The same code structure can be integrated into a ROS node using ros_control for real-time deployment.

In embedded robotic controllers written in C++ (e.g., via ros_control), the continuous-time dynamics are implemented in discrete time. We approximate the first-order plant with forward Euler integration:

\[ \dot{x}(t) = -\frac{1}{\tau}x(t) + \frac{1}{\tau}u(t), \qquad y(t) = x(t), \]

and discretize with sampling period \( h > 0 \):

\[ x_{k+1} = x_k + h\Bigl(-\frac{1}{\tau}x_k + \frac{1}{\tau}u_k\Bigr). \]

The PI controller in discrete-time incremental form is

\[ u_k = u_{k-1} + K_p (e_k - e_{k-1}) + K_i h\, e_k. \]

Below is a minimal C++ program (without ROS integration) that simulates both a reference step and an output disturbance step.

#include <iostream>
#include <vector>

int main() {
    double tau = 0.5;
    double Kp  = 4.0;
    double Ki  = 5.0;

    double h   = 0.001;   // sampling period [s]
    double T   = 5.0;     // total simulation time
    int N      = static_cast<int>(T / h);

    std::vector<double> t(N), y_track(N), y_reg(N);

    // Tracking scenario: step in r, no disturbance
    double x = 0.0;
    double u = 0.0;
    double e_prev = 0.0;
    for (int k = 0; k < N; ++k) {
        double tk = k * h;
        t[k] = tk;

        double r = 1.0;    // step reference
        double d = 0.0;    // no disturbance

        double y = x + d;
        double e = r - y;

        // PI control (incremental form)
        double du = Kp * (e - e_prev) + Ki * h * e;
        u += du;
        e_prev = e;

        // Plant integration (forward Euler)
        double dx = (-1.0 / tau) * x + (1.0 / tau) * u;
        x += h * dx;

        y_track[k] = y;
    }

    // Regulation scenario: step disturbance at plant output, r = 0
    x = 0.0;
    u = 0.0;
    e_prev = 0.0;
    for (int k = 0; k < N; ++k) {
        double tk = k * h;
        double r = 0.0;
        double d = (tk >= 1.0) ? 0.5 : 0.0;  // step disturbance at t = 1 s

        double y = x + d;
        double e = r - y;

        double du = Kp * (e - e_prev) + Ki * h * e;
        u += du;
        e_prev = e;

        double dx = (-1.0 / tau) * x + (1.0 / tau) * u;
        x += h * dx;

        y_reg[k] = y;
    }

    // Print a few samples (in practice, log to file or plot offline)
    for (int k = 0; k < N; k += N / 10) {
        std::cout << "t = " << t[k]
                  << ", y_track = " << y_track[k]
                  << ", y_reg = " << y_reg[k]
                  << std::endl;
    }

    return 0;
}
      

In a real robotic application, this code would run inside a high-priority loop on a real-time operating system, with u sent to a motor driver and y obtained from an encoder or sensor via a hardware abstraction layer such as ROS control interfaces.

9.1 Java (Using a Simple Discrete-Time Loop)

In Java-based control software (e.g., for some industrial robots or educational platforms), one can implement the same discrete-time loop as in C++. Linear algebra libraries such as EJML can support more advanced state-space designs, but for this lesson a scalar ODE suffices.

public class TrackingVsRegulationDemo {

    public static void main(String[] args) {
        double tau = 0.5;
        double Kp  = 4.0;
        double Ki  = 5.0;

        double h   = 0.001;
        double T   = 5.0;
        int N      = (int) (T / h);

        double[] t      = new double[N];
        double[] yTrack = new double[N];
        double[] yReg   = new double[N];

        // Tracking scenario
        double x = 0.0;
        double u = 0.0;
        double ePrev = 0.0;

        for (int k = 0; k < N; ++k) {
            double tk = k * h;
            t[k] = tk;

            double r = 1.0;
            double d = 0.0;

            double y = x + d;
            double e = r - y;

            double du = Kp * (e - ePrev) + Ki * h * e;
            u += du;
            ePrev = e;

            double dx = (-1.0 / tau) * x + (1.0 / tau) * u;
            x += h * dx;

            yTrack[k] = y;
        }

        // Regulation scenario
        x = 0.0;
        u = 0.0;
        ePrev = 0.0;

        for (int k = 0; k < N; ++k) {
            double tk = k * h;

            double r = 0.0;
            double d = (tk >= 1.0) ? 0.5 : 0.0;

            double y = x + d;
            double e = r - y;

            double du = Kp * (e - ePrev) + Ki * h * e;
            u += du;
            ePrev = e;

            double dx = (-1.0 / tau) * x + (1.0 / tau) * u;
            x += h * dx;

            yReg[k] = y;
        }

        // Print a few samples
        for (int k = 0; k < N; k += N / 10) {
            System.out.println(String.format(
                "t = %.3f, yTrack = %.3f, yReg = %.3f",
                t[k], yTrack[k], yReg[k]
            ));
        }
    }
}
      

Java control frameworks used in robotics (e.g., educational FRC libraries) embed similar loops but wrap them in higher-level trajectory-tracking interfaces.

9.2 MATLAB/Simulink

MATLAB with Control System Toolbox and Simulink is widely used for motion control design. The commands below construct the same plant and PI controller and compare tracking vs regulation behavior.

tau = 0.5;
G = tf(1, [tau 1]);     % G(s) = 1 / (tau s + 1)

Kp = 4;
Ki = 5;
C  = tf([Kp Ki], [1 0]); % PI controller

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

t = 0:0.01:5;

% 1) Tracking: y for step in r
[y_track, t1] = step(T, t);

% 2) Regulation: y for step in output disturbance
[y_reg, t2] = step(S, t);

figure;
plot(t1, y_track, 'LineWidth', 1.5); hold on;
plot(t2, y_reg, 'LineWidth', 1.5);
yline(1, '--', 'Reference r(t) = 1');
yline(0, ':', 'Regulation target y(t) = 0');
xlabel('Time [s]'); ylabel('Output y(t)');
legend('Tracking (step r)', 'Regulation (step d)', ...
       'Location', 'Best');
grid on;
title('Tracking vs Regulation in MATLAB');
      

A Simulink model can be created with blocks:

• Step block for reference input.
• Sum block computing r - y.
• Transfer Fcn block for C(s) and another for G(s).
• Sum block adding an external disturbance signal to the plant output.
• Scope blocks to visualize tracking and regulation responses.

9.3 Wolfram Mathematica

In Mathematica, the same transfer functions can be represented using built-in control objects. The code below computes step responses for tracking and regulation.

tau = 1/2;
G = TransferFunctionModel[1/{tau s + 1}, s];
Kp = 4;
Ki = 5;
C  = TransferFunctionModel[(Kp s + Ki)/s, s];

L = SeriesConnection[C, G];

S = FeedbackTransferFunction[1, L];  (* S = 1 / (1 + L) *)
T = FeedbackTransferFunction[L, 1];  (* T = L / (1 + L) *)

tmax = 5;
trackingResp   = OutputResponse[T, UnitStep[t], {t, 0, tmax}];
regulationResp = OutputResponse[S, UnitStep[t], {t, 0, tmax}];

Plot[{trackingResp, regulationResp},
     {t, 0, tmax},
     PlotLegends -> {"Tracking y(t) for step r(t)",
                     "Regulation y(t) for step d(t)"},
     AxesLabel -> {"t", "y(t)"},
     GridLines -> Automatic]
      

Such symbolic and numerical tools are useful to analytically compare the influence of \( \tau, K_p, K_i \) on tracking vs regulation performance before implementing controllers on a physical robotic platform.

Problem 1 (Closed-Loop Maps and S, T): Consider the standard SISO unity-feedback loop with plant \( G(s) \), controller \( C(s) \), reference \( r(t) \), and output disturbance \( d(t) \). Derive the closed-loop transfer functions from \( r \) to \( y \) and from \( d \) to \( y \), and prove that \( S(s) + T(s) = 1 \).

Solution:

From Section 1 we have

\[ E(s) = R(s) - Y(s), \quad U(s) = C(s)E(s), \quad Y(s) = G(s)U(s) + D(s). \]

Substitute \( U(s) = C(s)(R(s) - Y(s)) \) into the plant:

\[ Y(s) = G(s)C(s)\bigl(R(s) - Y(s)\bigr) + D(s) = L(s)R(s) - L(s)Y(s) + D(s), \]

where \( L(s) = C(s)G(s) \). Collect terms in \( Y(s) \):

\[ Y(s)\bigl(1 + L(s)\bigr) = L(s)R(s) + D(s). \]

Therefore

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

Define \( T(s) = \frac{L(s)}{1+L(s)} \), \( S(s) = \frac{1}{1+L(s)} \). Then

\[ Y(s) = T(s)R(s) + S(s)D(s). \]

Finally,

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

This proves the decomposition identity central to tracking/regulation trade-offs.

Problem 2 (Steady-State Tracking Error for Step Reference): Assume the closed-loop system is internally stable and that \( T(s) \) is strictly proper. For a unit step reference \( r(t) = u(t) \) and \( d(t) = 0 \), compute the steady-state error \( e_{\infty} = \lim_{t \to \infty} e(t) \) in terms of \( T(0) \).

Solution:

The output is \( Y(s) = T(s) \frac{1}{s} \). Using the final value theorem,

\[ \lim_{t \to \infty} y(t) = \lim_{s \to 0} sY(s) = \lim_{s \to 0} s T(s) \frac{1}{s} = T(0). \]

The steady-state error is

\[ e_{\infty} = \lim_{t \to \infty} (r(t) - y(t)) = 1 - T(0). \]

Hence zero steady-state tracking error occurs iff \( T(0) = 1 \). Using \( S(0) + T(0) = 1 \), this is equivalent to \( S(0) = 0 \).

Problem 3 (Steady-State Regulation Error for Step Disturbance): Assume again that the closed-loop system is internally stable. Let \( r(t) \equiv 0 \) and \( d(t) = d_0 u(t) \) with \( d_0 \neq 0 \). Derive \( \lim_{t \to \infty} y(t) \) in terms of \( S(0) \). Under what condition is perfect regulation achieved for this disturbance?

Solution:

With \( R(s) = 0 \), we have \( Y(s) = S(s)\frac{d_0}{s} \). Therefore,

\[ \lim_{t \to \infty} y(t) = \lim_{s \to 0} sY(s) = \lim_{s \to 0} s S(s)\frac{d_0}{s} = d_0 S(0). \]

Perfect regulation (zero steady-state deviation) requires \( d_0 S(0) = 0 \). For \( d_0 \neq 0 \), this means \( S(0) = 0 \). Thus the same low-frequency condition that guarantees good step tracking also enforces perfect rejection of step load disturbances.

Problem 4 (Trade-Off Between Tracking and Noise Rejection): Suppose measurement noise \( n(t) \) is added at the sensor, so the measured output is \( y_m(t) = y(t) + n(t) \), and the controller uses \( e(t) = r(t) - y_m(t) \). Show that the transfer function from noise \( N(s) \) to output \( Y(s) \) is (under unity feedback) approximately \( -T(s) \), and explain qualitatively how attempting to improve tracking at high frequencies may worsen noise amplification.

Solution:

The block diagram can be algebraically modeled as:

\[ E(s) = R(s) - Y(s) - N(s), \quad U(s) = C(s)E(s), \quad Y(s) = G(s)U(s) + D(s). \]

With \( D(s) = 0 \) for simplicity and \( R(s) = 0 \), we have

\[ E(s) = -Y(s) - N(s), \quad U(s) = C(s)\bigl(-Y(s) - N(s)\bigr), \]

and

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

Thus

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

Therefore, the magnitude of high-frequency noise in the output is proportional to \( |T(j\omega)| \). If we increase bandwidth aggressively to improve tracking of high-frequency references (making \( |T(j\omega)| \) closer to 1 over a larger frequency band), we also increase the amplification of measurement noise in that band. This illustrates the fundamental compromise between fast tracking and noise rejection.

Problem 5 (Integral Action and Low-Frequency Regulation): Consider a plant \( G(s) \) with finite DC gain \( G(0) \) and a controller \( C(s) = \frac{K_i}{s} \). Assume the closed-loop system is internally stable for some range of \( K_i > 0 \). Show that \( S(0) = 0 \) and interpret this result for both tracking and regulation of step signals.

Solution:

With \( C(s) = \frac{K_i}{s} \), the loop transfer function is

\[ L(s) = C(s)G(s) = \frac{K_i}{s}G(s). \]

Since \( G(0) \) is finite and nonzero, we have for small \( s \):

\[ L(s) \approx \frac{K_i G(0)}{s}. \]

Hence

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

Taking the limit as \( s \to 0 \) gives

\[ S(0) = \lim_{s \to 0} \frac{s}{s + K_i G(0)} = 0. \]

Therefore \( T(0) = 1 \). As in Problems 2 and 3, this implies perfect tracking of step references (zero steady-state error) and perfect rejection of step output disturbances (zero steady-state deviation), provided internal stability holds and the signals remain within the linear operating region of the plant. This explains the prominence of integral action in both servo and regulator designs.

In this lesson we rigorously defined reference tracking (servo behavior) and regulation (disturbance rejection) for SISO LTI feedback systems. Starting from the canonical unity-feedback equations, we derived the closed-loop maps in terms of the loop transfer function \( L(s) = C(s)G(s) \) and the sensitivity functions \( S(s) \) and \( T(s) \). We showed how low values of \( |S(j\omega)| \) at low frequencies support both good tracking and strong disturbance rejection, while small \( |T(j\omega)| \) at high frequencies is needed to attenuate sensor noise and unmodeled high-frequency dynamics. The identity \( S + T = 1 \) enforces unavoidable trade-offs between these objectives. Finally, we illustrated the behavior numerically using multi-language implementations suitable for robotic and mechatronic applications.

Subsequent lessons in this chapter will exploit these concepts to design controllers and reference shaping filters that explicitly balance tracking quality and disturbance rejection at key frequencies.