Réveil externe ESP32 après un sommeil profond

Cet article montre comment mettre l’ESP32 en mode veille profonde et le réveiller avec un réveil externe. Une source de réveil externe peut être la pression d’un bouton-poussoir, la détection de mouvement ou d’autres scénarios impliquant la modification de la valeur d’un signal : de HAUT à BAS ou de BAS à HAUT.
Vous disposez de deux possibilités de réveil externe : ext0 et ext1.

Mis à jour le 8 octobre 2024.

Tout au long de cet article, nous aborderons les sujets suivants :

comment mettre l’ESP32 en mode veille profonde ;
réveillez l’ESP32 en modifiant la valeur d’un GPIO (avec un bouton poussoir) en utilisant la méthode ext0 ;
réveillez l’ESP32 en utilisant plusieurs GPIO en utilisant la méthode ext1 ;
identifiez quel GPIO a provoqué le réveil.

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 garder à l’esprit que :

Tout d’abord, vous devez configurer 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. Dans cet article, nous allons vous montrer comment utiliser les sources de réveil externes.
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.

Réveil externe

Le réveil externe est l’un des moyens de sortir l’ESP32 d’un sommeil profond. Cela signifie que vous pouvez réveiller l’ESP32 en basculant la valeur d’un signal sur une broche, comme en appuyant sur un bouton. Vous disposez de deux possibilités de réveil externe : ext0 et ext1.

Réveil externe (ext0)

Cette source de réveil vous permet d’utiliser une broche pour réveiller l’ESP32. L’option de source de réveil ext0 utilise les GPIO RTC pour se réveiller. Ainsi, les périphériques RTC restent allumés pendant le sommeil profond si cette source de réveil est demandée.

Pour utiliser cette source de réveil, vous utilisez la fonction suivante :

esp_sleep_enable_ext0_wakeup(GPIO_NUM_X, level)

Cette fonction accepte comme premier argument la broche que vous souhaitez utiliser, dans ce format GPIO_NUM_X, dans lequel X représente le numéro GPIO de cette broche.

Le deuxième argument, niveau, peut être 1 ou 0. Cela représente l’état du GPIO qui déclenchera le réveil.

Remarque : vous ne pouvez utiliser que des broches qui sont des GPIO RTC avec cette source de réveil. Voici une liste des GPIO RTC pour différents modèles de puces ESP32 :

ESP32-S3 : 0-21 ;
ESP32 : 0, 2, 4, 12-15, 25-27, 32-39 ;
ESP32-S2 : 0-21 ;

Réveil externe (ext1)

Cette source de réveil vous permet d’utiliser plusieurs GPIO RTC. Cette source de réveil est implémentée par le contrôleur RTC. Ainsi, les périphériques RTC et les mémoires RTC peuvent être mis hors tension dans ce mode.

Pour utiliser cette source de réveil, vous utilisez la fonction suivante :

esp_sleep_enable_ext1_wakeup_io(bitmask, mode);

Cette fonction accepte deux arguments :

Un masque de bits des numéros GPIO qui provoqueront le réveil ;
Mode : la logique pour réveiller l’ESP32. Cela peut être :
- ESP_EXT1_WAKEUP_ALL_LOW : réveillez-vous lorsque tous les GPIO deviennent faibles ;
- ESP_EXT1_WAKEUP_ANY_HIGH : réveillez-vous si l’un des GPIO devient haut.

Si vous utilisez un ESP32-S2, ESP32-S3, ESP32-C6 ou ESP32-H2, voici les modes disponibles :

ESP_EXT1_WAKEUP_ANY_LOW : réveillez-vous lorsque l’un des GPIO sélectionnés est faible
ESP_EXT1_WAKEUP_ANY_HIGH : se réveille lorsque l’un des GPIO sélectionnés est élevé

Remarque : vous ne pouvez utiliser que des broches qui sont des GPIO RTC.

Pour tous les détails sur la source de réveil en veille profonde ext1, jetez un œil à la documentation sur le sommeil profond d’Espressif.

Pièces requises

Pour suivre ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Code – Exemple de réveil externe

Pour programmer l’ESP32, nous utiliserons l’IDE Arduino. Vous devez donc vous assurer que le noyau ESP32 Arduino est installé. Suivez le didacticiel suivant pour installer le module complémentaire ESP32, si ce n’est pas déjà fait :

L’exemple suivant montre comment utiliser la source de réveil externe. Vous pouvez le trouver dans Fichier > Exemples > ESP32 Deep Sleep > ExternalWakeUp, ou vous pouvez le copier ci-dessous.

