Servo MG996R avec Arduino : couple, courant, alimentation, code

Le servo MG996R est le servomoteur de référence pour les tâches lourdes dans les projets Arduino, grâce à ses pignons métalliques et à un couple pouvant atteindre 11 kg·cm sous 6 V. Avec ses 55 grammes, il soulève l'épaule d'un bras robotique, ouvre un couvercle lourd ou fait pivoter un support de caméra pan-tilt. Mais cette force a un prix : en charge, le MG996R consomme jusqu'à 2,5 A. Tu ne peux donc pas le brancher simplement sur la broche 5V de l'Arduino comme un SG90 ; il lui faut une alimentation externe de 5–6 V, une masse commune (GND) et un condensateur près du servo. Si tu ignores ces règles, le servo tremble, l'Arduino redémarre sans cesse et l'ordinateur peut même couper le port USB.

Dans ce guide, tu vas apprendre à interpréter le couple et le courant du MG996R avec de vrais chiffres, à choisir la bonne alimentation, à utiliser la plage de 500–2500 µs avec la bibliothèque Servo pour trouver les limites de ton propre servo, et à éviter les tremblements et les redémarrages. Ensuite, on passera au code pour ESP32 et Raspberry Pi Pico, au module PCA9685 qui pilote 16 servos avec deux fils, au choix des servos pour un bras robotique et à la comparaison avec le SG90 et le MG90S.

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

Le MG996R est une version améliorée de l'ancien MG995 de TowerPro : sa carte de commande et ses pignons revus se centrent plus fidèlement et laissent moins de jeu. Dans le boîtier se trouvent un petit moteur à courant continu, un réducteur à pignons métalliques qui ralentit le moteur et multiplie son couple, un potentiomètre qui mesure l'angle de l'axe de sortie et une carte de commande qui gère l'ensemble. La carte lit toutes les 20 ms (50 Hz) la largeur de l'impulsion qui arrive sur le fil de signal, compare l'angle demandé à celui indiqué par le potentiomètre et fait tourner le moteur jusqu'à ce que l'écart disparaisse. Une impulsion d'environ 1500 µs correspond à la position centrale ; les impulsions plus courtes font tourner l'axe d'un côté, les plus longues de l'autre. La bande morte de 5 µs de la fiche technique signifie que le servo ignore les variations plus petites. On a expliqué le principe général des servomoteurs dans Qu'est-ce qu'un servomoteur ?.

Que signifie le couple ? Bien lire la valeur en kg·cm

Le couple est la capacité du servo à faire tourner une charge située à une certaine distance de son axe ; il se mesure en force × distance. 11 kg·cm signifie qu'il peut tenir 11 kg à 1 cm de l'axe ou 1,1 kg à 10 cm ; si la distance double, la charge qu'il peut déplacer est divisée par deux. Pour convertir en newton-mètres, multiplie par 0,098 : 11 kg·cm ≈ 1,08 N·m. Le point essentiel est le suivant : la valeur de la fiche technique est le couple de blocage, c'est-à-dire la limite où l'axe s'arrête, où le courant est maximal et où le servo chauffe. En usage continu, ne pas dépasser la moitié de cette valeur garde le servo au frais, réduit les tremblements et prolonge la vie des pignons.

Le tableau ne tient compte que de la charge en bout de bras. Dans un vrai mécanisme, le poids du bras lui-même, les autres servos montés dessus et la pince s'ajoutent au couple ; il faut multiplier la masse de chaque pièce par sa distance à l'axe, puis tout additionner. Par exemple, si un bras de 15 cm porte à son extrémité une pince de 150 g et un objet de 100 g, ces deux éléments représentent à eux seuls 0,25 × 15 = 3,75 kg·cm ; avec le poids du bras, le total peut atteindre 5 kg·cm. C'est juste en dessous de la moitié du couple de blocage du MG996R sous 6 V, c'est donc le bon choix. Tu trouveras le calcul du couple pièce par pièce, avec un exemple, dans le guide du bras robotique Arduino.

Courant : pourquoi ne pas alimenter le MG996R par la broche 5V de l'Arduino ?

