Arduino IDE vs. PlatformIO für ESP32: Was nehmen?
Arduino IDE 2 oder PlatformIO für den ESP32? Vergleich zu Bibliotheksversionen, Arduino-ESP32 3.x, Debugging und Tests, mit der platformio.ini des Gizmo Ticker.
- Autor
Mauro Brambilla- Veroffentlicht
- Lesezeit
- 9 Min.
- Kategorie
- Vergleiche

Kurz gesagt
Nimm Arduino IDE 2 für ein Board und einen Sketch. Nimm PlatformIO, wenn Bibliotheken, Targets oder Tests feste Versionen brauchen: Die platformio.ini hält jede Version im Projekt, nicht auf deinem Rechner.
Für ein Board und einen Sketch nimmst du Arduino IDE 2. Für ein ESP32-Projekt mit mehreren Bibliotheken, mehr als einem Build-Target oder Tests nimmst du PlatformIO. Beide kompilieren deinen Code gegen Espressifs Arduino-ESP32-Core, der eigentliche Unterschied ist also, wo die Versionen liegen: in der IDE auf deinem Rechner, in PlatformIO in einer platformio.ini im Projekt.
Ich baue die drei OpenGizmo-Firmwares (Gizmo Ticker, Gizmo Reolink Switch und Gizmo Camera) mit PlatformIO. Dieser Vergleich stützt sich deshalb auf ihre echten Konfigurationsdateien und auf die offiziellen Dokus beider Tools, jeweils mit dem Datum, an dem ich die Fakten geprüft habe: November 2026. Er behandelt auch die unbequemen Stellen, nämlich die Arduino-ESP32-3.x-Lücke, die Leute zu einem Fork getrieben hat, und einen nummerierten Weg, einen Sketch umzuziehen.
Was nimmst du für ein ESP32-Projekt?
Entscheide danach, was das Projekt wiederholen können muss. Wenn jemand anderes (oder du in einem Jahr) dieselbe Firmware auf einem frischen Rechner neu bauen muss, müssen die Versionen im Projekt stehen. Wenn du heute Abend nur eine LED blinken sehen willst, nicht.

| Thema | Arduino IDE 2 | PlatformIO |
|---|---|---|
| Projektdatei | Ein Sketch-Ordner mit einer .ino-Datei | platformio.ini plus die Ordner src/, test/ und lib/ |
| Wo die Bibliotheken liegen | Einmal über den Library Manager installiert, von jedem Sketch geteilt | Pro Projekt aus lib_deps in den Ordner libdeps geladen |
| Versionen festlegen | Nicht in der IDE; Arduino-CLI-Sketch-Profile können es | Zeilen platform und lib_deps, mit exakten Versionen, Bereichen oder Git-Tags |
| Mehrere Targets | Immer nur ein Board-Menü | Ein Abschnitt [env:name] pro Target, gewählt mit -e |
| Kommandozeile | Arduino CLI ist ein separates Tool | pio run, pio test und pio device monitor sind das Kernwerkzeug |
| Unit-Tests auf deinem Computer | Kein Test-Runner, den ich in der Doku gefunden habe | pio test mit der nativen Plattform und Unity |
| Frameworks für den ESP32 | Arduino-ESP32-Core | Arduino und ESP-IDF |
| Woher der ESP32-Core kommt | Espressifs Index im Boards Manager | Der in der Plattform espressif32 mitgelieferte Core |
Arduino IDE 2.3.11 war am 12. November 2026 die neueste Version, und PlatformIOs Visual-Studio-Code-Erweiterung enthält PlatformIO Core, du musst die Kommandozeile also nicht separat installieren. Beides stammt aus den Arduino-IDE-Releases und der PlatformIO-Doku für VS Code.
Wie sieht eine echte platformio.ini aus?
Eine platformio.ini ist die eine Datei, die festlegt, mit welchem Board, welcher Plattformversion und welchen Bibliotheken ein Projekt gebaut wird. Hier die Firmware-Konfiguration des Gizmo Ticker, kopiert aus microcontroller/platformio.ini mit gekürzten Kommentaren:
[platformio]
default_envs = release
[env:release]
extra_scripts = pre:firmware_version.py
board = seeed_xiao_esp32s3
platform = espressif32 @ 8.0.0
framework = arduino
board_build.partitions = huge_app.csv
build_src_flags = -Wformat
monitor_speed = 115200
lib_deps =
majicdesigns/MD_Parola@3.7.5
majicdesigns/MD_MAX72XX@3.5.1
esp32async/ESPAsyncWebServer@3.12.1
esp32async/AsyncTCP@3.5.0
bblanchon/ArduinoJson@7.2.2
bblanchon/StreamUtils@1.9.2
https://github.com/open-gizmo/gizmo-common.git#v2.5.1
[env:debug]
extends = env:release
build_unflags = -DCORE_DEBUG_LEVEL=0
build_flags =
-D PIO_DEV_MODE=1
-D CORE_DEBUG_LEVEL=3
[env:native]
platform = native@1.2.1
test_framework = unity
test_build_src = yes
build_src_filter = -<*> +<server/settings_json.cpp> +<api/market_refresh.cpp> +<api/market_data.cpp>
build_flags =
-std=gnu++17
-D UNITY_INCLUDE_DOUBLE
lib_deps =
throwtheswitch/Unity@2.6.1
bblanchon/ArduinoJson@7.2.2Zeile für Zeile macht jeder Teil Folgendes:
board = seeed_xiao_esp32s3wählt die Board-Definition des Seeed Studio XIAO ESP32-S3: 240 MHz, 8 MB Flash-Speicher, 320 KB RAM. Es ist nicht das generischeesp32dev, das ESP32-Dev-Module-Profil mit 4 MB Flash. Jede ESP32-Variante braucht ihre eigene ID.platform = espressif32 @ 8.0.0legt die Toolchain und den mitgelieferten Arduino-ESP32-Core fest. Dazu unten mehr.board_build.partitions = huge_app.csvgibt der App einen einzigen 3-MB-Slot, den ich in jeder OpenGizmo-Firmware nutze, weil keine davon Over-the-Air-Updates macht. Der Beitrag zur Partitionstabelle erklärt den Kompromiss.lib_depslistet jede Bibliothek mit exakter Version. Die letzte Zeile zeigt auf einen Git-Tag unserer gemeinsamen Bibliothekgizmo-common.[env:debug]kopiertreleasemitextendsund dreht das Log-Level des Cores von 0 auf 3. Derselbe Code, ein anderer Build, gewählt mitpio run -e debug -t upload.[env:native]baut drei Quelldateien für deinen Computer statt für das Board, um Tests auszuführen. Der Filter-<*> +<datei>heißt "nichts außer diesen Dateien".
Dieselben drei Abschnitte (release, debug, native) stehen in den Konfigurationen von Reolink Switch und Camera. Die Kamera nutzt board = esp32cam, das ihr PSRAM für die Frame-Buffer einschaltet.

