ESP32 Einparkhilfe selber bauen: LED-Ampel mit ESPHome und Home Assistant

Wer eine schmale Garage hat, kennt das Problem: Beim Einparken fährt man langsam Richtung Wand und versucht einzuschätzen, wie viel Platz noch bleibt. Manchmal hilft ein Tennisball an einer Schnur, manchmal eine Markierung auf dem Boden. Etwas eleganter geht es mit einer selbst gebauten Einparkhilfe.

Für dieses Projekt verwenden wir einen ESP32, einen günstigen Ultraschallsensor und drei LEDs. Daraus entsteht eine kleine Einparkampel, die den Abstand zur Garagenwand misst. Grün bedeutet weiterfahren, Gelb heißt langsam werden und Rot zeigt an, dass die gewünschte Parkposition erreicht ist.

Das Schöne daran: Die Einparkhilfe funktioniert eigenständig. Mit ESPHome übertragen wir den gemessenen Abstand zusätzlich an Home Assistant. Dadurch lässt sich das Projekt später beispielsweise um eine Garagenbeleuchtung oder weitere Automationen erweitern.

In diesem Artikel zeige ich dir den Aufbau, die Verkabelung und eine vollständige ESPHome-Konfiguration.

So funktioniert unsere ESP32-Einparkhilfe

Das Herzstück ist ein HC-SR04-Ultraschallsensor. Er sendet einen kurzen Ultraschallimpuls aus und misst, wie lange das Echo bis zur Rückkehr benötigt. Daraus lässt sich der Abstand zu einem Gegenstand berechnen.

Wir befestigen den Sensor an der Garagenwand, sodass er auf eine möglichst ebene Fläche an der Fahrzeugfront gerichtet ist. Der ESP32 wertet die Messwerte aus und steuert drei LEDs an.

Abstand	Anzeige	Bedeutung
Über 80 cm	Grün	Weiter vorfahren
40 bis 80 cm	Gelb	Langsam vorfahren
20 bis unter 40 cm	Rot	Gewünschte Parkposition erreicht
Unter 20 cm	Rot blinkend	Sehr geringer Abstand, anhalten

Die Entfernungen sind Beispielwerte. Du solltest sie später auf deine Garage und dein Fahrzeug abstimmen. Die Anlage ist eine zusätzliche Orientierungshilfe und ersetzt weder den Blick auf die Umgebung noch die Einparkhilfe des Fahrzeugs.

Benötigte Bauteile für die Einparkhilfe

Besonders viel Hardware benötigen wir nicht. Wer schon einmal mit ESP32 und ESPHome gearbeitet hat, dürfte einige Teile sogar bereits zu Hause haben.

1. ESP32 Entwicklungsboard

Als Steuerung verwenden wir ein gewöhnliches ESP32-DevKit mit WLAN. Ein ESP32-WROOM-32-Board ist für dieses Projekt vollkommen ausreichend. Achte auf die verfügbaren GPIO-Pins und darauf, dass das Board über USB programmiert werden kann.

ESP32 Entwicklungsboards bei Amazon ansehen*

2. HC-SR04 Ultraschallsensor

Der HC-SR04 gehört zu den bekanntesten Ultraschallsensoren für kleine Elektronikprojekte. Er besitzt vier Anschlüsse: VCC, Trig, Echo und GND.

Für unsere Einparkhilfe genügt der einfache Sensor zunächst vollkommen. Allerdings eignet sich die offene Bauform vor allem für einen geschützten, trockenen Montageort. In einer feuchten Garage kann eine entsprechend geschützte Sensorvariante sinnvoller sein.

HC-SR04 Ultraschallsensoren bei Amazon ansehen*

3. Drei LEDs für die Ampel

Für die Anzeige benötigen wir eine rote, eine gelbe und eine grüne LED. Dazu kommen drei Vorwiderstände mit jeweils 330 Ohm. Für den ersten Aufbau sind einzelne LEDs besonders praktisch, weil wir sie direkt an den ESP32 anschließen können.

Später lassen sich die LEDs in ein kleines Gehäuse einbauen. Alternativ kann man ein fertiges LED-Ampelmodul verwenden. Dabei müssen allerdings Anschlussbelegung, Betriebsspannung und Vorwiderstände zum Modul passen.

LEDs und passende Widerstände bei Amazon ansehen*

4. Breadboard, Kabel und Widerstände

Für den ersten Test verwenden wir ein Breadboard und passende Jumper-Kabel. Zusätzlich brauchen wir zwei Widerstände mit 1 kOhm und 2 kOhm für einen Spannungsteiler am Echo-Ausgang des Ultraschallsensors.

Breadboard- und Elektroniksets bei Amazon ansehen*

Außerdem benötigen wir ein passendes USB-Kabel und ein 5-V-USB-Netzteil. Für die endgültige Montage empfiehlt sich ein Kunststoffgehäuse.

Elektronikgehäuse bei Amazon ansehen*

Wer gerade erst mit ESP32-Projekten anfängt, kann sich auch ein Starterset anschauen. In vielen Sets sind Breadboard, Widerstände, LEDs und Anschlusskabel enthalten. Worauf du beim Kauf achten solltest, erkläre ich in meinem Artikel ESP32 Starter Set für ESPHome und Smart Home.

ESP32 und Ultraschallsensor richtig verkabeln

Bevor wir uns mit der Software beschäftigen, verbinden wir zunächst die Bauteile. Für den Anfang empfehle ich den Aufbau auf einem Breadboard. So können wir die Schaltung später leichter verändern.

HC-SR04 anschließen

HC-SR04	ESP32
VCC	5 V / VIN*
GND	GND
Trig	GPIO 5
Echo	GPIO 18 über Spannungsteiler

*Der verwendete 5-V- beziehungsweise VIN-Anschluss muss bei deinem ESP32-Board tatsächlich die USB-Versorgung bereitstellen. Prüfe dafür die Pinbelegung des konkreten Boards.

Wichtig: Der gewöhnliche HC-SR04 wird mit 5 V versorgt und gibt am Echo-Anschluss ein 5-V-Signal aus. Der ESP32 verträgt an seinen GPIO-Eingängen jedoch nur 3,3-V-Logik. Deshalb darf Echo nicht direkt an GPIO 18 angeschlossen werden.

Wir bauen einen einfachen Spannungsteiler:

HC-SR04 Echo
     |
  1 kOhm
     |
     +---------- GPIO 18 (ESP32)
     |
  2 kOhm
     |
    GND

Damit werden aus einem 5-V-Echo-Signal ungefähr 3,33 V. Die beiden Widerstände gehören in Reihe zwischen Echo und GND. Der ESP32-Eingang wird am Verbindungspunkt der Widerstände angeschlossen.

Wenn du einen geeigneten 3,3-V-kompatiblen Ultraschallsensor verwendest, ist dieser Spannungsteiler gegebenenfalls nicht erforderlich. Entscheidend ist das Datenblatt der tatsächlich verbauten Variante.

LED-Ampel anschließen

Die drei LEDs werden jeweils über einen eigenen 330-Ohm-Widerstand an einem GPIO des ESP32 betrieben. Der kürzere Anschluss der üblichen bedrahteten LED ist die Kathode und wird mit GND verbunden.

LED	GPIO	Anschluss
Grün	GPIO 25	Über 330 Ohm
Gelb	GPIO 26	Über 330 Ohm
Rot	GPIO 27	Über 330 Ohm

Alle drei LED-Kathoden werden mit GND verbunden. Für den Aufbau verwenden wir gewöhnliche kleine 3-mm- oder 5-mm-LEDs. Leistungsstarke LEDs oder LED-Streifen benötigen eine andere Ansteuerung.

ESPHome auf dem ESP32 einrichten

Für die Programmierung verwenden wir ESPHome. Damit können wir den ESP32 über eine YAML-Datei konfigurieren und benötigen keine eigene Arduino-Software.

Falls du bisher noch nicht mit ESPHome gearbeitet hast, findest du auf meiner Website bereits eine ausführliche Anleitung: ESPHome: Anleitungen und Projekte.

Lege im ESPHome Device Builder zunächst ein neues Gerät mit dem Namen garage-einparkhilfe an. Für das Beispiel verwenden wir ein klassisches ESP32-DevKit. Die folgende Konfiguration kann anschließend in die YAML-Datei übernommen werden.

Vollständige ESPHome-Konfiguration

esphome:
  name: garage-einparkhilfe
  friendly_name: Garage Einparkhilfe

esp32:
  board: esp32dev
  framework:
    type: esp-idf

logger:

api:

ota:
  - platform: esphome

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  ap:
    ssid: "Garage-Einparkhilfe"
    password: "GarageSetup123"

captive_portal:

output:
  - platform: gpio
    pin: GPIO25
    id: led_gruen

  - platform: gpio
    pin: GPIO26
    id: led_gelb

  - platform: gpio
    pin: GPIO27
    id: led_rot

globals:
  - id: abstand_gueltig
    type: bool
    restore_value: no
    initial_value: 'false'

sensor:
  - platform: ultrasonic
    trigger_pin: GPIO5
    echo_pin: GPIO18
    name: "Abstand Garagenwand"
    id: garage_abstand
    unit_of_measurement: "cm"
    accuracy_decimals: 0
    update_interval: 500ms
    timeout: 2m

    filters:
      - multiply: 100.0
      - median:
          window_size: 5
          send_every: 1
          send_first_at: 1

    on_value:
      then:
        - lambda: |-
            const float d = x;

            if (!std::isfinite(d) || d < 2.0f ||
                d > 200.0f) {
              id(abstand_gueltig) = false;
              id(led_gruen).turn_off();
              id(led_gelb).turn_off();
              id(led_rot).turn_off();
              return;
            }

            id(abstand_gueltig) = true;

            id(led_gruen).turn_off();
            id(led_gelb).turn_off();
            id(led_rot).turn_off();

            if (d > 80.0f) {
              id(led_gruen).turn_on();
            } else if (d >= 40.0f) {
              id(led_gelb).turn_on();
            } else if (d >= 20.0f) {
              id(led_rot).turn_on();
            }

    on_value_range:
      - below: 20.0
        then:
          - output.turn_off: led_gruen
          - output.turn_off: led_gelb

interval:
  - interval: 500ms
    then:
      - if:
          condition:
            lambda: |-
              return id(abstand_gueltig) &&
                std::isfinite(id(garage_abstand).state)
                && id(garage_abstand).state < 20.0f;
          then:
            - output.turn_off: led_gruen
            - output.turn_off: led_gelb
            - output.turn_on: led_rot
            - delay: 250ms
            - output.turn_off: led_rot

  - interval: 3s
    then:
      - if:
          condition:
            lambda: |-
              return !std::isfinite(
                id(garage_abstand).state);
          then:
            - output.turn_off: led_gruen
            - output.turn_off: led_gelb
            - output.turn_off: led_rot

Die Konfiguration ist als Ausgangspunkt gedacht. Vor dem Einbau solltest du sie im ESPHome Device Builder validieren und die Funktion der Ampel am Breadboard überprüfen. Je nach ESPHome-Version können Anpassungen erforderlich sein.

Die Messung erfolgt alle 500 Millisekunden. Ein Medianfilter glättet einzelne Ausreißer. Die Ampel wird direkt vom ESP32 gesteuert und benötigt nach dem Start keine aktive Home-Assistant-Verbindung.

Bei fehlender oder ungültiger Messung sollen die LEDs ausgeschaltet bleiben. Ein solches Verhalten muss beim Test geprüft werden, damit ein Sensorfehler nicht versehentlich als freie Fahrt interpretiert wird.

Einparkhilfe in Home Assistant integrieren

Nach dem ersten Flashen verbindet sich der ESP32 mit deinem WLAN. Wenn die ESPHome-Integration eingerichtet ist, kann Home Assistant das neue Gerät erkennen.

Falls das nicht automatisch funktioniert, hilft die Anleitung ESPHome mit Home Assistant verbinden.

Nach erfolgreicher Integration erscheint der Sensor Abstand Garagenwand in Home Assistant. Die Entfernung wird in Zentimetern angezeigt.

Du kannst den Sensor beispielsweise auf deinem Dashboard einbinden. Besonders praktisch ist eine einfache Kachel mit dem aktuellen Abstand. So lässt sich auch vom Smartphone aus überprüfen, ob der Sensor plausible Werte liefert.

Abstände an die eigene Garage anpassen

Die voreingestellten 80, 40 und 20 Zentimeter passen natürlich nicht zu jeder Garage. Vor allem die Position des Sensors spielt eine große Rolle.

Ich würde zunächst die gewünschte Endposition des Autos festlegen. Anschließend misst du mit einem Zollstock den Abstand zwischen Fahrzeugfront und Sensor. Dieser Wert dient als Orientierung für den roten Bereich.

Steht dein Fahrzeug beispielsweise bei einem Abstand von 50 Zentimetern genau richtig, kannst du die Rot-Schwelle entsprechend ändern. Plane ausreichend Sicherheitsabstand ein und teste die Anzeige mit einer zweiten Person. Beachte dabei, dass die vorderste Fahrzeugstelle möglicherweise außerhalb des Messkegels liegt.

Die Grenzwerte lassen sich im Lambda-Abschnitt der YAML-Konfiguration verändern. Für die Blinkfunktion muss die untere Grenze im Intervallblock ebenfalls angepasst werden.

ESP32 Einparkhilfe dauerhaft in der Garage montieren

Wenn die Schaltung zuverlässig funktioniert, können wir sie fest montieren. Für den ESP32 eignet sich ein kleines Kunststoffgehäuse. Die LEDs sollten vom Fahrersitz gut sichtbar sein.

Der Ultraschallsensor gehört an eine Stelle, an der er die Fahrzeugfront möglichst direkt erfassen kann. Zu niedrige oder seitliche Montagepositionen können zu Fehlmessungen führen. Auch schräg stehende Fahrzeugteile, offene Kühlergrills oder andere reflektierende Flächen beeinflussen die Messung.

Bei der Kabelführung solltest du darauf achten, dass keine Leitungen im Fahrbereich liegen. Die Elektronik wird ausschließlich über ein geeignetes USB-Netzteil versorgt. Arbeiten an der festen 230-V-Elektroinstallation gehören in die Hände einer Elektrofachkraft.

Mein Tipp: Baue die Schaltung erst dauerhaft ein, wenn du die Messwerte an mehreren Tagen und mit unterschiedlichen Einparkpositionen geprüft hast. Ein Breadboard ist für einen dauerhaften Aufbau in einer Garage nur bedingt geeignet.

Mögliche Erweiterungen der Einparkhilfe

Mit dem ersten funktionierenden Aufbau ist das Projekt noch lange nicht abgeschlossen. Der ESP32 bietet genügend Möglichkeiten, um weitere Funktionen einzubauen.

• OLED-Display: Zeigt den Abstand zusätzlich als Zahl an.
• Akustischer Signalgeber: Gibt bei geringem Abstand einen Warnton aus.
• Garage beleuchten: Home Assistant kann bei Annäherung des Fahrzeugs eine passende Beleuchtung aktivieren.
• Messwerte überwachen: Über das Dashboard lassen sich Abstandswerte und Sensorprobleme kontrollieren.
• Zweiter Sensor: Kann eine zusätzliche Messrichtung überwachen, benötigt aber eine passende Platzierung und abgestimmte Messintervalle.

Gerade ein kleines Display könnte interessant sein. Welche Möglichkeiten es mit ESPHome gibt, habe ich bereits im Artikel ESP32, ESPHome und Smarthome zusammengestellt.

Häufige Probleme beim Nachbau

Der Ultraschallsensor zeigt keine Werte an

Prüfe zuerst die Spannungsversorgung und die Verbindung der Masseleitungen. Anschließend solltest du kontrollieren, ob Trigger und Echo mit den richtigen GPIO-Pins verbunden sind. Auch der Spannungsteiler muss korrekt aufgebaut sein.

Die Entfernung springt ständig

Ultraschallsensoren reagieren empfindlich auf die Beschaffenheit und Ausrichtung der reflektierenden Fläche. Versuche, den Sensor etwas anders auszurichten. Auch eine stabile Stromversorgung und kurze Anschlussleitungen können helfen.

Eine LED leuchtet nicht

Kontrolliere die Polung der LED und den Vorwiderstand. Prüfe anschließend, ob der zugehörige GPIO in der Konfiguration stimmt. Verwende für den ersten Aufbau einzelne Standard-LEDs, damit du die Verdrahtung leichter nachvollziehen kannst.

Der ESP32 ist nicht in Home Assistant sichtbar

Prüfe die WLAN-Verbindung und den Status des Geräts im ESPHome Device Builder. Die Einparkampel kann lokal weiterhin funktionieren, auch wenn die Verbindung zu Home Assistant vorübergehend unterbrochen ist.

Fazit: Eine Einparkhilfe für wenige Euro selber bauen

Eine selbst gebaute ESP32-Einparkhilfe ist ein überschaubares DIY-Projekt mit echtem Alltagsnutzen. Ein günstiger Ultraschallsensor übernimmt die Entfernungsmessung, der ESP32 wertet die Daten aus und drei LEDs machen den Abstand direkt sichtbar.

Besonders interessant finde ich, dass sich die Einparkhilfe später problemlos erweitern lässt. Ein Display, ein akustischer Hinweis oder eine Verbindung zur Garagenbeleuchtung sind nur einige Möglichkeiten.

Für den ersten Versuch reichen die einfache LED-Ampel und der Abstandssensor vollkommen aus. Die endgültige Montage würde ich erst vornehmen, wenn die Schaltung zuverlässig misst und die gewünschten Abstände richtig eingestellt sind.

Wenn du weitere Projekte mit ESP32 und ESPHome suchst, findest du auf smarthome-tricks.de auch Anleitungen zum Bau eines günstigen Temperatursensors und zum ESP32 WLAN-Taster für Home Assistant.

*Dieser Beitrag enthält Affiliate-Links. Wenn du über einen solchen Link etwas kaufst, erhalte ich gegebenenfalls eine kleine Provision. Für dich entstehen dadurch keine zusätzlichen Kosten. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen.