¿Por qué un proyecto con batería que funciona perfecto en la mesa se apaga a los dos días cuando lo dejas en terreno? Casi siempre la respuesta es la misma: el microcontrolador pasa el 99% del tiempo sin hacer nada, pero consumiendo como si trabajara. Un ESP32 despierto gasta del orden de 30 mA aunque solo esté esperando que alguien apriete un botón, y eso vacía cualquier batería chica en un par de días.
En esta guía vas a armar un banco de prueba simple con una Seeed Studio XIAO ESP32-S3, un pulsador y un LED, y vas a medir con un multímetro cuánto baja el consumo cuando el chip entra en deep sleep. Las cifras de referencia vienen del montaje original de Circuit Digest: 31,21 mA en modo activo y 0,13 mA (130 µA) dormido, una reducción cercana al 99,6%. Al final vas a saber configurar un pin de despertar (ext0), guardar datos que sobreviven al sueño con RTC_DATA_ATTR, medir corriente en microamperios sin engañarte y calcular cuánto te dura una batería en la vida real.
Concepto: qué se apaga y qué sigue vivo en deep sleep
El ESP32 tiene dos mundos dentro del mismo chip. El dominio digital principal incluye los núcleos de la CPU, la SRAM, la radio WiFi/Bluetooth y los relojes de alta frecuencia. El dominio RTC es un rincón de muy bajo consumo con su propio reloj lento, unos pocos KB de memoria (RTC memory), algunos periféricos y, en varios modelos, el coprocesador ULP.
En deep sleep el chip corta la alimentación de todo el dominio principal y deja vivo solo el dominio RTC, que se queda vigilando una condición de despertar. Cuando esa condición se cumple, el chip no continúa donde quedó: se reinicia y vuelve a ejecutar setup() desde cero. Esa es la diferencia clave con el light sleep, donde la CPU solo se pausa y retoma la línea siguiente.
Que se reinicie tiene una consecuencia práctica que confunde a mucha gente la primera vez: toda variable normal se pierde. Si quieres que un contador o la última lectura de un sensor sobreviva, tienes que guardarla en la memoria RTC con el atributo RTC_DATA_ATTR, o en flash con la librería Preferences si además debe sobrevivir a un corte de energía.
Los modos de energía, comparados
Estos son los valores típicos del chip pelado según Espressif. Una placa de desarrollo siempre consume más, porque suma regulador, LED de encendido y otros circuitos.
| Modo | Estado de la CPU | Consumo típico (chip) | Cuándo usarlo |
|---|---|---|---|
| Activo | Corriendo | 40 mA a 160 mA | Procesar datos, transmitir por WiFi o Bluetooth |
| Modem sleep | Corriendo, radio apagada | 3 mA a 20 mA | Tareas locales con conexiones WiFi ocasionales |
| Light sleep | Pausada (reloj detenido) | ~0,8 mA | Pausas cortas donde necesitas retomar sin reiniciar |
| Deep sleep | Apagada | 10 µA a 150 µA | Sensores a batería, registradores periódicos, eventos |
| Hibernación | Apagada, sin memoria RTC | ~2,5 µA | Esperas muy largas que solo despierta el timer RTC |
Cinco formas de despertar al chip
Una vez dormido, algo tiene que despertarlo. El ESP32 ofrece cinco fuentes:
- Timer (
esp_sleep_enable_timer_wakeup): despierta solo después de un intervalo, por ejemplo cada 15 minutos para leer un sensor. - Un pin externo, ext0: despierta cuando un pin RTC específico cambia a un nivel. Es el que usa este proyecto con el pulsador.
- Varios pines, ext1: despierta cuando uno o todos los pines de un grupo cambian. Sirve para un teclado o varios sensores de puerta.
- Touch (
touchSleepWakeUpEnable): despierta cuando un pin capacitivo detecta un dedo. - Coprocesador ULP: un programa diminuto revisa un umbral mientras la CPU principal duerme, y la despierta solo si hace falta.
Un detalle que el tutorial original no menciona: no cualquier GPIO sirve para ext0. Tiene que ser un pin conectado al dominio RTC, porque es el único circuito que sigue con energía. En la ESP32-S3 los GPIO 0 a 21 son RTC; en el ESP32 clásico la lista es más corta (0, 2, 4, 12 a 15, 25 a 27 y 32 a 39). En la XIAO, el pin D0 es el GPIO 1, así que funciona sin problema. Si usas otra placa y el chip no despierta nunca, lo primero que tienes que revisar es eso.
Hardware: el banco de prueba
El montaje es mínimo a propósito: lo interesante no es el circuito, sino la medición. Todo va en una protoboard con cables jumper.

