Capteurs de distance Arduino : HC-SR04, IR, VL53L0X et LiDAR

Choisir parmi les capteurs de distance pour Arduino ressemble au premier abord à la question « lequel mesure le plus loin », mais ce qui décide vraiment, c'est la surface à mesurer, la précision nécessaire, la finesse du faisceau et les conditions ambiantes. Le même HC-SR04 qui mesure la distance d'un mur au centimètre près peut devenir instable face au tissu moelleux d'un canapé, et un capteur laser bon marché, précis au millimètre, peut perdre la moitié de sa portée au soleil. Dans ce guide, on met côte à côte les six capteurs les plus utilisés dans les projets Arduino.

Les capteurs comparés sont : l'ultrason HC-SR04 et son cousin étanche JSN-SR04T, le capteur infrarouge à triangulation Sharp GP2Y0A21, les capteurs laser à temps de vol (ToF) VL53L0X et VL53L1X, le petit LiDAR TF-Luna et le capteur de proximité à courte portée TCRT5000. Pour chacun, on explique le principe, la portée, la précision, l'angle du faisceau, la réaction aux surfaces et l'interface, avec un exemple de code compilé. À la fin, un tableau résume lequel choisir pour quel projet.

Comment mesurent les capteurs de distance ? Trois principes

Presque tous les capteurs de distance utilisés avec Arduino reposent sur l'une de trois méthodes. Temps de vol : le capteur envoie une impulsion sonore ou lumineuse et mesure le temps que met le reflet à revenir ; la distance vaut la moitié du produit du temps par la vitesse. Les ultrasons le font avec le son, le VL53L0X et le TF-Luna avec la lumière. Comme la lumière est environ un million de fois plus rapide que le son, les capteurs ToF intègrent des puces spéciales qui chronomètrent à la picoseconde près. Triangulation : les capteurs Sharp IR envoient un faisceau infrarouge sur la cible et regardent où la lumière réfléchie tombe sur un détecteur sensible à la position (PSD) ; pour un objet proche, le point se déplace vers une extrémité, pour un objet lointain vers l'autre. Intensité de réflexion : des capteurs simples comme le TCRT5000 mesurent seulement la force de la lumière qui revient ; comme cela dépend beaucoup de la couleur de la surface, c'est de la détection de proximité plutôt qu'une vraie mesure de distance.

Le grand tableau comparatif

Le tableau ci-dessous rassemble les valeurs typiques des modules. Les portées sont celles des fabricants ; dans un vrai projet, elles peuvent être plus courtes selon la surface et l'environnement. Les prix variant selon les pays, ils sont donnés de façon relative.

HC-SR04 : le classique à ultrasons

Le HC-SR04 envoie huit impulsions sonores à 40 kHz et maintient sa broche ECHO à HIGH jusqu'au retour de l'écho. L'Arduino mesure la durée de cette impulsion en microsecondes avec pulseIn(). À 20 °C, le son parcourt environ 343 mètres par seconde, soit 0,0343 cm par microseconde ; comme il fait l'aller-retour, distance = durée × 0,0343 / 2. La vitesse du son varie avec la température (environ 331,3 + 0,606 × T m/s) : entre 0 °C et 35 °C, l'écart est d'environ 6 %, soit jusqu'à 12 cm d'erreur à 2 mètres. Le code ci-dessous applique cette correction et prend la médiane de cinq mesures pour écarter les échos parasites occasionnels.

1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3const float SICAKLIK = 20.0;     // ortam sıcaklığı, °C / ambient temperature, °C
4float sesHizi;                   // cm/µs
5
6float mesafeOlc() {
7  digitalWrite(TRIG_PIN, LOW);
8  delayMicroseconds(2);
9  digitalWrite(TRIG_PIN, HIGH);  // 10 µs tetik darbesi / 10 µs trigger pulse
10  delayMicroseconds(10);
11  digitalWrite(TRIG_PIN, LOW);
12  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL);   // 30 ms ≈ 5 m sınırı / ~5 m limit
13  if (sure == 0) return -1;      // yankı yok / no echo
14  return sure * sesHizi / 2.0;   // gidiş-dönüş / round trip
15}
16
17void setup() {
18  Serial.begin(9600);
19  pinMode(TRIG_PIN, OUTPUT);
20  pinMode(ECHO_PIN, INPUT);
21  sesHizi = (331.3 + 0.606 * SICAKLIK) / 10000.0;   // m/s -> cm/µs (20 °C: 0,0343)
22}
23
24void loop() {
25  float olcum[5];
26  for (int i = 0; i < 5; i++) {  // 5 ölçüm, aralarında 60 ms / 5 readings, 60 ms apart
27    olcum[i] = mesafeOlc();
28    delay(60);
29  }
30  for (int i = 1; i < 5; i++) {  // sırala / sort
31    float x = olcum[i];
32    int j = i - 1;
33    while (j >= 0 && olcum[j] > x) { olcum[j + 1] = olcum[j]; j--; }
34    olcum[j + 1] = x;
35  }
36  float d = olcum[2];            // ortanca / median
37  if (d < 0) Serial.println("Menzil disi / out of range");
38  else { Serial.print(d, 1); Serial.println(" cm"); }
39}
40

