In earlier lessons of this chapter, we introduced sources of uncertainty, such as parameter errors and unmodeled dynamics, and we built simple uncertainty representations (parametric intervals, additive and multiplicative uncertainty on transfer functions). In this lesson, we perform case studies that explicitly connect these uncertainty descriptions to:

• Closed-loop characteristic polynomials and pole locations,
• Time-domain performance (overshoot, settling time), and
• Frequency-domain robustness (stability margins under unmodeled dynamics).

We consider unity-feedback systems with plant \( G(s) \) and controller \( C(s) \). The loop transfer function is \( L(s) = C(s)G(s) \) and the standard sensitivity and complementary sensitivity functions are

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

If the plant is perturbed from a nominal model \( G_0(s) \) to \( G(s) = G_0(s) + \delta G(s) \), then with \( L_0(s) = C(s)G_0(s) \) and \( S_0(s) \) the nominal sensitivity, a first-order (local) variation of \( T(s) \) satisfies

\[ \delta T(s) = \frac{\partial T}{\partial L}\Big|_{L=L_0(s)} \delta L(s) = S_0(s)^2\,\delta L(s) = S_0(s)^2\,C(s)\,\delta G(s). \]

Hence, frequencies where \( |S_0(j\omega)| \) is large are most sensitive to modeling error. Our case studies will repeatedly interpret uncertainty effects via \( S \), \( T \), and the closed-loop characteristic polynomial.

flowchart TD
  U["Uncertainty (param errors, unmodeled dyn)"]
    --> P0["Nominal plant G(s)"]
  P0 --> C["Controller C(s)"]
  C --> L["Loop L(s) = C(s)G(s)"]
  L --> ST["Closed-loop S(s), T(s)"]
  ST --> TD["Time response (overshoot, settling)"]
  ST --> FD["Freq response (margins)"]
  U --> CHECK["Compare true vs nominal behaviour"]
        

Consider a simplified translational robotic joint or servo, modeled (after linearization) as a mass–spring–damper system driven by a force input and with position output:

\[ G(s;m) = \frac{X(s)}{F(s)} = \frac{1}{m s^2 + d s + k}, \]

where \( m \) is the effective mass (including payload), \( d \) viscous friction, and \( k \) effective stiffness (e.g., actuator compliance). We use a PD controller

\[ C(s) = K_p + K_d s, \]

and form a unity-feedback loop to track a position reference \( r(t) \). The closed-loop characteristic equation is

\[ 1 + C(s)G(s;m) = 0 \;\Longleftrightarrow\; m s^2 + d s + k + (K_p + K_d s) = 0, \]

i.e.

\[ m s^2 + (d + K_d) s + (k + K_p) = 0. \]

Dividing by \( m \) we obtain the standard second-order form

\[ s^2 + \frac{d + K_d}{m} s + \frac{k + K_p}{m} = 0. \]

Comparing to the canonical second-order characteristic polynomial \( s^2 + 2\zeta\omega_n s + \omega_n^2 = 0 \), the natural frequency and damping ratio as functions of the uncertain mass \( m \) are

\[ \omega_n(m) = \sqrt{\frac{k + K_p}{m}}, \qquad \zeta(m) = \frac{d + K_d}{2\sqrt{m\,(k + K_p)}}. \]

Stability of a real second-order system requires positivity of all coefficients. Here this simply becomes

\[ m > 0, \quad d + K_d > 0, \quad k + K_p > 0, \]

so any positive mass \( m \) yields a stable closed-loop system as long as the controller gains are chosen such that \( d + K_d > 0 \) and \( k + K_p > 0 \). Therefore, parametric mass uncertainty does not threaten stability for this PD-controlled plant, but it does affect performance via \( \omega_n(m) \) and \( \zeta(m) \).

From Chapter 6 we recall approximate relationships for underdamped second-order systems with damping ratio \( 0 < \zeta < 1 \):

\[ M_p \approx \exp\!\left( -\frac{\pi \zeta}{\sqrt{1-\zeta^2}} \right), \qquad t_s \approx \frac{4}{\zeta \omega_n}, \]

