Despertar externo del ESP32 desde el sueño profundo

En el mundo de la tecnología, el ESP32 ha revolucionado la forma en que interactuamos con dispositivos electrónicos. En este artículo, exploraremos cómo despertar externamente al ESP32 desde el sueño profundo, una función que permite un ahorro significativo de energía y un mejor rendimiento en nuestras aplicaciones. ¡Sigue leyendo para descubrir todo lo que necesitas saber sobre esta emocionante característica!

Este artículo muestra cómo poner el ESP32 en modo de suspensión profunda y reactivarlo con un despertador externo, como presionar un botón. Usamos Arduino IDE para programar el ESP32 y explicamos cómo usar los métodos ext0 y ext1.

En este artículo cubrimos los siguientes temas:

• cómo poner el ESP32 en modo de suspensión profunda;
• active el ESP32 cambiando el valor de un GPIO (con un botón) usando el método ext0;
• active el ESP32 usando múltiples GPIO con el método ext1;
• Identifique qué GPIO provocó el despertar.

Para obtener más información sobre el sueño profundo y otras fuentes de vigilia, puedes seguir los siguientes tutoriales:

• [Complete Guide] ESP32 Deep Sleep con Arduino IDE y fuentes de activación
• Despierta ESP32 Touch desde el sueño profundo
• Temporizador ESP32 para despertar del sueño profundo

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. En este artículo le mostraremos cómo utilizar la fuente de activación externa.
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.

despertar externo

La activación externa es una de las formas de despertar el ESP32 del sueño profundo. Esto significa que puedes activar el ESP32 alternando el valor de una señal en un pin, como presionar un botón. Tiene dos opciones para la activación externa: ext0 y ext1.

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.

La siguiente imagen muestra el pinout de ESP32 y sus GPIO RTC resaltados en naranja claro (para la placa DOIT ESP32 V1). También puedes echar un vistazo a nuestra guía de referencia ESP32 GPIO.

Piezas requeridas

Para seguir este tutorial necesitarás los siguientes elementos:

• Placa ESP32 DOIT DEVKIT V1 (Leer mejor Placas de desarrollo ESP32)
• 2x pulsadores
• 2x resistencia de 10k ohmios
• tablero de circuitos
• Cables de puente

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Código – Activación externa

Para programar el ESP32 utilizamos Arduino IDE. Por lo tanto, debes asegurarte de tener instalado el complemento ESP32. Siga los siguientes tutoriales para instalar el complemento ESP32 si aún no lo ha hecho:

• Instale ESP32 en Arduino IDE (Windows, Mac OS X, Linux)

Para mostrarle cómo utilizar la fuente de activación externa (ext0), examinemos 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.

Echemos un vistazo rápido al código.

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

configuración()

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 kOhm.

(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 los GPIO RTC se pueden utilizar como fuente de activación. En lugar de GPIO 33, puede usar cualquier pin RTC GPIO para conectar su 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.

Presione el botón para activar el ESP32.

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

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:

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.

Codificar múltiples GPIO – Activación externa

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.

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.

Envolver

El ESP32 se puede despertar del modo de suspensión mediante un temporizador, los pines táctiles o un despertador externo. En este artículo, le mostramos cómo reactivar el ESP32 utilizando un despertador externo. Esto significa que puede activar el ESP32 cuando el valor de un GPIO cambia (de ALTO a BAJO o de BAJO a ALTO).

Para obtener más información sobre Deep Sleep con ESP32, consulte nuestra guía completa: ESP32 Deep Sleep con Arduino IDE y Wake-Up Sources.

Si te gusta ESP32, es posible que también te gusten los siguientes recursos:

• Aprende ESP32 con Arduino IDE (Curso)
• Servidor web ESP32 con BME280 – mini estación meteorológica
• Servidor web ESP32 con Arduino IDE – salidas de control
• Servidor web de temperatura ESP32 DHT11/DHT22

Despertar externo del ESP32 desde el sueño profundo

En este artículo aprenderás cómo poner el ESP32 en modo de sueño profundo y despertarlo con un despertador externo, como al presionar un botón. Utilizaremos Arduino IDE para programar el ESP32 y cubriremos cómo utilizar los métodos ext0 y ext1.

Temas a cubrir:

1. Cómo poner el ESP32 en modo de sueño profundo.
2. Despertar el ESP32 cambiando el valor de un GPIO (con un botón) utilizando el método ext0.
3. Despertar el ESP32 utilizando varios GPIOs mediante el método ext1.
4. Identificar qué GPIO causó el despertar.

¿Cómo escribir un Sketch de Sueño Profundo?

Para escribir un sketch que ponga tu ESP32 en modo de sueño profundo y luego lo despierte, debes tener en cuenta lo siguiente:

• Configurar las fuentes de despertar. Esto significa configurar qué despertará al ESP32. Puedes usar una o combinar varias fuentes de despertar. En este artículo, te mostraremos cómo utilizar la fuente de despertar externa.
• Decidir qué periféricos apagar o mantener encendidos durante el sueño profundo. Sin embargo, de manera predeterminada, el ESP32 apaga automáticamente los periféricos que no se necesitan con la fuente de despertar que defines.
• Finalmente, utilizas la función esp_deep_sleep_start() para poner tu ESP32 en modo de sueño profundo.

Despertar Externo

El despertar externo es una de las formas de despertar al ESP32 del sueño profundo. Esto significa que puedes despertar al ESP32 cambiando el valor de una señal en un pin, como al presionar un botón. Hay dos posibilidades de despertar externo: ext0 y ext1.

Despertar Externo (ext0)

Esta fuente de despertar te permite usar un pin para despertar al ESP32. Opción de fuente de despertar ext0 utiliza RTC GPIOs para despertar, por lo que los periféricos RTC se mantienen encendidos durante el sueño profundo si se solicita esta fuente de despertar.

Para usar esta fuente de despertar, se utiliza la siguiente función:

esp_sleep_enable_ext0_wakeup(GPIO_NUM_X, nivel)

donde X representa el número de GPIO de ese pin y nivel puede ser 1 o 0, que representa el estado del GPIO que provocará el despertar. Ten en cuenta que solo puedes usar pines que sean GPIOs RTC.

Despertar Externo (ext1)

Esta fuente de despertar te permite utilizar múltiples GPIOs RTC. Puedes usar dos funciones lógicas diferentes:

• Despertar al ESP32 si cualquiera de los pines que has seleccionado está alto.
• Despertar al ESP32 si todos los pines que has seleccionado están bajos.

Para usar esta fuente de despertar, se utiliza la siguiente función:

esp_sleep_enable_ext1_wakeup(bitmask, modo)

Donde bitmask son los números de GPIO que causarán el despertar y modo es la lógica para despertar al ESP32. Puedes obtener más información en la guía de referencia de GPIO de ESP32.

¡Esperamos que este artículo te haya sido de ayuda! Para más tutoriales sobre sueño profundo y otras fuentes de despertar, te invitamos a seguir con los siguientes enlaces:

• Guía completa: ESP32 Deep Sleep con Arduino IDE y fuentes de despertar
• ESP32 Touch Wake Up desde el sueño profundo
• ESP32 Temporizador Wake Up desde el sueño profundo