Développement d'applications embarquées avec OSEK/VDX : exemple du Robot Lego NXT

L'objet APPMODE ne dispose pas d'attribut et se déclare dans le fichier OIL de la façon suivante :

APPMODE nom_appmode 
 {
 };

Notons que lors de la spécification d'une application embarquée sur un processeur, au moins un objet APPMODE doit être défini.

Une tâche OSEK/VDX se déclare de la façon :

TASK nom_tache
  {
    AUTOSTART = TRUE
    PRIORITY = 1; 
    ACTIVATION = 1;
    SCHEDULE = FULL;
    STACKSIZE = 512;
  };

• l'attribut AUTOSTART indique si la tâche est activée ou non au démarrage de l'application. Il prend les valeurs TRUE ou FALSE ;
• l'attribut PRIORITY donne la priorité de la tâche où 1 correspond à la priorité la plus basse du système ;
• l'attribut ACTIVATION indique le nombre d'activations que la tâche peut retenir à un moment donné et les prendre en compte plus tard. Dans ce cas une seule activation ;
• l'attribut SCHEDULE indique le type d'ordonnancement de la tâche. OSEK/VDX est basée sur un ordonnancement à priorité fixe avec traitement FIFO pour les tâches de même priorité. Les politiques d'ordonnancement possibles sont : FULL pour un ordonnancement avec préemption et NON sans préemption ;
• l'attribut STACKSIZE indique la taille en octets de la pile utilisée par la tâche. Dans ce cas la tâche a une pile de taille 512 octets ;

Dans le fichier programme C, avant d'utiliser un objet TASK du fichier OIL, il faut le déclarer dans le fichier C. Pour cela, il faut appeler la fonction (ou service) suivante :

DeclareTask(nom_tache)

Cette fonction est généralement appelée en tout début de programme directement après les lignes #include.

Puis la définition effective de la tâche doit se présenter de la façon suivante :

TASK(nom_tache)
{
	//...
	TerminateTask();
}

Le corps de la tâche s'écrit à l'aide du langage C. En outre, une tâche OSEK/VDX se termine toujours par le service TerminateTask() dont le prototype est le suivant :

StatusType TerminateTask(void)

Ce service (ou fonction si vous voulez) est obligatoire, car il permet de terminer l'instance de la tâche en cours d'exécution. StatusType est un type de donnée globale du système qui permet de savoir si le service qui vient d'être appelé a généré une erreur ou pas (c'est un peu l'équivalent de la variable errno en C standard). Ceci est vrai pour plusieurs autres services.

Quelques fois, si une tâche doit se terminer en activant une autre tâche de l'application, le service TerminateTask() est remplacé par le service chainTask(nom_tache_a_activer) dont le prototype est le suivant :

StatusType chainTask(nom_tache_a_activer)

Il existe d'autres services qui peuvent être appliqués aux tâches. Leurs prototypes sont les suivants :

1. Le service permettant d'activer une tâche dont l'identifiant nom_tache_a_activer est donné en paramètre :

StatusType ActivateTask(nom_tache_a_activer)

2. Le service permettant de mettre dans la variable globale nom_tache du programme, le nom de la tâche en cours d'exécution dans le système. Ce service peut être appelé par une tâche de l'application ou une ISR (Interrupt Service Request) définie dans l'application :

StatusType GetTaskID(nom_tache)

3. Le service permettant de mettre dans la variable globale etat du programme, l'état (bloqué, endormie, en cours d'exécution ou prête) de la tâche dont l'identifiant est nom_tache. Ce service peut être appelé par une tâche de l'application ou une ISR (Interrupt Service Request) définie dans l'application :

StatusType GetTaskState(nom_tache, etat)

4. Le service appelé par la tâche en cours d'exécution pour s'endormir et lancer l'exécution de l'éventuelle tâche la plus prioritaire qui attend dans l'état prêt :

StatusType Schedule(void)

L'objet EVENT est déclaré dans le fichier OIL de la façon suivante:

EVENT un_evt
 {
  MASK = AUTO;
 };


TASK nom_tache_a_declencher
  {
    //...
    EVENT = un_evt;
  };

L'attribut MASK correspond à un entier de type UINT64 qui identifie de manière unique l'événement dans le système. Comme sur l'exemple précédent, il peut être initialisé par la valeur AUTO. Dans ce cas, c'est le système qui se charge de lui affecter une valeur unique.

