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.

À 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

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

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.

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

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;
distance entière ;

void setup() {
  // Définissez les entrées et les sorties :
  pinMode(trigPin, SORTIE);
  pinMode(echoPin, INPUT);

  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
}

boucle vide() {
  // Effacez le trigPin en le définissant sur LOW :
  digitalWrite(trigPin, LOW);
  retardMicrosecondes(5);

  // Déclenchez le capteur en réglant le trigPin haut pendant 10 microsecondes :
  digitalWrite(trigPin, HIGH);
  retardMicrosecondes(10);
  digitalWrite(trigPin, LOW);

  // Lit l'echoPin, pulseIn() renvoie la durée (longueur de l'impulsion) en microsecondes :
  durée = pulseIn(echoPin, HIGH);
  // Calcule la distance :
  distance = durée * 0,034 / 2 ;

  // Affiche la distance sur le Serial Monitor (Ctrl+Shift+M) :
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.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. Ainsi, partout où vous 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;
distance entière ;

Dans le  setup(), vous commencez par définir le trigPin comme sortie et l’echoPin comme entrée. Ensuite, vous initialisez la communication série à un débit en bauds 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 défini sur 9600 dans le moniteur série.

void setup() {
  // Définissez les entrées et les sorties :
  pinMode(trigPin, SORTIE);
  pinMode(echoPin, INPUT);

  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(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 vide() {
  // Effacez le trigPin en le définissant sur LOW :
  digitalWrite(trigPin, LOW);
  retardMicrosecondes(5);

  // Déclenchez le capteur en réglant le trigPin haut pendant 10 microsecondes :
  digitalWrite(trigPin, HIGH);
  retardMicrosecondes(10);
  digitalWrite(trigPin, LOW);

Ensuite, vous devez lire la longueur de l’impulsion envoyée par l’echoPin. J’utilise la fonction  pulseIn() pour cela. Cette fonction attend que la broche passe de BAS à HAUT, démarre la synchronisation, puis attend que la broche passe à BAS et arrête la synchronisation.

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

// Lit l'echoPin, pulseIn() renvoie la durée (longueur de l'impulsion) en microsecondes :
durée = pulseIn(echoPin, HIGH);
// Calcule la distance :
distance = durée * 0,034 / 2 ;

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

// Affiche la distance sur le Serial Monitor (Ctrl+Shift+M) :
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");

retard(50);
}

Exemple de code HC-SR04 avec la bibliothèque Arduino et 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 à lire, il ne sera pas retardé d’une seconde complète lorsqu’aucun écho n’est reçu et il dispose d’un filtre médian intégré.

Vous pouvez installer la bibliothèque en accédant à  Sketch> Inclure la bibliothèque> Ajouter la 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 un exemple de code modifié ci-dessous qui peut être utilisé avec la même configuration de câblage qu’avant.

/* Capteur de distance à ultrasons HC-SR04 avec code d'exemple de bibliothèque NewPing. Plus d'infos : www.www.makerguides.com */

// Inclure la bibliothèque :
#include <NouveauPing.h>

// Définir les broches et la distance max :
#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 évaluée à 400-500 cm.

sondeur NewPing(trigPin, echoPin, MAX_DISTANCE); // Configuration NewPing des broches et de la distance maximale.
durée de flottaison, distance ;

void setup() {
  Série.begin(9600); // Ouvrez le moniteur série à 9600 bauds pour voir les résultats du ping.
}

boucle vide() {
  retard(50); // Attendez 50 ms entre les pings (environ 20 pings/sec). 29 ms devrait être le délai le plus court entre les pings.
  
  durée = sonar.ping();
  distance = (durée / 2) * 0,0343 ;
  
  Serial.print("Distance = ");
  Serial.print(distance); // La distance sera de 0 lorsqu'elle est hors de la plage maximale définie.
  Serial.println(" cm");
}

Vous pouvez également utiliser  distance = sonar.ping_cm() ou  distance = sonar.ping_in() qui renvoie la distance mesurée en centimètres entiers ou en pouces. 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 n’utilisant qu’une seule 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 l’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 dans la bibliothèque NewPing, c’est qu’elle a 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 à la suite, rejette les lectures hors plage, puis fait 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.

int itérations = 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  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 que précédemment.

Connexions LCD I2C

Si vous n’utilisez pas d’Arduino Uno, les broches SDA et SCL peuvent se trouver à un emplacement différent. Un Arduino UNO avec la disposition R3 (brochage 1.0), a également les en-têtes de broche 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.

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

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

• Comment contrôler un LCD I2C de caractères avec Arduino

/*
Capteur de distance à ultrasons HC-SR04 avec exemple de code Arduino et I2C LCD.
Plus d'infos : https://www.makerguides.com
*/

// Inclure les bibliothèques :
#include <Fil.h>
#include <LiquidCrystal_I2C.h>

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

// Définir les broches SDA et SCL pour LCD :
#define SDAPin A4 // Broche de données
#define SCLPin A5 // Broche d'horloge

// Connexion à LCD via I2C, adresse par défaut 0x27 (A0-A2 non ponté) :
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Changer en (0x27,16,2) pour 1602 LCD

// Définir les variables :
longue durée;
distance entière ;

void setup() {
  // Définissez les entrées et les sorties :
  pinMode(trigPin, SORTIE);
  pinMode(echoPin, INPUT);

  // Lancer le LCD :
  lcd.init();
  LCD rétro-éclairage();
}

boucle vide() {
  // Effacez le trigPin en le définissant sur LOW :
  digitalWrite(trigPin, LOW);
  retardMicrosecondes(5);

  // Déclenchez le capteur en réglant le trigPin haut pendant 10 microsecondes :
  digitalWrite(trigPin, HIGH);
  retardMicrosecondes(10);
  digitalWrite(trigPin, LOW);

  // Lit l'echoPin. Cela renvoie la durée (longueur de l'impulsion) en microsecondes :
  durée = pulseIn(echoPin, HIGH);

  // Calcule la distance :
  distance = durée*0,034/2 ;

  // Affiche la distance sur le 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.print(distance); // Imprime la distance mesurée
  lcd.print(" 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 LCD n’a pas l’adresse I2C par défaut, 0x27, consultez le tutoriel 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 configuration. 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 très simple. Le schéma de câblage ci-dessous vous indique les connexions que vous devez effectuer. Notez que j’utilise un  DHT11 avec une carte de dérivation , donc je n’ai besoin que de câbler 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 que précédemment.

Connexions DHT11

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 installé la  bibliothèque Adafruit_Sensor  , qui est également  disponible sur GitHub . Vous pouvez également télécharger les deux librairies en cliquant sur les boutons ci-dessous :

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
*/

// Inclure la bibliothèque de capteurs Adafruit :
#include <Adafruit_Sensor.h> //https://github.com/adafruit/Adafruit_Sensor
// Inclure la bibliothèque Adafruit DHT :
#include <DHT.h> //https://github.com/adafruit/DHT-sensor-library

// Définir la broche Trig, la broche Echo et la 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;
distance entière ;
flotteur vitesse du son ;

// Créer un objet capteur DHT :
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Définissez les entrées et les sorties :
  pinMode(trigPin, SORTIE);
  pinMode(echoPin, INPUT);

  dht.begin();

  // Commencer la communication série :
  Série.begin(9600); // Démarre la communication série
}

boucle vide() {
  // Effacez le trigPin en le définissant sur LOW :
  digitalWrite(trigPin, LOW);
  retardMicrosecondes(5);

  // Déclenchez le capteur en réglant le trigPin haut pendant 10 microsecondes :
  digitalWrite(trigPin, HIGH);
  retardMicrosecondes(10);
  digitalWrite(trigPin, LOW);

  // Lit l'echoPin. Cela renvoie la durée (longueur de l'impulsion) en microsecondes :
  durée = pulseIn(echoPin, HIGH);

  // Lire la température :
  température flottante = dht.readTemperature();

  // Calcule la vitesse du son en m/s :
  vitesse du son = 331,3+(0,606*température);

  // Calcule la distance en cm :
  distance = durée*(vitesse du son/10000)/2 ;

  // Imprime la distance et la température sur le Serial Monitor :
  Serial.print("Température = ");
  Serial.print(température);
  Serial.print(" Celsius");
  Serial.print(", Distance = ");
  Serial.print(distance);
  Serial.println("cm");
  retard(100);
}

Exemple de code HC-SR04 avec DHT11 et I2C LCD

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 DHT11, I2C LCD et exemple de code Arduino.
Plus d'infos : https://www.makerguides.com
*/

// Inclure la bibliothèque de capteurs Adafruit :
#include <Adafruit_Sensor.h> // https://github.com/adafruit/Adafruit_Sensor
// Inclure 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 la DHTPin :
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Définissez les broches SDA et SCL à partir du LCD :
#define SDAPin A4 // Broche de données
#define SCLPin A5 // Broche d'horloge

// Connexion à LCD via i2c, adresse par défaut 0x27 (A0-A2 non ponté) :
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;
distance entière ;
flotteur vitesse du son ;

// Créer un objet capteur DHT :
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Définissez les entrées et les sorties :
  pinMode(trigPin, SORTIE);
  pinMode(echoPin, INPUT);

  dht.begin();

  // Lancer le LCD :
  lcd.init();
  LCD rétro-éclairage();

  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
}

boucle vide() {
  // Effacez le trigPin en le définissant sur LOW :
  digitalWrite(trigPin, LOW);
  retardMicrosecondes(5);

  // Déclenchez le capteur en réglant le trigPin haut pendant 10 microsecondes :
  digitalWrite(trigPin, HIGH);
  retardMicrosecondes(10);
  digitalWrite(trigPin, LOW);

  // Lit l'echoPin. Cela renvoie la durée (longueur de l'impulsion) en microsecondes :
  durée = pulseIn(echoPin, HIGH);

  // Lire la température :
  int temperature = dht.readTemperature();

  // Calcule la vitesse du son en m/s :
  vitesse du son = 331,3+(0,606*température);

  // Calcule la distance en cm :
  distance = durée*(vitesse du son/10000)/2 ;

  // Imprime la distance et la température sur le Serial Monitor :
  lcd.setCursor(0,0);
  lcd.print("Température : ");
  lcd.print(température);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Vitesse : ");
  lcd.print(vitesseduson);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distance : ");
  lcd.print(distance);
  lcd.print(" cm ");
  retard(100);
}

Dimensions HC-SR04

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

CAO HC-SR04

J’ai créé des dessins CAO de base du capteur à ultrasons HC-SR04 que vous pouvez télécharger ci-dessous.

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 informatif. Si vous l’avez fait,  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.

J’aimerais savoir quels projets vous envisagez de construire (ou avez déjà construit) avec le capteur de distance HC-SR04. Si vous avez des questions, des suggestions ou si vous pensez qu’il manque des choses dans ce tutoriel,  veuillez laisser un commentaire ci-dessous.

Notez que les commentaires sont conservés pour modération afin d’éviter les spams.