You are here: Home» Software & Computer» Arduino & Libraries» VL53L0X Library Mod

VL53L0X Library Mod

Githubvl53l0x-arduino-mod @ Github

VL53L0X library for Arduino

This is a fork of Pololus library which incorporated the PR by jjsch-dev to enable a non blocking reading of the sensor. I'm aware that other libraries offer that also, but this one has the smallest footprint in regards to program storage usage

Summary

This is a library for the Arduino IDE that helps interface with ST's VL53L0X time-of-flight distance sensor. The library makes it simple to configure the sensor and read range data from it via I²C.

Supported platforms

This library is designed to work with the Arduino IDE versions 1.6.x or later; we have not tested it with earlier versions. This library should support any Arduino-compatible board, including the Pololu A-Star 32U4 controllers.

Getting started

Hardware

A VL53L0X carrier can be purchased from Pololu's website. Before continuing, careful reading of the product page as well as the VL53L0X datasheet is recommended.

Make the following connections between the Arduino and the VL53L0X board:

5V Arduino boards

(including Arduino Uno, Leonardo, Mega; Pololu A-Star 32U4)

Arduino   VL53L0X board
-------   -------------
     5V - VIN
    GND - GND
    SDA - SDA
    SCL - SCL

3.3V Arduino boards

(including Arduino Due)

Arduino   VL53L0X board
-------   -------------
    3V3 - VIN
    GND - GND
    SDA - SDA
    SCL - SCL

Software

If you are using version 1.6.2 or later of the Arduino software (IDE), you can use the Library Manager to install this library:

  1. In the Arduino IDE, open the "Sketch" menu, select "Include Library", then "Manage Libraries...".
  2. Search for "VL53L0X".
  3. Click the VL53L0X entry in the list.
  4. Click "Install".

If this does not work, you can manually install the library:

  1. Download the latest release archive from GitHub and decompress it.
  2. Rename the folder "vl53l0x-arduino-master" to "VL53L0X".
  3. Move the "VL53L0X" folder into the "libraries" directory inside your Arduino sketchbook directory. You can view your sketchbook location by opening the "File" menu and selecting "Preferences" in the Arduino IDE. If there is not already a "libraries" folder in that location, you should make the folder yourself.
  4. After installing the library, restart the Arduino IDE.

Examples

Several example sketches are available that show how to use the library. You can access them from the Arduino IDE by opening the "File" menu, selecting "Examples", and then selecting "VL53L0X". If you cannot find these examples, the library was probably installed incorrectly and you should retry the installation instructions above.

ST's VL53L0X API and this library

Most of the functionality of this library is based on the VL53L0X API provided by ST (STSW-IMG005), and some of the explanatory comments in the code are quoted or paraphrased from the API source code, API user manual (UM2039), and the VL53L0X datasheet. For more explanation about the library code and how it was derived from the API, see the comments in VL53L0X.cpp.

This library is intended to provide a quicker and easier way to get started using the VL53L0X with an Arduino-compatible controller, in contrast to customizing and compiling ST's API for the Arduino. The library has a more streamlined interface, as well as smaller storage and memory footprints. However, it does not implement some of the more advanced functionality available in the API (for example, calibrating the sensor to work well under a cover glass), and it has less robust error checking. For advanced applications, especially when storage and memory are less of an issue, consider using the VL53L0X API directly.

Library reference

  • uint8_t last_status
    The status of the last I²C write transmission. See the Wire.endTransmission() documentation for return values.

  • VL53L0X()
    Constructor.

  • void setBus(TwoWire * bus)
    Configures this object to use the specified I²C bus. bus should be a pointer to a TwoWire object; the default bus is Wire, which is typically the first or only I²C bus on an Arduino. If your Arduino has more than one I²C bus and you have the VL53L0X connected to the second bus, which is typically called Wire1, you can call sensor.setBus(&Wire1);.

  • TwoWire * getBus()
    Returns a pointer to the I²C bus this object is using.

  • void setAddress(uint8_t new_addr)
    Changes the I²C slave device address of the VL53L0X to the given value (7-bit).

  • uint8_t getAddress()
    Returns the I²C address this object is using.

  • bool init(bool io_2v8 = true)
    Iniitializes and configures the sensor. If the optional argument io_2v8 is true (the default if not specified), the sensor is configured for 2V8 mode (2.8 V I/O); if false, the sensor is left in 1V8 mode. The return value is a boolean indicating whether the initialization completed successfully.

  • void writeReg(uint8_t reg, uint8_t value)
    Writes an 8-bit sensor register with the given value.

    Register address constants are defined by the regAddr enumeration type in VL53L0X.h.
    Example use: sensor.writeReg(VL53L0X::SYSRANGE_START, 0x01);

  • void writeReg16Bit(uint8_t reg, uint16_t value)
    Writes a 16-bit sensor register with the given value.

  • void writeReg32Bit(uint8_t reg, uint32_t value)
    Writes a 32-bit sensor register with the given value.

  • uint8_t readReg(uint8_t reg)
    Reads an 8-bit sensor register and returns the value read.

  • uint16_t readReg16Bit(uint8_t reg)
    Reads a 16-bit sensor register and returns the value read.

  • uint32_t readReg32Bit(uint8_t reg)
    Reads a 32-bit sensor register and returns the value read.

  • void writeMulti(uint8_t reg, uint8_t const * src, uint8_t count)
    Writes an arbitrary number of bytes from the given array to the sensor, starting at the given register.

  • void readMulti(uint8_t reg, uint8_t * dst, uint8_t count)
    Reads an arbitrary number of bytes from the sensor, starting at the given register, into the given array.

  • bool setSignalRateLimit(float limit_Mcps)
    Sets the return signal rate limit to the given value in units of MCPS (mega counts per second). This is the minimum amplitude of the signal reflected from the target and received by the sensor necessary for it to report a valid reading. Setting a lower limit increases the potential range of the sensor but also increases the likelihood of getting an inaccurate reading because of reflections from objects other than the intended target. This limit is initialized to 0.25 MCPS by default. The return value is a boolean indicating whether the requested limit was valid.

  • float getSignalRateLimit()
    Returns the current return signal rate limit in MCPS.

  • bool setMeasurementTimingBudget(uint32_t budget_us)
    Sets the measurement timing budget to the given value in microseconds. This is the time allowed for one range measurement; a longer timing budget allows for more accurate measurements. The default budget is about 33000 microseconds, or 33 ms; the minimum is 20 ms. The return value is a boolean indicating whether the requested budget was valid.

  • uint32_t getMeasurementTimingBudget()
    Returns the current measurement timing budget in microseconds.

  • bool setVcselPulsePeriod(vcselPeriodType type, uint8_t period_pclks) Sets the VCSEL (vertical cavity surface emitting laser) pulse period for the given period type (VL53L0X::VcselPeriodPreRange or VL53L0X::VcselPeriodFinalRange) to the given value (in PCLKs). Longer periods increase the potential range of the sensor. Valid values are (even numbers only):

    Pre: 12 to 18 (initialized to 14 by default)
    Final: 8 to 14 (initialized to 10 by default)

    The return value is a boolean indicating whether the requested period was valid.

  • uint8_t getVcselPulsePeriod(vcselPeriodType type)
    Returns the current VCSEL pulse period for the given period type.

  • void startContinuous(uint32_t period_ms = 0)
    Starts continuous ranging measurements. If the optional argument period_ms is 0 (the default if not specified), continuous back-to-back mode is used (the sensor takes measurements as often as possible); if it is nonzero, continuous timed mode is used, with the specified inter-measurement period in milliseconds determining how often the sensor takes a measurement.

  • void stopContinuous()
    Stops continuous mode.

  • bool VL53L0X::readRangeNoBlocking(uint16_t& range)
    Returns true if measurement is completed. Range of 65535 indicates timeout.

  • uint16_t readRangeContinuousMillimeters()
    Returns a range reading in millimeters when continuous mode is active.

  • uint16_t readRangeSingleMillimeters()
    Performs a single-shot ranging measurement and returns the reading in millimeters.

  • void setTimeout(uint16_t timeout)
    Sets a timeout period in milliseconds after which read operations will abort if the sensor is not ready. A value of 0 disables the timeout.

  • uint16_t getTimeout()
    Returns the current timeout period setting.

  • bool timeoutOccurred()
    Indicates whether a read timeout has occurred since the last call to timeoutOccurred().

Version history

  • 1.0.0 (2023-05-07): For into new repo, PR to enable non blocking reading
  • 1.3.1 (2022-04-05): Explicitly cast Wire.write() arguments to uint8_t. Removed 20ms hard limit for timing budget to match API 1.0.4.
  • 1.3.0 (2020-09-24): Added support for alternative I²C buses (thanks KurtE).
  • 1.2.0 (2019-10-31): Incorporated some updates from ST's VL53L0X API version 1.0.2 (this library was originally based on API version 1.0.0).
  • 1.1.0 (2019-10-29): Improved init() and added a check for its return value in examples; fixed a few other issues.
  • 1.0.2 (2017-06-27): Fixed a typo in a register modification in getSpadInfo() (thanks @tridge).
  • 1.0.1 (2016-12-08): Fixed type error in readReg32Bit().
  • 1.0.0 (2016-08-12): Original release.