In industrial and service robots, rotary actuators are almost never directly connected to joints. Instead, a gear train provides torque amplification and speed reduction. Let the motor shaft angle be \( \theta_m \) and the joint angle be \( q \). We define the (speed) gear ratio \( n > 1 \) for a reduction gear by

\[ n \triangleq \frac{\dot{\theta}_m}{\dot{q}} \quad\Rightarrow\quad \theta_m = n q,\;\; \dot{\theta}_m = n \dot{q}. \]

The ideal (lossless) gear imposes a power balance between motor and joint:

\[ P_m = \tau_m \dot{\theta}_m \;=\; \tau_q \dot{q} = P_q, \]

where \( \tau_m \) is the motor torque and \( \tau_q \) is the joint torque. Combined with the kinematic relation, this yields the torque transformation

\[ \tau_q = n\, \tau_m, \qquad \tau_m = \frac{1}{n}\, \tau_q \quad\text{(ideal, lossless gear)}. \]

In real systems, gear efficiency \( 0 < \eta \leq 1 \) modifies this relation to

\[ \tau_q = n\,\eta\, \tau_m, \qquad \tau_m = \frac{1}{n\,\eta}\, \tau_q. \]

Gears therefore act as an impedance transformer: they reshape both torque and inertia as seen from motor and joint sides. This motivates the concept of reflected inertia.

flowchart TD
  M["Motor shaft (theta_m, tau_m)"] --> G["Gear train (ratio n, efficiency eta)"]
  G --> J["Joint (q, tau_q)"]
  M --> KE1["Kinetic energy: 0.5*J_m*omega_m^2"]
  J --> KE2["Kinetic energy: 0.5*J_L*omega_q^2"]
  KE1 --> REQ["Reflected inertia seen at motor"]
  KE2 --> REJ["Reflected inertia seen at joint"]
        

Consider a single revolute joint driven through a gear by a motor. Let \( J_m \) be the motor rotor inertia and \( J_L \) the link inertia referred to the joint axis. For now, we neglect gear-body inertia and assume rigid, backlash-free gearing.

The kinetic energy expressed in terms of motor shaft velocity \( \dot{\theta}_m \) is

\[ T = \frac{1}{2} J_m \dot{\theta}_m^2 + \frac{1}{2} J_L \dot{q}^2. \]

Using the kinematic relation \( \dot{\theta}_m = n \dot{q} \) and \( q = \theta_m / n \), we can express everything either in joint or motor coordinates.

Expressed in motor coordinates.

\[ \dot{q} = \frac{1}{n}\dot{\theta}_m \quad\Rightarrow\quad T = \frac{1}{2} J_m \dot{\theta}_m^2 + \frac{1}{2} J_L \left(\frac{1}{n}\dot{\theta}_m\right)^2 = \frac{1}{2} \left( J_m + \frac{J_L}{n^2} \right) \dot{\theta}_m^2. \]

Thus the equivalent inertia seen at the motor is

\[ J_{\text{eq},m} = J_m + \frac{J_L}{n^2}. \]

Expressed in joint coordinates.

\[ \dot{\theta}_m = n \dot{q} \quad\Rightarrow\quad T = \frac{1}{2} J_m (n \dot{q})^2 + \frac{1}{2} J_L \dot{q}^2 = \frac{1}{2} \left( n^2 J_m + J_L \right) \dot{q}^2. \]

Hence the equivalent inertia seen at the joint is

\[ J_{\text{eq},q} = n^2 J_m + J_L. \]

The key observation is that inertia terms scale with the square of the gear ratio. High reduction ratios make the link inertia almost negligible from the motor's perspective, while the motor inertia can dominate the joint dynamics.

If we include a lumped gear inertia \( J_g \) on the motor side (e.g., pinion inertia), we simply add it:

\[ J_{\text{eq},m} = J_m + J_g + \frac{J_L}{n^2}, \qquad J_{\text{eq},q} = n^2 (J_m + J_g) + J_L. \]

We now derive the equation of motion in terms of the joint coordinate \( q \). Assume the joint is driven by a motor with torque \( \tau_m \), including joint-side load torque \( \tau_{\text{ext}} \) from gravity and other links. Following Chapter 10–11 notation, we can write the link dynamics at the joint as