where \( M_p \) is the (normalized) overshoot and \( t_s \) the 2% settling time. Substituting the expressions for \( \zeta(m) \) and \( \omega_n(m) \) gives

\[ M_p(m) \approx \exp\!\left( -\frac{\pi}{\sqrt{1-\zeta(m)^2}} \frac{d + K_d}{2\sqrt{m\,(k + K_p)}} \right), \]

\[ t_s(m) \approx \frac{4}{\zeta(m)\,\omega_n(m)} = \frac{8m}{(d + K_d)}. \]

Note that \( t_s(m) \) is linear in \( m \), while \( \zeta(m) \) and \( M_p(m) \) vary as a square-root function of \( m \).

3.1 Allowed Mass Range for a Damping-Ratio Specification

Suppose we require that the closed-loop damping ratio never drop below a minimum value \( \zeta_{\min} \) for all allowable payloads \( m \). The condition \( \zeta(m) \ge \zeta_{\min} \) gives

\[ \frac{d + K_d}{2\sqrt{m\,(k + K_p)}} \ge \zeta_{\min}. \]

Solving for \( m \) yields

\[ \sqrt{m} \le \frac{d + K_d}{2\zeta_{\min}\sqrt{k + K_p}} \quad\Longrightarrow\quad 0 < m \le m_{\max}, \]

\[ m_{\max} = \frac{(d + K_d)^2}{4\zeta_{\min}^2 (k + K_p)}. \]

Thus, for a given design \( (K_p, K_d) \), the damping-ratio requirement translates into an upper bound on allowable mass (payload).

3.2 Numerical Illustration

Consider a nominal design with \( d = 2 \), \( k = 50 \), \( K_d = 20 \), \( K_p = 150 \). Then

\[ d + K_d = 22, \qquad k + K_p = 200. \]

If we require \( \zeta_{\min} = 0.5 \), the upper mass limit is

\[ m_{\max} = \frac{22^2}{4\cdot 0.5^2 \cdot 200} = \frac{484}{200} \approx 2.42. \]

So the controller meets the damping-ratio requirement for \( 0 < m \lesssim 2.4 \). For the nominal \( m = 1 \), we obtain \( \zeta(1) \approx 0.78 \) (small overshoot), whereas at \( m = 2 \) we get \( \zeta(2) \approx 0.55 \) (more overshoot and slower response).

Many electromechanical actuators and robot joints exhibit unmodeled high-frequency dynamics, for example due to flexible modes or the inner current loop in a motor drive. A simple way to represent this is an extra high-frequency pole multiplying the nominal plant:

\[ G_{\text{true}}(s) = \frac{G_0(s)}{1 + \frac{s}{\omega_h}}, \]

where \( G_0(s) \) is the nominal (modeled) plant, and \( \omega_h \) is a large break frequency (rad/s) of a neglected pole. We design the controller \( C(s) \) for \( G_0(s) \) and obtain a nominal loop transfer function

\[ L_0(s) = C(s)G_0(s). \]

Suppose the nominal design has gain crossover frequency \( \omega_c \) and phase margin \( \text{PM}_0 \). At the frequency \( \omega_c \), the true loop transfer function becomes

\[ L_{\text{true}}(j\omega_c) = \frac{L_0(j\omega_c)}{1 + j\frac{\omega_c}{\omega_h}}. \]

The additional factor modifies the magnitude and phase at \( \omega_c \):

\[ \bigl|L_{\text{true}}(j\omega_c)\bigr| = \frac{\bigl|L_0(j\omega_c)\bigr|} {\sqrt{1 + \left(\frac{\omega_c}{\omega_h}\right)^2}}, \qquad \angle L_{\text{true}}(j\omega_c) = \angle L_0(j\omega_c) - \arctan\!\left( \frac{\omega_c}{\omega_h} \right). \]

If \( \omega_h \) is sufficiently larger than \( \omega_c \), the magnitude correction is small and the new gain crossover frequency remains close to \( \omega_c \). The main effect is an additional phase lag approximately equal to \( \arctan(\omega_c/\omega_h) \), reducing the phase margin:

