Bauteile · 10 Min. Lesezeit

VL53L0X Arduino: Laser-Entfernungssensor misst bis 2 m

VL53L0X Laser-Entfernungssensor mit Arduino, ESP32 und Pico: I2C-Anschluss, Messmodi, mehrere Sensoren per XSHUT und Vergleich mit dem HC-SR04.

Der VL53L0X ist ein ToF-Laser-Entfernungssensor (Time of Flight, Lichtlaufzeit) und einer der kleinsten und genauesten Wege, mit dem Arduino Abstände zu messen. Der Chip von STMicroelectronics sendet unsichtbares Laserlicht mit 940 nm aus, misst die Zeit, die das Licht bis zum Ziel und zurück braucht, und liefert das Ergebnis direkt in Millimetern. Das briefmarkengroße Modul wird nur mit den zwei Datenleitungen des I2C-Busses angeschlossen; im Standardmodus misst es bis etwa 1,2 Meter, im Long-Range-Modus bis zu 2 Meter.

In diesem Beitrag lernst du Schritt für Schritt, wie der VL53L0X funktioniert, wie du ihn an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt, worin sich die vier Messprofile unterscheiden und wie du mehrere Sensoren über den XSHUT-Pin am selben I2C-Bus betreibst. Außerdem vergleichen wir ihn mit dem beliebten Ultraschallsensor HC-SR04, damit du weißt, welcher für welches Projekt sinnvoller ist.

Was ist der VL53L0X und wie funktioniert er?

Im Sensor stecken zwei Hauptteile: ein VCSEL (Vertical-Cavity Surface-Emitting Laser, Laserdiode) als Lichtquelle und ein SPAD-Array (Single Photon Avalanche Diode), das sogar einzelne Photonen erkennt. Der VCSEL sendet sehr kurze Lichtimpulse, das SPAD-Array fängt die zurückkehrenden Photonen ein und der Chip misst die Zeitspanne dazwischen. Die Entfernung ergibt sich aus einer einfachen Formel: d = c × t / 2. Dabei ist c die Lichtgeschwindigkeit (etwa 300.000 km/s); weil das Licht den Weg zweimal zurücklegt, wird durch zwei geteilt. Für ein Objekt in 1 Meter Entfernung beträgt die Hin-und-zurück-Zeit nur 6,67 Nanosekunden. Eine so kurze Zeit mit einem einzigen Impuls zu messen ist fast unmöglich, deshalb sammelt der Chip die Statistik tausender Impulse und rechnet intern; du liest nur noch das fertige Ergebnis aus.

Der verwendete Laser gehört zur Laserklasse 1; bei normaler Nutzung ist er für die Augen ungefährlich und als Infrarotlicht mit bloßem Auge nicht sichtbar. Der Öffnungswinkel des Sensors beträgt etwa 25 Grad, die Messung erfolgt also in einem schmalen Kegel. Dadurch kannst du viel besser zielen als mit der breiten Schallkeule des HC-SR04; selbst ein kleines Objekt am Tischrand misst du, ohne dass die Wand daneben stört. Da das Ergebnis auf der Lichtgeschwindigkeit beruht, wird es von Temperatur und Luftfeuchtigkeit praktisch nicht beeinflusst.

EigenschaftWert
ChipSTMicroelectronics VL53L0X
MessprinzipLichtlaufzeit (ToF), 940-nm-VCSEL-Laser, Klasse 1
ReichweiteEtwa 3 cm – 1,2 m (Standard), bis 2 m (Long-Range-Modus, dunkle Umgebung, weißes Ziel)
Auflösung1 mm
GenauigkeitJe nach Modus etwa ±3 % bis ±5 %
ÖffnungswinkelEtwa 25°
Messdauer20 ms – 200 ms (je nach Timing Budget)
VersorgungChip 2,6–3,5 V; die meisten Module mit Regler, 3,3–5 V
StromEtwa 19 mA während der Messung, wenige µA im Standby
SchnittstelleI2C, max. 400 kHz, Standardadresse 0x29
PinsVIN, GND, SCL, SDA, GPIO1 (Interrupt), XSHUT (Abschaltung)

VL53L0X oder HC-SR04?

Beide Sensoren messen Abstände, aber ihre Physik ist völlig verschieden. Der HC-SR04 sendet eine 40-kHz-Schallwelle und horcht auf das Echo; da sich Schall mit etwa 343 m/s ausbreitet, ist die Zeitmessung einfach und die Reichweite geht bis 4 Meter. Der breite Schallkegel erfasst aber auch seitliche Objekte, und Stoff, Schaumstoff oder schräge Flächen schlucken oder lenken den Schall ab. Der VL53L0X misst dagegen mit Licht: Er ist sehr klein, zielt mit engem Winkel, ist auf kurze Distanzen stabiler und lässt sich dank I2C mit vielen Sensoren an einem Bus betreiben. Dafür tun sich direktes Sonnenlicht, sehr dunkle oder spiegelnde Oberflächen und Glas schwer. Kurz gesagt: Für kleine, schnelle Messungen unter 2 Metern ist der VL53L0X sinnvoller, für größere Reichweite und Außeneinsatz der HC-SR04. Weitere Optionen findest du im Vergleich der Entfernungssensoren.

EigenschaftVL53L0XHC-SR04
MessprinzipLaufzeit von Laserlicht (940 nm)Ultraschall-Echo (40 kHz)
ReichweiteEtwa 3 cm – 2 mEtwa 2 cm – 4 m
MesskegelEtwa 25°, schmal und gleichmäßigEtwa 15° Messwinkel, Schall breitet sich weiter aus
Auflösung1 mmEtwa 3 mm (praktisch ±1 cm)
AnschlussI2C (SDA, SCL)2 Digitalpins (Trig, Echo)
Mehrere SensorenMit XSHUT am selben I2C-BusJe ein eigener Pin, Sensoren können sich gegenseitig hören
Versorgung3,3–5 V (Modul)5 V
GrößeEtwa 25 × 13 mmEtwa 45 × 20 mm
Probleme beiSchwarzen oder spiegelnden Flächen, Glas, SonnenlichtStoff, Schaumstoff, schrägen Flächen, lauter Umgebung

VL53L0X anschließen: Arduino Uno, ESP32 und Pico

Die meisten Module auf dem Markt (GY-530, GY-VL53L0XV2 usw.) haben einen 2,8-V-Regler, Pull-up-Widerstände für die I2C-Leitungen und einen Pull-up für XSHUT. Deshalb kannst du das Modul sowohl an den 5V-Pin des Uno als auch an den 3V3-Pin von ESP32 und Pico anschließen. Die meisten günstigen Module laufen am Uno problemlos; wenn du die I2C-Leitungen bei Dauerprojekten trotzdem schützen willst, kannst du einen Logikpegel-Wandler verwenden. Wie der I2C-Bus funktioniert, erfährst du im Beitrag Was ist I2C?. GPIO1 ist ein Interrupt-Ausgang, der das Ende einer Messung meldet; für die Grundnutzung musst du ihn nicht anschließen.

VL53L0X-PinArduino UnoESP32Raspberry Pi Pico
VIN5V (oder 3.3V)3V33V3(OUT)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
XSHUT (optional)D4 (beim 2. Sensor D5)GPIO 25GP6
GPIO1 (optional)Nicht angeschlossenNicht angeschlossenNicht angeschlossen
Die Pins des nackten VL53L0X-Chips ohne Modul vertragen höchstens 3,6 V. Fertige Module haben einen Regler, daher darfst du VIN mit 5 V versorgen, aber setze den XSHUT-Pin am Uno nicht direkt auf HIGH: Schalte den Pin zum Einschalten des Sensors auf INPUT, den Rest erledigt der Pull-up-Widerstand auf dem Modul. Außerdem unterscheidet sich die Pinreihenfolge von Modell zu Modell; lies vor dem Anschließen unbedingt die Beschriftung auf der Platine.

