Interruptions ESP32 GPIO avec l’IDE Arduino

Apprenez à configurer et gérer les interruptions avec la carte ESP32 pour détecter et répondre aux changements sur ses GPIO d’entrée. Nous allons construire un exemple de projet utilisant un bouton-poussoir et un autre utilisant un capteur de mouvement PIR.

La définition d’une broche d’entrée ESP32 comme interruption vous permet de détecter rapidement les événements (changements dans l’état du GPIO) et d’y réagir en arrêtant le programme principal et en exécutant une fonction de rappel (également appelée routine de service d’interruption – ISR). Cela peut être utile pour détecter l’appui sur un bouton poussoir, lorsqu’un capteur dépasse un certain seuil, lorsqu’un mouvement est détecté, etc.

Table des matières

Dans ce tutoriel, nous aborderons les sujets suivants :

Conditions préalables

Avant de poursuivre ce didacticiel, vous devez avoir installé les cartes ESP32 dans votre IDE Arduino. Suivez ce prochain tutoriel pour installer l’ESP32 sur l’IDE Arduino, si vous ne l’avez pas déjà fait.

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 fournissent des mécanismes pour répondre aux événements externes, permettant à vos cartes ESP32 de réagir rapidement aux changements sans interrogation continue (vérification continue de la valeur actuelle d’une broche ou d’une variable).

Que sont les interruptions ?

Les interruptions sont des signaux qui interrompent le flux d’exécution normal d’un programme pour gérer un événement spécifique. 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. Cette tâche est également appelée routine de gestion des interruptions (ou routine de service d’interruption, ISR), comme le montre la figure ci-dessous.

En résumé, avec les interruptions, vous n’avez pas besoin de vérifier constamment la valeur actuelle d’une broche. Avec les interruptions, lorsqu’un changement est détecté, une fonction de rappel est déclenchée.

Types d’interruptions

Il existe différents types d’interruptions : les interruptions externes (basées sur le matériel) et les interruptions temporisées (interruptions logicielles).

1. Interruptions externes : déclenchées par des signaux externes et détectées sur les GPIO ESP32, comme une pression sur un bouton ou une lecture de capteur. Elles sont basées sur le matériel et associées à une broche GPIO spécifique. Lorsque l’état d’une broche change, cela déclenche la routine de service d’interruption (ISR). Nous nous concentrerons sur ceux-ci dans ce tutoriel.
2. Interruptions de minuterie (minuteries logicielles) : déclenchées en fonction d’intervalles de temps, permettant des actions périodiques ; elles sont basées sur un logiciel.

Utiliser les interruptions avec l’ESP32

Pour définir une interruption dans l’IDE Arduino, vous utilisez la fonction attachInterrupt(), qui accepte comme arguments : la broche GPIO, le nom de la fonction à exécuter et le mode :

attachInterrupt(GPIO, callback_function, mode);

Cette instruction doit être ajoutée au setup() de votre code Arduino.

Jetons un coup d’œil aux arguments que vous devez transmettre à cette fonction.

Interruption GPIO

Le premier argument de la fonction attachInterrupt() est le numéro GPIO où nous détecterons le changement. Par exemple, si vous souhaitez utiliser GPIO 27 comme interruption, vous pouvez utiliser :

digitalPinToInterrupt(27)

Avec une carte ESP32, toutes les broches pouvant servir d’entrées peuvent être définies comme des interruptions.

Fonction de rappel

Le deuxième argument de la fonction attachInterrupt() est le nom de la fonction qui sera appelée lorsque l’interruption sera déclenchée.

Maintenant, il y a quelques règles importantes que vous devez connaître lors de la définition de votre ISR (fonction de rappel).

1. L’ISR ne devrait rien renvoyer.
2. Les ISR doivent être aussi courts et rapides que possible car ils interrompent l’exécution normale du code.
3. Ils doivent avoir l’attribut ARDUINO_ISR_ATTR, afin qu’ils fonctionnent dans la RAM interne de l’ESP32 et non en Flash. L’accès à l’IRAM est beaucoup plus rapide, ce qui est essentiel pour que les ISR fonctionnent de manière fiable sans problèmes de synchronisation ni plantages lors des interruptions.
4. Les variables utilisées dans les ISR et dans tout le code doivent de préférence être volatiles. Cela empêche le compilateur de mettre en cache les valeurs dans les registres (et d’ignorer l’accès à la mémoire), de sorte que les lectures/écritures accèdent toujours à l’emplacement mémoire réel et reflètent les changements inattendus provoqués par l’interruption.

Voici un exemple d’ISR afin que vous puissiez vérifier sa syntaxe :

void ARDUINO_ISR_ATTR my_callback() {
    // Any code you want to run
}

Une autre chose importante à propos des ISR est que vous devez garder leur code aussi rapide et simple que possible et éviter des choses comme des opérations complexes, l’écriture sur Serial Monitor ou l’utilisation de delay(). Au lieu de cela, vous devez utiliser un indicateur ou un compteur pour indiquer que l’interruption s’est produite, puis gérer tout ce que vous devez faire dans la section code principal ou loop().

Mode

Le troisième argument est le mode. Il existe 5 modes différents :

• LOW : pour déclencher l’interruption chaque fois que la broche est LOW ;
• HIGH : pour déclencher l’interruption chaque fois que la broche est HIGH ;
• CHANGEMENT : pour déclencher l’interruption chaque fois que la broche change de valeur – par exemple, de HIGH à LOW ou de LOW à HIGH ;
• FALLING : lorsque la goupille passe de HAUT à BAS ;
• RISING : à déclencher lorsque la broche passe de LOW à HIGH.

L’image suivante vous aidera à mieux comprendre les différents modes de déclenchement.

Joindre une interruption avec des arguments

Outre la fonction attachInterrupt(), vous pouvez également utiliser la fonction attachInterruptArg() à la place. La fonction attachInterruptArg() est utilisée pour attacher l’interruption à la broche définie à l’aide d’arguments, ce qui signifie que vous pouvez transmettre des arguments à la fonction de rappel.

attachInterruptArg(uint8_t pin, void callback_function, void * arg, int mode);

• pin définit le numéro de broche GPIO.
• callback_function définit la fonction de rappel.
• arg pointeur vers les arguments d’interruption.
• mode définit le mode d’interruption.

Détacher/désactiver une interruption d’une broche GPIO

Lorsque vous ne souhaitez pas que l’ESP32 ne surveille plus la broche, vous pouvez appeler la fonction detachInterrupt() et passer en argument la broche GPIO.

detachInterrupt(digitalPinToInterrupt(interruptPin));

Exemple 1 : ESP32 – Détection d’une pression sur un bouton avec une interruption

Dans cette section, nous allons créer un exemple simple pour détecter une pression sur un bouton à l’aide d’une interruption. Nous utilisons un bouton poussoir dans cet exemple, mais vous pouvez utiliser un capteur avec un seuil, comme un capteur de mouvement PIR, par exemple (nous y reviendrons plus loin dans ce guide).

Pièces requises

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 !

Schéma de câblage

Pour cet exemple, vous devez connecter un bouton-poussoir au GPIO 18. Nous n’utiliserons aucune résistance pour le bouton-poussoir car nous utiliserons les résistances pull-up internes de l’ESP32. Câblez un fil du bouton-poussoir au GPIO 18 et l’autre à GND, comme indiqué dans le schéma ci-dessous.

Alternativement, vous pouvez utiliser n’importe quel autre GPIO approprié à condition de modifier le code. Assurez-vous de consulter notre guide de brochage ESP32.

Code

Téléchargez le code suivant sur votre ESP32. Il détecte les pressions sur les boutons-poussoirs et imprime le nombre de pressions sur le moniteur série.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-gpio-interrupts-arduino/
*********/
#include 

// Global variables for the button
const uint8_t buttonPin = 18;
volatile int32_t counter = 0;
volatile bool pressed = false;

