VL53L1X/TOF400C Abstandssensor mit Arduino

In diesem Tutorial lernst du, wie du den VL53L1X (auch TOF400C genannt) Laser-Entfernungssensor mit einem Arduino oder einem anderen gängigen Mikrocontroller (ESP32/ESP8266) verwendest, um Entfernungen zu messen.

Der VL53L1X ist ein sehr kleiner Time-of-Flight (ToF) Entfernungssensor, der infrarotes Laserlicht nutzt, um die Nähe eines Objekts zu messen. Durch die Messung der Zeit, die das Licht benötigt, um von einem Objekt reflektiert zu werden, kann er Entfernungen mit hoher Genauigkeit berechnen.

Benötigte Teile

Du benötigst einen VL53L1X Entfernungssensor. Als Mikrocontroller habe ich für dieses Projekt einen Arduino Uno verwendet, aber jeder andere Arduino oder ESP32/ESP8266 funktioniert ebenfalls. Außerdem verwenden wir ein OLED-Display, um die vom VL53L1X gemessenen Entfernungen anzuzeigen.

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.

Eigenschaften des VL53L1X

Der VL53L1X ist ein winziger Chip (4,4 x 2,5 x 1,56 mm) mit zwei Öffnungen oben. Eine für den Laserlicht-Emitter und eine für den Lichtsensor. Der VL53L1X arbeitet, indem er einen Laserlichtimpuls vom Emitter aussendet, das reflektierte Licht von einem Objekt am Detektor empfängt und basierend auf der benötigten Zeit (Time-of-Flight) die Entfernung zum Objekt berechnet. Das Bild unten zeigt die Emitter- und Detektorkegel.

Hier sind die Hauptspezifikationen des VL53L1X:

• 940 nm VCSEL-Emitter (IR-Licht, für das Auge unsichtbar)
• Messzeit 20 ms bis 1000 ms
• Programmierbare Region of Interest (ROI) Größe
• Programmierbare ROI-Position auf dem Empfangsarray
• Drei Distanzmodi: kurz, mittel und lang
• Entfernung zwischen 4 cm und 400 cm
• Auflösung: 1 mm
• Spannung: 2,6 bis 3,5 V
• I2C-Kommunikationsschnittstelle (bis zu 400 kHz)

Die programmierbaren Regionen of Interest (ROI) des VL53L1X erlauben es, das gesamte Sichtfeld zu verkleinern oder in mehrere Zonen zu unterteilen. Damit kannst du beispielsweise Gestenerkennung wie Wischen implementieren. Für mehr Details schau dir das Datenblatt des VL53L1X Sensors an:

VL53L1X als Teil eines LiDAR-Systems

Es gibt viele Anwendungen für Laser-Entfernungssensoren, wie Parkabstandswarnung, Einbruchserkennung, Hindernisvermeidung in der Robotik und mehr. Am wichtigsten werden Laser-Entfernungssensoren häufig in LiDAR Systemen eingesetzt, was für Licht Detektion und Reichweitenmessung steht und zur Erstellung hochpräziser 3D-Karten und Modelle verwendet wird.

Neben dem Laser-Entfernungssensor verfügt ein LiDAR-System typischerweise über eine GPS-Einheit und eine Trägheitsmesseinheit (IMU). Der Scanner ist ein Mechanismus, der den Laserstrahl über ein großes Gebiet bewegt, sodass das System Daten aus verschiedenen Winkeln und Positionen erfassen kann. Die GPS Einheit liefert genaue Standortdaten. Schließlich verfolgt die IMU die Orientierung und Bewegung des LiDAR-Systems, was für die Genauigkeit während des Scannens entscheidend ist.

Während die Laserimpulse ausgesendet und reflektiert werden, zeichnet das System kontinuierlich die Distanzmessungen zusammen mit den entsprechenden Winkeln und Positionen auf. Diese Daten werden dann verwendet, um eine Punktwolke zu erstellen, die die räumliche Verteilung der Objekte im gescannten Bereich darstellt.

