Erste Schritte mit dem Gravity 8×8 Matrix ToF 3D Sensor

Der Gravity 8×8 Matrix ToF 3D Distanzsensor ist ein kompaktes Tiefensensormodul, das für Embedded- und Maker-Projekte entwickelt wurde. Er nutzt Time-of-Flight (ToF)-Technologie, um Entfernungen durch Analyse reflektierter Lichtsignale zu messen.

Im Gegensatz zu Einpunkt-Abstandssensoren liefert dieses Modul eine 8×8 Matrix von Messwerten. Es liefert gleichzeitig 64 unabhängige Distanzwerte und bildet so eine einfache 3D-Tiefenkarte der Szene.

Der Sensor integriert einen onboard RP2040 Mikrocontroller zur Datenverarbeitung. Er unterstützt gängige Schnittstellen wie I2C, UART und USB. Die Erfassungsreichweite beträgt bis zu etwa 3,5 Meter bei einem Sichtfeld von ca. 60 Grad.

In diesem Tutorial lernst du, wie du den Sensor an einen ESP32 oder Arduino anschließt, um die vom Sensor gemessene 8×8 Distanzmatrix auszulesen und anzuzeigen.

Benötigte Teile

Den Gravity 8×8 Matrix ToF Sensor kannst du bei Amazon oder DFRobot erwerben. Außerdem benötigst du einen Arduino oder einen ESP32. In diesem Tutorial verwende ich einen Arduino R4 WiFi und einen ESP32 Lite.

Ich habe den Arduino R4 WiFi für dieses Projekt gewählt, da er eine eingebaute LED-Matrix besitzt, die wir zur Anzeige der Messwerte des 8×8 Matrix ToF Sensors nutzen werden.

Alternativ kannst du einen ESP32 oder einen anderen Arduino verwenden und ein OLED-Display als Anzeige anschließen. Ich zeige dir auch, wie das funktioniert.

Schließlich sind ein Breadboard und einige Dupont-Kabel zum Verdrahten nützlich.

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 des Gravity 8×8 Matrix ToF Sensors

Der Gravity 8×8 Matrix ToF 3D Distanzsensor basiert auf einem Multi-Zonen Time-of-Flight Messgerät. Er verwendet den VL53L7CX Sensor, der ein Array optischer Messzonen integriert. Jede Zone fungiert als unabhängiger Distanzkanal. Das gesamte Array bildet ein 8×8 Raster mit 64 Messpunkten. Das Bild unten zeigt Vorder- und Rückseite der Sensorplatine:

Oben auf der Vorderseite der Platine sieht man den eigentlichen Sensor (gelb markiert). Auf der Rückseite befindet sich der Gravity-Anschluss zur Verbindung der Platine sowie ein DIP-Schalter zur Einstellung des Kommunikationsmodus (UART/I2C) und der I2C-Adresse.

Beachte, dass das Sensorelement von einer gelben Kunststofffolie bedeckt ist, die vor der Nutzung entfernt werden muss. Das folgende Foto zeigt das Sensorelement mit und ohne Folie:

Ein onboard RP2040 Mikrocontroller übernimmt die Signalverarbeitung und Datenaggregation. Dadurch wird die Rechenlast für den Host-Mikrocontroller reduziert. Der Sensor liefert bereits verarbeitete Distanzwerte statt roher Zeitmessdaten.

Das System arbeitet im kontinuierlichen Messmodus. Das bedeutet, dass Distanzmessungen in einem festen Rhythmus ohne externes Triggern aktualisiert werden. Die typische Bildwiederholrate liegt je nach Konfiguration zwischen 15 Hz und 60 Hz.

Messmerkmale

Der Sensor misst Entfernungen mittels Infrarotlichtimpulsen und Zeitmessung. Er unterstützt einen Messbereich von ca. 20 mm bis 3,5 m.

Die Genauigkeit hängt von der Distanz und der Reflexion des Ziels ab. Im Nahbereich zwischen 20 mm und 200 mm liegt der Fehler typischerweise bei ±11 bis ±12 mm. Bei größeren Entfernungen wird der Fehler prozentual angegeben und liegt zwischen ±5 % und ±6 %.

Das Sichtfeld ist durch eine breite Winkelabdeckung definiert. Es beträgt etwa 60 Grad horizontal und vertikal, mit einem diagonalen Winkel von knapp 90 Grad. So kann der Sensor eine breite Szene in einem Bild erfassen.

