VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)

El VL53L0X es un producto novedoso basado en el sistema FlightSense de la empresa ST Microelectronics. Es una tecnología innovadora que permite medir distancia con independencia de la reflectividad del objetivo.

En lugar de calcular la distancia midiendo la cantidad de luz reflejada desde el objeto (en lo que influye significativamente el color y tipo de superficie), el VL53L0X mide con precisión el tiempo que tarda la luz en viajar desde el objeto más cercano y volver reflejada hasta el sensor (un proceso llamado Time-of-Fly, o Tiempo de vuelo).

Debido a que utiliza una fuente de luz con un haz muy estrecho, es bueno para determinar la distancia de solamente la superficie que está directamente delante. A diferencia de los sonares ultrasónicos que hacen rebotar sus ondas de sonido, en este caso el «cono» de la detección es muy estrecho. A diferencia de los sensores de distancia IR que intentan medir la cantidad de luz que regresa, el VL53L0x es mucho más preciso y no tiene problemas de linealidad o «imágenes dobles», en las que no se puede saber si un objeto está muy lejos o muy cerca.

Puede medir distancia con un alcance de hasta 2 m.

El control del procesador y la lectura de los resultados se realizan por medio de una interfaz I2C.

Características clave

Emisor infrarrojo: 940 nm
Distancia: hasta 2000 mm
Dirección I2C: Programable
Fuente de luz VCSEL (Vertical-cavity surface-emitting laser = Láser de emisión de superficie de cavidad vertical)
Sensor de rango con avanzado microcontrolador
El chip mide sólo 4,4 x 2,4 x 1,0 mm
Medición de distancia rápida y precisa
Mide rango absoluto hasta 2 m.
El rango reportado es independiente de la reflectividad del objetivo
Compensación óptica cruzada integrada avanzada para simplificar la selección del vidrio de cobertura
Seguro para el ojo humano
Dispositivo láser de clase 1 que cumple con la última norma IEC 60825-1: 2014 – 3ª edición
Fácil integración por el sistema de montaje de soldadura del chip
No tiene óptica adicional
Fuente de alimentación individual
Regulador de voltaje integrado en la plaqueta
Interfaz I2C para control de dispositivos y transferencia de datos
Pines de entrada salida de uso general Xshutdown (para reinicio) e Interrupt (interrupción)
Dirección I2C programable

Conexión con Arduino

VCC (en algunos fabricantes VIN) es la fuente de alimentación, el módulo acepta de 3 a 5V de alimentación. Use el mismo voltaje en el que se basa la lógica del microcontrolador. Para la mayoría de los Arduinos es 5V.
Conecte GND a tierra/alimentación común (marcado también GND en el Arduino).
Conecte el pin SCL al pin SCL (señal de reloj I2C en su Arduino. En un Arduino UNO también se conoce como pin A5, aunque está disponible del lado de los pines digitales. En un Mega es el digital 21 y en un Leonardo es el digital 3.
Conecte el pin SDA al pin SDA (datos I2C) en su Arduino. En un Arduino UNO también se conoce como pin A4, en un Mega es el digital 20 y en un Leonardo es el digital 2.

Los pines adicionales son:

GPIO1: este es un pin que usa el sensor para indicar que están listos los datos. Es útil para cuando se realiza una detección continua. Tenga en cuenta que no hay ajuste de nivel en este pin, es posible que no se pueda leer el voltaje de nivel lógico de 2,8V en un microcontrolador de 5V (podríamos en un Arduino UNO, pero no es seguro). La biblioteca de Adafruit no hace uso de este pin, pero está ahí para usuarios avanzados.

XSHUT – es el pin de apagado/reinicio para el sensor. Por defecto es alto. Hay un diodo de cambio de nivel para que se pueda usar la lógica de 3,3 – 5 V en este pin. Cuando el pin va a nivel bajo, el sensor entra en modo de apagado.

Abra el IDE de Arduino. Mantenga siempre actualizado a la última versión.

Abra en el menú HERRAMIENTAS la opción ADMINISTRAR BIBLIOTECAS.

Búsqueda y carga en el IDE Arduino de la biblioteca del VL53L0X

La elección ADMINISTRAR BIBLIOTECAS abrirá la siguiente ventana del Gestor de Bibliotecas:

En esa ventana tenemos, en la parte superior derecha una ventana de editor con la leyenda «Filtre su búsqueda…«, donde debemos escribir el nombre del dispositivo:

Esta búsqueda nos ofrece varias bibliotecas. Para Arduino UNO y relacionados tenemos la de Adafruit y la de Pololu. En artículos en la web recomiendan la de Pololu, porque es más simple que la del otro fabricante. De todos modos, podemos instalar ambas. No hay conflictos en esto. El botón que dice «Instalar» aparece cuando se coloca el puntero del mouse en la biblioteca elegida. Si no aparece, es porque ya está instalada. Si no fuese así, recurra a el enlace «More info» y descargue la biblioteca desde el sitio GitHub, en formato ZIP, y proceda a instalarla con las instrucciones que ofrecen AQUÍ.

El gestor nos indicará que la biblioteca está lista con un cartel remarcado «INSTALLED».

Las bibliotecas quedan listas para ser utilizadas. La que corresponde a Pololu se llama VL53L0X, mientras que la de Adafruit se llama igual y está dentro de todas las bibliotecas de este fabricante, que llevan su nombre comercial como prefijo.

Dirección para el bus I2C

La dirección por defecto de I2C es 0x29, pero recuerde que es posible programar esta dirección en el VL53L0X. Con la biblioteca Adafruit, hay dos maneras de establecer la nueva dirección. Durante la inicialización, en lugar de llamar a lox.begin(), se llama a lox.begin(0x30) para establecer la dirección en 0x30. O se puede, más adelante, llamar a lox.setAddress(0x30) en cualquier momento. Es importante realizar esta operación con una sola placa VL53L0X conectada al bus I2C, o todas quedarán cambiadas.

Programas de prueba

«Continuous», de Pololu
(Este ejemplo muestra cómo usar el «modo continuo» para tomar mediciones de distancia con el VL53L0X. La información se muestra en la pantalla emergente del Monitor Serie, que debe estar fijado en 9600 baudios.)

/* This example shows how to use continuous mode to take
range measurements with the VL53L0X. It is based on
vl53l0x_ContinuousRanging_Example.c from the VL53L0X API.

The range readings are in units of mm. */

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

VL53L0X sensor;

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

  sensor.init();
  sensor.setTimeout(500);

  // Start continuous back-to-back mode (take readings as
  // fast as possible).  To use continuous timed mode
  // instead, provide a desired inter-measurement period in
  // ms (e.g. sensor.startContinuous(100)).
  sensor.startContinuous();
}

void loop()
{
  Serial.print(sensor.readRangeContinuousMillimeters());
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

  Serial.println();
}

/* This example shows how to use continuous mode to take

range measurements with the VL53L0X. It is based on

vl53l0x_ContinuousRanging_Example.c from the VL53L0X API.

The range readings are in units of mm. */

#include <Wire.h>

#include <VL53L0X.h>

VL53L0X sensor;

void setup()

{

Serial.begin(9600);

Wire.begin();

sensor.init();

sensor.setTimeout(500);

// Start continuous back-to-back mode (take readings as

// fast as possible). To use continuous timed mode

// instead, provide a desired inter-measurement period in

// ms (e.g. sensor.startContinuous(100)).

sensor.startContinuous();

}

void loop()

{

Serial.print(sensor.readRangeContinuousMillimeters());

if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

Serial.println();

}

Y el que sigue es un ejemplo con la biblioteca de Adafruit, con los comentarios traducidos. Siempre con la misma conexión del diagrama de arriba.

#include "Adafruit_VL53L0X.h"
 
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
 
void setup() {
  Serial.begin(9600);
 
  // Iniciar sensor
  Serial.println("VL53L0X test");
  if (!lox.begin()) {
    Serial.println(F("Error al iniciar VL53L0X"));
    while(1);
  }
}
 
 
void loop() {
  VL53L0X_RangingMeasurementData_t measure;
    
  Serial.print("Leyendo sensor... ");
  lox.rangingTest(&measure, false); // si se pasa true como parametro, muestra por puerto serie datos de debug
 
  if (measure.RangeStatus != 4)
  {
    Serial.print("Distancia (mm): ");
   Serial.println(measure.RangeMilliMeter);
  } 
  else
  {
    Serial.println("  Fuera de rango ");
  }
    
  delay(100);
}

#include "Adafruit_VL53L0X.h"

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

void setup() {

Serial.begin(9600);

// Iniciar sensor

Serial.println("VL53L0X test");

if (!lox.begin()) {

Serial.println(F("Error al iniciar VL53L0X"));

while(1);

}

void loop() {

VL53L0X_RangingMeasurementData_t measure;

Serial.print("Leyendo sensor... ");

lox.rangingTest(&measure, false); // si se pasa true como parametro, muestra por puerto serie datos de debug

if (measure.RangeStatus != 4)

{

Serial.print("Distancia (mm): ");

Serial.println(measure.RangeMilliMeter);

}

else

{

Serial.println(" Fuera de rango ");

}

delay(100);

}

En el programa que sigue, para reducir el ruido de la medición se muestra el promedio de varias medidas. Las líneas comentadas muestran los distintos modos de funcionamiento.

/* ################## Sensor VL53L0X #############################
* Filename: VL53L0X_Ej1.ino
* Descripción: Test Medidor Distancia Laser
* Autor: Jose Mª Morales
* Revisión: 12-04-2017
* Probado: ARDUINO UNO r3 - IDE 1.8.2 (Windows7)
* Web: www.playbyte.es/electronica/
* Licencia: Creative Commons Share-Alike 3.0
* http://creativecommons.org/licenses/by-sa/3.0/deed.es_ES
* ##############################################################
*/

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

int n_Samples = 5; // numero de muestras para promediar

//#define LONG_RANGE // Aumenta sensibilidad, +rango, -precision
//#define HIGH_SPEED // Mayor velocidad, menor precision
#define HIGH_ACCURACY // Alta precision, menor velocidad


void setup() {

 Serial.begin(9600);
 Wire.begin();

 sensor.init();
 sensor.setTimeout(500);

//###### Parametros Medida simple ##########
#if defined LONG_RANGE
// Limite de la tasa de retorno (por defecto 0.25 MCPS)
 sensor.setSignalRateLimit(0.1);
// Periodo de pulso laser (por defecto 14 y 10 PCLKs)
 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
#endif

#if defined HIGH_SPEED
// reduce tiempo estimado a 20 ms (por defecto 33 ms)
 sensor.setMeasurementTimingBudget(20000);
#elif defined HIGH_ACCURACY
// incrementa tiempo estimado a 200 ms
 sensor.setMeasurementTimingBudget(200000);
#endif
}


void loop() {

 float DISTANCIA = getDISTANCIA (n_Samples);
 
 if (sensor.timeoutOccurred()) {
 Serial.println(" TIME OUT");
 }else {
 if (DISTANCIA< 2) Serial.println("Fuera de Rango (d < 2 cm)");
 else if (DISTANCIA>220) Serial.println("Fuera de Rango (d > 2 m)");
 else { 
 Serial.print(DISTANCIA, 1); // distancia en cm y 1 decimal
 Serial.println(" cm"); 
 }
 }
 delay (300);
}


float getDISTANCIA(int n) { // hacemos "n" mediciones

 float SUMA_n = 0;
 for (int i = 0; i < n; i++) { 
 SUMA_n += sensor.readRangeSingleMillimeters();
 }
 return( SUMA_n /n /10); // Promedio en centimetros
}

/* ################## Sensor VL53L0X #############################

* Filename: VL53L0X_Ej1.ino

* Descripción: Test Medidor Distancia Laser

* Autor: Jose Mª Morales

* Revisión: 12-04-2017

* Probado: ARDUINO UNO r3 - IDE 1.8.2 (Windows7)

* Web: www.playbyte.es/electronica/

* Licencia: Creative Commons Share-Alike 3.0

* http://creativecommons.org/licenses/by-sa/3.0/deed.es_ES

* ##############################################################

#include <Wire.h>

#include <VL53L0X.h>

VL53L0X sensor;

int n_Samples = 5; // numero de muestras para promediar

//#define LONG_RANGE // Aumenta sensibilidad, +rango, -precision

//#define HIGH_SPEED // Mayor velocidad, menor precision

#define HIGH_ACCURACY // Alta precision, menor velocidad

void setup() {

Serial.begin(9600);

Wire.begin();

sensor.init();

sensor.setTimeout(500);

//###### Parametros Medida simple ##########

#if defined LONG_RANGE

// Limite de la tasa de retorno (por defecto 0.25 MCPS)

sensor.setSignalRateLimit(0.1);

// Periodo de pulso laser (por defecto 14 y 10 PCLKs)

sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);

sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);

#endif

#if defined HIGH_SPEED

// reduce tiempo estimado a 20 ms (por defecto 33 ms)

sensor.setMeasurementTimingBudget(20000);

#elif defined HIGH_ACCURACY

// incrementa tiempo estimado a 200 ms

sensor.setMeasurementTimingBudget(200000);

#endif

}

void loop() {

float DISTANCIA = getDISTANCIA (n_Samples);

if (sensor.timeoutOccurred()) {

Serial.println(" TIME OUT");

}else {

if (DISTANCIA< 2) Serial.println("Fuera de Rango (d < 2 cm)");

else if (DISTANCIA>220) Serial.println("Fuera de Rango (d > 2 m)");

else {

Serial.print(DISTANCIA, 1); // distancia en cm y 1 decimal

Serial.println(" cm");

}

delay (300);

}

float getDISTANCIA(int n) { // hacemos "n" mediciones

float SUMA_n = 0;

for (int i = 0; i < n; i++) {

SUMA_n += sensor.readRangeSingleMillimeters();

}

return( SUMA_n /n /10); // Promedio en centimetros

}

Robots Didácticos

Robótica, Automatización, control industrial, microcontroladores, electrónica digital

VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)

1 comentario en “VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)”