Servomoteur qui tremble : solutions Arduino, ESP32, Pico
Ton servomoteur vibre, tourne tout seul ou fait redémarrer l'Arduino ? Corrige-le avec alimentation, masse commune, condensateur et PWM ESP32/Pico.
Le servomoteur qui tremble est l'une des pannes les plus fréquentes et les plus déroutantes des projets Arduino : le servo bourdonne et vibre là où il devrait rester immobile, il tourne tout seul sans aucune commande, ou l'Arduino redémarre au moment où il bouge et le code repart du début. La bonne nouvelle, c'est que la plupart de ces symptômes ne viennent pas d'un servo défectueux, mais de cinq causes principales : une alimentation insuffisante, l'absence de masse commune, un condensateur manquant, du bruit sur le signal ou un conflit de bibliothèques.
Dans ce guide, on explique pas à pas pourquoi chaque cause apparaît, comment la repérer au multimètre et comment la corriger durablement. Tu y trouveras les calculs de courant pour les servos les plus courants (SG90, MG90S, MG996R), le bon schéma de branchement, le code Arduino qui supprime les vibrations, le réglage PWM avec LEDC sur ESP32 et la solution MicroPython sur Raspberry Pi Pico. Si tu ne connais pas encore le fonctionnement de base d'un servo, commence par Qu'est-ce qu'un servomoteur ?.