\[ \text{PM}_{\text{true}} \approx \text{PM}_0 - \arctan\!\left(\frac{\omega_c}{\omega_h}\right). \]

4.1 Constraint on Neglected Pole Frequency

Suppose we require that the phase margin never fall below a minimum acceptable value \( \text{PM}_{\min} \) even in the presence of the neglected pole. The design must satisfy

\[ \text{PM}_{\text{true}} \ge \text{PM}_{\min} \quad\Longrightarrow\quad \text{PM}_0 - \arctan\!\left(\frac{\omega_c}{\omega_h}\right) \ge \text{PM}_{\min}. \]

Rearranging,

\[ \arctan\!\left(\frac{\omega_c}{\omega_h}\right) \le \text{PM}_0 - \text{PM}_{\min}, \]

\[ \frac{\omega_c}{\omega_h} \le \tan\!\bigl(\text{PM}_0 - \text{PM}_{\min}\bigr) \quad\Longrightarrow\quad \omega_h \ge \frac{\omega_c}{\tan\!\bigl(\text{PM}_0 - \text{PM}_{\min}\bigr)}. \]

This inequality constrains where unmodeled poles are allowed to appear without violating the desired phase-margin robustness. For example, if \( \omega_c = 10 \) rad/s, nominal margin \( \text{PM}_0 = 60^\circ \), and minimum acceptable \( \text{PM}_{\min} = 30^\circ \), then \( \text{PM}_0 - \text{PM}_{\min} = 30^\circ \) and \( \tan(30^\circ) \approx 0.577 \), so we require \( \omega_h \gtrsim 17.3 \) rad/s.

In the parametric mass-uncertainty case, the closed-loop characteristic polynomial depends explicitly on \( m \), but the denominator coefficients remain positive for all \( m > 0 \), so nominal stability is not at risk. However, increasing \( m \) reduces \( \omega_n(m) \) and \( \zeta(m) \), shifting poles towards the imaginary axis and thereby increasing the peak of \( |T(j\omega)| \) near the resonant frequency.

In contrast, the unmodeled high-frequency pole does not significantly disturb the location of low-frequency closed-loop poles, but it introduces additional phase lag and may create new lightly-damped closed-loop poles close to the stability boundary when combined with a high loop gain at intermediate frequencies. In this situation, \( |T(j\omega)| \) may develop large peaks at higher frequencies, corresponding to amplified resonances or noise.

Both case studies illustrate that:

• The magnitude of \( T(j\omega) \) encodes closed-loop amplification of reference and disturbance components, and its peaks move with parameter variations.
• The phase of \( L(j\omega) \) and the resulting phase margin are particularly sensitive to unmodeled high-frequency dynamics.
• Frequency ranges where \( |S(j\omega)| \) is large are most sensitive to modeling error, consistent with the local variation formula \( \delta T(s) \approx S_0(s)^2 C(s)\delta G(s) \).

flowchart TD
  MUNC["Mass uncertainty (m)"]
    --> POL1["Poles shift along real axis"]
  POL1 --> PERF1["Change in zeta(m), wn(m)"]
  PERF1 --> TD1["Overshoot / settling vary"]

  HFUNC["High-freq unmodeled pole"]
    --> LAG["Extra phase lag near wc"]
  LAG --> MARG["Reduced phase margin"]
  MARG --> RISK["Risk of instability & high-freq peaks"]
        

We now explore these case studies numerically in Python. We will:

1. Sample different values of the mass \( m \),
2. Approximate \( \zeta(m) \) and \( \omega_n(m) \), and
3. Optionally include a high-frequency unmodeled pole.

The example below uses the python-control library, which is widely used in robotics and control for transfer-function and state-space analysis. It can also be used within ROS-based simulation environments to prototype joint controllers.

import numpy as np
import control as ctl

# Nominal physical and controller parameters
d = 2.0
k = 50.0
Kp = 150.0
Kd = 20.0

