Driver I2C pca9685 16 servo moteurs

Le driver I2C PCA9685 est la carte qui permet de commander seize sorties PWM avec seulement deux fils de données. Sans elle, chaque servomoteur occuperait une broche du microcontrôleur et un timer logiciel : trois servos saturent déjà un Arduino Uno, et l’imprécision des impulsions générées par programme fait frémir les moteurs. Le PCA9685 génère les seize signaux lui-même, à partir d’un seul circuit intégré, avec une précision de 12 bits.

La carte se commande entièrement par le bus I2C (deux fils, SDA et SCL) et reste maîtresse de la forme d’onde : le microcontrôleur n’envoie qu’un numéro de canal et une valeur. Elle sert aussi bien aux servomoteurs qu’à la variation de luminosité de LED, à condition de choisir la fréquence qui convient à l’usage.

Ce que la carte fait

Le circuit PCA9685 est un contrôleur PWM à seize canaux conçu à l’origine pour piloter des LED en modulation de largeur d’impulsion. Trois de ses propriétés en font un pilote de servomoteurs idéal :

• Seize canaux indépendants, tous à la même fréquence. Chaque sortie a son propre rapport cyclique, réglable sur 4096 pas (12 bits). La fréquence, en revanche, est commune à toute la carte.
• Les impulsions sont générées par le matériel. Une fois la valeur écrite dans le registre du canal, le circuit l’entretient seul. Le programme peut faire autre chose — lire un capteur, piloter un moteur — sans que les servos bronchent.
• Six cavaliers d’adresse. A0 à A5 permettent de déplacer l’adresse I2C de la carte, donc d’en mettre jusqu’à 62 sur le même bus pour arriver à des centaines de sorties.

Ce que la photo montre

• le circuit PCA9685 soudé au centre de la carte, en boîtier à vingt-huit broches ;
• seize connecteurs à trois broches, disposés en deux rangées de huit, numérotés de 0 à 15 : chaque groupe porte le signal (PWM), l’alimentation du moteur (V+) et la masse (GND) ;
• un bornier à vis à deux pôles, repéré POWER et + / −, qui alimente l’ensemble des sorties ;
• un condensateur électrolytique de forte capacité, placé contre le bornier : il absorbe les pointes de courant quand plusieurs servos démarrent ensemble ;
• six pastilles d’adresse A0 à A5, à ponter au fer à souder pour changer d’adresse ;
• le connecteur de commande à six broches, repéré GND, OE, SCL, SDA, VCC, V+, sur le bord de la carte ;
• quelques LED de signalisation et les broches de sortie de l’alimentation logique.

Caractéristiques techniques

Le câblage

Quatre fils suffisent entre l’Arduino et la carte, plus deux pour l’alimentation des servomoteurs.

Chaque servomoteur se branche ensuite sur un groupe de trois broches, en respectant l’ordre de la sérigraphie : le fil de signal sur PWM, le + sur V+, le − sur GND. Sur un SG90, le fil orange ou jaune est le signal, le rouge l’alimentation, le marron la masse ; sur un MG995, le signal est jaune, l’alimentation rouge et la masse marron ou noire. Un servo branché à l’envers ne grille pas forcément, mais il reste immobile : c’est la première chose à vérifier avant de chercher dans le programme.

Sur les cartes Nano et Mega, le bus I2C n’est pas sur les mêmes broches : A4 et A5 sur l’Uno et la Nano, D20 et D21 sur la Mega. Le reste du câblage ne change pas.

Mini-projet : balayer quatre servomoteurs ensemble

Le montage de mise en route : quatre servomoteurs branchés sur les canaux 0 à 3, tous synchronisés, qui balaient l’angle de 0 à 180 degrés puis reviennent. C’est le programme à téléverser pour valider d’un coup le bus I2C, l’alimentation et le sens de rotation des quatre servos.

Ce qu’il faut

Le programme

La bibliothèque Adafruit_PWMServoDriver s’installe depuis le gestionnaire de bibliothèques de l’IDE Arduino (menu Croquis, Inclure une bibliothèque, Gérer les bibliothèques). À téléverser ensuite sur la carte.

/*
 * Carte driver I2C PCA9685 - 16 sorties PWM
 * Montage : quatre servomoteurs sur les canaux 0 a 3
 * Carte de developpement : Arduino Uno R3
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "Wire.h"
#include "Adafruit_PWMServoDriver.h"

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

const int CANAUX[4] = {0, 1, 2, 3};

// Impulsions en nombre de pas du circuit, a 50 Hz.
// 1 pas vaut environ 4,88 microsecondes : 102 pas = 0,5 ms, 512 pas = 2,5 ms.
const int PULS_MIN = 102;   // position 0 degre
const int PULS_MAX = 512;   // position 180 degres

void position(int canal, int angle) {
  int pulse = map(angle, 0, 180, PULS_MIN, PULS_MAX);
  pwm.setPWM(canal, 0, pulse);
}

void setup() {
  pwm.begin();
  pwm.setPWMFreq(50);   // frequence attendue par un servomoteur standard
}

void loop() {
  // Balayage de 0 a 180 degres par pas de 5
  for (int i = 0; i != 37; i++) {
    int angle = i * 5;
    for (int c = 0; c != 4; c++) {
      position(CANAUX[c], angle);
    }
    delay(20);
  }

  delay(500);

  // Retour de 180 a 0 degres
  for (int i = 36; i != -1; i--) {
    int angle = i * 5;
    for (int c = 0; c != 4; c++) {
      position(CANAUX[c], angle);
    }
    delay(20);
  }

  delay(500);
}

Comment ça marche

• La fréquence d’abord, les positions ensuite. pwm.setPWMFreq(50) règle la période à 20 ms, la valeur qu’attend un servomoteur standard. Cette fréquence est commune aux seize canaux : la changer décale toutes les positions calculées avant.
• Une impulsion, pas un rapport cyclique. setPWM(canal, 0, pulse) demande au circuit de laisser la sortie au niveau haut pendant pulse pas à partir du début de la période. Le servomoteur lit cette durée : environ 0,5 ms pour 0 degré, 1,5 ms pour 90 degrés, 2,5 ms pour 180 degrés. La fonction map fait la conversion.
• Le délai règle la vitesse. À 20 ms par pas de 5 degrés, le balayage complet prend une seconde environ. Descendez plus bas et le servo n’aura pas le temps de suivre : il grogne et saute des positions.
• Les quatre servos bougent ensemble parce que la boucle interne écrit successivement les quatre canaux avant le délai. Écrire les canaux un par un, sans cette boucle, produit un léger décalage visible sur un mouvement rapide.
• Le servo tient sa position sans ordre répété. Une fois l’impulsion programmée, le circuit la reproduit à chaque période indéfiniment : le programme peut sortir de la boucle, l’axe ne bougera plus.

Combien de servomoteurs par alimentation

La question qui décide de la réussite du montage n’est pas le nombre de canaux, mais le courant. Un SG90 à vide consomme de l’ordre de 100 à 200 mA et grimpe bien plus haut quand il force ; un MG995 métallique dépasse le milliampère par ampère en pointe. Seize servos qui démarrent en même temps peuvent donc réclamer plusieurs ampères, très au-delà de ce qu’une carte Arduino peut fournir.

• La logique et la puissance sont séparées sur cette carte : VCC alimente le circuit et le bus, V+ alimente les servomoteurs. C’est précisément ce qui permet d’utiliser une alimentation costaude pour les moteurs sans exposer le microcontrôleur.
• Le condensateur de la carte absorbe les pointes, mais il ne remplace pas une alimentation suffisante : il lisse, il ne fournit pas.
• Comptez une alimentation par petit groupe plutôt qu’une seule surdimensionnée si les servos sont nombreux et que le mouvement est simultané. Deux cartes de 5 V 2 A valent mieux qu’une de 5 V 10 A dont le courant passe par un seul fil.
• La masse reste commune entre l’alimentation des servos, la carte driver et le microcontrôleur. C’est le fil que l’on oublie en dernier et qui explique la moitié des montages silencieux.

Adresses I2C : plusieurs cartes sur le même bus

Par défaut, la carte répond à l’adresse 0x40. Si deux cartes partagent le même bus sans adresse distincte, elles répondent toutes les deux aux mêmes ordres et rien ne fonctionne correctement. Les six pastilles A0 à A5 permettent d’ajouter une valeur à cette adresse de base : ponter A0 donne 0x41, A1 donne 0x42, A0 et A1 ensemble donnent 0x43, et ainsi de suite jusqu’à 0x7F.

Le programme déclare alors l’adresse à la construction de l’objet : Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);. Dans le montage, chaque carte garde ses seize canaux et l’ensemble forme un seul bloc logique. Les pastilles sont petites et le pont doit être franc : un cavalier mal soudé donne une adresse qui change au moindre effort sur la carte.

Points d’attention

• Ne branchez jamais l’alimentation des servomoteurs sur VCC. Les deux entrées sont voisines sur le connecteur et les inverser envoie le courant des moteurs dans le circuit logique. Repérez les broches par leur nom imprimé, une fois pour toutes.
• N’alimentez pas quatre servos par la broche 5V de l’Arduino. Le régulateur de la carte de développement chauffe, la tension s’effondre, et le microcontrôleur redémarre en pleine rotation — symptôme typique de servos qui font « sauter » tout le montage.
• Une seule fréquence pour tous les canaux. Vous ne pouvez pas faire tourner des servomoteurs à 50 Hz et faire varier des LED à 1 kHz sur la même carte. Pour les LED seules, une fréquence élevée évite le scintillement visible ; avec un seul servo dans le montage, c’est 50 Hz qui s’impose.
• La broche OE reste inactive à l’état bas. Il est prudent de la relier à la masse pour que les sorties soient toujours validées, ou de la piloter par une broche du microcontrôleur si vous voulez couper d’un coup les seize canaux.
• La puissance doit être établie avant les ordres. Alimenter la carte en I2C alors que les servomoteurs ne sont pas encore alimentés laisse les moteurs sans couple sans que rien n’indique d’erreur.
• Un servo qui vibre sans bouger signale presque toujours une alimentation insuffisante ou une masse commune manquante, pas un défaut de la carte.
• Forcez jamais l’axe à la main. Le réducteur d’un petit servo est en plastique : le tourner de force casse des dents et le rend irréparable.

Questions fréquentes

Le programme compile mais aucun servo ne bouge

Dans l’ordre : vérifiez la masse commune entre l’alimentation des servos, la carte driver et le microcontrôleur ; vérifiez que le bornier V+ reçoit bien la tension et non seulement le connecteur logique ; vérifiez le sens des fiches de servo sur les trois broches (signal, +, −) ; et mesurez la tension au bornier pendant que le programme tourne — une chute au moment du mouvement désigne l’alimentation, pas le programme.

La carte ne répond pas du tout

C’est un problème de bus : SDA et SCL inversés, ou câbles Dupont mal enfoncés. Une bibliothèque de test qui balaie les adresses du bus détecte la carte en quelques secondes et confirme l’adresse réellement utilisée — utile aussi quand plusieurs cartes partagent le bus. Sur un Mega, pensez que le bus est sur D20 et D21, pas sur A4 et A5.

Les servos tremblent en position fixe

Un léger frémissement est normal sur un servo analogique bon marché : il n’a aucun retour de position et corrige en permanence. S’il est franc, cherchez du côté de l’alimentation — une chute de tension momentanée déplace les impulsions. Une fréquence correcte et une alimentation dédiée suffisent dans la très grande majorité des cas.

Peut-on commander un moteur pas à pas avec cette carte ?

Non. Le PCA9685 sort des signaux de commande, il ne fait pas passer le courant des bobinages. Un moteur pas à pas réclame un driver à régulation de courant, ou la carte ULN2003A pour les petits moteurs unipolaires à cinq fils.

Quelle fréquence choisir pour des LED ?

Le plus haut possible pour éviter le scintillement : la plage du circuit monte à environ 1500 Hz. Comme tous les canaux partagent la fréquence, un montage mixte servos et LED se règle sur la contrainte des servos, c’est-à-dire 50 Hz.

À combiner avec

La carte est livrée seule. Pour un robot à quatre pattes ou un bras articulé, les supports de servo donnent des points de fixation propres, et un Arduino Nano réduit l’encombrement une fois le prototype validé sur Uno. Si vous partez de zéro, le kit Arduino Uno starter apporte la carte de développement et les câbles ; il ne restera qu’à y ajouter le driver et les servomoteurs.