Arduino Abstandssensoren: HC-SR04, IR, VL53L0X und LiDAR

Die Wahl zwischen den Arduino-Abstandssensoren wirkt zunächst wie die Frage „Welcher misst am weitesten?“, entscheidend sind aber die Oberfläche, die du misst, die nötige Genauigkeit, wie schmal der Messstrahl sein muss und die Umgebung. Derselbe HC-SR04, der den Abstand zur Wand zentimetergenau misst, kann am weichen Stoff eines Sofas unruhig werden, und ein günstiger Lasersensor mit Millimeterauflösung verliert in der Sonne womöglich die Hälfte seiner Reichweite. In dieser Anleitung stellen wir die sechs in Arduino-Projekten am häufigsten genutzten Sensoren nebeneinander.

Wir vergleichen den Ultraschallsensor HC-SR04 und seinen wasserdichten Bruder JSN-SR04T, den Infrarot-Triangulationssensor Sharp GP2Y0A21, die Laser-Laufzeitsensoren (ToF) VL53L0X und VL53L1X, das kleine LiDAR TF-Luna und den Nahbereichssensor TCRT5000. Zu jedem erklären wir Messprinzip, Reichweite, Genauigkeit, Abstrahlwinkel, Verhalten auf Oberflächen und Schnittstelle und geben einen kompilierten Beispiel-Sketch. Zum Schluss fasst eine Tabelle zusammen, welcher Sensor zu welchem Projekt passt.

Wie messen Abstandssensoren? Drei Grundprinzipien

Fast alle Abstandssensoren am Arduino nutzen eines von drei Verfahren. Laufzeitmessung (Time of Flight): Der Sensor sendet einen Schall- oder Lichtimpuls und misst, wie lange die Reflexion für den Rückweg braucht; der Abstand ist das halbe Produkt aus Zeit und Geschwindigkeit. Ultraschallsensoren arbeiten mit Schall, VL53L0X und TF-Luna mit Licht. Weil Licht etwa eine Million Mal schneller ist als Schall, stecken in ToF-Sensoren spezielle Chips mit Zeitauflösung im Pikosekundenbereich. Triangulation: Sharp-IR-Sensoren senden einen Infrarotstrahl auf das Ziel und schauen, wo das reflektierte Licht auf einem positionsempfindlichen Detektor (PSD) landet; bei nahen Objekten wandert der Punkt an ein Ende, bei fernen ans andere. Reflexionsstärke: Einfache Sensoren wie der TCRT5000 messen nur, wie stark das zurückkommende Licht ist; da das stark von der Oberflächenfarbe abhängt, ist das eher Näherungserkennung als echte Abstandsmessung.

Die große Vergleichstabelle

Die folgende Tabelle fasst typische Modulwerte der Sensoren zusammen. Die Reichweiten sind Herstellerangaben; im echten Projekt können sie je nach Oberfläche und Umgebung kürzer ausfallen. Da Preise von Land zu Land schwanken, sind sie relativ angegeben.

HC-SR04: der Ultraschall-Klassiker

Der HC-SR04 sendet acht Schallimpulse mit 40 kHz und hält seinen ECHO-Pin auf HIGH, bis das Echo zurückkommt. Der Arduino misst die Länge dieses Impulses mit pulseIn() in Mikrosekunden. Schall legt bei 20 °C etwa 343 Meter pro Sekunde zurück, also 0,0343 cm pro Mikrosekunde; da der Schall hin und zurück läuft, gilt Abstand = Zeit × 0,0343 / 2. Die Schallgeschwindigkeit hängt von der Temperatur ab (etwa 331,3 + 0,606 × T m/s): Zwischen 0 °C und 35 °C liegen etwa 6 %, also bis zu 12 cm Fehler auf 2 Meter. Der folgende Code korrigiert das und nimmt den Median aus fünf Messungen, um gelegentliche Fehlechos auszusortieren.

