Actuators: How Robots Move

Every plan a robot's controller produces is worthless until something in the physical world changes. That's the actuator's job: convert electrical (or fluid) energy into mechanical motion. Think of the controller as the brain and the actuator as the muscle — the interface between intention and reality.

Actuators are characterized by three key quantities:

• Torque — the rotational force it can produce, measured in Newton-meters (N·m). Higher torque lifts heavier loads.
• Speed — how fast it rotates or moves, usually in RPM or rad/s. High speed is great for wheels; too much speed on a surgical arm is dangerous.
• Power — torque × angular velocity. Power is roughly fixed for a given motor; you can trade speed for torque using gears.

The torque-speed tradeoff is fundamental: a motor running fast produces little torque; slow it down through gears and torque multiplies. This is why a power drill shifts into low gear to drive a screw (high torque, low speed) and high gear to drive fast (low torque, high speed).

A DC (direct current) motor spins continuously when voltage is applied. It's the simplest electric actuator: apply more voltage, spin faster. Reverse the polarity, spin backward. DC motors are cheap, lightweight, and can reach tens of thousands of RPM.

The downside is that a bare DC motor has no built-in position awareness. If you need to stop it at a specific angle, you must add an encoder and a feedback controller. Without feedback, the motor's actual speed depends on load, temperature, and battery voltage — all things that vary unpredictably.

DC motors power almost everything that spins continuously: robot wheels, drone propellers, conveyor belts, cooling fans. For position control you always pair them with encoders and a control loop. The combination is sometimes packaged as a gearmotor — a DC motor with a built-in gearbox — which multiplies torque and reduces speed to a more useful range.

A stepper motor moves in discrete angular steps — typically 1.8° per step (200 steps per full revolution). Each electrical pulse advances the shaft one step. No encoder required: just count pulses and you know the position, assuming the motor never misses a step.

This makes steppers attractive for open-loop position control — you command 400 pulses and trust the motor traveled exactly two full revolutions. 3D printers rely on this almost universally.

The catch: if a stepper is overloaded it skips steps without telling you. The controller has no way to detect skipped steps unless you add an encoder (which turns it back into a closed-loop system). Steppers also run hot at high speeds because they draw full current even when stationary to hold position.

A servo motor (or simply servo) is a DC motor packaged with a gearbox, position encoder, and built-in control circuit. You send it a target angle and the internal controller adjusts power until it arrives there. The classic hobby servo accepts a PWM signal and positions its output shaft anywhere in a ~180° range.

Servos are the default choice when you need reliable, repeatable joint angle control without building your own control loop. Every radio-controlled car steering system, robotic arm joint, and animatronic joint uses servos.

Industrial servos (KUKA, Festo, Yaskawa) operate on the same principle but with higher torque, better encoders, and communication via industrial protocols (EtherCAT, CANbus) rather than hobby PWM signals. The distinction matters at scale: a 6-DOF industrial arm coordinates six servo drives simultaneously over a high-speed fieldbus, with microsecond timing precision.

The key tradeoff: servos cost more than bare DC motors and have a limited range of motion (hobby servos max out near 270°). For continuous rotation applications, a DC motor with encoder usually wins.

A microcontroller can't output variable voltage — its digital pins are either 0 V or 3.3/5 V. Pulse-Width Modulation (PWM) solves this by rapidly switching the pin on and off. The fraction of time the signal is high is the duty cycle:

• Duty cycle 100% → always on → full power.
• Duty cycle 50% → half the time on → roughly half power.
• Duty cycle 0% → always off → motor stopped.

A motor driver chip (e.g., L298N, DRV8833) amplifies the PWM signal from the microcontroller's milliamps to the amps a motor actually needs. Here's a simple example on Arduino:

// Pin 9 supports PWM on Arduino Uno
int motorPin = 9;
void setup() {
  pinMode(motorPin, OUTPUT);
}
void loop() {
  // analogWrite value 0-255 maps to duty cycle 0-100%
  analogWrite(motorPin, 128);  // ~50% speed
  delay(2000);
  analogWrite(motorPin, 255);  // full speed
  delay(2000);
  analogWrite(motorPin, 0);    // stopped
  delay(1000);
}

The key concept: analogWrite is digital switching done so fast (typically 490–980 Hz on Arduino) that the motor's own inductance smooths it into a nearly steady current.

Motors spin fast and produce little torque; most robotic tasks need the opposite. Gears are the solution. A gearbox with a gear ratio of 100:1 reduces output speed by 100× but multiplies torque by (approximately) 100×, minus friction losses.

Common gearing types in robotics:

Backlash is the play or slop in a gearbox — the small angular range where the input moves but the output doesn't, because gear teeth aren't in contact. Backlash causes positioning error and is a major factor in precision robotics. Harmonic drives eliminate backlash entirely, which is why they appear in every joint of an industrial robot arm despite their cost.

When electric motors can't produce enough force, fluid power takes over.

Hydraulic actuators push oil through cylinders under high pressure (up to 300 bar). A hydraulic excavator bucket exerts tens of thousands of Newtons — far beyond any reasonably sized electric motor. Boston Dynamics' original Atlas robot used hydraulic actuators precisely because of this power density. The tradeoffs: heavy pump and reservoir, risk of oil leaks, complex plumbing, poor energy efficiency.

Pneumatic actuators use compressed air instead of oil. They're lighter and faster-acting than hydraulics, and air leaks are less catastrophic than oil leaks. Industrial pick-and-place robots frequently use pneumatic grippers that snap open and closed in milliseconds. The downside: compressors are noisy, air is compressible (making precise force control difficult), and you need a continuous supply of compressed air.

Actuators fail in characteristic ways that every robotics engineer learns the hard way:

• Stall: A DC motor stops rotating because the load exceeds available torque. Current spikes to its maximum (stall current), usually 5–10× normal. Left in stall for more than a few seconds, the motor overheats and the windings burn out. Always add stall detection in firmware.

• Backlash: Gear slop causes positional error and can excite oscillations in a position controller. If your robot arm vibrates at a joint, backlash is usually the first suspect.

• Back-EMF: When a spinning motor is suddenly de-energized, its collapsing magnetic field generates a voltage spike (back-EMF) that can destroy a microcontroller. Always use a motor driver with flyback diodes or a dedicated H-bridge IC.

• Thermal derating: Motors produce less torque as they heat up. A motor that passes specs in a 10-second sprint may fail in a 10-minute sustained run. Check duty cycle and thermal resistance in the datasheet.

Building a robot is largely the practice of anticipating these failure modes and adding protective circuitry and software before they destroy hardware.

Here's the motor comparison table every beginner should pin to their workbench:

For a first robot project, start with hobby servos for joints and DC gearmotors (or hobby servos in continuous mode) for wheels. Add encoders as soon as precision matters. Upgrade to brushless motors when you need high speed or high efficiency.

The actuator choice shapes every other design decision downstream. Here's a practical example: suppose you're building a tabletop robotic arm with 4 degrees of freedom.

• Base rotation: A large hobby servo (e.g., MG996R, 10 kg·cm stall torque) can hold the arm upright and rotate it 180°.
• Shoulder joint: The heaviest joint — carries the full arm weight. A high-torque digital servo or a DC motor with a planetary gearbox and encoder.
• Elbow and wrist: Smaller loads; standard hobby servos work fine.

# Pseudocode: command arm joints via servo PWM
servo_base.set_angle(90)     # center position
servo_shoulder.set_angle(45) # 45 degrees up
servo_elbow.set_angle(120)   # 120 degrees
servo_wrist.set_angle(60)    # 60 degrees

The lesson: size each joint actuator for the worst-case load at that joint, including the weight of all downstream links and any payload. Undersized actuators stall; oversized actuators waste money and battery. Get the actuator sizing right before you write a single line of control code.