- Exigences
- Schéma du circuit du mode veille ESP32
- Présentation des modes de veille dans ESP32
- Programmation de l'ESP32 pour le mode veille profonde
- Test d'ESP32 en mode veille profonde
ESP32 est l'un des modules de microcontrôleur Wi-Fi les plus populaires et c'est un choix populaire dans de nombreuses applications IoT portables. Il s'agit d'un contrôleur puissant qui prend en charge la programmation Dual Core et possède également une prise en charge Bluetooth Low Energy (BLE) intégrée, ce qui en fait un bon choix pour les applications portables comme les appareils iBeacon, les trackers GPS, etc. Cependant, dans les applications alimentées par batterie comme celles-ci, la principale préoccupation est la batterie de secours. Cette batterie de secours peut être augmentée par un contrôle plus intelligent de l'unité de microcontrôleur, comme on peut programmer ESP32 en mode veille dans les conditions idéales pour augmenter la batterie de secours de l'appareil.
Dans ce projet, nous vérifierons la consommation actuelle de la très populaire unité de microcontrôleur compatible Wi-Fi et Bluetooth ESP32 en mode de fonctionnement normal et en mode veille profonde. Nous testerons également la différence et vérifierons comment mettre l'ESP32 en mode veille profonde. Vous pouvez également consulter l'article sur la façon de minimiser la consommation d'énergie des microcontrôleurs pour d'autres conseils qui peuvent être utilisés pour rendre votre conception beaucoup plus économe en énergie. En outre, si vous êtes intéressé par le mode veille d'autres microcontrôleurs, vous pouvez également consulter le mode veille Arduino et le mode veille ESP8266 NodeMCU.
Exigences
Pour ce faire, nous utiliserons le Devkit V4.0 basé sur ESP32 d'Espressif qui a un pont USB vers UART ainsi que d'autres broches ESP32 pour une connexion facile. La programmation se fera avec Arduino IDE. Si vous êtes complètement nouveau, alors pour commencer avec ESP32 en utilisant Arduino, lisez l'article lié avant de continuer.
Les exigences de ce projet sont les suivantes:
- Il passera en mode veille profonde en appuyant sur un bouton.
- Il sortira du mode veille profonde en appuyant sur un autre bouton.
- Pour détecter l'état de l'ESP32, une LED clignotera avec un temps d'allumage de 1000 millisecondes. Pendant le mode veille, il sera désactivé.
Par conséquent, des composants supplémentaires sont nécessaires
- LED - 1 pièce
- Bouton poussoir (interrupteur tactile) - 2 pièces
- Résistances 4,7k - 2 pièces
- Résistance 680R - 1 pc
- Planche à pain
- Brancher le fil
- Adaptateur 5V ou bloc d'alimentation
- Un câble micro-USB
- Arduino IDE avec interface de programmation ESP32 dans un PC ou un ordinateur portable.
Schéma du circuit du mode veille ESP32
Le schéma de mise en veille de l'ESP32 avec le bouton - poussoir est illustré ci-dessous.
Le schéma est assez simple. Il a deux boutons. Le bouton de veille mettra l'ESP32 en mode de veille profonde et un autre interrupteur est utilisé pour sortir l'ESP32 du mode de veille. Les deux boutons sont connectés au PIN 16 et au PIN 33. Les deux boutons sont configurés comme actifs bas lorsqu'ils sont enfoncés, par conséquent un pull-up supplémentaire est donné. Cependant, pour détecter si l'ESP 32 est en mode veille ou en mode de fonctionnement normal, la LED est connectée à la broche IO 4.
Présentation des modes de veille dans ESP32
Il existe de nombreux modes d'alimentation différents pour l'ESP32, à savoir le mode actif, le mode veille du modem, le mode veille légère, le mode veille profonde et le mode veille prolongée.
Pendant les conditions de fonctionnement normales, l'ESP32 fonctionne en mode actif. En mode actif ESP32, le processeur, le matériel WiFi / BT, la mémoire RTC et les périphériques RTC, co-processeurs ULP, sont tous activés et fonctionnent en fonction de la charge de travail. Cependant, sur différents modes d'alimentation, un ou plusieurs périphériques sont désactivés. Pour vérifier les différentes opérations du mode d'alimentation, suivez le tableau ci-dessous.
|
Matériel |
Mode actif |
Mode de veille du modem |
Mode veille légère |
Mode sommeil profond |
Hibernation |
|
CPU |
SUR |
SUR |
PAUSE |
DE |
DE |
|
WiFi / BT |
SUR |
DE |
DE |
DE |
DE |
|
Périphériques RTC et RTC |
SUR |
SUR |
SUR |
SUR |
DE |
|
Processeur ULP-Co |
SUR |
SUR |
SUR |
ALLUMÉ ÉTEINT |
DE |
Comme nous pouvons le voir dans le tableau ci-dessus, en mode veille profonde ESP32, souvent appelé modèle de surveillance par capteur ULP - le processeur, le WiFi / BT, la mémoire et les périphériques RTC, les coprocesseurs ULP sont tous désactivés. Seules la mémoire RTC et les périphériques RTC sont activés.
Pendant la situation de réveil, l'ESP32 doit être notifié par une source de réveil qui réveillera l'ESP32 du mode de veille profonde. Cependant, comme les périphériques RTC sont allumés, l'ESP32 peut être réveillé via des GPIO compatibles RTC. Il existe également d'autres options. Il peut être réveillé via des broches d'interruption de réveil externes ou en utilisant une minuterie pour réveiller l'ESP32. Dans ce projet, nous utilisons le réveil ext0 sur la broche 33.
Programmation de l'ESP32 pour le mode veille profonde
Le programme complet se trouve au bas de cette page. Il est écrit pour Arduino IDE et peut donc être facilement adapté à vos besoins. L'explication du code est la suivante.
Au début du code, // Créer une variable PushButton PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // définir la broche LED uint8_t led_pin = GPIO_NUM_4; // définir la broche de réveil uint8_t wakeUp_pin = GPIO_NUM_33;
Les trois lignes ci-dessus définissent la broche de réveil, la broche LED et la broche du mode veille.
void setup () { // mettez votre code de configuration ici, à exécuter une fois: // définissez le port série sur 115200 Serial.begin (115200); retard (1000); // définit la broche pushButton comme entrée avec le pinMode PullUp interne (pushBtn.pin, INPUT_PULLUP); // définit le gestionnaire d'interruption avec la broche pushButton en mode Falling attachInterrupt (pushBtn.pin, isr_handle, FALLING); // définit la broche Led comme sortie pinMode (led_pin, OUTPUT); // crée une tâche qui sera exécutée dans la fonction blinkLed (), avec la priorité 1 et exécutée sur le noyau 0 xTaskCreate ( blinkLed, / * Fonction de tâche. * / "blinkLed", / * nom de la tâche. * / 1024 * 2, / * Taille de la pile de la tâche * / NULL, / * paramètre de la tâche * / 5, / * priorité de la tâche * / & taskBlinkled); / * Poignée de tâche pour garder une trace de la tâche créée * / delay (500); // Configurer la broche 33 comme source de réveil ext0 avec le niveau logique BAS esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }
Dans ce qui précède, l'interruption est définie sur un mode descendant par l'extrait de code
attachInterrupt (pushBtn.pin, isr_handle, FALLING);
Par conséquent, chaque fois que l'interrupteur est enfoncé, le niveau logique passe de logique 1 (3,3 V) à logique 0 (0 V). La tension de la broche du bouton chutera et l'ESP32 identifiera que l'interrupteur est enfoncé. Il existe également une tâche créée pour faire clignoter la LED.
xTaskCreate ( blinkLed, / * Fonction de tâche. * / "blinkLed", / * nom de la tâche. * / 1024 * 2, / * Taille de pile de la tâche * / NULL, / * paramètre de la tâche * / 5, / * priorité de la tâche * / & taskBlinkled); / * Poignée de tâche pour garder une trace de la tâche créée * / delay (500);
La broche 33 est également configurée en utilisant l'extrait de code ci-dessous en tant que source de réveil externe identifiée comme extO.
esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);
Ensuite, dans la boucle while-
void loop () { // mettez votre code principal ici, à exécuter à plusieurs reprises: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Suspendre la tâche 'blinkLed' \ n"); // Suspend la tâche blinkLed vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("Aller en veille….. \ n", pushBtn.pin); pushBtn.pressed = false; // Va dormir maintenant esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); switch (wakeupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("utilisant le signal externe ext0 pour WakeUp From sleep"); Pause; case ESP_SLEEP_WAKEUP_EXT1: Serial.println ("en utilisant le signal externe ext1 pour WakeUp From sleep"); Pause; case ESP_SLEEP_WAKEUP_TIMER: Serial.println ("en utilisant le signal Timer pour WakeUp From sleep"); Pause; case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("utilisant le signal TouchPad pour WakeUp From sleep"); Pause; case ESP_SLEEP_WAKEUP_ULP: Serial.println ("utilisant le signal ULP pour WakeUp From sleep"); Pause; par défaut: break; Serial.printf ("Reprendre la tâche 'blinkLed' \ n"); // redémarre la tâche blinkLed vTaskResume (taskBlinkled); } }
La boucle while vérifie constamment si le bouton de veille est enfoncé ou non. Si le bouton est enfoncé, il arrêtera ou suspendra la tâche de clignotement de la LED et exécutera la fonction de démarrage du sommeil profond esp-
esp_deep_sleep_start ();
Dans cette situation, si le bouton d'interruption externe ext0 est enfoncé, il se réveillera immédiatement du mode de sommeil profond et reprendra la tâche de clignotement de la LED.
Enfin, la fonction de clignotement de la LED peut être vue dans les extraits ci-dessous, elle fera clignoter la LED 1000 ms secondes.
void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // bascule la valeur de la broche pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * Basculez simplement la LED toutes les 1000ms ou 1sec * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }
Test d'ESP32 en mode veille profonde
Le circuit est construit dans une maquette et un multimètre édition Metravi XB est utilisé pour mesurer le courant. Le courant consommé par le circuit en mode actif est de près de 58 mA mais en mode de sommeil profond, le courant est de près de 4,10 mA. L'image ci-dessous montre la consommation de courant en mode actif ESP32 -
En mode de sommeil profond, la consommation de courant est enregistrée tombée à environ 3,95 mA, l'image ci-dessous montre la consommation actuelle du mode de sommeil profond ESP32-
Cependant, en mode veille profonde, la consommation actuelle de l'ESP32 est de près de 150 uA. Mais la consommation de courant enregistrée pour cette carte ESP32 Devkit est de près de 4,10 mA. Cela est dû au CP2102 et au régulateur linéaire. Ces deux sont connectés à la ligne d'alimentation 5V. Il y a aussi une LED d'alimentation connectée à la ligne électrique qui consomme près de 2 mA de courant.
Par conséquent, il peut être facilement identifié que l'ESP32 consomme une très faible quantité d'énergie en mode de veille profonde, ce qui est très utile pour les opérations alimentées par batterie. Pour plus d'informations sur son fonctionnement, consultez la vidéo ci-dessous. Si vous avez des questions, laissez-les dans la section commentaires ci-dessous ou utilisez nos forums pour d'autres questions techniques.