PCA9685 Arduino: guida al driver per servo a 16 canali
PCA9685 con Arduino: collegamento, indirizzo I2C 0x40, alimentazione esterna dei servo, calibrazione degli impulsi, schede in cascata e codice per robot.
Il PCA9685 è una scheda driver PWM a 12 bit che, con una sola linea I2C, pilota 16 servomotori contemporaneamente e in modo indipendente. Su Arduino Uno la libreria Servo gestisce al massimo 12 servo e occupa completamente un timer: i pin finiscono e i servo iniziano a tremare. Il PCA9685 invece genera gli impulsi con un oscillatore interno, e al microcontrollore resta solo da dire "porta questo canale in questa posizione". Lo troverai in quasi tutti i progetti con molte articolazioni: bracci robotici, robot ragno, occhi animatronici o supporti pan-tilt per telecamere.
In questa guida vedrai il collegamento del PCA9685 con Arduino, perché i servo vanno alimentati con un alimentatore separato, come calibrare la larghezza d'impulso per trovare i veri valori di 0 e 180 gradi di ogni servo e come collegare più schede in cascata con i ponticelli di indirizzo. Poi scriveremo un robot ragno a 18 servo con due schede, un braccio robotico controllato da potenziometri con ESP32 e un driver MicroPython senza librerie per Raspberry Pi Pico. Se non conosci il funzionamento di base dei servomotori, dai prima un'occhiata a Che cos'è un servomotore?.