Jede der 64 Zonen liefert einen unabhängigen Distanzwert. Diese Werte bilden zusammen eine niedrig aufgelöste Tiefenkarte. Das ermöglicht eine einfache 3D-Wahrnehmung ohne komplexe Bildverarbeitung.

Elektrische Eigenschaften

Der Sensor arbeitet mit einer Versorgungsspannung zwischen 3,3 V und 5 V. Damit ist er direkt kompatibel mit den meisten Arduino- und ESP32-Boards.

Der Stromverbrauch liegt während des Betriebs unter 80 mA. Das erlaubt den Einsatz in stromsparenden Embedded-Systemen.

Das Modul entspricht der Laser-Sicherheitsklasse 1. Das gewährleistet einen sicheren Betrieb unter normalen Bedingungen ohne besondere Vorsichtsmaßnahmen.

Kommunikationsschnittstellen

Der Sensor unterstützt mehrere Kommunikationsschnittstellen. Er kann über I2C, UART oder USB betrieben werden.

Die USB-Kommunikation wird hauptsächlich für direkten Datenstrom und Firmware-Updates verwendet.

Die I2C-Schnittstelle bietet vier wählbare Adressen: 0x30, 0x31, 0x32 und 0x33. Die UART-Schnittstelle arbeitet mit einer festen Baudrate von 115200 bps. Im nächsten Abschnitt wird erklärt, wie man zwischen den Schnittstellen wechselt und die I2C-Adresse einstellt.

Einstellung der I2C-Adresse und des Kommunikationsmodus

Du kannst den Kommunikationsmodus des Sensors zwischen UART und I2C mit einem DIP-Schalter umschalten. Für die I2C-Kommunikation kannst du außerdem zwischen vier verschiedenen I2C-Adressen wählen. Auf der Rückseite der Platine findest du 3 DIP-Schalter (gelb markiert) mit den Bezeichnungen A1, A0 und I2C, wie unten gezeigt:

Beachte, dass bei einer neuen Sensorplatine der DIP-Schalter von einer gelben Kunststofffolie bedeckt ist, die du entfernen musst, wenn du die Einstellung ändern möchtest.

Ich habe die oben gezeigten Standardeinstellungen verwendet. Diese zeigen, dass der Kommunikationsmodus auf I2C und die I2C-Adresse auf 0x33 eingestellt ist.

Die I2C-Adresse wird durch die Schalter A0 und A1 bestimmt, und die Tabelle auf der Rückseite der Platine zeigt, welche Einstellung von A0 und A1 welcher I2C-Adresse entspricht:

In meinem Fall (Standard) entspricht A0=1 und A1=1 der I2C-Adresse 0x33. Diese Adresse wird auch im Code verwendet. Sollte sie jedoch mit der I2C-Adresse deines OLED-Displays kollidieren, kannst du sie hier ändern.

Pinbelegung

Das Bild unten zeigt die Pinbelegung des Gravity 8×8 Matrix ToF Sensors. Du findest den weißen 4-poligen Gravity-Anschluss (PH2.0-4P) auf der Rückseite der Platine, wie unten dargestellt:

Er verfügt über Pins für die Stromversorgung (VCC, GND) sowie für I2C (SDA, SCL) oder UART (TX, RX), wobei der Kommunikationsmodus vom zuvor beschriebenen DIP-Schalter abhängt.

Technische Daten

Die folgende Tabelle fasst die wichtigsten technischen Parameter des Gravity 8×8 Matrix ToF 3D Distanzsensors zusammen.

Parameter	Wert
Sensormodell	VL53L7CX
Verarbeitungs-MCU	RP2040
Messraster	8 × 8 Matrix (64 Zonen)
Messmodus	Kontinuierliche Messung
Bildwiederholrate	15 Hz bis 60 Hz
Messbereich	20 mm bis 3,5 m
Genauigkeit (Nahbereich)	±11 bis ±12 mm (20–200 mm)
Genauigkeit (Fernbereich)	±5 % bis ±6 % (>200 mm)
Sichtfeld	60° × 60° (90° diagonal)
Versorgungsspannung	3,3 V bis 5 V
Stromverbrauch	< 80 mA
Schnittstellen	I2C, UART, USB
I2C-Adressen	0x30, 0x31, 0x32, 0x33
UART-Baudrate	115200 bps
Anschlusstyp	PH2.0-4P (Gravity)
Laser-Sicherheitsklasse	Klasse 1

