PCA9685 com Arduino: guia do driver de servos de 16 canais
Ligação do PCA9685 com Arduino: endereço I2C 0x40, alimentação externa para os servos, calibração da largura de pulso e placas em cadeia, com códigos de braço robótico e robô aranha hexápode.
O PCA9685 é uma placa driver PWM de 12 bits que controla 16 servo motores ao mesmo tempo e de forma independente por um único barramento I2C. No Arduino Uno, a biblioteca Servo gerencia no máximo 12 servos e, para isso, deixa um timer totalmente ocupado; os pinos acabam e os servos começam a tremer. Já o PCA9685 gera os pulsos com seu próprio oscilador interno, então o seu microcontrolador só precisa dizer “leve este canal para esta posição”. Você encontra essa placa em quase todo projeto com várias articulações: braços robóticos, robôs aranha, olhos animatrônicos ou suportes de câmera pan-tilt.
Neste guia você vai aprender a ligação do PCA9685 com Arduino, por que precisa alimentar os servos com uma fonte separada, como calibrar a largura de pulso para encontrar os valores reais de 0 e 180 graus de cada servo e como ligar placas em cadeia com os jumpers de endereço. Depois vamos montar um robô aranha de 18 servos com duas placas, um braço robótico controlado por potenciômetros com ESP32 e um driver em MicroPython sem biblioteca para o Raspberry Pi Pico. Se você ainda não conhece o funcionamento básico dos servo motores, dê uma olhada antes em O que é servo motor?.

