Servomoteur Arduino : Du SG90 au Bras Robotique 6 Axes

En 1937, l’ingénieur américain Walter Good fabrique le premier servomoteur de modélisme à partir de pièces d’horlogerie et d’un petit moteur électrique, pour piloter à distance un avion radiocommandé. Quatre-vingt-sept ans plus tard, le SG90 que vous achetez à 8 dinars chez Didactico utilise exactement le même principe : un moteur DC, un train d’engrenages réducteur, un potentiomètre de feedback, et une petite carte de contrôle qui compare la position désirée à la position réelle. Cette simplicité géniale est la raison pour laquelle un bras robotique 6 axes, une porte automatique, un radar à ultrasons et le mouvement d’antenne d’un satellite reposent tous sur la même mécanique fondamentale. Dans ce guide complet, vous allez apprendre à maîtriser le servomoteur — du minuscule SG90 jusqu’au bras robotique 6 axes contrôlé en cinématique inverse, en passant par les pièges d’alimentation qui détruisent silencieusement vos Arduino.

1. Qu’y a-t-il dans un servo ? Démontage et principe

Démontez un SG90 (4 vis) et vous découvrez quatre éléments :

1. Un moteur DC à courant continu miniature (3-6 V, quelques centaines de mA).
2. Un train d’engrenages réducteur en plastique (SG90) ou métal (MG90S, MG996R) qui démultiplie le couple typiquement par 200 à 300.
3. Un potentiomètre mécaniquement couplé à l’axe de sortie : il fournit en permanence à l’électronique la position réelle de l’axe.
4. Une carte de contrôle qui lit le signal PWM entrant, mesure la tension du potentiomètre, calcule l’erreur de position, et alimente le moteur dans le bon sens jusqu’à la position cible.

Ce système en boucle fermée (closed-loop) est la définition même d’un servomécanisme. C’est ce qui distingue un servo d’un simple moteur DC : il connaît sa position et corrige automatiquement.

2. Le signal PWM 50 Hz expliqué

Le standard servo, hérité de la radiocommande RC des années 1970, est un signal PWM à 50 Hz (période de 20 ms). La position est codée par la largeur d’impulsion HIGH :

Position 0    1.0 ms HIGH puis 19.0 ms LOW
Position 90   1.5 ms HIGH puis 18.5 ms LOW
Position 180  2.0 ms HIGH puis 18.0 ms LOW

Pour un servo standard, la plage est 1 à 2 ms. Certains servos étendus acceptent 0,5 à 2,5 ms (correspondant à 0-180° voire 0-270°). La librairie Servo.h d’Arduino gère cela transparemment.

3. Types de servos et choix selon le projet

Pour 90 % des projets étudiants en Tunisie, démarrez avec 4 × SG90 ou MG90S. Le MG996R devient intéressant dès qu’il y a de la charge à soulever (pince qui attrape un objet de 100 g).

Servo continu : attention, ces servos n’ont plus de potentiomètre de feedback. La commande PWM contrôle la vitesse (1,5 ms = stop, 1 ms = arrière max, 2 ms = avant max), pas la position. Idéal pour des roues motrices.

4. Librairie Servo.h et premier code

#include <Servo.h>

Servo monServo;
const byte BROCHE_SERVO = 9;

void setup() {
  monServo.attach(BROCHE_SERVO);  // par defaut 544-2400 us
  // Ou avec plage personnalisee : monServo.attach(9, 500, 2500);
}

void loop() {
  for (int angle = 0; angle <= 180; angle++) {
    monServo.write(angle);
    delay(15);
  }
  for (int angle = 180; angle >= 0; angle--) {
    monServo.write(angle);
    delay(15);
  }
}

Sur Arduino UNO, la librairie Servo.h utilise Timer 1 et permet jusqu’à 12 servos. Sur ESP32, utilisez ESP32Servo qui pilote jusqu’à 16 servos via les canaux LEDC. Attention : sur UNO, l’usage de Servo.h désactive le PWM sur D9 et D10 (analogWrite).

