Systmes d'exploitation temps rel et multitches

Description gnrale
- Date du TP : llime semaine; - Dure du TP : 4,5 h (3 semaines) ; - Matriels ncessaires : Carte d'exprimentation, microcontrleur PIC 18f, programmateur, des composants lectroniques, plaque d'essai ; - Logiciels utiliss : RTOS, Complilateur C PCW, Simulateur ISIS, IC Writer ; - Public cible : 4ime niveau d'tudes de technicien suprieur en informatique industrielle ; - Partie du cours en rapport avec le TP : Classification logicielle des systmes temps rel, systmes multitches.

Objectifs
- Explorer les bases des systmes embarqus multitches ; - Apprendre les systmes d'exploitation temps rel RTOS ; - Assimiler les notions par un exemple d'un RTOS utilis dans des projets simples ; - Approfondir les acquis en programmation C des microcontrleurs PIC ; - Matrise des architectures des microcontrleurs Microchip PIC18.

Pr requis
Notions gnrales sur : - Systme d'exploitation ; - L'lectronique; - Algorithmique; - Programmation en C ; - Les microcontrleurs.

introduction

Maintenant, presque tous les systmes bass sur des microcontrleurs excutent plus qu'une activit. Par exemple, un systme qui contrle une temprature est compos de trois tches qu'ils se rptent aprs un court dlai, savoir : - Tche 1 : lire la temprature ; - Tche 2 : changer le format de la temprature - Tche 3 :amchage de la temprature On signale que la plus part des systmes complexes peuvent avoir plusieurs tches complexes. Dans un systme multitches, nombreuses tches ncessitent le CPU au mme temps, mais la on dispose seulement d'un seul CPU on a donc besoin de quelques formes d'organisation et de coordination qui permettent chaque tche d'avoir le temps de CPU qu'elle a besoin. Dans la pratique, chaque tche prend un temps trs bref, il parat donc comme si toutes les tches sont excutes en parallle et simultanment. Presque tous les systmes bass sur des microcontrleurs travaillent en temps rel. Un systme temps rel est un systme sensible au temps qui peut rpondre son environnement dans le temps le plus court possible. Le temps rel ne veut pas dire ncessairement que le microcontrleur devrait oprer haute vitesse. Ce qui est important dans un systme temps rel c'est qu'il doit avoir un temps de rponse rapide, bien qu'une haute vitesse puisse aider. Par exemple, on attend d'un systme temps rel bas sur des microcontrleurs et qui a plusieurs interrupteurs externes de rpondre immdiatement quand un interrupteur est activ ou lorsqu'un autre vnement se produit. Un systme d'exploitation temps rel (RTOS) est un code qui contrle l'allocation des tches quand le microcontrleur opre dans un environnement multitches. Par exemple un STR dcide quelle est la tche suivante qui sera excute ou comment coordonner la priorit des tches, et comment passer les donnes et les messages entre les tches. Cette partie explore les principales bases des systmes embarqus multitches et donne des exemples d'un STR utilis dans des projets simples. Le code des STR multitches sont des sujets compliqus et larges, et ce cours dcrit des concepts qui concernent ces derniers seulement brivement. Les lecteurs intresss devraient faire rfrence aux

nombreux livres et papiers disponibles sur les systmes d'exploitation, les systmes multitches, et les STR. Il y aplusieurs systmes STR disponibles sur le march pour les PIC microcontrleurs. Les plus connus des systmes STR de haut niveau pour les PIC sont Salvo (www.pumpkin.com), ce dernier peut tre utilis partir d'un compilateur C de PIC :High-tech, et le CCS (Custom Computer Services) qui intgrent des systmes RTOS. Dans cette partie, les exemples des projets STR sont bass sur le compilateur CCS (www.ccsinfo.com), qui est un des compilateurs PIC C les plus utiliss qui est dvelopp pour les sries des microcontrleurs : PIC16 et PIC18.

Machines d'tat

Les machines d'tat sont des constructions simples utilises pour excuter plusieurs activits, gnralement en suivant une squence .On remarque plusieurs systmes temps rel qui appartiennent cette catgorie. Par exemple, l'opration d'une machine laver ou d'un lave-vaisselle est dcrite simplement avec une instruction des Machines d'tat. Peut-tre la mthode la plus simple de construire des machines d'tat dans le C est d'utiliser une instruction switch-case. Par exemple, notre systme qui contrle la temprature est compos de trois tches nommes : Tche 1, Tche 2, et Tche 3, comme il est montr dans la figure 1.

Figure 1 Implmentation de la machine d'tat

for(;;) { state = 1 ; switch (state) { CASE 1: implement TASK 1 state++; break; CASE 2: implement TASK 2 state++; break; CASE 3: implement TASK 3 state = 1 ; break; } Delayms(n); }
Figure 2 Implmentation en C de la machine d'tat

