Electric motors (Lesson 1) produce high speed and modest torque. Robotic joints often demand the opposite: lower speed but higher torque and better load holding. A transmission changes the motor–load relationship by a mechanical advantage.

Consider a motor shaft angle \( \theta_m \) and a joint/load angle \( \theta_\ell \). A transmission defines a mapping \( \theta_\ell = f(\theta_m) \). For ideal gears and rigid links, the mapping is linear, enabling clean torque and power transforms.

flowchart TD
  M["Motor shaft (theta_m, omega_m, tau_m)"] --> T["Transmission ratio N"]
  T --> L["Load/joint (theta_l, omega_l, tau_l)"]
  L --> ENV["Environment / payload"]
        

For two meshing gears with tooth counts \( z_1 \) (motor side) and \( z_2 \) (load side), the pitch-line velocities must match:

\[ r_1 \, \omega_1 = r_2 \, \omega_2, \quad \text{with } r_i = \frac{m z_i}{2} \]

where \( m \) is the gear module. Thus

\[ \frac{\omega_1}{\omega_2} = \frac{r_2}{r_1} = \frac{z_2}{z_1}. \]

Define the gear ratio (reduction) \( N \) as motor speed divided by load speed:

\[ N \;\triangleq\; \frac{\omega_m}{\omega_\ell} = \frac{\theta_m}{\theta_\ell} = \frac{z_2}{z_1}. \]

So the angular mapping is \( \theta_\ell = \theta_m / N \) and \( \omega_\ell = \omega_m / N \).

Multi-stage gear trains. For stages \( N_1, N_2, \dots, N_k \) in series, pitch-line continuity yields:

\[ N_{\text{eq}} = \prod_{i=1}^{k} N_i. \]

Planetary sets (intro). A simple planetary with sun, ring, carrier speeds \( \omega_s,\omega_r,\omega_c \) satisfies Willis’ equation:

\[ \frac{\omega_s - \omega_c}{\omega_r - \omega_c} = -\frac{z_r}{z_s}. \]

Fixing one member (e.g., ring fixed \( \omega_r=0 \)) gives a high reduction while keeping coaxial input/output—common in robot joints.

In an ideal (lossless) rigid transmission, mechanical power is conserved:

\[ P_m = \tau_m \omega_m = \tau_\ell \omega_\ell = P_\ell. \]

Using \( \omega_\ell = \omega_m / N \):

\[ \tau_\ell = N \, \tau_m. \]

So speed decreases by \( N \) and torque increases by \( N \).

Real transmissions have efficiency \( 0 < \eta < 1 \) due to friction, lubrication shear, belt slip, etc. A standard steady-state model:

\[ \tau_\ell \omega_\ell = \eta \, \tau_m \omega_m. \]

Hence the delivered load torque (for motoring direction) is

\[ \tau_\ell = \eta N \tau_m. \]

Backdriving direction. When the load drives the motor, friction acts oppositely. A common approximation:

\[ \tau_m = \frac{\eta}{N}\tau_\ell \quad (\text{backdriving}). \]

Low efficiency therefore reduces backdrivability (useful for holding loads, harmful for force control).

Proof of torque scaling. Start from conservation of work for a small motion: \( \delta W = \tau_m \delta\theta_m = \tau_\ell \delta\theta_\ell \). With \( \delta\theta_\ell = \delta\theta_m / N \),

\[ \tau_m \delta\theta_m = \tau_\ell \frac{\delta\theta_m}{N} \;\Rightarrow\; \tau_\ell = N\tau_m. \]

This argument generalizes to any rigid transmission with constant ratio.

Transmissions not only scale torque/speed, they transform inertia and stiffness. Let the motor-side rotational inertia be \( J_m \) (including rotor and motor-side gears) and the load-side inertia be \( J_\ell \). Kinetic energy is:

\[ T = \tfrac{1}{2}J_m\omega_m^2 + \tfrac{1}{2}J_\ell\omega_\ell^2. \]

Substitute \( \omega_m = N\omega_\ell \):

\[ T = \tfrac{1}{2}(J_\ell + N^2 J_m)\omega_\ell^2. \]

Therefore the motor inertia reflected to the load is \( J_{m\to\ell} = N^2 J_m \). Likewise, the load inertia reflected to the motor is \( J_{\ell\to m} = J_\ell / N^2 \).