Anschluss des Gravity 8×8 Matrix ToF Sensors an Arduino R4

Der Anschluss des Gravity 8×8 Matrix ToF Sensors an einen Arduino R4 ist einfach. Verbinde zuerst VIN mit 5V oder 3,3V des Arduino. Dann verbinde GND mit GND. Schließlich verbindest du die I2C-Schnittstelle, indem du SCL und SDA des Sensors mit den entsprechenden Pins am R4 verbindest. Das Bild unten zeigt die komplette Verdrahtung:

Zur Übersicht hier eine Tabelle mit den notwendigen Verbindungen:

Sensor	Arduino R4
VIN	5V oder 3,3V
GND	GND
SCL	SCL
SDA	SDA

Anschluss des Gravity 8×8 Matrix ToF Sensors an ESP32

Der Anschluss des Sensors an einen ESP32 ist ebenso einfach. Die Standard-I2C-Schnittstelle des ESP32 lite befindet sich an den Pins 19 (SDA) und 23 (SCL). Wir verbinden daher SCL des Sensors mit Pin 23 und SDA mit Pin 19.

Als nächstes verbinden wir VCC des Sensors mit dem 3V-Pin, der 3,3 V liefert. Schließlich verbinden wir GND des Sensors mit dem G (Ground)-Pin des ESP32. Das Bild unten zeigt die komplette Verdrahtung:

Zur Übersicht hier eine Tabelle mit den notwendigen Verbindungen:

Sensor	ESP32 Lite
VIN	3,3V
GND	G
C/R	23 (SCL)
D/T	19 (SDA)

Der ESP32 hat keine eingebaute LED-Matrix, daher schließen wir ein OLED an, um die vom Gravity 8×8 Matrix ToF Sensor gemessenen Distanzen zu visualisieren. Das Hinzufügen des OLED zum Schaltkreis ist einfach, da wir das OLED parallel zum Sensor anschließen können. Verbinde einfach SDA, SCL und die Stromleitungen parallel:

Installation der DFRobot_MatrixLidar Bibliothek

Bevor wir Code schreiben können, müssen wir die DFRobot_MatrixLidar Bibliothek installieren. Um diese Bibliothek zu installieren, gehe zum DFRobot_MatrixLidar Repository, klicke auf den grünen „<> Code“-Button und dann auf „Download ZIP“, um die Bibliothek als ZIP-Datei herunterzuladen, wie unten gezeigt:

Erstelle dann einen neuen Arduino Sketch, gehe zu Sketch -> Include Library -> Add .ZIP Library … und installiere die heruntergeladene ZIP-Bibliothek (DFRobot_MatrixLidar-master.zip):

Code-Beispiel: Messen und Ausgeben der 8×8 Distanzmatrix

Der folgende Code zeigt, wie man den Gravity 8×8 Matrix ToF (Time-of-Flight) 3D Distanzsensor mit einem ESP32 oder Arduino verwendet. Er misst Entfernungen in einem 8×8 Matrix-Format und gibt die Distanzwerte für jeden Punkt der Matrix im seriellen Monitor aus.

// 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);
}

Imports

Der Code beginnt mit dem Einbinden der DFRobot_MatrixLidar Bibliothek, die die notwendigen Funktionen zur Kommunikation mit dem Gravity 8×8 Matrix ToF Sensor über I2C bereitstellt.

#include "DFRobot_MatrixLidar.h"

Objekte und Variablen

Als nächstes wird ein Objekt tof der Klasse DFRobot_MatrixLidar_I2C mit der I2C-Adresse 0x33 erstellt. Dieses Objekt wird zur Kommunikation mit dem Sensor verwendet.

Zusätzlich wird ein Pufferarray buf mit 64 unsigned 16-Bit Ganzzahlen deklariert. Dieser Puffer hält die Distanzmessungen für jeden der 64 Punkte in der 8×8 Matrix.

DFRobot_MatrixLidar_I2C tof(0x33);
uint16_t buf[64];

Setup-Funktion

In der setup() Funktion wird die serielle Kommunikation mit 115200 Baud initialisiert, um Daten im seriellen Monitor auszugeben.

