PCA9685 16-Channel PWM Driver

Qué es

El PCA9685 es un multiplicador de servos. Un microcontrolador solo tiene unos pocos canales de PWM por hardware, así que manejar los seis servos de un brazo robótico —y ya no digamos los dieciocho de un hexápodo— agota enseguida sus pines y temporizadores. Esta plaquita asume ese trabajo: genera 16 señales PWM independientes por hardware, y tú comandas todas ellas por dos hilos de I²C. Es la placa que hay detrás de la mayoría de los robots con varios servos.

Cómo funciona

Hablas con el PCA9685 por I²C, y los mismos dos pines (SCL/SDA) pueden llevar además otros sensores. Fijas una frecuencia PWM para todo el chip (50 Hz para servos de afición), y luego fijas la anchura de pulso de cada canal para posicionar su servo. Como el chip mantiene las 16 señales por hardware, el microcontrolador solo envía «canal 3 → 1,5 ms» y sigue adelante; nunca tiene que generar los tiempos a mano. Eso es lo que mantiene suave cada servo incluso cuando los dieciséis se mueven a la vez. La idea de convertir anchura de pulso en ángulo es la misma que cubre la página del servo SG90.

Cuándo usarlo

Recurre a un PCA9685 siempre que un robot tenga más servos de los que el microcontrolador tiene pines PWM, o cuando quieras los servos perfectamente estables:

• Brazos robóticos: varios servos de articulación moviéndose a la vez (combínalo con cinemática inversa).
• Hexápodos y cuadrúpedos: los servos de una docena de patas o más.
• Soportes de cabeza y cámara: libera los temporizadores del microcontrolador para otros menesteres.

Para un único servo de barrido —como el escáner ultrasónico de un esquivador de obstáculos— no lo necesitas; el microcontrolador puede manejar un servo directamente.

Cableado y errores comunes

• Dos rieles de alimentación. Lógica (VCC) desde el microcontrolador; alimentación de servos desde el terminal V+. Nunca pases la corriente de 16 servos por los 5 V del Arduino.
• Dimensiona V+ para el bloqueo, no para el reposo. Dieciséis servos pueden absorber varios amperios juntos; una alimentación corta de caudal se desploma y toda la placa vibra.
• Direcciones únicas al encadenar placas, con los jumpers de soldadura.
• Añade un condensador en paralelo con V+ para absorber los picos de corriente al arrancar los servos.

Patillaje

Tres grupos de conexiones: una cabecera de control que cableas al microcontrolador, dieciséis cabeceras de servo, y un terminal de alimentación que no debe confundirse con el primero.

El hecho más consecuente de esta placa es que VCC y V+ son rieles distintos. VCC alimenta el chip; V+ alimenta los servos. Puentearlos mete la corriente de bloqueo de los servos por el regulador del microcontrolador, que es la forma más rápida de dejar sin tensión a un Arduino.

Cablearlo a un Arduino

OE es más útil de lo que parece. Ponerlo en alto deshabilita las dieciséis salidas por hardware, al instante, sin ninguna transacción I²C. En un brazo que puede caer por la gravedad eso es una parada de emergencia de verdad, y funciona incluso si tu código se ha quedado colgado.

Dimensionar la alimentación de servos

Aquí es donde la mayoría de los proyectos con PCA9685 se equivocan, y la aritmética no es difícil.

Un servo de hobby absorbe aproximadamente:

Cuatro SG90 en un brazo pequeño, todos moviéndose a la vez, son cómodamente 1 A y pueden alcanzar picos de cerca de 2,6 A si se bloquean todos juntos, que es exactamente lo que pasa cuando el brazo choca contra su propio bastidor. Un cargador de móvil de 1 A no va a servir. Dimensiona para todos tus servos bloqueándose a la vez, o al menos para todos moviéndose más uno bloqueado.

El síntoma de una alimentación corta de caudal es característico y confuso: los servos vibran, la placa puede reiniciarse, y parece un problema de I²C o de código. No lo es. Pon un multímetro en V+ mientras se mueve el brazo y observa cómo se hunde.

