Guides · 13 min de lecture

Projets servomoteur Arduino : 15 idées avec SG90 et MG996R

15 projets servomoteur Arduino : radar, bras robotique, serrure, suiveur solaire, distributeur ; choisir SG90, MG90S ou MG996R, alimentation et PCA9685.

Les projets servomoteur Arduino sont le moyen le plus simple de faire vraiment bouger quelque chose : avec un seul fil, tu indiques un angle, le servo s'y rend et y reste. Dans ce guide, nous avons réuni 15 projets à servomoteur, du radar à ultrasons au bras robotique, en passant par la serrure RFID, le suiveur solaire et le distributeur automatique de croquettes. Pour chaque projet, tu trouveras dans un seul tableau quel servo choisir, combien il en faut, s'il vaut mieux les piloter directement depuis l'Arduino ou via un driver PCA9685, et comment les alimenter.

Avant les projets, nous verrons les différences entre le SG90, le MG90S et le MG996R, comment choisir l'alimentation selon le nombre de servos et combien de servos un Arduino Uno, un ESP32 ou un Raspberry Pi Pico peut piloter en même temps. Viennent ensuite des modèles de code compilés et prêts à l'emploi pour le radar, le bras robotique et le suiveur solaire. Si tu débutes avec les servos, lis d'abord Qu'est-ce qu'un servomoteur ?.

Micro servomoteur SG90 avec son câble trois couleurs
Micro servo SG90 : 9 grammes, environ 1,8 kg·cm de couple ; fil marron GND, rouge positif et orange signal.

Quel servo choisir : SG90, MG90S ou MG996R ?

La première valeur à regarder pour choisir un servo est le couple : il s'exprime en kg·cm et indique combien de kilos le servo peut tenir à 1 cm de l'axe. Plus le bras est long, moins il soulève, dans la même proportion ; un SG90 de 1,8 kg·cm tient à peine 300 grammes au bout d'un bras de 6 cm, et pas en continu. Le deuxième point est la matière des engrenages : le plastique saute sous l'effort, le métal encaisse les chocs. Le troisième est le courant : un gros servo demande une grosse alimentation. En pratique, le SG90 convient aux couvercles légers et aux capteurs à orienter, le MG90S aux petits mécanismes sollicités souvent ou en charge, et le MG996R à l'épaule d'un bras robotique et aux couvercles lourds.

ModèleCoupleEngrenagesCourant de blocageAlimentation conseilléeProjet type
SG901,8 kg·cm (4,8 V)Plastique650-750 mA5 VRadar, pan-tilt, petit couvercle
MG90S1,8-2,2 kg·cmMétal0,7-1 A5-6 VSerrure, pince, robot araignée
MG996R9,4-11 kg·cmMétal, double roulement2,5 A (6 V)6 V, 3 A par servoÉpaule de bras robotique, rideau, couvercle lourd
FS90R (360°)1,5 kg·cmPlastiquejusqu'à 800 mA5 VRoues, plateau tournant
Servomoteur MG996R à engrenages métalliques et ses palonniers
MG996R : engrenages métalliques et jusqu'à 11 kg·cm de couple ; idéal pour les bras robotiques et les mécanismes lourds, mais toujours avec une alimentation externe.

Tableau d'alimentation des servos : combien de servos, quel courant ?

Dans les projets à servos, la plupart des problèmes viennent de l'alimentation, pas du code. Au moment où il démarre, un servo appelle une brève pointe de courant ; si la broche 5V de l'Arduino, alimentée par l'USB, ne suit pas, la tension chute, la carte redémarre et le servo tremble. La règle est simple : un seul SG90 peu chargé peut tourner sur la broche 5V de l'Arduino ; au-delà, alimente les servos avec une alimentation externe de 5-6 V, relie son négatif au GND de l'Arduino et ajoute un condensateur de 470-1000 µF sur la ligne des servos. Pour dimensionner l'alimentation, additionne les courants de fonctionnement des servos et garde au moins 50 % de marge.

MontageCourant en mouvement (env.)Alimentation conseillée
1 × SG90, charge légère100-250 mALa broche 5V de l'Arduino suffit
2 × SG90 ou MG90S0,3-0,6 AExterne 5 V, 2 A
4 × MG90S (petit bras robotique)0,6-1,2 AExterne 5 V, 3 A
1 × MG996R0,5-0,9 A (2,5 A bloqué)6 V, 3 A
6 × MG996R (grand bras robotique)3-5,4 AAlimentation à découpage 6 V, 10 A
12 × MG90S (robot araignée)1,8-3,6 A5-6 V, 5 A, ou LiPo 2S avec BEC de 5 A
N'alimente jamais plusieurs servos, ni même un seul MG996R, par la broche 5V de l'Arduino, et n'essaie pas de les faire tourner sur une pile 9 V : ces petites piles ne fournissent pas le courant d'un servo et la carte redémarre sans arrêt. Avec une alimentation externe, n'oublie pas de relier les masses ; sans masse commune, le signal n'a plus de référence et le servo bouge au hasard.

Piloter les servos en direct ou avec un PCA9685 ?

Piloter quelques servos directement depuis les broches du microcontrôleur est la solution la plus simple. La bibliothèque Servo de l'Arduino Uno utilise le Timer1 pour générer les impulsions de 12 servos au maximum, mais pendant ce temps analogWrite ne fonctionne plus sur les broches 9 et 10. L'ESP32 attribue un canal PWM matériel à chaque servo et le Pico dispose de 16 canaux PWM. Dès que tu dépasses 5 ou 6 servos, que les impulsions se mettent à trembler ou que tu as besoin des broches pour autre chose, le driver PCA9685 entre en jeu : il pilote 16 servos avec seulement deux broches I2C et, comme il génère les impulsions avec sa propre horloge, il soulage le microcontrôleur. Son installation est détaillée dans le guide contrôleur de servos PCA9685.

PlateformeBibliothèqueServos en directAttention
Arduino Uno / NanoServo (intégrée)Jusqu'à 12Utilise le Timer1 : analogWrite ne marche plus sur D9 et D10
Arduino MegaServo (intégrée)Jusqu'à 48Beaucoup de servos demandent quand même une alimentation externe
ESP32ESP32ServoJusqu'à 16GPIO 18, 19, 21, 22, 23, 25, 26, 27 sûres ; 34-39 en entrée seulement
Raspberry Pi Picomachine.PWM (MicroPython)Jusqu'à 16Deux broches d'une même tranche PWM partagent la fréquence ; sans importance à 50 Hz
PCA9685 (avec toute carte)Adafruit PWM Servo Driver16 par carte, jusqu'à 62 cartes chaînéesL'alimentation des servos arrive par le bornier V+ de la carte

15 projets à servomoteur : servo, nombre et mode de pilotage

#ProjetServoNombrePilotageNiveau
1Réglage de l'angle au potentiomètreSG901DirectDébutant
2Radar à ultrasonsSG901DirectDébutant
3Couvercle de poubelle automatiqueMG90S1DirectDébutant
4Distributeur de croquettes automatiqueMG90S ou MG996R1DirectIntermédiaire
5Serrure à badge RFID ou à codeMG90S1DirectIntermédiaire
6Thermomètre à aiguille avec servoSG901DirectDébutant
7Tête pivotante du robot éviteur d'obstaclesSG901DirectIntermédiaire
8Support caméra pan-tilt au joystickSG902DirectDébutant
9Suiveur solaireMG90S2DirectIntermédiaire
10Barrière de passage à niveau (maquette)SG902DirectDébutant
11Ouvre-rideau ou ouvre-trappe en Wi-FiMG996R1Direct (ESP32)Intermédiaire
12Plateforme auto-stabilisée avec MPU6050MG90S2DirectAvancé
13Bras robotique de bureau 4 axesMG90S ou SG904Direct ou PCA9685Intermédiaire
14Bras robotique 6 axesMG996R et MG90S6PCA9685Avancé
15Robot araignée quadrupèdeMG90S12PCA9685Avancé