- La XIAO ESP32-S3 es el cerebro. Es chica, trae USB-C y un cargador de batería LiPo integrado, lo que la hace buena candidata para proyectos portátiles.
- El pulsador va en D0 (GPIO 1) y es el que despierta al chip.
- El LED va en D1 (GPIO 2) y hace de carga: cuando se enciende, simula el trabajo que haría tu proyecto al despertar.
- Una resistencia de 220 Ω en serie con el LED limita la corriente. El esquema original no la lista, pero sin ella el LED queda conectado directo al pin y fuerzas la salida del ESP32; con 220 Ω y 3,3 V el LED queda cerca de 5 a 6 mA, suficiente para verlo bien.

Las conexiones quedan así:
- Una pata del pulsador al pin 3V3 de la XIAO y la otra al pin D0. El código activa la resistencia pull down interna del dominio RTC, así que el pin lee LOW en reposo y HIGH cuando aprietas.
- El ánodo del LED (pata larga) a D1, el cátodo a la resistencia de 220 Ω y la resistencia a GND.
Si usas otra placa ESP32, el circuito es el mismo: solo cambia los números de pin en el código y verifica que el del botón sea un GPIO RTC.
Cómo medir corriente sin engañarte
El montaje original alimenta la placa desde una fuente de laboratorio a 5 V con el multímetro en serie, en modo amperímetro, entre la fuente y el pin de 5 V de la XIAO.

Tres cosas que conviene saber antes de medir, porque son la causa de casi todas las lecturas raras:
- No midas por USB. Si la placa está conectada al computador, la corriente entra por el USB y el multímetro no ve nada. Desconecta el USB después de cargar el código y alimenta solo por el pin de 5 V (o por las almohadillas de batería).
- Cambia de escala según el modo. En modo activo necesitas la escala de mA; para leer 130 µA, la de µA (200 µA en un multímetro de la serie 830). Ojo: en la escala más fina, el multímetro mete una resistencia interna que provoca una caída de tensión ("burden voltage"). Cuando el chip despierta y pide 40 mA, esa caída puede ser suficiente para que se reinicie. Si ves reinicios en bucle, sube de escala.
- Espera unos segundos. Justo después de dormirse, la corriente tarda un momento en estabilizarse, por los condensadores de la placa.
Software: el sketch de deep sleep
El programa completo cabe en setup(): el chip despierta, revisa por qué despertó, hace su trabajo y se vuelve a dormir. loop() queda vacío, porque nunca se ejecuta.
1. Saber por qué despertó
Lo primero es preguntarle al controlador de sueño cuál fue la causa del arranque, con esp_sleep_get_wakeup_cause(). Así distingues entre "acaban de enchufarme" y "alguien apretó el botón". Antes de eso, el sketch deja el LED como salida apagada e inicia el puerto serie a 115200 baudios.
2. Actuar según la causa
Si la causa es ESP_SLEEP_WAKEUP_EXT0, el botón fue el que despertó al chip: el programa suma uno a wakeCount, imprime el número de despertares y enciende el LED cinco segundos para simular una carga de trabajo. Si es cualquier otra causa (el primer encendido, por ejemplo), solo avisa por serie y se va directo a dormir.
wakeCount está declarado con RTC_DATA_ATTR, así que vive en la memoria RTC y conserva su valor entre ciclos de sueño. Si quitas ese atributo vas a ver siempre Boot Count: 1, porque la variable se reinicia en cada despertar. Es una buena prueba para entender el concepto.
3. Configurar el despertar y dormir
Antes de dormir, Serial.flush() se asegura de que el último mensaje salga completo por el puerto serie; sin esa línea, a veces el texto queda cortado. Después vienen las tres líneas que importan:
rtc_gpio_pulldown_en(BUTTON_PIN)yrtc_gpio_pullup_dis(BUTTON_PIN)dejan el pin del botón con pull down mientras duerme. Tienen que ser las funcionesrtc_gpio_*, no unpinMode(INPUT_PULLDOWN), porque durante el sueño el que manda en ese pin es el dominio RTC y la configuración digital normal se apaga con el resto.esp_sleep_enable_ext0_wakeup(BUTTON_PIN, 1)le pide al controlador RTC que despierte al chip cuando el pin pase a HIGH (el1es el nivel).esp_deep_sleep_start()apaga la CPU, la RAM, la radio y los relojes rápidos. El chip queda dormido hasta que el botón lleve el pin a 3,3 V.
El código completo está más abajo, en la sección "Código completo", y en el repositorio del autor, que también trae el sketch de comparación en modo activo (el mismo circuito, pero con un loop() que espera el botón sin dormir).
Un tropiezo típico de la XIAO ESP32-S3
La XIAO usa el USB nativo del ESP32-S3 como puerto serie. Cuando el chip se duerme, ese USB desaparece: el Monitor Serie se desconecta y el computador deja de ver el puerto. Es normal. Dos consecuencias:
- Los mensajes que imprime al despertar a veces no alcanzas a verlos, porque el puerto tarda en volver a aparecer. El
delay(500)después deSerial.begin()ayuda; si no basta, súbelo a 2000 mientras depuras. - Para cargar un sketch nuevo con la placa durmiendo, mantén presionado el botón BOOT de la XIAO mientras la conectas por USB. Entra al modo de carga y el IDE la vuelve a encontrar.
Pruebas: lo que muestra el multímetro
Con el sketch de modo activo, la placa en reposo y el LED apagado consume 31,21 mA. No está haciendo nada útil: solo da vueltas en loop() esperando el botón.

