ESP32 práctico ahorro de energía: conserva el estado de gpio, externo y...

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

¿Quieres maximizar la eficiencia energética de tu proyecto con ESP32? En este artículo, exploraremos cómo utilizar la función de Deep Sleep con Arduino IDE y diferentes fuentes de activación para lograr un ahorro significativo de energía. ¡Sigue leyendo para descubrir cómo implementar esta característica clave en tus dispositivos con ESP32!

Este artículo es una guía completa para el modo de suspensión profunda de ESP32 utilizando Arduino IDE. Le mostraremos cómo poner el ESP32 en suspensión profunda y veremos diferentes modos para reactivarlo: Temporizador para despertar, Toque DespertarY despertar externo. Esta guía proporciona ejemplos prácticos con código, explicaciones de código y esquemas.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Ver también: ESP8266 Sueño profundo con Arduino IDE

Este artículo se divide en cuatro partes diferenciadas:

  1. Presentamos el modo de suspensión profunda
  2. Temporizador de despertador
  3. Toque Despertar
  4. despertar externo

Presentamos el modo de suspensión profunda

El ESP32 puede cambiar entre diferentes modos de energía:

  • Modo activo
  • Modo de suspensión del módem
  • Modo de sueño ligero
  • Modo de sueño profundo
  • Estado de hibernación

Puede comparar los cinco modos diferentes en la siguiente tabla de la hoja de datos de ESP32 Espressif.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

El Hoja de datos ESP32 Expressif También proporciona una tabla que compara el consumo de energía de los diferentes modos de energía.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

y aqui esta tambien Tabla 10 para comparar el consumo de energía en modo activo:

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

¿Por qué el modo de sueño profundo?

No es ideal hacer funcionar su ESP32 con baterías en modo activo ya que la energía de las baterías se agota muy rápidamente.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Poner su ESP32 en modo de suspensión profunda reducirá el consumo de energía y hará que sus baterías duren más.

Cuando su ESP32 está en modo de suspensión profunda, las actividades que consumen más energía durante la operación se pausan, pero queda suficiente actividad para despertar el procesador cuando sucede algo interesante.

En el modo de suspensión profunda, no se produce ninguna actividad de CPU o Wi-Fi, pero el coprocesador de energía ultrabaja (ULP) aún se puede encender.

Mientras el ESP32 está en modo de suspensión profunda, la memoria RTC también permanece encendida, por lo que podemos escribir un programa para el coprocesador ULP y almacenarlo en la memoria RTC para acceder a periféricos, temporizadores internos y sensores internos.

Este modo de operación es útil cuando necesita reactivar la CPU principal mediante un evento externo, un temporizador o ambos, manteniendo al mismo tiempo el consumo de energía al mínimo.

Pines RTC_GPIO

Durante el sueño profundo, el coprocesador ULP puede utilizar algunos de los pines ESP32, a saber, los pines RTC_GPIO y los pines táctiles. La hoja de datos de ESP32 contiene una tabla con los pines RTC_GPIO. Puedes encontrar esta tabla Aquí en la página 7.

Puede utilizar esta tabla como referencia o echar un vistazo a la distribución de pines a continuación para encontrar los diferentes pines RTC_GPIO. Los pines RTC_GPIO están resaltados con un cuadro rectangular naranja.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Usted también puede estar interesado en: Referencia de distribución de pines de ESP32: ¿Qué pines GPIO debería utilizar?

Fuentes de despertar

Después de poner el ESP32 en modo de suspensión profunda, hay varias formas de reactivarlo:

  1. Puedes utilizar el… TemporizadorDespierte su ESP32 usando períodos de tiempo predefinidos;
  2. Puedes utilizar el… Alfileres táctiles;
  3. Puede Dos opciones para la función de alarma externa: Puede utilizar una alarma externa o varias alarmas externas diferentes;
  4. Puedes utilizar el… coprocesador ULP despertarse; esto no se trata en esta guía.

Escribe un boceto de sueño profundo.

Para escribir un boceto para poner su ESP32 en modo de suspensión profunda y luego reactivarlo, debe tener en cuenta lo siguiente:

  1. Primero necesitas configurar las fuentes de activación. Esto significa que configura lo que debería activar el ESP32. Puede utilizar una o combinar varias fuentes de activación.
  2. Puedes decidir qué periféricos debes apagar o dejar encendidos durante el sueño profundo. Sin embargo, de forma predeterminada, el ESP32 apagará automáticamente los periféricos que no sean necesarios con la fuente de activación que haya definido.
  3. Finalmente, utiliza el esp_deep_sleep_start() Función para poner tu ESP32 en modo de suspensión profunda.

