In previous lessons of this chapter, we introduced adaptive computed-torque control for robot manipulators. For an n-DOF manipulator with known kinematics and unknown dynamic parameters, the dynamics can be written in linearly parameterized form

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

where \( \mathbf{Y}(\cdot) \) is the regressor matrix and \( \boldsymbol{\theta}^\star \in \mathbb{R}^m \) collects inertial, Coriolis, and gravity parameters. In adaptive computed-torque control we choose

\[ \boldsymbol{\tau} = \mathbf{Y}(q,\dot{q},\dot{q}_r,\ddot{q}_r)\hat{\boldsymbol{\theta}},\quad \dot{\hat{\boldsymbol{\theta}}} = -\Gamma \mathbf{Y}^\top(q,\dot{q},\dot{q}_r,\ddot{q}_r)\,s \]

with filtered tracking error \( s \triangleq \dot{e} + \Lambda e \), \( e \triangleq q - q_d \), positive definite gain matrices \( \Lambda \), \( \Gamma \), and parameter estimate \( \hat{\boldsymbol{\theta}} \).

The Lyapunov analysis (Slotine–Li type) shows that \( s(t) \to 0 \) and \( \hat{\boldsymbol{\theta}}(t) \) remains bounded, providing tracking stability. However, to obtain parameter convergence, i.e. \( \hat{\boldsymbol{\theta}}(t) \to \boldsymbol{\theta}^\star \), we need the regressor signal generated along the closed-loop motion to be sufficiently rich. This richness is captured by the concept of persistent excitation (PE).

flowchart TD
  Qd["Desired joint trajectory q_d(t)"] --> CL["Closed-loop robot dynamics"]
  CL --> Y["Compute regressor phi(t) or Y(q, qdot, qr, qrdot)"]
  Y --> G["Build excitation matrix G(T) = integral phi(t) phi(t)^T dt"]
  G --> TEST["Check eigenvalues(G) above threshold"]
  TEST -->|yes| CONV["Parameter convergence (theory)"]
  TEST -->|no| REDESIGN["Redesign trajectory / add probing motion"]
  

In short: Lyapunov stability does not automatically give parameter convergence. Persistent excitation is the extra condition that links the regressor generated by the reference trajectory to uniqueness of the identified parameters.

Consider a time-varying regressor \( \boldsymbol{\phi}(t) \in \mathbb{R}^m \) which is typically a row or column of the robot regressor \( \mathbf{Y} \) (possibly stacked across joints). A standard continuous-time definition of persistent excitation is:

\[ \boldsymbol{\phi}(t) \text{ is persistently exciting } \Longleftrightarrow \exists\, T_0 > 0,\ \alpha_1 > 0,\ \alpha_2 > 0 \text{ such that } \forall t \ge 0, \]

\[ \alpha_1 \mathbf{I}_m \preceq \int_{t}^{t+T_0} \boldsymbol{\phi}(\sigma)\boldsymbol{\phi}(\sigma)^\top d\sigma \preceq \alpha_2 \mathbf{I}_m. \]

Here \( \preceq \) denotes the usual matrix inequality on symmetric matrices. Intuitively, in every time window of length \( T_0 \), the Gramian \( \int_{t}^{t+T_0} \boldsymbol{\phi}\boldsymbol{\phi}^\top \) is uniformly positive definite and bounded.

For discrete-time regressor samples \( \boldsymbol{\phi}(k) \) (e.g. sampled at the control period), we say that \( \boldsymbol{\phi}(k) \) is PE if there exist integers \( N_0 \), scalar bounds \( \alpha_1 > 0 \), \( \alpha_2 > 0 \) such that

\[ \forall k \ge 0,\quad \alpha_1 \mathbf{I}_m \preceq \sum_{i=k}^{k+N_0} \boldsymbol{\phi}(i)\boldsymbol{\phi}(i)^\top \preceq \alpha_2 \mathbf{I}_m. \]