def closed_loop_tf(m, omega_h=None):
    """
    Build the closed-loop transfer function for given mass m.
    If omega_h is not None, add an unmodeled high-frequency pole at s = -omega_h.
    """
    # Nominal plant (no unmodeled pole)
    G0 = ctl.tf([1.0], [m, d, k])
    if omega_h is not None:
        # True plant: extra high-frequency pole 1 / (1 + s/omega_h)
        # i.e. multiply by 1 / (1/omega_h * s + 1)
        Gtrue = G0 * ctl.tf([1.0], [1.0 / omega_h, 1.0])
    else:
        Gtrue = G0

    # PD controller
    C = ctl.tf([Kd, Kp], [1.0])

    # Unity feedback closed-loop
    T = ctl.feedback(C * Gtrue, 1.0)
    return T

def second_order_params(m):
    """Return zeta(m) and wn(m) from the derived formulas."""
    wn = np.sqrt((k + Kp) / m)
    zeta = (d + Kd) / (2.0 * np.sqrt(m * (k + Kp)))
    return zeta, wn

m_values = np.linspace(0.5, 2.5, 9)
for m in m_values:
    zeta, wn = second_order_params(m)
    Ts = 8.0 * m / (d + Kd)  # using t_s(m) ≈ 8m/(d+Kd)
    print(f"m = {m:4.2f}, zeta = {zeta:5.3f}, wn = {wn:6.3f}, Ts ≈ {Ts:5.3f} s")

# Example: add an unmodeled high-frequency pole and inspect margins
m_nom = 1.0
omega_h = 30.0  # high-frequency pole
T_true = closed_loop_tf(m_nom, omega_h=omega_h)
L_true = ctl.minreal(ctl.feedback(T_true, -1))  # approximate loop L(s) from T(s)

gm, pm, wg, wp = ctl.margin(L_true)
print("Approximate gain margin:", gm)
print("Approximate phase margin (deg):", pm)
print("Gain crossover frequency (rad/s):", wg)
      

In a robotics context, the sampled m values can represent different payloads carried by a manipulator or different tool heads on an end-effector. The above code lets you see how overshoot and settling change as the payload varies and how a neglected high-frequency mode reduces phase margin.

In low-level robotic controllers (e.g., inside a motor drive or a joint controller implemented with ROS control), the dynamics are often simulated or implemented directly from the differential equations in C++ or Java. We show a simple explicit-Euler integration of the PD-controlled mass–spring–damper system for a step reference.

7.1 C++ Example (Control Loop for Different Masses)

#include <iostream>
#include <vector>

struct PDServo {
    double d;   // viscous damping
    double k;   // stiffness
    double Kp;  // proportional gain
    double Kd;  // derivative gain

    // simulate closed-loop response for given mass m
    std::vector<double> simulate(double m, double t_end, double dt) const {
        double x = 0.0;   // position
        double v = 0.0;   // velocity
        double r = 1.0;   // unit step reference
        std::vector<double> y;
        y.reserve(static_cast<std::size_t>(t_end / dt) + 1);

        for (double t = 0.0; t <= t_end; t += dt) {
            double e = r - x;
            double edot = -v; // derivative of error (dr/dt = 0 for step)
            double u = Kp * e + Kd * edot;

            // mass-spring-damper dynamics: m x'' + d x' + k x = u
            double a = (u - d * v - k * x) / m;
            v += a * dt;
            x += v * dt;
            y.push_back(x);
        }
        return y;
    }
};

int main() {
    PDServo servo{2.0, 50.0, 150.0, 20.0};

    std::vector<double> masses{0.5, 1.0, 2.0};
    for (double m : masses) {
        auto y = servo.simulate(m, 5.0, 0.001);
        std::cout << "Final value for m = " << m
                  << " is " << y.back() << std::endl;
    }
    return 0;
}
      

In a robotics middleware such as ROS, the body of simulate can be adapted into a control callback that runs at a fixed sampling period, where u is sent as a torque or force command to the robot joint. Varying m corresponds to changing payload or link inertia.