5. Alimentation : LE point critique

Schéma d’alimentation correcte

     +-------------+
     |   Source    |
     | externe 5-6V|
     | (batterie,  |
     | alim murale,|
     | regulateur) |
     +------+------+
            |
            +---+-- VCC servo (fil rouge)
            |   |
            |   +-- VCC servo 2, 3, 4...
            |
     [Condensateur 470 uF]
            |
     +------+------+
     |     GND     |--- commun avec GND Arduino
     +-------------+

     Arduino pin D9 --- Signal servo (fil orange/jaune)

Trois points capitaux : (1) alimentation séparée pour les servos ; (2) condensateur de 470 µF à 1000 µF en parallèle pour absorber les pics ; (3) GND commun obligatoire entre alim servo et Arduino.

Choix de l’alimentation :

• 1 à 2 SG90 : alimentation USB séparée 5V/2A (chargeur smartphone) ou pile 4 AA
• 4 SG90/MG90S (bras robotique pédagogique) : alimentation 5V/4A ou batterie LiPo 2S + step-down
• 4 MG996R : alimentation 6V/10A (compter 1,5 A par servo en pic)

6. PCA9685 : piloter 16 servos par I2C

Au-delà de 4-5 servos, le câblage devient un cauchemar et les timers Arduino sont saturés. La solution professionnelle : le module PCA9685. C’est un driver PWM 16 canaux, 12 bits de résolution (4096 niveaux), pilotable en I2C (2 fils seulement). Chaînable jusqu’à 62 modules = 992 servos.

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver();
const uint16_t SERVO_MIN = 150;   // ~500 us pulse
const uint16_t SERVO_MAX = 600;   // ~2500 us pulse

void setup() {
  pca.begin();
  pca.setOscillatorFrequency(27000000);
  pca.setPWMFreq(50);  // 50 Hz pour servos
}

void loop() {
  for (uint16_t pulse = SERVO_MIN; pulse < SERVO_MAX; pulse++) {
    pca.setPWM(0, 0, pulse);  // canal 0
    delay(5);
  }
}

// Helper : convertir un angle en pulse PCA9685
uint16_t angleVersPulse(int angle) {
  return map(angle, 0, 180, SERVO_MIN, SERVO_MAX);
}

Le PCA9685 a sa propre entrée d’alimentation V+ pour les servos, totalement séparée du 5V logique I2C. Câblage parfait : Arduino → SDA/SCL/GND vers PCA9685 logic, et une alimentation 5V/6A séparée vers V+ du PCA9685.

7. Construire un bras robotique 4 axes

Architecture classique d’un bras à 4 degrés de liberté (DOF) :

• Axe 1 — Base (rotation horizontale) : MG996R, supporte le poids de tout le bras
• Axe 2 — Épaule : MG996R, supporte avant-bras + pince + charge
• Axe 3 — Coude : MG90S ou MG996R selon la portée
• Axe 4 — Pince ou rotation poignet : SG90 suffit

Pour la mécanique, vous avez deux options principales en Tunisie : (1) acheter un kit acrylique pré-découpé chez Didactico (rapide, économique) ; (2) imprimer en 3D avec un Bambu Lab P1S ou A1 — c’est ce que nous faisons au FabLab Sfax pour les projets de PFE personnalisés. Fichiers STL disponibles librement (cherchez “4DOF robot arm” sur Printables).

Code de pilotage joystick → 4 servos

#include <Servo.h>
Servo base, epaule, coude, pince;
const byte JOY_X = A0;
const byte JOY_Y = A1;
const byte JOY_BTN = 2;

int angleBase = 90;
int angleEpaule = 90;
int angleCoude = 90;
bool pinceFermee = false;

void setup() {
  base.attach(3);   base.write(90);
  epaule.attach(5); epaule.write(90);
  coude.attach(6);  coude.write(90);
  pince.attach(9);  pince.write(45);
  pinMode(JOY_BTN, INPUT_PULLUP);
}

