Iniziare con la scheda FireBeetle 2 ESP32-P4

La FireBeetle 2 ESP32-P4 è una scheda di sviluppo basata sul microcontrollore ESP32-P4 di Espressif. A differenza dei precedenti chip della serie ESP32, il P4 è ottimizzato come processore applicativo ad alte prestazioni e non integra direttamente la connettività wireless. Per fornire la capacità di rete, la scheda include un ESP32-C6 ausiliario che gestisce la comunicazione Wi-Fi 6 e Bluetooth 5.

La FireBeetle 2 ESP32-P4 integra funzionalità comuni per lo sviluppo come la programmazione USB Type-C, uno slot per schede microSD e un microfono PDM integrato. Espone una serie di pin GPIO, supporta varie interfacce periferiche ed è compatibile sia con gli ambienti di sviluppo Arduino che ESP-IDF. Tuttavia, il supporto per l’ambiente Arduino è ancora in fase di sviluppo e a settembre 2025 non tutte le funzionalità sono ancora disponibili.

In questo tutorial copriremo alcune delle caratteristiche della FireBeetle 2 ESP32-P4 e vedremo esempi pratici, inclusi il controllo GPIO, l’accesso alla scheda SD e la comunicazione Wi-Fi.

Parti Necessarie

Avrai bisogno di una scheda FireBeetle 2 ESP32-P4 con o senza la scheda di espansione e di un cavo USB-C per programmare la scheda e provare gli esempi di codice.

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.

La scheda FireBeetle 2 ESP32-P4

La scheda di sviluppo FireBeetle 2 ESP32-P4 è costruita attorno al system-on-chip ESP32-P4 di Espressif, che offre un processore dual-core RISC-V progettato per applicazioni embedded ad alte prestazioni.

L’ESP32-P4 integra un ampio set di interfacce periferiche, inclusi molteplici canali UART, SPI, I²C, I²S, PWM, ADC e DAC, oltre al supporto per interfacce MIPI-CSI e MIPI-DSI destinate alla connettività di telecamere e display. Su questa scheda, l’ESP32-P4 è abbinato a 16 MB di memoria flash esterna, che consente sia l’archiviazione delle applicazioni che il logging dei dati.

Coprocessore

Poiché l’ESP32-P4 non incorpora la connettività wireless, la scheda include un processore secondario, l’ESP32-C6, che funziona come coprocessore dedicato per la comunicazione Wi-Fi 6 (802.11ax) e Bluetooth 5.0. Il P4 e il C6 sono collegati internamente, permettendo al processore host di accedere alla rete wireless tramite API standard, lasciando i core del P4 completamente disponibili per i compiti a livello applicativo.

Interfacce

La FireBeetle 2 ESP32-P4 offre molteplici opzioni per l’interfacciamento esterno e l’espansione. È presente un connettore USB Type-C che offre sia USB CDC per programmazione e debug, sia supporto USB OTG 2.0 per interfacciamenti ad alta velocità. La scheda espone pin di I/O generici su due header doppi. Per applicazioni multimediali, la scheda include connettori dedicati MIPI-CSI e MIPI-DSI, supportando input da telecamera e output su display con elevata larghezza di banda. È integrato uno slot per schede microSD per l’archiviazione esterna, e un microfono digitale MEMS PDM (MSM261DGT003) è disponibile per l’ingresso audio, collegato tramite la periferica I²S del P4.

Componenti

Altri componenti a bordo includono un pulsante di reset, un pulsante boot/IO35 per entrare in modalità programmazione e LED di stato per indicazione di alimentazione e I/O generali. Il circuito di regolazione dell’alimentazione permette di alimentare la scheda tramite il connettore USB-C o una fonte esterna. La combinazione di elaborazione ad alte prestazioni, memoria esterna, interfacce multimediali, connettività wireless tramite coprocessore e periferiche integrate rende la FireBeetle 2 ESP32-P4 una piattaforma di sviluppo flessibile per applicazioni come interfacce uomo-macchina, acquisizione dati IoT, elaborazione multimediale e carichi di lavoro AI edge.

Scheda di Espansione

Puoi ottenere la scheda FireBeetle 2 ESP32-P4 con una Expansion board. La scheda di espansione non ha elettronica aggiuntiva ma amplia il numero di pin a cui puoi collegarti. L’immagine sotto mostra la scheda di espansione in alto e la FireBeetle 2 ESP32-P4 vera e propria in basso:

La scheda si inserisce semplicemente nell’header a doppia fila in cima alla scheda di espansione.

Specifiche Tecniche

Caratteristica	Dettagli
MCU Principale	Espressif ESP32-P4, dual-core RISC-V, fino a 400 MHz
Coprocessore	Espressif ESP32-C6, Wi-Fi 6 (802.11ax) e Bluetooth 5.0
Memoria Flash	16 MB flash QSPI esterna
PSRAM	Supportata (dipende dalla variante)
USB	USB Type-C, USB CDC per programmazione e seriale, supporto USB 2.0 OTG HS
Archiviazione	Slot per schede MicroSD/TF (interfaccia SDIO)
Audio	Microfono digitale PDM MSM261DGT003 integrato (interfaccia I²S)
Interfaccia Display	Connettore MIPI-DSI
Interfaccia Telecamera	Connettore MIPI-CSI
GPIO	Molteplici pin di I/O generici esposti su header doppi, logica a 3.3 V
Ingressi Analogici	Canali ADC integrati (ESP32-P4)
PWM / Timer	Molteplici canali PWM per controllo motori o LED
Connettività	Wi-Fi 6, Bluetooth 5.0 (tramite coprocessore ESP32-C6)
Pulsanti	Pulsante di reset, pulsante BOOT/IO35
Indicatori	LED di alimentazione, LED programmabile dall’utente (IO3)
Tensione di Funzionamento	Logica a 3.3 V (alimentata via USB-C o fonte esterna)
Dimensioni della Scheda	Formato FireBeetle (compatibile con altre schede della serie FireBeetle)

La tabella sopra riassume le specifiche tecniche della FireBeetle 2 ESP32-P4; per ulteriori informazioni consulta il Product Page, il Wiki e gli schemi collegati di seguito:

ESP32-P4 versus ESP32-S3

L’ESP32-P4 e l’ESP32-S3 sono entrambi membri della famiglia ESP32 di Espressif, ma sono progettati con priorità diverse. L’ESP32-S3 è un microcontrollore focalizzato sulla connettività che integra radio Wi-Fi e Bluetooth insieme a un processore dual-core, mentre l’ESP32-P4 è un processore applicativo ad alte prestazioni senza wireless integrato, destinato a compiti multimediali e computazionali intensivi.

ESP32-S3

L’ESP32-S3 dispone di un processore dual-core Xtensa LX7 che opera fino a 240 MHz, ottimizzato per l’accelerazione AI e compiti IoT generali. Include istruzioni vettoriali per carichi di lavoro di machine learning, Wi-Fi 4 integrato (802.11 b/g/n) e Bluetooth 5 (LE), rendendolo adatto a dispositivi connessi come prodotti per la casa intelligente, elettronica indossabile e hub di sensori. L’S3 supporta fino a 512 KB di SRAM interna, PSRAM esterna e ha un set tipico di periferiche ESP32 tra cui SPI, I²C, UART, I²S, PWM e ADC. Il suo equilibrio tra connettività, potenza di calcolo e accelerazione AI lo rende un SoC versatile per applicazioni in rete.

ESP32-P4

Al contrario, l’ESP32-P4 si basa su un processore dual-core RISC-V che opera fino a 400 MHz, offrendo un significativo aumento della capacità di calcolo grezzo rispetto all’S3. A differenza dell’S3, non include Wi-Fi o Bluetooth direttamente; invece, schede come la FireBeetle 2 ESP32-P4 lo abbinano a un coprocessore di connettività dedicato (es. ESP32-C6). Il P4 amplia il suo focus verso periferiche ad alte prestazioni, integrando interfacce non presenti sull’S3 come MIPI-CSI e MIPI-DSI per applicazioni di telecamere e display, USB 2.0 OTG con supporto ad alta velocità e una selezione più ricca di I/O. Con supporto per memoria esterna ampia e periferiche avanzate, l’ESP32-P4 è progettato per applicazioni come interfacce uomo-macchina, dispositivi multimediali, edge computing e sistemi di visione embedded.

Riepilogo

In sintesi, l’ESP32-S3 è un SoC incentrato sulla connettività con risorse di calcolo moderate e accelerazione AI integrata, ideale per dispositivi IoT con Wi-Fi e Bluetooth. L’ESP32-P4, invece, è un processore RISC-V ad alte prestazioni senza wireless nativo ma con opzioni multimediali e di interfaccia avanzate, destinato ad applicazioni che richiedono maggiore potenza di calcolo e supporto periferico più ricco, spesso con wireless gestito da un coprocessore esterno.