Temporizador de despertador

El ESP32 puede entrar en modo de suspensión profunda y luego despertarse en momentos predefinidos. Esta característica es particularmente útil cuando se ejecutan proyectos que requieren marcas de tiempo o tareas diarias mientras se mantiene bajo el consumo de energía.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

El controlador ESP32 RTC tiene un temporizador incorporado que le permite activar el ESP32 después de un tiempo predefinido.

Habilitar activación del temporizador

Activar el ESP32 después de un período de tiempo predefinido es muy fácil. En el IDE de Arduino, todo lo que necesitas hacer es especificar el tiempo de suspensión en microsegundos en la siguiente función:

esp_sleep_enable_timer_wakeup(time_in_us)

código

Veamos cómo funciona esto con un ejemplo de la biblioteca. Abra su IDE de Arduino y vaya a archivo > Ejemplos > ESP32 > Sueño profundoy ábrelo TemporizadorDespertar bosquejo.

/*
Simple Deep Sleep with Timer Wake Up
=====================================
ESP32 offers a deep sleep mode for effective power
saving as power is an important factor for IoT
applications. In this mode CPUs, most of the RAM,
and all the digital peripherals which are clocked
from APB_CLK are powered off. The only parts of
the chip which can still be powered on are:
RTC controller, RTC peripherals ,and RTC memories

This code displays the most basic deep sleep with
a timer to wake it up and how to store data in
RTC memory to use it over reboots

This code is under Public Domain License.

Author:
Pranav Cherukupalli <[email protected]>
*/

#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) */

RTC_DATA_ATTR int bootCount = 0;

/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
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(115200);
  delay(1000); //Take some time to open up the Serial Monitor

  //Increment boot number and print it every reboot
  ++bootCount;
  Serial.println("Boot number: " + String(bootCount));

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

  /*
  First we configure the wake up source
  We set our ESP32 to wake up every 5 seconds
  */
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
  " Seconds");

  /*
  Next we decide what all peripherals to shut down/keep on
  By default, ESP32 will automatically power down the peripherals
  not needed by the wakeup source, but if you want to be a poweruser
  this is for you. Read in detail at the API docs
  http://esp-idf.readthedocs.io/en/latest/api-reference/system/deep_sleep.html
  Left the line commented as an example of how to configure peripherals.
  The line below turns off all RTC peripherals in deep sleep.
  */
  //esp_deep_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
  //Serial.println("Configured all RTC Peripherals to be powered down in sleep");

  /*
  Now that we have setup a wake cause and if needed setup the
  peripherals state in deep sleep, we can now start going to
  deep sleep.
  In the case that no wake up sources were provided but deep
  sleep was started, it will sleep forever unless hardware
  reset occurs.
  */
  Serial.println("Going to sleep now");
  delay(1000);
  Serial.flush(); 
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop(){
  //This is not going to be called
}

Ver código sin formato

Echemos un vistazo a este código. El primer comentario describe lo que se apaga durante el sueño profundo con la activación del temporizador.

In this mode CPUs, most of the RAM,
and all the digital peripherals which are clocked
from APB_CLK are powered off. The only parts of
the chip which can still be powered on are:
RTC controller, RTC peripherals ,and RTC memories

Cuando utilice la activación del temporizador, se encenderán el controlador RTC, los periféricos RTC y las piezas de memoria RTC.

Definir la hora para conciliar el sueño

Estas dos primeras líneas de código definen la cantidad de tiempo que el ESP32 duerme.

#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) */

Este ejemplo utiliza un factor de conversión de microsegundos a segundos, por lo que puedes calcular el tiempo de descanso en el HORA DE DORMIR Variable en segundos. En este caso, el ejemplo pone el ESP32 en modo de suspensión profunda durante 5 segundos.

Almacenar datos en la memoria RTC

Con el ESP32 puedes almacenar datos en las memorias RTC. El ESP32 tiene 8kB SRAM en la parte RTC, llamada RTC Fast Memory. Los datos almacenados aquí no se eliminan durante el sueño profundo. Sin embargo, se eliminan cuando presiona el botón de reinicio (el botón etiquetado como EN en la placa ESP32).

Para guardar datos en el almacenamiento RTC, solo necesita agregar RTC_DATA_ATTR antes de una definición de variable. El ejemplo salva el recuento de arranque Variable en la memoria RTC. Esta variable cuenta cuántas veces el ESP32 se despertó del sueño profundo.

RTC_DATA_ATTR int bootCount = 0;

razón para despertar

El código define entonces el print_wakeup_reason() Función que devuelve el motivo por el cual el ESP32 se despertó del modo de suspensión.

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;
  }
}

La instalación()

En el configuración() es donde debes poner tu código. En el sueño profundo el boceto nunca llega al Cinta() Expresión. Entonces tienes que poner el boceto completo en el configuración().

Este ejemplo comienza inicializando la comunicación en serie con una velocidad de baudios de 115200.

Serial.begin(115200);

Entonces eso es todo recuento de arranque La variable se incrementa en uno con cada reinicio y este número se imprime en el monitor serie.

++bootCount;
Serial.println("Boot number: " + String(bootCount));

El código luego llama al print_wakeup_reason() función, pero puede llamar a cualquier función que necesite para realizar la tarea deseada. Por ejemplo, es posible que desees activar tu ESP32 una vez al día para leer un valor de un sensor.

A continuación, el código define la fuente de activación mediante la siguiente función:

esp_sleep_enable_timer_wakeup(time_in_us)

Esta función acepta como argumento el tiempo de sueño en microsegundos, como vimos antes.

En nuestro caso tenemos lo siguiente:

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

Una vez completadas todas las tareas, el ESP se pone en modo de suspensión llamando a la siguiente función:

esp_deep_sleep_start()

El arco()

El Cinta() La sección está vacía porque el ESP32 entra en modo de suspensión antes de llegar a esta parte del código. Entonces tienes que poner todo tu boceto en el configuración().

Sube el boceto de ejemplo a tu ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos.

Probando el despertador con temporizador

Abra el monitor serie con una velocidad de baudios de 115200.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Cada 5 segundos el ESP se activa, imprime un mensaje en el monitor serie y vuelve a entrar en sueño profundo.

Cada vez que el ESP se despierta, recuento de arranque Aumentos variables. También imprime el motivo de la activación como se muestra en la imagen a continuación.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Sin embargo, tenga en cuenta que si presiona el botón EN en la placa ESP32, el contador de arranque se restablecerá a 1.

Puede modificar el ejemplo proporcionado y, en lugar de imprimir un mensaje, puede hacer que su ESP realice cualquier otra tarea. La activación del temporizador es útil para usar el ESP32 para realizar tareas periódicas como: B. realizar tareas diarias sin consumir mucha energía.

Toque Despertar

Puede despertar el ESP32 del modo de suspensión profundo utilizando los pines táctiles. Esta sección muestra cómo hacer esto con el IDE de Arduino.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Activar despertador táctil

Activar el ESP32 mediante un toque es fácil. En el IDE de Arduino hay que utilizar la siguiente función:

esp_sleep_enable_touchpad_wakeup()

código

Veamos cómo funciona esto con un ejemplo de la biblioteca. Abra su IDE de Arduino y vaya a archivo > Ejemplos > ESP32 > Sueño profundoy ábrelo TouchWakeUp bosquejo.

/*
  Deep Sleep with Touch Wake Up
  This code displays how to use deep sleep with a touch as a wake up source and how to store data in RTC memory to use it over reboots
  ESP32 can have multiple touch pads enabled as wakeup source
  ESP32-S2 and ESP32-S3 supports only 1 touch pad as wakeup source enabled
  This code is under Public Domain License. Author: Pranav Cherukupalli <[email protected]>
*/

#if CONFIG_IDF_TARGET_ESP32
  #define THRESHOLD   40      /* Greater the value, more the sensitivity */
#else //ESP32-S2 and ESP32-S3 + default for other chips (to be adjusted) */
  #define THRESHOLD   5000   /* Lower the value, more the sensitivity */
#endif

RTC_DATA_ATTR int bootCount = 0;
touch_pad_t touchPin;
/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
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;
  }
}