La figure 2 montre les machines de l'tat ralise suivant les trois tches et qui utilisent des switch-case . L'tat initial est 1, et chaque tche incremente le nombre de l'tat pour slectionner l'tat suivant qui sera excut. Le dernier tat slectionne l'tat 1, et il y a un dlai la fin de switch-case. La construction de l'tat de la machine est excute de faon continue dans une boucle sans fin. Dans plusieurs applications, les tats n'ont pas besoin tre excuts en squence. Plutt, le prochain tat est slectionn par l'tat prsent soit directement soit suivant quelques conditions. Cela est montr dans la figure 3. for(;;) { state = 1 ; switch (state) { CASE 1: implement TASK 1 state = 2; break; CASE 2: implement TASK 2 state = 3; break; CASE 3: implement TASK 3 state = 1 ; break; } Delay_ms(n); }

Figure 3 Slection du prochain tat partir de l'tat courant La machines d'tat, bien qu'elle soit facile implmenter, elle est primitive et elle a des applications limites. Ils peuvent tre utiliss seulement dans les systmes qui ne sont pas vraiment sensibles, o les activits de la tche sont prcis et sans priorit. De plus, quelques tches peuvent tre plus importantes qu'autres. Nous pouvons vouloir que quelques tches s'excutent toutes les fois qu'ils deviennent ligibles.

3 Le systme d'exploitation Temps rel (RTOS)

Les RTOS (Real Time Operating System) sont construits autour d'un noyau multitche qui contrle l'allocation de laps du temps des tches. Un laps du temps est la priode de temps pour l'excution d'une tche donne avant qu'elle sera arrte et remplac par une autre tche. Ce processus est connu par le changement de contexte, qui se rpte de faon continue. Quand le changement du contexte se produit, la tche est stoppe, les

registres du processeur sont sauvegards dans la mmoire, les registres du processeur de la prochaine tche disponible sont chargs dans le CPU et la nouvelle tche commence sa excution. Un RTOS fournit aussi les messages qui passent entre les tches, synchronisation des tches et allocation de ressources partages aux tches. Les parties de base d'un RTOS sont : - l'ordonnanceur (Scheduler) ; - services RTOS ; - Synchronisation et outils de la messagerie ;

3.1

L'ordonnanceur (The Scheduler)

L'ordonnanceur est au noyau de chaque RTOS, car il fournit les algorithmes pour choisir les tches pour l'excution. Trois types d'algorithmes d'ordonnancement existent : - Ordonnancement coopratif - Ordonnancement en anneau jetons - Ordonnancement premptif Lordonnancement coopratif est l'algorithme d'ordonnancement le plus simple et disponible. Chaque tche s'excute jusqu' ce qu'elle soit termine et renonce l'unit centrale de traitement CPU volontairement. L'ordonnancement coopratif ne peut pas satisfaire aux besoins du systme temps rel, puisqu'elle ne peut pas soutenir la priorit des tches selon l'importance. En outre, une tche simple peut utiliser l'unit centrale de traitement trop longue, tout en laissant un peu de temps pour les autres tches. L'ordonnanceur ne peut pas contrler les diverses temps d'excution des tches. Une construction de machine d'tat est une forme simple d'une technique d'ordonnancement cooprative. Dans l'ordonnanceur en anneau jetons, chaque tche est assigne une part de temps gale du CPU (voir La figure 4). Un compteur donne une tranche de temps pour chaque tche. Quand une tranche du temps de la tche accomplit, le compteur est mis zros et la tche est place la fin du cycle. Et de nouveau, des tches supplmentaires sont places la fin du cycle avec leurs compteurs mis zros. Ceci, comme l'ordonnanceur coopratif, n'est pas trs utile dans un systme en temps rel, car trs souvent certains tches prennent seulement quelques millisecondes tandis que d'autres exigent des centaines de millisecondes ou plus.

Figure 3 lordonnancement en anneau jetons

L'ordonnanceur premptif est considr comme un algorithme d'ordonnancement en temps rel. Il est bas sur la priorit, pour chaque tche est accorde une priorit (voir la figure 5). La tche avec la plus

haute priorit obtient le temps de CPU et elle se met en excution. Les systmes temps rel soutiennent gnralement des niveaux de priorit de 0 255, o 0 est la priorit la plus leve et 255 est la plus bas.

Figure 4 Ordonnancement premptif

L'ordonnanceur premptif est combin l'ordonnanceur en anneau jeton. Dans ce cas, les tches haute priorit s'excutent avant ceux qui possdent une faible priorit, par contre les tches au mme niveau prioritaire s'excutent par l'ordonnanceur en anneau jeton. Si une tche est prempte par une tche plus prioritaire, le compteur de temps est sauvegard puis restaurer quand il regagne le contrle de CPU. Dans un systme en temps rel, une tche peut tre dans les tats suivants (voir la figure 6) : - Prt - En excution - Bloqu

Figure 5 les tats dune tache

Quand une tche est d'abord cre, elle est habituellement l'tat prt et elle entre dans la liste des tches. De cet tat, selon l'algorithme d'ordonnancement, la tche peut devenir en excution. Une tche en excution devient une tche bloque si elle a besoin d'une ressource qui

n'est pas disponible. Par exemple, une tche peut avoir besoin des donnes d'un convertisseur A/D alors elle sera bloqu jusqu' ce qu'elle les reoit. Une fois que la ressource peut tre accde, la tche bloque devient une tche en excution si elle est la plus prioritaire dans le systme, si elle n'est pas prioritaire alors elle se dplace l'tat prt. Seulement une tche en excution peut tre bloque. Une tche prte ne peut pas tre bloque. Quand une tche se dplace d'un tat l'autre, le processeur sauve le contexte de la tche courante dans la mmoire, charges le contexte de la nouvelle tche de la mmoire et excute alors les nouvelles instructions. Le noyau temps rel fournit habituellement une interface pour raliser des oprations sur la tche. Les oprations typiques sur une tche sont :

Cration de la tche ; Suppression d'une tche ; Changement de la priorit d'une tche ; Changement de l'tat d'une tche. 3.2 Services de RTOS

Les services de RTOS sont utilits par le noyau pour crer les tches efficacement. Par exemple, une tche peut employer des services de temps pour obtenir la date du jour et l'heure. Certains de ces services sont : - Services manipulant les interruptions ; - Services de temps ; - Services de gestion du matriel ; - Services de gestion de mmoire ; - Services d'entre-sortie

3.3 Outils de synchronisation et de transmission de messages

Les outils de synchronisation et de transmission de messages sont construits par le noyau, ils aident dvelopper et crer des applications en temps rel. Certains de ces services sont : - Smaphores - Drapeaux d'vnement - Botes aux lettres - Pipes Files d'attente de message Les smaphores sont utiliss pour synchroniser l'accs aux ressources partages, telles que des secteurs de donnes communs. Des drapeaux d'vnement sont employs pour synchroniser les activits entre Tches. Botes aux lettres, pipes, et les files d'attente des messages sont employes pour envoyer des messages entre les tches.

Compilateur C de CCS et RTOS

La langue de CCS fournit les fonctions suivantes de RTOS ainsi que les fonctions normales e n C : - rtos_run() : initialise l'opration de RTOS. Toutes les oprations de contrle des tches sont mis en application aprs avoir appel cette fonction. - rtos_terminate() termine l'opration de RTOS. Contrle les retours au programme original sans RTOS. En faite, cette fonction est comme un retour de rtos_run (). - rtos_enable() reoit le nom d'une tche comme argument. Cette fonction active la tche et la fonction rtos_run() peut appeler la tche quand son temps est d. - rtos_disable() reoit le nom d'une tche comme argument. Cette fonction dsactive la tche ainsi elle ne sera plus appeler par le rtos_run() moins qu'elle soit appel nouveau en appelant rtos_enable(). - rtos_yield(), une fois appel en dedans d'une tche, elle retourne le contrle au dispat-cheur. Tous les tches devraient appeler cette fonction pour librer le processeur ainsi d'autres tches peuvent utiliser le temps de processeur. - rtos_msg_jsend() reoit un nom de tche et un octet comme arguments. La fonction envoie l'octet la tche indique, o elle est place dans la file d'attente de message de la tche. - rtos_msg_read() lit l'octet situ dans la file d'attente de message de la tche. - rtos_msg_ poll() retourne vrai s'il y a des donnes dans la file d'attente de message de la tche. Cette fonction devrait s'appeler avant de lire l'octet de la file d'attente de message de la tche. - rtos.jsignal0 reoit le nom de smaphore et incremente cette smaphore. - rtos_wait() reoit un nom de smaphore et attend la ressource lie au smaphore devenir disponible. Le compteur de smaphore est alors ainsi dcrment la tche peut rclamer la ressource. - rtos_await() reoit une expression comme argument, et la tche attend jusqu' l'expression soit vrai. - rtos_overrun () reoit un nom de tche comme argument, et la fonction renvoie vrai si cette tche a dbord son temps assign. - rtos_stats () retourne les statistiques d'une tche indique. Les statistiques peuvent tre les temps minimum et maximum d'excution de la tche et tout le temps d'excution de la tche. Le nom de tche et le type de statistiques sont indiqus comme arguments la fonction.

Prparation de RTOS

En plus des fonctions prcdentes, la commande de prprocesseur #use rtos() doit tre indiqu au dbut du programme avant d'appeler n'importe quel fonction de l'RTOS. Le format de cette commande de prprocesseur est : #use rtos(timer=n, minor_cycle=m) o le timer est entre 0 et 4 et spcifie au processeur le timer qui sera employ par le RTOS et le minor_cycle est le plus long temps d'excution de n'importe quelle tche. Le nombre crit ici doit tre suivi de s, ms, us ou de ns.

