We consider a standard unity-feedback configuration with a plant \( G(s) \), a controller \( C(s) \), an optional reference prefilter \( F(s) \), a reference input \( r(t) \) and an additive disturbance \( d(t) \) injected at the plant input.

Let \( R(s), D(s), Y(s) \) be the Laplace transforms of \( r(t), d(t), y(t) \). The error signal is \( e(t) = r_f(t) - y(t) \) with \( r_f(t) \) the filtered reference and \( r_f(t) \leftrightarrow F(s)R(s) \). The control input is \( u(t) \) with \( u(t) \leftrightarrow C(s)E(s) \).

For this configuration, a straightforward block-diagram manipulation yields

\[ Y(s) = \frac{F(s)C(s)G(s)}{1 + C(s)G(s)}R(s) + \frac{G(s)}{1 + C(s)G(s)}D(s). \]

Define the loop transfer function, sensitivity, and complementary sensitivity as

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

Then the closed-loop transfer functions from reference and disturbance to output are

\[ T_r(s) = \frac{Y(s)}{R(s)} = F(s)T(s), \qquad T_d(s) = \frac{Y(s)}{D(s)} = G(s)S(s). \]

Tracking design focuses on shaping \( T_r(s) \) so that \( y(t) \) follows \( r(t) \) with acceptable overshoot, settling time, and steady-state error. Regulation design focuses on \( T_d(s) \) so that disturbances are rejected around the operating point (often with \( r(t) = 0 \)).

Two-degree-of-freedom (2-DOF) designs exploit the fact that \( F(s) \) affects tracking but not disturbance rejection, because \( T_d(s) \) depends only on \( G(s) \) and \( C(s) \).

flowchart TD
  RQ["Specify specs: tracking, regulation, noise"] --> PLANT["Model plant G(s)"]
  PLANT --> STRUCT["Choose C(s) and optional F(s) (2-DOF)"]
  STRUCT --> TFs["Compute S(s)=1/(1+L(s)), T(s)=L(s)/(1+L(s))"]
  TFs --> SHAPE["Check |T_r(jw)| and |T_d(jw)| vs. specs"]
  SHAPE --> SIM["Simulate steps in r(t) and d(t)"]
  SIM --> ITER["Iterate on C(s), F(s) until requirements met"]
        

We study a normalized first-order plant, representative of speed control in a DC motor or a low-inertia robotic joint:

\[ G(s) = \frac{1}{s + 1}. \]

We design a PI controller for set-point tracking of a unit step \( r(t) = 1, \; t \ge 0 \) with:

• zero steady-state error to a step,
• settling time \( T_s \approx 2 \,\text{s} \),
• overshoot \( M_p \lesssim 10\% \).

Consider the PI controller

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

The loop transfer function is

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

The characteristic equation of the closed loop (with unity feedback and \( F(s) = 1 \)) is

\[ 1 + L(s) = 0 \;\Longleftrightarrow\; s(s+1) + K_p s + K_i = 0. \]

Expanding yields a second-order polynomial

\[ s^2 + (1 + K_p)s + K_i = 0. \]

We approximate the closed-loop behavior by the standard second-order model

\[ s^2 + 2\zeta \omega_n s + \omega_n^2 = 0, \]

where \( \zeta \) is the damping ratio and \( \omega_n \) the natural frequency. Matching coefficients gives

\[ 1 + K_p = 2\zeta \omega_n, \qquad K_i = \omega_n^2. \]

For a target overshoot \( M_p \lesssim 10\% \), a common choice is \( \zeta \approx 0.7 \). The approximate settling time for a second-order system is

\[ T_s \approx \frac{4}{\zeta \omega_n}. \]

Requiring \( T_s \approx 2 \,\text{s} \) leads to \( \zeta \omega_n \approx 2 \). With \( \zeta = 0.7 \) we get \( \omega_n \approx 2 / 0.7 \approx 2.86 \). For convenience we choose \( \omega_n = 3 \,\text{rad/s} \), then

\[ K_p = 2\zeta \omega_n - 1 = 2 \cdot 0.7 \cdot 3 - 1 = 4.2 - 1 = 3.2, \qquad K_i = \omega_n^2 = 9. \]

