In robot control, we rarely know the exact dynamics. Unmodeled friction, payload variation, flexibilities, and external forces act as disturbances. A disturbance observer (DOB) estimates these disturbances online from available measurements (typically joint positions and control inputs) and feeds back an approximate cancelation term to the plant input.

Consider a single-input single-output (SISO) plant with input \( u(t) \), disturbance \( d(t) \), and output \( y(t) \). In the Laplace domain:

\[ y(s) = P(s)\big(u(s) + d(s)\big), \]

where \( P(s) \) is the true plant transfer function. We only know a nominal model \( P_n(s) \), such that

\[ P(s) = \big(1 + \Delta(s)\big) P_n(s), \]

with \( \Delta(s) \) modeling uncertainty. The DOB builds a filtered estimate of the disturbance \( \hat{d}(s) \) using a stable, low-pass filter \( Q(s) \):

\[ \hat{d}(s) = Q(s)\big(P_n^{-1}(s) y(s) - u(s)\big). \]

Intuitively, \( P_n^{-1}(s) y(s) \) is the equivalent input that would have generated the measured output if the plant were exactly \( P_n(s) \). The difference to the actual input \( u(s) \) contains both disturbance contributions and model mismatch. Passing this difference through \( Q(s) \) yields a smoothed disturbance estimate.

The disturbance estimate is then subtracted from the nominal control input:

\[ u(s) = u_0(s) - \hat{d}(s), \]

where \( u_0(s) \) is computed by a nominal controller (e.g., PD, computed torque). The DOB therefore forms an inner loop that makes the plant behave closer to the nominal model seen by the outer-loop controller.

flowchart TD
  R["Reference r"] --> C["Nominal controller C"]
  C --> U0["Nominal input u0"]
  U0 --> SUM1["Summing node"]
  DH["- d_hat"] --> SUM1
  SUM1 --> U["Applied input u"]
  U --> P["Physical robot joint (P)"]
  P --> Y["Measured joint output y"]

  Y --> PN["Pn^-1"]
  PN --> SUM2["Equivalent input - u"]
  U --> SUM2
  SUM2 --> Q["Filter Q(s)"]
  Q --> DH
        

For an \(n\)-DOF manipulator, the joint-space dynamics (which students know from the kinematics and dynamics course) are

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

where \( \mathbf{q} \in \mathbb{R}^n \) are joint angles, \( \boldsymbol{\tau}_c \) are commanded joint torques, and \( \boldsymbol{\tau}_d \) collects all disturbance torques:

• unmodeled Coulomb and viscous friction,
• link flexibility effects,
• payload changes,
• external contact forces projected into joint space,
• parametric errors in \( \mathbf{M}, \mathbf{C}, \mathbf{g} \).

Using a nominal model \( \mathbf{M}_n(\mathbf{q}), \mathbf{C}_n(\mathbf{q},\dot{\mathbf{q}}), \mathbf{g}_n(\mathbf{q}) \), we write

\[ \begin{aligned} \mathbf{M}_n(\mathbf{q}) \ddot{\mathbf{q}} + \mathbf{C}_n(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}_n(\mathbf{q}) &= \boldsymbol{\tau}_c + \boldsymbol{\tau}_\Delta + \boldsymbol{\tau}_d,\\ \boldsymbol{\tau}_\Delta &= \big(\mathbf{M} - \mathbf{M}_n\big)\ddot{\mathbf{q}} + \big(\mathbf{C} - \mathbf{C}_n\big)\dot{\mathbf{q}} + \big(\mathbf{g} - \mathbf{g}_n\big). \end{aligned} \]

Here \( \boldsymbol{\tau}_\Delta \) is the modeling error torque. The DOB aims at estimating the total disturbance torque \( \boldsymbol{\tau}_u = \boldsymbol{\tau}_\Delta + \boldsymbol{\tau}_d \), which is additive at the input of the nominal dynamics.

For design and analysis, we often consider each joint approximately decoupled and described by a scalar model:

\[ M_n(q_i) \ddot{q}_i = \tau_{c,i} + \tau_{u,i}, \]

where coupling terms are absorbed into \( \tau_{u,i} \) and treated as disturbances. This is justified if an inner torque loop has sufficiently high bandwidth or if couplings are relatively weak in the considered regime.

For a SISO plant with additive input disturbance and multiplicative modeling error, the DOB estimator

\[ \hat{d}(s) = Q(s)\big(P_n^{-1}(s) y(s) - u(s)\big) \]

can be analyzed explicitly. Using \( y(s) = P(s) \big(u(s) + d(s)\big) \) and \( P(s) = (1+\Delta(s))P_n(s) \), we get

\[ \begin{aligned} P_n^{-1}(s)y(s) - u(s) &= P_n^{-1}(s)P(s)\big(u(s)+d(s)\big) - u(s) \\ &= \big(1 + \Delta(s)\big)\big(u(s)+d(s)\big) - u(s) \\ &= \Delta(s) u(s) + \big(1 + \Delta(s)\big) d(s). \end{aligned} \]

Hence

\[ \hat{d}(s) = Q(s)\Big(\Delta(s) u(s) + \big(1+\Delta(s)\big) d(s)\Big). \]

The control input is chosen as \( u(s) = u_0(s) - \hat{d}(s) \), so the signal entering the true plant is

\[ u(s) + d(s) = u_0(s) - \hat{d}(s) + d(s). \]

Substituting the expression for \( \hat{d}(s) \) gives a closed-loop from \( d(s) \) to \( y(s) \) that depends on \( Q(s) \) and \( \Delta(s) \). After algebra (omitted here for brevity but strongly recommended as an exercise), the disturbance-to-output transfer function contains the factor

\[ T_d(s) = \big(1 - Q(s)\big) + Q(s)\Delta(s), \]

which should be small over the frequency range where disturbances and modeling error are significant. A typical design guideline is

\[ |T_d(\mathrm{j}\omega)| = \big|\big(1-Q(\mathrm{j}\omega)\big) + Q(\mathrm{j}\omega)\Delta(\mathrm{j}\omega)\big| \ll 1 \quad \text{for low and mid frequencies}, \]

and \( Q(\mathrm{j}\omega) \approx 0 \) at high frequencies, to avoid noise amplification. The DOB can be interpreted using the small-gain theorem discussed in the previous robust stability lesson: as long as \( \|\Delta\|_\infty \|Q\|_\infty < 1 \), the internal loop remains robustly stable.

A common choice is a strictly proper, low-pass filter of the form

\[ Q(s) = \frac{\omega_c}{s + \omega_c}, \]

with cut-off frequency \( \omega_c \) chosen below the noise bandwidth but as high as allowed by modeling uncertainty and sampling.

We now embed the DOB into joint-space control. Consider a single joint whose dominant dynamics are approximated by a rigid-body inertia model

\[ J_n \ddot{q}(t) = \tau_c(t) + \tau_u(t), \]

where \( J_n \) is the nominal inertia and \( \tau_u \) is the unmodeled torque. In Laplace domain:

\[ q(s) = P_n(s)\big(\tau_c(s) + \tau_u(s)\big), \quad P_n(s) = \frac{1}{J_n s^2}. \]

The DOB needs the inverse nominal dynamics:

\[ P_n^{-1}(s) = J_n s^2. \]

Since we only measure position \( q(t) \), we approximate \( \ddot{q}(t) \) numerically (e.g., via filtered differentiation) and use the identity

\[ J_n \ddot{q}(t) = \tau_c(t) + \tau_u(t) \quad \Rightarrow \quad \tau_u(t) = J_n \ddot{q}(t) - \tau_c(t). \]

A continuous-time DOB therefore computes

\[ \hat{\tau}_u(s) = Q(s)\big(J_n s^2 q(s) - \tau_c(s)\big), \]

with a low-pass filter \( Q(s) \) to attenuate noise in the estimated acceleration. The compensated torque command becomes

\[ \tau(s) = \tau_0(s) - \hat{\tau}_u(s), \]

where \( \tau_0 \) is generated by the nominal controller, e.g.

\[ \tau_0 = J_n \ddot{q}_d + K_p\big(q_d - q\big) + K_d\big(\dot{q}_d - \dot{q}\big), \]

corresponding to a computed-torque-like PD controller built on the nominal model. The DOB acts as an inner robustness loop, while the outer-loop PD+feedforward shapes the nominal dynamics.

For vector-valued joint coordinates, we often implement component-wise DOBs (one per joint) using diagonal \( J_n \) and scalar filters \( Q(s) \), which is a good trade-off between simplicity and performance when the inner torque loop bandwidth is high.

flowchart TD
  START["Start control cycle (joint i)"] --> ACC["Estimate q_ddot from q"]
  ACC --> DIFF["Compute J_n * q_ddot - tau_c"]
  DIFF --> LPF["Filter through Q(s) (discrete)"]
  LPF --> DHAT["Disturbance torque estimate tau_u_hat"]
  DHAT --> COMP["Compensated torque: tau = tau0 - tau_u_hat"]
  COMP --> APPLY["Send tau to actuator"]
        

The DOB inner loop modifies the closed-loop dynamics seen by the outer controller. Assuming an outer-loop controller stabilizes the nominal plant \( P_n(s) \), DOB design aims to preserve stability in the presence of modeling error \( \Delta(s) \) and ensure strong disturbance attenuation.

Let \( L_0(s) \) denote the nominal loop transfer function (outer controller times nominal plant). Under mild assumptions (properness, stability of \( Q(s) \) and \( P_n(s) \)), the DOB-modified loop remains stable if the feedback loop formed by \( Q(s)\Delta(s) \) satisfies the small-gain condition

\[ \big\| Q(s)\Delta(s) \big\|_\infty < 1. \]

This inequality restricts how aggressive \( Q(s) \) can be:

• If \( \|\Delta\|_\infty \) is small (accurate model), we can choose \( Q(s) \) with higher bandwidth, giving faster disturbance rejection.
• If modeling uncertainty is large, \( Q(s) \) must be more conservative (slower) to maintain robustness, leaving some disturbance unattenuated.

In joint-space robot applications, practical tuning usually follows this heuristic:

1. Start from a stable, well-tuned joint-space controller (PD or computed torque).
2. Identify an approximate inertia \( J_n \) (from CAD or identification) and dominant sampling frequency.
3. Choose a first-order \( Q(s) = \omega_c/(s+\omega_c) \) with \( \omega_c \) smaller than:
   • half the sampling frequency (to avoid discretization artifacts),
   • the frequency where model uncertainty becomes dominant (Bode plots of \( \Delta(s) \)).
4. Gradually increase \( \omega_c \) until performance is acceptable.

This design should be cross-checked with the robust stability conditions introduced in the previous lesson, by checking that the DOB does not push any closed-loop poles close to the imaginary axis or violate gain/phase margins.

We implement a simple DOB for a single joint described by \( J \ddot{q} = \tau + \tau_u \). We discretize a first-order filter \( Q(s) = \omega_c/(s+\omega_c) \) with forward Euler to obtain

\[ \dot{\hat{\tau}}_u(t) = -\omega_c \hat{\tau}_u(t) + \omega_c\big(J_n \ddot{q}(t) - \tau_c(t)\big). \]

Discretization with sampling period \( T_s \) gives

\[ \hat{\tau}_u[k+1] = \hat{\tau}_u[k] + T_s\Big(-\omega_c \hat{\tau}_u[k] + \omega_c\big(J_n \ddot{q}[k] - \tau_c[k]\big)\Big). \]

The acceleration is estimated from velocity (or position) via finite differences. The following Python code samples illustrate the DOB step inside a control loop:

import numpy as np

class JointDOB:
    def __init__(self, J_nom, w_c, dt):
        self.J_nom = J_nom
        self.w_c = w_c
        self.dt = dt
        self.tau_u_hat = 0.0
        self.q_prev = 0.0
        self.qdot_prev = 0.0
        self.initialized = False

    def update(self, q, qdot, tau_c):
        """
        q     : current joint position
        qdot  : current joint velocity
        tau_c : commanded torque (outer-loop before DOB)
        returns: compensated torque tau = tau_c - tau_u_hat
        """
        if not self.initialized:
            self.q_prev = q
            self.qdot_prev = qdot
            self.initialized = True

        # Approximate acceleration from velocity (could be low-pass filtered in practice)
        qddot = (qdot - self.qdot_prev) / self.dt

        # Disturbance estimate dynamics (forward Euler discretization)
        rhs = -self.w_c * self.tau_u_hat + self.w_c * (self.J_nom * qddot - tau_c)
        self.tau_u_hat = self.tau_u_hat + self.dt * rhs

        tau = tau_c - self.tau_u_hat

        self.q_prev = q
        self.qdot_prev = qdot
        return tau

# Example use inside a control loop
dt = 0.001
dob = JointDOB(J_nom=1.0, w_c=50.0, dt=dt)
Kp, Kd = 100.0, 20.0

def joint_controller(q, qdot, q_des, qdot_des, qddot_des):
    # nominal computed-torque-like law
    tau_c = (1.0 * qddot_des
             + Kp * (q_des - q)
             + Kd * (qdot_des - qdot))
    # DOB compensation
    tau = dob.update(q, qdot, tau_c)
    return tau
      

In a multi-DOF robot, we implement one JointDOB per joint, or a vectorized version using numpy arrays and a diagonal nominal inertia approximation.

A typical real-time implementation in C++ uses Eigen for linear algebra and runs at high frequency in a robot controller thread. Below is a minimal per-joint DOB implementation; a vector version replaces double by Eigen::VectorXd.

#include <Eigen/Dense>

class JointDOB {
public:
    JointDOB(double J_nom, double w_c, double dt)
        : J_nom_(J_nom), w_c_(w_c), dt_(dt),
          tau_u_hat_(0.0), q_prev_(0.0), qdot_prev_(0.0), initialized_(false) {}

    double update(double q, double qdot, double tau_c) {
        if (!initialized_) {
            q_prev_ = q;
            qdot_prev_ = qdot;
            initialized_ = true;
        }

        // Acceleration estimate
        double qddot = (qdot - qdot_prev_) / dt_;

        // Disturbance estimate update
        double rhs = -w_c_ * tau_u_hat_ + w_c_ * (J_nom_ * qddot - tau_c);
        tau_u_hat_ += dt_ * rhs;

        double tau = tau_c - tau_u_hat_;

        q_prev_ = q;
        qdot_prev_ = qdot;
        return tau;
    }

private:
    double J_nom_;
    double w_c_;
    double dt_;
    double tau_u_hat_;
    double q_prev_;
    double qdot_prev_;
    bool initialized_;
};

// Example vector extension (sketch):
// Eigen::VectorXd tau = tau_c - tau_u_hat;
// tau_u_hat += dt_ * (-w_c_ * tau_u_hat + w_c_ * (J_nom_.asDiagonal() * qddot - tau_c));
      

In a full robot controller, this DOB is called after computing the nominal torque tau_c (from PD or model-based control) and before sending commands to the actuators. Care must be taken to keep the DOB computations deterministic and real-time safe.

In Java, we use simple classes and primitive types. The following example shows a SISO DOB for one joint, which can be embedded inside a larger robot control framework.

public class JointDOB {
    private final double Jnom;
    private final double wc;
    private final double dt;

    private double tauUHat = 0.0;
    private double qPrev = 0.0;
    private double qdotPrev = 0.0;
    private boolean initialized = false;

    public JointDOB(double Jnom, double wc, double dt) {
        this.Jnom = Jnom;
        this.wc = wc;
        this.dt = dt;
    }

    public double update(double q, double qdot, double tauC) {
        if (!initialized) {
            qPrev = q;
            qdotPrev = qdot;
            initialized = true;
        }

        double qddot = (qdot - qdotPrev) / dt;

        double rhs = -wc * tauUHat + wc * (Jnom * qddot - tauC);
        tauUHat = tauUHat + dt * rhs;

        double tau = tauC - tauUHat;

        qPrev = q;
        qdotPrev = qdot;
        return tau;
    }
}

// Usage:
// JointDOB dob = new JointDOB(1.0, 50.0, 0.001);
// double tau = dob.update(q, qdot, tauC);
      

For multi-DOF systems, arrays or small matrix libraries can be used to implement vector DOBs, but often a per-joint SISO DOB is sufficient, as long as couplings are treated in the outer loop.

MATLAB and Simulink are standard tools for DOB prototyping. We first specify the nominal joint model and Q-filter, then connect them in Simulink.

% Parameters
J_nom = 1.0;      % nominal inertia
wc    = 50;       % DOB cutoff frequency (rad/s)

s = tf('s');

% Nominal joint model and inverse
Pn   = 1 / (J_nom * s^2);
Pinv = J_nom * s^2;

% Q-filter
Q = wc / (s + wc);

% Example: disturbance observer block in transfer function form
% d_hat(s) = Q(s) * (Pinv(s) * y(s) - tau_c(s))

% In Simulink:
% 1) Use a second derivative block (or 'Derivative' plus filtering) on q(t)
% 2) Multiply by J_nom to get J_nom * q_ddot
% 3) Subtract tau_c to form J_nom * q_ddot - tau_c
% 4) Pass through first-order transfer function wc / (s + wc)
% 5) Subtract d_hat from tau_c to obtain tau = tau_c - d_hat
      

A Simulink implementation consists of:

• plant block for the robot joint (possibly nonlinear via Simscape Multibody),
• outer-loop PD or computed-torque controller,
• inner Q-filter implemented via a first-order transfer function block,
• sum blocks realizing J_nom * q_ddot - tau_c and tau = tau_c - d_hat.

Discrete-time implementation uses the c2d function with the chosen sampling time to convert \( Q(s) \) into \( Q(z) \).

Mathematica provides symbolic and numeric tools to analyze DOB structures. The snippet below builds a simple DOB for a joint inertia model and derives the disturbance transfer function symbolically.

(* Parameters *)
Jnom  = 1.0;
wc    = 50.0;
s     = LaplaceTransformVariable[s];

Pn    = 1/(Jnom s^2);
Pinv  = Jnom s^2;
Q[s_] := wc/(s + wc);

(* Symbolic modeling of plant uncertainty: P = (1 + Delta) Pn *)
Delta[s_] := Symbol["Delta"][s];

(* Disturbance observer estimate *)
dHat[s_, y_, u_] := Q[s] (Pinv y - u);

(* Define plant input and disturbance *)
u0[s_]  := Symbol["u0"][s];
d[s_]   := Symbol["d"][s];

(* Closed-loop equations (u = u0 - dHat) *)
u[s_]   := u0[s] - dHat[s, y[s], u[s]];

(* Plant equation y = P (u + d) *)
y[s_]   := (1 + Delta[s]) Pn (u[s] + d[s]);

(* Now eliminate u to get symbolic T_d(s) = y(s)/d(s) if desired *)
(* In practice, you would use FullSimplify and Solve to manipulate the expressions. *)
      

This environment is useful for deriving analytic expressions for \( T_d(s) \) and exploring how different Q-filters and uncertainty models affect robustness, connecting back to the theoretical analysis earlier in this lesson.

Problem 1 (Deriving the DOB Disturbance Estimate): Let \( y(s) = P(s)\big(u(s) + d(s)\big) \) with \( P(s) = \big(1+\Delta(s)\big)P_n(s) \). Show that the DOB estimate \( \hat{d}(s) = Q(s)\big(P_n^{-1}(s)y(s) - u(s)\big) \) can be written as

\[ \hat{d}(s) = Q(s)\Big(\Delta(s) u(s) + \big(1+\Delta(s)\big)d(s)\Big). \]

Solution:

\[ \begin{aligned} P_n^{-1}(s)y(s) - u(s) &= P_n^{-1}(s)P(s)\big(u(s) + d(s)\big) - u(s) \\ &= P_n^{-1}(s)\big(1+\Delta(s)\big)P_n(s)\big(u(s)+d(s)\big) - u(s) \\ &= \big(1+\Delta(s)\big)\big(u(s)+d(s)\big) - u(s) \\ &= u(s) + d(s) + \Delta(s)u(s) + \Delta(s)d(s) - u(s) \\ &= \Delta(s)u(s) + \big(1+\Delta(s)\big)d(s). \end{aligned} \]

Multiplying by \( Q(s) \) yields the desired formula for \( \hat{d}(s) \).

Problem 2 (Residual Disturbance with Perfect Model): Suppose \( \Delta(s) = 0 \) (perfect model) and \( Q(s) \equiv 1 \). Show that the DOB completely cancels the disturbance \( d(s) \) at the plant input, i.e., that \( u(s) + d(s) = u_0(s) \).

Solution:

For \( \Delta(s) = 0 \), we have \( P(s) = P_n(s) \) and

\[ \hat{d}(s) = Q(s)\big(P_n^{-1}(s)y(s) - u(s)\big) = Q(s)\big(u(s)+d(s) - u(s)\big) = Q(s) d(s). \]

With \( Q(s) = 1 \), this gives \( \hat{d}(s) = d(s) \). The control is \( u(s) = u_0(s) - \hat{d}(s) = u_0(s) - d(s) \), so

\[ u(s) + d(s) = u_0(s) - d(s) + d(s) = u_0(s), \]

meaning that the plant effectively sees the undisturbed input \( u_0(s) \), and the disturbance is fully canceled.