Wo liegen die Bibliotheken, und wie legst du ihre Versionen fest?
Versionen festlegen heißt, die exakte Version, mit der du gebaut hast, neben den Code zu schreiben, damit ein Build im nächsten Jahr dieselbe Bibliothek und denselben Core nutzt. Die beiden Tools unterscheiden sich darin, wo diese Aufzeichnung liegen kann.
Arduino IDE 2: einmal installiert, von jedem Sketch geteilt
Du fügst den ESP32-Core hinzu, indem du die Paketindex-URL von Espressif in die Einstellungen der IDE einfügst und dann die Plattform esp32 im Boards Manager installierst, wie es die Installationsanleitung für Arduino-ESP32 beschreibt. Bibliotheken kommen aus dem Library Manager. Beides wird einmal auf dem Rechner installiert. Aktualisierst du eine Bibliothek für einen Sketch, bekommen alle anderen Sketches die neue Version auch, und nichts im Sketch-Ordner hält fest, gegen welche Version er geschrieben wurde.

Das ist in Ordnung für einen Sketch, den du an einem Abend fertigstellst. Es tut weh, wenn ein Bibliotheks-Update eine API ändert und du dir merken musst, welches deiner Projekte welche Version nutzt.
Arduino-CLI-Sketch-Profile: die Antwort der Arduino-Seite
Die Arduino-Seite hat eine Antwort, aber sie steckt im Kommandozeilen-Tool. In der Arduino CLI listet ein Sketch-Profil in einer sketch.yaml das Board, die Version der Core-Plattform und die Bibliotheksversionen auf. Laut Arduinos Doku ist ein Build mit Profil "is isolated from the system and will rely only on the resources specified in the profile". Ein Beispielprofil für das XIAO ESP32-S3:
profiles:
release:
fqbn: esp32:esp32:XIAO_ESP32S3
platforms:
- platform: esp32:esp32 (3.3.12)
platform_index_url: https://espressif.github.io/arduino-esp32/package_esp32_index.json
libraries:
- ArduinoJson (7.2.2)
default_profile: releaseGebaut wird es mit arduino-cli compile --profile release. Diese Seite dokumentiert die CLI; ich konnte daraus nicht bestätigen, dass das Fenster der Arduino IDE 2 Profile anbietet, betrachte die IDE selbst also als reine Globalinstallation.
PlatformIO: Versionen im Projekt
PlatformIO lädt, was in lib_deps steht, in den Ordner libdeps des Projekts (der Standardwert der Option libdeps_dir ist workspace_dir/libdeps), zwei Projekte teilen sich also nie eine Bibliothek. Die lib_deps-Doku zeigt Registry-Namen (owner/name), SemVer-Bereiche wie bblanchon/ArduinoJson @ ~5.6,!=5.4 und Git-URLs mit Tag (...git#v2.0). OpenGizmo nutzt exakte Versionen und einen Git-Tag; der Release-Workflow installiert sogar ein festes PlatformIO Core (platformio==6.2.0), damit CI und ein frischer Clone dieselben Versionen auflösen.
Unterstützt PlatformIO den neuesten Arduino-ESP32-Core?
Ja, Stand November 2026, aber es hat gedauert. PlatformIOs Plattform espressif32 bringt einen Arduino-ESP32-Core mit, und die Releases-Seite der Plattform zeigt, welchen:
| espressif32-Release | Datum | Arduino-ESP32-Core |
|---|---|---|
| 6.13.0 | 26. Feb. | 2.0.17 |
| 7.0.0 bis 7.1.0 | 30. Apr. bis 31. Aug. | 2.0.17 |
| 8.0.0 | 19. Okt. | 3.3.12 |
Die offizielle Plattform blieb also in der gesamten 7.x-Linie auf Core 2.0.17, während Espressifs eigener Boards-Manager-Index schon auf 3.x weitergezogen war. Diese Lücke ist der Grund, warum die Community-Plattform pioarduino, ein Fork der offiziellen, beliebt wurde. Du nutzt sie, indem du die platform-Zeile durch eine URL ersetzt:
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zipAuch ihr Stable-Release bringt inzwischen Arduino 3.3.12 mit und ergänzt Extras wie einen hybriden Kompiliermodus für Chips, die der Arduino-Core nicht abdeckt. Da die offizielle 8.0.0 aufgeholt hat, würde ich bei der offiziellen Plattform bleiben, es sei denn, du brauchst eines dieser Extras. Die Release Notes zu 8.0.0 warnen außerdem, dass Arduino-ESP32 3.x das für v4.0 geplante vollständige Bluetooth-Refactoring noch nicht hat.
Daraus folgen zwei praktische Regeln. Lege die Plattform fest (espressif32 @ 8.0.0, oder ~8.0.0, um Patch-Releases zu akzeptieren), denn ein Plattform-Update ist ein Core-Update, und der Sprung von Core 2 auf Core 3 ändert APIs. Und lies die Release-Seite, bevor du aktualisierst. Alle drei OpenGizmo-Repositories legen espressif32 @ 8.0.0 fest, sie bauen also auf Core 3.3.12.
Wie schneiden die Debugging-Möglichkeiten ab?
Das meiste ESP32-Debugging ist Serial-Logging, und das können beide Tools. Der Unterschied bei PlatformIO ist, dass ein Log-Level ein Build-Profil ist: pio run -e debug -t upload und danach pio device monitor liefert dir die Ticker-Firmware mit den Meldungen des Cores, und release hält das serielle Log aus. Die README des Tickers dokumentiert die drei Build-Profile.
Hardware-Debugging (Breakpoints und Einzelschritte) braucht eine Probe. Laut PlatformIOs Seite zum XIAO ESP32-S3 hat das Board keine Debug-Probe an Bord und ist nicht für Debugging gerüstet; die Seite listet externe Tools, die du mit der Option debug_tool wählst, darunter esp-builtin. Die Arduino IDE 2 hat einen eigenen Debugger; in ihrer Doku konnte ich nicht bestätigen, dass ESP32-Boards abgedeckt sind, prüf das also, bevor du eine Probe kaufst. Ich nutze bei den OpenGizmo-Firmwares keinen Hardware-Debugger: Sie setzen auf das Debug-Profil und das serielle Log.
Kannst du ESP32-Code ohne Board per Unit-Test prüfen?
Wenn die Logik keine Hardware anfasst, ja. PlatformIOs Unit-Testing kann dieselben Tests auf deinem Computer (die native Plattform) oder auf einem angeschlossenen Board ausführen, mit Frameworks wie Unity. In der Konfiguration oben kompiliert [env:native] nur drei Dateien, und pio test -e native führt sie aus:
server/settings_json.cpp, die Zuordnung zwischen Einstellungen und dem JSON der Web-APIapi/market_refresh.cpp, die entscheidet, wann die Preise neu abgerufen werdenapi/market_data.cpp, die die Antwort von CoinGecko liest
Diese Tests liegen in microcontroller/test/, und der Release-Workflow führt pio test -e native aus, bevor er die Firmware baut. Die Grenze ist real: Native Tests decken Logik ab, die auf einem PC kompiliert. Alles, was mit der Matrix, dem WLAN oder dem Flash-Speicher spricht, braucht weiterhin ein Board. In der Doku der Arduino IDE 2 habe ich keinen Test-Runner gefunden, auf dieser Seite würdest du also von Hand auf dem Board testen oder es mit einem anderen Tool automatisieren.
Wie ziehst du einen Arduino-Sketch auf PlatformIO um?
Ein Sketch aus einer Datei ist in wenigen Schritten umgezogen. Die Umwandlungsregeln stammen aus PlatformIOs Anleitung ino to cpp.
- Installiere Visual Studio Code und dann die Erweiterung PlatformIO IDE über die Extensions-Ansicht. Sie enthält PlatformIO Core.
- Wähle in PlatformIO Home New Project, such dein Board aus (
seeed_xiao_esp32s3für ein XIAO ESP32-S3,esp32devfür ein klassisches ESP32-DevKit) und das Arduino-Framework. Du bekommst eineplatformio.iniundsrc/main.cpp. - Füge deinen Sketch in
src/main.cppein. Setz#include <Arduino.h>an den Anfang und deklariere jede eigene Funktion, bevor sie aufgerufen wird. Deklarieresetupundloopnicht. - Verschiebe jede Bibliothek nach
lib_deps. Such in der PlatformIO Registry, kopiere die Formowner/nameund ergänze die Version, die du genutzt hast, zum Beispielbblanchon/ArduinoJson@7.2.2. - Lege die Plattform fest:
platform = espressif32 @ 8.0.0. Übernimm Auswahlen aus dem Tools-Menü, die wichtig waren, etwa das Partitionsschema (board_build.partitions) und die serielle Geschwindigkeit (monitor_speed = 115200). - Führe
pio runaus. Behebe fehlende Prototypen oder Includes, bis der Build durchläuft. - Schließe das Board an und führe
pio run -t uploadaus, danachpio device monitor, um die serielle Ausgabe zu lesen.
Sobald es läuft, füge ein [env:debug] hinzu, das deine Hauptumgebung per extends erweitert, wie im Beispiel oben. Das ist die günstigste Verbesserung, die dir der Umstieg bringt.
Was kostet dich PlatformIO, und wann gewinnt Arduino IDE?
Der stärkste Einwand gegen PlatformIO sind die Einstiegskosten. Du lernst eine ini-Datei, eine Ordnerstruktur und ein paar Befehle, bevor es zum ersten Mal blinkt, und das Editor-Erlebnis hängt von einer VS-Code-Erweiterung ab. Upgrades von Core und Plattform passieren explizit, was gut für die Reproduzierbarkeit ist und bedeutet, dass du die Release Notes lesen musst. Für einen einzelnen Sketch zahlt sich nichts davon aus.
Arduino IDE 2 gewinnt, wenn das Projekt ein Sketch auf einem Board ist, wenn du einem Tutorial folgst, das dafür geschrieben wurde, oder wenn du Espressifs neuesten Core am Tag seines Erscheinens direkt aus dem Index des Boards Managers willst. Ihre Dokumentation ist der bessere Startpunkt für die erste Woche.
Es gibt auch eine dritte Antwort: beide überspringen. OpenGizmos Projekte liefern fertige Firmware, die du aus dem Browser flasht, und die Anleitung zu ESP Web Tools erklärt, wie. Eine Toolchain brauchst du nur, um den Code zu ändern.
Womit solltest du also anfangen?
Fang mit Arduino IDE 2 an, wenn du heute den ersten Upload willst. Wechsle zu PlatformIO, sobald du dich dabei ertappst, ein zweites Board-Profil, einen Test oder die Möglichkeit zu wollen, eine alte Version neu zu bauen. Der oben beschriebene Umzug eines Sketches ist kurz, und lib_deps plus eine festgelegte Plattform bescheren dir Builds, die weiter funktionieren.
Was ich geprüft habe: die Konfigurationsdateien der drei OpenGizmo-Firmware-Repositories, die Release Notes von espressif32 und die oben verlinkten offiziellen Dokus, Stand November 2026. Was ich nicht geprüft habe: ob der Debugger der Arduino IDE 2 mit ESP32-Boards funktioniert und ob ihre Oberfläche Sketch-Profile anbietet. Lies als Nächstes die Pinbelegungs-Anleitung zum XIAO ESP32-S3 für das Board aus diesen Konfigurationen, oder die Bauanleitung für den Gizmo Ticker, um das ganze Projekt mit diesem Setup gebaut zu sehen.
Haufig gestellte Fragen
Finden Sie schnelle Antworten auf die haufigsten Fragen zu diesem Thema.
Bei Projekten mit mehreren Bibliotheken, mehr als einem Build-Target oder Tests ja: PlatformIO hält die Versionen von Plattform, Board und Bibliotheken in einer platformio.ini im Projekt. Für einen einzelnen Sketch auf einem Board ist Arduino IDE 2 schneller gestartet und hat weniger bewegliche Teile.
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.






