In a typical cascade control architecture, the physical plant is partitioned into a fast inner subsystem and a slower outer subsystem, connected via a measured intermediate signal. For example, in a DC motor drive, the inner loop regulates armature current, while the outer loop regulates speed or position. Abstractly, we consider a plant factorization \( G(s) = G_i(s) G_o(s) \), where:

• \( G_i(s) \) is the inner plant (e.g., actuator or current dynamics),
• \( G_o(s) \) is the remaining dynamics seen by the outer loop.

The inner loop uses a controller \( C_i(s) \) to regulate the intermediate variable (e.g., current or torque) and forms an inner feedback loop. The outer controller \( C_o(s) \) then acts on an effective plant that already includes the closed inner dynamics.

Let \( v(s) \) denote the inner controlled variable and \( w(s) \) its reference generated by the outer loop. The inner loop (with unity feedback) has open-loop transfer function \( L_i(s) = C_i(s)G_i(s) \) and closed-loop transfer functions

\[ T_i(s) = \frac{C_i(s)G_i(s)}{1 + C_i(s)G_i(s)}, \qquad S_i(s) = \frac{1}{1 + C_i(s)G_i(s)}. \]

Here \( T_i(s) \) is the inner complementary sensitivity (reference to inner output), and \( S_i(s) \) is the inner sensitivity (disturbance and model-error transfer). For frequencies where \( \lvert L_i(j\omega) \rvert \gg 1 \), we have \( T_i(j\omega) \approx 1 \) and \( S_i(j\omega) \approx 0 \), so the inner variable tracks its reference almost perfectly and rejects disturbances effectively.

From the outer loop point of view, the inner loop plus inner plant behaves as an effective subsystem with transfer function

\[ G_{\mathrm{eff}}(s) = G_o(s) T_i(s). \]

The central idea of cascade design is therefore: first design a fast, robust inner loop such that \( T_i(s) \) is approximately constant in the frequency range where the outer loop will operate; then treat \( G_{\mathrm{eff}}(s) \) as the plant for the outer loop design (Lesson 3).

flowchart TD
  R["Outer reference r"] --> CO["Outer controller Co(s)"]
  CO --> W["Inner reference w"]
  W --> CI["Inner controller Ci(s)"]
  CI --> GI["Inner plant Gi(s)"]
  GI --> V["Intermediate variable v"]
  V --> GO["Outer plant Go(s)"]
  GO --> Y["Output y"]
  Y -->|feedback| CO
  V -->|feedback| CI
        

Consider the full cascade with unity feedback in both loops. The outer controller sees the effective plant \( G_{\mathrm{eff}}(s) = G_o(s)T_i(s) \). The outer open-loop transfer function is

\[ L_o(s) = C_o(s) G_{\mathrm{eff}}(s) = C_o(s) G_o(s) T_i(s). \]

The overall closed-loop sensitivity from reference \( r \) to output \( y \) is

\[ S(s) = \frac{1}{1 + L_o(s)} = \frac{1}{1 + C_o(s)G_o(s)T_i(s)}. \]

Suppose we design the outer loop under the simplifying assumption that the inner loop is ideal, i.e. \( T_i(s) = K_{\mathrm{in}} \) (a constant gain, often normalized to \( K_{\mathrm{in}} = 1 \)). In reality, \( T_i(s) \) is a dynamic transfer function. We can quantify the deviation from the ideal model by writing

\[ T_i(s) = K_{\mathrm{in}}\bigl(1 + \Delta_i(s)\bigr), \]

where \( \Delta_i(s) \) captures the inner-loop dynamics and modeling error as seen by the outer loop. The actual outer open-loop is then

\[ L_o^{\mathrm{real}}(s) = C_o(s)G_o(s)K_{\mathrm{in}}\bigl(1 + \Delta_i(s)\bigr) = L_o^{\mathrm{ideal}}(s)\bigl(1 + \Delta_i(s)\bigr), \]

where \( L_o^{\mathrm{ideal}}(s) = C_o(s)G_o(s)K_{\mathrm{in}} \) is the loop gain used for outer-loop design. The corresponding closed-loop sensitivities satisfy

