VL53L0X con Arduino: sensore di distanza laser fino a 2 m
Come usare il sensore laser VL53L0X con Arduino, ESP32 e Pico: collegamento I2C, modalità di misura, più sensori con XSHUT e confronto con HC-SR04.
Il VL53L0X è un sensore laser di distanza ToF (Time of Flight, tempo di volo), uno dei modi più piccoli e precisi per misurare distanze con Arduino. Questo chip di STMicroelectronics emette una luce laser invisibile a 940 nm, misura il tempo che la luce impiega a colpire il bersaglio e tornare, e ti restituisce il risultato direttamente in millimetri. Il modulo, grande come un francobollo, si collega con i soli due fili dati dell'I2C; in modalità predefinita misura fino a circa 1,2 metri, in modalità a lungo raggio fino a 2 metri.
In questo articolo vedrai passo dopo passo come funziona il VL53L0X, come collegarlo ad Arduino Uno, ESP32 e Raspberry Pi Pico, qual è la differenza tra i quattro profili di misura e come collegare più sensori sullo stesso bus I2C con il pin XSHUT. Lo confronteremo anche con il diffuso sensore di distanza HC-SR04 a ultrasuoni, così capirai quale conviene in ogni progetto.
Cos'è il VL53L0X e come funziona?
All'interno del sensore ci sono due componenti principali: un VCSEL (laser a emissione superficiale con cavità verticale) che emette la luce e una matrice di SPAD (diodi a valanga a singolo fotone) capaci di rilevare anche un solo fotone. Il VCSEL invia impulsi di luce brevissimi, la matrice SPAD cattura i fotoni di ritorno e il chip misura il tempo trascorso. La distanza si ricava con una formula semplice: d = c × t / 2. Qui c è la velocità della luce (circa 300.000 km/s) e il risultato si divide per due perché la luce percorre il tragitto due volte. Per un oggetto a 1 metro il tempo di andata e ritorno è di soli 6,67 nanosecondi. Misurare un tempo così breve con un solo impulso è quasi impossibile, quindi il chip raccoglie le statistiche di migliaia di impulsi ed esegue il calcolo al proprio interno; tu leggi soltanto il risultato già pronto.
Il laser utilizzato è di Classe 1: nell'uso normale non è pericoloso per gli occhi e, essendo infrarosso, è invisibile a occhio nudo. Il campo visivo del sensore è di circa 25 gradi, quindi la misura avviene all'interno di un cono stretto. Così puoi puntare il bersaglio molto meglio che con l'ampio fascio sonoro dell'HC-SR04: puoi misurare anche un piccolo oggetto sul bordo del tavolo senza disturbi dalla parete accanto. Poiché il risultato si basa sulla velocità della luce, praticamente non è influenzato da temperatura e umidità ambientali.
| Caratteristica | Valore |
|---|---|
| Chip | STMicroelectronics VL53L0X |
| Principio di misura | Tempo di volo (ToF), laser VCSEL a 940 nm, Classe 1 |
| Portata | Circa 3 cm – 1,2 m (predefinita), fino a 2 m (modalità lungo raggio, ambiente buio, bersaglio bianco) |
| Risoluzione | 1 mm |
| Precisione | Circa ±3% – ±5% a seconda della modalità |
| Campo visivo | Circa 25° |
| Tempo di misura | 20 ms – 200 ms (in base al timing budget) |
| Alimentazione | Chip 2,6–3,5 V; la maggior parte dei moduli ha un regolatore, 3,3–5 V |
| Corrente | Circa 19 mA durante la misura, pochi µA in standby |
| Interfaccia | I2C, max 400 kHz, indirizzo predefinito 0x29 |
| Pin | VIN, GND, SCL, SDA, GPIO1 (interrupt), XSHUT (spegnimento) |
VL53L0X o HC-SR04?
Entrambi i sensori misurano la distanza, ma la loro fisica è completamente diversa. L'HC-SR04 emette un'onda sonora a 40 kHz e ascolta l'eco; poiché il suono viaggia a circa 343 m/s, la temporizzazione è facile e la portata arriva a 4 metri. Tuttavia l'ampio cono sonoro rileva anche gli oggetti laterali, e tessuti, gommapiuma e superfici inclinate assorbono o deviano il suono. Il VL53L0X invece misura con la luce: è molto piccolo, punta il bersaglio con un angolo stretto, è più stabile a distanza ravvicinata e, grazie all'I2C, permette di condividere un solo bus tra molti sensori. In compenso soffre la luce solare diretta, le superfici molto scure o a specchio e il vetro. In breve: se ti serve una misura piccola e veloce sotto i 2 metri, scegli il VL53L0X; se ti servono più portata e uso all'aperto, l'HC-SR04 è più sensato. Per altre alternative guarda il confronto tra sensori di distanza.
| Caratteristica | VL53L0X | HC-SR04 |
|---|---|---|
| Principio di misura | Tempo di volo della luce laser (940 nm) | Eco di ultrasuoni (40 kHz) |
| Portata | Circa 3 cm – 2 m | Circa 2 cm – 4 m |
| Cono di misura | Circa 25°, stretto e regolare | Circa 15° di angolo di misura, il suono si diffonde di più |
| Risoluzione | 1 mm | Circa 3 mm (in pratica ±1 cm) |
| Collegamento | I2C (SDA, SCL) | 2 pin digitali (Trig, Echo) |
| Più sensori | Sullo stesso bus I2C con XSHUT | Un pin per ogni sensore, possono sentire l'eco l'uno dell'altro |
| Alimentazione | 3,3–5 V (modulo) | 5 V |
| Dimensioni | Circa 25 × 13 mm | Circa 45 × 20 mm |
| Situazioni difficili | Superfici nere o a specchio, vetro, luce solare | Tessuti, gommapiuma, superfici inclinate, ambienti rumorosi |
Collegamento del VL53L0X: Arduino Uno, ESP32 e Pico
La maggior parte dei moduli in commercio (come GY-530 e GY-VL53L0XV2) ha un regolatore a 2,8 V, resistenze di pull-up per le linee I2C e una resistenza di pull-up per XSHUT. Così puoi collegare il modulo sia al pin 5V dell'Uno sia al pin 3V3 di ESP32 e Pico. La maggior parte dei moduli economici comunica senza problemi con l'Uno; se però vuoi proteggere le linee I2C in progetti che resteranno accesi a lungo, puoi usare un convertitore di livello logico. Se vuoi capire la logica del bus I2C, leggi Cos'è l'I2C. Il pin GPIO1 è un'uscita di interrupt che segnala la fine della misura; nell'uso di base non devi collegarlo.
| Pin VL53L0X | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (oppure 3.3V) | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 |
| SDA | A4 | GPIO 21 | GP4 |
| XSHUT (facoltativo) | D4 (D5 per il 2° sensore) | GPIO 25 | GP6 |
| GPIO1 (facoltativo) | Non collegato | Non collegato | Non collegato |
Passo dopo passo: la prima misura con Arduino
- Collega i cavi secondo la tabella: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
- Se sul sensore c'è una pellicola protettiva gialla o arancione, staccala con cura: la pellicola rovina completamente la misura.
- Nell'IDE di Arduino apri il Gestore Librerie, cerca VL53L0X e installa la libreria firmata Pololu. Anche Adafruit_VL53L0X funziona, ma include l'API completa di ST e occupa molta più memoria sull'Uno. Se hai problemi con l'installazione, leggi come aggiungere librerie in Arduino.
- Carica il codice qui sotto e apri il Monitor Seriale a 115200 baud.
- Avvicina e allontana la mano davanti al sensore e guarda i valori cambiare in millimetri e centimetri.
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}| Comando | Cosa fa? |
|---|---|
| sensor.setTimeout(500) | Se il sensore non risponde entro 500 ms, smette di aspettare; il codice non resta bloccato per sempre. |
| sensor.init() | Carica la sequenza di configurazione di ST ed esegue la calibrazione SPAD; se restituisce false, il sensore non è stato trovato sul bus I2C. |
| sensor.startContinuous() | Fa eseguire al sensore misure consecutive e continue. |
| sensor.readRangeContinuousMillimeters() | Restituisce l'ultima misura in millimetri; se non c'è un bersaglio arriva un valore intorno a 8190. |
| sensor.timeoutOccurred() | Restituisce true se l'ultima lettura è andata in timeout (in tal caso il valore è 65535). |
Modalità di misura del VL53L0X
Sul VL53L0X la qualità della misura dipende da tre impostazioni: il timing budget (il tempo dedicato a una misura), il limite del rapporto di segnale (il riflesso più debole considerato valido) e il periodo dell'impulso VCSEL (la durata degli impulsi laser). Più alto è il budget, più fotoni raccoglie il sensore e più stabile è la misura, ma diventa più lenta; un budget di 200 ms significa solo 5 misure al secondo. Abbassare il limite del segnale dal valore predefinito di 0,25 MCPS a 0,1 MCPS fa accettare anche riflessi deboli e allunga la portata, ma aumenta il rischio di letture errate. Portare i periodi degli impulsi dai valori predefiniti 14 e 10 a 18 e 14 invia più energia ai bersagli lontani. ST definisce queste impostazioni come quattro profili pronti; nel codice qui sotto puoi scegliere il profilo togliendo il commento all'inizio della riga che ti interessa. Puoi usare l'impostazione a lungo raggio anche insieme a quella di velocità o di precisione.
| Profilo | Timing budget | Portata tipica | Precisione | Quando usarlo? |
|---|---|---|---|---|
| Predefinito | Circa 30 ms | 1,2 m | Circa ±3–4% | Misura di uso generale |
| Alta precisione | 200 ms | 1,2 m | Sotto ±3% | Misura di livello, righello di precisione |
| Lungo raggio | 33 ms | 2 m | Circa ±4% | Ambiente buio, bersaglio lontano |
| Alta velocità | 20 ms | 1,2 m | Circa ±5% | Robot veloci, rilevamento di gesti della mano |
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}Più VL53L0X: cambiare indirizzo con XSHUT
Ogni VL53L0X esce di fabbrica con lo stesso indirizzo 0x29, che non può essere modificato in modo permanente. Se colleghi due sensori direttamente sullo stesso bus, rispondono entrambi nello stesso momento e la comunicazione si corrompe. La soluzione è il pin XSHUT: con XSHUT a LOW il sensore si spegne completamente e non compare sul bus I2C. All'avvio svegli i sensori uno alla volta e assegni a ciascuno un nuovo indirizzo via software. Il nuovo indirizzo vale solo finché non viene tolta l'alimentazione o XSHUT non torna a LOW; per questo l'operazione si fa ogni volta in setup(). Con questo metodo montare su un robot tre sensori, a sinistra, al centro e a destra, è molto facile; in pratica il limite è dato dal numero di pin digitali liberi e dalla lunghezza totale dei cavi.
- Collega in comune i pin VIN, GND, SDA e SCL di tutti i sensori; collega il pin XSHUT di ciascun sensore a un pin digitale separato (nell'esempio D4 e D5).
- All'inizio di setup() porta tutti i pin XSHUT a LOW per spegnere tutti i sensori.
- Accendi il 1° sensore, avvialo con init() e assegnagli il nuovo indirizzo con setAddress(0x30).
- Accendi il 2° sensore, avvialo e assegnagli l'indirizzo 0x31; se ci sono altri sensori, continua con 0x32, 0x33 e così via.
- Avvia la misura continua su tutti i sensori e leggi ciascuno con il proprio oggetto.
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 con ESP32
Sull'ESP32 la stessa libreria Pololu funziona senza modifiche. I pin I2C predefiniti sono GPIO 21 (SDA) e GPIO 22 (SCL); indicarli esplicitamente con Wire.begin(21, 22) ti evita sorprese su schede diverse. Poiché i pin dell'ESP32 lavorano a 3,3 V, puoi portare XSHUT direttamente a HIGH; non serve il metodo INPUT usato sull'Uno. L'esempio qui sotto misura con un budget di 50 ms, calcola la media delle ultime 5 misure e accende il LED integrato quando l'oggetto si avvicina a meno di 15 cm. Fare la media è il modo più semplice per attenuare i valori ballerini; per metodi più avanzati leggi il filtraggio dei dati dei sensori. Se vuoi seguire la distanza dal telefono, puoi unire il codice all'esempio del web server 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 e MicroPython con VL53L0X
In MicroPython non esiste un modulo integrato per il VL53L0X; devi copiare sul Pico con Thonny il file driver vl53l0x.py preparato dalla comunità. Questi driver portano in Python la sequenza di inizializzazione di ST e di solito offrono le funzioni start(), read() e stop(); controlla una volta i nomi delle funzioni nel file del driver che usi. Per il collegamento usiamo i pin GP4 (SDA) e GP5 (SCL) di I2C0; nella scansione dovresti vedere 0x29 (41 in decimale). L'istruzione Pin("LED") usata nel codice, da MicroPython 1.20 in poi, seleziona il LED integrato sia sul Pico sia sul Pico W. Anche con il Pico, se usi più sensori vale la stessa logica di XSHUT; poiché il Pico lavora a 3,3 V, puoi portare i pin XSHUT direttamente a HIGH. Se sei nuovo di MicroPython, dai prima un'occhiata ai fondamenti di 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 rangingConsigli per una misura corretta
- Il colore del bersaglio conta: le superfici bianche e opache riflettono bene la luce; su superfici nere, grigio scuro o vellutate la portata può dimezzarsi o ridursi ancora di più.
- Evita la luce solare: la luce del sole ha una forte componente infrarossa e aumenta il rumore di fondo del sensore. All'aperto tieni il sensore all'ombra oppure scegli l'HC-SR04.
- Attenzione al vetro di copertura: se metti il sensore dentro una scatola, il vetro o l'acrilico davanti riflette parte della luce all'indietro (crosstalk) e fa risultare la misura più corta. Se usi una copertura, scegli un materiale sottile, trasparente agli infrarossi e il più vicino possibile al sensore.
- Superfici lucide a specchio: la luce può rimbalzare altrove da una superficie lucida inclinata; tieni il sensore il più perpendicolare possibile alla superficie.
- Bersagli piccoli: il cono di 25 gradi si allarga con la distanza; a 1 metro vede un'area di circa 44 cm di diametro. Misurando un piccolo oggetto da lontano, anche la parete dietro può influire sul risultato.
- Tieni i cavi corti: il bus I2C si degrada con cavi lunghi; oltre i 30 cm porta la velocità a 100 kHz e fai passare i cavi lontano da quelli dei motori.
Idee di progetto con il VL53L0X
- Assistente per il parcheggio in garage: misura la distanza dell'auto dal muro e cambia il colore del LED man mano che si avvicina. Per un esempio dettagliato guarda il sistema di parcheggio con Arduino.
- Cestino o dispenser di sapone senza contatto: quando avvicini la mano a 10 cm, un servo apre il coperchio; nel progetto del cestino intelligente puoi usare il VL53L0X al posto dell'HC-SR04.
- Robot evita-ostacoli a tre occhi: monta un sensore a sinistra, uno al centro e uno a destra e collegali sullo stesso bus con XSHUT; il robot evita-ostacoli farà curve molto più intelligenti.
- Indicatore di livello di cibo o cereali: montalo sul coperchio del serbatoio e mostra la quantità rimasta in percentuale; fa coppia perfetta con il progetto della macchina automatica per il cibo.
- Dimmer a gesti della mano: converti la distanza della mano dal sensore in luminosità del LED con il PWM; per esempio 5 cm tutto acceso, 30 cm spento.
- Righello digitale: mostra la distanza misurata a grandi cifre su un display OLED e trasformalo in uno strumento di misura da scrivania.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| init() restituisce false, il sensore non si trova | SDA e SCL scambiati, nessuna alimentazione o pin sbagliato | Cerca l'indirizzo 0x29 con uno scanner I2C; sull'Uno controlla che SDA = A4 e SCL = A5 |
| I valori restano sempre intorno a 8190 | Bersaglio fuori portata, pellicola protettiva non rimossa o superficie troppo scura | Stacca la pellicola, avvicina il bersaglio, prova il profilo a lungo raggio |
| La misura è sfalsata di qualche centimetro | Offset del modulo o vetro di copertura davanti | Misura a una distanza nota e sottrai la differenza nel codice; togli o cambia la copertura |
| I valori saltano continuamente | Timing budget breve, luce ambientale, bersaglio piccolo | Porta il budget a 50–200 ms, fai la media di più misure |
| 65535 e messaggio di timeout | Cavo I2C lungo o allentato, sensore resettato | Accorcia i cavi, stringi i collegamenti, riavvia il sensore |
| Uno dei due sensori non risponde affatto | Conflitto di indirizzi o collegamento XSHUT mancante | Controlla i pin XSHUT, accendi i sensori uno alla volta e assegna indirizzi diversi |
| All'aperto la misura risulta troppo corta | Rumore infrarosso della luce solare | Tieni il sensore all'ombra, usa il profilo ad alta precisione o passa all'HC-SR04 |
Con le sue dimensioni ridotte, il campo visivo stretto e la risoluzione al millimetro, il VL53L0X aggiunge un occhio preciso a progetti che vanno dai robot agli interruttori senza contatto; scegliendo il profilo giusto e correggendo l'offset otterrai risultati molto più stabili a corta distanza, dove i sensori a ultrasuoni faticano. Nell'app BlueGrays puoi consultare passo dopo passo, con schemi e codice, i progetti di misura della distanza, sensore di parcheggio, misuratore di altezza e robot evita-ostacoli, e adattare facilmente la stessa logica al tuo progetto con il VL53L0X.
Domande frequenti
Fino a quanti metri misura il VL53L0X?
Con le impostazioni predefinite la portata affidabile è di circa 1,2 metri. Nel profilo a lungo raggio, in ambiente buio e con un bersaglio bianco che riflette bene, può misurare fino a 2 metri. Su superfici grigie o scure e con luce solare questa portata si riduce sensibilmente.
Meglio il VL53L0X o l'HC-SR04?
Dipende dall'uso. Il VL53L0X è piccolo, ha un angolo stretto ed è più stabile sotto i 2 metri; grazie all'I2C si collegano facilmente più sensori sullo stesso bus. L'HC-SR04 misura fino a 4 metri, non risente della luce solare e rileva il vetro, ma fatica sulle superfici morbide come i tessuti.
Qual è l'indirizzo I2C del VL53L0X e come si cambia?
L'indirizzo predefinito a 7 bit è 0x29; nella notazione a 8 bit si scrive anche 0x52. L'indirizzo si cambia via software con la funzione setAddress(), ma non è permanente: quando manca l'alimentazione o XSHUT va a LOW, torna a 0x29. Con più sensori devi accenderli a turno con XSHUT e assegnare l'indirizzo a ogni avvio.
Perché il VL53L0X mostra il valore 8190?
La libreria Pololu restituisce un valore come 8190 o 8191 quando non trova un riflesso valido nel campo visivo del sensore. Il bersaglio può essere fuori portata, la superficie troppo scura o la pellicola protettiva sul sensore non essere stata rimossa. Il valore 65535 invece indica un timeout I2C; controlla cavi e alimentazione.
Il VL53L0X funziona alla luce del sole?
Funziona, ma le prestazioni calano. La luce solare contiene una forte componente infrarossa che aumenta il rumore di fondo del sensore e la portata può dimezzarsi o ridursi ancora. All'aperto aiuta tenere il sensore all'ombra, scegliere il profilo ad alta precisione e usarlo a corta distanza.
Qual è la differenza tra VL53L0X e VL53L1X?
Il VL53L1X è il membro più recente della stessa famiglia: misura fino a 4 metri e ti permette di selezionare solo una parte del campo visivo (ROI). Il VL53L0X è limitato a 2 metri, ma costa meno ed è più che sufficiente per progetti a corta distanza. Le librerie dei due sensori sono diverse, quindi il codice non si trasferisce identico.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
HC-SR04 Misura della distanza (display seriale)
Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

Sensore di parcheggio con HC-SR04
Una versione in miniatura del sensore di parcheggio delle auto: più qualcosa si avvicina, più i bip accelerano.

Misurazione della distanza tramite display LCD
Uno strumento che misura le distanze senza righello: muovi la mano avanti e indietro davanti al sensore e guarda il numero cambiare.

Progetto di misurazione dell'altezza
Un misuratore d'altezza da appendere allo stipite della porta che ti dice in centimetri quanto è alto chi ci sta sotto.

Lettura della riflessione (prossimità) con TCRT5000
Con un piccolo sensore che manda luce invisibile e misura quanta ne torna indietro, rilevi la superficie che ha davanti.

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

ESP32 HC-SR04 Misuratore di distanza a ultrasuoni
Il sensore a ultrasuoni HC-SR04 misura la distanza in base al tempo che il suo impulso sonoro impiega a rimbalzare su un oggetto e tornare (tempo di volo). L'ESP32 invia un impulso di 10 microsecondi al pin TRIG e legge la durata dell'eco su ECHO con pulseIn(). La distanza appare in cm su un LCD I2C 16x2. L'HC-SR04 funziona a 5 V, quindi ECHO richiede un partitore di tensione, altrimenti il GPIO a 3,3 V dell'ESP32 si danneggia.

Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
La versione ESP32 di un sensore di parcheggio! Il sensore a ultrasuoni HC-SR04 misura la distanza dall'oggetto davanti. Più si avvicina, più si riempie una barra di 5 LED (verde → giallo → rosso) e più il buzzer suona rapido. Molto vicino (sotto i 10 cm) parte un allarme continuo e si accendono tutti i LED. Il display OLED SSD1306 mostra i cm in tempo reale a caratteri grandi, insieme a un messaggio di stato.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

