Composants · 12 min de lecture

PCA9685 Arduino : contrôleur de servos 16 canaux, guide complet

PCA9685 Arduino : câblage I2C (0x40), alimentation externe des servos, calibrage des impulsions, chaînage de cartes, code pour bras robot et robot araignée.

Le PCA9685 est une carte pilote PWM 12 bits capable de commander 16 servomoteurs en même temps et de façon indépendante, avec un seul bus I2C. Sur l'Arduino Uno, la bibliothèque Servo gère au maximum 12 servos et monopolise un timer entier : les broches manquent et les servos se mettent à trembler. Le PCA9685, lui, génère les impulsions avec son propre oscillateur ; ton microcontrôleur n'a plus qu'à dire « mets ce canal à cette position ». Tu retrouveras cette carte dans presque tous les projets à plusieurs articulations : bras robot, robot araignée, yeux animatroniques ou support de caméra pan-tilt.

Dans ce guide, tu vas voir le câblage du PCA9685 avec Arduino, pourquoi tu dois alimenter les servos avec une source séparée, comment calibrer la largeur d'impulsion pour trouver les vraies positions 0 et 180 degrés de chaque servo, et comment chaîner des cartes grâce aux ponts d'adresse. Ensuite, nous écrirons le code d'un robot araignée à 18 servos avec deux cartes, d'un bras robot piloté par potentiomètres avec un ESP32 et d'un pilote MicroPython sans bibliothèque pour le Raspberry Pi Pico. Si le fonctionnement de base des servomoteurs ne t'est pas familier, jette d'abord un œil à Qu'est-ce qu'un servomoteur ?.

Servomoteur SG90
Le servo le plus utilisé avec le PCA9685 est le SG90 : chaque canal de la carte accepte directement sa fiche à trois broches.

Qu'est-ce que le PCA9685 et comment fonctionne-t-il ?

Le PCA9685 est en réalité une puce conçue par NXP pour piloter des LED, mais sa fréquence réglable la rend parfaite pour les servos. Elle contient un oscillateur de 25 MHz et un compteur de 12 bits commun à tous les canaux : une période PWM est découpée en 4096 pas (ticks). Pour chaque canal, tu écris deux nombres : le pas où le signal monte (ON) et celui où il descend (OFF). Pour les servos, on choisit 50 Hz, soit une période de 20 ms. Un pas dure donc 20 ms / 4096 ≈ 4,88 µs ; pour convertir une largeur d'impulsion en pas, tu utilises la formule tick = impulsion (µs) / 4,88. Par exemple, l'impulsion de position centrale de 1,5 ms correspond à 1500 / 4,88 ≈ 307 pas. Une fois le canal réglé, la carte continue à produire ce signal toute seule : le servo reste en position même si l'Arduino est occupé ailleurs.

CaractéristiqueValeur
PuceNXP PCA9685
Nombre de canaux16 sorties PWM indépendantes
Résolution12 bits (4096 pas par période)
Fréquence PWMEnviron 24–1526 Hz (50 Hz pour les servos)
CommunicationI2C, jusqu'à 1 MHz
Adresse par défaut0x40 (0x40–0x7F avec les ponts A0–A5)
Alimentation logique (VCC)2,3–5,5 V
Alimentation des servos (V+)Externe, généralement 5–6 V selon le servo
Courant de sortie25 mA en absorption, 10 mA en fourniture par canal (signal uniquement)
Sur la carteSur la plupart des modules : résistances de rappel SDA/SCL et résistance série de 220 Ω sur les sorties
Largeur d'impulsionPas (tick) à 50 HzPosition typique du servo
0,5 ms (500 µs)≈ 102Environ 0° pour un SG90
1,0 ms (1000 µs)≈ 2050° standard (servos à plage étroite)
1,5 ms (1500 µs)≈ 307Position centrale (90°)
2,0 ms (2000 µs)≈ 410180° standard
2,4 ms (2400 µs)≈ 492Environ 180° pour un SG90

Câblage du PCA9685 : Arduino Uno, ESP32 et Pico

