Éviter les variables globales lors de l'utilisation d'interruptions dans les systèmes embarqués

Existe-t-il un bon moyen de mettre en œuvre la communication entre un ISR et le reste du programme pour un système embarqué qui évite les variables globales?

Il semble que le modèle général consiste à avoir une variable globale qui est partagée entre l'ISR et le reste du programme et utilisée comme indicateur, mais cette utilisation de variables globales va à l'encontre de moi. J'ai inclus un exemple simple utilisant des ISR de style avr-libc:

volatile uint8_t flag;

int main() {
    ...

    if (flag == 1) {
        ...
    }
    ...
}

ISR(...) {
    ...
    flag = 1;
    ...
}

Je ne peux pas voir de loin ce qui est essentiellement un problème de portée; toutes les variables accessibles à la fois par l'ISR et le reste du programme doivent être intrinsèquement globales, sûrement? Malgré cela, j'ai souvent vu des gens dire des choses comme «les variables globales sont un moyen de mettre en œuvre la communication entre les ISR et le reste du programme» (c'est moi qui souligne), ce qui semble impliquer qu'il existe d'autres méthodes; s'il existe d'autres méthodes, quelles sont-elles?

Il existe une méthode standard de facto pour ce faire (en supposant une programmation C):

• Les interruptions / ISR sont de bas niveau et ne doivent donc être implémentées que dans le pilote lié au matériel qui génère l'interruption. Ils ne devraient pas être situés ailleurs que dans ce pilote.
• Toutes les communications avec l'ISR sont effectuées uniquement par le conducteur et le conducteur. Si d'autres parties du programme ont besoin d'accéder à ces informations, il doit le demander au pilote via les fonctions setter / getter ou similaires.
• Vous ne devez pas déclarer de variables "globales". Variables de portée de fichier de signification globale avec liaison externe. C'est-à-dire: des variables qui pourraient être appelées avec un externmot-clé ou simplement par erreur.
• Au lieu de cela, pour forcer l'encapsulation privée à l'intérieur du pilote, toutes ces variables partagées entre le pilote et l'ISR doivent être déclarées static. Une telle variable n'est pas globale mais limitée au fichier où elle est déclarée.
• Pour éviter les problèmes d'optimisation du compilateur, ces variables doivent également être déclarées comme volatile. Remarque: cela ne donne pas d'accès atomique ni ne résout la rentrée!
• Une certaine manière de mécanisme de ré-entrée est souvent nécessaire dans le pilote, au cas où l'ISR écrit dans la variable. Exemples: désactivation d'interruption, masque d'interruption global, sémaphore / mutex ou lectures atomiques garanties.

cette utilisation des variables globales va à l'encontre de moi

Tel est le vrai problème. Passer à autre chose.

Maintenant, avant que les genoux ne se plaignent immédiatement de la façon dont cela est impur, permettez-moi de nuancer un peu. Il y a certainement un danger à utiliser des variables globales à outrance. Mais ils peuvent également augmenter l'efficacité, ce qui compte parfois dans les petits systèmes aux ressources limitées.

La clé est de penser à quand vous pouvez raisonnablement les utiliser et ne risquez pas de vous causer des ennuis, par rapport à un bug qui ne fait qu'attendre. Il y a toujours des compromis. Bien qu'éviter généralement les variables globales pour communiquer entre l'interruption et le code de premier plan est une ligne directrice insoutenable, la prendre, comme la plupart des autres lignes directrices, à un extrême religieux est contre-productif.

Voici quelques exemples où j'utilise parfois des variables globales pour transmettre des informations entre le code d'interruption et de premier plan:

1. Compteurs d'horloge gérés par l'interruption de l'horloge système. J'ai généralement une interruption d'horloge périodique qui s'exécute toutes les 1 ms. Cela est souvent utile pour différents moments du système. Une façon d'extraire ces informations de la routine d'interruption pour que le reste du système puisse les utiliser est de garder un compteur de tick d'horloge global. La routine d'interruption incrémente le compteur à chaque tick d'horloge. Le code de premier plan peut lire le compteur à tout moment. Je le fais souvent pendant 10 ms, 100 ms et même 1 seconde.

   Je m'assure que les graduations de 1 ms, 10 ms et 100 ms sont d'une taille de mot qui peut être lue en une seule opération atomique. Si vous utilisez un langage de haut niveau, assurez-vous d'indiquer au compilateur que ces variables peuvent changer de manière asynchrone. En C, par exemple , vous les déclarez volatiles externes . Bien sûr, c'est quelque chose qui va dans un fichier include en conserve, vous n'avez donc pas besoin de vous en souvenir pour chaque projet.

   Je fais parfois le compteur de ticks 1 s le compteur de temps total écoulé, alors faites 32 bits de large. Cela ne peut pas être lu en une seule opération atomique sur la plupart des petits micro que j'utilise, donc ce n'est pas rendu mondial. Au lieu de cela, une routine est fournie qui lit la valeur de plusieurs mots, traite des mises à jour possibles entre les lectures et renvoie le résultat.

   Bien sûr, il aurait pu y avoir des routines pour obtenir les plus petits compteurs de 1 ms, 10 ms, etc. Cependant, cela ne fait vraiment pas grand-chose pour vous, ajoute de nombreuses instructions au lieu de lire un seul mot et utilise un autre emplacement de pile d'appels.

   Quel est l'inconvénient? Je suppose que quelqu'un pourrait faire une faute de frappe qui écrit accidentellement sur l'un des compteurs, ce qui pourrait alors gâcher un autre timing dans le système. Écrire délibérément sur un compteur n'aurait aucun sens, donc ce type de bogue devrait être quelque chose de non intentionnel comme une faute de frappe. Semble très improbable. Je ne me souviens pas que cela se soit produit dans plus de 100 petits projets de microcontrôleurs.

2. Valeurs A / N finales filtrées et ajustées. Une chose courante à faire est d'avoir une routine d'interruption gérer les lectures d'un A / D. Je lis généralement les valeurs analogiques plus rapidement que nécessaire, puis j'applique un peu de filtrage passe-bas. Il y a souvent aussi une mise à l'échelle et un décalage qui sont appliqués.

   Par exemple, l'A / D peut lire la sortie 0 à 3 V d'un diviseur de tension pour mesurer l'alimentation 24 V. Les nombreuses lectures sont exécutées à travers un certain filtrage, puis mises à l'échelle de sorte que la valeur finale soit en millivolts. Si l'alimentation est à 24,015 V, la valeur finale est 24015.

   Le reste du système ne voit qu'une valeur actualisée en direct indiquant la tension d'alimentation. Il ne sait pas et n'a pas besoin de se soucier quand exactement cela est mis à jour, d'autant plus qu'il est mis à jour beaucoup plus souvent que le temps d'établissement du filtre passe-bas.

   Encore une fois, une routine d'interface peut être utilisée, mais vous en tirez très peu d'avantages. L'utilisation de la variable globale chaque fois que vous avez besoin de la tension d'alimentation est beaucoup plus simple. N'oubliez pas que la simplicité n'est pas seulement pour la machine, mais que plus simple signifie également moins de risques d'erreur humaine.

Toute interruption particulière sera une ressource globale. Parfois, cependant, il peut être utile que plusieurs interruptions partagent le même code. Par exemple, un système peut avoir plusieurs UART, qui doivent tous utiliser une logique d'envoi / réception similaire.

Une bonne approche pour gérer cela consiste à placer les éléments utilisés par le gestionnaire d'interruption, ou des pointeurs vers eux, dans un objet de structure, puis à ce que les gestionnaires d'interruption matériels réels soient quelque chose comme:

void UART1_handler(void) { uart_handler(&uart1_info); }
void UART2_handler(void) { uart_handler(&uart2_info); }
void UART3_handler(void) { uart_handler(&uart3_info); }

Les objets uart1_info, uart2_infoetc. seraient des variables globales, mais ce seraient les seules variables globales utilisées par les gestionnaires d'interruption. Tout le reste que les gestionnaires vont toucher serait traité dans ces limites.

Notez que tout ce qui est accessible à la fois par le gestionnaire d'interruption et par le code de la ligne principale doit être qualifié volatile. Il peut être plus simple de déclarer simplement volatiletout ce qui sera utilisé par le gestionnaire d'interruption, mais si les performances sont importantes, il peut être utile d'écrire du code qui copie les informations dans des valeurs temporaires, les opère, puis les réécrit. Par exemple, au lieu d'écrire:

if (foo->timer)
  foo->timer--;

écrire:

uint32_t was_timer;
was_timer = foo->timer;
if (was_timer)
{
  was_timer--;
  foo->timer = was_timer;
}

La première approche peut être plus facile à lire et à comprendre, mais sera moins efficace que la seconde. La question de savoir si cela dépend de l'application.

Voici trois idées:

Déclarez la variable indicateur comme statique pour limiter la portée à un seul fichier.

Rendez la variable d'indicateur privée et utilisez les fonctions getter et setter pour accéder à la valeur d'indicateur.

Utilisez un objet de signalisation tel qu'un sémaphore au lieu d'une variable indicateur. L'ISR définirait / publierait le sémaphore.

Une interruption (c'est-à-dire le vecteur qui pointe vers votre gestionnaire) est une ressource globale. Donc, même si vous utilisez une variable sur la pile ou sur le tas:

volatile bool *flag;  // must be initialized before the interrupt is enabled

ISR(...) {
    *flag = true;
}

ou du code orienté objet avec une fonction 'virtuelle':

HandlerObject *obj;

ISR(...) {
    obj->handler_function(obj);
}

… La première étape doit impliquer une variable globale réelle (ou au moins statique) pour atteindre ces autres données.

Tous ces mécanismes ajoutent une indirection, ce qui n'est généralement pas le cas si vous souhaitez extraire le dernier cycle du gestionnaire d'interruption.

Je suis en train de coder pour Cortex M0 / M4 en ce moment et l'approche que nous utilisons en C ++ (il n'y a pas de balise C ++, donc cette réponse pourrait être hors sujet) est la suivante:

Nous utilisons une classe CInterruptVectorTablequi contient toutes les routines de service d'interruption qui sont stockées dans le vecteur d'interruption réel du contrôleur:

#pragma location = ".intvec"
extern "C" const intvec_elem __vector_table[] =
{
  { .__ptr = __sfe( "CSTACK" ) },           // 0x00
  __iar_program_start,                      // 0x04

  CInterruptVectorTable::IsrNMI,            // 0x08
  CInterruptVectorTable::IsrHardFault,      // 0x0C
  //[...]
}

La classe CInterruptVectorTableimplémente une abstraction des vecteurs d'interruption, vous pouvez donc lier différentes fonctions aux vecteurs d'interruption pendant l'exécution.

L'interface de cette classe ressemble à ceci:

class CInterruptVectorTable  {
public :
    typedef void (*IsrCallbackfunction_t)(void);                      

    enum InterruptId_t {
        INTERRUPT_ID_NMI,
        INTERRUPT_ID_HARDFAULT,
        //[...]
    };

    typedef struct InterruptVectorTable_t {
        IsrCallbackfunction_t IsrNMI;
        IsrCallbackfunction_t IsrHardFault;
        //[...]
    } InterruptVectorTable_t;

    typedef InterruptVectorTable_t* PinterruptVectorTable_t;


public :
    CInterruptVectorTable(void);
    void SetIsrCallbackfunction(const InterruptId_t& interruptID, const IsrCallbackfunction_t& isrCallbackFunction);

private :

    static void IsrStandard(void);

public :
    static void IsrNMI(void);
    static void IsrHardFault(void);
    //[...]

private :

    volatile InterruptVectorTable_t virtualVectorTable;
    static volatile CInterruptVectorTable* pThis;
};

Vous devez créer les fonctions qui sont stockées dans la table vectorielle staticcar le contrôleur ne peut pas fournir de thispointeur car la table vectorielle n'est pas un objet. Donc, pour contourner ce problème, nous avons le pThispointeur statique à l'intérieur du CInterruptVectorTable. En entrant dans l'une des fonctions d'interruption statiques, il peut accéder au pThispointeur pour accéder aux membres du même objet CInterruptVectorTable.

Maintenant, dans le programme, vous pouvez utiliser le SetIsrCallbackfunctionpour fournir un pointeur de fonction à une staticfonction qui doit être appelée lorsqu'une interruption se produit. Les pointeurs sont stockés dans le InterruptVectorTable_t virtualVectorTable.

Et l'implémentation d'une fonction d'interruption ressemble à ceci:

void CInterruptVectorTable::IsrNMI(void) {
    pThis->virtualVectorTable.IsrNMI(); 
}

Donc, cela appellera une staticméthode d'une autre classe (qui peut être private), qui peut alors contenir un autre static thispointeur pour accéder aux variables membres de cet objet (un seul).

Je suppose que vous pourriez construire et interfacer comme IInterruptHandleret stocker des pointeurs vers des objets, donc vous n'avez pas besoin du static thispointeur dans toutes ces classes. (peut-être essayons-nous cela dans la prochaine itération de notre architecture)

L'autre approche fonctionne bien pour nous, car les seuls objets autorisés à implémenter un gestionnaire d'interruption sont ceux à l'intérieur de la couche d'abstraction matérielle, et nous n'avons généralement qu'un seul objet pour chaque bloc matériel, donc cela fonctionne bien avec les static thispointeurs. Et la couche d'abstraction matérielle fournit une autre abstraction aux interruptions, appelée ICallbackqui est ensuite implémentée dans la couche de périphérique au-dessus du matériel.

Accédez-vous aux données globales? Bien sûr, mais vous pouvez rendre privées la plupart des données globales nécessaires, comme les thispointeurs et les fonctions d'interruption.

Ce n'est pas à l'épreuve des balles, et cela ajoute des frais généraux. Vous aurez du mal à implémenter une pile IO-Link en utilisant cette approche. Mais si vous n'êtes pas extrêmement serré avec les timings, cela fonctionne très bien pour obtenir une abstraction flexible des interruptions et de la communication dans les modules sans utiliser de variables globales accessibles de partout.