Classical linear control design assumes that the plant \( P(s) \), controller \( C(s) \), and feedback interconnection are linear and that all signals remain within ranges where linear models are valid. In practice:

• Actuators saturate: \( |u(t)| \le u_{\max} \), and often also \( |\dot{u}(t)| \le \dot{u}_{\max} \).
• States and outputs have safety limits: \( |y(t)| \le y_{\max} \).
• Disturbances can be large, driving the system far from the linearization point.

Consider a standard unity-feedback loop with plant \( P(s) \) and controller \( C(s) \), and define the loop transfer function

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

For an additive disturbance at the plant output, \( d(t) \), the Laplace-domain relations (with reference \( r(t) = 0 \)) are

\[ Y(s) = S(s) D(s), \qquad U(s) = -C(s) S(s) D(s). \]

Thus, \( S(s) \) governs disturbance-to-output behavior, while \( C(s)S(s) \) governs disturbance-to-actuator behavior. When \( |D(s)| \) is large or when \( |C(j\omega)S(j\omega)| \) is large in some frequency band, actuator constraints are violated and the closed loop behaves nonlinearly.

flowchart TD
  R["Reference r"] --> SUM1["Sum e = r - y"]
  Y["Output y"] --> SUM1
  SUM1 --> C["Controller C(s)"]
  C --> SAT["Actuator with limit '|u| <= u_max'"]
  SAT --> P["Plant P(s)"]
  P --> SUM2["Output summing node"]
  D["Disturbance d"] --> SUM2
  SUM2 --> Y
  SAT -->|"violates bound"| NL["Nonlinear behavior"]
        

The key message: even a perfectly tuned linear controller cannot overcome the combination of hard constraints and arbitrarily large disturbances. Instead, performance is fundamentally limited by the size of the disturbances and the allowable ranges of signals.

Suppose an additive output disturbance is sinusoidal: \( d(t) = \bar{D} \sin(\omega_0 t) \). For a stable closed loop, the steady-state response is sinusoidal at the same frequency. Using frequency-response notation with \( s = j\omega_0 \), we obtain

\[ |Y(j\omega_0)| = |S(j\omega_0)| \bar{D}, \qquad |U(j\omega_0)| = |C(j\omega_0) S(j\omega_0)| \bar{D}. \]

An actuator magnitude constraint \( |u(t)| \le u_{\max} \) implies the frequency-domain bound

\[ |C(j\omega_0) S(j\omega_0)| \bar{D} \le u_{\max}. \]

Hence the achievable disturbance attenuation \( |S(j\omega_0)| \) cannot be made arbitrarily small if \( |C(j\omega_0)| \) and \( u_{\max} \) are bounded. Rearranging,

\[ |S(j\omega_0)| \le \frac{u_{\max}}{|C(j\omega_0)| \bar{D}}. \]

To reduce \( |S(j\omega_0)| \) (better disturbance rejection), classical loop-shaping increases \( |L(j\omega_0)| = |C(j\omega_0)P(j\omega_0)| \), which usually means increasing \( |C(j\omega_0)| \). However, a larger controller magnitude increases the left-hand side of the actuator-bound inequality for fixed disturbance amplitude \( \bar{D} \). The designer faces a three-way compromise between:

• Disturbance amplitude \( \bar{D} \),
• Desired disturbance rejection \( |S(j\omega_0)| \), and
• Available actuator range \( u_{\max} \).

This frequency-domain picture already reveals that for sufficiently large disturbances \( \bar{D} \), the inequality cannot be satisfied no matter how the linear controller is tuned.

flowchart TD
  SPEC["Choose spec: small |S(jw0)|, bounds u_max, disturbance D_bar"] --> DESIGN["Design C(s) to shape L(s)"]
  DESIGN --> CHECK["Check |C(jw0) S(jw0)| D_bar <= u_max?"]
  CHECK -->|yes| OK["Linear design feasible (locally)"]
  CHECK -->|no| FAIL["Requirements infeasible or \nneed constraint-aware design"]
        

To obtain explicit algebraic limitations, consider a simple first-order plant with an additive constant disturbance:

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

where \( D > 0 \) is a constant disturbance. We apply a static feedback controller

