ESP32 FreeRTOS : minuteries logicielles/interruptions de minuterie (Arduino)

Dans ce guide, vous apprendrez à utiliser des minuteries logicielles (interruptions de minuterie) avec l’ESP32 à l’aide de la programmation FreeRTOS sur l’IDE Arduino. Nous examinerons les minuteries de rechargement automatique (périodiques) et les minuteries ponctuelles, et fournirons des exemples simples afin que vous puissiez facilement appliquer des minuteries logicielles à vos propres projets. Vous verrez que l’utilisation des minuteries du logiciel FreeRTOS facilitera grandement la planification de différentes tâches dans vos projets.

Vous êtes nouveau sur FreeRTOS ? Voici d’autres tutoriels FreeRTOS avec l’ESP32 que nous vous recommandons de suivre :

Table des matières

Interruptions de minuterie/minuteries logicielles

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é.

Une minuterie logicielle vous permet de planifier l’exécution d’une fonction à une heure précise ultérieurement. La fonction que le minuteur appelle est connue sous le nom de fonction de rappel, et l’intervalle entre le démarrage du minuteur et l’exécution du rappel est la période du minuteur.

Dans FreeRTOS avec l’ESP32, nous avons deux types de minuteries disponibles :

• Minuterie périodique (minuterie de rechargement automatique) : une minuterie qui se déclenchera indéfiniment toutes les x secondes que vous définissez. Cela vous permet d’exécuter une tâche périodiquement. Par exemple, faire clignoter une LED toutes les secondes.
• One-shot Timer : un timer qui se déclenchera une fois après une période prédéfinie. Cela vous permet d’exécuter une tâche spécifique après une durée prédéfinie. Par exemple, allumez une LED cinq secondes après avoir appuyé sur un bouton-poussoir.

Bases des minuteries FreeRTOS

Voici quelques concepts de base sur la création et la gestion des minuteries FreeRTOS avec l’ESP32 sur l’IDE Arduino :

Créer une minuterie

Pour créer un timer, vous utilisez la fonction xTimerCreate() et transmettez les paramètres suivants comme arguments dans cet ordre :

• nom de la minuterie
• période
• autoReload (pdTRUE pour une minuterie périodique ou pdFALSE pour une minuterie ponctuelle)
• timerID (une valeur définie par l’utilisateur transmise au rappel)
• fonction de rappel

Par exemple:

xTimerCreate(
    "BlinkTimer",                   // Timer name
    1000 / portTICK_PERIOD_MS,      // 1s period
    pdTRUE,                         // Auto-reload (periodic timer)
    NULL,                           // Timer ID
    BlinkCallback                   // Callback function
);

Démarrer une minuterie

Pour démarrer une minuterie, utilisez xTimerStart(timer, blockTime). Le premier argument est le gestionnaire du minuteur et le deuxième argument est le nombre de secondes à attendre avant de démarrer le minuteur.

Arrêter une minuterie

Pour arrêter un timer en cours d’exécution, il vous suffit d’appeler xTimerStop(timer, blockTime). Les arguments sont les mêmes que pour la fonction précédente.

Réinitialisation d’une minuterie

Pour réinitialiser un minuteur, c’est-à-dire redémarrer le compte à rebours d’un minuteur, même s’il est déjà en cours, appelez xTimerReset(timer, blockTime). Les arguments sont les mêmes que les fonctions précédentes.

Démarrage d’une minuterie dans les ISR (routines de service d’interruption)

Si vous souhaitez démarrer une minuterie à partir d’un ISR (fonction de routine de service d’interruption), vous devez appeler xTimerStartFromISR(timer, &higherPriorityTaskWoken).

upperPriorityTaskWoken peut être pdTRUE ou pdFALSE. Définissez sur pdTRUE si la tâche est de priorité plus élevée et que nous devons y passer immédiatement. Dans ce cas, nous devrions appeler portYIELD_FROM_ISR() depuis l’ISR pour passer immédiatement à cette tâche pour une réactivité en temps réel.

Minuterie périodique FreeRTOS avec l’ESP32

Maintenant que nous avons appris les bases des minuteries logicielles, nous allons commencer par tester quelques exemples simples pour vous montrer comment créer et gérer des minuteries périodiques (rechargement automatique) avec l’ESP32 à l’aide de FreeRTOS dans l’IDE Arduino.

1) Faire clignoter une LED avec une minuterie périodique

Le premier exemple que nous examinerons est un simple croquis de LED Blink. Cette esquisse crée une minuterie périodique FreeRTOS pour basculer l’état d’une LED chaque seconde.

Ceci est un exemple simple et facile pour vous montrer comment utiliser réellement les minuteries. Voici comment cela fonctionne :

1. Démarrage d’un chronomètre avec une période d’une seconde.
2. Après la période de minuterie, sa fonction de rappel s’exécute.
3. La fonction de rappel bascule l’état d’une LED (elle l’allume d’abord).
4. Après la période de minuterie (une seconde), la fonction de rappel s’exécutera à nouveau, basculant l’état de la LED (cette fois, elle l’éteindra).
5. Cela se répétera indéfiniment, jusqu’à ce que le programme soit arrêté ou jusqu’à ce que vous arrêtiez le minuteur. Cela créera un effet clignotant.

Schéma de circuit

Pour cet exemple, nous ferons clignoter la LED intégrée de l’ESP32. Dans notre cas, il est connecté au GPIO 2. D’autres cartes ESP32 peuvent avoir la LED intégrée connectée à un autre GPIO.

Alternativement, vous pouvez réellement câbler une LED physique via une résistance de 220 Ohm à votre carte.

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 !

Code

Le code suivant utilise des minuteries FreeRTOS périodiques pour faire clignoter le voyant intégré de l’ESP32. Vous pouvez le télécharger sur votre carte ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-freertos-software-timers-interrupts/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 

#define LED_PIN 2

TimerHandle_t blinkTimer = NULL;

bool ledState = false;

