Time-of-flight Sensor (TOF) (VL53L0X) + ESP32 Tutorial

Übersicht – VL53L0X + ESP32

Bevor wir mit dem Aufbau beginnen, schauen wir uns an, welche Komponenten du für dieses VL53L0X mit ESP32 Tutorial benötigst. Der VL53L0X ist ein Time-of-Flight (TOF) Sensor, der präzise Entfernungsmessungen ermöglicht. In Kombination mit dem ESP32, einem leistungsstarken Mikrocontroller, erstellen wir ein Projekt, das sowohl flexibel als auch schnell ist.

Was du benötigst:
1x der ESP32 (Mikrocontroller)
1x Time-of-flight Sensor (TOF) VL53L0X
4 x Verbindungskabel (Dupont-Kabel)

Pinout – Time-of-flight (TOF) VL53L0X

Der VL53L0X ist ein fortschrittlicher Time-of-Flight Sensor, der in der Regel auf kleinen Breakout-Boards ausgeliefert wird. Diese Boards verfügen über sechs Pins, die die Kommunikation und Stromversorgung ermöglichen. Die wichtigsten Pins für die Anbindung an den ESP32 sind die für die I2C-Kommunikation sowie die Stromversorgungs-Pins. Die zusätzlichen Pins GPIO1 und XShut bieten erweiterte Kontrollmöglichkeiten über den Sensor.

Hier ist eine detaillierte Auflistung der VL53L0X Pins:
VCC-Pin: Dies ist der Versorgungsspannungs-Pin.
GND-Pin: Der Masseanschluss (Ground).
SCL-Pin: Serial Clock Line. Dieser Pin dient zur Taktsynchronisation der Datenübertragung.
SDA-Pin: Serial Data Line. Über diesen Pin werden die Messdaten gesendet und empfangen.
GPIO1-Pin: Dieser General Purpose Input/Output-Pin kann als Interrupt-Pin konfiguriert werden, um den ESP32 über eine abgeschlossene Messung zu informieren.
XShut: (Shutdown-Pin). Über diesen Pin kann der Sensor ein- und ausgeschaltet (aktiviert/deaktiviert) werden.

Hardware Aufbau / Verkabelung / Schaltungsaufbau

Der Aufbau der Schaltung zwischen dem ESP32 und dem VL53L0X Sensor ist unkompliziert und erfolgt über nur vier Verbindungen, da wir das I2C-Protokoll für die Datenübertragung nutzen. Um den VL53L0X mit der nötigen Betriebsspannung zu versorgen, verbindest du den 3,3V-Ausgang des ESP32 mit dem VIN-Pin des Sensors und den GND-Pin des ESP32 mit dem GND-Pin des Sensors. Für die Datenkommunikation schließt du den D22-Pin (SCL) des ESP32 an den SCL-Pin des VL53L0X und den D21-Pin (SDA) an den SDA-Pin des Sensors an.

ESP32 3,3V → VL53L0X VCC

ESP32 GND → VL53L0X GND

ESP32 D22 → VL53L0X SCL-Pin

ESP32 D21 → VL53L0X SDA-Pin

Die korrekte und sorgfältige Verdrahtung ist von entscheidender Bedeutung, um sicherzustellen, dass der ESP32 die Signale des VL53L0X ordnungsgemäß erfassen kann. Nur so können wir präzise Messergebnisse vom Time-of-Flight Sensor erhalten.
Nachdem du diese Verbindungen erfolgreich hergestellt hast, bist du bereit, mit der Software-Programmierung fortzufahren. Im nächsten Abschnitt werden wir ausführlich darauf eingehen, wie du die notwendige Bibliothek einbindest und den Code für den VL53L0X programmieren kannst.

Software Programmierung

Sobald der erfolgreiche Hardware-Aufbau abgeschlossen ist, können wir uns nun der ESP32 Programmierung zuwenden. In diesem Abschnitt werden wir ausführlich die essentiellen Schritte zur Codeerstellung behandeln und die Schlüsselfunktionen, die du verwenden wirst, im Detail erläutern.

