ToF Sensor Module VL53L5CX, 8x8 zone, I2C, 3–5 VDC

The VL53L5CX sensor module is a Time-of-Flight (ToF) distance camera that splits its field of view into a grid of up to 8x8 zones and returns the distance measured in each zone at the same time, not just a single value like classic distance sensors.

It is useful in obstacle detection projects for mobile robots, counting people at a door, gesture control, automatically stopping a machine when a hand gets close, or simple room mapping, wherever a single distance reading is not enough.

How it works:

The sensor emits pulses of invisible laser light with a 940 nm VCSEL emitter and measures how long it takes the light to reach the object and return to the SPAD photodetector array inside the chip.

The basic principle of any ToF sensor is that the distance equals the speed of light multiplied by the time of flight and divided by two, that is d = (c x t) / 2, where c is the speed of light, approximately 3 x 10 to the power of 8 meters per second, and t is the measured round-trip time.

In the case of the VL53L5CX this calculation is done internally, by the sensor's own electronics, and the result arrives already processed over I2C, in millimeters, for each of the up to 64 zones, at a rate of up to 60 Hz.

The sensor can work in 4x4 zone resolution, for simple and fast applications, or 8x8 zones, for more detail of the scene. The maximum useful distance is approximately 4 meters, with a typical accuracy of around 5 percent of the measured distance, depending on the target's reflectance and the ambient light conditions.

What you need:

• 1 x ToF Sensor Module VL53L5CX, 8x8 zone, I2C, 3–5 VDC
• 1 x Placa dezvoltare Uno R3 cu Wifi ESP8266, compatibila Arduino
• 1 x 40 Fire Dupont 20cm, Tata-Mama
• 1 x Breadboard 830 puncte MB-102

Wiring:

The module is powered on the VIN pin with a voltage in the 3 - 5 VDC range, so it can be connected directly to the 5 V output of an Arduino Uno, without an additional level converter, since the board already has the regulator and the logic level adaptation needed for SDA and SCL. The LPn and INT pins are optional for a basic connection, but we use them in this tutorial to show how to control the sensor's power-up and how to read the interrupt state.

Libraries:

From the Library Manager, install the SparkFun VL53L5CX Arduino Library, author SparkFun Electronics, minimum version 1.0.3, searching for this exact name. The Wire library for I2C communication is already included in the Arduino IDE and does not need to be installed separately.

The code:

The following program initializes the sensor, sets the resolution to 8x8 zones and prints the grid of distances read in each frame to the serial monitor.

/*
  VL53L5CX 8x8 Multizone Time-of-Flight Sensor - Basic Reading Example
  Board: Arduino Uno
  Library: SparkFun VL53L5CX Arduino Library (by SparkFun Electronics)
  This sketch initializes the VL53L5CX sensor over I2C, sets the
  resolution to 8x8 zones and continuously prints the distance grid
  (in millimeters) to the Serial Monitor.
*/
#include <Wire.h>
#include <SparkFun_VL53L5CX_Library.h>
// Pins used to control the sensor from the Arduino Uno
const int LPN_PIN = 3; // Low power / enable pin, HIGH = sensor enabled
const int INT_PIN = 2; // Interrupt output pin from the sensor
SparkFun_VL53L5CX myImager;
VL53L5CX_ResultsData measurementData; // Holds one frame of ranging data
int imageResolution = 0; // Current resolution reported by the sensor (16 or 64)
int imageWidth = 0;      // Grid width used only for pretty printing
void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("VL53L5CX 8x8 Zone Distance Example");
  // Configure control pins
  pinMode(LPN_PIN, OUTPUT);
  digitalWrite(LPN_PIN, HIGH); // Enable the sensor (LPn HIGH = normal operation)
  pinMode(INT_PIN, INPUT_PULLUP);
  Wire.begin();
  Wire.setClock(400000); // Optional, use 400kHz I2C for faster frame transfer
  Serial.println("Initializing sensor, this can take up to 10 seconds...");
  if (myImager.begin() == false)
  {
    Serial.println("Sensor not found - check wiring and LPn pin. Freezing.");
    while (1)
      ;
  }
  myImager.setResolution(8 * 8); // Enable all 64 zones
  imageResolution = myImager.getResolution(); // Confirm resolution (16 or 64)
  imageWidth = sqrt(imageResolution);         // 4 or 8
  myImager.startRanging();
  Serial.println("Sensor ready, starting measurements.");
}
void loop()
{
  // Just for demonstration, read the interrupt pin state
  bool interruptActive = (digitalRead(INT_PIN) == LOW);
  if (myImager.isDataReady())
  {
    if (myImager.getRangingData(&measurementData))
    {
      Serial.print("Interrupt active: ");
      Serial.println(interruptActive ? "yes" : "no");
      // Print the distance grid, row by row
      for (int row = 0; row < imageWidth; row++)
      {
        for (int col = 0; col < imageWidth; col++)
        {
          int index = row * imageWidth + col;
          Serial.print(measurementData.distance_mm[index]);
          Serial.print("\t");
        }
        Serial.println();
      }
      Serial.println();
    }
  }
  delay(50); // Small delay between polling cycles
}