/*
Method to print the touchpad by which ESP32
has been awaken from sleep
*/
void print_wakeup_touchpad(){
  touchPin = esp_sleep_get_touchpad_wakeup_status();

  #if CONFIG_IDF_TARGET_ESP32
    switch(touchPin)
    {
      case 0  : Serial.println("Touch detected on GPIO 4"); break;
      case 1  : Serial.println("Touch detected on GPIO 0"); break;
      case 2  : Serial.println("Touch detected on GPIO 2"); break;
      case 3  : Serial.println("Touch detected on GPIO 15"); break;
      case 4  : Serial.println("Touch detected on GPIO 13"); break;
      case 5  : Serial.println("Touch detected on GPIO 12"); break;
      case 6  : Serial.println("Touch detected on GPIO 14"); break;
      case 7  : Serial.println("Touch detected on GPIO 27"); break;
      case 8  : Serial.println("Touch detected on GPIO 33"); break;
      case 9  : Serial.println("Touch detected on GPIO 32"); break;
      default : Serial.println("Wakeup not by touchpad"); break;
    }
  #else
    if(touchPin < TOUCH_PAD_MAX)
    {
      Serial.printf("Touch detected on GPIO %dn", touchPin); 
    }
    else
    {
      Serial.println("Wakeup not by touchpad");
    }
  #endif
}

