# PCA9685 servo driver: 16 channels over two I2C wires

> How the PCA9685 drives 16 servos over I2C: pulse counts at 50 Hz, separate servo power, addressing and Arduino code. India pricing and limits.

Canonical: https://roboticsengineering.in/components/pca9685-servo-driver/ | Published: 2026-10-27 | Updated: 2026-10-27

**The PCA9685 board solves one specific problem: an Arduino cannot produce sixteen clean 50 Hz servo signals while also doing anything else.** This ₹180–₹350 I2C board generates all sixteen in hardware, and the servo current never touches your microcontroller.

## Key specifications

| Channels | 16 |
| --- | --- |
| PWM resolution | 12-bit (4096 counts) |
| PWM frequency | 24 Hz to 1526 Hz |
| Default frequency for servos | 50 Hz |
| Bus | I2C, default address 0x40 |
| Address range | 0x40 to 0x7F, up to 62 boards |
| Logic supply | 2.3-5.5 V |
| Servo supply | separate V+ terminal, typically 4.8-6 V |
| Outputs | 220 ohm series resistors |
| Output enable | active low |
| Clock | internal 25 MHz oscillator |
| Size | about 62 x 25 mm |

**Substitute:** The Arduino Servo library for one or two servos, or a second PCA9685 for more channels.

## Why sixteen channels need a separate chip

An AVR-based Arduino has three hardware timers. The Servo library consumes one timer for every twelve servos it drives, and the pulses are interrupt-timed, so every servo you add costs the board some attention. At twelve servos on an Uno you are already near the practical limit, and the software PWM has visible jitter when the sketch also reads sensors or runs serial.

The PCA9685 is a 12-bit, 16-channel PWM controller. It runs its own 25 MHz clock, generates all sixteen outputs without CPU help, and only needs the microcontroller to write new pulse lengths over I2C. One update per servo is a handful of bytes; after that the chip keeps producing the same pulses indefinitely.

## Power wiring is the whole job

The board has two power inputs and they are not interchangeable. VCC powers the logic and takes 2.3–5.5 V, usually from the Arduino’s 5 V or 3.3 V pin. The screw terminal marked V+ feeds the servo rail, and every servo’s positive wire connects there. The ground of the servo supply, the board’s ground and the Arduino ground must all meet.

- **Do not feed servos from the Arduino 5 V pin.** Sixteen servos, or even four MG996Rs, will brown out the board. Use a separate 5–6 V supply sized for the stall current of every servo that can move at once.
- **Add a 1000 µF capacitor across V+ and GND** at the terminal. It absorbs the current spike at the start of each move.
- **Keep the servo supply within the servos’ rating.** The board passes V+ through; it does not regulate it. A 2S pack at 8.4 V will destroy 6 V servos.
- **Check the terminal rating.** The screw terminal and PCB traces are not rated for dozens of amps. For a large hexapod, split the servos across two supplies or two boards rather than pushing everything through one connector.

