ESP32-S3 en Arduino IDE: DevKitC N16R8, dos puertos USB y PSRAM
ESP32-S3 en Arduino IDE: qué significan N16R8 y N8R2, puerto UART y USB, USB CDC On Boot, PSRAM OPI, LED RGB en GPIO48, ajustes del DevKitC y teclado USB HID.
El ESP32-S3 es el chip de doble núcleo con WiFi y Bluetooth de Espressif, mejorado con USB nativo, más pines, una PSRAM grande e instrucciones vectoriales que aceleran los cálculos de inteligencia artificial. La placa que más vas a ver es la ESP32-S3-DevKitC-1 y sus clones: trae dos puertos USB-C, un botón BOOT, un botón RST y un único LED RGB direccionable. Los códigos como N16R8 o N8R2 que aparecen en la placa o en el módulo indican el tamaño de la memoria flash y de la PSRAM, y son la clave para configurar bien el Arduino IDE.
En esta guía vas a aprender en qué se diferencia el ESP32-S3 del ESP32 clásico, qué significan los códigos de modelo, cuál de los dos puertos USB usar y cuándo, el ajuste USB CDC On Boot que resuelve el Monitor Serie vacío y cómo elegir el modo de PSRAM correcto (OPI o QSPI). Después escribirás un sketch de prueba que enciende el LED RGB integrado, un ejemplo que reserva un búfer de 1 MB en la PSRAM y un proyecto HID que hace que la computadora reconozca al ESP32-S3 como un teclado USB.
¿Qué es el ESP32-S3? Diferencias con el ESP32 clásico
El ESP32-S3 no se diseñó para reemplazar al ESP32 clásico, sino para cubrir lo que a este le faltaba. La diferencia más grande es el USB nativo: el chip se conecta directo a la computadora, sin conversor USB-serie de por medio, y puede presentarse como puerto serie, teclado, mouse o dispositivo MIDI. Sus núcleos Xtensa LX7 suman instrucciones vectoriales para procesamiento de señales y redes neuronales, y las interfaces dedicadas de cámara (DVP) y de pantalla LCD paralela facilitan los proyectos de imagen. A cambio le faltan dos cosas: no tiene Bluetooth Classic (solo Bluetooth 5 LE) ni DAC para salidas analógicas.
| Característica | ESP32 (clásico) | ESP32-S3 |
|---|---|---|
| Procesador | Xtensa LX6, doble núcleo, 240 MHz | Xtensa LX7, doble núcleo, 240 MHz, instrucciones vectoriales |
| SRAM interna | 520 KB | 512 KB |
| PSRAM | Hasta 4 MB en módulos WROVER | 2 MB Quad u 8 MB Octal según el módulo |
| Bluetooth | Classic y BLE 4.2 | Solo BLE 5 (con soporte de largo alcance) |
| USB | No tiene, necesita un chip USB-serie aparte | USB OTG nativo y USB Serial/JTAG |
| GPIO utilizables | Unos 34 | 45 |
| Pines táctiles | 10 | 14 |
| DAC (salida analógica) | 2 canales, 8 bits | No tiene |
| Interfaz de cámara y pantalla | Cámara por I2S (ESP32-CAM) | Interfaz DVP de cámara y LCD paralela dedicadas |