Du kannst ein einfaches LiDAR selbst bauen, indem du den Laser-Entfernungssensor an einen Servo montierst und den Servo benutzt, um die Umgebung zu scannen, während der Sensor die Entfernungen misst. In diesem Tutorial verwenden wir jedoch nur den Laser-Entfernungssensor selbst, ohne ein Scan-Gerät.

Anwendungsschema des VL53L1X

Das folgende Anwendungsschema zeigt dir die externe Verkabelung, die nötig ist, um den VL53L1X Chip zu verwenden. Du siehst die Pull-up-Widerstände für die I2C-Schnittstelle, die den VL53L1X mit einem Mikrocontroller (Host) verbindet, sowie zwei Kondensatoren, die die Stromversorgung stabilisieren.

SDA und SCL sind die Pins für die I2C-Schnittstelle. XSHUT ist der Abschalt-Pin, mit dem du den Sensor ausschalten kannst, wenn er auf Masse gezogen wird. Das ist nützlich, wenn du mehrere VL53L1X Sensoren an derselben I2C-Leitung anschließen möchtest. GPIO1 ist ein Interrupt-Pin, der dem Mikrocontroller signalisiert, dass Daten bereitstehen.

Statt den winzigen VL53L1X Chip direkt zu verwenden, ist es besser, ein Breakout-Board zu nehmen, das die oben genannten Elektronikkomponenten bereits integriert hat und viel einfacher anzuschließen ist.

Breakout-Board für VL53L1X

Das folgende Bild zeigt die Rück- und Vorderseite eines typischen Breakout-Boards für den VL53L1X. Der eigentliche Sensorchip befindet sich hinter der ovalen Schutzabdeckung. Die Abdeckung reduziert den Einfluss von Umgebungslicht auf die Sensor-Genauigkeit.

Das Pinout hat die gleichen Pins wie oben beschrieben. SDA, SCL für I2C, GPIO1 als Interrupt-Signal, XSHUT für die Chip-Auswahl sowie VIN und GND für die Stromversorgung.

Anschluss des VL53L1X

Dank der I2C-Schnittstelle des VL53L1X ist der Anschluss an einen Arduino einfach. Verbinde zuerst die SCL- und SDA-Pins des VL53L1X Breakout-Boards mit den entsprechenden Pins am Arduino-Board wie unten gezeigt. Verbinde dann Masse mit GND und 3,3 V mit VIN des VL53L1X.

Das VL53L1X Breakout-Board läuft mit 5 V oder 3,3 V und du kannst entweder für VIN verwenden. Hier nutze ich 3,3 V für VIN. Als nächstes schreiben wir etwas Code, um die Funktion des VL53L1X Sensors zu testen.

Code zum Messen der Entfernung mit VL53L1X

Bevor du Entfernungen mit dem VL53L1X Sensor messen kannst, musst du eine Bibliothek installieren. Die gängigsten sind die Adafruit VL53L1X Library und die VL53L1X Library by Pololu. Ich hatte jedoch Probleme mit den Adafruit-Bibliotheken beim Schreiben des Tutorials für den VL53L0X Distance Sensor und werde daher die VL53L1X Library by Pololu verwenden. Sie bietet auch mehr Konfigurationsmöglichkeiten für den VL53L1X.

Installation der VL53L1X Bibliothek von Pololu

Um die VL53L1X Library by Pololu zu installieren, öffne den Library Manager, suche nach VL53L1X, finde die von Pololu und installiere sie. Das Bild unten zeigt, wie das aussieht, wenn die Bibliothek installiert ist:

Mit der installierten Bibliothek testen wir den Sensor. Der folgende Code liest die vom VL53L1X gemessenen Entfernungen aus und gibt sie im Serial Monitor aus.

#include "VL53L1X.h"

VL53L1X sensor;

void sensor_init(VL53L1X::DistanceMode range_mode, bool high_speed) {
  Wire.begin();
  sensor.setTimeout(500);
  sensor.init();
  sensor.setDistanceMode(range_mode);  
  int budget = high_speed ? 33000 : 140000;
  sensor.setMeasurementTimingBudget(budget);
}

void setup() {
  Serial.begin(9600);
  // range_mode: VL53L1X::Short, VL53L1X::Medium, or VL53L1X::Long
  sensor_init(VL53L1X::Medium, false);   
}

