Introduction au C en Temps Réel et Gestion des Interruptions

TL;DR

La programmation C en temps réel vise à garantir que les opérations critiques s'exécutent dans des délais stricts, ce qui est essentiel pour les systèmes embarqués et les applications où la réactivité est cruciale. La gestion des interruptions est un mécanisme clé pour répondre rapidement aux événements externes sans bloquer le programme principal. Comprendre les priorités et la latence est fondamental pour concevoir des systèmes prévisibles et fiables.

1. The Mental Model

Imaginez que votre code est un chef d'orchestre qui doit s'assurer que chaque instrument (tâche) joue sa partie au bon moment. Les interruptions sont comme des signaux d'alarme urgents du public (événements externes) qui exigent l'attention immédiate du chef, peu importe ce qu'il est en train de diriger.

2. The Core Material

Le C est un choix populaire pour la programmation en temps réel grâce à son contrôle direct sur le matériel et ses performances. Cependant, "temps réel" ne signifie pas "rapide", mais plutôt "prévisible". Un système temps réel garantit qu'une tâche s'exécutera toujours dans un délai maximum défini, même si ce délai n'est pas le plus court possible.

Qu'est-ce que le Temps Réel ?

Photo by Bakr Magrabi on Pexels

Il existe différents types de systèmes temps réel :
* Temps réel dur (Hard Real-Time): La violation d'une échéance entraîne une défaillance catastrophique du système. Exemples : systèmes de contrôle d'avion, freins ABS.
* Temps réel souple (Soft Real-Time): La violation d'une échéance dégrade les performances mais n'entraîne pas une défaillance du système. Exemples : lecture vidéo, jeux en ligne.
* Temps réel ferme (Firm Real-Time): Une violation occasionnelle est tolérable, mais les résultats tardifs n'ont aucune valeur. Exemples : production audio/vidéo.

Gestion des Interruptions

Photo by Ann H on Pexels

Les interruptions sont des mécanismes matériels qui permettent à des périphériques (timers, boutons, capteurs) de signaler au CPU qu'un événement s'est produit et qu'il nécessite une attention immédiate. Lorsque le CPU reçoit une interruption, il suspend l'exécution de sa tâche actuelle, sauvegarde son contexte, puis exécute une fonction spéciale appelée Routine de Service d'Interruption (ISR - Interrupt Service Routine). Une fois l'ISR terminée, le CPU restaure son contexte et reprend l'exécution de la tâche principale.

Les étapes clés d'une interruption sont :

graph TD
    A["Événement externe (ex: bouton pressé)"] --> B["Génère une requête d'interruption (IRQ)"]
    B --> C{CPU occupé ?};
    C -- Oui --> D["IRQ en attente"];
    C -- Non --> E["CPU suspend la tâche actuelle"];
    E --> F["Sauvegarde le contexte CPU (registres)"];
    F --> G["Exécute la Routine de Service d'Interruption (ISR)"];
    G --> H["Restaure le contexte CPU"];
    H --> I["Reprend la tâche principale"];
    D --> E;

Concepts Clés en Temps Réel et Interruptions

Photo by Atlantic Ambience on Pexels

1. Latence d'Interruption (Interrupt Latency): C'est le temps entre le moment où l'interruption se produit et le début de l'exécution de l'ISR. Il est crucial de le minimiser dans les systèmes temps réel.
2. Jitter: C'est la variation de la latence d'interruption. Un faible jitter est vital pour la prévisibilité.
3. Priorité des Interruptions: Sur la plupart des microcontrôleurs, les interruptions peuvent être configurées avec différentes priorités. Une interruption de priorité plus élevée peut préempter une ISR de priorité plus faible.
4. Contexte (Context): L'état actuel du CPU (valeurs des registres, pointeur de pile) qui doit être sauvegardé et restauré lors d'une interruption.
5. Section Critique (Critical Section): Une portion de code qui ne doit pas être interrompue. Pour les protéger, on désactive temporairement les interruptions ou on utilise des mutex/sémaphores dans un RTOS.

Programmer une ISR en C

Photo by Daniil Komov on Pexels

Dans un environnement embarqué, une ISR est souvent une fonction spéciale déclarée avec un mot-clé spécifique au compilateur (ex: __interrupt, ISR, interrupt).

Points importants pour les ISR :
* Court et rapide: Les ISR doivent être aussi courtes et efficaces que possible pour minimiser la latence et ne pas retarder d'autres tâches.
* Pas de fonctions bloquantes: Évitez les fonctions qui attendent, comme delay(), ou les opérations d'E/S lentes.
* Accès aux variables partagées: Si une ISR modifie une variable utilisée par le programme principal, cette variable doit être déclarée volatile pour s'assurer que le compilateur ne l'optimise pas de manière incorrecte.
* Limiter les appels de fonctions: Chaque appel de fonction a un coût (sauvegarde/restauration de la pile).

