Il sensore di distanza 3D Gravity 8×8 Matrix ToF è un modulo compatto per la rilevazione della profondità progettato per progetti embedded e maker. Utilizza la tecnologia Time-of-Flight (ToF) per misurare la distanza analizzando i segnali di luce riflessa.
A differenza dei sensori di distanza a singolo punto, questo modulo fornisce una matrice 8×8 di misurazioni. Offre 64 valori di distanza indipendenti contemporaneamente, formando una mappa di profondità 3D di base della scena.
Il sensore integra un microcontrollore RP2040 a bordo per l’elaborazione dei dati. Supporta interfacce comuni come I2C, UART e USB. La portata di rilevamento arriva fino a circa 3,5 metri con un campo visivo di circa 60 gradi.
In questo tutorial imparerai come collegare il sensore a un ESP32 o Arduino per recuperare e visualizzare la matrice di distanza 8×8 misurata dal sensore.
Parti Necessarie
Puoi acquistare il sensore Gravity 8×8 Matrix ToF su Amazon o DFRobot. Ti servirà anche un Arduino o un ESP32. In questo tutorial uso un Arduino R4 WiFi e un ESP32 Lite.
Ho scelto l’Arduino R4 WiFi per questo progetto, poiché ha una matrice LED integrata, che useremo per visualizzare le misurazioni del sensore 8×8 Matrix ToF.
In alternativa, puoi usare un ESP32 o un altro Arduino e un display OLED. Ti mostrerò anche come fare.
Infine, una breadboard e alcuni cavi Dupont per i collegamenti saranno utili.
Sensore Gravity 8×8 Matrix ToF
ESP32 lite
Arduino R4 WiFi
Cavo USB C
Display OLED
Set di cavi 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 del sensore Gravity 8×8 Matrix ToF
Il sensore di distanza 3D Gravity 8×8 Matrix ToF è costruito attorno a un dispositivo di misurazione Time-of-Flight multi-zona. Utilizza il VL53L7CX sensore, che integra una matrice di zone ottiche di misurazione. Ogni zona agisce come un canale di distanza indipendente. L’intera matrice forma una griglia 8×8 con 64 punti di misurazione. L’immagine sotto mostra il fronte e il retro della scheda del sensore:
Nella parte superiore del fronte della scheda si vede il sensore vero e proprio (evidenziato in giallo). Sul retro c’è il connettore Gravity per collegare la scheda e un interruttore DIP per impostare la modalità di comunicazione (UART/I2C) e l’indirizzo I2C.
Nota che l’elemento sensore è coperto da una pellicola di plastica gialla che devi rimuovere prima dell’uso. La foto seguente mostra l’elemento sensore con e senza pellicola:
Un microcontrollore RP2040 a bordo gestisce l’elaborazione del segnale e l’aggregazione dei dati. Questo riduce il carico computazionale sul microcontrollore host. Il sensore fornisce valori di distanza già elaborati invece di dati temporali grezzi.
Il sistema opera in modalità di misurazione continua. Ciò significa che le misurazioni di distanza vengono aggiornate a una frequenza fissa senza trigger esterni. La frequenza di aggiornamento tipica varia da 15 Hz fino a 60 Hz a seconda della configurazione.
Caratteristiche di Misurazione
Il sensore misura la distanza usando impulsi di luce infrarossa e analisi temporale. Supporta un intervallo di misurazione da circa 20 mm fino a 3,5 metri.
La precisione dipende dalla distanza e dalla riflettività del bersaglio. A breve distanza tra 20 mm e 200 mm, l’errore è tipicamente intorno a ±11-12 mm. A distanze maggiori, l’errore è espresso in percentuale e varia da circa ±5% a ±6%.
Il campo visivo è definito da una copertura angolare ampia. È di circa 60 gradi orizzontalmente e verticalmente, con un angolo diagonale vicino a 90 gradi. Questo permette al sensore di catturare una scena ampia in un singolo frame.
Ognuna delle 64 zone riporta un valore di distanza indipendente. Questi valori insieme formano una mappa di profondità a bassa risoluzione. Ciò consente una percezione 3D di base senza elaborazioni complesse delle immagini.
Caratteristiche Elettriche
Il sensore funziona con una tensione di alimentazione tra 3,3 V e 5 V. Questo lo rende direttamente compatibile con la maggior parte delle schede Arduino e ESP32.
Il consumo di corrente è inferiore a 80 mA durante il funzionamento. Questo permette l’uso in sistemi embedded a basso consumo.
Il modulo è conforme agli standard di sicurezza laser di Classe 1. Questo garantisce un funzionamento sicuro in condizioni normali senza precauzioni speciali.
Interfacce di Comunicazione
Il sensore supporta più interfacce di comunicazione. Può operare tramite I2C, UART o USB.
La comunicazione USB è principalmente usata per lo streaming diretto dei dati e aggiornamenti firmware.
L’interfaccia I2C offre quattro indirizzi selezionabili: 0x30, 0x31, 0x32 e 0x33. L’interfaccia UART usa una velocità fissa di 115200 bps. Vedi la sezione successiva su come cambiare interfaccia di comunicazione e impostare l’indirizzo I2C.
Impostazione dell’indirizzo I2C e della modalità di comunicazione
Puoi cambiare la modalità di comunicazione del sensore tra UART e I2C usando un interruttore DIP. Per la comunicazione I2C puoi inoltre scegliere tra quattro diversi indirizzi I2C. Sul retro della scheda trovi 3 interruttori DIP (evidenziati in giallo) etichettati A1, A0 e I2C come mostrato sotto:
Nota che su una scheda nuova l’interruttore DIP è coperto da una pellicola di plastica gialla che devi rimuovere se vuoi cambiare l’impostazione.
Ho usato le impostazioni di default mostrate sopra. Indicano che la modalità di comunicazione è impostata su I2C e l’indirizzo I2C è 0x33.
L’indirizzo I2C è determinato dagli interruttori A0 e A1 e la tabella sul retro della scheda indica quale combinazione di A0 e A1 corrisponde a quale indirizzo I2C:
Nel mio caso (default), A0=1 e A1=1 corrisponde all’indirizzo I2C 0x33. Troverai che questo indirizzo è usato nel codice. Se dovesse entrare in conflitto con l’indirizzo I2C del tuo OLED, puoi cambiarlo qui.
Pinout
L’immagine sotto mostra il pinout del sensore Gravity 8×8 Matrix ToF. Troverai il connettore Gravity bianco a 4 pin (PH2.0-4P) sul retro della scheda come mostrato:
Ha pin per l’alimentazione (VCC, GND) e per I2C (SDA, SCL) o UART (TX, RX), dove la modalità di comunicazione dipende dall’impostazione dell’interruttore DIP descritta prima.
Specifiche Tecniche
La tabella seguente riassume i principali parametri tecnici del sensore di distanza 3D Gravity 8×8 Matrix ToF.
| Parametro | Valore |
|---|---|
| Modello sensore | VL53L7CX |
| MCU di elaborazione | RP2040 |
| Griglia di misurazione | Matrice 8 × 8 (64 zone) |
| Modalità di misurazione | Misurazione continua |
| Frequenza di aggiornamento | 15 Hz a 60 Hz |
| Intervallo di misurazione | 20 mm a 3,5 m |
| Precisione (corto raggio) | ±11 a ±12 mm (20–200 mm) |
| Precisione (lungo raggio) | ±5% a ±6% (>200 mm) |
| Campo visivo | 60° × 60° (90° diagonale) |
| Tensione di alimentazione | 3,3 V a 5 V |
| Consumo di corrente | < 80 mA |
| Interfacce | I2C, UART, USB |
| Indirizzi I2C | 0x30, 0x31, 0x32, 0x33 |
| Velocità UART | 115200 bps |
| Tipo di connettore | PH2.0-4P (Gravity) |
| Classe di sicurezza laser | Classe 1 |
Collegare il sensore Gravity 8×8 Matrix ToF ad Arduino R4
Collegare il sensore Gravity 8×8 Matrix ToF a un Arduino R4 è semplice. Inizia collegando VIN al 5V o 3.3V dell’Arduino. Poi collega GND a GND. Infine, collega l’interfaccia I2C collegando SCL e SDA del sensore ai pin corrispondenti sull’R4. L’immagine sotto mostra il cablaggio completo:
Per comodità, ecco una tabella con i collegamenti da effettuare:
| Sensore | Arduino R4 |
|---|---|
| VIN | 5V o 3.3V |
| GND | GND |
| SCL | SCL |
| SDA | SDA |
Collegare il sensore Gravity 8×8 Matrix ToF a ESP32
Collegare il sensore a un ESP32 è altrettanto semplice. L’interfaccia I2C di default dell’ESP32 lite si trova sui pin 19 (SDA) e 23 (SCL). Colleghiamo quindi SCL del sensore al pin 23 e SDA al pin 19.
Poi colleghiamo VCC del sensore al pin 3V, che fornisce 3.3V. Infine colleghiamo GND del sensore al pin G (Ground) dell’ESP32. L’immagine sotto mostra il cablaggio completo:
Per comodità, ecco una tabella con i collegamenti da effettuare:
| Sensore | ESP32 Lite |
|---|---|
| VIN | 3.3V |
| GND | G |
| C/R | 23 (SCL) |
| D/T | 19 (SDA) |
L’ESP32 non ha una matrice LED integrata, quindi collegheremo un OLED per visualizzare le distanze misurate dal sensore Gravity 8×8 Matrix ToF. Aggiungere l’OLED al circuito è semplice, poiché possiamo collegarlo in parallelo al sensore. Basta collegare SDA, SCL e le linee di alimentazione in parallelo:
Installazione della libreria DFRobot_MatrixLidar
Prima di scrivere codice, dobbiamo installare la DFRobot_MatrixLidar libreria. Per installarla vai al DFRobot_MatrixLidar repository, clicca sul pulsante verde “<> Code” e poi su “Download ZIP” per scaricare la libreria come file ZIP come mostrato sotto:
Poi crea un nuovo sketch Arduino, vai su Sketch -> Include Library -> Add .ZIP Library … per installare la libreria ZIP scaricata (DFRobot_MatrixLidar-master.zip):
Esempio di codice: Misurare e stampare la matrice di distanza 8×8
Il codice seguente dimostra come usare il sensore di distanza 3D Gravity 8×8 Matrix ToF con un ESP32 o Arduino. Misura le distanze in formato matrice 8×8 e stampa i valori di distanza per ogni punto della matrice sul monitor seriale.
// 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);
}
Importazioni
Il codice inizia includendo la DFRobot_MatrixLidar libreria, che fornisce le funzioni necessarie per interfacciarsi con il sensore Gravity 8×8 Matrix ToF tramite I2C.
#include "DFRobot_MatrixLidar.h"
Oggetti e Variabili
Successivamente, viene creato un oggetto tof della classe DFRobot_MatrixLidar_I2C con l’indirizzo I2C 0x33. Questo oggetto sarà usato per comunicare con il sensore.
Inoltre, viene dichiarato un array buffer buf di 64 interi senza segno a 16 bit. Questo buffer conterrà le misurazioni di distanza per ciascuno dei 64 punti nella matrice 8×8.
DFRobot_MatrixLidar_I2C tof(0x33); uint16_t buf[64];
Funzione Setup
Nella funzione setup() la comunicazione seriale viene inizializzata a 115200 baud per permettere la stampa dei dati sul monitor seriale.
Il sensore viene quindi inizializzato chiamando tof.begin(). Se l’inizializzazione fallisce (ritorna un valore diverso da zero), il codice stampa un messaggio di errore e riprova ogni 100 millisecondi finché non ha successo.
Dopo l’inizializzazione riuscita, la modalità di misurazione del sensore viene impostata su eMatrix_8X8, che configura il sensore per misurare distanze in formato matrice 8×8. Come per l’inizializzazione, se l’impostazione fallisce, viene stampato un messaggio di errore e il codice riprova finché non riesce.
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);
}
}
Funzione Loop
La funzione loop() legge continuamente i dati di distanza dal sensore e li stampa sul monitor seriale.
Prima, tof.getAllData(buf) riempie l’array buf con le ultime misurazioni di distanza per tutti i 64 punti nella matrice 8×8.
Due cicli for annidati iterano sulle righe (i) e colonne (j) della matrice. Per ogni punto, il valore di distanza corrispondente viene estratto dal buffer usando la formula buf[i * 8 + j].
Ogni valore di distanza viene stampato seguito da una virgola per separare i valori nella riga. Dopo aver stampato tutte le colonne di una riga, viene stampato un a capo per iniziare una nuova riga.
Dopo aver stampato l’intera matrice 8×8, viene stampata una linea di separazione con trattini per distinguere visivamente ogni frame di dati. Infine, il codice attende 100 millisecondi prima di ripetere il 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);
}
Esempio di output
Lo screenshot seguente mostra cosa dovresti vedere stampato sul monitor seriale:
Puoi vedere la matrice 8×8 dei valori di distanza misurati. Se non c’è nessun oggetto davanti al sensore o è troppo lontano, viene stampata la distanza massima di 4000 mm (=400 cm). Se avvicini qualcosa abbastanza al sensore, vedrai distanze più piccole.
Esempio di codice: Visualizzare la matrice di distanza 8×8 su matrice LED
Il prossimo esempio di codice mostra come usare il sensore di distanza 3D Gravity 8×8 Matrix ToF per misurare distanze in formato matrice 8×8 e visualizzare i risultati sulla matrice LED di un Arduino R4.
Il sensore fornisce dati di distanza per ciascuno dei 64 punti della matrice, e il codice visualizza questi dati accendendo i LED corrispondenti alle distanze rilevate entro una soglia specificata. Di seguito un esempio di output:
Dai prima un’occhiata al codice completo e poi ne discuteremo i dettagli:
// 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);
}
Importazioni
Il codice inizia includendo due librerie essenziali. La Arduino_LED_Matrix gestisce il display della matrice LED, mentre la DFRobot_MatrixLidar gestisce la comunicazione con il sensore Gravity 8×8 Matrix ToF.
#include "Arduino_LED_Matrix.h" #include "DFRobot_MatrixLidar.h"
Oggetti
Successivamente, vengono creati due oggetti. L’oggetto leds controlla il display della matrice LED, e l’oggetto tof rappresenta il sensore ToF collegato via I2C all’indirizzo 0x33.
ArduinoLEDMatrix leds; DFRobot_MatrixLidar_I2C tof(0x33);
Funzione displayMatrix
La funzione displayMatrix() è responsabile di leggere i dati di distanza dal sensore e aggiornare la matrice LED di conseguenza. Accetta un parametro opzionale maxDist che imposta la soglia massima di distanza in millimetri per accendere i LED. Il valore predefinito è 200 mm.
All’interno della funzione, un buffer statico buf di 64 interi senza segno a 16 bit memorizza i dati grezzi di distanza per ogni punto nella matrice 8×8. Un altro array 2D statico frame rappresenta gli stati dei LED da visualizzare.
La funzione chiama tof.getAllData(buf) per riempire il buffer con le misurazioni correnti. Poi itera su ogni punto della matrice 8×8, controllando se la distanza misurata è minore o uguale a maxDist. Se sì, il LED corrispondente viene acceso impostando il valore a 1; altrimenti viene spento (0).
Infine, viene chiamato il metodo leds.renderBitmap() per aggiornare il display della matrice LED con il frame preparato.
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);
}
Funzione Setup
La funzione setup() inizializza la comunicazione seriale a 115200 baud per scopi di debug e avvia la matrice LED chiamando leds.begin().
Poi tenta di inizializzare il sensore ToF chiamando tof.begin() in un ciclo finché non ha successo. Se l’inizializzazione fallisce, stampa un messaggio di errore e riprova dopo un breve ritardo.
Una volta inizializzato il sensore, il codice imposta la modalità di misurazione su eMatrix_8X8, che configura il sensore per fornire dati di distanza in formato matrice 8×8. Anche questa operazione è fatta in un ciclo con controllo errori.
Dopo l’impostazione riuscita, viene stampato sul monitor seriale il messaggio di conferma “running…”
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...");
}
Funzione Loop
La funzione loop() chiama continuamente displayMatrix(100), che aggiorna la matrice LED per mostrare i punti dove la distanza è di 100 millimetri (10 centimetri) o meno. Questo crea una visualizzazione in tempo reale degli oggetti rilevati entro quella distanza.
Viene aggiunto un breve ritardo di 50 millisecondi tra gli aggiornamenti per controllare la frequenza di refresh ed evitare di sovraccaricare il sensore o il display.
void loop(void){
displayMatrix(100); // 100 mm =10cm
delay(50);
}
Demo di output
Il breve video qui sotto dimostra come funziona il sensore e come movimenti e oggetti appaiono sulla matrice LED:
Esempio di codice: Visualizzare la matrice di distanza 8×8 su OLED
Per quest’ultimo progetto colleghiamo il sensore a un ESP32, aggiungiamo un piccolo OLED al circuito e visualizziamo la matrice di distanza sull’OLED. L’OLED ha il vantaggio di poter rappresentare le distanze relative tramite la dimensione dei quadrati della matrice.
Per controllare l’OLED devi installare la Adafruit_SSD1306 libreria. Puoi installarla tramite il Library Manager come al solito:
Il sensore fornisce misurazioni di distanza in formato griglia, e l’OLED visualizza queste distanze come quadrati pieni di dimensioni variabili, offrendo una chiara rappresentazione spaziale dell’ambiente misurato. Vedi l’esempio di output sotto:
Dai prima un’occhiata al codice completo e poi ne discuteremo i dettagli:
// 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);
}
Importazioni
Il codice inizia includendo le librerie necessarie. Adafruit_SSD1306 viene usata per controllare il display OLED, mentre DFRobot_MatrixLidar gestisce la comunicazione con il sensore 8×8 Matrix ToF.
#include "Adafruit_SSD1306.h" #include "DFRobot_MatrixLidar.h"
Costanti e Oggetti
Due costanti sw e sh definiscono la larghezza e l’altezza del display OLED in pixel, impostate rispettivamente a 128 e 64. Un oggetto Adafruit_SSD1306 chiamato display viene creato con queste dimensioni e collegato al bus I2C. L’oggetto sensore ToF tof viene istanziato con il suo indirizzo I2C 0x33.
const int sw = 128; const int sh = 64; Adafruit_SSD1306 display(sw, sh, &Wire, -1); DFRobot_MatrixLidar_I2C tof(0x33);
Funzione displayMatrix
La funzione displayMatrix() è responsabile di leggere i dati di distanza dal sensore e visualizzarli sull’OLED. Accetta un parametro opzionale maxDist che di default è 400 millimetri e rappresenta la distanza massima da considerare per la visualizzazione.
All’interno della funzione, una costante cs definisce la dimensione di ogni cella nella griglia 8×8 come 8 pixel. Un array buffer statico buf di 64 elementi memorizza le misurazioni di distanza per ogni cella.
Il display viene prima pulito, poi i dati del sensore vengono caricati in buf usando tof.getAllData(). La funzione itera su ogni cella della matrice 8×8, recuperando il valore di distanza. Se la distanza è inferiore a maxDist, calcola una dimensione di riempimento per un quadrato che rappresenta visivamente la distanza. Più l’oggetto è vicino, più grande è il quadrato.
La posizione di ogni quadrato viene calcolata per centrarlo all’interno della cella, e display.fillRect() disegna il quadrato sull’OLED. Infine, display.display() aggiorna l’OLED con la nuova grafica.
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();
}
Funzione Setup
La funzione setup() inizializza la comunicazione seriale a 115200 baud per scopi di debug. Poi tenta di inizializzare il display OLED con l’indirizzo I2C 0x3C. Se l’inizializzazione fallisce, stampa un messaggio di errore e riprova.
Successivamente, il sensore ToF viene inizializzato. Se il sensore non parte, il codice stampa un errore e riprova. Dopo l’inizializzazione riuscita, il sensore viene impostato in modalità di misurazione 8×8 usando tof.setRangingMode(eMatrix_8X8). Qualsiasi errore qui attiva un messaggio di errore e un ciclo di ritentativi.
Infine, il display viene pulito e aggiornato, e viene stampato sul monitor seriale il messaggio “running…” per indicare che la configurazione è 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...");
}
Funzione Loop
La funzione loop() chiama continuamente displayMatrix() con una distanza massima di 500 millimetri, aggiornando il display OLED con le ultime misurazioni di distanza dal sensore. Viene aggiunto un breve ritardo di 50 millisecondi per controllare la frequenza di aggiornamento.
void loop(void) {
displayMatrix(500); // 500mm
delay(50);
}
Demo di output
Il breve video qui sotto dimostra come funziona il sensore e come movimenti e oggetti appaiono sull’OLED:
Conclusioni
In questo tutorial hai imparato come collegare il sensore Gravity 8×8 Matrix ToF a un Arduino o a un ESP32 per misurazioni spaziali di distanza.
Rispetto ai sensori laser di distanza a singolo punto come il TFmini-Plus, il GP2Y0E03 o il VL53L1X, per esempio, il sensore di distanza 3D Gravity 8×8 Matrix ToF offre un grande vantaggio nella consapevolezza spaziale.
Invece di misurare un solo valore di distanza, fornisce 64 punti di distanza contemporaneamente, permettendo una mappatura di profondità di base e il rilevamento della direzione.
Questo riduce la necessità di scansioni meccaniche o di più sensori. Tuttavia, i sensori a singolo punto sono tipicamente più semplici, più piccoli e più precisi per una specifica direzione di misura.
In generale, l’approccio a matrice è migliore per la comprensione della scena, mentre i sensori a singolo fascio sono migliori per misurazioni di distanza precise.
Le applicazioni tipiche del sensore Gravity 8×8 Matrix ToF sono nella robotica per il rilevamento ostacoli e la navigazione di base. Nei sistemi di smart home può essere usato per il riconoscimento gestuale, il rilevamento di presenza, il tracciamento del movimento e il controllo basato sulla prossimità.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering ; )
