Stage 05 · Lesson 05/15

Robotics Fundamentals · Lesson 05

Actuators & Transmissions

Est. 55–70 min

Why

Why a strong-looking motor can still drop your arm

Lesson 3 gave the body its joints; this lesson gives them muscles. An actuator turns energy (usually electrical) into motion. A transmission — gears, belts, screws, cables — reshapes that motion: slower but stronger, rotary into linear, or moved to a better place on the robot. Modern Robotics puts the problem simply: most motors spin fast with low torque, but robot joints need slow motion with high torque, so speed reduction and torque amplification are required.

By the end you will be able to: compare brushed DC motors, brushless motors, steppers and RC servos; compute the holding torque a joint needs with τ = r × F; explain what a gear ratio does to torque and speed, including efficiency; describe harmonic drives, planetary and worm gears, belts and lead screws, and when each is used; read a smart-servo datasheet (the ROBOTIS XL430-W250) honestly — knowing that stall torque is not continuous torque; and test a servo’s holding ability safely on the bench.

The three parts of a strain-wave gear laid out on a table: a thin flexible cup, a solid ring with internal teeth and an oval bearing assembly
A Harmonic Drive strain-wave gear set: the elliptical Wave Generator, the thin flexible Flexspline cup and the rigid Circular Spline ring. Harmonic Drive explains that the Flexspline has two fewer teeth than the Circular Spline, so every half-turn of the Wave Generator moves it by just one tooth — a very large reduction in a compact package, with zero backlash. Many industrial and collaborative arms use them in their joints.Photo: Pieceofmetalwork · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Concept

Actuators and transmissions in plain words: muscles and the tendons that multiply them

Think of a bicycle. Your legs are the motor: strong but they can only push so fast. On a steep hill you shift to a low gear — your legs spin quickly, the wheel turns slowly, and you climb with less effort. On a flat road you shift up — more speed, less push. Gears never create energy; they trade speed for torque. A robot joint is the hill: it needs slow, strong turning, so it almost always rides in a very low gear.

The actuator family

Common electric actuators in small and large robots (Adafruit Motor Selection Guide; Modern Robotics 8.9)
ActuatorHow it movesStrengthsWatch out forTypical robot use
Brushed DC motorSpins when current flows; speed ∝ voltageCheap, simple, easy to drive with an H-bridgeFast and weak without a gearbox; brushes wearWheels, small gearmotors
Brushless DC (BLDC)Electronic commutation instead of brushesQuiet, efficient, long lifeNeeds a dedicated controllerDrones, high-end arm joints
Stepper motorMoves in discrete stepsPrecise, repeatable positioning and holding torqueCan lose steps if overloaded; draws current while holding3D printers, CNC, gantries
RC servoDC motor + gear train + driver + potentiometer feedbackPosition control from one signal wireAbout 180° range on most; twitch and noise when holdingHobby arm joints, grippers
Smart servo (e.g. DYNAMIXEL)Motor + gears + encoder + controller, on a data busReports position, load, temperature; set limits in registersCosts more; needs a bus adapterTurtleBot3 wheels, research arms

Torque: why distance matters

OpenStax University Physics explains torque with a door: push near the hinge and it barely moves; push at the handle and it swings easily. Torque depends on the force, the lever arm (distance from the axis) and the angle between them. For a robot joint holding a link out horizontally, gravity pulls straight down at right angles to the arm — the worst case.

τ = r F sin θ → worst case (arm horizontal): τ = m g d

  • τ = torque (N·m); m = mass (kg); g = 9.81 m/s²; d = distance from the joint axis to that mass’s centre (m). Add up every mass beyond the joint: links, servos, gripper, payload. 1 kg·cm ≈ 0.098 N·m.

Gear ratio: the speed–torque trade

τ_out = η G τ_motor, ω_out = ω_motor ÷ G

  • G = gear ratio (e.g. 100 for 100:1); η ≤ 1 = efficiency (friction losses). Modern Robotics: with G = 2 the maximum torque doubles and the maximum speed halves. Many DC motors have no-load speeds of 10 000 rpm or more, so robot joints often use ratios of 100 or more.