Dans le fichier programme C, avant d'utiliser un objet EVENT du fichier OIL, il faut le déclarer dans le fichier C. Pour cela, il faut appeler la fonction (ou service) suivante :

DeclareEvent(un_evt)

Plusieurs services sont offerts pour le traitement de l'objet EVENT. Ce sont :

1. Le service appelé dans le corps d'une tâche ou d'une ISR quelconque pour lui permette de transmettre l'événement nommé un_evt à la tâche nom_tache_a_declencher qui le possède :

StatusType SetEvent(nom_tache_a_declencher, un_evt)

2. Le service permettant à une tâche (exemple, nom_tache_a_declencher) possédant l'événement un_evt d'attendre sur ce dernier :

StatusType WaitEvent(un_evt)

3. Le service permettant d'effacer l'attente sur un événement :

StatusType ClearEvent(un_evt)

4. Le service appelé dans le corps d'une tâche ou d'une ISR quelconque pour récupérer l'état courant de l'attribut MASK de l'événement un_evt que possède la tâche nom_tache_a_declencher :

StatusType GetEvent(nom_tache_a_declencher, un_evt)

L'exemple ci-dessous montre la structuration de deux tâches manipulant un événement :

TASK(nom_tache_declencheur_evt)
{
	//...
	SetEvent(nom_tache_a_declencher, un_evt);
	TerminateTask();
}

TASK(nom_tache_a_declencher)
{
	WaitEvent(un_evt);
	//...
	ClearEvent(un_evt) //effacer l'événement pour permettre sa réutilisation par la suite
	TerminateTask();
}

L'objet RESOURCE est déclaré dans le fichier OIL de la façon suivante :

RESOURCE une_ressource
{
RESOURCEPROPERTY = STANDARD;
};


TASK nom_tache
  {
    //...
    RESOURCE = une_ressource;
  };

L'attribut RESOURCEPROPERTY correspond à une variable de type ENUM qui peut prendre les valeurs suivantes :
- STANDARD indique que la ressource est une ressource normale, c'est-à-dire non liée à une autre et n'est pas une ressource interne ;
- LINKED indique que la ressource est liée à une autre ressource de type STANDARD ou LINKED. Laquelle ressource doit disposer d'un attribut supplémentaire LINKEDRESOURCE de type RESOURCE_TYPE ;
- INTERNAL indique que la ressource est interne et ne peut donc être accessible par l'application.

Dans le fichier programme C, avant d'utiliser un objet RESOURCE du fichier OIL, il faut le déclarer dans le fichier C. Pour cela, il faut appeler la fonction (ou service) suivante :

DeclareResource(une_ressource)

Plusieurs services sont offerts pour le traitement de l'objet RESOURCE. Ce sont :

1. Le service appelé dans le corps d'une tâche ou d'une ISR quelconque pour entrer dans la section critique dans l'objet une_ressource permet de mettre en place l'exclusion mutuelle :

StatusType GetResource(une_ressource)

2. Le service permettant à une tâche ou à une ISR de sortir de la section critique :

StatusType ReleaseResource(une_ressource)

L'exemple ci-dessous montre la mise en place dans le fichier C d'une exclusion mutuelle pour protéger une donnée partagée dans le corps de la tâche nom_tache :

typedef struct{
  float temperature ;
  float pression ;
}type_donnee_partagee ;

type_donnee_partagee donnee_partagee;  //variable globale dans le programme

TASK(nom_tache)
 {
	//...
	GetResource(une_ressource); 
	//section critique : utilisation de donnee_partagee
	ReleaseResource(une_ressource);
	//...
	TerminateTask();
 }

L'objet ISR est déclaré dans le fichier OIL de la façon suivante :

ISR traiteur_interruptions
 {
   CATEGORY = 2;
   PRIORITY = 7;
   //...
 };

L'attribut CATEGORY définit la catégorie de l'ISR. Il correspond à une variable de type UINT32 qui ne peut prendre que les valeurs 1 et 2. L'attribut PRIORITY est un entier qui indique la priorité (1 étant la plus petite) de l'ISR parmi les ISR définies dans l'application. Par ailleurs, une ISR peut utiliser d'autres objets tels que des RESOURCE, EVENT, MESSAGE, etc. Pour cela, ils doivent être déclarés à l'intérieur de ce dernier.

