Aucun titre de diapositive

1
Les systèmes temps-réel
Département informatique Option SI Année
2003-2004 Philippe Kauffmann
2
(No Transcript)
3
Architecture des systèmes temps réel

• Concepts généraux
• les diverses structures applicatives
• notions sous-jacentes aux interruptions
• systèmes embarqués (ou enfuis)
• notions sous-jacentes aux tâches
• Séquencement des tâches
• Le système d'exploit. LINUX RT
• Par Guénal Davalan
• principes généraux et exploitation
• Le noyau temps réel µCOS
• principes généraux
• les fonctions de gestion des tâches
• exploitation du noyau et spécificité

• Dialogue entre tâches
• méthodes simplifiées
• sémaphores
• messages
• files d'attente
• Tâches spécialisées
• Entrées-sorties
• communications série
• Systèmes évolués
• répartis
• mesure de performance
• allocation dynamique des tâches

4
Les applications informatiques

• Les deux principaux types d'applications et
  variantes
• sur ordinateur
• embarquées ou enfouies
• hybrides et en réseau
• Les différentes structures
• programme séquentiel seul calculette,
  Minitel
• séquentiel sur système d'exploitation monotâche
  programme DOS
• séquentiel sur système d'exploitation multitâche
  application Windows ou UNIX
• application temps réel autonome thermostat
  programmable
• application temps réel sur noyau temps réel
  injection et allumage automobile
• application temps réel sur système d'exploitation
  process industriel

5
Les diverses structures

• Application autonome

bonjour
Capteur d'entrée
programme
1 2 3 4 5 6 7 8 9
Actionneur de sortie
afficheur-clavier

• Application sur moniteur

• téléchargement
• lancement-arrêt
• "monitoring" extraction et modification de
  paramètres

sorties
bonjour
Application (programme)
1 2 3 4 5 6 7 8 9
moniteur
entrées
afficheur-clavier
6
Les diverses structures

• Application sur noyau multi-tâches

Tâche 1
Tâche 2
entrées
noyau
Tâche 3
sorties
Tâche 4
Tâche n
7
Les diverses structures

• Application sur système d'exploitation mono-tâche

• Applications sur système d'exploitation
  multi-tâches

gestionnaire de communications
gestionnaire de communications
E/S standard
E/S standard
processus 1
Noyau (kernel)
cur
application
processus 2
Interpréteur de commande
Terminal (shell)
processus n
Mémoires de masse
Mémoires de masse
8
Les diverses sortes de noyaux et systèmes
d'exploitation

• coopératif
• préemptif
• temps réel coopératif
• temps réel préemtif

• Noyau
• système d'exploitation

• soft
• hard

9
Notions liées aux interruptions
Programme principal

• Une interruption est un mécanisme électronique
  qui permet d'interrompre l'exécution du programme
  en cours suite à un événement externe (source
  d'interruption) pour exécuter le programme lié à
  cette événement et destiné à le traiter.
• L'interruption est elle temps réel ?
• Fonctionnement d'une interruption
• achèvement de l'exécution de l'instruction en
  cours,
• sauvegarde de l'adresse de retour
• sauvegarde du contexte
• exécution du code
• retour et réinitialisation du fanion
  d'interruption.

Données et fanions
Programme d'interruption
Préparation de données
Evénement externe
Récupération de données
10
Notions liées aux interruptions

• Notions C associées
• utilisation du mot clef volatile
• utilisation du déclarateur interrupt(n) ou
  modification du module de démarrage
• utilisation d'opérations atomiques (inhibition
  des interruptions) soit par des fonctions
  spécifiques, soit par des instructions assembleur
  en ligne
• utilisation de façon exclusive de fonctions
  réentrantes dans les interruptions

• Les interruptions sont liées aux
• applications autonomes
• moniteurs
• noyaux temps réel
• systèmes d'exploitation monotâches
• systèmes d'exploitation multitâches
• Les noyaux et systèmes d'exploitation masquent
  certains aspects et certaines interruptions

11
Systèmes embarqués ou enfouis

• Ce sont tous les systèmes qui ne ressemblent en
  rien à des ordinateurs, mais qui sont pourtant
  basés sur des programmes informatiques
• - Contrôle de process automates programmables,
  contrôleurs de moteurs, usines d'alimentation, de
  produits chimiques,