void loop() {
  int x = analogRead(JOY_X);
  int y = analogRead(JOY_Y);

  // Zone morte centrale
  int dx = (abs(x - 512) > 80) ? (x - 512) / 200 : 0;
  int dy = (abs(y - 512) > 80) ? (y - 512) / 200 : 0;

  angleBase   = constrain(angleBase + dx, 0, 180);
  angleEpaule = constrain(angleEpaule + dy, 30, 150);

  base.write(angleBase);
  epaule.write(angleEpaule);

  if (digitalRead(JOY_BTN) == LOW) {
    pinceFermee = !pinceFermee;
    pince.write(pinceFermee ? 90 : 30);
    delay(300);
  }
  delay(20);
}

8. Cinématique inverse simplifiée

Plutôt que de piloter chaque servo séparément, la cinématique inverse (IK — Inverse Kinematics) permet de spécifier la position cible de la pince en (x, y, z) et de calculer automatiquement les angles. Pour un bras 2D simple (épaule + coude, longueurs L1 et L2) :

#include <math.h>
#include <Servo.h>
Servo epaule, coude;

const float L1 = 12.0;  // cm avant-bras
const float L2 = 10.0;  // cm bras

bool deplacer(float x, float y) {
  float d = sqrt(x*x + y*y);
  if (d > L1 + L2 || d < fabs(L1 - L2)) {
    return false;  // hors de portee
  }
  // Loi des cosinus
  float cos_coude = (x*x + y*y - L1*L1 - L2*L2) / (2 * L1 * L2);
  float angle_coude = acos(cos_coude);
  float angle_epaule = atan2(y, x) - atan2(L2 * sin(angle_coude),
                                            L1 + L2 * cos(angle_coude));

  int deg_epaule = degrees(angle_epaule);
  int deg_coude  = degrees(angle_coude);
  epaule.write(constrain(90 + deg_epaule, 0, 180));
  coude.write(constrain(90 + deg_coude, 0, 180));
  return true;
}

void setup() {
  epaule.attach(5); coude.attach(6);
  Serial.begin(115200);
}

void loop() {
  // Trace un cercle dans le plan vertical
  for (int t = 0; t < 360; t += 5) {
    float rad = radians(t);
    float x = 15.0 + 4 * cos(rad);
    float y = 12.0 + 4 * sin(rad);
    deplacer(x, y);
    delay(50);
  }
}

Pour un bras 3D (4 ou 6 axes), les équations se compliquent mais le principe reste le même. Pour aller plus loin, regardez la librairie RobotIK ou ROS sur Raspberry Pi.

9. Mode teach : enregistrer des positions

Le “teach mode” est utilisé dans l’industrie : on déplace manuellement le bras à une position, on appuie sur un bouton pour enregistrer les angles, puis on rejoue la séquence en boucle. Code simplifié :

const byte NB_POS = 10;
int sequence[NB_POS][4];  // 4 angles par position
byte nbEnregistrees = 0;
bool modeReplay = false;

void loop() {
  if (digitalRead(BTN_REC) == LOW && nbEnregistrees < NB_POS) {
    sequence[nbEnregistrees][0] = angleBase;
    sequence[nbEnregistrees][1] = angleEpaule;
    sequence[nbEnregistrees][2] = angleCoude;
    sequence[nbEnregistrees][3] = anglePince;
    nbEnregistrees++;
    delay(500);
  }

  if (digitalRead(BTN_PLAY) == LOW) modeReplay = true;

  if (modeReplay) {
    for (byte i = 0; i < nbEnregistrees; i++) {
      deplacerVers(sequence[i][0], sequence[i][1],
                   sequence[i][2], sequence[i][3]);
      delay(1500);
    }
    modeReplay = false;
  }
}