In robot adaptive control, \( \boldsymbol{\phi}(t) \) is constructed from joint positions, velocities, accelerations, and possibly reference signals. The PE condition means that the robot explores the parameter space in such a way that no nonzero parameter vector can remain invisible to the measured signals.

To isolate the role of PE, consider the classic linear regression model

\[ y(t) = \boldsymbol{\phi}^\top(t)\boldsymbol{\theta}^\star \]

where \( \boldsymbol{\theta}^\star \) is constant but unknown. We implement the gradient-type adaptive law

\[ \dot{\hat{\boldsymbol{\theta}}}(t) = -\Gamma \boldsymbol{\phi}(t) e(t),\quad e(t) \triangleq y(t) - \boldsymbol{\phi}^\top(t)\hat{\boldsymbol{\theta}}(t), \]

with positive definite learning gain matrix \( \Gamma \). Define the parameter error

\[ \tilde{\boldsymbol{\theta}}(t) \triangleq \hat{\boldsymbol{\theta}}(t) - \boldsymbol{\theta}^\star. \]

Then \( e(t) = \boldsymbol{\phi}^\top(t)\tilde{\boldsymbol{\theta}}(t) \) and the error dynamics is

\[ \dot{\tilde{\boldsymbol{\theta}}}(t) = -\Gamma \boldsymbol{\phi}(t)\boldsymbol{\phi}^\top(t) \tilde{\boldsymbol{\theta}}(t). \]

Choose the Lyapunov function

\[ V(t) = \tfrac{1}{2}\tilde{\boldsymbol{\theta}}^\top(t) \Gamma^{-1}\tilde{\boldsymbol{\theta}}(t). \]

Its derivative along trajectories is

\[ \dot{V}(t) = -\tilde{\boldsymbol{\theta}}^\top(t) \boldsymbol{\phi}(t)\boldsymbol{\phi}^\top(t)\tilde{\boldsymbol{\theta}}(t) = -e^2(t) \le 0, \]

which shows boundedness of \( \tilde{\boldsymbol{\theta}}(t) \) and square integrability of \( e(t) \). To conclude \( \tilde{\boldsymbol{\theta}}(t) \to 0 \), we use the PE inequality. Integrating \( \dot{V} \) over a window \( [t, t+T_0] \) gives

\[ V(t+T_0) - V(t) = -\int_{t}^{t+T_0} \tilde{\boldsymbol{\theta}}^\top(\sigma) \boldsymbol{\phi}(\sigma)\boldsymbol{\phi}^\top(\sigma) \tilde{\boldsymbol{\theta}}(\sigma)\,d\sigma. \]

Under PE and boundedness of \( \tilde{\boldsymbol{\theta}}(\sigma) \), one can show that if \( \tilde{\boldsymbol{\theta}}(t) \) does not converge to zero, then the integral above cannot remain bounded, which contradicts the boundedness of \( V(t) \). A more detailed argument yields exponential convergence of \( \tilde{\boldsymbol{\theta}}(t) \) with rate proportional to the lower bound \( \alpha_1 \) in the PE condition.

For robot manipulators, the adaptive law applied to \( s \) can be reduced to such a linear form where the regressor is built from the closed-loop motion. PE of the robot regressor along the executed trajectory is therefore the key structural assumption behind full parameter convergence in adaptive robot control.

In practice we never have access to the infinite-time regressor. Instead we collect samples over a finite horizon and approximate the excitation Gramian using sums. For discrete-time samples \( \boldsymbol{\phi}(k) \in \mathbb{R}^m \) with sampling period \( T_s \), a typical finite-time Gramian is

\[ G_N \triangleq T_s \sum_{k=0}^{N} \boldsymbol{\phi}(k)\boldsymbol{\phi}(k)^\top. \]

A practical test is to check whether the smallest eigenvalue \( \lambda_{\min}(G_N) \) is sufficiently large compared to noise and modeling errors. A small value indicates that some directions in parameter space are weakly excited and will be poorly identified.

For robot arms, one often designs multi-sine trajectories for each joint:

\[ q_{d,i}(t) = q_{0,i} + \sum_{k=1}^{K} a_{ik} \sin(\omega_{ik} t + \varphi_{ik}), \]

with multiple incommensurate frequencies \( \omega_{ik} \). Such trajectories tend to generate a persistently exciting regressor for many manipulator models, while joint limits and velocity/torque constraints bound the amplitudes \( a_{ik} \).

flowchart TD
  START["Specify identification task (which parameters?)"]
  START --> LIM["Impose joint limits & torque/velocity bounds"]
  LIM --> TRAJ["Choose multi-sine joint trajectories"]
  TRAJ --> SIM["Simulate robot and compute regressor samples phi(k)"]
  SIM --> G["Form Gramian G_N = sum phi(k) phi(k)^T"]
  G --> EIG["Compute eigenvalues(G_N)"]
  EIG --> GOOD["If lambda_min large: accept trajectory"]
  EIG --> BAD["If lambda_min small: adjust frequencies/amplitudes"]
        

This design loop is routinely implemented offline before running adaptive control experiments on actual hardware, where safety and saturation constraints are strict.

While PE is mathematically elegant, real robots rarely satisfy strict PE conditions:

• Finite experiment duration: the theoretical PE condition is uniform in time, but experiments occur over a finite horizon. We only guarantee excitation on that horizon, so asymptotic convergence is replaced by finite-time accuracy.
• Input saturation and safety constraints: high-frequency or large-amplitude probing signals that improve excitation may violate torque, velocity, or safety limits. Trajectories must therefore be rich but safe.
• Measurement noise: noisy joint position, velocity, and acceleration estimates inflate the Gramian and can make the PE test unreliable. One typically regularizes the Gramian or filters signals before evaluating eigenvalues.
• Unmodeled dynamics: friction, flexibility, and sensor dynamics cause the true input–output relation to deviate from the linear parameterization. Even with PE regressor signals, the identified parameters converge to effective rather than physical values.
• Structural unidentifiability: some parameter combinations (e.g. masses vs inertia about joints) are inherently indistinguishable from torque data. PE cannot fix structural non-identifiability; only identifiable parameter combinations can converge.

To alleviate these issues, many adaptive robot controllers use:

• Normalization of regressors to avoid excessively large learning steps when signals spike.
• Projection operators to keep parameter estimates inside a known compact set, preventing divergence when excitation is poor.
• Data reuse / concurrent learning ideas, where stored past data provide additional virtual excitation if the plant is not currently moving in rich ways.

These techniques relax pure PE assumptions and aim for robust performance under realistic robot operating conditions.

We illustrate PE numerically using Python. First, we create two regressors: one persistently exciting (multi-frequency) and one nearly rank-deficient. We compute the discrete Gramian and its eigenvalues, and then run a scalar adaptive law to observe identification quality.

import numpy as np

# Time grid
T_end = 40.0
dt = 0.01
t = np.arange(0.0, T_end, dt)
N = len(t)

# Regressor dimension m = 2
def phi_pe(tt):
    # Rich regressor: different frequencies
    return np.array([np.sin(0.7 * tt), np.cos(1.3 * tt)])

def phi_poor(tt):
    # Nearly collinear components: poor excitation
    s = np.sin(0.7 * tt)
    return np.array([s, 2.0 * s])

# Build samples
Phi_pe = np.zeros((N, 2))
Phi_poor = np.zeros((N, 2))
for k in range(N):
    Phi_pe[k, :] = phi_pe(t[k])
    Phi_poor[k, :] = phi_poor(t[k])

def gramian(Phi, dt):
    # G_N = dt * sum phi(k) phi(k)^T
    G = np.zeros((Phi.shape[1], Phi.shape[1]))
    for k in range(Phi.shape[0]):
        phi_k = Phi[k, :].reshape(-1, 1)
        G += phi_k @ phi_k.T
    return dt * G

G_pe = gramian(Phi_pe, dt)
G_poor = gramian(Phi_poor, dt)

eig_pe = np.linalg.eigvalsh(G_pe)
eig_poor = np.linalg.eigvalsh(G_poor)

print("Eigenvalues (PE regressor)   :", eig_pe)
print("Eigenvalues (poor regressor):", eig_poor)

# Simple scalar identification example:
theta_star = 2.0    # true parameter
gamma = 5.0         # adaptation gain
theta_hat_pe = 0.0
theta_hat_poor = 0.0

for k in range(N - 1):
    # Use only the first component as scalar regressor
    phi1 = Phi_pe[k, 0]
    phi2 = Phi_poor[k, 0]
    y1 = phi1 * theta_star
    y2 = phi2 * theta_star

    e1 = y1 - phi1 * theta_hat_pe
    e2 = y2 - phi2 * theta_hat_poor

    # Forward Euler discretization of theta_dot = -gamma * phi * e
    theta_hat_pe += dt * (-gamma * phi1 * e1)
    theta_hat_poor += dt * (-gamma * phi2 * e2)

print("Estimated theta (PE regressor)   :", theta_hat_pe)
print("Estimated theta (poor regressor):", theta_hat_poor)
      

In a robotics context, Phi_pe and Phi_poor would be constructed from rows of the manipulator regressor Y(q, qdot, qr, qrdot) computed along a chosen trajectory using a robotics library (e.g. roboticstoolbox-python).

In C++, the Eigen library is commonly used for linear algebra. Together with libraries such as RBDL, Pinocchio, or Orocos KDL, we can generate regressor samples for a robot and test excitation numerically.

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

// Each regressor sample is an Eigen::VectorXd of size m
double computeMinEigenvalue(
    const std::vector<Eigen::VectorXd> &samples,
    double dt)
{
    if (samples.empty()) {
        return 0.0;
    }
    std::size_t m = static_cast<std::size_t>(samples[0].size());
    Eigen::MatrixXd G = Eigen::MatrixXd::Zero(m, m);
    for (std::size_t k = 0; k < samples.size(); ++k) {
        const Eigen::VectorXd &phi = samples[k];
        G += phi * phi.transpose();
    }
    G *= dt;

    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es(G);
    if (es.info() != Eigen::Success) {
        throw std::runtime_error("Eigen decomposition failed");
    }
    Eigen::VectorXd vals = es.eigenvalues();
    return vals.minCoeff();
}

int main() {
    // Example: suppose we already filled samples with regressor vectors
    std::vector<Eigen::VectorXd> samples;
    double dt = 0.001;

    // ... fill samples using a robotics dynamics library:
    // for each time step, call something like:
    //   RBDL::NonlinearEffects(model, q, qdot, tau);
    // or build a regressor Y(q, qdot, qr, qrdot) manually.

    try {
        double lambda_min = computeMinEigenvalue(samples, dt);
        std::cout << "lambda_min(G_N) = " << lambda_min << std::endl;
    } catch (const std::exception &ex) {
        std::cerr << "Error: " << ex.what() << std::endl;
    }
    return 0;
}
      

In practice, you would combine this with a C++ robot dynamics library to generate regressor samples along a trajectory, then verify that lambda_min(G_N) exceeds a design threshold before trusting parameter convergence theorems.

Java is less common for low-level robot control but is used in higher-level frameworks. The EJML library supports efficient dense linear algebra. The following example computes a discrete Gramian for regressors obtained from a higher-level robot simulator or middleware:

import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;
import java.util.List;

public class ExcitationChecker {

    public static DMatrixRMaj gramian(List<DMatrixRMaj> phiList, double dt) {
        if (phiList.isEmpty()) {
            return new DMatrixRMaj(0, 0);
        }
        int m = phiList.get(0).getNumRows();
        DMatrixRMaj G = new DMatrixRMaj(m, m);
        G.zero();

        DMatrixRMaj outer = new DMatrixRMaj(m, m);
        DMatrixRMaj phiT = new DMatrixRMaj(1, m);

        for (DMatrixRMaj phi : phiList) {
            // outer = phi * phi^T
            phiT.reshape(1, m);
            CommonOps_DDRM.transpose(phi, phiT);
            CommonOps_DDRM.mult(phi, phiT, outer);
            CommonOps_DDRM.addEquals(G, outer);
        }

        CommonOps_DDRM.scale(dt, G);
        return G;
    }
}
      

One can then compute eigenvalues using EJML or another Java library to obtain an approximate minimum eigenvalue and decide whether the regressor is sufficiently exciting for identification.

MATLAB, together with Robotics System Toolbox and Simulink, is a standard environment for robot control experiments. A typical workflow is:

1. Define a robot model (e.g. DH parameters or URDF import).
2. Specify joint-space multi-sine trajectories for identification.
3. Simulate the closed-loop system in Simulink, logging q, qdot, and reference signals.
4. Post-process logs to compute the regressor Y and the Gramian.

% Example: PE check from logged regressor data Y_k (N x m)
load('regressor_log.mat', 'Y', 'dt');  % Y: N-by-m, dt: sampling time

[N, m] = size(Y);
G = zeros(m, m);
for k = 1:N
    phi_k = Y(k, :).';
    G = G + (phi_k * phi_k.');
end
G = dt * G;

lambda = eig((G + G.') / 2);    % symmetrized for numerical stability
lambda_min = min(lambda);

disp('Eigenvalues of G_N:');
disp(lambda.');
fprintf('lambda_min(G_N) = %.4f\n', lambda_min);

% Threshold for "practical PE" decision
lambda_threshold = 1e-2;
if lambda_min > lambda_threshold
    disp('Regressor is sufficiently exciting on this horizon.');
else
    disp('Regressor is poorly exciting; redesign trajectory.');
end
      

In Simulink, the adaptive law for robot control can be implemented using blocks for computing the regressor Y(q, qdot, qr, qrdot), matrix gains, and integrators for theta_hat. The Gramian analysis is typically performed offline in MATLAB.

Wolfram Mathematica is useful for symbolic manipulations and analytic insight. For a simple two-dimensional regressor built from sinusoids, we can compute the Gramian symbolically and inspect its eigenvalues:

(* Define regressor phi(t) *)
phi[t_] := {
  Sin[omega1 t],
  Cos[omega2 t]
};

(* Continuous-time Gramian over [0, T0] *)
G[T0_] := Integrate[
  phi[t].Transpose[{phi[t]}],
  {t, 0, T0},
  Assumptions -> {T0 > 0, omega1 > 0, omega2 > 0}
];

(* Example numeric parameters *)
omega1Val = 0.7;
omega2Val = 1.3;
T0Val = 20.0;

Gnum = G[T0Val] /. {omega1 -> omega1Val, omega2 -> omega2Val};
eigs = Eigenvalues[Gnum];

Print["Gramian G(T0) = "];
Print[MatrixForm[Gnum]];
Print["Eigenvalues = ", eigs];
      

For robot applications, the regressor phi[t] can be derived symbolically from the manipulator equations using Mathematica's FullSimplify and then integrated analytically or numerically to reason about excitation properties without discretization artifacts.

Problem 1 (Scalar PE and Parameter Convergence). Consider the scalar regression \( y(t) = \phi(t)\theta^\star \) with adaptive law

\[ \dot{\hat{\theta}}(t) = -\gamma \phi(t)e(t),\quad e(t) = y(t) - \phi(t)\hat{\theta}(t), \]

where \( \gamma > 0 \). Assume \( \phi(t) \) is bounded and persistently exciting in the sense that

\[ \exists\, T_0 > 0,\ \alpha_1 > 0:\quad \forall t \ge 0,\quad \int_{t}^{t+T_0} \phi^2(\sigma)\,d\sigma \ge \alpha_1. \]

Show that the parameter error \( \tilde{\theta}(t) \triangleq \hat{\theta}(t) - \theta^\star \) converges to zero.

Solution. We have \( e(t) = \phi(t)\tilde{\theta}(t) \) and

\[ \dot{\tilde{\theta}}(t) = -\gamma \phi^2(t)\tilde{\theta}(t). \]

Consider the Lyapunov function \( V(t) = \tfrac{1}{2}\tilde{\theta}^2(t) \). Then

\[ \dot{V}(t) = \tilde{\theta}(t)\dot{\tilde{\theta}}(t) = -\gamma \phi^2(t)\tilde{\theta}^2(t) \le 0. \]

Hence \( \tilde{\theta}(t) \) is bounded and \( \tilde{\theta}^2(t) \) is nonincreasing. Integrating over \( [t,t+T_0] \) gives

\[ V(t+T_0) - V(t) = -\gamma \int_{t}^{t+T_0} \phi^2(\sigma)\tilde{\theta}^2(\sigma)\,d\sigma. \]

Since \( V(t) \) is bounded below, the left-hand side is bounded from below. Assume by contradiction that \( |\tilde{\theta}(t)| \ge \varepsilon > 0 \) for all large \( t \). Then

\[ \int_{t}^{t+T_0} \phi^2(\sigma)\tilde{\theta}^2(\sigma)\,d\sigma \ge \varepsilon^2 \int_{t}^{t+T_0} \phi^2(\sigma)\,d\sigma \ge \varepsilon^2 \alpha_1, \]

which implies that \( V(t) \) decreases by at least \( \gamma\varepsilon^2\alpha_1 \) every interval of length \( T_0 \). This contradicts boundedness of \( V(t) \). Therefore \( \tilde{\theta}(t) \to 0 \).

Problem 2 (PE for Sinusoidal Regressors). Let \( \boldsymbol{\phi}(t) \in \mathbb{R}^2 \) be

\[ \boldsymbol{\phi}_1(t) = \begin{bmatrix} \sin(\omega t)\\ \cos(\omega t) \end{bmatrix}, \quad \boldsymbol{\phi}_2(t) = \begin{bmatrix} \sin(\omega t)\\ 2\sin(\omega t) \end{bmatrix}. \]

Which of these regressors is persistently exciting?

Solution. For \( \boldsymbol{\phi}_1(t) \), the components \( \sin(\omega t) \) and \( \cos(\omega t) \) are linearly independent over any interval of length larger than a period. The Gramian

\[ G_1(T_0) = \int_{t}^{t+T_0} \boldsymbol{\phi}_1(\sigma) \boldsymbol{\phi}_1^\top(\sigma)\,d\sigma \]

is full rank for any \( T_0 \) sufficiently large and its eigenvalues remain bounded away from zero uniformly in \( t \). Thus \( \boldsymbol{\phi}_1 \) is PE. For \( \boldsymbol{\phi}_2 \), the second component is always twice the first, so the regressor lives in a one-dimensional subspace. Hence \( G_2(T_0) \) has rank one for all \( T_0 \), and \( \boldsymbol{\phi}_2 \) is not PE.

Problem 3 (PE and Constant Trajectories for Robots). Consider a robot controlled with a constant desired joint position \( q_d(t) = q_0 \). Argue qualitatively why the corresponding regressor \( \mathbf{Y}(q,\dot{q},\dot{q}_r,\ddot{q}_r) \) is not persistently exciting, and which types of parameters become difficult to identify.

Solution. If \( q_d(t) \) is constant, the closed-loop motion converges so that \( q(t) \to q_0 \) and \( \dot{q}(t), \ddot{q}(t) \to 0 \). The regressor then becomes essentially constant in time and dominated by the gravity term \( \mathbf{g}(q_0) \). Inertial and Coriolis parameters, which affect torques through velocities and accelerations, are not excited. The Gramian built from such a regressor is rank-deficient and fails PE. Only combinations of parameters that influence static torques at \( q_0 \) can be identified; dynamic parameters remain unidentifiable.

Problem 4 (Rank Condition and Non-PE). Let \( \boldsymbol{\phi}(k) \in \mathbb{R}^m \) be a discrete-time regressor and consider the finite Gramian

\[ G_N = \sum_{k=0}^{N} \boldsymbol{\phi}(k)\boldsymbol{\phi}(k)^\top. \]

Show that if \( \operatorname{rank}(G_N) < m \) for all \( N \), then \( \boldsymbol{\phi}(k) \) is not persistently exciting.

Solution. If \( \operatorname{rank}(G_N) < m \) for all \( N \), there exists a nonzero vector \( v \in \mathbb{R}^m \) such that \( v^\top G_N v = 0 \) for all \( N \). But

\[ v^\top G_N v = \sum_{k=0}^{N} v^\top \boldsymbol{\phi}(k)\boldsymbol{\phi}(k)^\top v = \sum_{k=0}^{N} (v^\top \boldsymbol{\phi}(k))^2. \]

Therefore \( (v^\top \boldsymbol{\phi}(k))^2 = 0 \) for all \( k \), which implies \( v^\top \boldsymbol{\phi}(k) = 0 \) for all samples. Thus there is a nonzero parameter direction \( v \) to which the regressor is blind. The PE condition requires the Gramian over windows to be uniformly positive definite, which cannot hold in this case. Hence \( \boldsymbol{\phi}(k) \) is not PE.

Problem 5 (Trajectory Design Under Torque Limits). Suppose each joint torque is limited by \( \|\boldsymbol{\tau}(t)\|_\infty \le \tau_{\max} \) and joint velocities by \( \|\dot{q}(t)\|_\infty \le \dot{q}_{\max} \). Describe how you would design a multi-sine trajectory that is rich enough to produce approximate PE while respecting these bounds.

Solution. One practical strategy is:

• Choose a base configuration \( q_0 \) away from joint limits.
• For each joint, construct \( q_{d,i}(t) = q_{0,i} + \sum_{k=1}^{K} a_{ik}\sin(\omega_{ik} t + \varphi_{ik}) \) with moderate amplitudes \( a_{ik} \) so that the resulting velocities \( \dot{q}_{d,i}(t) \) are below \( \dot{q}_{\max} \).
• Select multiple incommensurate frequencies \( \omega_{ik} \) to avoid periodic repetition of the same regressor patterns and increase excitation richness.
• Simulate the robot with these trajectories and compute the resulting torques. If \( \|\boldsymbol{\tau}(t)\|_\infty \) exceeds \( \tau_{\max} \), scale down the amplitudes \( a_{ik} \) uniformly.
• Compute the discrete Gramian from simulated regressor samples and adjust amplitudes and frequencies until the minimum eigenvalue exceeds a chosen threshold.

This approach trades off safety constraints against excitation richness in a systematic manner.

This lesson introduced persistent excitation as the key signal property enabling parameter convergence in adaptive robot control. We defined PE in continuous and discrete time, showed how it enters Lyapunov-based proofs for linear adaptive laws, and linked it to the regressor generated by adaptive computed-torque controllers for manipulators. We also emphasized the considerable practical limitations of strict PE on physical robots and presented numerical methods for approximating excitation using finite-time Gramians. Finally, we demonstrated how to implement such checks in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, preparing the ground for experimental comparisons between adaptive and fixed-model controllers in the next lesson.