With these gains, the closed-loop characteristic polynomial is

\[ s^2 + (1 + 3.2)s + 9 = s^2 + 4.2 s + 9, \]

which yields the desired approximate settling time and damping. Because the loop now contains an integrator, the closed-loop system is of type 1, implying zero steady-state error to a step reference.

To verify zero steady-state error, we use the final value theorem. The reference-to-output transfer function is

\[ T_r(s) = \frac{Y(s)}{R(s)} = \frac{C(s)G(s)}{1 + C(s)G(s)} = \frac{K_p s + K_i}{s^2 + (1 + K_p)s + K_i}. \]

For a unit-step input \( R(s) = 1/s \), the steady-state output is

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

Substituting \( K_p, K_i \) and evaluating at \( s = 0 \) gives \( T_r(0) = 1 \), so \( y_{\infty} = 1 \) and the steady-state tracking error is zero.

For the PI design above, \( L(s) = C(s)G(s) = (K_p s + K_i)/(s(s+1)) \) and the sensitivity functions are

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

At low frequency (\( s \to 0 \)), the integrator in \( C(s) \) causes \( |L(j\omega)| \) to be very large, so \( |S(j\omega)| \approx 0 \) and \( |T(j\omega)| \approx 1 \). This gives:

• good reference tracking (since \( T_r(j\omega) \approx 1 \)),
• good rejection of low-frequency disturbances (since \( |T_d(j\omega)| = |G(j\omega)S(j\omega)| \) is small).

For high frequency (\( \omega \to \infty \)), the magnitude of \( L(j\omega) \) typically decays, so \( S(j\omega) \approx 1 \) and \( T(j\omega) \approx 0 \), which makes the closed loop robust to high-frequency modeling errors but can expose it to measurement noise.

To reduce overshoot without sacrificing disturbance rejection, we introduce a simple reference prefilter

\[ F(s) = \frac{\omega_f}{s + \omega_f}, \qquad \omega_f < \omega_n. \]

Now the tracking transfer function is

\[ T_r(s) = F(s)T(s) = \frac{\omega_f}{s + \omega_f} \, T(s), \]

which low-pass filters the reference before it is applied to the feedback loop. The disturbance transfer function is unchanged:

\[ T_d(s) = G(s)S(s), \]

because the disturbance path does not include \( F(s) \). This is a prototypical 2-DOF design: \( C(s) \) is tuned primarily for regulation/robustness, while \( F(s) \) shapes the tracking transient.

We now simulate the closed-loop behavior for the PI controller with \( K_p = 3.2 \), \( K_i = 9.0 \), \( G(s) = 1/(s+1) \), and \( F(s) = \omega_f/(s + \omega_f) \) (optional; for simplicity we take \( F(s)=1 \) in the code). The continuous-time dynamics in state-space form are:

• Integrator state: \( z(t) = \int_0^t (r(\sigma) - y(\sigma)) \, d\sigma \)
• Plant state: \( y(t) \) with \( \dot{y}(t) = -y(t) + u(t) + d(t) \)
• Control law: \( u(t) = K_p (r(t) - y(t)) + K_i z(t) \)

Thus,

\[ \dot{z}(t) = r(t) - y(t), \qquad \dot{y}(t) = -y(t) + K_p (r(t) - y(t)) + K_i z(t) + d(t). \]

We implement these equations with explicit Euler integration for simplicity and clarity. In robotics practice, these structures appear in:

• Python: joint controllers via python-control and roboticstoolbox,
• C++: ROS (ros_control) with Eigen-based dynamics,
• Java: robotics stacks using EJML or similar linear algebra libraries,
• MATLAB/Simulink: Control System Toolbox and Robotics System Toolbox,
• Mathematica: symbolic/numeric analysis with StateSpaceModel and ParametricNDSolve.

4.1 Python Implementation (Robotics-Oriented Script)

import numpy as np

# Controller parameters from design
Kp = 3.2
Ki = 9.0

# Simulation parameters
dt = 0.001     # time step [s]
t_final = 8.0  # final time [s]
n_steps = int(t_final / dt) + 1

