Ratgeber · 10 Min. Lesezeit

Einparkhilfe mit Arduino: HC-SR04, Piepton, LED-Balken und OLED

Einparkhilfe mit Arduino bauen: HC-SR04, Tabelle Abstand zu Pieptakt, nicht blockierender millis()-Code, LED-Balken, OLED-Anzeige, ESP32-Version, Einbautipps.

Eine Einparkhilfe mit Arduino ist ein kleiner Fahrhelfer: Ein HC-SR04-Ultraschallsensor misst den Abstand zum Hindernis hinter dir, der Piepton wird schneller, je näher du kommst, ein LED-Balken füllt sich von Grün bis Rot, und auf Wunsch zeigt ein OLED-Display den Abstand in Zentimetern an. Die Parksensoren echter Autos arbeiten nach demselben Prinzip: Ein Sensor im Stoßfänger sendet eine Schallwelle aus, berechnet aus der Laufzeit des Echos den Abstand und warnt den Fahrer mit einem Piepton. Mit einem Arduino Uno, einem HC-SR04, einem Summer (Buzzer) und fünf LEDs baust du das Gleiche an einem Abend auf dem Steckbrett nach.

In dieser Anleitung legen wir zuerst die Abstandszonen und den Pieptakt jeder Zone in einer Tabelle fest. Dann schreiben wir Code, der mit millis() statt delay() arbeitet, damit das Piepen die Messung nie anhält. Danach erweitern wir den Code um ein OLED-Display, verringern Messfehler mit einem Medianfilter und einer Temperaturkorrektur, schreiben eine ESP32-Version mit passivem Summer und Hysterese und besprechen zum Schluss, wie du den Sensor am Auto oder an der Garagenwand montierst.

HC-SR04 Ultraschall-Abstandssensor
HC-SR04: Ein Zylinder sendet eine 40-kHz-Schallwelle, der andere horcht auf das Echo. Diese beiden Zylinder sind die Augen der Einparkhilfe.

Wie funktioniert eine Einparkhilfe?

Gibst du dem TRIG-Pin des HC-SR04 einen Impuls von 10 Mikrosekunden, sendet der Sensor acht Schallimpulse mit 40 kHz aus, einer Frequenz, die das menschliche Ohr nicht hört, und setzt den ECHO-Pin auf HIGH. Trifft der Schall auf ein Hindernis und kommt zurück, geht ECHO auf LOW. Die Zeit, in der ECHO HIGH bleibt, ist die Laufzeit hin und zurück. Bei 20 °C legt Schall in Luft etwa 343 Meter pro Sekunde zurück, also einen Zentimeter in rund 29 Mikrosekunden. Rechnet man Hin- und Rückweg zusammen, wird die Formel sehr einfach: Abstand (cm) = Zeit (µs) / 58. Das Echo von einer Wand in 1 Meter Entfernung braucht zum Beispiel etwa 5800 µs.

Die Einparkhilfe wiederholt diese Messung 15- bis 20-mal pro Sekunde und ordnet das Ergebnis einer Zone zu. Mit der Zone ändern sich die Zahl der leuchtenden LEDs und der Pieptakt. Diese Werte des HC-SR04 sind für eine Einparkhilfe wichtig:

EigenschaftWert
Versorgung5 V, etwa 15 mA
Schallfrequenz40 kHz
Messbereich2–400 cm (zuverlässig zum Einparken 3–250 cm)
ErfassungswinkelKegel von etwa 15°
TriggerimpulsMindestens 10 µs HIGH an TRIG
MessrateMindestens 60 ms zwischen zwei Messungen
AuflösungEtwa 3 mm

Materialliste

BauteilAnzahlHinweis
Arduino Uno oder Nano1ESP32-Version weiter unten
HC-SR04 Ultraschallsensor1Außen am Auto besser den wasserdichten JSN-SR04T
Aktiver Summer (Buzzer)1In der ESP32-Version ein passiver Summer
LEDs (2 grün, 2 gelb, 1 rot)5Nebeneinander als LED-Balken
Widerstand 220 Ω5Einer pro LED
0,96-Zoll-I2C-OLED-Display1Optionale Anzeige
Steckbrett und Jumperkabel1 SatzKabel kurz halten
Widerstände 1 kΩ und 2 kΩJe einerNur für ESP32, Spannungsteiler an ECHO

Tabelle: Abstand und Pieptakt

Die Parksensoren echter Autos beginnen meist ab etwa 1,5 Metern mit einem langsamen Piepen, werden schneller, je näher das Hindernis kommt, und gehen auf den letzten 25–30 Zentimetern in einen Dauerton über. Der Fahrer erkennt allein am Rhythmus, wie viel Platz noch bleibt, ohne auf ein Display zu schauen. Unser Entwurf hat fünf Warnzonen und eine sichere Zone. Jeder Piepton dauert 50 ms; der Abstand in der Tabelle ist die Zeit zwischen dem Beginn zweier Pieptöne:

ZoneAbstandPieptaktLeuchtende LEDsBedeutung
SicherMehr als 150 cmStillKeineFrei
1101–150 cm800 ms1 grünHindernis erkannt
271–100 cm500 ms2 grünLangsamer
346–70 cm300 ms2 grün + 1 gelbVorsicht
426–45 cm150 ms2 grün + 2 gelbSehr nah
525 cm und wenigerDauertonAlle fünf (inklusive Rot)Stopp

Du kannst die Werte an dein Auto anpassen: Bei einem Auto mit langem Überhang hinten oder in einer engen Garage ist es sicherer, die Stoppzone auf 35–40 cm zu legen. Soll sich der Pieptakt stufenlos statt in Stufen ändern, ersetzt du die Zonentabelle mit der map()-Funktion durch eine Umrechnung wie intervall = map(abstand, 25, 150, 100, 800). Eine gestufte Tabelle lässt sich aber mit dem Ohr besser unterscheiden: Der Fahrer merkt am Klang sofort, wenn er von Zone drei in Zone vier wechselt.

Schaltplan: HC-SR04, Summer und LED-Balken

Bauteil und PinArduino UnoESP32Hinweis
HC-SR04 VCC5VVIN (5V)Der Sensor braucht 5 V
HC-SR04 GNDGNDGNDGemeinsame Masse
HC-SR04 TRIGD9GPIO 4Trigger-Ausgang
HC-SR04 ECHOD10GPIO 18Am ESP32 über Teiler 1 kΩ + 2 kΩ
Summer (+)D8GPIO 19Am Uno aktiver, am ESP32 passiver Summer
LED 1 und 2 (grün)D2, D3GPIO 25, 26Je LED ein 220-Ω-Vorwiderstand
LED 3 und 4 (gelb)D4, D5GPIO 27, 32Je LED ein 220-Ω-Vorwiderstand
LED 5 (rot)D6GPIO 33Leuchtet in der Stoppzone
OLED SDA / SCLA4 / A5GPIO 21 / 22Optional
OLED VCC5V3V3Pinreihenfolge des Moduls prüfen
Der ECHO-Pin des HC-SR04 gibt 5 V aus. Für den Arduino Uno ist das kein Problem, die Pins des ESP32 vertragen aber nur 3,3 V. Setze zwischen ECHO und GPIO 18 einen Widerstand von 1 kΩ und zwischen GPIO 18 und GND einen von 2 kΩ: 5 V × 2 / 3 ≈ 3,3 V. Die Werte kannst du mit dem Werkzeug Spannungsteiler prüfen. Vergiss auch die Vorwiderstände der LEDs nicht: 220 Ω ergeben an 5 V etwa 13 mA; für deine eigenen LEDs hilft dir das Werkzeug LED-Vorwiderstand.

Warum millis() statt delay()?

Die meisten Einparkhilfe-Sketche im Netz erzeugen den Piepton so: Summer an, delay(50), aus, delay(intervall). In einer 800-ms-Zone macht das den Arduino in jedem Durchlauf fast eine Sekunde lang blind. Ein Auto, das mit 2 km/h rückwärts fährt, legt in dieser Zeit rund 45 cm zurück; LEDs und Ton hinken dem echten Abstand immer hinterher, und im schlimmsten Fall ist die Messung genau beim Einfahren in die Stoppzone eingefroren. Richtig ist es, beide Aufgaben zu trennen: alle 60 ms messen und in jedem Durchlauf mit millis() entscheiden, ob der Summer an oder aus sein soll. Die Idee erklären wir ausführlich in millis() statt delay().

Aufbau Schritt für Schritt

  1. Stecke den HC-SR04 an ein Ende des Steckbretts, die Zylinder zeigen nach außen; verbinde VCC mit 5V und GND mit GND.
  2. Verbinde TRIG mit D9 und ECHO mit D10. Halte die Kabel kurz; ein lockeres Jumperkabel verfälscht die Messwerte zufällig.
  3. Reihe die fünf LEDs nebeneinander auf: von links nach rechts zwei grüne, zwei gelbe und eine rote. Verbinde das lange Bein (Anode) jeder LED über einen 220-Ω-Widerstand mit D2–D6 und das kurze Bein mit der GND-Schiene.
  4. Verbinde das Plus-Bein des aktiven Summers mit D8 und das andere Bein mit GND. Aktive Summer haben meist ein Pluszeichen auf der Oberseite und piepen von selbst, sobald 5 V anliegen.
  5. Lade den Code hoch, öffne den seriellen Monitor mit 115200 Baud und nähere deine Hand langsam dem Sensor. Abstand und Zonennummer sollten alle 60 ms erscheinen.
  6. Stell einen Karton auf den Boden, markiere mit dem Maßband 150, 100, 70, 45 und 25 cm und schiebe den Karton zu diesen Punkten, um zu prüfen, ob die Zonen richtig wechseln.

