Das FireBeetle 2 ESP32-P4 ist ein Entwicklungsboard, das um den ESP32-P4 Mikrocontroller von Espressif herum entwickelt wurde. Im Gegensatz zu früheren ESP32-Serie-Chips ist der P4 als Hochleistungs-Anwendungsprozessor optimiert und integriert keine drahtlose Konnektivität direkt. Um Netzwerkfähigkeit bereitzustellen, enthält das Board einen zusätzlichen ESP32-C6, der Wi-Fi 6 und Bluetooth 5 Kommunikation übernimmt.
Das FireBeetle 2 ESP32-P4 integriert gängige Entwicklungsfunktionen wie USB Type-C Programmierung, einen microSD-Kartensteckplatz und ein eingebautes PDM-Mikrofon. Es bietet eine Vielzahl von GPIO-Pins, unterstützt verschiedene Peripherieschnittstellen und ist sowohl mit Arduino als auch mit ESP-IDF Entwicklungsumgebungen kompatibel. Die Unterstützung für die Arduino-Umgebung befindet sich jedoch noch in der Entwicklung und ist Stand September 2025 noch nicht vollständig verfügbar.
In diesem Tutorial behandeln wir einige Funktionen des FireBeetle 2 ESP32-P4 und führen praktische Beispiele durch, darunter GPIO-Steuerung, SD-Kartenzugriff und Wi-Fi-Kommunikation.
Benötigte Teile
Du benötigst ein FireBeetle 2 ESP32-P4 Board mit oder ohne Erweiterungsboard sowie ein USB-C-Kabel, um das Board zu programmieren und die Codebeispiele auszuprobieren.
FireBeetle 2 ESP32-P4 AI Development Kit
USB C Kabel
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Das FireBeetle 2 ESP32-P4 Board
Das FireBeetle 2 ESP32-P4 Entwicklungsboard basiert auf dem ESP32-P4 System-on-Chip von Espressif, der einen Dual-Core RISC-V Prozessor für leistungsstarke Embedded-Anwendungen bietet.
Der ESP32-P4 integriert eine breite Palette von Peripherieschnittstellen, darunter mehrere UART, SPI, I²C, I²S, PWM, ADC und DAC Kanäle sowie Unterstützung für MIPI-CSI und MIPI-DSI Schnittstellen, die für Kamera- und Display-Anschlüsse vorgesehen sind. Auf diesem Board ist der ESP32-P4 mit 16 MB externem Flash-Speicher kombiniert, der sowohl für die Anwendungsspeicherung als auch für die Datenprotokollierung genutzt wird.
Koprozessor
Da der ESP32-P4 keine drahtlose Konnektivität integriert, enthält das Board einen sekundären Prozessor, den ESP32-C6, der als dedizierter Koprozessor für Wi-Fi 6 (802.11ax) und Bluetooth 5.0 Kommunikation fungiert. P4 und C6 sind intern verbunden, sodass der Host-Prozessor über Standard-APIs auf die drahtlose Netzwerktechnik zugreifen kann, während die Kerne des P4 vollständig für Anwendungsebene-Aufgaben verfügbar bleiben.
Schnittstellen
Das FireBeetle 2 ESP32-P4 bietet mehrere Optionen für externe Schnittstellen und Erweiterungen. Ein USB Type-C Anschluss ist vorhanden, der sowohl USB CDC für Programmierung und Debugging als auch USB OTG 2.0 Unterstützung für Hochgeschwindigkeits-Geräteanschlüsse bietet. Das Board stellt General-Purpose I/O Pins auf zwei Steckleisten bereit. Für Multimedia-Anwendungen sind dedizierte MIPI-CSI und MIPI-DSI Anschlüsse vorhanden, die Kameraeingang und Displayausgang mit hoher Datenrate unterstützen. Ein microSD-Kartensteckplatz ist für externen Speicher integriert, und ein onboard PDM digitales MEMS-Mikrofon (MSM261DGT003) steht für Audioeingaben zur Verfügung, das über die I²S-Schnittstelle des P4 verbunden ist.
Komponenten
Weitere onboard Komponenten umfassen einen Reset-Knopf, einen Boot/IO35-Knopf zum Aufrufen von Programmiermodi sowie Status-LEDs für Stromversorgung und allgemeine I/O-Anzeige. Die Stromversorgungs-Schaltung ermöglicht die Versorgung des Boards über den USB-C Anschluss oder eine externe Quelle. Die Kombination aus Hochleistungsprozessor, externem Speicher, Multimedia-Schnittstellen, drahtloser Konnektivität über den Koprozessor und integrierten Peripherien macht das FireBeetle 2 ESP32-P4 zu einer flexiblen Entwicklungsplattform für Anwendungen wie Mensch-Maschine-Schnittstellen, IoT-Datenerfassung, Multimedia-Verarbeitung und Edge-AI-Workloads.
Erweiterungsboard
Du kannst das FireBeetle 2 ESP32-P4 Board mit einem Expansion board erhalten. Das Erweiterungsboard enthält keine zusätzliche Elektronik, erweitert aber die Anzahl der anschließbaren Pins. Das Bild unten zeigt das Erweiterungsboard oben und das eigentliche FireBeetle 2 ESP32-P4 Board unten:
Das Board wird einfach in die doppelte Stiftleiste oben auf dem Erweiterungsboard gesteckt.
Technische Spezifikation
| Merkmal | Details |
|---|---|
| Haupt-MCU | Espressif ESP32-P4, Dual-Core RISC-V, bis zu 400 MHz |
| Koprozessor | Espressif ESP32-C6, Wi-Fi 6 (802.11ax) und Bluetooth 5.0 |
| Flash-Speicher | 16 MB externer QSPI-Flash |
| PSRAM | Unterstützt (abhängig von Variante) |
| USB | USB Type-C, USB CDC für Programmierung und seriell, USB 2.0 OTG HS Unterstützung |
| Speicher | MicroSD/TF Kartensteckplatz (SDIO Schnittstelle) |
| Audio | Onboard MSM261DGT003 PDM digitales Mikrofon (I²S Schnittstelle) |
| Display-Schnittstelle | MIPI-DSI Anschluss |
| Kamera-Schnittstelle | MIPI-CSI Anschluss |
| GPIO | Mehrere General-Purpose I/O Pins auf zwei Steckleisten, 3,3 V Logik |
| Analoge Eingänge | Integrierte ADC-Kanäle (ESP32-P4) |
| PWM / Timer | Mehrere PWM-Kanäle für Motor- oder LED-Steuerung |
| Konnektivität | Wi-Fi 6, Bluetooth 5.0 (über ESP32-C6 Koprozessor) |
| Tasten | Reset-Taste, BOOT/IO35-Taste |
| Anzeigeelemente | Power-LED, benutzerprogrammierbare LED (IO3) |
| Betriebsspannung | 3,3 V Logik (versorgt über USB-C oder externe Quelle) |
| Board-Abmessungen | FireBeetle Formfaktor (kompatibel mit anderen FireBeetle Serienboards) |
Die obige Tabelle fasst die technischen Spezifikationen des FireBeetle 2 ESP32-P4 zusammen. Für weitere Informationen siehe das Product Page, das Wiki und die unten verlinkten Schaltpläne:
ESP32-P4 versus ESP32-S3
Der ESP32-P4 und ESP32-S3 sind beide Mitglieder der ESP32-Familie von Espressif, wurden jedoch mit unterschiedlichen Schwerpunkten entwickelt. Der ESP32-S3 ist ein auf Konnektivität fokussierter Mikrocontroller, der Wi-Fi und Bluetooth Radios zusammen mit einem Dual-Core Prozessor integriert, während der ESP32-P4 ein leistungsstärkerer Anwendungsprozessor ohne integrierte drahtlose Schnittstellen ist, der für Multimedia- und rechenintensive Aufgaben gedacht ist.
ESP32-S3
Der ESP32-S3 verfügt über einen Dual-Core Xtensa LX7 Prozessor mit bis zu 240 MHz, optimiert für KI-Beschleunigung und allgemeine IoT-Aufgaben. Er beinhaltet Vektor-Instruktionen für maschinelles Lernen, integriertes Wi-Fi 4 (802.11 b/g/n) und Bluetooth 5 (LE), was ihn geeignet macht für vernetzte Geräte wie Smart-Home-Produkte, Wearables und Sensor-Hubs. Der S3 unterstützt bis zu 512 KB internen SRAM, externes PSRAM und verfügt über eine typische ESP32-Peripherieausstattung mit SPI, I²C, UART, I²S, PWM und ADC. Seine Balance aus Konnektivität, Rechenleistung und KI-Beschleunigung macht ihn zu einem vielseitigen SoC für vernetzte Anwendungen.
ESP32-P4
Im Gegensatz dazu basiert der ESP32-P4 auf einem Dual-Core RISC-V Prozessor mit bis zu 400 MHz, der eine deutlich höhere Rohrechenleistung als der S3 bietet. Im Gegensatz zum S3 integriert er kein Wi-Fi oder Bluetooth direkt; stattdessen werden Boards wie das FireBeetle 2 ESP32-P4 mit einem dedizierten Konnektivitäts-Koprozessor (z.B. ESP32-C6) kombiniert. Der P4 legt seinen Fokus auf Hochleistungsperipherie, integriert Schnittstellen, die der S3 nicht bietet, wie MIPI-CSI und MIPI-DSI für Kamera- und Display-Anwendungen, USB 2.0 OTG mit Hochgeschwindigkeitsunterstützung und eine größere Auswahl an I/O. Mit Unterstützung für großen externen Speicher und fortschrittliche Peripherien ist der ESP32-P4 für Anwendungen wie Mensch-Maschine-Schnittstellen, Multimedia-Geräte, Edge-Computing und eingebettete Vision-Systeme konzipiert.
Zusammenfassung
Zusammenfassend ist der ESP32-S3 ein konnektivitätsorientiertes SoC mit moderaten Rechenressourcen und integrierter KI-Beschleunigung, das sich am besten für Wi-Fi- und Bluetooth-fähige IoT-Geräte eignet. Der ESP32-P4 hingegen ist ein leistungsstärkerer RISC-V Prozessor ohne native drahtlose Schnittstellen, aber mit erweiterten Multimedia- und Schnittstellenoptionen, der Anwendungen anspricht, die mehr Rechenleistung und umfangreichere Peripherieunterstützung benötigen, wobei die drahtlose Kommunikation oft von einem externen Koprozessor übernommen wird.
| Merkmal | ESP32-P4 | ESP32-S3 |
|---|---|---|
| CPU-Architektur | Dual-Core RISC-V (RV32IMAC) | Dual-Core Xtensa LX7 |
| Maximale CPU-Frequenz | Bis zu 400 MHz | Bis zu 240 MHz |
| Drahtlos | Keine (externer Koprozessor erforderlich, z.B. ESP32-C6) | Integriert Wi-Fi 4 (802.11 b/g/n) + Bluetooth 5 (LE) |
| Interner SRAM | ~768 KB (konfigurierbar, + externe Unterstützung) | 512 KB |
| Externer Speicher | Bis zu 32 MB Flash, optional PSRAM (boardabhängig) | Bis zu 16 MB Flash, optional PSRAM |
| KI / Beschleunigung | Allgemeine RISC-V DSP-Erweiterungen | Vektor-Instruktionen für ML/AI-Beschleunigung |
| USB-Unterstützung | USB 2.0 OTG (High-Speed 480 Mbps) | USB 1.1 OTG (Full-Speed 12 Mbps) |
| Multimedia-Schnittstellen | MIPI-DSI (Display), MIPI-CSI (Kamera) | LCD-Schnittstelle (8/16-bit parallel), kein MIPI |
| Audio-Schnittstellen | I²S / PDM, bis zu mehreren Kanälen | I²S / PDM, bis zu mehreren Kanälen |
| Weitere Peripherien | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO |
| Sicherheit | AES, SHA, RSA, ECC, HMAC, Secure Boot, TrustZone (PMP) | AES, SHA, RSA, ECC, HMAC, Secure Boot |
| Zielanwendungen | HMI, Multimedia, Vision, Audioverarbeitung, Edge-Computing | IoT, smarte Geräte, Wearables, Sensor-Hubs |
Installation des ESP32 Core
Wenn dies dein erstes Projekt mit einem Board der ESP32-Serie ist, musst du zuerst den ESP32 Core installieren. Falls ESP32 Boards bereits in deiner Arduino IDE installiert sind, kannst du diesen Abschnitt überspringen.
Öffne zunächst den Preferences-Dialog, indem du im „File“-Menü „Preferences…“ auswählst. Dadurch öffnet sich der unten gezeigte Preferences-Dialog.
Unter dem Reiter Settings findest du unten im Dialog ein Eingabefeld mit der Bezeichnung „Additional boards manager URLs“:
In dieses Eingabefeld kopiere die folgende URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Dies teilt der Arduino IDE mit, wo die ESP32 Core Bibliotheken zu finden sind. Als Nächstes installieren wir die ESP32 Boards über den Boards Manager.
Öffne den Boards Manager über „Tools -> Boards -> Board Manager“. Der Boards Manager erscheint in der linken Seitenleiste. Gib oben im Suchfeld „ESP32“ ein und du solltest zwei Arten von ESP32 Boards sehen; die „Arduino ESP32 Boards“ und die „esp32 von Espressif“ Boards. Wir wollen die „esp32 libraries von Espressif“. Klicke auf die INSTALL Schaltfläche und warte, bis der Download und die Installation abgeschlossen sind.
Board auswählen
Schließlich müssen wir ein ESP32 Board auswählen. Für das FireBeetle 2 ESP32-P4 Board wählen wir das generische „ESP32P4 Dev Module“. Klicke dazu auf das Dropdown-Menü und dann auf „Select other board and port…“:
Es öffnet sich ein Dialog, in dem du „esp32p4“ in die Suchleiste eingibst. Du siehst das Board „ESP32P4 Dev Module“ unter Boards. Klicke darauf, wähle den COM-Port aus, um es zu aktivieren, und klicke dann auf OK:
Beachte, dass du das Board über das USB-Kabel mit deinem Computer verbinden musst, bevor du einen COM-Port auswählen kannst. Das Board hat zwei USB-Ports. Für die Programmierung musst du den Port an der kurzen Seite des Boards verwenden:
Werkzeugeinstellungen
In den nächsten Abschnitten findest du Codebeispiele für die verschiedenen Hardware-Komponenten des Boards. Du benötigst die folgenden Einstellungen, damit sie funktionieren. Diese findest du im Tools-Menü:
Wichtig ist vor allem, dass Flash Size auf 16MB(128MB), Partition Scheme auf 16M Flash (3MB APP/9.9MB FATFS) und PSRAM auf Enabled gesetzt ist.
Du musst außerdem USB Mode auf Hardware CDC and JTAG einstellen, sonst funktioniert die serielle Kommunikation nicht und Serial.print()gibt beispielsweise nichts im Serial Monitor aus. Die anderen Einstellungen sollten die Standardwerte sein.
Codebeispiel: Serielle Kommunikation
Wir beginnen mit dem Test der seriellen Kommunikation. Öffne deine Arduino IDE, gib den folgenden Code ein und lade ihn auf das FireBeetle 2 ESP32-P4 Board hoch.
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("test");
delay(5000);
}
Du solltest den Text „test“ im Serial Monitor sehen. Falls nicht, überprüfe, ob die Baudrate auf 115200 eingestellt ist, USB Mode auf „Hardware CDC and JTAG“ steht und dein USB-Kabel am richtigen Port angeschlossen ist:
Codebeispiel: Eingebaute LED
Das FireBeetle 2 ESP32-P4 Board hat eine eingebaute LED, die an GPIO 3 angeschlossen ist. Der folgende Code ist das klassische Blink-Beispiel, mit dem du die Funktion der eingebauten LED testen kannst. Die LED wird jede Sekunde ein- und ausgeschaltet:
#define LED_BUILTIN 3
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Codebeispiel: GPIO
Ich habe die GPIO getestet, indem ich eine LED mit einem 220-Ohm-Widerstand an GPIO 36 und GND angeschlossen habe, wie unten gezeigt:
Der folgende Code verwendet PWM (Pulsweitenmodulation), um die Helligkeit der LED langsam zu verändern:
#define LED_PIN 36
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
for (int b = 0; b < 255; b++) {
analogWrite(LED_PIN, b);
delay(10);
}
}
Anschließend habe ich einen Schalter (SW) zwischen GPIO33 und GND hinzugefügt, um die Eingangsseite der GPIO zu testen, wie im folgenden Schaltbild gezeigt:
Der folgende Code prüft, ob du die LED durch Betätigen des Schalters (SW) ein- oder ausschalten kannst:
#define BUTTON_PIN 33
#define LED_PIN 36
void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(LED_PIN, OUTPUT);
}
void loop() {
int state = digitalRead(BUTTON_PIN);
if (state == LOW) {
digitalWrite(LED_PIN, LOW);
} else {
digitalWrite(LED_PIN, HIGH);
}
delay(100);
}
Codebeispiel: I2C und OLED
Um die I2C-Kommunikation zu testen, habe ich ein OLED angeschlossen. Die Hardware-I2C-Pins des FireBeetle 2 ESP32-P4 sind SCL=8, SDA=7. Zusätzlich musst du GND und VCC mit 3V3 verbinden. Das Foto unten zeigt die Verdrahtung auf einem Breadboard:
Der folgende Code initialisiert das Display und gibt dann den Text „make“ auf dem OLED aus:
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(4);
oled.setTextColor(WHITE);
}
void loop() {
oled.clearDisplay();
oled.setCursor(20, 16);
oled.print("make");
oled.display();
delay(1000);
}
Wenn du mehr Beispiele für OLED-Anwendungen sehen möchtest, schau dir unser How to use the MQ-2 Gas Sensor with Arduino and an OLED, das Spectrum Analyzer with ESP32 and MAX4466 und das TFmini-Plus Distance Sensor with Arduino Tutorials an.
Codebeispiel: SD-Karte
Im nächsten Beispiel testen wir die SD-Karten-Schnittstelle. Du musst eine formatierte SD-Karte in den SD-Kartensteckplatz einlegen, damit dieses Beispiel funktioniert.
Der folgende Code schreibt eine Datei (test.txt) mit dem Text „Hello from FireBeetle 2“ auf die SD-Karte und liest den Inhalt der Datei wieder aus:
#include "FS.h"
#include "SD_MMC.h"
#define SD_POWER 21 // SD1_PWRN
void setup() {
Serial.begin(115200);
delay(1000);
// Enable SD card power
pinMode(SD_POWER, OUTPUT);
digitalWrite(SD_POWER, HIGH);
delay(10);
Serial.println("Mounting SD card...");
if (!SD_MMC.begin("/sdcard", true)) { // true = 1-bit mode if needed
Serial.println("Card Mount Failed");
return;
}
uint8_t cardType = SD_MMC.cardType();
if (cardType == CARD_NONE) {
Serial.println("No SD card attached");
return;
}
Serial.println("SD card mounted");
// ---- Write test ----
File file = SD_MMC.open("/test.txt", FILE_WRITE);
if (!file) {
Serial.println("Failed to open file for writing");
return;
}
file.println("Hello from FireBeetle 2");
file.close();
Serial.println("Write finished.");
// ---- Read back ----
file = SD_MMC.open("/test.txt");
if (!file) {
Serial.println("Failed to open file for reading");
return;
}
Serial.println("Reading file contents:");
while (file.available()) {
Serial.write(file.read()); // print byte by byte
}
file.close();
Serial.println("\nRead finished.");
}
void loop() { }
Das Schreiben und Lesen von der SD-Karte erfolgt mit den üblichen Funktionen, aber beachte, dass du die Stromversorgung für die SD-Karte einschalten musst, indem du GPIO 21 auf High setzt, bevor du die SD-Karten-Schnittstelle verwenden kannst.
Codebeispiel: WiFi
Im letzten Beispiel testen wir das WiFi über den ESP32-C6 Koprozessor. Glücklicherweise musst du nichts Besonderes tun. Der folgende Code öffnet eine Webseite auf deinem Computer und zeigt den Text „Hello from FireBeetle“ an:
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "SSID";
const char* password = "PASSWORD";
WebServer server(80);
void handleRoot() {
server.send(200, "text/html",
"<h1>Hello from FireBeetle</h1>");
}
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("ESP32-P4 Web Server test");
WiFi.begin(ssid, password);
Serial.printf("Connecting to %s", ssid);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected!");
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
server.on("/", handleRoot);
server.begin();
Serial.println("Open the IP above in your browser.");
}
void loop() {
server.handleClient();
}
Beachte, dass du die Konstanten für ssid und password ändern musst, aber es ist keine spezielle Konfiguration für die Nutzung des ESP32-C6 Koprozessors erforderlich.
Fazit
Das FireBeetle 2 ESP32-P4 kombiniert Espressifs leistungsstarken ESP32-P4 Prozessor mit einem ESP32-C6 Koprozessor, um sowohl starke Anwendungsprozessorleistung als auch moderne drahtlose Konnektivität zu bieten. Mit seinem großen Flash-Speicher, microSD-Kartenunterstützung, onboard PDM-Mikrofon und dedizierten MIPI-CSI/DSI Schnittstellen richtet sich das Board an KI- und Multimedia-Anwendungen.
Beachte, dass ich das onboard PDM-Mikrofon nicht zum Laufen bringen konnte, was an unvollständiger Unterstützung des ESP32-P4 im aktuellen Arduino Core (3.x) liegen kann. Ebenso habe ich die CSI- und DSI-Ports nicht getestet, da sie meines Wissens noch nicht unterstützt werden (Stand Sep 2025). Sie funktionieren jedoch, wenn du ESP-IDF verwenden möchtest. Siehe das Camera Server Using FireBeetle 2 ESP32P4 Tutorial.
Die Bluetooth-Funktionalität konnte ebenfalls nicht erfolgreich getestet werden, da die Standardbibliotheken ArduinoBLE und BluetoothSerial noch nicht mit dem ESP32-P4 kompatibel sind; obwohl BLE vom onboard ESP32-C6 Koprozessor gehandhabt wird, sind die notwendigen APIs im Arduino Core derzeit offenbar noch nicht vollständig verfügbar.
Mit der Weiterentwicklung des Arduino Cores für ESP32-P4 und der Freigabe weiterer ESP-IDF-Funktionalitäten wird erwartet, dass Peripherien wie das PDM-Mikrofon, CSI, DSI und BLE in Arduino-Sketches leichter nutzbar werden.
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln 😉