Au repos et sans charge, le MG996R ne consomme qu'environ 10 mA (s'il maintient une charge, ce courant augmente avec elle), mais en mouvement le courant monte à 0,5–0,9 A, et quand l'axe force ou pendant les premières millisecondes de chaque démarrage, il approche 2,5 A. Quand un Arduino Uno est alimenté par USB, le courant total disponible sur sa broche 5V est limité par le fusible de 500 mA de la carte, dont une partie est consommée par la carte elle-même. Au moment où le servo démarre, la ligne 5 V chute nettement pendant quelques millisecondes, le processeur devient instable et la carte redémarre. L'ordinateur peut aussi couper pendant un moment un port USB qui détecte une surintensité.

Les fils font aussi partie du problème. Les fils de liaison fins et les contacts d'une plaque d'essai atteignent facilement 0,2 Ω au total. Calcule-le avec la loi d'Ohm : avec un pic de 2,5 A, 2,5 × 0,2 = 0,5 V se perdent dans le câblage seul ; l'alimentation de 5 V arrive au servo sous 4,5 V, il perd de la force et tremble. Les contacts d'une plaque d'essai sont d'ailleurs prévus pour environ 1 A. Branche les fils d'alimentation du MG996R directement sur un bornier à vis ou sur une barrette de distribution soudée plutôt que sur la plaque d'essai, et utilise du fil de 20–22 AWG.

Bien alimenter : 5–6 V externe, masse commune et condensateur

1. Choisis l'alimentation : Utilise une alimentation à découpage de 5 V ou 6 V capable de fournir le courant du tableau ci-dessus pour ton nombre de servos. Pour les projets portables, 4 piles AA NiMH (4,8 V) ou une LiPo 2S avec un régulateur abaisseur (UBEC) réglé sur 6 V conviennent bien.
2. Envoie le positif uniquement au servo : Relie le positif de l'alimentation au fil rouge du MG996R ; ne le relie pas à la broche 5V de l'Arduino.
3. Relie les masses : Relie le négatif de l'alimentation à la fois au fil marron du servo et à la broche GND de l'Arduino. Le signal est une tension mesurée par rapport à la masse ; sans masse commune, le servo ne comprend pas les impulsions.
4. Branche le signal : Relie le fil orange à la broche D9 de l'Arduino Uno (GPIO 18 sur l'ESP32, GP15 sur le Pico).
5. Ajoute un condensateur : Place un condensateur électrolytique de 470–1000 µF / 16 V entre les fils d'alimentation du servo, le plus près possible de celui-ci ; la patte repérée par la bande va au négatif. Avec plusieurs servos, compte environ 100 µF par servo.
6. Alimente l'Arduino séparément : Fais-le fonctionner par USB ou par la prise jack. Ainsi, les chutes de tension causées par le servo n'atteignent pas le processeur.

La bibliothèque Servo et la plage de 500–2500 µs

La bibliothèque Servo d'Arduino est fournie avec l'IDE. Quand tu écris servo.attach(9), elle utilise par défaut la plage 544–2400 µs et fait correspondre write(0) et write(180) à ces deux extrémités ; beaucoup de MG996R n'atteignent pas tout à fait 180 degrés avec cette plage. Pour l'élargir, écris servo.attach(9, 500, 2500). Ce détail compte, car writeMicroseconds() ne peut pas non plus sortir des limites fixées dans attach : si tu écris writeMicroseconds(2500) sans les avoir définies, la bibliothèque ramène discrètement la valeur à 2400. Par ailleurs, write() interprète les nombres inférieurs à 544 comme des angles et les plus grands comme des microsecondes.

Sur l'Arduino Uno, la bibliothèque Servo gère jusqu'à 12 servos et, comme elle utilise le Timer1, analogWrite ne fonctionne plus sur les broches 9 et 10 tant qu'un servo est attaché. La limite mécanique varie aussi un peu d'un MG996R à l'autre : la fiche technique du fabricant indique environ 120 degrés de rotation avec les impulsions standard de 1000–2000 µs, tandis qu'avec la plage élargie la plupart des servos approchent les 180 degrés. Un servo poussé au-delà de sa limite bute contre sa butée interne, consomme le courant de blocage, grésille et chauffe. La première chose à faire est donc de trouver la plage d'impulsions sûre de ton servo avec le programme ci-dessous.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}

1. Téléverse le programme, ouvre le moniteur série à 115200 bauds et règle la fin de ligne sur Nouvelle ligne.
2. Tape 1500 ; le servo se place au centre. Monte le palonnier à ce moment-là pour qu'il pointe vers la position centrale de ton mécanisme.
3. Descends vers la limite basse par pas de 50 µs avec des valeurs comme 1000, 800 et 700. Si le servo ne bouge plus ou commence à grésiller, reviens de 30–50 µs par rapport à la dernière valeur et note ce nombre comme MIN_US.
4. Fais de même pour la limite haute avec des valeurs comme 2000, 2200 et 2300 afin de trouver MAX_US. Tu utiliseras ces deux nombres dans les programmes suivants.

