Guía para reducir el consumo de energía del ESP32 en un 95%

Si desea crear un proyecto que funcione con baterías, debe asegurarse de que el consumo de energía del ESP32 sea lo más bajo posible para aumentar la vida útil de la batería.

En este artículo, le mostraré cómo reducir el consumo de energía de su placa ESP32 en más del 95%.

Puede reducir el consumo de energía del ESP32 en un 95% si utiliza una tarjeta ESP32 optimizada para un menor consumo de energía, como la Escarabajo de fuego ESP32 en combinación con el modo de energía Deep-Sleep o Hibernation del ESP32 para activar el ESP32 lo menos posible.

Los resultados de la medición del consumo de energía para 6 placas de microcontroladores ESP32 diferentes se resumen en la siguiente tabla.

	Reference [mA]	Light-Sleep [mA]	Deep-Sleep [mA]	Hibernation [mA]
ESP32 – DevKitC	51	10	9	9
Ai-Thinker NodeMCU-32S	55	15.05	6.18	6.18
Adafruit HUZZAH32	47	8.43	6.81	6.80
Sparkfun ESP32 Thing	41	5.67	4.43	4.43
FireBeetle ESP32	39	1.94	0.011	0.008
WiPy 3.0	192	–	0.015	–

Cableado para medir el consumo energético del ESP32

En primer lugar, es importante saber medir el consumo de corriente de cada microcontrolador. La siguiente imagen muestra el cableado entre todos los componentes.

En mi experiencia, estoy usando la fuente de alimentación de mi laboratorio que alimenta la placa ESP32 con un voltaje constante de 5V. Las placas ESP32 tienen un pin de entrada, que le permite alimentar la placa con diferentes rangos de voltaje, todos compatibles con 5V. Este pin de entrada está conectado a la toma de voltaje del banco de energía.

Luego, el pin de tierra (GND) de la placa ESP32 se conecta a la entrada de mi multímetro que mide el flujo de corriente del circuito. Puede usar cualquier multímetro que desee, pero yo estoy usando mi PeakTech 3430 que tiene un puerto USB para conectar el multímetro a la PC para registrar las medidas. Para cerrar el circuito, la salida del multímetro se conecta con el polo de tierra de la fuente de alimentación del laboratorio.

Para el ESP32 – DevKitC y el Sparkfun ESP32 Thing, tuve que presionar el botón de reinicio en la placa del microcontrolador para que las placas funcionen en los modos de suspensión. Solo necesita alimentar las placas desde el banco de energía y reiniciar la placa una vez.
Para el ESP32 – DevKitC, solo fueron posibles las mediciones en modo amperio y no en modo miliamperio.

Descripción general de las placas ESP32 para bajo consumo de energía

Hay muchas placas ESP32 diferentes en el mercado y algunas de ellas ya están optimizadas para un bajo consumo de energía. Por lo tanto, el primer paso es asegurarse de comprar una tarjeta ESP32 que tenga un menor consumo de energía que la tarjeta promedio.

La siguiente tabla muestra las seis placas ESP32 diferentes que utilicé para este tutorial con el microcontrolador incorporado y los pines utilizados para la medición de corriente.

Placa ESP32	Microcontrolador	Pin de entrada	Pin de salida
ESP32 – DevKitC	ESP32	V5	GND
Ai-Thinker NodeMCU-32S	ESP32-S2	5V	GND
Adafruit HUZZAH32	ESP32	USB	GND
Sparkfun ESP32 Thing	ESP32	VUSB	GND
FireBeetle ESP32	ESP32-S2	VCC	GND
WiPy 3.0	ESP32	VIN	GND

Las placas ESP32 tienen un consumo de energía diferente que queremos medir como referencia. Para las mediciones de potencia de referencia, descargué un programa vacío al microcontrolador junto con el script de muestra ESP32 que usa la placa como un escáner WiFi.

La siguiente imagen muestra el consumo de energía del script vacío.