Dclaration d'une tche

Une tche est juste dclare comme n'importe quelle autre fonction de C, mais la tche dans une application multitche n'a aucun argument et ne retourne aucune valeur. Avant qu'une tche soit dclare, a la commande de prprocesseur #task est ncessaire pour indiquer les options de la tche. Le format de cette commande de prprocesseur est : #task(rate=n, max=m, queue=p) o le paramtre rate indique combien de fois la tche devrait s'appeler. Le nombre indiqu doit tre suivi par s, ms, us ou de ns. Le paramtre max indique combien de temps de processeur occup par tche lors de son excution. Le temps spcifi ici doit tre moins ou gal au temps indiqu par le minor_cycle. Le paramtre queue est optionnel, et il indique nombre d'octets rserver pour la tche pour recevoir des messages d'autres tches. La valeur par dfaut est 0. Dans l'exemple suivant, une tche appele my_ticks est appel chaque 20ms et elle n'emploie pas plus que 100ms de temps de processeur. Cette tche est indique sans l'option de queue : #task(rate=20ms, max= 100ms) void my_ticks()

{ }

Exemple d'application

Dans le projet suivant, bas sur 1' RTOS, quatre LED sont relies la moiti infrieure de PORTB d'un microcontrleur de type PIC18F452.ce programme se compose de quatre tches, o chaque tche clignote une LED diffrents frquence : - La tche 1, appele le task_B0, clignote la LED relie au port RB0 un taux de 250ms. - la tche 2 de, appele le task_Bl, clignote la LED relie au port RB1 un taux de 500ms. - La tche 3, appele le task_B2, clignote la LED relie au port RB2 une fois par une seconde. - La tche 4, appele le task_B3, clignote la LED relie au port RB3 une fois toutes les deux secondes.

La figure 7 montre le schma de circuit du projet. Un cristal 4MHz est employ comme horloge. Les pins RB0-RB3 de PORTB sont relies aux LED par les rsistances de protection.

Figure 6- montage

Le logiciel est bas sur le compilateur C de CCS, et le programme est donn dans listing 7. Dans le programme principale, les pins du PORTB sont dclares comme des sorties et le RTOS est excut en appelant la fonction rtos_run (). Le chemin du fichier de dclaration de CCS RTOS devrait tre inclus au dbut de le programme. La commande de prprocesseur # use delay dit au compilateur que nous employons une horloge 4MHz. Le Timer de RTOS est dclar comme Timer 0 et le temps de minor_cycle est dclarer 10ms en utilisant la commande de prprocesseur #use rtos. Le programme se compose de quatre tches semblables : - La tche task_B0 clignote la LED relie RBO un taux de 250ms, la LED est allume pendant 250ms, puis teinte pendant 250ms, et ainsi de suite. La fonction output-toggle est utilis pour changer l'tat de la LED chaque fois que la tche s'appelle. Dans le compilateur CCS, PIN_B0 se rfre la pin RBO du microcontrleur. - La tche task_Bl clignote la LED relie RB1 un taux de 500ms. - La tche task_B2 clignote la LED relie RB2 chaque seconde.

- Finalement, la tche task_B3 clignote la LED relie RB3 toutes les deux secondes Le programme donn sur le listing xxx est un programme multitche o les LED clignotent indpendamment les uns des autres et concurremment.

Travail demand
1. Lire la partie thorique pour bien assimiler les notions thoriques sur l'RTOS. 2. Commenter le listing. 3. Compiler le programme avec PCW par la suite vrifier son bon fonctionnement l'aide de la simulation par ISIS. 4. Cbler le schma sur une plaque d'essai puis programmer le microcontrleur.

#include <rtos.h> #use delay (clock=4000000) // // Define which timer to use and minorcycle for RTOS // #use rtos(timer=0, minor_cycle=10ms) // // Declare TASK 1 - called every 250ms // #task(rate=250ms, max=10ms) void task_B0() { outputtoggle(PINBO); // Toggle RBO } // // Declare TASK 2 - called every 500ms // #task(rate=500ms, max=10ms) voidtask_Bl() { outputtoggle(PINBl); // Toggle RBI } // // Declare TASK 3 - called every second // #task(rate=ls, max=10ms) void task_B2() { output_toggle(PIN_B2); // Toggle RB2 }

// // Declare TASK 4 - called every 2 seconds // #task(rate=2s, max=10ms) void task_B3() { output_toggle(PIN_B3); // Toggle RB3 } // // Start of MAIN program // void main() { settrisb(O); // Configure PORTB as outputs rtos_run(); // Start RTOS
}^