\[ J_L(q) \ddot{q} + C_L(q,\dot{q}) \dot{q} + g_L(q) = \tau_q + \tau_{\text{ext}}, \]

where \( C_L(q,\dot{q}) \) collects Coriolis/centrifugal effects and \( g_L(q) \) gravitational torque. On the motor side (rotor + gear inertia), we have

\[ (J_m + J_g) \ddot{\theta}_m + b_m \dot{\theta}_m = \tau_m - \tau_{\text{load},m}, \]

where \( b_m \) is viscous friction at the motor and \( \tau_{\text{load},m} \) is the torque transmitted through the gear from the joint load. Using the non-ideal gear relation

\[ \tau_q = n\,\eta\, \tau_m, \qquad \tau_{\text{load},m} = \frac{1}{n\,\eta}\tau_q, \]

and the kinematic constraint \( \theta_m = n q \), we can eliminate \( \theta_m \). Differentiating: \( \dot{\theta}_m = n \dot{q} \), \( \ddot{\theta}_m = n \ddot{q} \), hence the motor equation becomes

\[ (J_m + J_g) n \ddot{q} + b_m n \dot{q} = \tau_m - \frac{1}{n\,\eta}\tau_q. \]

Solving for \( \tau_q \) and equating with the link dynamics produces a single equivalent equation in \( q \). With moderate algebra, one obtains the joint-side equation:

\[ \underbrace{\left(J_L(q) + n^2(J_m + J_g)\right)}_{J_{\text{eq},q}(q)} \ddot{q} + C_L(q,\dot{q}) \dot{q} + g_L(q) + b_{\text{eq}} \dot{q} = n\,\eta\, \tau_m + \tau_{\text{ext}}, \]

where \( b_{\text{eq}} = n^2 b_m + b_q \) combines motor viscous friction and joint-side viscous friction \( b_q \) (from Lesson 1). In this form, the effect of the gear is entirely captured by the equivalent inertia and friction terms and by the torque scaling \( n\,\eta \).

For an \( n \)-DOF manipulator with generalized joint coordinates \( \mathbf{q} \in \mathbb{R}^n \) and motor coordinates \( \boldsymbol{\theta}_m \in \mathbb{R}^n \), we define a diagonal gear ratio matrix

\[ \boldsymbol{\theta}_m = \mathbf{N} \mathbf{q}, \qquad \mathbf{N} = \operatorname{diag}(n_1,\dots,n_n). \]

The standard rigid-body dynamics (without explicit motor inertias) in joint coordinates are

\[ \mathbf{H}(\mathbf{q}) \ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) = \boldsymbol{\tau}_q + \boldsymbol{\tau}_{\text{ext}}, \]

with \( \mathbf{H}(\mathbf{q}) \) the joint-space inertia matrix. Let \( \mathbf{J}_m \) be the diagonal rotor+gear inertia matrix in motor coordinates and \( \mathbf{b}_m \) the motor-side viscous friction. The motor dynamics are

\[ \mathbf{J}_m \ddot{\boldsymbol{\theta}}_m + \mathbf{b}_m \dot{\boldsymbol{\theta}}_m = \boldsymbol{\tau}_m - \boldsymbol{\tau}_{\text{load},m}. \]

Using the generalized relations

\[ \boldsymbol{\theta}_m = \mathbf{N} \mathbf{q}, \quad \dot{\boldsymbol{\theta}}_m = \mathbf{N} \dot{\mathbf{q}}, \quad \ddot{\boldsymbol{\theta}}_m = \mathbf{N} \ddot{\mathbf{q}}, \]

and the non-ideal torque mapping (componentwise) \( \boldsymbol{\tau}_q = \mathbf{N}\, \boldsymbol{\eta}\, \boldsymbol{\tau}_m \), where \( \boldsymbol{\eta} = \operatorname{diag}(\eta_1,\dots,\eta_n) \), one can derive the joint-space dynamics including motor inertias:

