HC-SR04 Module Ultrasonique Détection de Distance

Description

Module Ultrasonique Détection de Distance HC-SR04

Le module HC-SR04 est un capteur de distance à ultrasons populaire qui utilise des ondes sonores pour mesurer la distance à un objet. Il offre des mesures de distance précises de 2 cm à 400 cm avec une précision d’environ 3 mm.

Caractéristiques en détail

• Tension de fonctionnement : 5V DC
• Courant de fonctionnement : < 15mA
• Fréquence de fonctionnement : 40 kHz
• Angle de détection : 15 degrés
• Distance de mesure : 2 cm à 400 cm
• Précision : ± 3 mm
• Dimensions : 45 x 20 x 15 mm

Fonctionnement

Le capteur HC-SR04 utilise un émetteur et un récepteur à ultrasons. L’émetteur envoie une rafale d’ultrasons, et le récepteur attend l’écho réfléchi par un objet. Le temps écoulé entre l’émission et la réception de l’onde est utilisé pour calculer la distance à l’objet en utilisant la formule : $\text{Distance} = \frac{\text{Vitesse du son} \times \text{Temps}}{2}$

Applications

• Robotique : Évitement d’obstacles
• Systèmes de sécurité : Détection de présence
• Projets de bricolage : Mesure de distance et surveillance
• Automatisation industrielle : Contrôle et détection d’objets

Brochage

• Trig : Connecté à la broche de déclenchement (Trig) de l’Arduino
• Echo : Connecté à la broche d’écho (Echo) de l’Arduino
• VCC : Connecté à l’alimentation 5V de l’Arduino
• GND : Connecté à la masse de l’Arduino

Comment l’utiliser

Pour utiliser le capteur HC-SR04 avec un Arduino, connectez la broche Trig à une sortie numérique (par exemple, D2), la broche Echo à une entrée numérique (par exemple, D3), la broche VCC à l’alimentation 5V et la broche GND à la masse.

Comment l’utiliser avec Arduino Uno

Exemple de code Arduino de base

#define trigPin 2 // Définir la broche 2 pour le Trig
#define echoPin 3 // Définir la broche 3 pour l'Echo


long duration; // Variable pour la durée de l'écho
int distance; // Variable pour la distance calculée


void setup() {
  pinMode(trigPin, OUTPUT); // Configurer trigPin en sortie
  pinMode(echoPin, INPUT); // Configurer echoPin en entrée
  Serial.begin(9600); // Initialiser la communication série à 9600 bauds
}


void loop() {
  // Envoyer une impulsion ultrasonique de 10 µs
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigPin, LOW);


  // Lire la durée de l'écho
  duration = pulseIn(echoPin, HIGH);


  // Calculer la distance en utilisant la formule
  distance = duration * 0.034 / 2; 


  // Afficher la distance sur le moniteur série
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");


  delay(1000); // Attendre 1 seconde avant de refaire une lecture
}

But du code

Ce code lit les valeurs du capteur ultrasonique et calcule la distance à un objet. Les résultats sont affichés sur le moniteur série.

Composants nécessaires pour le code de base

• Arduino Uno
• Module détecteur de distance ultrasonique HC-SR04
• Câbles de connexion

Explication détaillée du code de base

1. Initialisation des broches : trigPin est configuré comme une sortie et echoPin comme une entrée.
2. Envoi du signal ultrasonique : Une impulsion de 10 µs est envoyée sur trigPin pour déclencher l’émission d’une rafale d’ultrasons.
3. Mesure du temps d’écho : La durée du retour de l’écho est mesurée sur echoPin.
4. Calcul de la distance : La distance est calculée en multipliant la durée par la vitesse du son (0.034 cm/µs) et en divisant par 2.
5. Affichage de la distance : La distance calculée est affichée sur le moniteur série.

Brochage détaillé des connexions du code de base

• Trig : Connecté à la broche 2 de l’Arduino
• Echo : Connecté à la broche 3 de l’Arduino
• VCC : Connecté à la broche 5V de l’Arduino
• GND : Connecté à la broche GND de l’Arduino

Exemple de code Arduino avancé pour affichage sur LCD avec commentaires détaillés

#include <Wire.h> // Inclusion de la bibliothèque Wire pour I2C
#include <LiquidCrystal_I2C.h> // Inclusion de la bibliothèque LiquidCrystal_I2C pour l'écran LCD I2C


// Constantes
const int TRIG_PIN = 2; // Définir la broche 2 pour le Trig
const int ECHO_PIN = 3; // Définir la broche 3 pour l'Echo
const int PULSE_DURATION = 10; // Durée de l'impulsion en microsecondes
const float SPEED_OF_SOUND = 0.034; // Vitesse du son en cm par microseconde


LiquidCrystal_I2C lcd(0x27, 16, 2); // Initialisation de l'écran LCD I2C avec l'adresse 0x27 et une taille de 16x2


void setup() {
  pinMode(TRIG_PIN, OUTPUT); // Configurer TRIG_PIN en sortie
  pinMode(ECHO_PIN, INPUT); // Configurer ECHO_PIN en entrée
  lcd.begin(); // Initialiser l'écran LCD
  lcd.backlight(); // Allumer le rétroéclairage de l'écran LCD
  Serial.begin(9600); // Initialiser la communication série à 9600 bauds
}


void loop() {
  // Envoyer une impulsion ultrasonique de 10 µs
  digitalWrite(TRIG_PIN, LOW); 
  delayMicroseconds(2); 
  digitalWrite(TRIG_PIN, HIGH); 
  delayMicroseconds(PULSE_DURATION); 
  digitalWrite(TRIG_PIN, LOW);


  // Lire la durée de l'écho
  long duration = pulseIn(ECHO_PIN, HIGH);


  // Vérifier les lectures invalides du capteur
  if (duration == 0) {
    Serial.println("Erreur: Lecture du capteur invalide");
    return;
  }


  // Calculer la distance en utilisant la formule
  float distance = duration * SPEED_OF_SOUND / 2;


  // Afficher la distance sur l'écran LCD
  lcd.setCursor(0, 0); // Positionner le curseur à la première ligne
  lcd.print("Distance: "); 
  lcd.print(distance, 2); // Afficher avec 2 décimales
  lcd.print(" cm");


  // Afficher la distance sur le moniteur série
  Serial.print("Distance: ");
  Serial.print(distance, 2);
  Serial.println(" cm");


  delay(1000); // Attendre 1 seconde avant de refaire une lecture
}

Explication détaillée du code amélioré

1. Inclusion des bibliothèques : Les bibliothèques Wire.h et LiquidCrystal_I2C.h sont incluses pour permettre la communication avec l’écran LCD utilisant le protocole I2C.
2. Définition des constantes : Les constantes définissent les broches du capteur ultrasonique (TRIG_PIN et ECHO_PIN), la durée de l’impulsion (PULSE_DURATION), et la vitesse du son en cm par microseconde (SPEED_OF_SOUND).
3. Initialisation des broches et de l’écran LCD :
   • La fonction setup() initialise l’écran LCD en appelant les méthodes begin() et backlight() de la bibliothèque LiquidCrystal_I2C.
   • Elle initialise également la communication série à une vitesse de 9600 bauds.
   • Les broches TRIG_PIN et ECHO_PIN sont configurées respectivement en sortie et en entrée.
4. Envoi du signal ultrasonique :
   • Une impulsion de 10 µs est envoyée sur TRIG_PIN pour déclencher l’émission d’une rafale d’ultrasons.
5. Mesure du temps d’écho :
   • La durée du retour de l’écho est mesurée sur ECHO_PIN à l’aide de la fonction pulseIn().
6. Vérification des lectures invalides :
   • Si la durée mesurée est de 0, un message d’erreur est affiché sur le moniteur série et le programme retourne sans effectuer de calculs supplémentaires.
7. Calcul de la distance :
   • La distance est calculée en utilisant la formule (duration * SPEED_OF_SOUND / 2).
8. Affichage des valeurs :
   • La distance est affichée sur l’écran LCD avec deux décimales de précision.
   • La distance est également affichée sur le moniteur série avec deux décimales de précision.

Composants nécessaires pour le code avancé

• Arduino Uno
• Module détecteur de distance ultrasonique HC-SR04
• Écran LCD I2C 1602
• Câbles de connexion

Installation de Drivers/bibliothèques

Codes de base et avancé Aucune bibliothèque spéciale n’est nécessaire pour le code de base. Pour le code avancé utilisant un écran LCD I2C, installez la bibliothèque LiquidCrystal_I2C via le gestionnaire de bibliothèques de l’IDE Arduino.

1. Ouvrez l’IDE Arduino.
2. Allez dans le menu Sketch -> Include Library -> Manage Libraries…
3. Recherchez LiquidCrystal_I2C et cliquez sur Installer.

Datasheet du HC-SR04

Mots clés: ultrasonic, ranging, range, sr04, sensor, sonar.