Ce tutoriel montre comment mettre l’ESP32 en mode veille profonde et le réveiller à l’aide de différentes sources de réveil à l’aide du micrologiciel MicroPython. Nous couvrirons le réveil par minuterie et le réveil externe.
L’ESP32 peut également être réveillé d’un sommeil profond à l’aide des touches tactiles en définissant un seuil. Bien que cette fonctionnalité soit déjà implémentée dans MicroPython, elle ne fonctionne pas correctement au moment de la rédaction de ce didacticiel. Nous mettrons à jour cet article dès qu’il fonctionnera.
Le sommeil profond avec l’ESP8266 fonctionne un peu différemment qu’avec l’ESP32. Nous avons donc créé un article dédié au sommeil profond avec ESP8266 en utilisant MicroPython.
Si vous possédez un ESP8266, nous vous recommandons de lire notre Guide des sources de sommeil profond et de réveil MicroPython ESP8266.
Conditions préalables
Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :
En savoir plus sur MicroPython : eBook sur la programmation MicroPython avec ESP32 et ESP8266
Présentation du sommeil profond
Faire fonctionner votre ESP32/ESP8266 en mode actif avec des batteries n’est pas idéal, car l’énergie des batteries se videra très rapidement.
Si vous mettez votre ESP32 en mode veille profonde, cela réduira la consommation électrique et vos batteries dureront plus longtemps. Avoir l’ESP32 en mode veille profonde signifie couper avec 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.
Lorsqu’ils fonctionnent en mode veille profonde, l’ESP32 a une consommation de courant sur la gamme μA. Avec une carte personnalisée et soigneusement conçue, vous pouvez obtenir une consommation minimale de seulement 5 A. Cependant, si vous utilisez une carte de développement ESP32 complète avec un programmeur intégré, des LED intégrées, etc. (comme la carte ESP32 DOIT), vous ne pourrez pas atteindre un état d’alimentation aussi faible, mais vous pouvez encore économiser de l’énergie.
Sources de réveil
Après avoir mis l’ESP32 en mode veille profonde, il existe plusieurs façons de le réveiller :
- Vous pouvez utiliser le minuteur: réveil de l’ESP32 après des périodes de temps prédéfinies.
- Vous pouvez utiliser un réveil externe: cela signifie que l’ESP32 peut se réveiller lorsqu’un changement d’état d’une broche se produit.
- Vous pouvez utiliser le toucher les épingles: implémenté, mais ne fonctionne pas comme prévu au moment de la rédaction, nous n’en parlerons donc pas pour le moment ;
- Vous pouvez utiliser le coprocesseur ULP pour vous réveiller : nous n’avons pas encore testé cette fonctionnalité.
Minuterie 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 qui nécessitent un horodatage ou des tâches quotidiennes, tout en maintenant une faible consommation d’énergie.
Pour mettre l’ESP32 en mode veille profonde pendant un nombre de secondes prédéterminé, il suffit d’utiliser le sommeil profond() fonction de la machine module. Cette fonction accepte comme arguments, le temps de veille en millisecondes comme suit :
machine.deepsleep(sleep_time_ms)Regardons un exemple simple pour voir comment cela fonctionne. Dans le code suivant, l’ESP32 est en mode veille prolongée pendant 10 secondes, puis il se réveille, fait clignoter une LED et se rendort.
# Complete project details at https://Raspberryme.com
import machine
from machine import Pin
from time import sleep
led = Pin (2, Pin.OUT)
#blink LED
led.value(1)
sleep(1)
led.value(0)
sleep(1)
# wait 5 seconds so that you can catch the ESP awake to establish a serial communication later
# you should remove this sleep line in your final script
sleep(5)
print('Im awake, but Im going to sleep')
#sleep for 10 seconds (10000 milliseconds)
machine.deepsleep(10000)
Comment fonctionne le code
Tout d’abord, importez les bibliothèques nécessaires :
import machine
from machine import Pin
from time import sleepCréer un Épingler objet qui fait référence à GPIO 2 appelé LED. Il s’agit de la LED intégrée.
led = Pin (2, Pin.OUT)Les commandes suivantes font clignoter la LED.
led.value(1)
sleep(1)
led.value(0)
sleep(1)Dans ce cas, nous faisons clignoter une LED à des fins de démonstration, mais l’idée est d’ajouter votre code principal dans cette section du script.
Avant d’aller dormir, nous ajoutons un délai de 5 secondes et imprimons un message pour indiquer qu’il va dormir.
sleep(5)
print('Im awake, but Im going to sleep')Il est important d’ajouter un délai de 5 secondes avant d’aller dormir lorsque nous développons les scripts. Lorsque vous souhaitez télécharger un nouveau code sur le tableau, il doit être éveillé. Donc, si vous n’avez pas le retard, il sera difficile de le rattraper pour télécharger un nouveau code plus tard. Après avoir obtenu le code final, vous pouvez supprimer ce délai.
Enfin, mettez l’ESP32 en veille profonde pendant 10 secondes (10 000 millisecondes).
machine.deepsleep(10000)Après 10 secondes, l’ESP32 se réveille et exécute le code depuis le début, de la même manière que lorsque vous appuyez sur le bouton EN/RST.
Manifestation
Copiez le code fourni au main.py fichier de votre ESP32. Téléchargez le nouveau code et appuyez sur le bouton EN/RST après le téléchargement.
L’ESP32 doit faire clignoter la LED intégrée et imprimer un message. Ensuite, il s’endort. Ceci est répété maintes et maintes fois.
Si vous ne savez pas comment télécharger le script, suivez ce tutoriel si vous utilisez Thonny IDE, ou celui-ci si vous utilisez uPyCraft IDE.
Réveil externe
L’ESP32 peut également être réveillé du sommeil lorsqu’il y a un changement sur l’état d’une broche. Il existe deux possibilités de réveil externe avec l’ESP32 : poste0 et poste1.
Le mode ext0 vous permet d’utiliser un GPIO comme source de réveil. Le mode ext1 vous permet de définir plusieurs GPIO comme source de réveil en même temps.
Seuls les GPIO RTC peuvent être utilisés comme source de réveil. Les GPIO RTC sont mis en évidence avec un rectangle orange dans le diagramme suivant.
En savoir plus sur les GPIO ESP32 : Référence de brochage ESP32 : quelles broches GPIO devez-vous utiliser ?
Réveil externe – ext0
Pour illustrer comment utiliser le réveil externe ext0, nous utiliserons un bouton-poussoir comme source de réveil. L’ESP32 se réveille lorsque vous appuyez sur le bouton poussoir.
Pour cet exemple, vous avez besoin des composants suivants :
Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !
Diagramme schématique
Câblez le circuit en suivant le schéma suivant. Dans cet exemple, nous utilisons GPIO14 pour réveiller l’ESP32, mais vous pouvez utiliser n’importe quel autre GPIO RTC.
Scénario
Le script suivant montre comment fonctionne ext0 : il utilise un GPIO comme source de réveil externe.
# Complete project details at https://Raspberryme.com
import machine
import esp32
from machine import Pin
from time import sleep
wake1 = Pin(14, mode = Pin.IN)
#level parameter can be: esp32.WAKEUP_ANY_HIGH or esp32.WAKEUP_ALL_LOW
esp32.wake_on_ext0(pin = wake1, level = esp32.WAKEUP_ANY_HIGH)
#your main code goes here to perform a task
print('Im awake. Going to sleep in 10 seconds')
sleep(10)
print('Going to sleep now')
machine.deepsleep()
Comment fonctionne le code
Tout d’abord, vous devez importer les modules nécessaires. Vous devez importer le esp32 module qui contient les méthodes pour définir une broche comme source de réveil.
Après avoir importé les modules nécessaires, définissez une broche de réveil. Dans ce cas, nous utilisons GPIO14 et nous l’appelons réveiller1. Ce GPIO doit être défini comme une entrée (Pin.IN).
wake1 = Pin(14, mode = Pin.IN)Ensuite, définissez ext0 comme source de réveil à l’aide de la wake_on_ext0() méthode comme suit :
esp32.wake_on_ext0(pin = wake1, level = esp32.WAKEUP_ANY_HIGH)le wake_on_ext0() La méthode accepte comme arguments le pin et le niveau :
- épingler: un objet de type Épingler (le GPIO qui agit comme une source de réveil)
- niveau: définit l’état du GPIO qui réveille l’ESP32. Le niveau peut être l’un des paramètres suivants :
- WAKEUP_ANY_HIGH
- WAKEUP_ALL_LOW
Dans ce cas, nous utilisons le WAKEUP_ANY_HIGH méthode qui réveille l’ESP32 lorsque le GPIO devient HAUT.
Votre code principal pour exécuter une tâche doit aller après avoir défini la source de réveil et juste avant de vous endormir.
Nous ajoutons un délai de 10 secondes avant d’aller dormir. Pour mettre l’ESP32 en veille profonde, il suffit d’utiliser le sommeil profond() méthode comme suit :
machine.deepsleep()Manifestation
Téléchargez le code sur l’ESP32 main.py déposer. Appuyez sur le bouton EN/RESET pour exécuter le code. L’ESP32 devrait se mettre en veille.
Maintenant, vous pouvez appuyer sur le bouton pour le réveiller du sommeil profond.
Réveil externe – ext1
Le réveil externe ext1 fonctionne de manière très similaire à ext0 mais il vous permet de définir plus d’un GPIO comme source de réveil. Pour montrer comment cela fonctionne, nous utiliserons deux boutons-poussoirs câblés à différents GPIO.
Pour cet exemple, vous avez besoin des composants suivants :
Diagramme schématique
Câblez le circuit en suivant le schéma suivant.
Dans ce cas, nous utilisons GPIO14 et GPIO12. Vous pouvez utiliser n’importe quel autre GPIO approprié, mais ceux-ci doivent être des GPIO RTC, sinon cette méthode ne fonctionnera pas.
Scénario
Le script suivant montre comment fonctionne ext1 : il utilise deux GPIO comme source de réveil externe, mais vous pouvez en utiliser plus si vous le souhaitez.
# Complete project details at https://Raspberryme.com
import machine
import esp32
from machine import Pin
from time import sleep
wake1 = Pin(14, mode = Pin.IN)
wake2 = Pin(12, mode = Pin.IN)
#level parameter can be: esp32.WAKEUP_ANY_HIGH or esp32.WAKEUP_ALL_LOW
esp32.wake_on_ext1(pins = (wake1, wake2), level = esp32.WAKEUP_ANY_HIGH)
#your main code goes here to perform a task
print('Im awake. Going to sleep in 10 seconds')
sleep(10)
print('Going to sleep now')
machine.deepsleep()
Comment fonctionne le code
Le code est similaire à l’exemple ext0, mais il utilise le wake_on_ext1() méthode à la place.
esp32.wake_on_ext1(pins = (wake1, wake2), level = esp32.WAKEUP_ANY_HIGH)le wake_on_ext1() La méthode accepte comme arguments les pins et le niveau :
- épingles: un tuple ou une liste avec des objets de type Épingler (les GPIO qui agissent comme une source de réveil)
- niveau: définit l’état des GPIO qui vont réveiller l’ESP32. Le niveau peut être l’un des paramètres suivants :
- WAKEUP_ANY_HIGH
- WAKEUP_ALL_LOW
Après avoir défini la source de réveil, vous pouvez mettre l’ESP32 en veille profonde :
machine.deepsleep()Conclusion
Nous espérons que vous avez trouvé ce didacticiel sur le sommeil profond avec l’ESP32 utilisant MicroPython utile. Nous avons couvert le réveil par minuterie et le réveil externe. Il y a aussi la possibilité de réveiller l’ESP32 à l’aide des touches tactiles. Bien que cela soit déjà disponible dans le dernier firmware MicroPython, il ne fonctionne pas comme prévu, nous ne l’avons donc pas inclus dans le didacticiel. En attendant, vous pouvez utiliser ESP32 Touch Wake Up avec Arduino IDE.
Si vous souhaitez en savoir plus sur la programmation des cartes ESP32 et ESP8266 avec MicroPython, consultez notre eBook : Programmation MicroPython avec ESP32 et ESP8266.
Nous avons d’autres tutoriels liés au sommeil profond qui pourraient vous intéresser :
Merci d’avoir lu.