Esptop 10 temporisation se réveille du sommeil profond à l'aide d'Arduino IDE
Ici, nous discuterons de la façon dont nous pouvons définir ESP32 en mode de sommeil profond à l'heure fixe pour économiser l'énergie. Avant d'apprendre à nous réveiller ESP32 du sommeil profond à l'aide de la minuterie, comprenons le concept de sommeil profond:
Qu'est-ce que le sommeil profond dans ESP32
ESP32 peut être un appareil avide de puissance en raison de son module WiFi et Bluetooth intégré. ESP32 dessine généralement 75mA pour les opérations nominales alors qu'elle peut aller à 240mA Lors de la transmission de données sur le WiFi. Cependant, nous pouvons optimiser cela en permettant le mode de sommeil profond.
En mode sommeil profond, les périphériques numériques ESP32, les RAM inutilisés et les processeurs sont désactivés. Seule la liste suivante des pièces reste opérationnelle:
- Contrôleur RTC
- Coprocesseur ULP
- RTC Mémoire rapide et lente
- Périphériques RTC
Lorsque le mode de sommeil profond est activé, le CPU principal est arrêté; Cependant, le coprocesseur ULP (Ultralowpower) peut toujours lire les données des capteurs et réveiller le CPU chaque fois qu'il est nécessaire.
Cette application d'ESP32 est utile lorsque nous voulons générer une sortie à un moment précis ou lorsqu'une interruption ou un événement externe se produit. Cela économise la puissance ESP32 car son processeur reste éteint pour le reste du temps et s'allume que lorsqu'il est appelé.
Avec le CPU ESP32, la mémoire principale est également flashée ou effacée, donc tout ce qui est stocké à l'intérieur de cette mémoire ne sera plus disponible. Seule la mémoire RTC est maintenue là. Par conséquent, ESP32 enregistre les données WiFi et Bluetooth à l'intérieur de la mémoire RTC avant de passer en mode de sommeil profond.
Une fois le mode de sommeil profond réinitialisé ou supprimé, la puce ESP32 commence l'exécution du programme depuis le tout début.
ESP32 peut être réveillé après un sommeil profond en utilisant différentes sources.
Réveiller les sources dans ESP32
Plusieurs sources sont disponibles pour réveiller ESP32 à partir du sommeil profond:
- Minuteur
- Tacs de touche
- Réveil externe ext0
- Réveil externe ext1
Dans ce guide, nous couvrirons Timer Wake Up Source pour ESP32.
Comment utiliser la minuterie pour se réveiller ESP32 de Sleep profondément
Le contrôleur RTC fourni avec ESP32 contient un module de minuterie qui peut réveiller l'appareil après une certaine période d'inactivité. Cette fonction a de vastes applications où nous avons besoin de calendrier ou de devoir exécuter des instructions à des moments précis tout en maintenant une consommation d'énergie optimale.
La commande suivante peut configurer la minuterie ESP32 comme source de réveil. Il accepte le temps en microsecondes comme argument.
esp_sleep_enable_timer_wakeup (time_in_micro-s)
Exemple de code
Si la carte ESP32 est installée dans Arduino IDE, alors ESP32 est livré avec un exemple de sommeil profond que nous utiliserons dans ce tutoriel. Dans Arduino IDE Deep Sleep Timer, l'exemple de réveil peut être ouvert en allant à: Fichier> Exemples> ESP32> Sleep profond> TIMERWAKEUP
Une nouvelle fenêtre s'ouvrira avec un croquis ci-dessous:
#define us_to_s_factor 1000000ull
#define time_to_sleep 5
Rtc_data_attr int bootCount = 0;
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: série.println ("Wakeup Reason Signal externe Utilisation de RTC_IO"); casser;
case esp_sleep_wakeup_ext1: série.println ("Wakeup Reason Signal externe en utilisant rtc_cntl"); casser;
Case ESP_SLEEP_WAKEUP_TIMER: série.println ("réveil causé par la minuterie"); casser;
case esp_sleep_wakeup_touchpad: série.println ("Wakeup causé par tactile"); casser;
Case ESP_SLOEPL_WAKEUP_ULP: SERIE.println ("Wakeup causé par le programme ULP"); casser;
par défaut: série.printf ("Le sommeil profond n'a pas provoqué de réveil:% d \ n", wakeup_reason); casser;
void setup()
En série.commencer (115200);
retard (1000);
++bootCount;
En série.println ("Boot Number:" + String (bootCount));
print_wakeup_reason ();
esp_sleep_enable_timer_wakeup (time_to_sleep * us_to_s_factor);
En série.println ("Configuration ESP32 pour dormir pour chaque" + chaîne (time_to_sleep) +
"Secondes");
En série.println ("va dormir maintenant");
En série.affleurer();
esp_deep_sleep_start ();
En série.println ("Ce ne sera jamais imprimé");
VOID LOOP ()
Définir un sommeil profond: Le code commence par décrire l'heure pour laquelle ESP32 passera en mode sommeil. Cela peut être modifié en fonction du temps requis. Ici, le temps est converti des microsecondes en secondes, nous avons donc réglé 5 secondes pour le mode de sommeil profond ESP32. Il se réveillera toutes les 5 secondes.
Mémoires de données RTC: Suivant en utilisant Rtc_data_attr Nous enregistrerons des données sur la mémoire RTC. Cet exemple comprend le boxer variable qui est stockée à l'intérieur de la mémoire RTC et compte le nombre de fois ESP32 se réveille après chaque sommeil profond.
La mémoire RTC n'est pas flasée lorsque ESP32 est en mode de sommeil profond. 8KB SRAM est inclus à l'intérieur de la pièce ESP32 RTC, également connue sous le nom de mémoire rapide RTC.
ESP32 Wake Up Reason: Ensuite en utilisant le print_wakeup_reason () fonction que nous avons imprimé la cause du réveil par un sommeil profond.
Dans installation() Le taux de bauds est défini pour la communication en série et le ++boxer La variable est incrémentée de 1 chaque fois que ESP32 se réveille à partir d'un sommeil profond. Le nombre total est imprimé sur le moniteur en série.
Enfin en utilisant la fonction esp_deep_sleep_start (), L'ESP32 est placé en mode veille.
Télécharger le code sur ESP32 à l'aide d'Arduino IDE.
Sortir
La sortie suivante peut être observée sur le moniteur en série d'Arduino IDE. Ici, nous pouvons voir qu'après 5 secondes, ESP32 se réveille à partir d'un sommeil profond et que le numéro de démarrage est incrémenté à chaque fois qu'il se réveille.
Note: Si nous appuyons sur le bouton EN ESP32 réinitialise le nombre de démarrage à 0.
Conclusion
Ici, dans ce didacticiel, nous avons configuré ESP32 pour nous réveiller du sommeil profond à l'aide d'un programme de minuterie. Nous avons simplement imprimé un message une fois que l'ESP32 se réveille; Cependant, en utilisant cet article, on peut exécuter n'importe quelle tâche une fois que l'ESP32 se réveille depuis un sommeil profond.