1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3const float SICAKLIK = 20.0;     // ortam sıcaklığı, °C / ambient temperature, °C
4float sesHizi;                   // cm/µs
5
6float mesafeOlc() {
7  digitalWrite(TRIG_PIN, LOW);
8  delayMicroseconds(2);
9  digitalWrite(TRIG_PIN, HIGH);  // 10 µs tetik darbesi / 10 µs trigger pulse
10  delayMicroseconds(10);
11  digitalWrite(TRIG_PIN, LOW);
12  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL);   // 30 ms ≈ 5 m sınırı / ~5 m limit
13  if (sure == 0) return -1;      // yankı yok / no echo
14  return sure * sesHizi / 2.0;   // gidiş-dönüş / round trip
15}
16
17void setup() {
18  Serial.begin(9600);
19  pinMode(TRIG_PIN, OUTPUT);
20  pinMode(ECHO_PIN, INPUT);
21  sesHizi = (331.3 + 0.606 * SICAKLIK) / 10000.0;   // m/s -> cm/µs (20 °C: 0,0343)
22}
23
24void loop() {
25  float olcum[5];
26  for (int i = 0; i < 5; i++) {  // 5 ölçüm, aralarında 60 ms / 5 readings, 60 ms apart
27    olcum[i] = mesafeOlc();
28    delay(60);
29  }
30  for (int i = 1; i < 5; i++) {  // sırala / sort
31    float x = olcum[i];
32    int j = i - 1;
33    while (j >= 0 && olcum[j] > x) { olcum[j + 1] = olcum[j]; j--; }
34    olcum[j + 1] = x;
35  }
36  float d = olcum[2];            // ortanca / median
37  if (d < 0) Serial.println("Menzil disi / out of range");
38  else { Serial.print(d, 1); Serial.println(" cm"); }
39}
40

• Mindestens 60 ms zwischen den Messungen: Misst du, während Echos des vorigen Impulses noch durch den Raum hallen, bekommst du falsche Werte.
• Weiche und schräge Flächen: Stoff, Schaumstoff und Vorhänge schlucken Schall; Flächen mit mehr als 45 Grad Neigung lenken das Echo vom Sensor weg.
• Breiter Strahl: Der etwa 15-Grad-Kegel deckt in 2 Metern eine Fläche von fast 50 cm ab; in einem schmalen Flur sieht er auch die Seitenwände.
• 3,3-V-Boards: Der klassische HC-SR04 braucht 5 V und sein ECHO liefert 5 V; an ESP32 und Pico gehört ein Spannungsteiler an ECHO, oder du nimmst den HC-SR04P, der mit 3,3 V läuft.
• Mehrere Sensoren: Zwei gleichzeitig ausgelöste HC-SR04 hören gegenseitig ihre Echos; löse sie nacheinander aus.

Anschluss des HC-SR04 sowie Nutzung mit seriellem Monitor und LCD erklärt der Beitrag Abstandssensor HC-SR04 ausführlich; hier konzentrieren wir uns auf den Vergleich.

JSN-SR04T: Ultraschall wasserdicht

Der JSN-SR04T arbeitet mit derselben Trigger-Echo-Logik wie der HC-SR04, sein Wandler sitzt aber in einer wasserdichten Kapsel am Kabel, getrennt von der Elektronikplatine. Deshalb ist er die Wahl für feuchte Orte wie Wassertanks, Brunnen, Regenwasserzisternen und Parksensoren im Freien. Zwei Unterschiede sind wichtig: Weil ein einziger Wandler sendet und lauscht, gibt es im Nahbereich eine Totzone (etwa 20–25 cm), und der Strahl ist breiter als beim HC-SR04. Montiere den Sensor im Tankdeckel, mindestens 25 cm über dem höchsten Wasserstand. Der folgende Code rechnet den Abstand in einen Füllstand in Prozent um.

1// JSN-SR04T ile su deposu doluluğu / water tank level with a JSN-SR04T
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const float SENSOR_BOSLUK = 25.0;  // sensörden en yüksek su seviyesine, cm (ölü bölge) / sensor to max level (blind zone)
5const float DEPO_DERINLIK = 120.0; // en yüksek seviyeden depo dibine, cm / max level to tank bottom
6
7float mesafeOlc() {
8  digitalWrite(TRIG_PIN, LOW);
9  delayMicroseconds(5);
10  digitalWrite(TRIG_PIN, HIGH);
11  delayMicroseconds(20);           // JSN-SR04T 10 µs'den uzun darbeyi sever / likes a longer pulse
12  digitalWrite(TRIG_PIN, LOW);
13  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 40000UL);
14  if (sure == 0) return -1;
15  return sure * 0.0343 / 2.0;      // 20 °C ses hızı / speed of sound at 20 °C
16}
17
18void setup() {
19  Serial.begin(9600);
20  pinMode(TRIG_PIN, OUTPUT);
21  pinMode(ECHO_PIN, INPUT);
22}
23
24void loop() {
25  float d = mesafeOlc();
26  if (d < 0) {
27    Serial.println("Yanki yok / no echo");
28  } else {
29    float suYuksekligi = DEPO_DERINLIK - (d - SENSOR_BOSLUK);   // dipten su yüksekliği / water height
30    float yuzde = constrain(suYuksekligi / DEPO_DERINLIK * 100.0, 0, 100);
31    Serial.print("Mesafe / distance: ");
32    Serial.print(d, 1);
33    Serial.print(" cm  Doluluk / fill: %");
34    Serial.println(yuzde, 0);
35  }
36  delay(1000);                     // su yüzeyi dalgalanır, sık ölçme / water ripples, measure slowly
37}
38

Sharp GP2Y0A21: analoges Infrarot

Der Sharp GP2Y0A21YK0F ist ein Infrarotsensor für 10 bis 80 cm, der abhängig vom Abstand eine Analogspannung ausgibt. Weil er trianguliert, ist er weniger farbempfindlich als Sensoren, die auf Reflexionsstärke beruhen. Sein Ausgang ist nicht linear: etwa 2,3 V bei 10 cm, 0,4 V bei 80 cm und dazwischen eine umgekehrte Potenzkurve. Der Code rechnet diese Kurve mit der Näherung Abstand = 29,988 × V^-1,173 um. Die größte Falle liegt unter 10 cm: Kommt das Ziel näher, fällt die Spannung wieder, und ein Objekt in 5 cm kann aussehen wie in 20 cm. Bau den Sensor so ein, dass das Ziel nie näher als 10 cm kommen kann.

1// Sharp GP2Y0A21YK0F (10–80 cm), analog / analog output
2const int SHARP_PIN = A0;
3
4float sharpCm() {
5  long toplam = 0;
6  for (int i = 0; i < 20; i++) {          // 20 okumanın ortalaması / average of 20 readings
7    toplam += analogRead(SHARP_PIN);
8    delay(2);
9  }
10  float volt = toplam / 20.0 * 5.0 / 1023.0;
11  if (volt < 0.35) return -1;             // 80 cm'den uzak / farther than 80 cm
12  float cm = 29.988 * pow(volt, -1.173);  // ters güç eğrisi / inverse power curve
13  if (cm > 80) return -1;
14  return cm;                              // 10 cm altı yanıltıcı / misleading below 10 cm
15}
16
17void setup() {
18  Serial.begin(9600);
19}
20
21void loop() {
22  float cm = sharpCm();
23  if (cm < 0) Serial.println("Menzil disi / out of range");
24  else { Serial.print(cm, 1); Serial.println(" cm"); }
25  delay(100);
26}
27

Sharp-Sensoren ziehen beim Messen kurze, hohe Stromspitzen, die auf der Versorgung Störungen erzeugen. Ein Kondensator von etwa 10 µF nahe an VCC und GND des Sensors beruhigt die Werte deutlich. Die Familie hat auch Mitglieder mit anderen Bereichen: Der GP2Y0A41SK0F arbeitet von 4 bis 30 cm, der GP2Y0A02YK0F von 20 bis 150 cm; jeder hat andere Kurvenkoeffizienten.

VL53L0X und VL53L1X: Laser-ToF-Sensoren

VL53L0X und VL53L1X sind winzige Laser-Laufzeitsensoren von STMicroelectronics. Sie senden einen unsichtbaren 940-nm-Laserimpuls, messen mit Photonenzählern die Rückkehrzeit der Reflexion und liefern das Ergebnis direkt in Millimetern über I2C. Sie sind nahezu farbunabhängig, ihr Strahl ist schmaler als beim Ultraschall, und eine Messung dauert 20–50 ms. Der VL53L0X misst im Standardmodus bis etwa 1,2 Meter, im Langstreckenmodus bis 2 Meter; der VL53L1X schafft 4 Meter, und sein Sichtfeld (ROI) lässt sich per Software einengen. Beide haben die Standard-I2C-Adresse 0x29. Der Code nutzt die VL53L0X-Bibliothek von Pololu; such im Bibliotheksverwalter nach „VL53L0X“ und installiere die Pololu-Version.

1#include <Wire.h>
2#include <VL53L0X.h>              // Pololu VL53L0X kütüphanesi / library
3
4VL53L0X sensor;
5
6void setup() {
7  Serial.begin(9600);
8  Wire.begin();                    // Uno: SDA A4, SCL A5 / ESP32: SDA 21, SCL 22
9  sensor.setTimeout(500);
10  if (!sensor.init()) {
11    Serial.println("VL53L0X bulunamadi / not found");
12    while (true) {}
13  }
14  // Uzun menzil modu (2 m'ye kadar, daha gürültülü) / long range mode (up to 2 m, noisier):
15  // sensor.setSignalRateLimit(0.1);
16  // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
17  // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
18  sensor.setMeasurementTimingBudget(50000);   // 50 ms: daha kararlı ölçüm / steadier reading
19  sensor.startContinuous();
20}
21
22void loop() {
23  uint16_t mm = sensor.readRangeContinuousMillimeters();
24  if (sensor.timeoutOccurred()) {
25    Serial.println("Zaman asimi / timeout");
26  } else if (mm >= 8190) {         // 8190-8191: hedef yok / no target
27    Serial.println("Menzil disi / out of range");
28  } else {
29    Serial.print(mm);
30    Serial.println(" mm");
31  }
32}
33

Das Messzeitbudget (Timing Budget) bestimmt das Verhältnis von Genauigkeit und Tempo: 20 ms sind schnell, aber verrauscht, 200 ms langsam, aber stabil. Sonnenlicht und starke Infrarotquellen verkürzen die Reichweite deutlich; berücksichtige das bei Messungen im Freien. Willst du zwei VL53L0X an einen I2C-Bus hängen, hältst du einen per XSHUT-Pin abgeschaltet und gibst dem anderen eine neue Adresse (setAddress), weil beide 0x29 haben; I2C-Details im Beitrag Was ist I2C.

TF-Luna: 8 Meter mit einem kleinen LiDAR

Das TF-Luna ist das kleine Einpunkt-LiDAR von Benewake: Es misst die Laufzeit mit moduliertem Infrarotlicht (850 nm), arbeitet von 0,2 bis 8 Meter mit einem sehr schmalen Strahl von nur 2 Grad und schafft bis zu 250 Messungen pro Sekunde. Standardmäßig sendet es jede Messung per UART mit 115200 Baud als 9-Byte-Paket: zwei Kopfbytes 0x59, Abstand (cm), Signalstärke, Innentemperatur und eine Prüfsumme. Liegt die Signalstärke unter 100 oder bei 65535 (Übersteuerung), gilt die Messung als unzuverlässig. Es wird mit 5 V versorgt, der UART-Pegel ist aber 3,3 V; deshalb passt es direkt an einen ESP32. Da SoftwareSerial am Uno bei 115200 Baud nicht zuverlässig ist, nimm ein Board mit Hardware-UART wie ESP32 oder Mega; die Logik zum Auswerten von UART-Paketen erklärt der Beitrag serielle UART-Kommunikation.

1// TF-Luna LiDAR, UART (115200), ESP32 Serial2
2// TF-Luna TX -> GPIO 16, RX -> GPIO 17, VCC 5V, GND
3const int RXD2 = 16, TXD2 = 17;
4
5uint8_t kare[9];                   // 0x59 0x59 DistL DistH AmpL AmpH TempL TempH Checksum
6int konum = 0;
7
8void setup() {
9  Serial.begin(115200);
10  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);
11}
12
13void loop() {
14  while (Serial2.available()) {
15    uint8_t b = Serial2.read();
16    if (konum < 2) {               // iki 0x59 başlık baytını bekle / wait for two 0x59 header bytes
17      if (b == 0x59) kare[konum++] = b;
18      else konum = 0;
19      continue;
20    }
21    kare[konum++] = b;
22    if (konum < 9) continue;
23    konum = 0;
24
25    uint8_t toplam = 0;
26    for (int i = 0; i < 8; i++) toplam += kare[i];
27    if (toplam != kare[8]) continue;             // sağlama toplamı hatalı / bad checksum
28
29    uint16_t mesafe = kare[2] | (kare[3] << 8);  // cm
30    uint16_t guc = kare[4] | (kare[5] << 8);     // sinyal gücü / signal strength
31    float derece = (kare[6] | (kare[7] << 8)) / 8.0 - 256.0;
32
33    if (guc < 100 || guc == 65535) {             // zayıf ya da aşırı sinyal / weak or saturated
34      Serial.println("Guvenilmez / unreliable");
35    } else {
36      Serial.print(mesafe);
37      Serial.print(" cm  guc / amp: ");
38      Serial.print(guc);
39      Serial.print("  ic sicaklik / chip temp: ");
40      Serial.println(derece, 1);
41    }
42  }
43}
44

TCRT5000: Annäherung und Linienerkennung

Der TCRT5000 ist kein Abstandsmesser, sondern ein Reflexsensor: Das Licht der Infrarot-LED wird von der Oberfläche zurückgeworfen, und der Fototransistor daneben misst, wie viel ankommt. Am besten arbeitet er bei etwa 2,5 mm, ab 1,5 cm wird das Signal schnell schwach. Weil Weiß viel und Schwarz kaum reflektiert, liefert er schon im selben Abstand je nach Farbe völlig andere Werte; deshalb dient er in Linienfolger-Robotern zur Schwarz-Weiß-Unterscheidung, zum Zählen von Löchern in Encoderscheiben und zur Erkennung sehr naher Objekte. Der Komparator auf dem Modul schaltet den Digitalausgang, sobald die per Poti eingestellte Schwelle überschritten wird. Details im Beitrag Infrarotsensor TCRT5000.

1// TCRT5000 modülü: DO dijital, AO analog / TCRT5000 module: DO digital, AO analog
2const int DO_PIN = 7;
3const int AO_PIN = A1;
4const int LED_PIN = 13;
5
6void setup() {
7  Serial.begin(9600);
8  pinMode(DO_PIN, INPUT);
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool nesneVar = (digitalRead(DO_PIN) == LOW);  // çoğu modülde LOW = yansıma var / LOW = reflection on most modules
14  int yansima = analogRead(AO_PIN);              // düşük değer = güçlü yansıma / low value = strong reflection
15  digitalWrite(LED_PIN, nesneVar);
16  Serial.print(nesneVar ? "Nesne VAR / object  " : "Nesne yok / none  ");
17  Serial.println(yansima);
18  delay(100);
19}
20

Einfluss von Oberfläche und Umgebung

Die Reichweite auf dem Papier ändert sich, sobald der Sensor auf die zu messende Oberfläche trifft. Ultraschallsensoren glänzen bei harten, schallreflektierenden Flächen, haben aber Mühe mit schallschluckendem Stoff; lichtbasierte Sensoren reagieren auf Farbe, Glanz und Sonnenlicht. Die Tabelle zeigt, welcher Sensor in welcher Situation zuverlässig bleibt.

Anschluss im Überblick: Uno, ESP32 und Pico

Ultraschallmessung mit dem Raspberry Pi Pico

In MicroPython misst machine.time_pulse_us() die Impulslänge; die Funktion entspricht pulseIn() am Arduino und liefert bei Zeitüberschreitung einen negativen Wert. Versorge den HC-SR04 über den VBUS-Pin (USB 5 V) des Pico und setz einen Teiler aus 1 kΩ + 2 kΩ in die ECHO-Leitung, oder nimm den HC-SR04P, der direkt mit 3,3 V läuft. Für VL53L0X und TF-Luna gibt es ebenfalls MicroPython-Treiber; das UART-Paket des TF-Luna wertest du mit machine.UART nach derselben Logik wie im Arduino-Code aus.

1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN)             # 5 V ECHO için gerilim bölücü şart / divider required for a 5 V ECHO
6SES_HIZI = 0.0343                  # cm/µs, 20 °C
7
8def mesafe_olc():
9    trig.low()
10    time.sleep_us(2)
11    trig.high()
12    time.sleep_us(10)              # 10 µs tetik / 10 µs trigger
13    trig.low()
14    sure = time_pulse_us(echo, 1, 30000)   # zaman aşımında eksi döner / negative on timeout
15    if sure < 0:
16        return None
17    return sure * SES_HIZI / 2
18
19while True:
20    d = mesafe_olc()
21    print("Menzil disi" if d is None else "{:.1f} cm".format(d))
22    time.sleep_ms(100)
23

Welcher Abstandssensor für welches Projekt?

Noch ein paar Projektideen: Schwenk einen HC-SR04 auf einem Servo und baue ein Arduino-Radar; nutze bei deinem hindernisvermeidenden Roboter vorn einen HC-SR04 und seitlich zwei VL53L0X; öffne den Deckel eines smarten Mülleimers, wenn sich eine Hand nähert; bau mit einem OLED-Display ein tragbares digitales Maßband, oder schick mit einem JSN-SR04T den Füllstand deines Wassertanks über einen ESP32 aufs Handy.

Häufige Fehler und Lösungen

Abstandssensoren sind der einfachste Weg, Arduino-Projekten ein Gespür für ihre Umgebung zu geben, und der richtige Sensor entscheidet darüber, ob ein Projekt ruhig läuft oder nervt. Die Tabellen und Codes dieses Vergleichs helfen dir, Budget und Leistung passend abzuwägen. In der BlueGrays-App findest du Projekte zur Abstandsmessung mit dem HC-SR04, zur Einparkhilfe, zur Körpergrößenmessung, zum hindernisvermeidenden Roboter, zur ESP32-Einparkhilfe und zur Abstandsmessung mit dem TCRT5000, jeweils Schritt für Schritt mit Schaltplan und Code.