7.2 Java Example (Including an Unmodeled High-Frequency Pole)

We can incorporate a simple unmodeled high-frequency pole as an extra first-order filter in the loop. This models neglected actuator dynamics:

public class PDServoHF {
    private double d, k, Kp, Kd;
    private double omegaH; // high-frequency pole

    public PDServoHF(double d, double k, double Kp, double Kd, double omegaH) {
        this.d = d;
        this.k = k;
        this.Kp = Kp;
        this.Kd = Kd;
        this.omegaH = omegaH;
    }

    public double[] simulate(double m, double tEnd, double dt) {
        double x = 0.0;   // position
        double v = 0.0;   // velocity
        double z = 0.0;   // state of unmodeled pole (first-order filter)
        double r = 1.0;   // step reference

        int N = (int) Math.round(tEnd / dt) + 1;
        double[] y = new double[N];
        int idx = 0;

        for (double t = 0.0; t <= tEnd; t += dt) {
            double e = r - x;
            double edot = -v;
            double u = Kp * e + Kd * edot;

            // unmodeled high-frequency pole: z' = -omegaH * z + omegaH * u
            double zdot = -omegaH * z + omegaH * u;
            z += zdot * dt;

            // plant dynamics: m x'' + d x' + k x = z
            double a = (z - d * v - k * x) / m;
            v += a * dt;
            x += v * dt;

            y[idx++] = x;
        }
        return y;
    }
}
      

The extra state z represents the filtered actuator command, which lags behind the ideal PD command u. When omegaH is not much larger than the closed-loop bandwidth, the effective phase margin is reduced, reproducing the behavior of Section 4.

8.1 MATLAB/Simulink Script

MATLAB is standard in control and robotics for modeling uncertainty and running parameter sweeps. The following script explores the dependence of damping ratio and step response on the mass parameter and adds an unmodeled high-frequency pole.

d  = 2;
k  = 50;
Kp = 150;
Kd = 20;

m_vec = linspace(0.5, 2.5, 9);
zeta_vec = zeros(size(m_vec));
wn_vec   = zeros(size(m_vec));

for i = 1:length(m_vec)
    m = m_vec(i);
    wn   = sqrt((k + Kp) / m);
    zeta = (d + Kd) / (2 * sqrt(m * (k + Kp)));
    wn_vec(i)   = wn;
    zeta_vec(i) = zeta;

    G0 = tf(1, [m d k]);
    C  = tf([Kd Kp], 1);
    Tm = feedback(C * G0, 1);
    % step(Tm); hold on;  % visualize effect of m on step response
end

% Example: add high-frequency pole
omega_h = 30;
m_nom   = 1.0;
G0 = tf(1, [m_nom d k]);
Gh = G0 * tf(1, [1/omega_h 1]);  % true plant
C  = tf([Kd Kp], 1);
Th = feedback(C * Gh, 1);

figure;
step(Th);
title('Closed-loop step with unmodeled high-frequency pole');

% Bode and margins
Lh = C * Gh;
figure;
margin(Lh);
title('Loop-shape and margins with high-frequency pole');
      

A Simulink model can use a Transfer Function block for G0, a PD controller block, and an additional first-order transfer function for the unmodeled pole. Parameter sweeps over m can be automated using MATLAB scripts with Simulink.SimulationInput and sim. The Robotics System Toolbox can be used to embed these controllers into rigid-body tree models of robot manipulators.

8.2 Wolfram Mathematica Notebook

Mathematica offers symbolic and numerical tools for parameterized transfer functions. The code below reproduces the mass-uncertainty analysis and computes time responses.

d  = 2;
k  = 50;
Kp = 150;
Kd = 20;

(* symbolic damping ratio and natural frequency *)
Clear[m];
wn[m_]   := Sqrt[(k + Kp)/m];
zeta[m_] := (d + Kd)/(2 Sqrt[m (k + Kp)]];

(* transfer function model with optional high-frequency pole *)
G0[m_] := TransferFunctionModel[1/(m s^2 + d s + k), s];
C      := TransferFunctionModel[Kd s + Kp, s];

omegaH = 30;
Gtrue[m_] := G0[m] * TransferFunctionModel[1/(1 + s/omegaH), s];

Tcl[m_]   := FeedbackConnect[C, G0[m]];
Ttrue[m_] := FeedbackConnect[C, Gtrue[m]];

(* numerical step responses for different masses *)
mVals = {0.5, 1.0, 2.0};
respNominal = Table[
  StepResponse[Tcl[mVals[[i]]], {t, 0, 5}],
  {i, Length[mVals]}
];

(* step response with high-frequency pole *)
respHF = StepResponse[Ttrue[1.0], {t, 0, 5}];
      

Symbolic expressions such as zeta[m] and wn[m] can be further analyzed to study how performance metrics depend on uncertainty, or to derive inequalities like those in Sections 3 and 4.

In practice, an engineer designing a feedback controller for a robotic actuator or mechatronic system can use the following workflow:

1. Identify key uncertain parameters (mass, inertia, friction, sensor gains).
2. Express the closed-loop characteristic polynomial explicitly in terms of those parameters whenever possible.
3. Use analytical conditions (Routh–Hurwitz, damping ratio formulas, phase-margin inequalities) to derive bounds on parameter variations.
4. Validate these bounds using time-domain and frequency-domain simulations in Python, C++, Java, MATLAB, or Mathematica.
5. Iterate the controller design (e.g., adjust \( K_p \), \( K_d \), low-pass filters) to achieve acceptable robustness margins and performance across the uncertainty set.

The case studies in this lesson instantiate this pattern. In later chapters on robustness analysis, these ideas will be formalized further with quantitative measures and design procedures.

Problem 1 (Damping Ratio Under Mass Uncertainty). Consider the PD-controlled mass–spring–damper system in Section 2 with plant \( G(s;m) = 1/(m s^2 + d s + k) \) and controller \( C(s) = K_p + K_d s \). Derive the expressions for \( \omega_n(m) \) and \( \zeta(m) \) and show that \( \zeta(m) \) is a decreasing function of \( m \).

Solution. The closed-loop characteristic equation is

\[ m s^2 + (d + K_d) s + (k + K_p) = 0. \]

Dividing by \( m \) yields

\[ s^2 + \frac{d + K_d}{m} s + \frac{k + K_p}{m} = 0. \]

Comparing with \( s^2 + 2\zeta\omega_n s + \omega_n^2 = 0 \) gives

\[ \omega_n(m) = \sqrt{\frac{k + K_p}{m}}, \qquad \zeta(m) = \frac{d + K_d}{2\sqrt{m\,(k + K_p)}}. \]

Treating \( m \) as a continuous variable, \( \zeta(m) \propto 1/\sqrt{m} \). Thus \( \zeta(m) \) decreases as \( m \) increases, as required.

Problem 2 (Mass Bound from Overshoot Specification). Using the same system as in Problem 1, suppose the specification is that the overshoot must remain below \( M_p^{\max} \). Use the approximate relation \( M_p \approx \exp(-\pi \zeta/\sqrt{1-\zeta^2}) \) to derive an inequality of the form \( m \le m_{\max} \). Do not attempt to obtain a closed form; instead, express the condition in terms of a minimum damping ratio \( \zeta_{\min} \) implied by \( M_p^{\max} \).

Solution.

1. Given \( M_p^{\max} \), solve numerically or from tables for the minimum damping ratio \( \zeta_{\min} \) such that \( \exp(-\pi\zeta_{\min}/\sqrt{1-\zeta_{\min}^2}) \le M_p^{\max} \).
2. Imposing \( \zeta(m) \ge \zeta_{\min} \) and using the formula for \( \zeta(m) \) gives \( (d + K_d) / (2\sqrt{m(k + K_p)}) \ge \zeta_{\min} \).
3. Solving for \( m \) reproduces

\[ 0 < m \le m_{\max} = \frac{(d + K_d)^2}{4\zeta_{\min}^2 (k + K_p)}. \]