/*
  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]>
*/
#include "driver/rtc_io.h"

#define BUTTON_PIN_BITMASK(GPIO) (1ULL << GPIO)  // 2 ^ GPIO_NUMBER in hex
#define USE_EXT0_WAKEUP          1               // 1 = EXT0 wakeup, 0 = EXT1 wakeup
#define WAKEUP_GPIO              GPIO_NUM_33     // Only RTC IO are allowed - ESP32 Pin example
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 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 does not need
    peripherals to be powered on.
    Note that using internal pullups/pulldowns also requires
    RTC peripherals to be turned on.
  */
#if USE_EXT0_WAKEUP
  esp_sleep_enable_ext0_wakeup(WAKEUP_GPIO, 1);  //1 = High, 0 = Low
  // Configure pullup/downs via RTCIO to tie wakeup pins to inactive level during deepsleep.
  // EXT0 resides in the same power domain (RTC_PERIPH) as the RTC IO pullup/downs.
  // No need to keep that power domain explicitly, unlike EXT1.
  rtc_gpio_pullup_dis(WAKEUP_GPIO);
  rtc_gpio_pulldown_en(WAKEUP_GPIO);

#else  // EXT1 WAKEUP
  //If you were to use ext1, you would use it like
  esp_sleep_enable_ext1_wakeup_io(BUTTON_PIN_BITMASK(WAKEUP_GPIO), ESP_EXT1_WAKEUP_ANY_HIGH);
  /*
    If there are no external pull-up/downs, tie wakeup pins to inactive level with internal pull-up/downs via RTC IO
         during deepsleep. However, RTC IO relies on the RTC_PERIPH power domain. Keeping this power domain on will
         increase some power comsumption. However, if we turn off the RTC_PERIPH domain or if certain chips lack the RTC_PERIPH
         domain, we will use the HOLD feature to maintain the pull-up and pull-down on the pins during sleep.
  */
  rtc_gpio_pulldown_en(WAKEUP_GPIO);  // GPIO33 is tie to GND in order to wake up in HIGH
  rtc_gpio_pullup_dis(WAKEUP_GPIO);   // Disable PULL_UP in order to allow it to wakeup on HIGH
#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 is not going to be called
}

Afficher le code brut

Cet exemple réveille l’ESP32 lorsque vous déclenchez le GPIO 33 à un niveau élevé. L’exemple de code montre comment utiliser les deux méthodes : ext0 et ext1. Si vous téléchargez le code tel quel, vous utiliserez ext0. La fonction pour utiliser ext1 est commentée. Nous allons vous montrer comment fonctionnent les deux méthodes et comment les utiliser.

Jetons un coup d’œil rapide au code.

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 raison pour laquelle l’ESP32 a été réveillé du sommeil.

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

installation()

Dans setup(), vous commencez par initialiser la communication série :

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

Ensuite, vous incrémentez un à la variable bootCount et imprimez cette variable dans Serial Monitor.

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

Ensuite, vous imprimez la raison du réveil à l’aide de la fonction print_wakeup_reason() définie précédemment.

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

Après cela, vous devez activer les sources de réveil. Nous allons tester chacune des sources de réveil, ext0 et ext1, séparément.

poste0

Dans cet exemple, l’ESP32 se réveille lorsque le GPIO 33 est déclenché à un niveau haut :

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

Au lieu du GPIO 33, vous pouvez utiliser n’importe quelle autre broche RTC GPIO. Définissez-le simplement sur la variable WAKEUP_GPIO au début du code.

#define WAKEUP_GPIO GPIO_NUM_33     // Only RTC IO are allowed

Résistances internes Pull-Up et Pull-Down

Nous appelons également les deux lignes suivantes :

rtc_gpio_pullup_dis(WAKEUP_GPIO);
rtc_gpio_pulldown_en(WAKEUP_GPIO);

La fonction rtc_gpio_pullup_dis() désactive toutes les résistances de rappel internes sur le GPIO de réveil : elle garantit que la broche n’est pas involontairement maintenue haute. Ceci est important car une résistance de rappel maintiendrait la broche haute, provoquant potentiellement des réveils involontaires.

La fonction rtc_gpio_pulldown_en() active la résistance pull-down interne sur le GPIO de réveil : elle garantit que la broche est maintenue basse jusqu’à ce qu’un signal de réveil valide (HIGH) soit reçu. En configurant la broche avec une résistance pull-down, nous garantissons qu’elle reste dans un état bas stable pendant le sommeil profond. Cette stabilité garantit que l’ESP32 se réveille uniquement lorsque la broche GPIO spécifiée reçoit un signal externe haut, correspondant à la condition de réveil définie par esp_sleep_enable_ext0_wakeup(WAKEUP_GPIO, 1).

