Atelier Arduino — Pilotage d’un servomoteur

Cet atelier Arduino a été conçu et animé dans le cadre de mes activités de formatrice.

L’objectif était de proposer une première approche concrète du pilotage d’un actionneur mécanique à travers le contrôle d’un servomoteur. Les participants ont pu manipuler des angles, créer des mouvements progressifs et organiser leur programme avec des boucles.

Présentation de l’atelier

Le montage repose sur une carte Arduino reliée à un servomoteur.

Un servomoteur permet de positionner un axe selon un angle précis, généralement compris entre 0 et 180 degrés. Il est particulièrement adapté aux projets nécessitant un mouvement contrôlé, comme une barrière, un bras articulé, une tête de robot ou un mécanisme d’ouverture.

Le programme réalisé pendant l’atelier enchaîne plusieurs mouvements :

• rotation progressive de l’axe de 0° à 180° ;
• rotation progressive de l’axe de 180° à 0° ;
• positionnement à des angles fixes pour observer le comportement mécanique ;
• répétition du cycle de mouvement en continu.

Démonstration

Ce GIF présente le résultat obtenu après téléversement du programme sur la carte Arduino.

Information composant

Schéma du montage

Connexions utilisées

Servomoteur	Carte Arduino
Fil signal (orange/jaune)	Broche numérique 9
Fil alimentation (rouge)	Broche 5V
Fil masse (marron/noir)	Broche GND

La broche numérique 9 est utilisée pour transmettre les instructions d’angle au servomoteur.

Pour un montage comportant plusieurs servomoteurs, une alimentation externe adaptée est recommandée. La masse de cette alimentation doit alors être reliée à celle de la carte Arduino.

Matériel utilisé

• Une carte Arduino
• Un servomoteur
• Des câbles Dupont
• Une plaque d’essai selon le montage
• Une alimentation adaptée selon le modèle
• Un câble USB
• La bibliothèque Servo

Objectifs pédagogiques

Cet atelier permettait d’aborder plusieurs notions fondamentales :

• découvrir la structure d’un programme Arduino ;
• comprendre le rôle des fonctions setup() et loop() ;
• utiliser une bibliothèque externe ;
• contrôler précisément un angle ;
• créer un mouvement progressif ;
• manipuler des boucles for ;
• comprendre les limites mécaniques d’un composant ;
• envisager le déclenchement d’un mouvement depuis un autre capteur.

Bibliothèque utilisée

Le programme s’appuie sur la bibliothèque Servo, qui facilite le contrôle des servomoteurs.

Elle est importée au début du programme :

#include <Servo.h>

Configuration du module

L’objet représentant le servomoteur est créé, puis rattaché à sa broche de commande :

Servo monServo;

void setup()
{
  monServo.attach(9);
}

Cette configuration précise :

• la broche utilisée par la carte Arduino pour envoyer le signal ;
• l’objet logiciel permettant de piloter l’angle du servomoteur.

Programme Arduino

// ========================================
// ATELIER ARDUINO - SERVOMOTEUR
// ========================================

#include <Servo.h>

// Configuration
#define sortie 9

// Création de l'objet servomoteur
Servo monServo;

// Déclaration préalable de la fonction personnalisée
void balayage();

// ===== SETUP =====
void setup()
{
  monServo.attach(sortie);
}

// ===== LOOP =====
void loop()
{
  balayage();
}

// ===== FONCTION : BALAYAGE 0° A 180° =====
void balayage()
{
  // Rotation progressive de 0° à 180°
  for (int angle = 0; angle <= 180; angle++)
  {
    monServo.write(angle);
    delay(15);
  }

  delay(200);

  // Rotation progressive de 180° à 0°
  for (int angle = 180; angle >= 0; angle--)
  {
    monServo.write(angle);
    delay(15);
  }

  delay(200);
}

Déroulement de l’atelier

L’atelier était organisé autour d’une progression simple et visuelle.

Initialisation du servomoteur

La fonction setup() rattache le servomoteur à sa broche de commande :

monServo.attach(sortie);

Le servomoteur est prêt à recevoir des instructions d’angle dès le démarrage du programme.

Manipulation des angles

L’angle du servomoteur est défini avec une seule instruction, comprise entre 0 et 180 :

monServo.write(angle);

Par exemple, cette instruction positionne l’axe au centre :

monServo.write(90);

Création de mouvements progressifs

Les boucles for permettent de parcourir une plage d’angles et de créer un effet de balayage :

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

Le delay(15) entre chaque angle ralentit suffisamment le mouvement pour le rendre fluide et visible.

Création d’un mouvement personnalisé

La fonction balayage() regroupe la logique du mouvement aller-retour de 0° à 180°.

Elle permet d’introduire l’organisation du code en fonctions et de montrer comment enchaîner plusieurs séquences de mouvement avec des pauses entre chacune.

Points de vigilance

Un servomoteur peut demander davantage de courant que la carte Arduino ne peut en fournir durablement.

Pour certains modèles ou plusieurs servomoteurs, une alimentation externe est nécessaire. Les masses de l’alimentation externe et de la carte Arduino doivent alors être reliées.

Prolongements possibles

Cet atelier peut être enrichi avec de nombreuses variantes :

• création d’une barrière automatique ;
• pilotage du servo avec un potentiomètre ;
• utilisation d’un capteur à ultrasons pour déclencher le mouvement ;
• construction d’un petit bras robotisé ;
• ajout de plusieurs positions enregistrées ;
• remplacement de delay() par une gestion basée sur millis() ;
• pilotage du servomoteur avec une carte ESP32 ;
• commande du mouvement depuis une interface web.

Bilan

Cet atelier propose une introduction ludique et accessible à la commande d’un actionneur mécanique.

Le retour visuel immédiat du servomoteur facilite la compréhension du code et permet d’aborder progressivement les variables, les boucles, les fonctions et la gestion des angles à travers une réalisation concrète.