Maîtriser le Capteur Ultrason HC-SR04 avec Arduino : Tutoriel Complet

Introduction

Dans ce tutoriel, nous allons apprendre comment fonctionne le capteur ultrasonique HC-SR04 et comment l'utiliser avec Arduino. C'est le capteur le plus populaire pour mesurer des distances et réaliser des robots évitant les obstacles avec Arduino.

J'ai déjà utilisé le capteur HC-SR04 pour construire plusieurs projets Arduino sympas que vous pouvez consulter ici :

• Radar Arduino (Sonar)
• Mesureur de Distance et Niveau à Bulle Numérique
• Projet Système de Sécurité et d'Alarme
• Robot Hexapode Fourmi Arduino

Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous. Il contient des informations supplémentaires et des exemples pour le capteur : spécifications, brochage, schémas de câblage, codes et plus.

Présentation Matérielle du HC-SR04

Le HC-SR04 est un capteur de mesure de distance abordable et facile à utiliser, avec une portée de 2 cm à 400 cm (environ 2 cm à 13 pieds).

Le capteur est composé de deux transducteurs ultrasoniques. L'un est un émetteur qui émet des impulsions ultrasonores, l'autre est un récepteur qui écoute les ondes réfléchies. C'est essentiellement un SONAR comme celui utilisé dans les sous-marins pour détecter les objets sous-marins.

Spécifications Principales

Brochage du Capteur Ultrasonique HC-SR04

Voici le brochage du capteur :

Le capteur a 4 broches. VCC et GND vont aux broches 5V et GND de l'Arduino. Les broches Trig (Trigger) et Echo vont sur n'importe quelles broches numériques de l'Arduino. Avec la broche Trig, on envoie l'onde ultrasonore depuis l'émetteur, et avec la broche Echo, on écoute le signal réfléchi.

Comment Fonctionne le Capteur de Distance Ultrasonique HC-SR04 ?

Il émet un ultrasound à 40 000 Hz qui se propage dans l'air. S'il y a un objet ou obstacle sur son chemin, l'onde rebondit vers le module. En tenant compte du temps de trajet et de la vitesse du son, on peut calculer la distance.

Pour générer l'ultrasound, il faut mettre la broche Trig à l'état HAUT pendant 10 µs. Cela envoie une rafale de 8 cycles ultrasonores qui voyage à la vitesse du son. La broche Echo passe à l'état HAUT immédiatement après l'envoi de cette rafale et commence à écouter ou attendre le retour de l'onde réfléchie par un objet.

S'il n'y a pas d'objet ou d'impulsion réfléchie, la broche Echo fait un timeout après 38 ms et repasse à l'état BAS.

Si on reçoit une impulsion réfléchie, la broche Echo repasse à l'état BAS avant ces 38 ms. Selon la durée pendant laquelle la broche Echo est restée HAUTE, on peut déterminer la distance parcourue par l'onde sonore, donc la distance du capteur à l'objet.

Pour cela, on utilise la formule de base :

Distance = Vitesse × Temps

On connaît la vitesse et le temps. Le temps est la durée pendant laquelle la broche Echo est HAUTE, et la vitesse est celle du son : 340 m/s. Il y a une étape supplémentaire : diviser le résultat par 2, car on mesure le temps aller-retour de l'onde sonore.

Exemple : si la broche Echo est HAUTE pendant 2 ms. Pour obtenir la distance en cm, on convertit la vitesse du son de 340 m/s en 34 cm/ms.

Distance = (Vitesse × Temps) / 2 = (34 cm/ms × 2 ms) / 2 = 34 cm.

Donc, si la broche Echo est HAUTE pendant 2 ms (mesuré avec la fonction pulseIn()), la distance est de 34 cm.

Comment Connecter le HC-SR04 à Arduino

Voici comment connecter le capteur HC-SR04 à une carte Arduino.

Les broches GND et VCC du module se connectent respectivement au GND et au 5V de l'Arduino, et les broches Trig et Echo à n'importe quelles broches d'entrée/sortie numériques.