Consequence. High reductions make the motor “see” a much smaller load inertia, easing control and allowing smaller motors, but the joint “feels” a large virtual inertia from the motor—reducing responsiveness to external forces.

Stiffness reflection. Suppose the motor shaft connects to a torsional spring of stiffness \( k_m \) (e.g., shaft elasticity). Potential energy: \( V = \tfrac{1}{2}k_m\theta_m^2 \). Using \( \theta_m = N\theta_\ell \):

\[ V = \tfrac{1}{2}(N^2 k_m)\theta_\ell^2 \;\Rightarrow\; k_{m\to\ell} = N^2 k_m. \]

So reductions increase effective stiffness quadratically.

We focus on properties that matter for actuation: ratio range, efficiency, backlash, and compliance.

Spur/Helical gears. Nearly constant ratio; efficiency typically \( \eta \approx 0.95\text{–}0.99 \) per stage. Backlash depends on tooth clearance and manufacturing tolerance.

Planetary gears. Coaxial, compact, high ratio by stacking stages. The equivalent ratio is the product of stage ratios as in Section 2. Inertia reflection is still \( N^2 \).

Harmonic drives (strain-wave gearing). Very high reduction in one stage, near-zero backlash when preloaded. Nonlinear elastic elements can slightly reduce efficiency (\( \eta \approx 0.7\text{–}0.9 \)), and torsional compliance appears at the joint.

Belt and chain drives. Ratio set by pulley/sprocket radii: \( N = r_2/r_1 \). Belts add compliance and can filter high-frequency torque ripple.

Lead screw / ball screw (rotational-to-linear). With screw lead \( p \) (m/rev), rotation \( \theta_m \) yields translation \( x = \frac{p}{2\pi}\theta_m \). The equivalent linear force:

\[ F = \frac{2\pi\eta}{p}\tau_m. \]

Such drives appear in prismatic joints and grippers.

Backlash is lost motion due to clearance between transmission elements. It creates a dead-zone in position and a discontinuity in torque transfer. Let the backlash width (at the output) be \( b \) radians. Define relative angle \( \Delta\theta = \theta_m/N - \theta_\ell \).

A simple static model for torque transfer uses a piecewise spring:

\[ \tau_\ell = \begin{cases} k_t(\Delta\theta - \tfrac{b}{2}) & \text{if } \Delta\theta > \tfrac{b}{2} \\ 0 & \text{if } |\Delta\theta| \le \tfrac{b}{2} \\ k_t(\Delta\theta + \tfrac{b}{2}) & \text{if } \Delta\theta < -\tfrac{b}{2} \end{cases} \]

where \( k_t \) is the torsional stiffness when teeth are engaged. The central interval is the deadband.

Hysteresis (play) model. Real backlash depends on direction. One common dynamical representation:

\[ \tau_\ell = k_t\big(\Delta\theta - \sigma(t)\tfrac{b}{2}\big),\quad \sigma(t)\in\{-1,+1\}, \]

where \( \sigma(t) \) switches only when contact changes side (a memory effect). This is a rate-independent hysteresis.

flowchart TD
  X["Delta_theta = theta_m/N - theta_l"] --> BZ{"|Delta_theta| <= b/2 ?"}
  BZ -->|yes| Z["tau_l = 0"]
  BZ -->|no, positive| P["tau_l = k_t*(Delta_theta - b/2)"]
  BZ -->|no, negative| N["tau_l = k_t*(Delta_theta + b/2)"]
        

Control relevance. Backlash introduces nonlinearity and can cause limit cycles under high-gain position control. Since you know linear control, note that the deadband behaves like a nonlinearity that violates assumptions of linear superposition.

Suppose a joint needs peak torque \( \tau_{\ell,\max} \) and max speed \( \omega_{\ell,\max} \). With motor limits \( \tau_{m,\max}, \omega_{m,\max} \) and efficiency \( \eta \), we require:

\[ \eta N \tau_{m,\max} \ge \tau_{\ell,\max}, \qquad \frac{\omega_{m,\max}}{N} \ge \omega_{\ell,\max}. \]

Thus a feasible interval for \( N \) is

\[ \frac{\tau_{\ell,\max}}{\eta \tau_{m,\max}} \le N \le \frac{\omega_{m,\max}}{\omega_{\ell,\max}}. \]

