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.

Veroffentlicht
Lesezeit
7 Min.
Kategorie
Vergleiche
Ein nachdenklicher Maker mit runder Brille steht zwischen einer YAML-Datei und einer C++-Datei, von beiden führen gestrichelte Pfeile nach oben zu einem ESP32-Board.

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 von ap_timeout ist 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.

OptionDu schreibstPasst gut fürHauptkosten
ESPHomeYAML, bei Bedarf mit C++-LambdasSensoren, Schalter und Displays für Home AssistantFunktionen kommen aus Komponenten, und für deine eigene App gibt es keinen Platz
Arduino-ESP32C++ mit Arduino-BibliothekenEigene Geräte mit einem großen Bibliotheks-ÖkosystemDu schreibst und pflegst alles oberhalb der Bibliotheken
ESP-IDFC oder C++ auf Espressifs FrameworkVolle Kontrolle über den Chip und seine TreiberEin steilerer Einstieg und mehr Code pro Funktion
MicroPythonPython, ausgeführt aus einer REPLSchnelle Experimente und SkripteEine 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.

Zwei Karten: ESPHome für Sensoren, Relais und Displays, mit Home Assistant als Oberfläche und YAML statt C++; eigene Firmware für eine eigene Web-App, Einrichtung und API

Wenn dein Board...Nimm
Ein Sensor, ein Relais oder ein Display ist, das Home Assistant steuertESPHome
Ohne eine Zeile Code eingerichtet und aktualisiert werden sollESPHome
Ein Protokoll oder eine Bibliothek ohne ESPHome-Komponente braucht und du gern ein Lambda schreibstESPHome mit Lambdas
Eine eigene Web-App ausliefern muss, kein DashboardEigene Firmware
Eine Einrichtung, eine API oder einen Browser-Flasher braucht, die du selbst entwirfstEigene Firmware
Einen Standard ausführen muss, den andere aufrufen können, etwa einen MCP-ServerEigene 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_include und css_include fü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) oder verify_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.

Ein XIAO auf einem Steckbrett funkt per WLAN an ein Smartphone mit seiner Einstellungs-App, mit den Schildern app on the board und no cloud, daneben ein gedrucktes Gehäuse

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.

Build-Kette: der Nuxt-Ordner webapp, gizmo-embed zu gzip-komprimiertem C++, ein PlatformIO-Build, dann das Board, das die UI ausliefert

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 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.

Veroffentlicht

Lust, 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.

Lies auch

Kategorien entdecken