In diesem Tutorial lernst du, wie du den VL53L0X (auch TOF0200C genannt) Distanzsensor mit einem Arduino oder einem anderen gängigen Mikrocontroller (ESP32/ESP8266) verwendest, um Entfernungen zu messen.
Der VL53L0X ist ein sehr kleiner Time-of-Flight Distanzsensor (ToF), der infrarotes Laserlicht nutzt, um die Entfernung zu einem Objekt zu messen. Indem er die Zeit misst, die das Licht benötigt, um von einem Objekt reflektiert zu werden, kann er Entfernungen mit hoher Genauigkeit berechnen. Die kompakte Größe und der geringe Stromverbrauch des Sensors machen ihn für eine Vielzahl von DIY-Projekten geeignet, darunter Robotik, Gestenerkennung und Näherungserkennung.
Benötigte Teile
Natürlich benötigst du einen VL53L0X Distanzsensor. Als Mikrocontroller habe ich für dieses Projekt einen Arduino Uno verwendet, aber jeder andere Arduino oder ESP32/ESP8266 funktioniert ebenfalls gut. Um die gemessenen Entfernungen anzuzeigen, habe ich ein OLED gewählt, aber du könntest auch ein LCD display.
VL53L0X Distanzsensor
Arduino Uno
USB-Kabel für Arduino UNO
Dupont-Kabelset
Breadboard
OLED-Display
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 VL53L0X
Der VL53L0X selbst ist ein winziger Chip (4,4 x 2,4 x 1,0 mm) mit zwei Öffnungen oben. Eine für den Laserlicht-Emitter und eine für den Lichtsensor. Das Bild unten zeigt den Chip:
Der VL53L0X 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 Kegel des Emitters und Detektors.
Hier sind die Hauptspezifikationen des VL53L0X:
- 940 nm VCSEL-Emitter (IR-Licht, für das Auge unsichtbar)
- Messzeit 30 ms
- Entfernung bis zu 2 m
- Funktioniert bei schwachem Licht und niedrigem Kontrast
- Spannung: 2,6 V – 5,5 V
- I2C-Kommunikationsschnittstelle
Weitere Details findest du im Datenblatt
Anwendungsschaltplan des VL53L0X
Der folgende Anwendungsschaltplan zeigt dir die externe Verkabelung, die für die Nutzung des VL53L0X nötig ist. Du siehst die Pull-up-Widerstände für die I2C-Schnittstelle, die den VL53L0X mit einem Mikrocontroller (Host) verbindet, sowie zwei Kondensatoren zur Stabilisierung der Stromversorgung.
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 LOW gezogen wird. Das ist nützlich, wenn du mehrere VL53L0X-Sensoren an derselben I2C-Leitung anschließen möchtest. GPIO1 ist ein Interrupt-Pin, der dem Mikrocontroller signalisiert, dass Daten bereitstehen.
Anstatt den winzigen VL53L0X 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 VL53L0X
Das folgende Bild zeigt ein typisches Breakout-Board für den VL53L0X. Das weiße Rechteck markiert die Stelle, an der sich der eigentliche VL53L0X-Chip befindet.
Das Pinout hat die zuvor besprochenen Pins: SDA, SCL für I2C, GPIO1 als Interrupt-Signal, XSHUT für die Chip-Auswahl sowie VIN und GND für die Stromversorgung. Beachte, dass du XSHUT auf LOW ziehen musst, wenn du den Chip abschalten möchtest.
Anschluss des VL53L0X
Dank der I2C-Schnittstelle des VL53L0X ist der Anschluss an einen Arduino einfach. Verbinde zuerst die SCL- und SDA-Pins des VL53L0X-Breakout-Boards mit den entsprechenden Pins am Arduino-Board, wie unten gezeigt. Verbinde dann Masse mit GND und 3,3 V mit VIN des VL53L0X.
Das VL53L0X-Breakout-Board läuft mit 5 V oder 3,3 V, du kannst also entweder für VIN verwenden. In der obigen Verkabelung verwende ich 3,3 V für VIN.
Als nächstes schreiben wir etwas Code, um die Funktion des VL53L0X-Sensors zu testen.
Code zum Messen der Entfernung mit VL53L0X
Bevor du Entfernungen mit dem VL53L0X messen kannst, musst du eine Bibliothek installieren. Ich verwende die Adafruit VL53L0X Library hier. Du kannst sie install it via the Library Manager wie gewohnt installieren:
Der Installer fragt dich möglicherweise, ob du nur die Bibliothek oder die Bibliothek mit ihren Abhängigkeiten installieren möchtest. Drücke in diesem Fall einfach „INSTALL ALL“:
Mit der installierten Bibliothek führen wir nun einen einfachen Testcode aus, um den Sensor zu testen.
// Measure distance with VL53L0X sensor
// by Makerguides
#include "Adafruit_VL53L0X.h"
Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
void setup() {
Serial.begin(9600);
sensor.begin();
}
void loop() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
if(measure.RangeStatus == 4) {
Serial.println("---");
} else {
Serial.println(measure.RangeMilliMeter);
}
delay(100);
}
Wie du siehst, bindet der Code die Adafruit_VL53L0X.h Bibliothek ein und erstellt das Sensorobjekt. In der setup() Funktion initialisieren wir den Sensor über sensor.begin(). In der loop()-Funktion erstellen wir ein measure Objekt, das die Messdaten durch Aufruf von sensor.rangingTest() empfängt. Wenn der RangeStatus Wert 4 ist, bedeutet das, dass kein Objekt erkannt wurde, und wir geben „—“ aus. Andernfalls holen wir die Entfernung aus RangeMilliMeter und geben sie aus.
Wenn du den obigen Code auf deinen Arduino hochlädst, solltest du Entfernungswerte im Serial Monitor sehen. Wenn kein Objekt vor dem Sensor ist oder es zu weit entfernt ist, wird „—“ angezeigt.
Wenn du Probleme hast und der Sensor nicht zu funktionieren scheint, überprüfe, ob die Verkabelung korrekt ist und die richtigen SDA- und SCL-Pins an deinem Mikrocontroller verwendet werden. Du kannst auch die Laserdiode des Sensors überprüfen, indem du ein Foto mit einer Digitalkamera (Handy) machst. Während IR-Licht für das menschliche Auge unsichtbar ist, kann die Kamera es sehen, und auf dem Kamerabildschirm solltest du das Flackern der Laser-LED (alle 100 ms) erkennen.
Verwendung der VL53L0X Bibliothek von Pololu
Ich hatte erhebliche Schwierigkeiten, die Adafruit VL53L0X Library mit Code zum Laufen zu bringen, der die Adafruit_SSD1306 Library verwendet, um die Entfernungen auf einem OLED anzuzeigen. Mehr dazu im nächsten Abschnitt.
Hier möchte ich dir nur eine alternative Implementierung zeigen, die die VL53L0X Library by Pololu verwendet. Abgesehen davon, dass sie besser mit dem OLED-Display funktioniert, bietet sie auch mehr Konfigurationsmöglichkeiten für den VL53L0X. Zum Beispiel kannst du zwischen Langstrecken- oder Kurzstreckenmodus und zwischen langsamem oder schnellem Modus wechseln.
Installation der VL53L0X Bibliothek von Pololu
Um die VL53L0X Library by pololu zu installieren, suche einfach nach VL53L0X, finde die von Pololu wie unten gezeigt und installiere sie mit dem Library Manager. Das Bild unten zeigt, wie das aussieht, wenn die Bibliothek installiert ist:
Codebeispiel für die VL53L0X Bibliothek von Pololu
Und hier ist das Codebeispiel, das Pololus Bibliothek für den VL53L0X verwendet, um Entfernungen zu messen:
#include "Wire.h"
#include "VL53L0X.h"
VL53L0X sensor;
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
void setup() {
Serial.begin(9600);
sensor_init(true, false);
}
void loop() {
Serial.println(get_distance());
}
Wir beginnen mit dem Einbinden der Wire.h und der VL53L0X.h Bibliothek und erstellen dann das Sensorobjekt.
Die sensor_init() Funktion konfiguriert den Sensor. Sie erlaubt dir, zwischen Kurz- oder Langstreckenmodus und zwischen hoher und niedriger Messgeschwindigkeit zu wechseln. Beachte, dass Langstrecken- und Schnellmodus weniger genau sind. Die folgenden zwei Tabellen aus dem datasheet zeigen dir die Kompromisse zwischen Geschwindigkeit, Reichweite und Genauigkeit:
Die get_distance() Funktion gibt die gemessene Entfernung in Millimetern zurück. Wenn das Objekt außerhalb der Reichweite ist, gibt der Sensor den Wert 8190 zurück. Ich habe festgestellt, dass du im Langstreckenmodus bis zu 2400 mm und im Kurzstreckenmodus bis zu 1300 mm messen kannst. Das war drinnen vor einer weißen Wand.
In der setup() Funktion initialisieren wir den Sensor und in der loop() Funktion holen wir die Entfernung und geben sie im Serial Monitor aus.
Wenn du den Code hochlädst und ausführst, solltest du die gemessenen Entfernungen im Serial Monitor sehen.
Beachte, dass die Ausgabe mit einer Entfernung von 8190 beginnt, was bedeutet, dass kein Objekt nah genug am Sensor erkannt wurde. Ich habe dann den Sensor zur Decke gerichtet und eine Entfernung von etwa 1700 mm gemessen und schließlich meine Hand in etwa 100 mm Entfernung vor den Sensor gehalten.
Im nächsten Abschnitt fügen wir unserem Schaltkreis ein OLED hinzu und verwenden dann beide Bibliotheken (Adafruit, Pololu), um Entfernungen zu messen und anzuzeigen.
Hinzufügen eines OLED zur Anzeige der VL53L0X-Daten
Da das OLED ebenfalls ein I2C-Gerät ist, ist der Anschluss einfach. Wir verbinden einfach SDA und SCL mit denselben Pins, an denen der VL53L0X-Sensor angeschlossen ist. Und da das OLED mit 3,3 V läuft, können wir auch die Stromversorgungsleitungen teilen.
Das Foto unten zeigt die komplette Verkabelung auf einem echten Breadboard:
Wenn du Schwierigkeiten mit dem OLED hast, schau dir das Tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino an.
Installation der Adafruit_SSD1306 OLED Bibliothek
In den folgenden zwei Abschnitten schreiben wir Code, um die vom VL53L0X gemessene Entfernung auf einem OLED-Display anzuzeigen. Im ersten Abschnitt verwenden wir Adafruits Bibliothek für den VL53L0X und im zweiten Abschnitt verwenden wir Pololus Bibliothek.
Bevor wir jedoch etwas auf dem OLED anzeigen können, müssen wir eine weitere Bibliothek installieren. In diesem Tutorial verwenden wir die Adafruit_SSD1306 Bibliothek, die du wie gewohnt über den Library Manager installieren kannst. Das Bild unten zeigt die Bibliothek nach der Installation:
Beachte, dass die I2C-Adresse für das OLED-Display in 0x3C auf oled.begin() eingestellt 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.
Anzeige der mit Adafruits VL53L0X Bibliothek gemessenen Entfernungen auf OLED
Der folgende Code verwendet Adafruits VL53L0X Bibliothek, um Entfernungen vom VL53L0X-Sensor zu lesen und diese dann auf dem OLED anzuzeigen. Schau dir zuerst den kompletten Code an, dann gehen wir auf die Details ein.
// Measure distance with VL53L0X sensor and show on OLED
// by Makerguides
#include "Adafruit_VL53L0X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled = Adafruit_SSD1306();
Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
oled.clearDisplay();
oled.setCursor(25, 10);
if (measure.RangeStatus == 4) {
oled.print(" -----");
} else {
oled.print(measure.RangeMilliMeter);
oled.print(" mm");
}
oled.display();
}
void setup() {
oled_init();
sensor.begin();
}
void loop() {
display();
delay(100);
}
Bibliotheken
Wir beginnen mit dem Einbinden der Adafruit_VL53L0X Bibliothek für den VL53L0X-Sensor und der Adafruit_SSD1306 Library für das OLED-Display.
#include "Adafruit_VL53L0X.h" #include "Adafruit_SSD1306.h"
Objekte
Als nächstes erstellen wir die sensor und die oled Objekte:
Adafruit_SSD1306 oled = Adafruit_SSD1306(); Adafruit_VL53L0X sensor = Adafruit_VL53L0X();
oled_init Funktion
Die oled_init() Funktion initialisiert das OLED und setzt die Textgröße und Farbe:
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Beachte, dass die I2C-Adresse für das OLED-Display in 0x3C auf oled.begin() eingestellt ist. Die meisten dieser kleinen OLEDs verwenden diese Adresse, 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.
display Funktion
Die display() Funktion ruft zuerst rangingTest() auf, um die Entfernung zu messen. Dann löschen wir das Display, setzen die Cursorposition und geben die Entfernung aus. Wenn keine Entfernung gemessen werden konnte (RangeStatus == 4), zeigen wir „—-“ an, um anzuzeigen, dass kein Objekt in Reichweite war:
void display() {
VL53L0X_RangingMeasurementData_t measure;
sensor.rangingTest(&measure, false);
oled.clearDisplay();
oled.setCursor(25, 10);
if (measure.RangeStatus == 4) {
oled.print(" -----");
} else {
oled.print(measure.RangeMilliMeter);
oled.print(" mm");
}
oled.display();
}
setup und loop Funktionen
In der setup() Funktion rufen wir die Initialisierer für das OLED und den VL53L0X-Sensor auf, und in der loop() Funktion zeigen wir die gemessene Entfernung alle 100 ms an:
void setup() {
oled_init();
sensor.begin();
}
void loop() {
display();
delay(100);
}
Probleme mit der Adafruit_VL53L0X Bibliothek
Beim Schreiben des obigen Codes bin ich auf mehrere Probleme gestoßen. Erstens konnte ich meinen üblichen Code zur Objekterstellung für das OLED-Objekt nicht verwenden:
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Zweitens konnte ich die sprintf() Funktion nicht verwenden, um formatierten Text in einen Puffer zu schreiben, der auf dem OLED angezeigt werden soll.
In beiden Fällen wurde der Code kompiliert und konnte hochgeladen werden, aber das Programm lief nicht, ohne Fehlermeldungen anzuzeigen. Ich vermute, dass es einen Speicherzugriffskonflikt zwischen den Adafruit_SSD1306 und Adafruit_VL53L0X Bibliotheken gibt.
Aufgrund dieser Probleme mit der Adafruit_VL53L0X Bibliothek habe ich beschlossen, eine andere Bibliothek auszuprobieren. Im folgenden Abschnitt zeige ich dir den Code, der Pololus VL53L0X Bibliothek verwendet.
Anzeige der mit Pololus VL53L0X Bibliothek gemessenen Entfernungen auf OLED
Der folgende Code verwendet Pololus Bibliothek für den VL53L0X, um Entfernungen vom VL53L0X-Sensor zu lesen und auf dem OLED anzuzeigen.
#include "Wire.h"
#include "VL53L0X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL53L0X sensor;
const int maxdist = 2400;
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
int dist = get_distance();
if (dist > maxdist)
sprintf(text, " -----");
else
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
int w = map(dist, 0, maxdist, 0, 120);
oled.drawFastHLine(4, 45, w, WHITE);
oled.display();
}
void setup() {
oled_init();
sensor_init(true, false);
}
void loop() {
display();
}
Wenn du den Code hochlädst und ausführst, solltest du Entfernungen in Millimetern auf dem OLED sehen, mit einer darunterliegenden Leiste, deren Länge proportional zur Entfernung ist.
Wenn sich nichts vor dem Sensor befindet (oder weiter als 2 m entfernt ist), zeigt das Display die maximale Entfernung „—–“ und eine Leiste in voller Länge an.
Bibliotheken
Wir beginnen mit dem Einbinden der benötigten Bibliotheken für das OLED und den VL53L0X. In diesem Codebeispiel verwenden wir Pololus VL53L0X Bibliothek, um Entfernungsdaten vom VL53L0X-Sensor zu lesen.
#include "Wire.h" #include "VL53L0X.h" #include "Adafruit_SSD1306.h"
Objekte und Konstanten
Als nächstes erstellen wir die oled und die sensor Objekte. Mit Pololus VL53L0X Bibliothek hatte ich keine Schwierigkeiten, das oled Objekt auf die übliche Weise zu erstellen (oled(128, 64, &Wire, -1)), während dieser Code mit Adafruits VL53L0X Bibliothek nicht funktionierte.
Adafruit_SSD1306 oled(128, 64, &Wire, -1); VL53L0X sensor; const int maxdist = 2400;
Die Konstante maxdist gibt die maximale Entfernung an, die der Code melden wird. Darüber hinaus signalisiert der Code, dass kein Objekt erkannt wurde.
sensor_init und get_distance Funktionen
Die sensor_init() und get_distance() Funktionen sind wie zuvor. sensor_init() initialisiert den VL53L0X-Sensor und setzt die verschiedenen Betriebsmodi, während get_distance() die gemessene Entfernung vom VL53L0X liest.
void sensor_init(bool long_range, bool high_speed) {
Wire.begin();
sensor.setTimeout(500);
sensor.init();
if (long_range) {
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
}
int budget = high_speed ? 20000 : 200000;
sensor.setMeasurementTimingBudget(budget);
}
int get_distance() {
return sensor.readRangeSingleMillimeters();
}
oled_init Funktion
Die oled_init() Funktion bleibt ebenfalls unverändert. Sie initialisiert das OLED und setzt die Textgröße und Farbe.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
display Funktion
Die display() Funktion holt die gemessene Entfernung vom VL53L0X-Sensor. Wenn die Entfernung größer als maxdist ist, geht sie davon aus, dass kein Objekt in Reichweite war, und zeigt „—–“ auf dem OLED an. Andernfalls wird der Entfernungswert ausgegeben.
void display() {
static char text[30];
int dist = get_distance();
if (dist > maxdist)
sprintf(text, " -----");
else
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
int w = map(dist, 0, maxdist, 0, 120);
oled.drawFastHLine(4, 45, w, WHITE);
oled.display();
}
Zusätzlich zur Textausgabe zeichnet die display() Funktion auch eine horizontale Linie unter dem Text, deren Länge proportional zur gemessenen Entfernung ist.
setup und loop Funktion
Die setup-Funktion initialisiert das OLED und den VL53L0X-Sensor. Der Sensormodus ist auf Langstrecke und Standardgeschwindigkeit (sensor_init(true, false)) eingestellt.
In der loop() Funktion rufen wir einfach die display() Funktion auf. Die loop läuft mit der maximalen Geschwindigkeit, mit der der Sensor Daten liefern kann (etwa 30 ms bei Standardgeschwindigkeit).
void setup() {
oled_init();
sensor_init(true, false);
}
void loop() {
display();
}
Und das war’s. Jetzt hast du dein eigenes Entfernungsmessgerät
Fazit
In diesem Tutorial hast du gelernt, wie du den VL53L0X Distanzsensor mit einem Arduino verwendest, um Entfernungen zu messen und diese auf einem OLED anzuzeigen.
Der VL53L0X Sensor ist ein sehr kleiner, schneller, hochpräziser Sensor, der infrarotes Laserlicht zur Entfernungsmessung nutzt. Der VL53L0X ist dem TOF10120 Sensor in Dimension, Funktion und Eigenschaften sehr ähnlich. Beide Sensoren verwenden die Time-of-Flight-Methode zur Berechnung der Entfernung zu einem Objekt. Der VL53L0X bietet mehr Konfigurationsmöglichkeiten (Langstrecke, schnelle Geschwindigkeit) und kann im Langstreckenmodus Objekte etwas weiter entfernt erkennen (2400 mm vs. 1800 mm), allerdings mit geringerer Genauigkeit.
Andere 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 und geringere Genauigkeit.
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln ; )
