Capteurs Ultrason Distance & Niveau : Comparatif Complet HC-SR04, JSN-SR04T, A02YYUW, URM37

📡 Principe de fonctionnement des capteurs ultrason

Un capteur ultrason mesure une distance en chronométrant le temps de vol (Time of Flight, ToF) d'une impulsion acoustique à 40 kHz. L'émetteur envoie une salve d'ultrasons ; le récepteur détecte l'écho renvoyé par l'obstacle. La distance est calculée avec :

La précision dépend de plusieurs facteurs souvent sous-estimés :

• Température de l'air — la vitesse du son varie de ≈ 0,6 m/s/°C. Sans compensation, une erreur de 10 °C introduit ~1,7 % d'erreur.
• Angle d'incidence — un angle supérieur à 15–20° par rapport à la normale de la surface peut disperser l'écho.
• Zone aveugle — distance minimale en dessous de laquelle le capteur ne distingue pas l'émission de la réception (2 à 30 cm selon le modèle).
• Diagramme de rayonnement — le faisceau n'est pas un rayon laser : il forme un cône de 15–30° qui peut capter des surfaces parasites.

🔵 HC-SR04 / HC-SR04P — Le classique incontournable

Interface Trigger / Echo

Le module expose 4 broches : VCC, GND, TRIG (impulsion 10 µs pour déclencher la mesure) et ECHO (signal haut pendant la durée du vol). Pas d'I²C ni de UART : tout repose sur la mesure de largeur d'impulsion.

Attention avec l'ESP32 : la broche ECHO du HC-SR04 classique sort à 5 V. L'ESP32 est tolérant 3,3 V. Utilisez un diviseur résistif 1kΩ/2kΩ ou le HC-SR04P (variante 3,3 V native).

🟢 US-100 — Compensation de température intégrée

Mode UART ou Trigger/Echo

L'US-100 est configurable via un cavalier. En mode UART 9600 bauds, envoyer 0x55 retourne la distance sur 2 octets (MSB / LSB en mm) ; envoyer 0x50 retourne la température interne. En mode Trigger/Echo, il se comporte comme un HC-SR04 mais nativement 3,3 V.

Le capteur de température intégré (précision ±2 °C) corrige automatiquement la vitesse du son en mode UART, ce qui améliore significativement la précision en environnements à température variable (garage, extérieur abrité).

🟡 JSN-SR04T — Sonde étanche déportée

Architecture sonde + carte de contrôle

Le JSN-SR04T sépare la sonde ultrason étanche (transducteur IP65 à câble) du module électronique. La sonde se monte à travers une paroi ou un couvercle de cuve, tandis que la carte reste au sec. Le câble de liaison mesure généralement 2,5 m.

L'interface est identique au HC-SR04 (Trigger 10 µs / ECHO) mais fonctionne en 5 V. La zone aveugle est plus importante (20 cm) : à retenir pour les cuves de faible hauteur ou les mesures proches.

Versions : le JSN-SR04T-2.0 propose en plus un mode UART. Vérifiez le silkscreen sur la carte pour confirmer la version.

🔵 A02YYUW — Entièrement étanche, interface UART

Module tout-en-un IP67

Contrairement au JSN-SR04T, l'A02YYUW intègre l'électronique directement dans la sonde. Il communique en UART 9600 bauds uniquement (3,3 V natif) : envoyer 0x01 pour déclencher une mesure, lire 3 octets en retour (0xFF, MSB, LSB).

La zone aveugle est réduite à 3 cm — excellent pour les cuves peu profondes. Idéal pour la surveillance de niveau de cuve d'eau, de récupérateur de pluie ou de réservoir monté sur Home Assistant via ESP32.

🟠 URM37 — Polyvalent multi-interface

Trois modes d'interface

L'URM37 (DFRobot) se configure via ses broches MODE :

• Mode UART (RS232 TTL) — commandes texte, lecture distance + température, compensation automatique
• Mode PWM — largeur d'impulsion proportionnelle à la distance, comme le HC-SR04 mais sur une seule broche
• Mode Trigger/Echo — compatible bibliothèques HC-SR04

Le capteur de température intégré (précision ±1 °C) permet une compensation automatique en mode UART, ce qui en fait l'un des plus précis de la catégorie sub-20 €.

🔴 MaxSonar MB7389 — Niveau industriel

Destiné aux applications exigeantes

Les capteurs MaxBotix HRXL-MaxSonar (MB7389, MB7395…) sont conçus pour des applications industrielles : mesure de niveau de décharge d'eaux pluviales, cuves de process, détection présence longue distance. Ils proposent simultanément 3 sorties : analogique (0–Vcc), UART (ASCII) et PWM.

Le filtre de bruit interne (multipoint median filter) rejette les échos parasites et les fausses mesures, là où les modules génériques décrochent. La plage de température opérationnelle (−40 à +85 °C) les rend adaptés à une installation en extérieur direct sans boîtier.

