VL53L0X ToF Sensor

What it is

The VL53L0X measures distance the way a laser rangefinder does—with light instead of sound. It fires an invisible infrared laser pulse and times the round trip, giving a tight, fast, millimetre-accurate reading over I²C. Where an HC-SR04 senses a wide cone with a few-centimetre spread, the VL53L0X senses a narrow spot with precision—the sensor you reach for when “roughly how far” isn’t good enough.

How it works

The package holds two apertures: a laser emitter and a SPAD receiver (a single-photon detector). The sensor fires a pulse of 940 nm infrared light, the receiver times how long the reflection takes to return, and—since light travels at a known speed—that time converts to a distance. All of the timing happens on-chip; your microcontroller just reads the millimetre value over I²C. The trade-offs versus sound are exactly the ones weighed in ultrasonic vs time-of-flight sensors.

When to use it

Reach for a VL53L0X when a robot needs precise, narrow-beam ranging:

• Close, exact distances — judging a specific gap, wall-following at a set offset, or a precise stop.
• Small or thin obstacles — a table leg or wire the wide ultrasonic cone would smear or miss.
• Fast loops — up to 50 Hz updates for responsive control.

For cheap, forgiving “is anything ahead?” detection over a wider area, the HC-SR04 is the better-value pick—and the filtering ideas in reading the HC-SR04 apply to any ranging stream, laser included.

Wiring and gotchas

• I²C, and address-collides. Every VL53L0X shares one default address—use the XSHUT pin to bring them up one at a time and reassign addresses to run several.
• Mind the ambient light. Bright sun (lots of infrared) and dark or mirror-like surfaces shorten the usable range.
• Keep the window clean. A fingerprint or dust on the aperture scatters the beam and corrupts readings.
• Respect the near limit (~5 cm); like any ranging sensor, it has a blind zone too close to measure.

Pinout

XSHUT is the pin that makes multiple sensors possible, and it is worth understanding before you buy the second one.

Running several VL53L0X sensors

Every VL53L0X powers up at the same address, 0x29, and there are no address-select pins. Put two on a bus and both answer at once, which corrupts every transaction. The address can be changed in software, but the change is volatile — it is lost at every power cycle.

The standard solution uses XSHUT to bring them up one at a time:

#include <Wire.h>
#include <VL53L0X.h>

const int XSHUT[] = {4, 5, 6};          // one GPIO per sensor
const uint8_t ADDR[] = {0x30, 0x31, 0x32};
VL53L0X sensor[3];

void setup() {
  Wire.begin();

  // 1. Hold every sensor in reset.
  for (int i = 0; i < 3; i++) { pinMode(XSHUT[i], OUTPUT); digitalWrite(XSHUT[i], LOW); }
  delay(10);

  // 2. Release one at a time and give each a new address before the next wakes.
  for (int i = 0; i < 3; i++) {
    digitalWrite(XSHUT[i], HIGH);
    delay(10);
    sensor[i].init();
    sensor[i].setAddress(ADDR[i]);      // now it is off 0x29 and the next can boot
    sensor[i].setTimeout(500);
  }
}

Two details that catch people: the pins must be driven LOW for reset and then released, and the whole sequence has to run again after every power cycle because the addresses do not persist. Some breakouts pull XSHUT high with an onboard resistor, so simply leaving the pin floating leaves the sensor enabled.

Timing budget: the accuracy/speed/range dial

The VL53L0X has one setting that matters more than all the others, and most example code never touches it. The timing budget is how long the sensor is allowed to integrate photons for a single measurement, and it trades three things against each other:

sensor.setMeasurementTimingBudget(20000);   // microseconds

There are also long-range and high-accuracy modes that adjust the signal-rate threshold and pulse periods. The practical rule: if the sensor is not reaching far enough, spend more time before you blame the sensor. A 200 ms budget genuinely doubles the usable range over a 20 ms one.

Minimal working code

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();

  if (!sensor.init()) {
    Serial.println("VL53L0X not found");   // check wiring and XSHUT
    while (1) {}
  }
  sensor.setTimeout(500);
  sensor.setMeasurementTimingBudget(33000);
  sensor.startContinuous();
}

void loop() {
  uint16_t mm = sensor.readRangeContinuousMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.println("timeout");
  } else if (mm >= 8190) {
    Serial.println("out of range");        // 8190/8191 mean "no valid target"
  } else {
    Serial.println(mm);
  }
  delay(20);
}

8190 and 8191 are not distances. They are the sensor’s way of saying it got no usable return — either nothing is there, or the target is too dark or too far. Code that treats 8191 as 8.19 metres will behave strangely in an empty room; code that treats it as zero will emergency-stop in one.

What it cannot see

The VL53L0X fails on almost exactly the opposite set of surfaces to an ultrasonic sensor, which is the entire basis for choosing between them.

The sunlight one is worth emphasising because it is the most surprising. A VL53L0X that works perfectly indoors can be nearly useless in a sunlit conservatory, and the failure is gradual — the range shortens rather than the readings becoming obviously wrong.

Troubleshooting

VL53L0X or something else?

The VL53L1X is worth calling out specifically: it is a drop-in improvement in almost every respect, and its programmable region of interest lets you narrow the field of view in software — effectively steering the beam without moving the sensor. If you are choosing today rather than using what you have, it is usually the better buy.