PlatformIO installieren: VS Code für Arduino, ESP32 und Pico
PlatformIO installieren in VS Code: platformio.ini für Uno, ESP32 und Pico, Bibliotheken per lib_deps, Upload, Serial Monitor und Umstieg von der IDE.
Mit der PlatformIO-Installation programmierst du Boards wie Arduino Uno, ESP32 und Raspberry Pi Pico aus einer einzigen professionellen Umgebung, indem du VS Code nur eine Erweiterung hinzufügst. Kurz gesagt: VS Code installieren, im Erweiterungen-Tab nach PlatformIO IDE suchen und installieren, beim ersten Start warten, bis die nötigen Werkzeuge geladen sind, und dann im PIO-Home-Bildschirm dein Board wählen und ein neues Projekt anlegen. Alles Weitere steckt in einer kleinen Konfigurationsdatei namens platformio.ini: Dort steht, welches Board, welches Framework, welche Bibliotheken und welche Baudrate für die serielle Schnittstelle verwendet werden.
Die Arduino IDE ist ein tolles Werkzeug zum Lernen, aber mit wachsenden Projekten stößt du an Grenzen: Die Codevervollständigung ist einfach gehalten, Bibliotheken gelten für alle Projekte gemeinsam, ein Bibliotheks-Update kann ein altes Projekt kaputtmachen, und die Board-Einstellungen werden nicht mit dem Projekt gespeichert. PlatformIO löst diese Probleme. In diesem Leitfaden installierst du alles Schritt für Schritt, legst dein erstes Projekt an, definierst mit platformio.ini drei verschiedene Boards in einem Projekt, fügst Bibliotheken hinzu, lädst Code hoch, öffnest den Serial Monitor und übernimmst bestehende Arduino-IDE-Projekte. Im letzten Abschnitt vergleichen wir beide Werkzeuge neutral, damit du entscheiden kannst, welches zu dir passt.

