From a modeling point of view, a rigid robot manipulator with \( n \) joints is described by the familiar equation

\[ \mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) + \mathbf{f}(\dot{\mathbf{q}}) = \boldsymbol{\tau} + \mathbf{d}(t), \]

where \( \mathbf{q}\in\mathbb{R}^n \) are joint positions, \( \mathbf{M}(\mathbf{q}) \) is the inertia matrix, \( \mathbf{C}(\mathbf{q},\dot{\mathbf{q}}) \) contains Coriolis and centrifugal terms, \( \mathbf{g}(\mathbf{q}) \) the gravity vector, \( \mathbf{f}(\dot{\mathbf{q}}) \) joint friction and other effects, \( \boldsymbol{\tau} \) the actuator torques, and \( \mathbf{d}(t) \) a lumped disturbance vector (e.g. external forces mapped into joints).

In model-based control (e.g. computed-torque control from previous chapters) we use a nominal model \( \hat{\mathbf{M}}, \hat{\mathbf{C}}, \hat{\mathbf{g}} \) that is only an approximation of the true dynamics. The discrepancy between the true robot and this nominal model is what we call uncertainty. It is useful to classify it as:

• Parametric uncertainty: the structure of the model is correct, but physical parameters (masses, inertias, link lengths, friction coefficients) are not exactly known.
• Unmodeled dynamics: real dynamics that are not included in the model at all (flexibilities, actuator dynamics, saturations, high-frequency modes, sensor dynamics).
• Disturbances: external or internal signals entering as unknown inputs (contact forces, payload variations, wind, unmeasured human interaction, process noise).

The classification below will be used throughout all robust and adaptive control chapters.

flowchart TD
  R["Physical robot"] --> ID["Identification / modeling"]
  ID --> NOM["Nominal rigid-body model"]
  NOM --> P["Parametric uncertainty \n(theta != theta_hat)"]
  NOM --> U["Unmodeled dynamics \n(flexibility, friction, delay)"]
  NOM --> D["Disturbances \n(forces, noise, payload)"]
  P --> S["Structured, low-dimensional"]
  U --> H["High-frequency or \nneglected modes"]
  D --> X["Exogenous or \nenvironment-driven"]
        

The nominal model used by a controller is typically written as

\[ \hat{\mathbf{M}}(\mathbf{q})\ddot{\mathbf{q}} + \hat{\mathbf{C}}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \hat{\mathbf{g}}(\mathbf{q}) = \boldsymbol{\tau}. \]

The true dynamics satisfy

\[ \mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) + \mathbf{f}(\dot{\mathbf{q}}) = \boldsymbol{\tau} + \mathbf{d}(t). \]

Define model errors

\[ \Delta \mathbf{M}(\mathbf{q}) = \mathbf{M}(\mathbf{q}) - \hat{\mathbf{M}}(\mathbf{q}),\quad \Delta \mathbf{C}(\mathbf{q},\dot{\mathbf{q}}) = \mathbf{C}(\mathbf{q},\dot{\mathbf{q}}) - \hat{\mathbf{C}}(\mathbf{q},\dot{\mathbf{q}}), \]

\[ \Delta \mathbf{g}(\mathbf{q}) = \mathbf{g}(\mathbf{q}) - \hat{\mathbf{g}}(\mathbf{q}). \]

Subtracting the nominal model from the true dynamics yields a compact uncertainty input acting at the torque level:

\[ \underbrace{ \hat{\mathbf{M}}(\mathbf{q})\ddot{\mathbf{q}} + \hat{\mathbf{C}}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \hat{\mathbf{g}}(\mathbf{q}) }_{\text{nominal rigid-body model}} = \boldsymbol{\tau} + \underbrace{\mathbf{w}(t,\mathbf{x})}_{\text{lumped uncertainty}}, \]

\[ \mathbf{w}(t,\mathbf{x}) = \mathbf{d}(t) - \Delta\mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} - \Delta\mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} - \Delta\mathbf{g}(\mathbf{q}) - \mathbf{f}(\dot{\mathbf{q}}). \]

Here \( \mathbf{x} = (\mathbf{q},\dot{\mathbf{q}}) \) is the robot state. The term \( \mathbf{w}(t,\mathbf{x}) \) combines:

• parametric mismatch in \( \mathbf{M},\mathbf{C},\mathbf{g} \),
• unmodeled dynamics such as friction, actuator dynamics, and flexible modes,
• disturbances \( \mathbf{d}(t) \).

