Componenti · 11 min di lettura

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?.

Servomotore SG90
Il servo più usato con il PCA9685 è l'SG90: ogni canale della scheda accoglie direttamente la sua spina a tre pin.

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.

CaratteristicaValore
ChipNXP PCA9685
Numero di canali16 uscite PWM indipendenti
Risoluzione12 bit (4096 passi per periodo)
Frequenza PWMCirca 24–1526 Hz (50 Hz per i servo)
ComunicazioneI2C, fino a 1 MHz
Indirizzo predefinito0x40 (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 uscita25 mA in assorbimento, 10 mA in erogazione per canale (solo segnale)
Sulla schedaNella maggior parte dei moduli pull-up su SDA/SCL e resistenze serie da 220 Ω sulle uscite
Larghezza d'impulsoPassi (tick) a 50 HzPosizione tipica del servo
0,5 ms (500 µs)≈ 102Circa 0° per l'SG90
1,0 ms (1000 µs)≈ 2050° standard (servo a corsa stretta)
1,5 ms (1500 µs)≈ 307Posizione centrale (90°)
2,0 ms (2000 µs)≈ 410180° standard
2,4 ms (2400 µs)≈ 492Circa 180° per l'SG90

Collegamento del PCA9685: Arduino Uno, ESP32 e Pico

Pin PCA9685Arduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (logica)5V3V33V3(OUT)
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
OELascia scollegato (sulla scheda è a GND)Lascia scollegatoLascia scollegato
V+ (morsetto a vite)Positivo di un alimentatore esterno da 5–6 VPositivo di un alimentatore esterno da 5–6 VPositivo 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)
L'errore più comune è confondere VCC con V+. VCC è solo l'alimentazione logica del chip e assorbe pochi milliampere; la potenza dei servo arriva da V+ sul morsetto a vite. Se provi ad alimentare i servo dal pin 5V di Arduino, la scheda si resetta, la porta USB va in sofferenza e il regolatore si scalda. Su ESP32 e Pico collega sempre VCC a 3V3: le resistenze di pull-up della scheda portano SDA e SCL a VCC, e con VCC a 5 V applicheresti 5 V a pin da 3,3 V. Anche il negativo dell'alimentatore esterno e il GND del microcontrollore devono essere in comune (GND comune).

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.

ServoA riposoIn movimentoIn stalloAlimentazione
SG90 (9 g, ingranaggi in plastica)≈ 10 mA100–250 mA≈ 650 mA4,8–6 V
MG90S (ingranaggi in metallo)≈ 10 mA150–300 mA≈ 700 mA4,8–6 V
MG996R (taglia standard)≈ 10 mA500–900 mA≈ 2,5 A4,8–7,2 V
Aggiungi un condensatore elettrolitico da 470–1000 µF ai morsetti V+ e GND (nel posto libero sulla scheda o direttamente sul morsetto); calcola all'incirca 100 µF per servo. La tensione nominale del condensatore deve essere almeno il doppio di quella di alimentazione (16 V per 6 V) e devi rispettare la polarità. Se hai un alimentatore da 12 V puoi abbassare la tensione a 5–6 V con un convertitore step-down LM2596; tieni però presente che senza dissipatore l'LM2596 lavora bene intorno a 2 A, quindi per robot grandi serve un convertitore più potente.

Prima accensione passo dopo passo: far ruotare 4 servo insieme

  1. Apri il Gestore librerie dell'Arduino IDE, cerca Adafruit PWM Servo Driver e installa la libreria.
  2. Collega i pin VCC, GND, SDA e SCL della scheda ad Arduino come nella tabella sopra; lascia scollegato il pin OE.
  3. 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.
  4. Collega l'alimentatore esterno da 5 V al morsetto a vite: il positivo a V+, il negativo a GND.
  5. 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.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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 saldatiIndirizzoEsempio d'uso
Nessuno0x401ª scheda (servo 0–15)
A00x412ª scheda (servo 16–31)
A10x423ª scheda
A0 + A10x434ª scheda
A20x445ª scheda
Tutti A0–A50x7FUltimo indirizzo
Nella catena anche la linea V+ passa da una scheda all'altra attraverso gli header. Far passare alcuni ampere di corrente dei servo per i sottili pin degli header li scalda e provoca cadute di tensione: per questo porta all'alimentatore cavi separati e spessi verso il morsetto a vite di ogni scheda. Se usi alimentatori diversi, interrompi il collegamento V+ tra le schede e lascia in comune solo il GND, altrimenti colleghi tra loro due alimentatori. Inoltre ogni scheda ha le proprie resistenze di pull-up: con molte schede in cascata la resistenza equivalente scende e affatica la linea; oltre 5–6 schede puoi dissaldare i pull-up di alcune di esse.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

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

SintomoCausa probabileSoluzione
I servo non si muovono affattoManca l'alimentazione V+ oppure setPWMFreq non è stata chiamataCollega l'alimentazione esterna al morsetto e controlla che setup contenga setPWMFreq(50)
I servo tremano e scattano a casoCorrente dell'alimentatore insufficiente, cavi sottiliAlimentatore più potente, cavi spessi e condensatore da 470–1000 µF sulla linea V+
Arduino si resetta quando i servo si muovonoI servo sono alimentati dal pin 5V di ArduinoDai potenza ai servo solo da V+ e metti in comune i GND
Il servo ronza a fine corsa e si scaldaSERVO_MIN o SERVO_MAX fuori dal limite meccanicoTrova i limiti con il codice di calibrazione e resta 5–10 passi all'interno
Il codice si blocca o la scheda non viene trovataIndirizzo sbagliato, SDA e SCL invertiti, due schede con lo stesso indirizzoEsegui uno scanner I2C e controlla i ponticelli di indirizzo
All'avvio i servo scattano bruscamenteTutti i servo vanno in posizione nello stesso istanteAvvia i servo uno alla volta con una breve pausa tra l'uno e l'altro
Gran parte dei tremolii dei servo non dipende dal software ma dall'alimentazione. Misura con un multimetro la tensione su V+ mentre i servo si muovono: se scende sotto 4,5 V, l'alimentatore non basta. Per una diagnosi più dettagliata leggi Problema di tremolio dei servo. Se vuoi che i servo restino morbidi quando il robot è fermo, puoi spegnere del tutto l'uscita di un canale con setPWM(canale, 0, 4096): un servo che non riceve impulsi non esercita coppia e non assorbe corrente.

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.

Vedi tutti i progetti
Coreografia di servo in cerchio - Animazioni con 32 servomotori
AR-97Avanzato
Premium

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.

4.5(40)
62
Utilizzo del servomotore
AR-35Principiante
Premium

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.

4.7(48)
67
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

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.

4.6(37)
53
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

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

4.7(42)
58
Servomotore ESP32 (controllo tramite potenziometro)
ES-16Intermedio
Premium

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.

4.3(29)
42
Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
ES-35Avanzato
Premium

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.

4.8(9)
16
Costruzione del servomotore a 360 gradi dal motore passo-passo
AR-68Intermedio
Premium

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.

4.5(22)
33