Componenti · 11 min di lettura

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.

CaratteristicaValore
ChipSTMicroelectronics VL53L0X
Principio di misuraTempo di volo (ToF), laser VCSEL a 940 nm, Classe 1
PortataCirca 3 cm – 1,2 m (predefinita), fino a 2 m (modalità lungo raggio, ambiente buio, bersaglio bianco)
Risoluzione1 mm
PrecisioneCirca ±3% – ±5% a seconda della modalità
Campo visivoCirca 25°
Tempo di misura20 ms – 200 ms (in base al timing budget)
AlimentazioneChip 2,6–3,5 V; la maggior parte dei moduli ha un regolatore, 3,3–5 V
CorrenteCirca 19 mA durante la misura, pochi µA in standby
InterfacciaI2C, max 400 kHz, indirizzo predefinito 0x29
PinVIN, 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.

CaratteristicaVL53L0XHC-SR04
Principio di misuraTempo di volo della luce laser (940 nm)Eco di ultrasuoni (40 kHz)
PortataCirca 3 cm – 2 mCirca 2 cm – 4 m
Cono di misuraCirca 25°, stretto e regolareCirca 15° di angolo di misura, il suono si diffonde di più
Risoluzione1 mmCirca 3 mm (in pratica ±1 cm)
CollegamentoI2C (SDA, SCL)2 pin digitali (Trig, Echo)
Più sensoriSullo stesso bus I2C con XSHUTUn pin per ogni sensore, possono sentire l'eco l'uno dell'altro
Alimentazione3,3–5 V (modulo)5 V
DimensioniCirca 25 × 13 mmCirca 45 × 20 mm
Situazioni difficiliSuperfici nere o a specchio, vetro, luce solareTessuti, 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 VL53L0XArduino UnoESP32Raspberry Pi Pico
VIN5V (oppure 3.3V)3V33V3(OUT)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
XSHUT (facoltativo)D4 (D5 per il 2° sensore)GPIO 25GP6
GPIO1 (facoltativo)Non collegatoNon collegatoNon collegato
I pin del chip VL53L0X nudo, senza modulo, sopportano al massimo 3,6 V. I moduli già pronti hanno un regolatore, quindi puoi dare 5 V a VIN, ma con l'uscita a 5 V dell'Uno non portare mai XSHUT direttamente a HIGH: per accendere il sensore rilascia il pin impostandolo come INPUT e lascia che la resistenza di pull-up del modulo faccia il resto. Inoltre l'ordine dei pin cambia da modello a modello; prima di collegare leggi sempre le scritte sulla scheda.

Passo dopo passo: la prima misura con Arduino

  1. Collega i cavi secondo la tabella: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
  2. Se sul sensore c'è una pellicola protettiva gialla o arancione, staccala con cura: la pellicola rovina completamente la misura.
  3. 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.
  4. Carica il codice qui sotto e apri il Monitor Seriale a 115200 baud.
  5. Avvicina e allontana la mano davanti al sensore e guarda i valori cambiare in millimetri e centimetri.
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}
ComandoCosa 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).
Se nel Monitor Seriale non vedi nulla, esegui prima uno scanner I2C: se il sensore è collegato bene, compare all'indirizzo 0x29. Se i valori sono sensati ma sfalsati di alcuni centimetri in modo costante, misura un bersaglio posto a 100 mm e a 500 mm con un righello e sottrai nel codice la differenza media. Nei moduli economici questo tipo di offset è frequente e questa semplice correzione migliora nettamente la misura.

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.

ProfiloTiming budgetPortata tipicaPrecisioneQuando usarlo?
PredefinitoCirca 30 ms1,2 mCirca ±3–4%Misura di uso generale
Alta precisione200 ms1,2 mSotto ±3%Misura di livello, righello di precisione
Lungo raggio33 ms2 mCirca ±4%Ambiente buio, bersaglio lontano
Alta velocità20 ms1,2 mCirca ±5%Robot veloci, rilevamento di gesti della mano
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}

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.

  1. 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).
  2. All'inizio di setup() porta tutti i pin XSHUT a LOW per spegnere tutti i sensori.
  3. Accendi il 1° sensore, avvialo con init() e assegnagli il nuovo indirizzo con setAddress(0x30).
  4. Accendi il 2° sensore, avvialo e assegnagli l'indirizzo 0x31; se ci sono altri sensori, continua con 0x32, 0x33 e così via.
  5. Avvia la misura continua su tutti i sensori e leggi ciascuno con il proprio oggetto.
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}
Se uno dei sensori viene resettato (calo di tensione, cavo allentato, disturbi del motore), il suo indirizzo torna a 0x29 e il codice non riesce più a trovarlo. Nei progetti con motori o cavi lunghi controlla regolarmente il risultato di timeoutOccurred() e, se serve, scrivi una funzione di riavvio che ripeta da capo la sequenza XSHUT. Quando scegli i nuovi indirizzi, fai attenzione a non farli coincidere con quelli di altri dispositivi sul bus, come un display OLED (0x3C) o un modulo RTC (0x68).

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.

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

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

Consigli 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

SintomoCausa probabileSoluzione
init() restituisce false, il sensore non si trovaSDA e SCL scambiati, nessuna alimentazione o pin sbagliatoCerca l'indirizzo 0x29 con uno scanner I2C; sull'Uno controlla che SDA = A4 e SCL = A5
I valori restano sempre intorno a 8190Bersaglio fuori portata, pellicola protettiva non rimossa o superficie troppo scuraStacca la pellicola, avvicina il bersaglio, prova il profilo a lungo raggio
La misura è sfalsata di qualche centimetroOffset del modulo o vetro di copertura davantiMisura a una distanza nota e sottrai la differenza nel codice; togli o cambia la copertura
I valori saltano continuamenteTiming budget breve, luce ambientale, bersaglio piccoloPorta il budget a 50–200 ms, fai la media di più misure
65535 e messaggio di timeoutCavo I2C lungo o allentato, sensore resettatoAccorcia i cavi, stringi i collegamenti, riavvia il sensore
Uno dei due sensori non risponde affattoConflitto di indirizzi o collegamento XSHUT mancanteControlla i pin XSHUT, accendi i sensori uno alla volta e assegna indirizzi diversi
All'aperto la misura risulta troppo cortaRumore infrarosso della luce solareTieni 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.

Vedi tutti i progetti
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

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

4.6(50)
82
Sensore di parcheggio con HC-SR04
AR-28Intermedio
Premium

Sensore di parcheggio con HC-SR04

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

4.8(64)
86
Misurazione della distanza tramite display LCD
AR-31Avanzato
Premium

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.

4.6(45)
59
Progetto di misurazione dell'altezza
AR-33Intermedio
Premium

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.

4.5(25)
34
Lettura della riflessione (prossimità) con TCRT5000
AR-77Intermedio
Premium

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.

4.6(33)
43
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49
ESP32 HC-SR04 Misuratore di distanza a ultrasuoni
ES-14Intermedio

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.

4.9(29)
48
Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
ES-38Avanzato
Premium

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.

14