\[ S^{\mathrm{real}}(s) - S^{\mathrm{ideal}}(s) = \frac{1}{1 + L_o^{\mathrm{ideal}}(s)\bigl(1 + \Delta_i(s)\bigr)} - \frac{1}{1 + L_o^{\mathrm{ideal}}(s)}. \]

With algebra, we obtain

\[ S^{\mathrm{real}}(s) - S^{\mathrm{ideal}}(s) = \frac{-L_o^{\mathrm{ideal}}(s)\,\Delta_i(s)}% {\bigl(1 + L_o^{\mathrm{ideal}}(s)\bigr)\bigl(1 + L_o^{\mathrm{ideal}}(s)\bigl(1 + \Delta_i(s)\bigr)\bigr)}. \]

Taking magnitudes, a sufficient condition for the deviation to be small in a frequency band \( \Omega \) is

\[ \sup_{\omega \in \Omega} \left\lvert \Delta_i(j\omega)\right\rvert \ll \inf_{\omega \in \Omega} \left\lvert 1 + L_o^{\mathrm{ideal}}(j\omega)\right\rvert. \]

In words: the inner-loop deviation from the ideal constant gain must remain small over frequencies where the outer loop has non-negligible loop gain. This leads directly to the heuristic that the inner loop should be substantially faster than the outer loop.

We now formalize performance and robustness goals for the inner loop. Let \( \omega_{c,i} \) denote the inner-loop gain crossover frequency and \( \omega_{c,o} \) the outer-loop crossover frequency. A widely used separation principle is:

\[ \frac{\omega_{c,i}}{\omega_{c,o}} \approx k_{\mathrm{sep}}, \qquad 4 \le k_{\mathrm{sep}} \le 10. \]

This ensures that, over the outer-loop bandwidth, the inner loop behaves almost statically. In the time domain, if the outer loop is designed to have a dominant settling time \( T_{s,o} \), the inner loop should satisfy roughly

\[ T_{s,i} \le \frac{T_{s,o}}{k_{\mathrm{sep}}}. \]

For a well-damped second-order equivalent inner loop, the 2% settling time is approximately \( T_{s,i} \approx \frac{4}{\zeta_i \omega_{n,i}} \), where \( \zeta_i \) is the damping ratio and \( \omega_{n,i} \) the natural frequency of the inner closed-loop dynamics.

Robust stability of the inner loop is characterized by classical margins:

• Inner phase margin \( \mathrm{PM}_i \) typically between 45° and 70°.
• Inner gain margin \( \mathrm{GM}_i \) typically > 6 dB.

These margins must be achieved for the inner loop before the outer loop is closed. A narrow inner margin can severely restrict the achievable performance of the outer loop and may even lead to closed-loop instability of the overall cascade.

To explicitly account for modeling uncertainty in the inner plant, suppose the true inner dynamics can be written as a multiplicative perturbation

\[ G_i^{\mathrm{true}}(s) = G_i(s)\bigl(1 + W_i(s)\Delta(s)\bigr), \qquad \lvert \Delta(j\omega)\rvert \le 1. \]

Here \( W_i(s) \) describes the frequency-dependent uncertainty level. Classical robustness theory shows that the inner loop is robustly stable if

\[ \sup_{\omega} \left\lvert W_i(j\omega) T_i(j\omega) \right\rvert < 1. \]

Since the outer loop will operate primarily at low and medium frequencies, inner-loop design is often guided by the simpler working rules:

• Ensure \( T_i(j\omega) \approx 1 \) for \( \omega \le \omega_{c,o} \).
• Ensure \( \lvert T_i(j\omega) \rvert \) is not excessively large at high frequencies, to avoid amplifying measurement noise and unmodeled dynamics.

A systematic design procedure for inner-loop tuning in cascade structures can be summarized as follows.

