ESP32 - Interruption GPIO

Dans ce tutoriel, nous allons apprendre à utiliser les interruptions GPIO dans l'ESP32. Les interruptions GPIO sur l'ESP32 permettent une gestion réactive et efficace des événements externes, ce qui les rend essentielles pour les applications en temps réel dans l'Internet des objets (IoT) et les systèmes embarqués. En comprenant et en configurant correctement ces interruptions, vous pouvez créer des projets robustes et réactifs qui réagissent immédiatement à l'environnement.

Préparation du matériel

1	×	ESP-WROOM-32 Dev Module
1	×	USB Cable Type-C
1	×	Push Button
1	×	Breadboard
1	×	Jumper Wires
1	×	(Recommended) Screw Terminal Expansion Board for ESP32
1	×	(Recommended) Power Splitter For ESP32

Or you can buy the following sensor kits:

1	×	DIYables Sensor Kit (30 sensors/displays)
1	×	DIYables Sensor Kit (18 sensors/displays)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

Qu'est-ce qu'une interruption GPIO ?

Une interruption GPIO est un signal qui amène le processeur à interrompre son exécution actuelle et à passer à un morceau spécifique de code connu sous le nom de routine de service d'interruption (ISR). Cela permet à l'ESP32 de gérer immédiatement les tâches de haute priorité, sans avoir besoin de scruter en continu les broches GPIO.

Interruptions dans l'ESP32

L'ESP32 prend en charge différents types d'interruptions GPIO :

Bord montant : Déclenché lorsque la broche GPIO passe de BAS à HAUT.
Bord descendant : Déclenché lorsque la broche GPIO passe de HAUT à BAS.
Deux bords : Déclenché à tout changement d'état, soit de BAS à HAUT, soit de HAUT à BAS.
Niveau bas : Déclenché lorsque la broche GPIO reste BAS.
Niveau haut : Déclenché lorsque la broche GPIO reste HAUT.

Comment configurer les interruptions GPIO sur ESP32

Pour configurer une interruption GPIO sur l'ESP32, vous devez suivre ces étapes :

Initialiser le GPIO : Définissez le mode du broche GPIO sur entrée ou sortie selon les besoins. Par exemple :

pinMode(GPIO_Pin, INPUT_PULLUP);

Attacher l'Interruption : Utilisez la fonction attachInterrupt() pour lier la broche GPIO à une ISR.

attachInterrupt(GPIO_Pin, ISR_function, mode);

Cette fonction accepte trois arguments :

GPIO_Pin : Spécifie la broche GPIO à utiliser comme broche d'interruption, indiquant quelle broche l'ESP32 doit surveiller.
ISR_function : Le nom de la fonction qui sera appelée chaque fois que l'interruption se produit.
mode : Définit la condition qui déclenche l'interruption. Il existe cinq constantes prédéfinies qui peuvent être utilisées :

RISING : Déclenchement lorsque la broche passe de BAS à HAUT (sur Front montant).
FALLING : Déclenchement lorsque la broche passe de HAUT à BAS (sur Front descendant).
CHANGE : Déclenchement lors de tout changement de l'état de la broche (sur Les deux fronts).
HIGH : Déclenchement lorsque la broche est HAUTE (sur Niveau haut).
LOW : Déclenchement lorsque la broche est BASSE (sur Niveau bas).

Définir la fonction ISR : Écrivez la routine de service d'interruption qui s'exécutera lorsque l'interruption est déclenchée.

La routine de service d'interruption (ISR) est une fonction qui est invoquée chaque fois qu'une interruption se produit sur la broche GPIO. Sa syntaxe ressemble à ceci.

void IRAM_ATTR ISR_function() { Statements; }

Plongeons dans un exemple pratique d'utilisation des interruptions avec un broche GPIO de l'ESP32 connectée à un bouton.

Diagramme de câblage

This image is created using Fritzing. Click to enlarge image

Si vous ne savez pas comment alimenter l'ESP32 et d'autres composants, vous pouvez trouver des conseils dans le tutoriel suivant : Comment alimenter l'ESP32.

Code d'Interruption ESP32

#define BUTTON_PIN 21 // The ESP32 pin GPIO21 connected to the button void IRAM_ATTR handleButtonPress(); void setup() { Serial.begin(9600); // Initialize the GPIO pin as an input pinMode(BUTTON_PIN, INPUT_PULLUP); // Attach interrupt to the GPIO pin attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), handleButtonPress, FALLING); } void loop() { // Main code here } // Interrupt Service Routine (ISR) void IRAM_ATTR handleButtonPress() { Serial.println("Button pressed!"); }

Dans cet exemple :

Le BUTTON_PIN est défini comme GPIO21.
La fonction pinMode() configure la broche GPIO comme une entrée avec une résistance de rappel interne.
La fonction attachInterrupt() associe l'ISR handleButtonPress au BUTTON_PIN, configuré pour se déclencher sur un front descendant.
La fonction handleButtonPress est l'ISR qui s'exécute lorsque le bouton est pressé.

Le code ci-dessus démontre à quoi ressemble un code d'interruption, mais il peut ne pas fonctionner en pratique car il utilise la fonction Serial.println(), qui prend plus de temps à traiter que ce qui est autorisé dans une routine de service d'interruption.

Pour tester le fonctionnement des interruptions, voir l'exemple de code pratique ci-dessous :

#define BUTTON_PIN 21 // The ESP32 pin GPIO21 connected to the button volatile bool buttonPressed = false; // use volatile for variable that is accessed from inside and outside ISR void IRAM_ATTR handleButtonPress(); void setup() { Serial.begin(9600); // Initialize the GPIO pin as an input pinMode(BUTTON_PIN, INPUT_PULLUP); // Attach interrupt to the GPIO pin attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), handleButtonPress, FALLING); } void loop() { // Main code here if (buttonPressed) { Serial.println("Button pressed!"); buttonPressed = false; // Reset the flag } // Other code here } // Interrupt Service Routine (ISR) void IRAM_ATTR handleButtonPress() { // Serial.println("Button pressed!"); // do NOT use function that takes long time to execute buttonPressed = true; }

Étapes rapides

Si c'est la première fois que vous utilisez l'ESP32, consultez Installation du logiciel ESP32..
Effectuez le câblage comme sur l'image ci-dessus.
Connectez la carte ESP32 à votre PC via un câble micro USB.
Ouvrez Arduino IDE sur votre PC.
Sélectionnez la bonne carte ESP32 (par exemple ESP32 Dev Module) et le port COM.
Copiez le code ci-dessus et ouvrez-le avec Arduino IDE.
Cliquez sur le bouton Upload sur Arduino IDE pour télécharger le code sur l'ESP32.
Appuyez plusieurs fois sur le bouton.
Vérifiez le résultat sur le Moniteur Série.

COM6

Send

Button pressed! Button pressed! Button pressed! Button pressed!

Autoscroll Show timestamp

Clear output

9600 baud

Newline

Il se peut que vous remarquiez qu'une seule pression sur le bouton entraîne l'affichage de plusieurs événements de pression sur le Moniteur Série. Ce n'est pas un problème d'interruption mais un problème lié au bouton lui-même. Pour apprendre à résoudre cela, consultez le tutoriel ESP32 - Bouton - Anti-rebond..

Vous pouvez voir un autre exemple qui utilise des interruptions dans ce tutoriel ESP32 - Encodeur rotatif..

Considérations importantes

Pas de paramètres ni de valeurs de retour : Une fonction ISR ne peut avoir aucun paramètre et ne doit rien retourner.
Temps d'exécution de l'ISR : Gardez le code de l'ISR aussi court et efficace que possible. De longues ISRs peuvent entraîner la perte d'autres interruptions par le système ou dégrader les performances globales.
Concurrence : Soyez attentif aux ressources partagées accédées au sein des ISRs. Utilisez des opérations atomiques ou désactivez les interruptions si nécessaire pour éviter les conditions de concurrence. En particulier, utilisez le mot-clé volatile pour les variables auxquelles on accède à la fois à l'intérieur et à l'extérieur de la fonction ISR.
IRAM_ATTR : Placez le code de l'ISR dans l'IRAM en utilisant l'attribut IRAM_ATTR pour garantir qu'il s'exécute rapidement sans être récupéré à partir de la mémoire flash.

Vidéo

Tutoriels connexes

※ OUR MESSAGES

Please feel free to share the link of this tutorial. However, Please do not use our content on any other websites. We invested a lot of effort and time to create the content, please respect our work!