# Allocate arrays
t = np.linspace(0.0, t_final, n_steps)
y = np.zeros(n_steps)   # plant output
z = np.zeros(n_steps)   # integral state
u = np.zeros(n_steps)   # control signal
d = np.zeros(n_steps)   # disturbance

# Reference: unit step
def reference(time):
    return 1.0

# Disturbance: step applied at t >= 3 s
def disturbance(time):
    return 0.2 if time >= 3.0 else 0.0

for k in range(n_steps - 1):
    r_k = reference(t[k])
    d_k = disturbance(t[k])
    e_k = r_k - y[k]

    # PI control law
    u[k] = Kp * e_k + Ki * z[k]

    # Integral state derivative
    dz = e_k

    # Plant: y_dot = -y + u + d
    dy = -y[k] + u[k] + d_k

    # Euler integration
    z[k + 1] = z[k] + dt * dz
    y[k + 1] = y[k] + dt * dy

# Last control and disturbance
u[-1] = Kp * (reference(t[-1]) - y[-1]) + Ki * z[-1]
d[-1] = disturbance(t[-1])

# At this point, t, y, u, d contain the closed-loop trajectory.
# In a robotic joint controller, similar logic would be embedded
# in a 1 kHz control loop using python-control or roboticstoolbox.
      

4.2 C++ Implementation (ROS-Style Control Loop Skeleton)

#include <iostream>
#include <vector>

int main() {
    // Controller gains
    const double Kp = 3.2;
    const double Ki = 9.0;

    // Simulation parameters
    const double dt = 0.001;
    const double t_final = 8.0;
    const int n_steps = static_cast<int>(t_final / dt) + 1;

    std::vector<double> t(n_steps), y(n_steps), z(n_steps), u(n_steps), d(n_steps);

    for (int k = 0; k < n_steps; ++k) {
        t[k] = k * dt;
    }

    auto reference = [](double time) {
        return 1.0; // unit step
    };

    auto disturbance = [](double time) {
        return (time >= 3.0) ? 0.2 : 0.0;
    };

    for (int k = 0; k < n_steps - 1; ++k) {
        double r_k = reference(t[k]);
        double d_k = disturbance(t[k]);
        double e_k = r_k - y[k];

        // PI control
        u[k] = Kp * e_k + Ki * z[k];

        // State derivatives
        double dz = e_k;
        double dy = -y[k] + u[k] + d_k;

        // Euler integration
        z[k + 1] = z[k] + dt * dz;
        y[k + 1] = y[k] + dt * dy;
        d[k]     = d_k;
    }
    // Final values
    d[n_steps - 1] = disturbance(t[n_steps - 1]);
    u[n_steps - 1] = Kp * (reference(t[n_steps - 1]) - y[n_steps - 1]) + Ki * z[n_steps - 1];

    // In a ROS controller, this loop structure would be embedded in a realtime
    // callback, publishing 'u' to an actuator and reading 'y' from sensors.
    std::cout << "Simulation finished, final output y(T) = " << y.back() << std::endl;
    return 0;
}
      

4.3 Java Implementation (Simulation Core with EJML or Similar Libraries)

public class PiTrackingSimulation {

    public static void main(String[] args) {
        double Kp = 3.2;
        double Ki = 9.0;

        double dt = 0.001;
        double tFinal = 8.0;
        int nSteps = (int) (tFinal / dt) + 1;

        double[] t = new double[nSteps];
        double[] y = new double[nSteps];
        double[] z = new double[nSteps];
        double[] u = new double[nSteps];
        double[] d = new double[nSteps];

        for (int k = 0; k < nSteps; ++k) {
            t[k] = k * dt;
        }

        for (int k = 0; k < nSteps - 1; ++k) {
            double r = 1.0; // unit step
            double dist = (t[k] >= 3.0) ? 0.2 : 0.0;
            double e = r - y[k];

            // PI controller
            u[k] = Kp * e + Ki * z[k];

            double dz = e;
            double dy = -y[k] + u[k] + dist;

            z[k + 1] = z[k] + dt * dz;
            y[k + 1] = y[k] + dt * dy;
            d[k] = dist;
        }
        // final sample
        double rEnd = 1.0;
        double distEnd = (t[nSteps - 1] >= 3.0) ? 0.2 : 0.0;
        double eEnd = rEnd - y[nSteps - 1];
        u[nSteps - 1] = Kp * eEnd + Ki * z[nSteps - 1];
        d[nSteps - 1] = distEnd;

        System.out.println("Final output y(T) = " + y[nSteps - 1]);

        // In a robotics Java stack, the same PI computation would run
        // in a periodic control task with joint states as feedback.
    }
}
      

4.4 MATLAB/Simulink Implementation

% Controller gains
Kp = 3.2;
Ki = 9.0;

% Continuous-time transfer functions (Control System Toolbox)
s = tf('s');
G = 1 / (s + 1);
C = Kp + Ki / s;

% Closed-loop with unity feedback and optional reference filter F(s)
F = 1;        % or F = wf / (s + wf) for some wf < 3
T_r = feedback(F * C * G, 1);   % reference-to-output
T_d = feedback(G, C);           % disturbance-to-output (input disturbance)

% Time vector and signals
t = 0:0.001:8;
r = ones(size(t));              % unit step
d = zeros(size(t));
d(t >= 3) = 0.2;                % step disturbance

% Simulate reference tracking only
[y_r, t_r] = step(T_r, t(end));

% Simulate combined reference and disturbance via lsim
sys_cl = ss([0 0; -1-Kp Ki; 1 0], [1 0; Kp Ki; 0 0], [0 1 0], 0);
% State vector: [z; y], input vector: [r; d]
u_input = [r.' d.'];
[y_cl, t_cl] = lsim(sys_cl, u_input, t);

plot(t_cl, y_cl), grid on
xlabel('Time [s]'), ylabel('Output y(t)')
title('PI tracking with disturbance step at t = 3 s')

% In Simulink, you would build an equivalent diagram using:
%   - Sum blocks for error and disturbance
%   - Discrete or continuous PI controller block
%   - First-order Transfer Fcn block for G(s)
%   - Optional prefilter F(s) in the reference path.
      

4.5 Wolfram Mathematica Implementation

(* Controller gains *)
Kp = 3.2;
Ki = 9.0;

(* System of ODEs *)
eqs = {
   z'[t] == 1 - y[t], (* r(t) = 1 *)
   y'[t] == -y[t] + Kp (1 - y[t]) + Ki z[t] +
     Piecewise[{ {0, t < 3}, {0.2, t >= 3} }] (* disturbance d(t) *)
   };

ics = {z[0] == 0, y[0] == 0};

sol = NDSolve[
   Join[eqs, ics],
   {z, y},
   {t, 0, 8}
   ][[1]];

Plot[Evaluate[y[t] /. sol], {t, 0, 8},
 PlotRange -> All,
 AxesLabel -> {"t", "y(t)"},
 PlotLabel -> "PI tracking with disturbance step at t = 3 s"]
      

These implementations realize the same continuous-time PI control law with a first-order plant. In robotic applications, such inner-loop tracking controllers are typically cascaded with outer loops (e.g., position or impedance control) and executed in real time on embedded hardware or middleware frameworks such as ROS.

We now emphasize the regulation aspect by setting the reference to zero \( r(t) \equiv 0 \) and analyzing the effect of the disturbance \( d(t) \) on the output. The disturbance-to-output transfer function is

\[ T_d(s) = \frac{Y(s)}{D(s)} = \frac{G(s)}{1 + C(s)G(s)} = G(s) S(s). \]

For our plant and PI controller,

\[ T_d(s) = \frac{\frac{1}{s+1}}{1 + \frac{K_p s + K_i}{s(s+1)}} = \frac{s}{s^2 + (1 + K_p)s + K_i}. \]

Consider a constant disturbance \( d(t) = d_0 \) with \( D(s) = d_0 / s \). The steady-state output is

\[ y_{\infty} = \lim_{t \to \infty} y(t) = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} s T_d(s) \frac{d_0}{s} = \lim_{s \to 0} T_d(s) d_0. \]

Using the expression for \( T_d(s) \),

\[ T_d(0) = \frac{0}{0^2 + (1 + K_p) \cdot 0 + K_i} = 0, \]

hence \( y_{\infty} = 0 \). The same PI controller that ensures zero steady-state tracking error also ensures zero steady-state output under a constant input disturbance. This is the classical integral-action disturbance rejection property.

