PCA9685 Servo Driver

Présentation

Le PCA9685 est un multiplicateur de servomoteurs. Un microcontrôleur n’a qu’une poignée de canaux PWM matériels, donc piloter les six servomoteurs d’un bras robotique — sans parler des dix-huit d’un hexapode — épuise vite ses broches et minuteurs. Cette petite carte prend ce travail : elle génère 16 signaux PWM indépendants en matériel, et vous les commandez tous sur deux fils I²C. C’est la carte derrière la plupart des robots multi-servos.

Fonctionnement

Vous parlez au PCA9685 en I²C — les mêmes deux broches (SCL/SDA) peuvent aussi porter d’autres capteurs. Vous fixez une fréquence PWM pour toute la puce (50 Hz pour les servomoteurs hobby), puis la largeur d’impulsion de chaque canal pour placer son servomoteur. Comme la puce tient les 16 signaux en matériel, le microcontrôleur envoie juste « canal 3 → 1,5 ms » et passe à autre chose ; il n’a jamais à générer la temporisation lui-même. C’est ce qui garde chaque servomoteur doux même quand les 16 bougent. L’idée largeur-d’impulsion-vers-angle est la même que celle de la page du servomoteur SG90.

Quand l’utiliser

Prenez un PCA9685 dès qu’un robot a plus de servomoteurs que le microcontrôleur n’a de broches PWM, ou quand vous voulez des servomoteurs parfaitement stables :

• Bras robotiques — plusieurs servomoteurs d’articulations bougeant ensemble (associez-le à la cinématique inverse).
• Hexapodes / quadrupèdes — une douzaine ou plus de servomoteurs de pattes.
• Tourelles pan-tilt et montures caméra — libérant les minuteurs du microcontrôleur pour autre chose.

Pour un seul servomoteur de balayage — comme le scan ultrason d’un éviteur d’obstacles — inutile ; le microcontrôleur peut piloter un servomoteur directement.

Câblage et pièges

• Deux rails d’alimentation. Logique (VCC) depuis le microcontrôleur ; puissance des servos depuis le bornier V+. Ne faites jamais passer le courant de 16 servomoteurs par le 5 V de l’Arduino.
• Dimensionnez V+ pour le blocage, pas le repos. Seize servomoteurs peuvent tirer plusieurs ampères ensemble ; une alimentation sous-dimensionnée s’affaisse et toute la carte tremble.
• Fixez des adresses uniques en chaînant des cartes, via les cavaliers à souder.
• Ajoutez un condensateur sur V+ pour absorber les pics de courant au démarrage des servos.

Brochage

Trois groupes de connexions : une barrette de commande câblée au microcontrôleur, seize barrettes servo, et un bornier d’alimentation à ne pas confondre avec le premier.

Le fait le plus lourd de conséquences sur cette carte est que VCC et V+ sont des rails différents. VCC fait marcher la puce ; V+ fait marcher les servos. Les ponter fait passer le courant de blocage des servos dans le régulateur du microcontrôleur, soit le moyen le plus rapide de faire décrocher un Arduino.

Le câbler à un Arduino

OE est plus utile qu’il n’y paraît. La tirer au haut coupe les seize sorties en matériel, instantanément, sans transaction I²C. Sur un bras qui peut tomber par gravité, c’est un vrai arrêt d’urgence, et il marche même si votre code s’est bloqué.

Dimensionner l’alimentation des servos

C’est là que la plupart des projets PCA9685 échouent, et l’arithmétique n’est pas dure.

Un servomoteur hobby tire environ :

Quatre SG90 sur un petit bras, bougeant tous ensemble, font confortablement 1 A et peuvent culminer près de 2,6 A s’ils bloquent tous ensemble — soit exactement ce qui arrive quand le bras cogne son propre cadre. Un chargeur de téléphone 1 A ne suffira pas. Dimensionnez pour tous vos servomoteurs bloqués simultanément, ou au minimum pour tous en mouvement plus un bloqué.

Le symptôme d’une alimentation sous-dimensionnée est distinctif et déroutant : les servos tremblent, la carte peut redémarrer, et cela ressemble à un problème I²C ou de code. Ce n’en est pas un. Mettez un multimètre sur V+ pendant que le bras bouge et regardez-le s’affaisser.

Ajoutez un condensateur sur V+. Quelque chose entre 470–1000 µF, près du bornier. Il ne peut pas porter un blocage soutenu — un condensateur de 1000 µF fournissant 1 A chute d’un volt chaque milliseconde — mais il absorbe le pic de courant franc à l’instant où un servo démarre, ce qui se couple sinon dans le rail logique.

Comment le PWM est réellement généré

Comprendre deux nombres ici rend tout problème de contrôleur de servos plus facile à diagnostiquer.

La puce tourne sur un oscillateur interne 25 MHz et le divise avec un prédiviseur :

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

Pour le 50 Hz que veulent les servos hobby, cela fait round(25000000 / 204800) - 1 = 121.

Chaque période est ensuite divisée en 4096 pas (12 bits). À 50 Hz la période fait 20 ms, donc un pas fait 20 ms / 4096 = 4,88 µs. Cela convertit les largeurs d’impulsion servo qui comptent vraiment en comptes à écrire :

Deux conséquences en découlent directement. D’abord, on obtient environ 205 comptes sur les 180° complets d’un servo, soit juste moins d’un compte par degré — la résolution 12 bits du PCA9685 n’est pas le facteur limitant d’un servo hobby, la zone morte du servo lui-même l’est. Ensuite, le prédiviseur ne s’écrit que puce en mode sommeil, c’est pourquoi toute bibliothèque bascule MODE1 autour d’un changement de fréquence.

L’oscillateur ne fait pas exactement 25 MHz

Les vraies cartes tournent à quelques pour cent du nominal, de façon stable par carte. Si vos servos sont systématiquement courts de leur angle commandé aux deux bouts, la correction n’est pas de trafiquer les largeurs d’impulsion — c’est de mesurer et corriger l’horloge :

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

Mesurez-la en commandant 50 Hz, en mettant un oscilloscope ou un analyseur logique sur une sortie, et en lisant la vraie période. Mettez à l’échelle le 25 MHz nominal par le rapport fréquence commandée sur fréquence mesurée. Faites cela une fois par carte et écrivez le nombre en commentaire.

Code minimal fonctionnel

#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);
  }
}

Les constantes SERVO_MIN/SERVO_MAX sont l’étalonnage, et elles diffèrent par servo — même entre deux du même modèle du même sachet. Trouvez-les en avançant lentement vers l’extérieur depuis 307 et en vous arrêtant dès que le servo bourdonne sans bouger, signe qu’il pousse contre sa propre butée en tirant du courant de blocage pour rien.

Notez aussi le balayage plutôt qu’un saut. setPWM change la position commandée instantanément, et le servo la tentera à pleine vitesse — ce qui sur un bras signifie un mouvement violent et un pic de courant. Avancer la consigne par pas est le profil de mouvement du pauvre, et cela vaut la peine même dans du code de test.

Chaîner des cartes

Chaque carte a six pastilles à souder, A0 à A5, donnant 64 adresses depuis 0x40. Pontez une combinaison différente sur chaque carte :

62 cartes est le maximum documenté — 0x70 est réservé à l’adresse d’appel général I²C, c’est pourquoi ce n’est pas 64 au complet. En pratique, la limite arrive bien plus tôt : 62 cartes font 992 servos, et l’alimentation pour cela est un problème d’ingénierie bien plus gros que le bus.

Un point à surveiller en chaînant : chaque carte porte ses propres pull-ups I²C 10 kΩ, et elles se mettent en parallèle. Dix cartes donnent 1 kΩ, ce qui commence à peser pour un bus 5 V. Passé une poignée de cartes, coupez les cavaliers de pull-up sur toutes sauf une.

Dépannage

PCA9685 ou PWM direct du microcontrôleur ?

Le seuil honnête : un ou deux servos, pilotez-les directement. Une tête de détection pivotante sur un éviteur d’obstacles n’a pas besoin de cette carte. Trois ou plus, ou tout servo dont la douceur compte, et le PCA9685 se paie aussitôt — non pour le nombre de broches, mais parce que le microcontrôleur cesse d’être responsable de la temporisation. Un servo piloté par la bibliothèque Servo tressaillira dès que votre boucle cale ; un piloté par un PCA9685 non.