ESP32-Core in der Arduino IDE installieren

In diesem Tutorial lernst du, wie du den ESP32 Core in der Arduino IDE installierst. Der ESP32 ist ein leistungsstarker und vielseitiger Mikrocontroller, der häufig in IoT- und Maker-Projekten verwendet wird. Um ihn mit der Arduino IDE zu programmieren, musst du den ESP32 Core installieren.

Der ESP32 Core fungiert als Brücke zwischen der Arduino-Umgebung und der ESP32-Hardware. Er stellt die notwendigen Werkzeuge, Bibliotheken und Definitionen bereit, um deinen Code für das ESP32-Board zu kompilieren und hochzuladen.

Du erfährst, was ein Arduino Core ist, warum er wichtig ist und wie du den ESP32 Core Schritt für Schritt installierst. Außerdem behandeln wir die Installation der benötigten USB-zu-Seriell-Treiber, die Auswahl des richtigen Boards und Ports sowie die Konfiguration der Board-Einstellungen. Am Ende bist du bereit, deine ESP32-Projekte mit der vertrauten Arduino IDE zu starten.

Was ist ein Core in der Arduino IDE?

Im Arduino-Ökosystem ist ein Core eine Sammlung von Softwarekomponenten, die es der Arduino IDE ermöglichen, Code für eine bestimmte Mikrocontroller-Familie oder ein Board zu kompilieren und hochzuladen. Er bildet die essentielle Brücke zwischen deinen Arduino-Sketches und der Hardware, die du programmieren möchtest. Ein Arduino Core umfasst typischerweise mehrere wichtige Bestandteile:

Board-Definitionen

Dies sind JSON- oder Konfigurationsdateien, die die hardware-spezifischen Details jedes unterstützten Boards beschreiben. Sie definieren CPU-Architektur, Taktfrequenz, verfügbare Pins, Speicherkapazitäten und weitere Hardwareparameter. Zum Beispiel enthält der ESP32 Core Definitionen für beliebte Boards wie das ESP32 Dev Module, WROOM- und WROVER-Varianten.

Compiler-Toolchain

Der Core bündelt die notwendigen Compiler- und Linker-Werkzeuge, die auf die Zielarchitektur zugeschnitten sind. Für den ESP32 bedeutet das die Xtensa GCC Toolchain, die deine Arduino-Sketches in Maschinencode übersetzt, den die CPU des ESP32 ausführen kann.

Upload-Tools

Diese Werkzeuge übernehmen den Prozess, deinen kompilierten Code auf das Board zu flashen. Für den ESP32 verwendet der Core esptool.py, ein Python-basiertes Dienstprogramm, das über die USB-zu-Seriell-Schnittstelle die Firmware hochlädt.

Core-Bibliotheken

Dazu gehören die Hardware-Abstraktionsschicht (HAL), Peripherietreiber und die Kern-APIs von Arduino, die für die Zielplattform angepasst sind. Für den ESP32 integriert der Core FreeRTOS für Multitasking, Wi-Fi- und Bluetooth-Stacks sowie weitere spezialisierte Bibliotheken, um die erweiterten Funktionen des Chips zu nutzen.

Warum wird ein Core benötigt?

Die Arduino IDE wurde ursprünglich für AVR-basierte Boards wie das Arduino Uno entwickelt. Wenn du einen anderen Mikrocontroller programmieren möchtest, wie den ESP32, muss die IDE verstehen, wie sie:

• Code für die neue CPU-Architektur kompiliert
• board-spezifische Hardwarefunktionen verwaltet
• Code mit dem passenden Protokoll und Werkzeugen hochlädt
• Bibliotheken bereitstellt, die die Peripherie des Boards unterstützen

Ohne einen Core kann die IDE nicht mit dem Board kommunizieren und keinen Code dafür kompilieren. Der Core ermöglicht es dir, denselben oder sehr ähnlichen Code für viele verschiedene Mikrocontroller zu verwenden und vereinfacht den Code meist auch.

Zum Beispiel zeigt das folgende Codebeispiel den klassischen Blink-Sketch für die Arduino IDE, der eine LED an GPIO 2 jede Sekunde blinken lässt:

#define LED_PIN 2

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

Der gleiche Code mit dem ESP-IDF, einer IDE speziell für ESP32-Programmierung, ist deutlich länger und komplexer:

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_PIN GPIO_NUM_2

void blink_task(void *pvParameter) {
    while (1) {
        gpio_set_level(LED_PIN, 1);
        vTaskDelay(pdMS_TO_TICKS(1000));

        gpio_set_level(LED_PIN, 0);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void) {
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << LED_PIN),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE
    };
    gpio_config(&io_conf);

    xTaskCreate(blink_task, "blink_task",
                2048, NULL, 5, NULL);
}

Architektur des ESP32 Cores

Der ESP32 Arduino Core basiert auf Espressifs offiziellem ESP-IDF (IoT Development Framework). Er verpackt die komplexen ESP-IDF APIs in Arduino-freundliche Funktionen und Klassen. Die Core-Architektur umfasst:

• Hardware-Abstraktionsschicht (HAL): Vereinfacht den Zugriff auf ESP32-Peripherien wie GPIO, ADC, SPI, I2C und UART.
• FreeRTOS Kernel: Ermöglicht Multitasking und Echtzeitbetrieb innerhalb von Arduino-Sketches.
• Arduino API-Schicht: Bietet vertraute Arduino-Funktionen (setup(), loop(), digitalWrite(), analogRead(), Serial usw.) angepasst an die ESP32-Hardware.

Diese Architektur erlaubt es Entwicklern, Arduino-Sketches zu schreiben, die auf ESP32-Mikrocontrollern oder jedem anderen Mikrocontroller mit verfügbarem Core laufen.

Installation oder Aktualisierung der Arduino IDE

Bevor du den ESP32 Core installierst, stelle sicher, dass du die neueste Version der Arduino IDE hast. Der ESP32 Core benötigt Arduino IDE 1.8.13 oder neuer. Eine veraltete IDE kann Kompatibilitätsprobleme verursachen.

Besuche die Arduino website. Wähle dein Betriebssystem: Windows, macOS oder Linux und lade die neueste stabile Version herunter.

Installation der Arduino IDE

• Windows: Führe die heruntergeladene .exe Datei aus und folge dem Installationsassistenten.
• macOS: Öffne die .dmg Datei und ziehe die Arduino-App in deinen Programme-Ordner.
• Linux: Entpacke das heruntergeladene Archiv und führe das install.sh Skript aus.

Aktualisierung der Arduino IDE

Wenn du die Arduino IDE bereits installiert hast, überprüfe deine Version unter Hilfe > Über Arduino (Windows/Linux) oder Arduino > Über Arduino (macOS). Vergleiche deine Version mit der neuesten auf der Arduino-Webseite.

Installation des USB-zu-Seriell-Treibers

Um dein ESP32-Board aus der Arduino IDE programmieren zu können, muss dein Computer über eine USB-zu-Seriell-Schnittstelle mit dem Board kommunizieren. Die meisten ESP32-Entwicklungsboards verwenden entweder den CP210x oder den CH340 USB-zu-Seriell-Chip. Die Installation des richtigen Treibers stellt sicher, dass dein Computer das Board korrekt erkennt.

USB-zu-Seriell-Chip identifizieren

Überprüfe zuerst, welchen USB-zu-Seriell-Chip dein ESP32-Board verwendet. Schau in die Produktbeschreibung oder auf den Aufdruck (Silkscreen) auf der Platine in der Nähe des USB-Anschlusses.

Gängige Chips sind der CP2102 / CP2104 von Silicon Labs und der CH340 / CH341 von WCH. Sobald du den Chip identifiziert hast, lade den passenden Treiber herunter:

Nach dem Download: Führe den Installer aus, folge den Anweisungen auf dem Bildschirm und starte den Computer neu, falls erforderlich.

Treiberinstallation überprüfen

Verbinde dein ESP32-Board per USB. Dann:

• Unter Windows öffne den Geräte-Manager und schaue unter Anschlüsse (COM & LPT) nach. Du solltest einen neuen COM-Port sehen, der mit dem Namen des USB-zu-Seriell-Chips beschriftet ist.
• Unter macOS oder Linux öffne ein Terminal und führe aus:

ls /dev/tty.*

Suche nach einem Gerät wie /dev/tty.SLAB_USBtoUART (CP210x) oder /dev/tty.wchusbserialXXXX (CH340).

Wenn du das Gerät siehst, wurde der Treiber erfolgreich installiert. Die Installation des richtigen USB-zu-Seriell-Treibers ist entscheidend. Ohne ihn kann die Arduino IDE keinen Code auf dein ESP32-Board hochladen. Nach diesem Schritt kannst du den ESP32 Core zur Arduino IDE hinzufügen.

ESP32 Core zur Arduino IDE hinzufügen

Jetzt, da du die Arduino IDE vorbereitet und den USB-zu-Seriell-Treiber installiert hast, ist es Zeit, den ESP32 Core hinzuzufügen. Dieser Schritt ermöglicht es der Arduino IDE, ESP32-Boards zu erkennen und zu programmieren.

Um den ESP32 Core zu installieren, öffne deine Arduino IDE und gehe zu Datei > Voreinstellungen wie unten gezeigt:

Dies öffnet den Voreinstellungen-Dialog. Am Ende dieses Dialogs findest du einen Abschnitt mit der Bezeichnung „Zusätzliche Boardverwalter-URLs:

Klicke auf die Schaltfläche rechts daneben, die einen weiteren Dialog öffnet, in dem du die URL eingeben kannst, von der der ESP32 Core heruntergeladen werden kann:

Es könnten bereits andere URLs vorhanden sein (in meinem Fall für ESP8266 und das Unihiker-Board). Füge dieser Liste die folgende URL für den ESP32 Core hinzu:

https://espressif.github.io/arduino-esp32/package_esp32_index.json

Alternativ kannst du auch diese verwenden:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Die Reihenfolge der URLs in der Liste spielt keine Rolle. Für andere Mikrocontroller-Architekturen siehe diese Liste von core URLs.

ESP32 Boards installieren

Öffne als Nächstes den Boardverwalter über Werkzeuge > Board > Boardverwalter. Gib im Suchfeld „esp32“ ein, finde den Eintrag „esp32 by Espressif Systems“ und klicke auf den INSTALLIEREN-Button:

Die Installation kann einige Minuten dauern, da alle notwendigen Dateien heruntergeladen werden. Nach der Installation schließe den Boardverwalter.

Du hast den ESP32 Core erfolgreich hinzugefügt. Nun kann die Arduino IDE Code für ESP32-Boards kompilieren und hochladen. Im nächsten Abschnitt konfigurieren wir die Board-Einstellungen passend zu deinem spezifischen ESP32-Modell.

ESP32 Board-Einstellungen konfigurieren

Nach der Installation des ESP32 Cores musst du die Board-Einstellungen konfigurieren. Diese Optionen steuern, wie die Arduino IDE deinen Sketch für den ESP32 baut, hochlädt und ausführt. Korrekte Einstellungen sind entscheidend für stabile Uploads, korrekte Speichernutzung und zuverlässiges Debugging.

Du findest alle Einstellungen unter Werkzeuge nach Auswahl eines ESP32-Boards. Der Screenshot unten zeigt die Einstellungen für ein „ESP32S3 Dev Module“:

Warum Board-Einstellungen wichtig sind

Der ESP32 ist sehr konfigurierbar. Er unterstützt verschiedene Upload-Methoden, Flash-Layouts, USB-Modi und Debug-Optionen. Falsche Einstellungen führen oft zu Upload-Fehlern, Boot-Loops oder unerwarteten Abstürzen.

Für die meisten Projekte sind jedoch nur wenige Einstellungen entscheidend. Andere sind fortgeschritten und können auf den Standardwerten bleiben. Die wichtigsten Einstellungen sind:

• Board: Muss genau zu deiner ESP32-Variante passen.
• Upload-Geschwindigkeit: Beeinflusst die Zuverlässigkeit des Uploads.
• Flash-Größe: Muss dem eingebauten Flash-Speicher entsprechen.
• Partition-Schema: Steuert die Aufteilung des Flash-Speichers.
• PSRAM: Externer RAM
• Port: Bestimmt, wohin die Firmware hochgeladen wird.

Sind diese korrekt, funktionieren die meisten Projekte ohne Probleme. Im Folgenden mehr Details zu diesen Einstellungen:

Flash-Größe

Diese Einstellung muss mit dem physischen Flash-Chip deines ESP32-Moduls übereinstimmen. Ist sie falsch, können Uploads zwar gelingen, aber Sketches stürzen zur Laufzeit ab.

Partition-Schema

Das Partition-Schema definiert, wie der Flash-Speicher des ESP32 aufgeteilt und zugewiesen wird. Es legt fest, wo Anwendungscode, Bootloader, Dateisysteme und optionale OTA-Update-Slots gespeichert sind. Diese Einstellung beeinflusst direkt die maximale Sketch-Größe und verfügbare Funktionen.

• Wähle Standard für einfache Sketches.
• Verwende Minimal SPIFFS, wenn deine Anwendung groß ist.
• Wähle OTA, wenn du Firmware drahtlos aktualisieren möchtest.

Upload-Geschwindigkeit

Höhere Geschwindigkeiten verkürzen die Upload-Zeit, können aber bei instabilen USB-Verbindungen zu Fehlern führen. Bei Upload-Problemen reduziere die Geschwindigkeit auf 115200.

USB CDC und USB-Modus

Diese Einstellungen sind wichtig für ESP32-S2 und ESP32-S3 Boards. Sie ermöglichen direkte USB-Kommunikation ohne externen USB-zu-Seriell-Wandler.

PSRAM

Aktiviere dies nur, wenn dein Board tatsächlich PSRAM besitzt. Andernfalls kann dein Sketch nicht starten. PSRAM wird typischerweise für speicherintensive Anwendungen wie Video oder Audio benötigt.

Einstellungen und ihre Funktion

Liste der häufigsten Einstellungen und deren Funktion:

Einstellung	Beschreibung	Wann ändern
USB CDC beim Booten	Ermöglicht USB-Seriell-Kommunikation über natives USB statt UART	Für ESP32-S2/S3 USB-basierte Boards aktivieren
USB-Modus	Wählt USB-Funktionalität (CDC, HID, MSC oder deaktiviert)	CDC für Serial Monitor verwenden
USB DFU beim Booten	Aktiviert den Device Firmware Update Modus beim Start	Für DFU-Flash-Workflows erforderlich
Upload-Modus	Definiert, wie Firmware hochgeladen wird (UART0, USB, OTA)	Nur ändern, wenn USB oder OTA verwendet wird
Upload-Geschwindigkeit	Übertragungsrate beim Upload	Bei Upload-Fehlern reduzieren
Flash-Größe	Größe des eingebauten Flash-Speichers (z.B. 4MB, 8MB, 16MB)	Muss zur Hardware passen
Flash-Modus	Kommunikationsmodus zwischen ESP32 und Flash (QIO, DIO, etc.)	Standard belassen, außer Datenblatt sagt anderes
Flash-Frequenz	Flash-Taktfrequenz (40MHz oder 80MHz)	Bei Instabilität reduzieren
Partition-Schema	Definiert Speicherlayout (App-Größe, SPIFFS, OTA)	Für OTA oder Dateisysteme ändern
Vor Sketch-Upload gesamten Flash löschen	Löscht den gesamten Flash vor dem Upload	Bei Boot- oder OTA-Problemen aktivieren
Core-Debug-Level	Steuert die Ausführlichkeit der Debug-Ausgabe	Während der Entwicklung erhöhen
PSRAM	Aktiviert externen pseudo-statischen RAM	Nur aktivieren, wenn Board PSRAM hat
JTAG-Adapter	Wählt JTAG-Schnittstelle für Debugging	Nur für Hardware-Debugging nötig
CPU-Frequenz	Setzt CPU-Taktfrequenz (z.B. 80MHz, 160MHz, 240MHz)	Für Stromsparmodus niedriger einstellen
Arduino läuft auf	Wählt Core (PRO oder APP CPU)	Standard für die meisten Anwendungen belassen

Board und Port auswählen

Nach der Konfiguration der ESP32-Board-Einstellungen musst du das richtige Board und den richtigen Port auswählen. Dieser Schritt teilt der Arduino IDE mit, welche ESP32-Variante du verwendest und wohin die Firmware hochgeladen werden soll. Falsche Auswahl ist eine der häufigsten Ursachen für Upload-Fehler.

ESP32 Board auswählen

Öffne zuerst das Werkzeuge > Board Menü. Scrolle dann zum ESP32 Arduino Abschnitt. Hier findest du eine lange Liste unterstützter Boards.

Wähle das Board, das deiner Hardware möglichst genau entspricht. Zum Beispiel:

• ESP32 Dev Module: Generisch und breit kompatibel
• DOIT ESP32 DEVKIT V1: Häufig verwendetes Entwicklungsboard
• ESP32-WROOM-DA Modul: Spezifische Modulvariante
• ESP32-S3 Dev Module: Für ESP32-S3-basierte Boards
• ESP32-C3 Dev Module: Für RISC-V-basierte ESP32-C3 Boards

Wenn du unsicher bist, starte mit dem ESP32 Dev Module. Es funktioniert mit den meisten ESP32-WROOM Boards und ist eine sichere Standardwahl.

ESP32 mit dem Computer verbinden

Verbinde nun den ESP32 mit deinem Computer über ein USB-Kabel. Verwende ein Datenkabel, keine reinen Ladekabel, da diese nicht funktionieren und oft für Verwirrung sorgen. Je nach Board erfolgt die Verbindung über:

• Einen externen USB-zu-Seriell-Wandler (CP210x, CH340, FTDI)
• Natives USB (ESP32-S2, ESP32-S3, ESP32-C3)

Port auswählen

Öffne anschließend Werkzeuge > Port. Nach dem Verbinden sollte ein neuer Port erscheinen.

Typische Portnamen sind:

• COMx unter Windows
• /dev/ttyUSBx oder /dev/ttyACMx unter Linux
• /dev/cu.usbserial-* oder /dev/cu.usbmodem-* unter macOS

Wähle den Port, der deinem ESP32 entspricht. Wenn mehrere Ports angezeigt werden, ziehe das Board ab und beobachte, welcher Port verschwindet. Stecke es wieder ein und wähle den neu erscheinenden Port aus.

Core-Installation testen

Nach Auswahl von Board und Port solltest du überprüfen, ob der ESP32 Core korrekt installiert und funktionsfähig ist. Dieser Schritt bestätigt, dass Toolchain, Board-Definitionen und Upload-Prozess wie erwartet arbeiten.

Test-Sketch öffnen

Starte mit einem bekannten Beispiel. Öffne den klassischen Blink-Sketch:

Datei > Beispiele > 01.Basics > Blink

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
  delay(1000);                      // wait for a second
}

Die meisten ESP32 Boards haben eine eingebaute LED. Die GPIO-Nummer variiert jedoch je nach Board. Wenn die LED später nicht blinkt, musst du möglicherweise die Pin-Definition anpassen. Bei vielen ESP32 Boards ist die eingebaute LED an GPIO 2 angeschlossen:

#define LED_BUILTIN 2

Füge die Definition für LED_BUILTIN oben im Sketch hinzu, falls sie fehlt, und ändere den GPIO bei Bedarf:

#define LED_BUILTIN 2

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH); 
  delay(1000);                      
  digitalWrite(LED_BUILTIN, LOW);  
  delay(1000);                     
}

Sketch kompilieren und hochladen

Klicke auf den Upload Button, um den Sketch auf den ESP32 zu flashen.

Beobachte während des Uploads die Kompilier- und Statusmeldungen unten in der IDE.

Bei manchen Boards musst du die BOOT Taste gedrückt halten, bis der Upload startet. Ein erfolgreicher Upload endet mit einer Meldung wie:

Leaving...
Hard resetting via RTS pin...

Dies zeigt an, dass der ESP32 programmiert und neu gestartet wurde.

Ergebnis überprüfen

Sobald der ESP32 neu startet, beobachte die eingebaute LED:

• Blinkt die LED, ist der ESP32 Core installiert und funktioniert korrekt.
• Passiert nichts, überprüfe nochmals den LED-Pin und die Board-Auswahl.

Serielle Kommunikation testen

Um die Einrichtung weiter zu bestätigen, öffne den Serial Monitor: Stelle die Baudrate auf 115200 ein. Führe dann folgenden Sketch aus, der einmal pro Sekunde „test“ an den Serial Monitor sendet:

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("test");
  delay(1000);
}

Wenn du die Nachrichten im Serial Monitor siehst, funktionieren USB-Kommunikation und ESP32 Core einwandfrei.

Häufige Installationsprobleme

Auch bei korrekter Installation können Probleme mit dem ESP32 Core auftreten. Die meisten Fehler hängen mit Treibern, Board-Einstellungen oder Upload-Konfiguration zusammen. Hier die häufigsten Probleme und deren Lösungen.

ESP32 erscheint nicht unter Ports

Wenn nach dem Verbinden kein Port erscheint, erkennt der Computer das Board nicht. Mögliche Ursachen und Lösungen:

• Installiere den richtigen USB-zu-Seriell-Treiber (CP210x, CH340 oder FTDI).
• Verwende ein bekanntes, datenfähiges USB-Kabel.
• Probiere einen anderen USB-Port am Computer.
• Für ESP32-S2 oder ESP32-S3 Boards aktiviere USB CDC beim Booten und wähle den korrekten USB-Modus.

Starte die Arduino IDE nach der Treiberinstallation neu.

Upload schlägt fehl mit „Timed out waiting for packet header“

Dieser Fehler zeigt, dass der ESP32 nicht in den Flash-Modus gewechselt ist. Versuche:

• Halte die BOOT Taste gedrückt, wenn der Upload startet.
• Reduziere die Upload-Geschwindigkeit auf 115200.
• Überprüfe, ob der richtige Port ausgewählt ist.
• Schließe andere Programme, die denselben seriellen Port verwenden.

Upload schlägt fehl mit „Wrong boot mode detected“

Du musst möglicherweise die BOOT- und RESET-Taste in einer bestimmten Reihenfolge drücken oder einen 1µF-Kondensator zwischen RESET/ENABLE und GND anschließen. Siehe das Wrong boot mode ESP32 Tutorial.

Kompilierfehler im Zusammenhang mit ESP32-Headern

Fehler, die fehlende Dateien wie esp_system.h oder WiFi.hmelden, deuten meist auf ein Core-Installationsproblem hin. Versuche:

• Den ESP32 Core im Boardverwalter neu zu installieren.
• Den ESP32-Paketordner zu löschen und erneut zu installieren.
• Sicherzustellen, dass nur eine ESP32 Core-Version installiert ist.

Sketch wird hochgeladen, läuft aber nicht

Wenn der Upload gelingt, der ESP32 den Sketch aber nicht ausführt, liegt wahrscheinlich ein Konfigurationsproblem vor. Prüfe folgende Einstellungen:

• Flash-Größe stimmt mit der Hardware überein.
• Partition-Schema unterstützt die Größe deines Sketches.
• PSRAM ist nur aktiviert, wenn das Board es besitzt.
• Vor Sketch-Upload gesamten Flash löschen ist für einen sauberen Test aktiviert.

Serial Monitor zeigt unleserliche Zeichen

Unleserliche Zeichen im Serial Monitor deuten meist auf eine falsche Baudrate hin. Stelle die Baudrate des Serial Monitors passend ein, z.B. 115200 oder 9600.

Für ESP32-S2 und ESP32-S3 Boards überprüfe auch, ob USB CDC aktiviert ist.

Board startet ständig neu

Wiederholte Neustarts können auf Strom- oder Konfigurationsprobleme hinweisen. Häufige Ursachen sind:

• Unzureichende Stromversorgung über den USB-Port
• Falsche Flash-Frequenz oder Flash-Modus
• Brownout-Erkennung, die Neustarts auslöst

Versuche einen USB-Hub mit eigener Stromversorgung oder reduziere die CPU-Frequenz.

Kompilierfehler oder Code funktioniert nicht

Manchmal musst du die Version des ESP32 Cores downgraden, da einige Bibliotheken neuere Versionen, speziell 3.x, nicht unterstützen. Üblicherweise ist Version 2.0.17 stabil.

Öffne den BOARDVERWALTER, tippe „esp32“ in die Suchleiste, wähle die Version für den „esp32 by Espressif“ Core und klicke auf „UPDATE“ wie unten gezeigt:

Dies lädt die ausgewählte Core-Version herunter und installiert sie.

Fazit

In diesem Tutorial hast du gelernt, wie du den ESP32 Core für die Arduino IDE installierst. Der Arduino Core vereinfacht die Programmierung, indem er eine benutzerfreundliche Umgebung mit vertrauten Funktionen und Bibliotheken bietet. Er abstrahiert die komplexen Hardware-Details, sodass du dich auf dein Projekt konzentrieren kannst, statt auf Low-Level-Code. Für weitere Informationen schau dir das Espressif Installation Guide an.

Der Hauptvorteil des Arduino Cores ist seine Zugänglichkeit. Anfänger können schnell mit der ESP32-Entwicklung starten, ohne tiefgehende Kenntnisse eingebetteter Systeme. Die große Arduino-Community und umfangreiche Bibliotheksunterstützung erleichtern Fehlersuche und Erweiterungen deiner Projekte.

Außerdem gibt es weitere cores für viele andere Mikroprozessoren, zum Beispiel den ESP8266, STM32 und RP2350. So kannst du eine breite Palette verschiedener Mikroprozessoren in derselben IDE und mit (fast) identischem Code programmieren.

Der Arduino Core hat jedoch auch Einschränkungen. Er bietet möglicherweise nicht alle erweiterten Funktionen der ESP32-Hardware. Performance-Optimierungen und Echtzeitfähigkeiten sind im Vergleich zur nativen ESP32-IDF (Espressif IoT Development Framework) eingeschränkt. Die ESP32-IDF ermöglicht volle Kontrolle über die Chip-Architektur und komplexe, optimierte Anwendungen, erfordert aber eine steilere Lernkurve.

Zusammenfassend: Wähle den Arduino Core, wenn du schnelle Entwicklung, Einfachheit und Community-Support möchtest. Nutze die ESP32-IDF, wenn du maximale Leistung, feinkörnige Kontrolle und Zugriff auf die neuesten ESP32-Funktionen brauchst.

Bei Fragen kannst du sie gerne im Kommentarbereich stellen.

Viel Spaß beim Tüfteln ; )