Micro servo motors are the unsung heroes of countless robotics, animatronics, and DIY automation projects. From precise camera gimbals to tiny robotic arms, these compact powerhouses deliver remarkable torque and speed in a package that fits on your fingertip. But anyone who has spent hours debugging a project only to discover their servo is twitching 5 degrees off target knows the painful truth: raw servos are rarely accurate out of the box.

Calibrating a micro servo motor—especially the popular SG90, MG90S, or SG92R variants—isn't just about making it spin to the right angle. It's about transforming a mass-produced, budget-friendly component into a precision instrument. In this guide, I'll walk you through the entire process, from understanding the physics of why servos drift to building your own calibration rig and writing firmware that compensates for mechanical imperfections.

Why Micro Servos Need Calibration

Before we dive into the "how," let's address the "why." Micro servos are fundamentally different from stepper motors or high-end industrial servos. They rely on a potentiometer feedback system combined with a small DC motor and a control board. The position is determined by comparing the input PWM (Pulse Width Modulation) signal with the voltage from the potentiometer wiper.

Here's where the problems start:

• Tolerance stack-up: The potentiometer itself has a tolerance of ±5% to ±10%. Two servos from the same batch can have different "center" positions for the same 1500µs pulse.
• Mechanical slop: The plastic gears in micro servos introduce backlash. When you command 90 degrees, the output shaft might stop at 88 or 92 degrees depending on the direction of approach.
• Temperature drift: As the servo warms up during operation, the internal resistance of the potentiometer changes, shifting the reference voltage.
• Power supply variance: Micro servos are notoriously sensitive to voltage drops. A 4.8V supply vs. a 6.0V supply can change the effective pulse range.

The result? Your robot arm picks up objects 3mm to the left, your pan-tilt camera drifts overnight, and your animatronic eye never quite looks where you want it to. Calibration fixes all of this.

Understanding the Pulse Width Range

Every micro servo has a theoretical operating range: typically 0° to 180°. This corresponds to a PWM pulse width, usually between 500µs and 2500µs. The center position (90°) is typically 1500µs.

But here's the kicker: these numbers are guidelines, not laws. A servo labeled "0° at 500µs" might actually hit its mechanical stop at 480µs or 530µs. Pushing beyond the real limits can damage the internal stopper or strip the gears.

The Standard vs. Extended Range

| Servo Model | Typical Min (µs) | Typical Center (µs) | Typical Max (µs) | Physical Range | |-------------|------------------|---------------------|------------------|----------------| | SG90 | 500 | 1500 | 2500 | ~0° to 180° | | MG90S | 600 | 1500 | 2400 | ~0° to 180° | | SG92R | 550 | 1500 | 2450 | ~0° to 180° | | TowerPro 9g | 500 | 1500 | 2500 | ~0° to 180° |

Notice the variation. A universal calibration routine that assumes 500-2500µs will work for most servos, but you'll never get true precision without individual tuning.

Tools You'll Need for Calibration

You don't need an oscilloscope or a laser interferometer. A basic setup will get you 95% of the way there. For the remaining 5%, we'll use a simple visual method.

Essential Hardware

• Arduino Uno (or any PWM-capable microcontroller): The brains of the operation.
• Breadboard and jumper wires: For quick connections.
• Micro servo (obviously): Start with the one you want to calibrate.
• External 5V power supply: Don't power the servo from the Arduino's 5V pin. Micro servos can draw 500mA to 1A under load, which will brown out your board. Use a separate 5V, 2A supply.
• 100µF capacitor: Solder or insert this across the servo's power terminals. It smooths out voltage spikes that cause jitter.
• Protractor or printed angle template: For visual measurement. A paper protractor taped to the servo horn works perfectly.
• Small screwdriver: For adjusting the potentiometer (if your servo has an external trim pot—most micro servos don't).

Optional but Recommended

• Logic analyzer: To verify PWM signal timing.
• Servo tester: A standalone device that lets you manually sweep the servo with a knob. Great for quick checks.
• Digital caliper: For measuring horn position with higher accuracy.

Step-by-Step Calibration Procedure

Let's get our hands dirty. I'll assume you're using an Arduino, but the same principles apply to Raspberry Pi Pico, ESP32, or any PWM-capable board.

Step 1: Establish a Baseline Connection

Connect your servo to the Arduino as follows: - Servo brown wire (ground) → Arduino GND (and external supply GND) - Servo red wire (power) → External 5V supply positive - Servo orange/yellow wire (signal) → Arduino pin 9 (PWM-capable)

Crucial: Connect the ground of the external supply to the Arduino's ground. Without a common ground, the control signal will float and the servo will behave erratically.

Upload this simple sweep sketch to verify basic operation:

cpp

include <Servo.h>

Servo myservo; int pos = 0;

void setup() { myservo.attach(9, 500, 2500); // Standard range }

void loop() { for (pos = 0; pos <= 180; pos += 1) { myservo.write(pos); delay(15); } for (pos = 180; pos >= 0; pos -= 1) { myservo.write(pos); delay(15); } }

If the servo sweeps smoothly from one end to the other, you're ready. If it buzzes, jitters, or stops prematurely, you have a power issue—check your supply and capacitor.

Step 2: Find the True Center

The center (90°) is the most critical point for most applications. It's where the servo has the most linear response and the least non-linearity.

1. Remove the servo horn (the plastic arm). You need to see the output shaft directly.
2. Command 90°: myservo.write(90);
3. Attach the horn so that it's as close to perfectly perpendicular to the servo body as possible. Tighten the screw.
4. Now, manually rotate the horn (gently) to feel the "dead zone." A properly centered servo will have equal resistance when you try to rotate it clockwise vs. counterclockwise.
5. Fine-tune with software: Adjust the write() value until the horn feels balanced. For example, if 90° feels off, try 88° or 92°. Record this value as your true center.

A typical SG90 might have a true center at 92° or 88°, not 90°. This is normal.

Step 3: Determine the Real Min and Max

Now we find the actual physical limits. We'll do this by gradually increasing the pulse width until the servo hits its mechanical stop, then backing off slightly.

Use this sketch to manually step through pulse widths:

cpp

include <Servo.h>

Servo myservo; int pulseWidth = 1500; // Start at center

void setup() { myservo.attach(9); Serial.begin(9600); Serial.println("Enter pulse width in microseconds (500-2500):"); }

void loop() { if (Serial.available() > 0) { pulseWidth = Serial.parseInt(); if (pulseWidth > 0) { myservo.writeMicroseconds(pulseWidth); Serial.print("Pulse: "); Serial.println(pulseWidth); } } }

Open the Serial Monitor. Start at 1500µs, then gradually decrease the value in steps of 10µs. At some point—say, 520µs—the servo will stop moving further and you'll hear a faint buzzing or clicking sound. This is the mechanical stop. Back off by 20µs (increase to 540µs). This is your safe minimum.

Repeat for the maximum: increase from 1500µs until you hit the stop, then back off by 20µs.

Write down these three values: - Min_pulse (e.g., 540µs) - Center_pulse (e.g., 1500µs, but you'll adjust it in the next step) - Max_pulse (e.g., 2460µs)

Step 4: Map Angles to Pulses

Now we have the raw pulse range. But we want to map this to a clean 0° to 180° range. This is where the magic happens.

The mapping is linear:

angle = (pulse - min_pulse) * 180 / (max_pulse - min_pulse)

Or in reverse:

pulse = min_pulse + (angle * (max_pulse - min_pulse) / 180)

But wait—this assumes the servo's response is perfectly linear. It's not. The potentiometer's resistance curve introduces a slight S-shaped distortion. To correct this, we need to measure at intermediate points.

Step 5: Build a Calibration Table (The Advanced Method)

For the highest accuracy, create a lookup table with 10-20 calibration points. Here's the process:

1. Print a protractor or use a digital angle gauge attached to the servo horn.
2. Command the servo to a known angle (e.g., 0°, 10°, 20°, ... up to 180°).
3. Measure the actual angle using the protractor.
4. Record the error: error = actual - commanded.

After collecting all 19 data points (0°, 10°, 20°, ..., 180°), you'll have a correction curve. For example:

| Commanded (°) | Actual (°) | Error (°) | |---------------|------------|-----------| | 0 | 2 | +2 | | 10 | 11 | +1 | | 20 | 21 | +1 | | 30 | 30 | 0 | | 40 | 39 | -1 | | 50 | 48 | -2 | | ... | ... | ... | | 180 | 178 | -2 |

To correct this, you invert the error. When the user commands 0°, you actually send a pulse corresponding to -2° (which might be 520µs instead of 540µs). This compensates for the mechanical offset.

Step 6: Implement the Correction in Firmware

Here's a complete Arduino sketch that uses a calibration table:

cpp

include <Servo.h>

Servo myservo;

// Calibration data: commanded angle -> corrected pulse width const int numPoints = 19; const int commandedAngles[numPoints] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180}; const int correctedPulses[numPoints] = {520, 620, 720, 820, 920, 1020, 1120, 1220, 1320, 1420, 1520, 1620, 1720, 1820, 1920, 2020, 2120, 2220, 2320};

void setup() { myservo.attach(9); Serial.begin(9600); }

void loop() { if (Serial.available() > 0) { int targetAngle = Serial.parseInt(); if (targetAngle >= 0 && targetAngle <= 180) { int pulse = interpolatePulse(targetAngle); myservo.writeMicroseconds(pulse); Serial.print("Moving to angle: "); Serial.print(targetAngle); Serial.print(" with pulse: "); Serial.println(pulse); } } }

int interpolatePulse(int angle) { // Linear interpolation between calibration points for (int i = 0; i < numPoints - 1; i++) { if (angle >= commandedAngles[i] && angle <= commandedAngles[i+1]) { float t = (float)(angle - commandedAngles[i]) / (commandedAngles[i+1] - commandedAngles[i]); return correctedPulses[i] + t * (correctedPulses[i+1] - correctedPulses[i]); } } return correctedPulses[numPoints - 1]; // Fallback }

This approach gives you ±1° accuracy on a standard SG90, which is remarkable for a $3 servo.

Advanced Calibration Techniques

Deadband Compensation

Micro servos have a deadband—a small range of pulse widths where the motor doesn't move because the error signal is too small to overcome static friction. Typically 4-8µs. To compensate, when your target angle is within the deadband of the current position, you can either do nothing (saves power) or apply a small overshoot then return.

Backlash Correction

When approaching an angle from different directions, the servo will land at slightly different positions due to gear slop. The solution: always approach from the same direction. In your firmware, when moving to a new angle, first move 5° past the target, then come back. This preloads the gears in a consistent direction.

Temperature Compensation

If your servo operates in varying temperatures (e.g., outdoor drone gimbal), you can add a temperature sensor (like a DS18B20) and adjust the pulse range based on a coefficient. A typical rule of thumb: for every 10°C increase, add 0.5µs to the minimum pulse and subtract 0.5µs from the maximum. This is coarse but effective.

Common Calibration Pitfalls

Mistake 1: Calibrating Without Load

A servo behaves differently under load. The friction from a robot arm or camera adds resistance that changes the effective position. Always calibrate with the expected load attached.

Mistake 2: Ignoring Power Supply Ripple

If your power supply has ripple (common with cheap USB adapters), the servo's internal comparator will oscillate, causing jitter. Use a linear regulator or add a 1000µF capacitor instead of 100µF.

Mistake 3: Using write() Instead of writeMicroseconds()

The write() function in the Arduino Servo library converts an angle to a pulse width using a hardcoded range (typically 544-2400µs). This bypasses your calibration. Always use writeMicroseconds() for precise control.

Mistake 4: Forgetting to Detach the Servo When Not in Use

If you leave a servo attached but idle, it will continue to draw power and maintain position. This heats up the motor and drifts the potentiometer. Use myservo.detach() when the servo is not moving.

Real-World Example: Calibrating a Pan-Tilt Camera Gimbal

Let's tie everything together with a practical scenario. You're building a pan-tilt gimbal for a small camera (like a Raspberry Pi Camera Module). You have two MG90S servos.

1. Calibrate each servo individually using the table method above. Record the min, center, and max pulses for pan and tilt.
2. Mount the servos and attach the camera.
3. Write a calibration routine that runs at startup: the gimbal sweeps to 0°, 90°, and 180° while you visually verify the camera's alignment. If it's off, you adjust the calibration table via a serial command.
4. Add backlash compensation: When the camera needs to move from 45° to 50°, first command 55°, then 50°. This ensures the gears are always loaded in the same direction.
5. Test under load: Point the camera at a grid pattern and verify that a 10° command actually moves the image by 10° on the grid. Adjust the calibration table if needed.

After this process, your gimbal will track objects with sub-degree accuracy, even with cheap servos.

When Calibration Isn't Enough

Sometimes, no amount of software calibration can fix a bad servo. Here are the signs that you need a replacement:

• The servo doesn't respond to pulse widths below 600µs or above 2400µs (indicates a damaged potentiometer).
• The servo oscillates continuously (hunting) even when stationary (bad control board).
• The output shaft has more than 5° of play (worn gears).

In these cases, don't waste time. A new SG90 costs less than $5. Replace it and calibrate the new one.

Automating the Calibration Process

If you're calibrating multiple servos (e.g., for a production run of robot arms), manual measurement becomes tedious. Here's how to automate:

1. Use a magnetic rotary encoder (like an AS5600) attached to the servo output shaft. This gives you digital feedback of the actual position.
2. Write a script that commands the servo to 0°, reads the encoder, commands 10°, reads the encoder, and so on. The script automatically generates the calibration table.
3. Store the table in EEPROM on the microcontroller, so each servo carries its own calibration data.

This reduces calibration time from 15 minutes per servo to 30 seconds.

Final Thoughts on Micro Servo Calibration

Calibrating a micro servo motor isn't a one-time fix—it's a mindset. Every time you change the load, the power supply, or the operating temperature, the calibration shifts. The best approach is to build calibration into your firmware from the start, with the ability to adjust parameters on the fly.

Remember: a calibrated $3 servo outperforms an uncalibrated $30 servo in precision. The difference isn't in the hardware—it's in the care you take to understand and compensate for its imperfections.

Now go calibrate your servos. Your robot will thank you.