Mouvement doux : un code qui réduit les pics de courant et les à-coups

Une seule commande comme servo.write(160) projette le servo vers sa cible à pleine vitesse, en parcourant 60 degrés en 0,14 seconde sous 6 V. Pendant ce temps, le moteur consomme presque son courant de blocage, le mécanisme subit un à-coup et l'objet tenu peut tomber. Découper le mouvement en petits pas réduit à la fois les pics de courant et le choc mécanique. Le programme ci-dessous fait avancer le servo de 1 degré toutes les 15 ms (environ 67°/s) et, comme il utilise millis(), tu peux faire autre chose en même temps.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

La fonction angleToUs() convertit l'angle en une impulsion comprise entre les valeurs MIN_US et MAX_US trouvées lors de l'étalonnage ; ainsi, 0 et 180 degrés deviennent les vraies extrémités sûres du servo. Un servo ne mémorise pas sa position hors tension et, dès qu'il reçoit la première impulsion, il rejoint cet angle à pleine vitesse. Appeler writeMicroseconds() avant attach() permet à la bibliothèque de sauter son impulsion par défaut de 1500 µs et d'envoyer directement ton angle de départ ; si tu ramènes le mécanisme dans la même pose de départ avant de l'éteindre, le saut à la mise sous tension disparaît presque. Règle la vitesse avec STEP_MS : 30 ms donne un mouvement lent et doux, 5 ms un mouvement rapide mais saccadé. Pour piloter le servo avec un potentiomètre, il suffit de convertir la lecture en angle et de l'écrire dans la variable target.

Tremblements et redémarrages de l'Arduino : causes et solutions

Piloter le MG996R avec un ESP32

La bibliothèque Servo standard d'Arduino ne fonctionne pas sur l'ESP32 ; installe la bibliothèque ESP32Servo depuis le gestionnaire de bibliothèques. Elle s'utilise presque de la même façon : tu fixes la période avec setPeriodHertz(50), et la bibliothèque refuse les limites en dehors de 500–2500 µs. La sortie de signal de l'ESP32 est en 3,3 V, ce que la grande majorité des MG996R reconnaissent sans problème ; si ton servo ne réagit pas ou se comporte de façon instable, ajoute un convertisseur de niveau logique sur la ligne de signal. Dans l'exemple ci-dessous, un potentiomètre relié à GPIO 34 fait tourner le servo. Comme le CAN de l'ESP32 est sur 12 bits, les lectures vont de 0 à 4095 et sont un peu bruitées ; c'est pourquoi le code filtre et utilise une bande morte.

1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R avec le Raspberry Pi Pico (MicroPython)

Sur le Raspberry Pi Pico, aucune bibliothèque supplémentaire n'est nécessaire : tu règles la PWM sur 50 Hz et tu donnes la largeur d'impulsion en nanosecondes avec duty_ns() ; 500 µs font 500000 ns. Le signal du Pico est lui aussi en 3,3 V. N'alimente pas le servo par la broche VBUS ou VSYS du Pico ; le courant de ces broches vient du port USB de l'ordinateur et le pic de courant du MG996R fera redémarrer le Pico. Alimente le servo avec une source externe et relie les masses. Le code ci-dessous déplace le servo en douceur, degré par degré, entre trois positions.

1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 servos avec un PCA9685 : beaucoup de MG996R avec deux fils

