Servo MG90S Arduino : différence avec le SG90, câblage, calibrage
Utiliser un servo MG90S avec Arduino : engrenages métalliques vs SG90, couple de 2,2 kg·cm, couleurs des fils, calibrage 500–2400 µs et code Uno, ESP32, Pico.
Le servo MG90S est un micro servomoteur de la même taille que le SG90 mais avec des engrenages métalliques : avec son boîtier de 13,4 grammes, il fournit un couple de blocage de 1,8 kg·cm sous 4,8 V et de 2,2 kg·cm sous 6 V, et il résiste aux chocs, aux collisions du bras et aux rotations accidentelles à la main bien mieux que le SG90 à engrenages en plastique. Utiliser un servo MG90S avec Arduino est aussi simple qu'un SG90 : les mêmes trois fils, la même bibliothèque Servo et le même signal à 50 Hz. Les différences sont dans les détails : il consomme un peu plus de courant, sa plage d'impulsions varie d'un exemplaire à l'autre et il faut le calibrer si tu veux des angles précis.
Dans ce guide, tu compareras les caractéristiques du MG90S à celles du SG90 et du MG996R, et tu verras les couleurs des fils ainsi que le câblage avec l'Arduino Uno, l'ESP32 et le Raspberry Pi Pico. Ensuite, tu apprendras comment la plage d'impulsions de 500–2400 µs se traduit en angle, comment trouver les limites de ton propre servo depuis le moniteur série et comment corriger l'erreur d'angle avec un calibrage en trois points. Les dernières parties traitent du dimensionnement d'une alimentation séparée, du pilotage depuis ton téléphone avec un ESP32, du code MicroPython pour le Pico et des articulations d'un bras robotique qui conviennent au MG90S.

Qu'est-ce que le servo MG90S et comment fonctionne-t-il ?
Le MG90S renferme un petit moteur à courant continu, un réducteur à engrenages 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. Toutes les 20 ms (50 Hz), la carte mesure la largeur de l'impulsion reçue sur le fil de signal, la compare à l'angle 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 ; plus courte, l'axe tourne d'un côté, plus longue, de l'autre. La bande morte de 5 µs indiquée dans la fiche technique est la moitié des 10 µs du SG90 : le MG90S réagit donc à de plus petites variations d'impulsion et tient sa position plus précisément. Nous avons expliqué le principe des servos depuis la base dans Qu'est-ce qu'un servomoteur ?.
| Caractéristique | Valeur |
|---|---|
| Tension de fonctionnement | 4,8–6 V |
| Couple de blocage | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) ≈ 0,18–0,22 N·m |
| Vitesse (pour 60°) | 0,10 s (4,8 V), 0,08 s (6 V) |
| Courant au repos | Environ 5–10 mA (axe immobile, sans charge) |
| Courant en mouvement | Environ 120–250 mA (sans charge) |
| Courant de blocage | Environ 0,7–1 A |
| Bande morte | 5 µs |
| Course | Environ 180° avec 500–2400 µs (variable selon l'exemplaire) |
| Signal | 50 Hz (période de 20 ms), position donnée par la largeur d'impulsion |
| Engrenages | Métalliques, roulement sur l'axe de sortie |
| Poids et dimensions | 13,4 g, 22,8 × 12,2 × 28,5 mm |
| Câble | Environ 25 cm ; marron GND, rouge positif, orange signal |
| Température de fonctionnement | 0–55 °C |
MG90S ou SG90 : engrenages, couple et courant
Vus de l'extérieur, les deux servos sont presque identiques : trous de fixation, largeur du boîtier et palonniers sont compatibles, tu peux donc monter un MG90S directement dans un support prévu pour le SG90. La vraie différence est à l'intérieur. Les engrenages en plastique du SG90 sautent des dents et cassent quand le bras heurte quelque chose ou que l'axe est forcé à la main ; ceux en métal du MG90S encaissent généralement le même choc sans dommage. Sous 6 V, le couple passe de 1,8 à 2,2 kg·cm et la vitesse descend à 0,08 seconde pour 60 degrés. En contrepartie, le MG90S pèse environ 4,4 grammes de plus, consomme un peu plus de courant au blocage et coûte en général deux à trois fois le prix d'un SG90. Les engrenages métalliques peuvent aussi avoir un léger jeu : sur un bras précis, cela se voit comme un ou deux degrés de flottement quand la charge change de sens.
| Caractéristique | SG90 | MG90S | MG996R |
|---|---|---|---|
| Engrenages | Plastique | Métal | Métal, double roulement |
| Couple de blocage | 1,8 kg·cm (4,8 V) | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) | 9,4 kg·cm (4,8 V), 11 kg·cm (6 V) |
| Vitesse (pour 60°) | 0,10 s (4,8 V) | 0,10 s (4,8 V), 0,08 s (6 V) | 0,17 s (4,8 V), 0,14 s (6 V) |
| Bande morte | 10 µs | 5 µs | 5 µs |
| Poids | 9 g | 13,4 g | 55 g |
| Dimensions | 22,2 × 11,8 × 31 mm | 22,8 × 12,2 × 28,5 mm | 40,7 × 19,7 × 42,9 mm |
| Tension de fonctionnement | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Courant de blocage | Environ 0,6–0,75 A | Environ 0,7–1 A | 2,5 A (6 V) |
| Résistance aux chocs | Faible, les dents cassent facilement | Bonne | Très bonne |
| Sur la broche 5V de l'Arduino | Un servo, charge légère | Un servo, charge légère | Non, toujours une alimentation externe |
| Usage typique | Premiers essais, couvercles légers | Poignet, pince, pan-tilt, petits robots | Épaule de bras robotique, couvercle lourd, direction |