1. Partition the plant: choose \( G_i(s) \) and \( G_o(s) \) such that \( G_i(s) \) captures the fastest and most direct dynamics associated with the actuator or inner variable.
2. Specify inner performance: choose a target bandwidth \( \omega_{c,i} \) and damping ratio \( \zeta_i \), respecting actuator limits and the desired separation relative to the outer loop.
3. Select controller structure: typically PI for inner loops with a first-order-like plant, or PID/lead for more complex dynamics.
4. Tune using frequency or pole-placement methods: compute controller parameters so that the closed-loop characteristic polynomial meets the desired \( \zeta_i \) and \( \omega_{n,i} \), and verify classical margins.
5. Check robustness: evaluate \( T_i(j\omega) \), \( S_i(j\omega) \), and margins for plausible uncertainty models \( W_i(s) \).
6. Freeze the inner loop: once satisfactory, treat \( G_{\mathrm{eff}}(s) = G_o(s)T_i(s) \) as the new plant for outer-loop design (Lesson 3).

flowchart TD
  A["Select inner plant Gi(s)"] --> B["Specify inner specs (bandwidth, damping, margins)"]
  B --> C["Choose structure (PI / PID / lead)"]
  C --> D["Tune gains from model or frequency response"]
  D --> E["Check Ti(s), Si(s), gain/phase margins"]
  E --> F{"Robust and fast enough?"}
  F -->|no| B
  F -->|yes| G["Freeze inner loop and expose Geff(s) = Go(s)*Ti(s) to outer design"]
        

Consider an inner current loop of a DC motor. Neglecting back-EMF for the moment, the armature current dynamics are well approximated by an RL circuit

\[ L\frac{di(t)}{dt} + R i(t) = K_u u(t), \]

where \( i(t) \) is the current, \( u(t) \) the applied voltage command from the inner controller, \( L \) the inductance, \( R \) the resistance, and \( K_u \) a gain factor (including converter gain). The transfer function from voltage to current is

\[ G_i(s) = \frac{I(s)}{U(s)} = \frac{K_u}{L s + R}. \]

We choose a PI controller

\[ C_i(s) = k_p + \frac{k_i}{s}, \]

so that the inner closed-loop will have zero steady-state error to a current step and sufficiently fast transient behavior.

\[ L_i(s) = C_i(s)G_i(s) = \left(k_p + \frac{k_i}{s}\right) \frac{K_u}{L s + R}. \]

The closed-loop transfer from current reference \( W(s) \) to current \( I(s) \) is

\[ T_i(s) = \frac{I(s)}{W(s)} = \frac{C_i(s)G_i(s)}{1 + C_i(s)G_i(s)} = \frac{k_p K_u s + k_i K_u}{L s^2 + (R + k_p K_u)s + k_i K_u}. \]

We would like \( T_i(s) \) to behave as a well-damped second-order system with desired natural frequency \( \omega_{n,i} \) and damping ratio \( \zeta_i \), i.e.

\[ T_i(s) \approx \frac{\omega_{n,i}^2}{s^2 + 2 \zeta_i \omega_{n,i} s + \omega_{n,i}^2}. \]

Matching coefficients of the denominator with the actual closed-loop denominator \( L s^2 + (R + k_p K_u)s + k_i K_u \), we require

\[ L s^2 + (R + k_p K_u)s + k_i K_u = L \bigl( s^2 + 2 \zeta_i \omega_{n,i} s + \omega_{n,i}^2 \bigr), \]

which yields the design equations

\[ \begin{aligned} R + k_p K_u &= 2 L \zeta_i \omega_{n,i}, \\ k_i K_u &= L \omega_{n,i}^2. \end{aligned} \]

Therefore, given \( L \), \( R \), \( K_u \), and desired \( \zeta_i \), \( \omega_{n,i} \), we choose

\[ k_p = \frac{2 L \zeta_i \omega_{n,i} - R}{K_u}, \qquad k_i = \frac{L \omega_{n,i}^2}{K_u}. \]

To respect the speed hierarchy between inner and outer loops, one selects \( \omega_{n,i} \) such that \( \omega_{n,i} \) is several times larger than the natural frequency targeted by the outer loop. At the same time, actuator saturation and noise amplification must be checked: too large \( k_p \) and \( k_i \) may drive the converter into saturation or excite unmodeled high-frequency effects.

