En este artículo, exploraremos cómo utilizar un temporizador con un ESP32 para despertar de manera eficiente del modo de bajo consumo conocido como sueño profundo. El ESP32 es un microcontrolador de alto rendimiento que ofrece una solución perfecta para controlar el tiempo de activación y desactivación de dispositivos de forma programada. Acompáñanos en este emocionante viaje hacia el mundo de la programación y la tecnología para maximizar el rendimiento de tus proyectos. ¡Vamos a despertar del sueño profundo con el ESP32!
Este tutorial muestra cómo poner el ESP32 en modo de suspensión profunda y reactivarlo después de un tiempo predeterminado usando un temporizador. El ESP32 está programado con Arduino IDE.
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
- Despertar externo del ESP32 desde el sueño profundo
- Despierta ESP32 Touch desde el 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 hacer lo siguiente:
- Primero, configure las fuentes de activación. Es decir, configurar qué debería activar el ESP32. Puede utilizar una o combinar varias fuentes de activación. En este artículo, le mostraremos cómo utilizar el proceso de activación con temporizador.
- 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.
- 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.
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
Para programar el ESP32 utilizamos Arduino IDE. Por lo tanto, debes asegurarte de tener instalado el complemento ESP32. Siga uno de 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)
Veamos cómo funciona Deep Sleep con Timer Wake Up usando 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
}
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 ESP32 entra 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().
Probando el despertador con temporizador
Sube el boceto de ejemplo a tu ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos.
Abra el monitor serie con una velocidad de baudios de 115200.
Cada 5 segundos el ESP32 se activa, imprime un mensaje en el monitor serie y vuelve a entrar en sueño profundo.
Cada vez que el ESP32 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.
Sin embargo, tenga en cuenta que si presiona el botón EN en la placa ESP32, el contador de arranque se restablecerá a 1.
Envolver
Esperamos que este tutorial te haya resultado útil. Ahora puedes modificar el ejemplo proporcionado y en lugar de imprimir un mensaje, puedes hacer que tu ESP32 realice cualquier otra tarea.
Habilitar el temporizador es útil para usar el ESP32 para realizar tareas periódicas sin consumir mucha energía, como lo hacemos en los siguientes proyectos:
- Temperatura de registro de datos ESP32 a la tarjeta MicroSD
- ESP32 publica valores de sensores en Google Sheets
Por último, también tenemos un tutorial sobre sueño profundo con el ESP8266 que te puede interesar: ESP8266 Deep Sleep con Arduino IDE.
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.
Configuración del temporizador ESP32 para despertar del sueño profundo
Este tutorial muestra cómo poner el ESP32 en modo de sueño profundo y despertarlo con un temporizador después de un tiempo predeterminado. El ESP32 se programará con Arduino IDE.
Preguntas frecuentes:
-
¿Qué fuentes de despertar se pueden utilizar con el ESP32?
Puedes configurar varias fuentes de despertar para el ESP32. En este tutorial, nos enfocamos en el despertar mediante temporizador.
-
¿Cómo se habilita el temporizador de despertar en el ESP32?
Para habilitar que el ESP32 se despierte después de un tiempo predeterminado, simplemente especifica el tiempo de espera en microsegundos en la función
esp_sleep_enable_timer_wakeup(tiempo_en_us)
. -
¿Cómo se puede guardar información en las memorias RTC del ESP32?
Para guardar datos en las memorias RTC del ESP32, utiliza el atributo
RTC_DATA_ATTR
antes de la definición de la variable que deseas guardar. -
¿Qué tareas pueden realizarse con el ESP32 en modo de sueño profundo?
El modo de sueño profundo con temporizador es útil para realizar tareas periódicas con el ESP32 sin consumir mucha energía. Puedes realizar diversas tareas, como el registro de datos de temperatura o publicar lecturas de sensores en Google Sheets.
Para aprender más sobre el sueño profundo y otras fuentes de despertar, te recomendamos seguir los tutoriales mencionados al comienzo de este artículo. Puedes encontrar ejemplos de código y explicaciones detalladas sobre el funcionamiento del temporizador de despertar en el ESP32.
¡Qué genial! Nunca pensé que un ESP32 podría ser tan útil para despertar de forma más inteligente. ¡Gracias por la idea!
¡Muy útil la idea! Nunca está de más usar la tecnología para despertar de forma inteligente. ¡Gracias por la sugerencia!
¡Qué interesante! Nunca había pensado en usar un ESP32 para despertar del sueño profundo. ¡Gracias por compartir la información!
¡Vaya, qué invento más útil! Nunca se me habría ocurrido usar un ESP32 para despertar, definitivamente una idea brillante. ¡Gracias por compartir la información!