Che cos'è il PCA9685 e come funziona?
Il PCA9685 è in realtà un chip che NXP ha progettato per pilotare LED, ma essendo la frequenza regolabile funziona perfettamente anche con i servo. Contiene un oscillatore da 25 MHz e un contatore a 12 bit condiviso da tutti i canali: un periodo PWM è diviso in 4096 passi (tick). A ogni canale scrivi due numeri: il passo in cui il segnale sale (ON) e quello in cui scende (OFF). Per i servo si sceglie una frequenza di 50 Hz, cioè un periodo di 20 ms. Un passo dura 20 ms / 4096 ≈ 4,88 µs, quindi per convertire una larghezza d'impulso in passi usi la formula tick = impulso (µs) / 4,88. Per esempio, l'impulso centrale di 1,5 ms corrisponde a 1500 / 4,88 ≈ 307 passi. Una volta impostato il canale, la scheda continua a generare il segnale da sola: il servo resta fermo anche quando Arduino è impegnato in altro.
| Caratteristica | Valore |
|---|---|
| Chip | NXP PCA9685 |
| Numero di canali | 16 uscite PWM indipendenti |
| Risoluzione | 12 bit (4096 passi per periodo) |
| Frequenza PWM | Circa 24–1526 Hz (50 Hz per i servo) |
| Comunicazione | I2C, fino a 1 MHz |
| Indirizzo predefinito | 0x40 (0x40–0x7F con i ponticelli A0–A5) |
| Alimentazione logica (VCC) | 2,3–5,5 V |
| Alimentazione servo (V+) | Esterna, di solito 5–6 V a seconda del servo |
| Corrente in uscita | 25 mA in assorbimento, 10 mA in erogazione per canale (solo segnale) |
| Sulla scheda | Nella maggior parte dei moduli pull-up su SDA/SCL e resistenze serie da 220 Ω sulle uscite |
| Larghezza d'impulso | Passi (tick) a 50 Hz | Posizione tipica del servo |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Circa 0° per l'SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | 0° standard (servo a corsa stretta) |
| 1,5 ms (1500 µs) | ≈ 307 | Posizione centrale (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | 180° standard |
| 2,4 ms (2400 µs) | ≈ 492 | Circa 180° per l'SG90 |
Collegamento del PCA9685: Arduino Uno, ESP32 e Pico
| Pin PCA9685 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (logica) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Lascia scollegato (sulla scheda è a GND) | Lascia scollegato | Lascia scollegato |
| V+ (morsetto a vite) | Positivo di un alimentatore esterno da 5–6 V | Positivo di un alimentatore esterno da 5–6 V | Positivo di un alimentatore esterno da 5–6 V |
| GND (morsetto a vite) | Negativo dell'alimentatore esterno (in comune con il GND della scheda) | Negativo dell'alimentatore esterno (in comune con il GND della scheda) | Negativo dell'alimentatore esterno (in comune con il GND della scheda) |
Alimentazione esterna: quanta corrente assorbono i servo?
Un servo a riposo assorbe solo 5–10 mA, ma quando si muove, e soprattutto quando è sotto sforzo (stallo), la corrente sale di colpo. Un SG90 in stallo può arrivare a 600–700 mA, un MG996R oltre 2 A. Quando tutte le articolazioni di un braccio robotico iniziano a muoversi insieme, questi picchi si sommano e la tensione di un alimentatore debole crolla: il risultato sono servo che tremano, scatti casuali e un Arduino che si resetta. La regola pratica: moltiplica il numero di servo che si muovono insieme per la corrente di picco e scegli un alimentatore che possa fornire in continuo almeno la metà del valore. Per un braccio con sei SG90 va bene un alimentatore da 5 V 3 A; per un robot ragno a 18 servo una sorgente da 5–6 V 8–10 A oppure un potente UBEC del mondo RC.
| Servo | A riposo | In movimento | In stallo | Alimentazione |
|---|---|---|---|---|
| SG90 (9 g, ingranaggi in plastica) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (ingranaggi in metallo) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (taglia standard) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Prima accensione passo dopo passo: far ruotare 4 servo insieme
- Apri il Gestore librerie dell'Arduino IDE, cerca Adafruit PWM Servo Driver e installa la libreria.
- Collega i pin VCC, GND, SDA e SCL della scheda ad Arduino come nella tabella sopra; lascia scollegato il pin OE.
- Inserisci i servo nei canali 0, 1, 2 e 3. Il filo di segnale arancione o giallo va sulla fila PWM, il rosso sulla fila V+, il marrone o nero sulla fila GND.
- Collega l'alimentatore esterno da 5 V al morsetto a vite: il positivo a V+, il negativo a GND.
- Accendi prima Arduino via USB e carica il codice, poi dai alimentazione ai servo. Se non sei sicuro dell'indirizzo, verifica con uno sketch scanner I2C che compaia 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() inizializza la scheda, setPWMFreq(50) porta il periodo a 20 ms per i servo. La riga setOscillatorFrequency(27000000) viene dagli esempi Adafruit: l'oscillatore interno del chip sulla carta è da 25 MHz, ma in realtà varia tra 23 e 27 MHz e la libreria calcola il prescaler in base a questo valore. Il lavoro vero lo fa setPWM(canale, on, off): lasciando on a 0 e scrivendo in off il numero di tick, l'impulso parte all'inizio del periodo e termina in quel passo. La funzione servoAci() converte con map() i gradi 0–180 nell'intervallo SERVO_MIN–SERVO_MAX. La libreria ha anche writeMicroseconds(canale, µs), che dà l'impulso direttamente in microsecondi, ma la sua precisione dipende dalla regolazione dell'oscillatore: lavorare con i tick e calibrare ogni servo è più affidabile.
Calibrazione della larghezza d'impulso: trova i limiti reali di ogni servo
I produttori indicano l'intervallo standard di 1–2 ms, ma in realtà ogni servo è diverso: un SG90 compie esattamente 180 gradi tra 0,5 e 2,4 ms, mentre un altro può fermarsi a 170 gradi. Se usi alla cieca i valori della tabella, il servo va a battuta contro il fermo meccanico, ronza, assorbe corrente inutilmente e con il tempo consuma gli ingranaggi. Il codice di calibrazione qui sotto invia al canale 0 il valore di tick che scrivi nel Monitor seriale. Parti da circa 300 e diminuisci il valore di 10 in 10; annota come SERVO_MIN il punto 5–10 passi sopra quello in cui il servo smette di ruotare o comincia a ronzare. Fai lo stesso verso l'alto per trovare SERVO_MAX. In un braccio robotico o in un robot ragno ogni articolazione è un servo a sé, quindi il metodo più pulito è ripetere la misura per ogni servo e salvare i valori in 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}Collegare più schede PCA9685 in cascata
Sul bordo superiore di ogni scheda ci sono sei ponticelli di indirizzo da A0 ad A5 (pad da saldare). Con tutti aperti l'indirizzo è 0x40; quando metti in corto un pad con una goccia di stagno, il bit corrispondente diventa 1 e il suo valore si somma all'indirizzo. Così sulla stessa linea I2C puoi collegare in teoria 62 schede, cioè 992 servo. Le due file di header a 6 pin ai lati delle schede sono in parallelo, quindi ti basta collegare la seconda scheda alla prima con un cavetto corto: SDA, SCL, VCC e GND proseguono lungo la catena. Nel codice crei un oggetto per ogni scheda e passi l'indirizzo al costruttore. Evita l'indirizzo 0x70, perché per impostazione predefinita è l'indirizzo "All Call" del chip, che risponde a tutte le schede insieme. Per approfondire l'indirizzamento I2C leggi Che cos'è l'I2C?.
| Ponticelli saldati | Indirizzo | Esempio d'uso |
|---|---|---|
| Nessuno | 0x40 | 1ª scheda (servo 0–15) |
| A0 | 0x41 | 2ª scheda (servo 16–31) |
| A1 | 0x42 | 3ª scheda |
| A0 + A1 | 0x43 | 4ª scheda |
| A2 | 0x44 | 5ª scheda |
| Tutti A0–A5 | 0x7F | Ultimo indirizzo |
Robot ragno: 18 servo con due PCA9685
In un robot ragno a sei zampe (esapode) ogni zampa ha tre articolazioni: l'anca (coxa) fissata al corpo, la coscia (femore) che alza e abbassa la zampa e il ginocchio (tibia) con la punta che poggia a terra. 6 × 3 = 18 servo superano i 16 canali di una scheda, quindi si collegano due schede in cascata: le zampe sinistre alla scheda con indirizzo 0x40, quelle destre alla scheda 0x41 con il ponticello A0 saldato. Un robot ragno a quattro zampe (quadrupede) con 12 servo sta invece su una sola scheda e lascia liberi 4 canali. Il codice qui sotto indirizza i servo da 0 a 17 con un unico numero, mette in piedi il robot e muove i ginocchi uno alla volta. Posizionare i servo uno per uno, con 100 ms di pausa tra l'uno e l'altro, evita il picco di corrente che si avrebbe alzando tutti e 18 insieme. Per una vera camminata, con il passo a treppiede (tripod) si sollevano tre zampe alla volta mentre le altre tre sostengono il 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}Braccio robotico con ESP32 e PCA9685 controllato da potenziometri
Su ESP32 la stessa libreria Adafruit funziona senza modifiche; i pin I2C sono GPIO 21 (SDA) e GPIO 22 (SCL). In questo esempio comandiamo un braccio robotico a quattro articolazioni (base, spalla, gomito, pinza) con quattro potenziometri. Collega i terminali esterni dei potenziometri a 3V3 e GND e i cursori ai GPIO 34, 35, 32 e 33 del gruppo ADC1: i pin ADC2 non si possono leggere quando il Wi-Fi è attivo, quindi questa scelta ti faciliterà anche l'aggiunta futura di un controllo wireless. L'ADC dell'ESP32 restituisce valori da 0 a 4095. Il codice non fa saltare ogni articolazione all'angolo obiettivo in un colpo solo, ma a ogni ciclo la avvicina del 10% della differenza: questo semplice smorzamento riduce le scosse del braccio e i picchi di corrente. Per la progettazione meccanica e l'ordine delle articolazioni, Braccio robotico con Arduino è un buon punto di partenza.
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 MicroPython con il PCA9685
Il core di MicroPython non include un driver PCA9685 già pronto, ma il chip si gestisce con pochi registri, tanto che puoi scrivere il driver da solo. Il registro MODE1 (0x00) risveglia il chip, il registro PRESCALE (0xFE) imposta la frequenza e i registri ON/OFF da quattro byte di ogni canale partono dall'indirizzo 0x06 e avanzano di quattro in quattro. Il prescaler si calcola con prescale = oscillatore / (4096 × frequenza) − 1 e si può scrivere solo quando il chip è in modalità sleep. Alimenta la scheda dal pin 3V3(OUT) del Pico e collega SDA a GP4 e SCL a GP5. Se sei alle prime armi con MicroPython, ti aiuta l'articolo Basi di MicroPython.
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)Idee di progetto con il PCA9685
- Braccio robotico: comanda un braccio a 4–6 articolazioni con potenziometri o con un joystick e salva i movimenti nella EEPROM per riprodurli.
- Robot ragno: costruisci un robot camminatore a quattro zampe con 12 servo o a sei zampe con 18 servo; a livello avanzato calcola le coordinate della punta della zampa con la cinematica inversa.
- Occhi e viso animatronici: muovi in sincronia 6–8 piccoli servo per palpebre, pupille e sopracciglia.
- Supporto pan-tilt per telecamera: con due servo ruota un modulo ESP32-CAM in orizzontale e in verticale e orientalo via Wi-Fi.
- Coreografia di servo: con due schede muovi 32 servo disposti in cerchio in onde e spirali.
- Dimmer LED a 16 canali: il PCA9685 è in fondo un driver LED; porta la frequenza a 1000 Hz e regola la luminosità di 16 LED senza sfarfallio. Qui usi esattamente la stessa logica del PWM.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| I servo non si muovono affatto | Manca l'alimentazione V+ oppure setPWMFreq non è stata chiamata | Collega l'alimentazione esterna al morsetto e controlla che setup contenga setPWMFreq(50) |
| I servo tremano e scattano a caso | Corrente dell'alimentatore insufficiente, cavi sottili | Alimentatore più potente, cavi spessi e condensatore da 470–1000 µF sulla linea V+ |
| Arduino si resetta quando i servo si muovono | I servo sono alimentati dal pin 5V di Arduino | Dai potenza ai servo solo da V+ e metti in comune i GND |
| Il servo ronza a fine corsa e si scalda | SERVO_MIN o SERVO_MAX fuori dal limite meccanico | Trova i limiti con il codice di calibrazione e resta 5–10 passi all'interno |
| Il codice si blocca o la scheda non viene trovata | Indirizzo sbagliato, SDA e SCL invertiti, due schede con lo stesso indirizzo | Esegui uno scanner I2C e controlla i ponticelli di indirizzo |
| All'avvio i servo scattano bruscamente | Tutti i servo vanno in posizione nello stesso istante | Avvia i servo uno alla volta con una breve pausa tra l'uno e l'altro |
Il PCA9685 è una scheda economica e robusta che mette ordine nel progetto non appena i servo superano i due o tre: una volta impostata la giusta alimentazione e calibrato ogni servo, il resto è solo scrivere angoli. Sulla stessa scheda puoi collegare anche servo più potenti come l'MG996R o servo a rotazione continua per ruote come l'FS90R. Nell'app BlueGrays trovi, con schemi e codice passo dopo passo, progetti come la coreografia circolare a 32 servo, il controllo dei servo con potenziometro e joystick e la serratura per porta RFID con ESP32.
Domande frequenti
Quanti servo si possono controllare con il PCA9685?
Una singola scheda PCA9685 pilota 16 servo in modo indipendente. Poiché con i ponticelli di indirizzo si possono collegare in cascata fino a 62 schede sulla stessa linea I2C, in teoria si gestiscono 992 servo. In pratica il limite non sono le schede, ma la corrente che l'alimentatore dei servo riesce a fornire.
Perché un servo collegato al PCA9685 trema?
La causa più comune è un alimentatore insufficiente: quando i servo si muovono la tensione V+ cala. La seconda è che SERVO_MIN e SERVO_MAX non calibrati portano il servo a battere contro il limite meccanico. Un alimentatore potente, cavi spessi, un condensatore grande sulla linea V+ e i giusti valori limite di solito risolvono il problema.
Qual è la differenza tra VCC e V+ sul PCA9685?
VCC è l'alimentazione logica del chip: si collega a 5V su Arduino Uno e a 3V3 su ESP32 e Pico e assorbe pochissima corrente. V+ è la linea di potenza dei servo e si alimenta da una sorgente esterna da 5–6 V. Scambiarli fa non funzionare la scheda o resetta il microcontrollore.
Come si cambia l'indirizzo I2C del PCA9685?
Metti in corto con lo stagno uno o più pad di saldatura A0–A5 sulla scheda. Senza saldature l'indirizzo è 0x40; saldando A0 diventa 0x41, saldando A1 diventa 0x42. Nel codice basta creare l'oggetto con il nuovo indirizzo, ad esempio Adafruit_PWMServoDriver(0x41).
Il PCA9685 funziona con l'ESP32?
Sì, la libreria Adafruit PWM Servo Driver funziona su ESP32 senza modifiche. Collega SDA a GPIO 21 e SCL a GPIO 22 e alimenta il VCC della scheda da 3V3, così le linee I2C restano a 3,3 V. Il segnale dei servo sarà quindi a 3,3 V, livello che la maggior parte dei servo standard riconosce senza problemi.
A cosa serve il PCA9685 oltre ai servo?
Il chip è in realtà un driver LED a 16 canali: portando la frequenza intorno ai 1000 Hz puoi regolare la luminosità dei LED in 4096 livelli. Si usa anche per controllare la velocità di piccoli motori DC tramite transistor o MOSFET. I canali non pilotano direttamente carichi elevati, generano solo il segnale di controllo.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Coreografia di servo in cerchio - Animazioni con 32 servomotori
Un progetto di animazione visiva con 32 servomotori disposti in cerchio su un Arduino Mega. I servo sono gestiti in un unico array, collegati ai pin 22–53 del Mega, e mostrano quattro sequenze di movimento: una vibrazione caotica ad angoli casuali, una spazzata sincronizzata, un'onda che gira lungo il cerchio e un ago di bussola che oscilla a destra e a sinistra.

Utilizzo del servomotore
Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

Funzionamento del servomotore con potenziometro
Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

Servomotore ESP32 (controllo tramite potenziometro)
In questo progetto controlliamo un servomotore SG90 tramite un potenziometro. Regoliamo l'angolo del servomotore mappando il valore analogico letto dal potenziometro su un intervallo compreso tra 0 e 180 gradi. La libreria ESP32Servo genera segnali per servomotori sui GPIO adatti dell'ESP32 che possono funzionare come uscite; in questo progetto si utilizza GPIO 18. Si tratta di un metodo di controllo fondamentale per bracci robotici, gimbal per telecamere e meccanismi di porte automatiche.

Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
Costruiamo una serratura smart con ESP32, modulo RFID RC522, servo SG90, display OLED SSD1306, buzzer attivo e 2 LED. Quando passi una tessera, il suo UID viene confrontato con quelle autorizzate definite nel codice; se corrisponde, il servo apre (LED verde + 2 bip brevi) e richiude dopo 5 secondi. Con una tessera sconosciuta si accende il LED rosso, suonano 3 bip rapidi e l'OLED mostra l'UID.

Costruzione del servomotore a 360 gradi dal motore passo-passo
Insegna a un normale motore passo-passo ad andare all'angolo che vuoi, lungo tutto il giro.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