Projets à un servo (1-7)

  • 1. Réglage de l'angle au potentiomètre : le « hello world » des servos. Tu convertis la valeur 0-1023 du potentiomètre en 0-180 degrés avec map() et tu l'envoies au servo. Le code et le câblage sont dans Qu'est-ce qu'un servomoteur ? ; tu réutiliseras la même logique dans tous les projets suivants.
  • 2. Radar à ultrasons : un capteur de distance HC-SR04 est collé sur un SG90, le servo balaie de 15 à 165 degrés et la distance mesurée à chaque angle part sur le port série. Sur l'ordinateur, un programme Processing transforme ces données en l'écran radar vert classique. Détails dans le projet radar Arduino, le code est plus bas.
  • 3. Couvercle de poubelle automatique : un HC-SR04 placé devant détecte une main à moins de 20 cm, le servo ouvre le couvercle et le referme quelques secondes plus tard. Si le couvercle est lourd, prends un MG90S à engrenages métalliques plutôt qu'un SG90 ; voir la poubelle intelligente.
  • 4. Distributeur de croquettes automatique : à heures fixes, le servo ouvre quelques secondes la trappe placée sous le réservoir. Un module RTC donne l'heure et la durée d'ouverture fixe la portion. Les distributeurs à vis sans fin demandent plus de couple, un MG996R ou un servo 360 degrés est alors préférable ; voir le distributeur automatique.
  • 5. Serrure à badge RFID ou à code : quand le bon badge RFID est présenté ou que le bon code est saisi sur le clavier matriciel, le servo tire le verrou. Comme le pêne frotte, un MG90S à engrenages métalliques dure bien plus longtemps.
  • 6. Thermomètre à aiguille avec servo : fixe une aiguille sur le palonnier et place derrière un carton gradué de 0 à 40 °C ; la température mesurée par le DHT11 est convertie en angle avec map(). La même idée sert d'indicateur d'humidité, de niveau sonore ou de nombre d'abonnés.
  • 7. Tête pivotante du robot éviteur d'obstacles : quand le robot s'arrête, le HC-SR04 monté sur le servo regarde à gauche et à droite, et le robot tourne du côté le plus dégagé. Ce simple ajout le rend bien plus malin qu'un robot à capteur fixe ; voir le robot éviteur d'obstacles.

Projets à deux servos (8-12)

  • 8. Support caméra pan-tilt au joystick : deux SG90 sont montés l'un sur l'autre : celui du bas tourne à l'horizontale (pan), celui du haut à la verticale (tilt). Les axes X et Y d'un module joystick sont affectés aux deux servos ; on peut fixer dessus une petite caméra, un laser ou un capteur.
  • 9. Suiveur solaire : quatre LDR mesurent de quel côté la lumière est la plus forte et deux servos orientent le panneau à l'horizontale et à la verticale vers la direction la plus lumineuse. Le vent force sur le bras du panneau, des MG90S sont donc un bon choix. Détails dans le suiveur solaire, le code ESP32 est plus bas.
  • 10. Barrière de passage à niveau : pour un réseau de train miniature ou un projet scolaire, deux SG90 abaissent et relèvent les barrières, des LED rouges clignotent en alternance et un buzzer donne l'alerte. L'arrivée du train est détectée par un capteur infrarouge ou un interrupteur reed ; ralentir le servo donne un rendu très réaliste.
  • 11. Ouvre-rideau ou ouvre-trappe en Wi-Fi : un ESP32 fait tourner un petit serveur web, et un appui sur le bouton du téléphone suffit pour qu'un MG996R tire le cordon du rideau ou actionne une trappe d'aération. Comme c'est un MG996R, une alimentation externe de 6 V est indispensable.
  • 12. Plateforme auto-stabilisée avec MPU6050 : l'accéléromètre MPU6050 mesure l'inclinaison de la plateforme et deux servos la corrigent dans le sens inverse pour garder la surface à l'horizontale. On obtient un gimbal simple qui stabilise un verre d'eau ou une petite caméra ; pour une réaction rapide, il faut des MG90S et un bon filtre.

Projets à nombreux servos : bras robotique et robot araignée (13-15)

  • 13. Bras robotique de bureau 4 axes : quatre servos animent la base, l'épaule, le coude et la pince. Pour un petit bras en acrylique ou imprimé en 3D, des MG90S suffisent et les quatre peuvent être pilotés directement par l'Uno ; les servos doivent être alimentés par une source externe de 5 V 3 A. Tu peux ajouter un pilotage manuel aux potentiomètres, au joystick ou des mouvements enregistrés puis rejoués ; voir le bras robotique Arduino.
  • 14. Bras robotique 6 axes : les grands bras métalliques utilisent des MG996R pour la base, l'épaule et le coude, et des MG90S pour le poignet et la pince. Piloter les six servos via un PCA9685 simplifie le câblage ; une alimentation 6 V 10 A et un code qui déplace les servos l'un après l'autre plutôt que tous ensemble réduisent les pointes de courant. Pour la charge de l'épaule, consulte le tableau de couple du MG996R.
  • 15. Robot araignée quadrupède : avec trois articulations par patte, il faut 12 servos, et à ce stade le PCA9685 devient quasi obligatoire. Le poids compte, on choisit donc des MG90S, et le robot est alimenté par une batterie LiPo 2S avec un BEC de 5 A. La marche se fait avec un tableau de poses qui modifie tour à tour les angles de chaque patte ; le modèle de bras robotique ci-dessous est un bon point de départ.
Les robots à roues utilisent un servo à rotation continue 360 degrés au lieu d'un servo classique : on règle la vitesse et le sens au lieu de l'angle. Les détails sont dans le guide servo 360 degrés FS90R. Pour des projets de démonstration, on peut même faire bouger 32 servos en synchronisation avec deux PCA9685 ; le projet de chorégraphie de servos en cercle de BlueGrays fait exactement cela.

Câblage commun : Arduino Uno, ESP32 et Pico

Fil du servoArduino UnoESP32Raspberry Pi PicoAlimentation externe 5-6 V
Marron / noir (GND)GNDGNDGNDNégatif (-)
Rouge (V+)5V (un seul SG90)Non reliéNon reliéPositif (+)
Orange / jaune (signal)D9GPIO 18GP15Non relié
GND de l'alimentationGND (commun)GND (commun)GND (commun)Négatif (-)

Code du projet 2 : radar à ultrasons avec Arduino

Le servo va sur D9, le TRIG du HC-SR04 sur D10 et l'ECHO sur D11. Le servo s'arrête tous les 2 degrés, attend 30 ms et mesure la distance ; le résultat part sur le port série au format « angle,distance ». L'écran radar de Processing ou le traceur série de l'IDE Arduino lisent directement ce format. Le délai de 30 ms passé à pulseIn correspond à environ 5 mètres ; sans écho, -1 est affiché. Le calcul de la distance est expliqué dans le guide du HC-SR04.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const int SERVO_PIN = 9;     // servo sinyali / servo signal
4const int TRIG_PIN = 10;     // HC-SR04 TRIG
5const int ECHO_PIN = 11;     // HC-SR04 ECHO
6
7Servo radar;
8
9int readDistanceCm() {
10  digitalWrite(TRIG_PIN, LOW);
11  delayMicroseconds(2);
12  digitalWrite(TRIG_PIN, HIGH);                        // 10 µs tetik darbesi / 10 µs trigger pulse
13  delayMicroseconds(10);
14  digitalWrite(TRIG_PIN, LOW);
15  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms (~5 m) / max 30 ms (~5 m)
16  if (us == 0) return -1;                              // yankı yok / no echo
17  return us * 0.0343 / 2;                              // µs -> cm
18}
19
20void scanTo(int angle) {
21  radar.write(angle);
22  delay(30);                                           // servo yerine otursun / let the servo settle
23  int d = readDistanceCm();
24  Serial.print(angle);                                 // "açı,mesafe" satırı / "angle,distance" line
25  Serial.print(',');
26  Serial.println(d);
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(TRIG_PIN, OUTPUT);
32  pinMode(ECHO_PIN, INPUT);
33  radar.attach(SERVO_PIN);
34}
35
36void loop() {
37  for (int a = 15; a <= 165; a += 2) scanTo(a);       // soldan sağa / left to right
38  for (int a = 165; a >= 15; a -= 2) scanTo(a);       // sağdan sola / right to left
39}

Code du projet 13 : bras robotique multi-servos sans delay