We now implement the RL current-loop example using Python and the python-control library. In robotics, similar inner loops appear inside motor drives and joint-level controllers. The same design can be used in conjunction with robotic simulation environments such as roboticstoolbox for Python.

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

# Inner plant parameters (example DC motor current loop)
L = 2e-3     # H
R = 0.5      # Ohm
Ku = 1.0     # converter gain (V-to-current scaling)

# Desired inner closed-loop specs
zeta_i = 0.7
omega_n_i = 500.0  # rad/s, gives very fast inner response

# PI design from the analytical formulas
kp = (2.0 * L * zeta_i * omega_n_i - R) / Ku
ki = (L * omega_n_i**2) / Ku

print("Inner PI gains: kp = {:.3f}, ki = {:.3f}".format(kp, ki))

# Transfer function models
s = ct.TransferFunction.s
Gi = Ku / (L * s + R)
Ci = kp + ki / s

Li = Ci * Gi               # inner open-loop
Ti = ct.feedback(Li, 1)    # inner closed-loop complementary sensitivity
Si = 1 - Ti                # inner sensitivity

# Step response of inner loop (current reference step)
t, y = ct.step_response(Ti)
plt.figure()
plt.plot(t, y)
plt.xlabel("t [s]")
plt.ylabel("i(t) / i_ref")
plt.title("Inner current loop step response")
plt.grid(True)

# Bode magnitude and margins for inner loop
plt.figure()
ct.bode_plot(Li, dB=True, Hz=False, omega_limits=(10, 1e4))
gm, pm, wcg, wcp = ct.margin(Li)
print("Inner loop margins: GM = {:.2f} dB, PM = {:.1f} deg".format(
    20.0 * np.log10(gm), pm))

plt.show()
      

In a robotic context, the designed Ci would typically be implemented inside the motor driver firmware, while higher-level joint position or torque controllers run in a separate layer using robot-specific libraries (e.g., torque or current commands via a fieldbus or ROS interface).

In embedded robotic controllers, inner loops are often implemented in C or C++ at high sampling rates. The code below illustrates a simple discrete-time PI current controller based on Euler integration of the RL dynamics. Libraries such as Eigen are commonly used for vectorized operations in multi-joint robots, while higher-level frameworks (e.g., ros_control or ros2_control) integrate such inner loops into full robotic systems.

#include <iostream>
#include <vector>

struct InnerPiController {
    double kp;
    double ki;
    double dt;
    double integral;

    InnerPiController(double kp_, double ki_, double dt_)
        : kp(kp_), ki(ki_), dt(dt_), integral(0.0) {}

    double update(double i_ref, double i_meas) {
        double e = i_ref - i_meas;
        integral += e * dt;
        double u = kp * e + ki * integral;
        return u;
    }
};

int main() {
    // RL parameters
    double L = 2e-3;
    double R = 0.5;
    double Ku = 1.0;

    // Same gains as in the Python example (numerical values could be copied)
    double kp = 1.4;   // example value
    double ki = 500.0; // example value
    double dt = 1e-4;  // 10 kHz sampling

    InnerPiController ctrl(kp, ki, dt);

    double i = 0.0;        // current state
    double i_ref = 5.0;    // desired current [A]
    double u = 0.0;        // control voltage

    int steps = 2000;
    for (int k = 0; k < steps; ++k) {
        // Controller update
        u = ctrl.update(i_ref, i);

        // Discrete-time RL model (forward Euler)
        double di_dt = (-R * i + Ku * u) / L;
        i += dt * di_dt;

        if (k % 100 == 0) {
            double t = k * dt;
            std::cout << t << " " << i << std::endl;
        }
    }

    return 0;
}
      

In a real robot, this code would run in a real-time loop inside a motor driver or low-level controller, receiving a current reference from an outer torque or velocity loop and sending PWM or voltage commands to the power electronics.

