Programmation événementielle
Systèmes embarqués - SNT Seconde
Programmation événementielle
Objectifs
- Comprendre le principe de la programmation événementielle par opposition à la programmation séquentielle.
- Identifier les composants clés d'un programme événementiel : événements, gestionnaires (ou 'callbacks') et boucle d'événements.
- Appliquer ce modèle à des cas concrets d'objets embarqués fonctionnant en temps réel.
Introduction
Imaginez un robot qui doit éviter un obstacle soudain, un système d'alarme qui se déclenche à une heure précise, ou un jeu vidéo où votre personnage saute dès que vous appuyez sur une touche. Ces systèmes ne font pas qu'attendre leur tour, ils réagissent immédiatement à des événements. C'est le monde de la programmation événementielle, au cœur des objets connectés qui nous entourent.
Comment programmer un système embarqué pour qu'il réagisse en temps réel à des événements imprévisibles provenant de son environnement ?
Séquentiel vs Événementiel : Deux logiques de programmation
Dans un programme séquentiel classique, le code s'exécute ligne par ligne, du début à la fin, selon un enchaînement prévisible défini par le programmeur. C'est comme suivre une recette de cuisine étape par étape. Cependant, cette approche montre ses limites pour les systèmes embarqués en interaction avec le monde réel. Imaginez un micro:bit programmé pour afficher la température. En séquentiel, il lirait la température une fois, l'afficherait, puis le programme s'arrêterait. Pour la mesurer en continu, il faudrait une boucle infinie (une 'boucle while True') qui lit et affiche sans cesse. Mais que se passe-t-il si on veut aussi réagir à l'appui d'un bouton ? Il faudrait vérifier à chaque tour de boucle si le bouton est pressé, ce qui est inefficace. La programmation événementielle inverse cette logique. Au lieu de demander en permanence 'Est-ce que quelque chose s'est passé ?', le programme est mis en attente. Il déclare : 'Quand tel événement se produira (ex: appui sur le bouton A), exécute cette fonction'. Le programme ne contrôle plus le flux principal ; il réagit à des stimuli externes (événements). Le cœur du système est une 'boucle d'événements' qui attend passivement et déclenche les fonctions appropriées.
Points clés
- Programmation séquentielle : Exécution linéaire et prévisible, contrôlée par le code.
- Programmation événementielle : Exécution pilotée par des occurrences (événements) externes ou internes.
- La boucle d'événements ('event loop') est le composant central qui écoute et distribue les événements aux fonctions gestionnaires.
Les éléments clés : Événement, Gestionnaire et Boucle
Un programme événementiel repose sur trois piliers. 1) L'Événement : C'est une occurrence détectée par le système. Il peut provenir de l'utilisateur (appui sur un bouton, connexion d'un capteur), du matériel (fin d'un minuteur, réception d'un message), ou du logiciel (changement d'une valeur). Dans un contexte embarqué, les événements sont souvent liés à des entrées/sorties (GPIO). 2) Le Gestionnaire d'événements (ou 'callback', fonction de rappel) : C'est une fonction ou un bloc de code qui est associé à un type d'événement spécifique. C'est la 'réponse' programmée à cet événement. Par exemple, la fonction 'allumer_led()' sera le gestionnaire pour l'événement 'bouton_A_presse'. 3) La Boucle d'événements : C'est le mécanisme, souvent invisible pour le programmeur de haut niveau, qui tourne en permanence en arrière-plan. Son rôle est de surveiller toutes les sources d'événements possibles (les boutons, les timers, les communications) et, dès qu'un événement est détecté, de mettre en file d'attente le gestionnaire correspondant pour qu'il soit exécuté. Sur une carte comme le micro:bit, utiliser 'microbit.on_button_pressed(Button.A, allumer_led)' est une instruction qui enregistre le gestionnaire 'allumer_led' auprès de la boucle d'événements interne de la carte pour l'événement 'bouton A pressé'.
Points clés
- Événement : Occurrence (ex: appui bouton) qui déclenche une action.
- Gestionnaire (Callback) : Fonction exécutée en réponse à un événement.
- Boucle d'événements : Programme principal qui écoute et distribue les événements aux gestionnaires appropriés.
Applications pratiques
Ce modèle est omniprésent dans les systèmes embarqués en temps réel. Prenons l'exemple d'un système d'arrosage automatique connecté. Le programme ne demande pas en boucle 'Est-ce qu'il est 6h du matin ?'. Il configure un timer (une minuterie) pour générer un événement 'alarme' à 6h00. La boucle d'événements attend. À 6h00, l'événement timer se déclenche, et le gestionnaire associé (une fonction 'ouvrir_electrovanne') est exécuté. Pendant ce temps, le système peut aussi réagir à d'autres événements : un événement 'bouton_manuel' pour arroser sur demande, ou un événement provenant d'un capteur d'humidité du sol ('sol_trop_sec') pour déclencher un arrosage d'appoint. Un autre exemple concret est un robot suiveur de ligne. Son programme principal est une boucle d'événements. Les capteurs infrarouges sous le robot génèrent des événements 'ligne_perdue à gauche' ou 'ligne_détectée'. Les gestionnaires de ces événements envoient des commandes aux moteurs pour corriger la trajectoire en temps réel, donnant l'impression d'un comportement réactif et intelligent.
Points clés
- Les minuteries (timers) sont des sources d'événements très courantes pour planifier des actions.
- Un même système peut gérer de multiples sources d'événements (boutons, capteurs, communications) de manière concurrente.
- Ce modèle permet de créer des systèmes réactifs qui semblent faire plusieurs choses 'en même temps', même avec un seul petit processeur.
À retenir
La programmation événementielle est un paradigme où l'exécution du code est déclenchée par des événements, et non par une séquence linéaire pré-établie. Elle est essentielle pour les systèmes embarqués en temps réel car elle permet de gérer des interactions imprévisibles avec l'environnement de manière réactive et efficace. Le modèle repose sur l'association entre des événements (ce qui se passe) et des gestionnaires ou 'callbacks' (ce qu'il faut faire), le tout orchestré par une boucle d'événements centrale.
- La programmation événementielle est réactive (elle répond à des événements) contrairement à la programmation séquentielle qui est active (elle interroge).
- Un programme événementiel est structuré autour de la boucle d'événements, des événements et des fonctions gestionnaires (callbacks).
- Ce modèle est indispensable pour programmer des systèmes embarqués interactifs et en temps réel (robots, objets connectés, interfaces).