3. Worked Example

Supposons que nous travaillons avec un microcontrôleur AVR (comme ceux des Arduino) et que nous voulons déclencher une action (allumer une LED) chaque fois qu'un bouton est pressé. Nous utiliserons une interruption externe pour cela.

#include <avr/io.h>         // Pour les registres du microcontrôleur
#include <avr/interrupt.h>  // Pour la gestion des interruptions
#include <util/delay.h>     // Pour la fonction _delay_ms

// Variable volatile car elle est modifiée dans l'ISR et lue dans le main
volatile int bouton_presse = 0;

// Routine de Service d'Interruption pour INT0 (broche D2 sur Arduino Uno)
// Le nom de l'ISR est spécifique à AVR, dépend du microcontrôleur
ISR(INT0_vect) {
    // Cette ISR s'exécute chaque fois que INT0 détecte un changement (front)
    // Nous mettons simplement un flag pour signaler que le bouton a été pressé
    bouton_presse = 1;
}

int main(void) {
    // Configuration de la broche D13 (LED intégrée sur Arduino Uno) comme sortie
    DDRB |= (1 << PB5); // PB5 correspond à la broche 13 sur l'ATmega328P

    // Configuration de l'interruption externe INT0 (broche D2)
    // EICRA: External Interrupt Control Register A
    // ISC01 et ISC00 contrôlent le type de front qui déclenche l'interruption
    // Ici, 1 0 -> falling edge (front descendant)
    EICRA |= (1 << ISC01); // Dégagement sur front descendant pour INT0
    EICRA &= ~(1 << ISC00); // Met le bit ISC00 à 0

    // EIMSK: External Interrupt Mask Register
    // Active l'interruption externe INT0
    EIMSK |= (1 << INT0);

    // Active les interruptions globales
    sei(); // set enable interrupt

    // Boucle principale
    while (1) {
        if (bouton_presse == 1) {
            // Le bouton a été pressé, allume la LED
            PORTB |= (1 << PB5); // Met la broche PB5 à HIGH
            _delay_ms(500);      // Garde la LED allumée pendant 500 ms
            PORTB &= ~(1 << PB5); // Éteint la LED

            // Réinitialise le flag pour attendre la prochaine pression
            bouton_presse = 0;
        }
        // Le microcontrôleur peut faire d'autres tâches ici pendant qu'il attend l'interruption
        // Par exemple, lire d'autres capteurs, mettre à jour un écran, etc.
    }

    return 0;
}

Dans cet exemple, l'ISR est extrêmement simple : elle se contente de modifier une variable volatile. Le travail "lourd" (allumer la LED et attendre) est effectué dans la boucle main, ce qui est une bonne pratique. L'ISR réagit rapidement, puis le programme principal gère l'action, permettant au système de rester réactif à d'autres interruptions si nécessaire.

4. Key Takeaways

• Le temps réel signifie prévisibilité, pas nécessairement vitesse, garantissant que les tâches critiques s'exécutent dans des délais définis.
• Les interruptions permettent au CPU de répondre rapidement aux événements externes sans avoir à sonder constamment les périphériques.
• Une Routine de Service d'Interruption (ISR) est une fonction spéciale exécutée lors d'une interruption ; elle doit être courte, rapide et non bloquante.
• Les variables partagées entre l'ISR et le code principal doivent être déclarées volatile pour éviter les problèmes d'optimisation du compilateur.
• La latence d'interruption et le jitter sont des métriques clés pour évaluer la réactivité et la prévisibilité d'un système temps réel.
• Les priorités d'interruption permettent de hiérarchiser les réponses aux différents événements.

Common mistakes to avoid:
- Ne pas déclarer volatile les variables partagées : cela peut entraîner un comportement inattendu en raison des optimisations du compilateur.
- Exécuter des opérations longues ou bloquantes dans une ISR : cela augmente la latence et le jitter, et peut rendre le système non réactif à d'autres interruptions.
- Oublier d'activer les interruptions globales (par exemple, sei() sur AVR) : sans cela, aucune ISR ne sera exécutée.
- Ne pas comprendre les registres spécifiques du microcontrôleur : la configuration des interruptions est très dépendante du matériel.

5. Now Try It

Modifiez l'exemple donné pour qu'appuyer sur le bouton active une LED pendant 200 ms, puis l'éteigne, et qu'appuyer une deuxième fois sur le bouton fasse clignoter une autre LED (sur une broche différente, par exemple D12) trois fois avec un délai de 100 ms entre chaque clignotement. Utilisez toujours la même interruption pour le bouton, mais adaptez la logique dans le main pour gérer les différents états d'appui sur le bouton. Le succès sera de voir la LED D13 s'allumer une fois après la première pression, puis la LED D12 clignoter trois fois après la deuxième pression, et ainsi de suite en alternance.