Dans le fichier programme C, une ISR est déclarée de la façon suivante :

ISR(traiteur_interruptions)
 {
  //..
 }

Plusieurs services sont offerts pour la gestion des ISR dans le système. Ce sont :

1. Le service appelé pour désactiver les interruptions masquables du système :

void DisableAllInterrupts(void)

2. Le service permettant de réactiver les interruptions désactivées par le service DisableAllInterrupts :

void EnableAllInterrupts(void)

3. Le service appelé pour désactiver les ISR de type 2 :

void SuspendOSInterrupts(void)

4. Le service permettant de réactiver les interruptions de type 2 mais aussi de type 1 :

void ResumeOSInterrupts(void)

Notons également qu'il existe aussi deux autres services que sont : SuspendAllInterrupts et ResumeAllInterrupts.

L'objet COUNTER est déclaré dans le fichier OIL de la façon suivante :

COUNTER nom_compteur
 {
   MINCYCLE = 1;
   MAXALLOWEDVALUE = 500000;
   TICKSPERBASE = 1;
 };

• L'attribut MINCYCLE de type UINT32, il permet de définir le nombre minimum de ticks (unité de temps de base de l'OS OSEK/VDX) obligatoire pour une alarme qui y est reliée ;
• L'attribut MAXALLOWEDVALUE, de type UINT32, il définit la valeur maximale du compteur ;
• L'attribut TICKSPERBASE de type UINT32, il définit le nombre de ticks d'horloge entre chaque comptage (dans l'exemple, on compte avec un pas de 1).

L'utilisation de l'objet COUNTER dans le fichier programme C est simple et ne nécessite que la fonction suivante :

DeclareCounter(nom_compteur)

L'objet ALARM est déclaré dans le fichier OIL de la façon suivante :

ALARM nom_alarme
 {
   COUNTER = nom_compteur; //le compteur doit avoir été défini
   ACTION = ACTIVATETASK
    {
     TASK = nom_tache; //la tâche doit avoir été définie
    };
   AUTOSTART = TRUE
    {
     ALARMTIME = 5;
     CYCLETIME = 9;
     APPMODE = appmode1;
    };
 };

Trois attributs sont importants à sa définition : COUNTER, ACTION et AUTOSTART.

- L'attribut COUNTER pour indiquer le compteur utilisé par l'alarme.

- L'attribut ACTION peut être utilisé pour réaliser trois opérations : la simple activation d'une tâche comme sur l'exemple précédent ; le déclenchement d'une tâche via la transmission d'un événement sur lequel elle attend. Dans ce cas, le code précédent traitant de l'action de l'alarme est remplacé par le suivant :

ACTION = SETEVENT
    {
     TASK = nom_tache; //la tâche qui attend sur l'événement. Doit déjà être définie
     EVENT = un_evt; //l'événement à transmettre. Doit déjà être défini
    };

L'attribut ACTION permet aussi d'appeler une routine de type alarm-callback. Nous n'entrons pas en détail pour ce cas.

- L'attribut AUTOSTART de type boolean permet de définir si l'alarme s'active ou non automatiquement au démarrage du système. Il prend donc les valeurs TRUE ou FALSE. Lorsque sa valeur est TRUE, il faut spécifier les paramètres suivants :

• ALARMTIME de type UINT32 qui représente la date au bout de laquelle l'alarme expirera pour la toute première fois ;
• CYCLETIME de type UINT32 qui représente la période de l'alarme si elle est cyclique (cas de l'exemple : 5 + 9; (5 + 9) + 9; ...) ;
• APPMOD la liste des modes dans lesquels le démarrage de l'alarme doit être effectué.

Dans le fichier programme C, un objet ALARM est préalablement déclaré avant toute utilisation via la fonction suivante :

DeclareAlarm(nom_alarme)

Plusieurs services sont offerts pour la gestion des ALARM dans le système. Ce sont :

1. Le service appelé pour mettre dans la variable info les informations sur l'alarme nommée nom_alarm :

StatusType GetAlarmBase(nom_alarme, info)

2. Le service appelé pour mettre dans la variable nombre_ticks_restant le nombre de ticks restants avant l'expiration de l'alarme nommée nom_alarm :