Code für die Arduino-Einparkhilfe (LED-Balken + Summer)

Der folgende Code setzt die Zonen aus der Tabelle genau um. Er misst alle 60 ms, nimmt den Median der letzten drei Messungen und erzeugt den Piepton unabhängig von der Messung mit millis(). Im ganzen Code steht kein einziges delay():

C++ (Arduino IDE)
1// Arduino park sensörü: HC-SR04 + 5 LED bar + aktif buzzer / Arduino parking sensor: HC-SR04 + 5-LED bar + active buzzer
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const int BUZZER_PIN = 8;
5const int LED_PINS[5] = {2, 3, 4, 5, 6};          // yeşil, yeşil, sarı, sarı, kırmızı / green, green, yellow, yellow, red
6
7// Bölge sınırları (cm) ve bip aralıkları (ms), tablodaki değerler / zone limits (cm) and beep periods (ms) from the table
8const int ZONE_CM[5] = {150, 100, 70, 45, 25};
9const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};  // 0 = sürekli ses / 0 = continuous tone
10const unsigned int BEEP_ON_MS = 50;                // her bipin süresi / length of each beep
11const unsigned long MEASURE_MS = 60;               // HC-SR04 için en az 60 ms / at least 60 ms for the HC-SR04
12
13unsigned long lastMeasure = 0;
14unsigned long lastBeep = 0;
15int samples[3] = {999, 999, 999};                  // son 3 ölçüm / last 3 readings
16int sampleIndex = 0;
17int distanceCm = 999;
18int zone = 0;                                      // 0 = güvenli, 5 = dur / 0 = safe, 5 = stop
19
20long readDistanceCm() {
21  digitalWrite(TRIG_PIN, LOW);
22  delayMicroseconds(2);
23  digitalWrite(TRIG_PIN, HIGH);                    // 10 µs tetik darbesi / 10 µs trigger pulse
24  delayMicroseconds(10);
25  digitalWrite(TRIG_PIN, LOW);
26  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı, yaklaşık 4,3 m / 25 ms timeout, about 4.3 m
27  if (us == 0) return 999;                         // yankı yok: engel uzakta / no echo: obstacle far away
28  return us / 58;                                  // µs / 58 = cm (gidiş-dönüş / round trip)
29}
30
31int median3(int a, int b, int c) {                 // üçün ortancası, ani sıçramaları atar / median of three, drops spikes
32  return max(min(a, b), min(max(a, b), c));
33}
34
35int zoneFor(int d) {
36  int z = 0;
37  for (int i = 0; i < 5; i++) {
38    if (d <= ZONE_CM[i]) z = i + 1;
39  }
40  return z;
41}
42
43void updateLeds() {
44  for (int i = 0; i < 5; i++) {
45    digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);  // bölge kadar LED yak / light as many LEDs as the zone
46  }
47}
48
49void updateBuzzer(unsigned long now) {
50  if (zone == 0) {                                 // güvenli bölge: sessiz / safe zone: silent
51    digitalWrite(BUZZER_PIN, LOW);
52    return;
53  }
54  unsigned int period = BEEP_MS[zone - 1];
55  if (period == 0) {                               // dur bölgesi: sürekli ses / stop zone: continuous tone
56    digitalWrite(BUZZER_PIN, HIGH);
57    return;
58  }
59  if (now - lastBeep >= period) lastBeep = now;    // yeni bip zamanı / time for a new beep
60  digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
61}
62
63void setup() {
64  pinMode(TRIG_PIN, OUTPUT);
65  pinMode(ECHO_PIN, INPUT);
66  pinMode(BUZZER_PIN, OUTPUT);
67  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
68  Serial.begin(115200);
69}
70
71void loop() {
72  unsigned long now = millis();
73  if (now - lastMeasure >= MEASURE_MS) {           // 60 ms'de bir ölç / measure every 60 ms
74    lastMeasure = now;
75    samples[sampleIndex] = readDistanceCm();
76    sampleIndex = (sampleIndex + 1) % 3;
77    distanceCm = median3(samples[0], samples[1], samples[2]);
78    zone = zoneFor(distanceCm);
79    updateLeds();
80    Serial.print(F("Mesafe / Distance: "));
81    Serial.print(distanceCm);
82    Serial.print(F(" cm  Bolge / Zone: "));
83    Serial.println(zone);
84  }
85  updateBuzzer(millis());                          // bip, ölçümden bağımsız akar / beeping runs independently of measuring
86}
CodeteilWas er macht
ZONE_CM und BEEP_MSHalten Zonengrenzen und Pieptakte an einer Stelle; um die Tabelle zu ändern, bearbeitest du nur diese beiden Zeilen.
pulseIn(..., 25000UL)Wartet höchstens 25 ms auf das Echo (etwa 4,3 m). Kommt keines, liefert die Funktion 0, und der Code wertet das als 999, also kein Hindernis.
us / 58Rechnet die Laufzeit hin und zurück in Zentimeter um.
median3()Nimmt den Median der letzten drei Messungen; ein einzelner Ausreißer bringt LEDs und Ton nicht durcheinander.
now - lastBeep >= periodPrüft, ob es Zeit für einen neuen Piepton ist; in den ersten 50 ms jedes Tons ist der Summer an, danach aus.
MEASURE_MS = 60Der kürzeste für den HC-SR04 empfohlene Messzyklus; misst du schneller, hältst du ein spätes Echo der vorigen Messung für eine neue.
Warum ist ein Medianfilter besser als ein Mittelwert? Sind drei Messungen 82, 83 und 3 cm, beträgt der Mittelwert 56 cm und das System springt fälschlich in Zone drei. Der Median ist 82 cm; ein einzelner Unsinnswert wird einfach ignoriert. Verschiedene Filterarten vergleichst du in Sensordaten filtern.