El consumo de corriente de WiPy 3.0 es 192 mA, que es mucho más alto que el consumo de corriente de otras placas ESP32 que están entre 39 mA y 55 mA. La razón es que WiPy 3.0 crea un WiFi local en el inicio que consume mucha energía.

Es importante saber que WiPy 3.0 no es un microcontrolador ESP32 estándar, ya que la placa no es compatible con Arduino IDE y debe programarse con MicroPython. Si no está familiarizado con MicroPython, necesitará mucho tiempo para que WiPy 3.0 funcione para su proyecto.

El FireBeetle ESP32 tiene el menor consumo de energía con 39 mA para el script vacío.

A continuación, queremos ver cuál es el consumo actual cuando el microcontrolador ejecuta el script de ejemplo del escáner WiFi. Dado que el script de muestra es de Arduino IDE y WiPy 3.0 no es compatible con Arduino IDE, no se tomó la siguiente medida para WiPy 3.0.

La siguiente imagen muestra el consumo de energía promedio para el script de escáner WiFi de ejemplo.

Como en la medición anterior, el Ai-Thinker NodeMCU-32S tiene el mayor consumo con 129mA y el FireBeetle ESP32 tiene el menor consumo de energía con 114mA.

Pero, ¿cómo es posible que el consumo de energía difiera entre las placas ESP32 que dependen del mismo microcontrolador?

Hay dos diferencias principales entre las placas ESP32. El primero es el regulador de voltaje utilizado y su eficiencia. La segunda diferencia es si las tarjetas utilizan el microcontrolador ESP32 o el microcontrolador ESP32-S2. Profundicemos en los diferentes reguladores de voltaje y la diferencia entre el microcontrolador ESP32 y ESP32-S2.

Comparación del regulador de voltaje de la placa ESP32

El propósito del regulador de voltaje en la placa ESP32 es proporcionar un voltaje operativo estable de 3.3V para el chip ESP32. Por lo tanto, la tensión de entrada de la placa se transforma y la energía resultante de la diferencia entre la tensión de entrada y la tensión de funcionamiento de 3,3 V se transforma en calor.

Además, si el regulador de voltaje no está funcionando, el regulador consume una corriente de reposo, también conocida como corriente de espera. Cuanto menor es la corriente de reposo del regulador de voltaje, más eficiente es la placa ESP32 y menos energía consume la placa.

La caída de voltaje es la diferencia entre el voltaje de salida y el voltaje de entrada a la que el regulador de voltaje deja de funcionar. En el caso de las placas ESP32, el voltaje de entrada debe ser superior a 3.3 V + voltaje de caída del regulador de voltaje. Cuanto menor sea la caída de voltaje, más tiempo funcionará su placa ESP32 cuando se alimenta con una batería, porque cuando la batería se descarga, el voltaje de la batería cae.

La siguiente tabla muestra las diferentes placas ESP32 con el regulador de voltaje utilizado, la caída máxima de voltaje y la corriente de reposo.

Placa ESP32	Regulador de tensión	Máxima caída de tensión	Corriente de reposo
ESP32 – DevKitC	AMS1117	1,1V @ 800mA	5mA
Ai-Thinker NodeMCU-32S	AMS1117	1,1V @ 800mA	5mA
Adafruit HUZZAH32	AP2112-3.3	0,4V @ 600mA	80µA
Sparkfun ESP32 Thing	AP2112-3.3	0,4V @ 600mA	80µA
FireBeetle ESP32	RT9080-33GJ5	0,31V @ 600mA	4µA
WiPy 3.0	No se sabe

El ESP32 – DevKitC y el Ai-Thinker NodeMCU-32S usan el regulador de voltaje AMS1117 que tiene la caída de voltaje más alta de 1.1V a 800mA y también la corriente de reposo más alta de 5 my.

El Adafruit HUZZAH32 y el Sparkfun ESP32 Thing tienen el AP2112-3.3 incorporado, que tiene una caída de voltaje máxima más baja de 0.4 V a 600 mA y también una corriente de reposo más baja de 80 µA y, por lo tanto, debería tener una ventaja para un menor consumo de energía. .

El mejor regulador de voltaje para bajo consumo de energía es el FireBeetle ESP32, que usa el regulador de voltaje RT9080-33GJ5 con un voltaje de caída de 0.31 V a 600 mA y una corriente de reposo ultra baja de solo 4 µA.

Para WiPy 3.0, no pude encontrar ninguna información sobre el regulador de voltaje utilizado en esta placa ESP32. Por lo tanto, no tengo información sobre la caída de voltaje máxima y la corriente de reposo.

Comparación entre ESP32 y ESP32-S2

Además, el microcontrolador ESP32 incorporado influye en el consumo de energía en general. Existe la primera generación del microcontrolador ESP32 y la segunda generación, llamada ESP-S2. La siguiente tabla muestra las diferencias importantes en el consumo de energía.

Puede encontrar información detallada sobre el microcontrolador en el Hoja de datos ESP32 y el ESP32-S2 Ficha de datos.

	ESP32	ESP32-S2
Año de lanzamiento	2016	2019
Microcontrolador	Xtensa single/dual-core 32-bit LX6	Xtensa single-core 32-bit LX7
Frecuencia de reloj	160/240 MHz	240 MHz
Co-procesador	ULP	ULP (RISC-V)

La primera generación del microcontrolador ESP32 fue lanzada en 2016 por Espressif, que utiliza el microcontrolador Xtensa LX6 de 32 bits de un solo núcleo / doble núcleo. Si el núcleo único está activo, la frecuencia de reloj es de 160 MHz y si el ESP32 está funcionando en modo de código dual, la frecuencia de reloj es de 240 MHz.

La segunda generación, llamada ESP32-S2, se lanzó en 2019 y cuenta con un microcontrolador rápido de un solo núcleo, el Xtensa LX7 de un solo núcleo de 32 bits y también un coprocesador mucho más potente.

Dado que el coprocesador ESP32-S2 se basa en la arquitectura RISC-V, el consumo de energía es mucho menor. El coprocesador ULP está activo cuando el procesador está desactivado en modo de suspensión y consume mucha menos energía que el procesador.

Además, el ESP32-S2 puede apagar el transceptor WiFi cuando no está en uso para ahorrar más energía, pero el WiFi sigue encendido. Esta función es muy útil cuando su proyecto no permite entrar en modo de sueño profundo porque el ESP32-S2 puede mantener la conexión WiFi con el enrutador.

La siguiente tabla muestra el consumo de corriente del ESP32 y ESP32-S2 en los diferentes modos de energía.

Es importante entender que este consumo de corriente se mide en perfectas condiciones y solo para el microcontrolador virgen y no para toda la placa con el ESP32 integrado. Por tanto, la comparación nos da una buena indicación de si una tarjeta ESP32 con un ESP32 o un ESP32-S2 tiene una ventaja cuando se trata de un bajo consumo de energía.

Debido a que también estamos viendo una fuerte dependencia entre el consumo de energía y los modos de energía, estamos interesados ​​en los diferentes modos de energía del microcontrolador ESP32.

Utilice los modos de bajo consumo ESP32 para reducir el consumo de energía

El ESP32 y el EPS-S2 tienen los mismos modos de energía que utilizan tecnologías avanzadas de administración de energía. En la siguiente sección de esta guía, describimos cada modo de energía, vemos qué partes del microcontrolador están activas o inactivas y cómo ingresar a cada modo de energía con código Arduino o para WiPy 3.0 con código en MicroPython.

Hay diferentes fuentes de activación para que el ESP32 vuelva del modo de ahorro de energía. Debido a que queremos enfocarnos en el uso de energía, no profundizamos en las diferentes fuentes de llamadas de atención. Por lo tanto, en la siguiente sección, solo uso el temporizador para establecer una hora específica cuando el ESP32 se activa. Encontrará información detallada sobre los modos de espera, así como todas las fuentes de alarma en el Documentos expresivos.

