- Requisitos
- Diagrama del circuito del modo de suspensión del ESP32
- Descripción general de los modos de suspensión en ESP32
- Programación del ESP32 para el modo de sueño profundo
- Prueba de ESP32 en modo de suspensión profunda
ESP32 es uno de los módulos de microcontroladores basados en Wi-Fi más populares y es una opción popular en muchas aplicaciones de IoT portátiles. Es un controlador potente que admite la programación de doble núcleo y también tiene soporte integrado de Bluetooth Low Energy (BLE), lo que lo convierte en una buena opción para aplicaciones portátiles como dispositivos iBeacon, rastreadores GPS, etc., la principal preocupación es la batería de respaldo. Esta batería de respaldo se puede aumentar mediante un control más inteligente sobre la unidad del microcontrolador, como se puede programar el ESP32 en modo de suspensión durante la condición ideal para aumentar la batería de respaldo del dispositivo.
En este proyecto, comprobaremos el consumo actual de la unidad de microcontrolador ESP32 habilitada para Wi-Fi y Bluetooth ampliamente popular en modo de trabajo normal y modo de suspensión profunda. Además, probaremos la diferencia y comprobaremos cómo poner el ESP32 en modo de sueño profundo. También puede consultar el artículo sobre cómo minimizar el consumo de energía en los microcontroladores para obtener otros consejos que se pueden utilizar para hacer que su diseño sea mucho más eficiente. Además, si está interesado en el modo de suspensión de otros microcontroladores, puede comprobar el modo de suspensión de Arduino y el modo de suspensión de ESP8266 NodeMCU también.
Requisitos
Para hacer esto, usaremos Devkit V4.0 basado en ESP32 de Espressif que tiene un puente USB a UART, así como otros pines ESP32 para una fácil conexión. La programación se realizará con Arduino IDE. Si es completamente nuevo, para comenzar con ESP32 usando Arduino, lea el artículo vinculado antes de continuar.
Los requisitos de este proyecto son los siguientes:
- Entrará en el modo de sueño profundo presionando un botón.
- Se despertará del modo de sueño profundo presionando otro botón.
- Para detectar el estado del ESP32, un LED parpadeará con un tiempo de encendido de 1000 milisegundos. Durante el modo de suspensión, se apagará.
Por lo tanto, se requieren componentes adicionales:
- LED - 1 pieza
- Pulsador (interruptor táctil) - 2 piezas
- Resistencias de 4.7k - 2 piezas
- Resistencia 680R - 1 pieza
- Tablero de circuitos
- Conectar cable
- Adaptador de 5V o fuente de alimentación
- Un cable micro-USB
- Arduino IDE con interfaz de programación ESP32 en una PC o Laptop.
Diagrama del circuito del modo de suspensión del ESP32
A continuación se muestra el esquema para poner el ESP32 en reposo con el botón pulsador.
El esquema es bastante simple. Tiene dos botones. El botón de reposo pondrá el ESP32 en modo de reposo profundo y se utilizará otro interruptor para reactivar el ESP32 del modo de reposo. Ambos botones están conectados en PIN 16 y PIN 33. Ambos botones se configuran como activo bajo cuando se presionan, por lo que se da un pull-up adicional. Sin embargo, para detectar si el ESP 32 está en modo de suspensión o en modo de condiciones de trabajo normales, el LED está conectado al Pin 4 de IO.
Descripción general de los modos de suspensión en ESP32
Hay muchos modos de energía diferentes para ESP32, a saber , modo activo, modo de suspensión del módem, modo de suspensión ligera, modo de suspensión profunda y modo de hibernación.
Durante las condiciones normales de trabajo, el ESP32 funciona en modo activo. Durante el modo activo de ESP32, la CPU, el hardware WiFi / BT, la memoria RTC y los periféricos RTC, los coprocesadores ULP, todos se activan y funcionan según la carga de trabajo. Sin embargo, en diferentes modos de energía, uno o más periféricos están apagados. Para verificar las diferentes operaciones del modo de energía, siga la siguiente tabla:
|
Hardware |
Modo activo |
Modo de suspensión del módem |
Modo de reposo ligero |
Modo de sueño profundo |
Hibernación |
|
UPC |
EN |
EN |
PAUSA |
APAGADO |
APAGADO |
|
WiFi / BT |
EN |
APAGADO |
APAGADO |
APAGADO |
APAGADO |
|
Periféricos RTC y RTC |
EN |
EN |
EN |
EN |
APAGADO |
|
Procesador ULP-Co |
EN |
EN |
EN |
ENCENDIDO APAGADO |
APAGADO |
Como podemos ver en la tabla anterior, en el modo de suspensión profunda ESP32 que a menudo se denomina patrón monitoreado por el sensor ULP: la CPU, WiFi / BT, la memoria RTC y los periféricos, los coprocesadores ULP están todos apagados. Solo se encienden la memoria RTC y los periféricos RTC.
Durante la situación de despertar, el ESP32 necesita ser notificado por una fuente de despertador que despertará al ESP32 del modo de suspensión profunda. Sin embargo, dado que los periféricos RTC están encendidos, el ESP32 se puede reactivar a través de GPIO habilitados para RTC. Hay otras opciones tambien. Puede activarse a través de pines de interrupción de activación externos o mediante un temporizador para activar el ESP32. En este proyecto, estamos usando ext0 wakeup en el pin 33.
Programación del ESP32 para el modo de sueño profundo
El programa completo se puede encontrar al final de esta página. Está escrito para Arduino IDE y, por lo tanto, puede adaptarse fácilmente a sus requisitos. La explicación del código es la siguiente.
Al principio del código, // Crea una variable PushButton PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // definir Led Pin uint8_t led_pin = GPIO_NUM_4; // definir el pin de activación uint8_t wakeUp_pin = GPIO_NUM_33;
Las tres líneas anteriores definen el pin de activación, el pin de LED y el pin de modo de suspensión.
void setup () { // ponga su código de configuración aquí, para que se ejecute una vez: // establezca el puerto serie en 115200 Serial.begin (115200); retraso (1000); // establece el pin pushButton como entrada con PullUp pinMode interno (pushBtn.pin, INPUT_PULLUP); // establece el controlador de interrupción con el pin pushButton en modo Falling attachInterrupt (pushBtn.pin, isr_handle, FALLING); // establece el pin Led como salida pinMode (led_pin, OUTPUT); // crea una tarea que se ejecutará en la función blinkLed (), con prioridad 1 y se ejecutará en el núcleo 0 xTaskCreate ( blinkLed, / * Task function. * / "blinkLed", / * nombre de la tarea. * / 1024 * 2, / * Tamaño de pila de la tarea * / NULL, / * parámetro de la tarea * / 5, / * prioridad de la tarea * / & taskBlinkled); / * Identificador de tareas para realizar un seguimiento de la tarea creada * / delay (500); // Configure el Pin 33 como fuente de activación ext0 con nivel lógico BAJO esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }
En lo anterior, el fragmento de código establece la interrupción en un modo descendente
attachInterrupt (pushBtn.pin, isr_handle, FALLING);
Por lo tanto, siempre que se presione el interruptor, el nivel lógico cambiará de 1 lógico (3,3 V) a 0 lógico (0 V). El voltaje del pin del botón caerá y el ESP32 identificará que el interruptor está presionado. También hay una tarea creada para hacer parpadear el LED.
xTaskCreate ( blinkLed, / * Función de tarea. * / "blinkLed", / * nombre de la tarea. * / 1024 * 2, / * Tamaño de pila de la tarea * / NULL, / * parámetro de la tarea * / 5, / * prioridad de la tarea * / & taskBlinkled); / * Identificador de tareas para realizar un seguimiento de la tarea creada * / delay (500);
El pin 33 también se configura utilizando el siguiente fragmento de código como fuente de activación externa identificada como ext0.
esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);
A continuación, en el bucle while-
void loop () { // ponga su código principal aquí, para que se ejecute repetidamente: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Suspender la tarea 'blinkLed' \ n"); // Suspender la tarea blinkLed vTaskSuspend (taskBlinkled); digitalWrite (led_pin, BAJO); Serial.printf ("Yendo a dormir….. \ n", pushBtn.pin); pushBtn.pressed = falso; // Vete a dormir ahora esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); switch (wakeupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("usando la señal externa ext0 para WakeUp From sleep"); romper; case ESP_SLEEP_WAKEUP_EXT1: Serial.println ("usando la señal externa ext1 para WakeUp From sleep"); romper; case ESP_SLEEP_WAKEUP_TIMER: Serial.println ("usando la señal del temporizador para WakeUp From sleep"); romper; case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("usando la señal del TouchPad para WakeUp From sleep"); romper; case ESP_SLEEP_WAKEUP_ULP: Serial.println ("usando la señal ULP para WakeUp From sleep"); romper; predeterminado: descanso; Serial.printf ("Reanudar la tarea 'blinkLed' \ n"); // reinicia la Tarea blinkLed vTaskResume (taskBlinkled); } }
El ciclo while comprueba constantemente si el botón de reposo está pulsado o no. Si se presiona el botón, detendrá o suspenderá la tarea de parpadeo del LED y ejecutará la función de inicio de sueño profundo esp-
esp_deep_sleep_start ();
En esta situación, si se presiona el botón de interrupción externa ext0, se despertará inmediatamente del modo de suspensión profunda y reanudará la tarea de parpadeo del led.
Por último, la función de parpadeo del LED se puede ver en los siguientes fragmentos, parpadeará el LED 1000 ms segundos.
void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // alternar el valor del pin pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * Simplemente cambie el LED cada 1000ms o 1seg * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }
Prueba de ESP32 en modo de suspensión profunda
El circuito está construido en una placa de pruebas y se utiliza un multímetro de edición Metravi XB para medir la corriente. La corriente consumida por el circuito en modo activo es de casi 58 mA, pero en el modo de reposo profundo, la corriente es de casi 4,10 mA. La siguiente imagen muestra el consumo de corriente del modo activo ESP32 -
En el modo de sueño profundo, el consumo de corriente se registra caído a alrededor de 3.95mA, la siguiente imagen muestra el consumo de corriente del modo de sueño profundo ESP32-
Sin embargo, en el modo de suspensión profunda, el consumo de corriente del ESP32 es de casi 150 uA. Pero el consumo de corriente registrado para esta placa ESP32 Devkit es de casi 4,10 mA. Esto se debe al CP2102 y al regulador lineal. Estos dos están conectados a la línea de alimentación de 5V. También hay un LED de alimentación conectado en la línea de alimentación que consume casi 2 mA de corriente.
Por lo tanto, se puede identificar fácilmente que el ESP32 consume una cantidad muy baja de energía en la condición de modo de suspensión profunda que es muy útil para operaciones con batería. Para obtener más información sobre cómo funcionó, consulte el video vinculado a continuación. Si tiene alguna pregunta, déjela en la sección de comentarios a continuación o use nuestros foros para otras preguntas técnicas.