• Attends au moins 60 ms entre deux mesures : si tu mesures pendant que les échos de l'impulsion précédente rebondissent encore dans la pièce, le résultat sera faux.
• Surfaces molles et inclinées : tissu, mousse et rideaux absorbent le son ; une surface inclinée de plus de 45 degrés renvoie l'écho ailleurs que vers le capteur.
• Faisceau large : le cône d'environ 15 degrés couvre une zone de près de 50 cm de diamètre à 2 mètres ; dans un couloir étroit, il peut voir aussi les murs latéraux.
• Cartes 3,3 V : le HC-SR04 classique demande 5 V et sa sortie ECHO sort du 5 V ; sur l'ESP32 et le Pico, mets un pont diviseur sur ECHO ou utilise le HC-SR04P qui fonctionne en 3,3 V.
• Plusieurs capteurs : deux HC-SR04 déclenchés en même temps entendent l'écho de l'autre ; déclenche-les l'un après l'autre.

Le câblage du HC-SR04 et son utilisation avec le moniteur série et un écran LCD sont détaillés dans l'article capteur de distance HC-SR04 ; ici, on se concentre sur la comparaison.

JSN-SR04T : l'ultrason étanche

Le JSN-SR04T fonctionne avec la même logique de déclenchement et d'écho que le HC-SR04, mais son transducteur est logé dans une capsule étanche au bout d'un câble, séparée de la carte électronique. C'est donc le choix pour les endroits humides : cuves d'eau, puits, récupérateurs d'eau de pluie, radars de recul en extérieur. Deux différences comptent : comme un seul transducteur émet et écoute, il existe une zone morte à courte distance (environ 20 à 25 cm), et son faisceau est plus large que celui du HC-SR04. Monte le capteur sur le couvercle de la cuve, au moins 25 cm au-dessus du niveau d'eau maximal. Le code ci-dessous convertit la distance en pourcentage de remplissage.

1// JSN-SR04T ile su deposu doluluğu / water tank level with a JSN-SR04T
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const float SENSOR_BOSLUK = 25.0;  // sensörden en yüksek su seviyesine, cm (ölü bölge) / sensor to max level (blind zone)
5const float DEPO_DERINLIK = 120.0; // en yüksek seviyeden depo dibine, cm / max level to tank bottom
6
7float mesafeOlc() {
8  digitalWrite(TRIG_PIN, LOW);
9  delayMicroseconds(5);
10  digitalWrite(TRIG_PIN, HIGH);
11  delayMicroseconds(20);           // JSN-SR04T 10 µs'den uzun darbeyi sever / likes a longer pulse
12  digitalWrite(TRIG_PIN, LOW);
13  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 40000UL);
14  if (sure == 0) return -1;
15  return sure * 0.0343 / 2.0;      // 20 °C ses hızı / speed of sound at 20 °C
16}
17
18void setup() {
19  Serial.begin(9600);
20  pinMode(TRIG_PIN, OUTPUT);
21  pinMode(ECHO_PIN, INPUT);
22}
23
24void loop() {
25  float d = mesafeOlc();
26  if (d < 0) {
27    Serial.println("Yanki yok / no echo");
28  } else {
29    float suYuksekligi = DEPO_DERINLIK - (d - SENSOR_BOSLUK);   // dipten su yüksekliği / water height
30    float yuzde = constrain(suYuksekligi / DEPO_DERINLIK * 100.0, 0, 100);
31    Serial.print("Mesafe / distance: ");
32    Serial.print(d, 1);
33    Serial.print(" cm  Doluluk / fill: %");
34    Serial.println(yuzde, 0);
35  }
36  delay(1000);                     // su yüzeyi dalgalanır, sık ölçme / water ripples, measure slowly
37}
38

Sharp GP2Y0A21 : l'infrarouge analogique

Le Sharp GP2Y0A21YK0F est un capteur infrarouge qui fonctionne entre 10 et 80 cm et délivre une tension analogique selon la distance. Comme il utilise la triangulation, il est moins sensible à la couleur de la cible que les capteurs basés sur l'intensité de réflexion. Sa sortie n'est pas linéaire : environ 2,3 V à 10 cm, 0,4 V à 80 cm, avec une courbe de puissance inverse entre les deux. Le code convertit cette courbe avec l'approximation distance = 29,988 × V^-1,173. Le piège principal se trouve sous 10 cm : quand la cible se rapproche, la tension rebaisse et un objet à 5 cm peut sembler être à 20 cm. Installe le capteur de sorte que la cible ne puisse jamais s'approcher à moins de 10 cm.

1// Sharp GP2Y0A21YK0F (10–80 cm), analog / analog output
2const int SHARP_PIN = A0;
3
4float sharpCm() {
5  long toplam = 0;
6  for (int i = 0; i < 20; i++) {          // 20 okumanın ortalaması / average of 20 readings
7    toplam += analogRead(SHARP_PIN);
8    delay(2);
9  }
10  float volt = toplam / 20.0 * 5.0 / 1023.0;
11  if (volt < 0.35) return -1;             // 80 cm'den uzak / farther than 80 cm
12  float cm = 29.988 * pow(volt, -1.173);  // ters güç eğrisi / inverse power curve
13  if (cm > 80) return -1;
14  return cm;                              // 10 cm altı yanıltıcı / misleading below 10 cm
15}
16
17void setup() {
18  Serial.begin(9600);
19}
20
21void loop() {
22  float cm = sharpCm();
23  if (cm < 0) Serial.println("Menzil disi / out of range");
24  else { Serial.print(cm, 1); Serial.println(" cm"); }
25  delay(100);
26}
27

Les capteurs Sharp tirent de courtes pointes de courant pendant la mesure, ce qui crée du bruit sur l'alimentation. Un condensateur d'environ 10 µF près des broches VCC et GND du capteur calme nettement les lectures. La famille compte d'autres modèles : le GP2Y0A41SK0F fonctionne de 4 à 30 cm, le GP2Y0A02YK0F de 20 à 150 cm ; chacun a ses propres coefficients de courbe.

VL53L0X et VL53L1X : les capteurs laser ToF

Le VL53L0X et le VL53L1X sont de minuscules capteurs laser à temps de vol de STMicroelectronics. Ils envoient une impulsion laser invisible à 940 nm, mesurent le temps de retour du reflet avec des compteurs de photons et donnent le résultat directement en millimètres via I2C. Ils sont presque indépendants de la couleur, leur faisceau est plus étroit que celui d'un ultrason et une mesure dure 20 à 50 ms. Le VL53L0X mesure jusqu'à environ 1,2 mètre en mode par défaut et 2 mètres en mode longue portée ; le VL53L1X atteint 4 mètres et son champ de vision (ROI) se réduit par logiciel. Les deux ont l'adresse I2C par défaut 0x29. Le code utilise la bibliothèque VL53L0X de Pololu ; cherche « VL53L0X » dans le gestionnaire de bibliothèques et installe la version Pololu.

1#include <Wire.h>
2#include <VL53L0X.h>              // Pololu VL53L0X kütüphanesi / library
3
4VL53L0X sensor;
5
6void setup() {
7  Serial.begin(9600);
8  Wire.begin();                    // Uno: SDA A4, SCL A5 / ESP32: SDA 21, SCL 22
9  sensor.setTimeout(500);
10  if (!sensor.init()) {
11    Serial.println("VL53L0X bulunamadi / not found");
12    while (true) {}
13  }
14  // Uzun menzil modu (2 m'ye kadar, daha gürültülü) / long range mode (up to 2 m, noisier):
15  // sensor.setSignalRateLimit(0.1);
16  // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
17  // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
18  sensor.setMeasurementTimingBudget(50000);   // 50 ms: daha kararlı ölçüm / steadier reading
19  sensor.startContinuous();
20}
21
22void loop() {
23  uint16_t mm = sensor.readRangeContinuousMillimeters();
24  if (sensor.timeoutOccurred()) {
25    Serial.println("Zaman asimi / timeout");
26  } else if (mm >= 8190) {         // 8190-8191: hedef yok / no target
27    Serial.println("Menzil disi / out of range");
28  } else {
29    Serial.print(mm);
30    Serial.println(" mm");
31  }
32}
33

Le budget de temps de mesure (timing budget) règle l'équilibre entre précision et vitesse : 20 ms, c'est rapide mais bruité ; 200 ms, c'est lent mais stable. Le soleil et les sources infrarouges puissantes réduisent nettement la portée ; tiens-en compte pour les mesures en extérieur. Pour brancher deux VL53L0X sur le même bus I2C, comme ils ont tous deux l'adresse 0x29, tu en maintiens un éteint avec sa broche XSHUT et tu donnes une nouvelle adresse à l'autre (setAddress) ; les détails I2C sont dans l'article Qu'est-ce que l'I2C.

TF-Luna : 8 mètres avec un petit LiDAR

Le TF-Luna est le petit LiDAR monopoint de Benewake : il mesure le temps de vol en modulant une lumière infrarouge à 850 nm, fonctionne de 0,2 à 8 mètres avec un faisceau très étroit de seulement 2 degrés et peut faire jusqu'à 250 mesures par seconde. Par défaut, il envoie chaque mesure en UART à 115200 bauds dans un paquet de 9 octets : deux octets d'en-tête 0x59, la distance (cm), la force du signal, la température interne et une somme de contrôle. Si la force du signal est inférieure à 100 ou égale à 65535 (surexposition), la mesure est jugée peu fiable. Il s'alimente en 5 V mais son niveau logique UART est de 3,3 V ; il se branche donc directement sur un ESP32. Comme le SoftwareSerial de l'Uno n'est pas fiable à 115200 bauds, préfère une carte avec UART matériel comme l'ESP32 ou la Mega ; la logique de décodage des paquets UART est expliquée dans l'article liaison série UART.

1// TF-Luna LiDAR, UART (115200), ESP32 Serial2
2// TF-Luna TX -> GPIO 16, RX -> GPIO 17, VCC 5V, GND
3const int RXD2 = 16, TXD2 = 17;
4
5uint8_t kare[9];                   // 0x59 0x59 DistL DistH AmpL AmpH TempL TempH Checksum
6int konum = 0;
7
8void setup() {
9  Serial.begin(115200);
10  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);
11}
12
13void loop() {
14  while (Serial2.available()) {
15    uint8_t b = Serial2.read();
16    if (konum < 2) {               // iki 0x59 başlık baytını bekle / wait for two 0x59 header bytes
17      if (b == 0x59) kare[konum++] = b;
18      else konum = 0;
19      continue;
20    }
21    kare[konum++] = b;
22    if (konum < 9) continue;
23    konum = 0;
24
25    uint8_t toplam = 0;
26    for (int i = 0; i < 8; i++) toplam += kare[i];
27    if (toplam != kare[8]) continue;             // sağlama toplamı hatalı / bad checksum
28
29    uint16_t mesafe = kare[2] | (kare[3] << 8);  // cm
30    uint16_t guc = kare[4] | (kare[5] << 8);     // sinyal gücü / signal strength
31    float derece = (kare[6] | (kare[7] << 8)) / 8.0 - 256.0;
32
33    if (guc < 100 || guc == 65535) {             // zayıf ya da aşırı sinyal / weak or saturated
34      Serial.println("Guvenilmez / unreliable");
35    } else {
36      Serial.print(mesafe);
37      Serial.print(" cm  guc / amp: ");
38      Serial.print(guc);
39      Serial.print("  ic sicaklik / chip temp: ");
40      Serial.println(derece, 1);
41    }
42  }
43}
44

TCRT5000 : proximité et détection de ligne

Le TCRT5000 n'est pas un télémètre mais un capteur à réflexion : la lumière de la LED infrarouge rebondit sur la surface et le phototransistor voisin mesure combien elle en renvoie. Il fonctionne au mieux à environ 2,5 mm et le signal faiblit vite au-delà de 1,5 cm. Comme le blanc réfléchit beaucoup et le noir très peu, il donne des valeurs complètement différentes selon la couleur, même à distance égale ; c'est pourquoi on l'utilise pour distinguer le noir du blanc dans les robots suiveurs de ligne, compter les trous d'un disque d'encodeur ou détecter des objets très proches. Le comparateur du module bascule la sortie numérique quand le seuil réglé au potentiomètre est franchi. Détails dans l'article capteur infrarouge TCRT5000.

1// TCRT5000 modülü: DO dijital, AO analog / TCRT5000 module: DO digital, AO analog
2const int DO_PIN = 7;
3const int AO_PIN = A1;
4const int LED_PIN = 13;
5
6void setup() {
7  Serial.begin(9600);
8  pinMode(DO_PIN, INPUT);
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool nesneVar = (digitalRead(DO_PIN) == LOW);  // çoğu modülde LOW = yansıma var / LOW = reflection on most modules
14  int yansima = analogRead(AO_PIN);              // düşük değer = güçlü yansıma / low value = strong reflection
15  digitalWrite(LED_PIN, nesneVar);
16  Serial.print(nesneVar ? "Nesne VAR / object  " : "Nesne yok / none  ");
17  Serial.println(yansima);
18  delay(100);
19}
20

Effet de la surface et de l'environnement

La portée annoncée d'un capteur change dès qu'il rencontre la surface à mesurer. Les ultrasons excellent sur les surfaces dures qui renvoient le son, mais peinent face aux tissus qui l'absorbent ; les capteurs à lumière réagissent à la couleur, à la brillance et au soleil. Le tableau montre quel capteur reste fiable dans quelle situation au moment de concevoir ton projet.

Résumé du câblage : Uno, ESP32 et Pico

Mesure à ultrasons avec le Raspberry Pi Pico

En MicroPython, la durée d'une impulsion se mesure avec machine.time_pulse_us() ; elle fait le même travail que pulseIn() sur Arduino et renvoie une valeur négative en cas de dépassement de délai. Alimente le HC-SR04 depuis la broche VBUS (5 V de l'USB) du Pico et mets un pont 1 kΩ + 2 kΩ sur la ligne ECHO, ou utilise le HC-SR04P qui fonctionne directement en 3,3 V. Il existe aussi des pilotes MicroPython pour le VL53L0X et le TF-Luna ; le paquet UART du TF-Luna se décode facilement avec machine.UART en suivant la même logique que le code Arduino.

1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN)             # 5 V ECHO için gerilim bölücü şart / divider required for a 5 V ECHO
6SES_HIZI = 0.0343                  # cm/µs, 20 °C
7
8def mesafe_olc():
9    trig.low()
10    time.sleep_us(2)
11    trig.high()
12    time.sleep_us(10)              # 10 µs tetik / 10 µs trigger
13    trig.low()
14    sure = time_pulse_us(echo, 1, 30000)   # zaman aşımında eksi döner / negative on timeout
15    if sure < 0:
16        return None
17    return sure * SES_HIZI / 2
18
19while True:
20    d = mesafe_olc()
21    print("Menzil disi" if d is None else "{:.1f} cm".format(d))
22    time.sleep_ms(100)
23

Quel capteur de distance pour quel projet ?

Quelques idées de projets aussi : fais tourner un HC-SR04 sur un servo pour créer un écran de radar Arduino ; mets un HC-SR04 à l'avant et deux VL53L0X sur les côtés de ton robot évitant les obstacles ; ouvre le couvercle d'une poubelle intelligente à l'approche d'une main ; fabrique un mètre numérique portable avec un écran OLED, ou envoie sur ton téléphone le niveau de ta cuve via un ESP32 et un JSN-SR04T.

Erreurs fréquentes et solutions

Les capteurs de distance sont le moyen le plus simple de donner à un projet Arduino la perception de son environnement, et choisir le bon fait toute la différence entre un projet qui tourne sereinement et un projet exaspérant. Les tableaux et les codes de ce comparatif t'aident à équilibrer budget et performances selon tes besoins. Dans l'application BlueGrays, tu trouveras des projets de mesure de distance avec HC-SR04, de radar de recul, de toise, de robot évitant les obstacles, de radar de recul avec ESP32 et de mesure de distance avec TCRT5000, pas à pas avec schéma et code.