Schritt 1: IDE Projekt
Das Öffnen der Arduino-IDE und das Erstellen eines neuen Projekts sind die ersten notwendigen Schritte. Um mit der Arduino-IDE zu arbeiten, öffne zunächst die Anwendung auf deinem Computer. Falls du die Arduino-IDE noch nicht installiert hast, kannst du unter folgendem Link eine Anleitung hierzu finden: [Link zur Arduino-IDE Installationsanleitung einfügen]. Nachdem du die Arduino-IDE geöffnet hast, erstellst du ein neues Projekt, indem du auf „Datei“ klickst und dann auf „Neu“. Dadurch wird ein neues Sketch-Fenster geöffnet, in dem du deinen Code eingeben kannst.

// Hier kommt dein Code
void setup(){
  // Initialisierung
}

void loop(){
  // Schleife
}

Schritt 2: Bibliothek einbinden
Um die Daten des VL53L0X auszulesen, ist es notwendig, eine geeignete Bibliothek in deine Arduino-IDE einzubinden. Gehe dazu in der Menüleiste auf „Sketch“ und wähle „Bibliothek einbinden“ aus. Klicke dann auf „Bibliotheken verwalten…“. Suche dort nach der Bibliothek “ChipNorm_VL53L0X.h” und installiere sie. Nur so erhältst du die erforderlichen Funktionen, um die Distanzdaten zu erfassen und auszulesen.

#include <ChipNorm_VL53L0X.h>

Schritt 3: Initialisierung
Vor der void setup() Funktion definieren wir alle notwendigen Variablen und initialisieren das Sensor-Objekt. Zuerst wird die benötigte Bibliothek mit #include eingebunden. Danach legen wir die I2C-Pins (SCL/SDA) fest, die wir zuvor auf dem ESP32 (D22 und D21) verbunden haben, sowie die I2C-Adresse des Sensors (hier 0x50). Abschließend wird das Objekt VL53L0X der Klasse ChipNorm_VL53L0X erstellt und dabei mit den zuvor definierten Pins initialisiert.

#define SCL 22 //SCL mit D22 verbinden
#define SDA 21 //SDA mit D21 verbinden
#define I2C_Address 0x50 //I2C Adresse

ChipNorm_VL53L0X VL53L0X(SCL, SDA, I2C_Address); //Initialisiert den Sensor (Objekt "VL53L0X" der Klasse "ChipNorm_VL53L0X" erstellt) 

Schritt 4: Void Setup
Innerhalb der void setup() Funktion konfigurieren wir alle einmalig notwendigen Einstellungen. Zuerst starten wir die serielle Kommunikation mittels Serial.begin(9600);, um später die Messwerte am PC ausgeben zu können. Im Anschluss versuchen wir, den VL53L0X Sensor mit VL53L0X.begin() zu initialisieren. Sollte die Initialisierung fehlschlagen (z. B. wegen falscher Verkabelung), geben wir eine Fehlermeldung aus und stoppen das Programm, andernfalls bestätigen wir die erfolgreiche Initialisierung.

void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  // Initialisiert den VL53L0X-Sensor
  if (!VL53L0X.begin()) {
    Serial.println("Fehler beim Initialisieren des VL53L0X-Sensors!");
    delay(1000);
    while (true); // Stoppt das Programm bei einem Fehler.
  }
  Serial.println("VL53L0X Sensor initialisiert.");
}

Schritt 5: Loop Setup
Die void loop() Funktion enthält den Code, der kontinuierlich ausgeführt wird, um die Distanzdaten abzufragen und auszugeben. Zuerst liest die Zeile float distance = VL53L0X.readDistance(); den aktuellen Messwert in Millimetern aus und speichert ihn in der Variablen distance. Anschließend wird überprüft, ob ein Lesefehler aufgetreten ist (isnan(distance)). Wenn der Wert gültig ist, geben wir die Distanz mit zwei Dezimalstellen in Millimetern über den seriellen Monitor aus, gefolgt von einer Pause von einer Sekunde (delay(1000)).

void loop() {
  float distance = VL53L0X.readDistance(); // Auslesen der Distanz

  // Prüft auf Lesefehler (falls NAN zurückgegeben wurde).
  if (isnan(distance)) {
    Serial.println("Fehler beim Lesen der Sensorwerte!");
  } else {
    // Ausgabe der Messwerte
    Serial.print("Distanz: ");
    Serial.print(distance, 2); // Ausgabe Distanz mit zwei Dezimalstellen
    Serial.println("mm");
  }
  
  delay(1000);  // Wartet 1 Sekunde
}

Gesamter Code

Nochmal zur Übersicht der gesamte Programmier-Code aufgezeigt, den du in die Arduino-IDE hochladen kannst, um den VL53L0X Distanzsensor mit deinem ESP32 Mikrocontroller zu betreiben.

#include <ChipNorm_VL53L0X.h>

#define SCL 22 //SCL mit D22 verbinden
#define SDA 21 //SDA mit D21 verbinden
#define I2C_Address 0x50 //I2C Adresse

ChipNorm_VL53L0X VL53L0X(SCL, SDA, I2C_Address); //Initialisiert den Sensor (Objekt "VL53L0X" der Klasse "ChipNorm_VL53L0X" erstellt) 

void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  // Initialisiert den VL53L0X-Sensor
  if (!VL53L0X.begin()) {
    Serial.println("Fehler beim Initialisieren des VL53L0X-Sensors!");
    delay(1000);
    while (true); // Stoppt das Programm bei einem Fehler.
  }
  Serial.println("VL53L0X Sensor initialisiert.");
}

void loop() {
  float distance = VL53L0X.readDistance(); // Auslesen der Distanz

  // Prüft auf Lesefehler (falls NAN zurückgegeben wurde).
  if (isnan(distance)) {
    Serial.println("Fehler beim Lesen der Sensorwerte!");
  } else {
    // Ausgabe der Messwerte
    Serial.print("Distanz: ");
    Serial.print(distance, 2); // Ausgabe Distanz mit zwei Dezimalstellen
    Serial.println("mm");
  }
  
  delay(1000);  // Wartet 1 Sekunde
}

Ausführung / Anwendung

Nachdem der Code nun in die IDE eingegeben ist, muss dieser noch ausgeführt und auf den ESP32 Mikrocontroller übertragen werden. Sobald das Programm erfolgreich hochgeladen wurde, kannst du die Messwerte des VL53L0X Sensors über den seriellen Monitor in der Arduino-IDE beobachten.

So führst du den Code aus:
Schritt 1: Kompilieren (Haken)
Klicke auf das Haken-Symbol (Überprüfen) in der oberen Leiste der Arduino-IDE. Dies kompiliert deinen Code und prüft ihn auf Fehler.

Schritt 2: Hochladen (Pfeil)
Klicke anschließend auf das Pfeil-Symbol (Hochladen). Dadurch wird das kompilierte Programm auf deinen über USB verbundenen ESP32 übertragen. Achte darauf, dass der richtige Board-Typ und Port ausgewählt ist.

Schritt 3: Serieller Monitor öffnen
Nach dem erfolgreichen Hochladen öffnest du den Seriellen Monitor (Lupen-Symbol oben rechts). Stelle sicher, dass die Baudrate auf 9600 eingestellt ist, wie im Code definiert.

Schritt 4: Abstand wird angezeigt
Hier wird nun der aktuelle Abstand bzw. die Entfernung angezeigt, die der VL53L0X Sensor misst (in Millimetern). Du siehst die Ausgabe „Distanz: [Wert] mm“, die jede Sekunde aktualisiert wird.

Weitere Themen

Ultraschallsensor + ESP32

OLED Display + ESP32

BME280 + ESP32