Composants Nécessaires

• Capteur Ultrasonique HC-SR04
• Carte Arduino
• Plaque d'essai (breadboard) et fils de connexion

Code Arduino pour Capteur Ultrasonique HC-SR04

Voici un code pour mesurer la distance avec le HC-SR04 et Arduino.

/* Capteur Ultrasonique HC-SR04 et Arduino par Dejan Nedelkovski, www.HowToMechatronics.com */
// Définition des broches
const int trigPin = 9;
const int echoPin = 10;
// Variables
long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT); // Trig en sortie
  pinMode(echoPin, INPUT);  // Echo en entrée
  Serial.begin(9600);       // Communication série
}

void loop() {
  // Nettoie la broche Trig
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Envoie l'impulsion de 10 µs
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Lit le temps de trajet sur Echo
  duration = pulseIn(echoPin, HIGH);
  // Calcule la distance
  distance = duration * 0.034 / 2;
  // Affiche sur le moniteur série
  Serial.print("Distance: ");
  Serial.println(distance);
}

Explication du Code

D'abord, on définit les broches Trig et Echo (ici broches 9 et 10). On a besoin d'une variable long duration pour le temps de trajet et d'un int distance pour la distance.

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;

Dans setup(), on configure Trig en sortie, Echo en entrée, et on démarre la communication série.

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

Dans loop(), on s'assure que Trig est LOW pendant 2 µs, puis on le met HIGH pendant 10 µs pour générer l'ultrasound.

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

Avec pulseIn(), on lit le temps de trajet et on le stocke dans duration. Cette fonction prend 2 paramètres : la broche Echo et l'état de l'impulsion à lire (HIGH ou LOW). Ici on lit HIGH car le HC-SR04 met Echo à HIGH après l'envoi de la rafale.

duration = pulseIn(echoPin, HIGH);

Cela démarre le chronométrage. Quand l'onde réfléchie est reçue, Echo passe à LOW, ce qui arrête le chronométrage. La fonction retourne la longueur de l'impulsion en microsecondes.

Pour la distance, on multiplie la durée par 0,034 et on divise par 2 comme expliqué.

distance = duration * 0.034 / 2;
Serial.print("Distance: ");
Serial.println(distance);

Exemple : Capteur Ultrasonique Arduino et Affichage LCD

Voici un autre exemple : utiliser le capteur ultrasonique avec Arduino et afficher les résultats sur un LCD.

Vous pouvez connecter le capteur et le LCD comme suit :

Le code de mesure est quasiment le même. Au lieu d'afficher sur le moniteur série, on affiche sur le LCD. Pour plus de détails sur la connexion LCD, consultez mon tutoriel dédié.

/* HC-SR04 et Arduino avec LCD par Dejan Nedelkovski, www.HowToMechatronics.com */
#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distanceCm, distanceInch;

void setup() {
  lcd.begin(16, 2);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  duration = pulseIn(echoPin, HIGH);
  distanceCm = duration * 0.034 / 2;
  distanceInch = duration * 0.0133 / 2;
  
  lcd.setCursor(0, 0);
  lcd.print("Distance: ");
  lcd.print(distanceCm);
  lcd.print(" cm");
  delay(10);
  
  lcd.setCursor(0, 1);
  lcd.print("Distance: ");
  lcd.print(distanceInch);
  lcd.print(" inch");
  delay(10);
}

Exemple de Code avec la Bibliothèque NewPing

Il existe une méthode plus simple et meilleure pour programmer la mesure de distance avec le HC-SR04 : la bibliothèque NewPing.

Dans le code précédent, on déclenchait manuellement le capteur et on mesurait la durée d'impulsion. Avec NewPing, on obtient la distance en une seule ligne de code.

#include <NewPing.h>
#define TRIGGER_PIN 9
#define ECHO_PIN 10
#define MAX_DISTANCE 400 // Distance max en cm

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {
  Serial.begin(9600);
}

void loop() {
  delay(50); // 50ms entre pings (~20 pings/sec). 29ms minimum.
  int distance = sonar.ping_cm(); // Envoie ping, récupère distance en cm
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");
}

C'est bien plus simple. On appelle ping_cm() sur l'objet sonar et on obtient la distance en cm. Pour les pouces, on utilise ping_in().

La bibliothèque a d'autres fonctionnalités utiles. Par exemple, ping_median(iterations [, max_cm_distance]) retourne la médiane de plusieurs mesures pour plus de précision. Le paramètre iterations définit le nombre d'échantillons (5 par défaut). ping_median() retourne la durée d'impulsion en microsecondes.

Pour plus de détails, consultez la page wiki de NewPing.

Améliorer la Précision du HC-SR04 avec un Capteur de Température DHT22

Le HC-SR04 est assez précis, mais comme son fonctionnement dépend de la vitesse du son, pour des résultats plus précis il faut tenir compte de la température de l'air. La vitesse du son change significativement avec la température. Par exemple, à 20°C elle est ~340 m/s, mais à -20°C elle tombe à ~315 m/s. L'humidité relative affecte aussi la vitesse.

Si on utilise ce capteur à diverses températures, il faut implémenter une compensation de température avec la formule :

Vitesse = 331,4 + 0,6 × Température + 0,0124 × Humidité_Relative

Voici un exemple :

Avec le HC-SR04, on utilise un capteur DHT11/DHT22 pour mesurer température et humidité, et on ajuste la vitesse du son en conséquence.

Code Arduino avec Compensation Température

/* Exemple par Dejan, How To Mechatronics, https://howtomechatronics.com/ */
#include <NewPing.h> // https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home
#include "dht.h"    // https://github.com/RobTillaart/DHTlib

#define TRIGGER_PIN 9
#define ECHO_PIN 10
#define MAX_DISTANCE 400
#define dht22 5 // Broche DHT22

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
dht DHT;

int readDHT, temp, hum;
float speedOfSound, distance, duration;

void setup() {
  Serial.begin(9600);
}

void loop() {
  delay(100);
  // Lecture température et humidité
  readDHT = DHT.read22(dht22);
  temp = DHT.temperature;
  hum = DHT.humidity;
  
  // Calcul vitesse du son en m/s
  speedOfSound = 331.4 + (0.6 * temp) + (0.0124 * hum);
  
  // Durée médiane sur 10 itérations (en µs)
  duration = sonar.ping_median(10);
  duration = duration / 1000000; // Conversion µs en secondes
  
  // Calcul distance
  distance = (speedOfSound * duration) / 2;
  distance = distance * 100; // Mètres en cm
  
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");
}

On lit d'abord température et humidité du DHT22, on calcule la vitesse du son, puis on obtient la durée de trajet en µs, on convertit en secondes et on calcule la distance en cm.

Dimensions et Modèle 3D du HC-SR04

J'ai créé un modèle 3D du capteur HC-SR04 au cas où vous en auriez besoin pour vos projets. Téléchargeable via le lien ci-dessous.

Vous pouvez trouver et télécharger ce modèle 3D sur Thangs.

Voici les dimensions du capteur HC-SR04 :

Notez qu'elles peuvent varier légèrement selon le fabricant.

Conclusion

Nous avons couvert l'essentiel sur l'utilisation du capteur ultrasonique HC-SR04 avec Arduino. C'est un excellent capteur pour de nombreux projets DIY nécessitant une mesure de distance sans contact, détection de présence ou d'objets, niveau ou positionnement.

J'ai mentionné mes projets avec ce capteur au début. Voici d'autres projets sympas utilisant le HC-SR04 et Arduino :

• Poubelle Automatique sans Contact à Détection de Mouvement
• Contrôle Lumière Intelligent par Gestes de la Main
• Mini Lévitation Acoustique
• Robot Évitement d'Obstacles

J'espère que ce tutoriel vous a plu. N'hésitez pas à poser vos questions dans les commentaires et consultez ma collection de 30+ projets Arduino.