Ce didacticiel montre comment mettre l’ESP32 en mode veille profonde et le réveiller avec une minuterie après une durée prédéterminée. L’ESP32 sera programmé avec Arduino IDE.
Mis à jour le 8 octobre 2024.
Pour en savoir plus sur le sommeil profond et les autres sources de réveil, vous pouvez suivre les tutoriels suivants :
Écrire un croquis de sommeil profond
Pour écrire un croquis pour mettre votre ESP32 en mode veille profonde, puis le réveiller, vous devez :
- Tout d’abord, configurez les sources de réveil. Cela signifie configurer ce qui réveillera l’ESP32. Vous pouvez en utiliser une ou combiner plusieurs sources de réveil. Cet article vous montre comment utiliser le réveil programmé. Utilisez la fonction esp_sleep_enable_timer_wakeup() et passez comme argument le temps de sommeil en microsecondes.
- Vous pouvez décider quels périphériques éteindre ou conserver pendant le sommeil profond. Cependant, par défaut, l’ESP32 éteint automatiquement les périphériques inutiles avec la source de réveil que vous définissez.
- Enfin, vous utilisez la fonction esp_deep_sleep_start() pour mettre votre ESP32 en mode veille profonde.
Minuterie de réveil
L’ESP32 peut passer en mode veille profonde, puis se réveiller à des périodes prédéfinies. Cette fonctionnalité est pratique si vous exécutez des projets nécessitant un horodatage ou des tâches quotidiennes tout en maintenant une faible consommation d’énergie.
Le contrôleur ESP32 RTC dispose d’une minuterie intégrée que vous pouvez utiliser pour réveiller l’ESP32 après une durée prédéfinie.
Activer le réveil programmé
Permettre à l’ESP32 de se réveiller après une heure prédéfinie est très simple. Dans l’IDE Arduino, il vous suffit de spécifier le temps de veille en microsecondes dans la fonction suivante :
esp_sleep_enable_timer_wakeup(time_in_us)Code
Pour programmer l’ESP32, nous utiliserons l’IDE Arduino. Vous devez donc vous assurer que le noyau ESP32 est installé. Suivez le tutoriel suivant si ce n’est pas déjà fait :
Voyons comment fonctionne le sommeil profond avec réveil programmé en utilisant un exemple du noyau ESP32 Arduino. Ouvrez votre IDE Arduino, accédez à Fichier > Exemples > ESP32 > Deep Sleep, puis ouvrez le croquis TimerWakeUp.
/*
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 1000000ULL /* 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: %d\n", 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");
Serial.flush();
esp_deep_sleep_start();
Serial.println("This will never be printed");
}
void loop() {
//This is not going to be called
}
Afficher le code brut
Jetons un coup d’oeil à ce code. Le premier commentaire décrit ce qui est éteint pendant le sommeil profond avec réveil programmé.
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
Lorsque vous utilisez le réveil par minuterie, les éléments qui seront allumés sont le contrôleur RTC, les périphériques RTC et les mémoires RTC.
Définir le temps de sommeil
Ces deux premières lignes de code définissent la période pendant laquelle l’ESP32 sera en veille.
#define uS_TO_S_FACTOR 1000000ULL /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP 5 /* Time ESP32 will go to sleep (in seconds) */Cet exemple utilise un facteur de conversion de microsecondes en secondes, afin que vous puissiez définir le temps de sommeil dans la variable TIME_TO_SLEEP en secondes. Dans ce cas, l’exemple mettra l’ESP32 en mode veille profonde pendant 5 secondes.
Enregistrer les données sur les mémoires RTC
Avec l’ESP32, vous pouvez sauvegarder des données sur les mémoires RTC. L’ESP32 dispose de 8 Ko de SRAM sur la partie RTC, appelée mémoire rapide RTC. Les données enregistrées ici ne sont pas effacées pendant le sommeil profond. Cependant, il est effacé lorsque vous appuyez sur le bouton de réinitialisation (le bouton marqué EN sur la carte ESP32).
Pour sauvegarder des données sur la mémoire RTC, il suffit d’ajouter RTC_DATA_ATTR avant une définition de variable. L’exemple enregistre la variable bootCount sur la mémoire RTC. Cette variable comptera combien de fois l’ESP32 s’est réveillé d’un sommeil profond.
RTC_DATA_ATTR int bootCount = 0;Raison du réveil
Ensuite, le code définit la fonction print_wakeup_reason(), qui imprime la source qui a provoqué le réveil du sommeil profond.
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: %d\n", wakeup_reason); break;
}
}La configuration()
Dans setup(), c’est là que vous devez mettre votre code. Vous devez écrire toutes les instructions avant d’appeler la fonction esp_deep_sleep_start().
Cet exemple commence par initialiser la communication série à un débit en bauds de 115 200.
Serial.begin(115200);Ensuite, la variable bootCount est augmentée de un à chaque redémarrage et ce numéro est imprimé sur le moniteur série.
++bootCount;
Serial.println("Boot number: " + String(bootCount));Ensuite, le code appelle la fonction print_wakeup_reason(), mais vous pouvez appeler n’importe quelle fonction pour effectuer une tâche souhaitée. Par exemple, vous souhaiterez peut-être réveiller votre ESP32 une fois par jour pour lire une valeur provenant d’un capteur.
Ensuite, le code définit la source de réveil en utilisant la fonction suivante :
esp_sleep_enable_timer_wakeup(time_in_us)Cette fonction accepte comme argument le temps de sommeil en microsecondes comme nous l’avons vu précédemment. Dans notre cas, nous avons les éléments suivants :
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);Ensuite, une fois toutes les tâches effectuées, l’ESP32 se met en veille en appelant la fonction suivante :
esp_deep_sleep_start()Dès que vous appelez la fonction esp_deep_sleep_start(), l’ESP32 se mettra en veille et n’exécutera aucun code écrit après cette fonction. Lorsqu’il se réveille d’un sommeil profond, il exécutera le code depuis le début.
boucle()
La section loop() est vide car l’ESP32 se mettra en veille avant d’atteindre cette partie du code. Vous devez donc écrire toutes vos tâches dans setup() avant d’appeler la fonction esp_deep_sleep_start().
Test du réveil programmé
Téléchargez l’exemple de croquis sur votre ESP32. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM. Ouvrez le moniteur série à un débit en bauds de 115 200.
Toutes les 5 secondes, l’ESP32 se réveille, imprime un message sur le moniteur série et se met à nouveau en veille profonde.
Chaque fois que l’ESP32 se réveille, la variable bootCount augmente. Il imprime également la raison du réveil, comme indiqué dans la figure ci-dessous.
Cependant, notez que si vous appuyez sur le bouton EN de la carte ESP32, cela réinitialise le bootCount à 1.
Conclusion
En résumé, nous vous avons montré comment utiliser la source de réveil par minuterie pour réveiller l’ESP32 dans cet appareil.
- Pour activer le réveil par minuterie, vous utilisez la fonction esp_sleep_enable_timer_wakeup(time_in_us) ;
- Utilisez la fonction esp_deep_sleep_start() pour démarrer le sommeil profond.
Vous pouvez modifier l’exemple fourni et au lieu d’imprimer un message, vous pouvez demander à votre ESP32 d’effectuer n’importe quelle autre tâche.
Le réveil par minuterie est utile pour effectuer des tâches périodiques avec l’ESP32 sans consommer beaucoup d’énergie, comme nous le faisons dans les projets suivants :
Enfin, nous avons également un tutoriel sur le sommeil profond avec l’ESP8266 qui pourrait vous intéresser : ESP8266 Deep Sleep with Arduino IDE.
Ceci est un extrait de notre cours : Apprenez l’ESP32 avec l’IDE Arduino. Si vous aimez ESP32 et souhaitez en savoir plus, nous vous recommandons de vous inscrire au cours Apprendre ESP32 avec Arduino IDE.
Cette vidéo vous emmène dans l’histoire de Raspberry Pi :
