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éristique | Valeur |
|---|---|
| Puce | STMicroelectronics VL53L0X |
| Principe de mesure | Temps de vol (ToF), laser VCSEL 940 nm, classe 1 |
| Portée | Environ 3 cm – 1,2 m (par défaut), jusqu'à 2 m (mode longue portée, environnement sombre, cible blanche) |
| Résolution | 1 mm |
| Précision | Environ ±3 % à ±5 % selon le mode |
| Champ de vision | Environ 25° |
| Durée de mesure | 20 ms – 200 ms (selon le budget de temps) |
| Alimentation | Puce 2,6–3,5 V ; la plupart des modules ont un régulateur, 3,3–5 V |
| Courant | Environ 19 mA pendant la mesure, quelques µA en veille |
| Interface | I2C, 400 kHz maximum, adresse par défaut 0x29 |
| Broches | VIN, 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éristique | VL53L0X | HC-SR04 |
|---|---|---|
| Principe de mesure | Temps de vol de la lumière laser (940 nm) | Écho ultrasonique (40 kHz) |
| Portée | Environ 3 cm – 2 m | Environ 2 cm – 4 m |
| Cône de mesure | Environ 25°, étroit et régulier | Environ 15° de mesure, le son se propage plus largement |
| Résolution | 1 mm | Environ 3 mm (en pratique ±1 cm) |
| Connexion | I2C (SDA, SCL) | 2 broches numériques (Trig, Echo) |
| Plusieurs capteurs | Sur le même bus I2C avec XSHUT | Une broche par capteur, ils peuvent entendre l'écho des autres |
| Alimentation | 3,3–5 V (module) | 5 V |
| Taille | Environ 25 × 13 mm | Environ 45 × 20 mm |
| Cas difficiles | Surface noire ou miroir, verre, lumière du soleil | Tissu, 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 VL53L0X | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (ou 3.3V) | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 |
| SDA | A4 | GPIO 21 | GP4 |
| XSHUT (facultatif) | D4 (D5 pour le 2e capteur) | GPIO 25 | GP6 |
| GPIO1 (facultatif) | Non connecté | Non connecté | Non connecté |
Pas à pas : première mesure avec Arduino
- Branche les fils selon le tableau : VIN → 5V, GND → GND, SDA → A4, SCL → A5.
- Si le capteur porte une bande de protection jaune ou orange, retire-la avec précaution ; cette bande fausse complètement la mesure.
- 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.
- Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds.
- Approche et éloigne ta main devant le capteur ; tu verras les valeurs changer en millimètres et en centimètres.
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}| Commande | Ce 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). |
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.
| Profil | Budget de temps | Portée typique | Précision | Quand l'utiliser ? |
|---|---|---|---|---|
| Par défaut | Environ 30 ms | 1,2 m | Environ ±3–4 % | Mesure d'usage général |
| Haute précision | 200 ms | 1,2 m | Moins de ±3 % | Mesure de niveau, règle précise |
| Longue portée | 33 ms | 2 m | Environ ±4 % | Environnement sombre, cible lointaine |
| Haute vitesse | 20 ms | 1,2 m | Environ ±5 % | Robot rapide, détection de geste de la main |
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.
- 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).
- Au début de setup(), mets toutes les broches XSHUT à LOW pour éteindre tous les capteurs.
- Allume le 1er capteur, démarre-le avec init() et donne-lui sa nouvelle adresse avec setAddress(0x30).
- Allume le 2e capteur, démarre-le et donne-lui l'adresse 0x31 ; s'il y en a d'autres, continue avec 0x32, 0x33.
- Lance la mesure continue sur tous les capteurs et lis chacun avec son propre objet.
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}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.
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.
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 rangingConseils 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ôme | Cause possible | Solution |
|---|---|---|
| init() renvoie false, capteur introuvable | SDA et SCL inversés, pas d'alimentation ou mauvaise broche | Cherche l'adresse 0x29 avec un scanner I2C ; vérifie que SDA = A4 et SCL = A5 sur l'Uno |
| Les valeurs restent autour de 8190 | Cible hors de portée, bande de protection non retirée ou surface trop sombre | Retire la bande, rapproche la cible, essaie le profil longue portée |
| Mesure décalée de quelques centimètres | Décalage du module ou verre devant le capteur | Mesure à une distance connue et retire l'écart dans le code ; retire ou change le cache |
| Les valeurs sautent sans cesse | Budget de temps court, lumière ambiante, petite cible | Passe 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 tout | Conflit d'adresse ou connexion XSHUT manquante | Vérifie les broches XSHUT, allume les capteurs un par un en leur donnant des adresses différentes |
| En extérieur, la mesure est trop courte | Bruit infrarouge de la lumière du soleil | Garde 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.
Projets à réaliser après cet article
Voir tous les projets
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…

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.

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.

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.

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.

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

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é.

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

