In earlier chapters we derived the equations of motion of an \( n \)-DOF robot manipulator in the standard form

\[ \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}, \]

where \( \mathbf{q}, \dot{\mathbf{q}}, \ddot{\mathbf{q}} \in \mathbb{R}^n \) are joint positions, velocities, and accelerations, \( \mathbf{M} \) is the inertia matrix, \( \mathbf{C} \) collects Coriolis/centrifugal terms, \( \mathbf{g} \) is gravity, and \( \mathbf{F} \) groups friction and other dissipative effects.

Each term depends on a finite set of physical parameters: link masses \( m_i \), centers of mass \( \mathbf{c}_i \), inertia tensors \( \mathbf{I}_i \), friction coefficients, gear ratios, etc. We collect these in a parameter vector

\[ \boldsymbol{\theta} = \begin{bmatrix} \text{link inertias} \\ \text{link masses} \\ \text{CoM components} \\ \text{friction coefficients} \\ \text{motor/gear parameters} \end{bmatrix} \in \mathbb{R}^p. \]

A dynamic model of the robot is therefore not just the symbolic form of the equations of motion, but the pair \( (\mathcal{M}, \boldsymbol{\theta}) \), where \( \mathcal{M} \) encodes structure (e.g. number of links, joint types) and \( \boldsymbol{\theta} \) encodes numerical values. Even with a perfectly correct structural model, wrong parameter values produce wrong predictions.

flowchart TD
  A["Physical robot"] --> B["Structural model: links, joints, tree"]
  B --> C["Symbolic dynamics: M(q), C(q, qdot), g(q), F(qdot)"]
  C --> D["Unknown numeric parameters theta"]
  D --> E["Predicted torques tau_model(q, qdot, qddot; theta)"]
  A --> F["Measured (q, qdot, qddot, tau)"]
  F --> G["Parameter identification"]
  G -->|"estimate theta_hat"| D
        

Parameter identification is the process of estimating \( \boldsymbol{\theta} \) from experimentally measured data. The central question of this lesson is: Why is this effort necessary? Why not simply rely on CAD data or manufacturer datasheets?

A key mathematical fact underlying identification is that robot dynamics are linear in the physical parameters. Although nonlinear in \( \mathbf{q}, \dot{\mathbf{q}}, \ddot{\mathbf{q}} \), the torques are linear in \( \boldsymbol{\theta} \):

\[ \boldsymbol{\tau}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}}) = \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}})\,\boldsymbol{\theta}, \quad \mathbf{Y} \in \mathbb{R}^{n \times p}. \]

The matrix \( \mathbf{Y} \) is called the regressor. It depends only on measured kinematic quantities and known geometric constants (e.g. link lengths), but not on unknown inertias or masses.

2.1 Example: 1-DOF rotary link

Consider a single rotary joint actuating a rigid link of length \( \ell \) and mass \( m \). Let \( q \) be the joint angle (measured from the downward vertical), \( \dot{q} \) its velocity, and \( \ddot{q} \) its acceleration. The dynamic equation with simple viscous and Coulomb friction is

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

where \( I \) is the joint inertia about the axis, \( b \) is viscous friction, and \( f_c \) is Coulomb friction. This can be rewritten as

\[ \tau = \underbrace{\begin{bmatrix} \ddot{q} & \dot{q} & \operatorname{sgn}(\dot{q}) & \sin(q) \end{bmatrix}}_{\mathbf{Y}(q,\dot{q},\ddot{q})} \underbrace{\begin{bmatrix} I \\ b \\ f_c \\ m g \ell \end{bmatrix}}_{\boldsymbol{\theta}}. \]

This example shows explicitly how nonlinear terms in \( q \) (here \( \sin(q) \)) enter as known scalar coefficients in \( \mathbf{Y} \), while unknown quantities are grouped into \( \boldsymbol{\theta} \).

2.2 Stacked measurements and algebraic model

Suppose we record \( N \) samples of a trajectory, and at each time \( t_k \) we measure \( \mathbf{q}_k, \dot{\mathbf{q}}_k, \ddot{\mathbf{q}}_k, \boldsymbol{\tau}_k \). For each sample,