Two more effects from Modern Robotics are worth knowing early. Friction rises with more gear stages, so η falls. And the motor’s rotor inertia appears G² times larger at the joint (the “apparent” or “reflected” inertia) — a big gear ratio makes the joint feel heavy and hard to back-drive. That is one reason the cheapest gearbox is not always the best.

The transmission menu

Transmissions you will meet
TransmissionWhat it doesProsCons
Spur / planetary gearboxReduces speed, multiplies torqueCompact, efficient, common in gearmotorsBacklash (play) between teeth
Harmonic (strain-wave) driveVery high reduction in one stageZero backlash, compact, accurateCostly; flexspline has a fatigue life
Worm gearHigh reduction at 90°Often hard to back-drive — holds the load when unpoweredLow efficiency; heat
Timing belt + pulleysMoves torque to another place; ratio = teeth ratioLight, quiet, lets you put the motor at the baseStretch; needs tensioning
Lead / ball screwTurns rotation into straight-line motionLarge force, precise linear movesSpeed limited by lead; ball screws cost more
Cable / tendonPulls a joint from a distanceVery light joints (robot hands)Stretch, friction, routing

Modern Robotics defines backlash as the amount of rotation available at the output without motion at the input — the “play” you feel when you wiggle a cheap servo horn. In a long arm, a little backlash at the shoulder becomes a big wobble at the tip (Lesson 9).

A cut-open reduction gearbox on display, showing the gears and bearings inside an aluminium housing
A cutaway reduction gear (Ricardo, shown at an engineering expo). Cutaways like this show how a few meshing gears inside a housing turn a fast, light-duty input into a slow, strong output — exactly what sits between the tiny motor and the horn of your servo.Photo: Matti Blume · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Visual

Visualise it: trade speed for torque

Pick a motor and a transmission and watch what happens to the **output speed and torque**. Notice the trade: whatever you gain in torque, you lose in speed — and every stage loses a little to friction.

Interactive · Actuator & transmission lab

Generic educational drawings of hobby servo, DC gearbox motor, and stepper

Integrated motor + gearbox + position loop. Great for early arms; torque limited.

Output speed

~0.7 rpm

Torque gain (ideal)

×150

Teaching model only — real gearboxes have losses, backlash, and current limits. Stage 4 drivers still apply: never GPIO-direct a motor.

Code lab

Code lab: holding torque, gear ratios and a real servo

The script does four things: (1) adds up the shoulder holding torque for an example arm; (2) shows how one fast, weak example motor changes through gear ratios 1, 10, 100 and 258.5 (with assumed efficiencies); (3) compares our need with the ROBOTIS XL430-W250’s published stall torque and speed; (4) works out a belt ratio and a lead screw. Run it with python3 gear_torque.py.

gear_torque.py · Python
"""gear_torque.py - how much torque does a joint need, and what does a gearbox do?
Physics: torque = force x lever arm (OpenStax University Physics 10.6).
Gearing: an ideal gearhead with ratio G multiplies torque by G and divides speed by G
(Modern Robotics 8.9); a real one also loses some to friction (efficiency eta)."""
import math

G_EARTH = 9.81

def holding_torque(mass_kg, dist_m):
    """Worst case: arm held horizontal, so the full weight acts at right angles."""
    return mass_kg * G_EARTH * dist_m

# --- 1. Torque needed at a shoulder (example arm, replace with your numbers) ---
upper_arm = (0.080, 0.06)   # mass kg, distance of its centre from the shoulder (m)
forearm = (0.060, 0.17)
elbow_servo = (0.055, 0.12)
payload = (0.050, 0.22)
parts = {"upper arm": upper_arm, "forearm": forearm, "elbow servo": elbow_servo, "payload": payload}
total = 0.0
print("== 1. Shoulder holding torque (arm horizontal) ==")
for name, (m, d) in parts.items():
    t = holding_torque(m, d)
    total += t
    print(f"{name:12s} {m*1000:5.0f} g at {d*100:4.1f} cm -> {t:.3f} N.m")
print(f"total {total:.3f} N.m = {total/0.0981:.1f} kg.cm ; with 2x safety factor {2*total:.3f} N.m")

# --- 2. What a gearbox does to a fast, weak motor (example motor) ---
motor_speed_rpm, motor_stall_nm = 10000, 0.010
print("\n== 2. Same motor, different gear ratios (eta = efficiency) ==")
print(" G      eta   output stall torque   output no-load speed")
# eta values are assumed examples for illustration, not datasheet numbers
for g, eta in [(1, 1.00), (10, 0.90), (100, 0.75), (258.5, 0.70)]:
    print(f"{g:6.1f}  {eta:.2f}   {motor_stall_nm*g*eta:8.3f} N.m          {motor_speed_rpm/g:8.1f} rpm")

# --- 3. A real smart servo: ROBOTIS XL430-W250 e-manual numbers ---
print("\n== 3. XL430-W250 (from its e-manual) ==")
stall, rpm = 1.4, 57   # N.m and rev/min at 11.1 V; gear ratio 258.5:1
print(f"stall torque {stall} N.m at 11.1 V, no-load {rpm} rpm -> {rpm*6:.0f} deg/s unloaded")
print(f"holding our shoulder needs {total:.3f} N.m = {100*total/stall:.0f}% of its stall torque")

# --- 4. Belts and lead screws ---
print("\n== 4. Other transmissions ==")
t20, t60 = 20, 60
print(f"belt 20T -> 60T pulley: ratio {t60/t20:.1f}:1 (3x torque, 1/3 speed)")
lead_mm, screw_rpm, screw_torque, eta = 8.0, 300, 0.2, 0.9   # eta assumed for illustration
# energy balance: one turn puts in 2*pi*T of work and pushes the nut one lead: F * lead = 2*pi*eta*T
speed = lead_mm * screw_rpm / 60
force = 2 * math.pi * eta * screw_torque / (lead_mm / 1000)
print(f"lead screw, 8 mm lead at 300 rpm -> {speed:.0f} mm/s; 0.2 N.m in -> about {force:.0f} N push")

Output (run with python3 gear_torque.py)

== 1. Shoulder holding torque (arm horizontal) ==
upper arm       80 g at  6.0 cm -> 0.047 N.m
forearm         60 g at 17.0 cm -> 0.100 N.m
elbow servo     55 g at 12.0 cm -> 0.065 N.m
payload         50 g at 22.0 cm -> 0.108 N.m
total 0.320 N.m = 3.3 kg.cm ; with 2x safety factor 0.640 N.m

== 2. Same motor, different gear ratios (eta = efficiency) ==
 G      eta   output stall torque   output no-load speed
   1.0  1.00      0.010 N.m           10000.0 rpm
  10.0  0.90      0.090 N.m            1000.0 rpm
 100.0  0.75      0.750 N.m             100.0 rpm
 258.5  0.70      1.809 N.m              38.7 rpm

== 3. XL430-W250 (from its e-manual) ==
stall torque 1.4 N.m at 11.1 V, no-load 57 rpm -> 342 deg/s unloaded
holding our shoulder needs 0.320 N.m = 23% of its stall torque

== 4. Other transmissions ==
belt 20T -> 60T pulley: ratio 3.0:1 (3x torque, 1/3 speed)
lead screw, 8 mm lead at 300 rpm -> 40 mm/s; 0.2 N.m in -> about 141 N push

Try it: change the arm length and payload and watch the required servo torque. Find the point where a small servo is no longer enough.

Interactive · Servo torque calculator

servo100 gL = 10 cmgravity
Tight: will heat up, may jitter

Torque needed

1.20 kg·cm

Same in SI

0.118 N·m

Servo rating

2.0 kg·cm

Load vs rating

60 %

Worst case is when the arm is horizontal (gravity pulls at 90°). Rule of thumb used by many hobbyists: keep the steady load at or below about half the rated (stall) torque. Rated torque comes from your servo's datasheet.

Real world

Transmissions inside real robots

  • Industrial and collaborative arms: Modern Robotics describes arms with motors combined with 100:1 zero-backlash harmonic drive gearing in the joints.
  • 3D printers and CNC machines: steppers with belts (fast axes) and lead screws (vertical axes).
  • Hobby arms: RC servos — a DC motor, a gear train, a driver and a potentiometer in one box.
  • Mobile robots: gearmotors or smart servos on the wheels; the TurtleBot3 Burger uses two XL430-W250s.
  • Robot hands: tendons (cables) let small, light fingers be driven by motors in the forearm.
A black toothed rubber timing belt wrapped around metal pulleys inside a machine
A toothed timing belt on its pulleys. The teeth stop it from slipping, and the ratio is simply the ratio of pulley teeth. Robot arms use belts to drive a joint from a motor mounted further back, keeping the arm’s moving mass low.Photo: Logansenf · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP
A ball-screw nut on a threaded shaft with its recirculation tubes removed, showing the channels and a few loose steel balls
A ball-screw nut with its recirculation tubes taken off. Steel balls roll between the screw and the nut instead of sliding, so friction is low and the nut moves precisely along the screw — the standard way to turn rotation into straight-line motion in CNC machines and gantry robots.Photo: Graibeard · CC BY-SA 3.0 · Source: Wikimedia Commons · resized, converted to WebP
Old rusty gears including a worm screw meshing with a large toothed wheel
A worm drive on old machinery. The screw-shaped worm turns the big wheel slowly, at 90°. Many worm drives are hard to turn backwards from the wheel side, so they hold a load without power — handy for lifts and some robot joints, at the cost of efficiency.Photo: Bernard Spragg. NZ from Christchurch, New Zealand · CC0 1.0 · Source: Wikimedia Commons · resized, converted to WebP

Bench build

Bench build: a safe servo holding test

Measure, don’t guess. You will hang a known small mass at increasing distances from a servo’s axis and watch for sag, buzzing and current — comparing reality with τ = m g d.

  1. Mount

    Clamp the servo firmly to the table edge with its shaft horizontal. Screw a straight servo arm (or a stiff ruler) to the horn.

  2. Power safely

    Servo red and brown/black to a 5–6 V supply; supply GND to Arduino GND; signal to pin 9. Put a multimeter in series with the supply (current range) if you have one.

  3. Hold horizontal

    Upload slow_servo_steps.ino (from Lesson 2) and type the angle that makes the arm horizontal.

  4. Add load

    Hang a small known mass (for example a 20 g bag of coins — weigh it) at 2 cm, then 4 cm, then 6 cm from the axis. Each time, note sag (degrees), sound and current.

  5. Compute

    For each position compute τ = m × 9.81 × d. Compare with your servo’s datasheet torque. At what torque did it start to sag or buzz?

  6. Stop early

    As soon as the servo buzzes continuously or gets warm, remove the load. You have found its practical limit — no need to cook it.

slow_servo_steps.ino (from Lesson 2) · Arduino C++
// slow_servo_steps.ino - move one joint in gentle 1-degree steps between soft limits.
// Servo signal on pin 9. Servo power comes from a SEPARATE 5-6 V supply, grounds joined.
#include <Servo.h>

Servo joint;
const int PIN = 9;
const int SOFT_MIN = 20;      // stay away from the hard end stops
const int SOFT_MAX = 160;
const int STEP_DELAY_MS = 15; // about 66 degrees per second

int angle = 90;

void moveTo(int target) {
  target = constrain(target, SOFT_MIN, SOFT_MAX);
  while (angle != target) {
    angle += (target > angle) ? 1 : -1;
    joint.write(angle);
    delay(STEP_DELAY_MS);
  }
  Serial.print("at ");
  Serial.println(angle);
}

void setup() {
  Serial.begin(9600);
  joint.write(angle);   // set the start position before attach() so it does not jump
  joint.attach(PIN);
  Serial.println("type an angle (20-160) and press Enter");
}

void loop() {
  if (Serial.available()) {
    int target = Serial.parseInt();
    if (target > 0) moveTo(target);
  }
}

Debugging

Debugging actuators and transmissions

SymptomLikely causeFix
Arm sags under load, servo buzzesTorque needed is near or above what the servo can giveShorten links, move mass closer to the joint, use a stronger servo or add a counterweight/spring
Servo gets hot while just holdingHolding near its limit for a long timeReduce load; rest the arm when idle; check the continuous rating, not stall
Tip wobbles when the arm stopsBacklash in gears, or a loose horn screwTighten the horn; preload with gravity; choose lower-backlash gearing
Belt-driven joint slips or jumpsBelt too loose or teeth skippingTension the belt; check pulley alignment
Lead-screw axis stalls at speedLead or speed too high for the motor torqueLower speed; use a smaller lead for more force
Board resets when the joint startsSupply sags under start-up current (Lesson 2)Bigger supply, capacitor on the rail, separate logic supply

Think

Think about it

Think

Meera has two choices for her arm’s shoulder: a servo rated 1.0 N·m stall at 6 V, or a smaller one rated 0.25 N·m. Her calculation says the shoulder needs 0.32 N·m holding torque. Arjun says, “0.32 is more than 0.25, but the big one is overkill — just use the small one and shorten the arm a little.” What would you advise, and why?

Experiment

Try it in the lab: size a shoulder joint

Thirty minutes with the transmission lab, the torque script and — optionally — the servo holding test.

Experiment

Size a shoulder joint

You will need

  • Actuator & transmission lab (below, runs in your browser)
  • Kitchen scale and ruler
  • Notebook
  • Optional: `gear_torque.py`; servo, 5–6 V supply, Arduino, multimeter

Steps

  1. In the transmission lab, pick one motor and try three gear ratios. Write the output torque and speed for each.
  2. Weigh the parts of your arm (or use the script’s example). Measure each part’s distance from the shoulder axis.
  3. Edit part 1 of `gear_torque.py` with your numbers and run it. Write your holding torque and the 2× value.
  4. Find a servo datasheet (or use the XL430-W250 numbers). Is it enough? What percentage of stall torque would you use?
  5. Optional bench: run the holding test and compare the load where your servo started to sag with the calculation.

Interactive · Actuator & transmission lab

Generic educational drawings of hobby servo, DC gearbox motor, and stepper

Integrated motor + gearbox + position loop. Great for early arms; torque limited.

Output speed

~0.7 rpm

Torque gain (ideal)

×150

Teaching model only — real gearboxes have losses, backlash, and current limits. Stage 4 drivers still apply: never GPIO-direct a motor.

Torque is force times distance, so length is the enemy of a shoulder. Gears trade speed for torque, but cost efficiency, backlash and reflected inertia. Stall torque is a limit, not a working point.

Knowledge check

Check your understanding

Knowledge check

1. An ideal gearbox with ratio G = 2 does what to a motor’s maximum torque and speed?

2. A 50 g payload held horizontally 22 cm from the shoulder needs about how much torque?

3. Why do robot joints often use gear ratios of 100 or more?

4. Which transmission has zero backlash and very high reduction in a compact package?

5. Backlash is…

6. Inside a typical RC servo you find…

7. Why should you not size a joint right at the motor’s stall torque?

8. A 20-tooth pulley drives a 60-tooth pulley. The output…

9. Which actuator moves in discrete steps with repeatable positioning?

10. The motor’s rotor inertia, seen at the joint through a gear ratio G, appears…

Mini assignment

Hands-on assignment

Mini assignment

Size every joint of a 3-joint desk arm

Design the actuators for a shoulder–elbow–wrist desk arm: compute holding torques, choose transmissions and servos, and test one joint on the bench if you can.

Deliverables

  • A table with each joint: masses beyond it, distances, holding torque, 2× value, chosen actuator and its datasheet torque (with voltage).
  • Your edited `gear_torque.py` output for your own arm.
  • A one-paragraph choice of transmission for each joint (direct servo, belt, gearbox…) with one reason each.
  • If you have hardware: your holding-test table (mass, distance, computed torque, sag, current) and a one-line conclusion.

Do this, step by step

  1. Sketch a shoulder–elbow–wrist desk arm and write the mass of each link, servo and the payload, and their distances from each joint.
  2. Compute holding torque at each joint (τ = m × g × d, summed for everything beyond the joint), then double it for a safety margin.
  3. Put your numbers into gear_torque.py, run it and check the script agrees with your hand result.
  4. Pick an actuator and transmission for each joint and note the datasheet torque and the voltage it is rated at.
  5. If you have hardware: do the holding test on one joint (servo on its own supply, common ground) and record mass, distance, torque, sag and current.

Stuck? Hints, one at a time

NoteTry the task first. Read one hint, try again, and only then read the next one.
  1. Hint 1: Start at the wrist. It only carries the gripper and payload. Then the elbow carries the wrist too, and the shoulder carries everything.
  2. Hint 2: Each part’s distance is measured from the joint you are sizing, not from the base.
  3. Hint 3: A servo’s own mass counts as a load for every joint behind it.
  4. Hint 4: If the shoulder needs too much, try moving the elbow servo to the base and driving the elbow with a belt or a linkage.

Challenges (pick by level)

  • 🟢 Easy: Convert 3.3 kg·cm to N·m. *Hint:* × 0.0981.
  • 🟢 Easy: From the XL430-W250 e-manual numbers, convert 57 rpm into degrees per second.
  • 🟡 Medium: How far from the shoulder can a 100 g payload be if the servo may use only 0.5 N·m in total and the arm itself already needs 0.2 N·m?
  • 🟡 Medium: A lead screw has a 2 mm lead. At 300 rpm how fast does the nut move? With 0.2 N·m and 90% efficiency, what force does it push?
  • 🟠 Hard-ish: Add a counterweight behind the shoulder in the script. Find the mass and distance that cut the holding torque in half.
  • 🔴 Hard: Explain, with numbers, why a 258.5:1 servo is hard to back-drive by hand. *Hint:* reflected inertia G² and gear friction.
  • ⚫ Expert: Read Modern Robotics Section 8.9 and write a one-page note on how the motor’s speed–torque curve changes with gear ratio, using your own arm as the example.

Next step

Your joints can move and hold. In Lesson 6 — Sensors & Proprioception you give the robot a sense of its own body: potentiometers, encoders, IMUs — and the difference between knowing yourself and knowing the world.

Look back: Lesson 4: Configuration Space Intuition. Next: Lesson 6: Sensors & Proprioception. Related: Stage 4 — Electronics and Stage 7 — Control Systems & PID.

Sources

  • Modern Robotics — K. M. Lynch & F. C. Park (preprint PDF) — Ch. 2 intro: motors are fast and weak, so transmissions (gears, cables, belts, chains) reduce speed and amplify torque; definition of backlash; Sec. 8.9: τ_gear = ηGτ_motor, G = 2 doubles torque and halves speed, DC motors of 10 000 rpm or more, joint ratios of 100 or more, apparent inertia G²·I_rotor; harmonic drive gearing in arm joints.
  • OpenStax University Physics Volume 1, 10.6 Torque — torque depends on force, lever arm and angle; the door example.
  • Adafruit Motor Selection Guide — brushed and brushless DC motors, steppers (discrete steps, repeatable positioning), gearmotors, RC servos (DC motor, gear train, H-bridge and potentiometer feedback).
  • Harmonic Drive LLC: Strain wave gear technology — Wave Generator, Flexspline and Circular Spline; two fewer teeth; one tooth per 180° of the Wave Generator; zero backlash.
  • ROBOTIS e-Manual: XL430-W250 — 258.5:1 gear ratio; stall torque 1.0 / 1.4 / 1.5 N·m at 9 / 11.1 / 12 V; no-load 57 rpm at 11.1 V; note that stall torque differs from continuous output.
  • SparkFun Learn: Hobby Servo Tutorial — servo current rises with mechanical load, up to an ampere or more.
  • Photos: Wikimedia Commons (credits under each image).

Self-attested for now — keep artifacts in your lab notebook.

Complete

Today's goal

0 of 1 done today

0-day streak
Daily goal:lessons, quizzes or assignments a day

Mark this lesson complete when you have worked the experiment, knowledge check, and assignment (even roughly).

Stuck somewhere?

Ask a doubt about this lesson

Saved with this lesson's id and your email so we can reply. Privacy · or email contact@aihubstation.in