Vous êtes sur la page 1sur 19

Chapitre 2: Le noyau temps réels µc/OSII

I. Introduction
Une application temps réel est en général conçue comme un ensemble
d’activités, appelées tâches, supposées s’exécuter en parallèle et coopérant
à la réalisation de l’application.
l’application Cette conception de l’application sous forme
parallèle pose bien sûr le problème de son exécution sur des machines qui,
pour les plus simples, sont monoprocesseur et ne peuvent donc offrir qu’une
exécution séquentielle. De ce point de vue, l’exécutif temps réel est donc un
logiciel qui présente à l’application une machine virtuelle supposée capable
d’exécuter en parallèle les tâches coopérantes de l’application.

12/09/2019 1
II. Tâche

Une tâche est un mode opératoire capable de générer une action. La tâche
est l’agent actif de l’application. C’est une portion de code séquentiel
correspondant souvent à la notion de procédure (ou fonction) dans le langage
de programmation utilisé pour coder l’application.
En pratique, une tâche est un programme écrit de telle sorte qu’il puisse
s’insérer dans le mécanisme de gestion du noyau temps réel.
Le modèle d’écriture d’une tâche est le suivant :

12/09/2019 2
II.1 Contexte d’une tâche

Le contexte d’une tâche est l’ensemble des informations dont un processeur a besoin
pour démarrer ou reprendre l’exécution d’un programme. L’opération qui consiste à
sauvegarder dans la pile courante le contexte d’une tâche, à recharger le contexte d’une
nouvelle tâche s’appelle une commutation de contexte. La primitive système qui
s’occupe de cette opération s’appelle l’ordonnanceur

II.2 « Tib » Task Informations Block


Priorité :
En plus du contexte, on associe à une tâche sa priorité par rapport aux autres tâches du
système. Dans beaucoup de noyau temps réel, cette priorité est un nombre entier Positif
compris entre 0 et 255.
Tib :
Le bloc d’information d’une tâche est une zône mémoire ou on a regroupé la priorité et
le contexte complet de la tâche. Il y’a donc un tib par tâche.
12/09/2019 3
II.3 Les états d’une tâche

La tâche étant un agent actif, il est naturel de lui associer un diagramme


d’état qui représente l’ensemble de ses états possibles ainsi que les
conditions associées aux transitions d’états.

12/09/2019 4
L’état non activable ou non opérationnel :
Le code et les données de la tâche sont résidents en mémoire. La tâche a donc
été créée, mais elle ne sollicite pas le processeur. Elle ne peut pas être prise en
charge par le noyau temps réel ; elle ne possède pas de tib.

L’état activable ou prêt :


Si par exemple, la tâche a subi une primitive de type OSTaskCreate ; un tib a
été créé et initialisé avec la priorité 2. Ce tib a été ensuite inséré dans la liste
des tibs des tâches activables, encore appelée « liste d’exécution ».

L’état en attente :
Lorsque l’on crée une nouvelle tâche, si les ressources nécessaires à
l’exécution de cette tâche sont occupées, on peut mettre le tib de cette nouvelle
tache dans une file d’attente. « En attente » signifie donc « en attente d’une
ressource ».

L’état actif ou en cours:


C’est l’état de la tâche qui possède le processeur et qui est en cours
d’exécution. Cette tâche a donc une priorité supérieure à toutes celles de la liste
d’exécution.

12/09/2019 5
III. Approche Multi-tâche

12/09/2019 6
III.1 Structure d’un programme sous µc/OS II

12/09/2019 7
III.2 Description Matérielle

12/09/2019 8
Adresses d’un afficheur LCD 4 lignes de 20 caractères

Chaque caractère alphanumérique est accessible via une adresse définie dans le plan ci-
dessous.

Commande sous µc-OSII pour l’affichage sur LCD L1

WriteCmdXLCD(0x40);
SetDDRamAddr(0x40);
putsXLCD(buf);
12/09/2019 9
IV. Synchronisation et communication entre les tâches
IV.1 Sémaphore
Un sémaphore est un objet qui permet de résoudre les problèmes de synchronisation
entre plusieurs tâches concurrentes et d’accès à des ressources partagées.

Syntaxe:

12/09/2019 10
Les sémaphores permettent de synchroniser l’accès aux ressources partagées. Dans
MicroC/OS-II un sémaphore doit être tout d’abord déclaré comme variable globale de type
OS_EVENT et doit être créé dans le programme main par OSSemCreate.

OS_EVENT *aSemaphore;
...
int main(void)
{
aSemaphore = OSSemCreate(1);
...
}

Void tache1(void *pdata)


{
INT8U err;
...
OSSemPend(aSemaphore, 0, &err);
……………………
OSSemPost(aSemaphore);
...
}12/09/2019 11
Exercice 1
On veut commander et coordonner un ensemble de robots, par une carte à base d’un
microcontrôleur 18Fxx programmé sous l’environnement µC/OS-II.
Écrire le programme qui contrôle le déplacement de plusieurs robots sur les chemins
suivants:
Sachant qu’on a deux robots ( 2 tâches ):
RobotAC : peut partir de A vers C.
RobotDA : peut partir de D vers A.

12/09/2019 12
Pour éviter tout risque de collision, il faut s’assurer que chaque segment de
chemin (segments AB, BC et DB) est utilisé par un robot au plus.

Soient les trois fonctions de chemin AD qui sont définis par :


void TraverserSegAB ( ) ; Traverser le segment AB
void TraverserSegBC ( ) ; Traverser le segment BC
void TraverserSegBD ( ) ; Traverser le segment BD

12/09/2019 13
IV.2 MailBox
Dans une application multitâche, les tâches sont autonomes. En effet, lorsque plusieurs
tâches participent chacune à la réalisation partielle d’un système de contrôle de processus
industriel, elles auront souvent à se communiquer des informations par boîte aux lettres
(mailbox).

Une boîte à lettre est une zone d'échange entre 2 tâches. Les boîtes aux lettres permettent
de synchroniser la communication entre des tâches asynchrones. Les primitives de
service sont préfixées OSMbox-----

12/09/2019 14
Dans µC/OS II la Boîte aux lettres doit être tout déclaré comme variable globale de type
OS_EVENT et créé dans le programme main par OSMboxCreate.

Syntaxe:

OS_EVENT *CommBox;
...
int main(void)
{
OSInit();
CommBox = OSMboxCreate((void*)0);
...
OSStart();
}

Remarque: Les Boîtes aux lettres peuvent être utilisé pour transmettre des donnée entre deux
tâches par le biais des fonctions OSMboxPend, OSMboxPost et OSMboxAccept.

12/09/2019 15
Exercice d’application 2

Soit un système à deux tâches :


La tâche 1 est un compteur qui affiche sa valeur de 0 à 100 de priorité 1 et
envoi un Mailbox à la tâche 2 qui continue le comptage de la tache 1 de
100 à 128 de priorité 3.
Ces deux compteurs vont afficher leurs valeurs sur un écran LCD.
Prévoir un sémaphore qui va protéger l’écran LCD.

12/09/2019 16
IV.2 File de messages

Une file de message est un ensemble des boîtes aux lettres (zone de mémoire). C’est une
liste de boîtes aux lettres: cela correspond à la file de messages.

Les primitives de service sont préfixées OSQ---.

Principe de file de messages

Le principe de file de messages se base sur l’algorithme du producteur et du consommateur,


dans ce mécanisme, il s’agit de régler les actions liées à une communication d’information
entre deux tâches: tâche de production d’informations, tâche de consommation
d’information.

12/09/2019 17
Il faut définir des opérateurs spécialisés travaillant sur un tampon mémoire du type déposer
une donnée dans le tampon de communication (OSQPost, OSQPostFront), prendre une
donnée dans le tampon de communication (OSQAccept, OSQPend).

Remarque : Il faut activer les fonctions de gestion de file de message dans le fichier
OS_cfg.h qui contient tout les paramètres, fonction et configuration utiliser dans
µC/OSII.
12/09/2019 18
Exercice d’application3

Soit un système à deux tâches :


La tâche 1 est un compteur qui affiche sa valeur de 0 à 100 de priorité 1 et
envoi un Mailbox à la tâche 2 qui continue le comptage de la tache 1 de
100 à 128 de priorité 3.
Ces deux compteurs vont afficher leurs valeurs sur un écran LCD.
Prévoir un sémaphore qui va protéger l’écran LCD.

12/09/2019 19

Vous aimerez peut-être aussi