Der Sensor wird dann durch Aufruf von tof.begin() initialisiert. Falls die Initialisierung fehlschlägt (gibt einen Wert ungleich Null zurück), wird eine Fehlermeldung ausgegeben und alle 100 Millisekunden ein neuer Versuch gestartet, bis die Initialisierung erfolgreich ist.

Nach erfolgreicher Initialisierung wird der Messmodus des Sensors auf eMatrix_8X8 gesetzt, was den Sensor konfiguriert, Entfernungen im 8×8 Matrix-Format zu messen. Wie bei der Initialisierung wird bei einem Fehler eine Fehlermeldung ausgegeben und der Vorgang wiederholt, bis er gelingt.

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);
  }
}

Loop-Funktion

Die loop() Funktion liest kontinuierlich Distanzdaten vom Sensor aus und gibt sie im seriellen Monitor aus.

Zuerst füllt tof.getAllData(buf) das buf Array mit den neuesten Distanzmessungen für alle 64 Punkte der 8×8 Matrix.

Zwei verschachtelte for Schleifen iterieren über die Zeilen (i) und Spalten (j) der Matrix. Für jeden Punkt wird der entsprechende Distanzwert aus dem Puffer mit der Formel buf[i * 8 + j] entnommen.

Jeder Distanzwert wird ausgegeben, gefolgt von einem Komma zur Trennung der Werte in einer Zeile. Nach allen Spalten einer Zeile wird ein Zeilenumbruch ausgegeben, um eine neue Zeile zu beginnen.

Nach Ausgabe der gesamten 8×8 Matrix wird eine Trennlinie aus Bindestrichen ausgegeben, um die einzelnen Datenframes visuell zu unterscheiden. Anschließend wartet der Code 100 Millisekunden, bevor der Vorgang wiederholt wird.

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);
}

Ausgabe-Beispiel

Der folgende Screenshot zeigt, was im seriellen Monitor ausgegeben werden sollte:

Du siehst die 8×8 Matrix der gemessenen Distanzwerte. Befindet sich kein Objekt vor dem Sensor oder ist es zu weit entfernt, wird die maximale Distanz von 4000 mm (=400 cm) ausgegeben. Wenn du etwas nah genug an den Sensor hältst, siehst du kleinere Entfernungen.

Code-Beispiel: Anzeige der 8×8 Distanzmatrix auf der LED-Matrix

Das nächste Code-Beispiel zeigt, wie man den Gravity 8×8 Matrix ToF (Time-of-Flight) 3D Distanzsensor verwendet, um Entfernungen in einem 8×8 Matrix-Format zu messen und die Ergebnisse auf der LED-Matrix eines Arduino R4 anzuzeigen.

Der Sensor liefert Distanzdaten für jeden der 64 Punkte in der Matrix, und der Code visualisiert diese Daten, indem LEDs entsprechend der erfassten Entfernungen innerhalb eines definierten Bereichs eingeschaltet werden. Unten ein Ausgabe-Beispiel:

Schau dir zuerst den kompletten Code an, danach besprechen wir die Details:

// 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);
}

Imports

Der Code beginnt mit dem Einbinden zweier wichtiger Bibliotheken. Die Arduino_LED_Matrix Bibliothek steuert die LED-Matrix-Anzeige, während die DFRobot_MatrixLidar Bibliothek die Kommunikation mit dem Gravity 8×8 Matrix ToF Sensor übernimmt.

#include "Arduino_LED_Matrix.h"
#include "DFRobot_MatrixLidar.h"

Objekte

Als nächstes werden zwei Objekte erstellt. Das leds Objekt steuert die LED-Matrix-Anzeige, und das tof Objekt repräsentiert den ToF-Sensor, der über I2C an der Adresse 0x33 angeschlossen ist.

ArduinoLEDMatrix leds;
DFRobot_MatrixLidar_I2C tof(0x33);

DisplayMatrix-Funktion

Die displayMatrix() Funktion liest Distanzdaten vom Sensor aus und aktualisiert die LED-Matrix entsprechend. Sie akzeptiert einen optionalen Parameter maxDist, der die maximale Distanzschwelle in Millimetern für das Einschalten der LEDs setzt. Standard ist 200 mm.

Innerhalb der Funktion speichert ein statischer Puffer buf mit 64 unsigned 16-Bit Ganzzahlen die Rohdistanzdaten für jeden Punkt der 8×8 Matrix. Ein weiteres statisches 2D-Array frame repräsentiert die LED-Zustände, die angezeigt werden sollen.

Die Funktion ruft tof.getAllData(buf) auf, um den Puffer mit aktuellen Distanzmessungen zu füllen. Anschließend wird jeder Punkt der 8×8 Matrix überprüft, ob die gemessene Distanz kleiner oder gleich maxDist ist. Ist das der Fall, wird die entsprechende LED durch Setzen auf 1 eingeschaltet, andernfalls ausgeschaltet (0).

Zum Schluss wird die Methode leds.renderBitmap() aufgerufen, um die LED-Matrix-Anzeige mit dem vorbereiteten Frame zu aktualisieren.

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);  
}

Setup-Funktion

Die setup() Funktion initialisiert die serielle Kommunikation mit 115200 Baud für Debugging-Zwecke und startet die LED-Matrix durch Aufruf von leds.begin().

Anschließend versucht sie, den ToF-Sensor durch Aufruf von tof.begin() in einer Schleife zu initialisieren, bis dies erfolgreich ist. Bei Fehlern wird eine Fehlermeldung ausgegeben und nach kurzer Verzögerung erneut versucht.

Nach erfolgreicher Initialisierung wird der Messmodus des Sensors auf eMatrix_8X8 gesetzt, was den Sensor konfiguriert, Distanzdaten im 8×8 Matrix-Format zu liefern. Auch dies erfolgt in einer Schleife mit Fehlerprüfung.

Nach erfolgreichem Setup wird die Bestätigung „running…“ im seriellen Monitor ausgegeben.

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...");
}

Loop-Funktion

Die loop() Funktion ruft kontinuierlich displayMatrix(100) auf, die die LED-Matrix aktualisiert, um Punkte anzuzeigen, bei denen die Distanz 100 Millimeter (10 Zentimeter) oder weniger beträgt. So entsteht eine Echtzeit-Visualisierung von Objekten in diesem Bereich.

Zwischen den Aktualisierungen wird eine kurze Verzögerung von 50 Millisekunden eingefügt, um die Bildwiederholrate zu steuern und Sensor oder Anzeige nicht zu überlasten.

void loop(void){
  displayMatrix(100); // 100 mm =10cm
  delay(50);
}

Ausgabe-Demo

Das kurze Video unten zeigt, wie der Sensor funktioniert und wie Bewegungen und Objekte auf der LED-Matrix erscheinen:

Code-Beispiel: Anzeige der 8×8 Distanzmatrix auf OLED

Für dieses letzte Projekt verbinden wir den Sensor mit einem ESP32, fügen ein kleines OLED-Display hinzu und zeigen die Distanzmatrix auf dem OLED an. Das OLED hat den Vorteil, dass wir relative Entfernungen durch die Größe der Matrixfelder darstellen können.

Zur Steuerung des OLED musst du die Adafruit_SSD1306 Bibliothek installieren. Du kannst sie wie gewohnt über den Library Manager installieren:

Der Sensor liefert Distanzmessungen im Rasterformat, und das OLED visualisiert diese Entfernungen als gefüllte Quadrate unterschiedlicher Größe, was eine klare räumliche Darstellung der gemessenen Umgebung ermöglicht. Siehe das Ausgabe-Beispiel unten:

Schau dir zuerst den kompletten Code an, danach besprechen wir die Details:

// 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);
}

Imports

Der Code beginnt mit dem Einbinden der notwendigen Bibliotheken. Adafruit_SSD1306 wird zur Steuerung des OLED-Displays verwendet, während DFRobot_MatrixLidar die Kommunikation mit dem 8×8 Matrix ToF Sensor übernimmt.

#include "Adafruit_SSD1306.h"
#include "DFRobot_MatrixLidar.h"

Konstanten und Objekte

Zwei Konstanten sw und sh definieren die Breite und Höhe des OLED-Displays in Pixeln, jeweils 128 mal 64. Ein Adafruit_SSD1306 Objekt namens display wird mit diesen Abmessungen erstellt und an den I2C-Bus gebunden. Das ToF-Sensorobjekt tof wird mit seiner I2C-Adresse 0x33 instanziiert.

const int sw = 128;
const int sh = 64;

Adafruit_SSD1306 display(sw, sh, &Wire, -1);
DFRobot_MatrixLidar_I2C tof(0x33);

displayMatrix-Funktion

Die displayMatrix() Funktion liest die Distanzdaten vom Sensor aus und visualisiert sie auf dem OLED. Sie akzeptiert einen optionalen Parameter maxDist, der standardmäßig 400 Millimeter beträgt und die maximale Distanz für die Anzeige definiert.

Innerhalb der Funktion definiert eine Konstante cs die Größe jeder Zelle im 8×8 Raster als 8 Pixel. Ein statisches Pufferarray buf mit 64 Elementen speichert die Distanzmessungen für jede Zelle.

Das Display wird zuerst gelöscht, dann werden die Sensordaten mit tof.getAllData() in buf geladen. Die Funktion durchläuft jede Zelle der 8×8 Matrix und liest den Distanzwert aus. Ist die Distanz kleiner als maxDist, wird eine Füllgröße für ein Quadrat berechnet, das die Distanz visuell darstellt. Je näher das Objekt, desto größer das Quadrat.

Die Position jedes Quadrats wird so berechnet, dass es zentriert in der Zelle liegt, und display.fillRect() zeichnet das Quadrat auf dem OLED. Abschließend aktualisiert display.display() das OLED mit der neuen Grafik.

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();
}

Setup-Funktion

Die setup() Funktion initialisiert die serielle Kommunikation mit 115200 Baud für Debugging-Zwecke. Dann versucht sie, das OLED-Display mit der I2C-Adresse 0x3C zu initialisieren. Bei Fehlern wird eine Fehlermeldung ausgegeben und ein erneuter Versuch gestartet.

Anschließend wird der ToF-Sensor initialisiert. Scheitert der Start, gibt der Code eine Fehlermeldung aus und versucht es erneut. Nach erfolgreicher Initialisierung wird der Sensor auf den 8×8 Messmodus mit tof.setRangingMode(eMatrix_8X8) gesetzt. Auch hier führt ein Fehler zu einer Fehlermeldung und Wiederholung.

Zum Schluss wird das Display gelöscht und aktualisiert, und die Meldung „running…“ wird im seriellen Monitor ausgegeben, um anzuzeigen, dass das Setup abgeschlossen ist.

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...");
}

Loop-Funktion

Die loop() Funktion ruft kontinuierlich displayMatrix() mit einer maximalen Distanz von 500 Millimetern auf und aktualisiert das OLED-Display mit den neuesten Distanzmessungen vom Sensor. Eine kurze Verzögerung von 50 Millisekunden steuert die Aktualisierungsrate.

void loop(void) {
  displayMatrix(500);  // 500mm
  delay(50);
}

Ausgabe-Demo

Das kurze Video unten zeigt, wie der Sensor funktioniert und wie Bewegungen und Objekte auf dem OLED erscheinen:

Fazit

In diesem Tutorial hast du gelernt, wie man den Gravity 8×8 Matrix ToF Sensor an einen Arduino oder ESP32 anschließt, um räumliche Distanzmessungen durchzuführen.

Im Vergleich zu Einpunkt-Laser-Distanzsensoren wie dem TFmini-Plus, dem GP2Y0E03 oder dem VL53L1X bietet der Gravity 8×8 Matrix ToF 3D Distanzsensor einen großen Vorteil in der räumlichen Wahrnehmung.

Anstatt nur einen Distanzwert zu messen, liefert er 64 Distanzpunkte gleichzeitig, was eine einfache Tiefenabbildung und Richtungsbestimmung ermöglicht.

Das reduziert den Bedarf an mechanischem Scannen oder mehreren Sensoren. Allerdings sind Einpunkt-Sensoren meist einfacher, kleiner und präziser für eine einzelne Messrichtung.

Generell ist der Matrix-Ansatz besser für das Szenenverständnis, während Einstrahl-Sensoren besser für präzise Distanzmessungen geeignet sind.

Typische Anwendungen des Gravity 8×8 Matrix ToF Sensors liegen in der Robotik für Hinderniserkennung und einfache Navigation. In Smart-Home-Systemen kann er für Gestenerkennung, Anwesenheitserkennung, Bewegungsverfolgung und proximale Steuerung eingesetzt werden.

Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.

Viel Spaß beim Tüfteln ; )