MicroPython : ESP8266 Sources de sommeil profond et de réveil

Ce guide montre comment utiliser le sommeil profond avec l’ESP8266 et comment le réveiller avec une minuterie ou un réveil externe à l’aide du micrologiciel MicroPython.

Si vous avez un ESP32, nous vous recommandons de lire notre Guide des sources de veille et de réveil MicroPython ESP32.

Conditions préalables

Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython flashé dans votre 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 :

Présentation du sommeil profond

Lorsque l’ESP8266 est en mode veille prolongée, tout est éteint sauf l’horloge en temps réel (RTC), qui permet à l’ESP8266 de suivre l’heure.

En mode veille profonde, la puce ESP8266 consomme environ
seulement 20uA.

Consommation d'énergie de la puce Deep Sleep ESP8266

Cependant, vous devez garder à l’esprit que dans une carte ESP8266 assemblée, elle consomme beaucoup plus de courant.

Nous avons pu construire un enregistreur de données de station météo avec l’ESP8266 en utilisant MicroPython qui ne consomme que 7uA lorsqu’il est en mode veille profonde : Enregistreur de données de station météorologique basse consommation utilisant ESP8266 et BME280 avec MicroPython

Minuterie Réveil

Il existe différentes manières de réveiller l’ESP8266 avec une minuterie après un sommeil profond. L’un des moyens les plus simples consiste à utiliser la fonction suivante dans votre code.

def deep_sleep(msecs):
  #configure RTC.ALARM0 to be able to wake the device
  rtc = machine.RTC()
  rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
  # set RTC.ALARM0 to fire after Xmilliseconds, waking the device
  rtc.alarm(rtc.ALARM0, msecs)
  #put the device to sleep
  machine.deepsleep()

Nous vous recommandons de copier la fonction précédente au début de votre script, puis d’appeler le sommeil profond() fonction pour mettre l’ESP8266 en mode veille profonde.

Cette sommeil profond() La fonction crée une minuterie qui réveille l’ESP8266 après un nombre prédéterminé de secondes. Pour utiliser cette fonction plus tard dans votre code, il vous suffit de passer en argument le temps de sommeil en millisecondes.

Scénario

Dans le code suivant, l’ESP8266 est en mode veille prolongée pendant 10 secondes. Lorsqu’il se réveille, il fait clignoter une LED et se rendort à nouveau. Ce processus est répété maintes et maintes fois.

# Complete project details at https://Raspberryme.com

import machine
from machine import Pin
from time import sleep

led = Pin(2, Pin.OUT)

def deep_sleep(msecs):
  # configure RTC.ALARM0 to be able to wake the device
  rtc = machine.RTC()
  rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)

  # set RTC.ALARM0 to fire after X milliseconds (waking the device)
  rtc.alarm(rtc.ALARM0, msecs)

  # put the device to sleep
  machine.deepsleep()
  
#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)
deep_sleep(10000)

Afficher le code brut

Comment fonctionne le code

Tout d’abord, importez les bibliothèques nécessaires :

import machine
from machine import Pin
from time import sleep

Créer un Épingler objet qui fait référence à GPIO 2 appelé LED. Pour notre carte, il s’agit de la LED embarquée.

led = Pin(2, Pin.OUT)

Après cela, ajoutez le sommeil profond() fonction à votre code:

def deep_sleep(msecs):
  #configure RTC.ALARM0 to be able to wake the device
  rtc = machine.RTC()
  rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
  # set RTC.ALARM0 to fire after Xmilliseconds, waking the device
  rtc.alarm(rtc.ALARM0, msecs)
  #put the device to sleep
  machine.deepsleep()

Les lignes suivantes font clignoter la LED.

led.value(1)
sleep(1)
led.value(0)
sleep(1)

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 ce délai de 5 secondes avant d’aller dormir lorsque nous développons le script. Lorsque vous souhaitez télécharger un nouveau code sur votre tableau, il doit être activé. Donc, si vous n’avez pas le délai, il sera difficile de le rattraper pour télécharger le code plus tard. Après avoir obtenu le code final, vous pouvez supprimer ce délai.

Enfin, mettez l’ESP8266 en veille prolongée pendant 10 secondes (10 000 millisecondes) en appelant le sommeil profond() fonction et en passant en argument le nombre de millisecondes.

deep_sleep(10000)

Après 10 secondes, l’ESP8266 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 RESET.

Téléchargement du code

Copiez le code fourni au main.py fichier et téléchargez-le sur votre ESP8266.

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.

Après avoir téléchargé le code, vous devez vous connecter GPIO16 (D0) à la broche RST afin que l’ESP8266 puisse se réveiller.

MicroPython ESP8266 NodeMCU Timer Wake Up Schéma du circuit de sommeil profond

Important: si vous ne connectez pas GPIO16 à la broche RST, l’ESP8266 ne se réveillera pas.

Manifestation

Après avoir téléchargé le code et connecté GPIO 16 (D0) à la broche RST, l’ESP8266 doit faire clignoter la LED intégrée et imprimer un message dans la coque.

Ensuite, il se met en veille pendant 10 secondes, se réveille et exécute à nouveau le code. Ce processus est répété maintes et maintes fois.

MicroPython ESP8266 Minuterie Wake Up Démonstration du sommeil profond

Sommeil profond avec ESP-01

Si vous souhaitez effectuer une configuration similaire avec une carte ESP-01, vous devez souder un fil comme indiqué dans la figure suivante. Cette petite broche de la puce est GPIO16 et elle doit être connectée à la broche RST.

MicroPython ESP-01 Timer Wake Up Schéma du circuit de sommeil profond

Cependant, les broches sont si petites qu’il est vraiment difficile de souder un tel fil au GPIO 16 sans endommager la puce.

En savoir plus sur les GPIO ESP8266 : Référence de brochage ESP8266 : quelles broches GPIO devez-vous utiliser ?

Réveil externe

L’ESP8266 ne prend pas en charge le réveil externe comme le fait l’ESP32. Mais, il y a quelque chose que nous pouvons faire à ce sujet.

Si nous mettons l’ESP8266 en veille prolongée pendant une durée indéterminée, il ne se réveillera que lorsque quelque chose réinitialise la carte. Ainsi, nous pouvons câbler quelque chose au TVD broche et l’utiliser comme un réveil externe. Il peut s’agir par exemple d’une pression sur un bouton poussoir ou d’un interrupteur magnétique à lames fermés.

L’ESP8266 se réinitialise lorsque le TVD la broche devient FAIBLE.

Diagramme schématique

Pour tester cette méthode, câblez un bouton poussoir au TVD épingler. Vous avez besoin des composants suivants pour le circuit :

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 !

Si vous utilisez un Kit NodeMCU ESP8266 12-E, suivez le schéma suivant.

Schéma du circuit de réveil profond MicroPython ESP8266 NodeMCU pour le réveil externe

Si vous utilisez un ESP-01, vous pouvez suivre le schéma suivant.

Schéma du circuit de réveil profond MicroPython ESP-01 NodeMCU pour le réveil externe

Scénario

Téléchargez le code suivant sur l’ESP8266 en tant que main.py.

# 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(0)
sleep(1)
led.value(1)
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(1)

#sleep for indefinite time
machine.deepsleep()

Afficher le code brut

Dans ce cas, il vous suffit d’appeler machine.deepsleep() après l’exécution du code principal.

Quand vous appelez machine.deepsleep() sans aucun argument, l’ESP8266 passera en mode veille prolongée indéfiniment jusqu’à ce que vous appuyiez sur le TVD bouton.

Manifestation

Après avoir câblé le circuit et téléchargé le code, vous pouvez tester votre configuration. Chaque fois que vous appuyez sur le bouton-poussoir qui est connecté au TVD broche, l’ESP8266 se réinitialise et se réveille. Il fait clignoter la LED embarquée et se rendort.

MicroPython ESP8266 NodeMCU Externe Wake Up Démonstration du sommeil profond

Conclusion

Nous espérons que vous avez trouvé ce projet sur le sommeil profond avec l’ESP8266 utile. Nous avons d’autres tutoriels sur le sommeil profond qui pourraient vous plaire :

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.

Merci d’avoir lu.