Messgenauigkeit: Einfluss von Temperatur und Oberfläche

Die Zahl 58 im Code geht von einer Schallgeschwindigkeit von etwa 345 m/s aus, also von Luft mit rund 22 °C. Die Schallgeschwindigkeit hängt aber von der Temperatur ab: v = 331,3 + 0,606 × T (m/s, T in °C). Im Winter bei 0 °C ist der Schall langsamer, das Echo kommt später zurück und der Sensor hält das Hindernis für etwas weiter entfernt, als es ist. Bei einem echten Abstand von 100 cm misst er ungefähr:

LufttemperaturSchallgeschwindigkeitMesswert (Zeit ÷ 58)
-10 °C325 m/sEtwa 106 cm
0 °C331 m/sEtwa 104 cm
10 °C337 m/sEtwa 102 cm
20 °C343 m/sEtwa 100 cm
30 °C350 m/sEtwa 99 cm
40 °C356 m/sEtwa 97 cm

Beim Einparken stören ein paar Zentimeter nicht. Willst du trotzdem im Sommer bei 40 °C in der Garage und im Winter bei Minusgraden denselben Stopppunkt, misst du die Temperatur mit einem DHT11 oder DS18B20 und berechnest den Abstand mit Zeit × (331,3 + 0,606 × T) / 20000. Die Oberfläche wirkt sich viel stärker aus als die Temperatur: Eine glatte Wand, ein Garagentor oder der Stoßfänger eines anderen Autos werfen den Schall gut zurück; ein dünner Pfosten, ein Maschendrahtzaun, ein Busch oder weiche Oberflächen wie Stoff schwächen das Echo oder schicken gar keins zurück. Eine schräg zum Sensor stehende Fläche lenkt den Schall außerdem in eine andere Richtung ab. Deshalb sollte eine Ultraschall-Einparkhilfe nie deine einzige Sicherheitsmaßnahme sein.

Abstand auf einem OLED-Display anzeigen

Für eine Anzeige, die der Fahrer sehen kann, ist ein 0,96-Zoll-OLED-Display ideal: Es zeigt den Abstand mit großen Ziffern und zeichnet darunter einen Balken, der sich füllt, je näher das Hindernis kommt. Die I2C-Verkabelung des Displays und die Installation der Bibliotheken Adafruit SSD1306 und Adafruit GFX erklären wir ausführlich in OLED-Display SSD1306. Das Display wird fünfmal pro Sekunde aufgefrischt; jede Aktualisierung dauert etwa 25–30 ms, häufigeres Zeichnen würde also Messung und Pieptakt stören.

C++ (Arduino IDE)
1// Park sensörü + 0,96" OLED: büyük rakamla mesafe ve doluluk çubuğu / parking sensor + 0.96" OLED: big distance digits and a fill bar
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1);     // 128x64, reset pini yok / 128x64, no reset pin
7
8const int TRIG_PIN = 9;
9const int ECHO_PIN = 10;
10const int BUZZER_PIN = 8;
11const int LED_PINS[5] = {2, 3, 4, 5, 6};
12const int ZONE_CM[5] = {150, 100, 70, 45, 25};
13const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
14const unsigned int BEEP_ON_MS = 50;
15const int MAX_SHOW_CM = 200;                       // çubuğun boş olduğu mesafe / distance where the bar is empty
16
17unsigned long lastMeasure = 0, lastBeep = 0, lastDraw = 0;
18int samples[3] = {999, 999, 999};
19int sampleIndex = 0;
20int distanceCm = 999;
21int zone = 0;
22
23long readDistanceCm() {
24  digitalWrite(TRIG_PIN, LOW);
25  delayMicroseconds(2);
26  digitalWrite(TRIG_PIN, HIGH);
27  delayMicroseconds(10);
28  digitalWrite(TRIG_PIN, LOW);
29  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
30  return us == 0 ? 999 : us / 58;
31}
32
33int median3(int a, int b, int c) {
34  return max(min(a, b), min(max(a, b), c));
35}
36
37void drawScreen() {
38  display.clearDisplay();
39  display.setTextSize(1);
40  display.setCursor(0, 0);
41  if (zone == 5) display.print(F("DUR / STOP"));
42  else if (zone == 0) display.print(F("Yol acik / Clear"));
43  else display.print(F("Yaklasiyor / Closer"));
44
45  display.setTextSize(3);                          // büyük rakamlar / big digits
46  display.setCursor(0, 18);
47  if (distanceCm >= 999) display.print(F("---"));
48  else display.print(distanceCm);
49  display.setTextSize(2);
50  display.print(F(" cm"));
51
52  // Yaklaştıkça dolan çubuk / a bar that fills as you get closer
53  int d = constrain(distanceCm, 0, MAX_SHOW_CM);
54  int fill = map(d, MAX_SHOW_CM, 0, 0, 124);
55  display.drawRect(0, 50, 128, 12, SSD1306_WHITE);
56  display.fillRect(2, 52, fill, 8, SSD1306_WHITE);
57  display.display();
58}
59
60void setup() {
61  pinMode(TRIG_PIN, OUTPUT);
62  pinMode(ECHO_PIN, INPUT);
63  pinMode(BUZZER_PIN, OUTPUT);
64  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
65  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  // OLED adresi genelde 0x3C / OLED address is usually 0x3C
66    for (;;);                                      // ekran yoksa dur / stop if no display
67  }
68  display.setTextColor(SSD1306_WHITE);
69}
70
71void loop() {
72  unsigned long now = millis();
73  if (now - lastMeasure >= 60) {
74    lastMeasure = now;
75    samples[sampleIndex] = readDistanceCm();
76    sampleIndex = (sampleIndex + 1) % 3;
77    distanceCm = median3(samples[0], samples[1], samples[2]);
78    zone = 0;
79    for (int i = 0; i < 5; i++) if (distanceCm <= ZONE_CM[i]) zone = i + 1;
80    for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
81  }
82  if (now - lastDraw >= 200) {                     // ekranı saniyede 5 kez yenile / refresh the screen 5 times a second
83    lastDraw = now;
84    drawScreen();
85  }
86  now = millis();
87  if (zone == 0) {
88    digitalWrite(BUZZER_PIN, LOW);
89  } else if (BEEP_MS[zone - 1] == 0) {
90    digitalWrite(BUZZER_PIN, HIGH);
91  } else {
92    if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
93    digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
94  }
95}

Je nach Zone zeigt die obere Zeile Yol acik / Clear, Yaklasiyor / Closer oder DUR / STOP. Die Texte sind zweisprachig (Türkisch / Englisch) und ohne Umlaute geschrieben, weil die Standardschrift der OLED-Bibliothek nur einfache ASCII-Zeichen kennt. Etwa 1 KB der 2 KB RAM des Uno gehen an den Bildpuffer; wenn du den Code erweiterst, lass feste Texte weiter in F(), sonst startet das Display womöglich gar nicht.

Einparkhilfe mit dem ESP32

Die ESP32-Version unterscheidet sich in drei Punkten. Erstens wird der Sensor weiter mit 5 V versorgt, der ECHO-Pin läuft aber über den Spannungsteiler. Zweitens nutzen wir statt eines aktiven einen passiven Summer und erzeugen mit der LEDC-Hardware des ESP32 einen 2,5-kHz-Ton; über die Frequenz bestimmst du den Klang selbst. Drittens haben wir 3 cm Hysterese eingebaut, damit die LEDs an einer Zonengrenze nicht flackern: Entfernt sich das Auto, muss der Abstand die Grenze um 3 cm überschreiten, bevor die Zone sinkt. Weil sich die LEDC-Funktionen in Version 3.x des ESP32-Arduino-Cores geändert haben, prüft der Code ESP_ARDUINO_VERSION_MAJOR und lässt sich mit 2.x und 3.x kompilieren.

C++ (Arduino IDE)
1// ESP32 park sensörü: HC-SR04 + 5 LED + pasif buzzer (LEDC), çekirdek 2.x ve 3.x / ESP32 parking sensor: HC-SR04 + 5 LEDs + passive buzzer (LEDC), core 2.x and 3.x
2const int TRIG_PIN = 4;
3const int ECHO_PIN = 18;                           // 1 kΩ + 2 kΩ gerilim bölücüyle / through a 1 kΩ + 2 kΩ divider
4const int BUZZER_PIN = 19;
5const int LED_PINS[5] = {25, 26, 27, 32, 33};
6const int ZONE_CM[5] = {150, 100, 70, 45, 25};
7const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
8const unsigned int BEEP_ON_MS = 50;
9const unsigned int TONE_HZ = 2500;                 // pasif buzzerın en yüksek sesi genelde 2–4 kHz / passive buzzers are loudest around 2–4 kHz
10const int HYST_CM = 3;                             // bölge sınırında titremeyi önler / stops flicker at zone limits
11const int BUZZER_CH = 0;                           // yalnız 2.x için LEDC kanalı / LEDC channel, 2.x only
12
13unsigned long lastMeasure = 0, lastBeep = 0;
14int samples[3] = {999, 999, 999};
15int sampleIndex = 0;
16int distanceCm = 999;
17int zone = 0;
18bool buzzerOn = false;
19
20void buzzer(bool on) {
21  if (on == buzzerOn) return;                      // yalnız değişince yaz / write only on change
22  buzzerOn = on;
23#if ESP_ARDUINO_VERSION_MAJOR >= 3
24  ledcWriteTone(BUZZER_PIN, on ? TONE_HZ : 0);     // 3.x: pin numarasıyla / 3.x: by pin number
25#else
26  ledcWriteTone(BUZZER_CH, on ? TONE_HZ : 0);      // 2.x: kanal numarasıyla / 2.x: by channel number
27#endif
28}
29
30long readDistanceCm() {
31  digitalWrite(TRIG_PIN, LOW);
32  delayMicroseconds(2);
33  digitalWrite(TRIG_PIN, HIGH);
34  delayMicroseconds(10);
35  digitalWrite(TRIG_PIN, LOW);
36  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
37  return us == 0 ? 999 : us / 58;
38}
39
40int median3(int a, int b, int c) {
41  return max(min(a, b), min(max(a, b), c));
42}
43
44int zoneFor(int d, int current) {
45  int z = 0;
46  for (int i = 0; i < 5; i++) if (d <= ZONE_CM[i]) z = i + 1;
47  if (current > 0 && z < current && d <= ZONE_CM[current - 1] + HYST_CM) z = current;  // uzaklaşırken 3 cm pay / 3 cm margin when moving away
48  return z;
49}
50
51void setup() {
52  Serial.begin(115200);
53  pinMode(TRIG_PIN, OUTPUT);
54  pinMode(ECHO_PIN, INPUT);
55  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
56#if ESP_ARDUINO_VERSION_MAJOR >= 3
57  ledcAttach(BUZZER_PIN, TONE_HZ, 8);              // 3.x: pin, frekans, çözünürlük / 3.x: pin, frequency, resolution
58#else
59  ledcSetup(BUZZER_CH, TONE_HZ, 8);                // 2.x: kanal kur, sonra pine bağla / 2.x: set up a channel, then attach the pin
60  ledcAttachPin(BUZZER_PIN, BUZZER_CH);
61#endif
62  buzzerOn = true;
63  buzzer(false);                                   // sessiz başla / start silent
64}
65
66void loop() {
67  unsigned long now = millis();
68  if (now - lastMeasure >= 60) {
69    lastMeasure = now;
70    samples[sampleIndex] = readDistanceCm();
71    sampleIndex = (sampleIndex + 1) % 3;
72    distanceCm = median3(samples[0], samples[1], samples[2]);
73    zone = zoneFor(distanceCm, zone);
74    for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
75    Serial.printf("Mesafe / Distance: %d cm  Bolge / Zone: %d\n", distanceCm, zone);
76  }
77  now = millis();
78  if (zone == 0) {
79    buzzer(false);
80  } else if (BEEP_MS[zone - 1] == 0) {
81    buzzer(true);
82  } else {
83    if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
84    buzzer(now - lastBeep < BEEP_ON_MS);
85  }
86}
Die Pins GPIO 34–39 des ESP32 sind reine Eingänge; schließt du TRIG oder die LEDs daran an, passiert nichts, für ECHO kannst du sie aber nutzen. Ist der Ton zu leise, probiere für TONE_HZ Werte zwischen 2000 und 4000; jeder passive Summer hat eine Frequenz, bei der er am lautesten ist. Wenn du den ESP32 noch nicht kennst, ist Was ist der ESP32? ein guter Einstieg.

