Économiser la vie de la batterie avec le sommeil profond : 20 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Vous souhaitez utiliser une batterie avec votre ESP32 ? Si c'est le cas, je discuterai aujourd'hui de quelques informations techniques importantes concernant ce sujet. On sait que ce microcontrôleur dépense beaucoup d'énergie lorsqu'il transmet des informations. Il consomme près de 190 milliampères. Dans cette vidéo, je vais montrer comment économiser l'énergie de l'ESP32 avec la fonction dite "DEEP SLEEP". Nous allons configurer la puce pour entrer dans ce mode, apprendre les moyens de sortir de ce mode et créer un exemple montrant trois façons différentes de réveiller l'ESP32.

Il est important de se rappeler que la radio dépense beaucoup d'énergie, plutôt que le processeur. L'économie d'énergie est très importante. En effet, les points de terminaison (les circuits qui envoient des informations) sont souvent alimentés par batterie et devraient durer jusqu'à cinq ans. Certains fabricants promettent une durée allant jusqu'à dix ans, et cela est valable pour les batteries de haute qualité qui n'utilisent pas autant les points de terminaison. Dans tous les autres cas, je vous conseille d'utiliser Deep Sleep pour économiser l'énergie de votre circuit.

Étape 1: Présentation

L'ESP32 dispose d'un mode d'économie d'énergie, appelé « Veille profonde ». Dans ce mode, les processeurs, la plupart des RAM et tous les périphériques cadencés numériques sont désactivés. Les seules parties de la puce qui peuvent encore être connectées sont le contrôleur RTC, les périphériques RTC (y compris le coprocesseur ULP) et les mémoires RTC.

Nous avons plusieurs façons de réveiller l'ESP32 lorsqu'il est endormi. Les sources de réveil peuvent être configurées à tout moment avant d'entrer en mode veille prolongée.

Étape 2: Façons de réveiller l'ESP32

Il existe cinq façons de réveiller l'ESP32:

• Minuterie

• Réveil externe (ext0)

• Réveil externe (ext1)

• Réveil du coprocesseur ULP

• Pavé tactile

Étape 3: Minuterie

Le contrôleur RTC a une minuterie intégrée qui peut être utilisée pour activer la puce après une période de temps prédéfinie. L'heure est spécifiée avec une précision de la microseconde.

esp_deep_sleep_enable_timer_wakeup(uint64_t time_in_us)

time_in_us> est le temps en microsecondes

Étape 4: Réveil externe (ext0)

Le module RTC IO contient une logique pour déclencher l'alarme lorsque l'un des GPIO RTC entre dans un niveau logique prédéfini. Le RTC IO fait partie du domaine d'alimentation des périphériques RTC, les périphériques RTC seront donc maintenus en vie pendant le sommeil profond si cette source d'activation est demandée.

esp_deep_sleep_enable_ext0_wakeup(gpio_num_t gpio_num, niveau int)

gpio_num> Numéro GPIO utilisé comme source d'activation. Seuls les GPIO fonctionnels RTC peuvent être utilisés: 0, 2, 4, 12-15, 25-27, 32-39.

level> niveau d'entrée qui déclenchera l'alarme (0 = LOW, 1 = HIGH)

Étape 5: Réveil externe (ext1)

Le contrôleur RTC contient une logique pour déclencher le réveil à l'aide de plusieurs GPIO RTC.

esp_deep_sleep_enable_ext1_wakeup (masque uint64_t, mode esp_ext1_wakeup_mode_t)

mask> masque de bits des numéros GPIO qui provoqueront l'activation. Seuls les GPIO compatibles RTC peuvent être utilisés dans ce bitmap: 0, 2, 4, 12-15, 25-27, 32-39.

mode> sélectionner la fonction logique utilisée pour déterminer la condition d'activation:

• ESP_EXT1_WAKEUP_ALL_LOW: se réveille lorsque tous les GPIO sélectionnés sont en LOW

• ESP_EXT1_WAKEUP_ANY_HIGH: se réveille lorsque l'un des GPIO sélectionnés est HAUT

Étape 6: Réveil du coprocesseur ULP

Le coprocesseur ULP peut fonctionner pendant que la puce est en veille profonde et peut être utilisé pour rechercher des capteurs, surveiller les valeurs de l'ADC ou du capteur tactile capacitif et activer la puce lorsqu'un événement spécifique est détecté.

Le coprocesseur ULP fait partie du domaine de puissance des périphériques RTC et exécute le programme stocké dans la mémoire lente RTC. Par conséquent, les périphériques RTC et la mémoire lente RTC seront activés pendant le sommeil profond si ce mode d'activation est demandé.