O que é o PCA9685 e como ele funciona?
O PCA9685 é, na verdade, um chip que a NXP projetou para controlar LEDs, mas, como a frequência é ajustável, ele funciona perfeitamente com servos também. Dentro dele há um oscilador de 25 MHz e um contador de 12 bits compartilhado por todos os canais; um período PWM é dividido em 4096 passos (ticks). Para cada canal você escreve dois números: o passo em que o sinal sobe (ON) e o passo em que ele desce (OFF). Para servos, a frequência é ajustada em 50 Hz, ou seja, o período é de 20 ms. Um passo dura 20 ms / 4096 ≈ 4,88 µs; portanto, para converter a largura de pulso desejada em ticks, use tick = pulso (µs) / 4,88. Por exemplo, o pulso de posição central de 1,5 ms equivale a 1500 / 4,88 ≈ 307 ticks. Depois que um canal é configurado, a placa continua gerando o sinal sozinha; mesmo com o Arduino ocupado com outras tarefas, o servo mantém a posição.
| Característica | Valor |
|---|---|
| Chip | NXP PCA9685 |
| Canais | 16 saídas PWM independentes |
| Resolução | 12 bits (4096 passos por período) |
| Frequência PWM | Cerca de 24–1526 Hz (50 Hz para servos) |
| Comunicação | I2C, até 1 MHz |
| Endereço padrão | 0x40 (0x40–0x7F com os jumpers A0–A5) |
| Alimentação lógica (VCC) | 2,3–5,5 V |
| Alimentação dos servos (V+) | Externa, normalmente 5–6 V conforme o servo |
| Corrente de saída | 25 mA absorvidos, 10 mA fornecidos por canal (apenas sinal) |
| Na placa | A maioria dos módulos tem resistores de pull-up em SDA/SCL e resistores em série de 220 Ω nas saídas |
| Largura de pulso | Ticks @ 50 Hz | Posição típica do servo |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Cerca de 0° em um SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | 0° padrão (servos de faixa estreita) |
| 1,5 ms (1500 µs) | ≈ 307 | Posição central (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | 180° padrão |
| 2,4 ms (2400 µs) | ≈ 492 | Cerca de 180° em um SG90 |
Ligação do PCA9685: Arduino Uno, ESP32 e Pico
| Pino do 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 | Deixe desligado (já puxado para GND na placa) | Deixe desligado | Deixe desligado |
| V+ (borne com parafuso) | Positivo da fonte externa de 5–6 V | Positivo da fonte externa de 5–6 V | Positivo da fonte externa de 5–6 V |
| GND (borne com parafuso) | Negativo da fonte externa (comum com o GND na placa) | Negativo da fonte externa (comum com o GND na placa) | Negativo da fonte externa (comum com o GND na placa) |
Alimentação externa: quanta corrente os servos consomem?
Um servo parado consome só 5–10 mA, mas em movimento, e principalmente quando está forçando sob carga (travamento, ou stall), a corrente dispara. Um SG90 travado pode consumir 600–700 mA, e um MG996R passa de 2 A. Quando todas as articulações de um braço robótico começam a se mover ao mesmo tempo, esses picos de corrente se somam e a tensão de uma fonte fraca cai; o resultado são servos tremendo, pulando aleatoriamente e um Arduino reiniciando. Uma regra prática: multiplique o número de servos que se movem ao mesmo tempo pela corrente de pico e escolha uma fonte que forneça continuamente pelo menos metade desse valor. Um adaptador de 5 V 3 A serve para um braço robótico com seis SG90, e uma fonte de 5–6 V 8–10 A, ou um UBEC potente do mundo do RC, para um robô aranha de 18 servos.
| Servo | Parado | Em movimento | Travado (stall) | Alimentação |
|---|---|---|---|---|
| SG90 (9 g, engrenagens de plástico) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (engrenagens de metal) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (tamanho padrão) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Primeiro teste passo a passo: girar 4 servos juntos
- Abra o Gerenciador de Bibliotecas na Arduino IDE, busque a biblioteca Adafruit PWM Servo Driver e instale.
- Ligue os pinos VCC, GND, SDA e SCL da placa ao Arduino como na tabela acima; deixe o pino OE desligado.
- Conecte os servos nos canais 0, 1, 2 e 3. O fio de sinal laranja ou amarelo do conector deve ficar na fileira PWM, o vermelho na fileira V+ e o marrom ou preto na fileira GND.
- Ligue a fonte externa de 5 V ao borne com parafuso: positivo no V+, negativo no GND.
- Primeiro alimente o Arduino pelo USB e carregue o código; depois ligue a alimentação dos servos. Se não tiver certeza do endereço da placa, confirme com um sketch scanner I2C que o endereço 0x40 aparece.
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() inicializa a placa e setPWMFreq(50) ajusta o período em 20 ms para os servos. A linha setOscillatorFrequency(27000000) vem dos exemplos da Adafruit: embora o oscilador interno do chip seja de 25 MHz no papel, na prática ele varia entre 23 e 27 MHz, e a biblioteca calcula o prescaler a partir desse valor. Quem faz o trabalho de verdade é setPWM(canal, on, off); se você deixar on em 0 e escrever o número de ticks em off, o pulso começa no início do período e termina nesse passo. A função servoAci() usa map() para converter 0–180 graus na faixa SERVO_MIN–SERVO_MAX. A biblioteca também tem a função writeMicroseconds(canal, µs), que recebe o pulso direto em microssegundos, mas, como a precisão dela depende do ajuste do oscilador, trabalhar com ticks e calibrar cada servo é mais confiável.
Calibração da largura de pulso: encontre os limites reais de cada servo
Os fabricantes de servos informam a faixa padrão de 1–2 ms, mas na prática cada servo é diferente: um SG90 gira os 180 graus completos entre 0,5 e 2,4 ms, enquanto outro pode parar em 170 graus. Se você usar os valores da tabela às cegas, o servo bate no batente mecânico no fim do curso, fica zumbindo, consome corrente à toa e desgasta as engrenagens com o tempo. O código de calibração abaixo envia ao canal 0 o valor de tick que você digita no Monitor Serial. Comece por volta de 300 e diminua o valor de 10 em 10; anote o ponto em que o servo para de girar ou começa a zumbir e use 5–10 ticks acima dele como SERVO_MIN. Faça o mesmo no sentido oposto para encontrar o SERVO_MAX. Em um braço robótico ou robô aranha, cada articulação é um servo diferente, então o método mais limpo é repetir essa medição para cada servo e guardar os valores em um 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}Ligando várias placas PCA9685 em cadeia
Na borda superior de cada placa há seis jumpers de endereço (ilhas de solda), de A0 a A5. Com todos abertos, o endereço é 0x40; quando você une uma ilha com solda, o bit correspondente vira 1 e o valor desse bit é somado ao endereço. Assim, em teoria, 62 placas, ou 992 servos, podem compartilhar o mesmo barramento I2C. Como as barras de 6 pinos dos dois lados das placas estão ligadas em paralelo, basta um cabo curto da primeira placa para a segunda; SDA, SCL, VCC e GND seguem ao longo da cadeia. No código, você cria um objeto separado para cada placa e passa o endereço dela ao construtor. Evite o endereço 0x70, porque ele é, por padrão, o endereço “All Call” (todos de uma vez) do chip. Para entender melhor o endereçamento I2C, veja O que é I2C?.
| Jumpers soldados | Endereço | Exemplo de uso |
|---|---|---|
| Nenhum | 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 |
| Todos de A0–A5 | 0x7F | Último endereço |
Robô aranha: 18 servos com duas PCA9685
Em um robô aranha de seis pernas (hexápode), cada perna tem três articulações: o quadril (coxa), preso ao corpo, a coxa (femur), que levanta e abaixa a perna, e o joelho (tibia), cuja ponta toca o chão. 6 × 3 = 18 servos ultrapassam os 16 canais de uma placa, então duas placas são encadeadas: as pernas esquerdas vão para a placa de endereço 0x40 e as direitas para a placa de endereço 0x41, com o jumper A0 soldado. Já um robô aranha de quatro pernas (quadrúpede) usa 12 servos, cabe em uma só placa e ainda sobram 4 canais. O código abaixo endereça os servos com um único número de 0 a 17, coloca o robô de pé e movimenta os joelhos um por vez. Posicionar os servos um a um, com 100 ms de espera entre eles, evita o pico de corrente que aconteceria se os 18 servos se levantassem ao mesmo tempo. Para caminhar de verdade, a marcha em tripé levanta três pernas por vez enquanto as outras três sustentam o corpo.
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}ESP32 e PCA9685: braço robótico controlado por potenciômetros
No ESP32, a mesma biblioteca da Adafruit funciona sem alterações; os pinos I2C são GPIO 21 (SDA) e GPIO 22 (SCL). Neste exemplo, controlamos um braço robótico de quatro articulações (base, ombro, cotovelo, garra) com quatro potenciômetros. Ligue os terminais externos dos potenciômetros ao 3V3 e ao GND e os terminais do meio aos GPIO 34, 35, 32 e 33, do grupo ADC1; como os pinos do ADC2 não podem ser lidos com o Wi-Fi ligado, essa escolha também facilita acrescentar controle sem fio depois. O ADC do ESP32 dá valores de 0 a 4095. Em vez de fazer cada articulação pular direto para o ângulo-alvo, o código a aproxima 10 por cento da diferença restante a cada ciclo; essa suavização simples reduz os trancos e o consumo repentino de corrente. Para o projeto mecânico e a ordem das articulações, Braço robótico com Arduino é um bom ponto 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 e PCA9685 com MicroPython
O MicroPython não tem um driver pronto do PCA9685 no núcleo, mas o chip é tão fácil de controlar com alguns registradores que você mesmo pode escrever o driver. O registrador MODE1 (0x00) acorda o chip, o registrador PRESCALE (0xFE) define a frequência e os registradores ON/OFF de quatro bytes de cada canal começam no endereço 0x06 e avançam de quatro em quatro. O valor do prescaler é calculado com prescale = oscilador / (4096 × frequência) − 1 e só pode ser escrito enquanto o chip está em modo de repouso. Alimente a placa pelo pino 3V3(OUT) do Pico e ligue SDA ao GP4 e SCL ao GP5. Se você está começando com MicroPython, Fundamentos de MicroPython vai ajudar.
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)Ideias de projetos com o PCA9685
- Braço robótico: controle um braço de 4–6 articulações com potenciômetros ou um joystick e grave os movimentos na EEPROM para reproduzi-los depois.
- Robô aranha: monte um robô que anda, com 12 servos em quatro pernas ou 18 servos em seis pernas; em nível avançado, use cinemática inversa para calcular as coordenadas da ponta das pernas.
- Olhos e rosto animatrônicos: mova 6–8 servos pequenos em sincronia para pálpebras, pupilas e sobrancelhas.
- Suporte de câmera pan-tilt: gire um módulo ESP32-CAM na horizontal e na vertical com dois servos e direcione-o pelo Wi-Fi.
- Coreografia de servos: movimente 32 servos dispostos em círculo, com duas placas, em padrões de onda e espiral.
- Dimmer de LED de 16 canais: o PCA9685 é, na verdade, um driver de LED; aumente a frequência para 1000 Hz e ajuste o brilho de 16 LEDs sem cintilação. Aqui você usa exatamente a mesma lógica do PWM.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| Os servos não se mexem | Sem alimentação no V+ ou setPWMFreq não foi chamada | Ligue a alimentação externa no borne e confira se setPWMFreq(50) está no setup |
| Os servos tremem e pulam aleatoriamente | Corrente da fonte insuficiente, fios finos | Use uma fonte mais forte, fios grossos e um capacitor de 470–1000 µF na linha V+ |
| O Arduino reinicia quando os servos se movem | Os servos estão sendo alimentados pelo pino 5V do Arduino | Alimente os servos só pelo V+ e una os GNDs |
| O servo zumbe e esquenta no fim do curso | SERVO_MIN ou SERVO_MAX está além do limite mecânico | Encontre os limites com o código de calibração e fique 5–10 ticks para dentro |
| O código trava ou a placa não é encontrada | Endereço errado, SDA e SCL invertidos, duas placas no mesmo endereço | Rode um sketch scanner I2C e confira os jumpers de endereço |
| Os servos dão um tranco forte ao ligar | Todos os servos vão para a posição ao mesmo tempo | Inicie os servos um por um, com uma pequena espera entre eles |
Assim que o projeto passa de dois ou três servos, o PCA9685 é uma placa barata e robusta que coloca tudo em ordem: depois de montar a alimentação corretamente e calibrar cada servo, o resto é só escrever ângulos. Para articulações mais fortes, você pode ligar servos MG996R na mesma placa, e servos FS90R para rodas de rotação contínua. No app BlueGrays você encontra projetos como a coreografia de 32 servos em círculo, o controle de servo com potenciômetro e joystick e a fechadura de porta RFID com ESP32, com esquema do circuito e código passo a passo.
Perguntas frequentes
Quantos servos dá para controlar com um PCA9685?
Uma única placa PCA9685 controla 16 servos de forma independente. Como até 62 placas podem ser encadeadas no mesmo barramento I2C com os jumpers de endereço, em teoria dá para controlar 992 servos. Na prática, o limite não são as placas, e sim a corrente que sua fonte consegue fornecer aos servos.
Por que o servo ligado ao PCA9685 treme?
A causa mais comum é uma fonte insuficiente; a tensão no V+ cai enquanto os servos se movem. A segunda causa são valores de SERVO_MIN e SERVO_MAX não calibrados, que fazem o servo forçar contra o limite mecânico. Uma fonte forte, fios grossos, um capacitor grande na linha V+ e os valores de limite corretos costumam resolver o problema.
Qual é a diferença entre VCC e V+ no PCA9685?
O VCC é a alimentação lógica do chip; é ligado ao 5V no Arduino Uno e ao 3V3 no ESP32 e no Pico, e consome pouquíssima corrente. O V+ é a linha de alimentação dos servos e recebe energia de uma fonte externa de 5–6 V. Confundir os dois faz a placa não funcionar ou o microcontrolador reiniciar.
Como mudar o endereço I2C do PCA9685?
Você une com solda uma ou mais das ilhas A0–A5 da placa. Sem nenhuma soldada, o endereço é 0x40; soldando A0, vira 0x41, e soldando A1, vira 0x42. No código, basta criar o objeto com o novo endereço, como Adafruit_PWMServoDriver(0x41).
O PCA9685 funciona com o ESP32?
Sim, a biblioteca Adafruit PWM Servo Driver funciona no ESP32 sem alterações. Ligue SDA ao GPIO 21 e SCL ao GPIO 22 e alimente o VCC da placa pelo 3V3 para que as linhas I2C fiquem em 3,3 V. Nesse caso o sinal dos servos também é de 3,3 V; a maioria dos servos padrão reconhece esse nível sem problemas.
Para que mais serve o PCA9685 além de servos?
O chip é, na verdade, um driver de LED de 16 canais; aumentando a frequência para cerca de 1000 Hz, você ajusta o brilho dos LEDs em 4096 níveis. Ele também pode controlar a velocidade de pequenos motores CC por meio de um transistor ou MOSFET. Os canais não acionam cargas grandes diretamente; eles só geram o sinal de controle.
Projetos para montar depois desta leitura
Ver todos os projetos
Coreografia em círculo: animações com 32 servos
Um projeto de animação visual com 32 servo motores dispostos em círculo e controlados por um Arduino Mega. Os servos são gerenciados em um único array e conectados aos pinos 22–53 do Mega. Eles executam quatro sequências de movimento: uma vibração caótica em que todos vão para ângulos aleatórios, uma varredura sincronizada em que todos se movem ao mesmo tempo, uma onda que gira suavemente pelo círculo e, por fim, uma agulha de bússola que oscila de um lado para o outro.

Uso de servo motor
O braço de um pequeno servo motor gira para três posições em sequência: o início, o meio e o fim do percurso, esperando dois segundos em cada parada.

Uso de servo motor com potenciômetro
Conforme você gira o botão do potenciômetro, o braço do servo motor gira junto: uma extremidade do botão corresponde a zero grau, e a outra, a meia volta.

Controle de servos com joystick
Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

Servo motor com ESP32 (controle por potenciômetro)
Neste projeto, controlamos um servo motor SG90 com um potenciômetro. Ajustamos o ângulo do servo mapeando o valor analógico lido do potenciômetro para a faixa de 0 a 180 graus. A biblioteca ESP32Servo gera sinais para o servo nos GPIOs do ESP32 adequados e capazes de operar como saída; este projeto usa o GPIO 18. Esse é um método básico de controle para braços robóticos, estabilizadores de câmera e mecanismos de portas automáticas.

Fechadura RFID com ESP32 (RC522 + servo + OLED + buzzer + LED)
Vamos montar uma fechadura inteligente com ESP32, módulo RFID RC522, servo motor SG90, display OLED SSD1306, buzzer ativo e 2 LEDs. Ao ler um cartão, seu UID é comparado à lista de cartões autorizados definida no código. Se estiver autorizado, o servo motor gira para abrir a fechadura (LED verde + 2 bipes curtos), que trava novamente após 5 segundos. Com um cartão não autorizado, o LED vermelho acende, 3 bipes rápidos soam e o UID lido aparece no OLED.

Servo motor de 360 graus com motor de passo
Ensine um motor de passo comum a ir até qualquer ângulo que você quiser, ao longo de uma volta completa.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