Dans un bras robotique, toutes les articulations doivent bouger en même temps et en douceur. Si tu écris directement l'angle final de chaque servo avec write(), les servos y sautent à pleine vitesse, le bras tremble et les pointes de courant grimpent. Le modèle ci-dessous rapproche chaque articulation de sa cible degré par degré avec millis() ; le tableau STEP_MS fixe la vitesse de chacune. En ajoutant des lignes au tableau POSES, tu écris ta propre séquence de mouvements, et la même structure convient au pan-tilt, à la barrière ou au robot araignée.

C++ (Arduino IDE)
1#include <Servo.h>
2
3// 4 eksenli robot kol: taban, omuz, dirsek, kıskaç / 4-axis robot arm: base, shoulder, elbow, gripper
4const byte JOINTS = 4;
5const byte PINS[JOINTS] = {3, 5, 6, 9};
6const unsigned int STEP_MS[JOINTS] = {15, 20, 20, 8};   // 1 derece için bekleme (ms) / wait per degree (ms)
7
8// Hareket sırası: her satır bir poz / move sequence: each row is a pose
9const int POSES[][JOINTS] = {
10  {90, 90, 90, 30},     // başlangıç / home
11  {40, 120, 60, 30},    // nesneye uzan / reach the object
12  {40, 120, 60, 90},    // kıskacı kapat / close the gripper
13  {140, 80, 100, 90},   // taşı / carry
14  {140, 80, 100, 30}    // bırak / release
15};
16const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
17
18Servo servos[JOINTS];
19int current[JOINTS], target[JOINTS];
20unsigned long lastStep[JOINTS];
21byte pose = 0;
22
23// Servoyu hedefe 1 derece yaklaştırır, delay kullanmaz / moves a servo 1 degree closer, no delay
24bool updateJoint(byte i) {
25  if (current[i] == target[i]) return true;            // hedefte / at target
26  if (millis() - lastStep[i] < STEP_MS[i]) return false;
27  lastStep[i] = millis();
28  current[i] += (target[i] > current[i]) ? 1 : -1;
29  servos[i].write(current[i]);
30  return current[i] == target[i];
31}
32
33void setup() {
34  for (byte i = 0; i < JOINTS; i++) {
35    current[i] = target[i] = POSES[0][i];
36    servos[i].write(current[i]);                       // attach öncesi başlangıç açısı / start angle before attach
37    servos[i].attach(PINS[i]);
38  }
39  delay(1000);
40}
41
42void loop() {
43  bool allDone = true;
44  for (byte i = 0; i < JOINTS; i++) {
45    if (!updateJoint(i)) allDone = false;              // hepsi aynı anda hareket eder / all move together
46  }
47  if (allDone) {                                       // poz tamam, sıradakine geç / pose reached, next one
48    delay(500);
49    pose = (pose + 1) % POSE_COUNT;
50    for (byte i = 0; i < JOINTS; i++) target[i] = POSES[pose][i];
51  }
52}

Appeler write() avant attach() évite qu'à la mise sous tension le servo saute d'abord à 90 degrés avant de rejoindre la pose de départ. Les servos sont sur D3, D5, D6 et D9 ; comme la bibliothèque Servo peut utiliser n'importe quelle broche numérique, la broche n'a pas besoin du repère PWM. Si l'Arduino redémarre quand le bras bouge, le problème vient de l'alimentation, pas du code ; suis la liste de vérification du guide servo qui tremble.

Code du projet 9 : suiveur solaire avec ESP32