StatusType GetAlarm(nom_alarme, nombre_ticks_restant)

3. Le service permettant de configurer l'alarme nommée nom_alarme pour qu'elle expire au bout d'un certaine temps. La variable nombre_ticks correspond à son nombre relatif de ticks pour faire un cycle. Si l'alarme est cyclique/périodique, alors sa période est indiquée dans la variable temps_cycle. Cette dernière vaut zéro si l'alarme n'est pas cyclique :

StatusType GetAlarm(nom_alarme, nombre_ticks, temps_cycle)

4. Le service permettant de configurer l'alarme nommée nom_alarme pour qu'elle expire à une date donnée. La variable nombre_ticks correspond à son nombre absolu de ticks pour faire un cycle. Si l'alarme est cyclique/périodique, alors sa période est indiquée dans la variable temps_cycle. Cette dernière vaut zéro si l'alarme n'est pas cyclique :

StatusType GetAlarm(nom_alarme, nombre_ticks, temps_cycle)

Un exemple de déclaration de l'objet OS dans le fichier OIL est la suivante :

OS nom_OS
  {
    STATUS = EXTENDED;
    STARTUPHOOK = FALSE;
    ERRORHOOK = FALSE;
    SHUTDOWNHOOK = FALSE;
    PRETASKHOOK = FALSE;
    POSTTASKHOOK = FALSE;
    USEGETSERVICEID = FALSE;
    USEPARAMETERACCESS = FALSE;
    USERESSCHEDULER = FALSE;
  };

Comme vous l'avez constaté, tous les attributs définis dans l'objet OS sont de type booléen à l'exception de l'attribut STATUS.

• STATUS de type ENUM, il permet de spécifier le mode de fonctionnement du système (standard ou étendu). Il prend les valeurs STANDARD ou EXTENDED ;
• STARTUPHOOK, permet de spécifier si l'application se lance exactement à la fin de l'initialisation du système d'exploitation et avant le début d'exécution de l'ordonnanceur ;
• ERRORHOOK, permet de spécifier si le système d'exploitation prend la main à la fin de l'exécution de tout service pour savoir s'il s'est bien exécuté ou pas ;
• SHUTDOWNHOOK, permet de spécifier si le système d'exploitation s'arrête à la fin de l'application ;
• PRETASKHOOK, traite du changement de contexte des tâches. Il permet de spécifier si le système d'exploitation prend la main juste avant que le processeur soit donné à une tâche, pour contrôler son état ;
• POSTTASKHOOK, traite du changement de contexte des tâches. Il permet de spécifier si le système d'exploitation prend la main juste après que le processeur soit retiré à la tâche en cours d'exécution, pour contrôler son état ;
• USEGETSERVICEID et USEPARAMETERACCESS, sont liés à ERRORHOOK. Ils permettent de spécifier si l'on autorise l'accès à certaines informations ;
• USERESSCHEDULER, permet de spécifier si la ressource RES_SCHEDULER (l'ordonnanceur du système d'exploitation) est utilisée par l'application comme une ressource ordinaire.

La déclaration de l'objet CPU dans le fichier OIL est la suivante :

CPU nom_du_cpu
  {
    //ici la description OIL de tous les objets OSEK/VDX dont utilise
   //l'application embarquée
  };

Il est possible de développer un programme embarqué conforme à OSEK/VDX, tant sur Linux que sur Windows. Nous nous focalisons ici sur le cas de Windows. La mise en place de la plateforme de développement OSEK/VDX sur Windows nécessite trois technologies :

• Cygwin : c'est un outil qui permet d'émuler certaines fonctionnalités de Linux sur le système d'exploitation Windows ;
• GNU ARM : c'est une distribution du compilateur GCC (GNU Compiler Collection) permettant de compiler du code destiné à s'exécuter sur des microcontrôleurs de type ARM. Il supporte ainsi le microcontrôleur ARM7 dont dispose le robot Lego NXT ;
• nxtOSEK : c'est le système d'exploitation conforme à OSEK/VDX s'exécutant sur le robot Lego NXT et qui est nécessaire dans la phase de compilation du code sur la machine hôte de développement.