Pourquoi un servo tremble-t-il ? Comprendre le principe
Un servo de loisir contient un petit moteur DC, un réducteur, un potentiomètre relié à l'axe de sortie et un circuit de commande. L'Arduino envoie une impulsion toutes les 20 millisecondes (50 Hz) ; sa largeur indique l'angle voulu : environ 0,5–1 ms pour 0 degré, 1,5 ms pour 90 degrés, 2–2,4 ms pour 180 degrés. Le circuit compare cette impulsion à la position réelle lue sur le potentiomètre et fait tourner le moteur pour corriger l'écart. À cause de cette boucle fermée, le servo traite chaque petite variation de largeur comme une nouvelle commande. Si l'impulsion dérive de quelques microsecondes, si la tension d'alimentation chute ou si du parasite s'ajoute, le servo corrige en permanence : c'est le bourdonnement et la vibration que tu constates. Un servo comme le SG90 a une zone morte (deadband) d'environ 10 µs ; dès que la variation du signal la dépasse, le moteur se met en marche.
| Caractéristique | SG90 | MG90S | MG996R |
|---|---|---|---|
| Tension de fonctionnement | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Engrenages | Plastique | Métal | Métal |
| Couple (4,8 V) | Environ 1,8 kg·cm | Environ 1,8 kg·cm | Environ 9,4 kg·cm |
| Courant en mouvement | 100–250 mA | 150–300 mA | 500–900 mA |
| Courant de blocage (stall) | Environ 650–750 mA | Environ 0,7–1 A | Environ 2,5 A |
| Source conseillée (un servo) | 5 V 1 A | 5 V 1 A | 6 V 3 A |
Symptômes et causes probables
| Symptôme | Cause probable | Premier réflexe |
|---|---|---|
| Le servo bourdonne et vibre légèrement à l'arrêt | Signal bruité, lecture instable du potentiomètre, butée mécanique | Ajoute un filtre et une zone morte dans le code, limite l'angle à 5–175 degrés |
| L'Arduino redémarre quand le servo bouge | La tension d'alimentation s'effondre (brownout) | Alimente le servo avec une source externe de 5–6 V |
| Le servo tourne au hasard tout seul | Pas de masse commune ou fil de signal flottant | Relie la masse de l'alimentation externe à la masse de l'Arduino |
| Le servo saute brusquement au démarrage | Commande de 90 degrés envoyée par attach(), broches de démarrage de l'ESP32 | Règle l'angle initial, choisis une broche sûre comme GPIO 18 sur ESP32 |
| Le servo ne tremble que lorsqu'un autre module fonctionne | Une bibliothèque coupe les interruptions ou conflit de timer | Repère la bibliothèque en conflit, utilise au besoin un driver PCA9685 |
| Le servo force et chauffe en butée | La largeur d'impulsion dépasse la limite mécanique du servo | Calibre la plage avec attach(pin, min, max) |
| Un servo 360 degrés tourne lentement au lieu de s'arrêter | Le point neutre (environ 1500 µs) a dérivé | Tourne le trimmer du servo ou affine la valeur d'arrêt |
Cause n°1 : alimentation insuffisante et redémarrage de l'Arduino
La première cause de tremblement et de redémarrage est d'alimenter le servo depuis la broche 5V de l'Arduino. Un SG90 ne consomme que quelques milliampères au repos, mais dans les premières millisecondes du mouvement, surtout sous charge ou si l'axe bute contre un obstacle, il peut dépasser 650 mA. Quand l'Arduino Uno est alimenté par USB, le 5V est limité par le port USB de l'ordinateur et par le fusible réarmable de 500 mA de la carte. Lors d'un appel de courant brusque, la ligne 5V peut descendre sous 4 V. Même si la protection brownout de l'ATmega328P n'intervient qu'autour de 2,7 V, cette chute a déjà perturbé le circuit du servo, les capteurs et la communication série. Si la tension s'effondre assez, le microcontrôleur redémarre, le code repasse par setup(), le servo retourne à sa position initiale, rappelle du courant et tu entres dans une boucle. C'est l'exemple classique du problème de redémarrage spontané de l'Arduino.
Pour confirmer, c'est facile : branche le multimètre entre 5V et GND et fais bouger le servo. Si la tension mesurée descend sous 4,6 V ou saute à chaque mouvement, l'alimentation est en cause. Pour corriger, alimente les servos séparément et base ton calcul sur le courant de blocage : pour un bras robotisé avec quatre SG90, 4 × 0,7 A = 2,8 A ; un adaptateur 5 V 3 A minimum ou un régulateur abaisseur LM2596 est donc judicieux. Avec des servos puissants comme le MG996R, compte 2,5 A par servo. Sur batterie, 4 piles AA (environ 6 V en alcaline, 4,8 V en NiMH) ou un pack Li-ion 2S abaissé à 6 V donnent de bons résultats ; avec le calculateur d'autonomie de batterie, tu peux estimer à l'avance la durée de ton projet.
Le bon branchement : alimentation externe et masse commune
| Fil du servo | Arduino Uno | ESP32 | Raspberry Pi Pico | Alimentation externe 5–6 V |
|---|---|---|---|---|
| Marron / noir (GND) | GND | GND | GND | Moins (-) |
| Rouge (V+) | Non connecté | Non connecté | Non connecté | Plus (+) |
| Orange / jaune (signal) | D9 | GPIO 18 | GP15 | Non connecté |
| GND de l'alimentation externe | GND (commun) | GND (commun) | GND (commun) | Moins (-) |
La ligne la plus critique de ce tableau est la dernière. Le servo mesure l'impulsion du fil de signal par rapport à sa propre masse. Si le moins de l'alimentation externe n'est pas relié à la masse de l'Arduino, le signal n'a plus de référence ; le servo interprète alors les tensions parasites des câbles et le bruit du secteur comme des impulsions aléatoires et se met à tourner tout seul. On a détaillé pourquoi la masse commune est indispensable dans l'article GND et masse commune. Si tu travailles sur breadboard, le module d'alimentation MB102 est une option pratique pour alimenter la ligne du servo ; mais son régulateur est limité en pratique à environ 700–800 mA, donc il convient à un ou deux petits servos au maximum.
Ajouter un condensateur : quelle valeur, où le placer ?
Même avec une alimentation externe, chaque démarrage du moteur du servo provoque des pics de courant de quelques millisecondes. Si les fils sont fins et longs, ces pics créent des creux de tension momentanés ; le circuit du servo devient instable pendant ces creux et les vibrations commencent. La solution est d'ajouter une réserve d'énergie locale sur la ligne d'alimentation : place, le plus près possible du connecteur du servo, entre plus et moins, un condensateur électrolytique de 470–1000 µF et, en parallèle, un condensateur céramique de 100 nF. L'électrolytique fournit le gros courant de courte durée, tandis que le céramique filtre le bruit haute fréquence produit par les balais du moteur. La tension nominale du condensateur doit valoir au moins 1,5–2 fois la tension d'alimentation ; pour une ligne de servo à 5–6 V, un modèle 10 V ou 16 V convient. Avec plusieurs servos, mettre un 470 µF à côté de chacun fonctionne mieux qu'un seul gros condensateur.
Bruit sur le signal et organisation des câbles
- Garde les câbles courts : évite un fil de signal de servo de plus de 50 cm. Si tu dois l'allonger, torsade les fils de signal et de GND (paire torsadée).
- Ajoute une résistance série : une résistance de 220–470 Ω entre la broche de la carte et le fil de signal du servo réduit les réflexions et les oscillations sur les longues lignes, et protège aussi la broche contre un court-circuit.
- Sépare puissance et signal : ne fais pas courir les fils transportant le courant d'un moteur ou d'un relais parallèlement à la ligne de signal du servo ; s'ils doivent se croiser, croise-les à angle droit.
- Vérifie les contacts de la breadboard : des jumpers lâches et des ressorts de breadboard fatigués provoquent des coupures momentanées ; si le tremblement change quand tu touches un fil, c'est un problème de contact.
- Bruit du potentiomètre : si tu commandes le servo avec un potentiomètre, la valeur d'analogRead fluctue de quelques unités et cela se répercute directement sur l'angle. Un condensateur de 100 nF entre le curseur du potentiomètre et GND, plus un filtre dans le code, règle le problème.
- Signal 3,3 V : l'ESP32 et le Pico génèrent des impulsions à 3,3 V. La plupart des servos, comme le SG90 et le MG996R, les reconnaissent sans souci ; pour un servo rare qui se montre instable, tu peux utiliser un convertisseur de niveau logique.
Éviter les tremblements dans le code : filtre et zone morte
Même avec un matériel irréprochable, le logiciel peut faire trembler le servo. Les erreurs les plus fréquentes : appeler attach() à chaque tour de loop(), passer directement à write() la valeur brute du potentiomètre et forcer le servo jusqu'à ses limites physiques (0 ou 180 degrés). Sur les servos bon marché, la butée mécanique se trouve souvent un peu en deçà de 0 et 180 degrés ; le servo n'atteint jamais la cible, continue de pousser, bourdonne et chauffe. Le code ci-dessous prend trois précautions à la fois : il lisse la lecture par moyenne exponentielle, garde l'angle entre 5 et 175 degrés et n'envoie une nouvelle commande au servo que si l'angle change d'au moins 2 degrés. Pour voir d'autres méthodes de filtrage, consulte l'article filtrage des données de capteur.
1#include <Servo.h>
2
3const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
4const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
5const int DEADBAND = 2; // derece cinsinden ölü bölge / dead band in degrees
6
7Servo servo;
8float filtered = 0; // filtrelenmiş okuma / filtered reading
9int lastAngle = -1; // son gönderilen açı / last angle sent
10
11void setup() {
12 servo.write(90); // attach öncesi başlangıç açısı (AVR) / start angle before attach (AVR)
13 servo.attach(SERVO_PIN); // yalnızca bir kez / only once
14 filtered = analogRead(POT_PIN);
15}
16
17void loop() {
18 int raw = analogRead(POT_PIN);
19 filtered = filtered * 0.9 + raw * 0.1; // üstel ortalama / exponential moving average
20 int angle = map((int)filtered, 0, 1023, 5, 175); // sınırlara dayanma / stay away from end stops
21
22 if (lastAngle < 0 || abs(angle - lastAngle) >= DEADBAND) {
23 servo.write(angle); // yalnızca belirgin değişimde / only on a real change
24 lastAngle = angle;
25 }
26 delay(15);
27}| Ligne / commande | À quoi ça sert ? |
|---|---|
| servo.write(90) (avant attach) | Avec la bibliothèque Servo AVR standard, la première impulsion démarre à 90 degrés ; cela réduit le saut au démarrage. |
| filtered = filtered * 0.9 + raw * 0.1 | Moyenne mobile exponentielle : elle supprime les variations brusques et laisse passer les changements lents. Plus le coefficient 0.1 est petit, plus le filtre est fort mais plus la réaction est lente. |
| map(..., 5, 175) | Fait fonctionner le servo sans le plaquer contre ses butées mécaniques. |
| DEADBAND = 2 | N'envoie pas de nouvelle commande si l'angle change de moins de 2 degrés ; la zone morte supprime les petites vibrations. |
| delay(15) | Laisse au servo le temps d'atteindre la nouvelle position et limite la fréquence de lecture. |
| attach(pin, 500, 2400) | Sert à calibrer la plage d'impulsions sur les vraies limites du servo ; les valeurs par défaut sont 544 et 2400 µs. |
| servo.detach() | Coupe l'impulsion une fois la cible atteinte ; le bourdonnement cesse, mais le servo perd son couple de maintien. |
Conflits de bibliothèques et de timers
La bibliothèque Servo standard de l'Arduino Uno génère les impulsions avec le timer matériel Timer1 et des interruptions. Cette conception permet de piloter jusqu'à 12 servos avec un seul timer, mais elle a deux effets secondaires : elle ne peut pas fonctionner en même temps qu'une autre bibliothèque utilisant Timer1, et la précision des impulsions dépend de l'exécution des interruptions à temps. Tout code qui désactive les interruptions pendant quelques centaines de microsecondes allonge l'impulsion en cours et le servo sursaute. Si le tremblement ne commence que lorsqu'un module précis entre en jeu, tu es presque certainement dans ce cas.
- analogWrite sur les broches 9 et 10 : avec la bibliothèque Servo, le PWM ne fonctionne plus sur ces deux broches de l'Uno ; déplace la LED ou le driver de moteur qui y est branché vers la broche 3, 5, 6 ou 11.
- Bibliothèques RF 433 MHz : VirtualWire et le pilote RH_ASK de RadioHead utilisent aussi Timer1 par défaut ; tu verras une erreur de compilation ou des mouvements de servo irréguliers. Pour les détails, lis l'article module RF 433 MHz.
- Rubans NeoPixel : Adafruit NeoPixel et FastLED désactivent les interruptions pendant l'envoi des données ; sur un long ruban, cela dure des millisecondes et le servo sursaute à chaque mise à jour. Si des WS2812B et un servo cohabitent, mets le ruban à jour moins souvent.
- SoftwareSerial et DHT : les deux coupent brièvement les interruptions pendant la réception d'un octet ou la lecture du capteur ; c'est une cause fréquente des tremblements sur les bras de servo commandés par un module Bluetooth.
- Solution durable : utiliser un driver de servos PCA9685 qui génère les impulsions avec son propre matériel ; quoi que fasse l'Arduino, jusqu'à 16 servos reçoivent un signal stable.
Réglages PWM du servo sur ESP32
Sur ESP32, la bibliothèque Servo standard d'Arduino ne fonctionne pas ; on utilise soit la bibliothèque ESP32Servo, soit directement le module PWM LEDC intégré. Comme LEDC est matériel, il n'est pas affecté par les interruptions et génère des impulsions très stables ; la seule condition est de régler la fréquence sur 50 Hz et une résolution suffisante. À 14 bits, la période de 20 ms est divisée en 16384 pas ; chaque pas vaut environ 1,22 µs, ce qui est largement assez précis pour un servo. On choisit 14 bits parce que les puces récentes comme l'ESP32-S3 et l'ESP32-C3 le supportent aussi. Les fonctions LEDC ont changé dans la version 3.x du noyau ESP32 Arduino, donc le code ci-dessous est écrit pour compiler avec les deux versions :
1// ESP32 Arduino core 2.x ve 3.x uyumlu / compatible with ESP32 Arduino core 2.x and 3.x
2const int SERVO_PIN = 18; // güvenli bir GPIO / a safe GPIO
3const int PWM_FREQ = 50; // 50 Hz = 20 ms periyot / 20 ms period
4const int PWM_BITS = 14; // ESP32, S3 ve C3 destekler / supported by ESP32, S3 and C3
5const int MIN_US = 500; // 0 derece darbesi / 0 degree pulse
6const int MAX_US = 2400; // 180 derece darbesi / 180 degree pulse
7
8#if ESP_ARDUINO_VERSION_MAJOR < 3
9const int PWM_CHANNEL = 0; // 2.x için LEDC kanalı / LEDC channel for 2.x
10#endif
11
12uint32_t usToDuty(uint32_t us) {
13 return us * ((1UL << PWM_BITS) - 1) / 20000UL; // mikrosaniyeyi duty değerine çevir / convert microseconds to duty
14}
15
16void servoWriteUs(uint32_t us) {
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18 ledcWrite(SERVO_PIN, usToDuty(us)); // 3.x: pin numarası / pin number
19#else
20 ledcWrite(PWM_CHANNEL, usToDuty(us)); // 2.x: kanal numarası / channel number
21#endif
22}
23
24void servoWriteAngle(int angle) {
25 angle = constrain(angle, 0, 180);
26 servoWriteUs(map(angle, 0, 180, MIN_US, MAX_US));
27}
28
29void setup() {
30#if ESP_ARDUINO_VERSION_MAJOR >= 3
31 ledcAttach(SERVO_PIN, PWM_FREQ, PWM_BITS);
32#else
33 ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_BITS);
34 ledcAttachPin(SERVO_PIN, PWM_CHANNEL);
35#endif
36 servoWriteAngle(90); // başlangıç konumu / start position
37}
38
39void loop() {
40 for (int a = 30; a <= 150; a++) { // yumuşak tarama / smooth sweep
41 servoWriteAngle(a);
42 delay(15);
43 }
44 for (int a = 150; a >= 30; a--) {
45 servoWriteAngle(a);
46 delay(15);
47 }
48}Il y a deux autres pièges propres à l'ESP32. Le premier concerne les broches de démarrage : des broches comme GPIO 0, 2, 12, 14 et 15, ainsi que les broches 1 et 3 du port série, peuvent émettre de courtes impulsions au démarrage ; si le servo est dessus, il sursaute à chaque reset. Pour les servos, GPIO 13, 18, 19, 23, 25, 26, 27, 32 et 33 sont des choix sûrs ; les broches 34–39 sont en entrée seule et ne peuvent pas piloter un servo. Le second est la sensibilité à l'alimentation : avec le Wi-Fi actif, l'ESP32 tire déjà des pics de plus de 300 mA, et si le servo est alimenté par la même ligne, tu verras le message « Brownout detector was triggered » dans le moniteur série. On a traité cette erreur dans l'article brownout et Guru Meditation sur ESP32 ; en bref, alimente le servo séparément et relie les masses.
Servo sur Raspberry Pi Pico (MicroPython)
Chaque broche GPIO du Raspberry Pi Pico peut générer du PWM matériel ; la puce dispose de 8 tranches PWM et de 16 canaux au total. En MicroPython, après avoir réglé la fréquence de l'objet PWM sur 50 Hz, tu peux donner directement la largeur d'impulsion en nanosecondes avec duty_ns() ; c'est bien plus sûr que de jongler avec des pourcentages ou des duty sur 16 bits. Le code ci-dessous commande le servo sur GP15 avec le potentiomètre sur GP26 et applique exactement la même logique de filtre et de zone morte que l'exemple Arduino. La sortie 3V3 du Pico ne convient pas pour alimenter un servo, ni en tension ni en courant ; alimente le servo avec une source externe de 5 V et mets les masses en commun.
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15)) # servo sinyali GP15 / servo signal on GP15
5servo.freq(50) # 50 Hz = 20 ms
6pot = ADC(26) # potansiyometre GP26 (ADC0) / potentiometer on GP26 (ADC0)
7
8MIN_US = 500 # 0 derece / 0 degrees
9MAX_US = 2400 # 180 derece / 180 degrees
10DEADBAND = 2 # ölü bölge (derece) / dead band (degrees)
11
12def write_angle(angle):
13 angle = max(5, min(175, angle)) # sınırlara dayanma / stay away from end stops
14 us = MIN_US + (MAX_US - MIN_US) * angle // 180
15 servo.duty_ns(us * 1000) # mikrosaniye -> nanosaniye / microseconds -> nanoseconds
16
17filtered = pot.read_u16()
18last = -100
19write_angle(90) # başlangıç konumu / start position
20
21while True:
22 filtered = filtered * 0.9 + pot.read_u16() * 0.1 # üstel ortalama / exponential moving average
23 angle = int(filtered * 180 / 65535)
24 if abs(angle - last) >= DEADBAND:
25 write_angle(angle)
26 last = angle
27 time.sleep_ms(20)Liste de contrôle étape par étape
- Débranche le servo de la carte et alimente-le uniquement avec une source externe de 5–6 V ; vérifie que son courant couvre le nombre de servos × le courant de blocage.
- Relie la masse de l'alimentation externe à la masse de l'Arduino, de l'ESP32 ou du Pico ; ce seul fil met fin à la plupart des problèmes de « rotation toute seule ».
- Mesure la tension d'alimentation au multimètre pendant que le servo bouge ; si elle descend sous 4,6 V, prends une source plus puissante ou des fils plus gros.
- Ajoute un condensateur électrolytique de 470–1000 µF et un céramique de 100 nF à côté du connecteur du servo, en vérifiant les polarités.
- Raccourcis le fil de signal, ajoute si besoin une résistance série de 220–470 Ω et fiabilise les contacts de la breadboard.
- Vérifie dans le code qu'attach() n'est appelé que dans setup(), que l'angle reste entre 5 et 175 degrés et que tu utilises un filtre et une zone morte.
- Si le servo tremble quand un autre module fonctionne, désactive les bibliothèques une par une pour trouver le conflit ; passe au PCA9685 si nécessaire.
- S'il tremble toujours, remplace-le par un autre servo pour tester ; un servo dont le potentiomètre est usé ou l'engrenage cassé tremble dans toutes les conditions.
Points d'attention pour les projets avec servos
- Bras robotisé : sur un bras robotisé à quatre ou six servos, ne les fais pas tous bouger en même temps ; espace les commandes de 100–200 ms pour que les pics de courant ne s'additionnent pas.
- Projet radar : dans les projets de balayage continu comme un radar Arduino, fais tourner le servo degré par degré et attends 15–30 ms à chaque pas ; de grands sauts brusques provoquent à la fois des tremblements et des pics de courant.
- Charges lourdes : pour une serrure de porte ou un support de caméra, utilise le MG996R à engrenages métalliques plutôt qu'un SG90, et choisis une source d'au moins 3 A.
- Servos à rotation continue : si des servos 360 degrés comme le FS90R dérivent à l'arrêt, ce n'est pas un tremblement mais un problème de calibration ; ajuste finement autour de 1500 µs pour l'arrêt.
- Projets sur batterie : relâcher le servo avec detach() une fois le mouvement terminé supprime le bourdonnement et prolonge l'autonomie ; c'est très efficace si le mécanisme ne glisse pas sous son propre poids.
Un servo qui tremble paraît compliqué au premier abord, mais il se règle presque toujours dans le même ordre : d'abord l'alimentation, puis la masse commune, ensuite le condensateur, le câblage et enfin le logiciel. En suivant cet ordre, tu auras rarement besoin de changer le servo lui-même. Pour les détails du calcul de puissance, jette aussi un œil au guide alimentation de l'Arduino. Dans l'application BlueGrays, tu trouveras pas à pas les schémas et les codes de projets comme la commande de servo par potentiomètre, le servo avec joystick, le servo ESP32 et la serrure de porte RFID, pour mettre tout de suite en pratique ce que tu as appris ici.
Questions fréquentes
Pourquoi mon servomoteur tremble-t-il ?
La cause la plus courante est une tension d'alimentation insuffisante ou instable : quand le servo est alimenté par la broche 5V de l'Arduino, la tension chute lors des appels de courant et le circuit de commande devient instable. D'autres causes possibles : absence de masse commune, signal bruité, valeurs fluctuantes du potentiomètre et servo forcé contre sa butée mécanique. Une alimentation externe de 5–6 V, une masse commune et un condensateur de 470–1000 µF règlent la plupart des cas.
Pourquoi mon servo tourne-t-il tout seul ?
Si le servo tourne sans aucune commande, c'est en général que la ligne de signal n'a pas de référence : la masse de l'alimentation externe n'est pas reliée à celle de l'Arduino, ou le fil de signal est mal connecté. Le servo prend alors le bruit capté par les câbles pour des impulsions. Sur les servos 360 degrés, la rotation lente vient d'une dérive du point neutre (environ 1500 µs) qu'on corrige avec le trimmer du servo.
Pourquoi l'Arduino redémarre-t-il quand le servo fonctionne ?
Au démarrage, un servo peut tirer des centaines de milliampères, et plus de 2 A pour les gros modèles. Si ce courant passe par la ligne USB ou le régulateur de l'Arduino, le 5 V s'effondre et le microcontrôleur redémarre. Alimente le servo avec une source séparée et relie seulement les masses : les redémarrages s'arrêtent.
Quel condensateur en µF faut-il pour un servo ?
Pour un SG90 ou un MG90S, un électrolytique de 470 µF près du connecteur du servo est un bon début ; pour un gros servo comme le MG996R, prends 1000 µF. Ajouter un céramique de 100 nF filtre aussi le bruit haute fréquence. La tension nominale doit être d'au moins 10 V pour une ligne de 5–6 V, et la polarité doit être respectée.
Peut-on alimenter un servo depuis la broche 5V de l'Arduino ?
Pour essayer un seul SG90 à vide, la broche 5V suffit souvent, mais ce n'est pas une solution fiable. La ligne USB est limitée à environ 500 mA et un servo bloqué dépasse cette valeur. Avec deux servos ou plus, un servo sous charge ou un MG996R, utilise obligatoirement une source externe.
Pourquoi mon servo tremble-t-il ou ne marche-t-il pas sur ESP32 ?
Sur ESP32, la bibliothèque Servo standard d'Arduino ne fonctionne pas ; il faut utiliser ESP32Servo ou le PWM LEDC réglé sur 50 Hz. Brancher le servo sur une broche de démarrage comme GPIO 0, 2, 12 ou 15 provoque des sauts à chaque reset, et l'alimenter depuis la ligne de l'ESP32 entraîne des erreurs de brownout. Une broche sûre comme GPIO 18 et une alimentation 5 V séparée règlent le problème.
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.

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.

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