Añade un condensador en paralelo con V+. Algo en el rango de 470–1000 µF, cerca del terminal. No puede transportar un bloqueo sostenido: un condensador de 1000 µF suministrando 1 A pierde un voltio cada milisegundo, pero sí absorbe el pico brusco de corriente del instante en que arranca un servo, que es lo que se acopla al riel lógico.

Cómo se genera realmente el PWM

Entender dos números de aquí hace que cualquier problema de controlador de servos sea más fácil de diagnosticar.

El chip funciona con un oscilador interno de 25 MHz y lo divide con un preescalador:

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

Para los 50 Hz que quieren los servos de hobby, eso es round(25000000 / 204800) - 1 = 121.

Cada periodo se divide después en 4096 pasos (12 bits). A 50 Hz el periodo es de 20 ms, así que un paso es 20 ms / 4096 = 4,88 µs. Eso convierte las anchuras de pulso que realmente te importan en las cuentas que escribes:

De aquí se derivan dos consecuencias. Primero, obtienes unas 205 cuentas en los 180° completos de un servo, que es apenas una cuenta por grado: la resolución de 12 bits del PCA9685 no es el factor limitante en un servo de hobby, lo es la zona muerta del propio servo. Segundo, el preescalador solo se puede escribir mientras el chip está en modo de reposo, y por eso todas las bibliotecas conmutan MODE1 alrededor de un cambio de frecuencia.

El oscilador no es exactamente 25 MHz

Las placas reales se desvían unos pocos puntos porcentuales del valor nominal, y lo hacen de forma consistente por placa. Si tus servos se quedan sistemáticamente cortos de su ángulo comandado en los dos extremos, la solución no es maquillar las anchuras de pulso: es medir y corregir el reloj:

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

Mídelo mandando 50 Hz, poniendo un osciloscopio o un analizador lógico en cualquier salida, y leyendo el periodo real. Escala los 25 MHz nominales por el cociente entre la frecuencia comandada y la medida. Hazlo una vez por placa y escribe el número en un comentario.

Código mínimo funcional

#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);
  }
}

Las constantes SERVO_MIN/SERVO_MAX son la calibración, y varían por servo, incluso entre dos del mismo modelo de la misma bolsa. Encuéntralas avanzando poco a poco hacia fuera desde 307 y parando en el momento en que el servo zumbe sin moverse, lo que significa que está empujando contra su propio tope final y absorbiendo corriente de bloqueo para nada.

Fíjate también en el barrido en lugar del salto. setPWM cambia la posición comandada al instante, y el servo lo intentará a máxima velocidad, lo que en un brazo robótico significa un movimiento violento y un pico de corriente. Convertir el comando en pasos es el perfil de movimiento del hombre pobre, y merece la pena hacerlo incluso en código de prueba.

Encadenar placas

Cada placa tiene seis pads de soldadura, A0 a A5, que dan 64 direcciones desde 0x40. Pon una combinación distinta en cada placa:

62 placas es el máximo documentado: 0x70 está reservada para la dirección de llamada general de I²C, y por eso no son las 64 completas. En la práctica el límite llega mucho antes: 62 placas son 992 servos, y la alimentación para eso es un problema de ingeniería bastante mayor que el bus.

Una cosa a la que vigilar al encadenar: cada placa lleva sus propios pull-ups de I²C de 10 kΩ, y se ponen en paralelo. Diez placas dan 1 kΩ, que ya es carga pesada para un bus de 5 V. A partir de un puñado de placas, corta los jumpers de pull-up en todas menos una.

Resolución de problemas

¿PCA9685 o PWM directo del microcontrolador?

El umbral honesto: uno o dos servos, manéjalos directamente. Una cabeza de sensor de barrido en un esquivador de obstáculos no necesita esta placa. Tres o más, o cualquier servo cuya suavidad importe, y el PCA9685 se amortiza de inmediato: no por el número de pines, sino porque el microcontrolador deja de ser responsable de los tiempos. Un servo manejado con la biblioteca Servo se sacudirá cada vez que tu bucle se atasque; uno manejado con un PCA9685 no.