Étape 7: Pavé tactile

Le contrôleur RTC contient une logique pour déclencher l'alarme à l'aide des capteurs tactiles capacitifs. La définition de la goupille tactile, cependant, est différente. Nous devons utiliser l'interruption tactile pour chacune des broches souhaitées.

Après avoir réglé les interruptions, nous avons activé le mode réveil pour utiliser les capteurs.

//Configurer le pavé tactile comme source de réveil esp_sleep_enable_touchpad_wakeup();

Étape 8: Entrer en mode veille prolongée

Après avoir défini un mode de réveil, une seule commande pour mettre l'ESP32 en mode veille profonde (en dépensant 2,5 A ou moins) suffit. J'insiste ici sur le fait que cette dépense provient de la puce ESP et non de la plaque, car cette dernière dépense plus.

esp_deep_sleep_start();

A partir de cette commande, l'ESP32 s'endort et n'exécute pas les prochaines lignes de code par exemple.

Important: tous les paramètres de réveil doivent être définis avant d'exécuter la commande ci-dessus.

Étape 9: Voici quelques informations plus importantes

L'appel ci-dessous renvoie la cause du réveil ESP32.

1: EXT0 2: EXT1 3: MINUTERIE 4: PAVÉ TACTILE 5: ULP

esp_sleep_get_wakeup_cause();

Si nous définissons le réveil par le pavé tactile, nous pouvons récupérer quel GPIO le toucher s'est produit grâce à la commande

esp_sleep_get_touchpad_wakeup_status();

Chaque fois que l'ESP32 se réveille, il effectuera à nouveau un cycle de configuration. Ainsi, toutes les variables qui ne sont pas définies dans la mémoire RTC retourneront à leur état initial.

Pour garder les variables en mémoire même après s'être endormi, utilisez la déclaration de variable dans l'exemple ci-dessous:

//RTC_DATA_ATTR loca une variable de mémoire RTCRTC_DATA_ATTR int bootCount = 0;

Étape 10: Démonstration

La vidéo montre le fonctionnement du programme, conformément à l'image.

Étape 11: Nœud Wi-FiMCU-32S ESP-WROOM-32

Étape 12: Assemblage

Étape 13: Programmer

Nous allons maintenant créer un programme dans lequel nous allons configurer l'ESP32 pour entrer en mode veille profonde. Celui-ci sera réveillé de trois manières différentes: une pour le réveil externe (ext0), une pour la minuterie et une pour le pavé tactile. Ils ne peuvent pas fonctionner ensemble, nous utiliserons donc une variable qui sera un compteur du nombre de fois que l'ESP32 a donné Boot pour configurer le mode de réveil.

Étape 14: Bibliothèque requise

Pour contrôler l'écran OLED, nous avons besoin d'une bibliothèque externe. Pour cela, nous allons télécharger la bibliothèque U8g2.

Dans l'IDE Arduino, allez dans le menu Sketch >> Inclure la bibliothèque >> Gérer les bibliothèques….

Étape 15: Bibliothèques et variables

Nous avons inclus la bibliothèque pour contrôler l'affichage OLED, ainsi qu'un constructeur de l'instance du contrôleur d'affichage. De plus, nous allouons la variable dans la mémoire RTC. Nous définissons la sensibilité pour l'acceptation tactile, le facteur de conversion de la microseconde pour les secondes et le temps que l'ESP32 passe en mode veille (en secondes).

#include //biblioteca para controle do display oled

//construtor da instancia do controlador do display //SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C display (SCL, SDA, U8X8_PIN_NONE); //RTC_DATA_ATTR contient une mémoire variable RTC RTC_DATA_ATTR int bootCount = 0; //sensibilidade para aceitação do toque #define Threshold 40 //fator de conversão de microsegundos para segundos #define uS_TO_S_FACTOR 1000000 //tempo que o ESP32 ficará em modo sleep (em segundos) #define TIME_TO_SLEEP 3

Étape 16: Configuration

Dans le programme d'installation, nous incrémentons le nombre de fois où le démarrage s'est produit. Nous appelons la fonction pour imprimer le motif Boot. Si le numéro de démarrage est PAR, nous configurons l'ESP32 pour qu'il se réveille via le bouton (EXT0). S'il s'agit d'un multiple de 3, nous réglons l'ESP32 pour qu'il se réveille après un temps défini. Sinon, nous avons configuré les broches tactiles capacitives pour réveiller l'ESP32. Enfin, nous définissons le pavé tactile comme source de réveil et forçons l'ESP32 à entrer en mode veille.

void setup() { Serial.begin(115200); retard(1000); //incrémenter le nombre de fois que le démarrage de BOOT ++bootCount; configureDisplay(); //Chama une fonction pour imprimer ou motiver BOOT print_wakeup_reason(); //se o numero de boot for PAR configuramos o ESP32 para despertar atraves do botão (EXT0) if(bootCount % 2 == 0) { esp_sleep_enable_ext0_wakeup(GPIO_NUM_39, 1); //1 = High, 0 = Low } //se for multiplo de 3 configuramos o ESP32 para despertar depois de um tempo definido else if(bootCount % 3 == 0) { esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); } //Caso contrario configuramos os pinos de touch capacitivo para despertar o ESP32 else { //Setup interrupt on Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); //Configurer le pavé tactile comme source de réveil esp_sleep_enable_touchpad_wakeup(); } Serial.println ("Entrer dans le mode veille"); esp_deep_sleep_start (); //força o ESP32 entrer dans le mode SLEEP }

Étape 17: Boucle, rappel et configuration de l'affichage

Dans le Loop, nous n'avons rien à faire. Nous procédons ensuite à l'interruption du rappel si nous avons quelque chose à faire lorsque l'interruption se produit. Concernant configureDisplay, nous initialisons l'affichage et configurons certains paramètres. Nous imprimons à l'écran le nombre de fois que le Boot s'est produit.

//nada a se fazer no loopvoid loop() { } //callback das interrupções void callback(){ //caso queira fazer algo ao ocorrer a interrupção } void configureDisplay() { //initializa o display e configura alguns parametros display. commencer(); display.setPowerSave(0); //modo powerSave (0-Off ? 1-On) display.setFont(u8x8_font_torussansbold8_u); //fonte utilizada //imprime aucun affichage sur le nombre de fenêtres que aconteceu ou BOOT display.drawString(0, 0, "BOOT NUM:"); display.drawString(0, 2, String(bootCount).c_str()); display.drawString(0, 4, "MOTIVO:"); }

Étape 18: Print_wakeup_reason (connaître la cause du réveil)

Ici, nous avons la fonction d'imprimer la cause du réveil de l'ESP32. Vérifiez la broche et imprimez sur l'écran.

//Função para imprimir a cause do ESP32 despertarvoid print_wakeup_reason(){ esp_sleep_wakeup_cause_t wakeup_reason; Chaîne motif = ""; wakeup_reason = esp_sleep_get_wakeup_cause(); //recupera a cause do despertar switch (wakeup_reason) { case 1:reason = "EXT0 RTC_IO BTN"; Pause; cas 2:raison = "EXT1 RTC_CNTL"; Pause; cas 3:raison = "TIMER"; Pause; cas 4:raison = "TACTILE"; Pause; cas 5:raison = "PROGRAMME ULP"; Pause; par défaut:reason = "AUCUNE CAUSE DS"; Pause; } Serial.println(raison); display.clearLine(6); //apaga a linha 6 affiche display.drawString(0, 6, Reason.c_str()); //Imprime a cause do despertar no display //se despertou por TOUCHPAD, então vamos verificar em qual dos pinos ocorreu if(wakeup_reason == 4) { print_wakeup_touchpad(); //verifica o pino e imprime pas d'affichage } }

Étape 19: Print_wakeup_touchpad (connaître le GPIO Touch)

Maintenant, dans cette étape, nous avons la fonction d'imprimer la broche qui a été touchée. Nous avons récupéré le GPIO qui a réveillé l'ESP32 et l'avons imprimé sur l'écran.

//Função para imprimir o pino que tocadovoid print_wakeup_touchpad() { touch_pad_t touchPin; touchPin = esp_sleep_get_touchpad_wakeup_status(); //recupera o GPIO que despertou o ESP32 String GPIO = ""; switch(touchPin) { case 0: GPIO = "4"; Pause; cas 1: GPIO = "0"; Pause; cas 2: GPIO = "2"; Pause; cas 3: GPIO = "15"; Pause; cas 4: GPIO = "13"; Pause; cas 5: GPIO = "12"; Pause; cas 6: GPIO = "14"; Pause; cas 7: GPIO = "27"; Pause; cas 8: GPIO = "33"; Pause; cas 9: GPIO = "32"; Pause; par défaut: Serial.println("Réveil pas par le pavé tactile"); Pause; } Serial.println("GPIO: "+GPIO); display.clearLine(7);//apaga a linha 7 do display display.drawString(0, 7, "GPIO: "); display.drawString(6, 7, GPIO.c_str()); //Imprimer o GPIO }

Étape 20: Télécharger les fichiers

PDF

INO