MicroPython : interruptions de minuterie avec l’ESP32/ESP8266

Dans ce guide, vous apprendrez à utiliser les interruptions de minuterie (minuteries et gestion des événements) avec les ESP32 et ESP8266 programmés avec MicroPython. Les interruptions programmées vous permettent de planifier et d’exécuter des tâches spécifiques à intervalles réguliers ou après un délai désigné.

Table des matières:

Dans ce tutoriel, nous aborderons les sujets suivants :

Conditions préalables

Avant de poursuivre ce tutoriel, assurez-vous de vérifier les prérequis suivants

Micrologiciel MicroPython

Pour suivre ce tutoriel, vous devez installer le firmware MicroPython sur vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre tableau. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

• ThonnyIDE :
• L’EDI uPyCraft :

Si vous aimez programmer en utilisant VS Code, il existe également une option : MicroPython : Programmer ESP32/ESP8266 en utilisant VS Code et Pymakr

En savoir plus sur MicroPython : Programmation MicroPython avec ESP32 et ESP8266

Pièces requises

Pour compléter les exemples de ce didacticiel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Présentation des interruptions

Les interruptions sont utiles pour que les choses se produisent automatiquement dans les programmes de microcontrôleurs et peuvent aider à résoudre les problèmes de synchronisation. Les interruptions et la gestion des événements fournissent des mécanismes pour répondre aux événements, permettant à l’ESP32/ESP8266 de réagir rapidement aux changements sans interrogation continue (vérification continue de la valeur actuelle d’une broche ou d’une variable ou vérification continue de l’heure).

L’utilisation d’interruptions programmées est particulièrement utile pour que quelque chose se produise périodiquement ou après une période prédéfinie sans vérifier constamment le temps écoulé.

Types d’interruptions

Il existe différents types d’interruptions : les interruptions externes et les interruptions temporisées :

• Interruptions externes : déclenchées par des signaux externes tels qu’une pression sur un bouton ou une lecture d’un capteur ; elles sont basées sur le matériel et associées à une broche GPIO spécifique. Lorsque l’état d’une broche change, une tâche est déclenchée. Apprenez-en davantage sur les interruptions externes avec l’ESP32/ESP8266 dans cet article : MicroPython : Interruptions externes avec ESP32 et ESP8266.

• Interruptions programmées (minuteries) : déclenchées en fonction d’intervalles de temps, permettant des actions périodiques ; elles utilisent la minuterie matérielle des cartes pour déclencher des rappels à intervalles réguliers. Nous examinerons ce type d’interruptions dans cet article.

Le minuteur de classe MicroPython

Le module machine MicroPython est livré avec une classe appelée Timer qui fournit des méthodes pour exécuter une fonction de rappel périodiquement dans une période donnée ou une fois après un délai prédéfini. Ceci est utile pour planifier des événements ou exécuter des tâches périodiques sans vérifier constamment le temps écoulé.

Jetons un coup d’œil rapide aux constructeurs Timer.

Créer une minuterie

Pour créer un timer, il vous suffit d’appeler le constructeur Timer() et de passer en argument l’identifiant du timer, comme suit :

my_timer = Timer(id)

Ensuite, vous initialisez un timer en utilisant la méthode init() sur l’objet Timer() et vous passez en argument le mode timer, la période et la fonction de rappel. Voici un exemple :

my_timer.init(mode=Timer.PERIODIC, period=1000, callback=timer_callback)

Cela initialise une minuterie périodique qui exécutera la fonction timer_callback toutes les 1 000 millisecondes (1 seconde). Vous pouvez modifier le paramètre de période sur n’importe quelle période souhaitée.

Au lieu d’appeler périodiquement la fonction de rappel, vous souhaiterez peut-être également l’exécuter une fois après une heure prédéfinie. Pour cela, vous pouvez utiliser le mode Timer.ONE_SHOT comme suit :

my_timer.init(mode=Timer.ONE_SHOT, period=1000, callback=timer_callback)

Cette ligne de code configure une minuterie (my_timer) pour qu’elle s’exécute en mode unique, déclenchant la fonction de rappel spécifiée (timer_callback) après 1 000 millisecondes.

Apprenez-en davantage sur la classe Timer dans la documentation MicroPython.

Interruptions de minuterie avec l’ESP32/ESP8266

Nous allons maintenant examiner différents scénarios d’application d’interruptions de minuterie avec l’ESP32/ESP8266.

1. Faire clignoter une LED avec une minuterie
2. Clignotement de plusieurs LED à différentes fréquences
3. Anti-rebond d’un bouton-poussoir avec une minuterie

1. Faire clignoter une LED avec une minuterie – MicroPython

Dans cet exemple, vous apprendrez à faire clignoter une LED à l’aide d’une minuterie. Cela vous aidera à comprendre le fonctionnement des minuteries périodiques.

Schéma de circuit

Nous ferons clignoter une LED connectée au GPIO 13. Alors, connectez une LED à l’ESP32 ou à l’ESP8266 sur ce GPIO. Vous pouvez utiliser les diagrammes suivants comme référence.

ESP32

Lecture recommandée : Référence de brochage ESP32 : quelles broches GPIO devez-vous utiliser ?

Nœud MCU ESP8266

Lecture recommandée : Référence de brochage ESP8266 : quelles broches GPIO devez-vous utiliser ?

Code

L’exemple suivant utilise la classe Timer pour faire clignoter une LED toutes les demi-secondes. Ce code est compatible avec les cartes ESP32 et ESP8266.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-timer-interrupts-ep32-esp8266/

from machine import Pin, Timer
from time import sleep

# LED pin
led_pin = 13
led = Pin(led_pin, Pin.OUT)

# Callback function for the timer
def toggle_led(timer):
    led.value(not led.value())  # Toggle the LED state (ON/OFF)

# Create a periodic timer
blink_timer = Timer(1)
blink_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_led)  # Timer repeats every half second

try:
    # Main loop (optional)
    while True:
        print('Main Loop is running')
        sleep(2)
except KeyboardInterrupt:
    # Keyboard interrupt occurred, deinitialize the timer
    blink_timer.deinit()
    print('Timer deinitialized')
    # Turn off the LED
    led.value(0)

Afficher le code brut

Dans ce code, nous créons un timer appelé clignotant_timer :

blink_timer = Timer(1)

Ensuite, nous initialisons le timer avec les paramètres suivants :

blink_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_led)

Cela signifie que cette minuterie appellera la fonction toggle_led tous les 500, pour toujours (ou jusqu’à ce que vous arrêtiez le programme).

La fonction toggle_led, comme son nom l’indique, basculera l’état de la LED :

# Callback function for the timer
def toggle_led(timer):
    led.value(not led.value())  # Toggle the LED state (ON/OFF)

Les fonctions de rappel du minuteur doivent avoir un argument qui est transmis automatiquement par l’objet Timer lorsque l’événement est déclenché.

Avec les minuteries, vous pouvez également exécuter d’autres tâches sur la boucle principale sans interférer les unes avec les autres. Par exemple, dans notre cas, dans la boucle principale, nous imprimerons un message toutes les deux secondes.

while True:
    print('Main Loop is running')
    sleep(2)

Lorsque l’utilisateur arrête le programme (KeyboardInterrupt), nous désinitialisons le timer à l’aide de la méthode deinit() et éteignons la LED.

except KeyboardInterrupt:
    # Keyboard interrupt occurred, deinitialize the timer
    blink_timer.deinit()
    print('Timer deinitialized')
    # Turn off the LED
    led_pin.value(0)

Tester le code

Avec une LED connectée au GPIO 13, exécutez le code précédent sur votre carte.

Vous recevrez le message « Main Loop is running » toutes les deux secondes sur le Shell, tandis que la LED clignote toutes les demi-secondes en même temps.

2. Clignotement de plusieurs LED à différentes fréquences

Après avoir testé l’exemple précédent, il est facile de comprendre que si vous créez plusieurs minuteurs, vous pouvez exécuter plusieurs tâches à des fréquences différentes. Dans cet exemple, nous ferons clignoter deux LED différentes. L’un clignotera toutes les demi-secondes et l’autre toutes les deux secondes.

Schéma de circuit

Câblez deux LED à l’ESP32/ESP8266 (pour distinguer les différentes LED, nous utiliserons des couleurs différentes) :

• LED rouge : GPIO 13 – clignotera toutes les demi-secondes ;
• LED jaune : GPIO 12 – clignotera toutes les deux secondes.

Vous pouvez utiliser les schémas suivants comme référence pour câbler le circuit.

ESP32

Nœud MCU ESP8266

Code

Le code suivant utilise des minuteries pour faire clignoter deux LED différentes à des fréquences différentes. Le code est compatible avec les cartes ESP32 et ESP8266.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-timer-interrupts-ep32-esp8266/
 
from machine import Pin, Timer
from time import sleep

# LEDs
red_led_pin = 12
red_led = Pin(red_led_pin, Pin.OUT)
yellow_led_pin = 13
yellow_led = Pin(yellow_led_pin, Pin.OUT)

# Callback function for the red timer
def toggle_red_led(timer):
    red_led.value(not red_led.value())  # Toggle the LED state (ON/OFF)
    print('red LED is: ', red_led.value())

# Callback function for the yellow timer
def toggle_yellow_led(timer):
    yellow_led.value(not yellow_led.value())  # Toggle the LED state (ON/OFF)
    print('yellow LED is: ', yellow_led.value())

# Create periodic timers
red_timer = Timer(1)
yellow_timer = Timer(2)

# Init the timers
red_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_red_led)  # Timer repeats every 0.5 second
yellow_timer.init(mode=Timer.PERIODIC, period=2000, callback=toggle_yellow_led)  # Timer repeats every 2 seconds

try:
    # Main loop (optional)
    while True:
        print('Main Loop is running')
        sleep(2)
        
except KeyboardInterrupt:
    # Keyboard interrupt occurred, deinitialize the timers
    red_timer.deinit()
    yellow_timer.deinit()
    print('Timers deinitialized')
    # Turn off the LEDs
    yellow_led.value(0)
    red_led.value(0)

Afficher le code brut

Dans ce code, nous créons deux minuteries différentes, une pour chaque LED :

# Create periodic timers
red_timer = Timer(1)
yellow_timer = Timer(2)

Ensuite, nous appelons les fonctions de rappel correspondantes à différents intervalles :

# Init the timers
red_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_red_led)  # Timer repeats every 0.5 second
yellow_timer.init(mode=Timer.PERIODIC, period=2000, callback=toggle_yellow_led)  # Timer repeats every 2 seconds

Les fonctions de rappel basculent simplement la valeur actuelle de la LED :

# Callback function for the red timer
def toggle_red_led(timer):
    red_led.value(not red_led.value())  # Toggle the LED state (ON/OFF)
    print('red LED is: ', red_led.value())

# Callback function for the yellow timer
def toggle_yellow_led(timer):
    yellow_led.value(not yellow_led.value())  # Toggle the LED state (ON/OFF)
    print('yellow LED is: ', yellow_led.value())

Tester le code

Exécutez le code précédent sur l’ESP32 ou l’ESP8266. Vous remarquerez que les deux LED clignoteront à des fréquences différentes.

En même temps, vous recevrez un message de la boucle while toutes les deux secondes. Cela montre que les autres tâches n’interfèrent pas avec notre boucle.

3. Anti-rebond d’un bouton-poussoir avec une minuterie

Le rebond du bouton se produit lorsque le bouton-poussoir compte plus d’une pression alors qu’en fait, vous venez d’appuyer une seule fois. Ceci est très courant dans les boutons mécaniques comme les boutons-poussoirs.

Cela se produit parce que les contacts électriques à l’intérieur du bouton se connectent et se déconnectent très rapidement avant d’atteindre un état stable, ce qui amènera le système à enregistrer plusieurs événements de pression, provoquant un décompte inexact. Pour éviter ce problème, nous pouvons ajouter des techniques anti-rebond utilisant des délais ou des minuteries.

Dans cet exemple, nous verrons comment utiliser des minuteries et des événements pour empêcher le rebond d’un bouton-poussoir.

Schéma de circuit

Pour cet exemple, câblez une LED (GPIO 13) et un bouton-poussoir (GPIO12) à l’ESP32 et à l’ESP8266.

• LED (GPIO13)
• Bouton-poussoir (GPIO 12)

Vous pouvez utiliser les diagrammes schématiques suivants comme référence.

ESP32

Nœud MCU ESP8266

Code

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-timer-interrupts-ep32-esp8266/
 
from machine import Pin, Timer
import time

led = Pin(13, Pin.OUT)
button = Pin(12, Pin.IN, Pin.PULL_UP)
counter = 0  # Initialize the button press count
debounce_timer = None

def button_pressed(pin):
    global counter, debounce_timer  # Declare variables as global

    if debounce_timer is None:
        counter += 1
        print("Button Pressed! Count: ", counter)
        
        # Toggle the LED on each button press
        led.value(not led.value())

        # Start a timer for debounce period (e.g., 200 milliseconds)
        debounce_timer = Timer(1)
        debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

def debounce_callback(timer):
    global debounce_timer
    debounce_timer = None

# Attach the interrupt to the button's rising edge
button.irq(trigger=Pin.IRQ_RISING, handler=button_pressed)

try:
    # Main loop (optional)
    while True:
        print("Loop is running")
        time.sleep(5)
except KeyboardInterrupt:
    # Keyboard interrupt occurred, deinitialize the timer
    debounce_timer.deinit()
    # Turn off the LED
    led.value(0)

Afficher le code brut

Comment fonctionne le code

Jetons un coup d’œil rapide à la façon dont nous utilisons les minuteries pour anti-rebondir un bouton-poussoir.

Contenu associé : Entrées et sorties numériques ESP32/ESP8266 avec MicroPython

Cet exemple utilise un minuteur unique (debounce_timer) déclenché à chaque pression sur un bouton avec une période anti-rebond spécifiée, dans cet exemple 200 millisecondes. Vous pouvez augmenter la période anti-rebond si vous obtenez toujours des faux positifs.

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

Pour détecter une pression sur un bouton-poussoir, nous utilisons des interruptions externes. La fonction button_pressed sera déclenchée en mode montant (lorsque le bouton est enfoncé).

button.irq(trigger=Pin.IRQ_RISING, handler=button_pressed)

Contenu associé : MicroPython : interruptions avec ESP32 et ESP8266.

Lorsque le bouton est enfoncé, la fonction button_pressed est appelée, incrémentant le compteur, basculant la LED et démarrant la minuterie unique pour anti-rebond.

counter += 1
print("Button Pressed! Count: ", counter)
        
# Toggle the LED on each button press
led.value(not led.value())

# Start a timer for debounce period (e.g., 200 milliseconds)
debounce_timer = Timer(1)
debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

La fonction debounce_callback du timer est appelée lorsque le timer one-shot expire, réinitialisant le debounce_timer sur None.

def debounce_callback(timer):
    global debounce_timer
    debounce_timer = None

Si le minuteur n’a pas encore expiré, si une autre pression sur un bouton est détectée, elle ne sera pas prise en compte car le debounce_timer n’a pas été réinitialisé sur Aucun :

if debounce_timer is None:

Notez que nous utilisons des variables globales afin de pouvoir y accéder dans toutes les parties du code, y compris à l’intérieur des fonctions :

global counter, debounce_timer  # Declare variables as global

Ce n’est qu’une des nombreuses façons d’empêcher le rebond d’un bouton-poussoir.

L’utilisation de Aucun

En Python/MicroPython, None est souvent utilisé comme espace réservé ou valeur par défaut pour indiquer l’absence de valeur significative. Dans cet exemple précédent, None nous aide à gérer l’état de la variable debounce_timer.

debounce_timer est initialement défini sur None pour indiquer qu’aucun minuteur anti-rebond n’est actuellement actif.

debounce_timer = None

Dans la fonction button_pressed, la condition suivante vérifie s’il n’y a pas de minuterie anti-rebond active.

if debounce_timer is None:

S’il n’y a pas de minuteur actif (Aucun), les actions d’appui sur le bouton sont effectuées et un nouveau minuteur ponctuel, debounce_timer, est lancé.

debounce_timer = Timer(1)
debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

Lorsque le minuteur ponctuel expire, la fonction debounce_callback est appelée et redéfinit debounce_timer sur None, indiquant que la période anti-rebond est terminée.

def debounce_callback(timer):
    global debounce_timer
    debounce_timer = None

Tester le code

Exécutez le code sur votre ESP32/ESP8266. Appuyez plusieurs fois sur le bouton poussoir. Vous remarquerez que vous n’obtiendrez pas de faux positifs et qu’il comptera le nombre de fois où le bouton-poussoir a été enfoncé.

Si vous obtenez des faux positifs, vous devez augmenter la période anti-rebond de 200 millisecondes sur le debounce_timer.

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

Conclusion

Dans ce didacticiel, vous avez appris à utiliser les interruptions de minuterie avec les ESP32 et ESP8266 programmés avec MicroPython. L’utilisation d’interruptions de minuterie est utile pour que les choses se produisent périodiquement sans avoir à vérifier constamment le temps écoulé.

Nous avons un tutoriel sur les interruptions externes qui pourrait vous être utile : MicroPython : Interruptions avec ESP32 et ESP8266.

Apprenez-en davantage sur MicroPython grâce à nos ressources :

Merci d’avoir lu.

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :