Que vous souhaitiez réaliser un robot autonome, un portail automatique, un appareil de mesure, ou je ne sais quoi d’autre, quoi de plus simple et facile à utiliser qu’un capteur à ultrasons type HC-SR04 ? Surtout que ce type d’émetteur/récepteur ultrasonique est vraiment pas cher, et est très facilement pilotable via Arduino, ESP32, ou tout autre microcontrôleur de votre choix ! C’est pourquoi je vous propose de le découvrir aujourd’hui, dans sa version HC-SR04P, compatible 3,3V et 5V.
Dans ce tuto, nous verrons le principe de fonctionnement de la mesure par ultrasons, puis verrons en détail les caractéristiques du capteur HC-SR04 P (puce RCWL-9610), son raccordement à une carte Arduino ou un ESP32, et comment faire des mesures de distances avec (et ce, avec et sans librairie arduino). Ça vous dit ? Alors en avant !
Remarque : surtout ne pensez pas qu’une technologie donnée (ultrason, infrarouge, lidar, etc) est fondamentalement meilleure qu’une autre. En effet, chaque technologie a ses atouts, et ses faiblesses. Par exemple, concernant les capteurs à ultrasons, ils ont l’avantage d’être pas chers, faciles d’utilisation, et pouvant fonctionner aussi bien de jour comme de nuit ; par contre, ils ont l’inconvénient de pouvoir facilement être perturbés face aux surfaces « molles » ou absorbantes (l’écho est altéré/diminué/retardé), ou face aux plans inclinés (là, l’écho peut être totalement dévié, trompant ainsi le détecteur). En clair : il n’y a pas de capteurs meilleurs que d’autres dans l’absolu, mais seulement des capteurs mieux adaptés que d’autres suivant la situation, et vos besoins 😉
| Module | Description | Lien |
|---|---|---|
 | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Voir le prixComment fonctionne la mesure par ultrasons ?
Basiquement, la mesure par ultrasons fonctionne grâce au principe de l’écho sonore (le retour d’un son vers soi, après avoir rebondi sur un objet/obstacle). Il faut donc émettre des ultrasons, et en fonction du temps qu’aura mis le son à revenir, on pourra estimer la distance séparant le module ultrasonique d’un objet donné (du fait que nous connaissons la vitesse du son, environ égale à 343 m/s).
C’est d’ailleurs exactement ce que fait le module ultrasonique HC-SR04 que je vous présente ici. En effet, il :
- émet une salve d’ultrasons, et passe une ligne spécifique à l’état HAUT
- puis dès qu’un retour est reçu, repasse cette ligne l’état BAS
Et l’écart de temps (en secondes) entre le passage de l’état haut à l’état bas sur cette ligne permet de déterminer la distance (en mètres), du fait qu’on connait la vitesse du son (en mètres par seconde). Tout simplement 😉
Visuellement parlant, voici une illustration permettant de voir un exemple d’aller-retour d’ultrasons, entre un capteur ultrasonore HCSR04 et un mur :
Sur cette image, vous voyez un module HC-SR04 (en bleu, à gauche) avec ses 2 transducteurs (les « petits cylindres gris », qui sont en fait des émetteurs/récepteurs ultrasonores). Dans le cas du HC SR04, c’est le transducteur « du haut » qui envoie des impulsions ultrasonores (dessinées en vert). Ces ultrasons, lorsqu’ils rencontrent une surface réfléchissante, sont renvoyés suivant leur incidence. En résulte un retour des ondes ultrasonores (ici dessinées en orange), aussi appelé écho, qui sera capté par le transducteur « du bas » du module HC-SR04.
Remarque : au niveau du transducteur d’émission du HC-SR04, l’émission d’ultrasons se disperse sous forme de cône (d’environ 15° d’angle d’ouverture effective). Donc tous les ultrasons émis ne filent pas « tout droit », mais sont plus ou moins dispersés à l’intérieur de ce « cône d’émission ». Ensuite, chaque onde ultrasonique rencontrant un obstacle est réfléchie selon son incidence, ce qui fait que les échos partent dans plusieurs directions différentes. Du reste, pour que le dessin reste simple et lisible, je ne vous ai tracé que les ultrasons qui reviennent pile-poil vers le récepteur ultrasonique (c’est pourquoi les ultrasons émis « en vert » partent légèrement vers le bas ici, mais il faut bien comprendre qu’il y en a un peu dans « tous les sens », suivant le cône d’émission évoqué précédemment).
Vous noterez que le module HC SR04 que je vous ai présenté ici (à gauche, sur l’image ci-dessus) dispose de 4 broches électriques :
- VCC et GND, pour l’alim
- TRIG, qui est une ligne d’entrée nous permettant de demander au module d’émettre des salves d’ultrasons (8 ultrasons émis à chaque fois, à 40 kHz de fréquence)
- ECHO, qui est une ligne de sortie fournissant une impulsion électrique, dont la durée est proportionnelle à la distance mesurée
Ce sont donc via ces broches, TRIG et ECHO, que nous allons pouvoir faire de la mesure par ultrasons. Et en mesurant la durée d’impulsion sur la ligne ECHO, on pourra en déduire une distance.
Visuellement parlant, sur le plan temporel, voici comment se déroulent les choses avec un capteur HC SR04 :
Sur la ligne « ECHO », on voit clairement l’impulsion électrique proportionnelle à la distance (aller-retour) des ultrasons. Et pour calculer une distance à partir de là, il suffira de multiplier cette durée d’impulsion par la vitesse du son (environ 343 m/s), et diviser le résultat par 2 (car le son fait un aller+retour avant d’être capté, et nous on cherche uniquement à mesurer une distance, soit un « aller simple » ou un « retour seulement »).
En résumé, on peut donc dire que :
Par exemple, en pratique :
- si l’impulsion sur la ligne écho dure 0,010 s
- et que la vitesse du son est égale à 343 m/s
- alors la distance aller+retour est égale à 0,010 * 343, soit 3,43 m
- du coup, la distance « aller simple » est égale à 3,43/2, soit 1,715 m
Voilà, de manière simplifiée, comment fonctionne la mesure par ultrasons !
Nota 1 : si aucun écho n’a été reçu par le module HC-SR04 au bout d’un certain temps (généralement 38 ms, ce qui correspond à une distance théorique d’environ 6,5 mètres), alors la ligne ECHO est automatiquement remise à l’état bas.
Nota 2 : ici, je vous ai présenté les choses de manière très simplifiée, afin que vous puissiez en comprendre les grands principes. Mais en réalité, la diffusion et la réflexion d’ondes ultrasonores est bien plus complexe que cela. Car, par exemple, un retour son (écho) peut potentiellement être altéré/atténué suivant la surface rencontrée, voire même complètement dévié, face à une surface inclinée / en biais (où là, le capteur à ultrason pourrait très bien vous dire qu’aucun obstacle ne figure devant lui… alors qu’il y en a bien un !). C’est là où il peut être intéressant de compléter les capteurs à ultrasons par d’autres types de capteurs (d’autre technologie j’entends, comme l’infrarouge), histoire de pallier aux faiblesses de l’un avec l’autre 🙂
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Caractéristiques du capteur à ultrasons HC-SR04P (version RCWL-9610, compatible 3,3/5V)
Pour info, le HC-SR04P que je vous présente ici est tout simplement une évolution du célèbre capteur à ultrasons « HC-SR04 » (sans le « P » à la fin), très connu pour faire des mesures de distances avec arduino. Ce capteur HC SR04P, basé sur le contrôleur RCWL-9610, apporte plusieurs améliorations significatives, à savoir :
- une compatibilité 3,3V (en plus des 5V)
- une interface UART ou I²C (en plus du mode TRIG/ECHO), activable au besoin
- une conso plus faible au repos (très appréciable, lorsqu’on fonctionne sur batterie !)
Et ce, tout en gardant une totale rétrocompatibilité avec l’ancien modèle HC-SR04 (même principe de mesure par ultrasons, même brochage/pinout, même taille de PCB, et mêmes diamètres/emplacements de trous de fixation).
Bien entendu, le fait que le HC-SR04P puisse être alimenté en 5V ET en 3,3V est sans conteste son véritable atout. Car ainsi, il devient compatible avec toutes les cartes et microcontrôleurs 3,3 volts (comme les ESP32, STM32, Raspberry Pi Pico, etc), là où le HC SR04 « basique » était uniquement compatible avec les cartes Arduino et µC fonctionnant en 5 volts.
Du reste, voici un aperçu des principales caractéristiques de ce module HC SR04P :
Au niveau des différences entre le HC-SR04P et le HC-SR04, on a, du point de vue de la « version P » :
- une plage de tension d’alimentation étendue, allant de 2,8 à 5,5V (idéale donc pour les microcontrôleurs 3,3 et 5V)
- une consommation vraiment faible au repos (2 à 3 mA seulement, et ce, grâce à la puce RCWL-9610A)
- une portée (distance mesurable) pouvant aller de 2 cm à 4 m (plus précisément : 4m sous 3,3V et 4,5m sous 5V)
Parallèlement, on conserve tous les atouts du « HC-SR04 de base », à savoir :
- des ultrasons émis à 40 kHz, par salves de 8 à la suite
- une précision de mesure de ± 3 mm
- un angle de détection effectif de 15° (remarque : la diffusion d’ultrasons atteint généralement 30°, mais seules les ondes émises dans le « couloir des 15° » sont vraiment « efficaces », si je puis dire)
- les broches TRIG et ECHO pour un pilotage « à la main », comme historiquement 😉
Nota : la sélection du mode de communication (I2C, UART, ou GPIO TRIG/ECHO) se fait via 2 jumpers/pads à souder sur le PCB, comme nous le verrons à la fin de cet article.
Ah oui… avant de passer à la suite, voici le pinout (brochage) du HC-SR04P :
Comme vous pouvez le constater, le module HC-SR04P dispose d’un connecteur à 4 broches, dont :
- une broche VCC (pour y brancher l’alimentation, entre 2,8V et 5,5V, en courant continu)
- une broche TRIG / RX / SCL / IO, qui montre au passage les 4 modes de communication possibles du HC SR04P, à savoir :
- TRIG = mode « normal » (fonctionnement classique, comme le HC SR04 de base)
- RX = mode UART
- SCL = mode I²C
- IO = mode OneWire (demande d’émission d’ultrasons et réception écho sur la même ligne)
- une broche ECHO / TX / SDA
- une broche GND (la masse, donc !)
Pour la suite de cet article, on va rester en « mode normal », pour que cet article soit valable aussi bien pour le HC-SR04P que le HC-SR04 historique. C’est pourquoi vous verrez uniquement des branchements notés VCC, TRIG, ECHO, et GND. Du reste, je vous dirai quelques mots sur les modes UART et I2C en fin d’article, histoire de vous dire ce qu’ils apportent, et là où le bât blesse (eh oui… rien n’est parfait !).
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Comment raccorder un HC-SR04P à un Arduino Uno ?
Câbler un module HC-SR04P sur un Arduino Uno est on ne peut plus simple ! Car seulement 4 fils suffisent pour ce faire, à savoir :
- 2 fils pour l’alimentation (VCC et GND), avec VCC = +5V ici
- 2 fils pour la communication (TRIG et ECHO)
Schématiquement parlant, voici d’ailleurs un exemple de câblage d’HC-SR04 P sur Arduino Uno :
Deux remarques, liées à ce câblage :
- les lignes TRIG et ECHO ont respectivement été branchées sur D3 et D2, mais on aurait très bien pu utiliser d’autres broches arduino (les signaux véhiculant sur TRIG/ECHO étant basiquement de type tout-ou-rien)
- il n’y a pas besoin de résistance pull-up (ou pull-down) sur la ligne ECHO, du fait que les signaux émanant du HC-SR04 sont des niveaux forts (0 ou +VCC)
Difficile de faire plus simple, avouez ! Du reste, voici à quoi ressemble le raccordement sur breadboard, de mon côté (c’est le montage avec lequel j’ai fait mes essais programmes, que je vous ai partagé un peu plus loin) :
Voilà pour la partie Arduino ! À présent, si vous souhaitez faire la même chose sur un ESP32, c’est dans le paragraphe suivant ; sinon, vous pouvez sauter directement aux exemples de code qui suivent 😉
Comment câbler un HC-SR04 P sur un ESP32 ?
Raccorder un module HC-SR04 à un ESP32 est plus ou moins simple, selon le modèle que vous utilisez. En effet :
- si vous utilisez un HC-SR04P (version « P » donc), comme moi ici, alors le branchement est aussi simple qu’avec un Arduino Uno
- si vous utilisez un HC-SR04 (ancien modèle, non « P »), alors il faudra :
- alimenter le module en +5V (quand bien même votre microcontrôleur ESP32 tourne en +3,3V)
- mettre en place un pont diviseur de tension sur la sortie ECHO du module, afin d’abaisser la tension de 5 volts à 3,3 volts, afin de ne pas griller l’entrée du µC de votre carte ESP32)
Pour que ce soit plus clair, voici une image vous présentant les 2 modèles d’HC SR04, et un exemple de branchement possible sur ESP32 (plus précisément ici, sur une carte ESP32-S3 DevKitC, que j’avais sous la main) :
Pour ma part, du fait que j’ai utilisé un HC-SR04P pour faire mes essais sur ESP32, le branchement est au final aussi simple qu’avec un Arduino Uno. La preuve en photo, avec mon montage réalisé sur breadboard (qui m’a servi à vérifier les programmes qui suivent) :
Voilà ! Je pense que nous avons fait le tour de la partie matérielle. À présent, passons à la partie logicielle, pour donner vie à cet émetteur récepteur à ultrasons !
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Exemple de code #1 : programme utilisant la fonction pulseIn
À présent, nous allons voir un exemple de code arduino HC-SR04, compatible Arduino et ESP32, utilisant la fonction pulseIn. Ce programme permettra d’afficher une distance détectée d’obstacle, en centimètres, toutes les secondes, sur le moniteur série de l’IDE Arduino. En clair, par exemple : si un obstacle est placé 5 cm devant le capteur à ultrasons HC-SR04, alors on s’attendra à voir affiché « Distance = 5 cm » dans le moniteur série !
Chose importante, sur laquelle j’insiste ici : nous n’allons pas utiliser la moindre librairie spécialisée, mais simplement la fonction « pulseIn », native sous Arduino IDE.
Nota : pour ceux qui ne le sauraient pas, la fonction arduino « pulseIn » permet de mesurer une durée d’impulsion, sur une broche numérique donnée. Cette impulsion peut être de type « état HAUT » (HIGH), comme ce sera le cas ici avec le HC SR04, ou « état bas » (LOW). Par exemple, si l’on souhaite mesurer une impulsion à l’état haut sur la pin D7, alors il suffira d’écrire dans le code « valeur = pulseIn(7, HIGH); » (la variable ‘valeur’ devant être de type ‘unsigned long’). Du reste, cette fonction pulseIn accepte un 3ème argument, optionnel, pour indiquer une valeur de « timeout » (temps d’attente maximal, en microsecondes) ; je ne l’ai pas intégré au code ici, car le HCSR04 a son propre timeout (38 ms, en général), mais si vous souhaitez mettre une valeur plus courte, libre à vous de le faire ici 😉
Alors, côté programme, voici le code arduino permettant de faire des mesures de distances avec un HC-SR04 et la fonction pulseIn :
// ===================================================================================================
// ______ _ _///_ _ _ _
// / _ \ (_) | ___| | | | (_)
// | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
// | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
// | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
// \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
// | |
// \_|
// ===================================================================================================
//
// Nom Projet : Tuto HC-SR04 P (capteur à ultrasons)
// Desc Projet : Programme de test capteur HC-SR04P utilisant les lignes ECHO et TRIG,
// en utilisant la fonction arduino "pulseIn"
//
// Fichier : prg1-HCSR04-P-TestEchoTrigAvecPulseIn.ino
// Créé le : 26.04.2026
// Auteur : Jérôme TOMSKI
// Site : https://passionelectronique.fr/
// GitHub : https://github.com/PassionElectronique/Programmes-tests-capteur-HC-SR04
// Licence : https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================
// Inclusion des librairies nécessaires
// Constantes
#define brochePourLigneECHO 2 // La broche D2 du microcontrôleur sera reliée à la ligne ECHO du HC-SR04P
#define brochePourLigneTRIG 3 // La broche D3 du microcontrôleur sera reliée à la ligne TRIG du HC-SR04P
// ========================
// Initialisation programme
// ========================
void setup() {
// Définition des entrées/sorties
pinMode(brochePourLigneECHO, INPUT); // Sortie ECHO du HC-SR04 --> vers entrée microcontrôleur (donc "input" côté µC)
pinMode(brochePourLigneTRIG, OUTPUT); // Entrée TRIG du HC-SR04 <-- reçoit sortie microcontrôleur (donc "output" côté µC)
// Mise à l'état bas de la ligne TRIG, pour que le HC-SR04 soit au repos
digitalWrite(brochePourLigneTRIG, LOW);
// Démarrage du moniteur série
Serial.begin(9600);
Serial.println(F("======================================================="));
Serial.println(F("Programme #1 : mesures de distances toutes les secondes"));
Serial.println(F(" avec le capteur HC-SR04, en utilisant la"));
Serial.println(F(" fonction arduino 'pulseIn' "));
Serial.println(F("======================================================="));
Serial.println();
// Petite pause de stabilisation avant de passer à la boucle loop (permet aussi d'ignorer certaines mesures "involontaires" du HC-SR04, au démarrage)
delay(500);
}
// =================
// Boucle principale
// =================
void loop() {
// Variables
long duree_en_microsecondes;
float distance_en_centimetres;
// Lance une mesure ultrason, récupère la durée écoulée (entre émission ultrason et réception écho),
// puis calcule la distance correspondante et affiche cette distance sur le moniteur série
duree_en_microsecondes = effectueUneMesureSurLeHCSR04();
distance_en_centimetres = convertitMicrosecondesEnCentimetres(duree_en_microsecondes);
afficheDistanceEnCmSurMoniteurSerie(distance_en_centimetres);
// Pause d'une seconde (1000 ms) entre chaque rebouclage (remarque : ne pas aller trop vite ici, en tout cas pas en dessous de 60ms, sinon on aurait possiblement des échos parasites)
delay(1000);
}
// =======================================
// Fonction : effectueUneMesureSurLeHCSR04
// =======================================
long effectueUneMesureSurLeHCSR04(void) {
// -------------------------------------------------------------
// Procédure à suivre avec le HC-SR04, pour effectuer une mesure
// -------------------------------------------------------------
// - mettre la ligne TRIG à l'état bas pendant 2 µs (inutile si elle l'était déjà avant, mais c'est une "bonne pratique", recommandée par les fabricants)
// - mettre la ligne TRIG à l'état haut pendant 10 µs (pas moins, même si on aurait pu mettre plus) ; nota : c'est ce "front montant" sur TRIG qui lance l'émission d'ultrasons sur le HC-SR04
// - mettre la ligne TRIG à l'état bas, pour préparer la lecture suivante, plus tard
// - mesure la durée d'impulsion sur la ligne ECHO, en microsecondes) ; nota : la ligne ECHO passe immédiatement à l'état HAUT "dès le 1er ultrason émis", et repassera à l'état BAS dès le 1er ultrason reçu
// Sécurité avant démarrage
digitalWrite(brochePourLigneTRIG, LOW);
delayMicroseconds(2);
// Impulsion de 10 µs à l'état haut sur TRIG, pour lancer une émission d'ultrason par le HC-SR04
digitalWrite(brochePourLigneTRIG, HIGH);
delayMicroseconds(10);
digitalWrite(brochePourLigneTRIG, LOW);
// Mesure de la durée d'impulsion à l'état HAUT sur ECHO, et retourne cette valeur (durée en microsecondes, pour rappel)
// Remarque : j'ai rajouté ici un timeout de 30000 µs (30 ms), afin qu'on arrête la mesure de durée sur la ligne ECHO, si jamais cette ligne ne revenait pas à l'état bas (absence d'écho ou dysfonctionnement HC-SR04, donc)
return pulseIn(brochePourLigneECHO, HIGH, 30000);
}
// ==============================================
// Fonction : convertitMicrosecondesEnCentimetres
// ==============================================
float convertitMicrosecondesEnCentimetres(long duree_en_microsecondes) {
// -----------------------
// Explications techniques
// -----------------------
// La vitesse du son est approximativement égale à 343 mètres par seconde (si on fait abstraction de l'incidence de la température et tout et tout !!!)
//
// Donc :
// - comme vitesse_son = 343 m/s
// - alors vitesse_son = 34300 cm/s
// - alors vitesse_son = 34.3 cm/ms
// - alors vitesse_son = 0.0343 cm/µs
//
// Toutes ces lignes sont donc équivalentes, mais avec la dernière, on peut calculer un nombre de centimètres (cm) à partir d'une durée en microsecondes (µs)
return duree_en_microsecondes * 0.0343 / 2; // Nota : on divise par 2 car là on a mesuré un temps aller/retour au niveau du HC-SR04 ;
// donc si on veut une distance, il faut qu'on prenne que l'aller ou le retour seul, donc la moitié de l'aller retour, en somme !
}
// ==============================================
// Fonction : afficheDistanceEnCmSurMoniteurSerie
// ==============================================
void afficheDistanceEnCmSurMoniteurSerie(float distance_en_centimetres) {
// Envoi des données sur le moniteur série
Serial.print(F("Distance = "));
Serial.print(distance_en_centimetres);
Serial.println(F(" cm"));
}Comme vous pouvez le constater, le programme est divisé en plusieurs blocs :
- la fonction « setup » qui initialise les entrées/sorties utilisées ici, et le retour série
- la fonction « loop » qui va demander des mesures en microsecondes (µs), puis les convertir en centimètres (cm), puis les afficher sur le moniteur série
- la fonction « effectueUneMesureSurLeHCSR04 » qui permet de faire une mesure avec un HCSR04, en utilisant la fameuse fonction « pulseIn »
- la fonction « convertitMicrosecondesEnCentimetres » qui permet de convertir des µs en cm, en utilisant la vitesse du son (environ 343 m/s)
- et la fonction « afficheDistanceEnCmSurMoniteurSerie » qui permet d’afficher la distance calculée en centimètres, sur le moniteur série
À noter qu’on aurait pu intégrer ces 3 dernières fonctions à la fonction loop, histoire de simplifier le code. Mais j’ai préféré vous le présenter ainsi, afin que ce soit plus pédagogique (décrire les choses « étape par étape », visuellement parlant, me semblait plus pédagogique !).
Du reste, si vous uploadez ce code et ouvrez le moniteur série, alors vous devriez voir des valeurs s’afficher. De mon côté, voici les distances mesurées, avec un obstacle positionné à environ 7 cm du capteur HCSR04P :
Maintenant, voyons comment écrire un programme plus simple, en utilisant la librairie « newping » (plus facile à comprendre encore, si vous débutez avec les HCSR04 !)
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Exemple de code #2 : programme utilisant la librairie NewPing
Ici, nous allons voir un exemple de programme qui affiche une distance mesurée par le HC-SR04 toutes les secondes, mais cette fois-ci, en utilisant une librairie « spécialisée ». Cette librairie s’appelle « NewPing » et est téléchargeable depuis l’IDE Arduino, comme n’importe quelle autre bibliothèque arduino. À noter que cette librairie NewPing est compatible avec Arduino et ESP32 (même si ce n’est pas à 100% pour ce dernier, si vous « poussez les choses » !). En fait, utiliser une telle librairie apporte plus de lisibilité, ce qui est idéal si vous débutez avec la programmation HC-SR04 😉
Par contre, pour utiliser cette librairie « NewPing », vous aurez besoin qu’elle soit installée dans votre IDE Arduino. Si ce n’est pas le cas, il faudra alors préalablement le faire. Pour cela, il faudra aller dans le menu Outils > Gérer les bibliothèques, pour ouvrir le gestionnaire de librairies arduino. Ensuite, il suffira de taper « newping » dans le champ de recherche, et d’appuyer sur la touche ENTRÉE de votre clavier pour lancer la recherche. Vous devriez voir ainsi apparaître la librairie « NewPing by Tim Eckel ». À ce moment là, il ne vous restera plus qu’à cliquer sur Installer, et attendre que le mot « Installed » apparaisse à l’écran, pour que tout soit bon !
En image, voici un aperçu du gestionnaire de bibliothèque arduino (avant et après installation de la librairie NewPing de Tim Eckel) :
À présent, nous pouvons voir en détail le code de ce deuxième programme (qui comme vous allez pouvoir le constater, est plus court que le précédent et plus facile à comprendre, si vous débutez avec Arduino et ESP32) :
// ===================================================================================================
// ______ _ _///_ _ _ _
// / _ \ (_) | ___| | | | (_)
// | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
// | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
// | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
// \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
// | |
// \_|
// ===================================================================================================
//
// Nom Projet : Tuto HC-SR04P (capteur à ultrasons)
// Desc Projet : Programme de test capteur HC-SR04-P utilisant les lignes ECHO et TRIG,
// en utilisant la librairie "newping"
//
// Fichier : prg2-HCSR04-P-TestEchoTrigAvecNewPing.ino
// Créé le : 08.05.2026
// Auteur : Jérôme TOMSKI
// Site : https://passionelectronique.fr/
// GitHub : https://github.com/PassionElectronique/Programmes-tests-capteur-HC-SR04
// Licence : https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================
// Inclusion des librairies nécessaires
#include <NewPing.h> // À installer à partir du menu Outils > Gérer les bibliothèques (nom de la librairie = "NewPing" de Tim Eckel)
// Constantes
#define brochePourLigneECHO 2 // La broche D2 du microcontrôleur sera reliée à la ligne ECHO du HC-SR04 P
#define brochePourLigneTRIG 3 // La broche D3 du microcontrôleur sera reliée à la ligne TRIG du HC-SR04 P
#define distanceMaxiEnCentimetres 400 // Distance maximale qu'on "s'autorise" à mesurer, en centimètres
// Création d'un objet, arbitrairement nommé 'monSonar', pour contrôler notre capteur HC-SR04P
NewPing monSonar(brochePourLigneTRIG, brochePourLigneECHO, distanceMaxiEnCentimetres);
// ========================
// Initialisation programme
// ========================
void setup() {
// Démarrage du moniteur série
Serial.begin(9600);
Serial.println(F("======================================================="));
Serial.println(F("Programme #2 : mesures de distances toutes les secondes"));
Serial.println(F(" avec le capteur HC-SR04, en utilisant la"));
Serial.println(F(" librairie 'NewPing' de Tim Eckel "));
Serial.println(F("======================================================="));
Serial.println();
// Petite pause de stabilisation avant de passer à la boucle loop (permet aussi d'ignorer certaines mesures "involontaires" du HC-SR04, au démarrage)
delay(500);
}
// =================
// Boucle principale
// =================
void loop() {
// Lancement d'une mesure (ping) et récupération de la distance mesurée
unsigned int distanceMesureeEnCentimetres = monSonar.ping_cm();
// Nota : si la valeur retournée est égale à 0, c'est qu'elle se situe en dehors de la plage de distance définie
// Affichage de cette valeur sur le port série
if (distanceMesureeEnCentimetres == 0) {
Serial.println("Hors de portée ou erreur");
} else {
Serial.print("Distance : ");
Serial.print(distanceMesureeEnCentimetres);
Serial.println(" cm");
}
// Pause d'une seconde (1000 ms) entre chaque rebouclage (pour que les valeurs mesurées ne défilent pas trop vite sur le moniteur série)
delay(1000);
// Remarque : vous pouvez évidemment baisser cette valeur de 1000ms, histoire d'aller plus vite ! Toutefois,
// évitez de descendre en dessous de 50/60 ms, sans quoi vous allez vous retrouver avec des échos parasites !!
}Une fois uploadé, si vous ouvrez le moniteur série d’Arduino IDE, vous devriez voir quelque chose de semblable à cela s’afficher (remarque : ici, j’ai mis un obstacle à environ 25cm de distance, et l’ai rapproché petit à petit, jusqu’à 4cm de distance) :
Vous noterez qu’on n’a pas de chiffres après la virgule affichés ici. Ceci est normal (mais regrettable !), car la fonction « sonar.ping_cm() » de la librairie « NewPing » renvoie un « unsigned int » (un nombre entier positif, donc). Pour pallier à ce problème, on pourrait utiliser la fonction « sonar.ping() » à la place de « sonar.ping_cm() », qui retourne des microsecondes, mais ce faisant, çela reviendrait à faire des calculs comme dans l’exemple de code #1, vu plus haut !
Du coup, perso, je vous recommanderai :
- d’utiliser la fonction « pulseIn », comme nous avons vu dans le 1er exemple, si vous n’avez qu’un seul capteur, et si vous êtes à l’aise avec le « pilotage manuel » et les calculs mathématiques basiques
- d’utiliser la librairie « NewPing » si vous souhaitez avoir un code simplifié, ou si vous débutez
Après, libre à vous de faire comme vous l’entendez, bien entendu 😉
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Quid du HC-SR04P en mode UART ou I2C (puce RCWL-9610) ?
Eh oui… le gros avantage du HC-SR04P, par rapport au « simple » HC-SR04, est d’offrir plusieurs modes de communication possibles. En effet, on a le choix entre :
- le mode GPIO (les classiques broches TRIG et ECHO, comme sur un HC-SR04 « basique »)
- le mode UART (les broches TX/RX, permettant une communication série directe, entre 2 éléments)
- le mode I2C (les broches SCL/SDA, permettant une communication série entre 1 maître et un à plusieurs esclaves)
- et le mode OneWire (qui est ni plus ni moins que le mode GPIO, mais utilisant qu’un seul fil, en fait !)
Remarque : les broches TRIG/RX/SCL/IO sont confondues sur la même broche ; de même pour ECHO/TX/SDA
Basiquement, ce mode de fonctionnement se sélectionne physiquement, au dos du PCB du HC-SR04P, via les pads/jumpers nommés « M1 » et « M2 ». Et selon si on fait un pont de soudure au niveau de M1 et/ou de M2, on peut choisir l’un de ces 4 modes possibles.
Visuellement, voici comment se présentent les choses :
Mais peut-être vous demanderez alors vous pourquoi je n’ai pas parlé de tout ça plus tôt ? Car franchement, par exemple, communiquer en I2C, est autrement plus simple que gérer soi-même les pins TRIG et ECHO ! Eh bien… c’est que tout cela semble génial sur le papier, mais en pratique, tout ne marche pas aussi bien (et c’est peu de le dire !!!).
En effet, après plusieurs essais réalisés en I2C et en UART, le résultat était vraiment médiocre. En effet, la puce RCWL-9610 semble mal gérer les échos en mode I2C ou UART, et les retours d’infos sont plus ou moins souvent totalement erronés (tests réalisés sur plusieurs HCSR04P, histoire d’être sûr que je ne sois pas tombé sur un module défaillant). J’ai d’ailleurs pu découvrir sur le net, après coup, que c’était un problème récurrent et reconnu avec les modules HC-SR04P (puce RCWL 9610).
Au passage, certains ont essayé de filtrer ces mauvais résultats (valeurs retournées très élevées, typiquement), mais ceci ne fût pas viable sur le long terme, du fait qu’il y a des moments où le capteur à ultrasons retourne constamment des valeurs erronées …
Du coup, je vous recommande de rester en « mode normal » (GPIO) avec un HC-SR04P, plutôt que de vous hasarder avec les modes I2C ou UART ! D’autant plus les PCB des HC SR04 sont mal conçus, selon moi, du fait que les 2 pads de M1 (et les 2 pads de M2) sont trop éloignés/espacés pour faire un pont de soudure facilement (à moins d’avoir une large panne à souder au bout de son fer, pour chauffer simultanément les 2 pads de M1 ou de M2, sinon c’est vraiment galère !).
Quid de l’amélioration des mesures avec une sonde de température ?
Juste un mot avant de vous quitter, sur l’ajout d’une sonde température pour obtenir une meilleure estimation des distances avec un HC-SR04.
En fait, en réalité, il faut savoir que la vitesse du son n’est pas constamment de 343 m/s (dans cet article, j’ai uniquement utilisé cette valeur pour garder les choses simples). En pratique, la vitesse du son est notamment influencée par la température ambiante, selon la formule suivante (simplifiée) :
Pour que vous compreniez mieux les choses, voici des exemples de calculs de vitesse du son, à certaines températures données :
- Si la t° ambiante est de -20°C, alors la vitesse du son sera de ~ 319 m/s
- Si la t° ambiante est de 0°C, alors la vitesse du son sera de ~ 331 m/s
- Si la t° ambiante est de 20°C, alors la vitesse du son sera de ~ 343 m/s (valeur prise en référence, dans cet article, pour simplifier les choses)
- Si la t° ambiante est de 40°C, alors la vitesse du son sera de ~ 355 m/s
Ici, on voit clairement que la vitesse du son peut être significativement impactée, lorsqu’on a de grands écarts de températures. Par exemple, entre 40° et 0°, on voit qu’il y a un écart de 7%, au niveau de la vitesse du son (355 m/s à 40°C, et « seulement » 331 m/s à 0°C).
Donc si vous souhaitez affiner vos mesures de distances avec le HC SR04, une sonde de température en complément est une bonne idée, pour estimer plus précisément la vitesse du son (et donc la distance mesurée). Mais cela étant dit, il faut relativiser les choses, du fait de la marge d’erreur du HC-SR04 en lui-même (±3 mm annoncés, mais parfois ±1 cm constaté, sous certaines conditions !).
Du reste, si vous ne cherchez pas à faire des mesures « ultra précises », alors vous pouvez fort bien vous passer de l’ajout d’une sonde de température (surtout que ça fera des composants et fils en moins !).
| Module | Description | Lien |
|---|---|---|
| | Capteur à ultrasons HC-SR04P (compatible 5V et 3,3V) |
Tuto HC-SR04 : Conclusion !
Nous voici au terme de cet article sur l’émetteur récepteur à ultrasons HC-SR04 (en version « P », compatible 3,3/5V et protocoles I2C/UART). En espérant que tout ceci pourra vous servir, dans vos futurs projets ! Par contre, n’idéalisez pas ce capteur, et gardez bien en tête ses faiblesses (notamment le fait qu’il a du mal avec les objets à surfaces absorbantes, fines, ou à angles/biais importants).
Du reste, si j’ai le temps, pourquoi ne pas développer une carte d’interface I2C digne de ce nom, pour ce petit capteur ultrasonique fort utile ? Hum… à suivre 😉
Dans tous les cas, je vous dis : à très bientôt !
Jérôme.
À découvrir aussi : le capteur de température DHT22 (et comparaison avec le DHT11)
(*) Mis à jour le 16/06/2026
Afin de filtrer au maximum les messages de type "spam" ou "inappropriés", chaque commentaire est soumis à modération, et validé manuellement. Du coup, il se peut que certains commentaires ne soient pas publiés, ou sinon, avec un peu de retard. Par ailleurs, j'ai malheureusement plus de messages à traiter que de temps pour y répondre ; c'est pourquoi je ne pourrais pas répondre à tout le monde. Désolé …
