Componentes · 11 min de lectura

Sensor de distancia láser VL53L0X con Arduino: mide hasta 2 m

¿Cómo usar el sensor láser VL53L0X con Arduino, ESP32 y Pico? Conexión I2C, modos de medición, varios sensores con XSHUT y comparación con el HC-SR04.

El VL53L0X es un sensor láser de distancia ToF (Time of Flight, tiempo de vuelo), una de las formas más pequeñas y precisas de medir distancias con Arduino. Este chip de STMicroelectronics emite una luz láser invisible de 940 nm, mide cuánto tarda en rebotar en el objetivo y devuelve el resultado directamente en milímetros. El módulo, del tamaño de un sello, se conecta solo con los dos cables de datos del I2C; en modo normal mide hasta 1,2 metros y en modo largo alcance hasta 2 metros.

En este artículo aprenderás paso a paso cómo funciona el VL53L0X, cómo conectarlo a Arduino Uno, ESP32 y Raspberry Pi Pico, qué diferencia hay entre los cuatro perfiles de medición y cómo conectar varios sensores al mismo bus I2C con el pin XSHUT. También lo compararemos con el popular sensor de distancia HC-SR04 para que veas cuál conviene en cada proyecto.

¿Qué es el VL53L0X y cómo funciona?

Dentro del sensor hay dos piezas principales: un VCSEL (diodo láser de emisión vertical) que emite la luz y una matriz de SPAD (diodos de avalancha de un solo fotón) capaz de detectar hasta un único fotón. El VCSEL envía pulsos de luz muy cortos, los SPAD capturan los fotones que vuelven y el chip mide el tiempo transcurrido. La distancia sale de una fórmula sencilla: d = c × t / 2. Aquí c es la velocidad de la luz (unos 300.000 km/s) y se divide entre dos porque la luz recorre el camino dos veces. Para un objeto a 1 metro, el tiempo de ida y vuelta es de solo 6,67 nanosegundos. Como medir un tiempo tan corto con un solo pulso es casi imposible, el chip acumula la estadística de miles de pulsos y hace el cálculo internamente; tú solo lees el resultado.

El láser es de Clase 1; en uso normal no es peligroso para los ojos y, al ser infrarrojo, no se ve a simple vista. El ángulo de visión del sensor es de unos 25 grados, es decir, la medición se hace dentro de un cono estrecho. Así puedes apuntar mucho mejor que con la onda de sonido ancha del HC-SR04: puedes medir un objeto pequeño en el borde de la mesa sin que te moleste la pared de al lado. Como el resultado depende de la velocidad de la luz, apenas le afectan la temperatura ni la humedad.

CaracterísticaValor
ChipSTMicroelectronics VL53L0X
Principio de mediciónTiempo de vuelo (ToF), láser VCSEL de 940 nm, Clase 1
AlcanceAprox. 3 cm – 1,2 m (por defecto), hasta 2 m (modo largo alcance, ambiente oscuro, objetivo blanco)
Resolución1 mm
PrecisiónAprox. ±3 % – ±5 % según el modo
Ángulo de visiónAprox. 25°
Tiempo de medición20 ms – 200 ms (según el presupuesto de tiempo)
AlimentaciónChip 2,6–3,5 V; la mayoría de módulos con regulador, 3,3–5 V
CorrienteAprox. 19 mA midiendo, unos pocos µA en espera
InterfazI2C, máx. 400 kHz, dirección por defecto 0x29
PinesVIN, GND, SCL, SDA, GPIO1 (interrupción), XSHUT (apagado)

¿VL53L0X o HC-SR04?

Los dos sensores miden distancias, pero su física es totalmente distinta. El HC-SR04 emite una onda de sonido de 40 kHz y escucha el eco; como el sonido viaja a unos 343 m/s, medir el tiempo es fácil y el alcance llega a 4 metros. Pero su cono ancho detecta también objetos laterales, y la tela, la espuma y las superficies inclinadas absorben o desvían el sonido. El VL53L0X mide con luz: es muy pequeño, apunta con un ángulo estrecho, es más estable a distancias cortas y, gracias al I2C, permite compartir un solo bus entre muchos sensores. En cambio, la luz solar directa, las superficies muy oscuras o brillantes como un espejo y el cristal le cuestan. Resumen: si necesitas una medición pequeña y rápida por debajo de 2 metros, el VL53L0X; si necesitas más alcance o uso en exteriores, el HC-SR04. Para otras opciones, mira la comparativa de sensores de distancia.

CaracterísticaVL53L0XHC-SR04
Principio de mediciónTiempo de vuelo de luz láser (940 nm)Eco de ultrasonidos (40 kHz)
AlcanceAprox. 3 cm – 2 mAprox. 2 cm – 4 m
Cono de mediciónAprox. 25°, estrecho y regularAprox. 15° de ángulo de medición, el sonido se abre más
Resolución1 mmAprox. 3 mm (en la práctica ±1 cm)
ConexiónI2C (SDA, SCL)2 pines digitales (Trig, Echo)
Varios sensoresEn el mismo bus I2C con XSHUTUn pin por sensor; pueden oír el eco del otro
Alimentación3,3–5 V (módulo)5 V
TamañoAprox. 25 × 13 mmAprox. 45 × 20 mm
Situaciones difícilesSuperficie negra o de espejo, cristal, luz solarTela, espuma, superficie inclinada, ambiente ruidoso

Conexión del VL53L0X: Arduino Uno, ESP32 y Pico

La mayoría de módulos del mercado (GY-530, GY-VL53L0XV2, etc.) llevan un regulador de 2,8 V, resistencias pull-up para las líneas I2C y una pull-up para XSHUT. Así puedes conectar el módulo al pin 5V del Uno o al pin 3V3 del ESP32 y de la Pico. La mayoría de módulos baratos se comunican sin problemas con el Uno; aun así, en proyectos que van a funcionar mucho tiempo y quieras proteger las líneas I2C, puedes usar un conversor de nivel lógico. Si te interesa cómo funciona el bus, echa un vistazo a qué es I2C. El pin GPIO1 es una salida de interrupción que avisa cuando termina la medición; para un uso básico no hace falta conectarlo.

Pin del VL53L0XArduino UnoESP32Raspberry Pi Pico
VIN5V (o 3.3V)3V33V3(OUT)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
XSHUT (opcional)D4 (D5 en el 2.º sensor)GPIO 25GP6
GPIO1 (opcional)No se conectaNo se conectaNo se conecta
Los pines del chip VL53L0X desnudo, sin módulo, aguantan como máximo 3,6 V. En los módulos ya hechos hay regulador, así que puedes dar 5 V a VIN, pero no pongas el pin XSHUT directamente en HIGH con la salida de 5 V del Uno: para encender el sensor, deja el pin como INPUT y la resistencia pull-up del módulo se encarga del resto. Además, el orden de los pines cambia de un modelo a otro; lee siempre las serigrafías de la placa antes de conectar.

Paso a paso: primera medición con Arduino

  1. Conecta los cables según la tabla: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
  2. Si el sensor tiene una cinta protectora amarilla o naranja, quítala con cuidado; la cinta estropea por completo la medición.
  3. En el IDE de Arduino abre el Gestor de bibliotecas, escribe VL53L0X e instala la biblioteca de Pololu. La Adafruit_VL53L0X también funciona, pero incluye la API completa de ST y ocupa mucha más memoria en el Uno. Si tienes problemas con la instalación, mira cómo añadir bibliotecas en Arduino.
  4. Sube el código siguiente y abre el Monitor Serie a 115200 baudios.
  5. Acerca y aleja la mano del sensor y comprueba cómo cambian los valores en milímetros y centímetros.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6void setup() {
7  Serial.begin(115200);
8  Wire.begin();                          // Uno: SDA=A4, SCL=A5
9  sensor.setTimeout(500);                // 500 ms cevap bekle / wait 500 ms for a reply
10  if (!sensor.init()) {
11    Serial.println(F("VL53L0X bulunamadi / not found"));
12    while (1) {}
13  }
14  sensor.startContinuous();              // sürekli ölçüm / continuous ranging
15}
16
17void loop() {
18  uint16_t mm = sensor.readRangeContinuousMillimeters();
19  if (sensor.timeoutOccurred()) {
20    Serial.println(F("Zaman asimi / Timeout"));
21    return;
22  }
23  if (mm > 2000) {                       // geçerli yansıma yok / no valid return
24    Serial.println(F("Menzil disi / Out of range"));
25  } else {
26    Serial.print(mm);
27    Serial.print(F(" mm = "));
28    Serial.print(mm / 10.0, 1);
29    Serial.println(F(" cm"));
30  }
31  delay(100);
32}
Comando¿Qué hace?
sensor.setTimeout(500)Si el sensor no responde en 500 ms, deja de esperar; el código no se queda colgado para siempre.
sensor.init()Carga la secuencia de ajustes de ST y hace la calibración SPAD; si devuelve false, el sensor no se ha encontrado en el bus I2C.
sensor.startContinuous()Hace que el sensor mida de forma continua, una medición tras otra.
sensor.readRangeContinuousMillimeters()Devuelve la última medición en milímetros; si no hay objetivo, llega un valor cercano a 8190.
sensor.timeoutOccurred()Devuelve true si la última lectura agotó el tiempo (en ese caso el valor es 65535).
Si no ves nada en el Monitor Serie, ejecuta primero un escáner I2C: si el sensor está bien conectado, aparecerá en la dirección 0x29. Si los valores son lógicos pero van desviados unos centímetros de forma constante, mide con una regla el objetivo a 100 mm y a 500 mm y resta la diferencia media en el código. Este tipo de desfase es común en los módulos baratos y esta sencilla corrección mejora notablemente la medición.

Modos de medición del VL53L0X

En el VL53L0X la calidad de la medición depende de tres ajustes: el presupuesto de tiempo (el tiempo dedicado a cada medición), el límite de tasa de señal (el reflejo más débil que se considera válido) y el periodo de pulso del VCSEL (la duración de los pulsos láser). Cuanto mayor es el presupuesto, más fotones recoge el sensor y más estable es la medición, pero más lenta; un presupuesto de 200 ms son solo 5 mediciones por segundo. Bajar el límite de señal de 0,25 MCPS por defecto a 0,1 MCPS amplía el alcance al aceptar reflejos débiles, pero aumenta el riesgo de lecturas erróneas. Subir los periodos de pulso de 14 y 10 por defecto a 18 y 14 envía más energía al objetivo lejano. ST define estos ajustes como cuatro perfiles predefinidos; en el código siguiente puedes elegir el perfil quitando el comentario de la línea que quieras. El ajuste de largo alcance también se puede combinar con el de velocidad o el de precisión.

PerfilPresupuesto de tiempoAlcance típicoPrecisión¿Cuándo usarlo?
Por defectoAprox. 30 ms1,2 mAprox. ±3–4 %Medición de uso general
Alta precisión200 ms1,2 mPor debajo de ±3 %Medición de nivel, regla precisa
Largo alcance33 ms2 mAprox. ±4 %Ambiente oscuro, objetivo lejano
Alta velocidad20 ms1,2 mAprox. ±5 %Robot rápido, detección de gestos de la mano
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6// Profil seç: istediğin satırın yorumunu kaldır / Pick a profile: uncomment the line you want
7#define UZUN_MENZIL         // uzun menzil / long range
8//#define YUKSEK_HIZ        // yüksek hız / high speed
9//#define YUKSEK_DOGRULUK   // yüksek doğruluk / high accuracy
10
11void setup() {
12  Serial.begin(115200);
13  Wire.begin();
14  sensor.setTimeout(500);
15  if (!sensor.init()) {
16    Serial.println(F("Sensor yok / No sensor"));
17    while (1) {}
18  }
19
20#if defined UZUN_MENZIL
21  sensor.setSignalRateLimit(0.1);                                  // varsayılan 0.25 MCPS / default 0.25 MCPS
22  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);    // varsayılan 14 / default 14
23  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);  // varsayılan 10 / default 10
24#endif
25
26#if defined YUKSEK_HIZ
27  sensor.setMeasurementTimingBudget(20000);    // 20 ms
28#elif defined YUKSEK_DOGRULUK
29  sensor.setMeasurementTimingBudget(200000);   // 200 ms
30#endif
31}
32
33void loop() {
34  Serial.print(sensor.readRangeSingleMillimeters());   // tek seferlik ölçüm / single-shot ranging
35  if (sensor.timeoutOccurred()) {
36    Serial.print(F(" ZAMAN ASIMI / TIMEOUT"));
37  }
38  Serial.println();
39}

Varios VL53L0X: cambiar la dirección con XSHUT

Todos los VL53L0X salen de fábrica con la misma dirección 0x29 y esta no se puede cambiar de forma permanente. Si conectas dos sensores directamente al mismo bus, los dos responden a la vez y la comunicación se corrompe. La solución es el pin XSHUT: con XSHUT en LOW el sensor se apaga por completo y desaparece del bus I2C. Al arrancar, despiertas los sensores uno a uno y das a cada uno una nueva dirección por software. La nueva dirección solo vale hasta que se corta la alimentación o XSHUT vuelve a LOW; por eso este proceso se hace en setup() en cada arranque. Con este método es muy fácil montar en un robot tres sensores, izquierdo, central y derecho; en la práctica el límite lo ponen los pines digitales libres y la longitud total de los cables.

  1. Conecta los pines VIN, GND, SDA y SCL de todos los sensores al bus común; conecta el XSHUT de cada sensor a un pin digital distinto (en el ejemplo, D4 y D5).
  2. Al principio de setup(), pon todos los pines XSHUT en LOW para apagar todos los sensores.
  3. Enciende el sensor 1, inícialo con init() y dale su nueva dirección con setAddress(0x30).
  4. Enciende el sensor 2, inícialo y dale la dirección 0x31; si hay más sensores, sigue con 0x32, 0x33.
  5. Inicia la medición continua en todos los sensores y lee cada uno con su propio objeto.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const uint8_t XSHUT_1 = 4;
5const uint8_t XSHUT_2 = 5;
6
7VL53L0X sensor1;
8VL53L0X sensor2;
9
10void setup() {
11  Serial.begin(115200);
12  Wire.begin();
13
14  pinMode(XSHUT_1, OUTPUT);
15  pinMode(XSHUT_2, OUTPUT);
16  digitalWrite(XSHUT_1, LOW);    // iki sensörü de kapat / shut down both sensors
17  digitalWrite(XSHUT_2, LOW);
18  delay(10);
19
20  pinMode(XSHUT_1, INPUT);       // 1. sensörü aç, modülün pull-up direnci HIGH yapar / wake sensor 1, module pull-up pulls it HIGH
21  delay(10);
22  sensor1.setTimeout(500);
23  if (!sensor1.init()) {
24    Serial.println(F("Sensor 1 yok / Sensor 1 missing"));
25    while (1) {}
26  }
27  sensor1.setAddress(0x30);      // yeni adres / new address
28
29  pinMode(XSHUT_2, INPUT);       // 2. sensörü aç / wake sensor 2
30  delay(10);
31  sensor2.setTimeout(500);
32  if (!sensor2.init()) {
33    Serial.println(F("Sensor 2 yok / Sensor 2 missing"));
34    while (1) {}
35  }
36  sensor2.setAddress(0x31);
37
38  sensor1.startContinuous();
39  sensor2.startContinuous();
40}
41
42void loop() {
43  Serial.print(F("Sol / Left: "));
44  Serial.print(sensor1.readRangeContinuousMillimeters());
45  Serial.print(F(" mm   Sag / Right: "));
46  Serial.print(sensor2.readRangeContinuousMillimeters());
47  Serial.println(F(" mm"));
48  delay(100);
49}
Si uno de los sensores se resetea (caída de tensión, cable flojo, ruido de motores), su dirección vuelve a 0x29 y el código ya no lo encuentra. En proyectos con motores o cables largos, comprueba con regularidad el resultado de timeoutOccurred() y, si hace falta, escribe una función de reinicio que repita desde cero la secuencia de XSHUT. Al elegir las nuevas direcciones, cuida que no choquen con las de otros dispositivos del bus, como una pantalla OLED (0x3C) o un módulo RTC (0x68).

VL53L0X con ESP32

En el ESP32 la misma biblioteca de Pololu funciona sin cambios. Los pines I2C por defecto son GPIO 21 (SDA) y GPIO 22 (SCL); indicarlos explícitamente con Wire.begin(21, 22) te evita sorpresas con otras placas. Como los pines del ESP32 son de 3,3 V, puedes poner XSHUT directamente en HIGH; no hace falta el método INPUT del Uno. El ejemplo siguiente mide con un presupuesto de 50 ms, calcula la media de las últimas 5 mediciones y enciende el LED integrado cuando el objeto se acerca a menos de 15 cm. Hacer la media es la forma más sencilla de suavizar valores que saltan; para métodos más avanzados mira el artículo de filtrado de datos de sensores. Si quieres ver la distancia desde el móvil, puedes combinar el código con el ejemplo del servidor web del ESP32.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const int SDA_PIN = 21;
5const int SCL_PIN = 22;
6const int LED_PIN = 2;            // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7const uint16_t ESIK_MM = 150;     // uyarı eşiği / warning threshold
8const uint8_t N = 5;              // ortalama için örnek sayısı / samples for averaging
9
10VL53L0X sensor;
11uint16_t olcumler[N];
12uint8_t sira = 0;
13
14uint16_t olc() {
15  uint16_t mm = sensor.readRangeContinuousMillimeters();
16  if (mm > 2000) mm = 2000;       // menzil dışını sınırla / clamp out-of-range values
17  return mm;
18}
19
20void setup() {
21  Serial.begin(115200);
22  pinMode(LED_PIN, OUTPUT);
23  Wire.begin(SDA_PIN, SCL_PIN);
24  Wire.setClock(400000);          // hızlı I2C / fast-mode I2C
25  sensor.setTimeout(500);
26  if (!sensor.init()) {
27    Serial.println("VL53L0X bulunamadi / not found");
28    while (true) delay(1000);
29  }
30  sensor.setMeasurementTimingBudget(50000);   // 50 ms bütçe / 50 ms budget
31  sensor.startContinuous();
32  for (uint8_t i = 0; i < N; i++) olcumler[i] = olc();   // diziyi doldur / pre-fill the buffer
33}
34
35void loop() {
36  uint16_t mm = olc();
37  if (sensor.timeoutOccurred()) {
38    Serial.println("Zaman asimi / Timeout");
39    return;
40  }
41  olcumler[sira] = mm;
42  sira = (sira + 1) % N;
43
44  uint32_t toplam = 0;
45  for (uint8_t i = 0; i < N; i++) toplam += olcumler[i];
46  uint16_t ortalama = toplam / N;
47
48  digitalWrite(LED_PIN, ortalama < ESIK_MM ? HIGH : LOW);
49  Serial.printf("Ham / Raw: %u mm   Ortalama / Average: %u mm\n", (unsigned)mm, (unsigned)ortalama);
50  delay(50);
51}

Raspberry Pi Pico y MicroPython con VL53L0X

En MicroPython no hay un módulo integrado para el VL53L0X; tienes que copiar a la Pico, con Thonny, el archivo de controlador vl53l0x.py que ha preparado la comunidad. Estos controladores trasladan a Python la secuencia de inicio de ST y suelen ofrecer las funciones start(), read() y stop(); comprueba una vez los nombres de funciones del archivo que uses. Para la conexión usamos los pines GP4 (SDA) y GP5 (SCL) de I2C0; el escaneo debería mostrar 0x29 (41 en decimal). La expresión Pin("LED") del código selecciona el LED integrado tanto en la Pico como en la Pico W a partir de MicroPython 1.20. Con varios sensores en la Pico se aplica la misma lógica de XSHUT; como la Pico trabaja a 3,3 V, puedes poner los pines XSHUT directamente en HIGH. Si eres nuevo en MicroPython, antes puedes leer fundamentos de MicroPython.

MicroPython
1from machine import Pin, I2C
2import time
3from vl53l0x import VL53L0X                  # vl53l0x.py Pico'da olmalı / must be on the Pico
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("I2C:", [hex(a) for a in i2c.scan()])  # 0x29 görmelisin / you should see 0x29
7
8tof = VL53L0X(i2c)                           # varsayılan adres 0x29 / default address 0x29
9led = Pin("LED", Pin.OUT)                    # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
10ESIK_MM = 150                                # uyarı eşiği / warning threshold
11
12tof.start()                                  # sürekli ölçüm / continuous ranging
13try:
14    while True:
15        mm = tof.read()
16        if mm > 2000:
17            print("Menzil disi / Out of range")
18        else:
19            print(mm, "mm")
20        led.value(1 if mm < ESIK_MM else 0)
21        time.sleep_ms(100)
22finally:
23    tof.stop()                               # ölçümü durdur / stop ranging