• - Automobile, marine et aviation injection
  électronique, ABS, FADEC, contrôleurs de vol,
  systèmes de navigation, contrôle d'armes,
  systèmes de communication,
• - Bureaux et applications domestiques
  calculettes, photocopieurs, télécopieurs,
  micro-ondes, lave-linge et lave-vaisselle,
  thermostats, téléviseur, chaîne HIFI,
  magnétoscope, camescope,
• - Communications téléphones portables et sans
  fil, ponts, routeurs,
• - Périphériques d'ordinateurs souris,
  moniteurs, cartes graphiques, imprimantes,
  terminaux, disques durs, claviers, scanners,
  modems, alimentations de secours,
• Hormis les systèmes les plus sophistiqués qui
  sont très souvent répartis, ils n'utilisent pas
  de systèmes d'exploitation.
• Le plus souvent temps réel, avec ou sans noyau
  (plus gourmand).

12
Systèmes embarqués ou enfouis architectures

• Structure tâche de fond/interruptions

Tâches de fond Tâches d'interruptions
T1
Priorité faible
Priorité forte
T2
T1
T3
T4
T5
T6
T5
T4
Temps
13
Systèmes embarqués ou enfouis architectures

• Noyau non préemptif

Priorité faible
T1
Interruptions
Priorité forte
T2
T1
T3
T4
Temps
14
Systèmes embarqués ou enfouis architectures

• Noyau préemptif

Priorité 2
Interruptions
Tâche d'attente
Priorité 0
Priorité 1
Ticks
T1
T2
T1
Fin
Repos
T3
T4
T3
Fin
Repos
Temps
15
Tâches et notions associées

• Définition d'une tâche
• - Une tâche est un programme élémentaire qui est
  lancé par le noyau ou une autre tâche.
• - Il contient des fonctions qui rendent la main
  au noyau, ou donnent la main à d'autres tâches.
• - Une tâche est un morceau de programme qui se
  répète indéfiniment.
• - Une tâche possède des propriétés spécifiques
  
• - priorité,
• - temps processeur,
• - données, etc..
• - Une tâche peut être dans différents états
• endormie, en attente, prête, active, interrompue.

• Notions associées
• Section critique
• morceau de code qui ne doit pas être interrompu
• Ressource
• toute entité utilisée par une tâche
• Ressource partagée
• entité utilisée par plusieurs tâches

16
Séquencement des tâches

• Divers états d'une tâche

En attente
OSMboxPost()
OSMboxPend()
OSTaskdel()
OSQPost()
OSQPend()
OSQPostFront()
OSSemPost()
OSSemPend()
OSTaskResume()
OSTaskSuspend()
OSTimeDlyResume()
OSTimeDly()
OSTimeTick()
OSTimeDlyHMSM()
OSTaskCreateExt()
OSTaskCreate()
OS_TASK_SW()
interruption
OSStart()
Endormie
Interruption
Active
Prête
OSIntExit()
OSIntExit()
OSTaskDel()
tâche préemptée
OSTaskDel()
17
Séquencement des tâches

• Mécanisme de commutation avec un noyau non
  préemptif
• Si une tâche rend la main au noyau, le noyau
  passe la main à la tâche suivante de la liste des
  tâches prête.
• La tâche prête ayant la plus forte priorité est
  retenue.
• Si plusieurs tâches ont même priorité, ces tâches
  sont sélectionnées à tour de rôle par le noyau.
• Mécanisme de commutation avec un noyau préemptif
• A chaque tick d'horloge, le noyau regarde si une
  tâche plus prioritaire est active. Si oui, il
  commute sur cette tâche selon les mêmes règles
  que pour le noyau non préemptif.
• Eventuellement (selon le noyau), si une tâche à
  épuisé son droit au fonctionnement, le noyau
  commute sur la tâche suivante selon les même
  règles que pour le noyau non préemptif.

18
Séquencement des tâches

• Gestion des priorités
• Priorités statiques
• La priorité est définie une fois pour toute à la
  création de la tâche.
• Priorités dynamiques
• La priorité de la tâche peut être modifiée
  dynamiquement au cours de l'exécution pour
  s'adapter aux circonstances et surtout pour
  éviter les inversions de priorité.
