ESPHome oder eigene Firmware auf dem ESP32: Was passt?
ESPHome oder eigene ESP32-Firmware? Eine Entscheidungstabelle, was ESPHome nicht kann und warum Web-App, Portal und MCP-Server von OpenGizmo PlatformIO nutzen.
- Autor
Mauro Brambilla- Veroffentlicht
- Lesezeit
- 7 Min.
- Kategorie
- Vergleiche

Kurz gesagt
Nimm ESPHome, wenn das Board ein Sensor oder Schalter ist, den Home Assistant steuert. Schreib eigene Firmware, wenn es eine eigene Web-App, Einrichtung oder API ausliefern muss, wie die drei von OpenGizmo.
Nimm ESPHome, wenn dein ESP32 ein Sensor, Schalter oder Display ist, das Home Assistant steuert: Du beschreibst es in YAML, und ESPHome erzeugt und baut die Firmware. Nimm eigene Firmware (dein eigenes C++ mit dem Arduino-Framework oder ESP-IDF, oder MicroPython), wenn das Board etwas können muss, das keine Komponente abdeckt, etwa eine eigene Web-App ausliefern oder ein eigenes Protokoll sprechen.
Alle drei OpenGizmo-Projekte nutzen eigene Firmware, gebaut mit PlatformIO. Dieser Beitrag stellt beide Wege nebeneinander, mit der ESPHome-Dokumentation (Stand November 2026) und dem echten Code von Gizmo Ticker, Gizmo Reolink Switch und Gizmo Camera. Vorab eine Sache: Ich habe diese Projekte nicht in ESPHome nachgebaut. Wenn ich sage, dass eine Funktion keinen Platz hat, meine ich die Dokumentation, die ich gelesen habe, und kein Experiment.
Was nimmt dir ESPHome ab?
ESPHome ist ein Werkzeug, das aus einer YAML-Datei Firmware für einen ESP32 oder einen ähnlichen Chip macht. Die eigene Startseite sagt, dass du damit Smart-Home-Geräte ohne Code bauen kannst und dass jedes Gerät sofort lokal mit Home Assistant zusammenarbeitet. Du listest Komponenten auf (einen Temperatursensor an einem Pin, ein Relais, ein Display), und ESPHome kompiliert und flasht sie.
Vier Dinge sind schon dabei, und sie sparen richtig Zeit:
- Eine native API für Home Assistant. Füg
api:zur Konfiguration hinzu, und das Gerät erscheint bei den entdeckten Integrationen, wie die Seite zur API-Komponente beschreibt. Die Verschlüsselung ist optional. - Over-the-Air-Updates. Die OTA-Komponente bietet das native Protokoll, einen Upload über die Webseite des Geräts oder einen Download von einem Webserver, dazu einen Safe Mode, um sich von einem fehlerhaften Build zu erholen.
- WLAN-Fallback. Mit einem
ap:-Block startet die WLAN-Komponente nur dann einen Hotspot, wenn der Router nicht erreichbar ist (der Standardwert vonap_timeoutist 90 Sekunden), und über das Captive Portal kannst du das Netzwerk ändern oder Firmware hochladen. - Eine Komponentenbibliothek. Ein Beispiel aus diesem Blog: Die MAX7219-Display-Komponente unterstützt verkettete Chips, Drehung und Scrollen.
Der letzte Punkt zählt, um fair zu bleiben. Die Hardware ist nicht der Grund, warum OpenGizmo ESPHome auslässt: Es gibt eine Komponente für die MAX7219-Kette des Tickers und eine ESP32-Kamerakomponente, deren Seite ein Pin-Beispiel für Ai-Thinker enthält, die Boardfamilie der Gizmo Camera.
ESPHome im Vergleich mit Arduino, ESP-IDF und MicroPython
ESPHome sitzt auf den Frameworks, der eigentliche Vergleich ist also ein Stack. Die Seite zur ESP32-Plattform sagt, dass ESPHome standardmäßig ESP-IDF nutzt und Arduino für den klassischen ESP32, den S2, S3 und C3 anbietet, eingebunden als ESP-IDF-Komponente. Eigene Firmware heißt, direkt eins der anderen zu wählen.
| Option | Du schreibst | Passt gut für | Hauptkosten |
|---|---|---|---|
| ESPHome | YAML, bei Bedarf mit C++-Lambdas | Sensoren, Schalter und Displays für Home Assistant | Funktionen kommen aus Komponenten, und für deine eigene App gibt es keinen Platz |
| Arduino-ESP32 | C++ mit Arduino-Bibliotheken | Eigene Geräte mit einem großen Bibliotheks-Ökosystem | Du schreibst und pflegst alles oberhalb der Bibliotheken |
| ESP-IDF | C oder C++ auf Espressifs Framework | Volle Kontrolle über den Chip und seine Treiber | Ein steilerer Einstieg und mehr Code pro Funktion |
| MicroPython | Python, ausgeführt aus einer REPL | Schnelle Experimente und Skripte | Eine Laufzeitumgebung auf dem Chip und weniger fertige Bibliotheken für exotische Bauteile |
Einige Quellen zur Tabelle: Die Arduino-ESP32-Dokumentation sagt, dass der Core 3.3.12 auf ESP-IDF 5.5 basiert, die beiden sind also eine Familie. Der ESP-IDF-Leitfaden nennt es Espressifs Framework für IoT-Anwendungen, gebaut mit CMake und Ninja. Die ESP32-Referenz von MicroPython listet ESP32, C3, C6, S2 und S3 sowie eine REPL auf UART0 mit 115200 Baud. Die Spalte "Hauptkosten" ist mein Urteil, kein Benchmark: Ich habe hier nichts gemessen.
Zur Toolchain-Seite eigener Firmware findest du im Vergleich von Arduino IDE und PlatformIO alle Details. Dieser Beitrag dreht sich um die Ebene darüber: ob du überhaupt Firmware schreiben solltest.
Wann ist ESPHome die richtige Wahl?
ESPHome ist die richtige Wahl, wenn die Antwort auf "Wer spricht mit diesem Board?" Home Assistant lautet. Dann bekommst du Integration, Updates und Fallback-Hotspot geschenkt, und ein paar Zeilen YAML ersetzen Hunderte Zeilen C++, die du sonst pflegen müsstest.
Es passt auch, wenn du viele ähnliche Geräte willst, denn jedes ist nur eine kurze Datei. Und es ist der bessere Start, wenn du kein C++ schreiben willst: Genau das ist der erklärte Zweck des Werkzeugs.

