In previous chapters, we have assumed that both the plant and controller are linear and time-invariant, so the closed-loop system can be analyzed using transfer functions and state-space methods. In practice, however, several components of a control loop are nonlinear:

• Actuator saturation (e.g., voltage/current limits, valve opening limits).
• Dead-zones (backlash, mechanical play, static friction).
• Rate limits (maximum slew rate of actuators).
• Sensor nonlinearities (quantization, saturating sensors).

These nonlinearities are often negligible near a nominal operating point, where a linear approximation is valid. But under large reference changes, disturbances, or tight constraints, they substantially alter closed-loop behavior and invalidate predictions based on a purely linear model. Conceptually, the design and implementation process can be summarized as:

flowchart TD
  A["Linear model of plant"] --> B["Design linear controller (C)"]
  B --> C["Implement controller in hardware/software"]
  C --> D["Actual loop with saturation and other nonlinearities"]
  D --> E["Observed closed-loop behavior"]
  E --> F["Compare with linear predictions"]
  F --> G["Assess limitations and refine design or choose advanced methods"]
        

Our goal in this lesson is not to replace linear control, but to understand its limitations when confronted with nonlinearities, and to derive simple mathematical tools that anticipate these limitations.

We begin with static nonlinearities, which are memoryless maps applied instantaneously to a signal. Given an input scalar signal \( v(t) \), the output is \( u(t) = \varphi(v(t)) \) for some nonlinear function \( \varphi:\mathbb{R}\to\mathbb{R} \).

2.1 Actuator Saturation

A standard model for actuator saturation with symmetric bounds \( \pm u_{\max} \) is

\[ \operatorname{sat}_{u_{\max}}(v) = \begin{cases} -u_{\max}, & v \le -u_{\max},\\[4pt] v, & -u_{\max} < v < u_{\max},\\[4pt] u_{\max}, & v \ge u_{\max}. \end{cases} \]

Important properties:

• Oddness: \( \operatorname{sat}_{u_{\max}}(-v) = -\operatorname{sat}_{u_{\max}}(v) \).
• Monotonicity: \( v_1 \le v_2 \Rightarrow \operatorname{sat}_{u_{\max}}(v_1) \le \operatorname{sat}_{u_{\max}}(v_2) \).
• Global Lipschitz with constant 1: for all \( v_1, v_2 \in \mathbb{R} \),

  \[ \bigl|\operatorname{sat}_{u_{\max}}(v_1) - \operatorname{sat}_{u_{\max}}(v_2)\bigr| \le |v_1 - v_2|. \]

The Lipschitz property is easily proved by a case distinction corresponding to whether each argument is in the linear region or in a saturated region. In the linear region the map is \( u=v \) so equality holds; in a saturated region the slope is zero, so the difference of outputs can never exceed the difference of inputs.

2.2 Dead-Zone Nonlinearity

A dead-zone models situations where small inputs produce no output, for example static friction or backlash. A symmetric dead-zone with width \( 2d \) can be written as

\[ \operatorname{dz}_d(v) = \begin{cases} v + d, & v \le -d,\\[4pt] 0, & -d < v < d,\\[4pt] v - d, & v \ge d. \end{cases} \]

Dead-zones destroy small-signal responsiveness: the linear model predicts a nonzero output for arbitrarily small inputs, while the real system does not respond until the input exceeds the dead-zone width.

Consider an LTI plant with state \( x_p \in \mathbb{R}^{n_p} \) and a linear controller with state \( x_c \in \mathbb{R}^{n_c} \):

\[ \begin{aligned} \dot{x}_p(t) &= A_p x_p(t) + B_p u(t), \quad y(t) = C_p x_p(t),\\[4pt] \dot{x}_c(t) &= A_c x_c(t) + B_c e(t), \quad v(t) = C_c x_c(t) + D_c e(t),\\[4pt] e(t) &= r(t) - y(t), \end{aligned} \]

where \( r(t) \) is the reference signal. In the ideal linear design we would set \( u(t) = v(t) \). With saturation the actuator command is

\[ u(t) = \varphi\bigl(v(t)\bigr) = \operatorname{sat}_{u_{\max}}\bigl(v(t)\bigr). \]

Introducing the combined state \( x = \begin{bmatrix} x_p' & x_c' \end{bmatrix}' \), we can write the closed-loop system as a Lur'e-type feedback interconnection:

\[ \dot{x}(t) = A x(t) + B \,\varphi\bigl(F x(t) + G r(t)\bigr) + H r(t), \]

for appropriately defined matrices \( A, B, F, G, H \) obtained by straightforward block-matrix manipulations from \( A_p, B_p, C_p \) and \( A_c, B_c, C_c, D_c \).

Near an equilibrium \( (x^\star, r^\star) \) where the actuator is not saturated (i.e., \( |v^\star| < u_{\max} \)), the nonlinearity has derivative \( \varphi'(v^\star) = 1 \) and the Jacobian of the nonlinear closed-loop system coincides with that of the linear design. However, if \( |v^\star| \ge u_{\max} \) or if transients force \( v(t) \) into saturation, the effective gain becomes \( \varphi'(v) = 0 \) in the saturated regions, and the local dynamics are governed by a different linearization. This is a first indication that linear predictions (e.g., from root locus or Bode plots) may fail for large signals.

flowchart TD
  R["r"] --> SUM["Sum r - y"]
  Y["y"] --> SUM
  SUM --> CBLK["Linear controller C"]
  CBLK --> SAT["Static nonlinearity 'sat'"]
  SAT --> P["Linear plant G"]
  P --> Y
        

The diagram emphasizes that a single static nonlinearity breaks the global linearity of the loop, even when the individual blocks \( C \) and \( G \) are strictly linear.

A powerful way to characterize static nonlinearities is via sector conditions. A nonlinearity \( \varphi:\mathbb{R} \to \mathbb{R} \) is said to belong to the sector \( [k_1, k_2] \) if for all \( v \in \mathbb{R} \),

\[ \bigl(\varphi(v) - k_1 v\bigr)\,\bigl(k_2 v - \varphi(v)\bigr) \ge 0. \]

Geometrically, the graph of \( \varphi(v) \) lies between two straight lines through the origin with slopes \( k_1 \) and \( k_2 \).

4.1 Saturation in Sector Form

For symmetric saturation with center slope 1, one can show:

\[ \operatorname{sat}_{u_{\max}} \in [0, 1]. \]

Proof sketch: for every \( v \),

• \( \operatorname{sat}_{u_{\max}}(v)\,v \ge 0 \) because the saturation has the same sign as \( v \).
• \( \bigl(\operatorname{sat}_{u_{\max}}(v) - v\bigr)\,v \le 0 \) because in the linear region the difference is zero, while in the saturated region the slope of the nonlinearity is smaller than 1, so the output is closer to zero in magnitude than \( v \).

Hence the inequalities \( 0 \le \operatorname{sat}_{u_{\max}}(v)\,v \le v^2 \) hold for all \( v \), which is equivalent to the sector condition with \( k_1=0,\,k_2=1 \).

4.2 Lur'e Systems and Limitations of Linear Design

The block diagram in Section 3 is an example of a Lur'e system, where a stable LTI block is in feedback with a static nonlinearity in a known sector. Classical absolute stability criteria (e.g., circle criterion, Popov criterion) give frequency-domain conditions on the linear part that guarantee closed-loop stability for all nonlinearities in a given sector.

The circle criterion, for instance, states that if the Nyquist plot of the LTI part lies outside a certain circle in the complex plane determined by the sector bounds \( [k_1, k_2] \), then the closed-loop Lur'e system is globally asymptotically stable. While a full derivation is beyond the scope of this introductory lesson, the key message is:

• Linear controller design that ignores saturation may produce a Nyquist curve that violates these geometric conditions.
• Such a design can be perfectly stable in the purely linear model but can lose stability or exhibit limit cycles once the real actuator saturates.

Thus, sector conditions bridge classical linear frequency-domain analysis with nonlinear stability guarantees and expose a fundamental limitation of naive linear design.

For oscillatory behavior in systems with weak nonlinearities, the describing function provides an approximate method to predict limit cycles using tools similar to those of linear analysis.

5.1 General Definition

Consider a scalar nonlinearity \( \varphi(v) \) excited by a sinusoidal input \( v(t) = A \sin(\omega t) \). If the output is approximately sinusoidal at the same frequency, \( u(t) \approx A N(A) \sin(\omega t) \), then the describing function \( N(A) \) is defined as

\[ N(A) = \frac{2}{\pi A}\int_{0}^{\pi} \varphi\bigl(A\sin\theta\bigr)\, \sin\theta\,\mathrm{d}\theta. \]

For odd nonlinearities such as symmetric saturation, the describing function is real and represents an amplitude-dependent effective gain.

5.2 Describing Function of Symmetric Saturation

Let \( \varphi(v) = \operatorname{sat}_{u_{\max}}(v) \) with symmetric limit \( \pm u_{\max} \). For small inputs \( A \le u_{\max} \), the nonlinearity acts linearly and \( N(A) = 1 \). For larger amplitudes \( A > u_{\max} \), define \( \delta = \arcsin\bigl(u_{\max}/A\bigr) \). One can show, by splitting the integral into unsaturated and saturated regions, that

\[ N(A) = \frac{2}{\pi}\Bigl( \delta + \sin\delta\cos\delta \Bigr), \quad A > u_{\max}, \]

where \( \sin\delta = u_{\max}/A \) and \( \cos\delta = \sqrt{1 - (u_{\max}/A)^2} \). Using these relations, we may also write

\[ N(A) = \frac{2}{\pi}\left( \arcsin\left(\frac{u_{\max}}{A}\right) + \frac{u_{\max}}{A}\sqrt{1 - \left(\frac{u_{\max}}{A}\right)^2} \right), \quad A > u_{\max}. \]

Sketch of derivation. For \( A > u_{\max} \), the input sinusoid is unsaturated only when \( |A\sin\theta| \le u_{\max} \), i.e., \( |\sin\theta| \le u_{\max}/A \). This corresponds to \( \theta \in [0,\delta] \cup [\pi-\delta,\pi] \) with \( \delta = \arcsin(u_{\max}/A) \). On this set, the output is \( \varphi(A\sin\theta) = A\sin\theta \); elsewhere, it is clamped to \( \pm u_{\max} \). Splitting the integral in the definition of \( N(A) \) accordingly, and exploiting symmetry, leads after straightforward calculations to the expression above.

In describing-function analysis, the closed-loop system with linear part transfer function \( G(s) \) and saturation is approximated by a linear loop with gain \( N(A) \) in place of the nonlinearity. A (approximate) limit cycle with amplitude \( A \) and frequency \( \omega \) satisfies

\[ 1 + N(A)\,G(\mathrm{j}\omega) = 0. \]

This equation shows explicitly how saturation can create self-sustained oscillations even when the purely linear closed-loop system is asymptotically stable, illustrating a profound limitation of linear design in the presence of nonlinearities.

Consider the second-order plant

\[ G(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

with parameters \( \omega_n = 1 \,\text{rad/s} \), \( \zeta = 0.2 \). Suppose we design a simple proportional controller

\[ C(s) = K, \quad u(t) = K\bigl(r(t) - y(t)\bigr), \]

assuming no saturation. Classical linear design might choose \( K = 8 \) to obtain a desired bandwidth and damping. In reality, the actuator is limited to \( |u(t)| \le u_{\max} \), with \( u_{\max} = 2 \), so that

\[ u(t) = \operatorname{sat}_{2}\Bigl(K\bigl(r(t) - y(t)\bigr)\Bigr). \]

We now simulate this closed-loop system in several programming environments to visualize the discrepancy between the linear prediction and the nonlinear reality for a unit step reference \( r(t) = 1 \).

The following Python code simulates the nonlinear closed-loop system using a simple explicit Euler method. The plant is expressed in state space as

\[ \dot{x}_1 = x_2,\quad \dot{x}_2 = -2\zeta\omega_n x_2 - \omega_n^2 x_1 + \omega_n^2 u,\quad y = x_1. \]

import numpy as np
import matplotlib.pyplot as plt

# Plant parameters
omega_n = 1.0
zeta = 0.2

# Controller parameters
K = 8.0
u_max = 2.0

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

def closed_loop_step(t_final=20.0, dt=1e-3):
    n_steps = int(t_final / dt)
    t = np.linspace(0.0, t_final, n_steps + 1)
    x = np.zeros((2, n_steps + 1))  # [x1; x2]
    y = np.zeros(n_steps + 1)
    u = np.zeros(n_steps + 1)

    for k in range(n_steps):
        r = 1.0  # unit step
        y[k] = x[0, k]
        e = r - y[k]
        v = K * e
        u[k] = sat(v, u_max)

        # state derivatives
        x1, x2 = x[:, k]
        dx1 = x2
        dx2 = -2.0 * zeta * omega_n * x2 - omega_n**2 * x1 + omega_n**2 * u[k]

        # Euler integration
        x[0, k+1] = x1 + dt * dx1
        x[1, k+1] = x2 + dt * dx2

    # final output at last step
    y[-1] = x[0, -1]
    e = 1.0 - y
    return t, y, u, e

if __name__ == "__main__":
    t, y, u, e = closed_loop_step()
    fig1, ax1 = plt.subplots()
    ax1.plot(t, y)
    ax1.set_xlabel("t [s]")
    ax1.set_ylabel("y(t)")
    ax1.set_title("Output with actuator saturation")

    fig2, ax2 = plt.subplots()
    ax2.plot(t, u)
    ax2.set_xlabel("t [s]")
    ax2.set_ylabel("u(t)")
    ax2.set_title("Saturated control input")

    plt.show()
      

Note that, compared to the linear prediction, the saturated system typically exhibits slower convergence and possibly overshoot patterns that differ from linear theory, especially if the initial error is large so that the actuator remains saturated for a significant time.

In more advanced work, one can use libraries such as python-control (commonly imported as import control) to define control.TransferFunction models and combine them with custom time-domain simulation including saturation, but the core idea remains the same as in the explicit Euler implementation shown above.

In C++, we can implement the same simulation using a simple time-stepping loop. For linear algebra-heavy control tasks one might use libraries like Eigen, but here we restrict ourselves to scalar operations.

#include <iostream>
#include <fstream>
#include <cmath>

double sat(double u, double u_max) {
    if (u > u_max) return u_max;
    if (u < -u_max) return -u_max;
    return u;
}

int main() {
    const double omega_n = 1.0;
    const double zeta = 0.2;
    const double K = 8.0;
    const double u_max = 2.0;

    const double t_final = 20.0;
    const double dt = 1e-3;
    const int n_steps = static_cast<int>(t_final / dt);

    double x1 = 0.0, x2 = 0.0;
    double t = 0.0;

    std::ofstream fout("saturation_response.csv");
    fout << "t,y,u\n";

    for (int k = 0; k <= n_steps; ++k) {
        double y = x1;
        double r = 1.0;
        double e = r - y;
        double v = K * e;
        double u = sat(v, u_max);

        fout << t << "," << y << "," << u << "\n";

        // plant dynamics
        double dx1 = x2;
        double dx2 = -2.0 * zeta * omega_n * x2
                     - omega_n * omega_n * x1
                     + omega_n * omega_n * u;

        x1 += dt * dx1;
        x2 += dt * dx2;
        t += dt;
    }

    fout.close();
    std::cout << "Simulation data written to saturation_response.csv\n";
    return 0;
}
      

The resulting CSV file can be plotted with any plotting tool. By comparing this response with the response of the purely linear system (obtained by removing the call to sat), one can quantify the control performance loss due to saturation.

Java can also be used to prototype control simulations. For matrix-based computations, libraries such as Apache Commons Math provide linear algebra routines, but the scalar second-order simulation can be written directly.

public class SaturationSimulation {
    static double sat(double u, double uMax) {
        if (u > uMax) return uMax;
        if (u < -uMax) return -uMax;
        return u;
    }

    public static void main(String[] args) {
        double omegaN = 1.0;
        double zeta = 0.2;
        double K = 8.0;
        double uMax = 2.0;

        double tFinal = 20.0;
        double dt = 1e-3;
        int nSteps = (int) (tFinal / dt);

        double x1 = 0.0;
        double x2 = 0.0;
        double t = 0.0;

        System.out.println("t,y,u");

        for (int k = 0; k <= nSteps; ++k) {
            double y = x1;
            double r = 1.0;
            double e = r - y;
            double v = K * e;
            double u = sat(v, uMax);

            System.out.println(t + "," + y + "," + u);

            double dx1 = x2;
            double dx2 = -2.0 * zeta * omegaN * x2
                        - omegaN * omegaN * x1
                        + omegaN * omegaN * u;

            x1 += dt * dx1;
            x2 += dt * dx2;
            t  += dt;
        }
    }
}
      

The printed data can be redirected to a file and post-processed, for example in MATLAB, Python, or any plotting tool, to inspect the saturated closed-loop response.

MATLAB, together with the Control System Toolbox and Simulink, is a standard environment for control-oriented simulations. Below we show a pure MATLAB script using ODE integration, and we briefly outline a Simulink block-diagram implementation.

10.1 MATLAB Script

% Parameters
omega_n = 1.0;
zeta    = 0.2;
K       = 8.0;
u_max   = 2.0;

% Nonlinear closed-loop dynamics
f = @(t, x) [ ...
    x(2); ...
    -2*zeta*omega_n*x(2) - omega_n^2*x(1) + ...
      omega_n^2*sat_fun(K*(1 - x(1)), u_max) ...
];

function u = sat_fun(v, u_max)
    u = min(max(v, -u_max), u_max);
end

% Simulate
tspan = [0 20];
x0 = [0; 0];
[t, x] = ode45(f, tspan, x0);
y = x(:, 1);

figure;
plot(t, y, 'LineWidth', 1.5);
grid on;
xlabel('t [s]');
ylabel('y(t)');
title('Closed-loop response with actuator saturation');
      

10.2 Simulink Realization

In Simulink, the nonlinear closed-loop system can be built using:

• A Transfer Fcn block representing \( G(s) \).
• A Gain block representing the proportional controller \( K \).
• A Sum block implementing \( e = r - y \).
• A Saturation block with limits \( \pm u_{\max} \).
• Scope blocks to visualize \( y(t) \) and \( u(t) \).

By comparing the response of the Simulink model with and without the Saturation block, one immediately observes the performance limitations introduced by actuator bounds and the potential for nonlinear phenomena such as long-lived transients and altered overshoot.

Mathematica provides symbolic and numerical solvers that are well suited for nonlinear dynamical systems. The following code uses NDSolve to simulate the same example:

omegaN = 1.0;
zeta   = 0.2;
K      = 8.0;
uMax   = 2.0;

sat[v_] := Piecewise[{
  {-uMax, v <= -uMax},
  {v, -uMax < v < uMax},
  {uMax, v >= uMax}
}];

eqs = {
  x1'[t] == x2[t],
  x2'[t] == -2 zeta omegaN x2[t] - omegaN^2 x1[t] +
            omegaN^2 sat[K (1 - x1[t])],
  x1[0] == 0,
  x2[0] == 0
};

sol = NDSolve[eqs, {x1, x2}, {t, 0, 20}][[1]];

Plot[Evaluate[x1[t] /. sol], {t, 0, 20},
  AxesLabel -> {"t", "y(t)"},
  PlotLabel -> "Closed-loop response with saturation"
]
      

One advantage of Mathematica is that it allows symbolic exploration of linearized models around equilibria, which can be compared with numerical simulations of the full nonlinear system to quantify the validity of the linear approximation.

Problem 1 (Sector Bound of Saturation): Show rigorously that the symmetric saturation nonlinearity \( \varphi(v) = \operatorname{sat}_{u_{\max}}(v) \) belongs to the sector \( [0, 1] \).

Solution:

We must show that for all \( v \in \mathbb{R} \),

\[ \bigl(\varphi(v) - 0\cdot v\bigr)\,\bigl(1\cdot v - \varphi(v)\bigr) \ge 0, \quad\text{i.e.,}\quad \varphi(v)\bigl(v - \varphi(v)\bigr) \ge 0. \]

We consider three cases:

1. If \( |v| < u_{\max} \), then \( \varphi(v) = v \). Hence \( \varphi(v)(v - \varphi(v)) = v(v - v) = 0 \ge 0 \).
2. If \( v \ge u_{\max} \), then \( \varphi(v) = u_{\max} \), and since \( v \ge u_{\max} \ge 0 \), we have \( v - \varphi(v) = v - u_{\max} \ge 0 \). Thus \( \varphi(v)(v - \varphi(v)) = u_{\max}(v - u_{\max}) \ge 0 \).
3. If \( v \le -u_{\max} \), then \( \varphi(v) = -u_{\max} \), and \( v - \varphi(v) = v + u_{\max} \le 0 \). The product of two non-positive numbers is non-negative, so \( \varphi(v)(v - \varphi(v)) \ge 0 \).

In all cases, the sector inequality holds, so \( \operatorname{sat}_{u_{\max}} \in [0,1] \).

Problem 2 (Equilibrium with Saturation): Consider the closed-loop system of Section 6 with plant \( G(s) = \omega_n^2/(s^2 + 2\zeta\omega_n s + \omega_n^2) \) and controller \( u(t) = \operatorname{sat}_{u_{\max}}(K(r - y)) \). For a constant reference \( r \), derive the equilibrium condition for the output \( y^\star \).

Solution:

At equilibrium, all derivatives are zero, so \( \dot{x}_1 = \dot{x}_2 = 0 \). From the plant equations,

\[ \dot{x}_1 = x_2 = 0,\quad \dot{x}_2 = -2\zeta\omega_n x_2 - \omega_n^2 x_1 + \omega_n^2 u = 0. \]

The first equation gives \( x_2^\star = 0 \). The second becomes

\[ -\omega_n^2 x_1^\star + \omega_n^2 u^\star = 0 \quad\Rightarrow\quad x_1^\star = u^\star. \]

Since the output is \( y^\star = x_1^\star \), the equilibrium condition is

\[ y^\star = \operatorname{sat}_{u_{\max}}\bigl(K(r - y^\star)\bigr). \]

This is a nonlinear algebraic equation in \( y^\star \). In the unsaturated regime, where \( |K(r - y^\star)| \le u_{\max} \), we have \( y^\star = K(r - y^\star) \), so

\[ (1 + K)\,y^\star = K r \quad\Rightarrow\quad y^\star = \frac{K}{1 + K} r. \]

If this solution violates the inequality \( |K(r - y^\star)| \le u_{\max} \), then the actuator is saturated at equilibrium. In that case, \( u^\star \) is either \( u_{\max} \) or \( -u_{\max} \), and the equilibrium satisfies \( y^\star = \pm u_{\max} \) with the sign chosen consistently with \( r - y^\star \).

Problem 3 (Describing Function Limit Cycle Condition): Let a stable LTI plant with transfer function \( G(s) \) be in feedback with a symmetric saturation nonlinearity. Using the describing function \( N(A) \) of Section 5, state the approximate condition for the existence of a limit cycle of amplitude \( A \) and frequency \( \omega \).

Solution:

The describing function method replaces the nonlinearity by an amplitude-dependent gain \( N(A) \) in the loop. The closed-loop characteristic equation of the approximate linearized system is

\[ 1 + N(A)\,G(s) = 0. \]

A limit cycle of frequency \( \omega \) corresponds to a root on the imaginary axis, i.e., \( s = \mathrm{j}\omega \), so the condition becomes

\[ 1 + N(A)\,G(\mathrm{j}\omega) = 0. \]

In polar form, this can be split into magnitude and phase conditions:

• Magnitude: \( |N(A)\,G(\mathrm{j}\omega)| = 1 \).
• Phase: \( \arg\bigl(N(A)\,G(\mathrm{j}\omega)\bigr) = -\pi \) (mod \( 2\pi \)).

Since \( N(A) \) is real and positive for symmetric saturation, the phase condition reduces to \( \arg G(\mathrm{j}\omega) = -\pi \) (mod \( 2\pi \)) and the magnitude condition simplifies to \( N(A)\,|G(\mathrm{j}\omega)| = 1 \). These equations can be solved graphically or numerically for \( A, \omega \), if a limit cycle exists.

Problem 4 (Integrator Windup and Saturation): Suppose the controller is PI, \( u(t) = K_p e(t) + K_i \int_0^t e(\tau)\,\mathrm{d}\tau \), with the same saturating actuator as before. Explain qualitatively why the integral term can cause very large overshoot and slow recovery when the actuator saturates, even if the linear PI design meets all specifications.

Solution:

In the linear PI design, the integrator accumulates error and drives the steady-state error to zero. When the actuator saturates, however, the actual input applied to the plant no longer follows the computed controller output. If a large error persists (for example, after a large step in \( r(t) \)), the integrator state keeps growing according to

\[ \frac{\mathrm{d}}{\mathrm{d}t} \Bigl(\int_0^t e(\tau)\,\mathrm{d}\tau\Bigr) = e(t), \]

even though the applied control \( u(t) \) is clamped at \( \pm u_{\max} \). This phenomenon is called integrator windup. Once the error changes sign or the signal leaves saturation, the integrator state may be extremely large, so the controller continues to command large control actions keeping the actuator in saturation for a long time. The closed-loop response thus exhibits:

• Large overshoot (the plant output keeps moving in the old direction while the integrator unwinds).
• Slow recovery to the desired operating point (the integrator state must decay before control signals reenter the linear region).

This behavior is not predicted by the linear PI model, which assumes unlimited actuator authority. Anti-windup schemes modify the controller structure specifically to account for saturation, thereby addressing a key limitation of naive linear design.

In this lesson, we investigated how static nonlinearities, especially actuator saturation and dead-zone, restrict the validity of linear control design. After formalizing saturation and dead-zone as static nonlinear maps, we embedded saturation into a state-space description of the closed-loop system and recognized the resulting Lur'e structure. Sector conditions provide a compact way to characterize such nonlinearities and connect them with frequency-domain stability criteria such as the circle criterion.

We introduced the describing function of symmetric saturation as an amplitude-dependent effective gain and derived its explicit form. This allows approximate prediction of limit cycles via the condition \( 1 + N(A)G(\mathrm{j}\omega) = 0 \), demonstrating that nonlinearities can produce oscillations even when the linear design is stable. Finally, we simulated a second-order plant with a saturated actuator in multiple programming environments, observing how saturation degrades tracking, modifies overshoot, and can cause integrator windup when combined with integral control.

In subsequent lessons in this chapter, we will broaden the discussion to limitations arising from strong coupling (MIMO systems), constraints, and large disturbances, and briefly indicate how modern nonlinear and robust control methodologies address some of these fundamental issues.