Composants · 12 min de lecture

Capteur de distance laser VL53L0X avec Arduino : mesure jusqu'à 2 m

Comment utiliser le capteur laser VL53L0X avec Arduino, ESP32 et Pico ? Branchement I2C, modes de mesure, plusieurs capteurs via XSHUT et comparaison avec le HC-SR04.

Le VL53L0X est un capteur de distance laser ToF (Time of Flight, temps de vol), l'un des moyens les plus petits et les plus précis de mesurer une distance avec Arduino. Cette puce de STMicroelectronics émet une lumière laser invisible de 940 nm, mesure le temps que la lumière met à revenir après avoir touché la cible et donne le résultat directement en millimètres. Ce module de la taille d'un timbre se branche avec seulement les deux fils de données de l'I2C ; il mesure jusqu'à environ 1,2 mètre en mode par défaut et jusqu'à 2 mètres en mode longue portée.

Dans cet article, tu vas découvrir pas à pas le fonctionnement du VL53L0X, son branchement sur Arduino Uno, ESP32 et Raspberry Pi Pico, la différence entre les quatre profils de mesure et comment connecter plusieurs capteurs sur le même bus I2C grâce à la broche XSHUT. Tu le compareras aussi au célèbre capteur ultrasonique HC-SR04 pour savoir lequel choisir selon ton projet.

Qu'est-ce que le VL53L0X et comment fonctionne-t-il ?

À l'intérieur du capteur, il y a deux éléments principaux : un VCSEL (laser à cavité verticale émettant par la surface) qui émet la lumière, et un réseau de SPAD (diodes à avalanche à photon unique) capable de détecter un seul photon. Le VCSEL envoie de très courtes impulsions lumineuses, les SPAD captent les photons de retour et la puce mesure le temps écoulé. La distance se calcule avec une formule simple : d = c × t / 2. Ici, c est la vitesse de la lumière (environ 300 000 km/s) et le résultat est divisé par deux, car la lumière parcourt le trajet deux fois. Pour un objet à 1 mètre, l'aller-retour ne dure que 6,67 nanosecondes. Mesurer une durée aussi courte avec une seule impulsion est presque impossible ; la puce accumule donc la statistique de milliers d'impulsions et fait le calcul en interne : toi, tu lis simplement le résultat.

Le laser utilisé est de classe 1 ; il n'est pas dangereux pour les yeux en usage normal et, étant infrarouge, il est invisible à l'œil nu. Le champ de vision du capteur est d'environ 25 degrés : la mesure se fait donc dans un cône étroit. Tu peux ainsi viser bien mieux qu'avec l'onde sonore large du HC-SR04 ; tu peux mesurer un petit objet au bord d'une table sans accrocher le mur à côté. Comme le résultat repose sur la vitesse de la lumière, il n'est presque pas influencé par la température ni l'humidité.

CaractéristiqueValeur
PuceSTMicroelectronics VL53L0X
Principe de mesureTemps de vol (ToF), laser VCSEL 940 nm, classe 1
PortéeEnviron 3 cm – 1,2 m (par défaut), jusqu'à 2 m (mode longue portée, environnement sombre, cible blanche)
Résolution1 mm
PrécisionEnviron ±3 % à ±5 % selon le mode
Champ de visionEnviron 25°
Durée de mesure20 ms – 200 ms (selon le budget de temps)
AlimentationPuce 2,6–3,5 V ; la plupart des modules ont un régulateur, 3,3–5 V
CourantEnviron 19 mA pendant la mesure, quelques µA en veille
InterfaceI2C, 400 kHz maximum, adresse par défaut 0x29
BrochesVIN, GND, SCL, SDA, GPIO1 (interruption), XSHUT (arrêt)

VL53L0X ou HC-SR04 ?

Les deux capteurs mesurent une distance, mais leur physique est totalement différente. Le HC-SR04 émet une onde sonore de 40 kHz et écoute l'écho ; le son se propageant à environ 343 m/s, le chronométrage est facile et la portée atteint 4 mètres. En revanche, le large cône sonore détecte aussi les objets sur les côtés, et le tissu, la mousse et les surfaces inclinées absorbent ou dévient le son. Le VL53L0X mesure avec la lumière : il est minuscule, vise la cible avec un angle étroit, est plus stable à courte distance et, grâce à l'I2C, plusieurs capteurs peuvent partager le même bus. En contrepartie, la lumière directe du soleil, les surfaces très sombres ou brillantes comme un miroir et le verre le mettent en difficulté. En résumé : pour une mesure petite et rapide sous 2 mètres, choisis le VL53L0X ; pour une portée plus longue et l'extérieur, le HC-SR04 est plus logique. Pour d'autres options, consulte la comparaison des capteurs de distance.

CaractéristiqueVL53L0XHC-SR04
Principe de mesureTemps de vol de la lumière laser (940 nm)Écho ultrasonique (40 kHz)
PortéeEnviron 3 cm – 2 mEnviron 2 cm – 4 m
Cône de mesureEnviron 25°, étroit et régulierEnviron 15° de mesure, le son se propage plus largement
Résolution1 mmEnviron 3 mm (en pratique ±1 cm)
ConnexionI2C (SDA, SCL)2 broches numériques (Trig, Echo)
Plusieurs capteursSur le même bus I2C avec XSHUTUne broche par capteur, ils peuvent entendre l'écho des autres
Alimentation3,3–5 V (module)5 V
TailleEnviron 25 × 13 mmEnviron 45 × 20 mm
Cas difficilesSurface noire ou miroir, verre, lumière du soleilTissu, mousse, surface inclinée, environnement bruyant

Branchement du VL53L0X : Arduino Uno, ESP32 et Pico

La plupart des modules du marché (GY-530, GY-VL53L0XV2, etc.) embarquent un régulateur 2,8 V, des résistances de pull-up pour les lignes I2C et une résistance de pull-up pour XSHUT. Tu peux donc brancher le module aussi bien sur la broche 5V de l'Uno que sur la broche 3V3 de l'ESP32 et du Pico. La plupart des modules bon marché communiquent sans problème avec l'Uno ; pour les projets destinés à tourner longtemps, tu peux tout de même protéger les lignes I2C avec un convertisseur de niveau logique. Si tu veux comprendre la logique du bus, lis l'article Qu'est-ce que l'I2C. La broche GPIO1 est une sortie d'interruption qui signale la fin d'une mesure ; pour une utilisation de base, tu n'as pas besoin de la brancher.

Broche VL53L0XArduino UnoESP32Raspberry Pi Pico
VIN5V (ou 3.3V)3V33V3(OUT)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
XSHUT (facultatif)D4 (D5 pour le 2e capteur)GPIO 25GP6
GPIO1 (facultatif)Non connectéNon connectéNon connecté
Les broches de la puce VL53L0X nue, sans module, supportent 3,6 V au maximum. Sur les modules prêts à l'emploi, tu peux alimenter VIN en 5 V grâce au régulateur, mais ne mets pas la broche XSHUT directement à HIGH avec la sortie 5 V de l'Uno : pour allumer le capteur, configure la broche en INPUT pour la laisser flotter, la résistance de pull-up du module s'occupe du reste. Par ailleurs, l'ordre des broches change d'un modèle à l'autre ; lis toujours les inscriptions sur la carte avant de brancher.

Pas à pas : première mesure avec Arduino

  1. Branche les fils selon le tableau : VIN → 5V, GND → GND, SDA → A4, SCL → A5.
  2. Si le capteur porte une bande de protection jaune ou orange, retire-la avec précaution ; cette bande fausse complètement la mesure.
  3. Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, tape VL53L0X et installe la bibliothèque signée Pololu. Adafruit_VL53L0X fonctionne aussi, mais elle contient l'API complète de ST et occupe beaucoup plus de mémoire sur l'Uno. Si l'installation te pose problème, lis Ajouter une bibliothèque Arduino.
  4. Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds.
  5. Approche et éloigne ta main devant le capteur ; tu verras les valeurs changer en millimètres et en centimètres.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6void setup() {
7  Serial.begin(115200);
8  Wire.begin();                          // Uno: SDA=A4, SCL=A5
9  sensor.setTimeout(500);                // 500 ms cevap bekle / wait 500 ms for a reply
10  if (!sensor.init()) {
11    Serial.println(F("VL53L0X bulunamadi / not found"));
12    while (1) {}
13  }
14  sensor.startContinuous();              // sürekli ölçüm / continuous ranging
15}
16
17void loop() {
18  uint16_t mm = sensor.readRangeContinuousMillimeters();
19  if (sensor.timeoutOccurred()) {
20    Serial.println(F("Zaman asimi / Timeout"));
21    return;
22  }
23  if (mm > 2000) {                       // geçerli yansıma yok / no valid return
24    Serial.println(F("Menzil disi / Out of range"));
25  } else {
26    Serial.print(mm);
27    Serial.print(F(" mm = "));
28    Serial.print(mm / 10.0, 1);
29    Serial.println(F(" cm"));
30  }
31  delay(100);
32}
CommandeCe qu'elle fait
sensor.setTimeout(500)Si le capteur ne répond pas en 500 ms, il arrête d'attendre ; le code ne reste pas bloqué indéfiniment.
sensor.init()Charge la séquence de réglage de ST et fait l'étalonnage SPAD ; si elle renvoie false, le capteur est introuvable sur le bus I2C.
sensor.startContinuous()Fait mesurer le capteur en continu, les mesures s'enchaînant sans interruption.
sensor.readRangeContinuousMillimeters()Renvoie la dernière mesure en millimètres ; sans cible, une valeur autour de 8190 arrive.
sensor.timeoutOccurred()Renvoie true si la dernière lecture a dépassé le délai (la valeur est alors 65535).
Si tu ne vois rien dans le moniteur série, lance d'abord un scanner I2C : si le capteur est bien branché, il apparaît à l'adresse 0x29. Si les valeurs sont cohérentes mais décalées de quelques centimètres de façon constante, place la cible à 100 mm et à 500 mm avec une règle, mesure et retire l'écart moyen dans le code. Ce genre de décalage est fréquent sur les modules bon marché, et cette correction simple améliore nettement la mesure.

Les modes de mesure du VL53L0X

Trois réglages déterminent la qualité de mesure du VL53L0X : le budget de temps (la durée accordée à une mesure), la limite du taux de signal (la réflexion la plus faible considérée comme valide) et la période des impulsions VCSEL (la longueur des impulsions laser). Plus le budget augmente, plus le capteur collecte de photons et plus la mesure est stable, mais plus elle est lente ; un budget de 200 ms ne donne que 5 mesures par seconde. Baisser la limite du signal de 0,25 MCPS par défaut à 0,1 MCPS accepte aussi les réflexions faibles et allonge la portée, mais augmente le risque de lectures erronées. Passer les périodes d'impulsion de 14 et 10 par défaut à 18 et 14 envoie plus d'énergie vers la cible lointaine. ST définit ces réglages sous forme de quatre profils prêts à l'emploi ; dans le code ci-dessous, tu peux choisir le profil en retirant le commentaire au début de la ligne voulue. Tu peux aussi combiner le réglage longue portée avec celui de la vitesse ou de la précision.

ProfilBudget de tempsPortée typiquePrécisionQuand l'utiliser ?
Par défautEnviron 30 ms1,2 mEnviron ±3–4 %Mesure d'usage général
Haute précision200 ms1,2 mMoins de ±3 %Mesure de niveau, règle précise
Longue portée33 ms2 mEnviron ±4 %Environnement sombre, cible lointaine
Haute vitesse20 ms1,2 mEnviron ±5 %Robot rapide, détection de geste de la main
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6// Profil seç: istediğin satırın yorumunu kaldır / Pick a profile: uncomment the line you want
7#define UZUN_MENZIL         // uzun menzil / long range
8//#define YUKSEK_HIZ        // yüksek hız / high speed
9//#define YUKSEK_DOGRULUK   // yüksek doğruluk / high accuracy
10
11void setup() {
12  Serial.begin(115200);
13  Wire.begin();
14  sensor.setTimeout(500);
15  if (!sensor.init()) {
16    Serial.println(F("Sensor yok / No sensor"));
17    while (1) {}
18  }
19
20#if defined UZUN_MENZIL
21  sensor.setSignalRateLimit(0.1);                                  // varsayılan 0.25 MCPS / default 0.25 MCPS
22  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);    // varsayılan 14 / default 14
23  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);  // varsayılan 10 / default 10
24#endif
25
26#if defined YUKSEK_HIZ
27  sensor.setMeasurementTimingBudget(20000);    // 20 ms
28#elif defined YUKSEK_DOGRULUK
29  sensor.setMeasurementTimingBudget(200000);   // 200 ms
30#endif
31}
32
33void loop() {
34  Serial.print(sensor.readRangeSingleMillimeters());   // tek seferlik ölçüm / single-shot ranging
35  if (sensor.timeoutOccurred()) {
36    Serial.print(F(" ZAMAN ASIMI / TIMEOUT"));
37  }
38  Serial.println();
39}

Plusieurs VL53L0X : changer l'adresse avec XSHUT

Chaque VL53L0X sort d'usine avec la même adresse 0x29, et cette adresse ne peut pas être modifiée de façon permanente. Si tu branches deux capteurs directement sur le même bus, les deux répondent en même temps et la communication est perturbée. La solution, c'est la broche XSHUT : quand XSHUT est à LOW, le capteur est complètement éteint et invisible sur le bus I2C. Au démarrage, tu réveilles les capteurs un par un et tu donnes à chacun une nouvelle adresse par logiciel. La nouvelle adresse n'est valable que jusqu'à la coupure de l'alimentation ou jusqu'à ce que XSHUT repasse à LOW ; cette opération se fait donc dans setup() à chaque démarrage. Avec cette méthode, il est très facile de monter trois capteurs (gauche, centre, droite) sur un robot ; en pratique, la limite vient du nombre de broches numériques libres et de la longueur totale des câbles.

  1. Relie VIN, GND, SDA et SCL de tous les capteurs au bus commun ; relie la broche XSHUT de chaque capteur à une broche numérique distincte (D4 et D5 dans l'exemple).
  2. Au début de setup(), mets toutes les broches XSHUT à LOW pour éteindre tous les capteurs.
  3. Allume le 1er capteur, démarre-le avec init() et donne-lui sa nouvelle adresse avec setAddress(0x30).
  4. Allume le 2e capteur, démarre-le et donne-lui l'adresse 0x31 ; s'il y en a d'autres, continue avec 0x32, 0x33.
  5. Lance la mesure continue sur tous les capteurs et lis chacun avec son propre objet.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const uint8_t XSHUT_1 = 4;
5const uint8_t XSHUT_2 = 5;
6
7VL53L0X sensor1;
8VL53L0X sensor2;
9
10void setup() {
11  Serial.begin(115200);
12  Wire.begin();
13
14  pinMode(XSHUT_1, OUTPUT);
15  pinMode(XSHUT_2, OUTPUT);
16  digitalWrite(XSHUT_1, LOW);    // iki sensörü de kapat / shut down both sensors
17  digitalWrite(XSHUT_2, LOW);
18  delay(10);
19
20  pinMode(XSHUT_1, INPUT);       // 1. sensörü aç, modülün pull-up direnci HIGH yapar / wake sensor 1, module pull-up pulls it HIGH
21  delay(10);
22  sensor1.setTimeout(500);
23  if (!sensor1.init()) {
24    Serial.println(F("Sensor 1 yok / Sensor 1 missing"));
25    while (1) {}
26  }
27  sensor1.setAddress(0x30);      // yeni adres / new address
28
29  pinMode(XSHUT_2, INPUT);       // 2. sensörü aç / wake sensor 2
30  delay(10);
31  sensor2.setTimeout(500);
32  if (!sensor2.init()) {
33    Serial.println(F("Sensor 2 yok / Sensor 2 missing"));
34    while (1) {}
35  }
36  sensor2.setAddress(0x31);
37
38  sensor1.startContinuous();
39  sensor2.startContinuous();
40}
41
42void loop() {
43  Serial.print(F("Sol / Left: "));
44  Serial.print(sensor1.readRangeContinuousMillimeters());
45  Serial.print(F(" mm   Sag / Right: "));
46  Serial.print(sensor2.readRangeContinuousMillimeters());
47  Serial.println(F(" mm"));
48  delay(100);
49}
Si l'un des capteurs est réinitialisé (chute de tension, fil mal serré, parasites de moteur), son adresse revient à 0x29 et le code ne le trouve plus. Dans les projets avec moteurs ou longs câbles, vérifie régulièrement le résultat de timeoutOccurred() et, si besoin, écris une fonction de redémarrage qui refait toute la séquence XSHUT. En choisissant les nouvelles adresses, veille à ce qu'elles n'entrent pas en conflit avec celles des autres appareils du bus, comme un écran OLED (0x3C) ou un module RTC (0x68).

VL53L0X avec l'ESP32

Sur l'ESP32, la même bibliothèque Pololu fonctionne sans modification. Les broches I2C par défaut sont GPIO 21 (SDA) et GPIO 22 (SCL) ; les indiquer explicitement avec Wire.begin(21, 22) t'évite les surprises d'une carte à l'autre. Comme les broches de l'ESP32 sont en 3,3 V, tu peux mettre XSHUT directement à HIGH ; la méthode INPUT de l'Uno n'est pas nécessaire. L'exemple ci-dessous mesure avec un budget de 50 ms, fait la moyenne des 5 dernières mesures et allume la LED intégrée de la carte quand un objet passe sous 15 cm. Faire une moyenne est la façon la plus simple de lisser des valeurs qui sautent ; pour des méthodes plus avancées, lis Filtrage des données de capteur. Si tu veux suivre la distance depuis ton téléphone, tu peux combiner le code avec l'exemple de serveur web ESP32.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const int SDA_PIN = 21;
5const int SCL_PIN = 22;
6const int LED_PIN = 2;            // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7const uint16_t ESIK_MM = 150;     // uyarı eşiği / warning threshold
8const uint8_t N = 5;              // ortalama için örnek sayısı / samples for averaging
9
10VL53L0X sensor;
11uint16_t olcumler[N];
12uint8_t sira = 0;
13
14uint16_t olc() {
15  uint16_t mm = sensor.readRangeContinuousMillimeters();
16  if (mm > 2000) mm = 2000;       // menzil dışını sınırla / clamp out-of-range values
17  return mm;
18}
19
20void setup() {
21  Serial.begin(115200);
22  pinMode(LED_PIN, OUTPUT);
23  Wire.begin(SDA_PIN, SCL_PIN);
24  Wire.setClock(400000);          // hızlı I2C / fast-mode I2C
25  sensor.setTimeout(500);
26  if (!sensor.init()) {
27    Serial.println("VL53L0X bulunamadi / not found");
28    while (true) delay(1000);
29  }
30  sensor.setMeasurementTimingBudget(50000);   // 50 ms bütçe / 50 ms budget
31  sensor.startContinuous();
32  for (uint8_t i = 0; i < N; i++) olcumler[i] = olc();   // diziyi doldur / pre-fill the buffer
33}
34
35void loop() {
36  uint16_t mm = olc();
37  if (sensor.timeoutOccurred()) {
38    Serial.println("Zaman asimi / Timeout");
39    return;
40  }
41  olcumler[sira] = mm;
42  sira = (sira + 1) % N;
43
44  uint32_t toplam = 0;
45  for (uint8_t i = 0; i < N; i++) toplam += olcumler[i];
46  uint16_t ortalama = toplam / N;
47
48  digitalWrite(LED_PIN, ortalama < ESIK_MM ? HIGH : LOW);
49  Serial.printf("Ham / Raw: %u mm   Ortalama / Average: %u mm\n", (unsigned)mm, (unsigned)ortalama);
50  delay(50);
51}

Raspberry Pi Pico et MicroPython avec le VL53L0X

En MicroPython, il n'existe pas de module intégré pour le VL53L0X ; tu dois copier sur le Pico, avec Thonny, le fichier pilote vl53l0x.py préparé par la communauté. Ces pilotes portent en Python la séquence d'initialisation de ST et proposent en général les fonctions start(), read() et stop() ; vérifie une fois les noms de fonctions dans le fichier du pilote que tu utilises. Pour le branchement, nous utilisons les broches GP4 (SDA) et GP5 (SCL) de l'I2C0 ; le scan doit afficher 0x29 (41 en décimal). L'expression Pin("LED") utilisée dans le code sélectionne la LED intégrée sur le Pico comme sur le Pico W à partir de MicroPython 1.20. Avec plusieurs capteurs sur le Pico, la même logique XSHUT s'applique ; comme le Pico fonctionne en 3,3 V, tu peux mettre les broches XSHUT directement à HIGH. Si MicroPython est nouveau pour toi, jette d'abord un œil à Les bases de MicroPython.

MicroPython
1from machine import Pin, I2C
2import time
3from vl53l0x import VL53L0X                  # vl53l0x.py Pico'da olmalı / must be on the Pico
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("I2C:", [hex(a) for a in i2c.scan()])  # 0x29 görmelisin / you should see 0x29
7
8tof = VL53L0X(i2c)                           # varsayılan adres 0x29 / default address 0x29
9led = Pin("LED", Pin.OUT)                    # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
10ESIK_MM = 150                                # uyarı eşiği / warning threshold
11
12tof.start()                                  # sürekli ölçüm / continuous ranging
13try:
14    while True:
15        mm = tof.read()
16        if mm > 2000:
17            print("Menzil disi / Out of range")
18        else:
19            print(mm, "mm")
20        led.value(1 if mm < ESIK_MM else 0)
21        time.sleep_ms(100)
22finally:
23    tof.stop()                               # ölçümü durdur / stop ranging

Conseils pour une mesure précise

  • La couleur de la cible compte : les surfaces blanches et mates réfléchissent bien la lumière ; sur le noir, le gris foncé ou le velours, la portée peut tomber à la moitié ou moins.
  • Évite la lumière du soleil : la lumière du soleil contient une forte composante infrarouge qui augmente le bruit de fond du capteur. En extérieur, garde le capteur à l'ombre ou préfère le HC-SR04.
  • Attention au verre de protection : si tu places le capteur dans un boîtier, le verre ou l'acrylique devant lui renvoie une partie de la lumière (crosstalk) et la mesure paraît trop courte. Si tu utilises un cache, choisis un matériau fin, transparent à l'infrarouge et aussi proche que possible du capteur.
  • Surfaces brillantes comme un miroir : la lumière peut rebondir dans une autre direction sur une surface brillante inclinée ; garde le capteur le plus perpendiculaire possible à la surface.
  • Petites cibles : le cône de 25 degrés s'élargit avec la distance ; à 1 mètre, il couvre une zone d'environ 44 cm de diamètre. En mesurant un petit objet de loin, le mur derrière peut aussi fausser le résultat.
  • Garde les câbles courts : le bus I2C se dégrade sur de longs câbles ; au-delà de 30 cm, baisse la vitesse à 100 kHz et éloigne les câbles de ceux des moteurs.

Idées de projets avec le VL53L0X

  • Aide au stationnement de garage : mesure la distance entre la voiture et le mur et change la couleur de la LED à mesure qu'elle approche. Pour un exemple détaillé, lis Système de parking Arduino.
  • Poubelle ou distributeur de savon sans contact : quand ta main s'approche à 10 cm, un servo ouvre le couvercle ; dans le projet de poubelle intelligente, tu peux utiliser le VL53L0X à la place du HC-SR04.
  • Robot éviteur d'obstacles à trois yeux : place un capteur à gauche, au centre et à droite et relie-les sur le même bus avec XSHUT ; un robot éviteur d'obstacles fait des virages bien plus malins.
  • Jauge de niveau de croquettes ou de céréales : monte-la sur le couvercle de la trémie et affiche la quantité restante en pourcentage ; elle s'associe très bien au projet de distributeur automatique de croquettes.
  • Variateur par geste de la main : convertis la distance de ta main au capteur en luminosité de LED avec le PWM ; par exemple 5 cm pleine luminosité, 30 cm éteint.
  • Règle numérique : affiche la distance mesurée en gros chiffres sur un écran OLED et transforme le montage en instrument de mesure de bureau.

Erreurs fréquentes et solutions

SymptômeCause possibleSolution
init() renvoie false, capteur introuvableSDA et SCL inversés, pas d'alimentation ou mauvaise brocheCherche l'adresse 0x29 avec un scanner I2C ; vérifie que SDA = A4 et SCL = A5 sur l'Uno
Les valeurs restent autour de 8190Cible hors de portée, bande de protection non retirée ou surface trop sombreRetire la bande, rapproche la cible, essaie le profil longue portée
Mesure décalée de quelques centimètresDécalage du module ou verre devant le capteurMesure à une distance connue et retire l'écart dans le code ; retire ou change le cache
Les valeurs sautent sans cesseBudget de temps court, lumière ambiante, petite ciblePasse le budget à 50–200 ms, fais la moyenne de plusieurs mesures
65535 et message de délai dépasséCâble I2C long ou mal serré, capteur réinitialiséRaccourcis les câbles, resserre les connexions, redémarre le capteur
L'un des deux capteurs ne répond pas du toutConflit d'adresse ou connexion XSHUT manquanteVérifie les broches XSHUT, allume les capteurs un par un en leur donnant des adresses différentes
En extérieur, la mesure est trop courteBruit infrarouge de la lumière du soleilGarde le capteur à l'ombre, utilise le profil haute précision ou passe au HC-SR04

Avec sa petite taille, son champ de vision étroit et sa résolution millimétrique, le VL53L0X ajoute un œil précis à de nombreux projets, des robots aux interrupteurs sans contact ; en choisissant le bon profil et en corrigeant le décalage, tu obtiens des résultats bien plus stables à courte distance, là où les capteurs ultrasoniques peinent. Dans l'application BlueGrays, tu peux découvrir pas à pas, avec schémas et codes, les projets de mesure de distance, de capteur de stationnement, de toise et de robot éviteur d'obstacles, et adapter facilement la même logique à ton propre projet avec le VL53L0X.

Questions fréquentes

Jusqu'à combien de mètres le VL53L0X mesure-t-il ?

Avec les réglages par défaut, la portée fiable est d'environ 1,2 mètre. En profil longue portée, dans un environnement sombre et avec une cible blanche bien réfléchissante, il peut mesurer jusqu'à 2 mètres. Sur des surfaces grises ou sombres et en plein soleil, cette portée diminue nettement.

VL53L0X ou HC-SR04 : lequel est le meilleur ?

Cela dépend de l'usage. Le VL53L0X est petit, à angle étroit et plus stable sous 2 mètres ; grâce à l'I2C, plusieurs capteurs se branchent facilement sur le même bus. Le HC-SR04 mesure jusqu'à 4 mètres, n'est pas gêné par la lumière du soleil et détecte le verre, mais il peine sur les surfaces molles comme le tissu.

Quelle est l'adresse I2C du VL53L0X et comment la changer ?

L'adresse par défaut sur 7 bits est 0x29 ; on l'écrit aussi 0x52 en notation 8 bits. L'adresse se change par logiciel avec la fonction setAddress(), mais elle n'est pas permanente : elle revient à 0x29 à la coupure de l'alimentation ou quand XSHUT passe à LOW. Avec plusieurs capteurs, tu dois les allumer un par un avec XSHUT et leur donner une adresse à chaque démarrage.

Pourquoi le VL53L0X affiche-t-il la valeur 8190 ?

Quand la bibliothèque Pololu ne trouve aucune réflexion valide dans le champ de vision, elle renvoie une valeur comme 8190 ou 8191. La cible peut être hors de portée, la surface trop sombre, ou la bande de protection sur le capteur n'a pas été retirée. La valeur 65535 signifie un délai I2C dépassé ; vérifie les câbles et l'alimentation.

Le VL53L0X fonctionne-t-il en plein soleil ?

Il fonctionne, mais ses performances baissent. La lumière du soleil contient une forte composante infrarouge qui augmente le bruit de fond du capteur, et la portée peut tomber à la moitié ou moins. En extérieur, il vaut mieux garder le capteur à l'ombre, choisir le profil haute précision et l'utiliser à courte distance.

Quelle est la différence entre le VL53L0X et le VL53L1X ?

Le VL53L1X est le membre plus récent de la même famille ; il mesure jusqu'à 4 mètres et permet de choisir seulement une partie du champ de vision (ROI). Le VL53L0X est limité à 2 mètres, mais il est moins cher et largement suffisant pour les projets à courte distance. Les bibliothèques des deux capteurs étant différentes, le code ne se transpose pas tel quel.

Voir tous les projets
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Capteur de stationnement avec HC-SR04
AR-28Intermédiaire
Premium

Capteur de stationnement avec HC-SR04

Une version miniature du radar de recul des voitures : plus un objet s'approche, plus les bips s'accélèrent.

4.8(64)
86
Mesure de la distance à l'aide d'un écran LCD
AR-31Avancé
Premium

Mesure de la distance à l'aide d'un écran LCD

Un appareil qui mesure les distances sans règle : avance et recule ta main devant le capteur et regarde le nombre changer.

4.6(45)
59
Projet de mesure de la taille
AR-33Intermédiaire
Premium

Projet de mesure de la taille

Une toise qui se fixe au cadre de la porte et te dit en centimètres la taille de la personne qui se tient dessous.

4.5(25)
34
Lecture de réflexion (proximité) avec TCRT5000
AR-77Intermédiaire
Premium

Lecture de réflexion (proximité) avec TCRT5000

Avec un petit capteur qui envoie une lumière invisible et mesure ce qui revient, tu détectes la surface placée devant lui.

4.6(33)
43
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

5.0(38)
49
ESP32 HC-SR04 Télémètre à ultrasons
ES-14Intermédiaire

ESP32 HC-SR04 Télémètre à ultrasons

Le capteur à ultrasons HC-SR04 mesure une distance d'après le temps que met son impulsion sonore à rebondir sur un objet et revenir (temps de vol). L'ESP32 envoie une impulsion de 10 microsecondes sur TRIG et lit la durée de l'écho sur ECHO avec pulseIn(). La distance s'affiche en cm sur un LCD I2C 16x2. Le HC-SR04 fonctionne en 5 V : ECHO a besoin d'un pont diviseur, sinon le GPIO 3,3 V de l'ESP32 est endommagé.

4.9(29)
48
Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
ES-38Avancé
Premium

Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)

La version ESP32 d'un radar de recul ! Le capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'objet devant lui. Plus il se rapproche, plus une barre de 5 LED se remplit (vert → jaune → rouge) et plus le buzzer bipe vite. Tout près (moins de 10 cm), une alarme continue retentit et toutes les LED s'allument. L'écran OLED SSD1306 affiche la distance en cm en grands caractères, avec un message d'état.

14