| Wenn dein Board... | Nimm |
|---|---|
| Ein Sensor, ein Relais oder ein Display ist, das Home Assistant steuert | ESPHome |
| Ohne eine Zeile Code eingerichtet und aktualisiert werden soll | ESPHome |
| Ein Protokoll oder eine Bibliothek ohne ESPHome-Komponente braucht und du gern ein Lambda schreibst | ESPHome mit Lambdas |
| Eine eigene Web-App ausliefern muss, kein Dashboard | Eigene Firmware |
| Eine Einrichtung, eine API oder einen Browser-Flasher braucht, die du selbst entwirfst | Eigene Firmware |
| Einen Standard ausführen muss, den andere aufrufen können, etwa einen MCP-Server | Eigene Firmware |
Was kann ESPHome nicht?
ESPHome ist keine geschlossene Kiste, und es hat Auswege, die du kennen solltest. Lambdas sind C++ im YAML, das jede Komponente über ihre ID lesen kann, und mit den externen Komponenten importierst du Community-Code oder lokalen Code aus einem Git-Repository oder einem Ordner. ESPHome warnt außerdem, dass es Lambdas ungeprüft in das erzeugte C++ kopiert.
Die Grenzen zeigen sich, wenn die Oberfläche das Produkt ist und nicht das Gerät:
- Der Webserver ist eine feste Seite. Die Komponente web_server hat drei Oberflächenversionen, lokale Assets, optionale Authentifizierung sowie
js_includeundcss_includefür Erweiterungen. Ihre Dokumentation beschreibt keinen Weg, eine eigene, getrennte Seite zu hosten. - Auch das Captive Portal ist eine feste Seite. Seine Dokumentation bietet WLAN-Einstellungen und einen Firmware-Upload, und die einzige Option ist die Kompression der eingebetteten Assets.
- HTTP-Anfragen haben kleine Standardwerte. Die Komponente http_request hält einen Antwortpuffer von 1 kB, bis du ihn erhöhst, und prüft auf dem ESP32 standardmäßig HTTPS-Zertifikate. Ein Gerät mit selbstsigniertem Zertifikat braucht daher eine CA-Datei (
ca_certificate_path, was die Seite empfiehlt) oderverify_ssl: false, was laut Seite die Sicherheit verringert. - Die native API spricht nur mit wenigen Clients. Die API-Seite sagt, dass nur das ESPHome-Tool, Home Assistant und ioBroker sie nutzen. Ein KI-Agent oder dein eigenes Skript steht nicht auf dieser Liste.
Nichts davon ist ein Bug. Es beschreibt ein Werkzeug, das auf Geräte optimiert ist, nicht auf Produkte.
Wie unterscheiden sich Updates und WLAN-Einrichtung?
ESPHome bringt sowohl einen Update-Weg als auch einen WLAN-Fallback-Hotspot mit, und die beiden Ansätze unterscheiden sich darin, wem der Code gehört. Bei ESPHome konfigurierst du den Fallback-Hotspot und die OTA-Plattform, und das Projekt pflegt die Implementierung. Bei eigener Firmware wählst du jedes Teil selbst, was dir Freiheit gibt, aber auch die Rechnung beschert.
OpenGizmo ist ein gutes Beispiel für die Rechnung. Das Captive Portal ist Code, der mir gehört: gizmo-common startet einen offenen Hotspot, beantwortet jeden DNS-Namen mit der eigenen Adresse und leitet Testanfragen auf /ap-setup um. Der Vergleich der WLAN-Provisioning-Methoden zeigt, was das an Sicherheit kostet. Und es gibt gar kein OTA: Die drei Firmwares nutzen die Partitionstabelle huge_app.csv mit einem einzigen 3-MB-App-Slot, Updates laufen also per USB aus dem Browser, wie der OTA-Vergleich erklärt. ESPHome-Nutzer bekommen OTA und Safe Mode, ohne eine Zeile zu schreiben.
Warum nutzen die OpenGizmo-Projekte eigene Firmware?
Vier Gründe, und jeder ist in den Repositories sichtbar. Es sind Gründe für diese Produkte, nicht für jedes Board.