Broche PCA9685Arduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (logique)5V3V33V3(OUT)
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
OELaisse en l'air (reliée à GND sur la carte)Laisse en l'airLaisse en l'air
V+ (bornier à vis)Plus de l'alimentation externe 5–6 VPlus de l'alimentation externe 5–6 VPlus de l'alimentation externe 5–6 V
GND (bornier à vis)Moins de l'alimentation externe (commun avec GND sur la carte)Moins de l'alimentation externe (commun avec GND sur la carte)Moins de l'alimentation externe (commun avec GND sur la carte)
L'erreur la plus fréquente est de confondre VCC et V+. VCC n'alimente que la logique de la puce et ne consomme que quelques milliampères ; la puissance des servos arrive par V+ sur le bornier à vis. Si tu essaies d'alimenter les servos depuis la broche 5V de l'Arduino, la carte se réinitialise, le port USB est sollicité et le régulateur chauffe. Avec l'ESP32 et le Pico, relie impérativement VCC à 3V3 : les résistances de rappel de la carte tirent SDA et SCL vers VCC, et avec un VCC à 5 V tu appliquerais 5 V à des broches 3,3 V. Le moins de l'alimentation externe doit aussi être relié à la GND du microcontrôleur (GND commune).

Alimentation externe : quel courant consomme un servo ?

Au repos, un servo ne consomme que 5–10 mA, mais quand il bouge, et surtout quand il force sous charge (blocage, ou stall), le courant grimpe d'un coup. Un SG90 qui force peut atteindre 600–700 mA, un MG996R plus de 2 A. Quand toutes les articulations du bras robot se mettent en mouvement en même temps, ces pics s'additionnent et la tension d'une source trop faible s'effondre : résultat, des servos qui tremblent, qui sautent au hasard et un Arduino qui redémarre. La règle pratique : multiplie le nombre de servos qui bougent simultanément par le courant de pointe et choisis une source capable de fournir en continu au moins la moitié du résultat. Pour un bras robot de six SG90, un adaptateur 5 V 3 A convient ; pour un robot araignée à 18 servos, une source 5–6 V 8–10 A ou un UBEC puissant du monde RC est un bon choix.

ServoAu reposEn mouvementEn blocage (stall)Alimentation
SG90 (9 g, pignons plastique)≈ 10 mA100–250 mA≈ 650 mA4,8–6 V
MG90S (pignons métal)≈ 10 mA150–300 mA≈ 700 mA4,8–6 V
MG996R (taille standard)≈ 10 mA500–900 mA≈ 2,5 A4,8–7,2 V
Ajoute un condensateur électrolytique de 470–1000 µF entre les bornes V+ et GND, à l'emplacement prévu sur la carte ou directement sur le bornier ; compte environ 100 µF par servo. Sa tension nominale doit valoir au moins le double de la tension d'alimentation (16 V pour 6 V), et fais attention à la polarité. Si tu as un adaptateur 12 V, tu peux abaisser la tension à 5–6 V avec un module abaisseur LM2596 ; en revanche, sans dissipateur, le LM2596 travaille confortablement autour de 2 A, et les gros robots demandent un convertisseur plus costaud.

Première mise en route pas à pas : fais tourner 4 servos ensemble

  1. Dans l'IDE Arduino, ouvre le gestionnaire de bibliothèques, cherche Adafruit PWM Servo Driver et installe-la.
  2. Relie les broches VCC, GND, SDA et SCL de la carte à l'Arduino comme dans le tableau ci-dessus ; laisse la broche OE en l'air.
  3. Branche les servos sur les canaux 0, 1, 2 et 3. Le fil de signal orange ou jaune de la fiche va du côté PWM, le rouge du côté V+, le marron ou noir du côté GND.
  4. Relie l'alimentation externe 5 V au bornier à vis : le plus sur V+, le moins sur GND.
  5. Allume d'abord l'Arduino par USB et téléverse le code, puis mets l'alimentation des servos sous tension. Si tu n'es pas sûr de l'adresse de la carte, vérifie avec un scanner I2C que 0x40 apparaît.
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() initialise la carte et setPWMFreq(50) règle la période à 20 ms pour les servos. La ligne setOscillatorFrequency(27000000) vient des exemples Adafruit : l'oscillateur interne de la puce est de 25 MHz sur le papier, mais varie en réalité entre 23 et 27 MHz, et la bibliothèque calcule le prédiviseur à partir de cette valeur. Le vrai travail est fait par setPWM(canal, on, off) : en laissant on à 0 et en écrivant le nombre de ticks dans off, l'impulsion démarre au début de la période et se termine à ce pas. La fonction servoAci() convertit 0–180 degrés en plage SERVO_MIN–SERVO_MAX avec map(). La bibliothèque propose aussi writeMicroseconds(canal, µs), qui donne l'impulsion directement en microsecondes ; mais sa précision dépend du réglage de l'oscillateur, donc travailler en ticks et calibrer chaque servo est plus fiable.

Calibrage de la largeur d'impulsion : trouve les vraies limites de chaque servo

Les fabricants annoncent la plage standard de 1–2 ms, mais en réalité chaque servo est différent : un SG90 fait un vrai 180 degrés entre 0,5 et 2,4 ms, alors qu'un autre s'arrête à 170 degrés. Si tu utilises aveuglément les valeurs du tableau, le servo bute contre la butée mécanique en bout de course, bourdonne, consomme du courant inutilement et use ses pignons avec le temps. Le code de calibrage ci-dessous envoie au canal 0 la valeur de ticks que tu tapes dans le moniteur série. Commence autour de 300 et diminue la valeur par pas de 10 ; note comme SERVO_MIN une valeur 5–10 pas au-dessus du point où le servo arrête de tourner ou commence à bourdonner. Fais la même chose dans l'autre sens pour trouver SERVO_MAX. Sur un bras robot ou un robot araignée, chaque articulation est un servo distinct : le plus propre est de répéter la mesure pour chaque servo et de ranger les valeurs dans un tableau.

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}

Chaîner plusieurs cartes PCA9685

Sur le bord supérieur de chaque carte, il y a six ponts d'adresse (pastilles à souder) de A0 à A5. Tous ouverts, l'adresse est 0x40 ; quand tu soudes une pastille, le bit correspondant passe à 1 et sa valeur s'ajoute à l'adresse. En théorie, tu peux ainsi brancher 62 cartes, soit 992 servos, sur le même bus I2C. Les connecteurs à 6 broches des deux côtés de la carte étant en parallèle, il suffit de relier la deuxième carte à la première avec un câble court ; SDA, SCL, VCC et GND se propagent ainsi le long de la chaîne. Dans le code, tu crées un objet par carte et tu lui passes son adresse dans le constructeur. Évite l'adresse 0x70, qui est par défaut l'adresse « tous les appareils » (All Call) de la puce. Pour approfondir l'adressage I2C, consulte Qu'est-ce que l'I2C ?.

Ponts soudésAdresseExemple d'utilisation
Aucun0x40Carte 1 (servos 0–15)
A00x41Carte 2 (servos 16–31)
A10x42Carte 3
A0 + A10x43Carte 4
A20x44Carte 5
A0–A5 tous0x7FDernière adresse
Dans un chaînage, la ligne V+ passe aussi d'une carte à l'autre par les connecteurs. Faire transiter plusieurs ampères de courant de servos par de fines broches les fait chauffer et provoque une chute de tension ; tire donc des câbles séparés et épais depuis l'alimentation jusqu'au bornier à vis de chaque carte. Si tu utilises des alimentations différentes, coupe la liaison V+ entre les cartes et ne laisse que la GND commune ; sinon, tu relies les deux sources entre elles. De plus, comme chaque carte possède ses résistances de rappel, la résistance équivalente diminue quand tu chaînes beaucoup de cartes et charge le bus ; au-delà de 5–6 cartes, tu peux dessouder les résistances de rappel de certaines d'entre elles.

Robot araignée : 18 servos avec deux PCA9685

Dans un robot araignée à six pattes (hexapode), chaque patte a trois articulations : la hanche (coxa) fixée au corps, la cuisse (fémur) qui lève la patte et le genou (tibia) dont l'extrémité touche le sol. 6 × 3 = 18 servos dépassent les 16 canaux d'une seule carte, donc on chaîne deux cartes : les pattes gauches sur la carte d'adresse 0x40, les pattes droites sur la carte d'adresse 0x41 avec le pont A0 soudé. Un robot araignée à quatre pattes (quadrupède) tient sur une seule carte avec 12 servos et laisse 4 canaux libres. Le code ci-dessous adresse les servos de 0 à 17 avec un seul numéro, met le robot debout et fait bouger les genoux à tour de rôle. Positionner les servos un par un, avec 100 ms d'attente entre chacun, évite le pic de courant qu'entraînerait le démarrage simultané des 18 servos. Pour une vraie marche, on utilise l'allure en tripode : trois pattes se lèvent en même temps pendant que les trois autres portent le corps.

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}

Bras robot piloté par potentiomètres avec ESP32 et PCA9685

Sur l'ESP32, la même bibliothèque Adafruit fonctionne sans modification ; les broches I2C sont GPIO 21 (SDA) et GPIO 22 (SCL). Dans cet exemple, on commande un bras robot à quatre articulations (base, épaule, coude, pince) avec quatre potentiomètres. Relie les extrémités des potentiomètres à 3V3 et GND, et les broches centrales aux GPIO 34, 35, 32 et 33 du groupe ADC1 ; comme les broches ADC2 ne sont pas lisibles quand le Wi-Fi est actif, ce choix te facilitera aussi l'ajout d'un contrôle sans fil plus tard. L'ADC de l'ESP32 renvoie des valeurs de 0 à 4095. Au lieu de faire sauter chaque articulation d'un coup vers l'angle cible, le code la rapproche de 10 % de l'écart à chaque boucle ; ce lissage simple réduit les secousses du bras et les appels de courant brutaux. Pour la conception mécanique et l'ordre des articulations, Bras robot Arduino est un bon point de départ.

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}

PCA9685 avec Raspberry Pi Pico et MicroPython

Le noyau de MicroPython ne contient pas de pilote PCA9685 prêt à l'emploi, mais piloter la puce avec quelques registres est si simple que tu peux écrire le pilote toi-même. Le registre MODE1 (0x00) réveille la puce, le registre PRESCALE (0xFE) fixe la fréquence, et les registres ON/OFF de quatre octets de chaque canal commencent à l'adresse 0x06 et avancent de quatre en quatre. La valeur du prédiviseur se calcule avec prescale = oscillateur / (4096 × fréquence) − 1 et ne peut être écrite que lorsque la puce est en mode veille. Alimente la carte depuis la broche 3V3(OUT) du Pico, relie SDA à GP4 et SCL à GP5. Si MicroPython est nouveau pour toi, l'article Les bases de MicroPython t'aidera.

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)

Idées de projets avec le PCA9685

  • Bras robot : commande un bras de 4–6 articulations avec des potentiomètres ou un joystick, enregistre les mouvements dans l'EEPROM et rejoue-les.
  • Robot araignée : construis un robot marcheur à quatre pattes (12 servos) ou à six pattes (18 servos) ; en niveau avancé, calcule la position du bout de patte avec la cinématique inverse.
  • Yeux et visage animatroniques : synchronise 6–8 petits servos pour les paupières, les pupilles et les sourcils.
  • Support de caméra pan-tilt : oriente un module ESP32-CAM à l'horizontale et à la verticale avec deux servos, et pilote-le par Wi-Fi.
  • Chorégraphie de servos : fais bouger 32 servos disposés en cercle, avec deux cartes, en motifs de vagues et de spirales.
  • Variateur de LED à 16 canaux : le PCA9685 est en fait un pilote de LED ; monte la fréquence à 1000 Hz pour régler la luminosité de 16 LED sans scintillement. Tu retrouves ici exactement le principe du PWM.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Les servos ne bougent pas du toutPas d'alimentation V+ ou setPWMFreq n'a pas été appeléBranche une alimentation externe au bornier et vérifie que setPWMFreq(50) est bien dans setup
Les servos tremblent, sautent au hasardCourant de la source insuffisant, câbles trop finsSource plus puissante, câbles épais et condensateur de 470–1000 µF sur la ligne V+
L'Arduino se réinitialise quand les servos bougentLes servos sont alimentés par la broche 5V de l'ArduinoAlimente les servos uniquement par V+ et relie les GND
Le servo bourdonne et chauffe en bout de courseSERVO_MIN ou SERVO_MAX dépasse la limite mécaniqueTrouve les limites avec le code de calibrage et garde 5–10 pas de marge
Le code se bloque ou la carte est introuvableMauvaise adresse, SDA et SCL inversés, deux cartes à la même adresseLance un scanner I2C et vérifie les ponts d'adresse
Les servos sursautent brutalement au démarrageTous les servos vont en position en même tempsDémarre les servos un par un avec une courte pause entre chacun
La plupart des tremblements de servos viennent de l'alimentation et non du logiciel. Mesure la tension V+ avec un multimètre pendant que les servos bougent ; si elle descend sous 4,5 V, ta source est insuffisante. Pour des étapes de diagnostic plus détaillées, consulte Problème de tremblement des servos. Si tu veux que les servos restent souples quand le robot est à l'arrêt, tu peux couper complètement la sortie d'un canal avec setPWM(canal, 0, 4096) ; un servo qui ne reçoit plus d'impulsions n'exerce aucun couple et ne consomme rien.

Dès que le nombre de servos dépasse deux ou trois, le PCA9685 remet de l'ordre dans le projet : une fois la bonne alimentation en place et chaque servo calibré, il ne reste plus qu'à écrire des angles. Pour des articulations plus puissantes, tu peux aussi brancher sur la même carte des servos MG996R, et des FS90R pour des roues à rotation continue. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets comme la chorégraphie circulaire à 32 servos, le contrôle de servos par potentiomètre et joystick, ou la serrure de porte RFID avec ESP32.

Questions fréquentes

Combien de servos peut-on contrôler avec un PCA9685 ?

Une seule carte PCA9685 pilote 16 servos de façon indépendante. Comme on peut chaîner jusqu'à 62 cartes sur le même bus I2C grâce aux ponts d'adresse, 992 servos sont possibles en théorie. En pratique, la limite n'est pas le nombre de cartes mais le courant que ton alimentation peut fournir aux servos.

Pourquoi mon servo tremble-t-il avec le PCA9685 ?

La cause la plus courante est une alimentation insuffisante : la tension V+ chute quand les servos bougent. La deuxième est un SERVO_MIN ou SERVO_MAX non calibré, qui pousse le servo contre sa butée mécanique. Une source puissante, des câbles épais, un gros condensateur sur la ligne V+ et de bonnes valeurs limites règlent souvent le problème.

Quelle est la différence entre VCC et V+ sur le PCA9685 ?

VCC est l'alimentation logique de la puce ; elle se relie au 5V sur l'Arduino Uno, au 3V3 sur l'ESP32 et le Pico, et consomme très peu. V+ est la ligne de puissance des servos, alimentée par une source externe de 5–6 V. Les confondre empêche la carte de fonctionner ou fait redémarrer le microcontrôleur.

Comment changer l'adresse I2C du PCA9685 ?

Tu soudes un ou plusieurs ponts parmi les pastilles A0–A5 de la carte. Sans aucune soudure, l'adresse est 0x40 ; avec A0 soudé, elle devient 0x41, avec A1 soudé, 0x42. Dans le code, il suffit de créer l'objet avec la nouvelle adresse, par exemple Adafruit_PWMServoDriver(0x41).

Le PCA9685 fonctionne-t-il avec l'ESP32 ?

Oui, la bibliothèque Adafruit PWM Servo Driver fonctionne sur l'ESP32 sans modification. Relie SDA à GPIO 21, SCL à GPIO 22 et alimente le VCC de la carte en 3V3 pour que les lignes I2C restent à 3,3 V. Le signal des servos est alors à 3,3 V, niveau que la plupart des servos standard détectent sans problème.

À quoi sert le PCA9685 en dehors des servos ?

La puce est en réalité un pilote de LED à 16 canaux ; en montant la fréquence autour de 1000 Hz, tu peux régler la luminosité des LED sur 4096 niveaux. On l'utilise aussi pour contrôler la vitesse de petits moteurs à courant continu via un transistor ou un MOSFET. Les canaux ne pilotent pas directement de fortes charges, ils ne produisent qu'un signal de commande.

Voir tous les projets
Chorégraphie de servos en cercle - Motifs animés avec 32 servos
AR-97Avancé
Premium

Chorégraphie de servos en cercle - Motifs animés avec 32 servos

Un projet d'animation visuelle avec 32 servomoteurs disposés en cercle sur un Arduino Mega. Les servos sont gérés dans un seul tableau, branchés sur les broches 22 à 53 du Mega, et enchaînent quatre séquences : une vibration chaotique à des angles aléatoires, un balayage synchronisé, une vague qui tourne autour du cercle et une aiguille de boussole qui oscille de gauche à droite.

4.5(40)
62
Utilisation du servomoteur
AR-35Débutant
Premium

Utilisation du servomoteur

Le bras d'un petit servomoteur tourne tour à tour vers trois positions : tout au début, pile au milieu et tout au bout, en attendant deux secondes à chaque arrêt.

4.7(48)
67
Utilisation d'un servomoteur avec un potentiomètre
AR-36Débutant
Premium

Utilisation d'un servomoteur avec un potentiomètre

Quand tu tournes le bouton du potentiomètre, le bras du servomoteur tourne avec lui : un bout du bouton correspond à zéro degré, l'autre à un demi-tour.

4.6(37)
53
Servocommande avec joystick
AR-60Intermédiaire
Premium

Servocommande avec joystick

Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.

4.7(42)
58
Servomoteur ESP32 (commande par potentiomètre)
ES-16Intermédiaire
Premium

Servomoteur ESP32 (commande par potentiomètre)

Dans ce projet, nous contrôlons un servomoteur SG90 à l'aide d'un potentiomètre. Nous réglons l'angle du servomoteur en mappant la valeur analogique lue par le potentiomètre sur une plage de 0 à 180 degrés. La bibliothèque ESP32Servo génère des signaux de servomoteur sur les GPIO appropriés de l'ESP32 pouvant fonctionner en sortie ; ce projet utilise GPIO 18. Il s'agit d'une méthode de contrôle fondamentale pour les bras robotiques, les cardans de caméra et les mécanismes de portes automatiques.

4.3(29)
42
Serrure de porte RFID ESP32 (RC522 + servomoteur + écran OLED + buzzer + LED)
ES-35Avancé
Premium

Serrure de porte RFID ESP32 (RC522 + servomoteur + écran OLED + buzzer + LED)

On fabrique une serrure connectée avec un ESP32, un module RFID RC522, un servo SG90, un écran OLED SSD1306, un buzzer actif et 2 LED. L'UID de la carte lue est comparé aux cartes autorisées définies dans le code ; s'il correspond, le servo ouvre (LED verte + 2 bips courts) puis referme au bout de 5 secondes. Une carte inconnue allume la LED rouge, déclenche 3 bips rapides et affiche son UID sur l'OLED.

4.8(9)
16
Construction d'un servomoteur à 360 degrés à partir d'un moteur pas à pas
AR-68Intermédiaire
Premium

Construction d'un servomoteur à 360 degrés à partir d'un moteur pas à pas

Apprends à un moteur pas à pas ordinaire à aller à l'angle que tu veux, sur tout le tour.

4.5(22)
33