\[ u(t) = -k y(t) = -k x(t), \]

subject to an actuator saturation \( |u(t)| \le u_{\max} \). We want to understand whether it is possible to choose \( k \ge 0 \) so that both:

• Steady-state regulation accuracy is good: \( |y_{\mathrm{ss}}| \le y_{\max} \),
• Actuator limit is respected in steady state: \( |u_{\mathrm{ss}}| \le u_{\max} \).

3.1 Closed-loop steady-state behavior

Substituting the control law into the plant dynamics gives

\[ \dot{x}(t) = -(1 + k) x(t) + D. \]

For \( k > -1 \) the closed loop is asymptotically stable. The steady-state value \( x_{\mathrm{ss}} \) is obtained by setting \( \dot{x}(t) = 0 \):

\[ 0 = -(1 + k) x_{\mathrm{ss}} + D \quad \Rightarrow \quad x_{\mathrm{ss}} = \frac{D}{1 + k}. \]

Therefore,

\[ y_{\mathrm{ss}} = x_{\mathrm{ss}} = \frac{D}{1 + k}, \qquad u_{\mathrm{ss}} = -k x_{\mathrm{ss}} = -\frac{k D}{1 + k}. \]

3.2 Constraints translated into inequalities on \( k \)

The steady-state accuracy requirement \( |y_{\mathrm{ss}}| \le y_{\max} \) gives

\[ \left|\frac{D}{1 + k}\right| \le y_{\max} \quad \Rightarrow \quad \frac{D}{1 + k} \le y_{\max} \quad \Rightarrow \quad 1 + k \ge \frac{D}{y_{\max}} \quad \Rightarrow \quad k \ge \frac{D}{y_{\max}} - 1. \]

The actuator constraint \( |u_{\mathrm{ss}}| \le u_{\max} \) yields

\[ \left|\frac{k D}{1 + k}\right| \le u_{\max} \quad \Rightarrow \quad \frac{k D}{1 + k} \le u_{\max} \quad \Rightarrow \quad k D \le u_{\max}(1 + k). \]

Rearranging,

\[ k D - u_{\max} k \le u_{\max} \quad \Rightarrow \quad k(D - u_{\max}) \le u_{\max}. \]

Two cases arise:

• If \( D \le u_{\max} \), then \( D - u_{\max} \le 0 \) and the inequality is automatically satisfied for all \( k \ge 0 \); the actuator is not a limiting factor in steady state.
• If \( D > u_{\max} \), then \( D - u_{\max} > 0 \), so we obtain an upper bound on \( k \):

  \[ k \le \frac{u_{\max}}{D - u_{\max}}. \]

3.3 Feasibility condition and a simple fundamental limitation

In the interesting regime \( D > u_{\max} \) (disturbance larger than actuator capability), both a lower and an upper bound on \( k \) must be satisfied:

\[ k \ge \frac{D}{y_{\max}} - 1, \qquad k \le \frac{u_{\max}}{D - u_{\max}}. \]

A feasible \( k \ge 0 \) exists if and only if the lower bound does not exceed the upper bound, i.e.

\[ \frac{D}{y_{\max}} - 1 \le \frac{u_{\max}}{D - u_{\max}}. \]

Multiplying both sides by the positive quantity \( y_{\max}(D - u_{\max}) \) and simplifying,

\[ (D - y_{\max})(D - u_{\max}) \le u_{\max} y_{\max} \quad \Rightarrow \quad D^2 - D(y_{\max} + u_{\max}) \le 0. \]

Since \( D > 0 \), the inequality \( D(D - (y_{\max} + u_{\max})) \le 0 \) is equivalent to

\[ D \le y_{\max} + u_{\max}. \]

Conclusion. For the simple first-order plant with static feedback, there exists a feedback gain \( k \ge 0 \) that simultaneously satisfies the steady-state accuracy constraint \( |y_{\mathrm{ss}}| \le y_{\max} \) and actuator constraint \( |u_{\mathrm{ss}}| \le u_{\max} \) if and only if

\[ D \le y_{\max} + u_{\max}. \]

If the disturbance magnitude exceeds the sum of the allowable output deviation and maximum actuator effort, no static linear feedback gain can deliver both specifications. This is an explicit manifestation of a fundamental limitation imposed by constraints under large disturbances.

Note that this result concerns only steady-state. In more complex plants (higher order, integrators, non-minimum phase zeros) or when transient performance (e.g., overshoot) is specified, additional limitations appear and the analysis becomes more intricate.

When actuator limits are reached, the effective control law becomes nonlinear. Using a saturating actuator, the applied input is

\[ u_{\mathrm{sat}}(t) = \operatorname{sat}(u_c(t)), \]

where the commanded input \( u_c(t) \) is computed by the linear controller and \( \operatorname{sat}(\cdot) \) is the static nonlinearity

\[ \operatorname{sat}(u) = \begin{cases} u_{\max}, & \text{if } u \ge u_{\max},\\ u, & \text{if } |u| \le u_{\max},\\ -u_{\max}, & \text{if } u \le -u_{\max}. \end{cases} \]

In the region \( |u_c| \le u_{\max} \), the closed-loop dynamics coincide with the designed linear model. Outside this region, the effective input is clipped and the closed-loop dynamics change, often reducing effective feedback gain and potentially degrading stability margins or inducing limit cycles.

Even though the saturation function is continuous and globally Lipschitz, its piecewise-linear character creates a local region in which linear analysis is valid. Large disturbances can push trajectories outside this region, invalidating linear predictions. The feasibility condition derived in Section 3 can be interpreted as describing a disturbance magnitude for which the desired operating point lies strictly inside the unsaturated region.

Linear analysis tools (root locus, Bode, Nyquist, sensitivity functions) remain essential, but under constraints and large disturbances they describe only the behavior within a limited region of the state and signal space. This motivates more advanced topics such as anti-windup design, model predictive control, and nonlinear analysis, which treat constraints explicitly.

We now simulate the first-order system of Section 3 with saturation using a simple time-step integration in Python. The dynamics are

\[ \dot{x}(t) = -x(t) + u_{\mathrm{sat}}(t) + D, \qquad u_{\mathrm{sat}}(t) = \operatorname{sat}(-k x(t)). \]

We implement the simulation using explicit Euler integration. The Python control library can be used for linear analysis of \( P(s) \) and \( C(s) \), but here the saturation requires a time-domain nonlinear simulation.

import numpy as np

def sat(u, u_max):
    return np.clip(u, -u_max, u_max)

# Parameters
k = 5.0            # feedback gain
D = 3.0            # constant disturbance
u_max = 1.0        # actuator limit
x0 = 0.0           # initial condition
t_final = 20.0
dt = 0.001

N = int(t_final / dt)
t = np.linspace(0.0, t_final, N + 1)
x = np.zeros(N + 1)
u_cmd = np.zeros(N + 1)
u_applied = np.zeros(N + 1)

x[0] = x0

for n in range(N):
    # Linear controller (commanded input)
    u_cmd[n] = -k * x[n]
    # Saturated actuator
    u_applied[n] = sat(u_cmd[n], u_max)
    # First-order dynamics: x_dot = -x + u + D
    x_dot = -x[n] + u_applied[n] + D
    x[n + 1] = x[n] + dt * x_dot

# final command value
u_cmd[N] = -k * x[N]
u_applied[N] = sat(u_cmd[N], u_max)

# Example: plotting (requires matplotlib)
if __name__ == "__main__":
    import matplotlib.pyplot as plt
    fig, axs = plt.subplots(2, 1, sharex=True)
    axs[0].plot(t, x)
    axs[0].set_ylabel("y(t) = x(t)")
    axs[1].plot(t, u_applied, label="u_applied")
    axs[1].plot(t, u_cmd, "--", label="u_cmd (linear)")
    axs[1].set_ylabel("u(t)")
    axs[1].set_xlabel("time [s]")
    axs[1].legend()
    plt.show()
      

By varying \( k \), \( D \), and \( u_{\max} \), students can empirically verify the feasibility condition \( D \le y_{\max} + u_{\max} \) by checking whether the steady-state output remains within the desired bound and whether the actuator spends significant time in saturation.

In C++, we can perform the same simulation using standard containers and a simple Euler integrator. Libraries such as Eigen for linear algebra or Boost.odeint for ODE integration are useful in more complex settings, but here we implement the core logic from scratch to highlight the structure.

#include <iostream>
#include <vector>
#include <algorithm>

double sat(double u, double u_max) {
    return std::max(-u_max, std::min(u, u_max));
}

int main() {
    double k = 5.0;
    double D = 3.0;
    double u_max = 1.0;
    double x0 = 0.0;
    double t_final = 20.0;
    double dt = 0.001;

    int N = static_cast<int>(t_final / dt);
    std::vector<double> t(N + 1), x(N + 1), u_cmd(N + 1), u_applied(N + 1);

    x[0] = x0;
    t[0] = 0.0;

    for (int n = 0; n < N; ++n) {
        t[n + 1] = t[n] + dt;

        u_cmd[n] = -k * x[n];
        u_applied[n] = sat(u_cmd[n], u_max);

        double x_dot = -x[n] + u_applied[n] + D;
        x[n + 1] = x[n] + dt * x_dot;
    }

    u_cmd[N] = -k * x[N];
    u_applied[N] = sat(u_cmd[N], u_max);

    // Print a few samples
    for (int n = 0; n <= N; n += N / 10) {
        std::cout << "t=" << t[n]
                  << "  x=" << x[n]
                  << "  u=" << u_applied[n] << std::endl;
    }

    return 0;
}
      

This code is easily extended to higher-order plants by replacing the scalar state \( x \) with a vector and the scalar dynamics with a suitable discretization of the corresponding linear ODEs.

In Java, similar logic applies. Numerical integration for control simulations is often packaged in larger frameworks, but the essential structure remains the same.

public class SaturatedFirstOrder {
    private static double sat(double u, double uMax) {
        return Math.max(-uMax, Math.min(u, uMax));
    }

    public static void main(String[] args) {
        double k = 5.0;
        double D = 3.0;
        double uMax = 1.0;
        double x0 = 0.0;
        double tFinal = 20.0;
        double dt = 0.001;

        int N = (int) (tFinal / dt);
        double[] t = new double[N + 1];
        double[] x = new double[N + 1];
        double[] uCmd = new double[N + 1];
        double[] uApplied = new double[N + 1];

        x[0] = x0;
        t[0] = 0.0;

        for (int n = 0; n < N; ++n) {
            t[n + 1] = t[n] + dt;

            uCmd[n] = -k * x[n];
            uApplied[n] = sat(uCmd[n], uMax);

            double xDot = -x[n] + uApplied[n] + D;
            x[n + 1] = x[n] + dt * xDot;
        }

        uCmd[N] = -k * x[N];
        uApplied[N] = sat(uCmd[N], uMax);

        for (int n = 0; n <= N; n += N / 10) {
            System.out.printf("t=%.3f  x=%.4f  u=%.4f%n", t[n], x[n], uApplied[n]);
        }
    }
}
      

In industrial Java-based control and simulation systems, one would typically wrap this logic in classes that represent plants, controllers, and constraints, with numerical solvers abstracted in dedicated libraries.

MATLAB provides both script-based and Simulink-based workflows. Script-based simulation of the saturated loop can be implemented via explicit discretization or ode45. In Simulink, a typical model uses:

• A Gain block for -k,
• A Saturation block implementing \( \operatorname{sat}(\cdot) \),
• A Sum block inserting the disturbance \( D \), and
• An Integrator block for the state \( x \).

% Parameters
k = 5.0;
D = 3.0;
u_max = 1.0;
x0 = 0.0;
t_final = 20.0;
dt = 0.001;

N = floor(t_final / dt);
t = linspace(0, t_final, N + 1);
x = zeros(1, N + 1);
u_cmd = zeros(1, N + 1);
u_applied = zeros(1, N + 1);

x(1) = x0;

for n = 1:N
    u_cmd(n) = -k * x(n);
    u_applied(n) = max(-u_max, min(u_cmd(n), u_max));
    x_dot = -x(n) + u_applied(n) + D;
    x(n + 1) = x(n) + dt * x_dot;
end