Câblage du circuit

Pour tester cet exemple, connectez un bouton-poussoir à votre ESP32 en suivant le schéma suivant. Le bouton est connecté au GPIO 33 à l’aide d’une résistance pull-down de 10k Ohm.

Notez que seuls les GPIO RTC peuvent être utilisés comme source de réveil. Vous pouvez vérifier le brochage de votre carte pour identifier les GPIO RTC. Au lieu du GPIO 33, vous pouvez utiliser n’importe quelle broche RTC GPIO pour connecter votre bouton.

Tester l’exemple

Testons cet exemple. Téléchargez l’exemple de code 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.

Appuyez sur le bouton poussoir pour réveiller l’ESP32.

Réveil externe en veille profonde ESP32 avec bouton-poussoir

Essayez ceci plusieurs fois et voyez le nombre de démarrages augmenter à chaque pression sur un bouton.

Utiliser cette méthode est utile pour réveiller votre ESP32 à l’aide d’un bouton poussoir, par exemple, pour exécuter une tâche particulière. Cependant, avec cette méthode, vous ne pouvez utiliser qu’un seul GPIO comme source de réveil.

Et si vous souhaitez avoir des boutons différents, tous réveillent l’ESP, mais effectuent des tâches différentes ? Pour cela, vous devez utiliser la méthode ext1.

poste1

La source de réveil ext1 vous permet de réveiller l’ESP32 en utilisant différents GPIO et d’effectuer différentes tâches en fonction du GPIO qui a provoqué le réveil.

Au lieu d’utiliser la fonction esp_sleep_enable_ext0_wakeup(), vous utilisez la fonction esp_sleep_enable_ext1_wakeup_io().

esp_sleep_enable_ext1_wakeup_io(BUTTON_PIN_BITMASK(WAKEUP_GPIO), ESP_EXT1_WAKEUP_ANY_HIGH);

Dans cet exemple particulier, pour exécuter cette partie du code, assurez-vous de définir la variable USE_EXT0_WAKEUP sur 0 au début du code comme ceci :

#define USE_EXT0_WAKEUP  0  // 1 = EXT0 wakeup, 0 = EXT1 wakeup

La fonction esp_sleep_enable_ext1_wakeup_io()

Le premier argument de la fonction esp_sleep_enable_ext1_wakeup_io() est un masque de bits des GPIO que vous utiliserez comme source de réveil, et le deuxième argument définit la logique pour réveiller l’ESP32.

Masque de bits GPIO

Pour définir le bitmask des GPIO, on peut utiliser la macro BUTTON_PIN_BITMASK() définie au début du code.

#define BUTTON_PIN_BITMASK(GPIO) (1ULL << GPIO)  // 2 ^ GPIO_NUMBER in hex

BUTTON_PIN_BITMASK(GPIO) est une macro qui crée un masque de bits pour un GPIO spécifique. Ce n’est pas une fonction mais se comporte de manière assez similaire en acceptant un argument et en renvoyant une valeur.

Donc, si vous souhaitez renvoyer le masque de bits pour un GPIO spécifique, il vous suffit de l’appeler ainsi :

BUTTON_PIN_BITMASK(WAKEUP_GPIO)

Ainsi, esp_sleep_enable_ext1_wakeup_io() ressemblera à ceci :

esp_sleep_enable_ext1_wakeup_io(BUTTON_PIN_BITMASK(WAKEUP_GPIO), ESP_EXT1_WAKEUP_ANY_HIGH);

Masque de bits pour plusieurs GPIO

Pour créer un masque de bits pour plusieurs GPIO à l’aide de la macro BUTTON_PIN_BITMASK(GPIO), vous pouvez utiliser OR au niveau du bit (|) pour combiner les masques de bits individuels pour chaque broche GPIO. Voici comment procéder :

Supposons que vous souhaitiez créer un masque de bits pour les broches GPIO 2 et 15. Vous pouvez le faire en combinant les masques de bits individuels pour chaque broche comme ceci :

uint64_t bitmask = BUTTON_PIN_BITMASK(GPIO_NUM_2) | BUTTON_PIN_BITMASK(GPIO_NUM_15);

Nous verrons ensuite un exemple utilisant plusieurs GPIO comme source de réveil.

Mode réveil

Le deuxième argument de la fonction esp_sleep_enable_ext1_wakeup_io() est le mode de réveil. Comme nous l’avons vu précédemment, voici vos options :

ESP_EXT1_WAKEUP_ALL_LOW : réveillez-vous lorsque tous les GPIO deviennent faibles ;
ESP_EXT1_WAKEUP_ANY_HIGH : réveillez-vous lorsque l’un des GPIO devient haut.

Si vous utilisez un ESP32-S2, ESP32-S3, ESP32-C6 ou ESP32-H2, voici les modes disponibles :

ESP_EXT1_WAKEUP_ANY_LOW : réveillez-vous lorsque l’un des GPIO sélectionnés est faible
ESP_EXT1_WAKEUP_ANY_HIGH : se réveille lorsque l’un des GPIO sélectionnés est élevé

Dans notre exemple particulier, nous utilisons ESP_EXT1_WAKEUP_ANY_HIGH. Ainsi, l’ESP32 se réveillera lorsque l’un des GPIO du masque de bits sera élevé.

Comme avec l’ext0, nous désactivons les résistances internes pull-up et activons les résistances pull-down pour assurer la stabilité de la lecture du GPIO de réveil.

Réveil externe – Plusieurs GPIO

Maintenant, vous devriez pouvoir réveiller l’ESP32 à l’aide de différents boutons et identifier quel bouton a provoqué le réveil. Dans cet exemple, nous utiliserons GPIO 2 et GPIO 15 comme source de réveil.

Schématique

Câblez deux boutons à votre ESP32. Dans cet exemple, nous utilisons GPIO 2 et GPIO 15, mais vous pouvez connecter vos boutons à n’importe quel GPIO RTC.

ESP32 deux boutons poussoirs pour sortir du sommeil profond

Coder plusieurs GPIO – Réveil externe

Vous devez apporter quelques modifications à l’exemple de code que nous avons utilisé précédemment :

créez un masque de bits pour utiliser GPIO 15 et GPIO 2. Nous vous avons déjà montré comment procéder ;
activez ext1 comme source de réveil ;
créez une fonction qui identifie le GPIO qui a provoqué le réveil.

Le croquis suivant met en œuvre tous ces changements.

/*  
  Rui Santos & Sara Santos - Raspberryme.com
  https://Raspberryme.com/learn-esp32-with-arduino-ide/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include "driver/rtc_io.h"

#define BUTTON_PIN_BITMASK(GPIO) (1ULL << GPIO)  // 2 ^ GPIO_NUMBER in hex
#define WAKEUP_GPIO_2              GPIO_NUM_2     // Only RTC IO are allowed - ESP32 Pin example
#define WAKEUP_GPIO_15              GPIO_NUM_15     // Only RTC IO are allowed - ESP32 Pin example

// Define bitmask for multiple GPIOs
uint64_t bitmask = BUTTON_PIN_BITMASK(WAKEUP_GPIO_2) | BUTTON_PIN_BITMASK(WAKEUP_GPIO_15);

RTC_DATA_ATTR int bootCount = 0;

/*
Method to print the GPIO that triggered the wakeup
*/
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);
}

/*
  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");
      print_GPIO_wake_up();
      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();

  //Use ext1 as a wake-up source
  esp_sleep_enable_ext1_wakeup_io(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);
  // enable pull-down resistors and disable pull-up resistors
  rtc_gpio_pulldown_en(WAKEUP_GPIO_2);
  rtc_gpio_pullup_dis(WAKEUP_GPIO_2);
  rtc_gpio_pulldown_en(WAKEUP_GPIO_15);
  rtc_gpio_pullup_dis(WAKEUP_GPIO_15);

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

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

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil rapide au fonctionnement du code.

Masque de bits GPIO

Vous définissez le masque de bits GPIOs au début du code :

#define BUTTON_PIN_BITMASK(GPIO) (1ULL << GPIO)  // 2 ^ GPIO_NUMBER in hex
#define WAKEUP_GPIO_2           GPIO_NUM_2       // Only RTC IO are allowed - 
#define WAKEUP_GPIO_15          GPIO_NUM_15      // Only RTC IO are allowed 

// Define bitmask for multiple GPIOs
uint64_t bitmask = BUTTON_PIN_BITMASK(WAKEUP_GPIO_2) | BUTTON_PIN_BITMASK(WAKEUP_GPIO_15);

Identifiez le GPIO qui a provoqué le réveil

Nous créons une fonction appelée print_GPIO_wake_up() qui imprime le GPIO qui a provoqué le réveil :

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

La fonction esp_sleep_get_ext1_wakeup_status() renvoie un masque de bits avec le GPIO qui a provoqué le réveil. Nous pouvons obtenir le numéro GPIO comme suit :

log(GPIO_reason))/log(2)

Imprimer la raison du réveil

Nous avons modifié la fonction print_wakeup_reason() pour imprimer le GPIO qui a provoqué le réveil lorsque la source du réveil est ext1 :

case ESP_SLEEP_WAKEUP_EXT1:
  Serial.println("Wakeup caused by external signal using RTC_CNTL");
  print_GPIO_wake_up();
  break;

Activer ext1 comme source de réveil

Activez ext1 comme source de réveil en transmettant le masque de bits et le mode de réveil des GPIO.

esp_sleep_enable_ext1_wakeup_io(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);

N’oubliez pas de désactiver toutes les résistances pull-up internes et d’activer les résistances pull-down sur les GPIO utilisés comme source de réveil.

rtc_gpio_pulldown_en(WAKEUP_GPIO_2);
rtc_gpio_pullup_dis(WAKEUP_GPIO_2);
rtc_gpio_pulldown_en(WAKEUP_GPIO_15);
rtc_gpio_pullup_dis(WAKEUP_GPIO_15);

Activer le sommeil profond

Enfin, appelez esp_deep_sleep_start() pour mettre l’ESP32 en mode veille profonde.

esp_deep_sleep_start();

Tester l’esquisse

Après avoir téléchargé le code sur la carte, l’ESP32 sera en mode veille profonde. Vous pouvez le réveiller en appuyant sur les boutons poussoirs.

Ouvrez le moniteur série à un débit en bauds de 115 200. Appuyez sur les boutons-poussoirs pour réveiller l’ESP32. Sur le moniteur série, vous devriez obtenir la raison du réveil et le GPIO qui a provoqué le réveil.

Conclusion

Dans ce tutoriel, vous avez appris à réveiller l’ESP32 à l’aide d’un réveil externe. Cela signifie que vous pouvez réveiller l’ESP32 en modifiant l’état d’une broche GPIO.

En résumé:

Vous ne pouvez utiliser les GPIO RTC que comme réveil externe ;
Vous pouvez utiliser deux méthodes différentes : ext0 et ext1 ;
ext0 vous permet de réveiller l’ESP32 en utilisant une seule broche GPIO ;
ext1 vous permet de réveiller l’ESP32 en utilisant plusieurs broches GPIO.

Pour en savoir plus sur le sommeil profond avec l’ESP32, jetez un œil à notre guide complet : ESP32 Deep Sleep with Arduino IDE and Wake Up Sources.

Si vous aimez ESP32, vous aimerez peut-être également les ressources suivantes :

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 :

La Crosse Technology - WT522 Réveil Radio-Piloté avec Projection - Blanc

Réveil externe ESP32 après un sommeil profond

Écrire un croquis de sommeil profond

Réveil externe

Réveil externe (ext0)

Réveil externe (ext1)

Pièces requises

Code – Exemple de réveil externe

Enregistrer les données sur les mémoires RTC

Raison du réveil

installation()

poste0

Résistances internes Pull-Up et Pull-Down

Câblage du circuit

Tester l’exemple

poste1

La fonction esp_sleep_enable_ext1_wakeup_io()

Masque de bits GPIO

Masque de bits pour plusieurs GPIO

Mode réveil

Réveil externe – Plusieurs GPIO

Schématique

Coder plusieurs GPIO – Réveil externe

Comment fonctionne le code ?

Masque de bits GPIO

Identifiez le GPIO qui a provoqué le réveil

Imprimer la raison du réveil

Activer ext1 comme source de réveil

Activer le sommeil profond

Tester l’esquisse

Conclusion

MicroPython : ESP32/ESP8266 TM1637 Affichage LED à 4 chiffres et 7 segments

ESP32 : 10 projets faciles pour les débutants

ESP32 avec lecteur MP3 YX5300/YX6300 (Arduino)

ESP32 : affichage TM1637 à 4 chiffres et 7 segments (Arduino)

Clintech Pico : nouvelle carte de développement Raspberry Pi RP2354B avec 48 GPIO

Grinn GenioSoM-360 : Un SoM puissant pour l’IA dans les applications compactes

Construisez un réveil parlant à l’aide du XIAO ESP32-S3

Exécutez des périphériques USB hors de l’alimentation de votre banc avec USBpwrMe

PycoClaw : la solution IA pour microcontrôleurs compatibilité OpenClaw