Thus, once \( \zeta_{\min} \) is found from \( M_p^{\max} \), the corresponding mass bound follows directly.

Problem 3 (Phase-Margin Degradation by a Neglected Pole). Revisit the high-frequency unmodeled pole case of Section 4. Starting from \( L_{\text{true}}(j\omega_c) = L_0(j\omega_c)/(1 + j\omega_c/\omega_h) \), derive the approximate relation \( \text{PM}_{\text{true}} \approx \text{PM}_0 - \arctan(\omega_c/\omega_h) \) and the design inequality \( \omega_h \ge \omega_c / \tan(\text{PM}_0 - \text{PM}_{\min}) \).

Solution.

1. The additional factor \( 1/(1 + j\omega_c/\omega_h) \) contributes a phase of \( -\arctan(\omega_c/\omega_h) \) at \( \omega_c \), because the angle of \( 1 + jx \) is \( \arctan(x) \).
2. Hence the true phase at \( \omega_c \) is the nominal phase minus this amount, so the phase margin is reduced by \( \arctan(\omega_c/\omega_h) \).
3. Requiring \( \text{PM}_0 - \arctan(\omega_c/\omega_h) \ge \text{PM}_{\min} \) and solving for \( \omega_h \) yields the inequality shown in Section 4, using the monotonicity of the tangent function on \( (0, \pi/2) \).

Problem 4 (Local Sensitivity of Complementary Sensitivity). Let \( T(s) = L(s)/(1 + L(s)) \). Show that the derivative of \( T \) with respect to \( L \) is \( \partial T / \partial L = 1/(1+L)^2 \). Interpret this result in terms of the nominal sensitivity \( S_0(s) = 1/(1 + L_0(s)) \).

Solution. Differentiating gives

\[ \frac{\partial T}{\partial L} = \frac{(1 + L) - L}{(1 + L)^2} = \frac{1}{(1 + L)^2}. \]

Evaluating at the nominal loop \( L_0(s) \), we obtain \( \partial T / \partial L|_{L_0} = S_0(s)^2 \). Hence, a perturbation \( \delta L(s) \) produces \( \delta T(s) \approx S_0(s)^2 \delta L(s) \). Where \( |S_0(j\omega)| \) is large (e.g., near poor robustness), the same modeling error has a larger impact on the closed loop.

Problem 5 (Settling-Time Constraint for Payload Variations). For the PD-controlled system in Problem 1, suppose the requirement is that the settling time satisfy \( t_s(m) \le T_s^{\max} \) for all \( m \) in a range. Using \( t_s(m) \approx 8m/(d + K_d) \), determine the maximum allowed mass \( m_{\max} \) and compare it to the damping-ratio-based bound in Problem 2.

Solution.

1. The approximate settling-time relation gives \( 8m/(d + K_d) \le T_s^{\max} \).
2. Solving for \( m \) yields

\[ 0 < m \le m_{\max}^{(t_s)} = \frac{T_s^{\max}(d + K_d)}{8}. \]

For a given controller, we now have two upper bounds: \( m_{\max}^{(\zeta)} \) from Problem 2 and \( m_{\max}^{(t_s)} \) from this problem. The effective allowed mass range is \( 0 < m \le \min\{m_{\max}^{(\zeta)}, m_{\max}^{(t_s)}\} \).

This lesson used detailed case studies to connect abstract uncertainty models with concrete consequences for stability and performance in linear feedback systems. For a PD-controlled mass–spring–damper plant, we showed explicitly how mass (payload) uncertainty affects closed-loop poles, damping ratio, overshoot, and settling time, and we derived analytic bounds on allowable mass variations to meet time-domain specifications.

For unmodeled high-frequency poles, we quantified the reduction of phase margin as an additional phase lag at the gain crossover frequency, and we obtained an inequality relating the frequency of neglected poles to desired robustness margins. These analyses were implemented in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, illustrating how modern software tools support robustness studies for robotic and mechatronic systems.

In the next chapter, these insights will be formalized further in the context of classical robustness analysis using gain and phase margins, sensitivity functions, and frequency-domain design tools.