Schritt für Schritt: Die erste Messung mit Arduino

  1. Verbinde die Kabel gemäß Tabelle: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
  2. Wenn auf dem Sensor ein gelber oder orangefarbener Schutzstreifen klebt, ziehe ihn vorsichtig ab; der Streifen verfälscht die Messung komplett.
  3. Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach VL53L0X und installiere die Bibliothek von Pololu. Adafruit_VL53L0X funktioniert auch, enthält aber die komplette ST-API und belegt auf dem Uno deutlich mehr Speicher. Wenn du bei der Installation nicht weiterkommst, lies Arduino-Bibliothek hinzufügen.
  4. Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 115200 Baud.
  5. Bewege deine Hand vor dem Sensor hin und her; die Werte ändern sich in Millimetern und Zentimetern.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6void setup() {
7  Serial.begin(115200);
8  Wire.begin();                          // Uno: SDA=A4, SCL=A5
9  sensor.setTimeout(500);                // 500 ms cevap bekle / wait 500 ms for a reply
10  if (!sensor.init()) {
11    Serial.println(F("VL53L0X bulunamadi / not found"));
12    while (1) {}
13  }
14  sensor.startContinuous();              // sürekli ölçüm / continuous ranging
15}
16
17void loop() {
18  uint16_t mm = sensor.readRangeContinuousMillimeters();
19  if (sensor.timeoutOccurred()) {
20    Serial.println(F("Zaman asimi / Timeout"));
21    return;
22  }
23  if (mm > 2000) {                       // geçerli yansıma yok / no valid return
24    Serial.println(F("Menzil disi / Out of range"));
25  } else {
26    Serial.print(mm);
27    Serial.print(F(" mm = "));
28    Serial.print(mm / 10.0, 1);
29    Serial.println(F(" cm"));
30  }
31  delay(100);
32}
BefehlWas er macht
sensor.setTimeout(500)Wenn der Sensor nicht innerhalb von 500 ms antwortet, wird das Warten abgebrochen; der Code hängt nicht ewig.
sensor.init()Lädt die Einstellsequenz von ST und führt die SPAD-Kalibrierung durch; bei false wurde der Sensor am I2C-Bus nicht gefunden.
sensor.startContinuous()Sorgt dafür, dass der Sensor ununterbrochen Messung an Messung reiht.
sensor.readRangeContinuousMillimeters()Gibt die letzte Messung in Millimetern zurück; ohne Ziel kommt ein Wert um 8190.
sensor.timeoutOccurred()Gibt true zurück, wenn das letzte Auslesen in ein Timeout lief (der Wert ist dann 65535).
Siehst du im Seriellen Monitor nichts, lass zuerst einen I2C-Scanner laufen: Ist der Sensor richtig angeschlossen, erscheint er unter der Adresse 0x29. Sind die Werte plausibel, aber konstant um ein paar Zentimeter verschoben, miss ein Ziel mit dem Lineal bei 100 mm und 500 mm und ziehe die mittlere Abweichung im Code ab. Solche Offsets sind bei günstigen Modulen häufig, und diese einfache Korrektur verbessert die Messung spürbar.

VL53L0X-Messmodi

Beim VL53L0X bestimmen drei Einstellungen die Messqualität: das Timing Budget (die Zeit pro Messung), das Signalratenlimit (die schwächste Reflexion, die noch als gültig zählt) und die VCSEL-Impulsperiode (die Länge der Laserimpulse). Je größer das Budget, desto mehr Photonen sammelt der Sensor und desto stabiler wird die Messung, aber auch langsamer; ein Budget von 200 ms bedeutet nur 5 Messungen pro Sekunde. Senkst du das Signallimit vom Standardwert 0,25 MCPS auf 0,1 MCPS, werden auch schwache Reflexionen akzeptiert und die Reichweite wächst, aber das Risiko für Fehlmessungen steigt. Setzt du die Impulsperioden von den Standardwerten 14 und 10 auf 18 und 14, gelangt mehr Energie zu weit entfernten Zielen. ST fasst diese Einstellungen in vier fertigen Profilen zusammen; im Code unten wählst du ein Profil, indem du das Kommentarzeichen vor der gewünschten Zeile entfernst. Die Long-Range-Einstellung lässt sich auch mit der Geschwindigkeits- oder Genauigkeitseinstellung kombinieren.

