Comment utiliser un capteur de distance à ultrasons HC-SR04 avec Arduino

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

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

Les capteurs de distance / proximité à ultrasons bon marché sont excellents, mais dans certains projets, vous pourriez avoir besoin d’un capteur étanche comme le JSN-SR04T ou d’un capteur infrarouge qui n’est pas influencé par les changements de température.

Composants matériels

  1. Capteur HC-SR04
  2. Arduino Uno Rev 3 Arduino Uno Rev3
  3. Breadbord
  4. Fils
  5. Câble USB type A / B
  6. lcd LCD I2C 20 × 4 caractères (en option)
  7. Capteur DHT11 (en option)

Comment fonctionne un capteur de distance à ultrasons?

Les capteurs à ultrasons fonctionnent en émettant des ondes sonores avec une fréquence trop élevée pour qu’un humain puisse les entendre. Ces ondes sonores voyagent 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 à ultrasons les détecte. En mesurant le temps écoulé entre l’envoi et la réception des ondes sonores, la distance entre le capteur et l’objet peut être calculée.

Comment fonctionnent les capteurs à ultrasons Maxbotix
Principe de fonctionnement des capteurs de distance à ultrasons. Source:  https://www.maxbotix.com/

À 20 ° C, la vitesse du son est d’environ 343 m / s ou 0,034 cm / µs. Disons que le temps entre l’envoi et la réception des ondes sonores est de 2000 microsecondes. Si vous multipliez la vitesse du son par le temps que les ondes sonores ont parcouru, vous obtenez la distance parcourue par les ondes sonores.

Distance = Vitesse x Temps

Mais ce n’est pas le résultat que nous recherchons. La distance entre le capteur et l’objet n’est en réalité que la moitié de cette distance car les ondes sonores se sont déplacées du capteur vers l’objet et de l’objet vers le capteur. Vous devez donc diviser le résultat par deux.

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

Et donc pour l’exemple cela devient:

Distance (cm) = 0.0343 (cm/µs) × 2000 (µs) / 2 = 34.3 cm


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

La vitesse du son dépend en fait fortement de la température et dans une bien moindre mesure de l’humidité de l’air. Wikipedia déclare que la  vitesse du son  augmente d’environ 0,6 m / s par degré Celsius. Dans la plupart des cas à 20 ° C, vous pouvez simplement utiliser 343 m / s, mais si vous souhaitez obtenir des lectures 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é puisque son effet sur la vitesse du son n’est que très faible.

Vous trouverez ci-dessous un didacticiel sur l’utilisation d’un  capteur de  température et d’humidité DHT11 pour calibrer la vitesse du son et obtenir une lecture de distance plus précise avec le HC-SR04.


Comment fonctionne le HC-SR04

À l’avant du   capteur HC-SR04 , vous pouvez trouver deux cylindres en argent (transducteurs à ultrasons), l’un est l’émetteur des ondes sonores et l’autre est le récepteur. Pour permettre au capteur de générer une rafale sonore, vous devez régler la broche de déclenchement sur une valeur élevée pendant au moins 10 µs. Le capteur crée alors une rafale de 8 cycles d’ultrasons à 40 kHz.

Cette salve sonore se déplace à la vitesse du son et rebondit et est reçue par le récepteur du capteur. La broche Echo délivre alors le temps que les ondes sonores ont parcouru en microsecondes.

Vous pouvez utiliser la  pulseIn() fonction dans le code Arduino pour lire la longueur de l’impulsion à partir de la broche Echo. Après cela, vous pouvez utiliser la formule mentionnée ci-dessus pour calculer la distance entre le capteur et l’objet.

Spécifications HC-SR04

Tension de fonctionnement5 V
Courant de fonctionnement15 mA
La fréquence40 kHz
Plage de mesure2 – 400 cm
Résolution3 mm
Angle de mesure15 degrés
Signal d’entrée de déclenchement10 µs high pulse
CoûtVérifiez le prix

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

Fiche technique HC-SR04

Câblage – Connexion de HC-SR04 à Arduino UNO

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

HC-SR04-capteur-de-distance-ultrasonique-avec-diagramme-de-câblage-Arduino-tutoriel-schématique
HC-SR04 avec schéma de câblage Arduino

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

Connexions HC-SR04

HC-SR04Arduino
VCC5 V
TrigonométrieBroche 2
ÉchoBroche 3
GNDGND

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écharger du code. Vous pouvez télécharger l’exemple de code suivant sur votre Arduino à l’aide de l’  IDE Arduino . Ensuite, je vais vous expliquer comment fonctionne le code.

/ * Exemple de code pour le capteur de distance à ultrasons HC-SR04 avec Arduino. Aucune bibliothèque requise. Plus d’infos: https://www.makerguides.com * /
// Définir la broche Trig et Echo:
#define trigPin 2
#define echoPin 3
// Définir les variables:
longue durée;
int distance;
void setup () {
// Définir les entrées et les sorties:
pinMode ( trigPin, OUTPUT ) ;
pinMode ( echoPin, INPUT ) ;
// Commencez la communication série à un débit de 9600 bauds:
En série. commencer ( 9600 ) ;
}
boucle void () {
// Effacez le trigPin en le définissant sur LOW:
digitalWrite ( trigPin, LOW ) ;
delayMicrosecondes ( 5 ) ;
// Déclenchez le capteur en définissant le trigPin élevé pendant 10 microsecondes:
digitalWrite ( trigPin, HIGH ) ;
delayMicrosecondes ( 10 ) ;
digitalWrite ( trigPin, LOW ) ;
// Lire le echoPin, pulseIn () renvoie la durée (longueur de l’impulsion) en microsecondes:
durée = pulseIn ( echoPin, HIGH ) ;
// Calculez la distance:
distance = duration * 0.034 / 2;
// Affiche la distance sur le moniteur série (Ctrl + Maj + M):
En série. print ( “Distance =” ) ;
En série. impression ( distance ) ;
En série. println ( “cm” ) ;
retard ( 50 ) ;
}

Comment fonctionne le code

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

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

// Définir la broche Trig et Echo:
#define trigPin 2
#define echoPin 3

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

// Définir les variables:
longue durée;
int distance;

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

void setup () {
// Définir les entrées et les sorties:
pinMode ( trigPin, OUTPUT ) ;
pinMode ( echoPin, INPUT ) ;
// Commencez la communication série à un débit de 9600 bauds:
En série. commencer ( 9600 ) ;
}

Dans le  loop(), vous déclenchez le capteur en réglant le trigPin HIGH pendant 10 µs. Notez que pour obtenir un signal propre, vous commencez par effacer le trigPin en le réglant sur LOW pendant 5 microsecondes.

boucle void () {
// Effacez le trigPin en le définissant sur LOW:
digitalWrite ( trigPin, LOW ) ;
delayMicrosecondes ( 5 ) ;
// Déclenchez le capteur en définissant le trigPin élevé pendant 10 microsecondes:
digitalWrite ( trigPin, HIGH ) ;
delayMicrosecondes ( 10 ) ;
digitalWrite ( trigPin, LOW ) ;

Ensuite, vous devez lire la longueur de l’impulsion envoyée par l’échoPin. J’utilise la fonction  pulseIn() pour cela. Cette fonction attend que la broche passe de BAS à HAUT, démarre le chronométrage, puis attend que la broche passe à BAS 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 didacticiel.

// Lire le echoPin, pulseIn () renvoie la durée (longueur de l’impulsion) en microsecondes:
durée = pulseIn ( echoPin, HIGH ) ;
// Calculez la distance:
distance = duration * 0.034 / 2;

Enfin, la distance calculée est imprimée sur le moniteur série.

// Affiche la distance sur le moniteur série (Ctrl + Maj + M):
En série. print ( “Distance =” ) ;
En série. impression ( distance ) ;
En série. println ( “cm” ) ;
retard ( 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 à ultrasons. La dernière version de cette bibliothèque peut être téléchargée ici sur  bitbucket.org.  Vous remarquerez peut-être que le code ci-dessous, qui utilise la bibliothèque NewPing, est beaucoup plus court que le code que nous utilisions auparavant. En plus de cela, la bibliothèque NewPing inclut d’autres fonctionnalités intéressantes. Il vous permet de définir une distance maximale de lecture, il ne restera pas en retard pendant une seconde complète lorsqu’aucun écho n’est reçu et il dispose d’un filtre médian intégré.

NewPing_v1.9.1.zip

Vous pouvez installer la bibliothèque en allant dans  Sketch> Inclure la bibliothèque> Ajouter une bibliothèque .ZIP  dans l’IDE Arduino.

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

/ * Capteur de distance à ultrasons HC-SR04 avec exemple de code de bibliothèque NewPing. Plus d’infos: www.makerguides.com * /
// Inclut la bibliothèque:
#include <NewPing.h>
// Définir les broches et la distance maximale:
#define trigPin 2
#define echoPin 3
#define MAX_DISTANCE 350 // Distance maximale pour laquelle nous voulons envoyer un ping (en centimètres). La distance maximale du capteur est de 400 à 500 cm.
NewPing sonar ( trigPin, echoPin, MAX_DISTANCE ) ; // Configuration NewPing des broches et distance maximale.
durée du flotteur, distance;
void setup () {
En série. commencer ( 9600 ) ; // Ouvre le moniteur série à 9600 bauds pour voir les résultats du ping.
}
boucle void () {
retard ( 50 ) ; // Attendez 50 ms entre les pings (environ 20 pings / s). 29 ms devrait être le délai le plus court entre les pings.
durée = sonar. ping () ;
distance = (duration / 2) * 0.0343;
En série. print ( “Distance =” ) ;
En série. impression ( distance ) ; // La distance sera de 0 lorsqu’elle est hors de la plage maximale définie.
En série. println ( “cm” ) ;
}

Vous pouvez également utiliser  distance = sonar.ping_cm() ou  distance = sonar.ping_in() qui renvoie la distance mesurée en centimètres ou en pouces entiers. Avec cette fonction, vous n’avez pas besoin de prendre une mesure de durée et de calculer la distance.

Interfaçage des capteurs à ultrasons en mode 3 broches

La bibliothèque NewPing facilite également l’interface avec les capteurs à ultrasons tout en utilisant seulement 1 broche d’E / S. Cela peut être pratique si vous avez très peu de broches d’E / S disponibles ou si vous souhaitez utiliser un capteur à ultrasons à 3 broches comme le  Parallax Ping .

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

// Définir la broche Trig et Echo
#define trigPin 2
#define echoPin 2

Comment utiliser le filtre numérique ping_median ()

La principale chose que j’aime à propos de la bibliothèque NewPing est qu’elle possède un filtre médian intégré. Ce filtre peut grandement améliorer la précision de vos lectures HC-SR04. La  ping_median() fonction prend de nombreuses mesures de durée d’affilée, jette les lectures hors de portée, puis calcule la moyenne des autres. Par défaut, cela prendra 5 lectures mais vous pouvez spécifier combien cela devrait prendre. Remplacez la ligne 19 par les lignes ci-dessous.

itérations int = 5 ;
durée = sonar. ping_median ( itérations ) ;

Exemple de code HC-SR04 avec I2C LCD et Arduino

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

HC-SR04 avec câblage I2C LCD et Arduino UNO
HC-SR04 avec Arduino et schéma de câblage LCD I2C.

Connexions LCD I2C

LCD I2CArduino
GNDGND
VCC5 V
SDAA4
SCLA5

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

TableauSDASCL
Arduino unoA4A5
Arduino NanoA4A5
Arduino Micro23
Arduino Mega 25602021
Arduino Leonardo23
Arduino Due2021
Emplacements des broches I2C pour différentes cartes Arduino

Le code utilise la   bibliothèque LiquidCrystal_I2C , que vous pouvez télécharger  ici sur GitHub . Assurez-vous que cette bibliothèque exacte est installée! Il comprend également la   bibliothèque Wire.h , qui vous permet de communiquer avec les périphériques I2C. Cette bibliothèque doit être préinstallée avec l’IDE Arduino.

LiquidCrystal_I2C-master.zip

Si vous souhaitez en savoir plus sur la façon de contrôler un écran LCD I2C avec Arduino, vous pouvez consulter le tutoriel complet ici.

  • Comment contrôler un écran LCD I2C avec Arduino
/*
Capteur de distance à ultrasons HC-SR04 avec exemple de code LCD Arduino et I2C.
Plus d’infos: https://www.makerguides.com
*/
// Inclut les bibliothèques:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Définir la broche Trig et Echo:
#define trigPin 2
#define echoPin 3
// Définissez les broches SDA et SCL pour l’écran LCD:
#define SDAPin A4 // Broche de données
#define SCLPin A5 // Broche d’horloge
// Se connecter à l’écran LCD via I2C, adresse par défaut 0x27 (A0-A2 sans cavalier):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C ( 0x27 , 20 , 4 ) ; // Changer en (0x27,16,2) pour 1602 LCD
// Définir les variables:
longue durée;
int distance;
void setup () {
// Définir les entrées et les sorties:
pinMode ( trigPin, OUTPUT ) ;
pinMode ( echoPin, INPUT ) ;
// Lancez l’écran LCD:
lcd. init () ;
lcd. rétroéclairage () ;
}
boucle void () {
// Effacez le trigPin en le définissant sur LOW:
digitalWrite ( trigPin, LOW ) ;
delayMicrosecondes ( 5 ) ;
// Déclenchez le capteur en définissant le trigPin élevé pendant 10 microsecondes:
digitalWrite ( trigPin, HIGH ) ;
delayMicrosecondes ( 10 ) ;
digitalWrite ( trigPin, LOW ) ;
// Lire le echoPin. Cela renvoie la durée (longueur de l’impulsion) en microsecondes:
durée = pulseIn ( echoPin, HIGH ) ;
// Calculez la distance:
distance = duration*0.034/2;
// Afficher la distance sur l’écran LCD:
lcd. setCursor ( 0 , 0 ) ; // Positionne le curseur sur la colonne 1, ligne 1 (le comptage commence à zéro)
lcd. print ( “Distance =” ) ; // Imprime la chaîne “Display =” sur l’écran LCD
lcd. impression ( distance ) ; // Imprime la distance mesurée
lcd. impression ( “cm” ) ; // Imprime “cm” sur l’écran LCD, des espaces supplémentaires sont nécessaires pour effacer les caractères précédemment affichés
retard ( 50 ) ;
}

Notez que j’ai utilisé un écran LCD 20 x 4. Si vous avez un écran LCD de taille différente (16 x 2 est également courant), vous devez changer 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 didacticiel I2C complet où j’explique comment vous pouvez trouver l’adresse.


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

Comme mentionné précédemment, 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 de  température et d’humidité DHT11 ou  DHT22 à votre installation. Cela vous permettra de calibrer la vitesse du son en temps réel et ainsi d’augmenter la précision de vos mesures.

L’ajout d’un capteur DHT11 est vraiment simple. Le schéma de câblage ci-dessous vous montre les connexions que vous devez effectuer. Notez que j’utilise un  DHT11 avec une carte de dérivation , 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 être différent  selon le fabricant. Le capteur HC-SR04 est connecté de la même manière qu’auparavant.

HC-SR04 avec câblage DHT11 et Arduino UNO
HC-SR04 avec schéma de câblage Arduino et DHT11.

Connexions DHT11

DHT11Arduino
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  ici sur GitHub . Cette bibliothèque ne fonctionne que si vous avez également la  bibliothèque Adafruit_Sensor  installée, qui est également  disponible sur GitHub . Vous pouvez également télécharger les deux bibliothèques en cliquant sur les boutons ci-dessous:

DHT-sensor-library-master.zip
Adafruit_Sensor-master.zip

Vous pouvez cliquer sur le bouton dans le coin supérieur droit du champ de code pour copier le code.

/*
Capteur de distance à ultrasons HC-SR04 avec exemple de code DHT11 et Arduino.
Plus d’infos: https://www.makerguides.com
*/
// Inclut la bibliothèque de capteurs Adafruit:
#include <Adafruit_Sensor.h> //https://github.com/adafruit/Adafruit_Sensor
// Inclut la bibliothèque Adafruit DHT:
#include <DHT.h> //https://github.com/adafruit/DHT-sensor-library
// Définir la broche Trig, la broche Echo et DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Définir le type de capteur DHT:
#define DHTType DHT11
// Définir les variables:
longue durée;
int distance;
flotteur speedofsound;
// Créer un objet capteur DHT:
DHT dht = DHT ( DHTPin, DHTType ) ;
void setup () {
// Définir les entrées et les sorties:
pinMode ( trigPin, OUTPUT ) ;
pinMode ( echoPin, INPUT ) ;
dht. begin () ;
// Commencer la communication série:
En série. commencer ( 9600 ) ; // Démarre la communication série
}
boucle void () {
// Effacez le trigPin en le définissant sur LOW:
digitalWrite ( trigPin, LOW ) ;
delayMicrosecondes ( 5 ) ;
// Déclenchez le capteur en définissant le trigPin élevé pendant 10 microsecondes:
digitalWrite ( trigPin, HIGH ) ;
delayMicrosecondes ( 10 ) ;
digitalWrite ( trigPin, LOW ) ;
// Lire le echoPin. Cela renvoie la durée (longueur de l’impulsion) en microsecondes:
durée = pulseIn ( echoPin, HIGH ) ;
// Lire la température:
température du flotteur = dht. readTemperature () ;
// Calcul de la vitesse du son en m / s:
speedofsound = 331,3 + ( 0,606 * température ) ;
// Calculez la distance en cm:
distance = durée * ( vitesse du son / 10000 ) / 2 ;
// Imprimer la distance et la température sur le moniteur série:
En série. print ( “Température =” ) ;
En série. impression ( température ) ;
En série. impression ( “Celsius” ) ;
En série. print ( “, Distance =” ) ;
En série. impression ( distance ) ;
En série. println ( “cm” ) ;
retard ( 100 ) ;
}

Exemple de code HC-SR04 avec DHT11 et I2C LCD

HC-SR04 avec schéma de câblage LCD Arduino, DHT11 et I2C.

Le code ci-dessous peut être utilisé pour combiner les 3 exemples ci-dessus. Il affiche à la fois la température, la vitesse du son et la distance mesurée sur l’écran LCD.

/*
Capteur de distance à ultrasons HC-SR04 avec exemple de code DHT11, I2C LCD et Arduino.
Plus d’infos: https://www.makerguides.com
*/
// Inclut la bibliothèque de capteurs Adafruit:
#include <Adafruit_Sensor.h> // https://github.com/adafruit/Adafruit_Sensor
// Inclut la bibliothèque Adafruit DHT:
#include <DHT.h> // https://github.com/adafruit/DHT-sensor-library
#include <Wire.h> // Bibliothèque pour la communication I2C
#include <LiquidCrystal_I2C.h> // Bibliothèque pour LCD
// Définir la broche Trig, la broche Echo et DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Définissez les broches SDA et SCL à partir de l’écran LCD:
#define SDAPin A4 // Broche de données
#define SCLPin A5 // Broche d’horloge
// Connectez-vous à l’écran LCD via i2c, adresse par défaut 0x27 (A0-A2 sans cavalier):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C ( 0x27 , 20 , 4 ) ;
// Définir le type de capteur DHT:
#define DHTType DHT11
// Définir les variables:
longue durée;
int distance;
flotteur speedofsound;
// Créer un objet capteur DHT:
DHT dht = DHT ( DHTPin, DHTType ) ;
void setup () {
// Définir les entrées et les sorties:
pinMode ( trigPin, OUTPUT ) ;
pinMode ( echoPin, INPUT ) ;
dht. begin () ;
// Lancez l’écran LCD:
lcd. init () ;
lcd. rétroéclairage () ;
// Commencez la communication série à un débit de 9600 bauds:
En série. commencer ( 9600 ) ;
}
boucle void () {
// Effacez le trigPin en le définissant sur LOW:
digitalWrite ( trigPin, LOW ) ;
delayMicrosecondes ( 5 ) ;
// Déclenchez le capteur en définissant le trigPin élevé pendant 10 microsecondes:
digitalWrite ( trigPin, HIGH ) ;
delayMicrosecondes ( 10 ) ;
digitalWrite ( trigPin, LOW ) ;
// Lire le echoPin. Cela renvoie la durée (longueur de l’impulsion) en microsecondes:
durée = pulseIn ( echoPin, HIGH ) ;
// Lire la température:
température int = dht. readTemperature () ;
// Calcul de la vitesse du son en m / s:
speedofsound = 331,3 + ( 0,606 * température ) ;
// Calculez la distance en cm:
distance = durée * ( vitesse du son / 10000 ) / 2 ;
// Imprimer la distance et la température sur le moniteur série:
lcd. setCursor ( 0 , 0 ) ;
lcd. print ( “Température:” ) ;
lcd. impression ( température ) ;
lcd. impression ( “” “\ xDF” “C” ) ;
lcd. setCursor ( 0 , 1 ) ;
lcd. print ( “Vitesse:” ) ;
lcd. impression ( speedofsound ) ;
lcd. impression ( “m / s” ) ;
lcd. setCursor ( 0 , 2 ) ;
lcd. print ( “Distance:” ) ;
lcd.print(distance);
lcd. impression ( “cm” ) ;
retard ( 100 ) ;
}

HC-SR04 Dimensions

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

HC-SR04 Dimensions
HC-SR04 Dimensions

Conclusion

Dans cet article, je vous ai montré comment fonctionne le capteur de distance à ultrasons HC-SR04 et comment vous pouvez l’utiliser avec Arduino. J’espère que vous l’avez trouvé utile et instructif. Si c’est le cas,  partagez-le avec un ami  qui aime aussi l’électronique!

Projet personnel: Il y a quelques mois, j’ai construit une installation murale interactive avec des amis. Nous avons utilisé une trentaine de capteurs de distance à ultrasons pour détecter les personnes marchant devant le mur. Le mur comprenait des lumières et des effets sonores qui changeaient en fonction de la distance à laquelle les gens se tenaient.

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.

    Rejoindre la liste d'attente Nous vous informerons lorsque le produit arrivera en stock. Veuillez laisser votre adresse E-mail et la quantité voulue.

    Main Menu

    بحاجة الى مساعدة ؟