Skip to content

Latest commit

 

History

1 Commit

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Inside the Hand

An interactive, physically modelled cutaway of the actuators inside a humanoid robot hand.

Start on a hand with eleven actuators, fly into the index knuckle and pick its gearbox. The motor, the drive electronics, the gears, the heat and the feel of the finger all follow from the physics, so you can watch what a gear ratio really trades.

The page opens on a robot hand, flies into the index knuckle and shows its actuator cut open: driver board, brushless motor, three-stage planetary gearbox and output bearing

Open the live demo  ·  one HTML file, nothing to install

Why

Humanoid hands are everywhere right now, and nearly all of them hinge on a part few people have seen inside: a finger-sized actuator. A tiny motor spins at thousands of rpm and a gearbox trades that speed for torque. The ratio decides how hard a finger can grip, how hot it runs, how fast it moves and how it feels when you push it. This page lets you make that choice yourself and see the consequences, part by part.

What's in it

  • A hand full of actuators. Eleven: one at each knuckle and each middle finger joint, two in the thumb and one at the wrist. The last joint of each finger follows the middle one through a linkage, as in many robot hands.
  • One actuator, opened up. An 18 mm module: a driver board with three half-bridges and a 14-bit magnetic encoder, a 15 mm brushless motor with 12 teeth and 14 magnets, a gearbox and a four-point-contact output bearing. Everything is drawn six times life size.
  • Four drives, with real tooth counts. Direct; planetary in one to three stages (4:1 to 216:1); cycloidal (11:1 to 29:1); strain wave (30:1, 50:1 and 100:1).
  • Three tasks. Hold a load out on the fingertip, Flex the finger through a 2.4 s curl-and-open, or Backdrive it by dragging the finger yourself.
  • Five views. The whole hand; a cutaway with hatched section faces; an exploded stack; and sections straight down the axis through the motor and through the gears. When the motor is too fast to follow, the close-ups run in slow motion; the numbers stay real-time.
  • Live instruments. The three phase currents; the stator field against the magnet axis (field-oriented control holds it 90 electrical degrees ahead); and a 30-minute forecast of the winding temperature.

Screenshots

The robot hand with its actuators labelled
The hand: an actuator at every knuckle and middle joint, two in the thumb, one at the wrist.
The index knuckle actuator cut open
The index knuckle, cut open: driver board, motor, three-stage 216:1 planetary, output bearing. Holding 500 g costs half a watt.
The strain-wave actuator pulled apart along its axis
Exploded strain-wave module: wave generator, 100-tooth flexspline, 102-tooth circular spline, output bearing.
Section across the motor
Down the motor's axis: 12 teeth, 14 magnets. Each tooth's pole follows the three phase currents.
Animated section of the strain-wave gear
Strain wave, 50:1. The elliptical wave generator walks the 100-tooth flexspline back two teeth per turn inside the 102-tooth ring.
Animated section of the cycloidal drive
Cycloidal, 15:1. The eccentric rolls a 15-lobe disc around 16 pins; pins in oversized holes carry out the slow, reversed turn.
Section across a planetary stage
Planetary: a 12-tooth sun, 24-tooth planets and a fixed 60-tooth ring. Three stages of 6:1 make 216:1.
Direct drive overheating while holding a load
No gearbox: 15 mN·m can't hold 500 g. The finger sags and the winding heads for 120 °C within seconds.

What a gear ratio trades

A ratio N multiplies torque by N and divides speed by N. For the same load the motor needs 1/N of the current, so the heat in its copper falls by N². But the rotor has to spin N times faster whenever the finger moves, so its inertia, felt at the fingertip, grows by N².

Here is the model holding 500 g out on the fingertip, which takes 0.46 N·m at the knuckle:

Drive Motor torque Copper loss Winding Rotor felt at the tip Top speed Backdrive friction
Direct, 1:1 needs 460 mN·m, has 15 25 W, finger sags 120 °C in 9 s < 0.1 g 90,000°/s 0.2 mN·m
Cycloidal, 29:1 needs 15.9 mN·m, has 15 25 W, sags a little 120 °C in 10 s 2.8 g 3,100°/s 14.5 mN·m
Planetary, 36:1 13 mN·m 18 W 120 °C in 14 s 4.4 g 2,500°/s 12 mN·m
Strain wave, 50:1 9.2 mN·m 9.3 W 120 °C in 32 s 8.8 g 1,800°/s 60 mN·m
Strain wave, 100:1 4.6 mN·m 2.3 W 120 °C in 12 min 35 g 900°/s 67 mN·m
Planetary, 216:1 2.1 mN·m 0.5 W settles below 50 °C 159 g 417°/s 59 mN·m

Top speed is the knuckle with the motor at 15,000 rpm. Rotor felt at the tip is the motor's own inertia, spun N times faster, expressed as mass at the fingertip. Backdrive friction is what you push against at the knuckle.