ProfilTiming BudgetTypische ReichweiteGenauigkeitWann verwenden?
StandardEtwa 30 ms1,2 mEtwa ±3–4 %Allgemeine Messungen
Hohe Genauigkeit200 ms1,2 mUnter ±3 %Füllstandsmessung, präzises Lineal
Große Reichweite33 ms2 mEtwa ±4 %Dunkle Umgebung, weit entferntes Ziel
Hohe Geschwindigkeit20 ms1,2 mEtwa ±5 %Schneller Roboter, Handbewegungserkennung
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6// Profil seç: istediğin satırın yorumunu kaldır / Pick a profile: uncomment the line you want
7#define UZUN_MENZIL         // uzun menzil / long range
8//#define YUKSEK_HIZ        // yüksek hız / high speed
9//#define YUKSEK_DOGRULUK   // yüksek doğruluk / high accuracy
10
11void setup() {
12  Serial.begin(115200);
13  Wire.begin();
14  sensor.setTimeout(500);
15  if (!sensor.init()) {
16    Serial.println(F("Sensor yok / No sensor"));
17    while (1) {}
18  }
19
20#if defined UZUN_MENZIL
21  sensor.setSignalRateLimit(0.1);                                  // varsayılan 0.25 MCPS / default 0.25 MCPS
22  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);    // varsayılan 14 / default 14
23  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);  // varsayılan 10 / default 10
24#endif
25
26#if defined YUKSEK_HIZ
27  sensor.setMeasurementTimingBudget(20000);    // 20 ms
28#elif defined YUKSEK_DOGRULUK
29  sensor.setMeasurementTimingBudget(200000);   // 200 ms
30#endif
31}
32
33void loop() {
34  Serial.print(sensor.readRangeSingleMillimeters());   // tek seferlik ölçüm / single-shot ranging
35  if (sensor.timeoutOccurred()) {
36    Serial.print(F(" ZAMAN ASIMI / TIMEOUT"));
37  }
38  Serial.println();
39}

Mehrere VL53L0X: Adresse per XSHUT ändern

Jeder VL53L0X verlässt das Werk mit derselben Adresse 0x29, und diese Adresse lässt sich nicht dauerhaft ändern. Schließt du zwei Sensoren direkt an denselben Bus an, antworten beide gleichzeitig und die Kommunikation bricht zusammen. Die Lösung ist der XSHUT-Pin: Solange XSHUT auf LOW liegt, ist der Sensor komplett abgeschaltet und am I2C-Bus unsichtbar. Beim Start weckst du die Sensoren nacheinander auf und gibst jedem per Software eine neue Adresse. Die neue Adresse gilt nur, bis die Spannung wegfällt oder XSHUT wieder auf LOW geht; deshalb passiert das bei jedem Start in setup(). Mit dieser Methode kannst du an einem Roboter ganz leicht drei Sensoren links, in der Mitte und rechts montieren; praktisch begrenzen dich nur die Zahl der freien Digitalpins und die Gesamtlänge der Kabel.

  1. Verbinde VIN, GND, SDA und SCL aller Sensoren mit dem gemeinsamen Bus; den XSHUT-Pin jedes Sensors schließt du an einen eigenen Digitalpin an (im Beispiel D4 und D5).
  2. Setze zu Beginn von setup() alle XSHUT-Pins auf LOW, um alle Sensoren abzuschalten.
  3. Schalte Sensor 1 ein, starte ihn mit init() und gib ihm mit setAddress(0x30) seine neue Adresse.
  4. Schalte Sensor 2 ein, starte ihn und gib ihm die Adresse 0x31; bei weiteren Sensoren geht es mit 0x32, 0x33 weiter.
  5. Starte bei allen Sensoren die kontinuierliche Messung und lies jeden über sein eigenes Objekt aus.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const uint8_t XSHUT_1 = 4;
5const uint8_t XSHUT_2 = 5;
6
7VL53L0X sensor1;
8VL53L0X sensor2;
9
10void setup() {
11  Serial.begin(115200);
12  Wire.begin();
13
14  pinMode(XSHUT_1, OUTPUT);
15  pinMode(XSHUT_2, OUTPUT);
16  digitalWrite(XSHUT_1, LOW);    // iki sensörü de kapat / shut down both sensors
17  digitalWrite(XSHUT_2, LOW);
18  delay(10);
19
20  pinMode(XSHUT_1, INPUT);       // 1. sensörü aç, modülün pull-up direnci HIGH yapar / wake sensor 1, module pull-up pulls it HIGH
21  delay(10);
22  sensor1.setTimeout(500);
23  if (!sensor1.init()) {
24    Serial.println(F("Sensor 1 yok / Sensor 1 missing"));
25    while (1) {}
26  }
27  sensor1.setAddress(0x30);      // yeni adres / new address
28
29  pinMode(XSHUT_2, INPUT);       // 2. sensörü aç / wake sensor 2
30  delay(10);
31  sensor2.setTimeout(500);
32  if (!sensor2.init()) {
33    Serial.println(F("Sensor 2 yok / Sensor 2 missing"));
34    while (1) {}
35  }
36  sensor2.setAddress(0x31);
37
38  sensor1.startContinuous();
39  sensor2.startContinuous();
40}
41
42void loop() {
43  Serial.print(F("Sol / Left: "));
44  Serial.print(sensor1.readRangeContinuousMillimeters());
45  Serial.print(F(" mm   Sag / Right: "));
46  Serial.print(sensor2.readRangeContinuousMillimeters());
47  Serial.println(F(" mm"));
48  delay(100);
49}
Wird einer der Sensoren zurückgesetzt (Spannungseinbruch, Wackelkontakt, Motorstörungen), springt seine Adresse auf 0x29 zurück und der Code findet ihn nicht mehr. Prüfe bei Projekten mit Motoren oder langen Kabeln regelmäßig das Ergebnis von timeoutOccurred() und schreibe bei Bedarf eine Neustart-Funktion, die die XSHUT-Sequenz von vorn durchläuft. Achte bei der Wahl neuer Adressen darauf, dass sie nicht mit anderen Geräten am Bus kollidieren, etwa einem OLED-Display (0x3C) oder einem RTC-Modul (0x68).

VL53L0X mit dem ESP32

Auf dem ESP32 läuft dieselbe Pololu-Bibliothek ohne Änderungen. Die Standard-I2C-Pins sind GPIO 21 (SDA) und GPIO 22 (SCL); gibst du sie mit Wire.begin(21, 22) ausdrücklich an, erlebst du auf anderen Boards keine Überraschungen. Da die Pins des ESP32 mit 3,3 V arbeiten, darfst du XSHUT direkt auf HIGH setzen; die INPUT-Methode vom Uno ist nicht nötig. Das folgende Beispiel misst mit einem Budget von 50 ms, bildet den Mittelwert der letzten 5 Messungen und schaltet die Onboard-LED ein, wenn ein Objekt näher als 15 cm kommt. Mittelwertbildung ist der einfachste Weg, springende Werte zu glätten; fortgeschrittene Methoden findest du im Beitrag Sensordaten filtern. Wenn du die Entfernung auf dem Handy verfolgen möchtest, kannst du den Code mit dem Beispiel ESP32-Webserver kombinieren.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const int SDA_PIN = 21;
5const int SCL_PIN = 22;
6const int LED_PIN = 2;            // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7const uint16_t ESIK_MM = 150;     // uyarı eşiği / warning threshold
8const uint8_t N = 5;              // ortalama için örnek sayısı / samples for averaging
9
10VL53L0X sensor;
11uint16_t olcumler[N];
12uint8_t sira = 0;
13
14uint16_t olc() {
15  uint16_t mm = sensor.readRangeContinuousMillimeters();
16  if (mm > 2000) mm = 2000;       // menzil dışını sınırla / clamp out-of-range values
17  return mm;
18}
19
20void setup() {
21  Serial.begin(115200);
22  pinMode(LED_PIN, OUTPUT);
23  Wire.begin(SDA_PIN, SCL_PIN);
24  Wire.setClock(400000);          // hızlı I2C / fast-mode I2C
25  sensor.setTimeout(500);
26  if (!sensor.init()) {
27    Serial.println("VL53L0X bulunamadi / not found");
28    while (true) delay(1000);
29  }
30  sensor.setMeasurementTimingBudget(50000);   // 50 ms bütçe / 50 ms budget
31  sensor.startContinuous();
32  for (uint8_t i = 0; i < N; i++) olcumler[i] = olc();   // diziyi doldur / pre-fill the buffer
33}
34
35void loop() {
36  uint16_t mm = olc();
37  if (sensor.timeoutOccurred()) {
38    Serial.println("Zaman asimi / Timeout");
39    return;
40  }
41  olcumler[sira] = mm;
42  sira = (sira + 1) % N;
43
44  uint32_t toplam = 0;
45  for (uint8_t i = 0; i < N; i++) toplam += olcumler[i];
46  uint16_t ortalama = toplam / N;
47
48  digitalWrite(LED_PIN, ortalama < ESIK_MM ? HIGH : LOW);
49  Serial.printf("Ham / Raw: %u mm   Ortalama / Average: %u mm\n", (unsigned)mm, (unsigned)ortalama);
50  delay(50);
51}

