En este tutorial aprenderás a usar el sensor de distancia VL53L0X (también llamado TOF0200C) con un Arduino o cualquier otro microcontrolador común (ESP32/ESP8266) para medir distancias.
El VL53L0X es un sensor de distancia Time-of-Flight (ToF) muy pequeño que utiliza luz láser infrarroja para medir la distancia a un objeto. Midiendo el tiempo que tarda la luz en reflejarse en un objeto, puede calcular distancias con alta precisión. Su tamaño compacto y bajo consumo de energía lo hacen adecuado para una amplia variedad de proyectos DIY, incluyendo robótica, reconocimiento de gestos y detección de proximidad.
Partes necesarias
Obviamente, necesitarás un sensor de distancia VL53L0X. En cuanto al microcontrolador, usé un Arduino Uno para este proyecto, pero cualquier otro Arduino o un ESP32/ESP8266 también funcionará bien. Para mostrar las distancias medidas, elegí un OLED, pero también podrías usar un LCD display.
Sensor de distancia VL53L0X
Arduino Uno
Cable USB para Arduino UNO
Juego de cables Dupont
Protoboard
Pantalla OLED
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Características del VL53L0X
El VL53L0X es un chip diminuto (4.4 x 2.4 x 1.0 mm) con dos orificios en la parte superior. Uno para el emisor de luz láser y otro para el detector de luz. La imagen a continuación muestra el chip:
El VL53L0X funciona enviando un pulso de luz láser desde el emisor, recibiendo la luz reflejada de un objeto en el detector, y basándose en el tiempo que tardó (time-of-flight) calcula la distancia al objeto. La imagen a continuación muestra los conos del emisor y del detector.
Aquí están las principales especificaciones del VL53L0X:
- Emisor VCSEL de 940 nm (luz IR, invisible al ojo)
- Tiempo de medición 30 ms
- Distancia hasta 2 m
- Funciona en escenas con poca luz y bajo contraste
- Voltaje: 2.6V – 5.5V
- Interfaz de comunicación I2C
Puedes encontrar más detalles en la hoja de datos
Esquema de aplicación del VL53L0X
El siguiente esquema de aplicación muestra el cableado externo necesario para usar el VL53L0X. Puedes ver las resistencias pull-up para la interfaz I2C que conecta el VL53L0X a un microcontrolador (host), y dos condensadores para estabilizar la alimentación.
SDA y SCL son los pines para la interfaz I2C. XSHUT es el pin de apagado, que permite apagar el sensor cuando se conecta a tierra. Esto es útil si quieres conectar varios sensores VL53L0X a la misma línea I2C. GPIO1 es un pin de interrupción que puede avisar al microcontrolador que los datos están listos.
En lugar de usar el pequeño VL53L0X directamente, es mejor conseguir una placa breakout que ya tenga la electrónica integrada y sea mucho más fácil de conectar.
Placa breakout para VL53L0X
La siguiente imagen muestra una placa breakout típica para el VL53L0X. El rectángulo blanco marca el lugar donde está ubicado el chip VL53L0X.
El pinout tiene los pines que discutimos antes. SDA, SCL para I2C, GPIO1 como señal de interrupción, XSHUT para selección del chip, y VIN y GND para la alimentación. Ten en cuenta que debes conectar a tierra XSHUT si quieres apagar el chip.
Conectando el VL53L0X
Gracias a la interfaz I2C del VL53L0X, conectarlo a un Arduino es fácil. Primero, conecta los pines SCL y SDA de la placa breakout del VL53L0X a los pines correspondientes del Arduino como se muestra abajo. Luego, conecta tierra a GND y 3.3V a VIN del VL53L0X.
La placa breakout del VL53L0X funciona con 5V o 3.3V y puedes usar cualquiera para VIN. En el cableado anterior, estoy usando 3.3V para VIN.
Ahora, escribamos algo de código para probar el funcionamiento del sensor VL53L0X.
Código para medir distancia con VL53L0X
Antes de poder medir distancias con el sensor VL53L0X, tendrás que instalar una biblioteca. Yo estoy usando la Adafruit VL53L0X Library aquí. Puedes install it via the Library Manager como de costumbre:
El instalador puede preguntarte si quieres instalar solo la biblioteca o la biblioteca con sus dependencias. Simplemente presiona «INSTALL ALL» en este caso:
Con la biblioteca instalada, ejecutemos un código de prueba simple para probar el sensor.
// Measure distance with VL53L0X sensor
// by Makerguides
#include "Adafruit_VL53L0X.h"
Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
void setup() {
Serial.begin(9600);
sensor.begin();
}
void loop() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
if(measure.RangeStatus == 4) {
Serial.println("---");
} else {
Serial.println(measure.RangeMilliMeter);
}
delay(100);
}
Como puedes ver, el código incluye la biblioteca Adafruit_VL53L0X.h y crea el objeto sensor. En la función setup() inicializamos el sensor mediante sensor.begin(). En la función loop(), necesitamos crear un objeto measure que recibe los datos de medición llamando a sensor.rangingTest(). Si el valor de RangeStatus es 4, significa que no se detectó ningún objeto y se imprime «—«. De lo contrario, obtenemos la distancia de RangeMilliMeter y la mostramos.
Si subes el código anterior a tu Arduino, deberías ver valores de distancia impresos en el Monitor Serial. Si no hay ningún objeto frente al sensor o está demasiado lejos, verás «—» impreso.
Si tienes problemas y el sensor no parece funcionar, asegúrate de que el cableado sea correcto y que uses los pines SDA y SCL correctos en tu microcontrolador. También puedes verificar el diodo láser del sensor tomando una foto con una cámara digital (teléfono móvil). Aunque la luz IR es invisible al ojo humano, la cámara puede verla y en la pantalla deberías ver el LED láser parpadeando (cada 100 ms).
Usando la biblioteca VL53L0X de Pololu
Tuve considerables dificultades para hacer que la Adafruit VL53L0X Library funcionara con código que usa la Adafruit_SSD1306 Library para mostrar las distancias en un OLED. Más sobre eso en la siguiente sección.
Aquí solo quiero darte una implementación alternativa que usa la VL53L0X Library by Pololu. Además de funcionar mejor con la pantalla OLED, también ofrece más opciones de configuración para el VL53L0X. Por ejemplo, puedes cambiar entre modo de largo o corto alcance, y entre modo lento o rápido.
Instalando la biblioteca VL53L0X de Pololu
Para instalar la VL53L0X Library by pololu, solo busca VL53L0X, encuentra la de Pololu como se muestra abajo e instálala usando el Library Manager. La imagen a continuación muestra cómo se ve una vez instalada la biblioteca:
Ejemplo de código para la biblioteca VL53L0X de Pololu
Y a continuación está el ejemplo de código que usa la biblioteca de Pololu para el VL53L0X para medir distancias:
#include "Wire.h"
#include "VL53L0X.h"
VL53L0X sensor;
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
void setup() {
Serial.begin(9600);
sensor_init(true, false);
}
void loop() {
Serial.println(get_distance());
}
Comenzamos incluyendo la Wire.h y la VL53L0X.h biblioteca y luego creamos el objeto sensor.
La función sensor_init() configura el sensor. Permite cambiar entre modo de corto o largo alcance y entre velocidad de medición alta o baja. Ten en cuenta que los modos de largo alcance y rápido son menos precisos. Las siguientes dos tablas del datasheet muestran las compensaciones entre velocidad, alcance y precisión:
La función get_distance() devuelve la distancia medida en milímetros. Si el objeto está fuera de rango, el sensor devuelve un valor de 8190. Encontré que en modo de largo alcance puedes medir hasta 2400 mm y en modo de corto alcance hasta 1300 mm. Esto fue en interiores contra una pared blanca.
En la función setup() inicializamos el sensor y en la función loop() obtenemos la distancia y la imprimimos en el Monitor Serial.
Si subes y ejecutas el código deberías ver las distancias medidas impresas en el Monitor Serial.
Ten en cuenta que la salida comienza con una distancia de 8190, indicando que no había ningún objeto lo suficientemente cerca para ser detectado. Luego apunté el sensor al techo y obtuve una distancia de unos 1700 mm y finalmente puse mi mano frente al sensor a una distancia de unos 100 mm.
En la siguiente sección vamos a añadir un OLED a nuestro circuito y luego usaremos ambas bibliotecas (Adafruit, Pololu) para medir distancias y mostrarlas.
Añadiendo un OLED para mostrar datos del VL53L0X
Como el OLED también es un dispositivo I2C, conectarlo es sencillo. Simplemente conectamos SDA y SCL a los mismos pines a los que está conectado el sensor VL53L0X. Y como el OLED funciona a 3.3V, también podemos compartir las líneas de alimentación.
La foto a continuación muestra el cableado completo en una protoboard real:
Si tienes alguna dificultad con el OLED, echa un vistazo al tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino.
Instalando la biblioteca Adafruit_SSD1306 para OLED
En las siguientes dos secciones escribiremos código para mostrar la distancia medida por el sensor VL53L0X en una pantalla OLED. En la primera sección usaremos la biblioteca de Adafruit para el VL53L0X y en la segunda usaremos la biblioteca de Pololu.
Sin embargo, antes de poder mostrar algo en el OLED necesitamos instalar otra biblioteca. En este tutorial usaremos la biblioteca Adafruit_SSD1306, que puedes instalar vía Library Manager como de costumbre. La imagen a continuación muestra la biblioteca después de completar la instalación:
Ten en cuenta que la dirección I2C para la pantalla OLED está configurada en 0x3C en oled.begin(). La mayoría de estos pequeños OLED usan esta dirección (or 0x27) pero la tuya podría ser diferente. Si no ves nada en el OLED, probablemente tenga una dirección I2C distinta y tendrás que cambiarla.
Si no sabes la dirección I2C, echa un vistazo al tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino para encontrarla. También el tutorial Use SSD1306 I2C OLED Display With Arduino te enseñará más sobre cómo usar un OLED.
Mostrando distancias medidas con la biblioteca VL53L0X de Adafruit en OLED
El código a continuación usa la biblioteca de Adafruit para el VL53L0X para leer las mediciones de distancia del sensor VL53L0X y luego mostrarlas en el OLED. Mira el código completo primero y luego analizamos sus detalles.
// Measure distance with VL53L0X sensor and show on OLED
// by Makerguides
#include "Adafruit_VL53L0X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled = Adafruit_SSD1306();
Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
oled.clearDisplay();
oled.setCursor(25, 10);
if (measure.RangeStatus == 4) {
oled.print(" -----");
} else {
oled.print(measure.RangeMilliMeter);
oled.print(" mm");
}
oled.display();
}
void setup() {
oled_init();
sensor.begin();
}
void loop() {
display();
delay(100);
}
Bibliotecas
Comenzamos incluyendo la biblioteca Adafruit_VL53L0X para el sensor VL53L0X y la Adafruit_SSD1306 Library para la pantalla OLED.
#include "Adafruit_VL53L0X.h" #include "Adafruit_SSD1306.h"
Objetos
Luego creamos los objetos sensor y oled:
Adafruit_SSD1306 oled = Adafruit_SSD1306(); Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
Función oled_init
La función oled_init() inicializa el OLED y configura el tamaño y color del texto:
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Ten en cuenta que la dirección I2C para la pantalla OLED está configurada en 0x3C en oled.begin(). La mayoría de estos pequeños OLED usan esta dirección pero la tuya podría ser diferente. Si no ves nada en el OLED, probablemente tenga una dirección I2C distinta y tendrás que cambiarla. Si no sabes la dirección I2C, echa un vistazo al tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino.
Función display
La función display() primero llama a rangingTest() para medir la distancia. Luego limpiamos la pantalla, colocamos el cursor y mostramos la distancia. Si no se pudo medir la distancia (RangeStatus == 4), mostramos «—-» para indicar que no había ningún objeto en rango:
void display() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
oled.clearDisplay();
oled.setCursor(25, 10);
if (measure.RangeStatus == 4) {
oled.print(" -----");
} else {
oled.print(measure.RangeMilliMeter);
oled.print(" mm");
}
oled.display();
}
Funciones setup y loop
En la función setup() llamamos a los inicializadores para el OLED y el sensor VL53L0X, y en la función loop() mostramos la distancia medida cada 100 ms:
void setup() {
oled_init();
sensor.begin();
}
void loop() {
display();
delay(100);
}
Problemas con la biblioteca Adafruit_VL53L0X
Al escribir el código anterior, encontré varios problemas. Primero, no pude usar mi código habitual para crear el objeto OLED:
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Segundo, no pude usar la función sprintf() para imprimir texto formateado en un buffer para mostrarlo en el OLED.
En ambos casos el código compilaba, se podía subir, pero luego el programa no funcionaba, sin mostrar mensajes de error. Sospecho que hay algún conflicto de acceso a memoria entre las bibliotecas Adafruit_SSD1306 y Adafruit_VL53L0X.
Debido a estos problemas con la biblioteca Adafruit_VL53L0X, decidí probar otra biblioteca. En la siguiente sección te muestro el código que usa la biblioteca VL53L0X de Pololu.
Mostrando distancias medidas con la biblioteca VL53L0X de Pololu en OLED
El siguiente código usa la biblioteca de Pololu para el VL53L0X para leer las mediciones de distancia del sensor VL53L0X y mostrarlas en el OLED.
#include "Wire.h"
#include "VL53L0X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL53L0X sensor;
const int maxdist = 2400;
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
int dist = get_distance();
if (dist > maxdist)
sprintf(text, " -----");
else
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
int w = map(dist, 0, maxdist, 0, 120);
oled.drawFastHLine(4, 45, w, WHITE);
oled.display();
}
void setup() {
oled_init();
sensor_init(true, false);
}
void loop() {
display();
}
Si subes y ejecutas el código deberías ver distancias en milímetros mostradas en el OLED con una barra debajo proporcional en longitud a la distancia.
Si no hay nada frente al sensor (o está a más de 2 m), la pantalla mostrará «la distancia máxima «—–» y una línea de longitud completa.
Bibliotecas
Comenzamos incluyendo las bibliotecas necesarias para el OLED y el VL53L0X. En este ejemplo de código usamos la biblioteca VL53L0X de Pololu para leer datos de distancia del sensor VL53L0X.
#include "Wire.h" #include "VL53L0X.h" #include "Adafruit_SSD1306.h"
Objetos y constantes
Luego creamos los objetos oled y sensor. Con la biblioteca VL53L0X de Pololu no tuve dificultad en crear el objeto oled de la manera habitual (oled(128, 64, &Wire, -1)), mientras que este código no funcionaba usando la biblioteca VL53L0X de Adafruit.
Adafruit_SSD1306 oled(128, 64, &Wire, -1); VL53L0X sensor; const int maxdist = 2400;
La constante maxdist especifica la distancia máxima que el código reportará en las mediciones. Más allá de eso, el código indicará que no se detectó ningún objeto.
Funciones sensor_init y get_distance
Las funciones sensor_init() y get_distance() son iguales que antes. sensor_init() inicializa el sensor VL53L0X y configura los diferentes modos de operación, mientras que get_distance() lee la distancia medida del VL53L0X.
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
Función oled_init
La función oled_init() también permanece sin cambios. Inicializa el OLED y configura el tamaño y color del texto.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Función display
La función display() obtiene la distancia medida del sensor VL53L0X. Si la distancia es mayor que maxdist, asume que no hay objeto en rango y se imprime «—–» en el OLED. De lo contrario, se imprime el valor de la distancia.
void display() {
static char text[30];
int dist = get_distance();
if (dist > maxdist)
sprintf(text, " -----");
else
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
int w = map(dist, 0, maxdist, 0, 120);
oled.drawFastHLine(4, 45, w, WHITE);
oled.display();
}
Además de la salida de texto, la función display() también dibuja una línea horizontal debajo del texto con una longitud proporcional a la distancia medida.
Funciones setup y loop
La función setup inicializa el OLED y el sensor VL53L0X. El modo del sensor se establece en largo alcance y velocidad por defecto (sensor_init(true, false)).
En la función loop() simplemente llamamos a la función display(). El loop se ejecuta a la máxima velocidad que el sensor puede entregar datos (alrededor de 30 ms a velocidad por defecto).
void setup() {
oled_init();
sensor_init(true, false);
}
void loop() {
display();
}
Y eso es todo. Ahora tienes tu propia herramienta para medir distancias
Conclusiones
En este tutorial aprendiste a usar el sensor de distancia VL53L0X con un Arduino para medir distancias y mostrarlas en un OLED.
El sensor VL53L0X es un sensor muy pequeño, rápido y de alta precisión que usa luz láser infrarroja para medir distancias. El VL53L0X es muy similar al sensor TOF10120 en dimensiones, función y características. Ambos sensores usan el método Time-of-Flight para calcular la distancia a un objeto. El VL53L0X tiene más opciones de configuración (largo alcance, velocidad rápida) y puede, en modo largo alcance, detectar objetos a una distancia ligeramente mayor (2400 mm vs 1800 mm) aunque con menor precisión.
Otros sensores de distancia infrarrojos como el GP2Y0A710K0F o el GP2Y0A21YK0F usan triangulación para determinar la distancia basándose en el ángulo de la luz IR reflejada y tienen menor alcance y precisión.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