• Inversion de priorité
• Phénomène parasite qui peut être observé
  lorsqu'une tâche de forte priorité partage de
  façon exclusive une ressource avec une tâche de
  priorité faible. Dans certains cas, la priorité
  effective de la tâche de priorité forte devient
  celle de la tâche de priorité faible.
• Héritage de priorité
• Mécanisme qui donne automatiquement à une tâche
  de priorité faible celle d'une tâche de priorité
  forte, pour éviter le phénomène d'inversion de
  priorité.

19
Inversion de priorité
Tâche 1 (H) Tâche 2 (M) Tâche 3 (F)
Inversion de priorité
Inversion de priorité
Inversion de priorité
Tâche 1 (H) Tâche 2 (M) Tâche 3 (F)
(1) (2) (3) (4)
(5) (6) (7) (8)
20
Le noyau temps réel µCOS

• Installation et démarrage
• Principe du démarrage
• Exemple d'installation
• Les fonctions particulières
• Gestion des interruptions
• Contrôle de lordonnanceur
• Mesure d'un temps
• Obtenir des informations sur une tâche
• Surveillance des piles de tâche
• Communication entre tâches
• Sémaphores
• Messages

• Principes généraux
• Caractéristiques générales
• Fonctionnement de lordonnanceur
• Limitations
• La gestion des tâches
• Structure
• Création, destruction
• Arrêt et réactivation
• Changement de priorité
• La tâche d'attente
• la tâche "statistiques"
• Principe et possibilités
• Mise en uvre

21
Le noyau temps réel µCOS
Principes généraux

• Caractéristiques générales
• Noyau temps réel hard basé sur les priorités.
• Communication et échange de données par
  sémaphores et messages.
• Fonctionnement de l ordonnanceur
• Chaque tâche doit avoir une priorité propre.
• Si un temps est écoulé, un événement arrive, ou
  un tic d'horloge déclenche lordonnanceur,
  celui-ci cherche la tâche prête ayant le plus
  haut niveau de priorité et lui donne la main.
• Limitations
• Le noyau ne traite que les temps discrets
  (multiples du tic de base).
• Il ne fonctionne pas sur plusieurs processeurs en
  parallèle.
• Il ne supporte pas le fonctionnement en réseau
  (machines virtuelles), ni le partage de mémoire.

22
Le noyau temps réel µCOS
La gestion des tâches

• Structure d'une tâche
• void MaTache(void donnees)
• / code de demarrage /
• while (1)
• / code de la tâche /
• OSTimeDly(n) / fonction d'appel noyau
  /
• / code de la tâche /
• .
• .

23
Le noyau temps réel µCOS
La gestion des tâches

• Création
• Il existe deux fonctions de création, la fonction
  de base
• INT8U OSTaskCreate(void (task)(void pd), void
  pdata, OS_STK ptos, INT8U prio)
• Exemple
• INT8U err
• OS_STK pile32
• void MaTache(void data)
• .
• err OSTaskCreate(MaTache, (void )0(void
  )pile32-1,5)
• la fonction étendue qui utilise 5 paramètres
  supplémentaires pour permettre la réservation de
  mémoire supplémentaire, la définition d'un
  identifiant et la gestion de la pile.

24
Le noyau temps réel µCOS
La gestion des tâches

• Destruction
• Une tâche est supprimée par l'appel de la
  fonction
• INT8U OSTaskDel(INT8U prio)
• Ou la fonction indirecte qui demande à la tâche
  désignée de se tuer elle-même.
• INT8U OSTaskDelReq(INT8U prio)
• Une tâche supprimée (ou tuée) libère son TCB et
  les autres ressources qu'elle possède elle
  devient "dormante".
• Une tâche tuée peut être crée à nouveau de façon
  dynamique.

25
Le noyau temps réel µCOS
La gestion des tâches

• Arrêt et réactivation
• Une tâche peut être désactivée par l'appel de la
  fonction
• INT8U OSTaskSuspend(INT8U prio)
• Elle peut être réactivée par l'appel de la
  fonction
• INT8U OSTaskResume(INT8U prio)
• Une tâche désactivée (ou suspendue) conserve
  toutes ses ressources elle devient "en
  attente".
• La suspension est additive.

26
Le noyau temps réel µCOS
La gestion des tâches

• Changement de priorité
• On change la priorité d'une tâche par l'appel de
  la fonction
• INT8U OSTaskChangePrio(INT8U oldprio, INT8U
  newprio)
• La tâche d'attente
• Elle s'appelle IdleTask(), elle à la priorité la
  plus faible de toutes les tâches et elle est
  exécutée lorsqu'aucune autre tâche n'est prête.
• Elle incrémente en permanence la variable INT32U
  OSIdleCtr, ce qui permet de calculer le taux
  d'utilisation du processeur.

27
Le noyau temps réel µCOS
La tâche "statistiques"

• Principe et possibilités
• La tâche "statistiques" est une tâche spécialisée
  destinée à faire le calcul des statistiques
  d'utilisation du processeur. Elle est exécutée
  une fois par seconde et sa priorité est juste au
  dessus de la tâche d'attente.
• Elle actualise la variable INT8U CPUUsage qui
  donne le taux d'utilisation du processeur en .
• Mise en uvre
• Il faut et il suffit d'appeler la fonction void
  OSStatInit(void) comme première tâche après le
  démarrage du noyau.
• Le résultat du calcul est actualisé toutes les
  secondes dans INT8U CPUUsage.

28
Le noyau temps réel µCOS
Installation et démarrage

• Principe du démarrage
• Le noyau temps réel µCOS est fourni sous forme de
  source à associer directement à l'application.
• Il ne pré-existe donc pas au moment du lancement
  de l'application.
• Le projet de l'application doit donc inclure tous
  les fichiers (entêtes, configuration, portage C,
  portage assembleur) du noyau.
• Le programme principal (main) de l'application
  doit configurer, initialiser et lancer le noyau
  avant qu'une première tâche ne puisse lancer les
  autres.
• Après le lancement de la première tâche, le temps
  réel peut commencer.

29
Le noyau temps réel µCOS
Installation et démarrage

• Exemple d'installation (utilisant la tâche
  "statistiques")

include "includes.h" OS_STK PileTaskStart64,
PileTache132,.. . void TaskStart(void
data) void Tache1(void data) . void
main(void) OSInit() / initialisation du noyau
/ PC_DOSSaveReturn() PC_VectSet(uCOS,
OSTxSw) OS_ENTER_CRITICAL PC_VectSet(0x08,
OS_TickISR) PC_SetTickRate(OS_TICKS_PER_SEC) OS_
EXIT_CRITICAL / creation des messages et
semaphores / .
/ creation de la tache initiale et
demarrage/ OSTaskCreate(TaskStart, (void )0,
.) OSStart() void TaskStart(void
data) / affichage de données permanentes,
etc. / / initialisation de la tache
"statistiques" / OSStatInit() / creation des
autres taches / while(1) sprintf(s,
"3d", OSCPUUsage) / affichage des
statistiques / OSTimeDly(1000)
30
Le noyau temps réel µCOS
Les fonctions particulières

• Gestion des interruptions
• Le noyau peut être considéré comme une entité
  double
• l ordonnanceur qui est une interruption liée au
  générateur de "tics",
• l'ensemble des autres fonctions qui peut être
  considérée comme une tâche de fond.
• Les interruptions autres que celle du générateur
  de "tics" peuvent être considérées comme
  indépendantes et s'exécutant à l'insu du noyau.
  Leurs priorités et périodicités peuvent être
  supérieures et/ou inférieures à celles de
  lordonnanceur.
• Il est possible de faire en sorte qu'une
  inhibition des interruptions venant du noyau ne
  concerne pas certaines interruptions.
• Les interruptions peuvent partager des
  informations avec le reste de l'application en
  utilisant
• des zones de mémoire globale communes,
• des sémaphores,
• des messages.

31
Le noyau temps réel µCOS
Les fonctions particulières

• Contrôle de l'ordonnanceur
• L'odonnanceur est déclenché soit par un événement
  externe (message, sémaphore, création de tâche,
  changement de priorité d'une tâche, achèvement
  d'un temps d'attente), soit par l'événement
  interne "tic" déclenché à périodicité fixe
  définie au moment de l'initialisation.
• Les temps d'attente peuvent être générés par
  OSTimeDly(INT16U ticks) ou OSTimeDlyHMSM(INT8U
  heures, INT8U minutes, INT8U secondes, INT16U
  milli).
