Comment utiliser un capteur de distance ultrasonique HC-SR04 avec Arduino

Le HC-SR04 est un capteur de distance ultrasonique peu coûteux et facile à utiliser, avec une portée de 2 cm à 400 cm. Il est couramment utilisé dans les robots évitant les obstacles et les projets d’automatisation. Dans ce tutoriel, vous apprendrez comment fonctionne ce capteur et comment l’utiliser avec Arduino.

J’ai inclus 5 exemples avec un schéma de câblage et du code pour que vous puissiez commencer à expérimenter avec votre capteur. Nous commencerons par un exemple qui n’utilise pas de bibliothèque Arduino. Ensuite, je vous montrerai comment utiliser la bibliothèque NewPing pour créer un code plus compact.

Fournitures

Composants matériels

	HC-SR04 sensor	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	USB cable type A/B	× 1	Amazon
	20×4 character I2C LCD (optionnel)	× 1	Amazon
	DHT11 sensor (optionnel)	× 1	Amazon

Logiciel

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Comment fonctionne un capteur de distance ultrasonique ?

Les capteurs ultrasoniques fonctionnent en émettant des ondes sonores à une fréquence trop élevée pour être entendue par l’homme. Ces ondes sonores se propagent dans l’air à la vitesse du son, environ 343 m/s. S’il y a un objet devant le capteur, les ondes sonores sont réfléchies et le récepteur du capteur ultrasonique les détecte. En mesurant le temps écoulé entre l’émission et la réception des ondes, on peut calculer la distance entre le capteur et l’objet.

À 20°C, la vitesse du son est d’environ 343 m/s ou 0,034 cm/µs. Supposons que le temps entre l’émission et la réception des ondes sonores soit de 2000 microsecondes. En multipliant la vitesse du son par le temps de trajet des ondes, on obtient la distance parcourue par les ondes sonores.

Distance = Vitesse × Temps

Mais ce n’est pas le résultat que nous cherchons. La distance entre le capteur et l’objet est en réalité la moitié de cette distance, car les ondes sonores ont parcouru l’aller-retour entre le capteur et l’objet. Il faut donc diviser le résultat par deux.

Distance (cm) = Vitesse du son (cm/µs) × Temps (µs) / 2

Ainsi, pour l’exemple, cela donne :

Distance (cm) = 0,0343 (cm/µs) × 2000 (µs) / 2 = 34,3 cm

Dépendance de la vitesse du son à la température

La vitesse du son dépend en réalité fortement de la température et dans une moindre mesure de l’humidité de l’air. Wikipédia indique que la vitesse du son augmente d’environ 0,6 m/s par degré Celsius. Dans la plupart des cas, à 20°C, vous pouvez utiliser 343 m/s, mais si vous souhaitez obtenir des mesures plus précises, vous pouvez calculer la vitesse du son avec la formule suivante :

V (m/s) = 331,3 + (0,606 × T)

V = Vitesse du son (m/s)
T = Température de l’air (°C)

Cette formule n’inclut pas l’humidité car son effet sur la vitesse du son est très faible.

Vous trouverez ci-dessous un tutoriel sur la façon d’utiliser un DHT11 capteur de température et d’humidité pour calibrer la vitesse du son et obtenir une mesure de distance plus précise avec le HC-SR04.

Comment fonctionne le HC-SR04

À l’avant du capteur HC-SR04, vous trouverez deux cylindres argentés (transducteurs ultrasoniques), l’un est l’émetteur des ondes sonores et l’autre le récepteur. Pour que le capteur génère une impulsion sonore, vous devez mettre la broche Trig à l’état haut pendant au moins 10 µs. Le capteur crée alors une rafale de 8 cycles d’ultrasons à 40 kHz.

Cette impulsion sonore se propage à la vitesse du son, rebondit sur un objet et est reçue par le récepteur du capteur. La broche Echo délivre alors la durée du trajet des ondes sonores en microsecondes.

Vous pouvez utiliser la pulseIn() fonction dans le code Arduino pour lire la durée de l’impulsion sur la broche Echo. Ensuite, vous pouvez utiliser la formule mentionnée plus haut pour calculer la distance entre le capteur et l’objet.

Spécifications du HC-SR04

Tension de fonctionnement	5 V
Courant de fonctionnement	15 mA
Fréquence	40 kHz
Plage de mesure	2 – 400 cm
Résolution	3 mm
Angle de mesure	15 degrés
Signal d’entrée Trigger	Impulsion haute de 10 µs
Coût	Check price

Pour plus d’informations, vous pouvez consulter la fiche technique ci-dessous :

Câblage – Connexion du HC-SR04 à l’Arduino UNO

Le schéma de câblage ci-dessous montre comment connecter le capteur HC-SR04 à l’Arduino.

Les exemples de code ci-dessous utilisent les broches numériques 2 et 3 pour les broches trigger et echo respectivement, mais bien sûr vous pouvez les changer pour n’importe quelle broche numérique de votre choix.

Connexions HC-SR04

HC-SR04	Arduino
VCC	5 V
Trig	Broche 2
Echo	Broche 3
GND	GND

Exemple de code pour HC-SR04 avec Arduino

Maintenant que vous avez câblé le capteur, il est temps de connecter l’Arduino à l’ordinateur et de téléverser du code. Vous pouvez téléverser l’exemple de code suivant sur votre Arduino en utilisant l’IDE Arduino. Ensuite, je vous expliquerai comment fonctionne le code.

/* Example code for HC-SR04 ultrasonic distance sensor with Arduino. 
   No library required. More info: https://www.makerguides.com */

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);
  // Calculate the distance:
  distance = duration * 0.034 / 2;

  // Print the distance on the Serial Monitor (Ctrl+Shift+M):
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(50);
}

Comment fonctionne le code

Tout d’abord, les broches trigger et echo sont définies. Je les appelle trigPin et EchoPin. La broche trigger est connectée à la broche numérique 2 et la broche echo à la broche numérique 3 sur l’Arduino.

L’instruction #define est utilisée pour donner un nom à une valeur constante. Le compilateur remplacera toute référence à cette constante par la valeur définie lors de la compilation du programme. Ainsi, partout où vous mentionnez trigPin, le compilateur le remplacera par la valeur 2 lors de la compilation.

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

Ensuite, j’ai défini deux variables : duration et distance. Duration stocke le temps entre l’émission et la réception des ondes sonores. La variable distance est utilisée pour stocker la distance calculée.

// Define variables:
long duration;
int distance;

Dans la setup(), vous commencez par configurer trigPin en sortie et echoPin en entrée. Ensuite, vous initialisez la communication série à un débit de 9600 bauds. Plus tard, vous afficherez la distance mesurée dans le moniteur série, accessible avec Ctrl+Shift+M ou Outils > Moniteur Série. Assurez-vous que le débit est également réglé à 9600 dans le moniteur série.

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

Dans la loop(), vous déclenchez le capteur en mettant trigPin à HIGH pendant 10 µs. Notez que pour obtenir un signal propre, vous commencez par mettre trigPin à LOW pendant 5 microsecondes.

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

Ensuite, vous devez lire la durée de l’impulsion envoyée par echoPin. J’utilise pour cela la fonction pulseIn() . Cette fonction attend que la broche passe de LOW à HIGH, démarre le chronométrage, puis attend que la broche repasse à LOW et arrête le chronométrage.

Après cela, vous pouvez calculer la distance en utilisant la formule mentionnée dans l’introduction de ce tutoriel.

// Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
duration = pulseIn(echoPin, HIGH);
// Calculate the distance:
distance = duration * 0.034 / 2;

Enfin, la distance calculée est affichée dans le moniteur série.

// Print the distance on the Serial Monitor (Ctrl+Shift+M):
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");

delay(50);

Exemple de code HC-SR04 avec Arduino et bibliothèque NewPing

La bibliothèque NewPing écrite par Tim Eckel peut être utilisée avec de nombreux capteurs de distance ultrasoniques. La dernière version de cette bibliothèque peut être téléchargée ici sur bitbucket.org. Vous remarquerez que le code ci-dessous, qui utilise la bibliothèque NewPing, est beaucoup plus court que le code utilisé précédemment. De plus, la bibliothèque NewPing inclut d’autres fonctionnalités intéressantes. Elle vous permet de définir une distance maximale à lire, elle ne bloque pas pendant une seconde complète lorsqu’aucun écho n’est reçu et elle intègre un filtre médian.

Vous pouvez installer la bibliothèque en allant dans Sketch > Include Library > Add .ZIP Library dans l’IDE Arduino.

La bibliothèque inclut quelques exemples que vous pouvez utiliser, mais vous devrez les modifier pour correspondre à votre configuration matérielle. J’ai inclus un exemple de code modifié ci-dessous qui peut être utilisé avec le même câblage que précédemment.

/* HC-SR04 ultrasonic distance sensor with 
   NewPing library example code. 
   More info: www.www.makerguides.com */

// Include the library:
#include "NewPing.h"

// Define pins and max distance:
#define trigPin  2
#define echoPin  3
#define MAX_DISTANCE 350 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
float duration, distance;

void setup() {
  Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results.
}

void loop() {
  delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  
  duration = sonar.ping();
  distance = (duration / 2) * 0.0343;
  
  Serial.print("Distance = ");
  Serial.print(distance); // Distance will be 0 when out of set max range.
  Serial.println(" cm");
}

Vous pouvez aussi utiliser distance = sonar.ping_cm() ou distance = sonar.ping_in() qui renvoient la distance mesurée en centimètres entiers ou en pouces. Avec cette fonction, vous n’avez pas besoin de mesurer la durée ni de calculer la distance.

Interface des capteurs ultrasoniques en mode 3 broches

La bibliothèque NewPing facilite également l’interface avec des capteurs ultrasoniques en utilisant une seule broche d’entrée/sortie. Cela peut être utile si vous avez très peu de broches disponibles ou si vous souhaitez utiliser un capteur ultrasonique 3 broches comme le Parallax Ping.

Pour créer une configuration 3 broches (GND, 5V et SIG), vous devez connecter à la fois la broche trigger et la broche echo à la même broche numérique sur l’Arduino. Dans le code, la seule chose à changer est la ligne 6-7 en définissant la même broche pour trigPin et echoPin. Par exemple, la broche numérique 2.

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 2

Comment utiliser le filtre numérique ping_median()

Ce que j’aime particulièrement dans la bibliothèque NewPing, c’est qu’elle intègre un filtre médian. Ce filtre peut grandement améliorer la précision de vos mesures HC-SR04. La ping_median() fonction prend plusieurs mesures de durée à la suite, élimine les lectures hors plage, puis fait la moyenne des valeurs restantes. Par défaut, elle prend 5 mesures, mais vous pouvez spécifier combien elle doit en prendre. Remplacez la ligne 19 par les lignes ci-dessous.

int iterations = 5;
duration = sonar.ping_median(iterations);

Exemple de code HC-SR04 avec écran LCD I2C et Arduino

Pour afficher la distance mesurée sur un 2004 ou 1602écran LCD I2C, il vous suffit de faire les connexions suivantes et de téléverser le code ci-dessous. Le capteur HC-SR04 est connecté de la même manière qu’avant.

Connexions écran LCD I2C

Écran LCD I2C	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Si vous n’utilisez pas un Arduino Uno, les broches SDA et SCL peuvent être à un autre emplacement. Un Arduino UNO avec la disposition R3 (brochage 1.0) possède également les broches SDA (ligne de données) et SCL (ligne d’horloge) près de la broche AREF. Consultez le tableau ci-dessous pour plus de détails.

Carte	SDA	SCL
Arduino Uno	A4	A5
Arduino Nano	A4	A5
Arduino Micro	2	3
Arduino Mega 2560	20	21
Arduino Leonardo	2	3
Arduino Due	20	21

Le code utilise la bibliothèque LiquidCrystal_I2C , que vous pouvez télécharger sur GitHub. Assurez-vous d’avoir cette bibliothèque exacte installée ! Elle inclut aussi la bibliothèque Wire.h , qui permet de communiquer avec les périphériques I2C. Cette bibliothèque est généralement préinstallée avec l’IDE Arduino.

Si vous souhaitez en savoir plus sur le contrôle d’un écran LCD I2C avec Arduino, vous pouvez consulter notre tutoriel sur How to control a character I2C LCD with Arduino.

/* HC-SR04 ultrasonic distance sensor with 
   Arduino and I2C LCD example code.
   More info: https://www.makerguides.com
*/

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define SDA and SCL pin for LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Change to (0x27,16,2) for 1602 LCD 

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance:
  distance = duration*0.034/2;

  // Display the distance on the LCD:
  lcd.setCursor(0,0); // Set the cursor to column 1, line 1 (counting starts at zero)
  lcd.print("Distance = "); // Prints string "Display = " on the LCD
  lcd.print(distance); // Prints the measured distance
  lcd.print(" cm  "); // Prints "cm" on the LCD, extra spaces are needed to clear previously displayed characters
  
  delay(50);
}

Notez que j’ai utilisé un écran LCD 20 x 4. Si vous avez un écran LCD d’une autre taille (16 x 2 est aussi courant), vous devez modifier la ligne 20 en LiquidCrystal_I2C lcd(0x27,16,2);. Si votre écran LCD n’a pas l’adresse I2C par défaut, 0x27, consultez le tutoriel complet sur l’I2C où j’explique comment trouver l’adresse correcte.

Exemple de code HC-SR04 avec capteur de température DHT11 et Arduino

Comme mentionné plus tôt, la vitesse du son dépend fortement de la température de l’air. Si vous souhaitez mesurer de longues distances (3-4 m), il peut être judicieux d’ajouter un capteur DHT11 ou DHT22 de température et d’humidité à votre montage. Cela vous permettra de calibrer la vitesse du son en temps réel et ainsi d’améliorer la précision de vos mesures.

Ajouter un capteur DHT11 est très simple. Le schéma de câblage ci-dessous montre les connexions nécessaires. Notez que j’utilise un DHT11avec une carte d’interface, donc je n’ai besoin de câbler que 3 broches. Assurez-vous de vérifier l’étiquette du capteur, l’ordre des broches peut varier selon le fabricant. Le capteur HC-SR04 est connecté de la même manière qu’avant.

Connexions DHT11

DHT11	Arduino
VCC (+)	5 V
Signal (s)	Broche 4
GND (-)	GND

Le code ci-dessous utilise la bibliothèque Adafruit DHT Humidity & Temperature Sensor que vous pouvez télécharger sur GitHub. Cette bibliothèque ne fonctionne que si vous avez également installé la bibliothèque Adafruit_Sensor, disponible aussi sur GitHub. Vous pouvez aussi télécharger les deux bibliothèques en cliquant sur les boutons ci-dessous :

Vous pouvez cliquer sur le bouton en haut à droite du champ de code pour copier le code.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11 and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" //https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" //https://github.com/adafruit/DHT-sensor-library

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Begin Serial communication:
  Serial.begin(9600); // Starts the serial communication
}

void loop() {
  //  Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  float temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.print(" Celsius");
  Serial.print(", Distance = ");
  Serial.print(distance);
  Serial.println("cm");
  delay(100);
}

Exemple de code HC-SR04 avec DHT11 et écran LCD I2C

Le code ci-dessous permet de combiner les 3 exemples précédents. Il affiche la température, la vitesse du son et la distance mesurée sur l’écran LCD.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11, I2C LCD and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" // https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" // https://github.com/adafruit/DHT-sensor-library
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define SDA and SCL pin from LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via i2c, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4);

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();

  // Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  int temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  lcd.setCursor(0,0);
  lcd.print("Temperature: ");
  lcd.print(temperature);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Speed: ");
  lcd.print(speedofsound);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distance: ");
  lcd.print(distance);
  lcd.print(" cm  ");
  delay(100);
}

Dimensions du HC-SR04

Vous trouverez ci-dessous les dimensions du capteur ultrasonique HC-SR04. J’ai remarqué qu’il existe de petites différences entre fabricants, je vous recommande donc de vérifier avec votre propre capteur.

CAO HC-SR04

J’ai créé des dessins CAO basiques du capteur ultrasonique HC-SR04 que vous pouvez télécharger ci-dessous.

Conclusion

Dans cet article, je vous ai montré comment fonctionne le capteur de distance ultrasonique HC-SR04 et comment l’utiliser avec Arduino.

Projet personnel : Il y a quelque temps, j’ai réalisé une installation murale interactive avec des amis. Nous avons utilisé environ 30 capteurs de distance ultrasoniques pour détecter les personnes passant devant le mur. Le mur comprenait des lumières et des effets sonores qui changeaient en fonction de la distance des personnes.

Les capteurs de distance/proximité ultrasoniques bon marché sont excellents, mais dans certains projets, vous pourriez avoir besoin d’un capteur étanche comme le JSN-SR04T ou d’un capteur IR qui n’est pas influencé par les variations de température. Dans ce cas, les articles ci-dessous pourraient vous être utiles :

• Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial
• How to use a SHARP GP2Y0A21YK0F IR Distance Sensor with Arduino
• How to use a SHARP GP2Y0A710K0F IR Distance Sensor with Arduino
• MaxBotix MB7389 weather-resistant distance sensor tutorial
• MaxBotix MB1240 ultrasonic distance sensor Arduino tutorial

Si vous avez des questions, des suggestions ou si vous pensez que des éléments manquent dans ce tutoriel, veuillez laisser un commentaire ci-dessous.