What Is a Servo? Sizing, Wiring, and ESP32 Control Guide

A servo (or servo motor) is a closed-loop rotary or linear actuator that uses positional feedback to precisely control angular position, velocity, and acceleration. Unlike open-loop motors that blindly step or spin when voltage is applied, a servo continuously monitors its output shaft via an internal potentiometer or optical encoder. It compares this actual position to the commanded position and adjusts its internal H-bridge drive to eliminate any error. If you are building a robotic arm, a camera gimbal, or an automated valve controller, understanding what is a servo and how it differs from other motor types is the critical first step before writing a single line of code.

The Core Mechanics and Control Loop

Inside a standard hobby servo (like the ubiquitous SG90 or MG996R), you will find three main components: a brushed DC motor, a gear train, and a feedback potentiometer. The control circuitry reads the voltage from the potentiometer wiper, which changes as the output shaft rotates. An internal error amplifier compares this voltage to the incoming PWM (Pulse Width Modulation) signal from your microcontroller. If the shaft is not at the target angle, the amplifier drives the DC motor in the correct direction until the error reaches zero.

Industrial AC servos (like those from Yaskawa or Delta) replace the brushed DC motor and potentiometer with a 3-phase brushless motor and high-resolution optical encoders, but the fundamental closed-loop principle remains identical. The drive demands a target position and uses complex PID (Proportional-Integral-Derivative) tuning to move the load smoothly without overshooting.

Motor Type Comparison: Servo vs. Stepper vs. Brushless DC

A common mistake in embedded design is treating steppers and servos as interchangeable. They are not. Steppers excel at holding torque at zero speed but lose torque rapidly as speed increases. Servos maintain high torque across their entire speed range but require more complex control. Below is a direct comparison to help you select the right actuator for your load profile.

Sizing Rule of Thumb and Worked Load Example

Never size a motor based purely on the static weight of your load. You must account for dynamic forces, acceleration, and mechanical inefficiencies. The golden rule of thumb for servo sizing is to calculate the maximum required holding torque at the joint, then multiply by a safety factor of 2.0 to 2.5.

Worked Load Example: Robotic Arm Joint

Imagine you are designing the shoulder joint for a small robotic arm. The arm segment is 20 cm (0.2 m) long, and it needs to lift a payload of 500 g (0.5 kg) at maximum extension. The arm itself weighs 200 g (0.2 kg), with its center of mass at 10 cm (0.1 m).

1. Calculate Payload Torque: Force = mass × gravity = 0.5 kg × 9.81 m/s² = 4.9 N. Torque = 4.9 N × 0.2 m = 0.98 Nm.
2. Calculate Arm Torque: Force = 0.2 kg × 9.81 m/s² = 1.96 N. Torque = 1.96 N × 0.1 m = 0.196 Nm.
3. Total Static Torque: 0.98 + 0.196 = 1.176 Nm.
4. Convert to kg-cm: 1.176 Nm / 0.09806 ≈ 12 kg-cm.
5. Apply Safety Factor (2.5x): 12 kg-cm × 2.5 = 30 kg-cm.

Selection: You need a servo rated for at least 30 kg-cm at your operating voltage. A standard MG996R (13 kg-cm) will immediately stall and overheat. You should select a high-torque digital servo like the DS3218 (25kg-cm) if you can reduce the arm length slightly, or step up to a LewanSoul LX-16A bus servo (17kg-cm) and use a counterweight, or move to a NEMA 17 stepper with a 50:1 planetary gearbox for this specific joint.

Wiring, Terminals, and ESP32 Integration

Hobby servos use a standardized 3-pin JR or Futaba connector. Industrial servos use high-density D-sub or aviation connectors. For embedded prototyping, you will almost exclusively deal with the 3-pin hobby standard.

What Driver or Controller Does a Servo Demand?

Hobby servos demand a 50Hz PWM signal where the pulse width (typically 1000µs to 2000µs) dictates the angle. The ESP32 handles this natively using its LEDC (LED Control) or MCPWM peripherals via the ESP32Servo library. You do not need an external motor driver board for hobby servos; the microcontroller drives the signal wire directly, while the external power supply drives the motor.

Industrial AC servos, however, demand a dedicated servo drive (amplifier). The ESP32 cannot drive an industrial servo directly. You would need to output high-speed step/direction pulses to the drive's opto-isolated inputs, or communicate via an industrial bus like CANopen or RS-485 Modbus.

Failure Signatures: Hum, Overheat, and Stall

When debugging servo circuits, listen and feel for these specific failure modes:

• Humming / Jittering: The servo vibrates in place without moving to the target. This is almost always caused by a noisy PWM signal, a ground loop, or insufficient current from the power supply causing voltage ripple. Fix: Add a 470µF electrolytic capacitor across the servo VCC and GND, and ensure thick ground wires.
• Overheating: The casing is too hot to touch. This happens when the servo is commanded to a position it cannot physically reach (binding linkage), causing it to draw continuous stall current. Fix: Check mechanical limits and implement a software timeout to detach the servo after reaching the target.
• Stalling / Brownout: The servo stops moving, and the ESP32 randomly reboots. This occurs when a large servo draws peak stall current (often 2A to 5A), dragging the shared power rail voltage down below the ESP32's brownout threshold (usually ~2.4V on the 3.3V rail). Fix: Use completely separate power supplies for the logic and the motors, tied only at a single star-ground point.

ESP32 Servo Control Code

Below is a complete, copy-pasteable ESP32 sketch using the ESP32Servo library. It includes pin definitions and a detach sequence to prevent idle jitter and overheating.

#include <ESP32Servo.h>

// Pin Definitions
const int SERVO_PIN = 13;
const int MIN_US = 500;   // Minimum pulse width in microseconds
const int MAX_US = 2500;  // Maximum pulse width in microseconds

Servo myServo;

void setup() {
  Serial.begin(115200);
  
  // Allow allocation of all timers
  ESP32PWM::allocateTimer(0);
  ESP32PWM::allocateTimer(1);
  ESP32PWM::allocateTimer(2);
  ESP32PWM::allocateTimer(3);
  
  // Attach servo with specific pulse width limits
  myServo.setPeriodHertz(50); // Standard 50Hz servo
  myServo.attach(SERVO_PIN, MIN_US, MAX_US);
  
  Serial.println("Servo attached. Starting sweep...");
}

void loop() {
  // Sweep from 0 to 180 degrees
  for (int pos = 0; pos <= 180; pos += 1) {
    myServo.write(pos);
    delay(15); // Wait 15ms between steps for smooth motion
  }
  
  delay(1000); // Hold at 180 for 1 second
  
  // Sweep back to 0
  for (int pos = 180; pos >= 0; pos -= 1) {
    myServo.write(pos);
    delay(15);
  }
  
  // CRITICAL: Detach servo when idle to prevent jitter and overheat
  myServo.detach();
  Serial.println("Servo detached to save power and prevent heat.");
  
  delay(5000); // Wait 5 seconds before re-attaching for next cycle
  myServo.attach(SERVO_PIN, MIN_US, MAX_US);
}

Reference: For deeper understanding of the ESP32's underlying PWM hardware used by this library, consult the official Espressif LEDC API documentation.