La procédure d'installation de la plateforme de développement de programmes basés sur OSEK/VDX sur Windows est décrite sur le lien suivant : http://lejos-osek.sourceforge.net/installation_windows.htm.installation de nxtOSEK sur windows
Nous résumons ici en français cette procédure d'installation :

• Téléchargez la dernière version de Cygwin iciTéléchargez Cygwin et installez le (par exemple dans le répertoire C:\cygwin). Pendant la phase d'installation de Cygwin, en vous servant des captures d'écran présentées dans le lien d'installation d'origine, choisissez la version la plus récente de make (version supérieure ou égale à la 3.8) ainsi que les bibliothèques libintl1 à libintl8 et libncurves7 à libncurves10 ;
• Téléchargez la dernière version de l'installateur (le .exe) de GNUARM ici et installez-le (par exemple dans le répertoire C:\GNUARM). Pendant la phase d'installation de GNUARM, en vous servant des captures d'écran présentées dans le lien d'installation d'origine, décochez l'installation de FPU (Floating Point Unit) et Big Endian, car le processeur ARM7 du robot Lego n'en a pas besoin. Dans la fenêtre suivante, GNUARM vous proposera d'installer une nouvelle fois Cygwin, décochez cette case, car vous l'avez déjà installé ;
• Téléchargez iciTéléchargez les pilotes du robot Lego NXT le fichier compressé permettant d'installer sur votre machine les pilotes du robot Lego NXT. Ces pilotes sont nécessaires dans la phase de compilation sur votre machine. Dézippez-le dans un répertoire de votre choix (sur ma machine, je l'ai fait dans E:\OSEK). Puis vous rendre dans le répertoire suivant E:\OSEK\NXT Fantom Drivers\Windows\1.2\1.2.0\Products. En fonction que votre machine est une 32 ou une 64 bits, choisissez le bon setup d'installation des pilotes dans ce répertoire et exécutez le ;
• Lorsque le codage de votre application sera terminé sur votre machine de développement, vous aurez besoin de le flasher sur le robot pour qu'il puisse l'exécuter. C'est l'outil NXTTool qui gère cette opération de transfert de code vers le robot. Téléchargez iciTéléchargez NXTTool le fichier compressé de NXTTool et dézippez-le dans le répertoire d'installation de Cygwin (exemple C:\cygwin\nxttool) ;
• Pour que NXTTool fonctionne correctement, il a besoin du firmware NXT. Téléchargez iciTéléchargez le firmware NXT le fichier compressé du firmware NXT. Dézippez-le dans un répertoire de votre choix et copiez son contenu (constitué des fichiers d'extension .rfw) dans le répertoire d'installation de NXTTool (exemple C:\cygwin\nxttool) ;
• Il reste maintenant à installer nxtOSEK. Téléchargez iciTélechargez nxtOSEK le fichier compressé d'nxtOSEK et dézippez-le dans le répertoire d'installation de Cygwin (exemple C:\cygwin\nxtOSEK). Dans les dernières versions de nxtOSEK (par exemple le nxtOSEK 2.18), les auteurs ont décidé de ne plus le livrer avec le fichier exécutable sg.exe qui doit normalement se situer dans le répertoire \nxtOSEK\toppers_osek\sg. Cet exécutable joue un rôle important, car il permet de parser et de générer le code cible destiné au robot. Pour rajouter sg.exe dans le répertoire d'installation de nxtOSEK (C:\nxtOSEK\toppers_osek\sg) sur votre machine, téléchargez le fichier compressé osek_os-1.1.lzh ici. Dézippez le dans un répertoire de votre choix, copiez le fichier sg.exe et collez le dans votre répertoire C:\nxtOSEK\toppers_osek\sg.
• Pour flasher effectivement votre code sur le robot NXT, vous aurez besoin d'un câble USB à brancher entre votre machine et le robot. Pour faire que votre machine puisse reconnaître le robot NXT (à l'autre bout du câble USB) comme un périphérique externe (un peu comme une clé USB), vous devez installer l'outil libusb dont le setup se trouve dans le répertoire d'installation de nxtOSEK (exemple : C:\cygwin\nxtOSEK\lejos_nxj\3rdparty\lib).

Les opérations ci-dessus vous ont permis d'installer tous les logiciels qu'il faut pour compiler vos programmes et pouvoir les flasher sur le robot, mais ce n'est pas terminé. Pour que tout fonctionne correctement, rendez-vous dans le dossier ecrobot (situé dans le répertoire C:\cygwin\nxtOSEK), ouvrez (par exemple avec notePad++) le fichier tool_gcc.mak et renseignez les chemins d'installation de GNUARM et NXTTool, respectivement dans les variables GNUARM_ROOT et NXTTOOL_ROOT (exemple : GNUARM_ROOT=C:/GNUARM et NXTTOOL_ROOT=C:/cygwin/nexttool). Ces répertoires sont nécessaires pendant la phase de compilation.

Dans le dossier sample_c appartenant au répertoire d'installation de nxtOSEK (C:\cygwin\nxtOSEK\sample_c), il existe plusieurs programmes exemples que vous pouvez compiler pour tester votre installation complète de la plateforme. Si vous choisissez le programme helloworld par exemple, démarrez le terminal de Cygwin. Dans ce terminal, saisissez la commande cd C:/cygwin/nxtOSEK/samples_c/helloworld pour vous déplacer dans le répertoire helloworld. Puis saisissez la commande make all pour compiler le programme exemple helloworld. Si la compilation se déroule bien, c'est que votre installation de la plateforme de développement OSEK/VDX s'est bien passée. Vous pouvez ainsi commencer le codage de vos propres programmes embarqués.

Après avoir installé toute la plateforme de développement ci-dessus, vous pouvez coder vos applications via un EDI (Environnement de Développement Intégré) tel que Eclipse CDT. Avec Eclipse : vous bénéficiez de la coloration de code qui vous aidera à rapidement détecter des erreurs ; vous disposez de la possibilité de compiler et de déboguer votre code en un clic, ce qui vous affranchit des commandes à connaître et à saisir dans le terminal de Cygwin pour effectuer le même traitement ; vous disposez enfin de la possibilité de configurer le flashage de votre code sur le robot afin de rendre ce processus beaucoup plus simple que les commandes à saisir dans le terminal de Cygwin. Le lien suivant http://lejos-osek.sourceforge.net/eclipse.htm vous décrit la procédure à suivre pour l'installation d'Eclipse CDT et sa configuration. Cette procédure d'installation et de configuration d'Eclipse CDT est simple et nous ne la redécrivons pas ici. Par contre, l'étape 1 peut être omise dans cette procédure si vous téléchargez directement Eclipse dédié au développement C/C++ nommé Eclipse IDE for C/C++ DevelopersTéléchargez Eclipse pour le C/C++.

Étant donné que l'application est composée de deux tâches, il faut bien entendu les déclarer dans le fichier OIL. Ces dernières accèdent à une même donnée. Un accès en exclusion mutuelle est alors nécessaire pour garder sa cohérence, d'où le besoin de l'objet RESOURCE. De même les tâches acquerir_ultrason et rouler doivent se réveiller de manière périodique pour respectivement écrire et lire la donnée informant de la présence d'un obstacle ou non. D'où le besoin des objets COUNTER et ALARM pour réaliser la périodicité. Notons qu'au démarrage de l'application, c'est l'alarme qui doit déclencher les tâches.

Le fichier OIL de l'application est le suivant :

#include "implementation.oil"

