Controlador de servos PCA9685 con Arduino: guía de 16 canales
PCA9685 con Arduino: conexión I2C (0x40), alimentación externa para servos, calibración del pulso y encadenado de placas con código de brazo robótico y araña.
El PCA9685 es una placa controladora PWM de 12 bits que puede mover 16 servomotores a la vez e independientes entre sí usando un solo bus I2C. En el Arduino Uno la biblioteca Servo gestiona como máximo 12 servos y, además, ocupa por completo un temporizador: se acaban los pines y los servos empiezan a temblar. El PCA9685, en cambio, genera los pulsos con su propio oscilador interno y a tu microcontrolador solo le queda decir "pon este canal en esta posición". Verás esta placa en casi todos los proyectos con muchas articulaciones: brazos robóticos, robots araña, ojos animatrónicos o soportes de cámara pan-tilt.
En esta guía aprenderás a conectar el PCA9685 con Arduino, por qué tienes que alimentar los servos con una fuente aparte, cómo calibrar el ancho de pulso para encontrar los valores reales de 0 y 180 grados de cada servo y cómo se encadenan las placas con los puentes de dirección. Después escribiremos un robot araña de 18 servos con dos placas, un brazo robótico controlado con potenciómetros en el ESP32 y un controlador en MicroPython sin bibliotecas para la Raspberry Pi Pico. Si no conoces bien el funcionamiento básico de los servos, empieza por ¿Qué es un servomotor?.

¿Qué es el PCA9685 y cómo funciona?
El PCA9685 es en realidad un chip de NXP diseñado para controlar LEDs, pero como su frecuencia es ajustable funciona perfectamente con servos. Lleva un oscilador de 25 MHz y un contador de 12 bits compartido por todos los canales; el periodo PWM se divide en 4096 pasos (ticks). A cada canal le escribes dos números: el paso en que la señal sube (ON) y el paso en que baja (OFF). Para servos se elige una frecuencia de 50 Hz, es decir, un periodo de 20 ms. Cada paso dura 20 ms / 4096 ≈ 4,88 µs, así que para convertir un ancho de pulso en pasos usas tick = pulso (µs) / 4,88. Por ejemplo, el pulso de posición central de 1,5 ms equivale a 1500 / 4,88 ≈ 307 pasos. Una vez configurado el canal, la placa sigue generando la señal por sí sola; el servo se queda quieto aunque el Arduino esté ocupado con otras tareas.
| Característica | Valor |
|---|---|
| Chip | NXP PCA9685 |
| Número de canales | 16 salidas PWM independientes |
| Resolución | 12 bits (4096 pasos por periodo) |
| Frecuencia PWM | Aprox. 24–1526 Hz (50 Hz para servos) |
| Comunicación | I2C, hasta 1 MHz |
| Dirección por defecto | 0x40 (0x40–0x7F con los puentes A0–A5) |
| Alimentación lógica (VCC) | 2,3–5,5 V |
| Alimentación de servos (V+) | Externa, normalmente 5–6 V según el servo |
| Corriente de salida | 25 mA de sumidero y 10 mA de fuente por canal (solo para la señal) |
| En la placa | En la mayoría de módulos, resistencias pull-up en SDA/SCL y 220 Ω en serie en las salidas |
| Ancho de pulso | Pasos (ticks) a 50 Hz | Posición típica del servo |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Aprox. 0° en el SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | 0° estándar (servos de rango estrecho) |
| 1,5 ms (1500 µs) | ≈ 307 | Posición central (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | 180° estándar |
| 2,4 ms (2400 µs) | ≈ 492 | Aprox. 180° en el SG90 |
Conexión del PCA9685: Arduino Uno, ESP32 y Pico
| Pin del PCA9685 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (lógica) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Déjalo libre (en la placa está a GND) | Déjalo libre | Déjalo libre |
| V+ (borne de tornillo) | Positivo de la fuente externa de 5–6 V | Positivo de la fuente externa de 5–6 V | Positivo de la fuente externa de 5–6 V |
| GND (borne de tornillo) | Negativo de la fuente externa (unido al GND de la placa) | Negativo de la fuente externa (unido al GND de la placa) | Negativo de la fuente externa (unido al GND de la placa) |
Alimentación externa: ¿cuánta corriente consumen los servos?
Un servo en reposo consume solo 5–10 mA, pero al moverse, y sobre todo al forzar bajo carga (stall), la corriente se dispara. Un SG90 forzado puede llegar a 600–700 mA y un MG996R a más de 2 A. Cuando todas las articulaciones de un brazo empiezan a moverse a la vez, estos picos se suman y la tensión de una fuente débil cae; el resultado son servos que tiemblan, saltan al azar y un Arduino que se reinicia. La regla práctica: multiplica el número de servos que se moverán a la vez por la corriente de pico y elige una fuente que pueda dar de forma continua al menos la mitad de ese valor. Para un brazo de seis SG90 sirve un adaptador de 5 V y 3 A; para una araña de 18 servos, una fuente de 5–6 V y 8–10 A o un UBEC potente de los que se usan en radiocontrol.
| Servo | En reposo | En movimiento | Forzado (stall) | Alimentación |
|---|---|---|---|---|
| SG90 (9 g, engranaje de plástico) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (engranaje metálico) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (tamaño estándar) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Primera puesta en marcha paso a paso: mueve 4 servos a la vez
- Abre el Gestor de bibliotecas del IDE de Arduino, busca Adafruit PWM Servo Driver e instálala.
- Conecta los pines VCC, GND, SDA y SCL de la placa al Arduino como en la tabla anterior; deja el pin OE libre.
- Conecta los servos a los canales 0, 1, 2 y 3. El cable de señal naranja o amarillo va a la fila PWM, el rojo a la fila V+ y el marrón o negro a la fila GND.
- Conecta la fuente externa de 5 V al borne de tornillo: el positivo a V+ y el negativo a GND.
- Primero alimenta el Arduino por USB y sube el código, y después enciende la alimentación de los servos. Si no estás seguro de la dirección de la placa, comprueba con un escáner I2C que aparece la 0x40.
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(); // varsayılan adres 0x40 / default address 0x40
5
6const int SERVO_MIN = 110; // 0 derece için tick (kalibre et) / tick for 0 degrees (calibrate)
7const int SERVO_MAX = 500; // 180 derece için tick (kalibre et) / tick for 180 degrees (calibrate)
8
9void servoAci(uint8_t kanal, int aci) {
10 aci = constrain(aci, 0, 180);
11 int tick = map(aci, 0, 180, SERVO_MIN, SERVO_MAX);
12 pwm.setPWM(kanal, 0, tick); // darbe 0'da başlar, tick'te biter / pulse starts at 0, ends at tick
13}
14
15void setup() {
16 pwm.begin();
17 pwm.setOscillatorFrequency(27000000); // iç osilatör düzeltmesi / internal oscillator trim
18 pwm.setPWMFreq(50); // servo için 50 Hz (20 ms) / 50 Hz for servos (20 ms)
19 delay(10);
20}
21
22void loop() {
23 for (int aci = 0; aci <= 180; aci += 2) { // 0 -> 180 derece / degrees
24 for (uint8_t k = 0; k < 4; k++) servoAci(k, aci);
25 delay(15);
26 }
27 for (int aci = 180; aci >= 0; aci -= 2) { // 180 -> 0 derece / degrees
28 for (uint8_t k = 0; k < 4; k++) servoAci(k, aci);
29 delay(15);
30 }
31}pwm.begin() inicia la placa y setPWMFreq(50) fija el periodo en 20 ms para servos. La línea setOscillatorFrequency(27000000) viene de los ejemplos de Adafruit: aunque el oscilador interno del chip sea de 25 MHz sobre el papel, en la práctica varía entre 23 y 27 MHz y la biblioteca calcula el preescalador según este valor. El trabajo real lo hace setPWM(canal, on, off): si dejas on en 0 y escribes el número de ticks en off, el pulso empieza al principio del periodo y termina en ese paso. La función servoAci() convierte con map() el rango de 0–180 grados en el rango SERVO_MIN–SERVO_MAX. La biblioteca también tiene writeMicroseconds(canal, µs), que da el pulso directamente en microsegundos, pero como su precisión depende del ajuste del oscilador, es más fiable trabajar con ticks y calibrar cada servo.
Calibración del ancho de pulso: encuentra los límites reales de cada servo
Los fabricantes dan el rango estándar de 1–2 ms, pero en la práctica cada servo es distinto: un SG90 gira 180 grados completos entre 0,5 y 2,4 ms, mientras que otro puede quedarse en 170. Si usas ciegamente los valores de la tabla, el servo choca con el tope mecánico en el extremo, zumba, consume corriente innecesaria y desgasta los engranajes con el tiempo. El código de calibración de abajo envía al canal 0 el valor de ticks que escribas en el Monitor Serie. Empieza hacia 300 y ve bajando de 10 en 10; anota como SERVO_MIN un valor 5–10 pasos por encima del punto en que el servo deja de girar o empieza a zumbar. Haz lo mismo hacia arriba para encontrar SERVO_MAX. En un brazo robótico o una araña cada articulación es un servo distinto, así que lo más limpio es repetir esta medición para cada servo y guardar los valores en un array.
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
5
6void setup() {
7 Serial.begin(115200); // Seri Monitör: 115200, Yeni satır / Serial Monitor: 115200, Newline
8 pwm.begin();
9 pwm.setOscillatorFrequency(27000000);
10 pwm.setPWMFreq(50);
11 pwm.setPWM(0, 0, 307); // yaklaşık orta konum / roughly center position
12 Serial.println(F("Tick degeri yaz (80-650) / Enter tick value (80-650)"));
13}
14
15void loop() {
16 if (Serial.available()) {
17 int ticks = Serial.parseInt(); // yazılan sayıyı oku / read the typed number
18 if (ticks >= 80 && ticks <= 650) { // güvenli aralık / safe range
19 pwm.setPWM(0, 0, ticks);
20 Serial.print(F("Tick: "));
21 Serial.println(ticks);
22 }
23 while (Serial.available()) Serial.read(); // kalan karakterleri at / discard leftover characters
24 }
25}Encadenar varias placas PCA9685
En el borde superior de cada placa hay seis puentes de dirección (pads de soldadura) de A0 a A5. Con todos abiertos la dirección es 0x40; al unir un pad con una gota de estaño, el bit correspondiente pasa a 1 y se suma su valor a la dirección. Así, en teoría se pueden conectar 62 placas, es decir, 992 servos, al mismo bus I2C. Como los conectores de 6 pines de ambos lados de la placa están en paralelo, basta con unir la segunda placa a la primera con un cable corto; SDA, SCL, VCC y GND se transmiten a lo largo de la cadena. En el código creas un objeto distinto para cada placa y le pasas su dirección al constructor. Evita la dirección 0x70, ya que por defecto es la dirección "todos a la vez" (All Call) del chip. Para profundizar en el direccionamiento I2C, consulta ¿Qué es I2C?.
| Puentes soldados | Dirección | Ejemplo de uso |
|---|---|---|
| Ninguno | 0x40 | Placa 1 (servos 0–15) |
| A0 | 0x41 | Placa 2 (servos 16–31) |
| A1 | 0x42 | Placa 3 |
| A0 + A1 | 0x43 | Placa 4 |
| A2 | 0x44 | Placa 5 |
| A0–A5 todos | 0x7F | Última dirección |
Robot araña: 18 servos con dos PCA9685
En un robot araña de seis patas (hexápodo) cada pata tiene tres articulaciones: la cadera (coxa) unida al cuerpo, el fémur que sube y baja la pata y la tibia, cuyo extremo pisa el suelo. Como 6 × 3 = 18 servos superan los 16 canales de una sola placa, se encadenan dos: las patas izquierdas van a la placa con dirección 0x40 y las derechas a la placa 0x41 con el puente A0 soldado. Un robot araña de cuatro patas (cuadrúpedo) cabe en una sola placa con 12 servos y deja 4 canales libres. El código de abajo direcciona los servos del 0 al 17 con un único número, levanta el robot y mueve las rodillas una tras otra. Posicionar los servos de uno en uno, con 100 ms de espera entre ellos, evita el pico de corriente que se produciría si los 18 arrancaran a la vez. Para una marcha real, con el paso en trípode se levantan tres patas a la vez mientras las otras tres sostienen el cuerpo.
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver sol = Adafruit_PWMServoDriver(0x40); // sol bacaklar / left legs
5Adafruit_PWMServoDriver sag = Adafruit_PWMServoDriver(0x41); // sağ bacaklar (A0 lehimli) / right legs (A0 bridged)
6
7const int SERVO_MIN = 110;
8const int SERVO_MAX = 500;
9
10// servo no 0-17: 0-8 sol kart, 9-17 sağ kart / servo no 0-17: 0-8 left board, 9-17 right board
11void servoYaz(uint8_t no, int aci) {
12 int tick = map(constrain(aci, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
13 if (no < 9) sol.setPWM(no, 0, tick);
14 else sag.setPWM(no - 9, 0, tick);
15}
16
17void setup() {
18 sol.begin();
19 sol.setOscillatorFrequency(27000000);
20 sol.setPWMFreq(50);
21 sag.begin();
22 sag.setOscillatorFrequency(27000000);
23 sag.setPWMFreq(50);
24 Wire.setClock(400000); // hızlı I2C / fast I2C
25
26 for (uint8_t i = 0; i < 18; i++) { // ayağa kalk: tüm eklemler 90 derece / stand up: all joints at 90 degrees
27 servoYaz(i, 90);
28 delay(100); // akım sıçramasını azalt / reduce current surge
29 }
30}
31
32void loop() {
33 for (uint8_t bacak = 0; bacak < 6; bacak++) { // her bacağın dizini sırayla oynat / move each leg's knee in turn
34 uint8_t diz = bacak * 3 + 2; // her bacağın 3. servosu / third servo of each leg
35 servoYaz(diz, 60);
36 delay(300);
37 servoYaz(diz, 90);
38 delay(300);
39 }
40}Brazo robótico con potenciómetros: ESP32 y PCA9685
En el ESP32 la misma biblioteca de Adafruit funciona sin cambios; los pines I2C son GPIO 21 (SDA) y GPIO 22 (SCL). En este ejemplo controlamos un brazo robótico de cuatro articulaciones (base, hombro, codo y pinza) con cuatro potenciómetros. Conecta los extremos de los potenciómetros a 3V3 y GND, y los pines centrales a los GPIO 34, 35, 32 y 33 del grupo ADC1; como los pines ADC2 no se pueden leer con el Wi-Fi activo, esta elección también te facilitará añadir control inalámbrico más adelante. El ADC del ESP32 da valores entre 0 y 4095. En lugar de saltar de golpe al ángulo objetivo, el código acerca cada articulación el 10 % de la diferencia en cada vuelta del bucle; este suavizado simple reduce las sacudidas del brazo y los picos de corriente. Para el diseño mecánico y el orden de las articulaciones, Brazo robótico con Arduino es un buen punto de partida.
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
5
6const int SERVO_MIN = 110; // kalibrasyondan / from calibration
7const int SERVO_MAX = 500;
8const int POT_PINS[4] = {34, 35, 32, 33}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
9float konum[4] = {90, 90, 90, 90}; // anlık açılar / current angles
10
11void setup() {
12 Wire.begin(21, 22); // SDA, SCL
13 pwm.begin();
14 pwm.setOscillatorFrequency(27000000);
15 pwm.setPWMFreq(50);
16}
17
18void loop() {
19 for (int i = 0; i < 4; i++) {
20 int hedef = map(analogRead(POT_PINS[i]), 0, 4095, 0, 180); // 12 bit ADC -> açı / 12-bit ADC -> angle
21 konum[i] += (hedef - konum[i]) * 0.1f; // yumuşak geçiş / smoothing
22 int tick = map((long)konum[i], 0, 180, SERVO_MIN, SERVO_MAX);
23 pwm.setPWM(i, 0, tick);
24 }
25 delay(20); // her 20 ms'de bir güncelle / update every 20 ms
26}Raspberry Pi Pico y MicroPython con el PCA9685
El núcleo de MicroPython no incluye un controlador PCA9685, pero manejar el chip con unos pocos registros es tan fácil que puedes escribir el controlador tú mismo. El registro MODE1 (0x00) despierta el chip, el registro PRESCALE (0xFE) fija la frecuencia, y los registros ON/OFF de cuatro bytes de cada canal empiezan en la dirección 0x06 y avanzan de cuatro en cuatro. El valor del preescalador se calcula con prescale = oscilador / (4096 × frecuencia) − 1 y solo se puede escribir con el chip en modo reposo. Alimenta la placa desde el pin 3V3(OUT) de la Pico y conecta SDA a GP4 y SCL a GP5. Si eres nuevo en MicroPython, Fundamentos de MicroPython te ayudará.
1from machine import Pin, I2C
2import time
3
4class PCA9685:
5 def __init__(self, i2c, addr=0x40):
6 self.i2c = i2c
7 self.addr = addr
8 self._yaz(0x00, 0x00) # MODE1: uykudan çık / wake up
9 time.sleep_ms(5)
10
11 def _yaz(self, reg, deger):
12 self.i2c.writeto_mem(self.addr, reg, bytes([deger]))
13
14 def _oku(self, reg):
15 return self.i2c.readfrom_mem(self.addr, reg, 1)[0]
16
17 def frekans(self, hz, osc=27000000): # Adafruit ile aynı osilatör varsayımı / same oscillator assumption as Adafruit
18 prescale = int(osc / (4096 * hz) + 0.5) - 1
19 eski = self._oku(0x00)
20 self._yaz(0x00, (eski & 0x7F) | 0x10) # uyku kipi / sleep mode
21 self._yaz(0xFE, prescale) # ön bölücü / prescaler
22 self._yaz(0x00, eski)
23 time.sleep_ms(5)
24 self._yaz(0x00, eski | 0xA0) # yeniden başlat + otomatik artış / restart + auto-increment
25
26 def pwm(self, kanal, on, off):
27 reg = 0x06 + 4 * kanal # LEDn_ON_L yazmacı / LEDn_ON_L register
28 self.i2c.writeto_mem(self.addr, reg, bytes([on & 0xFF, on >> 8, off & 0xFF, off >> 8]))
29
30SERVO_MIN = 110 # 0 derece / 0 degrees
31SERVO_MAX = 500 # 180 derece / 180 degrees
32
33def servo_aci(pca, kanal, aci):
34 aci = max(0, min(180, aci))
35 tick = SERVO_MIN + (SERVO_MAX - SERVO_MIN) * aci // 180
36 pca.pwm(kanal, 0, tick)
37
38i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
39pca = PCA9685(i2c)
40pca.frekans(50) # servo için 50 Hz / 50 Hz for servos
41
42while True:
43 for aci in range(0, 181, 2): # 0 -> 180 derece / degrees
44 for k in range(4):
45 servo_aci(pca, k, aci)
46 time.sleep_ms(15)
47 for aci in range(180, -1, -2): # 180 -> 0 derece / degrees
48 for k in range(4):
49 servo_aci(pca, k, aci)
50 time.sleep_ms(15)Ideas de proyectos con el PCA9685
- Brazo robótico: controla un brazo de 4–6 articulaciones con potenciómetros o con un joystick, y guarda los movimientos en la EEPROM para reproducirlos.
- Robot araña: construye un robot caminante de cuatro patas con 12 servos o de seis patas con 18; a nivel avanzado, calcula con cinemática inversa las coordenadas de la punta de la pata.
- Ojos y cara animatrónicos: mueve de forma sincronizada de 6 a 8 servos pequeños para párpados, pupilas y cejas.
- Soporte de cámara pan-tilt: gira un módulo ESP32-CAM en horizontal y vertical con dos servos y oriéntalo por Wi-Fi.
- Coreografía de servos: mueve 32 servos dispuestos en círculo con dos placas, en patrones de ola y espiral.
- Regulador de 16 canales para LEDs: el PCA9685 es en realidad un controlador de LEDs; sube la frecuencia a 1000 Hz y ajusta el brillo de 16 LEDs sin parpadeo. Aquí usas exactamente la misma lógica del PWM.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Los servos no se mueven | No hay alimentación V+ o no se llamó a setPWMFreq | Conecta alimentación externa al borne y comprueba que setup contiene setPWMFreq(50) |
| Los servos tiemblan y saltan al azar | Corriente insuficiente de la fuente, cables finos | Fuente más potente, cable grueso y condensador de 470–1000 µF en la línea V+ |
| El Arduino se reinicia cuando se mueven los servos | Los servos se alimentan desde el pin 5V del Arduino | Da la alimentación de los servos solo por V+ y une los GND |
| El servo zumba y se calienta en el extremo | SERVO_MIN o SERVO_MAX fuera del límite mecánico | Encuentra los límites con el código de calibración y quédate 5–10 pasos por dentro |
| El código se cuelga o no se encuentra la placa | Dirección errónea, SDA y SCL invertidos, dos placas con la misma dirección | Ejecuta un escáner I2C y revisa los puentes de dirección |
| Al encender, los servos dan un tirón brusco | Todos los servos van a la posición a la vez | Arranca los servos de uno en uno con una pequeña espera entre ellos |
El PCA9685 es una placa barata y robusta que pone orden en el proyecto en cuanto pasas de dos o tres servos: una vez que montas bien la alimentación y calibras cada servo, el resto se reduce a escribir ángulos. Para articulaciones más fuertes puedes conectar a la misma placa servos MG996R, y para ruedas de giro continuo servos FS90R. En la app de BlueGrays encontrarás, con esquema y código paso a paso, proyectos como la coreografía circular de 32 servos, el control de servos con potenciómetro y joystick o una cerradura de puerta RFID con ESP32.
Preguntas frecuentes
¿Cuántos servos se pueden controlar con un PCA9685?
Una sola placa PCA9685 maneja 16 servos de forma independiente. Como con los puentes de dirección se pueden encadenar hasta 62 placas en el mismo bus I2C, en teoría se pueden gestionar 992 servos. En la práctica el límite no lo ponen las placas, sino la corriente que puede dar la fuente que alimenta los servos.
¿Por qué tiembla un servo conectado al PCA9685?
La causa más habitual es una fuente de alimentación insuficiente: la tensión de V+ cae cuando los servos se mueven. La segunda es que, con SERVO_MIN y SERVO_MAX sin calibrar, el servo choca con su límite mecánico. Una fuente potente, cable grueso, un condensador grande en la línea V+ y los valores límite correctos suelen resolver el problema.
¿Cuál es la diferencia entre VCC y V+ en el PCA9685?
VCC es la alimentación lógica del chip; se conecta a 5V en el Arduino Uno y a 3V3 en el ESP32 y la Pico, y consume muy poca corriente. V+ es la línea de potencia de los servos y se alimenta de una fuente externa de 5–6 V. Confundirlos hace que la placa no funcione o que el microcontrolador se reinicie.
¿Cómo se cambia la dirección I2C del PCA9685?
Unes con estaño uno o varios de los pads A0–A5 de la placa. Con todos abiertos la dirección es 0x40; si sueldas A0 pasa a 0x41 y si sueldas A1, a 0x42. En el código basta con crear el objeto con la nueva dirección, por ejemplo Adafruit_PWMServoDriver(0x41).
¿Funciona el PCA9685 con el ESP32?
Sí, la biblioteca Adafruit PWM Servo Driver funciona en el ESP32 sin cambios. Conecta SDA al GPIO 21 y SCL al GPIO 22, y alimenta el VCC de la placa desde 3V3 para que las líneas I2C se queden a 3,3 V. La señal de los servos será de 3,3 V, nivel que la mayoría de los servos estándar detecta sin problemas.
¿Para qué sirve el PCA9685 además de mover servos?
El chip es en realidad un controlador de LEDs de 16 canales; subiendo la frecuencia a unos 1000 Hz puedes ajustar el brillo de los LEDs en 4096 niveles. También se usa para controlar la velocidad de pequeños motores DC mediante un transistor o MOSFET. Los canales no mueven cargas grandes directamente, solo generan la señal de control.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Coreografía de servos en círculo - Patrones animados con 32 servos
Un proyecto de animación visual con 32 servomotores dispuestos en círculo sobre un Arduino Mega. Los servos se gestionan en un único array, se conectan a los pines 22–53 del Mega y muestran cuatro secuencias de movimiento: una vibración caótica en ángulos aleatorios, un barrido sincronizado, una ola que recorre el círculo y una aguja de brújula que oscila de lado a lado.

Uso del servomotor
El brazo de un pequeño servomotor gira por turnos a tres posiciones: al principio del todo, justo al centro y al final del todo, esperando dos segundos en cada parada.

Funcionamiento del servomotor con potenciómetro
A medida que giras el mando del potenciómetro, el brazo del servomotor gira con él: un extremo del mando equivale a cero grados y el otro a media vuelta.

Servocontrol con joystick
Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

Servomotor ESP32 (control mediante potenciómetro)
En este proyecto controlamos un servomotor SG90 mediante un potenciómetro. Ajustamos el ángulo del servo asignando el valor analógico leído en el potenciómetro al rango de 0 a 180 grados. La biblioteca ESP32Servo genera señales de servo en los GPIO adecuados del ESP32 que admiten salida; en este proyecto se utiliza GPIO 18. Este es un método de control básico para brazos robóticos, cardanes de cámara y mecanismos de puertas automáticas.

Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)
Construimos una cerradura inteligente con un ESP32, un módulo RFID RC522, un servo SG90, una pantalla OLED SSD1306, un zumbador activo y 2 LED. Al pasar una tarjeta, su UID se compara con las autorizadas definidas en el código; si coincide, el servo abre (LED verde + 2 pitidos cortos) y vuelve a cerrar a los 5 segundos. Con una tarjeta no autorizada se enciende el LED rojo, suenan 3 pitidos rápidos y la OLED muestra su UID.

Construcción de servomotor de 360 grados a partir de motor paso a paso
Enséñale a un motor paso a paso normal a ir al ángulo que quieras, a lo largo de toda la vuelta.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