Einbautipps für Auto und Garage

  • Höhe und Winkel: Montiere den Sensor 50–70 cm über dem Boden, parallel dazu und 3–5 Grad nach oben geneigt. Ein nach unten gerichteter Sensor hält Bodenwellen und die Bordsteinkante für Hindernisse.
  • Wasser und Staub: Der HC-SR04 ist nicht wasserdicht; Regen, Schmutz und die Waschanlage machen ihn schnell kaputt. Für ein System im Stoßfänger nimm eine wasserdichte Ultraschallsonde wie den JSN-SR04T. Diese Sonden messen erst ab 20–25 cm, deshalb musst du die Stoppzone auf 30–35 cm legen.
  • Stromversorgung: Das Bordnetz steigt bei laufendem Motor auf 13,8–14,4 V, beim Anlassen gibt es Einbrüche und beim Abschalten von Verbrauchern Spannungsspitzen. Versorge den Arduino nicht direkt mit 12 V, sondern senke die Spannung mit einem Abwärtswandler wie dem LM2596 auf 5 V und sichere ihn mit 1 A ab. Speist du die Schaltung aus dem Stromkreis des Rückfahrscheinwerfers, läuft sie nur im Rückwärtsgang.
  • Kabel: Den Sensor kannst du in den Stoßfänger, den Arduino in den Kofferraum und Summer und LED-Balken in Sichtweite des Fahrers setzen. Für TRIG- und ECHO-Leitungen über 3–4 Meter nimm verdrillte Adern und setze einen 100-nF-Kondensator zwischen VCC und GND des Sensors.
  • Mehrere Sensoren: Echte Autos haben meist 3–4 Sensoren im hinteren Stoßfänger. Triggerst du zwei HC-SR04 gleichzeitig, hört einer das Echo des anderen; miss sie nacheinander mit mindestens 30–60 ms Pause und melde dem Fahrer den kleinsten Abstand.
  • Version für die Garagenwand: Wenn du am Auto nichts verändern willst, montiere den Sensor auf Stoßfängerhöhe an der Rückwand der Garage. Beim Einfahren wechselt der LED-Balken wie eine Ampel von Grün auf Rot; das ist die einfachste und sicherste Einparkhilfe überhaupt.
Dieses Projekt dient dem Lernen und Basteln und ersetzt nicht die Sicherheitssysteme des Autos. Klemme vor Arbeiten an der Fahrzeugelektrik den Minuspol der Batterie ab und halte Kabel von beweglichen Teilen und vom Auspuff fern. Nutze weiter deine Spiegel und den Schulterblick für Hindernisse, die der Sensor nicht sieht, etwa dünne Pfosten, Kinder oder Tiere.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Abstand immer 999 oder ändert sich nichtTRIG und ECHO vertauscht, VCC nicht 5 V oder Kabel lockerPins mit der Anschlusstabelle vergleichen, Sensor an 5V anschließen
Werte springen zufälligWeiche oder schräge Fläche, lockeres Steckbrett, zu häufige MessungenMedianfilter nutzen, mindestens 60 ms zwischen den Messungen lassen
Abstand friert beim Piepen einIm Code steht ein delay()Piepton mit millis() erzeugen, den Code aus diesem Artikel verwenden
Summer knistert oder bleibt stummCode für aktiven Summer mit passivem Summer verwendet oder umgekehrtBeim Uno-Code einen aktiven, beim ESP32-Code einen passiven Summer nehmen
LEDs flackern an der ZonengrenzeDer Abstand pendelt genau an der GrenzeDie 3-cm-Hysterese aus dem ESP32-Code auch in den Uno-Code übernehmen
ESP32 misst gar keinen AbstandSensor mit 3,3 V versorgt oder Teiler verkehrt herumVCC an VIN anschließen, der 2-kΩ-Widerstand muss auf der GND-Seite sitzen
Am Tisch richtig, am Auto FehlalarmeDer Sensor sieht den Boden, das Kennzeichen oder die AnhängerkupplungSensor höher setzen und 3–5 Grad nach oben neigen
Summer zu leiseDer Pin liefert nicht genug StromSummer über einen NPN-Transistor wie den BC547 ansteuern
Mach nach jeder Änderung denselben Test: Schieb den Karton auf die Markierungen bei 150, 100, 70, 45 und 25 cm und vergleiche die Zonennummer im seriellen Monitor mit der Tabelle. Stimmt sie überall, ist dein System fertig. Details zum Sensor und einen ersten Abstands-Sketch findest du in HC-SR04 Ultraschallsensor, die Summerarten in Was ist ein Buzzer?.