\[ \left[ \mathbf{H}(\mathbf{q}) + \mathbf{N}^\top \mathbf{J}_m \mathbf{N} \right] \ddot{\mathbf{q}} + \mathbf{C}_{\text{eq}}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) + \mathbf{b}_{\text{eq}} \dot{\mathbf{q}} = \mathbf{N}\, \boldsymbol{\eta}\, \boldsymbol{\tau}_m + \boldsymbol{\tau}_{\text{ext}}. \]

Here, \( \mathbf{N}^\top \mathbf{J}_m \mathbf{N} \) is the reflected motor inertia matrix in joint coordinates and \( \mathbf{b}_{\text{eq}} \) combines motor and joint friction. The Coriolis/centrifugal term \( \mathbf{C}_{\text{eq}}(\mathbf{q},\dot{\mathbf{q}}) \) is obtained by recomputing the Christoffel symbols using the total inertia \( \mathbf{H}(\mathbf{q}) + \mathbf{N}^\top \mathbf{J}_m \mathbf{N} \), ensuring energy consistency.

We implement a simple one-DOF joint with gear ratio \( n \) and compare the step response for different gear ratios. We use numpy for arithmetic, and this code can be embedded in a robotics pipeline based on roboticstoolbox-python by wrapping the equivalent inertia and friction into the manipulator model.

import numpy as np

def reflected_inertia_single(J_m, J_L, n, J_g=0.0):
    """
    Compute equivalent inertia seen at joint for a geared single-DOF system.
    J_m : motor inertia
    J_L : link inertia at joint
    n   : gear ratio (theta_m = n * q)
    J_g : gear lumped inertia on motor side
    """
    J_eq_q = n**2 * (J_m + J_g) + J_L
    J_eq_m = (J_m + J_g) + J_L / (n**2)
    return J_eq_q, J_eq_m

def joint_dynamics(t, x, params):
    """
    State x = [q, qdot].
    Dynamics: J_eq * qdd + b_eq * qdot + k_load * q = n * eta * tau_m + tau_ext
    Here we use a simple linear spring load and constant motor torque.
    """
    q, qdot = x
    J_eq = params["J_eq"]
    b_eq = params["b_eq"]
    k_load = params["k_load"]
    n = params["n"]
    eta = params["eta"]
    tau_m = params["tau_m"]
    tau_ext = params["tau_ext"]

    # Equation: J_eq * qdd = n*eta*tau_m + tau_ext - b_eq*qdot - k_load*q
    qddot = (n * eta * tau_m + tau_ext - b_eq * qdot - k_load * q) / J_eq
    return np.array([qdot, qddot])

def simulate_forward_euler(f, x0, t_grid, params):
    x = np.zeros((len(t_grid), len(x0)))
    x[0] = x0
    for k in range(len(t_grid) - 1):
        dt = t_grid[k+1] - t_grid[k]
        xdot = f(t_grid[k], x[k], params)
        x[k+1] = x[k] + dt * xdot
    return x

if __name__ == "__main__":
    # Physical parameters
    J_m = 0.002     # kg*m^2
    J_L = 0.05      # kg*m^2
    J_g = 0.001     # gear inertia
    b_m = 0.001     # motor viscous friction
    b_q = 0.02      # joint viscous friction
    k_load = 5.0    # Nm/rad (e.g. elastic load)
    tau_ext = 0.0   # external torque
    tau_m = 1.0     # step motor torque (Nm)
    eta = 0.9       # efficiency

    # Compare two gear ratios
    t_grid = np.linspace(0.0, 1.0, 200)
    x0 = np.array([0.0, 0.0])

    for n in [10.0, 100.0]:
        J_eq_q, J_eq_m = reflected_inertia_single(J_m, J_L, n, J_g)
        b_eq = n**2 * b_m + b_q

        params = {
            "J_eq": J_eq_q,
            "b_eq": b_eq,
            "k_load": k_load,
            "n": n,
            "eta": eta,
            "tau_m": tau_m,
            "tau_ext": tau_ext,
        }

        x_traj = simulate_forward_euler(joint_dynamics, x0, t_grid, params)
        q_traj = x_traj[:, 0]
        print(f"Gear ratio n={n}: final joint angle = {q_traj[-1]:.3f} rad")
      

Higher gear ratios yield slower but more heavily damped responses due to the increased equivalent inertia and friction at the joint.

