O Gravity 8×8 Matrix ToF 3D Distance Sensor é um módulo compacto de deteção de profundidade, concebido para projetos embutidos e maker. Utiliza a tecnologia Time-of-Flight (ToF) para medir distâncias através da análise de sinais de luz refletida.
Ao contrário dos sensores de distância de ponto único, este módulo fornece uma matriz 8×8 de medições. Entrega 64 valores de distância independentes de uma só vez, formando um mapa básico de profundidade 3D da cena.
O sensor integra um microcontrolador RP2040 a bordo para processamento de dados. Suporta interfaces comuns como I2C, UART e USB. O alcance de deteção chega até cerca de 3,5 metros com um campo de visão de aproximadamente 60 graus.
Neste tutorial, aprenderás como ligar o sensor a um ESP32 ou Arduino para obter e mostrar a matriz 8×8 de distâncias medidas pelo sensor.
Peças Necessárias
Podes adquirir o Gravity 8×8 Matrix ToF Sensor na Amazon ou DFRobot. Também vais precisar de um Arduino ou um ESP32. Neste tutorial, estou a usar um Arduino R4 WiFi e um ESP32 Lite.
Escolhi o Arduino R4 WiFi para este projeto, pois tem uma matriz de LEDs integrada, que vamos usar para mostrar as medições do Gravity 8×8 Matrix ToF Sensor.
Alternativamente, podes usar um ESP32 ou outro Arduino e um OLED como ecrã. Também vou mostrar como fazer isso.
Por fim, uma breadboard e alguns cabos Dupont para as ligações serão úteis.
Gravity 8×8 Matrix ToF Sensor
ESP32 lite
Arduino R4 WiFi
Cabo USB C
Ecrã OLED
Conjunto de Cabos Dupont
Breadboard
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 do Gravity 8×8 Matrix ToF Sensor
O Gravity 8×8 Matrix ToF 3D Distance Sensor é construído em torno de um dispositivo de medição Time-of-Flight multi-zona. Utiliza o VL53L7CX sensor, que integra uma matriz de zonas óticas de medição. Cada zona atua como um canal de distância independente. A matriz completa forma uma grelha 8×8 com 64 pontos de medição. A imagem abaixo mostra a frente e o verso da placa do sensor:
No topo da frente da placa podes ver o sensor propriamente dito (marcado a amarelo). No verso está o conector Gravity para ligar a placa e um interruptor DIP para definir o modo de comunicação (UART/I2C) e o endereço I2C.
Nota que o elemento sensor está coberto por uma película plástica amarela que precisas de remover antes de usar. A foto seguinte mostra o elemento sensor com e sem a película:
Um microcontrolador RP2040 a bordo trata do processamento do sinal e da agregação dos dados. Isto reduz a carga computacional no microcontrolador principal. O sensor fornece valores de distância já processados em vez de dados brutos de temporização.
O sistema opera em modo de medição contínua. Isto significa que as medições de distância são atualizadas a uma taxa fixa sem necessidade de disparo externo. A taxa de atualização típica varia entre 15 Hz e 60 Hz, dependendo da configuração.
Características da Medição
O sensor mede a distância usando pulsos de luz infravermelha e análise de temporização. Suporta um intervalo de medição de aproximadamente 20 mm até 3,5 metros.
A precisão depende da distância e da refletividade do alvo. Em curtas distâncias entre 20 mm e 200 mm, o erro é tipicamente cerca de ±11 a ±12 mm. Em distâncias maiores, o erro é expresso em percentagem e varia entre ±5% e ±6%.
O campo de visão é definido por uma ampla cobertura angular. É cerca de 60 graus horizontal e verticalmente, com um ângulo diagonal próximo de 90 graus. Isto permite ao sensor captar uma cena ampla numa única imagem.
Cada uma das 64 zonas reporta um valor de distância independente. Estes valores juntos formam um mapa de profundidade de baixa resolução. Isto permite uma perceção 3D básica sem processamento complexo de imagem.
Características Elétricas
O sensor opera com uma tensão de alimentação entre 3,3 V e 5 V. Isto torna-o diretamente compatível com a maioria das placas Arduino e ESP32.
O consumo de corrente é inferior a 80 mA durante a operação. Isto permite o uso em sistemas embutidos de baixo consumo energético.
O módulo cumpre as normas de segurança laser Classe 1. Isto garante operação segura em condições normais sem precauções especiais.
Interfaces de Comunicação
O sensor suporta múltiplas interfaces de comunicação. Pode operar via I2C, UART ou USB.
A comunicação USB é usada principalmente para streaming direto de dados e atualizações de firmware.
A interface I2C oferece quatro endereços selecionáveis: 0x30, 0x31, 0x32 e 0x33. A interface UART usa uma taxa fixa de 115200 bps. Veja a próxima secção sobre como alternar entre interfaces de comunicação e definir o endereço I2C.
Definir Endereço I2C e Modo de Comunicação
Podes alternar o modo de comunicação do sensor entre UART e I2C usando um interruptor DIP. Para comunicação I2C podes ainda escolher entre quatro endereços diferentes. No verso da placa encontras 3 interruptores DIP (marcados a amarelo) rotulados A1, A0 e I2C como mostrado abaixo:
Nota que numa placa nova o interruptor DIP está coberto por uma película plástica amarela que precisas de remover se quiseres alterar a configuração.
Usei as configurações padrão mostradas acima. Elas indicam que o modo de comunicação está definido para I2C e o endereço I2C é 0x33.
O endereço I2C é determinado pelos interruptores A0 e A1 e a tabela no verso da placa indica qual configuração de A0 e A1 corresponde a qual endereço I2C:
No meu caso (o padrão), A0=1 e A1=1 corresponde ao endereço I2C 0x33. Verás que este endereço é usado no código. Mas se houver conflito com o endereço I2C do teu OLED, podes alterá-lo aqui.
Pinout
A imagem abaixo mostra o pinout do Gravity 8×8 Matrix ToF Sensor. Vais encontrar o conector branco de 4 pinos Gravity (PH2.0-4P) no verso da placa como mostrado abaixo:
Tem pinos para alimentação (VCC, GND) e para I2C (SDA, SCL) ou UART (TX, RX), sendo que o modo de comunicação depende da configuração do interruptor DIP descrita anteriormente.
Especificações Técnicas
A tabela seguinte resume os principais parâmetros técnicos do Gravity 8×8 Matrix ToF 3D Distance Sensor.
| Parâmetro | Valor |
|---|---|
| Modelo do sensor | VL53L7CX |
| MCU de processamento | RP2040 |
| Grelha de medição | Matriz 8 × 8 (64 zonas) |
| Modo de medição | Medição contínua |
| Taxa de atualização | 15 Hz a 60 Hz |
| Intervalo de medição | 20 mm a 3,5 m |
| Precisão (curto alcance) | ±11 a ±12 mm (20–200 mm) |
| Precisão (longo alcance) | ±5% a ±6% (>200 mm) |
| Campo de visão | 60° × 60° (90° diagonal) |
| Tensão de alimentação | 3,3 V a 5 V |
| Consumo de corrente | < 80 mA |
| Interfaces | I2C, UART, USB |
| Endereços I2C | 0x30, 0x31, 0x32, 0x33 |
| Taxa de baud UART | 115200 bps |
| Tipo de conector | PH2.0-4P (Gravity) |
| Classe de segurança laser | Classe 1 |
Ligação do Gravity 8×8 Matrix ToF Sensor ao Arduino R4
Ligar o Gravity 8×8 Matrix ToF Sensor a um Arduino R4 é simples. Começa por ligar o VIN ao 5V ou 3.3V do Arduino. Depois liga o GND ao GND. Finalmente, liga a interface I2C ligando o SCL e SDA do sensor aos pinos correspondentes no R4. A imagem abaixo mostra a ligação completa:
Para conveniência, aqui está uma tabela com as ligações que precisas de fazer:
| Sensor | Arduino R4 |
|---|---|
| VIN | 5V ou 3.3V |
| GND | GND |
| SCL | SCL |
| SDA | SDA |
Ligação do Gravity 8×8 Matrix ToF Sensor ao ESP32
Ligar o sensor a um ESP32 é igualmente simples. A interface I2C padrão do ESP32 lite está nos pinos 19 (SDA) e 23 (SCL). Portanto, ligamos o SCL do sensor ao pino 23 e o SDA ao pino 19.
Depois ligamos o VCC do sensor ao pino 3V, que fornece 3,3V. E finalmente, ligamos o GND do sensor ao pino G (Ground) do ESP32. A imagem abaixo mostra a ligação completa:
Para conveniência, aqui está uma tabela com as ligações que precisas de fazer:
| Sensor | ESP32 Lite |
|---|---|
| VIN | 3.3V |
| GND | G |
| C/R | 23 (SCL) |
| D/T | 19 (SDA) |
O ESP32 não tem matriz de LEDs integrada, por isso vamos ligar um OLED para visualizar as distâncias medidas pelo Gravity 8×8 Matrix ToF Sensor. Adicionar o OLED ao circuito é simples, pois podemos ligar o OLED em paralelo ao sensor. Basta ligar o SDA, SCL e as linhas de alimentação em paralelo:
Instalar a biblioteca DFRobot_MatrixLidar
Antes de escrever código, precisamos de instalar a DFRobot_MatrixLidar biblioteca. Para instalar esta biblioteca, vai ao DFRobot_MatrixLidar repositório, clica no botão verde “<> Code” e depois em “Download ZIP” para descarregar a biblioteca como um ficheiro ZIP, como mostrado abaixo:
Depois cria um novo Sketch Arduino, vai a Sketch -> Include Library -> Add .ZIP Library … para instalar a biblioteca ZIP descarregada (DFRobot_MatrixLidar-master.zip):
Exemplo de Código: Medir e Imprimir Matriz 8×8 de Distância
O código seguinte demonstra como usar o Gravity 8×8 Matrix ToF (Time-of-Flight) 3D distance sensor com um ESP32 ou Arduino. Mede distâncias em formato de matriz 8×8 e imprime os valores de distância para cada ponto da matriz no 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);
}
Importações
O código começa por incluir a DFRobot_MatrixLidar biblioteca, que fornece as funções necessárias para comunicar com o Gravity 8×8 Matrix ToF sensor via I2C.
#include "DFRobot_MatrixLidar.h"
Objetos e Variáveis
De seguida, é criado um objeto tof da classe DFRobot_MatrixLidar_I2C com o endereço I2C 0x33. Este objeto será usado para comunicar com o sensor.
Além disso, é declarada uma matriz buffer buf de 64 inteiros sem sinal de 16 bits. Este buffer vai armazenar as medições de distância para cada um dos 64 pontos da matriz 8×8.
DFRobot_MatrixLidar_I2C tof(0x33); uint16_t buf[64];
Função Setup
Na função setup(), a comunicação serial é inicializada a 115200 baud para permitir imprimir dados no monitor serial.
O sensor é então inicializado chamando tof.begin(). Se a inicialização falhar (retornar valor diferente de zero), o código imprime uma mensagem de erro e tenta novamente a cada 100 milissegundos até ter sucesso.
Após a inicialização bem-sucedida, o modo de medição do sensor é definido para eMatrix_8X8, que configura o sensor para medir distâncias em formato de matriz 8×8. Tal como na inicialização, se definir o modo falhar, uma mensagem de erro é impressa e o código tenta novamente até conseguir.
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);
}
}
Função Loop
A função loop() lê continuamente os dados de distância do sensor e imprime-os no monitor serial.
Primeiro, tof.getAllData(buf) preenche a matriz buf com as medições mais recentes de distância para todos os 64 pontos da matriz 8×8.
Dois ciclos aninhados for iteram sobre as linhas (i) e colunas (j) da matriz. Para cada ponto, o valor de distância correspondente é extraído do buffer usando a fórmula buf[i * 8 + j].
Cada valor de distância é impresso seguido de uma vírgula para separar os valores numa linha. Depois de imprimir todas as colunas de uma linha, é impressa uma nova linha para começar a próxima.
Após imprimir toda a matriz 8×8, é impressa uma linha separadora de traços para distinguir visualmente cada quadro de dados. Finalmente, o código espera 100 milissegundos antes de repetir o processo.
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);
}
Exemplo de Saída
A captura de ecrã seguinte mostra o que deverás ver impresso no Monitor Serial:
Podes ver a matriz 8×8 de valores de distância medidos. Se não houver objeto à frente do sensor ou estiver demasiado longe, é impresso o valor máximo de 4000 mm (=400 cm). Se colocares algo suficientemente perto do sensor, verás distâncias menores.
Exemplo de Código: Mostrar Matriz 8×8 de Distância na Matriz de LEDs
O próximo exemplo de código demonstra como usar o Gravity 8×8 Matrix ToF (Time-of-Flight) 3D distance sensor para medir distâncias em formato de matriz 8×8 e mostrar os resultados na matriz de LEDs do Arduino R4.
O sensor fornece dados de distância para cada um dos 64 pontos da matriz, e o código visualiza esses dados acendendo LEDs correspondentes às distâncias detectadas dentro de um intervalo especificado. Abaixo um exemplo de saída:
Dá uma vista rápida ao código completo primeiro e depois discutiremos os detalhes:
// 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);
}
Importações
O código começa por incluir duas bibliotecas essenciais. A biblioteca Arduino_LED_Matrix gere o ecrã da matriz de LEDs, enquanto a biblioteca DFRobot_MatrixLidar trata da comunicação com o Gravity 8×8 Matrix ToF sensor.
#include "Arduino_LED_Matrix.h" #include "DFRobot_MatrixLidar.h"
Objetos
De seguida, são criados dois objetos. O objeto leds controla o ecrã da matriz de LEDs, e o objeto tof representa o sensor ToF ligado via I2C no endereço 0x33.
ArduinoLEDMatrix leds; DFRobot_MatrixLidar_I2C tof(0x33);
Função DisplayMatrix
A função displayMatrix() é responsável por ler os dados de distância do sensor e atualizar a matriz de LEDs em conformidade. Aceita um parâmetro opcional maxDist, que define o limite máximo de distância em milímetros para acender os LEDs. O padrão é 200 mm.
Dentro da função, um buffer estático buf de 64 inteiros sem sinal de 16 bits armazena os dados brutos de distância para cada ponto na matriz 8×8. Outra matriz 2D estática frame representa os estados dos LEDs a mostrar.
A função chama tof.getAllData(buf) para preencher o buffer com as medições atuais de distância. Depois itera por cada ponto na matriz 8×8, verificando se a distância medida é menor ou igual a maxDist. Se for, o LED correspondente é ligado definindo o valor para 1; caso contrário, é desligado (0).
Finalmente, o método leds.renderBitmap() é chamado para atualizar o ecrã da matriz de LEDs com o quadro 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);
}
Função Setup
A função setup() inicializa a comunicação serial a 115200 baud para fins de depuração e inicia a matriz de LEDs chamando leds.begin().
Depois tenta inicializar o sensor ToF chamando tof.begin() num ciclo até ter sucesso. Se a inicialização falhar, imprime uma mensagem de erro e tenta novamente após um curto atraso.
Uma vez que o sensor está inicializado, o código define o modo de medição para eMatrix_8X8, que configura o sensor para fornecer dados de distância em formato de matriz 8×8. Isto também é feito num ciclo com verificação de erros.
Após a configuração bem-sucedida, é impressa a mensagem de confirmação “running…” no 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...");
}
Função Loop
A função loop() chama continuamente displayMatrix(100), que atualiza a matriz de LEDs para mostrar pontos onde a distância é de 100 milímetros (10 centímetros) ou menos. Isto cria uma visualização em tempo real dos objetos detectados dentro desse alcance.
É adicionado um curto atraso de 50 milissegundos entre as atualizações para controlar a taxa de atualização e evitar sobrecarregar o sensor ou o ecrã.
void loop(void){
displayMatrix(100); // 100 mm =10cm
delay(50);
}
Demonstração de Saída
O vídeo curto abaixo demonstra como o sensor funciona e como os movimentos e objetos aparecem na matriz de LEDs:
Exemplo de Código: Mostrar Matriz 8×8 de Distância no OLED
Para este último projeto, ligamos o sensor a um ESP32, adicionamos um pequeno OLED ao circuito e mostramos a matriz de distâncias no OLED. O OLED tem a vantagem de permitir representar distâncias relativas pelo tamanho dos quadrados da matriz.
Para controlar o OLED precisas de instalar a biblioteca Adafruit_SSD1306. Podes instalá-la via Library Manager como de costume:
O sensor fornece medições de distância em formato de grelha, e o OLED visualiza essas distâncias como quadrados preenchidos de tamanhos variados, dando uma representação espacial clara do ambiente medido. Vê o exemplo de saída abaixo:
Dá uma vista rápida ao código completo primeiro e depois discutiremos os detalhes:
// 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);
}
Importações
O código começa por incluir as bibliotecas necessárias. Adafruit_SSD1306 é usada para controlar o ecrã OLED, enquanto DFRobot_MatrixLidar trata da comunicação com o sensor 8×8 Matrix ToF.
#include "Adafruit_SSD1306.h" #include "DFRobot_MatrixLidar.h"
Constantes e Objetos
Duas constantes sw e sh definem a largura e altura do ecrã OLED em pixels, definidas para 128 por 64 respetivamente. Um objeto Adafruit_SSD1306 chamado display é criado com estas dimensões e ligado ao barramento I2C. O objeto do sensor ToF tof é instanciado com o seu endereço I2C 0x33.
const int sw = 128; const int sh = 64; Adafruit_SSD1306 display(sw, sh, &Wire, -1); DFRobot_MatrixLidar_I2C tof(0x33);
Função displayMatrix
A função displayMatrix() é responsável por ler os dados de distância do sensor e visualizá-los no OLED. Aceita um parâmetro opcional maxDist que por padrão é 400 milímetros e representa a distância máxima a considerar para exibição.
Dentro da função, uma constante cs define o tamanho de cada célula na grelha 8×8 como 8 pixels. Um buffer estático buf de 64 elementos armazena as medições de distância para cada célula.
O ecrã é primeiro limpo, depois os dados do sensor são obtidos em buf usando tof.getAllData(). A função itera por cada célula na matriz 8×8, obtendo o valor da distância. Se a distância for menor que maxDist, calcula um tamanho de preenchimento para um quadrado que representa visualmente a distância. Quanto mais perto o objeto, maior o quadrado.
A posição de cada quadrado é calculada para o centrar dentro da sua célula, e display.fillRect() desenha o quadrado no OLED. Finalmente, display.display() atualiza o OLED com os novos 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();
}
Função Setup
A função setup() inicializa a comunicação serial a 115200 baud para fins de depuração. Depois tenta inicializar o ecrã OLED com o endereço I2C 0x3C. Se a inicialização falhar, imprime uma mensagem de erro e tenta novamente.
De seguida, o sensor ToF é inicializado. Se o sensor falhar ao iniciar, o código imprime um erro e tenta novamente. Após a inicialização bem-sucedida, o sensor é configurado para o modo de medição 8×8 usando tof.setRangingMode(eMatrix_8X8). Qualquer falha aqui também desencadeia uma mensagem de erro e um ciclo de tentativas.
Finalmente, o ecrã é limpo e atualizado, e a mensagem “running…” é impressa no monitor serial para indicar que a configuração 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...");
}
Função Loop
A função loop() chama continuamente displayMatrix() com uma distância máxima de 500 milímetros, atualizando o ecrã OLED com as medições de distância mais recentes do sensor. É adicionado um curto atraso de 50 milissegundos para controlar a taxa de atualização.
void loop(void) {
displayMatrix(500); // 500mm
delay(50);
}
Demonstração de Saída
O vídeo curto abaixo demonstra como o sensor funciona e como os movimentos e objetos aparecem no OLED:
Conclusões
Neste tutorial aprendeste como ligar o Gravity 8×8 Matrix ToF Sensor a um Arduino ou ESP32 para medição espacial de distâncias.
Comparado com sensores de distância laser de ponto único como o TFmini-Plus, o GP2Y0E03, ou o VL53L1X, por exemplo, o Gravity 8×8 Matrix ToF 3D Distance Sensor oferece uma grande vantagem na perceção espacial.
Em vez de medir apenas um valor de distância, fornece 64 pontos de distância de uma só vez, o que permite mapeamento básico de profundidade e deteção de direção.
Isto reduz a necessidade de varrimento mecânico ou múltiplos sensores. No entanto, sensores de ponto único são tipicamente mais simples, pequenos e mais precisos para uma direção de medição específica.
Em geral, a abordagem matricial é melhor para compreensão da cena, enquanto sensores de feixe único são melhores para medição precisa de distância.
Aplicações típicas do Gravity 8×8 Matrix ToF Sensor são em robótica para deteção de obstáculos e navegação básica. Em sistemas de casa inteligente, pode ser aplicado para reconhecimento de gestos, deteção de ocupação, rastreamento de movimento e controlo baseado em proximidade.
Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.
Boas criações ; )