Quand le nombre de servos augmente, ou quand tu utilises des bibliothèques qui coupent les interruptions, le module PCA9685 te simplifie la vie. Cette carte est un générateur PWM 16 canaux sur 12 bits qui dialogue avec l'Arduino en I2C par les seuls fils SDA et SCL. Comme elle génère les impulsions avec sa propre horloge, le signal reste stable même quand le processeur est occupé ailleurs. Son adresse par défaut est 0x40 ; en modifiant l'adresse avec les ponts de soudure A0–A5 de la carte, on peut brancher 62 cartes sur le même bus, soit 992 servos en théorie. À 50 Hz, la période de 20 ms est divisée en 4096 pas, et un pas vaut environ 4,9 µs : 500 µs correspondent à environ 102 pas et 2500 µs à environ 512.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Pour utiliser le programme, installe la bibliothèque Adafruit PWM Servo Driver depuis le gestionnaire de bibliothèques. La ligne setOscillatorFrequency(27000000) est importante : sur le papier, l'horloge interne du PCA9685 tourne à 25 MHz, mais en réalité elle varie entre environ 23 et 27 MHz, et les exemples d'Adafruit utilisent 27 MHz. Sans ce réglage, les impulsions fixées avec writeMicroseconds() peuvent s'écarter de quelques pour cent. Démarrer les servos un par un, à 200 ms d'intervalle, évite que les 16 tirent leur courant de démarrage en même temps. Si chaque servo a ses propres limites, transforme MIN_US et MAX_US en tableaux de 16 éléments et étalonne chaque canal. Le programme fonctionne aussi tel quel sur l'ESP32, car la bibliothèque Wire y utilise par défaut GPIO 21 et 22.

MG996R, SG90 et MG90S : comparatif

C'est la charge et la longueur du bras qui décident. Pour faire tourner une pièce de quelques grammes ou simplement expérimenter, le SG90 suffit. Si tu veux le même format avec des pignons métalliques résistants aux chocs, choisis le MG90S. Si le couple nécessaire dépasse 1 kg·cm, par exemple pour porter 100 g au bout d'un bras de 10 cm, passe au MG996R. Le MG996R offre environ cinq fois le couple du SG90, mais il est plus lent, six fois plus lourd et consomme trois à quatre fois plus de courant ; prévois l'alimentation et la fixation mécanique en conséquence. Si 11 kg·cm ne suffisent toujours pas, regarde du côté des servos plus gros de la classe 20 kg·cm, comme le DS3218.

Choisir les servos d'un bras robotique

• Base : MG996R. Ne fais pas reposer tout le poids du bras sur l'axe du servo ; ajoute un roulement à la base pour que le servo n'ait qu'à le faire tourner.
• Épaule : C'est l'articulation la plus sollicitée. Utilise un MG996R ; si le bras dépasse 20 cm, ajoute un servo de la classe 20 kg·cm ou un contrepoids.
• Coude : MG996R. Placer le servo lourd au niveau de l'épaule et entraîner le coude par une biellette réduit la charge de l'épaule.
• Poignet et rotation du poignet : Un MG90S suffit ; un MG996R ici ne ferait qu'ajouter du poids à porter pour l'épaule.
• Pince : SG90 ou MG90S. Règle l'angle de fermeture au point où les doigts touchent tout juste l'objet ; un servo qui continue à serrer consomme son courant de blocage.
• Fixation : Monte un palonnier métallique sur l'axe à 25 dents du MG996R et bloque-le avec la vis centrale ; les palonniers en plastique s'arrachent vite à ce couple.

Idées de projets avec le MG996R

• Bras robotique : Un bras à 6 servos avec des MG996R à la base, à l'épaule et au coude, et des MG90S au poignet et à la pince ; la construction est dans le guide du bras robotique.
• Caméra pan-tilt : Fais pivoter un module ESP32-CAM à l'horizontale et à la verticale avec deux MG996R.
• Suiveur solaire : Repère la direction de la lumière avec quatre LDR et oriente un petit panneau vers le soleil avec un MG996R ; détails dans l'article sur le suiveur solaire.
• Poubelle intelligente : Une poubelle intelligente qui ouvre un couvercle lourd à l'approche d'une main.
• Serrure à carte : Tire un verrou avec un MG996R quand le RFID RC522 lit la bonne carte.
• Grue au joystick : Une petite grue ou pelleteuse qui se déplace sur deux axes avec un joystick.
• Entraînement continu : Une roue lente mais puissante avec la version à rotation continue (360 degrés) du MG996R ; la différence est expliquée dans l'article sur le servo 360 degrés.

Bien alimenté, le MG996R est un moteur robuste et bon marché qui assure sans peine des tâches impossibles pour les petits servos. Retiens les règles : alimentation externe de 5–6 V, masse commune, condensateur près du servo, plage d'impulsions étalonnée et mouvements doux, puis un PCA9685 quand le nombre de servos augmente. Dans l'application BlueGrays, tu trouveras des projets comme le pilotage d'un servo au potentiomètre et au joystick, une serrure RFID avec ESP32 et servo ou une chorégraphie de 32 servos, chacun avec son schéma pas à pas et son code prêt à l'emploi.