Die Web-App ist das Produkt
Jedes Board liefert eine Nuxt-4-Web-App aus. Der Build ist nuxt generate, dann macht gizmo-embed aus gizmo-common die statischen Dateien zu gzip-komprimierten C++-Arrays unter microcontroller/src/webui/, wie die Notizen zur eingebetteten Web-UI beschreiben. Die Firmware liefert sie aus dem Not-Found-Handler aus, Dateien mit Hash bleiben ein Jahr im Cache. Das fertige App-Image ist eine einzige Datei von etwa 1,7 bis 1,8 MB (die Größen stehen im OTA-Beitrag). Für so etwas hat der dokumentierte Webserver von ESPHome keinen Platz.

Die Einrichtung wird entworfen, nicht konfiguriert
Die Einrichtungsseite gehört zur selben Web-App, und gizmo-common begrenzt, was der Hotspot erreichen kann, auf vier API-Pfade. So ein Detail kann das feste Portal von ESPHome nicht ausdrücken. gizmo-common speichert die WLAN-Zugangsdaten über die Arduino-Bibliothek Preferences im NVS-Speicher des Boards. Hätte das Produkt keine eigene Web-App, wäre das Portal der Teil, den ich als Ersten an ESPHome abgeben würde.
Die Camera spricht MCP
Die Gizmo Camera beantwortet Model-Context-Protocol-Anfragen unter /mcp und liefert unter /llms.txt eine Anleitung für Agenten aus. Der Protokollcode ist mcp_protocol.cpp, 509 Zeilen, abgedeckt durch native Tests. Man könnte ihn als externe ESPHome-Komponente verpacken, aber der Protokollcode müsste trotzdem geschrieben werden, nur in einem anderen Build-System.
Der Reolink-Client hat eigene Regeln
Der Reolink Switch meldet sich für ein Sitzungstoken an, erneuert es eine Minute bevor der NVR es ablaufen lässt, bündelt Befehle und versucht es mit einer frischen Verbindung erneut, wenn der NVR eine offen gehaltene kappt. Außerdem ruft er setInsecure() auf, weil Reolink-NVRs üblicherweise selbstsignierte Zertifikate vorweisen, ein Kompromiss, den ich in diesem Beitrag erkläre. Diese Logik steckt in reolink.cpp und reolink_protocol.cpp, und die zweite Datei wird auf dem Computer getestet.
Dazu kommt die Build-Seite: Jedes Repository fixiert Plattform, Bibliotheken und den gizmo-common-Tag in platformio.ini und führt vor jedem Release pio test -e native aus. Der Beitrag zu Arduino IDE und PlatformIO zeigt diese Datei.
Womit solltest du also anfangen?
Fang mit ESPHome an, wenn Home Assistant das Frontend ist, und das sage ich, obwohl ich es für OpenGizmo nicht nutze: Es nimmt dir die langweiligen und leicht zu verbockenden Teile ab. Wechsle zu eigener Firmware, wenn du merkst, dass du gegen das Werkzeug kämpfst. Bei OpenGizmo wären das die App, der Flasher und die API, die dem Board gehören.
Die Kosten dieser Entscheidung trägst du selbst. Ich pflege ein Portal, einen Flasher, einen Release-Workflow und den Protokollcode, und die Boards haben kein OTA. Was ich geprüft habe: die oben verlinkten ESPHome-Seiten, Stand November 2026, und den Code der drei Repositories. Was nicht: dass ESPHome keines dieser Projekte nachbauen kann, den Flash- und RAM-Verbrauch von ESPHome und sein Verhalten mit dem XIAO ESP32-S3 auf deiner Hardware. Lies als Nächstes die OpenGizmo-Übersicht, um das ganze Design zu sehen, oder welchen ESP32 du kaufen solltest, falls du noch kein Board gewählt hast.
Haufig gestellte Fragen
Finden Sie schnelle Antworten auf die haufigsten Fragen zu diesem Thema.
Keins von beiden ist generell besser. ESPHome ist schneller, wenn dein Board ein Sensor, Schalter oder Display ist, das Home Assistant steuert, denn du beschreibst es in YAML. Eigene Firmware gewinnt, wenn das Board eine eigene Web-App ausliefern, eine eigene Einrichtung abwickeln oder ein Protokoll sprechen soll, für das ESPHome keine Komponente hat.
Autor
Mauro BrambillaLust, dein eigenes Gizmo zu bauen?
Such dir ein Open-Source-Projekt mit dem ESP32 aus und folge der Schritt-für-Schritt-Anleitung, von der Teileliste und der Verkabelung bis zur Firmware und zum ersten Start.