Pour un mouvement fluide entre deux positions enregistrées, interpolez linéairement sur 50 étapes au lieu de sauter directement (sinon le servo va au max de vitesse).

10. Ajouter une caméra ESP32-CAM

L’ESP32-CAM (puce Espressif ESP32 + caméra OV2640) transforme votre bras robotique en système de vision. Trois usages pratiques :

1. Streaming Wi-Fi : voir en temps réel ce que voit la pince depuis votre smartphone.
2. Détection de couleur : la pince attrape uniquement les objets rouges (filtrage HSV via OpenCV sur Raspberry Pi qui pilote l’ESP32).
3. Détection AprilTag ou QR : le bras se positionne précisément face à un tag pour effectuer une opération.

Workflow type : ESP32-CAM streame vidéo en MJPEG sur Wi-Fi, un Raspberry Pi 4 ou un PC traite l’image avec OpenCV (Python), calcule la position cible (x, y) en cm, et envoie les coordonnées à l’Arduino via UART qui calcule la cinématique inverse et pilote les servos. C’est exactement la chaîne que nous avons montée pour un projet de PFE INSAT en avril 2025.

Dépannage rapide : 5 problèmes fréquents

1. Le servo tremble en permanence → Alimentation trop faible OU câble signal trop long sans masse de référence. Ajoutez un condensateur de 470 µF et raccourcissez les fils.
2. Arduino se reset au démarrage du servo → Vous alimentez le servo via Arduino 5V. Séparez les alimentations.
3. Le servo tourne dans le mauvais sens → Inversez la conversion : servo.write(180 - angle).
4. Le servo refuse d’aller jusqu’à 0° ou 180° → Plage par défaut 544-2400 µs trop conservative. Essayez attach(broche, 500, 2500).
5. Le servo “chante” doucement quand il maintient une position → Comportement normal sur servos analogiques bon marché. Passez à un servo digital pour silence total.

FAQ — Servomoteur Arduino bras robotique

Conclusion

Le servomoteur est probablement le composant le plus magique de l’électronique grand public : une mécanique de précision, une boucle de contrôle en temps réel, un protocole vieux de 50 ans toujours en vigueur, et un prix qui démarre à 8 dinars. Du minuscule SG90 qui anime la queue d’un robot-chat imprimé en 3D jusqu’au bras industriel à 6 axes piloté en ROS, vous travaillez toujours avec le même principe : un signal PWM qui code une position, et un système en boucle fermée qui s’y rend.

Chez Didactico Sfax, nous tenons en stock permanent toute la gamme : SG90, MG90S, MG996R, DS3218, servos continus FS90R, modules PCA9685, kits bras robotique 4 axes en acrylique, structures imprimables 3D, alimentations 5V/10A et batteries LiPo. Pour les étudiants ENIT, INSAT, ISBS, ISET et ESPRIT en projet de fin d’études, livraison 24-48h dans toute la Tunisie. Nous travaillons aussi avec les imprimantes Bambu Lab (P1S, A1, X1C) au FabLab Sfax pour réaliser des structures de bras sur-mesure, et avec l’écosystème Espressif (ESP32, ESP32-CAM) pour la partie vision. Pour aller plus loin, consultez notre guide complet Arduino UNO R3.

Quel sera votre prochain projet servo ? Un bras industriel miniature, un robot quadrupède, un gimbal pour caméra ? Partagez en commentaire — les meilleures idées seront retenues pour le prochain workshop FabLab.

🛒 Matériel nécessaire pour ce guide

Tout le matériel de ce tutoriel est disponible chez Didactico — livraison 24-48h partout en Tunisie, paiement à la livraison.

Servomoteur MG996 13KG 180 degree22,500 TNDServomoteur MG995 12KG 180 degree19,501 TNDServomoteur S3003 12KG 180 degree20,000 TND

Voir toute la catégorie « Robotique – Drones » →

📘 Guides liés : Construire son Premier Robot Arduino : Guide Complet Châssis 2WD + Évitement d'Obstacles