CPU ATMEL_AT91SAM7S256
{
  OS LEJOS_OSEK
  {
    STATUS = EXTENDED;
    STARTUPHOOK = FALSE;
    ERRORHOOK = FALSE;
    SHUTDOWNHOOK = FALSE;
    PRETASKHOOK = FALSE;
    POSTTASKHOOK = FALSE;
    USEGETSERVICEID = FALSE;
    USEPARAMETERACCESS = FALSE;
    USERESSCHEDULER = FALSE;
  };

  // Définition du mode de l'application
  APPMODE appmode1{}; 

  // Définition de la tâche acquerir_ultrason 
  TASK acquerir_ultrason
  {
    AUTOSTART = FALSE;
    PRIORITY = 2; 
    ACTIVATION = 1;
    SCHEDULE = FULL;
    STACKSIZE = 512;
    RESOURCE = obstacle;
  };
  
  // Définition de la tâche rouler 
  TASK rouler
  {
    AUTOSTART = FALSE;
    PRIORITY = 1; 
    ACTIVATION = 1;
    SCHEDULE = FULL;
    STACKSIZE = 512;
    RESOURCE = obstacle;
  };
  
  // Définition de la ressource pour l'exclusion mutuelle 
  RESOURCE obstacle
  {
    RESOURCEPROPERTY = STANDARD;
  };
  
  // Définition du compteur utilisé par l'alarme 
  COUNTER compteur
  {
    MINCYCLE = 1;
    MAXALLOWEDVALUE = 100000;
    TICKSPERBASE = 1;
  };
  
  // Définition de l'alarme périodique utilisée pour réveiller la tâche acquerir_ultrason 
  ALARM alarme_reveil_acquerirUltrason
  {
    COUNTER = compteur;
    ACTION = ACTIVATETASK
    {
     TASK = acquerir_ultrason;
    };
    AUTOSTART = TRUE
    {
     ALARMTIME = 10;
     CYCLETIME = 10;
     APPMODE = appmode1;
    };
   
  };
  
  // Définition de l'alarme périodique utilisée pour réveiller la tâche rouler 
  ALARM alarme_reveil_rouler
  {
    COUNTER = compteur;
    ACTION = ACTIVATETASK
    {
     TASK = rouler;
    };
    AUTOSTART = TRUE
    {
     ALARMTIME = 10;
     CYCLETIME = 10;
     APPMODE = appmode1;
    };
   
  };
  
};

Ci-dessous le code C de l'application. Il est important de se référer à l'API du robot NXT pour comprendre certaines fonctions utilisées dans le programme.

#include "kernel.h"
#include "kernel_id.h"
#include "ecrobot_interface.h"

DeclareResource(obstacle);
DeclareTask(acquerir_ultrason);
DeclareTask(rouler);
DeclareCounter(compteur);
DeclareAlarm(alarme_reveil_acquerirUltrason);
DeclareAlarm(alarme_reveil_rouler);

//structure de donnée informant de l'existence ou non d'un obstacle
typedef struct{
  int obstacleEnVue; // vaut 1 si obstacle et 0 sinon
}type_Obstacle;

//routine de traitement d'interruption nxtOSEK de type 2,
//elle est fournie par l'API du robot et doit figurer dans
//la liste des fonctions du programme
void user_1ms_isr_type2(void){
    StatusType ercd;
  // Increment System Timer Count 
  ercd = SignalCounter(compteur);
  if(ercd != E_OK){
    ShutdownOS(ercd);
  }
}

//fonction d'initialisation des pilotes de matériels utilisés par le robot
//dans l'application. Elle est fournie par l'API du robot et doit obligatoirement
//figurer dans la liste des fonctions du programme
void ecrobot_device_initialize(void){
  // Initialize ECRobot used devices 
  ecrobot_init_sonar_sensor(NXT_PORT_S1);
}

//déclaration de la variable globale partagée par les deux tâches
type_Obstacle donneeObstacle;

//corps de la tâche acquerir_ultrason
TASK(acquerir_ultrason){
  int distance = ecrobot_get_sonar_sensor(NXT_PORT_S1);
  GetResource(obstacle);
  if(distance > 20){
    donneeObstacle.obstacleEnVue = 0;
  }else{
    donneeObstacle.obstacleEnVue = 1;
  }
  ReleaseResource(obstacle);
  TerminateTask();
}

//corps de la tâche rouler
TASK(rouler){
  int vitesseDeplacementRobot = 70;
  int angleRotationRobot = 45;
  int obs = 0;
  GetResource(obstacle);
  obs = donneeObstacle.obstacleEnVue;
  ReleaseResource(obstacle);
  if(obs == 0){
    //commander les deux roues du robot à rouler :
    nxt_motor_set_speed(NXT_PORT_A, vitesseDeplacementRobot, 0);
    nxt_motor_set_speed(NXT_PORT_B, vitesseDeplacementRobot, 0);
  }else{
    //commander les roues du robot à tourner :
    nxt_motor_set_speed(NXT_PORT_A, vitesseDeplacementRobot - 30, 1); //freiner en réduisant de 30 la vitesse de la 1ère roue du robot
    nxt_motor_set_speed(NXT_PORT_B, -40, 1); //freiner en essayant d'imobiliser (vitesse négative) la 2ème roue, pour permettre au robot de pivoter
    nxt_motor_set_count(NXT_PORT_A, angleRotationRobot);
  }
  TerminateTask();
}