MicroPython : interruptions avec ESP32 et ESP8266

Apprenez à configurer et à gérer les interruptions à l’aide du micrologiciel MicroPython avec les cartes ESP32 et ESP8266. Vous construirez également un exemple de projet avec un capteur de mouvement PIR.

Conditions préalables

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

Présentation des interruptions

Les interruptions sont utiles pour faire en sorte que les choses se produisent automatiquement dans les programmes de microcontrôleur et peuvent aider à résoudre les problèmes de synchronisation. Avec les interruptions, vous n’avez pas besoin de vérifier constamment la valeur actuelle de la broche. Lorsqu’un changement est détecté, un événement est déclenché (une fonction est appelée).

Lorsqu’une interruption se produit, le processeur arrête l’exécution du programme principal pour exécuter une tâche, puis revient au programme principal comme indiqué dans la figure ci-dessous.

Ceci est particulièrement utile pour déclencher une action à chaque détection de mouvement ou à chaque appui sur un bouton poussoir sans avoir besoin de vérifier constamment son état.

Broches d’interruption ESP32 : vous pouvez utiliser tous les GPIO comme interruptions, sauf GPIO 6 à GPIO 11.

Broches d’interruption ESP8266 : vous pouvez utiliser tous les GPIO, sauf GPIO 16.

Configurer une interruption dans MicroPython

Pour configurer une interruption dans MicroPython, vous devez suivre les étapes suivantes :

1. Définir une fonction de gestion des interruptions. La fonction de gestion des interruptions doit être aussi simple que possible, afin que le processeur revienne rapidement à l’exécution du programme principal. La meilleure approche consiste à signaler au code principal que l’interruption s’est produite en utilisant une variable globale, par exemple. La fonction de gestion des interruptions doit accepter un paramètre de type Épingler. Ce paramètre est renvoyé à la fonction de rappel et fait référence au GPIO qui a provoqué l’interruption.

def handle_interrupt(pin):

2. Configurez le GPIO qui agira comme une broche d’interruption en tant qu’entrée. Par example:

pir = Pin(14, Pin.IN)

3. Attachez une interruption à cette broche en appelant le irq() méthode:

pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

le irq() La méthode accepte les arguments suivants :

• gâchette: ceci définit le mode de déclenchement. Il existe 3 conditions différentes :
  • Pin.IRQ_FALLING: pour déclencher l’interruption chaque fois que la broche passe de HIGH à LOW ;
  • Pin.IRQ_RISING: pour déclencher l’interruption chaque fois que la broche passe de LOW à HIGH.
  • 3: pour déclencher l’interruption sur les deux fronts (c’est-à-dire lorsqu’un changement est détecté)
• gestionnaire : c’est une fonction qui sera appelée lorsqu’une interruption sera détectée, dans ce cas la handle_interrupt() une fonction.

Exemple de projet avec capteur de mouvement PIR

Pour montrer comment gérer les interruptions, nous allons créer un projet simple avec un capteur de mouvement PIR. Chaque fois qu’un mouvement est détecté, nous allumons une LED pendant 20 secondes.

Pièces nécessaires

Voici une liste des pièces dont vous avez besoin pour construire le circuit :

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

Schéma – ESP32

Suivez le diagramme schématique suivant si vous utilisez une carte ESP32 :

Schéma – ESP8266

Suivez le diagramme schématique suivant si vous utilisez une carte ESP8266 :

Important: la Mini détecteur de mouvement AM312 PIR que nous utilisons dans ce projet fonctionne à 3,3 V. Cependant, si vous utilisez un autre capteur de mouvement PIR comme le HC-SR501, il fonctionne à 5V. Vous pouvez soit le modifier pour qu’il fonctionne à 3,3 V, soit simplement l’alimenter à l’aide de la broche Vin.

Dans la figure ci-dessous, nous fournissons le brochage du capteur de mouvement Mini AM312 PIR. Si vous utilisez un autre capteur de mouvement, veuillez vérifier son brochage avant d’assembler le circuit.

Code

Voici le script qui détecte le mouvement et allume une LED chaque fois qu’un mouvement est détecté. Ce code est compatible avec l’ESP32 et l’ESP8266.

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

from machine import Pin
from time import sleep

motion = False

def handle_interrupt(pin):
  global motion
  motion = True
  global interrupt_pin
  interrupt_pin = pin 

led = Pin(12, Pin.OUT)
pir = Pin(14, Pin.IN)

pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

while True:
  if motion:
    print('Motion detected! Interrupt caused by:', interrupt_pin)
    led.value(1)
    sleep(20)
    led.value(0)
    print('Motion stopped!')
    motion = False

Afficher le code brut

Comment fonctionne le code

Pour utiliser les interruptions, importez le Épingler classe de la machine module. Nous importons également le sommeil méthode de la temps module pour ajouter un délai dans notre script.

from machine import Pin
from time import sleep

Créez une variable appelée mouvement qui peut être vrai ou faux. Cette variable indiquera si un mouvement a été détecté ou non (il s’agit de la variable globale qui sera modifiée sur la fonction de gestion des interruptions).

motion = False

Ensuite, créez une fonction appelée handle_interrupt.

def handle_interrupt(pin):
  global motion
  motion = True
  global interrupt_pin
  interrupt_pin = pin 

Cette fonction sera appelée à chaque détection de mouvement. le handle_interrupt fonction a un paramètre d’entrée (épingler) dans lequel un objet de classe Épingler sera transmis lorsque l’interruption se produit (il indique quelle broche a causé l’interruption).

Ici, nous sauvegardons la broche qui a causé l’interruption dans le interruption_pin variable. Dans ce cas, ce n’est pas très utile car nous n’avons qu’une seule broche d’interruption. Cependant, cela peut être utile si nous avons plusieurs interruptions qui déclenchent la même fonction de gestion des interruptions et que nous voulons savoir quel GPIO a provoqué l’interruption.

Dans notre exemple, le handle_interrupt fonction change simplement le mouvement variable à Vrai et enregistre la broche d’interruption. Vous devez garder vos fonctions d’interruption de traitement aussi courtes que possible et éviter d’utiliser le imprimer() fonction à l’intérieur. Ensuite, le code principal devrait avoir toutes les choses que nous voulons qu’il se produise lorsque l’interruption se produit.

Noter: comme tu veux mouvement pour être utilisable à la fois dans la fonction et dans tout le code, il doit être déclaré comme global. Sinon, lorsqu’un mouvement est détecté, rien ne se passerait, car le mouvement variable changerait à l’intérieur de la fonction et non dans le corps principal du code.

En continuant avec le code, nous devons créer deux objets Pin. Un pour la LED allumée GPIO 12, et un autre pour le capteur de mouvement PIR sur GPIO 14.

led = Pin(12, Pin.OUT)
pir = Pin(14, Pin.IN)

Ensuite, définissez une interruption sur le pir en appelant le irq() méthode.

pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

Dans le boucler(), quand le mouvementest True, nous allumons la LED pendant 20 secondes et imprimons un message indiquant que le mouvement a été détecté et quelle broche a causé l’interruption.

if motion:
  print('Motion detected! Interrupt caused by:', interrupt_pin)
  led.value(1)
  sleep(20)

Après 20 secondes, éteignez la LED et imprimez un message pour indiquer que le mouvement s’est arrêté.

led.value(0)
print('Motion stopped!')

Enfin, réglez le mouvement variable à Faux :

motion = False

le mouvement ne peut redevenir Vrai que si un mouvement est détecté et que la handle_interrupt fonction est appelée.

Pour plus de simplicité, dans cet exemple, nous utilisons un délai pour maintenir la LED allumée pendant 20 secondes. Idéalement, vous devriez utiliser des minuteries.

Manifestation

Téléchargez le code sur votre carte ESP32/ESP8266. La LED doit s’allumer pendant 20 secondes lorsqu’un mouvement est détecté, et un message doit être imprimé dans le Shell.

Après 20 secondes, la LED s’éteint.

Noter: le détecteur de mouvement AM312 PIR a un délai par défaut de 8 secondes. Cela signifie qu’il ne sera pas déclenché avant que 8 secondes ne se soient écoulées depuis le dernier déclenchement.

Conclusion

Nous espérons que vous avez trouvé cet article intéressant. Nous avons appris à :

• configurer une broche comme une interruption
• gérer cette interruption dans votre code
• détecter quelle broche GPIO a causé l’interruption

Dans notre exemple, nous avons utilisé un capteur de mouvement PIR pour déclencher l’interruption. Mais l’exemple présenté peut également être utilisé pour détecter un appui sur un bouton, par exemple.

Si vous aimez programmer les cartes ESP32 et ESP8266 avec MicroPython, et que vous souhaitez en savoir plus, veuillez consulter les ressources suivantes :