Driver per servomotori PCA9685

Che cos’è

Il PCA9685 è un moltiplicatore di servomotori. Un microcontrollore dispone soltanto di pochi canali PWM hardware, quindi pilotare i sei servomotori di un braccio robotico — per non parlare dei diciotto di un esapodo — esaurisce rapidamente pin e timer. Questa piccola scheda si fa carico del compito: genera 16 segnali PWM indipendenti in hardware e riceve i comandi per tutti tramite due cavi I²C. È la scheda dietro la maggior parte dei robot con più servomotori.

Come funziona

Comunichi con il PCA9685 tramite I²C: gli stessi due pin (SCL/SDA) possono trasportare anche dati di altri sensori. Imposti una sola frequenza PWM per l’intero chip (50 Hz per i servomotori hobbistici), poi imposti la larghezza degli impulsi di ciascun canale per posizionare il relativo servomotore. Poiché il chip gestisce in hardware tutti i 16 segnali, il microcontrollore invia soltanto «canale 3 → 1.5 ms» e prosegue; non deve mai gestire direttamente la temporizzazione bit per bit. È questo che mantiene fluido ogni servomotore anche quando tutti e 16 sono in movimento. L’idea di convertire la larghezza dell’impulso in angolo è la stessa descritta nella pagina del servomotore SG90.

Quando usarlo

Scegli un PCA9685 quando un robot ha più servomotori di quanti pin PWM abbia il microcontrollore, oppure quando vuoi servomotori perfettamente stabili:

• Bracci robotici — più servomotori di giunto che si muovono insieme (abbinalo alla cinematica inversa).
• Esapodi / quadrupedi — servomotori per una dozzina o più di zampe.
• Supporti pan-tilt e per fotocamere — libera i timer del microcontrollore per altre attività.

Per un solo servomotore di scansione — come lo scanner ultrasonoro di un robot che evita ostacoli — non ti serve: il microcontrollore può pilotare direttamente un servomotore.

Cablaggio e aspetti critici

• Due linee di alimentazione. Logica (VCC) dal microcontrollore; alimentazione dei servomotori dal terminale V+. Non far mai passare la corrente di 16 servomotori attraverso il pin 5 V di Arduino.
• Dimensiona V+ per la corrente di stallo, non per quella a riposo. Sedici servomotori possono assorbire insieme diversi ampere; un alimentatore sottodimensionato subisce un calo di tensione e l’intera scheda oscilla.
• Imposta indirizzi univoci quando colleghi le schede in catena, tramite i jumper di saldatura.
• Aggiungi un condensatore tra V+ e terra per assorbire i picchi di corrente all’avvio dei servomotori.

Piedinatura

Tre gruppi di connessioni: un header di controllo da collegare al microcontrollore, sedici header per servomotori e un terminale di alimentazione da non confondere con il primo.

Il fatto più importante di questa scheda è che VCC e V+ sono linee di alimentazione diverse. VCC alimenta il chip; V+ alimenta i servomotori. Collegarle fa passare la corrente di stallo dei servomotori attraverso il regolatore del microcontrollore, che è il modo più rapido di causare un calo di tensione su Arduino.

Cablaggio ad Arduino

OE è più utile di quanto sembri. Portarlo a livello alto disabilita immediatamente e in hardware tutte e sedici le uscite, senza alcuna transazione I²C. Su un braccio che può cadere per gravità è un vero e proprio arresto di emergenza, e funziona anche se il codice si è bloccato.

Dimensionamento dell’alimentatore dei servomotori

Qui sbagliano la maggior parte dei progetti con PCA9685, e il calcolo non è difficile.

Un servomotore hobbistico assorbe all’incirca:

Quattro SG90 su un piccolo braccio, tutti in movimento contemporaneamente, assorbono comodamente 1 A e possono raggiungere picchi vicini a 2.6 A se vanno tutti in stallo insieme — cosa che accade esattamente quando il braccio urta il proprio telaio. Un caricabatterie per telefono da 1 A non basta. Dimensiona l’alimentatore per tutti i servomotori contemporaneamente in stallo o, come minimo, per tutti in movimento più uno in stallo.

Il sintomo di un alimentatore sottodimensionato è distintivo e fuorviante: i servomotori oscillano, la scheda può riavviarsi e sembra un problema di I²C o di codice. Non lo è. Collega un tester a V+ mentre il braccio si muove e osserva il calo di tensione.

Aggiungi un condensatore tra V+ e terra. Qualcosa nell’intervallo 470–1000 µF, vicino al terminale. Non può sostenere uno stallo prolungato — un condensatore da 1000 µF che fornisce 1 A perde un volt ogni millisecondo — ma assorbe il netto picco di corrente nell’istante in cui un servomotore si avvia, che è ciò che si trasferisce alla linea di alimentazione logica.

Come viene generato realmente il PWM

Comprendere due numeri qui rende più facile diagnosticare ogni problema del driver per servomotori.

Il chip funziona con un oscillatore interno da 25 MHz e lo divide mediante un prescaler:

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

Per i servomotori hobbistici a 50 Hz desiderati, il valore è round(25000000 / 204800) - 1 = 121.

Ogni periodo viene poi diviso in 4096 passi (12 bit). A 50 Hz il periodo è di 20 ms, quindi un passo è 20 ms / 4096 = 4.88 µs. Questo converte le larghezze degli impulsi del servomotore che ti interessano nei conteggi da scrivere:

Ne discendono direttamente due conseguenze. Primo, ottieni circa 205 conteggi sull’intera escursione di 180° di un servomotore, cioè appena meno di un conteggio per grado: la risoluzione a 12 bit del PCA9685 non è il fattore limitante di un servomotore hobbistico, ma lo è la zona morta del servomotore stesso. Secondo, il prescaler può essere scritto soltanto mentre il chip è in modalità sleep, motivo per cui ogni libreria attiva e disattiva MODE1 attorno a una modifica della frequenza.

L’oscillatore non è esattamente a 25 MHz

Le schede reali funzionano alcuni punti percentuali fuori dal valore nominale, in modo coerente per ciascuna scheda. Se i servomotori arrivano sistematicamente a un angolo inferiore a quello comandato a entrambi gli estremi, la soluzione non è correggere arbitrariamente le larghezze degli impulsi, ma misurare e correggere il clock:

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

Misuralo comandando 50 Hz, collegando un oscilloscopio o un analizzatore logico a un’uscita qualsiasi e leggendo il periodo reale. Scala il valore nominale di 25 MHz in base al rapporto tra frequenza comandata e misurata. Fallo una sola volta per scheda e annota il valore in un commento.

Codice funzionale minimo

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

// Per-servo calibration. These are NOT universal — measure your own.
const int SERVO_MIN = 150;   // counts at one end stop
const int SERVO_MAX = 600;   // counts at the other

int countsFor(int degrees) {
  return map(constrain(degrees, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
}

void setup() {
  pwm.begin();
  pwm.setOscillatorFrequency(25000000);  // replace with your measured value
  pwm.setPWMFreq(50);                    // hobby servos want 50 Hz
  delay(10);
}

void loop() {
  for (int a = 0; a <= 180; a += 5) {    // sweep, don't jump
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
  for (int a = 180; a >= 0; a -= 5) {
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
}

Le costanti SERVO_MIN/SERVO_MAX sono la calibrazione e variano da un servomotore all’altro, persino tra due dello stesso modello e dello stesso lotto. Per ogni singolo servomotore, aumenta lentamente la corsa a partire da 307 e fermati non appena il servomotore ronzia senza muoversi: significa che sta spingendo contro il proprio finecorsa e assorbe corrente di stallo senza ottenere nulla.

Osserva anche l’uso di una scansione anziché di un salto. setPWM cambia istantaneamente la posizione comandata e il servomotore la eseguirà alla velocità massima, il che su un braccio provoca un movimento violento e un picco di corrente. L’incremento del comando è una soluzione semplice ed economica per definire il profilo di movimento, ma vale la pena applicarla anche nel codice di prova.

Collegamento di più schede in catena

Ogni scheda ha sei superfici di saldatura, da A0 a A5, che forniscono 64 indirizzi a partire da 0x40. Collega una combinazione diversa su ciascuna scheda:

62 schede è il massimo documentato: 0x70 è riservato all’indirizzo I²C di chiamata generale, motivo per cui non sono disponibili tutti i 64. In pratica il limite arriva molto prima: 62 schede sono 992 servomotori e alimentarle è un problema ingegneristico molto più grande del bus.

Una cosa da controllare durante il collegamento in catena: ogni scheda ha le proprie resistenze di pull-up I²C da 10 kΩ, che vengono messe in parallelo. Dieci schede danno 1 kΩ, ormai un carico elevato per un bus a 5 V. Oltre poche schede, rimuovi i jumper di pull-up da tutte tranne una.

Risoluzione dei problemi

PCA9685 o PWM diretto del microcontrollore?

La soglia onesta: uno o due servomotori, pilotali direttamente. Una testa di scansione con sensori su un robot che evita ostacoli non ha bisogno di questa scheda. Tre o più, oppure qualsiasi servomotore la cui fluidità è importante, e il PCA9685 si ripaga immediatamente: non per il numero di pin, ma perché il microcontrollore non è più responsabile della temporizzazione. Un servomotore pilotato dalla libreria Servo scatta ogni volta che il loop si blocca; uno pilotato da un PCA9685 non lo fa.