Projekte für die Zeit nach der Einparkhilfe

  • Farbige Garagenanzeige: Nimm statt des LED-Balkens einen WS2812B-NeoPixel-Ring, der sich von Grün bis Rot füllt, je näher das Auto kommt.
  • Parkplatz-Belegungssystem: Bau ein Arduino-Parkplatzsystem, das jeden Stellplatz mit einem Sensor überwacht und die freien Plätze zählt.
  • Ultraschall-Radar: Bau ein Arduino-Radar, das den Sensor auf einem Servo schwenkt und die Umgebung abtastet.
  • Roboter, der Hindernissen ausweicht: Kombiniere dieselbe Abstandsmessung mit einer Motorsteuerung zu einem Hindernis-Roboter.
  • Präzise Messung auf kurze Distanz: Um den Stopppunkt millimetergenau einzustellen, probiere den VL53L0X-Laser-Abstandssensor; die Unterschiede findest du im Vergleich der Abstandssensoren.

Weil eine Einparkhilfe mit Arduino Ton, Licht und Messung in einem Projekt vereint, ist sie ein tolles erstes größeres Projekt und eignet sich auch gut für Schulprojekte und Wettbewerbe wie Jugend forscht. Passe die Zonentabelle an dein Auto an, teste das System zuerst in der Garage und geh dann mit den Einbautipps einen Schritt weiter. Den Schaltplan Schritt für Schritt und fertigen Code für dieselbe Schaltung findest du in der BlueGrays-App in den Projekten zur Einparkhilfe mit HC-SR04 und mit dem ESP32.

Häufige Fragen

Wie funktioniert eine Einparkhilfe mit Arduino?

Ein HC-SR04 sendet Ultraschall aus und misst die Laufzeit des Echos; der Arduino rechnet sie mit Zeit / 58 in Zentimeter um. Je nach Abstand wählt er eine Zone, die den Pieptakt des Summers und die Zahl der leuchtenden LEDs bestimmt. Mit millis() statt delay() läuft die Messung auch während des Piepens weiter.

Welche Reichweite hat der HC-SR04?

Laut Datenblatt misst der HC-SR04 2–400 cm, an einer glatten, großen Fläche liegt der zuverlässige Bereich aber bei etwa 3–250 cm. Zum Einparken reicht eine Warnung ab 150 cm völlig aus. Dünne Pfosten und weiche Flächen erkennt er unter Umständen selbst auf kurze Distanz nicht.

Ist der HC-SR04 wasserdicht?

Nein, der HC-SR04 ist weder wasser- noch staubdicht und übersteht Regen und Waschanlage nicht lange. Für den Einbau außen am Auto ist eine wasserdichte Sonde wie der JSN-SR04T die bessere Wahl. Brauchst du die Hilfe nur in der Garage, montierst du den Sensor am einfachsten an der Wand.

Aktiver oder passiver Summer für die Einparkhilfe?

Ein aktiver Summer hat einen eigenen Oszillator, piept sofort an 5 V und lässt sich mit digitalWrite schalten; dafür ist der Uno-Code hier geschrieben. Ein passiver Summer braucht eine Frequenz über tone() oder am ESP32 über LEDC, dafür wählst du die Tonhöhe selbst. Zum Unterscheiden legst du 5 V an: Der, der von selbst piept, ist aktiv.

Wie versorge ich den Arduino im Auto mit 12 V?

Das Bordnetz erreicht bei laufendem Motor bis zu 14,4 V und hat Spannungsspitzen, deshalb ist ein Abwärtswandler wie der LM2596 auf 5 V die sicherste Lösung. Ergänze eine 1-A-Sicherung. Speist du die Schaltung aus dem Rückfahrlicht, läuft sie nur im Rückwärtsgang.

Kann ich mehrere HC-SR04 gleichzeitig betreiben?

Ja, aber wenn sie im selben Moment senden, hören sie gegenseitig ihre Echos. Miss die Sensoren nacheinander mit mindestens 30–60 ms Pause und gib den kleinsten Abstand aus. Jeder Sensor braucht nur eigene TRIG- und ECHO-Pins.

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
Verwendung des Summers
AR-13Anfänger

Verwendung des Summers

Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

4.7(92)
170
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
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
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
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
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
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