Java is less common for very low-level control but is used in educational robotics (e.g., FIRST/WPILib). The following code demonstrates a simple time-domain simulation of the same inner PI current loop. The pattern is similar: a discrete-time PI controller plus an RL model integration.

public class InnerPiCurrentLoop {

    private final double kp;
    private final double ki;
    private final double dt;
    private double integral;

    public InnerPiCurrentLoop(double kp, double ki, double dt) {
        this.kp = kp;
        this.ki = ki;
        this.dt = dt;
        this.integral = 0.0;
    }

    public double update(double iRef, double iMeas) {
        double e = iRef - iMeas;
        integral += e * dt;
        return kp * e + ki * integral;
    }

    public static void main(String[] args) {
        // RL parameters
        double L = 2e-3;
        double R = 0.5;
        double Ku = 1.0;

        double kp = 1.4;    // example PI gains
        double ki = 500.0;
        double dt = 1e-4;

        InnerPiCurrentLoop controller = new InnerPiCurrentLoop(kp, ki, dt);

        double i = 0.0;
        double iRef = 5.0;

        int steps = 2000;
        for (int k = 0; k < steps; ++k) {
            double u = controller.update(iRef, i);

            // RL model: di/dt = (-R * i + Ku * u) / L
            double di_dt = (-R * i + Ku * u) / L;
            i += dt * di_dt;

            if (k % 100 == 0) {
                double t = k * dt;
                System.out.println(t + " " + i);
            }
        }
    }
}
      

In Java-based robotic platforms, the same inner-loop idea appears when users configure motor controller objects with given current or velocity loop gains, while the SDK hides the low-level discretization and scheduling details.

MATLAB and Simulink are widely used in control and robotics. The following script reproduces the PI inner loop design using Control System Toolbox functions. In a Simulink model, the same controller and plant would be implemented as blocks, often integrated with Robotics System Toolbox and Simscape Electrical models.

% Inner plant parameters
L = 2e-3;   % H
R = 0.5;    % Ohm
Ku = 1.0;   % gain

% Desired inner closed-loop specs
zeta_i = 0.7;
omega_n_i = 500;   % rad/s

% PI design
kp = (2 * L * zeta_i * omega_n_i - R) / Ku;
ki = (L * omega_n_i^2) / Ku;

% Transfer functions
s = tf('s');
Gi = Ku / (L * s + R);
Ci = kp + ki / s;

Li = Ci * Gi;
Ti = feedback(Li, 1);
Si = 1 - Ti;

% Step response
figure;
step(Ti);
grid on;
title('Inner current loop step response');

% Bode and margins
figure;
margin(Li);
grid on;
title('Inner loop Bode plot and margins');

disp('Inner PI gains:');
disp(table(kp, ki));
      

In Simulink, one typically represents the current loop using a PI Controller block, an RL plant model (either as a transfer function or as a physical Simscape model), and a feedback measurement block. The outer speed or position loop is then added on top, using the current loop as part of the actuator model.

Mathematica is useful for symbolic derivations and numerical analysis of inner-loop designs. The following code defines the inner RL plant, designs a PI controller, and computes the inner closed-loop transfer function.

(* Parameters *)
L = 2*10^-3;
R = 0.5;
Ku = 1.0;

zetaI = 0.7;
omegaNI = 500.0;

kp = (2*L*zetaI*omegaNI - R)/Ku;
ki = (L*omegaNI^2)/Ku;

s = LaplaceTransformVariable;

Gi = TransferFunctionModel[Ku/(L*s + R), s];
Ci = TransferFunctionModel[kp + ki/s, s];

Li = Series[Ci["TransferFunction"]*Gi["TransferFunction"], {s, Infinity, 0}];
Ti = SystemsModelFeedbackConnect[Ci*Gi, 1];

(* Simplify closed-loop transfer function *)
TiSimplified = TransferFunctionCancel[Ti]

(* Step response plot *)
stepPlot = OutputResponse[Ti, UnitStep[t], {t, 0, 0.05}];
ListLinePlot[stepPlot, AxesLabel -> {"t", "i(t)/i_ref"}, 
  PlotRange -> All, GridLines -> Automatic]
      

Symbolic manipulation in Mathematica can also be used to derive inner-loop design formulas (such as the PI gains above) from more complex plant models that might arise in robotic actuators with additional parasitic effects.

Problem 1 (Closed-Loop Inner Transfer Functions): Consider an inner loop with unity feedback, inner plant \( G_i(s) \), and controller \( C_i(s) \). The inner reference is \( W(s) \), and the measured variable is \( V(s) \). Derive the transfer functions \( T_i(s) = V(s)/W(s) \) and \( S_i(s) \) relating an additive disturbance \( D(s) \) at the plant input to the output.

Solution: The loop equations are

\[ E(s) = W(s) - V(s), \qquad U(s) = C_i(s)E(s), \]

\[ V(s) = G_i(s)\bigl(U(s) + D(s)\bigr) = G_i(s)\bigl(C_i(s)(W(s) - V(s)) + D(s)\bigr). \]

Collecting terms in \( V(s) \):

\[ V(s)\bigl(1 + C_i(s)G_i(s)\bigr) = C_i(s)G_i(s)W(s) + G_i(s)D(s). \]

Hence

\[ T_i(s) = \frac{V(s)}{W(s)} = \frac{C_i(s)G_i(s)}{1 + C_i(s)G_i(s)}, \qquad \frac{V(s)}{D(s)} = \frac{G_i(s)}{1 + C_i(s)G_i(s)}. \]

The disturbance-to-output transfer is therefore \( S_i(s)G_i(s) \) with \( S_i(s) = \frac{1}{1 + C_i(s)G_i(s)} \). The standard notation calls \( S_i(s) \) the sensitivity and \( T_i(s) \) the complementary sensitivity.

Problem 2 (Inner Bandwidth and Outer Robustness): Assume the inner loop has closed-loop transfer \( T_i(s) = \frac{\omega_{n,i}^2}{s^2 + 2\zeta_i \omega_{n,i}s + \omega_{n,i}^2} \) with \( \zeta_i = 0.7 \) and \( \omega_{n,i} = 10 \omega_{n,o} \), where \( \omega_{n,o} \) is the dominant natural frequency of the outer loop. Show that, for frequencies near \( \omega_{n,o} \), the magnitude of \( T_i(j\omega) \) is close to 1 and estimate the error \( \lvert T_i(j\omega_{n,o}) - 1 \rvert \).

Solution: Evaluate at \( \omega = \omega_{n,o} \):

\[ T_i(j\omega_{n,o}) = \frac{\omega_{n,i}^2}{-\omega_{n,o}^2 + j 2\zeta_i \omega_{n,i}\omega_{n,o} + \omega_{n,i}^2}. \]

With \( \omega_{n,i} = 10 \omega_{n,o} \), we obtain

\[ T_i(j\omega_{n,o}) = \frac{100 \omega_{n,o}^2}{-\omega_{n,o}^2 + j 20 \zeta_i \omega_{n,o}^2 + 100 \omega_{n,o}^2} = \frac{100}{99 + j 20 \zeta_i}. \]

For \( \zeta_i = 0.7 \), the denominator magnitude is \( \sqrt{99^2 + (14)^2} \approx \sqrt{9801 + 196} \approx \sqrt{9997} \approx 99.985 \), so

\[ \lvert T_i(j\omega_{n,o}) \rvert \approx \frac{100}{99.985} \approx 1.00015. \]

Thus \( \lvert T_i(j\omega_{n,o}) - 1 \rvert \) is on the order of \( 1.5 \times 10^{-4} \), confirming that the inner loop is almost indistinguishable from a unity gain over the outer-loop bandwidth when its natural frequency is ten times larger.

Problem 3 (PI Design via Pole Placement): For the RL current loop with transfer function \( G_i(s) = \frac{K_u}{L s + R} \), derive the PI gains that yield a closed-loop characteristic polynomial \( s^2 + 2\zeta_i \omega_{n,i} s + \omega_{n,i}^2 \).

Solution: From the derivation in Section 5, the denominator of the closed loop is