Robust control design will always assume that \( \mathbf{w}(t,\mathbf{x}) \) satisfies some a priori bound (norm-, energy-, or structure-based), and then guarantee performance for all signals within that bound.

A key structural property of rigid manipulator dynamics is that they are linear in a constant parameter vector \( \boldsymbol{\theta}\in\mathbb{R}^p \):

\[ \mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) = \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\,\boldsymbol{\theta}, \]

where \( \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\in\mathbb{R}^{n\times p} \) is called the regressor and \( \boldsymbol{\theta} \) stacks inertial and gravitational parameters (link masses, inertias, center-of-mass locations, etc.).

Parametric uncertainty assumes the structure of \( \mathbf{Y} \) is correct, but we do not know the exact value of \( \boldsymbol{\theta} \). Instead we only know that

\[ \boldsymbol{\theta} = \hat{\boldsymbol{\theta}} + \Delta\boldsymbol{\theta},\quad \left\|\Delta\boldsymbol{\theta}\right\|_2 \leq \rho_{\theta}, \]

for some known radius \( \rho_{\theta} > 0 \). The corresponding torque mismatch is

\[ \Delta\boldsymbol{\tau} = \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\,\Delta\boldsymbol{\theta}. \]

Using the induced 2-norm,

\[ \left\|\Delta\boldsymbol{\tau}\right\|_2 \leq \left\|\mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\right\|_2\, \left\|\Delta\boldsymbol{\theta}\right\|_2 \leq \gamma_Y(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\,\rho_{\theta}, \]

where \( \gamma_Y(\cdot) \) is an upper bound on the regressor norm. This kind of bound is central in robust control: if we know that the torque error stays within a ball for all possible parameter values, we can design feedback gains that stabilize the closed loop for any parameter realization in the admissible set.

In later adaptive control chapters, \( \boldsymbol{\theta} \) will be considered unknown-but-constant and estimated online; in robust control we usually keep \( \boldsymbol{\theta} \) fixed but uncertain within a specified set.

Unmodeled dynamics are dynamical effects that are simply not present in the nominal model, often because they are high-frequency, weakly excited, or too complex to model accurately. Typical examples:

• joint and link flexibilities, gear compliance;
• actuator dynamics (motor inductance, power electronics, current loops);
• unmodeled nonlinear friction (stiction, Stribeck effect);
• sensor dynamics and filtering delays.

A convenient way to represent unmodeled dynamics at the state level is to write the true closed-loop dynamics as

\[ \dot{\mathbf{x}} = \mathbf{f}_0(\mathbf{x},\boldsymbol{\tau}) + \mathbf{w}_u(t,\mathbf{x},\boldsymbol{\tau}), \]

where \( \mathbf{f}_0 \) corresponds to the nominal rigid-body model and \( \mathbf{w}_u \) encapsulates all unmodeled effects. For robust analysis, we usually assume that there exist known functions \( \alpha(\cdot), \beta(\cdot) \) such that

\[ \left\|\mathbf{w}_u(t,\mathbf{x},\boldsymbol{\tau})\right\|_2 \leq \alpha(\|\mathbf{x}\|_2) + \beta(\|\boldsymbol{\tau}\|_2) \quad \forall t \geq 0. \]

Importantly, the inequality above does not require detailed knowledge of \( \mathbf{w}_u \); it only requires bounds on how big it can be relative to state and input. These bounds will later appear in Lyapunov-based robust stability proofs and in small-gain type conditions.

Disturbances are signals entering the robot that are not commanded by the controller. They can arise from the environment (contact forces), payload changes, modeling simplifications, or process noise. It is useful to distinguish how they enter the dynamics:

\[ \dot{\mathbf{x}} = \mathbf{f}(\mathbf{x}) + \mathbf{g}(\mathbf{x})\boldsymbol{\tau} + \underbrace{\mathbf{g}(\mathbf{x})\mathbf{d}_m(t,\mathbf{x})}_{\text{matched disturbance}} + \underbrace{\mathbf{d}_u(t,\mathbf{x})}_{\text{unmatched disturbance}}. \]

• Matched disturbances: enter through the same channels as the control input (same column space as \( \mathbf{g}(\mathbf{x}) \)). For joint-torque controlled robots, any unknown joint torque (e.g. friction, payload torque) is matched.
• Unmatched disturbances: enter through directions that the controller cannot directly actuate (outside the range of \( \mathbf{g}(\mathbf{x}) \)), e.g. some unmodeled flexible modes or disturbances acting on unactuated coordinates.

Robust control for matched disturbances can often rely on cancellation strategies (e.g. sliding-mode control, disturbance observers in later lessons), while unmatched disturbances require different strategies (e.g. robust invariance and input-to-state stability arguments).

Around a fixed operating point (or a reference trajectory), the robot dynamics can be linearized into a state-space model

\[ \dot{\mathbf{x}} = (\mathbf{A} + \Delta\mathbf{A})\mathbf{x} + (\mathbf{B} + \Delta\mathbf{B})\mathbf{u} + \mathbf{E}\mathbf{w}, \]

where \( \Delta\mathbf{A}, \Delta\mathbf{B} \) capture parametric and unmodeled dynamics, and \( \mathbf{w} \) collects disturbances. A common assumption is norm-bounded uncertainty:

\[ \left\|\Delta\mathbf{A}\right\|_2 \leq \bar{\alpha},\quad \left\|\Delta\mathbf{B}\right\|_2 \leq \bar{\beta},\quad \left\|\mathbf{w}(t)\right\|_{\infty} \leq \bar{w}, \]

or a more structured description

\[ \dot{\mathbf{x}} = \mathbf{A}\mathbf{x} + \mathbf{B}\mathbf{u} + \mathbf{D}\,\Delta(t)\,\mathbf{z},\quad \mathbf{z} = \mathbf{E}_x\mathbf{x} + \mathbf{E}_u\mathbf{u}, \]

where \( \Delta(t) \) is an unknown but bounded matrix (often with \( \|\Delta(t)\|_2 \leq 1 \)). The vector \( \mathbf{z} \) collects those combinations of state and input that feed into the uncertainty block. This representation is the starting point for many robust control synthesis methods (e.g. small-gain, structured singular value), which will be introduced later.

flowchart TD
  X["State x"] --> NOM["Nominal LTI model (A,B)"]
  U["Control u"] --> NOM
  NOM --> XDOT0["Predicted xdot"]
  X --> Z["Signal z = Ex x + Eu u"]
  U --> Z
  Z --> DELTA["Uncertainty block Delta(t)"]
  DELTA --> W["Uncertainty output"]
  XDOT0 --> SUM["+ combination"]
  W --> SUM
  SUM --> XDOT["True xdot"]
        

Consider a single revolute joint modeled as a pendulum:

\[ I \ddot{q} + b \dot{q} + m g \ell \sin(q) = \tau + d(t), \]

with uncertain inertia \( I \), damping \( b \), and lumped gravity term \( m g \ell \). The nominal parameters are \( \hat{I}, \hat{b}, \widehat{m g \ell} \) with bounded deviations. The following Python code (NumPy-based) simulates several trajectories under random parameter samples and a simple PD control law.

import numpy as np

# Nominal parameters
theta_nom = np.array([0.5, 0.05, 1.0])  # [I_hat, b_hat, (m g l)_hat]
delta_bounds = np.array([0.1, 0.02, 0.2])  # max deviations |Delta theta_i|

def sample_theta():
    """Sample parameters within a box around theta_nom."""
    return theta_nom + (2.0 * np.random.rand(3) - 1.0) * delta_bounds

def disturbance(t):
    """Matched disturbance: bounded torque ripple."""
    return 0.2 * np.sin(5.0 * t)  # ||d(t)||_inf <= 0.2

def joint_dynamics(t, x, u, theta):
    """
    x = [q, qdot]
    theta = [I, b, mgl]
    """
    q, qdot = x
    I, b, mgl = theta

    # Unmodeled dynamics: crude Coulomb friction + small unmodeled torque
    fc = 0.05 * np.sign(qdot)  # unmodeled friction
    wu = 0.05 * np.sin(20.0 * t)  # high-frequency unmodeled mode

    # True dynamics (one-step Euler model)
    qddot = (u - b * qdot - mgl * np.sin(q) - fc + disturbance(t) + wu) / I
    return np.array([qdot, qddot])

def pd_control(t, x, q_ref=0.5):
    """Simple PD in joint space using nominal gains."""
    q, qdot = x
    Kp = 20.0
    Kd = 4.0
    e = q_ref - q
    edot = -qdot
    return Kp * e + Kd * edot

def simulate(T=5.0, dt=0.001, trials=5):
    N = int(T / dt)
    t_grid = np.linspace(0.0, T, N+1)
    q_hist = np.zeros((trials, N+1))
    q_ref = 0.5

    for k in range(trials):
        theta = sample_theta()
        x = np.array([0.0, 0.0])  # [q(0), qdot(0)]
        q_hist[k, 0] = x[0]

        for i in range(N):
            t = t_grid[i]
            u = pd_control(t, x, q_ref)
            dx = joint_dynamics(t, x, u, theta)
            x = x + dt * dx  # explicit Euler
            q_hist[k, i+1] = x[0]

    return t_grid, q_hist

if __name__ == "__main__":
    t, q_trajs = simulate()
    # Plot with matplotlib (not shown here); you would see a bundle of trajectories
    # corresponding to different parameter samples and disturbances.
      

In this simulation, parametric uncertainty appears in theta, unmodeled dynamics in fc and wu, and matched disturbances in disturbance(t). A robust controller must achieve acceptable tracking for all sampled parameter vectors and disturbance realizations.

In C++, one often uses matrix libraries such as Eigen to represent the regressor and parameter vector. The snippet below shows a simple one-DOF model with a parameter box and torque mismatch computation.

#include <iostream>
#include <random>
#include <Eigen/Dense>

struct JointParams {
  double I;    // inertia
  double b;    // viscous friction
  double mgl;  // gravity torque coefficient
};

JointParams sampleParams(const JointParams& nominal,
                         const JointParams& delta_max,
                         std::mt19937& gen) {
  std::uniform_real_distribution<double> dist(-1.0, 1.0);
  JointParams theta;
  theta.I   = nominal.I   + delta_max.I   * dist(gen);
  theta.b   = nominal.b   + delta_max.b   * dist(gen);
  theta.mgl = nominal.mgl + delta_max.mgl * dist(gen);
  return theta;
}

double torqueModel(const JointParams& theta, double q, double qdot, double qddot) {
  // tau = I qddot + b qdot + mgl sin(q)
  return theta.I * qddot + theta.b * qdot + theta.mgl * std::sin(q);
}

int main() {
  JointParams nominal{0.5, 0.05, 1.0};
  JointParams delta_max{0.1, 0.02, 0.2};

  std::mt19937 gen(42);

  double q = 0.3;
  double qdot = 0.1;
  double qddot = 0.0;

  // Nominal torque
  double tau_hat = torqueModel(nominal, q, qdot, qddot);

  // Sample one realization of parametric uncertainty
  JointParams theta_true = sampleParams(nominal, delta_max, gen);
  double tau_true = torqueModel(theta_true, q, qdot, qddot);

  double delta_tau = tau_true - tau_hat;
  std::cout << "Nominal tau = " << tau_hat
            << ", true tau = " << tau_true
            << ", mismatch = " << delta_tau << std::endl;

  return 0;
}
      

In a full robot implementation (e.g. using pinocchio, RBDL, or Orocos KDL libraries), the same idea generalizes with Eigen::VectorXd parameter vectors and regressor matrices Y(q, qdot, qddot).

Java is often used for higher-level robot software. The following simplified example implements a nominal joint model with an additive disturbance interface, suitable for simulation or MPC-style prediction.

public interface Disturbance {
    double value(double t, double q, double qdot);
}

public class JointModel {
    // Nominal parameters
    private final double I;
    private final double b;
    private final double mgl;

    private Disturbance disturbance;

    public JointModel(double I, double b, double mgl) {
        this.I = I;
        this.b = b;
        this.mgl = mgl;
        this.disturbance = (t, q, qdot) -> 0.0; // default: no disturbance
    }

    public void setDisturbance(Disturbance d) {
        this.disturbance = d;
    }

    public double[] f(double t, double[] x, double tau) {
        // x = [q, qdot]
        double q = x[0];
        double qdot = x[1];

        double d = disturbance.value(t, q, qdot); // matched disturbance
        double qddot = (tau - b * qdot - mgl * Math.sin(q) + d) / I;

        return new double[]{qdot, qddot};
    }
}
      

By changing the Disturbance implementation, one can simulate various disturbance patterns (steps, noise, contact events) and study how sensitive a particular control law is to these uncertainties.

10.1 MATLAB: Uncertain Parameters Using Robust Control Toolbox

MATLAB provides uncertain real parameters via ureal. For the one-DOF joint:

% Nominal values
I_nom   = 0.5;
b_nom   = 0.05;
mgl_nom = 1.0;

% Uncertain parameters with +-20% relative deviation
I_u   = ureal('I',   I_nom,   'Percentage', 20);
b_u   = ureal('b',   b_nom,   'Percentage', 20);
mgl_u = ureal('mgl', mgl_nom, 'Percentage', 20);

% State-space representation: x = [q; qdot]
A = [0 1;
     0 -b_u/I_u];

B = [0;
     1/I_u];

E = [0;
     1/I_u];   % matched disturbance input

C = eye(2);
D = zeros(2, 2);

sys_unc = ss(A, [B E], C, D, 'StateName', {'q','qdot'}, ...
                      'InputName', {'tau','d'}, ...
                      'OutputName', {'q','qdot'});
      

This model explicitly distinguishes between the control input tau and a matched disturbance channel d, with parametric uncertainty embedded in I_u and b_u.

10.2 Programmatic Simulink Construction (Conceptual)

Simulink models can be built programmatically to capture nominal dynamics plus disturbance blocks:

% Create a new Simulink model
model = 'joint_uncertain_model';
new_system(model);
open_system(model);

% Add blocks (simplified; positions omitted)
add_block('simulink/Sources/Step', [model '/tau_ref']);
add_block('simulink/Sources/Step', [model '/disturbance']);
add_block('simulink/Continuous/State-Space', [model '/joint_dyn']);

% Set state-space parameters using A,B,E
set_param([model '/joint_dyn'], 'A', mat2str(A), ...
                               'B', mat2str([B E]), ...
                               'C', 'eye(2)', ...
                               'D', 'zeros(2,2)');

% Connect blocks as needed and run:
set_param(model, 'StopTime', '5');
sim(model);
      

In a full implementation, you would also add output scopes, feedback loops (e.g. PD control), and logging blocks to inspect the response under different uncertainty realizations.

10.3 Wolfram Mathematica: Symbolic Uncertainty Sets

Mathematica is well suited for symbolic manipulation of uncertainty sets. For example, a parameter box and its induced torque bound can be written as:

ClearAll["Global`*"];

(* Parameters and uncertainty set *)
thetaNom = {I -> 0.5, b -> 0.05, mgl -> 1.0};
rhoI = 0.1; rhob = 0.02; rhomgl = 0.2;

ThetaRegion = RegionIntersection[
  Interval[{0.5 - rhoI, 0.5 + rhoI}],
  Interval[{0.05 - rhob, 0.05 + rhob}],
  Interval[{1.0 - rhomgl, 1.0 + rhomgl}]
];

(* Torque model: tau = I qddot + b qdot + mgl Sin[q] *)
tau[I_, b_, mgl_, q_, qdot_, qddot_] := I qddot + b qdot + mgl Sin[q];

(* Symbolic bound for torque mismatch at fixed (q, qdot, qddot) *)
q0 = 0.3; qdot0 = 0.1; qddot0 = 0.0;

tauNom = tau[0.5, 0.05, 1.0, q0, qdot0, qddot0];

(* Maximize |tau - tauNom| over the parameter intervals *)
maxDeltaTau = NMaximize[
  {
    Abs[tau[I, b, mgl, q0, qdot0, qddot0] - tauNom],
    I ∈ Interval[{0.5 - rhoI, 0.5 + rhoI}] &&
    b ∈ Interval[{0.05 - rhob, 0.05 + rhob}] &&
    mgl ∈ Interval[{1.0 - rhomgl, 1.0 + rhomgl}]
  },
  {I, b, mgl}
];
      

The value maxDeltaTau gives a worst-case torque deviation compatible with the parameter ranges, which can be used directly as a robust design bound.

In this lesson we built a precise vocabulary for uncertainty in robot control. Starting from the familiar manipulator dynamics, we decomposed the mismatch between true and nominal dynamics into three categories: parametric uncertainty (unknown but constant model parameters), unmodeled dynamics (additional modes and nonlinearities not present in the model), and disturbances (exogenous inputs such as contact forces). We introduced linear-in-parameters representations and norm-bounded uncertainty sets that will be used in Lyapunov-based robust stability analysis and in the synthesis of robust and adaptive controllers in the next lessons of this chapter.