Was ist PlatformIO und wie funktioniert es?
PlatformIO ist ein Open-Source-Entwicklungsökosystem für Embedded-Systeme. Im Kern steckt das in Python geschriebene Kommandozeilenwerkzeug PlatformIO Core; die VS-Code-Erweiterung macht es über Schaltflächen, Menüs und den PIO-Home-Bildschirm bequem nutzbar. Wenn du ein Projekt kompilierst, liest PlatformIO zuerst die platformio.ini, lädt dann den passenden Compiler (avr-gcc für den Uno, die Xtensa-Toolchain für den ESP32, arm-none-eabi-gcc für den Pico), das Framework und die Bibliotheken aus seinem eigenen Repository und kompiliert deinen Code. Diese Pakete werden nur einmal geladen und im Verzeichnis .platformio in deinem Benutzerordner gespeichert; spätere Projekte verwenden dieselben Pakete wieder. Mit diesen Begriffen kannst du die Datei viel leichter lesen:
| Begriff | Bedeutung | Beispiel |
|---|---|---|
| Platform | Paket mit Compiler und Upload-Werkzeugen für eine Mikrocontroller-Familie | atmelavr, espressif32, raspberrypi |
| Board | Ein bestimmtes Board innerhalb einer Platform; Pinbelegung, Taktfrequenz und Speicherangaben | uno, nanoatmega328, esp32dev, pico |
| Framework | Software-Grundlage, auf der du deinen Code schreibst | arduino, espidf |
| Environment (env) | Abschnitt, in dem Platform, Board, Framework und weitere Einstellungen zusammen definiert sind | [env:uno] |
| Bibliothek | Fertiges Codepaket, das per lib_deps ins Projekt kommt | adafruit/DHT sensor library |
| PIO Home | Startseite zum Öffnen von Projekten und zur Board- und Bibliothekssuche | Haus-Symbol in der Statusleiste |
PlatformIO installieren: Schritt für Schritt
- Lade Visual Studio Code von der offiziellen Website herunter und installiere es. Unter Windows erleichtert es die Arbeit im Terminal, wenn du bei der Installation die Option Add to PATH aktivierst.
- Öffne VS Code und klicke links auf den Tab Erweiterungen (Extensions) oder nutze das Tastenkürzel Strg+Umschalt+X (auf macOS Cmd+Umschalt+X).
- Gib PlatformIO IDE in das Suchfeld ein und installiere die von PlatformIO veröffentlichte Erweiterung mit Install. Die benötigte C/C++-Erweiterung wird automatisch mitinstalliert.
- Unten rechts erscheint die Meldung „Installing PlatformIO Core“. Je nach Internetgeschwindigkeit dauert dieser Schritt einige Minuten; schließe VS Code in dieser Zeit nicht.
- Nach der Installation fordert VS Code dich zum Neustart auf. Danach erscheint links das PlatformIO-Symbol und in der unteren Statusleiste ein Haus-Symbol.
- Klicke auf das Haus-Symbol, um den PIO-Home-Bildschirm zu öffnen. Wenn dieser Bildschirm ohne Fehler erscheint, ist die Installation abgeschlossen.
Erstes Projekt anlegen und Ordnerstruktur
Klicke in PIO Home auf New Project. Gib im Fenster einen Projektnamen ein (zum Beispiel blink-uno), tippe Arduino Uno ins Board-Feld und wähle es aus der Liste, lass als Framework Arduino stehen und bestimme den Speicherort. Mit Finish lädt PlatformIO zum ersten Mal das Platform-Paket für dein gewähltes Board; deshalb kann das erste Projekt einige Minuten dauern, spätere öffnen sich in Sekunden. Sobald das Projekt erstellt ist, öffnet VS Code den Ordner und du siehst diese Struktur:
| Ordner / Datei | Wofür? |
|---|---|
| platformio.ini | Das Herz des Projekts: Board, Framework, Bibliotheken und Port-Einstellungen |
| src/ | Deine Quelltexte; das Programm startet in der Datei main.cpp |
| include/ | Deine eigenen Header-Dateien (.h) |
| lib/ | Projektspezifische, von Hand hinzugefügte lokale Bibliotheken (jeweils in einem eigenen Unterordner) |
| test/ | Ordner für Unit-Tests |
| .pio/ | Build-Ausgaben und heruntergeladene Bibliotheken; wird bei Löschung neu erzeugt |
| .vscode/ | Einstellungen für VS Code und IntelliSense; wird automatisch erzeugt |
Was ist die Datei platformio.ini?
platformio.ini ist eine einfache Textdatei im INI-Format. Jeder Abschnitt, der mit einer eckigen Klammer beginnt, [env:name], definiert eine Build-Umgebung. Was du in der Arduino IDE im Menü Werkzeuge auswählst (Board, Baudrate), schreibst du hier als Text; wenn du das Projekt auf einen anderen Rechner mitnimmst oder einem Freund gibst, reisen die Einstellungen also mit dem Code. Zeilen, die mit einem Semikolon beginnen, sind Kommentare. Wenn wir der für den Uno erzeugten Datei die Geschwindigkeit des Serial Monitors hinzufügen, sieht sie so aus:
1; PlatformIO proje ayarları / PlatformIO project settings
2[env:uno]
3platform = atmelavr
4board = uno
5framework = arduino
6; Seri monitör hızı, Serial.begin ile aynı olmalı / Monitor speed, must match Serial.begin
7monitor_speed = 115200| Einstellung | Aufgabe | Beispielwert |
|---|---|---|
| platform | Zu verwendendes Platform-Paket; die Version lässt sich ebenfalls festlegen | atmelavr, [email protected] |
| board | Board-ID | uno, megaatmega2560, esp32dev, pico |
| framework | Software-Framework | arduino |
| monitor_speed | Geschwindigkeit des Serial Monitors (Standard 9600) | 115200 |
| upload_port | Upload-Port (wird bei leerer Angabe automatisch gefunden) | COM5, /dev/ttyUSB0 |
| upload_speed | Baudrate beim Hochladen (vor allem bei ESP-Boards) | 921600 |
| lib_deps | Automatisch herunterzuladende Bibliotheken | adafruit/DHT sensor library@^1.4.4 |
| build_flags | Zusätzliche Compiler-Flags und Makros | -D LED_PIN=2 |
| monitor_filters | Filter für die Ausgabe des Serial Monitors | time, esp32_exception_decoder |
Erster Code: main.cpp und der Unterschied mit Arduino.h
Die Datei main.cpp im Ordner src entspricht der .ino-Datei der Arduino IDE, mit zwei wichtigen Unterschieden. Erstens muss ganz am Anfang der Datei eine #include-Zeile stehen, die die Header-Datei Arduino.h einbindet; die Arduino IDE fügt sie im Hintergrund selbst hinzu, PlatformIO nicht. Zweitens folgt eine .cpp-Datei den echten C++-Regeln: Der Compiler muss eine Funktion kennen, bevor du sie aufrufst. Die Arduino IDE erzeugt Funktionsprototypen für dich; in PlatformIO definierst du die Funktion entweder vor ihrer Verwendung oder schreibst einen einzeiligen Prototyp an den Dateianfang. Das folgende Beispiel ist ein Blink-Programm, das auf Uno, ESP32 und Pico läuft:
1#include <Arduino.h>
2
3// LED_PIN platformio.ini'den gelebilir / LED_PIN may come from platformio.ini
4#ifndef LED_PIN
5#define LED_PIN LED_BUILTIN // Uno: 13, Pico: GP25
6#endif
7
8void blinkLed(int count); // prototip / prototype
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(LED_PIN, OUTPUT);
13 Serial.println("PlatformIO hazir / ready");
14}
15
16void loop() {
17 blinkLed(3);
18 delay(1000);
19}
20
21void blinkLed(int count) {
22 for (int i = 0; i < count; i++) {
23 digitalWrite(LED_PIN, HIGH);
24 delay(150);
25 digitalWrite(LED_PIN, LOW);
26 delay(150);
27 }
28 Serial.print("Yanip sondu / Blinked: ");
29 Serial.println(count);
30}Kompilieren, hochladen und Serial Monitor
| Aktion | Statusleiste / Menü | Terminal-Befehl |
|---|---|---|
| Kompilieren (Build) | Häkchen | pio run |
| Hochladen (Upload) | Pfeil nach rechts | pio run -t upload |
| Hochladen und Monitor öffnen | PlatformIO-Menü > Upload and Monitor | pio run -t upload -t monitor |
| Serial Monitor | Stecker-Symbol | pio device monitor |
| Aufräumen (Clean) | Papierkorb | pio run -t clean |
| Ports auflisten | PIO Home > Devices | pio device list |
| Bestimmte Umgebung kompilieren | Umgebungsauswahl (env:...) | pio run -e esp32dev |
| Bibliothek installieren | PIO Home > Libraries | pio pkg install -l "adafruit/DHT sensor library" |
Damit der Serial Monitor richtig funktioniert, muss monitor_speed in der platformio.ini mit der Baudrate in Serial.begin() im Code übereinstimmen; sonst siehst du unverständliche Zeichen auf dem Bildschirm. PlatformIO findet das angeschlossene Board meist selbst, kann aber bei mehreren seriellen Geräten am Rechner versuchen, auf den falschen Port zu laden. Liste in diesem Fall die Ports mit pio device list auf und trage den richtigen in die Zeilen upload_port und monitor_port ein. Hält der Serial Monitor der Arduino IDE oder ein anderes Terminalprogramm den Port offen, bricht der Upload mit „Access is denied“ oder „Resource busy“ ab; schließe dann einfach dieses Programm. Mehr über den Serial Monitor selbst findest du im Beitrag Arduino Serial Monitor. Der Befehl pio funktioniert immer im Terminal PlatformIO Core CLI, das du über das PlatformIO-Menü öffnest.
Uno, ESP32 und Pico in einem Projekt definieren
Eine der größten Stärken von PlatformIO ist, denselben Code für mehrere Boards kompilieren zu können. Du schreibst für jedes Board einen eigenen Abschnitt [env:...]; gemeinsame Einstellungen legst du in den namenlosen Abschnitt [env], den alle Umgebungen erben. Die folgende Tabelle fasst die Grundwerte dreier beliebter Boards zusammen:
| Wert | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (Arduino-Mbed-Core) |
| Onboard-LED | D13 | GPIO 2 (bei den meisten DevKit-Boards) | GP25 |
| Upload-Methode | USB-Seriell und Bootloader | USB-Seriell und esptool | USB und BOOTSEL-Modus |
| Typische monitor_speed | 9600 oder 115200 | 115200 | 115200 |
1[platformio]
2; Varsayılan ortam / Default environment
3default_envs = uno
4
5; Tüm ortamlarda ortak ayarlar / Settings shared by all environments
6[env]
7framework = arduino
8monitor_speed = 115200
9
10[env:uno]
11platform = atmelavr
12board = uno
13
14[env:esp32dev]
15platform = espressif32
16board = esp32dev
17upload_speed = 921600
18monitor_filters = esp32_exception_decoder
19; Dahili LED GPIO 2 / Onboard LED on GPIO 2
20build_flags = -D LED_PIN=2
21
22[env:pico]
23platform = raspberrypi
24board = picoDie Zeile default_envs legt fest, welche Umgebung die Schaltflächen zum Kompilieren und Hochladen in der Statusleiste verwenden; schreibst du sie nicht, kompiliert PlatformIO nacheinander alle Umgebungen der Datei. Über die Umgebungsauswahl in der Statusleiste kannst du jederzeit auf ein anderes Board wechseln oder im Terminal mit pio run -e esp32dev -t upload direkt auf den ESP32 hochladen. Das Flag -D LED_PIN=2 in der ESP32-Umgebung definiert das Makro LED_PIN im Code; da es beim Uno und Pico fehlt, fällt der Code dort auf LED_BUILTIN (13 bzw. 25) zurück. So läuft eine einzige main.cpp ohne jede Änderung auf allen drei Boards. Um die Pinbelegung der Boards schnell nachzuschlagen, kannst du das Pinout-Tool nutzen.
PlatformIO-Einstellungen für den ESP32
ESP32-Boards werden in PlatformIO wie in der Arduino IDE mit esptool geflasht. upload_speed = 921600 verkürzt die Upload-Zeit deutlich; ist dein Kabel lang oder schlecht und du bekommst Fehler, geh auf 460800 oder 115200 zurück. Der Filter esp32_exception_decoder übersetzt den unverständlichen Adress-Stack, den der Serial Monitor beim Absturz des Boards ausgibt, in Funktionsnamen und Zeilennummern; zum Aufspüren von Guru-Meditation-Fehlern ist das sehr wertvoll. Bleibt der Upload bei „Connecting...“ hängen, halte die BOOT-Taste am Board gedrückt und lass sie los, sobald der Upload beginnt; ausführliche Lösungen stehen im Beitrag ESP32 Failed to Connect. Wichtig ist auch die Core-Version: Die offizielle Platform espressif32 von PlatformIO nutzte lange den Arduino-ESP32-Core 2.x; brauchst du APIs, die es nur in 3.x gibt, kannst du zur von der Community gepflegten Platform pioarduino wechseln. Welcher Core verwendet wird, siehst du an der Version von framework-arduinoespressif32 in der PACKAGES-Zeile am Anfang der Build-Ausgabe. Soll dein Code mit beiden Versionen kompilieren, kannst du mit dem Makro ESP_ARDUINO_VERSION_MAJOR unterscheiden.
Raspberry Pi Pico und PlatformIO
Die offizielle Platform raspberrypi verwendet mit board = pico den offiziellen Mbed-OS-basierten RP2040-Core von Arduino. Viele Nutzer bevorzugen dagegen den arduino-pico-Core von Earle Philhower, der mehr Funktionen und eine bessere Bibliothekskompatibilität bietet; in PlatformIO verwendest du ihn über ein separates, von der Community gepflegtes Platform-Paket und die Einstellung board_build.core = earlephilhower. Welchen Core du auch wählst: Beim ersten Upload musst du den Pico eventuell bei gedrückter BOOTSEL-Taste an den USB-Port stecken; das Board erscheint am Rechner als Laufwerk namens RPI-RP2, und nach dem Hochladen startet es von selbst neu. Bei späteren Uploads brauchst du die Taste meist nicht mehr. Wichtiger Hinweis: PlatformIO unterstützt kein MicroPython. Willst du den Pico mit MicroPython programmieren, brauchst du einen Editor wie Thonny; Details findest du in den Beiträgen MicroPython-Grundlagen und Was ist der Raspberry Pi Pico?.
Bibliotheken hinzufügen: lib_deps
In PlatformIO werden Bibliotheken nicht für den ganzen Rechner, sondern für jedes Projekt einzeln installiert. Am saubersten ist es, in der platformio.ini eine lib_deps-Zeile zu ergänzen: Beim ersten Kompilieren lädt PlatformIO die Bibliothek aus der Registry und legt sie im Ordner .pio/libdeps/ ab. Du kannst den vollständigen Namen auch im Tab Libraries in PIO Home suchen und mit Add to Project hinzufügen; diese Schaltfläche schreibt die lib_deps-Zeile für dich. Unten siehst du ein Beispiel, das einen DHT11-Sensor an Pin D2 des Uno anschließt; zur Verkabelung des Sensors schau in den Beitrag DHT11 Temperatur- und Feuchtigkeitssensor.
1[env:uno]
2platform = atmelavr
3board = uno
4framework = arduino
5monitor_speed = 115200
6; Kütüphaneler ilk derlemede otomatik iner / Libraries download on first build
7lib_deps =
8 adafruit/DHT sensor library@^1.4.4
9 adafruit/Adafruit Unified Sensor@^1.1.91#include <Arduino.h>
2#include <DHT.h>
3
4#define DHT_PIN 2 // Uno D2 pini / Uno pin D2
5#define DHT_TYPE DHT11
6
7DHT dht(DHT_PIN, DHT_TYPE);
8
9void setup() {
10 Serial.begin(115200);
11 dht.begin();
12}
13
14void loop() {
15 delay(2000); // DHT11 en fazla 1 Hz / DHT11 max 1 Hz
16 float h = dht.readHumidity();
17 float t = dht.readTemperature();
18 if (isnan(h) || isnan(t)) {
19 Serial.println("Sensor okunamadi / Read failed");
20 return;
21 }
22 Serial.print("Sicaklik / Temp: ");
23 Serial.print(t, 1);
24 Serial.print(" C Nem / Hum: ");
25 Serial.print(h, 0);
26 Serial.println(" %");
27}Bei der Versionsangabe erlaubt ^1.4.4 Versionen ab 1.4.4, aber unter 2.0.0; ~1.4.4 akzeptiert nur Patches der Reihe 1.4.x; schreibst du nur 1.4.4, ist die Version komplett festgelegt. Das Festlegen der Version garantiert, dass derselbe Code auch in einem Jahr noch genauso kompiliert. Legst du eine Bibliothek, die nicht in der Registry ist oder die du selbst geschrieben hast, als Unterordner mit ihrem Namen in den lib-Ordner des Projekts, findet PlatformIO sie automatisch. Wenn du es mit der Bibliothekslogik der Arduino IDE vergleichen möchtest, lies den Beitrag Arduino-Bibliotheken hinzufügen.
Projekt von der Arduino IDE zu PlatformIO übernehmen
- Lege in PIO Home ein neues Projekt an und wähle dasselbe Board, das du in der Arduino IDE benutzt hast.
- Füge den Inhalt deiner .ino-Datei in src/main.cpp ein; hänge weitere .ino-Tabs aus demselben Ordner ans Ende der main.cpp an und kopiere .h- und .cpp-Dateien in den Ordner src.
- Füge ganz oben in der Datei die #include-Zeile für Arduino.h ein.
- Schreibe für jede Funktion außer setup() und loop() oben in der Datei einen Prototyp.
- Suche die benutzten Bibliotheken über PIO Home > Libraries und trage sie in lib_deps ein; gibst du die Versionsnummer aus der Arduino IDE an, erhältst du dasselbe Verhalten.
- Trage die Baudrate von Serial.begin() in die Zeile monitor_speed ein und kompiliere das Projekt. Behebe die verbleibenden Meldungen in der Fehlerliste nacheinander.
Alternativ kannst du den vorhandenen Ordner mit der Schaltfläche Import Arduino Project in PIO Home direkt importieren. PlatformIO wandelt die .ino-Dateien im Ordner src beim Kompilieren selbst in .cpp um und versucht, Prototypen zu erzeugen. Da diese Umwandlung bei komplexem Code danebenliegen kann und IntelliSense in .ino-Dateien nicht voll leistungsfähig arbeitet, ist auf lange Sicht der Wechsel zu main.cpp sinnvoller. Wenn du Schwierigkeiten hast, Compilermeldungen zu deuten, gelten die Erklärungen im Beitrag Arduino-Kompilierfehler auch für PlatformIO.
Arduino IDE oder PlatformIO?
| Merkmal | Arduino IDE 2.x | PlatformIO (VS Code) |
|---|---|---|
| Installation | Ein Paket, wenige Minuten | VS Code und Erweiterung; Werkzeuge werden bei der ersten Installation geladen |
| Codevervollständigung | Grundlegend | Fortgeschrittenes IntelliSense, Gehe zu Definition, Mehrfach-Umbenennen |
| Board-Einstellung | Im Menü Werkzeuge, nicht im Projekt gespeichert | In der platformio.ini, wandert mit dem Projekt |
| Bibliotheken | Für den ganzen Rechner gemeinsam | Pro Projekt getrennt, Version festlegbar |
| Mehrere Boards | Jedes Mal im Menü umstellen | Mehrere Umgebungen in einem Projekt |
| Dateistruktur | .ino; Ordnername muss dem Dateinamen entsprechen | src, include, lib; Standard-.cpp und -.h |
| Funktionsprototypen | Werden automatisch erzeugt | Von Hand schreiben (beim .ino-Import automatisch) |
| Versionsverwaltung mit Git | Möglich, aber Board-Einstellungen bleiben außen vor | Einfach; alles außer dem Ordner .pio wird verfolgt |
| Debugging und Tests | Bei manchen Boards ein Debugger | Debugger (Debug-Probe) und Unit-Test-Unterstützung |
| Eignung für Einsteiger | Sehr hoch | Mittel; erfordert eine kurze Eingewöhnung |
Kurz gesagt: Wenn du deine erste LED zum Leuchten bringst oder ein Schulprojekt mit wenigen Dateien baust, reicht die Arduino IDE und ist weniger verwirrend. Geht es um mehrere Boards, Code in vielen Dateien, Versionsverwaltung mit Git oder Teamarbeit, spart PlatformIO viel Zeit. Die beiden Werkzeuge schließen sich nicht aus; du kannst beide auf demselben Rechner nutzen. Hast du die Arduino IDE noch nicht installiert, kannst du mit dem Beitrag Arduino IDE installieren beginnen.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| 'xyz' was not declared in this scope | Funktionsprototyp fehlt | Prototyp vor setup() schreiben oder die Funktion nach oben verschieben |
| fatal error: DHT.h: No such file or directory | Bibliothek fehlt in lib_deps oder wurde einer anderen Umgebung hinzugefügt | Bibliothek im richtigen [env]-Abschnitt ergänzen und neu kompilieren |
| Unverständliche Zeichen im Serial Monitor | monitor_speed und Baudrate in Serial.begin() unterscheiden sich | Beide Werte angleichen (z. B. 115200) |
| Board nicht sichtbar, kein Port | Nur-Ladekabel oder fehlender CH340/CP2102-Treiber | Datenkabel verwenden, Treiber installieren, mit pio device list prüfen |
| Access is denied / Resource busy | Port ist in einem anderen Programm geöffnet | Serial Monitor der Arduino IDE und andere Terminals schließen |
| ESP32: Failed to connect, Wrong boot mode | Board ist nicht in den Download-Modus gewechselt | Upload mit gedrückter BOOT-Taste starten |
| Upload auf den Pico startet nicht | Board ist nicht im BOOTSEL-Modus | Bei gedrückter BOOTSEL-Taste einstecken und prüfen, ob das Laufwerk RPI-RP2 erscheint |
| Linux: Permission denied: /dev/ttyUSB0 | udev-Regel oder Benutzerrecht fehlt | Datei 99-platformio-udev.rules installieren, Benutzer zur Gruppe dialout hinzufügen |
| Windows: Kompilierung bricht mit unverständlichen Pfadfehlern ab | Sonderzeichen oder Leerzeichen im Benutzernamen | Core-Ordner mit PLATFORMIO_CORE_DIR nach C:\platformio verlegen |
| Installation hängt bei Installing PlatformIO Core | Internet-, Antivirus- oder Python-Problem | VS Code neu starten, Log unter Output > PlatformIO prüfen |
Erste Projekte, die du mit PlatformIO ausprobieren solltest
- Blink für mehrere Boards: Lade das obige Projekt mit drei Umgebungen nacheinander auf Uno, ESP32 und Pico und verstehe so die Logik der Umgebungsauswahl.
- Sensorlog mit Zeitstempel: Gib die Daten eines DHT11 mit der Einstellung monitor_filters = time mit Uhrzeit im Serial Monitor aus.
- WLAN-Webserver: Teile beim Projekt ESP32-Webserver den Code auf mehrere .cpp- und .h-Dateien auf und baue so eine saubere Struktur.
- Drahtloses Update: Lade Code mit ESP32 OTA per WLAN hoch, mit upload_protocol = espota und der IP-Adresse des Boards in der Zeile upload_port.
- Zustandsautomat: Schreibe die Logik eines Arduino-Zustandsautomaten in eine eigene Klassendatei und nutze so die Ordnerstruktur von PlatformIO.
- Zeitsteuerung ohne delay: Schreibe mit millis() ein Programm, das mehrere Aufgaben gleichzeitig erledigt.
Auch wenn die PlatformIO-Installation anfangs etwas länger dauert als die der Arduino IDE, wird es mit der Zeit zum Werkzeug, das am meisten Zeit spart, weil die platformio.ini alle Einstellungen des Projekts an einem Ort bündelt. Kompiliere und lade nach der Installation zuerst ein einfaches LED-Projekt hoch und geh dann zu Projekten mit Bibliotheken und mehreren Boards über. In der BlueGrays-App findest du LED-Projekte, Einsteigerprojekte für ESP32 und Pico sowie Sensorprojekte mit DHT11 und HC-SR04 Schritt für Schritt mit Schaltplan und Code; diese Codes kannst du direkt in dein eigenes PlatformIO-Projekt übernehmen und ausprobieren.
Häufige Fragen
Ist PlatformIO kostenlos?
Ja. PlatformIO Core und die Erweiterung PlatformIO IDE für VS Code sind Open Source und kostenlos. Für Hobby-, Schul- oder kommerzielle Projekte musst du für Board-Definitionen, Bibliotheksverwaltung, Kompilieren und Hochladen keine Lizenzgebühr zahlen.
Laufen Arduino-IDE-Sketche in PlatformIO?
Ja, denn mit framework = arduino werden derselbe Arduino-Core und dieselben Funktionen verwendet. Du musst den Code nur in src/main.cpp verschieben, oben die include-Zeile für Arduino.h ergänzen, Funktionsprototypen schreiben und die benutzten Bibliotheken in lib_deps eintragen.
Warum dauert die PlatformIO-Installation so lange?
Bei der ersten Installation werden PlatformIO Core, die Python-Umgebung und die Grundwerkzeuge geladen; beim ersten Projekt kommen Compiler und Framework deines Boards dazu. Da ESP32-Pakete mehrere hundert Megabyte groß sein können, dauert das je nach Verbindung 5–15 Minuten. Sind die Pakete einmal geladen, öffnen sich weitere Projekte schnell.
Unterstützt PlatformIO MicroPython?
Nein, PlatformIO ist für C/C++-basierte Frameworks wie Arduino und ESP-IDF gedacht. Willst du den Raspberry Pi Pico oder ESP32 mit MicroPython programmieren, brauchst du einen Editor wie Thonny. Dasselbe Board kannst du bei Bedarf aber auch mit PlatformIO im Arduino-Framework programmieren.
Wie füge ich in PlatformIO eine Bibliothek hinzu?
Am einfachsten öffnest du in PIO Home den Tab Libraries, suchst die Bibliothek und wählst mit Add to Project dein Projekt aus. Dabei wird die lib_deps-Zeile in die platformio.ini geschrieben, und die Bibliothek wird beim ersten Kompilieren automatisch geladen. Eigene Bibliotheken legst du als Unterordner in den lib-Ordner des Projekts.
Wie wähle ich in PlatformIO den COM-Port aus?
PlatformIO findet das angeschlossene Board meist automatisch. Bei mehreren seriellen Geräten kannst du den Port über die Port-Auswahl in der Statusleiste oder mit den Zeilen upload_port = COM5 und monitor_port = COM5 in der platformio.ini festlegen. Welche Ports angeschlossen sind, zeigt dir der Befehl pio device list.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken
Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W)
Das Auftaktprojekt der Raspberry-Pi-Pico-Reihe! Wir lassen die grüne eingebaute LED des Pico blinken und prüfen so, ob das Board funktioniert: das klassische "Hello World" als erstes Experiment. Keine externen Bauteile nötig, nur der Pico und ein USB-Kabel. Der Code ist in MicroPython geschrieben, der Sprache, die die Raspberry Pi Foundation offiziell unterstützt.

Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

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…

ESP32 Interne LED Blinken
Die eingebaute blaue LED auf dem ESP32 DevKit V1 zum Blinken bringen. Keine externen Komponenten erforderlich! Das erste Projekt, das Sie ausprobieren sollten, wenn Sie einen ESP32 kaufen. GPIO 2 ist mit der internen LED verbunden.

Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)
Der nächste Schritt nach der eingebauten LED des Pico: eine externe LED auf dem Steckbrett anschließen und über Pin GP14 steuern. Du lernst, jeden GPIO-Pin des Pico als Ausgang zu nutzen, die Polung der LED (langes Bein = Anode/+, kurzes Bein = Kathode/–) und warum ein Vorwiderstand (220Ω) Pflicht ist. Ohne ihn fließt zu viel Strom durch die LED und sie kann durchbrennen.

ESP32 LED-Steuerung mit Drucktaste (Push)
Die LED leuchtet auf, wenn die Taste gedrückt wird und geht aus, wenn sie losgelassen wird. Zeigt, wie der digitale Eingangspin des ESP32 und der interne Pull-up-Widerstand verwendet werden. Dank des INPUT_PULLUP-Modus ist kein externer Widerstand erforderlich.
Weitere Artikel
- Arduino IDE installieren: Windows, Mac, Linux und erster Sketch
- Arduino Bibliothek installieren: ZIP, manuell und Fehler lösen
- Was ist der ESP32? Eigenschaften, Einrichtung in der Arduino IDE und erstes WLAN-Projekt
- Was ist der Raspberry Pi Pico? MicroPython-Installation, Pinbelegung und erste Projekte
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