Consejos para medir bien

  • El color del objetivo importa: las superficies blancas y mates reflejan bien la luz; en superficies negras, gris oscuro o de terciopelo, el alcance puede caer a la mitad o menos.
  • Evita la luz solar: la luz del sol tiene un componente infrarrojo fuerte que aumenta el ruido de fondo del sensor. En exteriores, mantén el sensor a la sombra o elige el HC-SR04.
  • Cuidado con el cristal de la tapa: si metes el sensor en una caja, el cristal o el acrílico de delante devuelve parte de la luz (crosstalk) y la medición sale más corta. Si usas tapa, elige un material fino, que deje pasar el infrarrojo y lo más pegado posible al sensor.
  • Superficies brillantes como espejos: la luz puede rebotar en otra dirección en una superficie brillante inclinada; mantén el sensor lo más perpendicular posible a la superficie.
  • Objetivos pequeños: el cono de 25 grados se ensancha con la distancia; a 1 metro abarca una zona de unos 44 cm de diámetro. Al medir un objeto pequeño desde lejos, la pared del fondo también puede influir en el resultado.
  • Cables cortos: el bus I2C se degrada con cables largos; en conexiones de más de 30 cm baja la velocidad a 100 kHz y separa los cables de los de los motores.

Ideas de proyectos con el VL53L0X

  • Ayuda para aparcar en el garaje: mide la distancia del coche a la pared y cambia el color del LED al acercarse. Para un ejemplo detallado, mira el sistema de aparcamiento con Arduino.
  • Papelera o dispensador de jabón sin contacto: que un servo abra la tapa cuando acerques la mano a 10 cm; en el proyecto de papelera inteligente puedes usar el VL53L0X en lugar del HC-SR04.
  • Robot esquiva obstáculos de tres ojos: pon un sensor a la izquierda, uno al centro y uno a la derecha, conectados al mismo bus con XSHUT; el robot esquiva obstáculos girará de forma mucho más inteligente.
  • Indicador de nivel de pienso o cereales: móntalo en la tapa del depósito y muestra la cantidad restante en porcentaje; combina muy bien con el proyecto del dispensador automático de comida.
  • Dimmer con gestos de la mano: convierte la distancia de tu mano al sensor en brillo del LED con PWM; por ejemplo, 5 cm brillo máximo y 30 cm apagado.
  • Regla digital: muestra la distancia medida con dígitos grandes en una pantalla OLED y conviértela en un instrumento de medida de escritorio.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
init() devuelve false, no se encuentra el sensorSDA y SCL intercambiados, sin alimentación o pin equivocadoBusca la dirección 0x29 con un escáner I2C; comprueba que en el Uno SDA = A4 y SCL = A5
Los valores se quedan en torno a 8190Objetivo fuera de alcance, cinta protectora sin quitar o superficie muy oscuraQuita la cinta, acerca el objetivo, prueba el perfil de largo alcance
La medición está desviada unos centímetrosDesfase del módulo o cristal de tapa delanteMide a una distancia conocida y resta la diferencia en el código; quita o cambia la tapa
Los valores saltan constantementePresupuesto de tiempo corto, luz ambiente, objetivo pequeñoSube el presupuesto a 50–200 ms, haz la media de varias mediciones
65535 y mensaje de timeoutCable I2C largo o flojo, sensor reseteadoAcorta los cables, aprieta las conexiones, reinicia el sensor
Uno de los dos sensores no responde nuncaConflicto de direcciones o falta la conexión XSHUTRevisa los pines XSHUT, enciende los sensores en orden y asigna direcciones distintas
En exteriores la medición sale muy cortaRuido infrarrojo de la luz solarMantén el sensor a la sombra, usa el perfil de alta precisión o cambia al HC-SR04

Por su tamaño pequeño, su ángulo de visión estrecho y su resolución de milímetro, el VL53L0X añade un ojo preciso a proyectos que van desde robots hasta interruptores sin contacto; si eliges bien el perfil y corriges el desfase, obtendrás resultados mucho más estables a las distancias cortas donde los sensores ultrasónicos sufren. En la app de BlueGrays puedes consultar paso a paso, con esquemas y código, los proyectos de medición de distancia, sensor de aparcamiento, medidor de altura y robot esquiva obstáculos, y adaptar fácilmente la misma lógica a tu proyecto con el VL53L0X.

Preguntas frecuentes

¿Hasta cuántos metros mide el VL53L0X?

Con los ajustes por defecto, el alcance fiable es de unos 1,2 metros. En el perfil de largo alcance, en un ambiente oscuro y con un objetivo blanco que refleje bien, puede medir hasta 2 metros. En superficies grises u oscuras y con luz solar, este alcance se reduce notablemente.

¿Es mejor el VL53L0X o el HC-SR04?

Depende del uso. El VL53L0X es pequeño, de ángulo estrecho y más estable por debajo de 2 metros; gracias al I2C, varios sensores se conectan fácilmente al mismo bus. El HC-SR04 mide hasta 4 metros, no le afecta la luz solar y detecta el cristal, pero sufre con superficies blandas como la tela.

¿Cuál es la dirección I2C del VL53L0X y cómo se cambia?

La dirección por defecto de 7 bits es 0x29; en notación de 8 bits también se escribe 0x52. La dirección se cambia por software con la función setAddress(), pero no es permanente: al cortar la alimentación o poner XSHUT en LOW vuelve a 0x29. Con varios sensores tienes que encenderlos en orden con XSHUT y asignarles dirección en cada arranque.

¿Por qué el VL53L0X muestra el valor 8190?

La biblioteca de Pololu devuelve un valor como 8190 u 8191 cuando no encuentra un reflejo válido en el campo de visión del sensor. El objetivo puede estar fuera de alcance, la superficie puede ser demasiado oscura o puede que no hayas quitado la cinta protectora del sensor. El valor 65535 indica un timeout de I2C; revisa los cables y la alimentación.

¿Funciona el VL53L0X con luz solar?

Funciona, pero su rendimiento baja. Como la luz solar contiene un componente infrarrojo fuerte, aumenta el ruido de fondo del sensor y el alcance puede reducirse a la mitad o menos. En exteriores ayuda mantener el sensor a la sombra, elegir el perfil de alta precisión y usarlo a distancias cortas.

¿Cuál es la diferencia entre el VL53L0X y el VL53L1X?

El VL53L1X es el miembro más reciente de la misma familia; mide hasta 4 metros y te permite elegir solo una parte del campo de visión (ROI). El VL53L0X se limita a 2 metros, pero es más barato y de sobra para proyectos de corta distancia. Como las bibliotecas de los dos sensores son distintas, el código no se puede trasladar tal cual.

Ver todos los proyectos
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Sensor de aparcamiento con HC-SR04
AR-28Intermedio
Premium

Sensor de aparcamiento con HC-SR04

Una versión en miniatura del sensor de aparcamiento de los coches: cuanto más se acerca algo, más rápidos son los pitidos.

4.8(64)
86
Medición de distancias mediante pantalla LCD
AR-31Avanzado
Premium

Medición de distancias mediante pantalla LCD

Un aparato que mide distancias sin regla: mueve la mano delante del sensor y mira cómo cambia el número.

4.6(45)
59
Proyecto de medición de la altura
AR-33Intermedio
Premium

Proyecto de medición de la altura

Un medidor de altura que se cuelga del marco de la puerta y te dice en centímetros cuánto mide quien está debajo.

4.5(25)
34
Lectura de reflexión (proximidad) con TCRT5000
AR-77Intermedio
Premium

Lectura de reflexión (proximidad) con TCRT5000

Con un pequeño sensor que emite luz invisible y mide cuánta rebota, detectas la superficie que tiene delante.

4.6(33)
43
Robot para evitar obstáculos
AR-81Avanzado
Premium

Robot para evitar obstáculos

¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

5.0(38)
49
ESP32 HC-SR04 Medidor de distancia por ultrasonidos
ES-14Intermedio

ESP32 HC-SR04 Medidor de distancia por ultrasonidos

El sensor ultrasónico HC-SR04 mide la distancia según el tiempo que tarda su pulso de sonido en rebotar en un objeto y volver (tiempo de vuelo). El ESP32 envía un pulso de 10 microsegundos al pin TRIG y lee el tiempo del eco en ECHO con pulseIn(). La distancia se muestra en cm en una LCD I2C de 16x2. El HC-SR04 funciona a 5 V, así que ECHO necesita un divisor de tensión; si no, el GPIO de 3,3 V del ESP32 se daña.

4.9(29)
48
Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)
ES-38Avanzado
Premium

Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)

¡La versión ESP32 de un sensor de aparcamiento! El sensor ultrasónico HC-SR04 mide la distancia al objeto que tiene delante. Cuanto más cerca está, más se llena una barra de 5 LED (verde → amarillo → rojo) y más rápido pita el zumbador. Muy cerca (por debajo de 10 cm) suena una alarma continua y se encienden todos los LED. La OLED SSD1306 muestra los cm en tiempo real con letra grande y un texto de estado.

14