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

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éristique | Valeur |
|---|---|
| Puce | NXP PCA9685 |
| Nombre de canaux | 16 sorties PWM indépendantes |
| Résolution | 12 bits (4096 pas par période) |
| Fréquence PWM | Environ 24–1526 Hz (50 Hz pour les servos) |
| Communication | I2C, jusqu'à 1 MHz |
| Adresse par défaut | 0x40 (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 sortie | 25 mA en absorption, 10 mA en fourniture par canal (signal uniquement) |
| Sur la carte | Sur la plupart des modules : résistances de rappel SDA/SCL et résistance série de 220 Ω sur les sorties |
| Largeur d'impulsion | Pas (tick) à 50 Hz | Position typique du servo |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Environ 0° pour un SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | 0° standard (servos à plage étroite) |
| 1,5 ms (1500 µs) | ≈ 307 | Position centrale (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | 180° standard |
| 2,4 ms (2400 µs) | ≈ 492 | Environ 180° pour un SG90 |
Câblage du PCA9685 : Arduino Uno, ESP32 et Pico
| Broche PCA9685 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (logique) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Laisse en l'air (reliée à GND sur la carte) | Laisse en l'air | Laisse en l'air |
| V+ (bornier à vis) | Plus de l'alimentation externe 5–6 V | Plus de l'alimentation externe 5–6 V | Plus 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) |
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.
| Servo | Au repos | En mouvement | En blocage (stall) | Alimentation |
|---|---|---|---|---|
| SG90 (9 g, pignons plastique) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (pignons métal) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (taille standard) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Première mise en route pas à pas : fais tourner 4 servos ensemble
- Dans l'IDE Arduino, ouvre le gestionnaire de bibliothèques, cherche Adafruit PWM Servo Driver et installe-la.
- 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.
- 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.
- Relie l'alimentation externe 5 V au bornier à vis : le plus sur V+, le moins sur GND.
- 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.
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.
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és | Adresse | Exemple d'utilisation |
|---|---|---|
| Aucun | 0x40 | Carte 1 (servos 0–15) |
| A0 | 0x41 | Carte 2 (servos 16–31) |
| A1 | 0x42 | Carte 3 |
| A0 + A1 | 0x43 | Carte 4 |
| A2 | 0x44 | Carte 5 |
| A0–A5 tous | 0x7F | Dernière adresse |
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.
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.
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.
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ôme | Cause probable | Solution |
|---|---|---|
| Les servos ne bougent pas du tout | Pas 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 hasard | Courant de la source insuffisant, câbles trop fins | Source plus puissante, câbles épais et condensateur de 470–1000 µF sur la ligne V+ |
| L'Arduino se réinitialise quand les servos bougent | Les servos sont alimentés par la broche 5V de l'Arduino | Alimente les servos uniquement par V+ et relie les GND |
| Le servo bourdonne et chauffe en bout de course | SERVO_MIN ou SERVO_MAX dépasse la limite mécanique | Trouve les limites avec le code de calibrage et garde 5–10 pas de marge |
| Le code se bloque ou la carte est introuvable | Mauvaise adresse, SDA et SCL inversés, deux cartes à la même adresse | Lance un scanner I2C et vérifie les ponts d'adresse |
| Les servos sursautent brutalement au démarrage | Tous les servos vont en position en même temps | Démarre les servos un par un avec une courte pause entre chacun |
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.
Projets à réaliser après cet article
Voir tous les projets
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.

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.

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.

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

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.

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.

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