Raspberry Pi Pico und MicroPython mit dem VL53L0X

In MicroPython gibt es kein eingebautes Modul für den VL53L0X; du musst eine von der Community erstellte Treiberdatei vl53l0x.py mit Thonny auf den Pico kopieren. Diese Treiber übertragen die Initialisierungssequenz von ST nach Python und bieten meist die Funktionen start(), read() und stop() an; prüfe einmal die Funktionsnamen in der Datei deines Treibers. Für den Anschluss verwenden wir die Pins GP4 (SDA) und GP5 (SCL) von I2C0; beim Scan solltest du 0x29 (dezimal 41) sehen. Der im Code verwendete Ausdruck Pin("LED") wählt ab MicroPython 1.20 bei Pico und Pico W die Onboard-LED aus. Auch beim Pico gilt für mehrere Sensoren dieselbe XSHUT-Logik; da der Pico mit 3,3 V arbeitet, darfst du die XSHUT-Pins direkt auf HIGH setzen. Wenn du neu in MicroPython bist, wirf zuerst einen Blick auf MicroPython-Grundlagen.

MicroPython
1from machine import Pin, I2C
2import time
3from vl53l0x import VL53L0X                  # vl53l0x.py Pico'da olmalı / must be on the Pico
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("I2C:", [hex(a) for a in i2c.scan()])  # 0x29 görmelisin / you should see 0x29
7
8tof = VL53L0X(i2c)                           # varsayılan adres 0x29 / default address 0x29
9led = Pin("LED", Pin.OUT)                    # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
10ESIK_MM = 150                                # uyarı eşiği / warning threshold
11
12tof.start()                                  # sürekli ölçüm / continuous ranging
13try:
14    while True:
15        mm = tof.read()
16        if mm > 2000:
17            print("Menzil disi / Out of range")
18        else:
19            print(mm, "mm")
20        led.value(1 if mm < ESIK_MM else 0)
21        time.sleep_ms(100)
22finally:
23    tof.stop()                               # ölçümü durdur / stop ranging

Tipps für genaue Messungen

  • Die Farbe des Ziels zählt: Weiße und matte Flächen reflektieren Licht gut; bei schwarzen, dunkelgrauen oder samtartigen Oberflächen kann die Reichweite auf die Hälfte oder weniger sinken.
  • Meide Sonnenlicht: Sonnenlicht hat einen starken Infrarotanteil und erhöht das Hintergrundrauschen des Sensors. Halte den Sensor im Freien im Schatten oder greife lieber zum HC-SR04.
  • Vorsicht bei Abdeckglas: Wenn du den Sensor in ein Gehäuse einbaust, wirft eine davorgesetzte Glas- oder Acrylscheibe einen Teil des Lichts zurück (Crosstalk) und lässt die Messung zu kurz erscheinen. Wähle für eine Abdeckung ein dünnes, infrarotdurchlässiges Material, das möglichst nah am Sensor sitzt.
  • Spiegelnde Flächen: Das Licht kann von einer schräg stehenden glänzenden Fläche in eine andere Richtung abprallen; halte den Sensor möglichst senkrecht zur Fläche.
  • Kleine Ziele: Der 25-Grad-Kegel wird mit der Entfernung breiter; in 1 Meter Abstand erfasst er eine Fläche von etwa 44 cm Durchmesser. Misst du ein kleines Objekt aus der Ferne, kann die Wand dahinter in das Ergebnis einfließen.
  • Halte die Kabel kurz: Der I2C-Bus wird bei langen Kabeln störanfällig; senke bei Verbindungen über 30 cm die Geschwindigkeit auf 100 kHz und führe die Kabel weg von Motorleitungen.

Projektideen mit dem VL53L0X

  • Garagen-Einparkhilfe: Miss den Abstand des Autos zur Wand und ändere die LED-Farbe, je näher es kommt. Ein ausführliches Beispiel findest du im Beitrag Arduino-Parkplatzsystem.
  • Berührungsloser Mülleimer oder Seifenspender: Nähert sich deine Hand auf 10 cm, öffnet ein Servo den Deckel; im Projekt smarter Mülleimer kannst du statt des HC-SR04 den VL53L0X verwenden.
  • Hindernisvermeidender Roboter mit drei Augen: Montiere je einen Sensor links, in der Mitte und rechts und schließe sie per XSHUT an denselben Bus an; ein Hindernisvermeidungs-Roboter fährt damit viel klügere Kurven.
  • Füllstandsanzeige für Futter oder Getreide: Montiere ihn im Deckel des Behälters und zeige die Restmenge in Prozent an; ein guter Partner für das Projekt automatischer Futterspender.
  • Dimmer per Handbewegung: Wandle den Abstand deiner Hand zum Sensor per PWM in LED-Helligkeit um; 5 cm volle Helligkeit, 30 cm aus.
  • Digitales Lineal: Gib den gemessenen Abstand in großen Ziffern auf einem OLED-Display aus und mach daraus ein Messgerät für den Schreibtisch.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
init() gibt false zurück, Sensor nicht gefundenSDA und SCL vertauscht, keine Versorgung oder falscher PinSuche mit einem I2C-Scanner nach Adresse 0x29; prüfe beim Uno, dass SDA = A4 und SCL = A5 ist
Werte stehen dauerhaft bei etwa 8190Ziel außer Reichweite, Schutzstreifen nicht entfernt oder Fläche zu dunkelStreifen abziehen, Ziel näher heranbringen, das Long-Range-Profil testen
Messung ist um einige Zentimeter verschobenModul-Offset oder Abdeckglas davorBei bekanntem Abstand messen und die Differenz im Code abziehen; Abdeckung entfernen oder ersetzen
Werte springen ständigZu kurzes Timing Budget, Umgebungslicht, kleines ZielBudget auf 50–200 ms erhöhen, mehrere Messungen mitteln
65535 und Timeout-MeldungLanges oder lockeres I2C-Kabel, Sensor wurde zurückgesetztKabel kürzen, Verbindungen festziehen, Sensor neu starten
Einer von zwei Sensoren antwortet nichtAdresskonflikt oder fehlende XSHUT-VerbindungXSHUT-Pins prüfen, Sensoren nacheinander einschalten und unterschiedliche Adressen vergeben
Im Freien wird die Messung zu kurzInfrarotrauschen durch SonnenlichtSensor im Schatten halten, das Profil für hohe Genauigkeit nutzen oder auf den HC-SR04 wechseln

Mit seiner kleinen Größe, dem schmalen Öffnungswinkel und der Millimeter-Auflösung gibt der VL53L0X Projekten von Robotern bis zu berührungslosen Schaltern ein präzises Auge; wählst du das richtige Profil und korrigierst den Offset, erhältst du auf kurzen Distanzen, bei denen Ultraschallsensoren Mühe haben, deutlich stabilere Ergebnisse. In der BlueGrays-App findest du Schritt für Schritt Projekte wie Abstandsmessung, Einparksensor, Körpergrößenmesser und hindernisvermeidenden Roboter mit Schaltplan und Code, und dieselbe Logik lässt sich leicht mit dem VL53L0X auf dein eigenes Projekt übertragen.

Häufige Fragen

Wie weit misst der VL53L0X?

Mit den Standardeinstellungen liegt die verlässliche Reichweite bei etwa 1,2 Metern. Im Long-Range-Profil misst er in dunkler Umgebung und mit einem weißen, gut reflektierenden Ziel bis zu 2 Meter. Bei grauen oder dunklen Flächen und bei Sonnenlicht sinkt diese Reichweite deutlich.

Ist der VL53L0X oder der HC-SR04 besser?

Das hängt vom Einsatz ab. Der VL53L0X ist klein, hat einen engen Winkel und ist unter 2 Metern stabiler; dank I2C lassen sich mehrere Sensoren leicht an einem Bus betreiben. Der HC-SR04 misst bis 4 Meter, wird von Sonnenlicht nicht gestört und erkennt Glas, tut sich aber bei weichen Flächen wie Stoff schwer.

Wie lautet die I2C-Adresse des VL53L0X und wie ändere ich sie?

Die 7-Bit-Standardadresse ist 0x29; in der 8-Bit-Schreibweise steht dort 0x52. Die Adresse wird per Software mit setAddress() geändert, ist aber nicht dauerhaft: Fällt die Spannung weg oder wird XSHUT auf LOW gesetzt, springt sie auf 0x29 zurück. Bei mehreren Sensoren musst du sie bei jedem Start der Reihe nach per XSHUT einschalten und mit Adressen versehen.

Warum zeigt der VL53L0X den Wert 8190?

Die Pololu-Bibliothek liefert einen Wert wie 8190 oder 8191, wenn der Sensor im Sichtfeld keine gültige Reflexion findet. Das Ziel kann außer Reichweite sein, die Fläche zu dunkel oder der Schutzstreifen auf dem Sensor noch nicht entfernt. Der Wert 65535 bedeutet dagegen ein I2C-Timeout; prüfe Kabel und Versorgung.

Funktioniert der VL53L0X bei Sonnenlicht?

Er funktioniert, aber die Leistung sinkt. Da Sonnenlicht einen starken Infrarotanteil enthält, steigt das Hintergrundrauschen des Sensors und die Reichweite kann auf die Hälfte oder weniger fallen. Im Freien helfen Schatten für den Sensor, das Profil für hohe Genauigkeit und der Einsatz auf kurze Distanzen.

Was ist der Unterschied zwischen VL53L0X und VL53L1X?

Der VL53L1X ist das neuere Mitglied derselben Familie; er misst bis 4 Meter und erlaubt dir, nur einen Teil des Sichtfelds (ROI) auszuwählen. Der VL53L0X ist auf 2 Meter begrenzt, aber günstiger und für Projekte auf kurze Distanz mehr als ausreichend. Da die Bibliotheken der beiden Sensoren verschieden sind, lässt sich der Code nicht eins zu eins übertragen.

Alle Projekte ansehen
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

HC-SR04 Abstandsmessung (serielle Anzeige)

Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

4.6(50)
82
Parksensor mit HC-SR04
AR-28Mittel
Premium

Parksensor mit HC-SR04

Eine Mini-Ausgabe der Einparkhilfe im Auto: Je näher etwas kommt, desto schneller piept es.

4.8(64)
86
Abstandsmessung mit LCD-Display
AR-31Fortgeschritten
Premium

Abstandsmessung mit LCD-Display

Ein Gerät, das ohne Lineal Abstände misst: Beweg deine Hand vor dem Sensor vor und zurück und sieh zu, wie sich die Zahl ändert.

4.6(45)
59
Projekt Körpergrößenmessung
AR-33Mittel
Premium

Projekt Körpergrößenmessung

Ein Größenmesser für den Türrahmen, der dir in Zentimetern sagt, wie groß die Person darunter ist.

4.5(25)
34
Reflexion (Nähe) mit TCRT5000 messen
AR-77Mittel
Premium

Reflexion (Nähe) mit TCRT5000 messen

Mit einem kleinen Sensor, der unsichtbares Licht aussendet und misst, wie viel davon zurückkommt, erkennst du die Fläche vor ihm.

4.6(33)
43
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

Roboter zur Hindernisvermeidung

Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

5.0(38)
49
ESP32 HC-SR04 Ultraschall-Entfernungsmesser
ES-14Mittel

ESP32 HC-SR04 Ultraschall-Entfernungsmesser

Der Ultraschallsensor HC-SR04 misst Entfernungen über die Laufzeit seines Schallimpulses zum Objekt und zurück (Time of Flight). Der ESP32 sendet einen 10-Mikrosekunden-Impuls an TRIG und liest die Echozeit an ECHO mit pulseIn(). Die Entfernung erscheint in cm auf einem 16x2-I2C-LCD. Der HC-SR04 läuft mit 5 V, daher braucht ECHO einen Spannungsteiler, sonst nimmt der 3,3-V-GPIO des ESP32 Schaden.

4.9(29)
48
ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)
ES-38Fortgeschritten
Premium

ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)

Die ESP32-Version einer Einparkhilfe! Der Ultraschallsensor HC-SR04 misst den Abstand zum Objekt davor. Je näher es kommt, desto weiter füllt sich eine Leiste aus 5 LEDs (grün → gelb → rot) und desto schneller piept der Summer. Ganz nah (unter 10 cm) ertönt ein Daueralarm und alle LEDs leuchten. Das SSD1306-OLED zeigt den aktuellen Abstand in cm groß an, dazu einen Statustext.

14