• Il est possible d'achever prématurément un temps
  d'attente par l'appel à la fonction
  OSTimeDlyResume(IN8U prio).
• Il est possible d'inhiber l'ordonnanceur par
  OSSchedLock(void) et de le déverrouiller par
  OSSchedUnlock(void). Ces deux fonctions sont
  dangereuses !

32
Le noyau temps réel µCOS
Les fonctions particulières

• Mesure d'un temps
• Deux fonctions existent pour mesurer le temps en
  nombre de tics
• OSTimeSet(IN32U ticks) pour initialiser et
  IN32U OSTimeGet(void) pour lire la valeur
  courante.
• Des fonctions spécifiques à chaque processeur
  existent pour mesurer des temps plus fins.
• Sur PC il existe deux fonctions pour mesurer des
  temps en micro-secondes, ainsi qu'une fonction
  d'initialisation
• void PC_ElapsedInit(void) pour initialiser les
  fonctions de mesure,
• void PC_ElapsedStart(void) pour démarrer à zéro
  et
• INT16U PC_ElapsedStop(void) pour lire la valeur
  mesurée.

33
Le noyau temps réel µCOS
Les fonctions particulières

• Obtenir des informations sur une tâche
• La fonction INT8U OSTaskQuery(INT8U prio, OS_TCB
  pdata) retourne les principaux éléments de la
  structure de contrôle de la tâche désignée par
  son numéro de priorité.
• Les informations contenues (exemple simplifié)
  sont les suivantes
• typedef struct os_tcb
• OS_STK OSTCBStkPtr / pointe sur la pile de la
  tâche /
• struct os_tcb OSTCBNext / suivant de la liste
  chaînée /
• struct os_tcb OSTCBPrev / précédant de la
  liste chaînée /
• INT16U OSTCBDly / nombre de tics à attendre /
• INT8U OSTCBStat / état de la tâche /
• INT8U OSTCBPrio / priorité de la tâche /
• ..
• OS_TCB

34
Le noyau temps réel µCOS
Les fonctions particulières

• Surveillance des piles de tâche
• Dans les systèmes à micro-contrôleur, la mémoire
  est souvent très limitée. Pour en faire le
  meilleur usage il convient de ne donner que le
  stricte nécessaire de pile à chaque tâche. Pour
  cela il faut pouvoir mesurer l'utilisation de la
  pile.
• Il est possible de surveiller l'utilisation de la
  pile de chaque tâche si la tâche a été créée en
  mode étendu avec validation des variables
  OS_OPT_STK_CHK et OS_TASK_STK_CLR.
• La fonction INT8U OSTaskStkChk(INT8U prio, INT32U
  pfree, INT32U pused) retourne la quantité de
  pile libre et la quantité de pile utilisée, en
  octets. La tâche dont on veut connaître
  l'utilisation de la pile est définie par sa
  priorité.

35
Le noyau temps réel µCOS
Communication entres tâches

• Principes
• µCOS supporte les principes de communication
  standards suivants
• Sémaphores d'exclusion mutuelle, de
  synchronisation, de comptage.
• Les messages de taille et structure quelconque.
• Les files d'attente de messages de taille
  prédéfinies
• L'ensemble de ces dispositifs sont étudiés de
  façon générale au chapitre suivant, µCOS étant
  utilisé en tant qu'exemple d'application.

36
Dialogue entre tâches

• Présentation du problème du partage de ressources
• Accéder à la ressource doit être fait de façon
  atomique.
• Exemple du partage d'une variable lue et écrite
  en plusieurs étapes.
• Méthodes diverses simples
• Inhibition des interruptions
• Garantit l'atomicité mais augmente le temps de
  réponse aux interruptions.
• Méthode du test et activation
• Un fanion supplémentaire d'accès à la ressource
  est utilisé.
• Il est testé et activé de façon atomique.
• Lorsqu'une tâche le voit initialement actif elle
  renonce à accéder à la ressource.
• Blocage de l'ordonnanceur
• Inhibe la préemption durant l'accès à la
  ressource.

37
Les sémaphores

• Présentation des sémaphores
• Mécanisme semblable à un fanion évolué pour
  indiquer qu'une ressource est en cours
  d'utilisation.
• Un sémaphore peut être binaire ou à comptage.
• Un sémaphore est créé et exploité par des
  fonctions spécifiques.
• Sémaphores de synchronisation
• servent à créer des "rendez vous".
• Sémaphores d'exclusion
• pour protéger une ressource partagée.
• Le "baiser de la mort"
• Une tâche 1 qui dispose d'une ressource 1 dont la
  tâche 2 a besoin, bloque le système si la tâche 2
  dispose d'une ressource 2 dont la tâche 1 a aussi
  besoin.

Tâche 2
Tâche 1
Tâche 1
imprimante
Tâche 2
38
Les sémaphores

• Fonctions associées

OSSemCreate()
OSSemPost()
Tâche 1
OSSemPend() OSSemAccept() OSSemQuery()
Tâche 2
ou
OSSemPost() OSSemAccept()
interruption
39
Les sémaphores

• Exemple sémaphore d'accès exclusif à une
  fonction non réentrante
• / dans les déclarations initiales /
• OS_EVENT SemExemple
• / dans le début de "main" /
• SemExemple OSSemCreate(1) / création avec
  sémaphore libre /
• / exploitation du sémaphore dans une tâche /
• INT8U err
• ...
• OSSemPend(SemExemple, 0, err) / prise du
  sémaphore sans "timeout" /
• -gt fonction non réentrante
• OSSemPost(SemExemple) / restitution du
  sémaphore /

40
Les messages

• Les messages sont un moyen pour transmettre des
  données d'une tâche à une autre.
• Ils sont une alternative à l'utilisation de
  mémoire partagée.
• Ils peuvent être transférés via un lien réseau
  sur un système multi-processeur ou sur une
  machine virtuelle.
• Le message est une structure de donnée de taille
  et forme quelconque.
• En local, le message n'est jamais transmis, seul
  son adresse est transmise.

41
Les messages

• Fonctions associées

OSMboxCreate()
OSMboxPost()
Tâche 1
OSMboxPend() OSMboxAccept() OSMboxQuery()
Tâche 2
Boîte aux lettres
Message
OSMboxPost() OSMboxAccept()
interruption
42
Les messages

• Exemple message transmis entre deux tâches
• / dans les déclarations initiales /
• OS_EVENT MesExemple
• / dans le début de "main" /
• MesExemple OSMboxCreate((void )0) /
  création avec boîte aux lettres vide /
• / émission du message dans une tâche /
• INT8U MonMessage
• OSMboxPost(MesExemple, (void )MonMessage)
• / attente du message dans une autre tâche sans
  "timeout" /
• INT8U err, LeMessage, Message
• LeMessage (INT8U )OSMboxPend(MesExemple, 0,
  err)
• Message LeMessage

43
Les files d'attente

• Les messages sont transmis dans une boîte aux
  lettres qui ne peut contenir qu'un seul message.
• Cette possibilité est parfois trop restrictive,
  on utilise alors la "file d'attente" qui est un
  système de messagerie qui utilise une boîte aux
  lettres pouvant contenir un nombre de messages
  prédéfini.
• Les possibilités sont les mêmes que pour les
  messages, mais en addition il est en général
  possible de remplir la boîte en mode LIFO ou
  FIFO.
• Comme pour les messages et les sémaphores, il est
  possible d'obtenir l'état courant ou de récupérer
  un message sans attendre.

44
Les files d'attente

• Fonctions associées

OSQCreate()
OSQPost() OSQPostFront() OSQFlush()
Tâche 1
OSQPend() OSQAccept() OSQQuery()
N
Tâche 2
File d'attente
Message
OSQPost() OSQPostFront() OSQFlush() OSQAccept()
interruption
45
Les entrées / sorties

• Ces fonctions sont spécifiques du processeur et
  du système
• Dans le cas dun PC
• Le clavier
• la fonction INT8U PCGetKey((INT16S )touche)
  nest pas bloquante, retourne 0 si aucune touche
  na été pressée, ou 1 sinon avec le code ASCII de
  la touche.
• L'écran
• Deux fonctions permettent décrire directement en
  couleur dans la mémoire décran un caractère
  void PC_DispChar(INT8U x, IN8U y, char ascii,
  INT8U color) ou une chaîne de caractères void
  PC_DispStr(INT8U x, IN8U y, (char )string, INT8U
  color).