Including inertia. If you desire a joint acceleration \( \alpha_{\ell,\max} \), the net required torque is \( \tau_\ell = J_{\text{eq}}\alpha_\ell + \tau_{\text{load}} \), with \( J_{\text{eq}} = J_\ell + N^2 J_m \). So increasing \( N \) improves motor-side acceleration capability but raises joint-side inertia.

These snippets compute equivalent ratios and simulate a backlash deadband. They are minimal and intended to reinforce the formulas above.

8.1 Python (NumPy)

import numpy as np

def eq_ratio(stages):
    """stages: list of (z_motor, z_load) for each gear mesh"""
    N = 1.0
    for z1, z2 in stages:
        N *= (z2 / z1)
    return N

def reflected_inertia(Jm, Jl, N):
    """Return (Req at load side, Req at motor side)."""
    J_at_load = Jl + (N**2) * Jm
    J_at_motor = Jm + Jl / (N**2)
    return J_at_load, J_at_motor

def backlash_torque(theta_m, theta_l, N, b, kt):
    """Piecewise spring backlash model at output."""
    dtheta = theta_m / N - theta_l
    if abs(dtheta) <= b/2:
        return 0.0
    elif dtheta > b/2:
        return kt * (dtheta - b/2)
    else:
        return kt * (dtheta + b/2)

# Example usage
stages = [(20, 80), (18, 54)]  # two stages
N = eq_ratio(stages)
print("N_eq =", N)

Jm, Jl = 2e-4, 5e-3
print("Reflected inertia:", reflected_inertia(Jm, Jl, N))

# static torque for a few relative angles
for d in np.linspace(-0.05, 0.05, 5):
    tm = N*(0.0 + d)  # pick theta_m so that theta_m/N - theta_l = d
    tl = 0.0
    print(d, backlash_torque(tm, tl, N, b=0.02, kt=150.0))
      

8.2 C++ (header-only style)

#include <iostream>
#include <vector>
#include <cmath>

double eq_ratio(const std::vector<std::pair<double,double>>& stages){
    double N = 1.0;
    for(const auto& s : stages){
        double z1 = s.first, z2 = s.second;
        N *= (z2 / z1);
    }
    return N;
}

double backlash_torque(double theta_m, double theta_l, double N,
                       double b, double kt){
    double dtheta = theta_m / N - theta_l;
    if(std::abs(dtheta) <= b/2.0) return 0.0;
    if(dtheta > b/2.0) return kt * (dtheta - b/2.0);
    return kt * (dtheta + b/2.0);
}

int main(){
    std::vector<std::pair<double,double>> stages{
      {20,80},
      {18,54}
    };
    double N = eq_ratio(stages);
    std::cout << "N_eq=" << N << std::endl;

    double tau = backlash_torque(N*0.03, 0.0, N, 0.02, 150.0);
    std::cout << "tau_l=" << tau << std::endl;
    return 0;
}
      

8.3 Java

import java.util.*;

public class TransmissionMath {
    static double eqRatio(List<double[]> stages){
        double N = 1.0;
        for(double[] s : stages){
            double z1 = s[0], z2 = s[1];
            N *= (z2 / z1);
        }
        return N;
    }

    static double backlashTorque(double thetaM, double thetaL, double N,
                                 double b, double kt){
        double dtheta = thetaM / N - thetaL;
        if(Math.abs(dtheta) <= b/2.0) return 0.0;
        if(dtheta > b/2.0) return kt * (dtheta - b/2.0);
        return kt * (dtheta + b/2.0);
    }

    public static void main(String[] args){
        List<double[]> stages = Arrays.asList(new double[]{20,80}, new double[]{18,54});
        double N = eqRatio(stages);
        System.out.println("N_eq=" + N);

        double tauL = backlashTorque(N*0.03, 0.0, N, 0.02, 150.0);
        System.out.println("tau_l=" + tauL);
    }
}
      

8.4 MATLAB / Simulink-style script

function demo_transmission()
    % Two-stage geartrain
    stages = [20 80; 18 54]; % each row: [z1 z2]
    N = prod(stages(:,2) ./ stages(:,1));

    fprintf('N_eq = %.3f\n', N);

    % Reflected inertia
    Jm = 2e-4; Jl = 5e-3;
    J_at_load  = Jl + (N^2)*Jm;
    J_at_motor = Jm + Jl/(N^2);

    fprintf('J_at_load = %.6f, J_at_motor = %.6f\n', J_at_load, J_at_motor);

    % Backlash torque curve
    b = 0.02; kt = 150;
    dtheta = linspace(-0.05, 0.05, 200);
    tauL = arrayfun(@(d) backlash_torque(N*d, 0, N, b, kt), dtheta);

    figure; plot(dtheta, tauL); grid on;
    xlabel('\Delta\theta'); ylabel('\tau_\ell');
    title('Backlash deadband torque model');
