Der moderne Weg – ESP32-C6 mit VS Code & PlatformIO

Hand aufs Herz: Wolltet ihr nicht eigentlich schon immer mal den opensource TextEditor Visual Studio Code als Alternative ausprobieren? Aber oft schreckt der erste Blick darauf ab: Es wirkt unübersichtlich, riesig und man fragt sich unweigerlich: „Lohnt sich der ganze Aufwand für mich überhaupt?“

In diesem Tutorial zeige ich euch deshalb, wie einfach die Umsetzung mit Visual Studio Code und PlatformIO tatsächlich sein kann.
Wir gehen das Schritt für Schritt an. Als Praxisbeispiel bringen wir die eingebaute RGB-LED des ESP32-C6 farbig zum Leuchten und schauen uns optional an, wie man das Projekt direkt sauber auf GitHub sichert.

Schritt 1: „Das Power-Trio“ installieren

Zuerst benötigen wir die Software. Vergiss das gigantische „Visual Studio 2022“ (lila Icon). Wir brauchen das schlanke Visual Studio Code (blaues Icon), das bei Entwicklern weltweit Standard ist.

Download: Lade dir VS Code für Linux, Mac oder Windows herunter (am besten den „System Installer“).
Einrichten: Nach der Installation öffnen wir links in der Leiste die Erweiterungen (das Tetris-Symbol oder Tastenkürzel Strg+Shift+X).
Das Trio: Suche und installiere diese drei Erweiterungen:
- PlatformIO IDE (Das Ameisen-Icon): Unser Manager für Boards und Bibliotheken.
- C/C++ (von Microsoft): Sorgt für die intelligente Autovervollständigung.
- German Language Pack (Optional): Damit die Menüs in deiner gewünschten Sprache sind.

Hinweis: Nach der Installation von PlatformIO fordert VS Code einen Neustart. Gib ihm danach ruhig 1-2 Minuten Zeit, da er im Hintergrund Python und notwendige Tools nachlädt.

Schritt 2: Das Projekt anlegen (Die C6-Besonderheit)

Klicke links auf das PlatformIO-Icon (Ameise)
– Wähle im Menü „PIO Home“ > „Open“
– Klicke auf den Button „New Project“

Fülle den Assistenten aus:
- Name: Projekt Name
- Board: Espressif ESP32-C6-DevKitC-1 (oder dein dir vorliegendes Entwicklungsboard).
- Framework: Arduino.

Klicke auf Finish. (Der erste Start dauert etwas, da er Compiler herunterlädt).

Schritt 3: Die Schaltzentrale – `platformio.ini` verstehen und einrichten

In der Arduino-IDE klickst du dich durch Menüs, um Boards und Bibliotheken auszuwählen. In VS Code machen wir das professioneller: Wir schreiben eine Konfigurationsdatei. Das hat den riesigen Vorteil, dass jeder, der dein Projekt öffnet, automatisch die gleichen Einstellungen hat.

Die Datei heißt platformio.ini und liegt im Hauptverzeichnis deines Projekts.

Diese ist bereits mit der Board Informationen incl. Library Quelle gefüllt, die beim Anlegen genannt wurde.

Da in diesem kleinen Projekt, nun die RGB-LED angesprochen werden soll, muss hier noch die NEOPixel Library hinzugefügt werden.

lib_deps =
adafruit/Adafruit NeoPixel

Tipp: Den genauen Namen einer Library findest du im PlatformIO Library Registry. Dort kannst du suchen und den Eintrag direkt kopieren.

Deine Konfiguration

Lösche den kompletten Inhalt deiner platformio.ini und füge folgenden Block ein. Die Zeilen mit dem beginnenden Semikolon sind lediglich zum besseren Verständnis und werden eigentlich nicht benötigt.

; [env:...] definiert den Namen der Umgebung. Frei wählbar.
[env:esp32-c6-devkitc-1]

; 1. DIE PLATTFORM (Der wichtigste Teil für den C6!)
; Statt dem Standard nutzen wir hier einen Link zur Community-Version.
; Diese enthält den notwendigen Arduino Core 3.0 Support für den C6.
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip

; 2. DAS BOARD & FRAMEWORK
; Welches Board hast du? Und in welcher "Sprache" (Arduino) schreiben wir?
board = esp32-c6-devkitc-1
framework = arduino

; 3. DER SERIELLE MONITOR
; Hier legen wir die Geschwindigkeit fest. Muss zum Code (Serial.begin) passen!
monitor_speed = 115200

; 4. BIBLIOTHEKEN-MANAGER (Das "Killer-Feature")
; Wir müssen Bibliotheken nicht manuell suchen. Wir listen sie hier auf.
; PlatformIO lädt sie automatisch herunter.
lib_deps = 
    adafruit/Adafruit NeoPixel

Was passiert hier genau? (Die Erklärung für deine Leser)

