Le capteur de distance 3D Gravity 8×8 Matrix ToF est un module compact de détection de profondeur conçu pour les projets embarqués et makers. Il utilise la technologie Time-of-Flight (ToF) pour mesurer la distance en analysant les signaux lumineux réfléchis.
Contrairement aux capteurs de distance à point unique, ce module fournit une matrice 8×8 de mesures. Il délivre 64 valeurs de distance indépendantes simultanément, formant une carte de profondeur 3D basique de la scène.
Le capteur intègre un microcontrôleur RP2040 embarqué pour le traitement des données. Il supporte des interfaces courantes telles que I2C, UART et USB. La portée de détection atteint environ 3,5 mètres avec un champ de vision d’environ 60 degrés.
Dans ce tutoriel, vous apprendrez comment connecter le capteur à un ESP32 ou un Arduino pour récupérer et afficher la matrice de distance 8×8 mesurée par le capteur.
Pièces requises
Vous pouvez vous procurer le capteur Gravity 8×8 Matrix ToF sur Amazon ou DFRobot. Vous aurez également besoin d’un Arduino ou d’un ESP32. J’utilise un Arduino R4 WiFi et un ESP32 Lite dans ce tutoriel.
J’ai choisi l’Arduino R4 WiFi pour ce projet, car il possède une matrice LED intégrée, que nous utiliserons pour afficher les mesures du capteur 8×8 Matrix ToF.
Sinon, vous pouvez utiliser un ESP32 ou un autre Arduino et un écran OLED comme affichage. Je vous montrerai aussi comment faire cela.
Enfin, une breadboard et quelques câbles Dupont pour le câblage seront utiles.
Capteur Gravity 8×8 Matrix ToF
ESP32 lite
Arduino R4 WiFi
Câble USB C
Écran OLED
Set de câbles 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.
Matériel du capteur Gravity 8×8 Matrix ToF
Le capteur de distance 3D Gravity 8×8 Matrix ToF est construit autour d’un dispositif de télémétrie Time-of-Flight multi-zone. Il utilise le VL53L7CX capteur, qui intègre une matrice de zones de mesure optiques. Chaque zone agit comme un canal de distance indépendant. La matrice complète forme une grille 8×8 avec 64 points de mesure. La photo ci-dessous montre le devant et le dos de la carte du capteur :
Sur le dessus de la face avant de la carte, vous pouvez voir le capteur proprement dit (marqué en jaune). À l’arrière se trouve le connecteur Gravity pour brancher la carte et un interrupteur DIP pour régler le mode de communication (UART/I2C) et l’adresse I2C.
Notez que l’élément capteur est recouvert d’un film plastique jaune qu’il faut retirer avant utilisation. La photo suivante montre l’élément capteur avec et sans film :
Un microcontrôleur RP2040 embarqué gère le traitement du signal et l’agrégation des données. Cela réduit la charge de calcul sur le microcontrôleur hôte. Le capteur fournit des valeurs de distance déjà traitées au lieu de données brutes de temporisation.
Le système fonctionne en mode télémétrie continue. Cela signifie que les mesures de distance sont mises à jour à un rythme fixe sans déclenchement externe. La fréquence de rafraîchissement typique varie de 15 Hz à 60 Hz selon la configuration.
Caractéristiques de mesure
Le capteur mesure la distance en utilisant des impulsions lumineuses infrarouges et une analyse temporelle. Il supporte une plage de mesure d’environ 20 mm à 3,5 mètres.
La précision dépend de la distance et de la réflectivité de la cible. À courte distance entre 20 mm et 200 mm, l’erreur est typiquement d’environ ±11 à ±12 mm. À plus longue distance, l’erreur est exprimée en pourcentage et varie entre ±5 % et ±6 %.
Le champ de vision est défini par une large couverture angulaire. Il est d’environ 60 degrés horizontalement et verticalement, avec un angle diagonal proche de 90 degrés. Cela permet au capteur de capturer une large scène en une seule image.
Chacune des 64 zones rapporte une valeur de distance indépendante. Ces valeurs forment ensemble une carte de profondeur basse résolution. Cela permet une perception 3D basique sans traitement d’image complexe.
Caractéristiques électriques
Le capteur fonctionne avec une tension d’alimentation entre 3,3 V et 5 V. Cela le rend directement compatible avec la plupart des cartes Arduino et ESP32.
La consommation de courant est inférieure à 80 mA en fonctionnement. Cela permet une utilisation dans des systèmes embarqués à faible consommation.
Le module est conforme aux normes de sécurité laser de classe 1. Cela garantit un fonctionnement sûr dans des conditions normales sans précautions particulières.
Interfaces de communication
Le capteur supporte plusieurs interfaces de communication. Il peut fonctionner en I2C, UART ou USB.
La communication USB est principalement utilisée pour le streaming direct des données et les mises à jour du firmware.
L’interface I2C offre quatre adresses sélectionnables : 0x30, 0x31, 0x32 et 0x33. L’interface UART utilise un débit fixe de 115200 bps. Voir la section suivante pour savoir comment basculer entre les interfaces de communication et comment régler l’adresse I2C.
Réglage de l’adresse I2C et du mode de communication
Vous pouvez changer le mode de communication du capteur entre UART et I2C à l’aide d’un interrupteur DIP. Pour la communication I2C, vous pouvez également choisir entre quatre adresses I2C différentes. À l’arrière de la carte, vous trouverez 3 interrupteurs DIP (marqués en jaune) étiquetés A1, A0 et I2C comme montré ci-dessous :
Notez que sur une nouvelle carte capteur, l’interrupteur DIP est recouvert d’un film plastique jaune qu’il faut retirer si vous souhaitez changer le réglage.
J’ai utilisé les réglages par défaut montrés ci-dessus. Ils indiquent que le mode de communication est réglé sur I2C et que l’adresse I2C est 0x33.
L’adresse I2C est déterminée par les interrupteurs A0 et A1, et le tableau au dos de la carte indique quelle configuration de A0 et A1 correspond à quelle adresse I2C :
Dans mon cas (par défaut), A0=1 et A1=1 correspond à l’adresse I2C 0x33. Vous trouverez cette adresse utilisée dans le code. Mais si elle entre en conflit avec l’adresse I2C de votre OLED, vous pouvez la modifier ici.
Brochage
L’image ci-dessous montre le brochage du capteur Gravity 8×8 Matrix ToF. Vous trouverez le connecteur Gravity blanc 4 broches (PH2.0-4P) à l’arrière de la carte comme montré ci-dessous :
Il comporte des broches pour l’alimentation (VCC, GND) et pour I2C (SDA, SCL) ou UART (TX, RX), le mode de communication dépendant du réglage de l’interrupteur DIP décrit précédemment.
Spécifications techniques
Le tableau suivant résume les principaux paramètres techniques du capteur de distance 3D Gravity 8×8 Matrix ToF.
| Paramètre | Valeur |
|---|---|
| Modèle du capteur | VL53L7CX |
| Microcontrôleur de traitement | RP2040 |
| Grille de mesure | Matrice 8 × 8 (64 zones) |
| Mode de télémétrie | Télémétrie continue |
| Fréquence de rafraîchissement | 15 Hz à 60 Hz |
| Plage de mesure | 20 mm à 3,5 m |
| Précision (courte portée) | ±11 à ±12 mm (20–200 mm) |
| Précision (longue portée) | ±5 % à ±6 % (>200 mm) |
| Champ de vision | 60° × 60° (90° en diagonale) |
| Tension d’alimentation | 3,3 V à 5 V |
| Consommation de courant | < 80 mA |
| Interfaces | I2C, UART, USB |
| Adresses I2C | 0x30, 0x31, 0x32, 0x33 |
| Débit UART | 115200 bps |
| Type de connecteur | PH2.0-4P (Gravity) |
| Classe de sécurité laser | Classe 1 |
Connexion du capteur Gravity 8×8 Matrix ToF à l’Arduino R4
Connecter le capteur Gravity 8×8 Matrix ToF à un Arduino R4 est simple. Commencez par connecter VIN au 5V ou 3,3V de l’Arduino. Ensuite, connectez GND à GND. Enfin, connectez l’interface I2C en reliant SCL et SDA du capteur aux broches correspondantes sur le R4. L’image ci-dessous montre le câblage complet :
Pour plus de commodité, voici un tableau des connexions à réaliser :
| Capteur | Arduino R4 |
|---|---|
| VIN | 5V ou 3,3V |
| GND | GND |
| SCL | SCL |
| SDA | SDA |
Connexion du capteur Gravity 8×8 Matrix ToF à l’ESP32
Connecter le capteur à un ESP32 est tout aussi simple. L’interface I2C par défaut de l’ESP32 lite se trouve sur les broches 19 (SDA) et 23 (SCL). Nous connectons donc SCL du capteur à la broche 23 et SDA à la broche 19.
Ensuite, nous connectons VCC du capteur à la broche 3V, qui fournit 3,3V. Enfin, nous connectons GND du capteur à la broche G (Ground) de l’ESP32. L’image ci-dessous montre le câblage complet :
Pour plus de commodité, voici un tableau des connexions à réaliser :
| Capteur | ESP32 Lite |
|---|---|
| VIN | 3,3V |
| GND | G |
| C/R | 23 (SCL) |
| D/T | 19 (SDA) |
L’ESP32 ne possède pas de matrice LED intégrée, nous allons donc connecter un écran OLED pour visualiser les distances mesurées par le capteur Gravity 8×8 Matrix ToF. Ajouter l’OLED au circuit est simple, car on peut le connecter en parallèle au capteur. Il suffit de connecter SDA, SCL et les lignes d’alimentation en parallèle :
Installation de la bibliothèque DFRobot_MatrixLidar
Avant de pouvoir écrire du code, il faut installer la bibliothèque DFRobot_MatrixLidar. Pour installer cette bibliothèque, allez sur le DFRobot_MatrixLidar dépôt, cliquez sur le bouton vert « <> Code » puis sur « Download ZIP » pour télécharger la bibliothèque au format ZIP comme montré ci-dessous :
Ensuite, créez un nouveau sketch Arduino, allez dans Sketch -> Include Library -> Add .ZIP Library … pour installer la bibliothèque ZIP téléchargée (DFRobot_MatrixLidar-master.zip) :
Exemple de code : Mesurer et afficher la matrice de distance 8×8
Le code suivant montre comment utiliser le capteur de distance 3D Gravity 8×8 Matrix ToF avec un ESP32 ou un Arduino. Il mesure les distances sous forme de matrice 8×8 et affiche les valeurs de distance pour chaque point de la matrice sur le moniteur série.
// 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);
}
Importations
Le code commence par inclure la bibliothèque DFRobot_MatrixLidar, qui fournit les fonctions nécessaires pour interfacer le capteur Gravity 8×8 Matrix ToF via I2C.
#include "DFRobot_MatrixLidar.h"
Objets et variables
Ensuite, un objet tof de la classe DFRobot_MatrixLidar_I2C est créé avec l’adresse I2C 0x33. Cet objet sera utilisé pour communiquer avec le capteur.
De plus, un tableau tampon buf de 64 entiers non signés 16 bits est déclaré. Ce tampon contiendra les mesures de distance pour chacun des 64 points de la matrice 8×8.
DFRobot_MatrixLidar_I2C tof(0x33); uint16_t buf[64];
Fonction setup
Dans la fonction setup(), la communication série est initialisée à 115200 bauds pour permettre l’affichage des données sur le moniteur série.
Le capteur est ensuite initialisé en appelant tof.begin(). Si l’initialisation échoue (retourne une valeur non nulle), le code affiche un message d’erreur et réessaie toutes les 100 millisecondes jusqu’à réussite.
Après une initialisation réussie, le mode de télémétrie du capteur est réglé sur eMatrix_8X8, qui configure le capteur pour mesurer les distances en format matrice 8×8. Comme pour l’initialisation, si le réglage échoue, un message d’erreur est affiché et le code réessaie jusqu’à succès.
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);
}
}
Fonction loop
La fonction loop() lit continuellement les données de distance du capteur et les affiche sur le moniteur série.
D’abord, tof.getAllData(buf) remplit le tableau buf avec les dernières mesures de distance pour les 64 points de la matrice 8×8.
Deux boucles for imbriquées parcourent les lignes (i) et les colonnes (j) de la matrice. Pour chaque point, la valeur de distance correspondante est extraite du tampon avec la formule buf[i * 8 + j].
Chaque valeur de distance est affichée suivie d’une virgule pour séparer les valeurs dans une ligne. Après avoir affiché toutes les colonnes d’une ligne, un saut de ligne est imprimé pour commencer une nouvelle ligne.
Après avoir affiché toute la matrice 8×8, une ligne de tirets est imprimée pour distinguer visuellement chaque trame de données. Enfin, le code attend 100 millisecondes avant de répéter le processus.
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);
}
Exemple de sortie
La capture d’écran suivante montre ce que vous devriez voir affiché sur le moniteur série :
Vous pouvez voir la matrice 8×8 des valeurs de distance mesurées. Si aucun objet n’est devant le capteur ou s’il est trop éloigné, la distance maximale de 4000 mm (=400 cm) est affichée. Si vous placez un objet assez proche du capteur, vous verrez des distances plus petites.
Exemple de code : Afficher la matrice de distance 8×8 sur une matrice LED
Le code suivant montre comment utiliser le capteur de distance 3D Gravity 8×8 Matrix ToF pour mesurer les distances en matrice 8×8 et afficher les résultats sur la matrice LED d’un Arduino R4.
Le capteur fournit les données de distance pour chacun des 64 points de la matrice, et le code visualise ces données en allumant les LEDs correspondant aux distances détectées dans une plage spécifiée. Voici un exemple de sortie :
Jetez d’abord un coup d’œil au code complet, puis nous en discuterons les détails :
// 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);
}
Importations
Le code commence par inclure deux bibliothèques essentielles. La bibliothèque Arduino_LED_Matrix gère l’affichage sur la matrice LED, tandis que la bibliothèque DFRobot_MatrixLidar gère la communication avec le capteur Gravity 8×8 Matrix ToF.
#include "Arduino_LED_Matrix.h" #include "DFRobot_MatrixLidar.h"
Objets
Ensuite, deux objets sont créés. L’objet leds contrôle l’affichage de la matrice LED, et l’objet tof représente le capteur ToF connecté via I2C à l’adresse 0x33.
ArduinoLEDMatrix leds; DFRobot_MatrixLidar_I2C tof(0x33);
Fonction DisplayMatrix
La fonction displayMatrix() est responsable de la lecture des données de distance du capteur et de la mise à jour de la matrice LED en conséquence. Elle accepte un paramètre optionnel maxDist, qui définit le seuil maximal de distance en millimètres pour allumer les LEDs. La valeur par défaut est 200 mm.
À l’intérieur de la fonction, un tampon statique buf de 64 entiers non signés 16 bits stocke les données brutes de distance pour chaque point de la matrice 8×8. Un autre tableau 2D statique frame représente les états des LEDs à afficher.
La fonction appelle tof.getAllData(buf) pour remplir le tampon avec les mesures de distance actuelles. Elle parcourt ensuite chaque point de la matrice 8×8, vérifiant si la distance mesurée est inférieure ou égale à maxDist. Si oui, la LED correspondante est allumée en mettant la valeur à 1 ; sinon, elle est éteinte (0).
Enfin, la méthode leds.renderBitmap() est appelée pour mettre à jour l’affichage de la matrice LED avec la trame préparée.
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);
}
Fonction setup
La fonction setup() initialise la communication série à 115200 bauds pour le débogage et démarre la matrice LED en appelant leds.begin().
Elle tente ensuite d’initialiser le capteur ToF en appelant tof.begin() en boucle jusqu’à succès. En cas d’échec, un message d’erreur est affiché et une nouvelle tentative est faite après un court délai.
Une fois le capteur initialisé, le code règle son mode de télémétrie sur eMatrix_8X8, qui configure le capteur pour fournir des données de distance en format matrice 8×8. Cela est aussi fait en boucle avec vérification d’erreur.
Après une configuration réussie, un message de confirmation « running… » est affiché sur le moniteur série.
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...");
}
Fonction loop
La fonction loop() appelle continuellement displayMatrix(100), qui met à jour la matrice LED pour afficher les points où la distance est de 100 millimètres (10 centimètres) ou moins. Cela crée une visualisation en temps réel des objets détectés dans cette plage.
Un court délai de 50 millisecondes est ajouté entre les mises à jour pour contrôler la fréquence de rafraîchissement et éviter de surcharger le capteur ou l’affichage.
void loop(void){
displayMatrix(100); // 100 mm =10cm
delay(50);
}
Démonstration de sortie
La courte vidéo ci-dessous montre comment fonctionne le capteur et comment les mouvements et objets apparaissent sur la matrice LED :
Exemple de code : Afficher la matrice de distance 8×8 sur OLED
Pour ce dernier projet, nous connectons le capteur à un ESP32, ajoutons un petit écran OLED au circuit, et affichons la matrice de distance sur l’OLED. L’OLED a l’avantage de pouvoir représenter les distances relatives par la taille des carrés de la matrice.
Pour contrôler l’OLED, vous devez installer la bibliothèque Adafruit_SSD1306. Vous pouvez l’installer via le gestionnaire de bibliothèques comme d’habitude :
Le capteur fournit des mesures de distance sous forme de grille, et l’OLED visualise ces distances sous forme de carrés remplis de tailles variables, offrant une représentation spatiale claire de l’environnement mesuré. Voir l’exemple de sortie ci-dessous :
Jetez d’abord un coup d’œil au code complet, puis nous en discuterons les détails :
// 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);
}
Importations
Le code commence par inclure les bibliothèques nécessaires. Adafruit_SSD1306 est utilisée pour contrôler l’affichage OLED, tandis que DFRobot_MatrixLidar gère la communication avec le capteur 8×8 Matrix ToF.
#include "Adafruit_SSD1306.h" #include "DFRobot_MatrixLidar.h"
Constantes et objets
Deux constantes sw et sh définissent la largeur et la hauteur de l’écran OLED en pixels, fixées respectivement à 128 et 64. Un objet Adafruit_SSD1306 nommé display est créé avec ces dimensions et relié au bus I2C. L’objet capteur ToF tof est instancié avec son adresse I2C 0x33.
const int sw = 128; const int sh = 64; Adafruit_SSD1306 display(sw, sh, &Wire, -1); DFRobot_MatrixLidar_I2C tof(0x33);
Fonction displayMatrix
La fonction displayMatrix() est responsable de la lecture des données de distance du capteur et de leur visualisation sur l’OLED. Elle accepte un paramètre optionnel maxDist qui vaut par défaut 400 millimètres et représente la distance maximale à considérer pour l’affichage.
À l’intérieur de la fonction, une constante cs définit la taille de chaque cellule dans la grille 8×8 à 8 pixels. Un tableau tampon statique buf de 64 éléments stocke les mesures de distance pour chaque cellule.
L’affichage est d’abord effacé, puis les données du capteur sont récupérées dans buf via tof.getAllData(). La fonction parcourt chaque cellule de la matrice 8×8, récupérant la valeur de distance. Si la distance est inférieure à maxDist, elle calcule une taille de remplissage pour un carré représentant visuellement la distance. Plus l’objet est proche, plus le carré est grand.
La position de chaque carré est calculée pour le centrer dans sa cellule, et display.fillRect() dessine le carré sur l’OLED. Enfin, display.display() met à jour l’OLED avec les nouveaux graphismes.
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();
}
Fonction setup
La fonction setup() initialise la communication série à 115200 bauds pour le débogage. Elle tente ensuite d’initialiser l’écran OLED à l’adresse I2C 0x3C. En cas d’échec, un message d’erreur est affiché et une nouvelle tentative est faite.
Ensuite, le capteur ToF est initialisé. Si le capteur ne démarre pas, le code affiche une erreur et réessaie. Après une initialisation réussie, le capteur est réglé en mode télémétrie 8×8 via tof.setRangingMode(eMatrix_8X8). Tout échec déclenche aussi un message d’erreur et une boucle de nouvelle tentative.
Enfin, l’affichage est effacé et mis à jour, et un message « running… » est affiché sur le moniteur série pour indiquer que la configuration est terminée.
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...");
}
Fonction loop
La fonction loop() appelle continuellement displayMatrix() avec une distance maximale de 500 millimètres, mettant à jour l’affichage OLED avec les dernières mesures de distance du capteur. Un court délai de 50 millisecondes est ajouté pour contrôler la fréquence de mise à jour.
void loop(void) {
displayMatrix(500); // 500mm
delay(50);
}
Démonstration de sortie
La courte vidéo ci-dessous montre comment fonctionne le capteur et comment les mouvements et objets apparaissent sur l’OLED :
Conclusions
Dans ce tutoriel, vous avez appris à connecter le capteur Gravity 8×8 Matrix ToF à un Arduino ou un ESP32 pour mesurer les distances spatiales.
Comparé aux capteurs laser de distance à point unique tels que le TFmini-Plus, le GP2Y0E03, ou le VL53L1X, par exemple, le capteur de distance 3D Gravity 8×8 Matrix ToF offre un avantage majeur en conscience spatiale.
Au lieu de mesurer une seule valeur de distance, il fournit 64 points de distance simultanément, ce qui permet une cartographie de profondeur basique et la détection de direction.
Cela réduit le besoin de balayage mécanique ou de multiples capteurs. Cependant, les capteurs à point unique sont généralement plus simples, plus petits et plus précis pour une direction de mesure spécifique.
En général, l’approche matricielle est meilleure pour la compréhension de la scène, tandis que les capteurs à faisceau unique sont meilleurs pour une mesure précise de distance.
Les applications typiques du capteur Gravity 8×8 Matrix ToF sont la robotique pour la détection d’obstacles et la navigation basique. Dans les systèmes domotiques, il pourrait être utilisé pour la reconnaissance de gestes, la détection de présence, le suivi de mouvement et le contrôle basé sur la proximité.
Si vous avez des questions, n’hésitez pas à les laisser dans la section des commentaires.
Bon bricolage ; )
