La FireBeetle 2 ESP32-P4 es una placa de desarrollo diseñada alrededor del microcontrolador ESP32-P4 de Espressif. A diferencia de los chips anteriores de la serie ESP32, el P4 está optimizado como un procesador de aplicaciones de alto rendimiento y no integra conectividad inalámbrica directamente. Para proporcionar capacidad de red, la placa incluye un ESP32-C6 auxiliar que maneja la comunicación Wi-Fi 6 y Bluetooth 5.
La FireBeetle 2 ESP32-P4 integra características comunes de desarrollo como programación USB Tipo-C, una ranura para tarjeta microSD y un micrófono PDM a bordo. Expone una variedad de pines GPIO, soporta diversas interfaces periféricas y es compatible con los entornos de desarrollo Arduino y ESP-IDF. Sin embargo, el soporte para el entorno Arduino aún está en desarrollo y, a septiembre de 2025, no toda la funcionalidad está disponible.
En este tutorial, cubriremos algunas de las características de la FireBeetle 2 ESP32-P4 y realizaremos ejemplos prácticos, incluyendo control de GPIO, acceso a tarjeta SD y comunicación Wi-Fi.
Piezas necesarias
Necesitarás una placa FireBeetle 2 ESP32-P4 con o sin la placa de expansión y un cable USB-C para programar la placa y probar los ejemplos de código.
Kit de desarrollo AI FireBeetle 2 ESP32-P4
Cable USB C
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 placa FireBeetle 2 ESP32-P4
La placa de desarrollo FireBeetle 2 ESP32-P4 está construida alrededor del sistema en chip ESP32-P4 de Espressif, que ofrece un procesador RISC-V de doble núcleo diseñado para aplicaciones embebidas de alto rendimiento.
El ESP32-P4 integra un amplio conjunto de interfaces periféricas, incluyendo múltiples UART, SPI, I²C, I²S, canales PWM, ADC y DAC, junto con soporte para interfaces MIPI-CSI y MIPI-DSI destinadas a conectividad de cámara y pantalla. En esta placa, el ESP32-P4 está acompañado por 16 MB de memoria flash externa, permitiendo tanto almacenamiento de aplicaciones como registro de datos.
Coprocesador
Dado que el ESP32-P4 no incorpora conectividad inalámbrica, la placa incluye un procesador secundario, el ESP32-C6, que funciona como coprocessador dedicado para comunicación Wi-Fi 6 (802.11ax) y Bluetooth 5.0. El P4 y el C6 están conectados internamente, permitiendo que el procesador principal acceda a la red inalámbrica mediante APIs estándar, mientras que los núcleos del P4 quedan completamente disponibles para tareas a nivel de aplicación.
Interfaces
La FireBeetle 2 ESP32-P4 ofrece múltiples opciones para interfaz externa y expansión. Cuenta con un conector USB Tipo-C que ofrece tanto USB CDC para programación y depuración, como soporte USB OTG 2.0 para conexión de dispositivos de alta velocidad. La placa expone pines de entrada/salida de propósito general en conectores dobles. Para aplicaciones multimedia, incluye conectores dedicados MIPI-CSI y MIPI-DSI, que soportan entrada de cámara y salida de pantalla con alto ancho de banda. Integra una ranura para tarjeta microSD para almacenamiento externo y un micrófono digital MEMS PDM a bordo (MSM261DGT003) disponible para entrada de audio, conectado a través del periférico I²S del P4.
Componentes
Los componentes adicionales a bordo incluyen un botón de reset, un botón boot/IO35 para entrar en modos de programación y LEDs de estado para indicación de energía y E/S general. La circuitería de regulación de energía permite alimentar la placa desde el conector USB-C o una fuente externa. La combinación de procesamiento de alto rendimiento, memoria externa, interfaces multimedia, conectividad inalámbrica vía coprocessador y periféricos integrados hace de la FireBeetle 2 ESP32-P4 una plataforma flexible para aplicaciones como interfaces hombre–máquina, adquisición de datos IoT, procesamiento multimedia y cargas de trabajo de IA en el borde.
Placa de expansión
Puedes obtener la placa FireBeetle 2 ESP32-P4 con una Expansion board. La placa de expansión no tiene electrónica adicional pero amplía el número de pines a los que puedes conectar. La imagen a continuación muestra la placa de expansión arriba y la FireBeetle 2 ESP32-P4 real abajo:
La placa se inserta simplemente en el conector doble de pines en la parte superior de la placa de expansión.
Especificaciones técnicas
| Característica | Detalles |
|---|---|
| MCU principal | Espressif ESP32-P4, RISC-V de doble núcleo, hasta 400 MHz |
| Coprocesador | Espressif ESP32-C6, Wi-Fi 6 (802.11ax) y Bluetooth 5.0 |
| Memoria flash | 16 MB flash QSPI externa |
| PSRAM | Soportada (depende de la variante) |
| USB | USB Tipo-C, USB CDC para programación y serial, soporte USB 2.0 OTG HS |
| Almacenamiento | Ranura para tarjeta MicroSD/TF (interfaz SDIO) |
| Audio | Micrófono digital PDM MSM261DGT003 a bordo (interfaz I²S) |
| Interfaz de pantalla | Conector MIPI-DSI |
| Interfaz de cámara | Conector MIPI-CSI |
| GPIO | Múltiples pines de entrada/salida de propósito general expuestos en conectores dobles, lógica de 3.3 V |
| Entradas analógicas | Canales ADC integrados (ESP32-P4) |
| PWM / Temporizadores | Múltiples canales PWM para control de motores o LEDs |
| Conectividad | Wi-Fi 6, Bluetooth 5.0 (vía coprocessador ESP32-C6) |
| Botones | Botón de reset, botón BOOT/IO35 |
| Indicadores | LED de energía, LED programable por usuario (IO3) |
| Voltaje de operación | Lógica de 3.3 V (alimentado vía USB-C o fuente externa) |
| Dimensiones de la placa | Factor de forma FireBeetle (compatible con otras placas de la serie FireBeetle) |
La tabla anterior resume las especificaciones técnicas de la FireBeetle 2 ESP32-P4. Para información adicional, consulta el Product Page, el Wiki y los esquemas enlazados a continuación:
ESP32-P4 versus ESP32-S3
El ESP32-P4 y el ESP32-S3 son ambos miembros de la familia ESP32 de Espressif, pero están diseñados con prioridades diferentes. El ESP32-S3 es un microcontrolador enfocado en conectividad que integra radios Wi-Fi y Bluetooth junto con un procesador de doble núcleo, mientras que el ESP32-P4 es un procesador de aplicaciones de mayor rendimiento sin conectividad inalámbrica integrada, destinado a tareas multimedia y de cómputo intensivo.
ESP32-S3
El ESP32-S3 cuenta con un procesador Xtensa LX7 de doble núcleo que funciona hasta 240 MHz, optimizado para aceleración AI y tareas generales de IoT. Incluye instrucciones vectoriales para cargas de trabajo de aprendizaje automático, Wi-Fi 4 integrado (802.11 b/g/n) y Bluetooth 5 (LE), haciéndolo adecuado para dispositivos conectados como productos para hogares inteligentes, electrónica vestible y concentradores de sensores. El S3 soporta hasta 512 KB de SRAM interna, PSRAM externa y tiene un conjunto típico de periféricos ESP32 incluyendo SPI, I²C, UART, I²S, PWM y ADC. Su equilibrio entre conectividad, potencia de cómputo y aceleración AI lo convierte en un SoC versátil para aplicaciones en red.
ESP32-P4
En contraste, el ESP32-P4 está basado en un procesador RISC-V de doble núcleo que funciona hasta 400 MHz, proporcionando un aumento significativo en capacidad de cómputo bruto comparado con el S3. A diferencia del S3, no incluye Wi-Fi ni Bluetooth directamente; en su lugar, placas como la FireBeetle 2 ESP32-P4 lo emparejan con un coprocessador de conectividad dedicado (por ejemplo, ESP32-C6). El P4 amplía su enfoque hacia periféricos de alto rendimiento, integrando interfaces no presentes en el S3 como MIPI-CSI y MIPI-DSI para aplicaciones de cámara y pantalla, USB 2.0 OTG con soporte de alta velocidad y una selección más amplia de E/S. Con soporte para memoria externa grande y periféricos avanzados, el ESP32-P4 está diseñado para aplicaciones como interfaces hombre–máquina, dispositivos multimedia, computación en el borde y sistemas de visión embebida.
Resumen
En resumen, el ESP32-S3 es un SoC centrado en conectividad con recursos de cómputo moderados y aceleración AI integrada, ideal para dispositivos IoT con Wi-Fi y Bluetooth. Por otro lado, el ESP32-P4 es un procesador RISC-V de mayor rendimiento sin conectividad nativa pero con opciones avanzadas multimedia e interfaces, orientado a aplicaciones que requieren mayor rendimiento computacional y soporte periférico más rico, a menudo con la conectividad inalámbrica manejada por un coprocessador externo.
| Característica | ESP32-P4 | ESP32-S3 |
|---|---|---|
| Arquitectura CPU | Doble núcleo RISC-V (RV32IMAC) | Doble núcleo Xtensa LX7 |
| Frecuencia máxima CPU | Hasta 400 MHz | Hasta 240 MHz |
| Conectividad inalámbrica | Ninguna (se requiere coprocessador externo, p.ej., ESP32-C6) | Integrada Wi-Fi 4 (802.11 b/g/n) + Bluetooth 5 (LE) |
| SRAM interna | ~768 KB (configurable, + soporte externo) | 512 KB |
| Memoria externa | Hasta 32 MB flash, PSRAM opcional (depende de la placa) | Hasta 16 MB flash, PSRAM opcional |
| AI / Aceleración | Extensiones DSP generales RISC-V | Instrucciones vectoriales para aceleración ML/AI |
| Soporte USB | USB 2.0 OTG (Alta velocidad 480 Mbps) | USB 1.1 OTG (Velocidad completa 12 Mbps) |
| Interfaces multimedia | MIPI-DSI (Pantalla), MIPI-CSI (Cámara) | Interfaz LCD (paralelo 8/16 bits), sin MIPI |
| Interfaces de audio | I²S / PDM, hasta múltiples canales | I²S / PDM, hasta múltiples canales |
| Otros periféricos | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO |
| Seguridad | AES, SHA, RSA, ECC, HMAC, Secure Boot, TrustZone (PMP) | AES, SHA, RSA, ECC, HMAC, Secure Boot |
| Aplicaciones objetivo | HMI, multimedia, visión, procesamiento de audio, computación en el borde | IoT, dispositivos inteligentes, wearables, concentradores de sensores |
Instalación del núcleo ESP32
Si este es tu primer proyecto con una placa de la serie ESP32, necesitarás instalar primero el núcleo ESP32. Si ya tienes instaladas placas ESP32 en tu Arduino IDE, puedes saltarte esta sección.
Comienza abriendo el diálogo de Preferencias seleccionando “Preferences…” en el menú “File”. Esto abrirá el diálogo de Preferencias que se muestra a continuación.
En la pestaña Settings encontrarás un cuadro de edición en la parte inferior del diálogo etiquetado como “Additional boards manager URLs”:
En este campo de entrada copia la siguiente URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Esto permitirá que el Arduino IDE sepa dónde encontrar las librerías del núcleo ESP32. A continuación instalaremos las placas ESP32 usando el Gestor de Placas.
Abre el Gestor de Placas vía «Tools -> Boards -> Board Manager». Verás el Gestor de Placas en la barra lateral izquierda. Escribe «ESP32» en el campo de búsqueda en la parte superior y deberías ver dos tipos de placas ESP32; las «Arduino ESP32 Boards» y las placas «esp32 por Espressif». Queremos las librerías «esp32 por Espressif». Haz clic en el botón INSTALL y espera hasta que la descarga e instalación se completen.
Selección de placa
Finalmente, necesitamos seleccionar una placa ESP32. En el caso de la FireBeetle 2 ESP32-P4, elegimos el módulo genérico «ESP32P4 Dev Module». Para ello, haz clic en el menú desplegable y luego en «Select other board and port…»:
Esto abrirá un diálogo donde puedes escribir «esp32p4» en la barra de búsqueda. Verás la placa «ESP32P4 Dev Module» bajo Boards. Haz clic en ella y selecciona el puerto COM para activarla, luego haz clic en OK:
Ten en cuenta que debes conectar la placa mediante el cable USB a tu ordenador antes de poder seleccionar un puerto COM. La placa tiene dos puertos USB. Para programar debes usar el puerto en el lado corto de la placa:
Configuración de herramientas
En las siguientes secciones encontrarás ejemplos de código para los diversos componentes hardware de la placa y necesitarás las siguientes configuraciones para que funcionen. Puedes encontrar estas configuraciones en el menú Tools:
Lo más importante es que Flash Size esté configurado a 16MB(128MB), Partition Scheme a 16M Flash (3MB APP/9.9MB FATFS) y PSRAM esté habilitado.
También debes configurar USB Mode a Hardware CDC and JTAG, de lo contrario la comunicación serial no funcionará y Serial.print() no imprimirá nada en el Monitor Serial, por ejemplo. Las demás configuraciones deben estar en sus valores por defecto.
Ejemplo de código: Comunicación Serial
Comenzamos probando la comunicación Serial. Abre tu Arduino IDE, introduce el siguiente código y súbelo a la placa FireBeetle 2 ESP32-P4.
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("test");
delay(5000);
}
Deberías ver el texto «test» impreso en el Monitor Serial. Si no es así, verifica que la velocidad en baudios esté configurada a 115200, que USB Mode esté en «Hardware CDC and JTAG» y que tu cable USB esté conectado al puerto correcto:
Ejemplo de código: LED incorporado
La placa FireBeetle 2 ESP32-P4 tiene un LED incorporado conectado al GPIO 3. El código a continuación es el clásico ejemplo Blink que te permite probar el funcionamiento del LED incorporado. Enciende y apaga el LED cada segundo:
#define LED_BUILTIN 3
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Ejemplo de código: GPIO
Probé el GPIO conectando un LED con una resistencia de 220 Ohm a GPIO 36 y GND como se muestra a continuación:
El siguiente código usa PWM (Modulación por Ancho de Pulso) para cambiar lentamente el brillo 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);
}
}
Luego, añadí un interruptor (SW) entre GPIO33 y GND para probar la entrada del GPIO como se muestra en el siguiente circuito:
El siguiente código prueba si puedes encender o apagar el LED accionando el interruptor (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);
}
Ejemplo de código: I2C y OLED
Para probar la comunicación I2C conecté un OLED. Los pines hardware I2C de la FireBeetle 2 ESP32-P4 son SCL=8, SDA=7. Además, necesitas conectar GND y VCC a 3V3. La foto a continuación muestra el cableado en una protoboard:
El siguiente código inicializa la pantalla y luego imprime el texto «make» en el 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);
}
Si quieres ver más ejemplos de aplicaciones OLED, echa un vistazo a nuestro How to use the MQ-2 Gas Sensor with Arduino and an OLED, el Spectrum Analyzer with ESP32 and MAX4466 y el TFmini-Plus Distance Sensor with Arduinotutoriales.
Ejemplo de código: Tarjeta SD
En el siguiente ejemplo vamos a probar la interfaz de la tarjeta SD. Deberás insertar una tarjeta SD formateada en la ranura para que este ejemplo funcione.
El siguiente código escribe un archivo (test.txt) con el texto «Hello from FireBeetle 2» en la tarjeta SD y luego lee el contenido del archivo:
#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 escritura y lectura en la tarjeta SD usa las funciones habituales, pero ten en cuenta que debes activar la alimentación para la tarjeta SD configurando GPIO 21 en alto antes de poder usar la interfaz de la tarjeta SD.
Ejemplo de código: WiFi
En el último ejemplo probamos el WiFi a través del coprocessador ESP32-C6. Por suerte, no necesitas hacer nada especial. El código a continuación abre una página web en tu ordenador y muestra el texto «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();
}
Ten en cuenta que debes cambiar las constantes para el ssid y password pero no se requiere configuración especial para usar el coprocessador ESP32-C6.
Conclusiones
La FireBeetle 2 ESP32-P4 combina el procesador de alto rendimiento ESP32-P4 de Espressif con un coprocessador ESP32-C6 para ofrecer tanto un potente procesamiento de aplicaciones como conectividad inalámbrica moderna. Con su gran memoria flash, soporte para tarjeta microSD, micrófono PDM a bordo e interfaces dedicadas MIPI-CSI/DSI, la placa está orientada a aplicaciones de IA y multimedia.
Ten en cuenta que no pude hacer funcionar el micrófono PDM a bordo, lo que puede deberse al soporte incompleto del ESP32-P4 en el núcleo Arduino actual (3.x). De igual forma, no probé los puertos CSI y DSI, ya que hasta donde sé aún no están soportados (septiembre 2025). Sin embargo, funcionan si estás dispuesto a usar ESP-IDF. Consulta el Camera Server Using FireBeetle 2 ESP32P4 tutorial.
La funcionalidad Bluetooth tampoco pudo ser probada con éxito, ya que las librerías estándar ArduinoBLE y BluetoothSerial aún no son compatibles con el ESP32-P4; aunque el BLE es manejado por el coprocessador ESP32-C6 a bordo, las APIs necesarias no están completamente expuestas en el núcleo Arduino por ahora, al parecer.
A medida que el núcleo Arduino para ESP32-P4 madure y se exponga más funcionalidad de ESP-IDF, se espera que periféricos como el micrófono PDM, CSI, DSI y BLE sean más fáciles de usar en sketches Arduino.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje! 😉
