Ahorro de batería con sueño profundo: 20 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

¿Está interesado en usar una batería con su ESP32? Si es así, hoy discutiré información técnica importante sobre este tema. Sabemos que este microcontrolador gasta mucha energía cuando transmite información. Consume cerca de 190 miliamperios. En este video, mostraré cómo conservar energía del ESP32 con la función llamada "SUEÑO PROFUNDO". Configuraremos el chip para ingresar a este modo, aprenderemos las formas de salir de este modo y crearemos un ejemplo que muestre tres formas diferentes de activar el ESP32.

Es importante recordar que la radio gasta mucha energía, en lugar del procesador. El ahorro de energía es muy importante. Esto se debe a que los puntos finales (los circuitos que envían información) a menudo funcionan con baterías y deberían durar hasta cinco años. Hay algunos fabricantes que prometen una duración de hasta diez años, y esto es válido para baterías de alta calidad que no utilizan tanto los terminales. En todos los demás casos, le aconsejo que utilice Deep Sleep para ahorrar energía de su circuito.

Paso 1: Introducción

El ESP32 tiene un modo de ahorro de energía, llamado "Sueño profundo". En este modo, las CPU, la mayoría de la RAM y todos los periféricos con reloj digital se apagan. Las únicas partes del chip que aún se pueden conectar son el controlador RTC, los periféricos RTC (incluido el coprocesador ULP) y las memorias RTC.

Tenemos varias formas de despertar el ESP32 cuando está dormido. Las fuentes de activación se pueden configurar en cualquier momento antes de ingresar al modo de suspensión profunda.

Paso 2: formas de activar el ESP32

Hay cinco formas de activar ESP32:

• Temporizador

• Activación externa (ext0)

• Activación externa (ext1)

• Activación del coprocesador ULP

• Panel táctil

Paso 3: temporizador

El controlador RTC tiene un temporizador incorporado que se puede usar para activar el chip después de un período de tiempo predefinido. El tiempo se especifica con precisión de microsegundos.

esp_deep_sleep_enable_timer_wakeup (uint64_t time_in_us)

time_in_us> es el tiempo en microsegundos

Paso 4: Activación externa (ext0)

El módulo de E / S de RTC contiene lógica para activar la alarma cuando uno de los GPIO de RTC entra en un nivel lógico predefinido. El RTC IO es parte del dominio de potencia de los periféricos RTC, por lo que los periféricos RTC se mantendrán activos durante la suspensión profunda si se solicita esta fuente de activación.

esp_deep_sleep_enable_ext0_wakeup (gpio_num_t gpio_num, int level)

gpio_num> Número GPIO utilizado como fuente de activación. Solo se pueden usar GPIO funcionales de RTC: 0, 2, 4, 12-15, 25-27, 32-39.

nivel> nivel de entrada que activará la alarma (0 = BAJO, 1 = ALTO)

Paso 5: Activación externa (ext1)

El controlador RTC contiene lógica para activar el reloj de alarma utilizando múltiples GPIO RTC.

esp_deep_sleep_enable_ext1_wakeup (máscara uint64_t, modo esp_ext1_wakeup_mode_t)

máscara> máscara de bits de números GPIO que provocarán la activación. En este mapa de bits solo se pueden usar GPIO habilitados para RTC: 0, 2, 4, 12-15, 25-27, 32-39.

modo> seleccione la función lógica utilizada para determinar la condición de activación:

• ESP_EXT1_WAKEUP_ALL_LOW: se despierta cuando todos los GPIO seleccionados están en BAJO

• ESP_EXT1_WAKEUP_ANY_HIGH: se despierta cuando cualquiera de los GPIO seleccionados es ALTO

Paso 6: Activación del coprocesador ULP

El coprocesador ULP puede operar mientras el chip está en suspensión profunda y puede usarse para buscar sensores, monitorear ADC o valores de sensores táctiles capacitivos y activar el chip cuando se detecta un evento específico.

El coprocesador ULP es parte del dominio de potencia de los periféricos RTC y ejecuta el programa almacenado en la memoria lenta RTC. Por lo tanto, los periféricos RTC y la memoria lenta RTC se activarán durante la suspensión profunda si se solicita este modo de activación.

Paso 7: panel táctil

El controlador RTC contiene lógica para disparar la alarma usando los sensores táctiles capacitivos. Sin embargo, la definición del pin táctil es diferente. Debemos utilizar la interrupción táctil para cada uno de los pines deseados.

Después de configurar las interrupciones, habilitamos el modo de despertador para usar los sensores.

// Configurar el panel táctil como fuente de activación esp_sleep_enable_touchpad_wakeup ();

Paso 8: Ingresar al modo de suspensión profunda

Después de configurar un modo de activación, un solo comando para poner el ESP32 en modo de suspensión profunda (gastando 2.5 μA o menos) es suficiente. Destaco aquí que este gasto es del chip ESP y no de la placa, ya que esta última gasta más.

esp_deep_sleep_start ();

Desde este comando, el ESP32 se queda dormido y no ejecuta las siguientes líneas de código, por ejemplo.

Importante: Todos los ajustes de activación deben realizarse antes de ejecutar el comando anterior.

Paso 9: aquí hay más información importante

La siguiente llamada devuelve la causa de la activación de ESP32.

1: EXT0 2: EXT1 3: TEMPORIZADOR 4: TÁCTIL 5: ULP

esp_sleep_get_wakeup_cause ();

Si configuramos el despertador por el touchpad, podemos recuperar qué GPIO que el toque ocurrió a través del comando

esp_sleep_get_touchpad_wakeup_status ();

Cada vez que el ESP32 se activa, volverá a realizar un ciclo a través de la configuración. Por tanto, todas las variables que no estén definidas en la memoria RTC volverán a su estado inicial.

Para mantener las variables en la memoria incluso después de quedarse dormido, use la declaración de variable en el siguiente ejemplo:

// RTC_DATA_ATTR aloca un nivel variable en la memoria RTCRTC_DATA_ATTR int bootCount = 0;

Paso 10: demostración

El video muestra el programa funcionando, de acuerdo con la imagen.

Paso 11: Nodo WiFi MCU-32S ESP-WROOM-32

Paso 12: Montaje

Paso 13: Programa

Ahora crearemos un programa en el que configuraremos el ESP32 para ingresar al modo de suspensión profunda. Esto se activará de tres formas diferentes: una para activación externa (ext0), una para temporizador y otra para panel táctil. No pueden trabajar juntos, así que usaremos una variable que será un contador de la cantidad de veces que el ESP32 dio Boot para configurar la forma de despertar.

Paso 14: Se requiere biblioteca

Para controlar la pantalla OLED, necesitamos una biblioteca externa. Para ello, descargaremos la biblioteca U8g2.

En el IDE de Arduino, vaya al menú Sketch >> Incluir biblioteca >> Administrar bibliotecas….

Paso 15: Bibliotecas y variables

Hemos incluido la biblioteca para controlar la pantalla OLED, así como un constructor de la instancia del controlador de pantalla. Además, asignamos la variable en la memoria RTC. Configuramos la sensibilidad para la aceptación táctil, el factor de conversión de microsegundos por segundos y el tiempo que el ESP32 pasa al modo de suspensión (en segundos).

#include // biblioteca para controlar do display oled

// constructor de la instancia del controlador de visualización // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C visualización (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR aloca un nivel variable en la memoria RTC RTC_DATA_ATTR int bootCount = 0; // sensibilidade para aceitação do toque #define Threshold 40 // fator de conversão de microsegundos para segundos #define uS_TO_S_FACTOR 1000000 // tempo que o ESP32 ficará em modo sleep (em segundos) #define TIME_TO_SLEEP 3

Paso 16: configuración

En Configuración, incrementamos el número de veces que ocurrió el arranque. Llamamos a la función para imprimir el motivo de la bota. Si el número de inicio es PAR, configuramos el ESP32 para que se active mediante el botón (EXT0). Si es un múltiplo de 3, configuramos el ESP32 para que se active después de un tiempo establecido. De lo contrario, configuramos los pines táctiles capacitivos para activar el ESP32. Finalmente, configuramos el Touchpad como la fuente de activación y forzamos al ESP32 a ingresar al modo de suspensión.

configuración vacía () {Serial.begin (115200); retraso (1000); // incrementa el número de veces que o BOOT ocorreu ++ bootCount; configureDisplay (); // chama a função para imprimir o motivo do BOOT print_wakeup_reason (); // se o numero de arranque para configuraciones PAR o ESP32 para despertar através do botão (EXT0) if (bootCount% 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = Alto, 0 = Bajo} // se para multiplo de 3 configuraciones o ESP32 para despertar depois de um tempo definido else if (bootCount% 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // caso contrario configuramos los pinos de touch capacitivo para despertar o ESP32 else {// Interrupción de configuración en Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); // Configurar el panel táctil como fuente de activación esp_sleep_enable_touchpad_wakeup (); } Serial.println (“entrando em modo sleep ); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

Paso 17: Bucle, devolución de llamada y configuración

En el Loop, no tenemos nada que hacer. Luego procedemos a interrumpir la devolución de llamada si tenemos algo que hacer cuando ocurre la interrupción. Respecto a configureDisplay, inicializamos la pantalla y configuramos algunos parámetros. Imprimimos en la pantalla la cantidad de veces que sucedió el Boot.

// nada a se fazer no loopvoid loop () {} // callback das interrupções void callback () {// caso queira fazer algo ao ocorrer a interrupção} void configureDisplay () {// inicializa o muestra e configura algunos parámetros de visualización. empezar(); display.setPowerSave (0); // modo powerSave (0-Off? 1-On) display.setFont (u8x8_font_torussansbold8_u); // fonte utilizada // imprime no display os numero de veceses que aconteceu o BOOT display.drawString (0, 0, "BOOT NUM:"); display.drawString (0, 2, String (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

Paso 18: Print_wakeup_reason (conociendo la Causa del Despertar)

Aquí, tenemos la función para imprimir la causa del despertar del ESP32. Verifique el pin e imprima en la pantalla.

// función para imprimir una causa de ESP32 despertarvoid print_wakeup_reason () {esp_sleep_wakeup_cause_t wakeup_reason; Cadena motivo = ""; wakeup_reason = esp_sleep_get_wakeup_cause (); // recupera una causa do despertar switch (wakeup_reason) {caso 1: motivo = "EXT0 RTC_IO BTN"; rotura; caso 2: motivo = "EXT1 RTC_CNTL"; rotura; caso 3: motivo = "TEMPORIZADOR"; rotura; caso 4: motivo = "TÁCTIL"; rotura; caso 5: motivo = "PROGRAMA ULP"; rotura; predeterminado: motivo = "NO HAY CAUSA DS"; rotura; } Serial.println (motivo); display.clearLine (6); // apaga a linha 6 muestra display.drawString (0, 6, razón.c_str ()); // imprime una causa de despertar sin visualización // se despertó por TOUCHPAD, então vamos a verificar em qual dos pinos ocorreu if (wakeup_reason == 4) {print_wakeup_touchpad (); // verifica o pino e imprime no display}}

Paso 19: Print_wakeup_touchpad (conozca el GPIO Touch)

Ahora, en este paso, tenemos la función de imprimir el pin que se tocó. Recuperamos el GPIO que despertó el ESP32 y lo imprimimos en la pantalla.

// función para imprimir o pino que foi tocadovoid print_wakeup_touchpad () {touch_pad_t touchPin; touchPin = esp_sleep_get_touchpad_wakeup_status (); // recupera o GPIO que despertou o ESP32 String GPIO = ""; cambiar (touchPin) {caso 0: GPIO = "4"; rotura; caso 1: GPIO = "0"; rotura; caso 2: GPIO = "2"; rotura; caso 3: GPIO = "15"; rotura; caso 4: GPIO = "13"; rotura; caso 5: GPIO = "12"; rotura; caso 6: GPIO = "14"; rotura; caso 7: GPIO = "27"; rotura; caso 8: GPIO = "33"; rotura; caso 9: GPIO = "32"; rotura; predeterminado: Serial.println ("Activación no mediante panel táctil"); rotura; } Serial.println ("GPIO:" + GPIO); display.clearLine (7); // apaga a linha 7 mostrar display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // imprime o GPIO}

Paso 20: Descarga los archivos

PDF

INO