PCA9685 Servo Driver

What it is

The PCA9685 is a servo multiplier. A microcontroller has only a handful of hardware PWM channels, so driving a robot arm’s six servos—let alone a hexapod’s eighteen—quickly runs it out of pins and timers. This little board takes that job over: it generates 16 independent PWM signals in hardware, and you command all of them over two I²C wires. It’s the board behind most multi-servo robots.

How it works

You talk to the PCA9685 over I²C—the same two pins (SCL/SDA) can also carry other sensors. You set one PWM frequency for the whole chip (50 Hz for hobby servos), then set each channel’s pulse width to position its servo. Because the chip holds all 16 signals in hardware, the microcontroller just sends “channel 3 → 1.5 ms” and moves on; it never has to bit-bang the timing itself. That’s what keeps every servo smooth even when all 16 are moving. The pulse-width-to-angle idea is the same one covered on the SG90 servo page.

When to use it

Reach for a PCA9685 whenever a robot has more servos than the microcontroller has PWM pins, or when you want the servos rock-steady:

• Robot arms — several joint servos moving together (pair it with inverse kinematics).
• Hexapods / quadrupeds — a dozen or more legs’ worth of servos.
• Pan-tilt and camera rigs — freeing the microcontroller’s timers for other work.

For a single scanning servo—like the ultrasonic scanner on an obstacle-avoider—you don’t need it; the microcontroller can drive one servo directly.

Wiring and gotchas

• Two power rails. Logic (VCC) from the microcontroller; servo power from the V+ terminal. Never run 16 servos’ current through the Arduino’s 5 V.
• Size V+ for stall, not idle. Sixteen servos can pull several amps together; an undersized supply sags and the whole board jitters.
• Set unique addresses when chaining boards, via the solder jumpers.
• Add a capacitor across V+ to absorb the current spikes as servos start moving.

Pinout

Three groups of connections: a control header you wire to the microcontroller, sixteen servo headers, and a power terminal that must not be confused with the first one.

The single most consequential fact on this board is that VCC and V+ are different rails. VCC runs the chip; V+ runs the servos. Bridging them puts servo stall current through the microcontroller’s regulator, which is the fastest way to brown out an Arduino.

Wiring it to an Arduino

OE is more useful than it looks. Pulling it high disables all sixteen outputs in hardware, instantly, without an I²C transaction. On an arm that can drop under gravity that is a real emergency stop, and it works even if your code has hung.

Sizing the servo supply

This is where most PCA9685 projects go wrong, and the arithmetic is not hard.

A hobby servo draws roughly:

Four SG90s on a small arm, all moving at once, is comfortably 1 A and can peak near 2.6 A if they all stall together — which is exactly what happens when the arm hits its own frame. A 1 A phone charger will not do it. Size for all your servos stalling simultaneously, or at minimum for all of them moving plus one stalled.

The symptom of an undersized supply is distinctive and confusing: the servos jitter, the board may reset, and it looks like an I²C or code problem. It is not. Put a meter on V+ while the arm moves and watch it sag.

Add a capacitor across V+. Something in the 470–1000 µF range, close to the terminal. It cannot carry a sustained stall — a 1000 µF cap supplying 1 A drops a volt every millisecond — but it does absorb the sharp current spike at the instant a servo starts, which is what couples into the logic rail.

How the PWM is actually generated

Understanding two numbers here makes every servo-driver problem easier to diagnose.

The chip runs from an internal 25 MHz oscillator and divides it down with a prescaler:

prescale = round(25000000 / (4096 x frequency)) - 1

For the 50 Hz hobby servos want, that is round(25000000 / 204800) - 1 = 121.

Each period is then divided into 4096 steps (12-bit). At 50 Hz the period is 20 ms, so one step is 20 ms / 4096 = 4.88 µs. That converts the servo pulse widths you actually care about into the counts you write:

Two consequences fall straight out of this. First, you get about 205 counts across a servo’s full 180°, which is just under one count per degree — the PCA9685’s 12-bit resolution is not the limiting factor on a hobby servo, the servo’s own deadband is. Second, the prescaler can only be written while the chip is in sleep mode, which is why every library toggles MODE1 around a frequency change.

The oscillator is not exactly 25 MHz

Real boards run a few percent off nominal, and it is consistent per board. If your servos are systematically short of their commanded angle at both ends, the fix is not to fudge the pulse widths — it is to measure and correct the clock:

pwm.begin();
pwm.setOscillatorFrequency(26075000);  // measured, not the 25 MHz nominal
pwm.setPWMFreq(50);

Measure it by commanding 50 Hz, putting a scope or a logic analyser on any output, and reading the true period. Scale the nominal 25 MHz by the ratio of commanded to measured frequency. Do this once per board and write the number in a comment.

Minimal working code

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

// Per-servo calibration. These are NOT universal — measure your own.
const int SERVO_MIN = 150;   // counts at one end stop
const int SERVO_MAX = 600;   // counts at the other

int countsFor(int degrees) {
  return map(constrain(degrees, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
}

void setup() {
  pwm.begin();
  pwm.setOscillatorFrequency(25000000);  // replace with your measured value
  pwm.setPWMFreq(50);                    // hobby servos want 50 Hz
  delay(10);
}

void loop() {
  for (int a = 0; a <= 180; a += 5) {    // sweep, don't jump
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
  for (int a = 180; a >= 0; a -= 5) {
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
}

The SERVO_MIN/SERVO_MAX constants are the calibration, and they differ per servo — even between two of the same model from the same bag. Find them by stepping slowly outward from 307 and stopping the moment the servo buzzes without moving, which means it is pushing against its own end stop and drawing stall current for nothing.

Note also the sweep rather than a jump. setPWM changes the commanded position instantly, and the servo will attempt it at full speed — which on an arm means a violent movement and a current spike. Stepping the command is the poor man’s motion profile, and it is worth doing even in test code.

Chaining boards

Each board has six solder pads, A0 to A5, giving 64 addresses from 0x40. Bridge a different combination on each board:

62 boards is the documented maximum — 0x70 is reserved for the I²C general-call address, which is why it is not the full 64. In practice the limit arrives far sooner: 62 boards is 992 servos, and the power supply for that is a much larger engineering problem than the bus.

One thing to watch when chaining: every board carries its own 10 kΩ I²C pull-ups, and they parallel. Ten boards gives 1 kΩ, which is getting heavy for a 5 V bus. Past a handful of boards, cut the pull-up jumpers on all but one.

Troubleshooting

PCA9685 or direct microcontroller PWM?

The honest threshold: one or two servos, drive them directly. A scanning sensor head on an obstacle-avoider does not need this board. Three or more, or any servo whose smoothness matters, and the PCA9685 pays for itself immediately — not because of the pin count, but because the microcontroller stops being responsible for timing. A servo driven by the Servo library will twitch whenever your loop stalls; one driven by a PCA9685 will not.