Códigos de modelo del ESP32-S3: ¿qué significa N16R8?
El código que ves en el blindaje metálico del módulo o en el anuncio del vendedor se lee fácil: el número después de la N es la flash y el número después de la R es la PSRAM, ambos en megabytes. N16R8 significa 16 MB de flash y 8 MB de PSRAM; N8R2, 8 MB de flash y 2 MB de PSRAM. El código también dice cómo está conectada la PSRAM: en los módulos ESP32-S3-WROOM-1, R2 es PSRAM Quad SPI (QSPI) de cuatro líneas y R8 es PSRAM Octal SPI (OPI) de ocho líneas. Una V al final (como en N32R8V) indica módulos WROOM-2 cuya flash y PSRAM trabajan a 1,8 V. Con esta información eliges el ajuste de PSRAM en el Arduino IDE.
| Código | Flash | PSRAM | Ajuste de PSRAM en Arduino IDE |
|---|---|---|---|
| N8 | 8 MB | No tiene | Disabled |
| N16 | 16 MB | No tiene | 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 y Flash Mode: OPI 80MHz |
Dos puertos USB: diferencia entre UART y USB
Los dos puertos USB-C de la ESP32-S3-DevKitC-1 no hacen lo mismo. El que dice UART (COM en algunos clones) va a un chip USB-serie, un CP2102N o un CH343P según la versión de la placa, conectado a su vez a la UART0 del ESP32-S3 (GPIO 43 y 44). Es igual al único puerto de las placas ESP32 clásicas y pone la placa en modo descarga automáticamente al subir el código. El que dice USB, en cambio, está conectado directo a los pines GPIO 19 (D-) y GPIO 20 (D+) del chip. Al enchufarte ahí, la computadora ve el USB propio del ESP32-S3 sin ningún chip en medio; Windows 10 y 11, macOS y Linux no necesitan driver.
| Característica | Puerto UART (COM) | Puerto USB (nativo) |
|---|---|---|
| Conectado a | UART0 (GPIO 43 y 44) a través de un chip USB-serie | Directo a GPIO 19 (D-) y GPIO 20 (D+) |
| Driver | CP210x o CH343, según el chip | No hace falta |
| Nombre en la computadora | COMx, /dev/cu.usbserial-… o /dev/cu.wchusbserial… | COMx (USB JTAG/serial debug unit), /dev/cu.usbmodem…, /dev/ttyACM0 |
| La salida de Serial llega aquí | Con USB CDC On Boot: Disabled | Con USB CDC On Boot: Enabled |
| Subir código | Siempre, con reinicio automático | Casi siempre; si el sketch se cuelga o entra en deep sleep, el puerto puede desaparecer |
| Teclado y mouse USB (HID) | No puede | Puede con USB Mode: USB-OTG (TinyUSB) |
El ajuste USB CDC On Boot: ¿por qué el Monitor Serie está vacío?
Este es el problema más común de quienes usan el ESP32-S3: el código se sube, la placa funciona, pero al Monitor Serie no llega ni una línea. La causa es a qué puerto escribe el objeto Serial de tu sketch. Con Herramientas > USB CDC On Boot en Disabled, Serial escribe en la UART0, es decir, en el puerto UART; si tu cable está en el puerto USB, los mensajes nunca te llegan. Con Enabled, Serial se redirige al puerto USB nativo. La regla es simple: elige el ajuste según el puerto donde está el cable. Enabled para el puerto USB, Disabled para el puerto UART. Si con Enabled tu código tiene una espera como while (!Serial), ese bucle no termina nunca cuando la placa no está conectada a una computadora; usa en su lugar unos segundos de demora o un tiempo límite.
Ajustes del Arduino IDE (ESP32S3 Dev Module)
| Menú | Para N16R8 | Para N8R2 | Nota |
|---|---|---|---|
| Placa | ESP32S3 Dev Module | ESP32S3 Dev Module | También se elige esta en las placas clon |
| USB CDC On Boot | Enabled | Enabled | Disabled si usas el puerto UART |
| Flash Size | 16MB (128Mb) | 8MB (64Mb) | El valor N del código de modelo |
| Partition Scheme | 16M Flash (3MB APP/9.9MB FATFS) | 8M with spiffs (3MB APP/1.5MB SPIFFS) | Para programas grandes y un sistema de archivos |
| PSRAM | OPI PSRAM | QSPI PSRAM | El valor R del código de modelo |
| Flash Mode | QIO 80MHz | QIO 80MHz | OPI 80MHz en módulos WROOM-2 con V |
| USB Mode | Hardware CDC and JTAG | Hardware CDC and JTAG | USB-OTG (TinyUSB) para teclado o mouse USB |
| Upload Mode | UART0 / Hardware CDC | UART0 / Hardware CDC | Puede quedar el valor por defecto |
El soporte del ESP32-S3 viene dentro del paquete esp32 de Espressif que instalas desde el Gestor de placas; no hace falta otro paquete. Los pasos están en la guía cómo instalar Arduino IDE. Los nombres de los menús son los mismos en el core 2.x y en el 3.x. Si configuras mal la PSRAM verás uno de dos síntomas: con Disabled el sketch funciona pero se comporta como si no hubiera PSRAM; con QSPI PSRAM en una placa con PSRAM Octal, la placa muestra PSRAM ID read error al arrancar y no puede usar la PSRAM.
Primera prueba: LED RGB, puerto serie y PSRAM
El LED RGB de la DevKitC-1 es un LED direccionable tipo WS2812; se maneja con un solo pin y no se enciende con digitalWrite como un LED común, sino enviándole datos de color. El core de Arduino para ESP32 trae una función lista para eso: neopixelWrite en la versión 2.x y rgbLedWrite en la 3.x. En la versión 1.0 de la placa y en la mayoría de los clones el LED está en el GPIO 48; en la versión 1.1 de Espressif está en el GPIO 38, así que revisa la versión impresa en la parte de atrás de tu placa. Algunas placas clon tienen junto al LED un pequeño puente de soldadura marcado RGB; si el LED nunca enciende, ese puente puede estar abierto. El sketch de abajo enciende el LED en rojo, verde y azul y, al arrancar, escribe en el Monitor Serie el tamaño de la flash y de la PSRAM.
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}En una placa N16R8 bien configurada, el Monitor Serie muestra 16.777.216 bytes en la línea de Flash (el valor que elegiste en el menú Flash Size) y un valor cercano a 8 MB en la línea de PSRAM; la pequeña diferencia es el espacio que se reserva el administrador de la PSRAM. Si la línea de PSRAM muestra 0, revisa el ajuste de PSRAM en el menú. Si no llega nada, ajusta USB CDC On Boot según el puerto donde está el cable.
Usar la PSRAM: búferes grandes
Los 512 KB de memoria interna del ESP32-S3 se reparten entre la pila WiFi, el Bluetooth y tu código, y un arreglo grande la agota rápido. Por eso la PSRAM es tan importante: los búferes de cuadros de una cámara, un búfer de dibujo de pantalla completa para una pantalla a color, grabaciones de audio o documentos JSON grandes no entran en la memoria interna, pero sí cómodamente en 8 MB de PSRAM. En Arduino, la memoria de la PSRAM se reserva con ps_malloc; la mayoría de las librerías del ESP32 (como el driver de la cámara) ya usan la PSRAM por su cuenta. La PSRAM es más lenta que la memoria interna, así que deja las variables pequeñas y de uso frecuente en la RAM normal.
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 qué el ESP32-S3? Cámara, inteligencia artificial y USB HID
- Proyectos con cámara: la interfaz DVP dedicada y los 8 MB de PSRAM permiten mayor resolución y más cuadros por segundo con cámaras OV2640 u OV5640. Para compararlo con la solución clásica, mira la guía ESP32-CAM.
- Inteligencia artificial y audio: gracias a las instrucciones vectoriales, las librerías ESP-DL y ESP-SR de Espressif hacen tareas como detección de rostros y reconocimiento de palabra de activación en el propio chip.
- USB HID: la placa se conecta a la computadora como teclado, mouse, gamepad o dispositivo MIDI; es ideal para teclados de macros y controles de presentaciones.
- Pantallas a color: la interfaz LCD paralela y la PSRAM facilitan dibujar interfaces fluidas en pantallas TFT grandes.
- Más pines: 45 GPIO y 14 pines táctiles dan aire en proyectos con muchos sensores y botones.
- Bluetooth 5 LE: soporta el modo de largo alcance y 2 Mbps; el uso de BLE está en la guía Bluetooth BLE del ESP32.
USB HID: convertir el ESP32-S3 en un teclado
Una de las cosas más divertidas que el ESP32 clásico no puede hacer es que el ESP32-S3 aparezca en la computadora como un teclado USB de verdad. Para eso pon Herramientas > USB Mode en USB-OTG (TinyUSB) y conecta el cable al puerto que dice USB. El sketch de abajo escribe Hello y presiona Enter cada vez que presionas el botón BOOT de la placa (GPIO 0). El USB HID no envía letras sino posiciones de teclas, y la computadora las traduce según su propia distribución de teclado. En distribuciones como la latinoamericana o la española, algunos símbolos y signos de puntuación pueden salir distintos, por eso el ejemplo usa letras que caen en las mismas teclas en todas las distribuciones.
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#endifPines del ESP32-S3: a qué prestar atención
| Pines | Estado | Nota |
|---|---|---|
| GPIO 0, 3, 45, 46 | Usar con cuidado | Pines de arranque (strapping); importa su nivel al encender |
| GPIO 19, 20 | Reservados para USB | Líneas D- y D+ del USB nativo |
| GPIO 43, 44 | UART0 | TX y RX del puerto UART |
| GPIO 35, 36, 37 | No usar en módulos R8 | Conectados a la PSRAM Octal |
| GPIO 26–32 | No salen al exterior | Conectados a la flash y la PSRAM dentro del módulo |
| GPIO 1–10 | ADC1 | Lee valores analógicos de forma fiable incluso con WiFi |
| GPIO 11–20 | ADC2 | Poco fiable si se usa junto con el WiFi |
| GPIO 1–14 | Táctiles | A diferencia del ESP32 clásico, el valor sube al tocar |
| GPIO 8 y 9 | I2C | SDA y SCL por defecto en el core de Arduino |
| GPIO 47, 48 | 1,8 V en módulos V | Trabajan a 1,8 V en WROOM-2 |
Problemas comunes y soluciones
| Síntoma | Causa | Solución |
|---|---|---|
| El Monitor Serie está vacío | Cable en el puerto USB, USB CDC On Boot: Disabled | Ponlo en Enabled o conecta el cable al puerto UART |
| El puerto desaparece después de subir el código | El sketch se colgó, entró en deep sleep o USB Mode está en USB-OTG | Presiona RST con BOOT apretado y luego sube el código |
| Reinicios constantes o PSRAM ID read error | El ajuste de PSRAM no coincide con el módulo | Elige OPI PSRAM para R8 y QSPI PSRAM para R2 |
| El LED RGB no enciende | Placa versión 1.1 (GPIO 38) o puente de soldadura RGB abierto | Cambia RGB_PIN y suelda el puente |
| Serial Bluetooth not available or not enabled | El ESP32-S3 no tiene Bluetooth Classic | Usa la librería BLE en lugar de BluetoothSerial |
| 'dacWrite' was not declared in this scope | El ESP32-S3 no tiene DAC | Usa PWM con un filtro RC o un amplificador de audio I2S |
| Failed to connect to ESP32-S3 | La placa no entró en modo descarga | Entra en modo descarga con BOOT y RST; detalles en la guía ESP32 Failed to Connect |
Una vez que entiendes sus dos puertos y el ajuste de PSRAM, el ESP32-S3 es tan fácil de usar como el ESP32 clásico y mucho más capaz. Como el LED RGB de la placa es en realidad un WS2812 de un solo píxel, el proyecto Control de tira WS2812B NeoPixel con ESP32 de la app BlueGrays es un buen siguiente paso; también puedes seguir paso a paso los demás proyectos ESP32 de la app, con su diagrama de conexiones y el código listo, y adaptarlos a esta placa pasando los números de pin a pines que existen en la S3.
Preguntas frecuentes
¿Qué significa ESP32-S3 N16R8?
N16 indica que el módulo tiene 16 MB de memoria flash y R8, 8 MB de PSRAM. En los módulos ESP32-S3-WROOM-1 la PSRAM R8 se conecta por Octal SPI (OPI), así que en el Arduino IDE debes elegir OPI PSRAM en PSRAM y 16MB en Flash Size.
¿Cómo configurar el ESP32-S3 en el Arduino IDE?
Instala el paquete esp32 de Espressif desde el Gestor de placas y elige ESP32S3 Dev Module. Luego ajusta Flash Size y PSRAM según el código de tu módulo (por ejemplo 16MB y OPI PSRAM para un N16R8) y pon USB CDC On Boot en Enabled si conectas el cable al puerto USB.
¿Por qué el ESP32-S3 no muestra nada en el Monitor Serie?
Lo más probable es que el cable esté en el puerto USB y USB CDC On Boot esté en Disabled; en ese caso la salida de Serial va al puerto UART. Ponlo en Enabled y vuelve a subir el código, o conecta el cable al puerto UART y usa en el Monitor Serie los mismos baudios que en el sketch.
¿Cómo activar la PSRAM del ESP32-S3?
En el Arduino IDE, en Herramientas > PSRAM, elige la opción que corresponde a tu módulo: OPI PSRAM para los módulos R8 y QSPI PSRAM para los R2. En el código, psramFound() te dice si se detectó la PSRAM y ps_malloc() reserva búferes grandes en ella.
¿El ESP32-S3 tiene Bluetooth Classic?
No. El ESP32-S3 solo admite Bluetooth 5 LE, así que la librería BluetoothSerial y el emparejamiento directo con dispositivos Classic como el HC-05 no funcionan. Para comunicarte con el celular usa la librería BLE; si necesitas Bluetooth Classic, elige el ESP32 clásico.
¿En qué pin está el LED integrado del ESP32-S3?
El LED integrado de la ESP32-S3-DevKitC-1 es un LED RGB direccionable conectado al GPIO 48 en la versión 1.0 de la placa y en la mayoría de los clones, y al GPIO 38 en la versión 1.1. No se enciende con digitalWrite, sino enviando un color con neopixelWrite en el core 2.x o rgbLedWrite en el core 3.x.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Parpadeo del LED interno del ESP32
Parpadeo del LED azul incorporado en el ESP32 DevKit V1. ¡No se necesitan componentes externos! El primer proyecto que debe probar cuando compra un ESP32. GPIO 2 está conectado al LED interno.

LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
Aprenderás a cargar un firmware nuevo en el ESP32 por Wi-Fi, sin cable USB. Con la biblioteca ArduinoOTA, el ESP32 se hace visible en la red y aparece automáticamente como bluegrays-ota en la pestaña "Network port" del Arduino IDE. La primera carga se hace por USB; después, todas las actualizaciones son inalámbricas, algo clave para los dispositivos instalados sobre el terreno.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