For sinusoidal disturbances \( d(t) = d_a \sin(\omega_d t) \), the steady-state output amplitude is

\[ |y_{\text{ss}}(j\omega_d)| = |T_d(j\omega_d)| \, d_a. \]

Because \( T_d(j\omega) = G(j\omega)S(j\omega) \), we see the trade-off between disturbance rejection and robust stability:

• Making \( |S(j\omega)| \) small at low frequencies improves rejection of slowly varying disturbances.
• However, \( S(j\omega) + T(j\omega) = 1 \) implies that pushing \( |T(j\omega)| \) close to 1 over a broad band necessarily increases \( |S(j\omega)| \) elsewhere (a manifestation of the so-called waterbed effect).

In robotic arms or mobile robots, disturbances such as unmodeled friction, external forces, or slope changes act like input disturbances. The integral action in inner torque/velocity loops significantly reduces steady-state offsets due to these effects, but the gains must be balanced against stability margins and noise sensitivity, as seen in previous chapters.

Problem 1 (Reference and Disturbance Transfer Functions in 2-DOF Control): Consider the unity-feedback system with prefilter \( F(s) \), controller \( C(s) \), and plant \( G(s) \) described earlier. Disturbance \( d(t) \) enters additively at the plant input. Derive \( T_r(s) = Y(s)/R(s) \) and \( T_d(s) = Y(s)/D(s) \).

Solution:

Let \( R(s), D(s), Y(s) \) be the Laplace transforms of \( r(t), d(t), y(t) \). The filtered reference is \( R_f(s) = F(s)R(s) \). The error is \( E(s) = R_f(s) - Y(s) \), the control input is \( U(s) = C(s)E(s) \), and the plant output is

\[ Y(s) = G(s)\big(U(s) + D(s)\big). \]

Substituting \( U(s) = C(s)(F(s)R(s) - Y(s)) \) gives

\[ Y(s) = G(s)\left(C(s)F(s)R(s) - C(s)Y(s) + D(s)\right). \]

Collecting terms in \( Y(s) \) leads to

\[ \big(1 + C(s)G(s)\big)Y(s) = F(s)C(s)G(s)R(s) + G(s)D(s). \]

Hence

\[ Y(s) = \frac{F(s)C(s)G(s)}{1 + C(s)G(s)}R(s) + \frac{G(s)}{1 + C(s)G(s)}D(s), \]

so that

\[ T_r(s) = \frac{Y(s)}{R(s)} = F(s) \frac{C(s)G(s)}{1 + C(s)G(s)} = F(s)T(s), \\ T_d(s) = \frac{Y(s)}{D(s)} = \frac{G(s)}{1 + C(s)G(s)} = G(s)S(s). \]

Problem 2 (PI Design by Pole Matching): For the plant \( G(s) = 1/(s+1) \) and PI controller \( C(s) = K_p + K_i/s \), show that the closed-loop characteristic polynomial is \( s^2 + (1 + K_p)s + K_i \) and derive \( K_p, K_i \) that place the poles at \( s^2 + 2\zeta \omega_n s + \omega_n^2 = 0 \).

Solution:

The loop transfer function is \( L(s) = (K_p s + K_i)/(s(s+1)) \). The characteristic equation is \( 1 + L(s) = 0 \), i.e.,

\[ s(s+1) + K_p s + K_i = 0 \;\Longleftrightarrow\; s^2 + (1 + K_p)s + K_i = 0. \]

Matching with the desired polynomial \( s^2 + 2\zeta \omega_n s + \omega_n^2 \) yields

\[ 1 + K_p = 2\zeta \omega_n, \qquad K_i = \omega_n^2. \]

Therefore, \( K_p = 2\zeta \omega_n - 1 \), \( K_i = \omega_n^2 \).

Problem 3 (Zero Steady-State Error to Step Reference and Step Disturbance): For the same PI-controlled plant with \( G(s) = 1/(s+1) \) and \( C(s) = K_p + K_i/s \), prove that the steady-state tracking error to a step reference is zero, and that the steady-state output under a step disturbance is zero.

Solution:

For tracking, the error transfer function is

\[ E(s) = R(s) - Y(s) = R(s) - T_r(s)R(s) = \big(1 - T_r(s)\big)R(s) = S(s)R(s), \]

since \( T_r(s) = T(s) \) with \( F(s) = 1 \), and \( 1 - T(s) = S(s) \). Thus, for a unit-step reference \( R(s) = 1/s \),

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

With integral action, \( L(s) \) has a pole at \( s = 0 \), so \( |L(0)| = \infty \) and \( S(0) = 0 \): thus \( e_{\infty} = 0 \).

For a step disturbance \( d(t) = d_0 \), \( D(s) = d_0/s \), with \( r(t) \equiv 0 \) the steady-state output is

\[ y_{\infty} = \lim_{s \to 0} s T_d(s) \frac{d_0}{s} = \lim_{s \to 0} T_d(s) d_0 = T_d(0)d_0. \]

As shown earlier, \( T_d(s) = s / (s^2 + (1 + K_p)s + K_i) \), so \( T_d(0) = 0 \) and \( y_{\infty} = 0 \).

Problem 4 (Fundamental Trade-Off between \( S(s) \) and \( T(s) \)): Show that \( S(s) + T(s) = 1 \) and explain why this implies that one cannot make both \( |S(j\omega)| \) and \( |T(j\omega)| \) small over the same frequency range.

Solution:

By definition, \( S(s) = 1/(1 + L(s)) \) and \( T(s) = L(s)/(1 + L(s)) \). Then

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

Taking magnitudes on the imaginary axis, \( |S(j\omega) + T(j\omega)| = 1 \). Because the magnitude is subadditive, \( |S(j\omega)| + |T(j\omega)| \ge 1 \) for all \( \omega \). Thus, it is impossible for both \( |S(j\omega)| \) and \( |T(j\omega)| \) to be simultaneously small over the same frequency band. Improving low-frequency disturbance rejection by making \( |S(j\omega)| \) small necessarily pushes \( |T(j\omega)| \) closer to 1 in that band, affecting noise and robustness.

Problem 5 (Design Flow for Tracking and Regulation Specifications): Sketch a high-level decision process for choosing controller structure \( C(s) \) and prefilter \( F(s) \) when both tracking and disturbance rejection performance are specified.

Solution (design flow):

flowchart TD
  START["Start from specs on tracking and disturbance rejection"] --> PLANT["Obtain or identify plant G(s)"]
  PLANT --> TYPE["Need integral action (zero steady-state error)?"]
  TYPE -->|yes| INT["Choose PI or PID structure for C(s)"]
  TYPE -->|no| NOINT["Choose P/PD or lead-lag structure for C(s)"]
  INT --> LOOP["Shape loop L(s)=C(s)G(s) for margins and bandwidth"]
  NOINT --> LOOP
  LOOP --> PREF["Is overshoot or command aggressiveness a problem?"]
  PREF -->|yes| FSEL["Add prefilter F(s) to slow reference"]
  PREF -->|no| DONE["Use F(s)=1"]
        

This flow emphasizes that \( C(s) \) primarily sets loop properties (\( S(s), T(s) \)) and disturbance rejection, while the prefilter \( F(s) \) is a clean mechanism to tailor tracking transients without compromising regulation performance.

In this lesson we applied the tools developed in previous chapters to concrete tracking and regulation case studies. Starting from a normalized first-order plant, we designed a PI controller by matching closed-loop poles to a desired second-order model, obtaining explicit formulas for \( K_p \) and \( K_i \).

We derived and interpreted the sensitivity functions \( S(s) = 1/(1 + L(s)) \) and \( T(s) = L(s)/(1 + L(s)) \), showing how they encode reference tracking, disturbance rejection, and robustness trade-offs. The addition of a reference prefilter \( F(s) \) exemplified 2-DOF design, where tracking is shaped without altering disturbance rejection.

Implementation examples in Python, C++, Java, MATLAB/Simulink, and Mathematica demonstrated how the same continuous-time PI control law appears in software typical of robotics and mechatronic systems. The problems and solutions reinforced the algebra of closed-loop transfer functions and the conceptual limits imposed by \( S(s) + T(s) = 1 \). These case studies form a bridge to more complex multi-loop and robust designs encountered in later chapters and advanced control courses.