platform = https://...: Das ist unser „Workaround“. Normalerweise steht hier nur ein kurzer Name. Da wir aber den modernen C6 nutzen, zwingen wir VS Code, die allerneuesten Treiber direkt von GitHub herunterzuladen, statt auf das offizielle Update zu warten.
lib_deps: Das ist deine „Einkaufsliste“. Du schreibst einfach adafruit/Adafruit NeoPixel hinein. Als wie bei der Aktoren und Sensoren Library in der Arduino IDE.
Automatisierung: Sobald du diese Datei speicherst (Strg + S), schau mal unten rechts in die Ecke von VS Code. Du wirst sehen, dass er anfängt zu arbeiten („PlatformIO: Loading tasks…“). Er richtet jetzt deine komplette Werkstatt vollautomatisch ein.

Schritt 4: Der Code (`main.cpp`)

Da der ESP32-C6 auf dem Board meistens eine adressierbare RGB-LED (WS2812) statt einer einfachen LED hat, nutzen wir die eben installierte Adafruit_NeoPixel Bibliothek.

Öffne den Ordner src und die Datei main.cpp. Kopiere folgenden Code hinein:

#include <Arduino.h>
#include <Adafruit_NeoPixel.h>

// PIN-Konfiguration: 
// Bei vielen C6-Boards ist die RGB-LED an GPIO 8.
// Falls nicht: Prüfe GPIO 18 oder 19 (je nach Hersteller).
#define RGB_PIN 8  
#define NUMPIXELS 1

// Initialisierung der NeoPixel-Instanz
Adafruit_NeoPixel pixels(NUMPIXELS, RGB_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  // Serial Monitor starten
  Serial.begin(115200);
  delay(1000); // Kurze Wartezeit für den USB-Stack
  Serial.println("Systemstart: ESP32-C6 bereit!");

  // LED starten
  pixels.begin();
  pixels.setBrightness(50); // Helligkeit (0-255)
}

void loop() {
  // Rot
  pixels.setPixelColor(0, pixels.Color(255, 0, 0));
  pixels.show();
  Serial.println("LED Status: ROT");
  delay(1000);

  // Grün
  pixels.setPixelColor(0, pixels.Color(0, 255, 0));
  pixels.show();
  Serial.println("LED Status: GRÜN");
  delay(1000);

  // Blau
  pixels.setPixelColor(0, pixels.Color(0, 0, 255));
  pixels.show();
  Serial.println("LED Status: BLAU");
  delay(1000);
}

Schritt 5: Upload & Monitor

Unten in der blauen Status-Leiste findest du deine Werkzeuge:

Häkchen (✓): Kompilieren (prüft auf Fehler).
Pfeil nach rechts (→): Upload auf das Board.
Stecker-Symbol (🔌): Öffnet den Seriellen Monitor.

Klicke zum überprüfen auf das Häckchen, danach auf den Pfeil. Wenn der Upload durchläuft („SUCCESS“),

klicke auf den Stecker. Du solltest jetzt sehen:
LED Status: ROT …
LED Status: GRÜN …
und deine LED sollte passend blinken.

Glückwunsch! Dein C6 läuft mit VS Code.

Bonus: Wie Profis ihren Code sichern (GitHub & VS Code)

Dein Code läuft, aber er liegt nur lokal auf deiner Festplatte. Was, wenn du ihn mit Freunden teilen willst oder dein PC abstürzt? Hier kommt GitHub ins Spiel – direkt integriert in VS Code.

Exkurs: Was ist GitHub?

Stellt euch GitHub wie eine Mischung aus Google Drive und einer Zeitmaschine vor:

Speicher: Euer Code liegt sicher in der Cloud.
Zeitmaschine: Ihr könnt jeden Änderungsschritt („Commit“) speichern. Wenn ihr morgen etwas kaputt macht, könnt ihr einfach zum Stand von heute zurückkehren.

Anleitung: Vorbereitung

Voraussetzung: Git muss installiert sein und ihr habt einen (kostenlosen) Account auf github.com

Git Installation

Du musst Git auf deinem Rechner installiert haben (Version 2.0.0 oder neuer).
Ohne Git kann VS Code keine Commits, Branches oder Pushes ausführen.
Prüfen kannst du das mit git --version im Terminal. Falls nicht vorhanden: Git Download.

GitHub Account

Ein kostenloser Account auf github.com ist nötig.
Deine Zugangsdaten (Benutzername und E-Mail) müssen lokal konfiguriert sein:

git config –global user.name „Dein Name“
git config –global user.email „deine.email@example.com“

VS Code Erweiterungen

Standardmäßig hat VS Code schon Git-Integration.
Für erweiterte Funktionen (Pull Requests, Issues direkt in VS Code) empfiehlt sich die GitHub Pull Requests and Issues Extension.
Diese Erweiterung ermöglicht dir, dich direkt in VS Code bei GitHub anzumelden und mit Repositories zu arbeiten

Authentifizierung

Beim ersten Push oder Clone fragt VS Code nach der Anmeldung bei GitHub.
Du meldest dich über den Browser an, VS Code übernimmt dann das Token.
Danach kannst du direkt aus der Quellcodeverwaltung heraus „Publish Branch“ oder „Push“ nutzen.

Erster Upload aus der VS Code Quellverwaltung

Initialisieren: Klickt in VS Code links auf das Symbol „Quellcodeverwaltung“ (sieht aus wie ein Ast mit Abzweigungen). Klickt auf den blauen Button „Initialize Repository“.
Der „Schnappschuss“ (Commit): Ihr seht jetzt eure Dateien unter „Changes“.
- Fahrt mit der Maus darüber und klickt auf das + (Stage All).
- Gebt oben eine Notiz ein: „Mein erster C6 Code“.
- Klickt auf den Haken ✔ (Commit). Jetzt ist der Stand lokal gesichert.
Veröffentlichen (Publish): Klickt auf den Button „Publish Branch“.
- VS Code fragt euch: Private (nur für euch) oder Public (für alle sichtbar)?
- Wählt das Passende aus.

Fertig! Euer Projekt ist jetzt online. Ihr könnt den Link an Freunde schicken, und diese können (wie ich im ersten Teil gezeigt habe) den Code einfach in ihr VS Code klonen und direkt loslegen.

damit ihr immer den aktuellsten und funktionierenden Code für euer Board bekommt.

Github Teil 2: Den Code holen – Wie ihr das Projekt von Github in euer VS Code bekommt

Ihr habt VS Code und PlatformIO installiert und wollt nun irgend ein Code von Github verwenden und auf euren Rechner holen?

Vergesst das manuelle Herunterladen von ZIP-Dateien. VS Code kann das viel eleganter. Hier ist der Schritt-für-Schritt-Weg:

1. Die URL kopieren

Geht auf die GitHub-Seite eines Projekts
(z.B. github.com/prilchen/mein-projekt).

Klickt auf den grünen Button <> Code.
Klickt auf das Kopieren-Symbol neben der HTTPS-URL (die Zeile, die mit https://github.com... beginnt).

2. In VS Code „klonen“

Öffnet euer frisches Visual Studio Code. (Datei / Ordner schließen)

Auf der Startseite geht ihr wieder links auf das Symbol „Quellcodeverwaltung“ und wählt die Auswahl „Clone Git Repository…“.
- Alternativ: Drückt F1 (oder Strg+Shift+P) und tippt Clone ein. Wählt dann „Git: Clone“.
Es erscheint oben mittig ein Eingabefeld. Fügt dort die URL ein, die ihr eben kopiert habt, und drückt Enter.
VS Code fragt euch nun, wo ihr das Projekt speichern wollt. Wählt einen Ordner auf eurer Festplatte (z.B. C:\Projekte\NeuesProjekt).
Klickt auf „Repositoryspeicherort auswählen“.

3. Das Projekt öffnen

Sobald der Download fertig ist (das dauert meist nur Sekunden), fragt VS Code unten rechts: „Möchten Sie das geklonte Repository öffnen?“

👉 Klickt auf Öffnen (Open).

Hinweis: Falls VS Code fragt „Do you trust the authors…?“, bestätigt dies mit Yes, I trust the authors (da ihr den Code ja von meiner Seite habt).

4. Der „Magic Moment“ (Wichtig!)

Jetzt passiert das, was PlatformIO so genial macht. Ihr müsstet eigentlich Bibliotheken installieren und Boards einrichten… aber das müsst ihr nicht!

VS Code erkennt automatisch die Datei platformio.ini im Ordner.
Schaut mal unten rechts in die Statusleiste. Dort seht ihr Meldungen wie PlatformIO: Loading tasks... oder Installing dependencies....
Wartet kurz ab. PlatformIO liest meine Konfiguration, sieht „Aha, wir brauchen den ESP32-C6 Core und die NeoPixel-Bibliothek“ und lädt alles vollautomatisch herunter.

Sobald unten in der blauen Leiste das Häkchen (✓) und der Pfeil (→) auftauchen, ist euer System startklar.

5. Loslegen

Schließt euren ESP32-C6 an und klickt auf den Pfeil nach rechts (Upload). Fertig!

Warum ist das besser als „Download ZIP“?

Wenn ich morgen einen Fehler im Code behebe oder eine neue Funktion hinzufüge, müsst ihr nicht alles neu herunterladen. Ihr klickt in VS Code einfach unten links auf das Synchronisieren-Symbol (Kreispfeile) im Quellcode-Verwaltungs-Tab, und zack – habt ihr die neueste Version.

Youtube-Video: