Guia do ESP32-S3 DevKitC: N16R8, duas portas USB, PSRAM e Arduino IDE
Guia do ESP32-S3 DevKitC: o que significam N16R8 e N8R2, porta UART vs USB, USB CDC On Boot, PSRAM OPI, o LED RGB do GPIO48, ajustes da Arduino IDE e USB HID.
O ESP32-S3 é o chip dual-core da Espressif com Wi-Fi e Bluetooth, turbinado com USB nativo, mais pinos, PSRAM grande e instruções vetoriais que aceleram tarefas de IA. A placa que você mais vai ver é a ESP32-S3-DevKitC-1 e os clones dela: ela traz duas portas USB-C, um botão BOOT, um RST e um único LED RGB endereçável. Códigos como N16R8 ou N8R2 na placa ou no módulo dizem o tamanho da memória flash e da PSRAM, e são a chave para acertar os ajustes da Arduino IDE.
Neste guia você vai aprender em que o ESP32-S3 difere do ESP32 clássico, o que significam os códigos de modelo, qual das duas portas USB usar e quando, o ajuste USB CDC On Boot que resolve o Monitor Serial vazio e como escolher o modo de PSRAM certo (OPI ou QSPI). Depois você vai escrever um sketch de teste que acende o LED RGB da placa, um exemplo que aloca um buffer de 1 MB na PSRAM e um projeto HID que faz o ESP32-S3 aparecer no computador como um teclado USB.
O que é o ESP32-S3? Diferenças em relação ao ESP32 clássico
O ESP32-S3 não foi feito para substituir o ESP32 clássico, e sim para preencher as lacunas que ele deixou. A maior diferença é o USB nativo: o chip se conecta direto ao computador sem conversor USB-serial no meio e pode se apresentar como porta serial, teclado, mouse ou dispositivo MIDI. Os núcleos Xtensa LX7 trazem instruções vetoriais para processamento de sinais e cálculos de redes neurais, e as interfaces dedicadas de câmera (DVP) e de LCD paralelo facilitam projetos de imagem. Mas faltam duas coisas: não há Bluetooth Classic (só Bluetooth 5 LE) e não há DAC para saída analógica.
| Característica | ESP32 (clássico) | ESP32-S3 |
|---|---|---|
| Processador | Xtensa LX6, dual-core, 240 MHz | Xtensa LX7, dual-core, 240 MHz, instruções vetoriais |
| SRAM interna | 520 KB | 512 KB |
| PSRAM | Até 4 MB nos módulos WROVER | 2 MB Quad ou 8 MB Octal, conforme o módulo |
| Bluetooth | Classic e BLE 4.2 | Só BLE 5 (com suporte a longo alcance) |
| USB | Nenhum, precisa de um chip USB-serial separado | USB OTG nativo e USB Serial/JTAG |
| GPIO utilizáveis | Cerca de 34 | 45 |
| Pinos de toque | 10 | 14 |
| DAC (saída analógica) | 2 canais, 8 bits | Nenhum |
| Interface de câmera e display | Câmera via I2S (ESP32-CAM) | Interface DVP de câmera e LCD paralelo dedicadas |

Códigos de modelo do ESP32-S3: o que significa N16R8?
O código na blindagem metálica do módulo ou no anúncio do vendedor é fácil de ler: o número depois do N é o tamanho da flash e o número depois do R é o tamanho da PSRAM, ambos em megabytes. N16R8 significa 16 MB de flash e 8 MB de PSRAM; N8R2 significa 8 MB de flash e 2 MB de PSRAM. O código também diz como a PSRAM está ligada: nos módulos ESP32-S3-WROOM-1, R2 é PSRAM Quad SPI (QSPI) de quatro linhas e R8 é PSRAM Octal SPI (OPI) de oito linhas. Um V no fim (como em N32R8V) indica módulos WROOM-2 cuja flash e PSRAM trabalham em 1,8 V. Você escolhe o ajuste de PSRAM na Arduino IDE com base nessa informação.
| Código | Flash | PSRAM | Ajuste de PSRAM na Arduino IDE |
|---|---|---|---|
| N8 | 8 MB | Nenhuma | Disabled |
| N16 | 16 MB | Nenhuma | Disabled |
| N4R2 | 4 MB | 2 MB Quad (QSPI) | QSPI PSRAM |
| N8R2 | 8 MB | 2 MB Quad (QSPI) | QSPI PSRAM |
| N8R8 | 8 MB | 8 MB Octal (OPI) | OPI PSRAM |
| N16R8 | 16 MB | 8 MB Octal (OPI) | OPI PSRAM |
| N32R8V (WROOM-2) | 32 MB Octal, 1,8 V | 8 MB Octal (OPI) | OPI PSRAM e Flash Mode: OPI 80MHz |
Duas portas USB: UART vs USB
As duas portas USB-C do ESP32-S3-DevKitC-1 não fazem o mesmo trabalho. A porta marcada UART (COM em alguns clones) vai a um chip USB-serial, um CP2102N ou um CH343P conforme a revisão da placa, que por sua vez se liga às linhas UART0 do ESP32-S3 (GPIO 43 e 44). Ela é igual à única porta das placas ESP32 clássicas e coloca a placa em modo de download automaticamente nos uploads. A porta marcada USB é ligada direto aos GPIO 19 (D-) e GPIO 20 (D+) do chip. Conecte nela e o computador enxerga o próprio periférico USB do ESP32-S3, sem chip no meio; Windows 10 e 11, macOS e Linux não precisam de driver.
| Característica | Porta UART (COM) | Porta USB (nativa) |
|---|---|---|
| Ligada a | UART0 (GPIO 43 e 44) por um chip USB-serial | Direto aos GPIO 19 (D-) e GPIO 20 (D+) |
| Driver | CP210x ou CH343, conforme o chip | Não precisa |
| Nome no computador | COMx, /dev/cu.usbserial-… ou /dev/cu.wchusbserial… | COMx (USB JTAG/serial debug unit), /dev/cu.usbmodem…, /dev/ttyACM0 |
| A saída Serial vai para cá | Com USB CDC On Boot: Disabled | Com USB CDC On Boot: Enabled |
| Carregar código | Sempre, com reset automático | Normalmente; a porta pode sumir se o sketch travar ou entrar em deep sleep |
| Teclado e mouse USB (HID) | Não é possível | Possível com USB Mode: USB-OTG (TinyUSB) |
O ajuste USB CDC On Boot: por que o Monitor Serial está vazio?
Este é o problema que os usuários do ESP32-S3 mais encontram: o sketch carrega, a placa roda, mas nem uma linha chega ao Monitor Serial. O motivo é para qual porta o objeto Serial do seu sketch escreve. Com Ferramentas > USB CDC On Boot em Disabled, o Serial escreve na UART0, a porta UART; se o seu cabo está na porta USB, as mensagens nunca chegam. Coloque em Enabled e o Serial passa para a porta USB nativa. A regra é simples: combine o ajuste com a porta onde o cabo está. Enabled para a porta USB, Disabled para a porta UART. Com Enabled, uma espera como while (!Serial) no código fica em loop para sempre quando a placa não está ligada a um computador, então use alguns segundos de atraso ou um tempo limite.
Ajustes da Arduino IDE (ESP32S3 Dev Module)
| Menu | Para N16R8 | Para N8R2 | Observação |
|---|---|---|---|
| Placa | ESP32S3 Dev Module | ESP32S3 Dev Module | Também é a escolha certa para placas clone |
| USB CDC On Boot | Enabled | Enabled | Disabled se você usa a porta UART |
| Flash Size | 16MB (128Mb) | 8MB (64Mb) | O valor N do código de modelo |
| Partition Scheme | 16M Flash (3MB APP/9,9MB FATFS) | 8M with spiffs (3MB APP/1,5MB SPIFFS) | Para sketches grandes e sistema de arquivos |
| PSRAM | OPI PSRAM | QSPI PSRAM | O valor R do código de modelo |
| Flash Mode | QIO 80MHz | QIO 80MHz | OPI 80MHz nos módulos WROOM-2 com código V |
| USB Mode | Hardware CDC and JTAG | Hardware CDC and JTAG | USB-OTG (TinyUSB) para teclado ou mouse USB |
| Upload Mode | UART0 / Hardware CDC | UART0 / Hardware CDC | O padrão está bom |
O suporte ao ESP32-S3 faz parte do pacote esp32 da Espressif que você instala pelo Gerenciador de Placas; não precisa de pacote separado. Os passos de instalação estão no guia instalação da Arduino IDE. Os nomes dos menus são os mesmos nos cores 2.x e 3.x. Errar o ajuste de PSRAM dá um de dois sintomas: com Disabled, o sketch roda mas se comporta como se não houvesse PSRAM; com QSPI PSRAM escolhido em uma placa com PSRAM Octal, a placa mostra PSRAM ID read error ao iniciar e não consegue usar a PSRAM.
Primeiro teste: LED RGB, porta serial e PSRAM
O LED RGB do DevKitC-1 é um LED endereçável do tipo WS2812; ele é acionado por um único pino e aceso com dados de cor, não com digitalWrite como um LED comum. O core ESP32 Arduino tem uma função pronta para ele: neopixelWrite no 2.x e rgbLedWrite no 3.x. Na revisão 1.0 da placa e na maioria dos clones o LED fica no GPIO 48; na revisão 1.1 da Espressif fica no GPIO 38, então confira a revisão impressa no verso da sua placa. Algumas placas clone têm um pequeno jumper de solda marcado RGB ao lado do LED; se o LED nunca acender, esse jumper pode estar aberto. O sketch abaixo acende o LED em vermelho, verde e azul, um de cada vez, e mostra o tamanho da flash e da PSRAM no Monitor Serial ao iniciar.
1// ESP32-S3: dahili RGB LED, seri port, PSRAM ve flaş testi
2// ESP32-S3: onboard RGB LED, serial port, PSRAM and flash test
3const int RGB_PIN = 48; // DevKitC-1 v1.0 ve çoğu klon: 48, v1.1: 38 / v1.0 and most clones: 48, v1.1: 38
4
5void setRgb(uint8_t r, uint8_t g, uint8_t b) {
6#if ESP_ARDUINO_VERSION_MAJOR >= 3
7 rgbLedWrite(RGB_PIN, r, g, b); // çekirdek 3.x / core 3.x
8#else
9 neopixelWrite(RGB_PIN, r, g, b); // çekirdek 2.x / core 2.x
10#endif
11}
12
13void setup() {
14 Serial.begin(115200);
15 delay(1500); // USB'nin açılmasını bekle / give the USB port time to come up
16 Serial.println("ESP32-S3 hazir / ready");
17 Serial.printf("Flash: %lu bayt / bytes\n", (unsigned long)ESP.getFlashChipSize());
18 Serial.printf("PSRAM: %lu bayt / bytes\n", (unsigned long)ESP.getPsramSize()); // 0 ise menüden aç / if 0, enable it in the menu
19}
20
21void loop() {
22 setRgb(40, 0, 0); delay(500); // kırmızı / red
23 setRgb(0, 40, 0); delay(500); // yeşil / green
24 setRgb(0, 0, 40); delay(500); // mavi / blue
25 setRgb(0, 0, 0); delay(500); // kapalı / off
26}Em uma placa N16R8 com os ajustes certos, o Monitor Serial mostra 16.777.216 bytes na linha Flash (o valor que você escolheu no menu Flash Size) e um valor próximo de 8 MB na linha PSRAM; a pequena diferença é o espaço que o alocador da PSRAM reserva para si. Se a linha PSRAM mostrar 0, confira o ajuste de PSRAM no menu. Se não chegar nada, ajuste o USB CDC On Boot de acordo com a porta onde o cabo está.
Usando a PSRAM: buffers grandes
Os 512 KB de memória interna do ESP32-S3 são divididos entre a pilha Wi-Fi, o Bluetooth e o seu código, e declarar um array grande consome tudo rapidinho. Por isso a PSRAM importa: buffers de quadro de câmera, um buffer de desenho de tela inteira para um display colorido, gravações de áudio ou documentos JSON grandes não cabem na memória interna, mas cabem com folga em 8 MB de PSRAM. No Arduino, você aloca memória da PSRAM com ps_malloc; a maioria das bibliotecas do ESP32 (como o driver da câmera) já usa a PSRAM por conta própria. A PSRAM é mais lenta que a memória interna, então mantenha variáveis pequenas e muito usadas na RAM comum.
1// PSRAM'de 1 MB tampon ayırmak / allocating a 1 MB buffer in PSRAM
2void setup() {
3 Serial.begin(115200);
4 delay(1500);
5 if (!psramFound()) {
6 Serial.println("PSRAM yok: Araçlar > PSRAM ayarını kontrol et / no PSRAM: check Tools > PSRAM");
7 return;
8 }
9 const size_t SIZE = 1024 * 1024; // 1 MB, dahili RAM'e sığmaz / does not fit in internal RAM
10 uint8_t* buffer = (uint8_t*)ps_malloc(SIZE); // PSRAM'den ayır / allocate from PSRAM
11 if (buffer == NULL) {
12 Serial.println("Ayrılamadı / allocation failed");
13 return;
14 }
15 memset(buffer, 0xA5, SIZE); // tamponu doldur / fill the buffer
16 Serial.printf("1 MB tampon hazır, boş PSRAM / buffer ready, free PSRAM: %lu\n", (unsigned long)ESP.getFreePsram());
17 free(buffer);
18}
19
20void loop() {
21}Por que o ESP32-S3? Câmeras, IA e USB HID
- Projetos com câmera: a interface de câmera DVP dedicada e os 8 MB de PSRAM dão resoluções e taxas de quadros maiores com câmeras OV2640 ou OV5640. Para comparar com a abordagem clássica, veja o guia ESP32-CAM.
- IA e áudio: graças às instruções vetoriais, as bibliotecas ESP-DL e ESP-SR da Espressif rodam tarefas como detecção de rostos e reconhecimento de palavra de ativação direto no chip.
- USB HID: a placa pode se conectar ao computador como teclado, mouse, gamepad ou dispositivo MIDI, o que a torna ideal para macro pads e controles de apresentação.
- Displays coloridos: a interface de LCD paralelo e a PSRAM facilitam desenhar interfaces fluidas em telas TFT grandes.
- Mais pinos: 45 GPIOs e 14 pinos de toque dão folga em projetos com muitos sensores e botões.
- Bluetooth 5 LE: o modo de longo alcance e 2 Mbps são suportados; o uso do BLE está no guia Bluetooth BLE no ESP32.
USB HID: transformando o ESP32-S3 em teclado
Uma das coisas mais divertidas que o ESP32 clássico não consegue fazer é o ESP32-S3 aparecer no computador como um teclado USB de verdade. Coloque Ferramentas > USB Mode em USB-OTG (TinyUSB) e ligue o cabo na porta marcada USB. O sketch abaixo digita Hello e aperta Enter toda vez que você aperta o botão BOOT da placa (GPIO 0). O USB HID envia posições de teclas, não letras, e o computador traduz essas posições conforme o próprio layout de teclado. Em layouts como o QWERTZ alemão, o AZERTY francês ou o Q turco, algumas letras, dígitos e símbolos podem sair diferentes, por isso o exemplo usa letras que caem nas mesmas teclas em todos os layouts.
1// ESP32-S3 USB klavye: BOOT düğmesine basınca bilgisayara "Hello" yazar
2// ESP32-S3 USB keyboard: types "Hello" on the computer when you press BOOT
3// Araçlar > USB Mode: "USB-OTG (TinyUSB)" seç, kabloyu "USB" yazan porta tak
4// Tools > USB Mode: select "USB-OTG (TinyUSB)", plug the cable into the port marked "USB"
5#if !(defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32S2)) || ARDUINO_USB_MODE
6// Bu kart ya da bu USB Mode ayarı USB HID desteklemez / no USB HID on this board or USB Mode
7void setup() {
8 Serial.begin(115200);
9}
10
11void loop() {
12 Serial.println("USB Mode: USB-OTG (TinyUSB) gerekli / required");
13 delay(2000);
14}
15#else
16#include "USB.h"
17#include "USBHIDKeyboard.h"
18
19USBHIDKeyboard Keyboard;
20const int BUTTON_PIN = 0; // BOOT düğmesi / BOOT button
21
22void setup() {
23 pinMode(BUTTON_PIN, INPUT_PULLUP);
24 Keyboard.begin();
25 USB.begin();
26}
27
28void loop() {
29 if (digitalRead(BUTTON_PIN) == LOW) {
30 Keyboard.print("Hello"); // klavye düzeninden bağımsız harfler / layout-safe letters
31 Keyboard.write(KEY_RETURN);
32 while (digitalRead(BUTTON_PIN) == LOW) {
33 delay(10); // bırakılana kadar bekle / wait until released
34 }
35 delay(50); // titreşim payı / debounce margin
36 }
37}
38#endifPinos do ESP32-S3: com o que tomar cuidado
| Pinos | Situação | Observação |
|---|---|---|
| GPIO 0, 3, 45, 46 | Use com cuidado | Pinos de strapping; o nível deles ao iniciar importa |
| GPIO 19, 20 | Reservados ao USB | As linhas D- e D+ do USB nativo |
| GPIO 43, 44 | UART0 | TX e RX da porta UART |
| GPIO 35, 36, 37 | Não use em módulos R8 | Ligados à PSRAM Octal |
| GPIO 26–32 | Não expostos | Ligados à flash e à PSRAM dentro do módulo |
| GPIO 1–10 | ADC1 | Lê valores analógicos de forma confiável mesmo com o Wi-Fi ligado |
| GPIO 11–20 | ADC2 | Pouco confiável quando usado junto com o Wi-Fi |
| GPIO 1–14 | Toque | Ao contrário do ESP32 clássico, o valor sobe ao tocar |
| GPIO 8 e 9 | I2C | SDA e SCL padrão no core Arduino |
| GPIO 47, 48 | 1,8 V nos módulos V | Trabalham em 1,8 V no WROOM-2 |
Problemas comuns e soluções
| Sintoma | Causa | Solução |
|---|---|---|
| O Monitor Serial está vazio | Cabo na porta USB, USB CDC On Boot: Disabled | Coloque em Enabled ou ligue o cabo na porta UART |
| A porta some depois do upload | O sketch travou, entrou em deep sleep ou o USB Mode está em USB-OTG | Aperte RST segurando BOOT e depois carregue |
| Resets constantes ou PSRAM ID read error | O ajuste de PSRAM não combina com o módulo | Escolha OPI PSRAM para R8 e QSPI PSRAM para R2 |
| O LED RGB não acende | Placa revisão 1.1 (GPIO 38) ou jumper de solda RGB aberto | Mude o RGB_PIN, feche o jumper com solda |
| Serial Bluetooth not available or not enabled | O ESP32-S3 não tem Bluetooth Classic | Use a biblioteca BLE no lugar da BluetoothSerial |
| 'dacWrite' was not declared in this scope | O ESP32-S3 não tem DAC | Use PWM com filtro RC ou um amplificador de áudio I2S |
| Failed to connect to ESP32-S3 | A placa não entrou em modo de download | Entre em modo de download com BOOT e RST; detalhes no guia ESP32 Failed to Connect |
Depois que você entende as duas portas e o ajuste de PSRAM, o ESP32-S3 é tão fácil de usar quanto o ESP32 clássico e muito mais capaz. Como o LED RGB da placa é na verdade um WS2812 de um só pixel, o projeto Controle de Fita WS2812B NeoPixel com ESP32 no app BlueGrays é um ótimo próximo passo; você também pode seguir passo a passo os outros projetos ESP32 do app, com esquemas de ligação e código pronto, e adaptá-los a esta placa trocando os números dos pinos por pinos que existem no S3.
Perguntas frequentes
O que significa N16R8 em um ESP32-S3?
N16 significa que o módulo tem 16 MB de memória flash e R8 significa 8 MB de PSRAM. Nos módulos ESP32-S3-WROOM-1, a PSRAM R8 é ligada por Octal SPI (OPI), então na Arduino IDE você deve escolher OPI PSRAM em PSRAM e 16MB em Flash Size.
Qual porta USB devo usar no ESP32-S3 DevKitC?
As duas portas servem para carregar código e para o Monitor Serial. A porta UART se comporta como um ESP32 clássico e é usada com USB CDC On Boot: Disabled; a porta USB se liga direto ao chip, não precisa de driver e é usada com USB CDC On Boot: Enabled. Se você quer fazer um teclado ou mouse USB, precisa da porta USB.
Por que o meu ESP32-S3 não mostra nada no Monitor Serial?
O mais provável é que o cabo esteja na porta USB com o USB CDC On Boot em Disabled, então a saída Serial vai para a porta UART. Coloque em Enabled e carregue de novo, ou ligue o cabo na porta UART e ajuste o Monitor Serial para a mesma taxa de baud do sketch.
Como ativar a PSRAM do ESP32-S3 na Arduino IDE?
Em Ferramentas > PSRAM, escolha a opção que combina com o seu módulo: OPI PSRAM para módulos R8, QSPI PSRAM para módulos R2. No código, psramFound() informa se a PSRAM foi detectada, e ps_malloc() aloca buffers grandes nela.
O ESP32-S3 suporta Bluetooth Classic?
Não. O ESP32-S3 só suporta Bluetooth 5 LE, então a biblioteca BluetoothSerial e o pareamento direto com dispositivos Classic como o HC-05 não funcionam. Use a biblioteca BLE para falar com um celular; se você precisa de Bluetooth Classic, escolha o ESP32 clássico.
Em qual pino fica o LED integrado do ESP32-S3 DevKitC-1?
O LED integrado do ESP32-S3-DevKitC-1 é um LED RGB endereçável, no GPIO 48 na revisão 1.0 da placa e na maioria dos clones, e no GPIO 38 na revisão 1.1. Ele acende enviando uma cor com neopixelWrite no core 2.x ou rgbLedWrite no core 3.x, e não com digitalWrite.
Projetos para montar depois desta leitura
Ver todos os projetos
LED integrado do ESP32 piscando
Faça o LED azul integrado do ESP32 DevKit V1 piscar. Nenhum componente externo é necessário! O primeiro projeto para experimentar ao comprar um ESP32. GPIO 2 está conectado ao LED integrado.

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Controle de fita WS2812B NeoPixel com ESP32
Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

Atualização OTA no ESP32 — firmware sem fio (com display LCD)
Neste projeto, você aprende a carregar um novo firmware no ESP32 por Wi-Fi, sem cabo USB. Com a biblioteca ArduinoOTA, o ESP32 fica visível na rede e aparece automaticamente como bluegrays-ota na aba "Porta de rede" do Arduino IDE. A primeira carga é feita por USB, e todas as atualizações seguintes são sem fio — um recurso essencial para dispositivos em campo. O LCD I2C mostra o estado do Wi-Fi, o IP, o nome do host, a porcentagem de envio por OTA e as mensagens de erro em turco e inglês.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.
Mais artigos
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- Tutorial do ESP32-CAM: configuração, programação, transmissão ao vivo e cartão SD
- Tutorial de Bluetooth no ESP32: Classic ou BLE, controle de LED e sensores
- Erro Failed to connect no ESP32: solução com botão BOOT, driver e cabo
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