How the code works:

At the beginning of the program the LPN_PIN and INT_PIN pins are defined, the myImager object is created from the SparkFun_VL53L5CX class, along with the measurementData structure, where the library will put the data read from the sensor. The imageResolution and imageWidth variables hold the current resolution and the side length of the grid for neat output.

In the setup function, serial communication is started at 115200 baud, LPN_PIN is configured as an output and set to HIGH to enable the sensor, and INT_PIN is configured as an input with the internal pull-up. After Wire.begin, myImager.begin is called, which initializes the sensor and loads the internal firmware. Then myImager.setResolution(8 * 8) enables all 64 zones and myImager.startRanging() starts continuous measurements.

In the loop function, the state of INT_PIN is checked first, only to show that the sensor is actively signaling new data. Then myImager.isDataReady() is used to know when a new frame is ready, and myImager.getRangingData(&measurementData) brings the distance values in mm into the measurementData.distance_mm array, which the program goes through line by line to print the grid on the serial monitor.

Result:

Open the serial monitor at 115200 baud. After uploading the code and after the sensor initializes, you will periodically see an 8x8 grid of values, each representing the distance in millimeters measured in that zone of the field of view.

VL53L5CX 8x8 Zone Distance Example
Initializing sensor, this can take up to 10 seconds...
Sensor ready, starting measurements.
Interrupt active: no
512    498    505    511    620    615    609    598
520    501    499    507    611    602    598    590
530    510    495    500    600    590    585    580
545    522    501    498    588    579    570    565
560    535    510    495    575    566    560    552
578    548    520    500    562    555    548    540
595    562    530    505    550    542    535    528
610    578    540    512    540    532    525    518

Common problems:

If the serial monitor shows a message that the sensor was not found, first check the SDA and SCL connections, since wires swapped between them are the most common cause, and make sure LPn is HIGH, not floating or tied to ground.

If the displayed values are always 0 or very large and unstable, check whether you called myImager.startRanging() after setting the resolution and whether you leave a small delay between readings. A loop function that runs too fast without checking isDataReady may read partial frames.

If the module works correctly at first power-up but freezes after a while, check the power supply. A VIN wire that is too thin or an unstable source can cause sensor resets, especially when there are several I2C modules on the same bus.

If you use several VL53L5CX sensors on the same I2C bus and only one responds, keep LPn LOW on all sensors except one, change its I2C address in the code, then enable the next sensor one at a time, each one needing a unique address.

If the distances read differ from a measurement made with a tape measure, keep in mind that the sensor reports the distance perpendicular to the target surface, not the straight-line distance to an angled point. Very reflective or very dark surfaces can also reduce the useful range.

Limitations and tips:

The sensor measures useful distances of up to approximately 4 meters, with a typical accuracy of around 5 percent of the distance, which drops in strong direct sunlight on the target or on the lens.

The 60 Hz rate is a theoretical maximum available mainly at 4x4 resolution. At 8x8 zones the processing time per frame is longer, so for fast applications choose 4x4 resolution if you do not need fine scene detail.

The protective optical cover must be kept clean, since dust or fingerprints on it can introduce measurement errors or reduce the sensor's range.

Starting from this basic setup you can build a multi-zone presence detector, a simple obstacle avoidance system for a mobile robot, or a people counting application for people passing through a doorway, using the 64-zone grid to distinguish several targets in the same field of view.