void BlinkCallback(TimerHandle_t xTimer) {
  ledState = !ledState;
  
  if (ledState) {
    digitalWrite(LED_PIN, HIGH);
    Serial.print("LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN, LOW);
    Serial.print("LED is ");
    Serial.println("OFF");
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Starting FreeRTOS");
  Serial.println("Periodic Timer for LED Blink");

  pinMode(LED_PIN, OUTPUT);

  blinkTimer = xTimerCreate(
    "BlinkTimer",                   // Timer name
    1000 / portTICK_PERIOD_MS,      // 1s period
    pdTRUE,                         // Auto-reload (periodic timer)
    NULL,                           // Timer ID
    BlinkCallback                   // Callback function
  );
  if (blinkTimer == NULL) {
    Serial.println("Failed to create timer!");
    while (1);
  }

  xTimerStart(blinkTimer, 0); // Start timer immediately
}

void loop() {
  // Empty
}

Afficher le code brut

Comment fonctionne le code ?

Commencez par définir le GPIO connecté à la LED. Changez si vous utilisez une autre broche GPIO.

#define LED_PIN 2

Créez un gestionnaire pour le minuteur. Un gestionnaire est comme un nom que nous utilisons pour désigner le minuteur. Au début, nous l’avons défini sur NULL car nous n’avons pas encore créé le minuteur réel. Nous appellerons le gestionnaire de minuterie BlinkTimer.

TimerHandle_t blinkTimer = NULL;

Créez une variable appelée ledState pour conserver l’état actuel de la LED. Lors de la première exécution du programme, la LED est éteinte (faux).

bool ledState = false;

Fonction de rappel de minuterie

Le BlinkCallback est la fonction que nous souhaitons exécuter périodiquement. Il doit accepter un paramètre de type TimerHandle_t.

void BlinkCallback(TimerHandle_t xTimer) {
  ledState = !ledState;
  
  if (ledState) {
    digitalWrite(LED_PIN, HIGH);
    Serial.print("LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN, LOW);
    Serial.print("LED is ");
    Serial.println("OFF");
  }
}

Nous inversons d’abord l’état actuel de la LED :

ledState = !ledState;

Ensuite, nous allumons ou éteignons la LED en conséquence à l’aide de la fonction digitalWrite().

if (ledState) {
  digitalWrite(LED_PIN, HIGH);
  Serial.print("LED is ");
  Serial.println("ON");
} else {
  digitalWrite(LED_PIN, LOW);
  Serial.print("LED is ");
  Serial.println("OFF");
}

installation()

Dans setup(), initialisez le moniteur série et configurez la LED comme SORTIE.

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Starting FreeRTOS");
  Serial.println("Periodic Timer for LED Blink");

  pinMode(LED_PIN, OUTPUT);

Création de la minuterie

Ensuite, créez le minuteur,linkTimer, en utilisant la fonction xTimeCreate() que nous avons vue dans la section d’introduction. Ce timer, une fois démarré, appellera la fonction BlinkCallback toutes les 1000 millisecondes (1 seconde).

blinkTimer = xTimerCreate(
  "BlinkTimer",                   // Timer name
  1000 / portTICK_PERIOD_MS,      // 1s period
  pdTRUE,                         // Auto-reload (periodic timer)
  NULL,                           // Timer ID
  BlinkCallback                   // Callback function
);

Nous vérifions également si la minuterie a été créée avec succès. S’il ne parvient pas à être créé, il renverra NULL.

if (blinkTimer == NULL) {
    Serial.println("Failed to create timer!");
    while (1);
}

Démarrer la minuterie

Enfin, nous pouvons démarrer notre BlinkTimer en appelant la fonction xTimerStart(). Le timer démarrera immédiatement (le deuxième argument de la fonction est 0).

xTimerStart(blinkTimer, 0); // Start timer immediately

boucle()

Le loop() est vide car le planificateur FreeRTOS se charge de maintenir le programme en marche, en attendant les interruptions et les tâches du minuteur. Cependant, si cela est requis pour votre projet, vous pouvez ajouter le code dont vous avez besoin à la boucle().

void loop() {
  // Empty
}

Démonstration

Téléchargez le code sur votre carte ESP32.

Ensuite, ouvrez le moniteur série à un débit en bauds de 115 200.

La LED intégrée de l’ESP32 commencera à clignoter toutes les secondes (ou la LED connectée au GPIO 2).

Le moniteur série affichera l’état actuel de la LED (notez que la LED intégrée de l’ESP32 fonctionne avec une logique inversée).

Comme vous pouvez le constater, l’utilisation des minuteries périodiques FreeRTOS est assez simple, utile et pratique à utiliser dans vos projets. Par exemple, en plus de faire clignoter une LED, vous pouvez l’utiliser pour des tâches périodiques telles que l’obtention de données d’un capteur, l’envoi de données à un serveur, l’enregistrement de données sur une carte microSD, la vérification de l’état d’une entrée, et bien plus encore.

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

Après avoir compris comment créer un minuteur périodique, il est assez simple de créer plusieurs minuteurs si vous devez exécuter plusieurs tâches périodiquement avec des intervalles identiques ou différents.

Pour vous montrer comment procéder, nous allons créer un nouvel exemple qui fait clignoter deux LED à des fréquences différentes. Nous allons créer deux minuteries périodiques, une pour contrôler chaque LED.

Schéma de circuit

Pour cet exemple, connectez deux LED à votre carte ESP32 via une résistance de 220 Ohm. Nous connectons les LED aux GPIO 2 et 4, mais vous pouvez utiliser n’importe quelle autre broche appropriée. Assurez-vous simplement de modifier le code en conséquence.

Pièces requises :

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

Code

Téléchargez le code suivant sur votre carte ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-freertos-software-timers-interrupts/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#define LED_PIN_RED 2
#define LED_PIN_BLUE 4

TimerHandle_t blinkTimerRed = NULL;
TimerHandle_t blinkTimerBlue = NULL;

bool ledStateRed = false;
bool ledStateBlue = false;

void BlinkRedCallback(TimerHandle_t xTimer) {
  ledStateRed = !ledStateRed;
  
  if (ledStateRed) {
    digitalWrite(LED_PIN_RED, HIGH);
    Serial.print("Red LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN_RED, LOW);
    Serial.print("Red LED is ");
    Serial.println("OFF");
  }
}

void BlinkBlueCallback(TimerHandle_t xTimer) {
  ledStateBlue = !ledStateBlue;
  
  if (ledStateBlue) {
    digitalWrite(LED_PIN_BLUE, HIGH);
    Serial.print("Blue LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN_BLUE, LOW);
    Serial.print("Blue LED is ");
    Serial.println("OFF");
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Starting FreeRTOS");
  Serial.println("Periodic Timers for Two LEDs");

  pinMode(LED_PIN_RED, OUTPUT);
  pinMode(LED_PIN_BLUE, OUTPUT);

  blinkTimerRed = xTimerCreate(
    "BlinkTimerRed",               // Timer name
    700 / portTICK_PERIOD_MS,      // 1s period
    pdTRUE,                        // Auto-reload (periodic timer)
    NULL,                          // Timer ID
    BlinkRedCallback               // Callback function
  );
  if (blinkTimerRed == NULL) {
    Serial.println("Failed to create blinkTimerRed timer!");
    while (1);
  }

  blinkTimerBlue = xTimerCreate(
    "BlinkTimerBlue",               // Timer name
    1100 / portTICK_PERIOD_MS,      // 1s period
    pdTRUE,                         // Auto-reload (periodic timer)
    NULL,                           // Timer ID
    BlinkBlueCallback               // Callback function
  );
  if (blinkTimerBlue == NULL) {
    Serial.println("Failed to create blinkTimerBlue timer!");
    while (1);
  }

  xTimerStart(blinkTimerRed, 0); // Start timer immediately
  xTimerStart(blinkTimerBlue, 0); // Start timer immediately
}

void loop() {
  // Empty
}

Afficher le code brut

Comment fonctionne le code ?

Si vous avez compris comment créer un timer dans l’exemple précédent, vous verrez qu’il est assez simple de créer plusieurs timers.

Nous définissons les GPIO pour contrôler chacune des LED.

#define LED_PIN_RED 2
#define LED_PIN_BLUE 4

Ensuite, nous créons un gestionnaire de temps pour chaque minuterie. Chaque minuterie contrôlera une LED différente.

TimerHandle_t blinkTimerRed = NULL;
TimerHandle_t blinkTimerBlue = NULL;

Nous créons une fonction de rappel qui sera appelée après chaque timer pour contrôler chacune des LED.

void BlinkRedCallback(TimerHandle_t xTimer) {
  ledStateRed = !ledStateRed;
  
  if (ledStateRed) {
    digitalWrite(LED_PIN_RED, HIGH);
    Serial.print("Red LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN_RED, LOW);
    Serial.print("Red LED is ");
    Serial.println("OFF");
  }
}

void BlinkBlueCallback(TimerHandle_t xTimer) {
  ledStateBlue = !ledStateBlue;
  
  if (ledStateBlue) {
    digitalWrite(LED_PIN_BLUE, HIGH);
    Serial.print("Blue LED is ");
    Serial.println("ON");
  } else {
    digitalWrite(LED_PIN_BLUE, LOW);
    Serial.print("Blue LED is ");
    Serial.println("OFF");
  }
}

Dans setup(), nous pouvons en fait créer des minuteries pour faire clignoter chacune des LED. La minuterie suivante appellera la fonction BlinkRedCallback toutes les 700 millisecondes, ce qui entraînera le changement d’état de la LED rouge toutes les 700 millisecondes.

blinkTimerRed = xTimerCreate(
  "BlinkTimerRed",                   // Timer name
  700 / portTICK_PERIOD_MS,      // 1s period
  pdTRUE,                         // Auto-reload (periodic timer)
  NULL,                           // Timer ID
  BlinkRedCallback                   // Callback function
);
if (blinkTimerRed == NULL) {
  Serial.println("Failed to create blinkTimerRed timer!");
  while (1);
}

Nous créons également une minuterie pour contrôler les autres LED. Cette minuterie appellera la fonction BlinkBlueCallback toutes les 1 100 millisecondes.

blinkTimerBlue = xTimerCreate(
  "BlinkTimerBlue",                   // Timer name
  1100 / portTICK_PERIOD_MS,      // 1s period
  pdTRUE,                         // Auto-reload (periodic timer)
  NULL,                           // Timer ID
  BlinkBlueCallback                   // Callback function
);
if (blinkTimerBlue == NULL) {
  Serial.println("Failed to create blinkTimerBlue timer!");
  while (1);
}

Enfin, nous pouvons démarrer les timers en appelant la fonction xTimerStart().

xTimerStart(blinkTimerRed, 0); // Start timer immediately
xTimerStart(blinkTimerBlue, 0); // Start timer immediately

Le loop() est vide car le planificateur FreeRTOS se chargera d’exécuter les timers au moment approprié. Si vous en avez besoin, vous pouvez ajouter du code à loop() pour toute autre tâche dont vous avez besoin pour votre projet.

void loop() {
  // Empty
}

Démonstration

Téléchargez le code précédent sur votre carte ESP32.

Cela entraînera le clignotement de deux LED à des fréquences différentes.

Vous pouvez également ouvrir Serial Monitor pour vérifier les résultats.

Minuteries One-Shot FreeRTOS avec l’ESP32

Les minuteries ponctuelles déclencheront une fonction de rappel une fois après une période prédéfinie. Cela vous permet d’exécuter une tâche spécifique après une durée prédéfinie.

1) Basculer une LED avec un bouton-poussoir (avec un délai)

Pour vous montrer comment fonctionnent les minuteries ponctuelles, nous allons créer un exemple simple dans lequel nous allons basculer l’état d’une LED cinq secondes après avoir appuyé sur un bouton-poussoir.

Voici comment cela fonctionne :

• La LED est éteinte.
• Appuyez sur le bouton poussoir.
• Au bout de 5 secondes, la LED s’allume.
• La LED reste allumée.
• Appuyez sur le bouton poussoir.
• Au bout de 5 secondes, la LED s’éteint.

Schéma de circuit

Pour cet exemple, connectez une LED et un bouton poussoir aux GPIO ESP32. Nous connectons la LED au GPIO 2 et le bouton-poussoir au GPIO 4. Nous n’utilisons aucune résistance avec le bouton-poussoir car nous utiliserons la résistance de rappel interne de l’ESP32.

Pièces requises :

Code

Téléchargez le code suivant sur votre carte ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-freertos-software-timers-interrupts/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#define BUTTON_PIN 4
#define LED_PIN 2
#define DEBOUNCE_DELAY 200
#define TIMER_DELAY 5000

TimerHandle_t toggleTimer = NULL;
volatile uint32_t lastInterruptTime = 0;
volatile bool ledState = false;

void IRAM_ATTR buttonISR() {
  uint32_t currentTime = millis();
  if (currentTime - lastInterruptTime > DEBOUNCE_DELAY) {
    BaseType_t higherPriorityTaskWoken = pdFALSE;
    xTimerStartFromISR(toggleTimer, &higherPriorityTaskWoken);
    Serial.print("buttonISR: LED will ");
    if (ledState) {
      Serial.print("turn OFF");
    } else {
      Serial.print("turn ON");
    }
    Serial.print(" in 5 seconds");
    Serial.println();
    lastInterruptTime = currentTime;
    if (higherPriorityTaskWoken) {
      portYIELD_FROM_ISR();
    }
  }
}

void ToggleCallback(TimerHandle_t xTimer) {
  ledState = !ledState;
  if (ledState) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println("LED is ON");
  } else {
    digitalWrite(LED_PIN, LOW);
    Serial.println("LED is OFF");
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Starting FreeRTOS");

  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonISR, FALLING);

  toggleTimer = xTimerCreate(
    "ToggleTimer",                    // Timer name
    TIMER_DELAY / portTICK_PERIOD_MS, // 5s delay
    pdFALSE,                          // One-shot
    NULL,                             // Timer ID
    ToggleCallback                   // Callback
  );
  if (toggleTimer == NULL) {
    Serial.println("Failed to create timer!");
    while (1);
  }
}

void loop() {
  // Empty
}

Afficher le code brut

Comment fonctionne le code

Commencez par définir les GPIO pour la LED et pour le bouton poussoir. Nous utilisons respectivement les GPIO 2 et 4. Vous pouvez utiliser n’importe quel autre GPIO approprié.

#define BUTTON_PIN 4
#define LED_PIN 2

Définissez le délai anti-rebond du bouton-poussoir en millisecondes.

#define DEBOUNCE_DELAY 200

Définir le temps de temporisation du one-shot timer (temps entre l’appui sur le bouton poussoir et le changement d’état de la LED).

#define TIMER_DELAY 5000

Créez une poignée pour notre minuterie one-shot. Nous l’appelons toggleTimer.

TimerHandle_t toggleTimer = NULL;

Créez une variable pour vérifier combien de temps s’est écoulé depuis la dernière pression sur le bouton (pour éviter les faux positifs).

volatile uint32_t lastInterruptTime = 0;

Créez une variable appelée ledState pour conserver l’état actuel de la LED.

volatile bool ledState = false;  // Made volatile for ISR access

Dans setup(), nous initialisons le moniteur série à des fins de débogage.

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

Nous définissons le bouton-poussoir comme entrée avec une résistance de rappel interne.

pinMode(BUTTON_PIN, INPUT_PULLUP);

La LED est définie comme SORTIE.

pinMode(LED_PIN, OUTPUT);

Ensuite, nous définissons le bouton-poussoir comme une interruption sur le front DESCENDANT. Lorsque le bouton-poussoir est enfoncé, il appellera la fonction boutonISR.

attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonISR, FALLING);

Création du minuteur One-Shot

Nous créons notre timer one-shot, toggleTimer, en utilisant la fonction xTimerCreate(). Notez que nous avons le temps de retard de 5 secondes (deuxième argument) et que le troisième argument est pdFALSE, indiquant que nous voulons définir un temporisateur unique pour qu’il se déclenche après 5 secondes de son initialisation. Comme vous pouvez le constater, il est assez simple de configurer une minuterie ponctuelle.

Dans ce cas, il appellera la fonction ToggleCallback lorsqu’il sera déclenché.

toggleTimer = xTimerCreate(
  "ToggleTimer",                  // Timer name
  TIMER_DELAY / portTICK_PERIOD_MS,  // 5s delay
  pdFALSE,                        // One-shot
  NULL,                           // Timer ID
  ToggleCallback                  // Callback
);
if (toggleTimer == NULL) {
  Serial.println("Failed to create timer!");
  while (1);
}

Fonction boutonISR()

L’ISR (fonction de rappel) du bouton-poussoir est la fonction buttonISR(). Nous vérifions d’abord si nous disposons d’une pression de bouton-poussoir valide.

void IRAM_ATTR buttonISR() {
  uint32_t currentTime = millis();
  if (currentTime - lastInterruptTime > DEBOUNCE_DELAY) {

Ensuite, nous créons et définissons la variable upperPriorityTaskWoken sur pdFALSE. Cette variable nous indique si l’opération ISR (dans ce cas, le démarrage d’un minuteur) a débloqué une tâche de priorité plus élevée qui doit être exécutée immédiatement. Cela commence comme faux.

BaseType_t higherPriorityTaskWoken = pdFALSE;

Démarrer la minuterie

Ensuite, nous démarrons notre timer en appelant la fonction xTimerStartFromISR. Nous passons comme arguments le handle du timer, toggleTimer et l’adresse de upperPriorityTaskWoken (&higherPriorityTaskWoken) afin que FreeRTOS puisse mettre à jour l’indicateur si l’opération débloque une tâche de priorité plus élevée (comme la tâche de service de minuterie), ce qui nous permet de la vérifier ensuite (if (higherPriorityTaskWoken)) et de passer immédiatement à cette tâche si nécessaire pour une réactivité en temps réel. (portYIELD_FROM_ISR()).

xTimerStartFromISR(toggleTimer, &higherPriorityTaskWoken);

En démarrant notre timer, il exécutera la fonction ToggleCallback après cinq secondes (TIMER_DELAY). La fonction ToggleCallback bascule simplement l’état actuel de la LED.

void ToggleCallback(TimerHandle_t xTimer) {
  ledState = !ledState;
  if (ledState) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println("LED is ON");
  } else {
    digitalWrite(LED_PIN, LOW);
    Serial.println("LED is OFF");
  }
}

Démonstration

Téléchargez le code sur votre carte ESP32.

Ouvrez le moniteur série à un débit en bauds de 115 200.

Appuyez sur le bouton poussoir. Sur le moniteur série, vous recevrez le message : « boutonISR : la LED s’allumera dans 5 secondes ».

Et après cinq secondes, la LED s’allumera.

Appuyez à nouveau sur le bouton-poussoir et après 5 secondes, la LED s’éteindra.

Conclusion

Dans ce didacticiel, nous avons expliqué comment configurer et utiliser les minuteries du logiciel FreeRTOS avec l’ESP32 programmé avec l’IDE Arduino. Vous avez découvert les minuteries périodiques et ponctuelles.

Pour des informations plus détaillées sur les minuteries logicielles, vous pouvez consulter la documentation officielle.

Si vous souhaitez en savoir plus sur la programmation FreeRTOS avec l’ESP32, consultez nos autres tutoriels :

Vous voulez en savoir plus sur l’ESP32 ? Consultez nos ressources :

Merci d’avoir lu.

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