In cascade control, we nest two feedback loops around a process that can be decomposed into an inner (fast) subsystem and an outer (slow) subsystem. The outer loop regulates the final output \( y(t) \), while the inner loop regulates an intermediate variable \( y_1(t) \) that is closer to the actuator or to the main source of disturbances.

A typical decomposition of a SISO plant is into \( G_1(s) \) (actuator and local dynamics) and \( G_2(s) \) (main process dynamics). The controllers are \( C_1(s) \) for the inner loop and \( C_2(s) \) for the outer loop. The outer controller manipulates the setpoint \( v(t) \) of the inner loop instead of the actuator directly.

The essential idea is:

• The inner loop is designed to be fast and to reject disturbances acting on \( G_1(s) \).
• The outer loop then sees the inner closed loop as an effective plant and is designed more slowly.

flowchart TD
  R["r (outer setpoint)"]
  E2["Outer error e2 = r - y"]
  C2["Outer controller C2(s)"]
  V["Inner setpoint v"]
  E1["Inner error e1 = v - y1"]
  C1["Inner controller C1(s)"]
  G1["Inner plant G1(s)"]
  Y1["Inner variable y1"]
  G2["Outer plant G2(s)"]
  Y["Output y"]

  R --> E2
  Y --> E2
  E2 --> C2
  C2 --> V
  V --> E1
  Y1 --> E1
  E1 --> C1
  C1 --> G1
  G1 --> Y1
  Y1 --> G2
  G2 --> Y
        

Cascade architectures are ubiquitous in motion and robotic control, for example with an inner current or torque loop and an outer speed or position loop for a motor-driven joint. By designing the inner loop to be fast and well-damped, the outer loop sees a simplified, nearly first-order behavior.

Consider the inner loop alone. Let \( V(s) \) be the Laplace transform of the inner-loop setpoint \( v(t) \) and \( Y_1(s) \) that of the inner variable \( y_1(t) \). For a standard unity-feedback loop with controller \( C_1(s) \) and plant \( G_1(s) \):

\[ U_1(s) = C_1(s)\bigl(V(s) - Y_1(s)\bigr), \quad Y_1(s) = G_1(s) U_1(s). \]

Eliminating \( U_1(s) \), we obtain

\[ Y_1(s) = G_1(s) C_1(s)\bigl(V(s) - Y_1(s)\bigr) \quad \Rightarrow \quad Y_1(s)\bigl(1 + C_1(s) G_1(s)\bigr) = C_1(s) G_1(s) V(s). \]

Hence the closed-loop transfer function from inner setpoint \( V(s) \) to inner variable \( Y_1(s) \) is

\[ G_{\mathrm{cl},1}(s) \;=\; \frac{Y_1(s)}{V(s)} \;=\; \frac{C_1(s) G_1(s)}{1 + C_1(s) G_1(s)}. \]

The denominator \(1 + C_1(s) G_1(s)\) is the inner characteristic polynomial. Its roots determine the stability and transient behavior of the inner loop. In a cascade structure, we typically choose \( C_1(s) \) so that \( G_{\mathrm{cl},1}(s) \) is much faster than the dynamics of \( G_2(s) \), often approximating a well-damped first-order response.

The outer loop uses the inner closed loop as part of its plant. The signal flow is: \( R(s) \) (reference) enters the outer controller \( C_2(s) \) and produces the inner setpoint \( V(s) \), which is then converted by the inner loop into \( Y_1(s) \), and finally \( Y_1(s) \) passes through \( G_2(s) \) to produce the output \( Y(s) \).

Neglecting disturbances for the moment, we have

\[ V(s) = C_2(s)\bigl(R(s) - Y(s)\bigr), \qquad Y_1(s) = G_{\mathrm{cl},1}(s)V(s), \qquad Y(s) = G_2(s) Y_1(s). \]

Combining these relations, define the equivalent plant \( G_{\mathrm{eq}}(s) \) as seen by the outer controller:

\[ G_{\mathrm{eq}}(s) \;=\; G_{\mathrm{cl},1}(s)\,G_2(s). \]

The outer loop is now a standard unity-feedback loop with controller \( C_2(s) \) and plant \( G_{\mathrm{eq}}(s) \), so the overall closed-loop transfer function from reference \( R(s) \) to output \( Y(s) \) is

\[ T_{\mathrm{cas}}(s) \;=\; \frac{Y(s)}{R(s)} \;=\; \frac{C_2(s) G_{\mathrm{eq}}(s)} {1 + C_2(s) G_{\mathrm{eq}}(s)} \;=\; \frac{C_2(s) G_{\mathrm{cl},1}(s) G_2(s)} {1 + C_2(s) G_{\mathrm{cl},1}(s) G_2(s)}. \]

Note that if the inner loop is extremely fast, we can approximate \( G_{\mathrm{cl},1}(s) \approx k_1 \) (a constant gain) over the frequency range of interest for the outer loop. Then the outer-loop design essentially reduces to designing \( C_2(s) \) for the modified plant \( k_1 G_2(s) \).

A key motivation for cascade control is improved disturbance rejection for disturbances acting on the inner subsystem. Suppose an additive disturbance \( D_1(s) \) acts on the output of \( G_1(s) \), modeling for example a torque disturbance or an unmodeled load in a robotic actuator. The inner-loop dynamics become

\[ Y_1(s) = G_1(s) U_1(s) + D_1(s), \qquad U_1(s) = C_1(s)\bigl(V(s) - Y_1(s)\bigr). \]

Substituting \( U_1(s) \) yields

\[ Y_1(s) = G_1(s) C_1(s)\bigl(V(s) - Y_1(s)\bigr) + D_1(s) = G_1(s) C_1(s) V(s) - G_1(s) C_1(s) Y_1(s) + D_1(s). \]

Rearranging terms,

\[ Y_1(s)\bigl(1 + C_1(s) G_1(s)\bigr) = C_1(s) G_1(s) V(s) + D_1(s), \]

so the transfer function from \( D_1(s) \) to \( Y_1(s) \) is

\[ \frac{Y_1(s)}{D_1(s)} = \frac{1}{1 + C_1(s) G_1(s)}. \]

The final output is \( Y(s) = G_2(s) Y_1(s) \), therefore

\[ \frac{Y(s)}{D_1(s)} = \frac{G_2(s)}{1 + C_1(s) G_1(s)}. \]

For frequencies where the magnitude of the inner-loop open-loop transfer function \( C_1(j\omega) G_1(j\omega) \) is large and the inner loop is stable, the disturbance amplification factor \( \bigl|Y(s) / D_1(s)\bigr| \) becomes small. Thus, the inner loop rapidly compensates disturbances acting on \( G_1(s) \), effectively shielding the outer loop from them.

Without an inner loop, the same disturbance would directly propagate through the full plant \( G_1(s) G_2(s) \) before being attenuated by the single outer loop. Hence, cascade control is particularly advantageous when:

• Disturbances predominantly act on an identifiable subsystem (e.g., actuator side).
• A measurable intermediate variable \( y_1(t) \) is available with relatively small delay.
• The inner subsystem can be controlled to be significantly faster than the rest of the plant.

The basic workflow for designing a cascade controller for a SISO LTI system is:

1. Choose an intermediate variable \( y_1(t) \) that is measurable and close to key disturbances.
2. Model the inner subsystem \( G_1(s) \) and outer subsystem \( G_2(s) \).
3. Design the inner controller \( C_1(s) \) to achieve a fast, well-damped closed loop \( G_{\mathrm{cl},1}(s) \).
4. Form the equivalent plant \( G_{\mathrm{eq}}(s) = G_{\mathrm{cl},1}(s) G_2(s) \).
5. Design the outer controller \( C_2(s) \) for tracking and disturbance rejection at the system output.
6. Verify stability and robustness of the combined cascade structure.

flowchart TD
  A["Start: choose inner variable y1 and outer output y"]
  B["Model G1(s) and G2(s)"]
  C["Design inner controller C1(s) (fast loop)"]
  D["Close inner loop to get Gcl1(s)"]
  E["Form Geq(s) = Gcl1(s) * G2(s)"]
  F["Design outer controller C2(s)"]
  G["Check overall stability and robustness"]

  A --> B --> C --> D --> E --> F --> G
        

A frequently used rule of thumb for time-scale separation is that the inner-loop bandwidth (crossover frequency) should be several times larger than that of the outer loop, for example

\[ \omega_{c,1} \ge 3\,\omega_{c,2}, \]

where \( \omega_{c,1} \) is the frequency at which \( \lvert C_1(j\omega) G_1(j\omega)\rvert = 1 \) (inner-loop crossover) and \( \omega_{c,2} \) is the crossover frequency of the outer loop designed around \( G_{\mathrm{eq}}(s) \). This ensures that the outer controller mainly interacts with the quasi-static behavior of the inner loop.

In robotic servo drives, it is common to have a hierarchy such as:

• Inner current loop (fastest).
• Middle velocity loop.
• Outer position loop (slowest).

Each loop is designed assuming the inner loops are already well tuned and significantly faster.

We illustrate a simple continuous-time cascade control design with the python-control library (commonly used in robotics research for rapid prototyping). Let

\[ G_1(s) = \frac{5}{0.1 s + 1}, \qquad G_2(s) = \frac{2}{0.5 s + 1}, \]

representing a fast actuator plus a slower mechanical load. We choose simple proportional controllers \( C_1(s) = k_1 \), \( C_2(s) = k_2 \) for illustration.

import numpy as np
import control as ct
import matplotlib.pyplot as plt

# Laplace variable
s = ct.TransferFunction.s

# Inner and outer plants
G1 = 5 / (0.1 * s + 1)   # fast inner dynamics
G2 = 2 / (0.5 * s + 1)   # slower outer dynamics

# Inner and outer proportional controllers
k1 = 8.0   # inner-loop gain
k2 = 1.5   # outer-loop gain
C1 = k1
C2 = k2

# Inner closed loop: G_cl1(s) = C1*G1 / (1 + C1*G1)
G_cl1 = ct.feedback(C1 * G1, 1)

# Equivalent plant for outer loop
Geq = G_cl1 * G2

# Overall cascade closed loop
T_cascade = ct.feedback(C2 * Geq, 1)

# Compare with single-loop design (for reference)
G_single = G1 * G2
C_single = k1 * k2
T_single = ct.feedback(C_single * G_single, 1)

# Step responses
t = np.linspace(0, 5, 500)
t1, y_cas = ct.step_response(T_cascade, T=t)
t2, y_single = ct.step_response(T_single, T=t)

plt.figure()
plt.plot(t1, y_cas, label="Cascade closed loop")
plt.plot(t2, y_single, linestyle="--", label="Single-loop closed loop")
plt.xlabel("Time (s)")
plt.ylabel("Output y(t)")
plt.legend()
plt.grid(True)
plt.show()
      

In a robotic setting, \( G_1(s) \) may approximate the motor current loop, while \( G_2(s) \) approximates the joint mechanical dynamics. A library such as python-control can be integrated with higher-level frameworks like ROS for simulation and fast prototyping of cascade structures.

The following minimal C++ code sketches a discrete-time cascade controller that could be embedded in a real-time loop (for example as a custom controller in a ros_control or ros2_control framework). The inner loop regulates a velocity estimate, and the outer loop regulates position.

#include <iostream>

int main() {
    const double dt = 0.001;      // sampling time [s]
    const int N = 5000;           // simulation steps

    // Controller gains
    const double k1_p = 20.0;     // inner (velocity) P gain
    const double k2_p = 5.0;      // outer (position) P gain

    // Simple first-order plant model for velocity
    double v = 0.0;               // velocity state
    const double a = -50.0;       // pole coefficient
    const double b = 50.0;        // input gain

    double x = 0.0;               // position (integral of velocity)

    double r_pos = 1.0;           // desired position

    for (int k = 0; k < N; ++k) {
        // Outer loop: position control
        double e_pos = r_pos - x;
        double v_ref = k2_p * e_pos;     // desired velocity

        // Inner loop: velocity control
        double e_vel = v_ref - v;
        double u = k1_p * e_vel;        // actuator command (e.g., torque)

        // Plant update (Euler discretization)
        double dv = a * v + b * u;
        v += dv * dt;
        x += v * dt;

        if (k % 1000 == 0) {
            std::cout << "t = " << k * dt
                      << "  x = " << x
                      << "  v = " << v
                      << std::endl;
        }
    }
    return 0;
}
      

In practice, this logic would run inside a fixed-rate real-time loop, reading encoder measurements for position and velocity, and writing torque or current commands to the actuator. The inner loop must run at a high sampling rate to achieve the desired speed separation.

Java is less common in low-level robotic control, but it is used in some educational and industrial platforms (e.g., FIRST robotics). The following example shows a minimal object-oriented cascade controller with inner and outer proportional loops.

public class CascadeController {
    private double k1_p; // inner gain (velocity)
    private double k2_p; // outer gain (position)
    private double dt;

    private double v;    // velocity state
    private double x;    // position state

    public CascadeController(double k1_p, double k2_p, double dt) {
        this.k1_p = k1_p;
        this.k2_p = k2_p;
        this.dt = dt;
        this.v = 0.0;
        this.x = 0.0;
    }

    // One simulation step given desired position rPos
    public void step(double rPos) {
        double ePos = rPos - x;
        double vRef = k2_p * ePos;

        double eVel = vRef - v;
        double u = k1_p * eVel;

        // Simple plant model: dv/dt = -alpha * v + beta * u
        double alpha = 50.0;
        double beta = 50.0;
        double dv = -alpha * v + beta * u;

        v += dv * dt;
        x += v * dt;
    }

    public double getPosition() {
        return x;
    }

    public double getVelocity() {
        return v;
    }

    public static void main(String[] args) {
        CascadeController ctrl = new CascadeController(15.0, 4.0, 0.001);
        double rPos = 1.0;

        for (int k = 0; k < 5000; ++k) {
            ctrl.step(rPos);
            if (k % 1000 == 0) {
                System.out.println("t = " + (k * 0.001)
                        + "  x = " + ctrl.getPosition()
                        + "  v = " + ctrl.getVelocity());
            }
        }
    }
}
      

Such Java code can interface with platform-specific libraries for encoders and motor drivers, while preserving the cascade structure discussed in the theory.

MATLAB and Simulink are standard tools for control design and are widely used in robotics. The following script constructs the same cascade structure using transfer functions.

% Inner and outer plants
s = tf('s');
G1 = 5 / (0.1 * s + 1);
G2 = 2 / (0.5 * s + 1);

% Controllers
k1 = 8;  % inner
k2 = 1.5; % outer
C1 = k1;
C2 = k2;

% Inner closed loop
Gcl1 = feedback(C1 * G1, 1);

% Equivalent outer plant and cascade closed loop
Geq = Gcl1 * G2;
T_cascade = feedback(C2 * Geq, 1);

% Single-loop for comparison
G_single = G1 * G2;
C_single = k1 * k2;
T_single = feedback(C_single * G_single, 1);

% Step responses
figure;
step(T_cascade, T_single);
legend('Cascade', 'Single-loop');
title('Cascade vs Single-loop Step Response');
grid on;
      

In Simulink, you would instantiate nested feedback loops with Sum blocks, Gain blocks for \( C_1 \) and \( C_2 \), and Transfer Fcn blocks for \( G_1 \) and \( G_2 \). This structure closely matches implementation topologies used in industrial motion controllers.

Mathematica offers symbolic and numeric tools that are convenient for deriving and analyzing cascade structures symbolically before choosing numerical parameters.

(* Define Laplace variable and transfer functions *)
s = LaplaceTransformVariable;
G1 = 5/(0.1*s + 1);
G2 = 2/(0.5*s + 1);

k1 = 8;
k2 = 1.5;
C1 = k1;
C2 = k2;

(* Inner closed loop and equivalent outer plant *)
Gcl1 = FeedbackConnect[C1*G1, 1];
Geq = Gcl1*G2;

(* Overall cascade closed loop *)
Tcascade = FeedbackConnect[C2*Geq, 1];

(* Simplify the transfer function *)
TcascadeSimplified = TransferFunctionSimplify[Tcascade];

(* Step response *)
response = OutputResponse[TcascadeSimplified, UnitStep[t], t];
Plot[response, {t, 0, 5},
  AxesLabel -> {"t", "y(t)"},
  PlotLabel -> "Cascade Step Response"
]
      

Symbolic simplification can reveal how the closed-loop poles depend on controller gains, which helps in understanding the separation of time scales between inner and outer dynamics.

Problem 1 (Inner-loop closed-loop derivation): Consider an inner loop with controller \( C_1(s) \) and plant \( G_1(s) \) in unity negative feedback. Derive the closed-loop transfer function \( G_{\mathrm{cl},1}(s) = Y_1(s)/V(s) \) and the characteristic equation of the inner loop.

Solution:

The relations are

\[ U_1(s) = C_1(s)\bigl(V(s) - Y_1(s)\bigr), \qquad Y_1(s) = G_1(s) U_1(s). \]

Substituting \( U_1(s) \) into the second equation gives

\[ Y_1(s) = G_1(s) C_1(s)\bigl(V(s) - Y_1(s)\bigr) = G_1(s) C_1(s)V(s) - G_1(s) C_1(s)Y_1(s). \]

Rearranging,

\[ Y_1(s)\bigl(1 + C_1(s) G_1(s)\bigr) = C_1(s) G_1(s) V(s), \]

so

\[ G_{\mathrm{cl},1}(s) = \frac{Y_1(s)}{V(s)} = \frac{C_1(s) G_1(s)}{1 + C_1(s) G_1(s)}. \]

The characteristic equation of the inner loop is obtained by setting the denominator equal to zero: \( 1 + C_1(s) G_1(s) = 0 \). Its roots are the closed-loop poles of the inner loop.

Problem 2 (Overall closed-loop of cascade system): For a cascade system with inner closed loop \( G_{\mathrm{cl},1}(s) \), outer plant \( G_2(s) \), and outer controller \( C_2(s) \), derive the overall transfer function \( T_{\mathrm{cas}}(s) = Y(s)/R(s) \).

Solution:

First, define the equivalent plant as seen by the outer controller:

\[ G_{\mathrm{eq}}(s) = G_{\mathrm{cl},1}(s) G_2(s). \]

The outer loop is a standard unity-feedback loop:

\[ V(s) = C_2(s)\bigl(R(s) - Y(s)\bigr), \qquad Y(s) = G_{\mathrm{eq}}(s) V(s). \]

Eliminating \( V(s) \),

\[ Y(s) = G_{\mathrm{eq}}(s) C_2(s)\bigl(R(s) - Y(s)\bigr) = C_2(s) G_{\mathrm{eq}}(s)R(s) - C_2(s) G_{\mathrm{eq}}(s)Y(s). \]

Collecting terms in \( Y(s) \),

\[ Y(s)\bigl(1 + C_2(s) G_{\mathrm{eq}}(s)\bigr) = C_2(s) G_{\mathrm{eq}}(s) R(s), \]

so

\[ T_{\mathrm{cas}}(s) = \frac{Y(s)}{R(s)} = \frac{C_2(s) G_{\mathrm{eq}}(s)}{1 + C_2(s) G_{\mathrm{eq}}(s)} = \frac{C_2(s) G_{\mathrm{cl},1}(s) G_2(s)} {1 + C_2(s) G_{\mathrm{cl},1}(s) G_2(s)}. \]

Problem 3 (Disturbance rejection improvement): Consider a disturbance \( D_1(s) \) added to the output of \( G_1(s) \) in the inner loop, as modeled in Section 4. Show that the transfer function from \( D_1(s) \) to \( Y_1(s) \) is \( 1/(1 + C_1(s) G_1(s)) \), and interpret the result.

Solution:

The dynamics are

\[ Y_1(s) = G_1(s) U_1(s) + D_1(s), \qquad U_1(s) = C_1(s)\bigl(V(s) - Y_1(s)\bigr). \]

Substituting, we obtain

\[ Y_1(s) = G_1(s) C_1(s)\bigl(V(s) - Y_1(s)\bigr) + D_1(s) = G_1(s) C_1(s) V(s) - G_1(s) C_1(s) Y_1(s) + D_1(s). \]

Rearranging terms in \( Y_1(s) \) yields

\[ Y_1(s)\bigl(1 + C_1(s) G_1(s)\bigr) = C_1(s) G_1(s) V(s) + D_1(s). \]

Setting \( V(s) = 0 \) to study the disturbance response, we get

\[ Y_1(s)\bigl(1 + C_1(s) G_1(s)\bigr) = D_1(s), \quad\Rightarrow\quad \frac{Y_1(s)}{D_1(s)} = \frac{1}{1 + C_1(s) G_1(s)}. \]

If the inner loop is stable and has large loop gain at the disturbance frequency, the magnitude of this transfer function is small, so the disturbance has little effect on \( Y_1(t) \). This is the mechanism by which the inner loop protects the outer loop from disturbances acting on \( G_1(s) \).

Problem 4 (Time-scale separation condition): Let \( G_1(s) \) be approximately first-order with time constant \( T_1 \) in closed loop with \( C_1(s) \), and let \( G_2(s) \) be approximately first-order with time constant \( T_2 \). Give a simple inequality relating \( T_1 \) and \( T_2 \) that captures the idea of time-scale separation in cascade control, and explain why this inequality is reasonable.

Solution:

A simple and widely used heuristic is

\[ T_1 \le \frac{T_2}{3}. \]

That is, the inner loop should be at least about three times faster than the outer loop. This ensures that when the outer controller \( C_2(s) \) changes the setpoint \( v(t) \), the inner loop responds so quickly that, on the time scale of \( G_2(s) \), it can be approximated by a static gain. This justifies modeling the inner loop as a simple gain when designing \( C_2(s) \), and reduces the risk of undesirable interactions between the two loops.

Problem 5 (Equivalence to single-loop design): Assume \( G_{\mathrm{cl},1}(s) \approx k_1 \) in the frequency range of interest for the outer loop. Show that the cascade structure is approximately equivalent to a single-loop controller with controller \( C_{\mathrm{eq}}(s) = k_1 C_2(s) \) around the original plant \( G_2(s) \).

Solution:

If \( G_{\mathrm{cl},1}(s) \approx k_1 \), then the equivalent plant is

\[ G_{\mathrm{eq}}(s) = G_{\mathrm{cl},1}(s) G_2(s) \approx k_1 G_2(s). \]

The cascade outer loop has transfer function

\[ T_{\mathrm{cas}}(s) \approx \frac{C_2(s) k_1 G_2(s)}{1 + C_2(s) k_1 G_2(s)}. \]

A single-loop configuration with plant \( G_2(s) \) and controller \( C_{\mathrm{eq}}(s) = k_1 C_2(s) \) would have closed-loop transfer function

\[ T_{\mathrm{single}}(s) = \frac{C_{\mathrm{eq}}(s) G_2(s)}{1 + C_{\mathrm{eq}}(s) G_2(s)} = \frac{k_1 C_2(s) G_2(s)}{1 + k_1 C_2(s) G_2(s)}, \]

which is identical to the approximation for \( T_{\mathrm{cas}}(s) \). Thus, the cascade architecture behaves like a single-loop controller with appropriately scaled gain as long as the inner loop is much faster than the outer loop and remains well behaved.

In this lesson we introduced cascade control for SISO LTI systems. We showed how the inner loop forms a closed-loop subsystem with transfer function \( G_{\mathrm{cl},1}(s) = C_1(s) G_1(s) / \bigl(1 + C_1(s) G_1(s)\bigr) \), how the outer loop sees the equivalent plant \( G_{\mathrm{eq}}(s) = G_{\mathrm{cl},1}(s) G_2(s) \), and how the overall closed-loop transfer function is obtained. We analyzed disturbance rejection for disturbances acting on the inner subsystem and emphasized the role of time-scale separation between inner and outer loops.

Finally, we sketched implementations of cascade controllers in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, highlighting their relevance to robotic servo and motion control. Subsequent lessons will address systematic tuning of the inner and outer loops and the integration of cascade control with feedforward strategies.