In C++, one commonly uses libraries such as RBDL or orocos_kdl for rigid body dynamics. The reflected inertia computation can be integrated as a preprocessing step that modifies the diagonal terms of the joint-space inertia matrix before evaluating Coriolis and gravity terms. Below is a standalone example for a single-DOF joint.

#include <iostream>

struct GearJointParameters {
    double Jm;   // motor inertia
    double Jg;   // gear inertia on motor side
    double JL;   // link inertia at joint
    double bm;   // motor viscous friction
    double bq;   // joint viscous friction
    double n;    // gear ratio theta_m = n * q
    double eta;  // efficiency
};

class GearJointDynamicModel {
public:
    GearJointDynamicModel(const GearJointParameters& p)
    : p_(p)
    {
        computeReflectedParameters();
    }

    // Compute qdd for given state and motor torque
    double acceleration(double q, double qdot, double tau_m, double tau_ext = 0.0) const {
        // J_eq * qdd + b_eq * qdot = n * eta * tau_m + tau_ext
        double rhs = p_.n * p_.eta * tau_m + tau_ext - b_eq_ * qdot;
        return rhs / J_eq_;
    }

    double J_eq() const { return J_eq_; }
    double b_eq() const { return b_eq_; }

private:
    GearJointParameters p_;
    double J_eq_;
    double b_eq_;

    void computeReflectedParameters() {
        J_eq_ = p_.n * p_.n * (p_.Jm + p_.Jg) + p_.JL;
        b_eq_ = p_.n * p_.n * p_.bm + p_.bq;
    }
};

int main() {
    GearJointParameters params;
    params.Jm = 0.002;
    params.Jg = 0.001;
    params.JL = 0.05;
    params.bm = 0.001;
    params.bq = 0.02;
    params.n  = 50.0;
    params.eta = 0.9;

    GearJointDynamicModel model(params);

    double q = 0.0;
    double qdot = 0.0;
    double dt = 0.001;

    for (int k = 0; k < 1000; ++k) {
        double tau_m = 1.0; // step motor torque
        double qdd = model.acceleration(q, qdot, tau_m);
        qdot += qdd * dt;
        q += qdot * dt;
    }

    std::cout << "Equivalent inertia (joint side): " << model.J_eq() << std::endl;
    std::cout << "Final joint angle: " << q << " rad" << std::endl;
    return 0;
}
      

In a full robotics codebase, GearJointDynamicModel would be constructed per joint, and its J_eq would be added to the corresponding diagonal entry of the manipulator inertia matrix.

Java-based robotics stacks often use linear algebra libraries such as EJML for matrix operations. Here we show a scalar implementation that could be embedded in a larger multi-DOF framework.

public class GearedJoint {
    private final double Jm, Jg, JL, bm, bq, n, eta;
    private final double J_eq, b_eq;

    public GearedJoint(double Jm, double Jg, double JL,
                       double bm, double bq, double n, double eta) {
        this.Jm = Jm;
        this.Jg = Jg;
        this.JL = JL;
        this.bm = bm;
        this.bq = bq;
        this.n  = n;
        this.eta = eta;

        this.J_eq = n * n * (Jm + Jg) + JL;
        this.b_eq = n * n * bm + bq;
    }

    public double jointAcceleration(double q, double qdot,
                                    double tau_m, double tau_ext) {
        double rhs = n * eta * tau_m + tau_ext - b_eq * qdot;
        return rhs / J_eq;
    }

    public double getEquivalentInertia() {
        return J_eq;
    }

    public static void main(String[] args) {
        GearedJoint joint = new GearedJoint(
            0.002, 0.001, 0.05,   // Jm, Jg, JL
            0.001, 0.02,          // bm, bq
            80.0, 0.9             // n, eta
        );

        double q = 0.0;
        double qdot = 0.0;
        double dt = 0.001;

        for (int k = 0; k < 5000; ++k) {
            double t = k * dt;
            double tau_m = (t > 0.05) ? 1.0 : 0.0; // delayed step
            double qdd = joint.jointAcceleration(q, qdot, tau_m, 0.0);
            qdot += qdd * dt;
            q += qdot * dt;
        }

        System.out.println("Equivalent inertia J_eq = " + joint.getEquivalentInertia());
        System.out.println("Final joint angle q = " + q + " rad");
    }
}
      

This pattern generalizes to vector-matrix operations using EJML, where J_eq becomes a diagonal matrix added to the manipulator inertia matrix.

MATLAB is widely used for manipulator dynamics. The reflected inertia can be implemented as a simple function and integrated with ode45 or realized as a Simulink subsystem with gain and sum blocks.

function lesson14_gear_dynamics_demo()
    % Parameters
    Jm = 0.002;
    Jg = 0.001;
    JL = 0.05;
    bm = 0.001;
    bq = 0.02;
    n  = 60;
    eta = 0.9;
    tau_m = 1.0;
    tau_ext = 0.0;
    k_load = 5.0;

    J_eq = n^2 * (Jm + Jg) + JL;
    b_eq = n^2 * bm + bq;

    params = struct('J_eq', J_eq, 'b_eq', b_eq, ...
                    'k_load', k_load, 'n', n, ...
                    'eta', eta, 'tau_m', tau_m, ...
                    'tau_ext', tau_ext);

    tspan = [0 1];
    x0 = [0; 0]; % [q; qdot]
    [t, x] = ode45(@(t, x) joint_ode(t, x, params), tspan, x0);

    q = x(:, 1);
    figure; plot(t, q); xlabel('t [s]'); ylabel('q [rad]');
    title('Geared joint response');

    fprintf('Equivalent inertia J_eq = %.4f\n', J_eq);
end

function xdot = joint_ode(t, x, p)
    q = x(1);
    qdot = x(2);

    rhs = p.n * p.eta * p.tau_m + p.tau_ext ...
          - p.b_eq * qdot - p.k_load * q;

    qddot = rhs / p.J_eq;
    xdot = [qdot; qddot];
end
      

In Simulink, the same dynamics can be realized with a gain block n*eta on the motor torque input, a gain block 1/J_eq on the dynamics, and a feedback loop implementing b_eq*qdot + k_load*q.

Mathematica is convenient for symbolic derivations. The following notebook fragment derives the equivalent inertia seen at the joint and verifies the energy equivalence between motor and joint coordinates.

(* Define symbols *)
Clear["Global`*"];
Jm  =.; Jg  =.; JL  =.; n  =.;
Jm  = Symbol["Jm"];
Jg  = Symbol["Jg"];
JL  = Symbol["JL"];
n   = Symbol["n", Positive -> True];

thetaM[t_] := Symbol["thetaM"][t];
q[t_]      := thetaM[t]/n;

omegaM = D[thetaM[t], t];
omegaQ = D[q[t], t];

(* Kinetic energy in terms of thetaMdot *)
Tm = 1/2*Jm*omegaM^2 + 1/2*Jg*omegaM^2;
TL = 1/2*JL*omegaQ^2;
Ttotal = Simplify[Tm + TL];

Print["Total kinetic energy T(thetaMdot) = ", Ttotal];

(* Express in terms of qdot *)
qdot = D[q[t], t];
T_q = Simplify[Ttotal /. omegaM -> n*qdot];

Print["Total kinetic energy T(qdot) = ", T_q];

(* Extract equivalent inertia coefficient *)
J_eq_q = Coefficient[T_q, qdot^2] * 2;
Print["Equivalent inertia at joint: J_eq_q = ", J_eq_q];
      

Mathematica confirms \( J_{\text{eq},q} = n^2 (J_m + J_g) + J_L \) and, by reparameterization, yields the motor-side equivalent inertia as in Section 2.

In this lesson we formalized the role of gears in robotic actuators and showed how gear ratios transform torques and inertias between motor and joint coordinates. Using energy-based derivations, we obtained the fundamental rule that inertias scale with the square of the gear ratio, leading to equivalent inertia matrices such as \( \mathbf{H}_{\text{tot}}(\mathbf{q}) = \mathbf{H}(\mathbf{q}) + \mathbf{N}^\top \mathbf{J}_m \mathbf{N} \). Non-idealities such as efficiency and friction yield equivalent joint-side parameters that are essential for realistic dynamic models. Implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how these models are encoded in software that will be used later for simulation and control design.