The [servo motor guide](https://roboticsengineering.in/servo-motor-with-arduino/) covers pulse widths and supply sizing for one servo; multiply those numbers by the channels you plan to move together.

## Pulse arithmetic

At 50 Hz the period is 20 ms. The PCA9685 divides that period into 4096 counts, so one count is 20 ms / 4096 = 4.88 µs. Servo pulse widths translate directly:

| Pulse | Counts at 50 Hz | Typical meaning |
| --- | --- | --- |
| 0.5 ms | 102 | Beyond the safe end on most servos |
| 1.0 ms | 205 | One end of travel |
| 1.5 ms | 307 | Centre |
| 2.0 ms | 410 | Other end of travel |
| 2.5 ms | 512 | Beyond the safe end on most servos |

Stay inside 205–410 counts until you have tested the actual servo. A cheap SG90 will often accept 150–500, while a metal-gear unit may grind against its internal stop at either extreme. The [servo buying guide](https://roboticsengineering.in/servo-buying-guide-sg90-mg90s-mg996r/) lists the family differences.

## Addresses and more than sixteen servos

The default I2C address is 0x40. Six solder jumpers labelled A0–A5 add 1, 2, 4, 8, 16 and 32 to that address, giving usable addresses from 0x40 to 0x7F — enough for 62 boards and 992 channels on one bus in theory. In practice, bus capacitance and wire length limit you long before that.

Each board also has an output-enable pin, active low. Most modules pull it low, so the outputs are enabled by default. Tie it to a GPIO only if you want a hardware kill switch for every servo at once — useful on an arm that can crush something.

## Code: sixteen servos in a few lines

The Adafruit PWM Servo Driver library is the shortest reliable route. It works on Uno, Nano, ESP32 and Pico with the same calls.

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

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

const uint16_t SERVO_MIN = 205;   // 1.0 ms
const uint16_t SERVO_MAX = 410;   // 2.0 ms

void setup() {
  pwm.begin();
  pwm.setPWMFreq(50);             // analog servos expect 50 Hz
}

void setAngle(uint8_t channel, uint8_t degrees) {
  degrees = constrain(degrees, 0, 180);
  uint16_t pulse = map(degrees, 0, 180, SERVO_MIN, SERVO_MAX);
  pwm.setPWM(channel, 0, pulse);
}

void loop() {
  setAngle(0, 0);
  delay(800);
  setAngle(0, 180);
  delay(800);
}
```

On an ESP32 the default I2C pins are GPIO 21 (SDA) and GPIO 22 (SCL); on an Uno they are A4 and A5. The [I2C, SPI and UART guide](https://roboticsengineering.in/i2c-spi-uart-robotics/) explains pull-ups, bus length and address conflicts.

## What the board will not fix

It does not increase servo torque, it does not give position feedback, and it does not make a weak supply strong. It also adds a failure point: if the I2C bus locks up, every servo holds its last pulse, which can be worse than stopping. For an arm, add a hardware enable on the OE pin or a relay on the servo supply.

For a single pan-tilt pair, the Servo library on the Arduino is simpler and needs no extra board. The PCA9685 earns its place at six channels and above: hexapods, 3-DOF and 4-DOF arms, animatronics and LED-plus-servo projects. The [3-DOF arm build](https://roboticsengineering.in/projects/arduino-robot-arm-3dof/) is a realistic first use.

## Common questions

**Can I power servos from the Arduino through the PCA9685?**

No. The board only passes V+ through to the servo headers. Supply V+ from a separate 5–6 V source sized for the combined stall current, with a common ground.

**Why do my servos jitter on the PCA9685?**

Usually supply sag or a missing capacitor. Add 1000 µF across V+ and GND, use a supply that can deliver the stall current, and keep servo wires away from motor leads. A poor ground connection causes the same symptom.

**What frequency should I set?**

50 Hz for ordinary analog servos. Digital servos often accept 200–333 Hz, but check the datasheet before raising it; a 50 Hz signal is always safe.

**How many PCA9685 boards can share one I2C bus?**

Up to 62 with the six address jumpers, giving 992 channels in theory. Real buses are limited by capacitance, wire length and the number of devices that respond reliably.

**Can I use it with a Raspberry Pi?**

Yes. It is a 3.3 V-compatible I2C device and works with the same Adafruit library or any PCA9685 Python driver.

Related: [SG90 servo](https://roboticsengineering.in/components/sg90-servo/), [MG996R servo](https://roboticsengineering.in/components/mg996r-servo/), [servo motor with Arduino](https://roboticsengineering.in/servo-motor-with-arduino/).

## Sources and further reading

- [NXP PCA9685 product page](https://www.nxp.com/products/power-management/lighting-driver-and-controller-ics/led-drivers/16-channel-12-bit-pwm-fm-plus-ic-bus-led-controller:PCA9685) — datasheet, PWM resolution and I2C addressing.
- [Adafruit 16-channel PWM servo driver guide](https://learn.adafruit.com/16-channel-pwm-servo-driver) — wiring, power and library usage.
- [Arduino Wire library](https://docs.arduino.cc/libraries/wire/) — I2C basics for the microcontroller side.

Last reviewed: October 2026. Figures describe the common PCA9685 breakout; board layouts and terminal ratings vary. Prices are Indian retail ranges. Not bench-tested by this site.

Driving a gripper from this board? The [gripper design guide](https://roboticsengineering.in/robot-gripper-design-basics/) converts servo torque into grip force and explains pad choice.