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.

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:
| Eigenschaft | Wert |
|---|---|
| Versorgung | 5 V, etwa 15 mA |
| Schallfrequenz | 40 kHz |
| Messbereich | 2–400 cm (zuverlässig zum Einparken 3–250 cm) |
| Erfassungswinkel | Kegel von etwa 15° |
| Triggerimpuls | Mindestens 10 µs HIGH an TRIG |
| Messrate | Mindestens 60 ms zwischen zwei Messungen |
| Auflösung | Etwa 3 mm |
Materialliste
| Bauteil | Anzahl | Hinweis |
|---|---|---|
| Arduino Uno oder Nano | 1 | ESP32-Version weiter unten |
| HC-SR04 Ultraschallsensor | 1 | Außen am Auto besser den wasserdichten JSN-SR04T |
| Aktiver Summer (Buzzer) | 1 | In der ESP32-Version ein passiver Summer |
| LEDs (2 grün, 2 gelb, 1 rot) | 5 | Nebeneinander als LED-Balken |
| Widerstand 220 Ω | 5 | Einer pro LED |
| 0,96-Zoll-I2C-OLED-Display | 1 | Optionale Anzeige |
| Steckbrett und Jumperkabel | 1 Satz | Kabel kurz halten |
| Widerstände 1 kΩ und 2 kΩ | Je einer | Nur 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:
| Zone | Abstand | Pieptakt | Leuchtende LEDs | Bedeutung |
|---|---|---|---|---|
| Sicher | Mehr als 150 cm | Still | Keine | Frei |
| 1 | 101–150 cm | 800 ms | 1 grün | Hindernis erkannt |
| 2 | 71–100 cm | 500 ms | 2 grün | Langsamer |
| 3 | 46–70 cm | 300 ms | 2 grün + 1 gelb | Vorsicht |
| 4 | 26–45 cm | 150 ms | 2 grün + 2 gelb | Sehr nah |
| 5 | 25 cm und weniger | Dauerton | Alle 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 Pin | Arduino Uno | ESP32 | Hinweis |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5V) | Der Sensor braucht 5 V |
| HC-SR04 GND | GND | GND | Gemeinsame Masse |
| HC-SR04 TRIG | D9 | GPIO 4 | Trigger-Ausgang |
| HC-SR04 ECHO | D10 | GPIO 18 | Am ESP32 über Teiler 1 kΩ + 2 kΩ |
| Summer (+) | D8 | GPIO 19 | Am Uno aktiver, am ESP32 passiver Summer |
| LED 1 und 2 (grün) | D2, D3 | GPIO 25, 26 | Je LED ein 220-Ω-Vorwiderstand |
| LED 3 und 4 (gelb) | D4, D5 | GPIO 27, 32 | Je LED ein 220-Ω-Vorwiderstand |
| LED 5 (rot) | D6 | GPIO 33 | Leuchtet in der Stoppzone |
| OLED SDA / SCL | A4 / A5 | GPIO 21 / 22 | Optional |
| OLED VCC | 5V | 3V3 | Pinreihenfolge des Moduls prüfen |
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
- Stecke den HC-SR04 an ein Ende des Steckbretts, die Zylinder zeigen nach außen; verbinde VCC mit 5V und GND mit GND.
- Verbinde TRIG mit D9 und ECHO mit D10. Halte die Kabel kurz; ein lockeres Jumperkabel verfälscht die Messwerte zufällig.
- 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.
- 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.
- 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.
- 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():
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}| Codeteil | Was er macht |
|---|---|
| ZONE_CM und BEEP_MS | Halten 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 / 58 | Rechnet 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 >= period | Prü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 = 60 | Der 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. |
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:
| Lufttemperatur | Schallgeschwindigkeit | Messwert (Zeit ÷ 58) |
|---|---|---|
| -10 °C | 325 m/s | Etwa 106 cm |
| 0 °C | 331 m/s | Etwa 104 cm |
| 10 °C | 337 m/s | Etwa 102 cm |
| 20 °C | 343 m/s | Etwa 100 cm |
| 30 °C | 350 m/s | Etwa 99 cm |
| 40 °C | 356 m/s | Etwa 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.
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.
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}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.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Abstand immer 999 oder ändert sich nicht | TRIG und ECHO vertauscht, VCC nicht 5 V oder Kabel locker | Pins mit der Anschlusstabelle vergleichen, Sensor an 5V anschließen |
| Werte springen zufällig | Weiche oder schräge Fläche, lockeres Steckbrett, zu häufige Messungen | Medianfilter nutzen, mindestens 60 ms zwischen den Messungen lassen |
| Abstand friert beim Piepen ein | Im Code steht ein delay() | Piepton mit millis() erzeugen, den Code aus diesem Artikel verwenden |
| Summer knistert oder bleibt stumm | Code für aktiven Summer mit passivem Summer verwendet oder umgekehrt | Beim Uno-Code einen aktiven, beim ESP32-Code einen passiven Summer nehmen |
| LEDs flackern an der Zonengrenze | Der Abstand pendelt genau an der Grenze | Die 3-cm-Hysterese aus dem ESP32-Code auch in den Uno-Code übernehmen |
| ESP32 misst gar keinen Abstand | Sensor mit 3,3 V versorgt oder Teiler verkehrt herum | VCC an VIN anschließen, der 2-kΩ-Widerstand muss auf der GND-Seite sitzen |
| Am Tisch richtig, am Auto Fehlalarme | Der Sensor sieht den Boden, das Kennzeichen oder die Anhängerkupplung | Sensor höher setzen und 3–5 Grad nach oben neigen |
| Summer zu leise | Der Pin liefert nicht genug Strom | Summer über einen NPN-Transistor wie den BC547 ansteuern |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

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

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.

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.

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.

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.

Projekt Körpergrößenmessung
Ein Größenmesser für den Türrahmen, der dir in Zentimetern sagt, wie groß die Person darunter ist.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