void setup(){
  Serial.begin(115200);
  delay(1000); //Take some time to open up the Serial Monitor

  //Increment boot number and print it every reboot
  ++bootCount;
  Serial.println("Boot number: " + String(bootCount));

  //Print the wakeup reason for ESP32 and touchpad too
  print_wakeup_reason();
  print_wakeup_touchpad();

  #if CONFIG_IDF_TARGET_ESP32 
  //Setup sleep wakeup on Touch Pad 3 + 7 (GPIO15 + GPIO 27) 
  touchSleepWakeUpEnable(T3,THRESHOLD);
  touchSleepWakeUpEnable(T7,THRESHOLD);
  
  #else //ESP32-S2 + ESP32-S3
  //Setup sleep wakeup on Touch Pad 3 (GPIO3) 
  touchSleepWakeUpEnable(T3,THRESHOLD);

  #endif

  //Go to sleep now
  Serial.println("Going to sleep now");
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop(){
  //This will never be reached
}

Ver código sin formato

Estableciendo el umbral

Lo primero que debes hacer es establecer un umbral para los pines táctiles. En este caso fijamos el límite a 40. Dependiendo de su proyecto, es posible que necesite cambiar el umbral. 

#define Threshold 40

Cuando tocas un GPIO sensible al tacto, el valor detectado por el sensor disminuye. Por lo tanto, puede establecer un umbral que desencadene una acción cuando se detecta un toque.

El umbral establecido aquí significa que el ESP32 debería activarse cuando el valor leído por el GPIO sensible al tacto sea inferior a 40. Este valor se puede ajustar según la sensibilidad deseada.

Adjuntar interrupciones

Debe adjuntar interrupciones a los pines sensibles al tacto. Cuando se detecta un toque en un GPIO específico, se ejecuta una función de devolución de llamada. Por ejemplo, mire la siguiente línea: 

//Setup interrupt on Touch Pad 3 (GPIO15)
touchAttachInterrupt(T3, callback, Threshold);

Si el valor leído en T3 (GPIO 15) es menor que el del límite Variable, el ESP32 se despierta y el llamar de vuelta se ejecuta la función.

El Llamar de vuelta() La función solo se ejecuta cuando el ESP32 está activo.

  • Si el ESP32 está durmiendo y tocas T3, el ESP se despertará – el Llamar de vuelta() La función no se ejecutará si simplemente presiona y suelta el pin táctil.
  • Cuando el ESP32 esté activo y toque T3, se ejecutará la función de devolución de llamada. Entonces si tienes el Llamar de vuelta() Cuando activa ESP32, debe mantener presionado el toque de este pin por un momento hasta que se ejecute la función.

En este caso Llamar de vuelta() La función está vacía.

void callback(){
   //placeholder callback function
}

Si desea activar el ESP32 usando diferentes pines táctiles, solo necesita conectar interrupciones a estos pines.

A continuación necesitas hacer el esp_sleep_enable_touchpad_wakeup() Función para configurar los pines táctiles como fuente de activación.

//Configure Touchpad as wakeup source
esp_sleep_enable_touchpad_wakeup()

Esquema

Para probar este ejemplo, conecte un cable GPIO 15como se muestra en la siguiente figura.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

(Este esquema utiliza la versión del módulo ESP32 DEVKIT V1 con 30 GPIO; si está utilizando un modelo diferente, verifique la distribución de pines de la placa que está utilizando).

Probando el ejemplo

Sube el código a tu ESP32 y abre el monitor serial con una velocidad de baudios de 115200.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

El ESP32 entra en modo de suspensión profunda.

Puedes activarlo tocando el cable conectado al Touch Pin 3.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Cuando tocas el pin, el ESP32 muestra lo siguiente en el monitor serial: el número de inicio, el motivo del despertar y en qué GPIO se detectó el toque.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

despertar externo

Además del temporizador y los pines táctiles, también podemos despertar el ESP32 del modo de suspensión profunda cambiando el valor de una señal en un pin, como presionando un botón. A esto se le llama vigilia externa. Tiene dos opciones para la activación externa: ext0 y ext1.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Activación externa (ext0)

Esta fuente de activación le permite activar el ESP32 usando un pin.

La opción de fuente de activación ext0 utiliza GPIO RTC para la activación. Entonces, cuando se solicita esta fuente de activación, los periféricos RTC permanecerán encendidos durante el sueño profundo.

Para utilizar esta fuente de activación, utilice la siguiente función:

esp_sleep_enable_ext0_wakeup(GPIO_NUM_X, level)

Esta función acepta como primer argumento el pin que desea utilizar en este formato GPIO_NUM_Xen el cual X representa el número GPIO de este pin.

El segundo argumento, nivelpuede ser 1 o 0. Esto representa el estado del GPIO que desencadena el despertar.

Nota: Con esta fuente de activación solo puedes usar pines que sean RTC GPIO.

Activación externa (ext1)

Esta fuente de activación le permite utilizar múltiples GPIO RTC. Puede utilizar dos funciones lógicas diferentes:

  • Despierte el ESP32 cuando uno de los pines que seleccionó esté alto;
  • Despierte el ESP32 cuando todos los pines que seleccionó estén bajos.

Esta fuente de activación la implementa el controlador RTC. Por lo tanto, los periféricos RTC y las memorias RTC se pueden apagar en este modo.

Para utilizar esta fuente de activación, utilice la siguiente función:

esp_sleep_enable_ext1_wakeup(bitmask, mode)

Esta función acepta dos argumentos:

  • Una máscara de bits de los números GPIO que provocan la activación;
  • Modo: la lógica para despertar el ESP32. Esto puede ser:
    • ESP_EXT1_WAKEUP_ALL_LOW: Se despierta cuando todos los GPIO bajan;
    • ESP_EXT1_WAKEUP_ANY_HIGH: Despierta cuando uno de los GPIO sube.

Nota: Con esta fuente de activación solo puedes usar pines que sean RTC GPIO.

código

Veamos el ejemplo que viene con la biblioteca ESP32. Ir a archivo > Ejemplos > ESP32 > Sueño profundo > despertar externo:

/*
Deep Sleep with External Wake Up
=====================================
This code displays how to use deep sleep with
an external trigger as a wake up source and how
to store data in RTC memory to use it over reboots

This code is under Public Domain License.

Hardware Connections
======================
Push Button to GPIO 33 pulled down with a 10K Ohm
resistor

NOTE:
======
Only RTC IO can be used as a source for external wake
source. They are pins: 0,2,4,12-15,25-27,32-39.

Author:
Pranav Cherukupalli <[email protected]>
*/

#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex

RTC_DATA_ATTR int bootCount = 0;

/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
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(115200);
  delay(1000); //Take some time to open up the Serial Monitor

  //Increment boot number and print it every reboot
  ++bootCount;
  Serial.println("Boot number: " + String(bootCount));

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

  /*
  First we configure the wake up source
  We set our ESP32 to wake up for an external trigger.
  There are two types for ESP32, ext0 and ext1 .
  ext0 uses RTC_IO to wakeup thus requires RTC peripherals
  to be on while ext1 uses RTC Controller so doesnt need
  peripherals to be powered on.
  Note that using internal pullups/pulldowns also requires
  RTC peripherals to be turned on.
  */
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low

  //If you were to use ext1, you would use it like
  //esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

  //Go to sleep now
  Serial.println("Going to sleep now");
  delay(1000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop(){
  //This is not going to be called
}

Ver código sin formato

Este ejemplo activa el ESP32 cuando GPIO33 demasiado alto. El ejemplo de código muestra cómo utilizar ambos métodos: ext0 y ext1. Si carga el código tal como está, use ext0. Se comenta la función para usar ext1. Le mostraremos cómo funcionan ambos métodos y cómo usarlos.

Este código es muy similar a los anteriores de este artículo. En el configuración()Comience inicializando la comunicación en serie:

Serial.begin(115200); 
delay(1000); //Take some time to open up the Serial Monitor

Luego aumenta uno a eso recuento de arranque variable e imprimir esta variable en el monitor serie.

++bootCount;
Serial.println("Boot number: " + String(bootCount));

A continuación, imprima el motivo del despertar con el print_wakeup_reason() función previamente definida.

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

Luego deberá activar las fuentes de activación. Probamos cada fuente de activación, ext0 y ext1, por separado.

ext0

En este ejemplo, el ESP32 se activa cuando el GPIO33 se activa alto:

esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low

En lugar de GPIO33Puede utilizar cualquier otro pin RTC GPIO.

Esquema

Para probar este ejemplo, conecte un botón a su ESP32 siguiendo el siguiente diagrama de cableado. El botón está conectado a GPIO33 utilizando una resistencia desplegable de 10 K ohmios.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

(Este esquema utiliza la versión del módulo ESP32 DEVKIT V1 con 30 GPIO; si está utilizando un modelo diferente, verifique la distribución de pines de la placa que está utilizando).

Nota: Solo se pueden utilizar RTC GPIO como fuente de activación. En lugar de GPIO 33, también puedes usar cualquier pin RTC GPIO para conectar tu botón.

Probando el ejemplo

Probemos este ejemplo. Cargue el código de muestra a su ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos. Abra el monitor serie con una velocidad de baudios de 115200.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Presione el botón para activar el ESP32.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Pruebe esto varias veces y observe cómo aumenta el número de inicios con cada pulsación de tecla.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Este método es útil para activar su ESP32 con un botón, por ejemplo, para realizar una tarea específica. Sin embargo, este método sólo le permite utilizar un GPIO como fuente de activación.

¿Qué pasa si quieres tener diferentes botones que activen el ESP pero realicen diferentes tareas? Para hacer esto necesitas usar el método ext1.

ext1

Con ext1 puedes activar el ESP usando diferentes botones y realizar diferentes tareas dependiendo del botón presionado.

En lugar de eso esp_sleep_enable_ext0_wakeup() Usa la función esp_sleep_enable_ext1_wakeup() Función. Esta función está comentada en el código:

//If you were to use ext1, you would use it like
//esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

Descomente la función para obtener:

esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

El primer argumento de la función es una máscara de bits de los GPIO que está utilizando como fuente de activación, y el segundo argumento define la lógica para activar el ESP32.

En este ejemplo usamos la variable _KEYPIN-_BITMASKque se definió al principio del código:

#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex

Esto solo define un pin como fuente de activación. GPIO33. Debe cambiar la máscara de bits para configurar GPIO adicionales como fuente de activación.

máscara de bits GPIO

Para obtener la máscara de bits GPIO sigue los siguientes pasos:

  1. Calcule 2^(GPIO_NUMBER). Guarde el resultado como un número decimal.
  2. Ir a rapidtables.com/convert/number/decimal-to-hex.html y convertir el número decimal a un número hexadecimal.
  3. Reemplace el número hexadecimal obtenido en el _KEYPIN-_BITMASK Variable.

Máscara para un solo GPIO

Para ayudarle a comprender cómo obtener la máscara de bits GPIO, veamos un ejemplo. En el código de la biblioteca el botón está conectado a GPIO33. A la máscara para GPIO33:

1. Calcula 2^33. Recibes 8589934592;

2. Convierta este número (8589934592) a un número hexadecimal. Usted también puede este convertidor Para hacer eso:

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

3. Copie el número hexadecimal en el _KEYPIN-_BITMASK variable, y deberías obtener algo como esto:

#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex

Máscara para múltiples GPIO

Si quieres usar GPIO2 Y GPIO 15 Como fuente de activación, debes hacer lo siguiente:

  1. Calcula 2^2 + 2^15. Deberías obtener 32772.
  2. Convierta este número a hexadecimal. Debería obtener: 8004.
  3. Reemplace este número en el _KEYPIN-_BITMASK como sigue:
#define BUTTON_PIN_BITMASK 0x8004

Identificar el GPIO utilizado como fuente de activación

Si utiliza varios pines para activar el ESP32, es útil saber qué pin provocó la activación. Puede utilizar la siguiente función para esto:

esp_sleep_get_ext1_wakeup_status()

Esta función devuelve un número de base 2 con el número GPIO como exponente: 2^(GPIO). Entonces, para obtener el GPIO en decimal necesitas hacer el siguiente cálculo:

GPIO = log(RETURNED_VALUE)/log(2)

Activación externa: múltiples GPIO

Ahora debería poder activar el ESP32 usando diferentes claves e identificar qué tecla causó la activación. En este ejemplo utilizamos GPIO2 Y GPIO 15 como fuente de alerta.

Esquema

Conecte dos botones a su ESP32. En este ejemplo utilizamos GPIO2 Y GPIO 15pero puedes conectar tus botones a cualquier GPIO RTC.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

código

Debe realizar algunos cambios en el código de muestra que usamos antes:

  • Crea una máscara de bits para usar GPIO 15 Y GPIO2. Ya te hemos mostrado cómo hacer esto.
  • Habilite ext1 como fuente de activación.
  • Utilizar el esp_sleep_get_ext1_wakeup_status() Función para obtener el GPIO que activó el despertar.

En el siguiente boceto se implementan todos estos cambios.

/*
Deep Sleep with External Wake Up
=====================================
This code displays how to use deep sleep with
an external trigger as a wake up source and how
to store data in RTC memory to use it over reboots

This code is under Public Domain License.

Hardware Connections
======================
Push Button to GPIO 33 pulled down with a 10K Ohm
resistor

NOTE:
======
Only RTC IO can be used as a source for external wake
source. They are pins: 0,2,4,12-15,25-27,32-39.

Author:
Pranav Cherukupalli <[email protected]>
*/

#define BUTTON_PIN_BITMASK 0x8004 // GPIOs 2 and 15

RTC_DATA_ATTR int bootCount = 0;

/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
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;
  }
}

/*
Method to print the GPIO that triggered the wakeup
*/
void print_GPIO_wake_up(){
  uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
  Serial.print("GPIO that triggered the wake up: GPIO ");
  Serial.println((log(GPIO_reason))/log(2), 0);
}
  
void setup(){
  Serial.begin(115200);
  delay(1000); //Take some time to open up the Serial Monitor

  //Increment boot number and print it every reboot
  ++bootCount;
  Serial.println("Boot number: " + String(bootCount));

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

  //Print the GPIO used to wake up
  print_GPIO_wake_up();

  /*
  First we configure the wake up source
  We set our ESP32 to wake up for an external trigger.
  There are two types for ESP32, ext0 and ext1 .
  ext0 uses RTC_IO to wakeup thus requires RTC peripherals
  to be on while ext1 uses RTC Controller so doesnt need
  peripherals to be powered on.
  Note that using internal pullups/pulldowns also requires
  RTC peripherals to be turned on.
  */
  //esp_deep_sleep_enable_ext0_wakeup(GPIO_NUM_15,1); //1 = High, 0 = Low

  //If you were to use ext1, you would use it like
  esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

  //Go to sleep now
  Serial.println("Going to sleep now");
  delay(1000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop(){
  //This is not going to be called
}

Ver código sin formato

La máscara GPIO se define al principio del código:

#define BUTTON_PIN_BITMASK 0x8004 // GPIOs 2 and 15

Creas una función para imprimir el GPIO que provocó la activación:

void print_GPIO_wake_up(){
  int GPIO_reason = esp_sleep_get_ext1_wakeup_status();
  Serial.print("GPIO that triggered the wake up: GPIO ");
  Serial.println((log(GPIO_reason))/log(2), 0);
}

Y finalmente, habilite ext1 como fuente de activación:

esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

Probando el boceto

Conectado con dos botones. GPIO2 Y GPIO 15Puede cargar el código proporcionado en su ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos.

El ESP32 ahora está en modo de suspensión profunda. Puedes despertarlo presionando los botones.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Abra el monitor en serie con una velocidad de baudios de 115200. Presione los botones para activar el ESP32.

Deberías obtener algo similar en el monitor serie.

ESP32 Deep Sleep con Arduino IDE y fuentes de activación

Envolver

En este artículo te mostramos cómo utilizar el sueño profundo con el ESP32 y cómo despertarlo de diferentes maneras. Puede activar el ESP32 usando un temporizador, los pines táctiles o cambiando el estado de GPIO.

Resumamos lo que vimos sobre cada fuente de estela:

Temporizador de despertador

  • Para activar el temporizador, utilice el esp_sleep_enable_timer_wakeup(hora_en_EE.UU.) Función;
  • Utilizar el esp_deep_sleep_start() Función para inducir el sueño profundo.

Toque Despertar

  • Para usar los pines táctiles como fuente de activación, primero debe adjuntar interrupciones a los pines táctiles usando: touchAttachInterrupt (pin táctil, devolución de llamada, umbral)
  • Luego active los pines táctiles como fuente de activación con: esp_sleep_enable_touchpad_wakeup()
  • Finalmente, utiliza el esp_deep_sleep_start() Función para poner el ESP32 en modo de suspensión profunda.

despertar externo

  • Solo puede utilizar RTC GPIO para activación externa.
  • Puedes utilizar dos métodos diferentes: ext0 y ext1;
  • ext0 te permite activar el ESP32 con un solo pin GPIO;
  • Con ext1 puedes activar el ESP32 a través de múltiples pines GPIO.

Esperamos que esta guía le haya resultado útil. Si desea obtener más información sobre ESP32, asegúrese de consultar todos nuestros proyectos ESP32 y nuestro curso ESP32.

Este es un extracto de nuestro curso: Aprendiendo ESP32 con Arduino IDE. Si te gusta ESP32 y quieres aprender más sobre él, te recomendamos apuntarte al curso Aprende ESP32 con Arduino IDE.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded




Guía Completa para el Modo Deep Sleep con ESP32


Guía Completa para el Modo Deep Sleep con ESP32

Este artículo es una guía completa para el modo Deep Sleep con ESP32 utilizando Arduino IDE. Te mostraremos cómo poner el ESP32 en Deep Sleep y analizaremos diferentes modos para despertarlo: temporizador, sensibilidad al toque y activación externa. Esta guía proporciona ejemplos prácticos con código, explicación del código y esquemas.

Contenido Relacionado:

División del Artículo:

  1. Introducción al Modo Deep Sleep
  2. Despertar por Temporizador
  3. Despertar por Sensibilidad al Tacto
  4. Despertar Externo

Introducción al Modo Deep Sleep

El ESP32 puede alternar entre diferentes modos de consumo de energía, como el modo activo, modo de suspensión de módem, modo de suspensión ligera, modo de Deep Sleep y modo de hibernación. El modo Deep Sleep es ideal para reducir el consumo de energía y prolongar la duración de la batería.

En este modo, se detienen las actividades que consumen más energía mientras se mantiene una actividad mínima para despertar el procesador cuando ocurre algo interesante. Durante el Deep Sleep, ni la CPU ni las actividades de Wi-Fi tienen lugar, pero el coprocesador de Ultra Bajo Consumo (ULP) puede seguir encendido.

Es útil cuando necesitas despertar la CPU principal por un evento externo, temporizador o ambos, manteniendo un consumo mínimo de energía.

Pines RTC_GPIO

Durante el Deep Sleep, algunos pines del ESP32 pueden ser utilizados por el coprocesador ULP, esos son los pines RTC_GPIO y los Pines Táctiles.

Preguntas Frecuentes:

¿Por qué es importante el Modo Deep Sleep?

El modo Deep Sleep es fundamental para reducir el consumo de energía del ESP32, lo que ayuda a que las baterías duren más tiempo y sea ideal para proyectos con dispositivos alimentados por batería.

¿Cuáles son las fuentes para despertar el ESP32 del Deep Sleep?

El ESP32 puede despertarse del Deep Sleep utilizando un temporizador, pines táctiles o activación externa a través de GPIOs específicos definidos como fuentes de despertar.

¡Esperamos que esta guía te haya sido útil para comprender y utilizar el modo Deep Sleep con ESP32!


Related Posts:

3 comentarios en «ESP32 Deep Sleep con Arduino IDE y fuentes de activación»

Deja un comentario