O FireBeetle 2 ESP32-P4 é uma placa de desenvolvimento baseada no microcontrolador ESP32-P4 da Espressif. Ao contrário dos chips anteriores da série ESP32, o P4 é otimizado como um processador de aplicação de alto desempenho e não integra conectividade sem fios diretamente. Para fornecer capacidade de rede, a placa inclui um ESP32-C6 auxiliar que gere a comunicação Wi-Fi 6 e Bluetooth 5.
O FireBeetle 2 ESP32-P4 integra funcionalidades comuns de desenvolvimento, como programação USB Type-C, um slot para cartão microSD e um microfone PDM a bordo. Expõe uma variedade de pinos GPIO, suporta várias interfaces periféricas e é compatível com os ambientes de desenvolvimento Arduino e ESP-IDF. No entanto, o suporte para o ambiente Arduino ainda está em desenvolvimento e, em setembro de 2025, nem toda a funcionalidade está disponível.
Neste tutorial, vamos abordar algumas das funcionalidades do FireBeetle 2 ESP32-P4 e percorrer exemplos práticos, incluindo controlo de GPIO, acesso ao cartão SD e comunicação Wi-Fi.
Peças Necessárias
Vai precisar de uma placa FireBeetle 2 ESP32-P4, com ou sem a placa de expansão, e de um cabo USB-C para programar a placa e testar os exemplos de código.
Kit de Desenvolvimento AI FireBeetle 2 ESP32-P4
Cabo 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.
A placa FireBeetle 2 ESP32-P4
A placa de desenvolvimento FireBeetle 2 ESP32-P4 é construída em torno do sistema em chip ESP32-P4 da Espressif, que oferece um processador RISC-V dual-core projetado para aplicações embutidas de alto desempenho.
O ESP32-P4 integra um amplo conjunto de interfaces periféricas, incluindo múltiplos canais UART, SPI, I²C, I²S, PWM, ADC e DAC, além de suporte para interfaces MIPI-CSI e MIPI-DSI destinadas à conectividade de câmaras e ecrãs. Nesta placa, o ESP32-P4 está emparelhado com 16 MB de memória flash externa, permitindo armazenamento de aplicações e registo de dados.
Coprocessador
Como o ESP32-P4 não incorpora conectividade sem fios, a placa inclui um processador secundário, o ESP32-C6, que funciona como coprocessador dedicado para comunicação Wi-Fi 6 (802.11ax) e Bluetooth 5.0. O P4 e o C6 estão ligados internamente, permitindo que o processador principal aceda à rede sem fios através de APIs padrão, mantendo os núcleos do P4 totalmente disponíveis para tarefas ao nível da aplicação.
Interfaces
O FireBeetle 2 ESP32-P4 oferece múltiplas opções para interface externa e expansão. Está presente um conector USB Type-C, que oferece USB CDC para programação e depuração, bem como suporte USB OTG 2.0 para interface de dispositivos em alta velocidade. A placa expõe pinos de entrada/saída de uso geral em cabeçalhos duplos. Para aplicações multimédia, inclui conectores dedicados MIPI-CSI e MIPI-DSI, suportando entrada de câmara e saída de ecrã com alta largura de banda. Um slot para cartão microSD está integrado para armazenamento externo, e um microfone digital MEMS PDM a bordo (MSM261DGT003) está disponível para entrada de áudio, ligado através do periférico I²S do P4.
Componentes
Componentes adicionais a bordo incluem um botão de reset, um botão boot/IO35 para entrar em modos de programação, e LEDs de estado para indicação de energia e I/O geral. A circuitaria de regulação de energia permite que a placa seja alimentada pelo conector USB-C ou por fonte externa. A combinação de processamento de alto desempenho, memória externa, interfaces multimédia, conectividade sem fios via coprocessador e periféricos integrados torna o FireBeetle 2 ESP32-P4 uma plataforma de desenvolvimento flexível para aplicações como interfaces homem–máquina, aquisição de dados IoT, processamento multimédia e cargas de trabalho de IA na borda.
Placa de Expansão
Pode adquirir a placa FireBeetle 2 ESP32-P4 com uma Expansion board. A placa de expansão não tem eletrónica adicional, mas expande o número de pinos aos quais pode ligar. A imagem abaixo mostra a placa de expansão no topo e a placa FireBeetle 2 ESP32-P4 real em baixo:
A placa é simplesmente inserida no cabeçalho de pinos duplos no topo da placa de expansão.
Especificações Técnicas
| Característica | Detalhes |
|---|---|
| MCU Principal | Espressif ESP32-P4, RISC-V dual-core, até 400 MHz |
| Coprocessador | Espressif ESP32-C6, Wi-Fi 6 (802.11ax) e Bluetooth 5.0 |
| Memória Flash | 16 MB flash QSPI externa |
| PSRAM | Suportada (depende da variante) |
| USB | USB Type-C, USB CDC para programação e serial, suporte USB 2.0 OTG HS |
| Armazenamento | Slot para cartão MicroSD/TF (interface SDIO) |
| Áudio | Microfone digital PDM MSM261DGT003 a bordo (interface I²S) |
| Interface de Ecrã | Conector MIPI-DSI |
| Interface de Câmara | Conector MIPI-CSI |
| GPIO | Múltiplos pinos de I/O de uso geral expostos em cabeçalhos duplos, lógica 3.3 V |
| Entradas Analógicas | Canais ADC integrados (ESP32-P4) |
| PWM / Temporizadores | Múltiplos canais PWM para controlo de motores ou LEDs |
| Conectividade | Wi-Fi 6, Bluetooth 5.0 (via coprocessador ESP32-C6) |
| Botões | Botão de reset, botão BOOT/IO35 |
| Indicadores | LED de energia, LED programável pelo utilizador (IO3) |
| Tensão de Funcionamento | Lógica 3.3 V (alimentado via USB-C ou fonte externa) |
| Dimensões da Placa | Formato FireBeetle (compatível com outras placas da série FireBeetle) |
A tabela acima resume as especificações técnicas do FireBeetle 2 ESP32-P4; para informações adicionais consulte o Product Page, o Wiki e os esquemas ligados abaixo:
ESP32-P4 versus ESP32-S3
O ESP32-P4 e o ESP32-S3 são ambos membros da família ESP32 da Espressif, mas foram projetados com prioridades diferentes. O ESP32-S3 é um microcontrolador focado em conectividade que integra rádios Wi-Fi e Bluetooth juntamente com um processador dual-core, enquanto o ESP32-P4 é um processador de aplicação de alto desempenho sem conectividade sem fios integrada, destinado a tarefas multimédia e computação intensiva.
ESP32-S3
O ESP32-S3 possui um processador dual-core Xtensa LX7 a até 240 MHz, otimizado para aceleração de IA e tarefas gerais de IoT. Inclui instruções vetoriais para cargas de trabalho de machine learning, Wi-Fi 4 integrado (802.11 b/g/n) e Bluetooth 5 (LE), tornando-o adequado para dispositivos conectados como produtos de casa inteligente, eletrónica vestível e hubs de sensores. O S3 suporta até 512 KB de SRAM interna, PSRAM externa, e tem um conjunto típico de periféricos ESP32 incluindo SPI, I²C, UART, I²S, PWM e ADC. O seu equilíbrio entre conectividade, poder de computação e aceleração de IA faz dele um SoC versátil para aplicações em rede.
ESP32-P4
Em contraste, o ESP32-P4 baseia-se num processador RISC-V dual-core a até 400 MHz, oferecendo um aumento significativo na capacidade de computação bruta comparado ao S3. Ao contrário do S3, não inclui Wi-Fi ou Bluetooth diretamente; em vez disso, placas como o FireBeetle 2 ESP32-P4 emparelham-no com um coprocessador de conectividade dedicado (ex.: ESP32-C6). O P4 foca-se em periféricos de alto desempenho, integrando interfaces não presentes no S3, como MIPI-CSI e MIPI-DSI para aplicações de câmara e ecrã, USB 2.0 OTG com suporte de alta velocidade, e uma seleção mais rica de I/O. Com suporte para memória externa grande e periféricos avançados, o ESP32-P4 é projetado para aplicações como interfaces homem–máquina, dispositivos multimédia, computação na borda e sistemas de visão embutidos.
Resumo
Em resumo, o ESP32-S3 é um SoC centrado em conectividade com recursos moderados de computação e aceleração de IA integrada, mais adequado para dispositivos IoT com Wi-Fi e Bluetooth. O ESP32-P4, por outro lado, é um processador RISC-V de alto desempenho sem wireless nativo, mas com opções avançadas de multimédia e interfaces, direcionado a aplicações que requerem maior capacidade computacional e suporte periférico mais rico, frequentemente com wireless gerido por um coprocessador externo.
| Característica | ESP32-P4 | ESP32-S3 |
|---|---|---|
| Arquitetura CPU | Dual-core RISC-V (RV32IMAC) | Dual-core Xtensa LX7 |
| Frequência Máxima CPU | Até 400 MHz | Até 240 MHz |
| Wireless | Nenhum (coprocessador externo necessário, ex.: ESP32-C6) | Integrado Wi-Fi 4 (802.11 b/g/n) + Bluetooth 5 (LE) |
| SRAM Interna | ~768 KB (configurável, + suporte externo) | 512 KB |
| Memória Externa | Até 32 MB flash, PSRAM opcional (depende da placa) | Até 16 MB flash, PSRAM opcional |
| IA / Aceleração | Extensões DSP gerais RISC-V | Instruções vetoriais para aceleração ML/IA |
| Suporte USB | USB 2.0 OTG (Alta Velocidade 480 Mbps) | USB 1.1 OTG (Velocidade Completa 12 Mbps) |
| Interfaces Multimédia | MIPI-DSI (Ecrã), MIPI-CSI (Câmara) | Interface LCD (paralelo 8/16-bit), sem MIPI |
| Interfaces de Áudio | I²S / PDM, até múltiplos canais | I²S / PDM, até múltiplos canais |
| Outros Periféricos | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO | SPI, I²C, UART, PWM, ADC, DAC, SDIO, GPIO |
| Segurança | AES, SHA, RSA, ECC, HMAC, Secure Boot, TrustZone (PMP) | AES, SHA, RSA, ECC, HMAC, Secure Boot |
| Aplicações Alvo | HMI, multimédia, visão, processamento de áudio, computação na borda | IoT, dispositivos inteligentes, vestíveis, hubs de sensores |
Instalação do Core ESP32
Se este é o seu primeiro projeto com uma placa da série ESP32, precisará instalar primeiro o core ESP32. Se as placas ESP32 já estiverem instaladas no seu Arduino IDE, pode saltar esta secção.
Comece por abrir o diálogo de Preferências selecionando “Preferences…” no menu “File”. Isto abrirá o diálogo de Preferências mostrado abaixo.
Na aba Settings encontrará uma caixa de edição na parte inferior do diálogo rotulada “Additional boards manager URLs“:
Neste campo copie a seguinte URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Isto permitirá que o Arduino IDE saiba onde encontrar as bibliotecas do core ESP32. A seguir, vamos instalar as placas ESP32 usando o Gestor de Placas.
Abra o Gestor de Placas via “Tools -> Boards -> Board Manager”. Verá o Gestor de Placas aparecer na barra lateral esquerda. Digite “ESP32” no campo de pesquisa no topo e deverá ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as placas “esp32 by Espressif”. Queremos as “esp32 libraries by Espressif”. Clique no botão INSTALL e aguarde até que o download e a instalação estejam completos.
Seleção da Placa
Finalmente, precisamos selecionar uma placa ESP32. No caso da placa FireBeetle 2 ESP32-P4, escolhemos o módulo genérico “ESP32P4 Dev Module”. Para isso, clique no menu suspenso e depois em “Select other board and port…”:
Isto abrirá um diálogo onde pode digitar “esp32p4” na barra de pesquisa. Verá a placa “ESP32P4 Dev Module” em Boards. Clique nela e selecione a porta COM para ativá-la e depois clique em OK:
Note que precisa de ligar a placa ao computador via cabo USB antes de poder selecionar uma porta COM. A placa tem duas portas USB. Para programação deve usar a porta no lado curto da placa:
Configurações da Ferramenta
Nas próximas secções encontrará exemplos de código para os vários componentes de hardware da placa e precisará das seguintes configurações para que funcionem. Pode encontrar essas configurações no menu Tools:
Mais importante, o Flash Size está definido para 16MB(128MB), o Partition Scheme está definido para 16M Flash (3MB APP/9.9MB FATFS), e o PSRAM está ativado.
Também precisa definir o USB Mode para Hardware CDC and JTAG, caso contrário a comunicação serial não funcionará e Serial.print() não imprimirá nada no Monitor Serial, por exemplo. As outras configurações devem estar nos valores padrão.
Exemplo de Código: Comunicação Serial
Começamos por testar a comunicação Serial. Abra o seu Arduino IDE, insira o código seguinte e carregue-o para a placa FireBeetle 2 ESP32-P4.
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("test");
delay(5000);
}
Deverá ver o texto “test” impresso no Monitor Serial. Se não, verifique se a taxa de baud está definida para 115200, se o USB Mode está em “Hardware CDC and JTAG” e se o cabo USB está ligado à porta correta:
Exemplo de Código: LED embutido
A placa FireBeetle 2 ESP32-P4 tem um LED embutido ligado ao GPIO 3. O código abaixo é o clássico exemplo Blink que permite testar o funcionamento do LED embutido. Ele liga e desliga o LED a 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);
}
Exemplo de Código: GPIO
Testei o GPIO ligando um LED com um resistor de 220 Ohm ao GPIO 36 e GND conforme mostrado abaixo:
O código seguinte usa PWM (Modulação por Largura de Pulso) para alterar lentamente o brilho do 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);
}
}
De seguida, adicionei um interruptor (SW) entre o GPIO33 e o GND para testar o lado de entrada do GPIO conforme o circuito seguinte:
O código seguinte testa se consegue ligar ou desligar o LED ao acionar o 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);
}
Exemplo de Código: I2C e OLED
Para testar a comunicação I2C, liguei um OLED. Os pinos hardware I2C do FireBeetle 2 ESP32-P4 são SCL=8, SDA=7. Além disso, precisa ligar GND e VCC a 3V3. A foto abaixo mostra a ligação numa breadboard:
O código seguinte inicializa o ecrã e depois imprime o texto “make” no 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 quiser ver mais exemplos de aplicações OLED, dê uma vista de olhos nos nossos How to use the MQ-2 Gas Sensor with Arduino and an OLED, o Spectrum Analyzer with ESP32 and MAX4466 e os TFmini-Plus Distance Sensor with Arduino tutoriais.
Exemplo de Código: Cartão SD
No próximo exemplo vamos testar a interface do cartão SD. Terá de inserir um cartão SD formatado no slot para cartão SD para que este exemplo funcione.
O código seguinte escreve um ficheiro (test.txt) com o texto “Hello from FireBeetle 2” no cartão SD e lê o conteúdo do ficheiro de volta:
#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() { }
A escrita e leitura do cartão SD usam as funções habituais, mas note que tem de ligar a alimentação do cartão SD definindo o GPIO 21 em alto antes de poder usar a interface do cartão SD.
Exemplo de Código: WiFi
No último exemplo testamos o WiFi via o coprocessador ESP32-C6. Felizmente, não precisa fazer nada de especial. O código abaixo abre uma página web no seu computador e mostra o 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();
}
Note que tem de alterar as constantes para o ssid e password mas não é necessária nenhuma configuração especial para usar o coprocessador ESP32-C6.
Conclusões
O FireBeetle 2 ESP32-P4 combina o processador de alto desempenho ESP32-P4 da Espressif com um coprocessador ESP32-C6 para oferecer tanto forte processamento de aplicação como conectividade sem fios moderna. Com a sua grande memória flash, suporte a cartão microSD, microfone PDM a bordo e interfaces dedicadas MIPI-CSI/DSI, a placa destina-se a aplicações de IA e multimédia.
Note que não consegui fazer o microfone PDM a bordo funcionar, o que pode dever-se ao suporte incompleto para o ESP32-P4 no core Arduino atual (3.x). De forma semelhante, não testei as portas CSI e DSI, pois pelo que sei ainda não são suportadas (set 2025). No entanto, funcionam se estiver disposto a usar o ESP-IDF. Veja o tutorial Camera Server Using FireBeetle 2 ESP32P4.
A funcionalidade Bluetooth também não pôde ser testada com sucesso, uma vez que as bibliotecas padrão ArduinoBLE e BluetoothSerial ainda não são compatíveis com o ESP32-P4; embora o BLE seja gerido pelo coprocessador ESP32-C6 a bordo, as APIs necessárias parecem não estar totalmente expostas no core Arduino neste momento.
À medida que o core Arduino para ESP32-P4 amadurecer e mais funcionalidades do ESP-IDF forem expostas, espera-se que periféricos como o microfone PDM, CSI, DSI e BLE se tornem mais fáceis de usar em sketches Arduino.
Se tiver alguma dúvida, sinta-se à vontade para deixá-la na secção de comentários.
Boas experiências a criar 😉