// Interrupt Service Routine (ISR)
void ARDUINO_ISR_ATTR buttonISR() {
  counter++;
  pressed = true;
}

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(buttonPin, buttonISR, RISING);
  Serial.println("Press the button on GPIO 18.");
}

void loop() {
  if (pressed) {
    Serial.print("Button pressed ");
    Serial.print(counter);
    Serial.println(" times.");
    pressed = false;
  }
  delay(10);
}

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil au fonctionnement du code afin que vous puissiez comprendre comment utiliser les interruptions dans votre code.

Variables globales du bouton-poussoir

Tout d’abord, définissez les variables globales pour le bouton-poussoir. Nous définissons le bouton Pin comme une variable const car il ne changera pas tout au long du code. La variable compteur comptera le nombre de pressions sur le bouton-poussoir. Enfin, pressé est une variable booléenne qui indiquera si le bouton a été enfoncé ou non. Cela commence comme faux.

// Global variables for the button
const uint8_t buttonPin = 18;
volatile uint32_t counter = 0;
volatile bool pressed = false;

Notez que compteur et pressé sont des variables volatiles car elles seront utilisées à l’intérieur de l’ISR et également dans tout le code (dans la boucle()).

Routine de service d’interruption

Définissez la routine de service d’interruption, qui est la fonction de rappel qui s’exécutera lorsque l’interruption est déclenchée. Dans ce cas, la fonction s’appelle buttonISR() et elle possède l’attribut ARDUINO_ISR_ATTR afin que la fonction s’exécute sur l’IRAM ESP32 comme nous l’avons vu précédemment.

