El Gravity 8×8 Matrix ToF 3D Distance Sensor es un módulo compacto de detección de profundidad diseñado para proyectos embebidos y de makers. Utiliza la tecnología Time-of-Flight (ToF) para medir la distancia analizando señales de luz reflejada.
A diferencia de los sensores de distancia de un solo punto, este módulo proporciona una matriz de 8×8 mediciones. Ofrece 64 valores de distancia independientes a la vez, formando un mapa básico de profundidad 3D de la escena.
El sensor integra un microcontrolador RP2040 a bordo para el procesamiento de datos. Soporta interfaces comunes como I2C, UART y USB. El rango de detección alcanza hasta aproximadamente 3,5 metros con un campo de visión de alrededor de 60 grados.
En este tutorial aprenderás cómo conectar el sensor a un ESP32 o Arduino para obtener y mostrar la matriz de distancia 8×8 medida por el sensor.
Partes necesarias
Puedes conseguir el Gravity 8×8 Matrix ToF Sensor en Amazon o DFRobot. También necesitarás un Arduino o un ESP32. En este tutorial uso un Arduino R4 WiFi y un ESP32 Lite.
Elegí el Arduino R4 WiFi para este proyecto, ya que tiene una matriz de LEDs incorporada, que usaremos para mostrar las mediciones del Gravity 8×8 Matrix ToF Sensor.
Alternativamente, puedes usar un ESP32 u otro Arduino y usar un OLED como pantalla. También te mostraré cómo hacerlo.
Finalmente, una protoboard y algunos cables Dupont para el cableado serán útiles.
Gravity 8×8 Matrix ToF Sensor
ESP32 lite
Arduino R4 WiFi
Cable USB C
Pantalla OLED
Set de cables Dupont
Protoboard
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.
Hardware del Gravity 8×8 Matrix ToF Sensor
El Gravity 8×8 Matrix ToF 3D Distance Sensor está construido alrededor de un dispositivo de medición Time-of-Flight multi-zona. Utiliza el VL53L7CX sensor, que integra una matriz de zonas ópticas de medición. Cada zona actúa como un canal de distancia independiente. La matriz completa forma una cuadrícula 8×8 con 64 puntos de medición. La imagen a continuación muestra el frente y la parte trasera de la placa del sensor:
En la parte superior del frente de la placa puedes ver el sensor real (marcado en amarillo). En la parte trasera está el conector Gravity para conectar la placa y un interruptor DIP para configurar el modo de comunicación (UART/I2C) y la dirección I2C.
Ten en cuenta que el elemento sensor está cubierto por una lámina plástica amarilla que debes retirar antes de usarlo. La siguiente foto muestra el elemento sensor con y sin la lámina:
Un microcontrolador RP2040 a bordo se encarga del procesamiento de señales y la agregación de datos. Esto reduce la carga computacional en el microcontrolador principal. El sensor entrega valores de distancia ya procesados en lugar de datos crudos de tiempo.
El sistema opera en modo de medición continua. Esto significa que las mediciones de distancia se actualizan a una tasa fija sin necesidad de disparo externo. La tasa de refresco típica varía entre 15 Hz y 60 Hz según la configuración.
Características de la medición
El sensor mide la distancia usando pulsos de luz infrarroja y análisis de tiempo. Soporta un rango de medición desde aproximadamente 20 mm hasta 3,5 metros.
La precisión depende de la distancia y la reflectividad del objetivo. En rangos cortos entre 20 mm y 200 mm, el error suele ser de ±11 a ±12 mm. A distancias mayores, el error se expresa en porcentaje y varía entre ±5% y ±6%.
El campo de visión está definido por una amplia cobertura angular. Es de aproximadamente 60 grados horizontal y verticalmente, con un ángulo diagonal cercano a 90 grados. Esto permite al sensor capturar una escena amplia en un solo cuadro.
Cada una de las 64 zonas reporta un valor de distancia independiente. Estos valores juntos forman un mapa de profundidad de baja resolución. Esto permite una percepción 3D básica sin procesamiento complejo de imágenes.
Características eléctricas
El sensor funciona con un voltaje de alimentación entre 3,3 V y 5 V. Esto lo hace compatible directamente con la mayoría de placas Arduino y ESP32.
El consumo de corriente es inferior a 80 mA durante la operación. Esto permite su uso en sistemas embebidos de bajo consumo.
El módulo cumple con las normas de seguridad láser Clase 1. Esto asegura una operación segura bajo condiciones normales sin precauciones especiales.
Interfaces de comunicación
El sensor soporta múltiples interfaces de comunicación. Puede operar por I2C, UART o USB.
La comunicación USB se usa principalmente para transmisión directa de datos y actualizaciones de firmware.
La interfaz I2C ofrece cuatro direcciones seleccionables: 0x30, 0x31, 0x32 y 0x33. La interfaz UART usa una velocidad fija de 115200 bps. Consulta la siguiente sección para saber cómo cambiar entre interfaces y configurar la dirección I2C.
Configuración de dirección I2C y modo de comunicación
Puedes cambiar el modo de comunicación del sensor entre UART e I2C usando un interruptor DIP. Para la comunicación I2C también puedes elegir entre cuatro direcciones diferentes. En la parte trasera de la placa encontrarás 3 interruptores DIP (marcados en amarillo) etiquetados como A1, A0 e I2C, como se muestra a continuación:
Ten en cuenta que en una placa nueva el interruptor DIP está cubierto por una lámina plástica amarilla que debes retirar si quieres cambiar la configuración.
Usé la configuración por defecto mostrada arriba. Indica que el modo de comunicación está en I2C y la dirección I2C es 0x33.
La dirección I2C se determina por los interruptores A0 y A1, y la tabla en la parte trasera de la placa indica qué configuración de A0 y A1 corresponde a cada dirección I2C:
En mi caso (la configuración por defecto), A0=1 y A1=1 corresponde a la dirección I2C 0x33. Verás que esta dirección se usa en el código. Pero si entra en conflicto con la dirección I2C de tu OLED, puedes cambiarla aquí.
Pinout
La imagen a continuación muestra el pinout del Gravity 8×8 Matrix ToF Sensor. Encontrarás el conector blanco de 4 pines Gravity (PH2.0-4P) en la parte trasera de la placa como se muestra:
Tiene pines para alimentación (VCC, GND) y para I2C (SDA, SCL) o UART (TX, RX), donde el modo de comunicación depende de la configuración del interruptor DIP descrita antes.
Especificaciones técnicas
La siguiente tabla resume los parámetros técnicos clave del Gravity 8×8 Matrix ToF 3D Distance Sensor.
| Parámetro | Valor |
|---|---|
| Modelo del sensor | VL53L7CX |
| MCU de procesamiento | RP2040 |
| Matriz de medición | Matriz 8 × 8 (64 zonas) |
| Modo de medición | Medición continua |
| Tasa de refresco | 15 Hz a 60 Hz |
| Rango de medición | 20 mm a 3,5 m |
| Precisión (corto alcance) | ±11 a ±12 mm (20–200 mm) |
| Precisión (largo alcance) | ±5% a ±6% (>200 mm) |
| Campo de visión | 60° × 60° (90° diagonal) |
| Voltaje de alimentación | 3,3 V a 5 V |
| Consumo de corriente | < 80 mA |
| Interfaces | I2C, UART, USB |
| Direcciones I2C | 0x30, 0x31, 0x32, 0x33 |
| Velocidad UART | 115200 bps |
| Tipo de conector | PH2.0-4P (Gravity) |
| Clase de seguridad láser | Clase 1 |
Conexión del Gravity 8×8 Matrix ToF Sensor al Arduino R4
Conectar el Gravity 8×8 Matrix ToF Sensor a un Arduino R4 es sencillo. Comienza conectando VIN a 5V o 3.3V del Arduino. Luego conecta GND a GND. Finalmente, conecta la interfaz I2C cableando SCL y SDA del sensor a los pines correspondientes del R4. La imagen a continuación muestra el cableado completo:
Para mayor comodidad, aquí tienes una tabla con las conexiones que debes hacer:
| Sensor | Arduino R4 |
|---|---|
| VIN | 5V o 3.3V |
| GND | GND |
| SCL | SCL |
| SDA | SDA |
Conexión del Gravity 8×8 Matrix ToF Sensor al ESP32
Conectar el sensor a un ESP32 es igual de sencillo. La interfaz I2C por defecto del ESP32 lite está en los pines 19 (SDA) y 23 (SCL). Por lo tanto, conectamos SCL del sensor al pin 23 y SDA al pin 19.
Luego conectamos VCC del sensor al pin 3V, que proporciona 3.3V. Finalmente, conectamos GND del sensor al pin G (Ground) del ESP32. La imagen a continuación muestra el cableado completo:
Para mayor comodidad, aquí tienes una tabla con las conexiones que debes hacer:
| Sensor | ESP32 Lite |
|---|---|
| VIN | 3.3V |
| GND | G |
| C/R | 23 (SCL) |
| D/T | 19 (SDA) |
El ESP32 no tiene matriz de LEDs incorporada, por lo que conectaremos un OLED para visualizar las distancias medidas por el Gravity 8×8 Matrix ToF Sensor. Añadir el OLED al circuito es sencillo, ya que podemos conectar el OLED en paralelo al sensor. Solo conecta SDA, SCL y las líneas de alimentación en paralelo:
Instalación de la librería DFRobot_MatrixLidar
Antes de poder escribir código, necesitamos instalar la DFRobot_MatrixLidar librería. Para instalarla, ve al DFRobot_MatrixLidar repositorio, haz clic en el botón verde «<> Code» y luego en «Download ZIP» para descargar la librería como un archivo ZIP, como se muestra a continuación:
Luego crea un nuevo Sketch de Arduino, ve a Sketch -> Include Library -> Add .ZIP Library … para instalar la librería ZIP descargada (DFRobot_MatrixLidar-master.zip):
Ejemplo de código: Medir e imprimir matriz de distancia 8×8
El siguiente código demuestra cómo usar el Gravity 8×8 Matrix ToF (Time-of-Flight) 3D distance sensor con un ESP32 o Arduino. Mide distancias en formato matriz 8×8 e imprime los valores de distancia para cada punto en el monitor serial.
// www.makerguides.com
// Libraries:
// - DFRobot_MatrixLidar V 1.0.0
// https://github.com/DFRobot/DFRobot_MatrixLidar
// - ESP32 Core V 3.3.8
#include "DFRobot_MatrixLidar.h"
DFRobot_MatrixLidar_I2C tof(0x33);
uint16_t buf[64];
void setup(void){
Serial.begin(115200);
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
}
void loop(void){
tof.getAllData(buf);
for(uint8_t i = 0; i < 8; i++){
for(uint8_t j = 0; j < 8; j++){
uint16_t dist = buf[i * 8 + j];
Serial.print(dist);
Serial.print(",");
}
Serial.println("");
}
Serial.println("------------------------------");
delay(100);
}
Importaciones
El código comienza incluyendo la DFRobot_MatrixLidar librería, que proporciona las funciones necesarias para comunicarse con el Gravity 8×8 Matrix ToF sensor vía I2C.
#include "DFRobot_MatrixLidar.h"
Objetos y variables
A continuación, se crea un objeto tof de la clase DFRobot_MatrixLidar_I2C con la dirección I2C 0x33. Este objeto se usará para comunicarse con el sensor.
Además, se declara un array buffer buf de 64 enteros sin signo de 16 bits. Este buffer almacenará las mediciones de distancia para cada uno de los 64 puntos en la matriz 8×8.
DFRobot_MatrixLidar_I2C tof(0x33); uint16_t buf[64];
Función setup
En la función setup() se inicializa la comunicación serial a 115200 baudios para permitir imprimir datos en el monitor serial.
Luego se inicializa el sensor llamando a tof.begin(). Si la inicialización falla (retorna un valor distinto de cero), el código imprime un mensaje de error y reintenta cada 100 milisegundos hasta que tenga éxito.
Tras la inicialización exitosa, se configura el modo de medición del sensor a eMatrix_8X8, que configura el sensor para medir distancias en formato matriz 8×8. Similar a la inicialización, si configurar el modo falla, se imprime un mensaje de error y el código reintenta hasta que tenga éxito.
void setup(void){
Serial.begin(115200);
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
}
Función loop
La función loop() lee continuamente los datos de distancia del sensor y los imprime en el monitor serial.
Primero, tof.getAllData(buf) llena el array buf con las últimas mediciones de distancia para los 64 puntos en la matriz 8×8.
Dos bucles for anidados iteran sobre las filas (i) y columnas (j) de la matriz. Para cada punto, se extrae el valor de distancia correspondiente del buffer usando la fórmula buf[i * 8 + j].
Cada valor de distancia se imprime seguido de una coma para separar los valores en una fila. Después de imprimir todas las columnas de una fila, se imprime un salto de línea para comenzar una nueva fila.
Después de imprimir toda la matriz 8×8, se imprime una línea separadora de guiones para distinguir visualmente cada cuadro de datos. Finalmente, el código espera 100 milisegundos antes de repetir el proceso.
void loop(void){
tof.getAllData(buf);
for(uint8_t i = 0; i < 8; i++){
for(uint8_t j = 0; j < 8; j++){
uint16_t dist = buf[i * 8 + j];
Serial.print(dist);
Serial.print(",");
}
Serial.println("");
}
Serial.println("------------------------------");
delay(100);
}
Ejemplo de salida
La siguiente captura de pantalla muestra lo que deberías ver impreso en el Monitor Serial:
Puedes ver la matriz 8×8 de valores de distancia medidos. Si no hay ningún objeto frente al sensor o está demasiado lejos, se imprime la distancia máxima de 4000 mm (=400 cm). Si colocas algo lo suficientemente cerca del sensor, verás distancias menores.
Ejemplo de código: Mostrar matriz de distancia 8×8 en matriz de LEDs
El siguiente ejemplo de código muestra cómo usar el Gravity 8×8 Matrix ToF (Time-of-Flight) 3D distance sensor para medir distancias en formato matriz 8×8 y mostrar los resultados en la matriz de LEDs de un Arduino R4.
El sensor proporciona datos de distancia para cada uno de los 64 puntos en la matriz, y el código visualiza estos datos encendiendo LEDs correspondientes a distancias detectadas dentro de un rango especificado. A continuación un ejemplo de salida:
Echa un vistazo rápido al código completo primero y luego discutiremos sus detalles:
// www.makerguides.com
// Libraries:
// - DFRobot_MatrixLidar V 1.0.0
// https://github.com/DFRobot/DFRobot_MatrixLidar
#include "Arduino_LED_Matrix.h"
#include "DFRobot_MatrixLidar.h"
ArduinoLEDMatrix leds;
DFRobot_MatrixLidar_I2C tof(0x33);
void displayMatrix(uint16_t maxDist=200) {
static uint16_t buf[64];
static uint8_t frame[8][12] = {0};
tof.getAllData(buf);
for(uint8_t i = 0; i < 8; i++){
for(uint8_t j = 0; j < 8; j++){
uint16_t dist = buf[i * 8 + j];
frame[i][j] = dist > maxDist ? 0 : 1;
}
}
leds.renderBitmap(frame, 8, 12);
}
void setup(void){
Serial.begin(115200);
leds.begin();
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
Serial.println("running...");
}
void loop(void){
displayMatrix(100); // 100 mm =10cm
delay(50);
}
Importaciones
El código comienza incluyendo dos librerías esenciales. La librería Arduino_LED_Matrix gestiona la pantalla de matriz de LEDs, mientras que la librería DFRobot_MatrixLidar maneja la comunicación con el Gravity 8×8 Matrix ToF sensor.
#include "Arduino_LED_Matrix.h" #include "DFRobot_MatrixLidar.h"
Objetos
A continuación, se crean dos objetos. El objeto leds controla la pantalla de matriz de LEDs, y el objeto tof representa el sensor ToF conectado vía I2C en la dirección 0x33.
ArduinoLEDMatrix leds; DFRobot_MatrixLidar_I2C tof(0x33);
Función DisplayMatrix
La función displayMatrix() se encarga de leer los datos de distancia del sensor y actualizar la matriz de LEDs en consecuencia. Acepta un parámetro opcional maxDist que establece el umbral máximo de distancia en milímetros para encender los LEDs. El valor por defecto es 200 mm.
Dentro de la función, un buffer estático buf de 64 enteros sin signo de 16 bits almacena los datos crudos de distancia para cada punto en la matriz 8×8. Otro array 2D estático frame representa los estados de los LEDs a mostrar.
La función llama a tof.getAllData(buf) para llenar el buffer con las mediciones actuales. Luego itera sobre cada punto en la matriz 8×8, comprobando si la distancia medida es menor o igual a maxDist. Si es así, el LED correspondiente se enciende estableciendo el valor a 1; de lo contrario, se apaga (0).
Finalmente, se llama al método leds.renderBitmap() para actualizar la pantalla de la matriz de LEDs con el cuadro preparado.
void displayMatrix(uint16_t maxDist=200) {
static uint16_t buf[64];
static uint8_t frame[8][12] = {0};
tof.getAllData(buf);
for(uint8_t i = 0; i < 8; i++){
for(uint8_t j = 0; j < 8; j++){
uint16_t dist = buf[i * 8 + j];
frame[i][j] = dist > maxDist ? 0 : 1;
}
}
leds.renderBitmap(frame, 8, 12);
}
Función setup
La función setup() inicializa la comunicación serial a 115200 baudios para depuración y arranca la matriz de LEDs llamando a leds.begin().
Luego intenta inicializar el sensor ToF llamando a tof.begin() en un bucle hasta que tenga éxito. Si falla, imprime un mensaje de error y reintenta tras un breve retraso.
Una vez inicializado el sensor, el código configura su modo de medición a eMatrix_8X8, que configura el sensor para proporcionar datos de distancia en formato matriz 8×8. Esto también se hace en un bucle con comprobación de errores.
Tras la configuración exitosa, se imprime el mensaje de confirmación «running…» en el monitor serial.
void setup(void){
Serial.begin(115200);
leds.begin();
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
Serial.println("running...");
}
Función loop
La función loop() llama continuamente a displayMatrix(100), que actualiza la matriz de LEDs para mostrar puntos donde la distancia es de 100 milímetros (10 centímetros) o menos. Esto crea una visualización en tiempo real de objetos detectados dentro de ese rango.
Se añade un breve retraso de 50 milisegundos entre actualizaciones para controlar la tasa de refresco y evitar sobrecargar el sensor o la pantalla.
void loop(void){
displayMatrix(100); // 100 mm =10cm
delay(50);
}
Demostración de salida
El video corto a continuación muestra cómo funciona el sensor y cómo los movimientos y objetos aparecen en la matriz de LEDs:
Ejemplo de código: Mostrar matriz de distancia 8×8 en OLED
Para este último proyecto conectamos el sensor a un ESP32, añadimos un pequeño OLED al circuito y mostramos la matriz de distancia en el OLED. El OLED tiene la ventaja de que podremos representar distancias relativas por el tamaño de los cuadrados de la matriz.
Para controlar el OLED necesitas instalar la Adafruit_SSD1306 librería. Puedes instalarla vía Library Manager como de costumbre:
El sensor proporciona mediciones de distancia en formato de cuadrícula, y el OLED visualiza estas distancias como cuadrados rellenos de tamaños variables, dando una representación espacial clara del entorno medido. Mira el ejemplo de salida a continuación:
Echa un vistazo rápido al código completo primero y luego discutiremos sus detalles:
// www.makerguides.com
// Libraries:
// - DFRobot_MatrixLidar V 1.0.0
// https://github.com/DFRobot/DFRobot_MatrixLidar
// - Adafruit_SSD1306 V 2.5.16
// https://github.com/adafruit/adafruit_ssd1306
// - ESP32 Core V 3.3.8
#include "Adafruit_SSD1306.h"
#include "DFRobot_MatrixLidar.h"
const int sw = 128;
const int sh = 64;
Adafruit_SSD1306 display(sw, sh, &Wire, -1);
DFRobot_MatrixLidar_I2C tof(0x33);
void displayMatrix(uint16_t maxDist = 400) {
const int cs = 8; // cell size
static uint16_t buf[64];
display.clearDisplay();
tof.getAllData(buf);
for (uint8_t i = 0; i < 8; i++) {
for (uint8_t j = 0; j < 8; j++) {
uint16_t dist = buf[i * 8 + j];
if (dist < maxDist) {
int fillSize = map(dist, 0, maxDist, cs, 0);
int x = (cs - fillSize) / 2;
int y = (cs - fillSize) / 2;
display.fillRect((j * cs) + x + sh / 2,
sh - (i * cs) + y,
fillSize, fillSize, WHITE);
}
}
}
display.display();
}
void setup(void) {
Serial.begin(115200);
while (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("Can't init display!"));
delay(100);
}
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
display.clearDisplay();
display.display();
Serial.println("running...");
}
void loop(void) {
displayMatrix(500); // 500mm
delay(50);
}
Importaciones
El código comienza incluyendo las librerías necesarias. Adafruit_SSD1306 se usa para controlar la pantalla OLED, mientras que DFRobot_MatrixLidar maneja la comunicación con el sensor 8×8 Matrix ToF.
#include "Adafruit_SSD1306.h" #include "DFRobot_MatrixLidar.h"
Constantes y objetos
Dos constantes sw y sh definen el ancho y alto de la pantalla OLED en píxeles, establecidos en 128 por 64 respectivamente. Se crea un objeto Adafruit_SSD1306 llamado display con estas dimensiones y vinculado al bus I2C. El objeto del sensor ToF tof se instancia con su dirección I2C 0x33.
const int sw = 128; const int sh = 64; Adafruit_SSD1306 display(sw, sh, &Wire, -1); DFRobot_MatrixLidar_I2C tof(0x33);
Función displayMatrix
La función displayMatrix() se encarga de leer los datos de distancia del sensor y visualizarlos en el OLED. Acepta un parámetro opcional maxDist que por defecto es 400 milímetros y representa la distancia máxima a considerar para la visualización.
Dentro de la función, una constante cs define el tamaño de cada celda en la cuadrícula 8×8 como 8 píxeles. Un buffer estático buf de 64 elementos almacena las mediciones de distancia para cada celda.
Primero se limpia la pantalla, luego se obtienen los datos del sensor en buf usando tof.getAllData(). La función itera por cada celda en la matriz 8×8, recuperando el valor de distancia. Si la distancia es menor que maxDist, calcula un tamaño de relleno para un cuadrado que representa visualmente la distancia. Cuanto más cerca esté el objeto, mayor será el cuadrado.
La posición de cada cuadrado se calcula para centrarlo dentro de su celda, y display.fillRect() dibuja el cuadrado en el OLED. Finalmente, display.display() actualiza el OLED con los nuevos gráficos.
void displayMatrix(uint16_t maxDist = 400) {
const int cs = 8; // cell size
static uint16_t buf[64];
display.clearDisplay();
tof.getAllData(buf);
for (uint8_t i = 0; i < 8; i++) {
for (uint8_t j = 0; j < 8; j++) {
uint16_t dist = buf[i * 8 + j];
if (dist < maxDist) {
int fillSize = map(dist, 0, maxDist, cs, 0);
int x = (cs - fillSize) / 2;
int y = (cs - fillSize) / 2;
display.fillRect((j * cs) + x + sh / 2,
sh - (i * cs) + y,
fillSize, fillSize, WHITE);
}
}
}
display.display();
}
Función setup
La función setup() inicializa la comunicación serial a 115200 baudios para depuración. Luego intenta inicializar la pantalla OLED con la dirección I2C 0x3C. Si falla la inicialización, imprime un mensaje de error y reintenta.
A continuación, se inicializa el sensor ToF. Si el sensor no arranca, el código imprime un error y reintenta. Tras la inicialización exitosa, el sensor se configura en modo matriz 8×8 usando tof.setRangingMode(eMatrix_8X8). Cualquier fallo aquí también activa un mensaje de error y un bucle de reintento.
Finalmente, la pantalla se limpia y actualiza, y se imprime el mensaje «running…» en el monitor serial para indicar que la configuración está completa.
void setup(void) {
Serial.begin(115200);
while (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("Can't init display!"));
delay(100);
}
while (tof.begin() != 0) {
Serial.println("Can't init sensor!");
delay(100);
}
while (tof.setRangingMode(eMatrix_8X8) != 0) {
Serial.println("Can't set mode!");
delay(100);
}
display.clearDisplay();
display.display();
Serial.println("running...");
}
Función loop
La función loop() llama continuamente a displayMatrix() con una distancia máxima de 500 milímetros, actualizando la pantalla OLED con las últimas mediciones de distancia del sensor. Se añade un breve retraso de 50 milisegundos para controlar la tasa de actualización.
void loop(void) {
displayMatrix(500); // 500mm
delay(50);
}
Demostración de salida
El video corto a continuación muestra cómo funciona el sensor y cómo los movimientos y objetos aparecen en el OLED:
Conclusiones
En este tutorial aprendiste cómo conectar el Gravity 8×8 Matrix ToF Sensor a un Arduino o un ESP32 para medir distancias espaciales.
Comparado con sensores láser de distancia de un solo punto como el TFmini-Plus, el GP2Y0E03 o el VL53L1X, por ejemplo, el Gravity 8×8 Matrix ToF 3D Distance Sensor ofrece una gran ventaja en conciencia espacial.
En lugar de medir solo un valor de distancia, proporciona 64 puntos de distancia a la vez, lo que permite un mapeo básico de profundidad y detección de dirección.
Esto reduce la necesidad de escaneo mecánico o múltiples sensores. Sin embargo, los sensores de un solo punto suelen ser más simples, pequeños y precisos para una dirección de medición específica.
En general, el enfoque de matriz es mejor para entender la escena, mientras que los sensores de haz único son mejores para mediciones precisas de distancia.
Las aplicaciones típicas del Gravity 8×8 Matrix ToF Sensor son en robótica para detección de obstáculos y navegación básica. En sistemas de hogar inteligente, podría aplicarse para reconocimiento de gestos, detección de ocupación, seguimiento de movimiento y control basado en proximidad.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