📊 Tableau comparatif détaillé

🏗️ Applications pratiques

🪣 Mesure de niveau de cuve / réservoir

Le capteur est monté au sommet de la cuve, pointant vers le bas. La distance mesurée correspond à l'espace entre le capteur et la surface du liquide. Le niveau est calculé par soustraction :

Recommandations pour ce cas d'usage :

• Cuve intérieure sèche (cuve à fuel, eau potable couverte) → US-100 ou JSN-SR04T : bon rapport qualité/prix
• Cuve extérieure / récupérateur pluie → A02YYUW : IP67 nécessaire, zone aveugle 3 cm suffisante
• Cuve industrielle ou milieu sévère → MaxSonar MB7389
• Zone aveugle critique : si le capteur est monté à 10 cm du couvercle et la cuve fait 50 cm, un capteur avec zone aveugle de 20 cm (JSN-SR04T) ne verra pas le niveau plein !

🚗 Détection d'obstacle / aide au stationnement

Pour détecter la présence d'un véhicule (arrêt de portail, parking, capteur de recul DIY), le HC-SR04P ou l'US-100 suffisent largement. La portée effective utile se situe entre 20 et 200 cm dans ce contexte. Le faisceau large (~30°) est ici un avantage : il couvre une zone plutôt qu'un point.

🚶 Détection de présence / compteur de passage

Pour des distances de 0,5 à 3 m avec une rafraîchissement rapide, l'US-100 en mode UART ou l'URM37 sont préférables : la compensation de température évite les fausses détections dues aux variations thermiques d'une pièce ou d'un couloir.

🌧️ Pluviomètre à débordement / mesure de niveau de rivière

Usage délicat car la surface d'eau peut être agitée et la température varie fortement. Recommandé : MaxSonar MB7389 (IP67, −40/+85 °C, filtre multi-echo interne) ou, en version économique, l'A02YYUW protégé dans un boîtier orienté.

💻 Code ESP32 / Arduino

HC-SR04P — Mode Trigger / Echo (ESP32)

#define PIN_TRIG 5
#define PIN_ECHO 18

void setup() {
  Serial.begin(115200);
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
}

float mesureDistance() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  long duree = pulseIn(PIN_ECHO, HIGH, 25000); // timeout 25 ms → ~430 cm
  if (duree == 0) return -1;                   // pas d'écho
  return duree * 0.01715;                      // cm  (v_son 343 m/s à 20°C)
}

void loop() {
  float d = mesureDistance();
  if (d > 0)
    Serial.printf("Distance : %.1f cm\n", d);
  delay(100);
}

A02YYUW — Mode UART (ESP32)

#include <HardwareSerial.h>

HardwareSerial sensorSerial(1);  // UART1

#define RX_PIN 16
#define TX_PIN 17

void setup() {
  Serial.begin(115200);
  sensorSerial.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);
}

int lireDistanceMM() {
  sensorSerial.write(0x01);          // déclencher une mesure
  delay(100);
  if (sensorSerial.available() >= 3) {
    uint8_t buf[3];
    sensorSerial.readBytes(buf, 3);
    if (buf[0] == 0xFF) {            // octet de start
      return (buf[1] << 8) | buf[2]; // distance en mm
    }
  }
  return -1;
}

void loop() {
  int d = lireDistanceMM();
  if (d > 0)
    Serial.printf("Distance : %d mm (%.1f cm)\n", d, d / 10.0f);
  delay(500);
}

US-100 — Mode UART avec température (ESP32)

#include <HardwareSerial.h>

HardwareSerial sensorSerial(2);  // UART2

#define RX_PIN 16
#define TX_PIN 17

void setup() {
  Serial.begin(115200);
  sensorSerial.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);
}

int lireDistanceMM() {
  while (sensorSerial.available()) sensorSerial.read(); // vider buffer
  sensorSerial.write(0x55);
  delay(50);
  if (sensorSerial.available() >= 2) {
    uint8_t msb = sensorSerial.read();
    uint8_t lsb = sensorSerial.read();
    return (msb << 8) | lsb;  // distance en mm
  }
  return -1;
}

float lireTemperature() {
  while (sensorSerial.available()) sensorSerial.read();
  sensorSerial.write(0x50);
  delay(50);
  if (sensorSerial.available() >= 2) {
    uint8_t msb = sensorSerial.read();
    uint8_t lsb = sensorSerial.read();
    return ((msb << 8) | lsb) / 10.0f - 45.0f;  // °C
  }
  return -99.0f;
}

void loop() {
  Serial.printf("Distance : %d mm | Température : %.1f °C\n",
                lireDistanceMM(), lireTemperature());
  delay(1000);
}

🎯 Nos recommandations