Arduino et robotique

Atelier Arduino — Détection de distance avec un capteur ultrason et 3 LED

Atelier Arduino consacré à la mesure de distance avec un capteur ultrason HC-SR04 et à l'allumage de trois LED (rouge, verte, bleue) selon la distance détectée.

13/08/2026 6 min de lecture

Atelier Arduino — Détection de distance avec un capteur ultrason et 3 LED

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 de la mesure de distance grâce à un capteur ultrason, puis d’utiliser cette mesure pour allumer une LED différente selon la zone de distance détectée. Les participants ont pu manipuler des mesures physiques, des seuils logiques et une gestion simple de plusieurs sorties numériques.

Présentation de l’atelier

Le montage repose sur une carte Arduino reliée à un capteur ultrason HC-SR04 et à trois LED (rouge, verte, bleue).

Un capteur ultrason mesure une distance en envoyant une impulsion sonore inaudible et en chronométrant le temps mis par l’écho pour revenir. Ce principe est très utilisé en robotique pour la détection d’obstacles, le suivi de proximité ou le déclenchement d’actions automatiques.

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

émission d’une impulsion ultrason et mesure du temps de retour de l’écho ;
conversion du temps mesuré en distance (en centimètres) ;
comparaison de la distance à des seuils définis ;
allumage de la LED correspondant à la zone de distance détectée ;
répétition de la mesure en continu.

Démonstration

Allumage des LED selon la distance détectée par le capteur ultrason

Ce GIF présente le résultat obtenu après téléversement du programme sur la carte Arduino : plus un objet s’approche du capteur, plus la LED allumée change.

Information composant

Schéma du composant d'un capteur ultrason

Schéma du montage

Schéma de câblage entre une carte Arduino, un capteur ultrason et trois LED

Connexions utilisées

Composant	Broche	Carte Arduino
Capteur HC-SR04	`Trig`	Broche numérique `9`
Capteur HC-SR04	`Echo`	Broche numérique `10`
Capteur HC-SR04	`VCC`	Broche `5V`
Capteur HC-SR04	`GND`	Broche `GND`
LED rouge	Anode (via résistance)	Broche numérique `4`
LED verte	Anode (via résistance)	Broche numérique `3`
LED bleue	Anode (via résistance)	Broche numérique `2`
LED (les 3)	Cathode	Broche `GND`

Chaque LED est reliée en série avec une résistance (220 Ω à 330 Ω) afin de limiter le courant qui la traverse.

La broche Trig déclenche l’émission de l’impulsion ultrason, tandis que la broche Echo reçoit le signal de retour utilisé pour calculer la distance.

Matériel utilisé

Une carte Arduino
Un capteur ultrason HC-SR04
Une LED rouge, une LED verte, une LED bleue
Trois résistances (220 Ω à 330 Ω)
Des câbles Dupont
Une plaque d’essai
Un câble USB

Objectifs pédagogiques

Cet atelier permettait d’aborder plusieurs notions fondamentales :

comprendre le principe de mesure d’une distance par ultrasons ;
utiliser les fonctions pulseIn() et digitalWrite() ;
convertir une mesure physique (temps) en une grandeur exploitable (distance) ;
manipuler des seuils et des conditions if / else if ;
piloter plusieurs sorties numériques de façon exclusive ;
structurer un programme avec une fonction de mesure dédiée ;
envisager le déclenchement d’autres actions à partir d’une distance mesurée.

Configuration des broches

Les broches du capteur et des LED sont déclarées au début du programme :

#define TRIG 9
#define ECHO 10

#define LED_ROUGE 4
#define LED_VERTE 3
#define LED_BLEUE 2

Programme Arduino

// ========================================
// ATELIER ARDUINO - CAPTEUR ULTRASON + LED
// ========================================

// Configuration du capteur
#define TRIG 9
#define ECHO 10

// Configuration des LED
#define LED_ROUGE 4
#define LED_VERTE 3
#define LED_BLEUE 2

// Déclaration préalable des fonctions personnalisées
long mesurerDistance();
void allumerLed(long distance);

// ===== SETUP =====
void setup()
{
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);

  pinMode(LED_ROUGE, OUTPUT);
  pinMode(LED_VERTE, OUTPUT);
  pinMode(LED_BLEUE, OUTPUT);

  Serial.begin(9600);
}

// ===== LOOP =====
void loop()
{
  long distance = mesurerDistance();

  Serial.print("Distance : ");
  Serial.print(distance);
  Serial.println(" cm");

  allumerLed(distance);

  delay(200);
}

// ===== FONCTION : MESURE DE LA DISTANCE =====
long mesurerDistance()
{
  // Envoi de l'impulsion ultrason
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  // Mesure du temps de retour de l'écho
  long duree = pulseIn(ECHO, HIGH);

  // Conversion du temps en distance (cm)
  long distance = duree * 0.034 / 2;

  return distance;
}

// ===== FONCTION : ALLUMAGE DE LA LED SELON LA DISTANCE =====
void allumerLed(long distance)
{
  // Extinction de toutes les LED avant chaque mise à jour
  digitalWrite(LED_ROUGE, LOW);
  digitalWrite(LED_VERTE, LOW);
  digitalWrite(LED_BLEUE, LOW);

  if (distance <= 40)
  {
    // Objet très proche
    digitalWrite(LED_ROUGE, HIGH);
  }
  else if (distance <= 80)
  {
    // Objet à distance intermédiaire
    digitalWrite(LED_VERTE, HIGH);
  }
  else if (distance <= 130)
  {
    // Objet éloigné ou absence d'obstacle
    digitalWrite(LED_BLEUE, HIGH);
  }
}

Déroulement de l’atelier

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

Initialisation des broches

La fonction setup() configure les broches du capteur et des LED, puis initialise la communication série pour l’affichage des mesures :

pinMode(TRIG, OUTPUT);
pinMode(ECHO, INPUT);

Mesure de la distance

La fonction mesurerDistance() déclenche une impulsion sur TRIG, puis mesure la durée du signal reçu sur ECHO grâce à pulseIn() :

long duree = pulseIn(ECHO, HIGH);
long distance = duree * 0.034 / 2;

Cette formule convertit le temps de trajet aller-retour de l’onde sonore en une distance exprimée en centimètres.

Sélection de la LED à allumer

La fonction allumerLed() compare la distance mesurée à deux seuils et allume la LED correspondante :

  if (distance <= 40)
  {
    // Objet très proche
    digitalWrite(LED_ROUGE, HIGH);
  }
  else if (distance <= 80)
  {
    // Objet à distance intermédiaire
    digitalWrite(LED_VERTE, HIGH);
  }
  else if (distance <= 130)
  {
    // Objet éloigné 
    digitalWrite(LED_BLEUE, HIGH);
  }

Les LED sont systématiquement éteintes avant chaque nouvelle mesure, afin qu’une seule reste allumée à la fois.

Points de vigilance

Le capteur HC-SR04 fournit des mesures fiables dans une plage d’environ 2 cm à 400 cm ; en dehors de cette plage, la mesure peut être instable ou nulle.

Un angle trop faible entre le capteur et l’obstacle, ou une surface absorbant les ultrasons (tissu, mousse), peut fausser la lecture.

Comme pour tout composant alimenté en 5V, il est recommandé de vérifier le sens des connexions avant la mise sous tension.

Prolongements possibles

Cet atelier peut être enrichi avec de nombreuses variantes :

ajout d’un buzzer pour un signal sonore en cas de proximité ;
affichage de la distance sur un écran LCD ;
remplacement des seuils fixes par des seuils réglables avec un potentiomètre ;
utilisation d’une LED RGB unique à la place de trois LED séparées ;
déclenchement d’un servomoteur pour ouvrir une barrière automatique ;
envoi des mesures vers une interface web ou un tableau de bord ;
lissage des mesures par une moyenne glissante pour limiter les variations brutales.

Bilan

Cet atelier propose une introduction ludique et accessible à la mesure de distance et à la prise de décision conditionnelle en programmation embarquée.

Le retour visuel immédiat des LED facilite la compréhension du lien entre une mesure physique et une action logicielle, et permet d’aborder progressivement les entrées analogiques/numériques, les seuils et la structuration du code en fonctions à travers une réalisation concrète.