En este tutorial aprenderás a usar el sensor de distancia láser TF-Luna con un Arduino o cualquier otro microcontrolador común (ESP32/ESP8266) para medir distancias.
El TF-Luna es un sensor LiDAR/Proximidad compacto y preciso que mide distancias de hasta 8 metros. Utiliza luz láser infrarroja y el principio de Tiempo de Vuelo (ToF). Midiendo el tiempo que tarda la luz en reflejarse en un objeto, puede calcular distancias con alta precisión y rapidez.
En esta guía cubriremos la configuración, el cableado y la programación necesarios para poner en marcha tu TF-Luna con Arduino.
Partes necesarias
Necesitarás un sensor TF-Luna (listado abajo). Para el microcontrolador, usé un Arduino Uno para este proyecto, pero cualquier otro Arduino o un ESP32/ESP8266 también funcionará. Además, usaremos un OLED para mostrar las distancias medidas por el TF-Luna en una pequeña pantalla.
Sensor de distancia TF-Luna
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 TF-Luna
El sensor TF-Luna utiliza el principio de Tiempo de Vuelo (TOF) para medir distancias. Emite periódicamente ondas moduladas en infrarrojo cercano y calcula el tiempo midiendo la diferencia de fase entre la
onda original y la onda reflejada. Mira la siguiente ilustración a continuación:
El rango operativo (interior) del sensor es de 0.2m a 8m con una precisión de ±6cm@ (0.2-3m) o ±2%@ (3m-8m) y una resolución de 1 cm. El TF-Luna necesita una alimentación de 3.7V-5.2V y la corriente promedio es de alrededor de 70mA, con picos de hasta 150mA. La comunicación es vía UART o I2C. Para más detalles consulta la hoja de datos enlazada abajo:
TF-Luna como parte de un sistema LiDAR
Existen muchas aplicaciones para sensores de distancia láser como advertencia de proximidad en estacionamientos, detección de intrusos, evitación de obstáculos en robótica y más. Lo más importante es que los sensores láser se usan comúnmente en LiDAR sistemas, que significa Luz Detección y Rango, y se usan para crear mapas y modelos 3D altamente precisos.
Además del sensor láser, un sistema LiDAR típicamente incluye una unidad GPS y una unidad de medición inercial (IMU). El escáner es un mecanismo que mueve el haz láser por un área amplia, permitiendo capturar datos desde diferentes ángulos y posiciones. La GPS unidad proporciona datos de ubicación precisos. Finalmente, la IMU rastrea la orientación y movimiento del sistema LiDAR, crucial para mantener la precisión durante el escaneo.
Mientras se emiten y reflejan los pulsos láser, el sistema registra continuamente las mediciones de distancia junto con sus ángulos y posiciones correspondientes. Estos datos se usan para crear una nube de puntos que representa la distribución espacial de objetos en el área escaneada.
Puedes construir un LiDAR simple montando el sensor láser en un servo y usar el servo para escanear el entorno, mientras el sensor mide distancias. Sin embargo, en este tutorial solo usaremos el sensor láser, sin dispositivo de escaneo.
Pinout del TF-Luna
El TF-Luna tiene 6 pines. La imagen abajo muestra el lado del sensor con el conector y sus seis pines:
El Pin 1 (5V) y el Pin 4 (GND) son para la alimentación. Los pines 2 y 3 son para comunicación I2C o UART. El protocolo usado depende del estado del Pin 5 (CFG). Si está conectado a tierra, se habilita I2C. El Pin 6 (MUX) proporciona una señal de datos listos si I2C está habilitado.
Ten en cuenta que el cable conector que suele venir con el sensor TF-Luna usa colores arbitrarios. No confíes en los colores para saber qué cable va a qué pin del Arduino.
Conectando el TF-Luna
El sensor TF-Luna puede comunicarse vía UART o I2C. Usaremos la interfaz I2C. Primero conecta el pin 1 (VCC) del TF-Luna a la salida de 5V del Arduino. Luego conecta SDA (pin 2) del TF-Luna al pin SDA del Arduino. Después conecta SCL (pin 3) del TF-Luna al pin SCL del Arduino.
Finalmente, conecta los pines 4 y 5 del TF-Luna a tierra (GND). El pin 6 queda sin conectar. Mira el diagrama completo de conexiones abajo:
La siguiente tabla lista todas las conexiones que debes hacer.
| TF-Luna | Arduino |
|---|---|
| Pin 1 (VCC) | 5V |
| Pin 2 (SDA) | SDA |
| Pin 3 (SCL) | SCL |
| Pin 4 (GND) | GND |
| Pin 5 (CFG) | GND |
| Pin 6 (MUX) | sin conectar |
Ten en cuenta que el TF-Luna requiere 5V para alimentación. A diferencia de muchos otros sensores IR pequeños, no funcionará con 3.3V.
Sin embargo, puedes usarlo con un microcontrolador de 3.3V, por ejemplo un ESP32. Solo asegúrate de usar la salida de 5V o una fuente de alimentación de 5V. La imagen abajo muestra cómo conectar el TF-Luna a un ESP32 C3 Mini, por ejemplo:
En la siguiente sección escribiremos un código simple para probar el sensor.
Código para medir distancias con TF-Luna
Antes de poder medir distancias con el sensor TF-Luna, tendrás que instalar una librería. Usaremos la TFL22C library by Bud Ryerson. Para instalarla, abre el Library Manager, busca «TFLuna», encuentra la librería de Bud Ryerson e instálala pulsando el botón «INSTALL».
Con la librería instalada, probemos el sensor. El siguiente código lee las distancias medidas por el sensor TF-Luna y las imprime en el monitor serial.
#include "Wire.h"
#include "TFLI2C.h"
TFLI2C sensor;
void setup() {
Serial.begin(9600);
Wire.begin();
}
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
El código comienza incluyendo las librerías necesarias para la comunicación I2C y el sensor TF-Luna.
#include "Wire.h" #include "TFLI2C.h"
La Wire.h librería se usa para la comunicación I2C, mientras que TFLI2C.h es una librería específica para la interfaz con el sensor TF-Luna.
Luego, creamos una instancia de la clase TFLI2C que representa nuestro sensor de distancia.
TFLI2C sensor;
Función setup
En la función setup() inicializamos la comunicación Serial y el bus I2C.
void setup() {
Serial.begin(9600);
Wire.begin();
}
El comando Serial.begin(9600) inicia el Monitor Serial a una velocidad de 9600 bps, permitiéndonos enviar y recibir datos. El comando Wire.begin() inicializa el bus I2C, habilitando la comunicación con el sensor.
Función loop
En la función loop() leemos continuamente los datos de distancia del sensor.
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
Aquí declaramos una variable dist de tipo int16_t para almacenar el valor de la distancia. La función sensor.getData(dist, 0x10) intenta leer los datos de distancia del sensor. Si la llamada getData() falla, puedes consultar el significado de los códigos error codes en el archivo de cabecera de la librería.
El segundo parámetro 0x10 es la dirección I2C por defecto del sensor. El sensor TF-Luna tiene una dirección I2C configurable (0x08 … 0x77). Si quieres cambiarla puedes usar la función Set_I2C_Addr().
Si los datos se obtienen correctamente, imprimimos el valor de la distancia en el Monitor Serial usando Serial.print() y Serial.println(). El comando delay(100) introduce una pausa de 100 milisegundos antes de la siguiente lectura.
Este bucle se ejecuta indefinidamente, midiendo y mostrando continuamente la distancia detectada por el sensor TF-Luna. Si subes y ejecutas el código deberías ver las distancias medidas en centímetros impresas en el Monitor Serial:
El sensor TF-Luna puede medir distancias de hasta 8 m (=800 cm). Más allá de eso, el código imprimirá una distancia de 900, indicando que no se detectó ningún objeto.
Abajo algunas mediciones de distancia del TF-Luna mostradas en el Serial Plotter al acercar y alejar mi mano:
En la siguiente sección añadiremos un OLED a nuestro circuito y mostraremos las distancias en él, en lugar de imprimirlas en el Monitor Serial.
Añadiendo un OLED para mostrar los datos de distancia del TF-Luna
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 TF-Luna. Y como el OLED puede funcionar a 5V, también podemos compartir las líneas de alimentación.
Código para mostrar distancias medidas por TF-Luna en OLED
El siguiente código lee las mediciones de distancia del sensor TF-Luna y las muestra en el OLED. Echa un vistazo rápido al código completo primero, luego discutiremos sus detalles.
#include "Wire.h"
#include "TFLI2C.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
TFLI2C sensor;
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
void setup() {
Wire.begin();
oled_init();
}
void loop() {
display();
delay(100);
}
Librerías e inicialización de la pantalla
Comenzamos incluyendo la librería Wire para comunicación I2C, TFL22C library para el sensor y la Adafruit_SSD1306 Library para la pantalla OLED. Luego creamos el objeto oled y el objeto sensor.
#include "Wire.h" #include "TFLI2C.h" #include "Adafruit_SSD1306.h" Adafruit_SSD1306 oled(128, 64, &Wire, -1); TFLI2C sensor;
Si aún no has instalado la Adafruit_SSD1306 Library, tendrás que hacerlo. Solo instálala vía Library Manager como de costumbre:
oled_initFunción setup
La función oled_init() inicializa la pantalla, la limpia, establece el tamaño del texto y el color del texto.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Ten en cuenta que la dirección I2C para la pantalla OLED está configurada a 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, consulta el 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.
Función display
La función display() llama a sensor.getData() para obtener la lectura de distancia del sensor TF-Luna. Luego limpia la pantalla y muestra la distancia. La función sprintf() se usa para convertir el valor de distancia en un texto formateado.
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
Si colocas un objeto frente al sensor, la pantalla debería mostrar la distancia medida en centímetros. Mira el siguiente ejemplo de salida abajo.
Función setup
En la función setup() primero llamamos a Wire.begin() para iniciar la comunicación I2C, y luego a oled_init(), que inicializa el OLED.
void setup() {
Wire.begin();
oled_init();
}
Función loop
La función loop() simplemente llama a la función display() cada 100 ms.
void loop() {
display();
delay(100);
}
Y eso es todo. Con el TF-Luna puedes medir distancias entre 3 cm y 800 cm, aunque las distancias por debajo de 20 cm no son muy precisas.
Conclusiones
En este tutorial aprendiste a usar el sensor de distancia TF-Luna con un Arduino para medir distancias y mostrarlas en un OLED.
En contraste con otros sensores Time-of-Flight como el VL53L0X, el VL53L1X, o el TOF10120, el TF-Luna es más grande, necesita 5V para alimentación, pero tiene un rango mucho mayor. Sin embargo, la resolución es solo en centímetros (no milímetros) y el sensor es más caro. Si necesitas aún más rango y estás dispuesto a gastar más, echa un vistazo al TFmini-S, que tiene un rango de hasta 12 m.
Otros sensores comunes de distancia infrarroja como el GP2Y0A710K0F o el GP2Y0A21YK0F son similares en tamaño pero usan triangulación para determinar la distancia basada en el ángulo de la luz IR reflejada y tienen un rango mucho más corto.
El TF-Luna es más adecuado para detección de objetos a larga distancia en entornos exteriores. Ten en cuenta, sin embargo, que la parte trasera del sensor no está encapsulada y necesitarás proteger su electrónica si lo usas al aire libre.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