• Une fonction permet deffacer lécran void
  PC_DispClrScr(INT8U color).

46
Les communications série
Principe

• Une ou plusieurs tâches dinterruption sont liées
  au périphérique série concerné.
• Il y a autant de tâches d interruption que de
  sources d interruption liées au composant de
  communication.
• Ces tâches dinterruption communiquent avec
  l application via des tampons circulaires.
• Des fonctions propres aux ports série servent à
  initialiser et configurer la communication.
• Des fonctions de lecture et écriture permettent
  de transmettre des caractères à travers des
  tampons circulaires d'émission et réception et
  s'informer de l'état de chaque tampon.

47
Les communications série
Initialisation

• réservation des ressources
• void CommSetIntVect(INT8U ch) permet de
  s'approprier le vecteur d'interruption du port
  série, tandis que void CommRcIntVect(INT8U ch)
  permet de le restituer.
• void CommInit(void) permet d'initialiser les
  tampons circulaires.
• configuration (vitesse)
• La fonction INT8U CommCfgPort(INT8U ch, INT16U
  baud) permet de sélectionner la vitesse du port
  en fraction de 115200 Bauds.
• Fonctions spéciales
• void CommRxFlush(INT8U ch) permet de vider le
  tampon de réception.
• void CommR,TxIntDis(INT8U ch) permet d'inhiber
  l'interruption du port.
• void CommR,TxIntEn(INT8U ch) permet de valider
  l'interruption du port.

48
Les communications série
Communication avec tampon circulaire

• Réception
• INT8U CommGetChar(INT8U ch, INT16U timeout, INT8U
  err) permet d'obtenir le caractère reçu le plus
  ancien.
• BOOLEAN CommIsEmpty(INT8U ch) permet de savoir si
  il y a au moins un caractère dans le tampon
  circulaire de réception.
• Emission
• INT8U CommPutChar(INT8U ch, INT8U car, INT16U
  timeout) permet de placer le caractère car dans
  le tampon circulaire d'émission.
• BOOLEAN CommIsFull(INT8U ch) permet de savoir si
  le tampon circulaire d'émission est plein.

49
Les communications série
Exemple d'initialisation d'une communication série

• Initialisation dans le module de démarrage
• void main(void)
• .
• .
• CommInit() / Initialisation du tampon
  circulaire /
• CommCfgPort(COMM1, 9600)
• CommSetIntVect(COMM1) / Installation du
  vecteur d'interruption du port 1 /
• CommRxIntEn(COMM1) / Validation des
  interruptions en émission /
• .
• .

50
Les systèmes évolués
Mesure de performance

• Un  moniteur  peut mesurer dynamiquement
  plusieurs paramètres
• Taux dutilisation de chaque processeur
• Taux dutilisation de chaque pile de tâche
• Temps de latence de démarrage de chaque tâche
• Délais de transfert de sémaphores et messages
• Chronogramme d utilisation du processeur par
  chaque tâche
• Un moniteur peut éventuellement prendre en temps
  réel des
• décisions en fonction des valeurs mesurées.

51
Les systèmes évolués répartis

• On distingue deux types de systèmes répartis
• Les systèmes multiprocesseurs
• Deux ou plus de processeurs se répartissent le
  travail et s échangent les données via une
  mémoire commune. Cest une configuration à
   liaison serrée .
• Les machines virtuelles
• deux ou plusieurs nuds (processeurs, cartes ou
  systèmes autonomes) sont liées via un réseau
  local. Cest une configuration à  liaison
  lâche .
• Léchange de données et la synchronisation est
  effectuée via des messages transmis par le
  réseau.
• Lensemble est appelé machine virtuelle.

52
Les systèmes évolués répartis
Allocation dynamique des tâches

• Dans une machine virtuelle, certaines tâches ne
  sont pas liées à des ressources matérielles,
  elles peuvent donc sexécuter sur nimporte quel
  processeur.
• Dans ce cas, un mécanisme dallocation dynamique
  peut décider à quel processeur est affecté une
  tâche, soit
• pour décharger un processeur trop chargé,
• pour accélérer l exécution d une tâche en la
  plaçant sur un processeur peu chargé
• Une tâche peut ainsi migrer d un processeur à un
  autre en fonction des contraintes.