So misst du Entfernungen mit dem VL53L0X-Sensor und dem Arduino UNO

In diesem Tutorial erfährst du, wie du ganz einfach den VL53L0X-Sensor mit deinem Arduino UNO verbindest und verwendest. Mit diesem faszinierenden Sensor kannst du präzise Entfernungen messen, und das mit einer Reichweite von bis zu 2 Metern.

Was ist der VL53L0X-Sensor?

Der VL53L0X ist ein Time-of-Flight (ToF)-Laserabstandssensor, der mithilfe von Infrarot-Licht die Entfernung zu einem Objekt misst. Er ist kompakt und leicht zu integrieren, was ihn ideal für die Anwendung in Roboterprojekten, Drohnen oder zur Objekterkennung macht.

Ein Wort zur Reichweite: Die 2 Meter aus dem Datenblatt sind ein Bestwert unter Idealbedingungen – also bei wenig Umgebungslicht und einer hellen, matten Oberfläche. In der Praxis solltest du eher mit rund 1,2 Metern rechnen. Dunkle oder stark spiegelnde Objekte schlucken bzw. streuen das Infrarotlicht und verkürzen die Reichweite zusätzlich. Wenn dein Sensor also bei 80 cm aussteigt, ist er nicht defekt – er misst nur gerade eine schwarze Fläche.

Verkabelung des Sensors mit dem Arduino UNO

Bevor wir anfangen, den Sensor zu programmieren, müssen wir ihn erst einmal mit dem Arduino UNO verbinden. Die Verkabelung ist denkbar einfach:

1. Verbinde den VCC (oder auch VIN)-Pin des VL53L0X mit dem 5V-Pin des Arduino UNO.
2. Verbinde den GND-Pin des Sensors mit dem GND-Pin des Arduino UNO.
3. Verbinde den SDA-Pin mit dem A4-Pin (SDA) des Arduino UNO.
4. Verbinde den SCL-Pin mit dem A5-Pin (SCL) des Arduino UNO.

Achtung bei der Spannung: Die 5V gelten nur für Breakout-Boards mit eigenem Spannungsregler und Level-Shifter – dazu gehören die verbreiteten GY-530 bzw. GY-VL53L0XV2 sowie die Platine von Adafruit. Der nackte Sensorchip selbst verträgt nur 3,3 V. Wenn du dir bei deinem Board nicht sicher bist, schließe VCC an den 3,3V-Pin des Arduino an – das funktioniert in beiden Fällen.

Programmierung des Arduino UNO

Um den VL53L0X-Sensor verwenden zu können, musst du zunächst die passende Bibliothek in deiner Arduino IDE installieren. Suche hierfür im Bibliotheksmanager nach „VL53L0X“ und installiere die Bibliothek „VL53L0X“ von Pololu.

Jetzt können wir mit dem Programmieren beginnen! Erstelle einen neuen Sketch und füge den folgenden Code ein:

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  if (!sensor.init()) {
    Serial.println("Sensor nicht gefunden - bitte Verkabelung pruefen!");
    while (1);
  }

  sensor.setTimeout(500);

  Serial.println("VL53L0X-Sensor bereit!");
}

void loop() {
  uint16_t distance = sensor.readRangeSingleMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.println("Timeout!");
  } else {
    Serial.print("Abstand: ");
    Serial.print(distance);
    Serial.println(" mm");
  }

  delay(1000);
}

Lade den Sketch auf deinen Arduino UNO hoch und öffne den seriellen Monitor. Du solltest nun jede Sekunde die gemessene Entfernung in Millimetern angezeigt bekommen.

Wie funktioniert der Code?

Lass uns einen Blick auf die einzelnen Bestandteile des Codes werfen, um besser zu verstehen, wie das Programm funktioniert: Zuerst binden wir die benötigten Bibliotheken ein, nämlich Wire.h für die I2C-Kommunikation und VL53L0X.h für den Sensor.

#include <Wire.h>
#include <VL53L0X.h>

Danach erstellen wir ein Objekt sensor der Klasse VL53L0X.

VL53L0X sensor;

In der Setup-Funktion initialisieren wir die serielle Kommunikation mit einer Baudrate von 9600, die I2C-Kommunikation und den Sensor.

Wichtig ist dabei die Abfrage von sensor.init(): Diese Funktion gibt true zurück, wenn der Sensor gefunden wurde – und false, wenn nicht. Ohne diese Prüfung würde der Sketch scheinbar ganz normal weiterlaufen und dir munter Unsinnswerte ausgeben, obwohl der Sensor gar nicht antwortet. Genau das ist der häufigste Grund, warum dieses Projekt beim ersten Versuch nicht klappt. Schlägt die Initialisierung fehl, bleiben wir daher mit while (1); absichtlich stehen und geben eine klare Meldung aus.

Anschließend setzen wir ein Timeout von 500 ms für den Sensor, damit das Programm nicht ewig hängt, falls es Probleme bei der Messung geben sollte.

void setup() {
  Serial.begin(9600);
  Wire.begin();

  if (!sensor.init()) {
    Serial.println("Sensor nicht gefunden - bitte Verkabelung pruefen!");
    while (1);
  }

  sensor.setTimeout(500);

  Serial.println("VL53L0X-Sensor bereit!");
}

In der loop()-Funktion lesen wir die Entfernung in Millimetern mit sensor.readRangeSingleMillimeters() und speichern den Wert in der Variable distance. Anschließend prüfen wir mit sensor.timeoutOccurred(), ob die Messung überhaupt geklappt hat: Nur wenn kein Timeout aufgetreten ist, geben wir den Abstand auf dem seriellen Monitor aus. Danach warten wir eine Sekunde, bevor wir die nächste Messung durchführen.

Ein Detail, das leicht übersehen wird: Die Variable distance ist ein uint16_t und kein int. Der Grund: Bei einem Timeout liefert die Bibliothek den Wert 65535 zurück. Ein int ist auf dem Arduino UNO aber nur 16 Bit groß und vorzeichenbehaftet – aus 65535 würde dort also ein -1, und du bekämst einen negativen Abstand angezeigt. Mit uint16_t bleibt der Wert das, was er sein soll.

void loop() {
  uint16_t distance = sensor.readRangeSingleMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.println("Timeout!");
  } else {
    Serial.print("Abstand: ");
    Serial.print(distance);
    Serial.println(" mm");
  }

  delay(1000);
}

Damit funktioniert die Entfernungsmessung schon einmal grundsätzlich. Der serielle Monitor ist allerdings nur so lange praktisch, wie dein Projekt am Computer hängt. Bringen wir die Messwerte also als Nächstes auf ein eigenes Display.

Die Entfernung auf einem OLED-Display anzeigen

Was du zusätzlich benötigst

Um das Projekt zu erweitern und die gemessene Entfernung auf einem OLED-Display anzuzeigen, benötigst du zusätzlich:

• Ein I2C-OLED-Display (128×64 Pixel, z.B. SSD1306)
• Ein paar zusätzliche Jumper-Kabel

Verkabelung des OLED-Displays mit dem Arduino UNO

Die Verkabelung des OLED-Displays ist ähnlich einfach wie beim VL53L0X-Sensor:

1. Verbinde den VCC-Pin des OLED-Displays mit dem 5V-Pin des Arduino UNO.
2. Verbinde den GND-Pin des OLED-Displays mit dem GND-Pin des Arduino UNO.
3. Verbinde den SDA-Pin des OLED-Displays mit dem A4-Pin (SDA) des Arduino UNO.
4. Verbinde den SCL-Pin des OLED-Displays mit dem A5-Pin (SCL) des Arduino UNO.

Da das OLED-Display und der VL53L0X-Sensor beide I2C-Geräte sind, können sie gemeinsam an den I2C-Bus des Arduino UNO angeschlossen werden.

Die Bibliotheken installieren

Um das OLED-Display zu verwenden, musst du zunächst die passenden Bibliotheken in deiner Arduino IDE installieren. Hierzu gehst du wie folgt vor:

1. Suche im Bibliotheksmanager nach „Adafruit SSD1306“ und installiere die Bibliothek „Adafruit SSD1306 by Adafruit“.
2. Suche im Bibliotheksmanager nach „Adafruit GFX“ und installiere die Bibliothek „Adafruit GFX Library by Adafruit“.

Der erweiterte Code

Jetzt können wir den Code erweitern, um das OLED-Display zu nutzen. Erstelle einen neuen Sketch oder bearbeite den bestehenden und füge den folgenden Code ein:

#include <Wire.h>
#include <VL53L0X.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_ADDRESS 0x3C

VL53L0X sensor;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

void setup() {
  Serial.begin(9600);
  Wire.begin();

  if (!sensor.init()) {
    Serial.println("Sensor nicht gefunden - bitte Verkabelung pruefen!");
    while (1);
  }

  sensor.setTimeout(500);

  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
    Serial.println("Display nicht gefunden - Adresse 0x3D probieren!");
    while (1);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);

  Serial.println("VL53L0X-Sensor bereit!");
}

void loop() {
  uint16_t distance = sensor.readRangeSingleMillimeters();

  display.clearDisplay();
  display.setCursor(0, 0);

  if (sensor.timeoutOccurred()) {
    Serial.println("Timeout!");
    display.print("Timeout!");
  } else {
    Serial.print("Abstand: ");
    Serial.print(distance);
    Serial.println(" mm");

    display.print("Abstand: ");
    display.print(distance);
    display.print(" mm");
  }

  display.display();

  delay(1000);
}

Falls dein Display schwarz bleibt: Die meisten SSD1306-Displays hören auf die I2C-Adresse 0x3C – manche aber auf 0x3D. Ändere in diesem Fall einfach die Zeile #define OLED_ADDRESS 0x3C entsprechend ab. Dank der Prüfung von display.begin() weist dich der serielle Monitor auch von selbst darauf hin.

Lade den Sketch auf deinen Arduino UNO hoch. Die gemessene Entfernung sollte nun auf dem OLED-Display angezeigt werden.

Schneller messen: der Continuous Mode

Mit readRangeSingleMillimeters() stößt du für jede Messung einen kompletten Einzelvorgang an – zusammen mit dem delay(1000) bekommst du also genau einen Messwert pro Sekunde. Für eine Anzeige auf dem Display reicht das völlig. Sobald dein Projekt aber reagieren soll, etwa als Hinderniserkennung für einen Roboter, ist das viel zu langsam.

Für solche Fälle bietet die Bibliothek den Continuous Mode: Der Sensor misst dabei permanent im Hintergrund, und du holst dir einfach den jeweils aktuellsten Wert ab. Dazu startest du den Modus einmalig im setup():

// im setup(), nach sensor.setTimeout(500):
sensor.startContinuous();

Im Loop tauschst du dann nur noch die Lesefunktion aus und kannst das delay() deutlich verkürzen:

void loop() {
  uint16_t distance = sensor.readRangeContinuousMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.println("Timeout!");
  } else {
    Serial.print("Abstand: ");
    Serial.print(distance);
    Serial.println(" mm");
  }

  delay(100);
}

Damit bekommst du rund zehn Messungen pro Sekunde – genug, um auf ein Hindernis zu reagieren, bevor dein Roboter dagegen fährt.

Fazit

Jetzt weißt du, wie du den Time-of-Flight-Sensor mit deinem Arduino UNO verbinden und verwenden kannst, um präzise Entfernungsmessungen durchzuführen – wahlweise auf dem seriellen Monitor oder direkt auf einem OLED-Display. Mit dieser neuen Fähigkeit kannst du nun kreative Projekte entwickeln, bei denen Entfernungen eine wichtige Rolle spielen, wie beispielsweise Parkassistenten, Hinderniserkennung für Roboter oder sogar interaktive Kunstinstallationen.

Möchtest du eine weitere Messmethode kennenlernen? Hier erfährst du, wie du Entfernungen mit Ultraschall misst?