Pour choisir, calcule d'abord le couple nécessaire : le couple est le poids de la charge multiplié par sa distance à l'axe. Une charge de 100 g à 5 cm de l'axe demande 0,1 × 5 = 0,5 kg·cm. Sous 5 V, le MG90S fournit environ 2 kg·cm, mais c'est la limite de blocage, là où l'axe s'arrête ; en usage continu, rester au maximum à la moitié, soit environ 1 kg·cm, garde le servo au frais et prolonge la vie des engrenages. Avec ce calcul, le MG90S porte sans peine jusqu'à 200 g au bout d'un bras de 5 cm et jusqu'à 100 g au bout d'un bras de 10 cm. S'il te faut plus de 1 kg·cm, passe au servo MG996R ; si tu fais seulement des essais ou que tu fais tourner une pièce de quelques grammes, un SG90 suffit.
Couleurs des fils du MG90S et câblage
Les trois fils du MG90S suivent le code couleur de TowerPro. Certains fabricants choisissent d'autres couleurs, mais l'ordre est presque toujours le même, avec le positif au milieu. Si tu branches le connecteur à l'envers, le servo n'est généralement pas endommagé, il ne fonctionne simplement pas ; corrige quand même tout de suite, car le courant de masse du servo essaie alors de passer par la broche de signal de l'Arduino.
| Fil (TowerPro) | Rôle | Autres marques | Se branche sur |
|---|---|---|---|
| Marron | GND (négatif) | Noir | Négatif de l'alimentation et GND de l'Arduino |
| Rouge | Positif (4,8–6 V) | Rouge | 5 V ou positif externe 5–6 V |
| Orange | Signal (PWM) | Jaune ou blanc | Une broche numérique de la carte |
| Branchement | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Orange (signal) | D9 | GPIO 18 | GP15 |
| Rouge (positif) : un servo, charge légère | Broche 5V | Broche 5V (VIN), via l'USB | Broche VBUS (5 V de l'USB) |
| Rouge (positif) : avec charge ou plusieurs servos | Externe 5–6 V | Externe 5–6 V | Externe 5–6 V |
| Marron (GND) | GND et négatif de l'alimentation | GND et négatif de l'alimentation | GND et négatif de l'alimentation |
| Potentiomètre (exemple Uno) | Curseur sur A0, extrémités sur 5V et GND | — | — |
| Second servo (exemple Pico) | — | — | GP14 |
Alimentation séparée : combien de servos, quel courant ?
Un MG90S consomme 120–250 mA quand il bouge à vide, mais pendant les premières millisecondes de chaque démarrage et quand l'axe est forcé, le courant grimpe à 0,7–1 A. Avec plusieurs servos, ces pics s'additionnent. Pense aussi aux fils : les contacts de la plaque d'essai et les fins fils de connexion atteignent facilement 0,2 Ω au total. Avec la loi d'Ohm, lors d'un pic de 3,2 A quand quatre servos démarrent ensemble, on perd 3,2 × 0,2 = 0,64 V rien que dans les fils ; les 5 V de l'alimentation arrivent aux servos sous forme de 4,4 V, et les servos faiblissent et tremblent. Distribuer l'alimentation des servos par un bornier à vis ou une ligne soudée plutôt que par la plaque d'essai réduit fortement cette perte.
| Nombre de servos | En mouvement | Pire cas (tous bloqués) | Alimentation conseillée |
|---|---|---|---|
| 1 | 0,12–0,25 A | Environ 1 A | 5V de l'Arduino pour les essais à vide, 5 V 1 A en charge |
| 2 (pan-tilt) | 0,25–0,5 A | 2 A | 5 V, 2 A |
| 4 (petit bras robotique) | 0,5–1 A | 4 A | 5 V, 3–4 A |
| 6 | 0,75–1,5 A | 6 A | 5–6 V, 5 A et un code qui bouge les servos un par un |
| 16 (PCA9685) | 2–4 A | 16 A | Alimentation à découpage 5–6 V, 10 A ou plus |
- Choisis l'alimentation : utilise un bloc secteur à découpage de 5 V ou 4 accus AA NiMH (4,8 V). Des piles alcalines neuves montent jusqu'à 1,6 V chacune ; un support de 4 piles peut donc donner 6,4 V, un peu au-dessus de la limite du MG90S.
- Envoie le positif au servo : relie le positif de l'alimentation au fil rouge du servo, pas à la broche 5V de l'Arduino.
- Relie les masses : relie le négatif de l'alimentation à la fois au fil marron du servo et à la broche GND de l'Arduino ; sans masse commune, le servo ne lit pas correctement les impulsions.
- Ajoute un condensateur : place un condensateur électrolytique de 470 µF / 16 V sur l'alimentation des servos, près d'eux ; avec plusieurs servos, ajoute environ 100 µF par servo. La patte marquée d'une bande va au négatif.
- Branche le signal : relie le fil orange à la broche D9 de l'Uno et alimente l'Arduino séparément par l'USB ou sa prise jack.
La plage d'impulsions 500–2400 µs et la bibliothèque Servo
Avec la bibliothèque Servo fournie avec l'IDE Arduino, écrire servo.attach(9) donne une plage par défaut de 544–2400 µs, et write(0) et write(180) sont associés à ces deux extrémités. La plupart des MG90S ont besoin d'une impulsion plus courte que 544 µs pour 0 degré ; avec le réglage par défaut, le servo reste donc quelques degrés trop court d'un côté. Indiquer la plage avec servo.attach(9, 500, 2400) règle le problème. Ce détail compte, car writeMicroseconds() ne peut pas non plus sortir des limites passées à attach : sans elles, les 500 µs que tu écris sont relevés en silence à 544. Sur la plage 500–2400 µs, un degré vaut environ 1900 / 180 ≈ 10,6 µs. Comme la bande morte du MG90S est de 5 µs, tu peux même faire des pas d'un demi-degré avec writeMicroseconds().
| Angle | attach(9) par défaut (544–2400) | attach(9, 500, 2400) | Remarque |
|---|---|---|---|
| 0° | 544 µs | 500 µs | Quelques degrés d'écart en bout de course |
| 45° | 1008 µs | 975 µs | — |
| 90° | 1472 µs | 1450 µs | Le vrai centre se situe souvent entre 1450 et 1550 µs |
| 135° | 1936 µs | 1925 µs | — |
| 180° | 2400 µs | 2400 µs | À réduire s'il touche la butée mécanique |
Les valeurs du tableau sont calculées ; sur un vrai servo, l'impulsion pour 90 degrés peut être de 1500 ou 1520 µs au lieu de 1450. Certaines fiches techniques affirment que 1000–2000 µs donnent la course complète, mais en pratique le MG90S ne tourne alors que de 90–100 degrés. Si tu pousses l'impulsion au-delà de la limite mécanique, le servo force contre sa butée interne, bourdonne, tire le courant de blocage et chauffe ; comme les engrenages métalliques encaissent cet effort sans bruit, tu remarques le problème moins vite qu'avec un SG90. C'est pourquoi la première étape consiste à mesurer les limites de ton propre servo.
Calibrage de l'angle : trouve les limites de ton MG90S
Le code ci-dessous déplace le servo par pas de 10 µs grâce aux caractères que tu tapes dans le moniteur série. + allonge l'impulsion, - la raccourcit et c revient au centre (1500 µs) ; n enregistre la valeur actuelle comme limite basse et x comme limite haute. Après chaque enregistrement, le code affiche la ligne attach toute prête pour tes prochains programmes. Pour faire plusieurs pas d'un coup, tape +++++ puis Entrée ; le servo avance de cinq pas, soit 50 µs.
1#include <Servo.h>
2
3const byte SERVO_PIN = 9; // turuncu sinyal kablosu / orange signal wire
4const int STEP_US = 10; // her + ya da - için 10 µs / 10 µs per + or -
5
6Servo servo;
7int pulseUs = 1500; // ortadan başla / start at the center
8int minUs = 1000; // bulunacak alt sınır / lower limit to find
9int maxUs = 2000; // bulunacak üst sınır / upper limit to find
10
11void printPulse() {
12 Serial.print(F("Darbe / pulse: "));
13 Serial.print(pulseUs);
14 Serial.println(F(" us"));
15}
16
17void setup() {
18 Serial.begin(115200);
19 servo.writeMicroseconds(pulseUs); // önce darbe, sonra attach / pulse first, then attach
20 servo.attach(SERVO_PIN, 500, 2500); // geniş aralık: sınırı sen bulacaksın / wide range: you find the limits
21 Serial.println(F("+ / - : 10 us | c: 1500 us | n: min | x: max"));
22 printPulse();
23}
24
25void loop() {
26 if (!Serial.available()) return;
27 char key = Serial.read();
28 if (key == '+') pulseUs += STEP_US;
29 else if (key == '-') pulseUs -= STEP_US;
30 else if (key == 'c') pulseUs = 1500;
31 else if (key == 'n') minUs = pulseUs; // alt sınırı kaydet / save the lower limit
32 else if (key == 'x') maxUs = pulseUs; // üst sınırı kaydet / save the upper limit
33 else return; // Enter ve diğer tuşları yok say / ignore Enter and other keys
34
35 pulseUs = constrain(pulseUs, 500, 2500);
36 servo.writeMicroseconds(pulseUs);
37 printPulse();
38
39 if (key == 'n' || key == 'x') { // hazır attach satırı / ready-made attach line
40 Serial.print(F("servo.attach(9, "));
41 Serial.print(minUs);
42 Serial.print(F(", "));
43 Serial.print(maxUs);
44 Serial.println(F(");"));
45 }
46}- Branche le servo à vide, téléverse le code et ouvre le moniteur série à 115200 bauds.
- Tape c puis Entrée ; le servo se place à 1500 µs. Monte le palonnier sur la cannelure la plus proche du centre de ton mécanisme.
- Descends vers la butée basse avec -. Quand le servo ne tourne plus, bourdonne ou tremble, reviens de 3–4 pas (30–40 µs) et tape n.
- Fais de même vers la butée haute avec + et tape x. Note la ligne servo.attach(9, MIN, MAX) affichée dans le moniteur série.
- Repère les 90 degrés avec un rapporteur dessiné sur papier ou imprimé : enregistre comme US_90 l'impulsion pour laquelle le palonnier est parfaitement vertical.
À cause des cannelures de l'axe, le palonnier ne se monte que par crans fixes ; il est donc rarement pile au centre et tu corriges ces quelques degrés par logiciel. De plus, la relation entre impulsion et angle d'un servo n'est pas parfaitement linéaire : une correspondance à deux points qui vise juste à 0 et 180 degrés peut dériver de 3–5 degrés au milieu. Le calibrage en trois points supprime cette erreur : tu utilises les trois impulsions mesurées pour 0, 90 et 180 degrés et tu appelles la fonction map() séparément pour chaque moitié. Le code ci-dessous applique cette méthode pour transmettre au servo l'angle lu sur un potentiomètre branché sur A0.
1#include <Servo.h>
2
3const byte SERVO_PIN = 9; // turuncu kablo / orange wire
4const byte POT_PIN = A0; // potansiyometre orta bacağı / potentiometer wiper
5
6// Kalibrasyonda ölçtüğün üç nokta / the three points you measured
7const int US_0 = 520; // 0 derece / 0 degrees
8const int US_90 = 1480; // korna tam dik / horn exactly upright
9const int US_180 = 2380; // 180 derece / 180 degrees
10
11Servo servo;
12float smoothAngle = 90; // süzülmüş açı / filtered angle
13int lastAngle = -1;
14
15int angleToUs(int angle) {
16 angle = constrain(angle, 0, 180);
17 if (angle <= 90) return map(angle, 0, 90, US_0, US_90); // alt yarı / lower half
18 return map(angle, 90, 180, US_90, US_180); // üst yarı / upper half
19}
20
21void setup() {
22 servo.writeMicroseconds(angleToUs(90)); // açılışta ortada başla / start centered
23 servo.attach(SERVO_PIN, US_0, US_180);
24}
25
26void loop() {
27 int target = map(analogRead(POT_PIN), 0, 1023, 0, 180);
28 smoothAngle += (target - smoothAngle) * 0.15; // gürültüyü süz / filter the noise
29 int angle = (int)(smoothAngle + 0.5);
30 if (abs(angle - lastAngle) >= 2) { // 2 derecelik ölü bant / 2-degree deadband
31 servo.writeMicroseconds(angleToUs(angle));
32 lastAngle = angle;
33 }
34 delay(15);
35}Remplace US_0, US_90 et US_180 par tes propres mesures. angleToUs() fait correspondre 0–90 aux deux premiers points et 90–180 aux deux derniers, si bien que la position où le palonnier est vertical vaut vraiment 90 degrés. Utiliser writeMicroseconds() évite aussi l'arrondi au degré entier de write(). Les quelques pas de bruit de la lecture du potentiomètre sont atténués par un filtre simple de coefficient 0,15 et une bande morte de 2 degrés ; sans bande morte, le servo frétille sans arrêt sur place. Nous détaillons les autres causes dans servo qui tremble. Sur l'Uno, la bibliothèque Servo utilise le Timer1 : tant qu'un servo est attaché, analogWrite() ne fonctionne pas sur les broches D9 et D10.
MG90S avec l'ESP32 : pilotage depuis ton téléphone avec un curseur
Sur l'ESP32, la bibliothèque Servo standard d'Arduino ne fonctionne pas ; installe la bibliothèque ESP32Servo depuis le gestionnaire de bibliothèques. Elle fonctionne avec les versions 2.x et 3.x du core ESP32, reçoit la période via setPeriodHertz(50) et refuse les limites hors de 500–2500 µs. La sortie de signal de l'ESP32 est en 3,3 V, ce que la quasi-totalité des MG90S lisent sans problème. Le code ci-dessous connecte l'ESP32 à ton réseau Wi-Fi ; ouvre l'adresse IP affichée dans le moniteur série sur un téléphone connecté au même réseau et tu verras un curseur : dès que tu le relâches, le servo tourne à cet angle.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 18; // turuncu kablo / orange wire
8const int MIN_US = 500; // kalibrasyon değerlerin / your calibration values
9const int MAX_US = 2400;
10
11WebServer server(80);
12Servo servo;
13int currentAngle = 90;
14
15const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head>
16<meta name="viewport" content="width=device-width,initial-scale=1"><title>MG90S</title></head>
17<body style="font-family:sans-serif;text-align:center">
18<h2>MG90S: <span id="v">90</span>°</h2>
19<input id="s" type="range" min="0" max="180" value="90" style="width:90%">
20<script>
21const s = document.getElementById('s'), v = document.getElementById('v');
22s.oninput = () => v.textContent = s.value;
23s.onchange = () => fetch('/set?a=' + s.value);
24</script></body></html>)rawliteral";
25
26void handleRoot() {
27 server.send(200, "text/html", PAGE);
28}
29
30void handleSet() {
31 if (server.hasArg("a")) {
32 currentAngle = constrain(server.arg("a").toInt(), 0, 180); // 0–180 ile sınırla / clamp to 0–180
33 servo.write(currentAngle);
34 }
35 server.send(200, "text/plain", String(currentAngle));
36}
37
38void setup() {
39 Serial.begin(115200);
40 servo.setPeriodHertz(50); // 50 Hz servo sinyali / 50 Hz servo signal
41 servo.attach(SERVO_PIN, MIN_US, MAX_US);
42 servo.write(currentAngle);
43
44 WiFi.begin(ssid, password);
45 while (WiFi.status() != WL_CONNECTED) delay(300);
46 Serial.print(F("IP: "));
47 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
48
49 server.on("/", handleRoot);
50 server.on("/set", handleSet);
51 server.begin();
52}
53
54void loop() {
55 server.handleClient();
56}Quand il active le Wi-Fi, l'ESP32 tire brièvement jusqu'à 250 mA ; si le courant de démarrage du servo passe par la même ligne USB, la carte affiche "Brownout detector was triggered" et redémarre. Alimente le servo par une source 5 V séparée et relie les masses ; les détails sont dans erreur brownout de l'ESP32. Pour le signal, les GPIO 13, 18, 19, 23, 25, 26 et 27 sont de bons choix ; évite les GPIO 6–11, reliés à la mémoire flash, et les 34–39, qui sont des entrées uniquement.
MG90S 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(). La petite classe MicroServo ci-dessous mémorise les valeurs de calibrage de chaque servo et avance degré par degré pour un mouvement fluide. Dans l'exemple, le poignet d'un bras robotique est sur GP15 et la pince sur GP14. Sur le Pico, ces deux broches partagent la même tranche PWM (slice 7) et donc la même fréquence ; ce n'est pas gênant puisque les deux utilisent 50 Hz, mais si tu règles une autre broche de la même tranche à 1 kHz pour la luminosité d'une LED, le servo se dérègle aussi. Pour deux servos, utilise une alimentation 5 V externe plutôt que VBUS et relie les masses.
1from machine import Pin, PWM
2import time
3
4class MicroServo:
5 def __init__(self, pin, min_us=500, max_us=2400):
6 self.pwm = PWM(Pin(pin))
7 self.pwm.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
8 self.min_us = min_us # bu servonun kalibrasyonu / this servo's calibration
9 self.max_us = max_us
10 self.angle = None
11
12 def write(self, angle):
13 angle = max(0, min(180, angle)) # 0–180 ile sınırla / clamp to 0–180
14 us = self.min_us + (self.max_us - self.min_us) * angle / 180
15 self.pwm.duty_ns(int(us * 1000)) # µs -> ns
16 self.angle = angle
17
18 def move_to(self, target, ms_per_degree=10):
19 if self.angle is None: # ilk komut: doğrudan git / first command: go directly
20 self.write(target)
21 return
22 step = 1 if target > self.angle else -1
23 for a in range(int(self.angle), int(target) + step, step):
24 self.write(a) # derece derece ilerle / move degree by degree
25 time.sleep_ms(ms_per_degree)
26
27 def off(self):
28 self.pwm.duty_ns(0) # sinyali kes, servo serbest / stop the signal, servo goes limp
29
30wrist = MicroServo(15, 520, 2380) # bilek GP15 / wrist on GP15
31gripper = MicroServo(14, 600, 2300) # kıskaç GP14, aynı PWM dilimi / gripper on GP14, same PWM slice
32
33wrist.write(90)
34gripper.write(20)
35time.sleep(1)
36
37while True:
38 gripper.move_to(70) # kıskacı kapat / close the gripper
39 wrist.move_to(150)
40 time.sleep(0.5)
41 wrist.move_to(30)
42 gripper.move_to(20) # kıskacı aç / open the gripper
43 time.sleep(1)Le MG90S dans un bras robotique : pour quelle articulation ?
Les petits bras robotiques à 4 axes en acrylique ou imprimés en 3D sont en général montés avec quatre micro servos, et là le MG90S dure bien plus longtemps que le SG90 : quand le bras heurte quelque chose ou qu'on force la pince à la main, ce sont les engrenages en plastique qui cassent en premier. Sur un bras plus grand, le MG90S ne sert que pour les articulations d'extrémité. Le calcul est simple : multiplie le poids de chaque pièce située après l'articulation par sa distance à l'axe, puis additionne. Une pince de 40 g à 6 cm et un objet de 50 g à 8 cm imposent au servo du poignet 0,04 × 6 + 0,05 × 8 = 0,64 kg·cm, sous la limite sûre du MG90S d'environ 1 kg·cm sous 5 V.
| Articulation | Charge typique | Le MG90S convient-il ? |
|---|---|---|
| Base (rotation) | Faible si le poids du bras repose sur un roulement | Oui sur les petits bras, MG996R sur les grands |
| Épaule | La plus forte, 2–5 kg·cm | Seulement sur des bras très légers ; en général MG996R |
| Coude | Moyenne, 1–3 kg·cm | Oui sur les bras courts |
| Poignet | Faible, 0,3–1 kg·cm | Oui, idéal |
| Pince | Faible, mais risque de serrage permanent | Oui ; limite l'angle de fermeture selon l'objet |
L'erreur la plus fréquente avec une pince consiste à envoyer le servo au-delà de l'angle où il saisit l'objet. Ne pouvant atteindre sa consigne, le servo tire en permanence le courant de blocage, chauffe, et en quelques minutes le moteur ou la carte de commande peuvent être endommagés. Règle l'angle de fermeture au point où les mâchoires touchent tout juste l'objet, ou recule de quelques degrés une fois l'objet saisi. Tu trouveras le calcul de couple complet et la construction d'un bras à 6 axes dans le guide bras robotique Arduino ; pour piloter plus de six servos avec une seule carte, un contrôleur de servos PCA9685 te simplifie la tâche.
Idées de projets avec le MG90S
- Support pan-tilt pour caméra : oriente un module ESP32-CAM à l'horizontale et à la verticale avec deux MG90S ; les engrenages métalliques supportent les secousses.
- Radar Arduino : fais balayer un capteur HC-SR04 de 0 à 180 degrés par un MG90S et dessine un écran radar ; le montage est dans projet radar Arduino.
- Poubelle intelligente : une poubelle intelligente qui ouvre un couvercle léger quand une main approche.
- Distributeur de croquettes automatique : un distributeur automatique qui ouvre et ferme un petit clapet à heures fixes.
- Robot éviteur d'obstacles : un servo qui sert de cou et tourne le capteur de distance à gauche et à droite ; vois le guide du robot éviteur d'obstacles.
- Mini suiveur solaire : trouve la direction de la lumière avec deux LDR et oriente un petit panneau avec un MG90S ; détails dans suiveur solaire.
- Travaux à rotation continue : pour une roue ou un convoyeur, prends un servo 360 degrés à la place du MG90S.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Il manque quelques degrés d'un côté | La plage par défaut 544–2400 µs | Écris attach(9, 500, 2400) et calibre |
| Il bourdonne et chauffe en bout de course | L'impulsion dépasse la limite mécanique | Réduis aux valeurs MIN et MAX trouvées au calibrage |
| L'Arduino redémarre quand le servo bouge | Le servo est alimenté par l'USB via la broche 5V | Alimentation externe 5 V, masse commune et condensateur de 470 µF |
| Il tremble à l'arrêt | Alimentation faible, fils longs et fins ou bruit du potentiomètre | Fils épais, condensateur, filtre et bande morte |
| Aucune réaction ou mouvements aléatoires | La masse de l'alimentation externe n'est pas reliée à l'Arduino | Relie le négatif de l'alimentation au GND de l'Arduino |
| Cliquetis en charge, l'axe patine | Une dent est cassée ou la vis du palonnier est desserrée | Remplace le jeu d'engrenages, serre la vis centrale |
| Bien moins de couple que prévu, le servo pèse 9 g | Copie à engrenages en plastique | Pèse le servo : un vrai MG90S fait environ 13–14 g |
| Le servo sursaute à la mise sous tension | attach() envoie 1500 µs comme première impulsion | Donne l'impulsion de départ avec writeMicroseconds() avant attach() |
Le MG90S est le bon choix pour tout projet qui veut un servo plus robuste et un peu plus fort tout en gardant la taille d'un SG90. Retiens les règles : une alimentation 5 V externe dès que la charge n'est plus légère, une masse commune, un condensateur près du servo, une plage d'impulsions qui démarre à 500–2400 µs puis se resserre au calibrage, et un angle de fermeture limité sur la pince. Dans l'application BlueGrays, tu trouveras le pilotage de servos au potentiomètre et au joystick, une serrure RFID à servo sur ESP32 et une chorégraphie de 32 servos, chacun avec un schéma de câblage pas à pas et un code prêt à l'emploi.
Questions fréquentes
Quelle est la différence entre le MG90S et le SG90 ?
Ils ont la même taille et le même câblage, mais le MG90S a des engrenages métalliques et atteint 2,2 kg·cm sous 6 V, alors que le SG90, à engrenages en plastique, plafonne vers 1,8 kg·cm et perd facilement des dents lors d'un choc. Le MG90S pèse environ 13,4 g contre 9 g pour le SG90 et consomme un peu plus au blocage. Côté code, aucune différence : les deux fonctionnent avec la même bibliothèque Servo.
Quel poids peut soulever un servo MG90S ?
Le couple de blocage du MG90S est de 1,8 kg·cm sous 4,8 V et de 2,2 kg·cm sous 6 V : à 1 cm de l'axe, il retient tout juste environ 2 kg. En usage continu, compte la moitié du couple : environ 200 g au bout d'un bras de 5 cm et environ 100 g au bout d'un bras de 10 cm.
Peut-on alimenter un MG90S sur le 5V de l'Arduino ?
Pour des essais à vide, un seul MG90S fonctionne sur la broche 5V de l'Arduino. Mais quand le servo force, un courant proche de 1 A dépasse la limite de 500 mA de l'USB et l'Arduino redémarre. Pour un projet avec charge ou plusieurs servos, utilise une alimentation 5 V externe et relie les masses.
Le MG90S tourne-t-il à 180 ou à 360 degrés ?
Le MG90S standard tourne d'environ 180 degrés ; la course complète demande en général des impulsions de 500–2400 µs, et les limites varient d'un exemplaire à l'autre. Il existe aussi des versions à rotation continue 360 degrés, mais avec elles tu pilotes la vitesse et le sens, pas l'angle.
Pourquoi mon servo MG90S tremble ou grésille ?
La cause la plus courante est une alimentation trop faible : un servo alimenté par l'USB fait chuter la tension à chaque démarrage. S'il bourdonne en bout de course, la plage d'impulsions dépasse la limite mécanique ; réduis-la par calibrage. S'il tremble quand tu le pilotes au potentiomètre, filtre la lecture et ajoute une bande morte de 1–2 degrés.
Le MG90S fonctionne-t-il avec un ESP32 et un signal 3,3 V ?
Oui. La carte de commande du MG90S lit sans problème un signal de 3,3 V ; sur l'ESP32, la bibliothèque ESP32Servo suffit, sur le Pico la classe PWM de MicroPython. L'alimentation du servo doit rester à 5 V : ne l'alimente pas par la broche 3,3 V.
Projets à réaliser après cet article
Voir tous les projets
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.

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.

Robot évitant les obstacles
Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?
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