u_cmd(N + 1) = -k * x(N + 1);
u_applied(N + 1) = max(-u_max, min(u_cmd(N + 1), u_max));

figure;
subplot(2,1,1);
plot(t, x);
ylabel('y(t) = x(t)');
grid on;

subplot(2,1,2);
plot(t, u_applied, t, u_cmd, '--');
ylabel('u(t)');
xlabel('time [s]');
legend('u\_applied', 'u\_cmd (linear)');
grid on;
      

In Simulink, the same dynamics can be realized without explicit code, which makes it straightforward to add more realistic elements, such as rate limiters, measurement noise, or additional plant dynamics.

Mathematica can simulate the saturated loop using NDSolve with a piecewise definition of the control law. We again consider \( \dot{x}(t) = -x(t) + u_{\mathrm{sat}}(t) + D \).

(* Parameters *)
k = 5.0;
D = 3.0;
uMax = 1.0;
tFinal = 20.0;
x0 = 0.0;

sat[u_] := Max[-uMax, Min[u, uMax]];

eq = x'[t] == -x[t] + sat[-k x[t]] + D;
ic = x[0] == x0;

sol = NDSolve[{eq, ic}, x, {t, 0, tFinal}][[1]];

xFun[t_] := x[t] /. sol;
uCmd[t_] := -k xFun[t];
uSat[t_] := sat[uCmd[t]];

Plot[{xFun[t], uSat[t]}, {t, 0, tFinal},
 PlotLegends -> {"x(t)", "u_sat(t)"},
 AxesLabel -> {"t", ""}]
      

This Mathematica script emphasizes the functional style appropriate for more complex nonlinear and constraint-aware control simulations, while keeping the underlying system structure aligned with the linear control framework developed earlier in the course.

Problem 1 (Frequency-domain actuator constraint): Consider a stable unity-feedback loop with plant \( P(s) \) and controller \( C(s) \). An additive output disturbance is \( d(t) = \bar{D} \sin(\omega_0 t) \). Show that in steady state, the actuator magnitude at frequency \( \omega_0 \) satisfies \( |U(j\omega_0)| = |C(j\omega_0) S(j\omega_0)| \bar{D} \).

Solution: With reference \( r(t) = 0 \), the closed-loop relations are

\[ Y(s) = S(s) D(s), \qquad U(s) = C(s) E(s), \qquad E(s) = -Y(s), \]

so \( U(s) = -C(s) Y(s) = -C(s) S(s) D(s) \). For a sinusoidal disturbance, \( D(s) \) has a simple pole at \( s = j\omega_0 \), and in steady state the actuator response is sinusoidal at \( \omega_0 \) with magnitude \( |C(j\omega_0) S(j\omega_0)| \bar{D} \). The minus sign affects only the phase and not the magnitude. Thus \( |U(j\omega_0)| = |C(j\omega_0) S(j\omega_0)| \bar{D} \).

Problem 2 (Simple feasibility bound revisited): For the first-order loop in Section 3 with equations \( \dot{x} = -x + u + D \), \( u = -k x \), derive the condition \( D \le y_{\max} + u_{\max} \) for the existence of a gain \( k \ge 0 \) satisfying both \( |y_{\mathrm{ss}}| \le y_{\max} \) and \( |u_{\mathrm{ss}}| \le u_{\max} \).

Solution: As derived in Section 3, \( y_{\mathrm{ss}} = D/(1 + k) \) and \( u_{\mathrm{ss}} = -k D/(1 + k) \). The constraints yield

\[ k \ge \frac{D}{y_{\max}} - 1, \qquad k(D - u_{\max}) \le u_{\max}. \]

If \( D \le u_{\max} \) the second inequality is automatically satisfied for any \( k \ge 0 \), so some gain satisfying the first inequality always exists. If \( D > u_{\max} \), the second inequality implies \( k \le u_{\max}/(D - u_{\max}) \). Feasibility requires

\[ \frac{D}{y_{\max}} - 1 \le \frac{u_{\max}}{D - u_{\max}}, \]

which simplifies to \( D \le y_{\max} + u_{\max} \) as shown in the lesson. Thus, the bound \( D \le y_{\max} + u_{\max} \) is both necessary and sufficient for the existence of a suitable \( k \ge 0 \).

Problem 3 (Qualitative impact of saturation on stability margins): A plant \( P(s) \) with a well-tuned linear controller \( C(s) \) has comfortable gain and phase margins when analyzed without saturation. Explain qualitatively why actuator saturation can effectively reduce these margins, even though the linear loop transfer function \( L(s) = C(s)P(s) \) is unchanged.

Solution: Stability margins are computed from the linearized loop transfer function \( L(s) \) under the assumption that the controller output is applied directly to the plant. When saturation occurs, the effective input is \( u_{\mathrm{sat}} = \operatorname{sat}(u_c) \), which is a nonlinear function of the controller output. In regions where the controller attempts large corrections, \( \operatorname{sat}(\cdot) \) behaves like a smaller effective gain: \( \partial u_{\mathrm{sat}} / \partial u_c < 1 \). This state-dependent gain reduction modifies the effective loop transfer function, typically shrinking the loop gain where large corrections occur. As a result, the actual closed-loop behavior under saturation may exhibit reduced phase and gain margins, and phenomena such as limit cycles can appear even if the purely linear analysis predicts a robust response.

Problem 4 (Trade-off between disturbance rejection and control effort): Consider again the closed loop of Section 3. Show that as \( k \to \infty \), the steady-state disturbance-induced output \( y_{\mathrm{ss}} \) tends to zero, but the steady-state control effort \( u_{\mathrm{ss}} \) tends to \( -D \). Interpret this result in the context of constraints and large disturbances.

Solution: We have

\[ y_{\mathrm{ss}}(k) = \frac{D}{1 + k}, \qquad u_{\mathrm{ss}}(k) = -\frac{k D}{1 + k}. \]

Taking limits,

\[ \lim_{k \to \infty} y_{\mathrm{ss}}(k) = 0, \qquad \lim_{k \to \infty} u_{\mathrm{ss}}(k) = -D. \]

Thus, arbitrarily good disturbance rejection in this simple model is achieved only at the cost of a control effort whose magnitude approaches the disturbance itself. If \( |D| > u_{\max} \), then the required control effort cannot be delivered, and the linear design is not realizable. This illustrates a fundamental trade-off: improving disturbance rejection by increasing \( k \) eventually pushes the control effort against the actuator limits for sufficiently large disturbances.

Problem 5 (Local region of linearity): In the scalar system \( \dot{x} = a x + b u_{\mathrm{sat}} \) with \( u_{\mathrm{sat}}(t) = \operatorname{sat}(-k x(t)) \), characterize the region of \( x \)-space in which the closed-loop dynamics are exactly equivalent to the linear system \( \dot{x} = (a - b k)x \).

Solution: The saturation is inactive whenever \( |u_c| = | -k x | \le u_{\max} \), i.e.

\[ |x| \le \frac{u_{\max}}{k}. \]

In this region, \( u_{\mathrm{sat}} = u_c = -k x \) and the dynamics reduce to

\[ \dot{x} = a x + b(-k x) = (a - b k)x, \]

which is precisely the linear closed-loop system used in design. Outside this interval, the saturation changes the effective input, so the actual system no longer coincides with the linear model. Large disturbances can drive \( x \) outside the interval \( |x| \le u_{\max}/k \), making the linear analysis invalid and possibly altering stability properties.

In this lesson, we formalized how actuator and signal constraints interact with large disturbances to impose fundamental limitations on linear feedback control. Using sensitivity functions, we derived frequency-domain inequalities linking disturbance amplitudes, actuator limits, and achievable disturbance rejection. A simple first-order example demonstrated how, even with ideal linear design freedom, constraints yield explicit feasibility bounds such as \( D \le y_{\max} + u_{\max} \). We also emphasized that saturation turns a linear feedback loop into a nonlinear system, restricting the region in which linear analysis is valid. Finally, we implemented the saturated loop in Python, C++, Java, MATLAB/Simulink, and Mathematica, illustrating how these theoretical limitations manifest in simulation. These concepts motivate advanced constraint-aware techniques such as anti-windup, model predictive control, and nonlinear analysis, which are natural continuations beyond classical linear control.