\[ \boldsymbol{\tau}_k = \mathbf{Y}(\mathbf{q}_k,\dot{\mathbf{q}}_k,\ddot{\mathbf{q}}_k)\,\boldsymbol{\theta} \quad (k = 1,\dots,N). \]

Stacking these equations we obtain a linear system

\[ \underbrace{\begin{bmatrix} \boldsymbol{\tau}_1 \\ \vdots \\ \boldsymbol{\tau}_N \end{bmatrix}}_{\boldsymbol{\tau}_s \in \mathbb{R}^{Nn}} = \underbrace{\begin{bmatrix} \mathbf{Y}_1 \\ \vdots \\ \mathbf{Y}_N \end{bmatrix}}_{\mathbf{Y}_s \in \mathbb{R}^{Nn \times p}} \boldsymbol{\theta}. \]

If the stacked regressor \( \mathbf{Y}_s \) has full column rank, the parameter vector \( \boldsymbol{\theta} \) is (in the noise-free case) uniquely determined. This identifiability concept motivates the design of excitation trajectories (Chapter 19, Lesson 2).

In practice, we never know the true parameter vector \( \boldsymbol{\theta}^\star \) exactly. Instead, we use an approximate value \( \hat{\boldsymbol{\theta}} \) obtained from CAD, datasheets, or identification. Define the parameter error

\[ \tilde{\boldsymbol{\theta}} = \hat{\boldsymbol{\theta}} - \boldsymbol{\theta}^\star. \]

3.1 Modeling error in torque predictions

The true torque at a given state is \( \boldsymbol{\tau}^\star = \mathbf{Y}\boldsymbol{\theta}^\star \), while the model predicts \( \hat{\boldsymbol{\tau}} = \mathbf{Y}\hat{\boldsymbol{\theta}} \). Their difference is

\[ \Delta\boldsymbol{\tau} = \hat{\boldsymbol{\tau}} - \boldsymbol{\tau}^\star = \mathbf{Y}(\hat{\boldsymbol{\theta}}-\boldsymbol{\theta}^\star) = \mathbf{Y}\tilde{\boldsymbol{\theta}}. \]

Using the induced 2-norm \( \|\cdot\|_2 \), we obtain the bound

\[ \|\Delta\boldsymbol{\tau}\|_2 \le \|\mathbf{Y}\|_2 \,\|\tilde{\boldsymbol{\theta}}\|_2. \]

Thus, even if \( \|\tilde{\boldsymbol{\theta}}\|_2 \) is small, bad trajectory choices can make \( \|\mathbf{Y}\|_2 \) large and amplify torque errors. Identification aims at minimizing the parameter error, while trajectory design (excitation) aims at making the regressor well-conditioned.

3.2 Effect on simulation

When simulating the robot forward in time, we integrate

\[ \mathbf{M}(\mathbf{q};\hat{\boldsymbol{\theta}})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}};\hat{\boldsymbol{\theta}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q};\hat{\boldsymbol{\theta}}) + \mathbf{F}(\dot{\mathbf{q}};\hat{\boldsymbol{\theta}}) = \boldsymbol{\tau}_{\text{applied}}. \]

Even if the applied torques equal the true physical torques, parameter errors cause the simulated accelerations \( \ddot{\mathbf{q}}_{\text{sim}} \) to differ from the real accelerations \( \ddot{\mathbf{q}}_{\text{true}} \). Over time, these discrepancies accumulate and trajectories diverge. Accurate parameters are therefore crucial for off-line simulation, trajectory optimization, and hardware-in-the-loop testing.

flowchart TD
  P["Parameter error: theta_tilde"] --> Y["Dynamic regressor Y(q, qdot, qddot)"]
  Y --> DT["Torque mismatch Delta_tau = Y * theta_tilde"]
  DT --> ACC["Acceleration mismatch"]
  ACC --> SIM["Simulation error in q(t)"]
  DT --> CTRL["Extra disturbance for model-based control"]
  CTRL --> PER["Degraded tracking and energy usage"]
        

In control engineering, dynamic models are used for feedforward compensation and internal model-based designs. A typical structure (for each joint) is

\[ \tau_{\text{cmd}} = \hat{\mathbf{M}}(\mathbf{q})\mathbf{v} + \hat{\mathbf{C}}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \hat{\mathbf{g}}(\mathbf{q}), \]

where \( \mathbf{v} \) is a virtual control (e.g. PD term) and hats denote quantities computed with \( \hat{\boldsymbol{\theta}} \). Using the regressor representation,

\[ \tau_{\text{cmd}} = \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\mathbf{v})\hat{\boldsymbol{\theta}}, \quad \tau_{\text{true}} = \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\mathbf{v})\boldsymbol{\theta}^\star. \]

The difference \( \Delta\boldsymbol{\tau} = \mathbf{Y}\tilde{\boldsymbol{\theta}} \) acts as an unmodeled disturbance on the closed-loop dynamics. Even if the feedback controller is designed to stabilize the system, large parameter errors can:

• increase tracking errors and overshoot,
• cause oscillations due to poor cancellation of nonlinearities,
• increase actuator effort and energy consumption,
• reduce robustness margins.

Theoretical adaptive and robust control schemes (treated in other courses) explicitly use the dynamic regressor \( \mathbf{Y} \) to adjust or bound \( \tilde{\boldsymbol{\theta}} \). This is only possible because of the linear-in-parameters structure and the ability to estimate parameters from data.

To make the discussion concrete, we consider again the 1-DOF rotary link and implement the regressor and torque prediction in several languages. We compare torques obtained with nominal vs. "identified" parameters. In this lesson we only show how to use parameters; the actual estimation procedure will be derived in later lessons.

5.1 Python (NumPy)

import numpy as np

def regressor(q, qd, qdd):
    """
    Return Y(q, qd, qdd) for the 1-DOF rotary link.
    q, qd, qdd: scalars or NumPy arrays of the same shape.
    """
    q = np.array(q)
    qd = np.array(qd)
    qdd = np.array(qdd)
    sgn = np.sign(qd)
    return np.vstack((qdd, qd, sgn, np.sin(q))).T  # shape (N, 4)

# "True" parameters: [I, b, fc, mgL]
theta_true = np.array([0.8, 0.05, 0.2, 3.0])

# Nominal parameters (e.g., CAD)
theta_nominal = np.array([1.0, 0.02, 0.1, 2.5])

# Sample trajectory
t = np.linspace(0.0, 2.0, 201)
q = 0.5 * np.sin(2.0 * np.pi * t)
qd = np.gradient(q, t)
qdd = np.gradient(qd, t)

Y = regressor(q, qd, qdd)

tau_true = Y @ theta_true
tau_nominal = Y @ theta_nominal

rmse = np.sqrt(np.mean((tau_true - tau_nominal)**2))
print("Torque RMSE between true and nominal model:", rmse)
      

5.2 C++ (Eigen)

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

using Eigen::VectorXd;
using Eigen::MatrixXd;

VectorXd regressor(double q, double qd, double qdd) {
    VectorXd Y(4);
    Y(0) = qdd;
    Y(1) = qd;
    Y(2) = (qd > 0.0) ? 1.0 : ((qd < 0.0) ? -1.0 : 0.0);
    Y(3) = std::sin(q);
    return Y;
}

int main() {
    VectorXd theta_true(4), theta_nominal(4);
    theta_true << 0.8, 0.05, 0.2, 3.0;
    theta_nominal << 1.0, 0.02, 0.1, 2.5;

    double q = 0.5;      // example state
    double qd = 0.1;
    double qdd = -0.3;

    VectorXd Y = regressor(q, qd, qdd);
    double tau_true = Y.dot(theta_true);
    double tau_nominal = Y.dot(theta_nominal);

    std::cout << "tau_true = " << tau_true << std::endl;
    std::cout << "tau_nominal = " << tau_nominal << std::endl;
    std::cout << "difference = " << (tau_nominal - tau_true) << std::endl;
    return 0;
}
      

5.3 Java

public class OneLinkModel {

    // theta = [I, b, fc, mgL]
    private final double[] theta;

    public OneLinkModel(double[] theta) {
        if (theta.length != 4) {
            throw new IllegalArgumentException("theta must have length 4");
        }
        this.theta = theta.clone();
    }

    private double[] regressor(double q, double qd, double qdd) {
        double sgn;
        if (qd > 0.0) sgn = 1.0;
        else if (qd < 0.0) sgn = -1.0;
        else sgn = 0.0;

        return new double[] { qdd, qd, sgn, Math.sin(q) };
    }

    public double torque(double q, double qd, double qdd) {
        double[] Y = regressor(q, qd, qdd);
        double tau = 0.0;
        for (int i = 0; i < 4; ++i) {
            tau += Y[i] * theta[i];
        }
        return tau;
    }

    public static void main(String[] args) {
        double[] thetaTrue = {0.8, 0.05, 0.2, 3.0};
        double[] thetaNominal = {1.0, 0.02, 0.1, 2.5};

        OneLinkModel modelTrue = new OneLinkModel(thetaTrue);
        OneLinkModel modelNom = new OneLinkModel(thetaNominal);

        double q = 0.5, qd = 0.1, qdd = -0.3;
        double tauTrue = modelTrue.torque(q, qd, qdd);
        double tauNom = modelNom.torque(q, qd, qdd);

        System.out.println("tau_true = " + tauTrue);
        System.out.println("tau_nominal = " + tauNom);
        System.out.println("difference = " + (tauNom - tauTrue));
    }
}
      

5.4 MATLAB / Simulink

function tau = one_link_torque(q, qd, qdd, theta)
% theta = [I; b; fc; mgL]

Y = [qdd, qd, sign(qd), sin(q)];
tau = Y * theta;
end

% Example usage:
theta_true = [0.8; 0.05; 0.2; 3.0];
theta_nom  = [1.0; 0.02; 0.1; 2.5];

q   = 0.5;
qd  = 0.1;
qdd = -0.3;

tau_true = one_link_torque(q, qd, qdd, theta_true);
tau_nom  = one_link_torque(q, qd, qdd, theta_nom);
disp(['tau_true = ', num2str(tau_true)])
disp(['tau_nom  = ', num2str(tau_nom)])
disp(['difference = ', num2str(tau_nom - tau_true)])

% In Simulink, one can implement Y(q, qd, qdd) as a subsystem
% and multiply by the parameter vector theta (e.g., using a Gain
% block or Matrix Multiply block) to obtain tau.
      

5.5 Wolfram Mathematica

(* theta = {I, b, fc, mgL} *)
regressor[q_, qd_, qdd_] := {qdd, qd, Sign[qd], Sin[q]}

torque[q_, qd_, qdd_, theta_List] :=
  regressor[q, qd, qdd].theta

thetaTrue   = {0.8, 0.05, 0.2, 3.0};
thetaNom    = {1.0, 0.02, 0.1, 2.5};

q   = 0.5;
qd  = 0.1;
qdd = -0.3;

tauTrue = torque[q, qd, qdd, thetaTrue];
tauNom  = torque[q, qd, qdd, thetaNom];

Print["tau_true = ", tauTrue];
Print["tau_nom  = ", tauNom];
Print["difference = ", tauNom - tauTrue];
      

In all implementations, replacing the nominal parameter vector with an identified one (closer to the true values) reduces the torque mismatch, which in turn reduces prediction and control errors.

In this lesson we motivated why identifying dynamic parameters is essential for robotics. We showed that robot dynamics are linear in their physical parameters via the regressor \( \mathbf{Y}(\mathbf{q},\dot{\mathbf{q}},\ddot{\mathbf{q}}) \), and that parameter errors translate to torque mismatches \( \Delta\boldsymbol{\tau} = \mathbf{Y}\tilde{\boldsymbol{\theta}} \). These mismatches degrade simulation fidelity and model-based control performance. We also introduced the concept of identifiability via the rank of the stacked regressor and illustrated parameter usage in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

Subsequent lessons will address how to design excitation trajectories, formulate least-squares estimators, and validate dynamic models in a statistically sound framework.