void loop() {
  int dist = sensor.readRangeSingleMillimeters();
  Serial.println(dist);
  delay(1000);
}

Lass uns den Code in seine Bestandteile zerlegen, um ihn besser zu verstehen.

Bibliothek einbinden

Der Code beginnt mit dem Einbinden der notwendigen Bibliothek für den VL53L1X Sensor. Diese Bibliothek stellt die Funktionen bereit, die für die Kommunikation mit dem Sensor nötig sind.

#include "VL53L1X.h"

Erstellen eines Sensor-Objekts

Als nächstes erstellen wir eine Instanz der VL53L1X Klasse, die uns die Interaktion mit dem Sensor ermöglicht.

VL53L1X sensor;

Sensor-Initialisierungsfunktion

Die sensor_init() Funktion ist für die Initialisierung des Sensors zuständig. Sie nimmt zwei Parameter: range_mode, der den Distanzmessmodus angibt, und high_speed, der das Messzeitbudget bestimmt.

void sensor_init(VL53L1X::DistanceMode range_mode, bool high_speed) {
  Wire.begin();
  sensor.setTimeout(500);
  sensor.init();
  sensor.setDistanceMode(range_mode);  
  int budget = high_speed ? 33000 : 140000;
  sensor.setMeasurementTimingBudget(budget);
}

Innerhalb dieser Funktion:

• Wire.begin(); initialisiert die I2C-Kommunikation.
• sensor.setTimeout(500); setzt ein Timeout für Sensoroperationen.
• sensor.init(); initialisiert den Sensor.
• sensor.setDistanceMode(range_mode); setzt den Distanzmodus basierend auf dem Eingabeparameter.
• Das Messzeitbudget wird basierend darauf gesetzt, ob hoher Geschwindigkeit gewünscht ist.

Laut dem datasheet sollte das VL53L1X Timing-Budget wie folgt gesetzt werden.

• 20 ms ist das minimale Timing-Budget und kann nur im Kurzdistanzmodus verwendet werden.
• 33 ms ist das minimale Timing-Budget, das für alle Distanzmodi funktioniert.
• 140 ms ist das Timing-Budget, das die maximale Entfernung von 4 m (im Dunkeln auf einer weißen Fläche) im Langdistanzmodus ermöglicht.

Im Code verwende ich 33 ms für den Geschwindigkeitsmodus, da er mit allen Reichweiten funktioniert, und ansonsten 140 ms, da es die maximale Entfernung erlaubt.

Für die Reichweite kannst du die vordefinierten Konstanten VL53L1X::Short, VL53L1X::Medium oder VL53L1X::Long verwenden. Die Reichweite, die der Sensor messen kann, hängt vom gewählten Modus und dem Umgebungslicht ab. Die folgende Tabelle aus dem datasheet des VL53L1X zeigt die Abhängigkeiten:

Der Langdistanzmodus ermöglicht die längste mögliche Reichweite von bis zu 4 m – unter idealen Bedingungen (dunkel). Generell wird die Reichweite durch Umgebungslicht beeinflusst. Der Kurzdistanzmodus ist unempfindlicher gegenüber Umgebungslicht, hat aber typischerweise eine maximale Reichweite von 1,3 m.

Setup-Funktion

In der setup() Funktion starten wir die serielle Kommunikation und initialisieren den Sensor mit einem bestimmten Distanzmodus.

void setup() {
  Serial.begin(9600);
  // range_mode: VL53L1X::Short, VL53L1X::Medium, or VL53L1X::Long
  sensor_init(VL53L1X::Medium, false);   
}

Hier richtet Serial.begin(9600); den Serial Monitor mit einer Baudrate von 9600 ein. Die sensor_init() Funktion wird mit VL53L1X::Medium als Reichweitenmodus und false für hohe Geschwindigkeit aufgerufen, was bedeutet, dass der Sensor im mittleren Bereich mit längerem Timing-Budget arbeitet.

Loop-Funktion

Schließlich lesen wir in der loop() Funktion kontinuierlich die Entfernung vom Sensor aus und geben sie im Serial Monitor aus.

void loop() {
  int dist = sensor.readRangeSingleMillimeters();
  Serial.println(dist);
  delay(1000);
}

Wenn du den Code hochlädst und ausführst, solltest du die gemessenen Entfernungen im Serial Monitor sehen.

Im nächsten Abschnitt fügen wir unserem Schaltkreis ein OLED hinzu und zeigen die Entfernungen darauf an, anstatt sie im Serial Monitor auszugeben.

OLED hinzufügen, um VL53L1X-Daten anzuzeigen

Da das OLED ebenfalls ein I2C-Gerät ist, ist der Anschluss einfach. Wir verbinden SDA und SCL einfach mit denselben Pins, an denen der VL53L1X Sensor angeschlossen ist. Und da das OLED mit 3,3 V läuft, können wir auch die Stromversorgungsleitungen teilen.

Code zur Anzeige der vom VL53L1X gemessenen Entfernungen auf dem OLED

Der folgende Code liest die Distanzmessungen vom VL53L1X Sensor aus und zeigt sie auf dem OLED an. Schau dir zuerst den kompletten Code an, dann besprechen wir die Details.

#include "Wire.h"
#include "VL53L1X.h"
#include "Adafruit_SSD1306.h"

Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL53L1X sensor;

void sensor_init(VL53L1X::DistanceMode range_mode, bool high_speed) {
  Wire.begin();
  sensor.setTimeout(500);
  sensor.init();
  sensor.setDistanceMode(range_mode); 
  int budget = high_speed ? 33000 : 140000;
  sensor.setMeasurementTimingBudget(budget);
}

void oled_init() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
}

void display() {
  static char text[30];
  int dist = sensor.readRangeSingleMillimeters();
  sprintf(text, "%4d mm", dist);

  oled.clearDisplay();
  oled.setCursor(20, 25);
  oled.print(text);

  oled.display();
}

void setup() {
  oled_init();
  sensor_init(VL53L1X::Medium, false); 
}

void loop() {
  display();
}

Lass uns den Code in seine Teile zerlegen, um ihn besser zu verstehen.

Bibliothekseinbindungen

Am Anfang des Codes binden wir die notwendigen Bibliotheken für unser Projekt ein. Die Wire.h Bibliothek wird für die I2C-Kommunikation verwendet, VL53L1X.h ist für die Ansteuerung des VL53L1X Entfernungssensors und Adafruit_SSD1306.h für die Steuerung des OLED-Displays.

#include "Wire.h"
#include "VL53L1X.h"
#include "Adafruit_SSD1306.h"

Falls du die Adafruit_SSD1306 Library noch nicht installiert hast, musst du das tun. Einfach wie gewohnt über den Library Manager installieren:

Beachte, dass die I2C-Adresse für das OLED-Display auf 0x3C in oled.begin() gesetzt ist. Die meisten dieser kleinen OLEDs verwenden diese Adresse (or 0x27), aber deine könnte anders sein. Wenn du nichts auf dem OLED siehst, hat es höchstwahrscheinlich eine andere I2C-Adresse und du musst die Adresse ändern.

Wenn du die I2C-Adresse nicht kennst, schau dir das How to Interface the SSD1306 I2C OLED Graphic Display With Arduino Tutorial an, um sie herauszufinden. Auch das Use SSD1306 I2C OLED Display With Arduino Tutorial erklärt dir mehr darüber, wie man ein OLED verwendet.

Objektinitialisierung

Als nächstes erstellen wir Instanzen des OLED-Displays und des Entfernungssensors. Das OLED-Display wird mit einer Breite von 128 Pixeln und einer Höhe von 64 Pixeln initialisiert. Der &Wire Parameter zeigt an, dass wir die Wire-Bibliothek für die I2C-Kommunikation verwenden, und -1 zeigt, dass wir keinen Reset-Pin nutzen.

Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL53L1X sensor;

Sensor-Initialisierungsfunktion

Die sensor_init() Funktion initialisiert den VL53L1X Sensor. Sie nimmt zwei Parameter: range_mode, um den Distanzmessmodus einzustellen, und high_speed, um das Messzeitbudget zu bestimmen. Innerhalb der Funktion starten wir die I2C-Kommunikation, setzen ein Timeout für den Sensor, initialisieren ihn und konfigurieren den Distanzmodus. Das Messzeitbudget wird basierend darauf gesetzt, ob hohe Geschwindigkeit aktiviert ist oder nicht.

void sensor_init(VL53L1X::DistanceMode range_mode, bool high_speed) {
  Wire.begin();
  sensor.setTimeout(500);
  sensor.init();
  sensor.setDistanceMode(range_mode); 
  int budget = high_speed ? 33000 : 140000;
  sensor.setMeasurementTimingBudget(budget);
}

OLED-Initialisierungsfunktion

Die oled_init() Funktion initialisiert das OLED-Display. Sie beginnt damit, das Display mit dem SSD1306_SWITCHCAPVCC Parameter einzuschalten und die I2C-Adresse auf 0x3C zu setzen. Außerdem stellen wir die Textgröße auf 2 und die Textfarbe auf Weiß.

void oled_init() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
}

Anzeige-Funktion

Die display() Funktion liest die Entfernung vom Sensor aus und zeigt sie auf dem OLED-Bildschirm an. Zuerst wird ein statisches Zeichenarray text deklariert, um den Entfernungsstring zu speichern. Die Entfernung wird in Millimetern mit sensor.readRangeSingleMillimeters() gelesen und das Ergebnis mit text in das sprintf() Array formatiert. Das OLED-Display wird dann gelöscht, der Cursor auf eine bestimmte Position gesetzt und die Entfernung ausgegeben. Schließlich wird das Display aktualisiert, um den neuen Inhalt anzuzeigen.

void display() {
  static char text[30];
  int dist = sensor.readRangeSingleMillimeters();
  sprintf(text, "%4d mm", dist);

  oled.clearDisplay();
  oled.setCursor(20, 25);
  oled.print(text);

  oled.display();
}

Setup-Funktion

In der setup() Funktion rufen wir die Initialisierungsfunktionen für das OLED-Display und den Entfernungssensor auf. Der Sensor wird mit einem mittleren Reichweitenmodus und deaktivierter hoher Geschwindigkeit initialisiert.

void setup() {
  oled_init();
  sensor_init(VL53L1X::Medium, false); 
}

Loop-Funktion

Schließlich ruft die loop() Funktion kontinuierlich die display() Funktion auf, die den OLED-Bildschirm mit der neuesten Distanzmessung vom Sensor aktualisiert. Diese Schleife läuft ununterbrochen und liefert Echtzeit-Entfernungswerte.

void loop() {
  display();
}

Fazit

In diesem Tutorial hast du gelernt, wie du den VL53L1X Entfernungssensor mit einem Arduino benutzt, um Entfernungen zu messen und sie auf einem OLED anzuzeigen.

Der VL53L1X Sensor ist ein sehr kleiner, schneller, hochpräziser Sensor, der infrarotes Laserlicht zur Entfernungsmessung nutzt. Der VL53L1X ist fast identisch mit dem VL53L0X, hat aber eine größere Reichweite. Ersterer kann Entfernungen bis zu 400 cm messen, während letzterer auf 200 cm begrenzt ist. Wenn du einen Sensor für eine viel größere Reichweite brauchst, schau dir den TF Luna an, der Entfernungen bis zu 8 Meter messen kann.

Ein weiterer ähnlicher Laser-Entfernungssensor, der die Time-of-Flight-Methode verwendet, ist der TOF10120 Sensor. Der VL53L1X bietet jedoch mehr Konfigurationsmöglichkeiten (lange Reichweite, schnelle Geschwindigkeit) und hat eine größere Reichweite (bis zu 400 cm vs. 180 cm).

Andere gängige Infrarot-Entfernungssensoren wie der GP2Y0A710K0F oder der GP2Y0A21YK0F verwenden Triangulation, um die Entfernung basierend auf dem Winkel des reflektierten IR-Lichts zu bestimmen, und haben eine kürzere Reichweite sowie geringere Genauigkeit.

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

Viel Spaß beim Tüfteln ; )