Sur l'ESP32, la bibliothèque Servo de l'Arduino ne fonctionne pas ; installe à la place la bibliothèque ESP32Servo, qui tourne avec le même code sur les cores 2.x et 3.x. Chacune des quatre LDR se place entre 3V3 et une broche analogique, avec une résistance de 10 kΩ de cette broche vers GND ; plus il y a de lumière, plus la lecture augmente. Les LDR sont sur des broches ADC1 (32-35), car les broches ADC2 ne peuvent pas être lues quand le Wi-Fi est actif. Si le panneau tourne dans le mauvais sens, ton montage de servo est différent : il suffit d'inverser le 1 et le -1 dans le code. Le fonctionnement d'une LDR est expliqué dans capteur de lumière LDR.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int PAN_PIN = 18;      // yatay servo / horizontal servo
4const int TILT_PIN = 19;     // dikey servo / vertical servo
5// LDR'ler ADC1 pinlerinde (Wi-Fi ile çakışmaz) / LDRs on ADC1 pins (no Wi-Fi conflict)
6const int LDR_TL = 32, LDR_TR = 33, LDR_BL = 34, LDR_BR = 35;
7const int TOLERANCE = 80;    // bu farkın altında hareket etme / ignore smaller differences
8
9Servo pan, tilt;
10int panAngle = 90, tiltAngle = 45;
11
12void setup() {
13  analogReadResolution(12);                 // 0-4095
14  pan.setPeriodHertz(50);                   // standart servo 50 Hz / standard servo 50 Hz
15  tilt.setPeriodHertz(50);
16  pan.attach(PAN_PIN, 500, 2400);           // darbe aralığı (µs) / pulse range (µs)
17  tilt.attach(TILT_PIN, 500, 2400);
18  pan.write(panAngle);
19  tilt.write(tiltAngle);
20}
21
22void loop() {
23  int tl = analogRead(LDR_TL), tr = analogRead(LDR_TR);
24  int bl = analogRead(LDR_BL), br = analogRead(LDR_BR);
25  int top = (tl + tr) / 2, bottom = (bl + br) / 2;
26  int left = (tl + bl) / 2, right = (tr + br) / 2;
27
28  // Daha aydınlık tarafa 1 derece dön / turn 1 degree toward the brighter side
29  if (abs(left - right) > TOLERANCE) panAngle += (left > right) ? 1 : -1;
30  if (abs(top - bottom) > TOLERANCE) tiltAngle += (top > bottom) ? 1 : -1;
31  panAngle = constrain(panAngle, 5, 175);
32  tiltAngle = constrain(tiltAngle, 10, 90);
33
34  pan.write(panAngle);
35  tilt.write(tiltAngle);
36  delay(25);
37}

Servo avec un Raspberry Pi Pico (MicroPython)

Le Pico n'a besoin d'aucune bibliothèque supplémentaire : machine.PWM génère un signal à 50 Hz et tu fixes la largeur d'impulsion en nanosecondes. La fonction set_angle() ci-dessous convertit 0-180 degrés en une plage de 500-2400 µs ; si ton servo grogne en butée, resserre ces limites. Les broches du Pico sortent du 3,3 V et le SG90, le MG90S et le MG996R fonctionnent sans souci avec ce niveau de signal, mais l'alimentation du servo doit quand même venir de VBUS (5 V de l'USB) ou d'une source externe. En appliquant la même fonction à une liste d'objets PWM, tu peux porter tous les projets ci-dessus sur le Pico.

MicroPython
1from machine import Pin, PWM
2import time
3
4servo = PWM(Pin(15))         # GP15 sinyal / GP15 signal
5servo.freq(50)               # 50 Hz = 20 ms periyot / 20 ms period
6
7def set_angle(angle, min_us=500, max_us=2400):
8    angle = max(0, min(180, angle))                 # 0-180 arası sınırla / clamp to 0-180
9    us = min_us + (max_us - min_us) * angle / 180   # açı -> darbe (µs) / angle -> pulse (µs)
10    servo.duty_ns(int(us * 1000))                   # µs -> ns
11
12while True:
13    for a in range(0, 181, 2):                      # 0 -> 180 derece / degrees
14        set_angle(a)
15        time.sleep_ms(15)
16    for a in range(180, -1, -2):                    # 180 -> 0 derece / degrees
17        set_angle(a)
18        time.sleep_ms(15)

Erreurs fréquentes dans les projets à servomoteur

  • L'Arduino redémarre quand le servo bouge : les servos sont alimentés par la broche 5V reliée à l'USB. Utilise une alimentation externe, une masse commune et un condensateur de 470-1000 µF.
  • Le servo grogne et chauffe en butée : à 0 ou 180 degrés, il force contre la butée mécanique. Réduis la plage à 5-175 degrés ou étalonne les limites d'impulsion dans attach().
  • Le servo tremble : alimentation faible, câbles longs et fins ou potentiomètre bruité. Prends du câble plus épais, filtre la lecture et ajoute une zone morte qui ignore les petites variations.
  • analogWrite ne marche pas sur D9 et D10 : sur l'Uno, la bibliothèque Servo utilise le Timer1. Déplace la PWM de tes LED ou moteurs sur D3, D5, D6 ou D11.
  • Le bras ne soulève pas la charge : le couple se divise par la longueur du bras. Raccourcis le bras, allège la charge ou passe à la taille de servo supérieure (SG90 vers MG90S, MG90S vers MG996R).
  • Les engrenages en plastique ont cassé : le mécanisme bloque le servo, ou le bras a été forcé à la main. Là où l'effort est permanent, prends des servos à engrenages métalliques et ne tourne pas le palonnier à la main.
Avant d'enfermer le projet dans un boîtier, lance le code sans palonnier puis, pendant que la consigne de 90 degrés est active, enfonce le palonnier de façon à ce qu'il soit centré. Le mécanisme dispose ainsi de la même course des deux côtés et le servo ne tape pas en butée dès le premier essai.

Une fois leur principe compris, les servomoteurs ouvrent la porte à une infinité de projets ; les mêmes quelques lignes de code animent un radar comme un bras robotique. Si tu veux réaliser plusieurs de ces projets pas à pas, l'application BlueGrays propose le pilotage de servo au potentiomètre, le servo au joystick, le servo sur ESP32, la serrure RFID à servo, le robot éviteur d'obstacles et la chorégraphie de 32 servos en cercle, chacun avec son schéma de câblage et son code.

Questions fréquentes

Que peut-on faire avec un servomoteur ?

Tout ce qui doit aller à un angle et y rester : radar, bras robotique, serrure, suiveur solaire, distributeur de croquettes, support caméra pan-tilt et robots marcheurs sont les exemples les plus populaires. Avec des servos 360 degrés, on fabrique aussi de petits robots à roues.

Combien de servos peut-on brancher sur un Arduino ?

La bibliothèque Servo pilote directement jusqu'à 12 servos sur l'Arduino Uno et 48 sur le Mega. La vraie limite vient le plus souvent de l'alimentation, pas du nombre de broches. Au-delà de 5 ou 6 servos, un driver PCA9685 réduit le câblage et les tremblements ; une carte en pilote 16, et des cartes chaînées des centaines.

Faut-il acheter un SG90 ou un MG996R ?

Un SG90 suffit pour des couvercles légers, des capteurs à orienter et de petits bras. Les charges lourdes, l'épaule d'un bras robotique ou les mécanismes sous effort permanent demandent le MG996R à engrenages métalliques et jusqu'à 11 kg·cm, qui exige une alimentation externe capable de fournir 3 A par servo.

Peut-on alimenter un servo par la broche 5V de l'Arduino ?

Seulement un SG90 avec une charge légère. Avec plus de servos ou un gros servo, les pointes de courant font chuter la tension et l'Arduino redémarre. Utilise une alimentation externe de 5-6 V et relie son GND au GND de l'Arduino.

Pourquoi mon servomoteur tremble-t-il ?

La cause la plus fréquente est une alimentation insuffisante, suivie de l'absence de masse commune, d'une lecture de potentiomètre bruitée et d'un servo qui force contre sa butée. Une alimentation externe, un condensateur, une lecture filtrée et une plage réduite comme 5-175 degrés règlent la plupart des cas.

Comment piloter un servo avec un ESP32 ?

Sur l'ESP32, on utilise la bibliothèque ESP32Servo au lieu de la bibliothèque Servo standard ; attach(broche, 500, 2400) et write(angle) fonctionnent comme sur l'Arduino. Choisis des broches capables de sortie comme GPIO 18, 19 ou 25 et alimente le servo en 5 V, pas par la broche 3,3 V de l'ESP32.

Voir tous les projets
Utilisation du servomoteur
AR-35Débutant
Premium

Utilisation du servomoteur

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

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

Utilisation d'un servomoteur avec un potentiomètre

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

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

Servocommande avec joystick

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

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

Servomoteur ESP32 (commande par potentiomètre)

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

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

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

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

4.8(9)
16
Chorégraphie de servos en cercle - Motifs animés avec 32 servos
AR-97Avancé
Premium

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

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

4.5(40)
62
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

5.0(38)
49