\[ L s^2 + (R + k_p K_u)s + k_i K_u. \]

Equating coefficients with \( L s^2 + 2L \zeta_i \omega_{n,i}s + L\omega_{n,i}^2 \) yields

\[ \begin{aligned} R + k_p K_u &= 2L \zeta_i \omega_{n,i}, \\ k_i K_u &= L \omega_{n,i}^2. \end{aligned} \]

Solving for the gains gives

\[ k_p = \frac{2L \zeta_i \omega_{n,i} - R}{K_u}, \qquad k_i = \frac{L \omega_{n,i}^2}{K_u}. \]

These formulas are valid provided \( 2 L \zeta_i \omega_{n,i} > R \), ensuring \( k_p > 0 \).

Problem 4 (Inner Robustness Constraint): Let the inner plant have multiplicative uncertainty \( G_i^{\mathrm{true}}(s) = G_i(s)\bigl(1 + W_i(s)\Delta(s)\bigr) \), with \( \lvert \Delta(j\omega)\rvert \le 1 \). Show that a sufficient condition for robust stability of the inner loop is \( \sup_{\omega} \lvert W_i(j\omega)T_i(j\omega)\rvert < 1 \).

Solution: The unity-feedback interconnection of the nominal loop and the multiplicative uncertainty can be represented as a feedback of the stable system \( W_i(s)T_i(s) \) with \( \Delta(s) \). Robust stability for all \( \Delta \) with \( \lvert \Delta(j\omega)\rvert \le 1 \) follows from the small-gain theorem, which states that the closed loop is stable if

\[ \sup_{\omega} \left\lvert W_i(j\omega)T_i(j\omega)\right\rvert \cdot \sup_{\omega} \lvert \Delta(j\omega)\rvert < 1. \]

Since \( \sup_{\omega} \lvert \Delta(j\omega)\rvert \le 1 \) by assumption, it suffices that

\[ \sup_{\omega} \left\lvert W_i(j\omega)T_i(j\omega)\right\rvert < 1, \]

which is the claimed sufficient condition.

Problem 5 (Speed Hierarchy Constraints): Suppose an outer position loop is designed to have a dominant settling time \( T_{s,o} = 0.2 \,\text{s} \). You require a separation factor \( k_{\mathrm{sep}} = 5 \) and use the approximation \( T_{s,i} \approx \frac{4}{\zeta_i \omega_{n,i}} \) with \( \zeta_i = 0.7 \). Compute a lower bound on \( \omega_{n,i} \) that ensures the desired speed hierarchy.

Solution: The separation requirement is

\[ T_{s,i} \le \frac{T_{s,o}}{k_{\mathrm{sep}}} = \frac{0.2}{5} = 0.04 \,\text{s}. \]

Using \( T_{s,i} \approx \frac{4}{\zeta_i \omega_{n,i}} \) with \( \zeta_i = 0.7 \) gives

\[ \frac{4}{0.7 \omega_{n,i}} \le 0.04 \quad \Rightarrow \quad \omega_{n,i} \ge \frac{4}{0.7 \cdot 0.04} = \frac{4}{0.028} \approx 142.857 \,\text{rad/s}. \]

In practice, one might choose \( \omega_{n,i} \) somewhat larger (e.g., 200–300 rad/s) to allow margin for modeling error and actuator limitations.

In this lesson, we analyzed the role of inner loops in cascade control, deriving the inner complementary sensitivity \( T_i(s) \) and sensitivity \( S_i(s) \), and showing how the outer loop effectively sees the plant \( G_{\mathrm{eff}}(s) = G_o(s)T_i(s) \). We formalized speed and robustness requirements for the inner loop in terms of bandwidth separation, settling time, and classical stability margins, and we connected these requirements to multiplicative uncertainty models via small-gain conditions. A detailed RL current-loop example demonstrated PI design by pole placement, and multi-language implementations illustrated how such inner loops appear in practical robotic systems. In the next lesson, we will design outer loops on top of an already tuned inner loop, treating \( G_{\mathrm{eff}}(s) \) as the new plant.