No row wins every column, which is why real hands differ. CMU's LEAP Hand puts a small 288:1 servo at each of its 16 joints, and the Allegro hand gears its finger motors 369:1. The DLR/HIT Hand II uses flat brushless motors with 100:1 Harmonic Drive gears 20 mm across. The Shadow hand keeps its 20 motors in the forearm and pulls the fingers with tendons. Some designs refuse to be backdriven on purpose. The bebionic prosthetic hand ends each finger's gear train in a lead screw, so it holds a grip with the power off. Tesla described its 2022 Optimus finger drive as non-backdrivable.

How accurate is it?

Exact.

  • Tooth counts, meshing and every direction of rotation.
  • Each planetary stage meets its assembly and phasing conditions.
  • The cycloid disc is the true inward offset of a trochoid, so it touches every pin.
  • The flexspline bends like an inextensible ring by one tooth module (0.12 mm at 50:1), and its teeth are tinted where they mesh.
  • The motor's 12-tooth, 14-magnet winding (AacCBbaACcbB) is driven by three sinusoidal phase currents that keep the field 90 electrical degrees ahead of the magnets. Each tooth's north or south follows from those currents.

Modelled.

  • The knuckle as one degree of freedom: the finger and load plus the rotor's inertia reflected by N², Coulomb friction with stiction, light viscous drag and soft joint stops.
  • Gravity acting on the curled finger and the hanging load.
  • Torque = Kt·Iq, copper loss (τ/Km)², and copper resistance rising 0.393 %/K.
  • A two-node thermal network: winding → case → hand.
  • The controllers:
    • Hold is PD with gravity feed-forward.
    • Flex tracks a 2.4 s curl-and-open.
    • Backdrive only compensates gravity, with light damping.

Left out. Backlash, tooth and bearing compliance, cogging ripple, magnet heating, field weakening and contact with objects.

The parameters are self-consistent values for an 18 mm finger module, not a specific product:

Part Value
Motor 12 slots, 14 poles · Kt 5 mN·m/A · Km 3 mN·m/√W · 15 mN·m peak · rotor 0.25 g·cm² · 15,000 rpm at 24 V
Finger 91 mm from knuckle to tip, 35 g; the middle joints curl with the knuckle
Heat 8 K/W winding→case, 22 K/W case→hand, 2.5 and 18 J/K, 30 °C inside the hand, limit 120 °C
Backdrive friction Direct 0.2 mN·m · planetary ≈ 0.25·N + 1.5 per stage (mN·m) · cycloidal ≈ 0.5·N mN·m · strain wave 56–67 mN·m, scaled from a size-25 catalog by torque capacity

For comparison, a Ø16 mm Faulhaber 1628 B motor has Km ≈ 1.8 mN·m/√W.

Controls

Drag to orbit, scroll or pinch to zoom, and drag the index finger to push it.

Key Action
1–4 Gearbox: direct, planetary, cycloidal, strain wave
← → Ratio
H F B Hold, flex, backdrive
Z C E M G Hand, cutaway, explode, motor, gears
O Slow orbit
Space Flick the fingertip with 0.6 N
? How it works

Run it locally

The page is a single self-contained file. Open index.html in a browser, or serve the folder:

python3 -m http.server 8000

Then go to http://localhost:8000. It needs WebGL 2, which a recent Chrome, Edge, Safari or Firefox provides. It loads three.js from jsDelivr and two fonts from Google Fonts.

Working on it

src/
  head.html          <head>: fonts and CSS
  body.html          the canvas, panels, instruments and help dialog
  01-core.js         units; motor, thermal and finger constants; gear options; geometry helpers
  02-scene.js        renderer, camera, lights, procedural textures, materials
  03-actuator.js     housing, driver board, rotor, stator, output bearing
  04-hand.js         the hand, fingers, thumb and the hanging load
  05-gearboxes.js    section planes and the hatched cap shader; strain wave, planetary, cycloidal, direct
  06-physics.js      joint dynamics, control, FOC phase currents, thermal model
  07-ui.js           callout labels, instruments, story text and stats
  08-controls.js     buttons, keys, dragging the finger, camera flights, post-processing
  09-help.js         the "How it works" panel
  10-frame.js        per-frame update and boot
build.sh             assembles src/ into index.html
tools/               headless screenshots and video
docs/                images for this README

The JavaScript is one ES module, split into files by concern. The files share one scope and build.sh concatenates them in order, so there is no bundler and nothing to install. Edit src/, then run:

./build.sh

Reload index.html to see the result. index.html is committed so GitHub Pages can serve it as is.

Screenshots and video. Both tools drive headless Chrome over the DevTools protocol and need Node 22 or later. Chrome's default macOS path is built in; set CHROME to use another binary.

  • tools/shot.mjs renders any state to a PNG. The state parameters are listed at the top of tools/debug.js:
    node tools/shot.mjs out.png "gear=strainwave&opt=1&task=turn&view=gears" 1536 864 1.25
  • tools/record.mjs renders the scripted 44 s tour in tools/tour.js frame by frame and encodes tools/out/tour.mp4 with ffmpeg:
    node tools/record.mjs

Sources

The help panel's facts come from these:

Credits

License

MIT

About

An interactive, physically modelled cutaway of the actuators inside a humanoid robot hand: brushless motor and FOC, planetary, cycloidal and strain-wave gearboxes, heat, inertia and backdrivability.

Topics

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages