ESP32 avec capteur à ultrasons HC-SR04 avec Arduino IDE

ESP32 avec capteur à ultrasons HC-SR04 avec Arduino IDE

Ce guide montre comment utiliser le capteur à ultrasons HC-SR04 avec la carte ESP32 en utilisant le noyau Arduino. Le capteur à ultrasons utilise un sonar pour déterminer la distance à un objet. Nous allons vous montrer comment câbler le capteur à l’ESP32 et fournir plusieurs exemples de croquis pour déterminer la distance à un objet à l’aide du HC-SR04.

ESP32 avec module de capteur à ultrasons HC-SR04 avec Arduino IDE

Ce tutoriel couvre les sujets suivants :

Présentation du capteur à ultrasons HC-SR04

Le capteur à ultrasons HC-SR04 utilise un sonar pour déterminer la distance à un objet. Ce capteur lit de 2 cm à 400 cm (0,8 pouce à 157 pouces) avec une précision de 0,3 cm (0,1 pouce), ce qui convient à la plupart des projets amateurs. De plus, ce module particulier est livré avec des modules émetteurs et récepteurs à ultrasons.

L’image suivante montre le capteur à ultrasons HC-SR04.

HC-SR04 Module de capteur à ultrasons composant de mesure de distance avant

L’image suivante montre l’autre côté du capteur.

HC-SR04 Module de capteur à ultrasons Composant de mesure de distance Partie arrière

Où acheter le capteur à ultrasons HC-SR04 ?

Vous pouvez consulter le capteur Ultrasonic Sensor HC-SR04 sur Maker Advisor pour trouver le meilleur prix :

Données techniques du capteur à ultrasons HC-SR04

Le tableau suivant présente les principales caractéristiques et spécifications du capteur à ultrasons HC-SR04. Pour plus d’informations, vous devez consulter la fiche technique du capteur.

Source de courant 5V CC
Courant de travail 15 mA
Fréquence de travail 40kHz
Portée maximale 4 mètres
Portée minimale 2 cm
Angle de mesure 15º
Résolution 0,3 cm
Signal d’entrée de déclenchement impulsion TTL 10uS
Signal de sortie d’écho Impulsion TTL proportionnelle à la plage de distance
Dimensions 45 mm x 20 mm x 15 mm

Brochage du capteur à ultrasons HC-SR04

Voici le brochage du capteur à ultrasons HC-SR04.

VCC Alimente le capteur (5V)
Trigonométrie Broche d’entrée de déclenchement
Écho Broche de sortie d’écho
GND GND commun

Comment fonctionne le capteur à ultrasons HC-SR04 ?

Le capteur à ultrasons utilise un sonar pour déterminer la distance à un objet. Voici comment ça fonctionne:

  1. L’émetteur d’ultrasons (trig pin) émet un son à haute fréquence (40 kHz).
  2. Le son voyage dans l’air. S’il trouve un objet, il rebondit vers le module.
  3. Le récepteur d’ultrasons (broche d’écho) reçoit le son réfléchi (écho).
Comment fonctionne le module de capteur à ultrasons HC-SR04

En tenant compte de la vitesse du son dans l’air et du temps de trajet (temps écoulé depuis l’émission et la réception du signal) on peut calculer la distance à un objet. Voici la formule :

distance to an object = ((speed of sound in the air)*time)/2
  • vitesse du son dans l’air à 20ºC (68ºF) = 343 m/s

Pièces requises

Carte ESP32 Module de capteur à ultrasons HC-SR04 Pièces Arduino requises

Pour terminer ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1641836899 909 ESP32 avec capteur a ultrasons HC SR04 avec Arduino IDE

Schéma – ESP32 avec capteur à ultrasons HC-SR04

Câblez le capteur à ultrasons HC-SR04 à l’ESP32 comme indiqué dans le schéma suivant. Nous connectons la broche Trig à GPIO 5 et la broche Echo pour GPIO 18, mais vous pouvez utiliser n’importe quelle autre broche appropriée.

Schéma du capteur à ultrasons du circuit de câblage ESP32
Capteur à ultrasons ESP32
VCC NIV
Trigonométrie GPIO 5
Écho GPIO 18
GND GND

Préparation de l’IDE Arduino

Nous allons programmer la carte ESP32 en utilisant Arduino IDE. Assurez-vous donc que le module complémentaire ESP32 est installé. Suivez le tutoriel suivant :

Si vous souhaitez utiliser VS Code avec l’extension PlatformIO, suivez plutôt le tutoriel suivant pour apprendre à programmer l’ESP32 :

Code – Obtenir la distance d’un objet à l’aide du capteur à ultrasons HC-SR04 et de l’ESP32

Le croquis suivant est un exemple simple de la façon dont vous pouvez obtenir la distance entre le capteur et un objet à l’aide de la carte ESP32 avec le noyau Arduino.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp32-hc-sr04-ultrasonic-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

const int trigPin = 5;
const int echoPin = 18;

//define sound speed in cm/uS
#define SOUND_SPEED 0.034
#define CM_TO_INCH 0.393701

long duration;
float distanceCm;
float distanceInch;

void setup() {
  Serial.begin(115200); // Starts the serial communication
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
}

void loop() {
  // Clears the trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin on HIGH state for 10 micro seconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  
  // Calculate the distance
  distanceCm = duration * SOUND_SPEED/2;
  
  // Convert to inches
  distanceInch = distanceCm * CM_TO_INCH;
  
  // Prints the distance in the Serial Monitor
  Serial.print("Distance (cm): ");
  Serial.println(distanceCm);
  Serial.print("Distance (inch): ");
  Serial.println(distanceInch);
  
  delay(1000);
}

Afficher le code brut

Téléchargez le code sur votre tableau et cela fonctionnera immédiatement. Continuez à lire si vous voulez apprendre comment fonctionne le code ou passez à la section de démonstration.

Comment fonctionne le code

Tout d’abord, définissez le déclencheur et les broches d’écho.

const int trigPin = 5;
const int echoPin = 18;

Dans cet exemple, nous utilisons GPIO 5 et GPIO 18. Mais vous pouvez utiliser n’importe quel autre GPIO approprié – lisez la référence de brochage ESP32 : quelles broches GPIO devriez-vous utiliser ?

le SOUND_SPEED variable enregistre la vitesse du son dans l’air à 20ºC. Nous utilisons la valeur en cm/uS.

#define SOUND_SPEED 0.034

le CM_TO_INCH La variable nous permet de convertir la distance en centimètres en pouces.

#define CM_TO_INCH 0.393701

Ensuite, initialisez les variables suivantes.

long duration;
float distanceCm;
float distanceInch;

le durée variable enregistre le temps de parcours des ondes ultrasonores (temps écoulé depuis l’émission et la réception de l’onde de pouls). le distanceCm et distancePouce, comme son nom l’indique, enregistre la distance à un objet en centimètres et en pouces.

mettre en place()

Dans le mettre en place(), initialisez une communication série à un débit de 115 200 bauds afin que nous puissions imprimer les mesures sur le moniteur série.

Serial.begin(115200); // Starts the serial communication

Définir la goupille de déclenchement comme un SORTIR— la goupille de déclenchement émet les ultrasons. Et définissez la broche d’écho comme un SAISIR– la broche d’écho reçoit l’onde réfléchie et envoie un signal à l’ESP32 qui est proportionnel au temps de trajet.

pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input

boucler()

Dans le boucler(), les lignes suivantes produisent un 10uS HAUT impulsion sur la goupille de déclenchement – cela signifie que la goupille émettra des ultrasons. Notez qu’avant d’envoyer le pouls, nous donnons un bref MEUGLER pulser pour vous assurer d’obtenir un nettoyage HAUT impulsion.

// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

Nous utilisons le pulseIn() fonction pour obtenir le temps de trajet de l’onde sonore :

duration = pulseIn(echoPin, HIGH);

le pulseIn() La fonction lit une impulsion HAUT ou BAS sur une broche. Il accepte comme arguments la broche et l’état de l’impulsion (soit HAUT, soit BAS). Il renvoie la durée de l’impulsion en microsecondes. La durée d’impulsion correspond au temps qu’il a fallu pour se rendre à l’objet plus le temps qu’il a fallu pour revenir.

Ensuite, on calcule simplement la distance à un objet en tenant compte de la vitesse du son.

distanceCm = duration * SOUND_SPEED/2;

Convertissez la distance en pouces :

distanceInch = distanceCm * CM_TO_INCH;

Et enfin, imprimez les résultats sur le moniteur série.

Serial.print("Distance (cm): ");
Serial.println(distanceCm);
Serial.print("Distance (inch): ");
Serial.println(distanceInch);

Manifestation

Téléchargez le code sur votre tableau. N’oubliez pas de sélectionner le tableau que vous utilisez dans Outils > Planches. N’oubliez pas non plus de sélectionner le bon port COM dans Outils > Port.

Carte ESP32 HC-SR04 Module de capteur à ultrasons Démonstration Arduino

Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200. Appuyez sur le bouton RST intégré pour redémarrer la carte et elle commencera à imprimer la distance jusqu’à l’objet le plus proche sur le moniteur série. Quelque chose comme le montre l’image ci-dessous.

Capteur à ultrasons ESP32 ESP8266 Obtenir la distance à un objet Arduino

ESP32 avec HC-SR04 et écran OLED

Carte ESP32 Module de capteur à ultrasons HC-SR04 Pièces Arduino OLED requises

Dans cette section, nous allons vous montrer un exemple simple avec l’ESP32 qui affiche la distance sur un écran OLED I2C.

Pour mieux comprendre le fonctionnement du projet, nous vous recommandons de jeter un œil à notre tutoriel ESP32 avec l’écran I2C OLED.

Pièces requises

Voici une liste des pièces requises pour compléter cet exemple :

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1641836899 909 ESP32 avec capteur a ultrasons HC SR04 avec Arduino IDE

Schéma de principe – ESP32 avec HC-SR04 et écran OLED

Câblez toutes les pièces comme indiqué dans le schéma suivant.

ESP32 avec HC-SR04 et schéma de câblage d'affichage OLED

En savoir plus sur l’écran OLED avec l’ESP32 : Écran OLED ESP32 avec Arduino IDE

Code – Distance d’affichage ESP32 (HC-SR04) sur l’écran OLED

Pour utiliser cet exemple, assurez-vous que les bibliothèques Adafruit SSD1306 et Adafruit GFX sont installées. Vous pouvez installer ces bibliothèques via le gestionnaire de bibliothèques Arduino.

Aller à Esquisser > Bibliothèque > Gérer les bibliothèques, Rechercher « SSD1306,” et installez la bibliothèque SSD1306 d’Adafruit.

Installer la bibliothèque I2C OLED Display SSD1306 Arduino IDE

Après avoir installé la bibliothèque SSD1306 d’Adafruit, tapez « GFX » dans la zone de recherche et installez la bibliothèque.

Installation de la bibliothèque GFX ESP8266 ESP32 Arduino

Après avoir installé les bibliothèques, redémarrez votre IDE Arduino.

Ensuite, copiez simplement le code suivant sur votre IDE Arduino et téléchargez le code sur la carte.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp32-hc-sr04-ultrasonic-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

const int trigPin = 5;
const int echoPin = 18;

//define sound speed in cm/uS
#define SOUND_SPEED 0.034
#define CM_TO_INCH 0.393701

long duration;
int distanceCm;
int distanceInch;

void setup() {
  Serial.begin(115200);
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(500);
  display.clearDisplay();

  display.setTextSize(2);
  display.setTextColor(WHITE);
}

void loop() {
  // Clears the trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin on HIGH state for 10 micro seconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  
  // Calculate the distance
  distanceCm = duration * SOUND_SPEED/2;
  
  // Convert to inches
  distanceInch = distanceCm * CM_TO_INCH;
  
  // Prints the distance in the Serial Monitor
  Serial.print("Distance (cm): ");
  Serial.println(distanceCm);
  Serial.print("Distance (inch): ");
  Serial.println(distanceInch);

  display.clearDisplay();
  display.setCursor(0, 25);
  //Display distance in cm
  display.print(distanceCm);
  display.print(" cm");
  
  // Display distance in inches
  /* display.print(distanceInch);
  display.print(" in");*/
  display.display(); 

  delay(500);  
}

Afficher le code brut

Comment fonctionne le code

Commencez par inclure les bibliothèques requises pour l’écran OLED :

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Définissez la largeur et la hauteur de l’écran OLED. Nous utilisons un écran OLED 128 × 64 :

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Créé un Adafruit_SSD1306 objet appelé affichage pour gérer l’écran OLED.

Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire);

Définissez les broches auxquelles le capteur HC-SR04 est connecté.

const int trigPin = 5;
const int echoPin = 18;

Créez des variables pour enregistrer la distance et la durée entre la transmission et la réception des ondes sonores.

long duration;
int distanceCm;
int distanceInch;

mettre en place()

Dans le mettre en place(), initialisez une communication série à un débit en bauds de 115 200 afin que nous puissions imprimer les résultats sur le moniteur série.

Serial.begin(115200);

Définir la goupille de déclenchement comme un SORTIR et la broche d’écho comme un SAISIR.

pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input

Initialisez l’écran OLED :

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}

Définissez la taille de la police et la couleur de l’affichage.

display.setTextSize(2);
display.setTextColor(WHITE);

boucler()

Dans le boucler() C’est là que nous obtiendrons la distance et l’afficherons sur l’OLED.

Obtenez la distance (nous avons déjà expliqué dans la section précédente comment calculer la distance).

// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
  
// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);
  
// Calculate the distance
distanceCm = duration * SOUND_SPEED/2;
  
// Convert to inches
distanceInch = distanceCm * CM_TO_INCH;

Imprimez la distance sur le moniteur série.

// Prints the distance on the Serial Monitor
Serial.print("Distance (cm): ");
Serial.println(distanceCm);
Serial.print("Distance (inch): ");
Serial.println(distanceInch);

Effacer l’affichage dans chaque boucler() pour écrire de nouvelles lectures.

display.clearDisplay();

Réglez le curseur d’affichage sur (0, 25).

display.setCursor(0, 25);

Les lignes suivantes impriment la distance en centimètres sur l’écran OLED.

// Display static text
display.print(distanceCm);
display.print(" cm");

Commentez les lignes précédentes et décommentez les lignes suivantes si vous souhaitez afficher les lectures en pouces.

/* Display distance in inches
display.print(distanceInch);
display.print(" in");*/

Enfin, appelez display.display() pour afficher réellement les lectures sur l’OLED.

display.display();

La distance est mise à jour toutes les 500 millisecondes.

delay(500);

Manifestation

Téléchargez le code sur votre carte ESP32. Aller à Outils > Conseil et sélectionnez la carte ESP32 que vous utilisez. Aller à Outils > Port et sélectionnez le port auquel votre carte est connectée. Ensuite, cliquez sur le bouton de téléchargement.

Ouvrez le moniteur série à un débit en bauds de 115 200, appuyez sur le bouton RST intégré. Les mesures du capteur seront affichées à la fois sur le moniteur série et sur l’écran OLED.

Rapprochez un objet du capteur et voyez les valeurs changer.

Carte ESP32 HC-SR04 Module de capteur à ultrasons Démonstration Arduino OLED

Vous pouvez regarder une démonstration vidéo rapide :

Emballer

Le capteur à ultrasons HC-SR04 nous permet de déterminer la distance à un objet. Dans ce tutoriel, vous avez appris à utiliser le HC-SR04 avec l’ESP32. Nous avons des tutoriels pour d’autres capteurs populaires que vous pourriez aimer :

En savoir plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

  • ARCELI Capteur de transducteur de Mesure de Distance de Module ultrasonique de Distance de 5PCS HC-SR04 pour Arduino
    Utilisez le port IO TRIG pour déclencher la télémétrie. Il nous faut au moins 10 signaux haut niveau. Le module peut envoyer automatiquement 8 ondes carrées pro 40 kz et vérifiera si un signal est renvoyé. Si un signal est renvoyé, émettez un signal de niveau haut via le port IO ECHO. La durée du signal de niveau haut est le temps écoulé entre l'émetteur et la réception avec les ultrasons. Distance d'essai = durée du niveau haut * vitesse du son (340 m / s) / 2 Courant statique (max): 2mA; niveau de sortie électrique: 5V haut; Distance de détection: 2cm-450cm; Haute précision: 2mm
  • AZDelivery 3 x Capteur à Ultrasons Module Compatible avec HC-SR04 Télémètre Compatible avec Arduino et Raspberry Pi y Compris Un eBook
    ✅ Mesure de distance par ultrasons de 2 cm à 3 m jusqu'à une précision d'environ 3 mm. ✅ Dimensions: 45 x 20 x 19 mm (largeur avec broches env. 26 mm). ✅ Jusqu'à 50 mesures par seconde. ✅ Faible consommation d'énergie (env. 2 mA par mesure, max. 100 mA par seconde). ✅ Ce produit inclut un E-Book qui fournit des informations utiles sur la façon de commencer votre projet. Il permet une installation rapide et fait gagner du temps sur le processus de configuration. On y trouve une série d'exemples d'applications, des guides d'installation complets et des bibliothèques.
  • ELEGOO 5 pièces HC-SR04 Module Ultrason de Capteur de Distance pour Mega Nano Robet XBee Zigbee Ultrasonic Module Distance Sensor
    Capteur Ultrason de Mesure de Distance HC-SR04 (Ultrasonic Module Distance Sensor) Le HC-SR04 comprend un émetteur ultrason, un récepteur et un circuit de contrôle. Quand il est activé, il émet des séries d'impulsion ultrasonique à 40 kHz et reçoit l'écho d’un objet. La distance entre le capteur et l’objet est calculée en mesurant le temps de trajet des ondes sonores ( au moyen d’une base temps TTL ) entre l'émission et la réception de l'écho Alimentation: 5Volt continu; Courant de repos: moins de 5mA; Angle effectif: moins de 15° Distance mesurée:de 2 cm à 300 cm; Résolution:0,3 cm Contenu du Paquet: 5 x Module HC-SR04 avec un petit cadeau