end

function tau = backlash_torque(theta_m, theta_l, N, b, kt)
    dtheta = theta_m/N - theta_l;
    if abs(dtheta) <= b/2
        tau = 0;
    elseif dtheta > b/2
        tau = kt*(dtheta - b/2);
    else
        tau = kt*(dtheta + b/2);
    end
end
      

In Simulink, the backlash model corresponds to a “dead zone + spring” nonlinearity just before the load inertia block.

Problem 1 (Two-gear ratio and torque): A motor gear with \( z_1=18 \) teeth drives a load gear with \( z_2=72 \). The motor provides \( \tau_m=0.8\,\text{N·m} \) at \( \omega_m=300\,\text{rad/s} \). Assume ideal gears. Find \( N \), \( \tau_\ell \), and \( \omega_\ell \).

Solution:

\[ N = \frac{z_2}{z_1} = \frac{72}{18} = 4. \]

\[ \tau_\ell = N\tau_m = 4 \times 0.8 = 3.2\,\text{N·m}, \qquad \omega_\ell = \frac{\omega_m}{N} = \frac{300}{4}=75\,\text{rad/s}. \]

Problem 2 (Reflected inertia calculation): A motor with inertia \( J_m=3\times 10^{-4}\,\text{kg·m}^2 \) drives a joint load inertia \( J_\ell=6\times 10^{-3}\,\text{kg·m}^2 \) through a reduction \( N=12 \). Compute (a) motor inertia reflected to the load, (b) load inertia reflected to the motor.

Solution:

\[ J_{m\to\ell} = N^2 J_m = 12^2 \cdot 3\times 10^{-4} = 144 \cdot 3\times 10^{-4} = 4.32\times 10^{-2}\,\text{kg·m}^2. \]

\[ J_{\ell\to m} = \frac{J_\ell}{N^2} = \frac{6\times 10^{-3}}{144} \approx 4.17\times 10^{-5}\,\text{kg·m}^2. \]

Problem 3 (Feasible ratio interval): A joint needs \( \tau_{\ell,\max}=40\,\text{N·m} \) and \( \omega_{\ell,\max}=8\,\text{rad/s} \). A candidate motor has \( \tau_{m,\max}=2.5\,\text{N·m} \) and \( \omega_{m,\max}=160\,\text{rad/s} \). Transmission efficiency is \( \eta=0.85 \). Find the allowable range of \( N \).

Solution:

\[ N \ge \frac{\tau_{\ell,\max}}{\eta\tau_{m,\max}} = \frac{40}{0.85\times 2.5} = \frac{40}{2.125} \approx 18.82. \]

\[ N \le \frac{\omega_{m,\max}}{\omega_{\ell,\max}} = \frac{160}{8} = 20. \]

So \( 18.82 \le N \le 20 \). A reduction near 19–20 is required.

Problem 4 (Backlash deadband torque): A reduction \( N=6 \) has backlash width \( b=0.03\,\text{rad} \) at the output and engaged stiffness \( k_t=200\,\text{N·m/rad} \). For relative angles \( \Delta\theta = -0.025, 0.0, +0.05 \), compute the transmitted torque.

Solution: Here \( b/2=0.015 \).

• For \( \Delta\theta=-0.025 < -0.015 \):

  \[ \tau_\ell = k_t(\Delta\theta + b/2) = 200(-0.025 + 0.015)=200(-0.01)=-2\,\text{N·m}. \]

• For \( \Delta\theta=0 \): \( |\Delta\theta| \le 0.015 \Rightarrow \tau_\ell=0 \).
• For \( \Delta\theta=0.05 > 0.015 \):

  \[ \tau_\ell = 200(0.05 - 0.015)=200(0.035)=7\,\text{N·m}. \]

We derived constant-ratio transmission kinematics, showing that reductions scale speed by \( 1/N \) and torque by \( N \), with efficiency modifying the delivered torque. We proved that inertia and stiffness reflect through the square of the ratio, a key trade-off in robot drive design. Finally, we modeled backlash as a deadband/hysteresis nonlinearity, previewing its impact on control.