Problem 3 (Small-Gain-Based Q-Filter Design): Assume the uncertainty satisfies \( |\Delta(\mathrm{j}\omega)| \leq \bar{\Delta} \) for all \( \omega \). For a first-order Q-filter \( Q(s) = \omega_c/(s+\omega_c) \), derive a sufficient condition on \( \omega_c \) such that the small-gain condition \( \|Q\Delta\|_\infty < 1 \) holds.

Solution:

We have \( |Q(\mathrm{j}\omega)| = \omega_c/\sqrt{\omega^2 + \omega_c^2} \). For all \( \omega \), this is bounded by 1, and it attains its maximum at \( \omega = 0 \), where \( |Q(\mathrm{j}0)| = 1 \). Hence

\[ \|Q\Delta\|_\infty \leq \big(\sup_\omega |Q(\mathrm{j}\omega)|\big) \big(\sup_\omega |\Delta(\mathrm{j}\omega)|\big) \leq 1 \cdot \bar{\Delta}. \]

A sufficient condition for \( \|Q\Delta\|_\infty < 1 \) is therefore \( \bar{\Delta} < 1 \). Since changing \( \omega_c \) does not reduce the worst-case gain of \( Q \) below 1 for this simple first-order filter, more advanced Q-filter designs (with reduced low-frequency gain) or tighter modeling error bounds are needed for larger \( \bar{\Delta} \).

Problem 4 (DOB for Joint Inertia Variation): Consider a single joint with true inertia \( J = J_n(1+\delta) \), where \( \delta \) is an unknown constant, and dynamics \( J\ddot{q} = \tau_c \) without external disturbances. Show that the DOB based on \( J_n \) and a constant reference acceleration \( \ddot{q}_d \) can estimate the inertia mismatch as a steady disturbance.

Solution:

The true dynamics are \( J\ddot{q} = J_n(1+\delta)\ddot{q} = \tau_c \). Under ideal tracking \( \ddot{q} = \ddot{q}_d \), we have \( \tau_c = J_n(1+\delta)\ddot{q}_d \). The quantity entering the DOB is

\[ J_n \ddot{q}_d - \tau_c = J_n \ddot{q}_d - J_n(1+\delta)\ddot{q}_d = -J_n\delta \ddot{q}_d, \]

which is constant if \( \ddot{q}_d \) is constant. Passing through a low-pass filter \( Q(s) \) with unit DC gain, the DOB converges to \( \hat{\tau}_u = -J_n\delta \ddot{q}_d \), which corresponds exactly to the steady torque mismatch induced by the inertia error. Thus, the DOB compensates the inertia variation as if it were a constant disturbance.

Problem 5 (Interaction Between Outer Loop and DOB): A joint is controlled by an outer-loop PD controller plus DOB compensation as in Section 4. Explain qualitatively what happens if the DOB cutoff frequency \( \omega_c \) is chosen much higher than the outer-loop closed-loop bandwidth.

Solution:

If \( \omega_c \) is much larger than the outer-loop closed-loop bandwidth, the DOB reacts very quickly to any discrepancy between \( J_n\ddot{q} \) and \( \tau_c \). This means that:

• the DOB tries to cancel not only genuine disturbances and model errors but also transient dynamics generated by the outer loop,
• high-frequency measurement noise (especially in acceleration estimates) is strongly amplified, leading to noisy torque commands,
• the effective plant seen by the outer controller changes rapidly, which can reduce phase margin and potentially destabilize the overall loop.

Therefore, \( \omega_c \) should be chosen in coordination with the outer loop bandwidth, typically somewhat higher but not orders of magnitude larger, to achieve a good trade-off between disturbance rejection and robustness.

Disturbance observers provide a powerful, structurally simple method for enhancing robustness of robot joint and task-space controllers against unmodeled dynamics and external forces. By combining a nominal inverse model with a carefully tuned low-pass Q-filter, the DOB estimates an equivalent input disturbance and compensates it at the actuator level.

In this lesson we:

• modeled disturbances in joint-space manipulator dynamics,
• derived the standard DOB structure and its disturbance estimate formula,
• embedded the DOB into joint torque control laws and discussed multi-DOF extensions,
• analyzed robustness using small-gain reasoning and Q-filter design trade-offs,
• presented implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica.

These concepts form a bridge between classical robust control and practical robot controller implementations, and they will be complemented by adaptive and learning-based compensation schemes in subsequent chapters.