void ARDUINO_ISR_ATTR buttonISR() {

Dans cette fonction, nous augmentons la variable du compteur et définissons la variable enfoncée sur true, indiquant qu’une pression sur un bouton a eu lieu.

counter++;
pressed = true;

installation()

Dans setup(), initialisez le Serial Monitor à des fins de débogage.

void setup() {
  Serial.begin(115200);

Définir une interruption

Définissez d’abord la broche d’interruption comme entrée avec une résistance de rappel interne comme suit.

pinMode(buttonPin, INPUT_PULLUP);

Définissez la broche comme interruption et attribuez-lui une fonction de rappel avec le mode RISING (cela signifie que l’interruption sera déclenchée lorsque la broche d’interruption passe de LOW à HIGH – lorsque le bouton-poussoir est enfoncé).

attachInterrupt(buttonPin, buttonISR, RISING);

boucle()

Dans la boucle(), nous vérifions si le bouton-poussoir a été enfoncé. S’il a été appuyé, nous imprimons combien de fois il a été appuyé jusqu’à présent.

void loop() {
  if (pressed) {
    Serial.print("Button pressed ");
    Serial.print(counter);
    Serial.println(" times.");

En fin de compte, nous le redéfinissons sur false, afin de pouvoir imprimer lorsqu’il y a une nouvelle presse.

pressed = false;

Tester l’exemple

Téléchargez le code sur votre ESP32. Après le téléchargement, ouvrez le moniteur série à une vitesse de transmission de 115 200 bauds. Appuyez sur le bouton ESP32 RST pour qu’il commence à exécuter le code.

Appuyez sur le bouton poussoir.

Voyez le nombre de presses augmenter dans le moniteur série.

Problème : notez que lorsque vous appuyez sur le bouton-poussoir, il attrape parfois plus de pressions qu’il ne le devrait. Il s’agit d’un problème lié aux boutons mécaniques appelé rebond mécanique. Cela peut être résolu via un logiciel ou via du matériel.

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.

Nous allons vous montrer comment ajouter un anti-rebond à votre code pour éviter les fausses pressions sur un bouton-poussoir.

Détection d’une pression sur un bouton avec une interruption (avec anti-rebond)

Le code suivant est similaire au précédent, mais inclut les lignes de code nécessaires pour anti-rebond du bouton-poussoir.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-gpio-interrupts-arduino/
*********/
#include 

// Global variables for the button
const uint8_t buttonPin = 18;
volatile uint32_t counter = 0;
volatile bool pressed = false;

// For bedouncing the pushbutton
const unsigned long DEBOUNCE_DELAY = 50;  // in milliseconds
volatile unsigned long lastPressTime = 0;

// Interrupt Service Routine (ISR)
void ARDUINO_ISR_ATTR buttonISR() {
  unsigned long now = millis();
  if (now - lastPressTime > DEBOUNCE_DELAY) {
    counter++;
    pressed = true;
  }
  lastPressTime = now;
}

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(buttonPin, buttonISR, HIGH);
  Serial.println("Press the button on GPIO 18.");
}

void loop() {
  if (pressed) {
    Serial.print("Button pressed ");
    Serial.print(counter);
    Serial.println(" times.");
    pressed = false;
  }
  delay(10);
}

Afficher le code brut

Dans ce code, nous avons ajouté des variables pour gérer l’anti-rebond du bouton-poussoir.

// For bedouncing the pushbutton
const unsigned long DEBOUNCE_DELAY = 50;  // in milliseconds
volatile unsigned long lastPressTime = 0;

DEBOUNCE_DELAY définit le temps minimum requis entre les pressions sur les boutons pour enregistrer un événement valide (empêchant les faux déclenchements dus au rebond mécanique). Les 50 millisecondes devraient suffire. Si vous continuez à avoir des faux positifs, augmentez le temps anti-rebond.

Le lastPressTime enregistre l’heure de la dernière pression sur le bouton.

Dans la fonction buttonISR(), avant d’envisager un appui valide sur un bouton-poussoir, on vérifie d’abord si au moins 50 millisecondes se sont écoulées depuis le dernier appui. Nous obtenons le temps qui s’est écoulé depuis le démarrage du programme avec millis() (en millisecondes) et l’enregistrons dans la variable now.

unsigned long now = millis();
if (now - lastPressTime > DEBOUNCE_DELAY) {

Si oui, nous considérons que nous avons appuyé sur un bouton valide et nous augmentons la variable du compteur et définissons la variable enfoncée à true.

counter++;
pressed = true;

Après cela, mettez à jour le lastPressTime avec l’heure actuelle.

lastPressTime = now;

Tester l’exemple

Maintenant, si vous testez ce nouvel exemple, vous verrez que vous n’obtiendrez plus de faux positifs (si vous le faites, augmentez le délai anti-rebond dans votre code).

Exemple 2 : ESP32 avec un capteur PIR – Détecter un mouvement avec une interruption

Comme nous l’avons mentionné précédemment, vous pouvez également détecter des événements provoqués par des capteurs qui changent d’état de sortie lorsqu’ils atteignent un certain seuil, comme par exemple un capteur de mouvement PIR.

Ces capteurs émettent un signal HAUT lorsqu’un mouvement est détecté, ou un signal BAS si aucun mouvement n’est détecté. La sortie numérique du capteur PIR peut être lue par une broche GPIO ESP32, vous permettant de programmer des actions spécifiques en fonction de l’état de mouvement détecté.

Exemple de présentation

Nous allons créer un exemple simple qui allumera une LED lorsqu’un mouvement est détecté. Après avoir appris son fonctionnement, la même façon de penser peut être appliquée à des applications utiles, comme l’envoi d’un e-mail ou le déclenchement d’une alarme.

Voici comment fonctionne l’exemple :

• Le capteur détecte le mouvement.
• L’ESP32 détecte cet événement.
• Il imprime sur le moniteur série qu’un mouvement a été détecté.
• Il allume une LED pendant 20 secondes.
• Pendant ces 20 secondes, nous n’imprimons rien d’autre sur le moniteur série.
• Après ces 20 secondes et si aucun mouvement n’a été détecté, nous éteignons la LED et imprimons un message sur le moniteur série indiquant que le mouvement s’est arrêté.

Pièces requises

Pour cet exemple, vous avez besoin des pièces suivantes :

Schéma de circuit

Les capteurs PIR ont un GND, un VCC et une ligne de données. Connectez le GND au ESP32 GND, le VCC à 3,3 V et la ligne de données à un GPIO disponible. Nous utiliserons les broches suivantes :

Pour ce circuit, la LED est connectée au GPIO 26 et la broche de données du capteur de mouvement PIR est connectée au GPIO 27. Nous utiliserons le capteur de mouvement PIR AM312 qui fonctionne avec 3,3 V. La figure suivante montre le brochage du capteur de mouvement PIR AM312.

Vous pouvez utiliser le schéma suivant comme référence pour câbler votre circuit.

Le capteur de mouvement Mini AM312 PIR utilisé dans ce projet fonctionne à 3,3 V. Cependant, si vous utilisez un autre capteur de mouvement PIR comme le HC-SR501, il fonctionne à 5 V. Vous pouvez soit le modifier pour fonctionner à 3,3 V, soit simplement l’alimenter à l’aide de la broche Vin.

Code

Après avoir câblé le circuit, téléchargez le code suivant sur votre ESP32.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-pir-motion-sensor-interrupts-timers/
  ESP32 GPIO Interrupts with Arduino IDE: https://Raspberryme.com/esp32-gpio-interrupts-arduino/
*********/
#include 

// Set GPIOs for LED and PIR Motion Sensor
const uint8_t led = 26;
const uint8_t motionSensor = 27;

// Timer: Auxiliary variables
unsigned long now;
volatile unsigned long lastTrigger = 0;
volatile bool startTimer = false;

bool printMotion = false;

const unsigned long timeSeconds = 20 * 1000UL;  //20 seconds in milliseconds

void ARDUINO_ISR_ATTR motionISR() {
  lastTrigger = millis();
  startTimer = true;
}

void setup() {
  Serial.begin(115200);
  pinMode(motionSensor, INPUT_PULLUP);
  attachInterrupt(motionSensor, motionISR, RISING);

  // Set LED to LOW
  pinMode(led, OUTPUT);
  digitalWrite(led, LOW);
}

void loop() {
  now = millis();

// Turn LED on immediately on new trigger
  if (startTimer && !printMotion) {
    digitalWrite(led, HIGH);
    Serial.println("MOTION DETECTED!!!");
    printMotion = true;
  }

// Turn off the LED after timeout
  if (startTimer && (now - lastTrigger > timeSeconds)) {
    Serial.println("Motion stopped...");
    digitalWrite(led, LOW);
    startTimer = false;
    printMotion = false;
  }
}

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil rapide au code pour mieux comprendre son fonctionnement.

Définir des variables

Nous commençons par définir les broches du capteur de mouvement LED et PIR. Ajustez si vous utilisez des broches différentes :

const uint8_t led = 26;
const uint8_t motionSensor = 27;

Créez des variables pour suivre la durée de la LED à l’état allumé. La variable now enregistre l’heure actuelle (temps écoulé depuis le démarrage du programme), lastTrigger enregistre la dernière fois qu’un mouvement a été détecté et startTimer est une variable booléenne pour indiquer si la minuterie pour allumer la LED est actuellement en cours d’exécution ou non.

unsigned long now;
volatile unsigned long lastTrigger = 0;
volatile bool startTimer = false;

Nous avons également une autre variable pour savoir si le texte Motion Detected a déjà été imprimé sur le moniteur série.

bool printMotion = false;

La variable timeSeconds enregistre la durée pendant laquelle nous voulons que la LED reste allumée après la détection d’un mouvement. Vous pouvez ajuster selon vos préférences.

const unsigned long timeSeconds = 20 * 1000UL;  //20 seconds in milliseconds

mouvementISR()

Le motionISR() s’exécutera lorsqu’un mouvement est détecté. Nous enregistrons l’heure actuelle sur la variable lastTrigger pour suivre le moment où un mouvement a été détecté, et nous définissons la variable startTimer sur true pour indiquer qu’il est temps de démarrer la minuterie pour allumer la LED.

void ARDUINO_ISR_ATTR motionISR() {
  lastTrigger = millis();
  startTimer = true;
}

Nous gérerons ensuite ces variables dans la boucle() pour effectuer les tâches souhaitées.

installation()

Dans setup(), définissez le capteur de mouvement comme interruption en mode RISING (lorsqu’un mouvement est détecté, le capteur règle sa broche de sortie sur HIGH).

pinMode(motionSensor, INPUT_PULLUP);
attachInterrupt(motionSensor, motionISR, RISING);

Et réglez la LED comme SORTIE et réglez-la sur FAIBLE.

// Set LED to LOW
pinMode(led, OUTPUT);
digitalWrite(led, LOW);

boucle()

Dans la boucle(), nous obtenons constamment l’heure actuelle et la sauvegardons dans la variable now.

now = millis();

Ensuite, nous vérifions si la minuterie LED a démarré et si le message de mouvement n’a pas déjà été imprimé. Si ces conditions sont remplies, nous allumons la LED, imprimons un message sur le moniteur série et définissons la variable printMotion sur true, car nous avons maintenant imprimé le message Motion Detected sur le moniteur série.

if (startTimer && !printMotion) {
  digitalWrite(led, HIGH);
  Serial.println("MOTION DETECTED!!!");
  printMotion = true;
}

boucle()

Dans la boucle(), nous vérifions également si, depuis le démarrage du startTimer, 20 secondes se sont écoulées depuis le dernier déclencheur. Si 20 secondes se sont écoulées depuis le dernier déclenchement, nous éteignons la LED et définissons les variables startTimer et printMotion sur false.

if (startTimer && (now - lastTrigger > timeSeconds)) {
  Serial.println("Motion stopped...");
  digitalWrite(led, LOW);
  startTimer = false;
  printMotion = false;
}

Tester l’exemple

Téléchargez le code sur votre carte ESP32. Ouvrez le moniteur série à un débit en bauds de 115 200 et appuyez sur le bouton ESP32 RST pour qu’il commence à exécuter le code.

Déplacez votre main devant le capteur PIR.

La LED doit s’allumer et un message est imprimé sur le moniteur série indiquant « MOUVEMENT DÉTECTÉ !!! ».

Après 20 secondes, la LED devrait s’éteindre (si aucun mouvement n’a été détecté entre-temps).

Maintenant que vous comprenez comment utiliser les interruptions pour détecter un mouvement avec un capteur de mouvement PIR, vous pouvez facilement ajuster le code pour effectuer toutes les tâches utiles au lieu de contrôler une LED. Vous pouvez, par exemple, envoyer des notifications sur votre email ou votre smartphone pour indiquer qu’un mouvement a été détecté.

Nous avons un didacticiel présentant sept façons différentes d’envoyer des notifications avec l’ESP32 que vous pouvez explorer :

Conclusion

Dans ce didacticiel, nous avons expliqué comment utiliser les interruptions avec l’ESP32 pour détecter les changements sur ses GPIO. Au lieu d’avoir à interroger constamment l’état d’un GPIO, nous pouvons utiliser des interruptions. Notre code s’exécutera normalement et lorsqu’une interruption est détectée, une fonction de rappel (ISR) s’exécutera.

Nous avons couvert un exemple utilisant un bouton-poussoir et un autre utilisant un capteur de mouvement PIR, mais cela peut être appliqué à de nombreux autres capteurs dotés d’une broche de sortie qui change d’état lorsqu’un certain seuil est atteint. Pour un guide détaillé sur l’utilisation d’un capteur de mouvement PIR avec l’ESP32, vous pouvez consulter ce tutoriel :

Pour des tutoriels et des guides sur d’autres capteurs, vous pouvez consulter notre compilation de guides :

Si vous souhaitez également apprendre à utiliser les interruptions avec l’ESP32 à l’aide du micrologiciel MicroPython, consultez plutôt ces guides :

Nous espérons que vous avez trouvé ce guide utile. Pour en savoir plus sur l’ESP32, consultez nos ressources :

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :