Servo Motors: The Ultimate Guide

A servo motor is a control architecture. That idea trips up more engineers than it should. A servo is a motor plus a feedback sensor plus a controller that closes a loop around position (and usually velocity and torque underneath that). Strip out the sensor and the loop and you have a plain motor running open-loop. Bolt them on and almost any motor (brushed DC, brushless, AC induction, even a stepper) becomes a servo. The word describes what the thing does, and says nothing about what's inside it. "Servo" is a verb wearing a noun's clothes; the Latin servus, a slave that obeys a command and reports back.

That distinction matters because the term spans three wildly different product worlds. A $9 hobby servo from a model-aircraft shop and a $1,200 Kollmorgen AC servomotor with a 24-bit absolute encoder are both "servos," and an engineer who conflates them will either over-spend by 100x or under-spec a joint into early failure. The job of this guide is to give you the mental model to tell them apart, read their datasheets honestly, size them correctly, and not get burned by the failure modes that the marketing copy never mentions.

The take: The single most expensive mistake in servo selection is ignoring reflected inertia and RMS torque. Too little torque is rarely the real problem. Most engineers size on stall torque and no-load speed, both of which are peak, transient, marketing-friendly numbers. The joint actually lives or dies on its continuous RMS torque versus the thermally limited rated torque, and on whether the load inertia is within roughly 5 to 10x the rotor inertia. Get the inertia match and the duty cycle right and a "weaker" servo will outlast and outperform a "stronger" one chosen on stall torque alone.

Companion reading: brushless DC motors, gearboxes: harmonic and cycloidal, motor controllers and FOC, and encoders.

Table of contents

1. Key takeaways
2. What a servo motor actually is
3. The three worlds: RC, industrial, and smart serial servos
4. How an RC/hobby servo works
5. Inside an industrial servo system
6. Reading a servo datasheet
7. Smart serial servos for robotics
8. Gearing and torque
9. Control: cascaded loops, tuning, and limiting
10. Sizing a servo for your joint
11. Failure modes and thermal limits
12. Selection guide and comparison table
13. Practical wiring and power notes
14. Frequently asked questions

What a servo motor actually is

A servo is a closed-loop motion device. You command a target (usually a position) and the system measures where it actually is, computes the error, and drives the motor to kill that error. That feedback loop is the whole point. Without it you have open-loop control: you command an effort and hope the output lands where you wanted.

Open-loop vs closed-loop

A brushed DC motor with a fixed voltage is open-loop. Load it down and it slows; the controller never knows or cares. A stepper driven by step pulses is also open-loop in its classic form: it assumes each pulse advanced one micro-step, and if it skips a step under load, your position is silently wrong forever.

A servo refuses to be wrong silently. It watches the sensor. If the shaft is 2° short of target, it pushes harder. If it overshoots, it backs off or reverses. The error never gets to lie about itself.

Formally, that is negative feedback. With plant transfer function G(s) and controller C(s), the closed loop from command θ_cmd to output θ_out is θ_out/θ_cmd = C·G / (1 + C·G), and the response to a disturbance torque T_d is θ_out/T_d = G / (1 + C·G). The magic lives in the denominator. Wherever the loop gain |C·G| is large, at low frequencies where you care most, both the tracking error and the effect of a disturbance are divided down by (1 + C·G). Stiffness, accuracy, and disturbance rejection are all the same phenomenon: making loop gain large where it counts, without letting the phase lag at the crossover frequency roll past ~180° and turn your negative feedback positive. That is the entire game, and the motor controllers and FOC guide plays it in anger.

The three building blocks

Every servo, from the $9 hobby unit to the $1,200 industrial one, is the same three parts:

1. The motor (actuator). Converts electrical power to mechanical torque. Brushed DC in cheap servos; brushless PMSM (permanent-magnet synchronous) in good ones; AC synchronous in big industrial units.
2. The feedback sensor. Measures actual output. A potentiometer in hobby servos; an incremental or absolute encoder, resolver, or magnetic (Hall/magnetoresistive) sensor in better ones. See the encoders guide for the full taxonomy.
3. The controller (drive). Reads the command and the feedback, runs the control law (usually cascaded PID), and switches power to the motor through an H-bridge or three-phase inverter.

Rule of thumb: If a vendor sells you a "servo" but can't tell you what sensor closes the loop, you are buying a motor with optimistic marketing.

Why not just use a stepper or a geared DC motor?

Steppers are great open-loop for cost-sensitive, low-dynamics positioning (3D printers, small XY stages). But they lose steps under overload, run hot at hold, and waste current. Geared DC motors are cheap muscle with no idea where they are.

Servos win when you need accurate, repeatable position under varying load with good dynamics: robot joints, gimbals, CNC axes, steering, throttle bodies. You pay for the sensor and the smarts, and you get a system that corrects itself.

The three worlds: RC, industrial, and smart serial servos

"Servo" covers three product categories that barely resemble each other. Pick the wrong world and nothing downstream works.

World 1: RC/hobby servos

Self-contained boxes: motor, gear train, potentiometer, and a tiny control board, all in a plastic or metal case with a three-wire pigtail (power, ground, signal). You feed a PWM pulse, it moves to a position, typically over ~120 to 270° of travel. Cost: $5 to $80. Examples: HiTec HS-422, Futaba S3003, Savöx SC-1258TG, and the digital high-torque units like the Savöx SB-2290SG. This world is for small robots, RC vehicles, animatronics, pan-tilt rigs, and prototypes.

World 2: Industrial servo systems

A separate servomotor and servo drive (amplifier), joined by a power cable and a feedback cable. The motor has a precision encoder or resolver; the drive does the closed-loop math, often with a fieldbus interface (EtherCAT, CANopen, PROFINET) back to a PLC or motion controller. Cost: hundreds to thousands of dollars per axis. Examples: Kollmorgen AKM/AKD, Yaskawa Sigma-7, Beckhoff AM8000, Mitsubishi MELSERVO, Bosch Rexroth. This world runs CNC machines, packaging lines, pick-and-place, and industrial robot arms.

World 3: Smart serial servos

The newest category, built for robotics. Like an RC servo, everything is in one housing, but the controller is a real microcontroller, the feedback is a contactless magnetic encoder (often 12-bit, 4096 counts/rev), and you talk to it over a digital bus (TTL or RS-485) with a packet protocol. You can daisy-chain dozens on one bus, each addressable by ID, and read back position, velocity, current, temperature, and voltage. Cost: $25 to $1,000. Examples: ROBOTIS Dynamixel X-series (XL330, XM430, XH540) and P-series, plus the Feetech STS/SCS line. This world dominates research robots, humanoids, quadrupeds, and serious hobby/educational arms.

Attribute	RC/Hobby	Industrial	Smart Serial (Dynamixel-style)
Typical cost/axis	$5 to $80	$300 to $3,000+	$25 to $1,000
Motor type	Brushed (mostly)	PMSM / AC synchronous	Brushed or BLDC (coreless on premium)
Feedback	Potentiometer	Encoder / resolver, 17 to 24 bit	Magnetic encoder, 12-bit typ.
Command interface	PWM 1 to 2 ms @ ~50 Hz	±10 V, step/dir, EtherCAT/CANopen	Serial packet (Protocol 2.0)
Position range	120 to 270° (limited)	Multi-turn, unlimited	360° or multi-turn (extended mode)
Telemetry back	None	Full (drive)	Position, vel, current, temp, voltage
Holding torque	Yes, lossy	Yes, controlled	Yes, current-limited
Where it fits	Models, prototypes, animatronics	CNC, packaging, factory automation	Research robots, humanoids, arms

How an RC/hobby servo works

The RC servo is a beautiful piece of 1970s analog cleverness that has survived almost unchanged in concept. Understand it once and you understand half the small-robot world.

The PWM position command

Despite the name, the control signal differs from PWM in the power-electronics sense (it carries no power and the duty cycle isn't what matters). It's a pulse-width position code: a pulse repeated at roughly 50 Hz (every 20 ms), where the pulse width encodes the target position.

Standard RC servo signal (~50 Hz frame):

  1000 µs pulse  ->  full one way   (e.g. -60°)
  1500 µs pulse  ->  center / neutral (0°)
  2000 µs pulse  ->  full other way (+60°)

  |<------------------- 20 ms frame (50 Hz) ------------------->|
  |__                                                          |__
  |  |________________________________________________________|  |...
  |<>|  pulse width = position command (1000-2000 µs)

The 1000 to 2000 µs range with 1500 µs neutral is the de-facto standard. Many servos accept a wider range (about 500 to 2500 µs) for extended travel, but pushing past the mechanical stops will stall and cook the motor. The frame rate is loose: analog servos tolerate 40 to 60 Hz; digital ones often accept much faster frames.

The pulse width is your command resolution budget, and it is stingier than people assume. Over 1000 µs of usable pulse mapped onto, say, 120° of travel, one microsecond buys you 0.12°. If your microcontroller generates the pulse with a 16-bit timer at a coarse prescale, or worse, with a jittery software delayMicroseconds() loop, the quantization step of the command can exceed the servo's own deadband, and no amount of gear precision downstream recovers it. Generate servo pulses from a hardware timer/PWM peripheral, not from busy-wait code, and you have already beaten most hobby rigs on repeatability.

What's inside

Open the case and you find: a small brushed DC motor, a reduction gear train (often 3 to 6 stages of spur gears), a potentiometer geared to the output shaft, and a control board.

The potentiometer is the sensor. As the output rotates, the pot wiper voltage changes. The control board compares that feedback voltage against a voltage derived from the incoming pulse width. The difference (error) drives an H-bridge that powers the motor in the direction that reduces the error. When the pot voltage matches the command, the motor stops. That's the whole loop: a position servo built from a comparator and a motor driver.

Deadband

No servo holds an infinitely precise null. There's a deadband: a small error window where the controller does nothing, to stop the motor from buzzing and hunting around the target. Cheap analog servos have a wide deadband (sloppy, ~5 to 10 µs equivalent); good digital servos shrink it (crisp, ~1 to 3 µs), which is why digitals "lock in" harder.

Analog vs digital servos

The mechanical guts are often identical. The difference is the control board.

• Analog servos drive the motor with the ~50 Hz signal directly: the motor gets a power pulse only once per 20 ms frame. Cheap, low idle current, but soft holding torque and slow to respond, especially to small errors.
• Digital servos use a microcontroller that re-samples the error and re-drives the H-bridge at 300 Hz to 1 kHz or more, independent of the input frame rate. Result: faster response, tighter deadband, much stronger holding torque near the target, at the cost of higher idle current and more heat.

Rule: If your application needs the servo to hold against a load (a robot arm fighting gravity, a steering linkage), buy digital. If it just needs to slew to a position occasionally with little holding load, analog is cheaper and cooler.

Continuous-rotation "servos"

Pull out the pot and replace it with a fixed voltage divider, and the servo never reaches its target, so it spins continuously, with pulse width now commanding speed and direction instead of position. These "continuous rotation servos" are really just geared motors with a built-in PWM-to-speed driver. Convenient, but you've thrown away the closed loop; they're open-loop on speed.

Inside an industrial servo system

Industrial servos split the system into a motor and a drive (amplifier), and that separation is the source of their performance. The drive is a serious piece of power electronics and DSP, not a comparator on a hobby board.

The motor: AC servo vs brushless DC

Most modern industrial servomotors are permanent-magnet synchronous motors (PMSM), marketed as "AC servomotors." They're three-phase, sinusoidally driven, and electrically nearly identical to what the hobby/drone world calls a BLDC motor: the difference is mostly the back-EMF waveform (sinusoidal vs trapezoidal) and the control strategy. For the full treatment of the motor itself, see the brushless DC motors guide and the FOC controllers guide.

Key point: an "AC servo" and a "brushless DC servo" are siblings. Both are brushless PM machines. "AC servo" usually implies sinusoidal commutation with field-oriented control (FOC) and a high-resolution encoder; "brushless DC servo" sometimes implies simpler six-step trapezoidal commutation. Good industrial drives all do FOC now.

FOC is where a century-old piece of theory earns its keep. R. H. Park's 1929 dq0 transform ("Two-Reaction Theory of Synchronous Machines") rotates the three stationary phase currents into a reference frame locked to the rotor, turning the sinusoidally-varying phase quantities into two DC-like components: a torque-producing quadrature current i_q and a flux-producing direct current i_d. The drive regulates i_q to command torque and pins i_d ≈ 0 (for a surface-PM machine) so that no current is wasted fighting the magnets. That is why a modern servo can hold rated torque smoothly at zero speed, a thing a naive six-step drive does with an ugly torque ripple. The rated points themselves are defined under IEC 60034-1 (rotating electrical machines, rating and performance), which is the standard the honest numbers on the nameplate trace back to.

The feedback device

This is where industrial servos earn their price. Instead of a pot, you get:

• Incremental encoders: high resolution (e.g. 2,000 to 10,000 lines, quadrature-multiplied to 8,000 to 40,000 counts/rev), but need homing on power-up.
• Absolute encoders: know position at power-on without homing. Single-turn (e.g. 17-bit = 131,072 counts/rev) or multi-turn (e.g. 17-bit single + 16-bit turns counter). Modern Yaskawa/Mitsubishi units run 22 to 24 bit.
• Resolvers: rugged analog devices, great for high-temperature/high-vibration environments (motorsport, aerospace), lower resolution but nearly indestructible.

The cascaded control loops

The drive runs three nested loops, fastest on the inside:

   position cmd            velocity cmd            torque (current) cmd
        |                       |                          |
   +----v----+   error    +-----v----+   error    +--------v-------+
-->| POSITION |---------->| VELOCITY |----------->|  TORQUE/CURRENT |--> motor
   |  loop    |  (P/PI)   |  loop    |  (PI)      |  loop (PI, kHz) |
   +----^----+            +-----^----+            +--------^--------+
        |                       |                          |
   position fb            velocity fb               current fb (shunt)
   (encoder)             (diff. of pos)              (phase shunts)

• Torque/current loop runs fastest, often 8 to 20 kHz, regulating motor current (hence torque, since torque = Kt × current). This is the foundation; everything above assumes it can deliver commanded torque instantly.
• Velocity loop wraps the current loop, regulating shaft speed (PI control), typically at 1 to 4 kHz.
• Position loop is outermost, often just proportional (P) on position error feeding a velocity command, sometimes with feedforward, at 0.5 to 2 kHz.

You tune from the inside out: get the current loop right (usually auto-tuned to the motor's L and R), then velocity, then position. This cascade is what gives industrial servos their bandwidth, stiffness, and disturbance rejection. The same architecture appears, scaled down, inside good smart serial servos.

The nesting is not arbitrary; it obeys a timescale-separation rule. For the cascade to behave as if each inner loop were an ideal, instantaneous actuator to the loop outside it, each inner loop's closed-loop bandwidth should sit roughly 5 to 10× above the loop that wraps it. That is exactly why the numbers ladder down: current at 8 to 20 kHz, velocity at 1 to 4 kHz, position at 0.5 to 2 kHz. Violate the separation (say, crank the velocity-loop bandwidth up near the current-loop bandwidth) and the "fast" inner loop no longer looks like a stiff torque source to the velocity loop; its own dynamics leak into the outer loop as phase lag, the gain and phase margins collapse, and the axis rings. The current-loop bandwidth itself is capped by the electrical pole 1/τ_e = R/L and by the PWM/sampling rate (Nyquist says your loop bandwidth lives below half the sample rate, and in practice well below it once you budget for computational delay). You cannot tune your way past physics you did not buy.

Regeneration

Decelerating a high-inertia load, the motor becomes a generator and pumps energy back into the DC bus. Industrial drives handle this with a braking resistor (dump the energy as heat) or regenerative circuitry (return it to the mains). Ignore this on a big inertial load and the bus over-voltage fault will trip the drive, or pop it.

Reading a servo datasheet

Datasheets are where money is won or lost. Vendors lead with the flattering numbers. Here's how to read past them.

Spec	What it means	The trap
Stall torque	Max torque at zero speed, max voltage, momentarily	Peak, transient. You cannot run here continuously, it's a thermal death sentence.
No-load speed	Max speed with nothing on the shaft	You never operate here; any torque load drops it.
Rated (continuous) torque	Torque it can hold indefinitely without overheating	The number that actually sizes your continuous duty.
Rated speed	Speed at rated torque	The real operating corner of the speed-torque curve.
Peak torque	Short-burst max (industrial), e.g. 3x rated for a few seconds	Limited by I²t and demag, not by mechanics.
Torque constant Kt	N·m per amp of motor current	Lets you predict torque from current and vice versa.
Back-EMF constant Ke	Volts per rad/s	In SI units, Ke (V/(rad/s)) = Kt (N·m/A) numerically.
Rotor inertia Jm	Inertia of the spinning rotor (kg·m²)	Sets how much load inertia you can match (see sizing).
Rated current / peak current	Continuous and burst current	Drive must supply peak; supply must not brown out.
Duty cycle / S1 to S10	How long it can run at a given load	S1 = continuous; intermittent ratings let higher torque for limited time.
Holding torque	Torque to hold position statically	Still draws current and makes heat. Often near rated.

The speed-torque curve

This is the single most informative graphic in any servo datasheet. It plots torque (x) vs speed (y), with two regions:

• Continuous operating region: the box you live in for repetitive duty, bounded by rated torque and rated speed (thermally limited).
• Intermittent/peak region: torque you can pull for short bursts (acceleration), bounded by peak torque, current limits, and demag.

Plot your actual move profile's torque-speed points on this chart. Every point of continuous operation must sit inside the continuous box; transient peaks may enter the intermittent region. If your acceleration torque pokes outside even the peak region, the servo is too small. Full stop.

Kt, Ke, and the unit gotcha

Torque is proportional to current: T = Kt × I. Speed is set by voltage minus the IR drop: the motor spins until its back-EMF nearly equals the applied voltage.

In SI units, Kt (N·m/A) equals Ke (V·s/rad) numerically, they're the same physical constant viewed from the torque side and the voltage side. That is not a coincidence or an approximation; it falls straight out of energy conservation. A lossless motor converts electrical power at the back-EMF into mechanical power with no leftover: the power delivered against the back-EMF, E·I, must equal the mechanical power produced, T·ω. Substitute the two definitions E = Ke·ω and T = Kt·I:

   E · I  =  T · ω          (energy conservation, lossless conversion)
(Ke·ω)·I  =  (Kt·I)·ω
     Ke   =  Kt             ← identical, in coherent SI units

The ω and I cancel, leaving Ke = Kt as an identity, not a measurement. The classic mistake is mixing units: a Kt given in oz-in/A and a Ke in V/kRPM look unrelated until you convert both to SI. Convert everything to N·m, A, V, and rad/s before you trust any back-of-envelope math.

Torque from current:   T [N·m]   = Kt [N·m/A] × I [A]
Speed vs voltage:       ω [rad/s] ≈ (V - I·R) / Ke   with Ke = Kt in SI
Electrical power:       P_elec   = V × I
Mechanical power:       P_mech   = T × ω

The motor constant Km: the one figure of merit that can't be gamed

Kt alone is a trap: you can raise Kt arbitrarily by adding turns to the winding, but that also raises resistance R and the extra torque-per-amp buys you nothing thermally. The honest figure of merit is the motor constant:

Km = Kt / sqrt(R)      [N·m / sqrt(W)]

meaning:  T = Km × sqrt(P_dissipated)   → P_copper_loss = (T / Km)²

Km measures torque produced per square-root-watt of copper loss, and unlike Kt it is (to first order) invariant to the winding turns count: rewind the same iron and magnets for a different voltage and Km barely moves. Two candidate motors of the same frame size? The one with the higher Km makes your target torque with less heat, full stop. This is the number Maxon and the serious vendors publish precisely because it can't be inflated by a marketing rewind, and it is the cleanest single-number way to compare motors before you ever open the speed-torque curve.

Smart serial servos for robotics

Smart serial servos are the reason a graduate student can build a 20-DOF humanoid without a cabinet full of industrial drives. They collapse the whole servo system into one networked module.

What's in the box

Take a Dynamixel XM430-W350 as the canonical example: a coreless or cored brushed/BLDC motor, a metal-gear reduction (e.g. ~353:1), a contactless 12-bit magnetic encoder (4096 positions/rev), a current sensor, a temperature sensor, a microcontroller running a cascaded PID, and a half-duplex serial transceiver, all in a roughly 35 × 28 × 46 mm case. You get back, over the wire: present position, velocity, current, input voltage, and temperature.

The bus: TTL vs RS-485, and daisy-chaining

Two physical layers dominate:

• TTL half-duplex (Dynamixel X-series like XL/XM): a single data line shared by all devices, 3.3 V logic. Cheap, fine for short chains.
• RS-485 half-duplex (Dynamixel higher-end and P-series): a differential pair standardized as TIA/EIA-485-A. Because a differential receiver reads the difference between the two conductors, common-mode noise injected equally onto both (exactly what a switching motor supply radiates) subtracts out. That is why RS-485 tolerates long runs and electrically filthy environments where single-ended TTL turns into a bag of bit errors. Use it for anything beyond a benchtop.

Devices daisy-chain: each has two connectors wired in parallel so you string them in a line. Every device has a unique ID (0 to 252; 254 is broadcast) and a baud rate (commonly 57,600 bps, configurable up to 4.5 Mbps on X-series). The host (a U2D2 adapter or an OpenCR/OpenRB board) is the bus master; servos only speak when addressed.

Protocol 2.0 packet

ROBOTIS Protocol 2.0 is the common language. A simplified instruction packet:

Protocol 2.0 instruction packet layout:

 Header(3)   RSRV  ID   LEN(2)  INST  PARAMS...      CRC(2)
 FF FF FD    00    01   07 00   03    74 00 C8 00... LL HH
 |           |     |    |       |     |              |
 fixed       0x00  ID=1 length  WRITE addr+data      CRC-16

  INST examples:  0x01 PING   0x02 READ   0x03 WRITE
                  0x83 SYNC WRITE  0x92 BULK READ

The Sync Write and Bulk Read instructions are what make multi-joint robots practical: one packet commands position/velocity on many servos at once, or reads telemetry from many, instead of round-tripping each ID separately. The trailing 16-bit CRC (a cyclic redundancy check, stronger than a mere checksum) catches essentially all single- and burst-bit corruption on the wire: non-negotiable when a flipped bit means a joint slamming to the wrong angle.

The economics are unforgiving on a shared half-duplex bus. Each transaction costs its byte-time at B baud (10 bits/byte with 8-N-1 framing) plus the servo's response-delay and the master's line-turnaround. Round-trip 20 joints individually and that fixed overhead stacks 20-fold; fold them into one Sync Write and one Bulk Read and you pay it once. That is the difference between a loop that closes at hundreds of Hz and one that wheezes at 30: same hardware, different packet strategy.

Operating modes and current-based torque control

Modern X/P-series servos expose multiple control modes you switch by writing a register:

• Position control: go to an angle (single-turn).
• Extended position (multi-turn): track position across many revolutions.
• Velocity control: command a speed (continuous rotation).
• Current control: directly command motor current, i.e. torque. This is the big one for robotics: it lets you do compliant, force-controlled motion, gravity compensation, and back-drivable joints.
• Current-based position control: go to a position but cap the current/torque, so the joint is gentle and won't crush a finger or strip a gear.

That current-limited position mode is, honestly, the killer feature. It gives you a poor-man's torque-controlled joint without the cost of a true industrial drive, and it's why these dominate research arms and grippers.

Rule: If you need compliant or force-aware joints on a budget, smart serial servos with current control beat both RC servos (no telemetry) and industrial drives (no money) for most sub-10-kg robots.

Gearing and torque

Almost no servo motor is used at the motor shaft. Motors make their power at high speed and low torque; joints want the opposite. The gearbox is the translator, and it dominates the servo's real-world behavior.

Why reduction is mandatory

A small motor might make 0.05 N·m at 8,000 rpm. A robot elbow wants maybe 5 N·m at 60 rpm. A 100:1 reduction turns that 0.05 N·m into a theoretical 5 N·m (minus efficiency) and drops 8,000 rpm to 80 rpm. Torque multiplies by the ratio; speed divides by it. Reflected inertia, crucially, divides by the ratio squared, more on that in sizing.

Backlash

Backlash is the lost motion when you reverse direction: the gear teeth have to take up clearance before torque transmits. It's the enemy of positioning accuracy and the source of "wobble" in cheap servos.

• Spur/planetary gear RC servos: typically 0.1 to 0.5° of backlash. Fine for a camera gimbal, sloppy for a precise end-effector.
• Harmonic (strain-wave) drives: essentially zero backlash, under 1 arc-minute. The reason every precision robot wrist uses them, at a price.
• Cycloidal drives: very low backlash, high shock tolerance, used at the heavy base joints of industrial arms.

The hidden spring: torsional resonance

No gear train is infinitely rigid. The motor rotor, the finite torsional stiffness k of the gearbox and coupling, and the load inertia form a two-mass resonant system: a mass, a spring, and another mass. Its anti-resonant and resonant frequencies land near

ω_ares ≈ sqrt( k / J_load )              (numerator zero: load "hides")
ω_res  ≈ sqrt( k · (J_motor + J_load) / (J_motor · J_load) )   (pole: both masses ring)

with ω_res always above ω_ares. This matters because that resonance is a hard ceiling on how high you can push the velocity-loop bandwidth: try to close the loop near ω_res and the axis will sing audibly and then go unstable. Stiffer coupling (higher k) and a better inertia match push the resonance up and out of your way; a long, whippy shaft or a compliant harmonic drive with a heavy load pulls it down into your control band. When a well-sized servo mysteriously refuses to tune above a certain gain and buzzes at a fixed pitch, you have found ω_res, the resonance itself.

For the full gearbox treatment (strain-wave, cycloidal, planetary, and how to choose) see the gearboxes guide.

Metal vs nylon (Karbonite) gears

A perennial hobby-servo question:

• Nylon/Karbonite gears: quiet, cheap, self-lubricating, and they strip before they shatter under shock. That's a feature: the gear is the sacrificial fuse protecting the motor. Good for light loads and crash-prone applications.
• Steel/titanium gears: high torque capacity, durable under sustained load, but transmit shock straight into the motor and case. If you stall a metal-gear servo against a hard stop, the output shaft or the case mounts fail instead of a cheap gear.

Rule: Metal gears for sustained high torque; nylon gears when crash protection and cost matter more than ultimate strength. Don't put metal gears on a hobby airframe and assume you've upgraded: you've just moved the failure point to something more expensive.

Control: cascaded loops, tuning, and limiting

Whether it's a $9 servo or a $1,200 drive, the control law is some flavor of PID, usually cascaded. Knowing how it's structured tells you how to tune it and why it misbehaves.

The cascade, again, and why order matters

As shown earlier, the loop nests current → velocity → position. The reason for the cascade rather than one monster position-PID: each inner loop linearizes and stiffens the plant the outer loop sees. The velocity loop only works well if the current (torque) loop is fast and accurate; the position loop only works well if velocity is well-regulated. Tune inside-out. Tuning the position loop while the velocity loop is sloppy is chasing your tail.

PID terms, in servo language

• P (proportional): stiffness. Higher P = stronger correction per unit error = stiffer joint that holds position harder. Too high → oscillation/buzz.
• I (integral): kills steady-state error (e.g. droop under constant gravity load). Too high or unbounded → overshoot and integral windup.
• D (derivative): damping. Resists rapid error change, calms overshoot. Too high → amplifies sensor noise into jitter.

Many servo position loops are P-only on position with PI on velocity underneath: that combination handles the integral action where it belongs (velocity) and keeps the position loop clean.

For a starting point when you have no auto-tuner, the classic Ziegler-Nichols method (Ziegler & Nichols, 1942) still works on the velocity loop: raise P until the axis oscillates at a steady amplitude, note that ultimate gain K_u and oscillation period T_u, then back off per the ZN table. Treat the result as a rough seed, not gospel; ZN is aggressive and assumes a plant it doesn't really understand, so it typically leaves you near the edge of stability. Detune from there toward the phase margin you actually want (aim for ~45 to 60° of phase margin at crossover for a response that is fast but doesn't ring).

Anti-windup

When a servo saturates, commanding max current but the load won't move (stall, hard stop, slow ramp), the integrator keeps accumulating error it can't act on. When the obstruction clears, that stored-up integral term slams the output and you get a violent overshoot. Anti-windup clamps or back-calculates the integrator while saturated. Any decent servo firmware has it; if your homebrew loop overshoots wildly after a stall, this is almost always why.

Current limiting

The current limit protects the motor, the drive, and your fingers. It's set below the demagnetization and thermal limits. In smart serial servos it's a register you write (the "Goal Current" / current-limit). In industrial drives it's a torque-limit parameter, often switchable on the fly for force-sensitive operations (e.g. limit torque during a press-fit). Always set it deliberately: the default is often "as much as the hardware survives," which is not what you want crushing into an obstacle.

Feedforward

High-performance drives add feedforward: they predict the torque needed for the commanded acceleration (and the velocity needed for the commanded motion) and inject it directly, so the feedback loop only cleans up the residual. This dramatically improves tracking on fast, dynamic moves. It's why a well-tuned industrial servo can follow a complex trajectory with tiny following error, while a pure-feedback loop lags.

Sizing a servo for your joint

This is the section most engineers skip and most regret. Sizing on stall torque is how you end up with a servo that's "strong enough" on paper and burns out in a week. Do it properly.

Step 1: Reflected inertia

The load inertia, seen through the gearbox, is divided by the gear ratio squared:

J_reflected = J_load / N²     (N = gear reduction ratio)

Example: J_load = 0.02 kg·m²,  N = 50
J_reflected = 0.02 / 2500 = 8.0e-6 kg·m²  (8 µkg·m²)

That N² is why high-ratio gearboxes make big loads feel tiny to the motor, and why direct-drive (N≈1) servos must be physically huge to move any real inertia.

Step 2: The inertia-matching rule

Compare reflected load inertia to the motor's rotor inertia Jm:

inertia ratio = J_reflected / J_motor

• Ratio ≈ 1:1: theoretically optimal power transfer, very crisp, but expensive (needs a big motor or high ratio).
• Ratio 1:1 to ~10:1: the practical, tunable band. ~5:1 is a common, comfortable target.
• Ratio > 10:1: the load dominates; coupling compliance and resonance make the loop hard to tune. You'll have to soften gains and accept lower bandwidth.

If your ratio is 30:1, either increase the gear reduction (which cuts reflected inertia by N²) or pick a motor with higher rotor inertia. This single check prevents most "it oscillates and I can't tune it out" problems.

Step 3: Torque budget

Sum the torques the motor must supply, reflected to the motor shaft:

T_motor = T_accel + T_friction + T_gravity + T_external,   all referred to motor shaft

T_accel  = (J_motor + J_reflected) × α        (α = angular accel, rad/s²)
T_gravity (reflected) = T_gravity_load / (N × η)   (η = gearbox efficiency)

Don't forget gearbox efficiency η (planetary ~0.9, harmonic ~0.7 to 0.85, worm much lower), it makes the load harder to drive, so you divide by it when referring load torque back to the motor.

Step 4: RMS torque vs rated torque (the one that matters)

A move profile isn't constant torque. You accelerate (high torque), cruise (low torque), decelerate (torque, possibly negative), and dwell (holding torque). The motor's thermal limit responds to the root-mean-square torque over the full cycle, including the dwell:

T_rms = sqrt( Σ(T_i² × t_i) / Σ t_i )      over accel, cruise, decel, dwell

Requirement:  T_rms  ≤  T_rated (continuous)
              T_peak ≤  T_peak  (intermittent rating)

The sizing rule: Your peak move torque must fit under the peak/intermittent rating, and your RMS torque over the whole duty cycle must fit under the continuous (rated) torque. Stall torque and no-load speed don't enter the calculation at all: they're just the corners of the curve.

Add a margin: target T_rms at 70 to 80% of rated and T_peak at 80% of peak to leave headroom for voltage sag, hot ambient, and friction growth as the joint wears.

Failure modes and thermal limits

Servos almost always die thermally or from a single overload event. Knowing the modes lets you design them out.

Stall and I²t

A stalled servo draws stall current, often 5 to 10x running current, while producing zero mechanical output, so all of that electrical power becomes heat in the windings. The copper dissipation is P = I²R, and there is no ω to carry any of it away as mechanical work, so the winding is a pure resistive heater. The temperature rise is governed by a first-order thermal model:

C_th · dΔT/dt = I²R − ΔT / R_th        →   ΔT_final = I²R · R_th ,   τ_th = R_th · C_th

where R_th is the winding-to-ambient thermal resistance (K/W), C_th the thermal capacitance (J/K), and τ_th the thermal time constant. The winding rises toward its steady-state ΔT with time constant τ_th, often tens of seconds to a few minutes for a small servo. That is the whole reason a brief stall is survivable and a sustained one is fatal: for pulses much shorter than τ_th the winding integrates I²·t nearly adiabatically (heat has no time to escape), so the survivable energy is fixed and time-limited. Good drives and smart servos model exactly this as an I²t limit: integrate I² over a sliding window and fault out before the winding reaches its insulation ceiling.

Rule: Treat a stall as a fault, not an operating state. If your design ever holds a servo against a hard mechanical stop "to be sure," you're building a heater.

Gear stripping

Shock loads and stalls strip gear teeth. As noted, nylon gears strip as a sacrificial fuse; metal gears instead pass the shock to bearings, shafts, and mounts. Either way, repeated hard stops or crash impacts are the mechanical killer. Add compliance (a spring, a clutch) or current limiting upstream of a hard stop.

Brownout / under-voltage reset

The most common "ghost" failure: a servo's stall inrush sags the shared supply rail, the logic voltage dips below the microcontroller's brownout threshold, and the controller resets mid-motion. Symptoms look random and software-y but are pure power-electronics. Fix: separate rails, bulk capacitance, and adequate supply current (see wiring).

Demagnetization

Permanent magnets lose strength if exposed to a strong opposing field (from over-current) or excessive temperature beyond the magnet's grade rating. The mechanism is the knee of the demagnetization (second-quadrant B-H) curve: below the knee the magnet recoils elastically and recovers, but drive the operating point past the knee (with a large opposing armature field, a high temperature, or both, since the knee migrates upward as temperature rises) and the magnet takes a permanent set at a lower remanence. NdFeB is especially temperature-sensitive here, which is why high-temperature grades (the SH/UH/EH suffixes) exist. Demag is usually partial and permanent: the motor's Kt drops, so it makes less torque per amp, runs hotter for the same load, and edges further past the knee: a slow death spiral. Current limits and thermal limits exist largely to keep the operating point on the safe side of that knee.

Duty cycle and thermal class

The duty types S1 through S10 are defined by IEC 60034-1, not marketing whim. S1 (continuous) rated torque assumes steady-state thermal equilibrium; intermittent duty like S3 (defined by a cyclic duty factor, e.g. "S3 25%") allows higher torque because the motor sheds heat during off-time. Respect the rating: a servo rated for 25% duty at peak torque that you run at 60% duty will overheat even though no single move exceeds the peak number, because, per the thermal model above, it is the average I²R over the cycle that sets the equilibrium ΔT, and RMS torque is precisely the metric that captures it. The winding insulation class (thermally classified under IEC 60085) sets the ceiling: Class B ~130 °C, Class F ~155 °C, Class H ~180 °C, each figure being the maximum hot-spot temperature for a nominal insulation life. Note the arithmetic that follows: those ceilings are absolute winding temperatures, so a hotter ambient eats directly into your allowable ΔT and hence your continuous torque. Many servos derate hard above ~40 °C ambient for exactly this reason. A rough field rule from insulation chemistry (every ~10 °C over the rated hot-spot roughly halves insulation life) is why running "just a little hot" quietly steals years off a machine.

Bearing wear and backlash growth

The slow, boring failure: bearings and gear faces wear, backlash grows, the loop gets harder to tune, and accuracy drifts. Not catastrophic, but it's why a 5-year-old production line servo positions worse than a new one. Plan maintenance intervals for precision axes.

Selection guide and comparison table

Pick the world first, then the unit. Here's a decision shortcut and a real-product spec table spanning the three classes.

Decision shortcut

• Prototyping, models, animatronics, <2 kg loads, no telemetry needed → RC/hobby servo. Buy digital + metal gears if it holds load.
• Research robot, humanoid, gripper, arm, need current/torque feedback, 0.1 to 10 kg per joint → smart serial servo (Dynamixel X/P, Feetech).
• Factory automation, CNC, packaging, high duty, high precision, fieldbus to a PLC → industrial servomotor + drive.
• High-power, back-drivable, dynamic legged-robot joints → consider a custom BLDC + FOC controller (ODrive, Moteus) with an encoder, which is arguably a servo you assemble yourself. See the robot actuators guide for the full landscape.

Real-product spec table

Product	Class	Stall/rated torque	Speed (no-load)	Feedback	Interface	Voltage	Notes
Futaba S3003	RC analog	~0.41 N·m stall @ 6 V	~0.19 s/60°	Pot	PWM 50 Hz	4.8 to 6 V	Classic cheap hobby standard
Savöx SB-2290SG	RC digital	~6.9 N·m stall @ 8.4 V	~0.11 s/60°	Pot	PWM (digital)	6 to 8.4 V	Brushless, steel gear, high-torque
Dynamixel XL330-M288	Smart serial	~0.52 N·m stall @ 5 V	~104 rpm	12-bit mag	TTL, Protocol 2.0	3.7 to 6 V	Tiny, low-cost research servo
Dynamixel XM430-W350	Smart serial	~4.1 N·m stall @ 12 V	~46 rpm	12-bit mag	TTL, Protocol 2.0	10 to 14.8 V	Current control; arm/gripper workhorse
Dynamixel XH540-W270	Smart serial	~11.7 N·m stall @ 14.8 V	~46 rpm	12-bit mag	TTL/RS-485	10 to 14.8 V	High-torque robot joints
Kollmorgen AKM23	Industrial AC	~0.9 N·m rated, ~2.8 N·m peak	~6,000 rpm	17 to 24 bit abs/resolver	EtherCAT/analog (AKD drive)	120 to 240 VAC class	Continuous duty, machine axes
Teknic ClearPath CPM-SDSK	Integrated industrial	~0.4 to 3+ N·m models	up to ~6,000 rpm	Integrated encoder	Step/dir, pulse, serial	24 to 75 VDC	Motor+drive+encoder in one, NEMA frames
Maxon EC-i 40 + EPOS4	Modular servo	~0.1 N·m cont. (motor)	high (motor)	Encoder	CANopen/EtherCAT (EPOS4)	24 to 48 VDC	Build-your-own precision servo

Numbers are representative datasheet figures and vary by exact model/winding/voltage: always pull the current datasheet for the specific part and winding before committing.

Practical wiring and power notes

More servo projects fail on power integrity than on control theory. The fixes are cheap if you design them in.

Separate logic and motor power, common ground

Never run motor current through your microcontroller's 5 V regulator. The motor's inrush and stall current will sag the rail and reset the logic. Use two supplies: one clean rail for logic, one beefy rail for motor power. Tie their grounds together at a single point (the servo signal is referenced to motor-power ground, but the logic must share that reference).

   +5V logic ----[MCU / Pi]----signal---->|servo signal pin
                     |                     |
   GND --------------+---------------------+----+----> servo GND
                                                |
   +7.4V motor ----------------------[bulk cap]-+----> servo V+

Size for inrush and stall, not running current

A servo's running current might be 200 to 500 mA, but its inrush (startup) and stall current can be several amps each. Multiply by the number of servos that might move or stall simultaneously. A 20-servo robot can pull 20 to 40 A peak even if it idles at 2 A. Size the supply and wiring for the worst-case simultaneous draw, or stagger startup.

War story: A biped that walked flawlessly on the bench started face-planting the instant it took its own weight. The firmware was blamed for a week: new gait, new IMU filter, new everything. The real culprit: at the gait's double-support phase every leg servo commanded torque at the same instant, the summed stall inrush dragged the shared 6 V rail below the microcontroller's brownout threshold for a few milliseconds, and the MCU reset mid-stride. On a scope the rail sag was obvious; in the logs it looked like random software chaos. The fix was a fatter supply, bulk capacitance at the servos, and staggering the leg commands by a few milliseconds. Lesson: when motion and "software" bugs correlate perfectly with load, reach for the oscilloscope before the debugger.

Bulk capacitance near the drive

Put bulk capacitors (hundreds to thousands of µF, plus ceramics for high-frequency) close to the servos/drive to supply transient current and absorb regenerative spikes. This is the single cheapest fix for brownout resets and bus over-voltage trips on deceleration.

Common grounds and noise

PWM signal lines pick up motor noise. Keep signal wires short, route them away from motor-power conductors, and on long runs use RS-485 (differential) rather than TTL. For smart serial buses, a clean common ground across all devices is mandatory: a floating ground on one servo corrupts the whole chain.

Rule: If a microcontroller "randomly reboots" when motors move, stop debugging the firmware. It's a brownout. Separate the rails and add capacitance first.

Connector and current rating

Hobby servo pigtails and JST/Molex connectors are rated for modest current. Don't daisy-chain power for a dozen high-torque servos through one thin connector: distribute power with a proper bus bar or power-distribution board rated for the aggregate stall current. Melted connectors are a real and common failure.

Frequently asked questions

What is the difference between a servo motor and a regular DC motor? A regular DC motor is open-loop: you apply voltage and it spins, with no idea of its position. A servo motor is that motor (or a brushless/AC one) plus a position sensor and a closed-loop controller that drives the shaft to a commanded position and holds it there, correcting for load and disturbance. The motor is one of three parts; the sensor and controller are what make it a servo.

Is a servo motor AC or DC? Both exist. Hobby and many smart serial servos use a brushed DC motor; high-end smart servos and most industrial servos use a brushless permanent-magnet machine. Industrial "AC servomotors" are three-phase PMSMs driven sinusoidally: electrically they're close cousins of what the drone world calls a BLDC motor.

How does the PWM signal control an RC servo's position? The signal is a pulse repeated about every 20 ms (~50 Hz). The pulse width encodes position: roughly 1000 µs drives one extreme, 1500 µs is center, and 2000 µs is the other extreme. The servo's control board compares that commanded position against its potentiometer feedback and drives the motor until they match. The duty cycle itself carries no power: it's a position code.

Why does my servo get hot or burn out when holding a load? Holding a static load still requires torque, which requires current, which makes heat (I²t) even though the shaft isn't moving. If the holding torque is near the servo's rated torque, or it's fighting a hard stop (stall), heat builds until the windings overheat or the magnets demagnetize. Size the servo for the holding torque, add a mechanical brake or counterbalance, or set a current limit.

What's the difference between analog and digital RC servos? The mechanics are often identical; the control board differs. Analog servos drive the motor only once per ~50 Hz input frame, giving softer holding torque and slower response. Digital servos re-drive the H-bridge at 300 Hz to 1 kHz+ regardless of input frame rate, giving faster response, a tighter deadband, and much stronger holding torque, at the cost of higher idle current and more heat.

What is stall torque and can I run a servo at it continuously? Stall torque is the maximum torque a servo produces at zero speed, at max voltage, for an instant. No, you cannot run there continuously; at stall the motor draws maximum current and converts all of it to heat, so it overheats fast. Size continuous operation on the rated (continuous) torque, and check your RMS torque over the duty cycle against it.

What is the inertia matching rule and why does it matter? Compare the load inertia reflected through the gearbox (load inertia divided by gear ratio squared) to the motor's rotor inertia. Keep the ratio roughly between 1:1 and 10:1 (about 5:1 is a comfortable target). Outside that band, especially above 10:1, the load dominates, drive-train compliance causes resonance, and the control loop becomes hard to tune without softening gains and losing bandwidth.

Can I use a Dynamixel servo for torque or force control? Yes. Dynamixel X and P series support current-control mode, where you command motor current directly (current is proportional to torque). They also offer current-based position control, where the servo moves to a target but caps torque. That makes compliant, force-aware, back-drivable joints possible without an expensive industrial drive, the main reason these dominate research arms and grippers.

How do I daisy-chain and address multiple smart servos? Each servo has two parallel connectors so you wire them in a line on one shared bus (TTL or, better for noise, RS-485). Every servo gets a unique ID (0 to 252) and a matching baud rate, set once via the bus. A host adapter (e.g. ROBOTIS U2D2 or an OpenRB board) acts as bus master, and Sync Write / Bulk Read packets command or read many servos in a single transaction at high update rates.

Why does my microcontroller reset when the servos move? Almost certainly a brownout. Servo inrush and stall current sag a shared power rail below the logic's reset threshold. Fix it with separate logic and motor power supplies sharing a common ground, bulk capacitance near the servos, and a supply sized for worst-case simultaneous stall current, not running current.

Metal gears or nylon gears, which should I choose? Metal (steel/titanium) gears for sustained high torque and durability, but they transmit shock straight into the motor and mounts. Nylon/Karbonite gears are cheaper, quieter, self-lubricating, and strip as a sacrificial fuse on overload: good crash protection for light loads. Pick metal when load is high and steady; pick nylon when impacts are likely and the gear failing first is preferable to the motor or chassis failing.

What does the torque constant Kt tell me? Kt (N·m/A) is how much torque the motor makes per amp of motor current: torque = Kt × current. In SI units it equals the back-EMF constant Ke (V·s/rad) numerically, so the same constant predicts both torque-from-current and speed-from-voltage. It lets you estimate current draw for a required torque and check it against your supply and current limit.