Boîtes aux lettres dans Nucleus SE : Guide pratique de configuration et d'utilisation

Voir la série RTOS Revealed

Les boîtes aux lettres ont été introduites dans un article précédent comme l'un des mécanismes de communication inter-tâches les plus simples dans Nucleus SE — juste après les signaux. Elles offrent un moyen peu coûteux et hautement flexible de transférer des données simples entre tâches.

Utilisation des boîtes aux lettres

Dans Nucleus SE, les boîtes aux lettres sont définies à la compilation. Un maximum de 16 boîtes aux lettres peut être configuré par application. Si vous configurez zéro boîte aux lettres, le compilateur omet toutes les structures de données et le code API associés, gardant le binaire léger.

Une boîte aux lettres est essentiellement un emplacement de stockage qui peut contenir une seule variable de type ADDR. Une seule tâche peut écrire dans une boîte aux lettres à la fois. Une fois pleine, les tentatives d'écriture ultérieures échoueront jusqu'à ce que la boîte soit lue ou réinitialisée. Selon les options API, une tentative d'écriture dans une boîte pleine peut retourner une erreur ou suspendre la tâche jusqu'à ce qu'un espace devienne disponible.

Boîtes aux lettres vs Files d'attente

Certains systèmes d'exploitation remplacent les boîtes aux lettres par une file d'attente à entrée unique. Bien qu'une file puisse imiter le comportement d'une boîte aux lettres, elle entraîne un surcoût — pointeurs tête et queue, structures de données plus grandes, et plus de chemins de code — conduisant à une utilisation mémoire et un temps d'exécution plus élevés.

Dans Nucleus SE, vous pouvez choisir soit les boîtes aux lettres, soit les files. Si votre conception utilise beaucoup de files mais peu de boîtes aux lettres, échanger une boîte aux lettres contre une file augmentera légèrement la taille des données mais supprimera le code API spécifique aux boîtes, simplifiant la maintenance. Il est facile de tester les deux configurations pour comparer l'empreinte mémoire et la performance.

Les files d'attente seront couvertes dans un futur article.

Configuration des boîtes aux lettres

Nombre de boîtes aux lettres

La macro clé dans nuse_config.h est NUSE_MAILBOX_NUMBER. La valeur par défaut est 0, signifiant qu'aucune boîte aux lettres n'est activée. Vous pouvez la définir à tout entier entre 1 et 16. Une vérification à la compilation dans nuse_config_check.h déclenchera une erreur si la valeur est hors plage.

Définir une valeur non-nulle active le sous-système de boîtes aux lettres : les structures de données sont dimensionnées, et les symboles d'activation des API sont traités.

Activations des API

Chaque appel API de boîte aux lettres a un #define correspondant dans nuse_config.h :

• NUSE_MAILBOX_SEND
• NUSE_MAILBOX_RECEIVE
• NUSE_MAILBOX_RESET
• NUSE_MAILBOX_INFORMATION
• NUSE_MAILBOX_COUNT

Par défaut, tous sont définis sur FALSE, désactivant l'appel et son implémentation. Pour utiliser une API, activez la macro correspondante en la définissant sur TRUE. Activer une API sans boîtes aux lettres configurées causera une erreur à la compilation (sauf NUSE_Mailbox_Count(), toujours disponible). Utiliser une API désactivée produira une erreur à l'édition de liens.

/* Nombre de boîtes aux lettres dans le système – 0-16 */ #define NUSE_MAILBOX_NUMBER 0 /* Activateurs d'appels de service : */ #define NUSE_MAILBOX_SEND FALSE #define NUSE_MAILBOX_RECEIVE FALSE #define NUSE_MAILBOX_RESET FALSE #define NUSE_MAILBOX_INFORMATION FALSE #define NUSE_MAILBOX_COUNT FALSE 

Appels de service des boîtes aux lettres

Nucleus SE offre neuf appels de service liés aux boîtes aux lettres. Ceux implémentés dans SE sont :

• NUSE_Mailbox_Send() — écrire un message dans une boîte aux lettres.
• NUSE_Mailbox_Receive() — lire un message depuis une boîte aux lettres.
• NUSE_Mailbox_Reset() — vider une boîte aux lettres sans suspendre les tâches.
• NUSE_Mailbox_Information() — interroger l'état d'une boîte aux lettres.
• NUSE_Mailbox_Count() — retourner le nombre de boîtes aux lettres configurées.

D'autres fonctions comme création, suppression, récupération en masse, et diffusion ne sont pas implémentées dans SE.

Opérations d'écriture et de lecture

Les boîtes aux lettres supportent deux opérations de base : l'envoi (écriture) et la réception (lecture). Les deux APIs sont disponibles dans Nucleus RTOS et Nucleus SE, avec quelques différences en flexibilité et gestion d'erreurs.

Envoi vers une boîte aux lettres

Dans Nucleus RTOS, l'appel NU_Send_To_Mailbox supporte la suspension indéfinie ou temporisée si la boîte est pleine. Nucleus SE offre une version simplifiée : la suspension est optionnelle et les timeouts ne sont pas supportés.

Prototype exemple pour Nucleus SE :

STATUS NUSE_Mailbox_Send(NUSE_MAILBOX mailbox, ADDR *message, U8 suspend);

Paramètres :

• mailbox — index de la boîte aux lettres.
• message — pointeur vers une variable ADDR.
• suspend — NUSE_NO_SUSPEND ou NUSE_SUSPEND.

Les valeurs de retour incluent NUSE_SUCCESS, NUSE_INVALID_MAILBOX, NUSE_MAILBOX_FULL, et NUSE_MAILBOX_WAS_RESET.

Vue d'ensemble de l'implémentation

Quand le blocage est désactivé, la routine vérifie le drapeau d'état de la boîte aux lettres. Si la boîte est vide, elle écrit la donnée et marque la boîte comme pleine ; sinon elle retourne NUSE_MAILBOX_FULL.

Avec le blocage activé, le code boucle jusqu'à ce que le message soit posté avec succès ou que la tâche soit réveillée par une opération de réception. Si une tâche est suspendue sur la boîte aux lettres, elle est reprise immédiatement après un envoi réussi.

L'extrait suivant démontre la logique de base quand le blocage est activé (simplifié pour la lisibilité) :

do { if (!NUSE_Mailbox_Status[mailbox]) { // Boîte vide – stocker données et réveiller tâche en attente si existe. } else if (suspend == NUSE_NO_SUSPEND) { return NUSE_MAILBOX_FULL; } else { // Suspendre tâche jusqu'à ce que la boîte devienne vide. } } while (suspend == NUSE_SUSPEND); 

En résumé, l'API boîte aux lettres équilibre simplicité et flexibilité, permettant aux développeurs de choisir entre échec immédiat ou suspension de tâche selon les exigences de timing de leur application.