Al apretar el botón, el LED se enciende y el consumo sube a 40,40 mA: los mismos 31 mA de base más la corriente del LED.

Con el sketch de deep sleep, en reposo la lectura baja a 0,13 mA, es decir, 130 µA.

| Sketch | LED | Corriente | Qué está haciendo el ESP32 |
|---|---|---|---|
| Modo activo | Encendido | ~40,40 mA | CPU activa y LED encendido |
| Modo activo | Apagado | ~31,21 mA | CPU activa, dando vueltas en loop() |
| Deep sleep | Encendido | ~40,40 mA | Recién despertado, CPU activa y LED encendido |
| Deep sleep | Apagado | 0,13 mA | CPU, RAM y periféricos digitales apagados |
¿Por qué 130 µA y no los 7 µA del datasheet?
Espressif indica para el chip ESP32-S3 unos 7 a 8 µA en deep sleep. La diferencia hasta 130 µA no la consume el chip: la consumen el regulador de voltaje de la placa (su corriente de reposo), los divisores de tensión y otros componentes pasivos que siguen conectados a la alimentación. Es lo normal en cualquier placa de desarrollo, que está pensada para probar cómodo, no para durar años con una pila.
Si necesitas bajar de ahí, el camino es alimentar el chip con un regulador de muy baja corriente de reposo, quitar el LED de encendido si la placa lo tiene, y diseñar tu propio PCB cuando el prototipo ya esté probado.
Cuánto dura una batería: el cálculo que importa
El consumo dormido es solo la mitad de la historia. Lo que define la autonomía es la corriente promedio, que pondera cuánto tiempo pasa el chip en cada estado:
I_promedio = (I_activo × t_activo + I_sueño × t_sueño) / t_total
Con los números de este montaje, si aprietas el botón 10 veces al día y cada vez el LED queda 5 segundos encendido, el chip pasa 50 segundos al día a 40,4 mA y el resto a 0,13 mA. El promedio da cerca de 0,15 mA. Con una batería de 1000 mAh:
| Escenario (batería de 1000 mAh) | Corriente promedio | Duración estimada |
|---|---|---|
| Siempre en modo activo, en reposo | 31,21 mA | ~32 horas (1,3 días) |
| Deep sleep y 10 pulsaciones al día (5 s de LED cada una) | ~0,15 mA | ~270 días |
| Siempre en deep sleep (esta placa) | 0,13 mA | ~320 días |
Toma estos números como un techo, no como una promesa. No incluyen la autodescarga de la batería, la eficiencia del regulador ni el pico de consumo de cada arranque, que en un ESP32 puede pasar de 100 mA durante unas décimas de segundo, y mucho más si al despertar prende el WiFi. Ese es el error más común al pasar de esta demo a un nodo real: conectar el WiFi tarda uno a tres segundos a más de 100 mA, así que un nodo que despierta cada minuto para enviar un dato gasta casi todo en la conexión, no en el sueño. Por eso conviene espaciar los envíos o juntar varias lecturas y mandarlas de una vez.
Código completo
Este es el sketch de deep sleep tal como lo publica el autor. Ajusta BUTTON_PIN y LED_PIN si usas otra placa.
#include <driver/rtc_io.h> // Include RTC IO driver
#define BUTTON_PIN GPIO_NUM_1
#define LED_PIN 2
RTC_DATA_ATTR int wakeCount = 0;
void setup() {
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
Serial.begin(115200);
delay(500);
esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
if (wakeup_reason == ESP_SLEEP_WAKEUP_EXT0) {
wakeCount++;
Serial.println("\n--- ESP32 WOKE UP FROM DEEP SLEEP (BUTTON PRESSED) ---");
Serial.print("Boot Count: ");
Serial.println(wakeCount);
Serial.println("Status: LED ON - Active Load");
digitalWrite(LED_PIN, HIGH);
delay(5000);
digitalWrite(LED_PIN, LOW);
} else {
Serial.println("\n--- ESP32 INITIAL POWER-ON ---");
Serial.println("Status: System starting up directly into Deep Sleep...");
}
Serial.println("Status: Entering Deep Sleep Mode now...");
Serial.flush();
// Explicitly configure internal pull-down for RTC GPIO 33 during sleep
rtc_gpio_pulldown_en(BUTTON_PIN);
rtc_gpio_pullup_dis(BUTTON_PIN);
// Enable ext0 wake-up on HIGH signal
esp_sleep_enable_ext0_wakeup(BUTTON_PIN, 1);
esp_deep_sleep_start();
}
void loop() {
}
Variantes y mejoras
- Nodo sensor con despertar por timer. Cambia el botón por
esp_sleep_enable_timer_wakeup(15ULL * 60 * 1000000)para que el chip despierte cada 15 minutos, lea un sensor de temperatura (un DHT22 o un BME280 por I2C) y vuelva a dormir. Guarda las últimas lecturas en un arreglo conRTC_DATA_ATTRy conéctate al WiFi solo cada diez despertares para enviar todo junto: es la forma más simple de multiplicar la autonomía. - Varios botones con ext1. Si quieres un control remoto o un timbre con varias puertas,
esp_sleep_enable_ext1_wakeup()acepta una máscara de pines. Al despertar,esp_sleep_get_ext1_wakeup_status()te dice cuál de ellos fue el que se activó. - Batería real en vez de fuente de laboratorio. La XIAO ESP32-S3 tiene almohadillas para una batería LiPo de 3,7 V y la carga sola por USB-C. Alimentarla por ahí evita pasar por el regulador de 5 V y es el siguiente paso natural para llevar el proyecto a terreno. Para registrar el consumo en el tiempo, en lugar de mirar el multímetro, puedes poner un sensor de corriente INA219 entre la batería y la placa y anotar el promedio de varias horas.
Personalización para Chile
En Chile consigues todo lo necesario en MechatronicStore:
- Seeed Studio XIAO ESP32 S3 (SKU GS1-3): la misma placa del montaje original, con USB-C y cargador LiPo integrado.
- Pulsador Táctil 6x6x10mm 4 Pines (SKU GI2-10): el botón que despierta al chip desde D0.
- LED 5mm rojo (SKU GA1-5): la carga visible que simula el trabajo al despertar.
- Resistencias 1/4W 1 unidad 220Ω (SKU GK1-18): limita la corriente del LED.
- Breadboard / Protoboard 830 puntos MB102 (SKU C-302): para armar todo sin soldar.
- Cables macho macho 40 piezas 20cm (SKU C-411): para las conexiones en la protoboard.
- Multi Tester Digital con Protector MAS-830L (SKU E-301): mide en mA y en la escala de 200 µA, suficiente para ver los 130 µA del deep sleep.
En el original usan una fuente de laboratorio UNI-T y un multímetro CHNT; cualquier fuente de 5 V estable y cualquier multímetro con escala de microamperios cumplen la misma función. Si en vez de la XIAO tienes un ESP32 DevKit con ESP WROOM-32, el código funciona igual cambiando los pines (por ejemplo, el botón en GPIO 33 y el LED en GPIO 2), aunque esa placa tiene un regulador y un conversor USB que consumen bastante más dormidos.
Recursos
- Tutorial original (inglés): basado en How to use ESP32 Deep Sleep Mode for Low Power Consumption, de Anand D en Circuit Digest.
- Repositorio GitHub: Circuit Digest/ESP32-Deep Sleep, con el sketch de deep sleep y el de modo activo para comparar.
- Archivos descargables: código completo en .zip.
- Documentación adicional: modos de sueño en ESP IDF para ESP32-S3, de Espressif.
Versión chilena con componentes en stock local en MechatronicStore.











