ESP32 Deep Sleep avec Arduino IDE et sources de réveil

ESP32 Deep Sleep avec Arduino IDE et sources de réveil

Cet article est un guide complet pour le mode Veille profonde de l’ESP32 avec l’IDE Arduino. Nous allons vous montrer comment mettre l’ESP32 en veille profonde et examiner différents modes pour le réveiller : réveil programmé, réveil tactile et réveil externe. Ce guide fournit des exemples pratiques avec du code, une explication du code et des schémas de circuit.

Sources de sommeil profond et de réveil ESP32

Mis à jour le 8 octobre 2024.

Contenu associé : ESP8266 Deep Sleep avec Arduino IDE

Cet article est divisé en 4 parties différentes :

  1. Présentation du mode veille profonde
  2. Minuterie de réveil
  3. Touchez Réveil
  4. Réveil externe

Présentation du mode veille profonde

L’ESP32 peut basculer entre différents modes d’alimentation :

  • Mode actif
  • Mode veille du modem
  • Mode veille légère
  • Mode veille profonde
  • Mode veille prolongée

Vous pouvez comparer les cinq modes différents dans le tableau suivant de la fiche technique ESP32 Espressif.

consommation d'énergie esp32

La fiche technique de l’ESP32 Espressif fournit également un tableau comparant la consommation électrique des différents modes d’alimentation.

esp32 différents modes de veille

Et voici également le tableau 10 pour comparer la consommation électrique en mode actif :

Consommation d'énergie esp32 en mode actif

Pourquoi le mode veille profonde ?

Faire fonctionner votre ESP32 en mode actif avec des piles n’est pas idéal car l’énergie des piles s’épuisera très rapidement.

1731009713 415 ESP32 Deep Sleep avec Arduino IDE et sources de reveil

Si vous mettez votre ESP32 en mode veille profonde, cela réduira la consommation d’énergie et vos batteries dureront plus longtemps.

Avoir votre ESP32 en mode veille profonde signifie supprimer les activités qui consomment plus d’énergie pendant le fonctionnement, mais laisser juste assez d’activité pour réveiller le processeur lorsque quelque chose d’intéressant se produit.

En mode veille profonde, aucune activité CPU ni Wi-Fi n’a lieu, mais le coprocesseur Ultra Low Power (ULP) peut toujours être allumé.

Pendant que l’ESP32 est en mode veille profonde, la mémoire RTC reste également allumée, nous pouvons donc écrire un programme pour le coprocesseur ULP et le stocker dans la mémoire RTC pour accéder aux périphériques, aux minuteries internes et aux capteurs internes.

Ce mode de fonctionnement est utile si vous devez réveiller le processeur principal par un événement externe, une minuterie ou les deux tout en maintenant une consommation d’énergie minimale.

Broches RTC_GPIO

Pendant le sommeil profond, certaines des broches ESP32 peuvent être utilisées par le coprocesseur ULP, à savoir les broches RTC_GPIO et les Touch Pins. La fiche technique ESP32 fournit un tableau identifiant les broches RTC_GPIO. Vous pouvez trouver ce tableau ici à la page 14.

Vous pouvez utiliser ce tableau comme référence ou consulter le brochage suivant pour localiser les différentes broches RTC_GPIO. Les broches RTC_GPIO sont mises en évidence par un cadre rectangulaire orange.

1731009713 486 ESP32 Deep Sleep avec Arduino IDE et sources de reveil

Vous aimerez peut-être aussi lire : Référence de brochage ESP32 : quelles broches GPIO devez-vous utiliser ?

Sources de réveil

Après avoir mis l’ESP32 en mode veille profonde, il existe plusieurs façons de le réveiller :

  1. Vous pouvez utiliser la minuterie pour réveiller votre ESP32 en utilisant des périodes de temps prédéfinies ;
  2. Vous pouvez utiliser les punaises tactiles ;
  3. Vous pouvez utiliser deux possibilités de réveil externe : vous pouvez utiliser soit un seul réveil externe, soit plusieurs sources de réveil externes différentes ;
  4. Vous pouvez utiliser le coprocesseur ULP pour vous réveiller – cela ne sera pas abordé dans ce guide.

É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 :

  1. 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.
  2. 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.
  3. 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 particulièrement utile si vous exécutez des projets nécessitant un horodatage ou des tâches quotidiennes, tout en maintenant une faible consommation d’énergie.

Minuterie de réveil

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 durée prédéfinie est très simple. Dans l’IDE Arduino, il suffit de préciser le temps de veille en microsecondes dans la fonction suivante :

esp_sleep_enable_timer_wakeup(time_in_us)

Code

Voyons comment cela fonctionne à l’aide d’un exemple de la bibliothèque. 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 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: %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");
  delay(1000);
  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 laquelle vous souhaitez 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.

1731009713 920 ESP32 Deep Sleep avec Arduino IDE et sources de reveil

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.

Démonstration de réveil de la minuterie ESP32

Cependant, notez que si vous appuyez sur le bouton EN de la carte ESP32, cela réinitialise le nombre de démarrages à 1.

Vous pouvez modifier l’exemple fourni et, au lieu d’imprimer un message, vous pouvez demander à votre ESP d’effectuer n’importe quelle autre tâche. Le réveil programmé est utile pour effectuer des tâches périodiques avec l’ESP32, comme des tâches quotidiennes, sans consommer beaucoup d’énergie.

Touchez Réveil

Vous pouvez sortir l’ESP32 d’un sommeil profond à l’aide des broches tactiles. Cette section montre comment procéder à l’aide de l’IDE Arduino.

Touchez Réveil

Activer le réveil tactile

Permettre à l’ESP32 de se réveiller à l’aide d’une épingle tactile est simple. Dans l’IDE Arduino, vous devez utiliser la fonction suivante : passer en argument le touch pin et le seuil tactile :

touchSleepWakeUpEnable(TOUCH_PIN, THRESHOLD);

Code

Voyons comment cela fonctionne à l’aide d’un exemple de la bibliothèque. Ouvrez votre IDE Arduino, accédez à Fichier > Exemples > ESP32 Deep Sleep, puis ouvrez le croquis TouchWakeUp.

/*
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: %d\n", 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 %d\n", 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
}

Afficher le code brut

Définition du seuil

La première chose que vous devez faire est de définir une valeur seuil pour les broches tactiles.

#define THRESHOLD 40 // Greater the value, more the sensitivity

Les valeurs lues par une touche tactile diminuent lorsque vous la touchez. La valeur seuil signifie que l’ESP32 se réveillera lorsque la valeur lue sur la broche tactile sera inférieure à 40. Vous pouvez ajuster cette valeur en fonction de la sensibilité souhaitée.

Important : cependant, si vous utilisez un modèle ESP32-S2 ou ESP32-S3, cela fonctionne un peu
différemment. C’est pourquoi il y a un article différent dans le code qui définit un seuil différent pour ces conseils. Dans ce cas, plus la valeur est faible, plus la sensibilité est élevée.

#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

Définition des Touch Pins comme source de réveil

Pour définir un touch pin comme source de réveil, vous pouvez utiliser la fonction touchSleepWakeUpEnable() qui accepte comme arguments le touch pin et la valeur seuil qui réveillera la carte.

Dans cet exemple, il définit GPIO 15 (T3) et GPIO 27 (T7) comme sources de réveil avec la même valeur de seuil.

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

Si vous utilisez un modèle ESP32-S2 ou S3, l’exemple définit simplement le réveil sur GPIO 3 (T3). Notez que la numérotation des broches tactiles peut être différente selon le modèle de carte que vous utilisez.

#else // ESP32-S2 + ESP32-S3
  // Setup sleep wakeup on Touch Pad 3 (GPIO3)
  touchSleepWakeUpEnable(T3, THRESHOLD);

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

esp_deep_sleep_start();

Il s’agissait des instructions générales pour configurer les broches tactiles comme source de réveil. Jetons maintenant un œil aux autres sections du code.

installation()

Lorsque l’ESP32 sort du mode veille, il exécutera le code depuis le début jusqu’à ce qu’il trouve la fonction esp_deep_sleep_start().

Dans cet exemple particulier, nous avons une variable de contrôle appelée bootCount qui sera augmentée entre chaque cycle de sommeil afin que nous ayons une idée du nombre de fois que l’ESP32 s’est réveillé.

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

Nous appelons également les fonctions print_wakeup_reason() et print_wakeup_touchpad() définies plus tôt dans le code pour imprimer la raison du réveil et le code PIN qui a provoqué le réveil.

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

Câblage du circuit

Pour tester cet exemple, câblez un câble au GPIO 15, comme indiqué dans le schéma ci-dessous.

Signal de réveil tactile Câblage du circuit

Si vous utilisez un modèle ESP32-S2 ou ESP32-S3, veuillez vérifier l’emplacement de vos broches tactiles.

Tester l’exemple

Téléchargez le code sur votre ESP32 et ouvrez le moniteur série à un débit en bauds de 115 200.

1731009713 920 ESP32 Deep Sleep avec Arduino IDE et sources de reveil

L’ESP32 passe en mode veille profonde.

Vous pouvez le réveiller en touchant le fil connecté au Touch Pin 3.

Broches du capteur tactile ESP32 Arduino IDE

Lorsque vous touchez la broche, l’ESP32 affiche sur le moniteur série : le numéro de démarrage, la cause du réveil et quel GPIO tactile a provoqué le réveil.

Test des broches tactiles ESP32 comme source de réveil Démonstration du moniteur série

Réveil externe

Outre la minuterie et les broches tactiles, nous pouvons également sortir l’ESP32 du sommeil profond en basculant la valeur d’un signal sur une broche, comme en appuyant sur un bouton. C’est ce qu’on appelle un réveil externe. Vous disposez de deux possibilités de réveil externe : ext0 et ext1.

Réveil externe

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 resteront 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 : avec cette source de réveil, vous ne pouvez utiliser que des broches qui sont des GPIO RTC.

Réveil externe (ext1)

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.

Vous utilisez des broches qui sont des GPIO RTC.

Code

Explorons l’exemple fourni avec la bibliothèque ESP32. Accédez à Fichier > Exemples > ESP32 Deep Sleep > ExternalWakeUp :

/*
  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.

Bouton poussoir ESP32 connecté au GPIO 333

Remarque : seuls les GPIO RTC peuvent être utilisés comme source de réveil. Au lieu du GPIO 33, vous pouvez également 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.

1731009713 920 ESP32 Deep Sleep avec Arduino IDE et sources de reveil

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.

ESP32 teste le réveil externe

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

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.

ESP32 réveil externe plusieurs GPIO

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.

ESP32 Réveil Externe Plusieurs GPIO

Conclusion

Dans cet article, nous vous avons montré comment utiliser le sommeil profond avec l’ESP32 et différentes manières de le réveiller. Vous pouvez réveiller l’ESP32 à l’aide d’une minuterie, des broches tactiles ou d’un changement d’état GPIO.

Résumons ce que vous avez appris sur chaque source de réveil :

Minuterie de réveil

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

Touchez Réveil

  • Pour activer les broches tactiles comme source de réveil, utilisez la fonction touchSleepWakeUpEnable() ;
  • Enfin, vous utilisez la fonction esp_deep_sleep_start() pour mettre l’ESP32 en mode veille profonde.

Réveil externe

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

Nous espérons que vous avez trouvé ce guide utile. Si vous souhaitez en savoir plus sur ESP32, assurez-vous de consulter tous nos projets ESP32 et notre eBook ESP32.

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 :

YouTube video

  • KEYESTUDIO ESP32 Smart Home IoT Kit Compatible avec Arduino IDE, avec ESP32 Board, Python C, Musical Project, etc. Tutoriel en Ligne 13 Fonctions
  • ELEGOO Carte Starter Kit de Démarrage ESP-32 avec Tutoriel et Carte de Développement Microcontrôleur Double Cœur USB-C Prise en Charge AP/STA/AP+STA, Compatible avec Arduino IDE