Debido a que el ESP32 es un microcontrolador de 32 bits, la duración máxima de cada modo de suspensión es el valor máximo de un entero de 32 bits sin signo que es 0xFFFF FFFF o 4294967295 microsegundos, lo que equivale aproximadamente a 71 minutos.

Modem-Sleep para reducir el consumo de energía ESP32

En el modo de espera del módem, se suministra energía al procesador y el ESP32 alterna entre el modo activo y el modo de espera del módem según el uso de la comunicación WiFi. El cambio se realiza automáticamente y la frecuencia del procesador también se cambia automáticamente, según la carga del procesador y el uso de periféricos.

Dado que el ESP32 ingresa automáticamente al modo de energía en espera del módem, no hay función Arduino para ingresar a este modo de energía.

Espera de luz para reducir el consumo de energía del ESP32

Descripción general de las funciones de suspensión ligera del ESP32

El modo de suspensión ligera se diferencia del modo de suspensión del módem solo en que el ESP32 no está activo sino en pausa. Esto significa que la mayor parte de la RAM y la CPU están en un patrón de suspensión. En este modelo, los flip-flops internos no cambian de estado porque esta conmutación consume energía.

Durante el modo de espera, la banda base WiFi está desactivada pero la conexión WiFi permanece activa.

Código del programa ESP32 Light-Sleep

Podemos entrar en modo de suspensión ligera con la siguiente función: esp_light_sleep_start (void). El siguiente código de Arduino muestra cómo ingresar al modo de suspensión ligera

#define uS_TO_S_FACTOR 1000000ULL  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  5        /* Time ESP32 will go to sleep (in seconds) */

void print_wakeup_reason(){
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();

  switch(wakeup_reason)
  {
    case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    default : Serial.printf("Wakeup was not caused by deep sleep: %dn",wakeup_reason); break;
  }
}

void setup(){
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB
  }
}

void loop(){
  print_wakeup_reason(); //Print the wakeup reason for ESP32

  delay(5000);

  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); // ESP32 wakes up every 5 seconds
  
  Serial.println("Going to light-sleep now");
  Serial.flush(); 
  esp_light_sleep_start();
}

En la primera parte del script de Arduino, definimos dos variables para almacenar

• un factor para convertir el tiempo de microsegundos a segundos
• el tiempo en segundos que el ESP32 debería entrar en modo de suspensión ligera

El segundo paso es definir una función, llamada print_wakeup_reason, que nos dice el motivo del despertar del ESP32. Esta función es opcional y no es necesaria para poner el ESP32 en modo de energía. En la función, obtenemos la fuente de activación que causó el despertar del sueño y almacenamos la fuente en la variable wakeup_reason. En la siguiente sección de caso de conmutación, probamos todas las posibles fuentes de activación e imprimimos la fuente para que el EPS32 se active en el monitor en serie.

En la función de configuración establecemos una velocidad en baudios de 9600 que debería ser la misma que en el monitor serial de su Arduino IDE. Dado que el establecimiento de la conexión en serie entre la tarjeta ESP32 y su PC a través de la conexión USB lleva En breve, usamos el bucle while para asegurarnos de que su programa solo continúe cuando la conexión en serie esté lista.

Cuando se establece la conexión en serie, iniciamos la función de bucle e imprimimos el motivo del despertar en el monitor en serie llamando a la función print_wakeup_reason que definimos.

Ahora queremos pasar al modo de espera ligero. Por tanto, primero debemos definir cómo queremos despertarnos. En mi caso, elijo el temporizador para el despertador y la regla de los 5 segundos.

Ahora enviamos el mensaje de que nos vamos a dormir y con la función flush esperamos a que se envíen los datos de comunicación serial y nos quedamos dormidos llamando a la función esp_light_sleep_start.

El monitor de serie muestra la siguiente imagen.

Mediciones del multímetro ESP32 Light-Sleep

El WiPy 3.0 tiene un modo de suspensión ligero, pero en mi caso el consumo de energía no se redujo. Por lo tanto, el siguiente gráfico de barras y tabla muestran el consumo de energía en espera de luz para otras placas ESP32, así como la comparación con la medición de línea de base con un script Arduino vacío.

	Referencia de medición [mA]	Medición de sueño ligero [mA]	Porcentaje de reducción
ESP32 – DevKitC	51	10	-80.39%
Ai-Thinker NodeMCU-32S	55	15.05	-72.64%
Adafruit HUZZAH32	47	8.43	-82.06%
Sparkfun ESP32 Thing	41	5.67	-86.17%
FireBeetle ESP32	39	1.94	-95.03%

Si está interesado en las mediciones del multímetro, las siguientes imágenes son capturas de pantalla directas del flujo de corriente a lo largo del tiempo para cada placa de microcontrolador.

ESP32 – DevKitC

NodeMCU-32S Ai-Thinker

Adafruit HUZZAH32

Sparkfun ESP32 cosa

Escarabajo de fuego ESP32

La placa ESP32 que consume más corriente en modo de espera ligero es el Ai-Thinker NodeMCU-32S con 15.05mA, pero en comparación con la medición de referencia con el script Arduino vacío, la reducción de corriente es -72, 64%.

El porcentaje de reducción general más alto y el consumo de energía absoluto más bajo en el modo de espera ligero tiene el FireBeetle ESP32 con 1.94mA (-95.03%).

Todas las demás placas basadas en microcontroladores ESP32 son capaces de reducir su consumo de corriente entre un 80% y un 87%. Por lo tanto, si puede usar el modo de suspensión ligero en su proyecto con energía de la batería, la vida útil de la batería aumenta significativamente.

Hibernar para reducir el consumo de energía del ESP32

Descripción general de las funciones de sueño profundo del ESP32

En el modo de suspensión ligera, el ESP32 Core está en pausa y, después de un modelo de suspensión, el ESP32 Core está completamente inactivo durante el modo de energía de suspensión profunda. Solo el coprocesador ULP y el RTC permanecen activos.

Durante el modo de hibernación, la conexión WiFi no está activa, pero los datos de configuración WiFi se almacenan en la memoria del reloj de tiempo real. Por lo tanto, restablecer la conexión WiFi después de despertar el ESP32 del modo de hibernación es muy rápido.

Código del programa ESP32 Deep-Sleep

El siguiente código de Arduino le muestra cómo ingresar al modo de hibernación. Para WiPy 3.0, encontrará el código MicroPython en el Tutoriales de Pycom.

#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  5        /* Time ESP32 will go to sleep (in seconds) */

void print_wakeup_reason(){
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();

  switch(wakeup_reason)
  {
    case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    default : Serial.printf("Wakeup was not caused by deep sleep: %dn",wakeup_reason); break;
  }
}

void setup(){
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB
  }

  print_wakeup_reason(); //Print the wakeup reason for ESP32

  delay(5000);
  
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); // ESP32 wakes up every 5 seconds

  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON); // all RTC Peripherals are powered
  
  Serial.println("Going to deep-sleep now");
  Serial.flush(); 
  esp_deep_sleep_start();
}

void loop(){
}

La mayor parte del código de Arduino es el mismo que el código de espera de luz. Definimos las mismas variables y la función para imprimir el motivo del despertador.

Dado que el ESP32 inicia la función de configuración cada vez que el microcontrolador sale de la hibernación, estamos configurando todo nuestro código en la función de configuración y no usando la función de bucle invertido.

Después de configurar la velocidad en baudios y esperar la comunicación en serie, se llama a la función para el motivo de activación. Al igual que el modo de reposo ligero, definimos que el EPS32 debería activarse cuando el temporizador expire.

Para el modo de hibernación, podemos establecer si todos los dispositivos PSTN están encendidos o apagados. En el archivo de configuración en espera, definimos que los módulos RTC como RTC IO, sensores y coprocesador ULP permanecen activos.

El modo de energía de hibernación comienza con la función esp_deep_sleep_start. La siguiente imagen muestra el monitor serial para el script Arduino en sueño profundo.

Mediciones del multímetro de sueño profundo ESP32

Al igual que con el modo de suspensión ligera, queremos saber cuánta corriente consume cada placa ESP32 durante la fase de suspensión profunda y también si podemos reducir aún más el consumo de energía. Los siguientes gráficos de barras muestran el consumo actual de todas las placas ESP32 durante la fase de hibernación.

La siguiente tabla muestra la comparación del consumo de corriente del sueño profundo con la medición de referencia.

	Measurement Reference [mA]	Measurement Deep Sleep [mA]	Percentage Reduction
ESP32 – DevKitC	51	9	-82.35%
Ai-Thinker NodeMCU-32S	55	6.18	-88.76%
Adafruit HUZZAH32	47	6.81	-85.51%
Sparkfun ESP32 Thing	41	4.43	-89.20%
FireBeetle ESP32	39	0.011	-99.97%
WiPy 3.0	192	0.015	-99.99%

Las siguientes imágenes del multímetro muestran la verificación de cada placa de microcontrolador.

ESP32 – DevKitC

Ai-Thinker NodeMCU-32S

Adafruit HUZZAH32

Sparkfun ESP32 Thing

FireBeetle ESP32

WiPy 3.0

Ahora podemos ver qué tarjetas ESP32 se toman en serio el consumo mínimo de energía. El FireBeetle ESP32 y WiPy 3.0 consumen menos de 0.015mA en modo de hibernación. Todas las demás tarjetas consumen más de 400 veces la corriente.

Una de las razones del menor consumo de corriente es la construcción de reguladores de voltaje que tienen una menor corriente de reposo.

Hibernación para reducir el consumo de energía del ESP32

El WiPy 3.0 no tiene la opción de pasar al modo de energía de hibernación y, por lo tanto, no se tiene en cuenta en este modo de energía.

Descripción general de las funciones de hibernación ESP32

El modo de energía de hibernación es el modo de energía con el menor consumo de corriente. Un microcontrolador ESP32 virgen consume solo 5µA. El oscilador interno de 8 MHz y el coprocesador ULP están desactivados y la memoria de recuperación RTC está apagada. Solo un temporizador RTC en el reloj lento y algunos GPIO RTC están activos. El temporizador RTC o los GPIO RTC pueden sacar el chip del modo de hibernación.

Código del programa de hibernación ESP32

Para entrar en modo Power Hibernation, usamos el mismo script de Arduino que el modo de hibernación, pero seleccionamos que todos los dispositivos RTC estén deshabilitados. Por lo tanto, solo cambiamos el archivo de configuración de suspensión a:

esp_sleep_pd_config (ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);

Mediciones del multímetro de hibernación ESP32

El siguiente gráfico de barras y la tabla muestran el consumo de energía de las placas ESP32 en modo de hibernación.

	Referencia de medición [mA]	Hibernación Sueño Profundo [mA]	Porcentaje de reducción
ESP32 – DevKitC	51	9	-82.35%
Ai-Thinker NodeMCU-32S	55	6.18	-88.76%
Adafruit HUZZAH32	47	6.80	-85.53%
Sparkfun ESP32 Thing	41	4.43	-89.20%
FireBeetle ESP32	39	0.008	-99.98%

A partir de los datos, verá que solo hay cambios menores desde el modo de hibernación. Sin embargo, para Adafruit HUZZAH32 y FireBeetle ESP32, el consumo de corriente se puede reducir aún más a través del modo de hibernación. Para ESP32 – DevKitC, Ai-Thinker NodeMCU-32S y Sparkfun ESP32 Thing, la medición no muestra diferencia.

Aumente el tiempo de espera para reducir el consumo de energía

Aprendimos dos lecciones importantes del último capítulo, que nos ayudan a reducir aún más el consumo de energía de todo nuestro proyecto ESP32.

1. Establecer una conexión WiFi y enviar datos a través de WiFi tiene un consumo de energía muy alto
2. En modo Dee-Sleep o Hibernación, el consumo de energía del ESP32 es significativamente menor.

Por lo tanto, el consumo de energía se puede reducir si las fases individuales (despertar, enviar datos a través de WiFi, standby) se planifican con precisión.

Las diferentes fases se pueden describir claramente usando el ejemplo de una estación meteorológica:
El ESP32 está conectado a un sensor de temperatura y humedad DHT22. Si transmitimos la temperatura y la humedad cada 10 segundos, el consumo de energía será innecesariamente alto, porque la mayoría de las veces se transmiten los mismos valores medidos.

El consumo de energía se puede reducir transmitiendo lecturas solo cada 10 minutos en lugar de cada 10 segundos. Con esto hemos ampliado el tiempo de la oveja. Para reducir la cantidad de conexiones WiFi, cada vez que se despierta del modo de suspensión, los valores actuales del sensor se pueden comparar con los últimos valores enviados, para enviar nuevos datos a través de WiFi solo si la temperatura o la humedad han cambiado.

Para almacenar variables en modo de espera, deben cargarse en la memoria RTC, que es solo 8KB en ESP32. Solo necesita agregar RTC_DATA_ATT delante de la variable.

RTC_DATA_ATT int temperature;
RTC_DATA_ATT int humidity;

Resumen: así es como redujo el consumo de energía del ESP32

La siguiente tabla muestra una descripción general de todas las medidas que hice para las 6 placas ESP32 diferentes. El script Arduino vacío es la medida de referencia para todas las placas. Cabe señalar que WiPy 3.0 configura WiFi local de forma predeterminada y es por eso que el consumo de energía en la medición de línea de base es mucho mayor en comparación con otras tarjetas ESP32.

	Referencia [mA]	Light-Sleep [mA]	Deep-Sleep [mA]	Hibernation [mA]
ESP32 – DevKitC	51	10	9	9
Ai-Thinker NodeMCU-32S	55	15.05	6.18	6.18
Adafruit HUZZAH32	47	8.43	6.81	6.80
Sparkfun ESP32 Thing	41	5.67	4.43	4.43
FireBeetle ESP32	39	1.94	0.011	0.008
WiPy 3.0	192	–	0.015	–

Si comparamos el ESP32 – DevKitC y el Ai-Thinker NodeMCU-32S que solo tienen la mayor diferencia en la versión del chip ESP32, vemos que el ESP32-S2 ayuda a reducir el consumo de energía por hibernación e hibernación. modo de 9mA a 6.18mA.

El Adafruit HUZZAH32 tiene un regulador de voltaje incorporado con mayor eficiencia, pero el ESP32-S2 no. Por lo tanto, el consumo de corriente es menor que el de ESP32 – DevKitC pero mayor que el de Ai-Thinker NodeMCU-32S.

Curiosamente, el Sparkfun ESP32 Thing usa el mismo regulador de voltaje y microcontrolador ESP32 que el Adafruit HUZZAH32, pero tiene un consumo de energía significativamente menor:

• Referencia: -12.77%
• Espera de luz: -32,74%
• Sueño profundo: -34,95%
• Hibernación: -34,85%

Por lo tanto, sabemos que el regulador de voltaje y el microcontrolador ESP32 no son los únicos factores que influyen en el consumo de energía de la placa ESP32.

Si está buscando una placa ESP32 que consuma muy poca corriente, le recomiendo usar el FireBeetle ESP32 si está familiarizado con el IDE de Arduino y sus bibliotecas. Pero si desea probar algo nuevo y está familiarizado con MicroPython, también puede usar WiPy 3.0 para un proyecto de bajo consumo.

Si desea utilizar una batería para alimentar la placa del microcontrolador, el FireBeetle ESP32 tiene un conector JST estándar de 2 pines. Si desea conectar una batería de iones de litio con conector JST a WiPy 3.0, debe utilizar una tarjeta de expansión como la Tarjeta de expansión 3.0.

Si tiene alguna pregunta con respecto al consumo de energía del ESP32 en general o los diversos modos de bajo consumo, use la sección de comentarios a continuación para hacer su pregunta. Les responderé lo antes posible.

También tengo un tutorial para reducir el consumo de energía del ESP8266 o el Arduino.