Caratteristica	ESP32-P4	ESP32-S3
Architettura CPU	Dual-core RISC-V (RV32IMAC)	Dual-core Xtensa LX7
Frequenza Massima CPU	Fino a 400 MHz	Fino a 240 MHz
Wireless	Nessuno (coprocessore esterno richiesto, es. ESP32-C6)	Integrato Wi-Fi 4 (802.11 b/g/n) + Bluetooth 5 (LE)
SRAM Interna	~768 KB (configurabile, + supporto esterno)	512 KB
Memoria Esterna	Fino a 32 MB flash, PSRAM opzionale (dipende dalla scheda)	Fino a 16 MB flash, PSRAM opzionale
AI / Accelerazione	Estensioni DSP generali RISC-V	Istruzioni vettoriali per accelerazione ML/AI
Supporto USB	USB 2.0 OTG (High-Speed 480 Mbps)	USB 1.1 OTG (Full-Speed 12 Mbps)
Interfacce Multimediali	MIPI-DSI (Display), MIPI-CSI (Camera)	Interfaccia LCD (parallela 8/16 bit), senza MIPI
Interfacce Audio	I²S / PDM, fino a più canali	I²S / PDM, fino a più canali
Altre Periferiche	SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO	SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO
Sicurezza	AES, SHA, RSA, ECC, HMAC, Secure Boot, TrustZone (PMP)	AES, SHA, RSA, ECC, HMAC, Secure Boot
Applicazioni Target	HMI, multimedia, visione, elaborazione audio, edge computing	IoT, dispositivi smart, indossabili, hub di sensori

Installazione del Core ESP32

Se questo è il tuo primo progetto con una scheda della serie ESP32, dovrai prima installare il core ESP32. Se le schede ESP32 sono già installate nel tuo Arduino IDE, puoi saltare questa sezione.

Inizia aprendo la finestra Preferenze selezionando “Preferences…” dal menu “File”. Si aprirà la finestra Preferenze mostrata sotto.

Nella scheda Settings troverai una casella di modifica in fondo alla finestra etichettata “Additional boards manager URLs“:

In questo campo incolla il seguente URL:

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

Questo permetterà all’Arduino IDE di sapere dove trovare le librerie core ESP32. Successivamente installeremo le schede ESP32 usando il Boards Manager.

Apri il Boards Manager tramite “Tools -> Boards -> Board Manager”. Vedrai il Boards Manager apparire nella barra laterale sinistra. Inserisci “ESP32” nel campo di ricerca in alto e dovresti vedere due tipi di schede ESP32; le “Arduino ESP32 Boards” e le schede “esp32 by Espressif”. Noi vogliamo le “esp32 libraries by Espressif”. Clicca sul pulsante INSTALL e attendi che il download e l’installazione siano completati.

Selezione della Scheda

Infine dobbiamo selezionare una scheda ESP32. Nel caso della FireBeetle 2 ESP32-P4, scegliamo il generico “ESP32P4 Dev Module”. Per farlo, clicca sul menu a tendina e poi su “Select other board and port…”:

Si aprirà una finestra dove puoi inserire “esp32p4” nella barra di ricerca. Vedrai la scheda “ESP32P4 Dev Module” sotto Boards. Cliccaci sopra, seleziona la porta COM per attivarla e poi clicca OK:

Nota che devi collegare la scheda tramite cavo USB al computer prima di poter selezionare una porta COM. La scheda ha due porte USB. Per la programmazione devi usare la porta sul lato corto della scheda:

Impostazioni Strumenti

Nelle sezioni successive troverai esempi di codice per i vari componenti hardware della scheda e avrai bisogno delle seguenti impostazioni per farli funzionare. Puoi trovare queste impostazioni nel menu Tools:

Soprattutto, Flash Size è impostato su 16MB(128MB), Partition Scheme su 16M Flash (3MB APP/9.9MB FATFS), PSRAM su Enabled.

Devi anche impostare USB Mode su Hardware CDC and JTAG, altrimenti la comunicazione seriale non funzionerà e Serial.print() non stamperà nulla sul Serial Monitor, per esempio. Le altre impostazioni dovrebbero essere quelle di default.

Esempio di Codice: Comunicazione Serial

Iniziamo testando la comunicazione seriale. Apri il tuo Arduino IDE, inserisci il seguente codice e caricalo sulla scheda FireBeetle 2 ESP32-P4.

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

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

Dovresti vedere il testo “test” stampato sul Serial Monitor. In caso contrario, verifica che la velocità di trasmissione sia impostata a 115200, che USB Mode sia impostato su “Hardware CDC and JTAG” e che il cavo USB sia collegato alla porta corretta:

Esempio di Codice: LED integrato

La scheda FireBeetle 2 ESP32-P4 ha un LED integrato collegato al GPIO 3. Il codice seguente è il classico esempio Blink che ti permette di testare il funzionamento del LED integrato. Accende e spegne il LED ogni secondo:

#define LED_BUILTIN 3

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

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

Esempio di Codice: GPIO

Ho testato il GPIO collegando un LED con una resistenza da 220 Ohm al GPIO 36 e GND come mostrato sotto:

Il codice seguente usa il PWM (Pulse Width Modulation) per cambiare lentamente la luminosità del LED:

#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);
  }
}

Successivamente, ho aggiunto un interruttore (SW) tra GPIO33 e GND per testare l’ingresso del GPIO come mostrato nel circuito seguente:

Il codice seguente verifica se puoi accendere o spegnere il LED azionando l’interruttore (SW):

#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);
}

Esempio di Codice: I2C e OLED

Per testare la comunicazione I2C ho collegato un OLED. I pin hardware I2C della FireBeetle 2 ESP32-P4 sono SCL=8, SDA=7. Inoltre devi collegare GND e VCC a 3V3. La foto sotto mostra il cablaggio su una breadboard:

Il codice seguente inizializza il display e poi stampa il testo “make” sull’OLED:

#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);
}

Se vuoi vedere altri esempi di applicazioni OLED dai un’occhiata ai nostri How to use the MQ-2 Gas Sensor with Arduino and an OLED, al Spectrum Analyzer with ESP32 and MAX4466 e al TFmini-Plus Distance Sensor with Arduino tutorial.

Esempio di Codice: Scheda SD

Nel prossimo esempio testeremo l’interfaccia della scheda SD. Dovrai inserire una scheda SD formattata nello slot per schede SD perché questo esempio funzioni.

Il codice seguente scrive un file (test.txt) con il testo “Hello from FireBeetle 2” sulla scheda SD e legge il contenuto del file:

#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() { }

La scrittura e la lettura dalla scheda SD usano le funzioni usuali, ma devi accendere l’alimentazione per la scheda SD impostando GPIO 21 alto prima di poter usare l’interfaccia della scheda SD.

Esempio di Codice: WiFi

Nell’ultimo esempio testiamo il WiFi tramite il coprocessore ESP32-C6. Fortunatamente, non devi fare nulla di speciale. Il codice sotto apre una pagina web sul tuo computer e mostra il testo “Hello from FireBeetle”:

#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();
}

Nota che devi cambiare le costanti per il ssid e il password ma non è richiesta alcuna configurazione speciale per usare il coprocessore ESP32-C6.

Conclusioni

La FireBeetle 2 ESP32-P4 combina il processore ad alte prestazioni ESP32-P4 di Espressif con un coprocessore ESP32-C6 per offrire sia una forte capacità di elaborazione applicativa che una connettività wireless moderna. Con la sua ampia memoria flash, il supporto per schede microSD, il microfono PDM integrato e le interfacce dedicate MIPI-CSI/DSI, la scheda è pensata per applicazioni AI e multimediali.

Nota che non sono riuscito a far funzionare il microfono PDM integrato, probabilmente a causa del supporto incompleto per l’ESP32-P4 nell’attuale core Arduino (3.x). Allo stesso modo, non ho provato le porte CSI e DSI, poiché a quanto ne so non sono ancora supportate (settembre 2025). Tuttavia, funzionano se sei disposto a usare ESP-IDF. Vedi il tutorial Camera Server Using FireBeetle 2 ESP32P4.

Anche la funzionalità Bluetooth non è stata testata con successo, poiché le librerie standard ArduinoBLE e BluetoothSerial non sono ancora compatibili con l’ESP32-P4; sebbene il BLE sia gestito dal coprocessore ESP32-C6 integrato, le API necessarie non sono ancora completamente esposte nel core Arduino al momento.

Man mano che il core Arduino per ESP32-P4 maturerà e più funzionalità di ESP-IDF saranno esposte, si prevede che periferiche come il microfono PDM, CSI, DSI e BLE diventeranno più facili da usare negli sketch Arduino.

Se hai domande, sentiti libero di lasciarle nella sezione commenti.

Buon divertimento con il tinkering 😉