ESP32 Touch Réveil après un sommeil profond

Ce guide montre comment sortir l’ESP32 d’une veille profonde à l’aide des broches tactiles. L’ESP32 sera programmé à l’aide de l’IDE Arduino.

Mis à jour le 8 octobre 2024.

L’ESP32 peut sortir d’un sommeil profond à l’aide de plusieurs sources de réveil : minuterie, réveil externe et réveil tactile. Cet article montre comment utiliser le réveil tactile.

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. Ce didacticiel explique comment utiliser les broches tactiles comme source de réveil. Pour cela, utilisez la fonction touchSleepWakeUpEnable() et passez en arguments le touch pin et le seuil tactile.
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.

Touchez Réveil

La carte ESP32 dispose de 10 GPIO tactiles capacitifs (qui peuvent changer en fonction de la puce ESP32). Ces GPIO peuvent détecter les variations de tout ce qui détient une charge électrique, comme la peau humaine. Ils peuvent ainsi détecter les variations induites lorsqu’on touche les GPIO avec le doigt. Ces broches tactiles ESP32 peuvent être utilisées pour réveiller l’ESP32 d’un sommeil profond.

En savoir plus sur les broches tactiles ESP32 : Broches du capteur tactile capacitif ESP32 avec Arduino IDE.

Épingles tactiles

Les broches tactiles ESP32 sont surlignées en rose dans le schéma suivant.

1731069147 31 ESP32 Touch Reveil apres un sommeil profond

Vous pouvez voir que le capteur tactile 0 correspond au GPIO 4, le capteur tactile 2 au GPIO 2, et ainsi de suite.

Apprenez tout ce que vous devez savoir sur les GPIO ESP32 : Référence de brochage ESP32 : quelles broches GPIO devez-vous utiliser ?

Si vous utilisez un ESP32 avec la puce S3, consultez plutôt ce guide GPIO.

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 – Toucher Réveil

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 réveil tactile en utilisant un exemple du noyau ESP32 Arduino. Ouvrez votre IDE Arduino, accédez à Fichier > Exemples > ESP32 Deep Sleep, puis ouvrez l’exemple de 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 cavalier au GPIO 15 et/ou au GPIO 27, comme indiqué dans le schéma ci-dessous.

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

Pièces requises :

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 !

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.

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

Conclusion

Dans cet article, nous vous avons montré comment réveiller l’ESP32 à l’aide des GPIO tactiles. En résumé:

Tout d’abord, définissez la source de réveil en appelant la fonction touchSleepWakeUpEnable() et passez en arguments le touch pin et la valeur du seuil.

Ensuite, utilisez la fonction esp_deep_sleep_start() pour mettre l’ESP32 en mode veille profonde.

Vous pouvez en savoir plus sur le sommeil profond avec l’ESP32 avec notre guide complet : ESP32 Deep Sleep avec Arduino IDE et 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 :

ESP32 Touch Réveil après un sommeil profond

Écrire un croquis de sommeil profond

Touchez Réveil

Épingles tactiles

Activer le réveil tactile

Code – Toucher Réveil

Définition du seuil

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

installation()

Câblage du circuit

Tester l’exemple

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