Signaux

Dans ce RTOS Revealed, je vais examiner les signaux, qui sont la méthode la plus simple de communication inter-tâches prise en charge par Nucleus SE. Ils offrent un moyen très peu coûteux de transmettre des messages simples entre les tâches.

Utilisation des signaux

Les signaux sont différents de tous les autres types d'objets du noyau en ce qu'ils ne sont pas autonomes – les signaux sont associés à des tâches et n'ont pas d'existence indépendante. Si les signaux sont configurés pour une application, chaque tâche a un ensemble de huit indicateurs de signal.

Toute tâche peut définir les signaux d'une autre tâche. Seule la tâche propriétaire peut lire les signaux. La lecture est destructrice, c'est-à-dire que les signaux sont effacés par le processus de lecture. Aucune autre tâche ne peut lire ou effacer les signaux d'une tâche.

Il existe une fonction dans Nucleus RTOS qui permet à une tâche de désigner une fonction qui est exécutée lorsqu'une autre tâche définit un ou plusieurs de ses indicateurs de signal. Ceci est quelque peu analogue à une routine de service d'interruption. Cette capacité n'est pas prise en charge dans Nucleus SE; les tâches doivent interroger explicitement leurs indicateurs de signal.

Configuration des signaux

Comme pour la plupart des aspects de Nucleus SE, la configuration des signaux est principalement contrôlée par #define déclarations dans nuse_config.h . Le paramètre clé est NUSE_SIGNAL_SUPPORT , qui active la fonction (pour toutes les tâches de l'application). Il n'est pas question de spécifier le nombre de signaux - il y a simplement un ensemble de huit drapeaux pour chaque tâche dans l'application.

La définition de ce paramètre d'activation est la « validation principale » pour les signaux. Cela entraîne la définition et la taille d'une structure de données en conséquence, dont plus loin dans cet article. Il active également les paramètres d'activation de l'API.

Activation de l'API

Chaque fonction API (appel de service) dans Nucleus SE a un #define d'activation symbole dans nuse_config.h . Pour les signaux, ce sont :

NUSE_SIGNALS_SENDNUSE_SIGNALS_RECEIVE 

Par défaut, les deux sont définis sur FALSE , désactivant ainsi chaque appel de service et empêchant l'inclusion de tout code d'implémentation. Pour configurer des signaux pour une application, vous devez sélectionner les appels d'API que vous souhaitez utiliser et définir leurs symboles d'activation sur TRUE .

Voici un extrait du nuse_config.h par défaut fichier :

#define NUSE_SIGNAL_SUPPORT FALSE /* Active la prise en charge des signaux */#define NUSE_SIGNALS_SEND FALSE /* Activation d'appel de service */#define NUSE_SIGNALS_RECEIVE FALSE /* Activation d'appel de service */ 

Une erreur de temps de compilation se produira si une fonction API de signaux est activée et que la fonction de signaux n'a pas été activée. Si votre code utilise un appel d'API, qui n'a pas été activé, une erreur de temps de liaison se produira, car aucun code d'implémentation n'aura été inclus dans l'application. Bien sûr, l'activation des deux fonctions API est quelque peu redondante, car il ne servirait à rien d'activer la prise en charge des signaux et de ne pas disposer de ces API. Les activations sont incluses pour la compatibilité avec d'autres fonctionnalités Nucleus SE.

Signals Service Calls

Nucleus RTOS prend en charge quatre appels de service relatifs aux signaux, qui fournissent les fonctionnalités suivantes :

• Envoyer des signaux à une tâche spécifiée. Implémenté par NUSE_Signals_Send() dans Nucleus SE.

• Recevoir des signaux. Implémenté par NUSE_Signals_Receive() dans Nucleus SE.

• Enregistrez un gestionnaire de signal. Non implémenté dans Nucleus SE.

• Activer/désactiver (contrôler) les signaux. Non implémenté dans Nucleus SE.

La mise en œuvre de chacun de ces appels de service est examinée en détail.

Services d'envoi et de réception de signaux

Les opérations fondamentales, qui peuvent être effectuées sur l'ensemble de signaux d'une tâche, sont l'envoi de données (ce qui peut être fait par n'importe quelle tâche) et la lecture de données (et donc l'effacement des données, ce qui ne peut être fait que par le propriétaire) . Nucleus RTOS et Nucleus SE fournissent chacun deux appels d'API de base pour ces opérations, qui seront discutés ici.

Étant donné que les indicateurs de signaux sont des bits, ils sont mieux visualisés sous forme de nombres binaires. Comme le C standard ne prend pas en charge historiquement une représentation des constantes binaires (uniquement en octal et hexadécimal), la distribution Nucleus SE inclut un fichier d'en-tête utile - nuse_binary.h – qui contient #define symboles de la forme b01010101 pour toutes les 256 valeurs 8 bits. Voici un extrait du nuse_binary.h fichier :

#define b00000000 ((U8) 0x00)#define b0000001 ((U8) 0x01)#define b00000010 ((U8) 0x02)#define b00000011 ((U8) 0x03)#define b00000100 ((U8) 0x04)#define b00000101 ((U8) 0x05)

Envoi de signaux

N'importe quelle tâche peut envoyer des signaux à n'importe quelle autre tâche de l'application. L'envoi de signaux implique la définition d'un ou plusieurs indicateurs de signal. Il s'agit d'une opération OU qui n'a aucun effet sur les indicateurs définis précédemment.

Appel API Nucleus RTOS pour l'envoi de signaux

Prototype d'appel de service :

STATUS NU_Send_Signals(NU_TASK *tâche, signaux NON SIGNÉS );

Paramètres :

tâche – pointeur vers le bloc de contrôle de la tâche qui possède les drapeaux de signal à définir

signaux – la valeur des drapeaux de signalisation à définir

Retours :

NU_SUCCESS – l'appel s'est terminé avec succès

NU_INVALID_TASK – le pointeur de tâche n'est pas valide

Appel API Nucleus SE pour l'envoi de signaux

Cet appel d'API prend en charge la fonctionnalité clé de l'API Nucleus RTOS.

Prototype d'appel de service :

STATUS NUSE_Signals_Send (tâche NUSE_TASK, signaux U8) ;

Paramètres :

tâche – l'index (ID) de la tâche qui possède les drapeaux de signal à définir

signaux – la valeur des drapeaux de signalisation à définir

Retours :

NUSE_SUCCESS – l'appel s'est terminé avec succès

NUSE_INVALID_TASK – l'index de la tâche est invalide

Implémentation Nucleus SE de l'envoi de signaux

Voici le code complet pour le NUSE_Signals_Send() fonction :

STATUS NUSE_Signals_Send (tâche NUSE_TASK, signaux U8){ #if NUSE_API_PARAMETER_CHECKING if (tâche>=NUSE_TASK_NUMBER) { return NUSE_INVALID_TASK ; } #endif NUSE_CS_Enter(); NUSE_Task_Signal_Flags[tâche] |=signaux ; NUSE_CS_Exit(); renvoyer NUSE_SUCCESS ;} 

Le code est très simple. Après toute vérification des paramètres, les valeurs de signal sont combinées par OU dans les drapeaux de signal de la tâche spécifiée. Le blocage des tâches n'est pas pertinent pour les signaux.

Réception de signaux

Une tâche ne peut lire que son propre ensemble d'indicateurs de signal. Le processus de les lire est destructeur; c'est-à-dire que cela entraîne également l'effacement des drapeaux.

Appel API Nucleus RTOS pour la réception de signaux

Prototype d'appel de service :

NOUS SIGNÉS NU_Receive_Signals (VOID) ;

Paramètres :aucun

Renvoie :la valeur des drapeaux de signaux

Appel API Nucleus SE pour la réception de signaux

Cet appel d'API prend en charge la fonctionnalité clé de l'API Nucleus RTOS.

Prototype d'appel de service :

U8 NUSE_Signals_Receive(void);

Paramètres :aucun

Renvoie :la valeur des drapeaux de signal

Implémentation Nucleus SE des signaux de réception

Voici le code complet pour le NUSE_Signals_Receive() fonction :

U8 NUSE_Signals_Receive(void){ Signaux U8 ; NUSE_CS_Enter(); signaux =NUSE_Task_Signal_Flags[NUSE_Task_Active] ; NUSE_Task_Signal_Flags[NUSE_Task_Active] =0 ; NUSE_CS_Exit(); renvoyer des signaux ;} 

Le code est très simple. La valeur flags est copiée, la valeur d'origine effacée et la copie renvoyée par la fonction API. Le blocage des tâches n'est pas pertinent pour les signaux.