Temps Reel Full Cours

Temps Réel
S1
Introduction aux Systèmes multitâches

et
Systèmes temps réel
L. BOUHOUCH
2022/2023
PLAN
2
• Présentation du Syllabus ;
• Introduction & définitions ;
• Bref historique du temps réel ;
• Principe de l’architecture & du fonctionnement du STR ;
• Notion de "Système Multitâches".

INTRODUCTION & DEFINITIONS
3
 Définition générale (CNRS 1988) :

 Peut être qualifiée de "Temps réel" (ou "Temps contraint", ou encore "Réactif")
toute application mettant en œuvre un système informatique dont le
fonctionnement est lié à l'évolution dynamique de l'environnement qui lui est
connecté et dont il doit contrôler le comportement.
Rythme de l'interaction
Données
Environnement
Système Mesures
(ex : une chaîne de
informatique Evénements production, une
réaction chimique …)
Temps de réponse imposé par la Commandes

dynamique de l'environnement
INTRODUCTION
4
INTRODUCTION
5
INTRODUCTION
6
7
 Définition générale (CNRS 1988) :

 Peut être qualifiée de "Temps réel" (ou "Temps contraint", ou encore "Réactif")
toute application mettant en œuvre un système informatique dont le
fonctionnement est lié à l'évolution dynamique de l'environnement qui lui est
connecté et dont il doit contrôler le comportement.
Rythme de l'interaction
Données
Environnement
Système Mesures
(ex : une chaîne de
informatique Evénements production, une
réaction chimique …)
Temps de réponse imposé par la Commandes

dynamique de l'environnement
8
 Classification et autres points de vue du temps réel.

 Système Transformationnel :
 Activité de calcul, qui lit ses données et ses entrées lors de son démarrage, qui fournit
ses sorties, puis meurt.
 Système Interactif :
 Système en interaction quasi permanente avec son environnement, y compris après
l'initialisation du système ; la réaction du système est déterminée par les
événements reçus et par l'état courant (fonction des événements et des réactions
passés) ; le rythme de l'interaction est déterminé par le système et non par
l'environnement.
 Système Réactif ou Temps Réel :
 Système en interaction permanente avec son environnement, y compris après
l'initialisation du système ; la réaction du système est déterminée par les
événements reçus et par l'état courant (fonction des événements et des réactions
passées) ; mais le rythme de l'interaction est déterminé par l'environnement et
non par le système.
9
 Conséquences de la définition :
 Un système Temps Réel reçoit des événements venant du procédé à contrôler ; ces
événements peuvent être périodiques ou non
 le système doit réagir avant un délai ou une échéance ou une date fixée
 aucun événement ne doit être raté par le système
 Autre formulation : Un système fonctionne en "Temps Réel" s'il est capable d'absorber
toutes les informations d'entrée sans qu'elles soient trop vielles pour l'intérêt qu'elles
représentent, et par ailleurs de réagir à temps pour que cette réaction ait un sens.
 Ne pas réagir à temps peut être considéré comme une défaillance catastrophique
 Un système Temps Réel est souvent critique et doit souvent être tolérant aux pannes
 Mise en place de mécanismes de tolérance aux défaillances :
Réplication, Programmation N-version, Vérification formelles …
  L'important est de respecter l'échéance
  Un résultat juste hors délai peut être inutilisable et considéré comme une faute
  Parfois réagir trop tôt est aussi une faute (Contrôle dans un avion)
  Temps Réel = Ponctualité
10
Aspect temporel de la dynamique des procédés :
Ordre de grandeur
Temps
de la contrainte temporelle Contrôle
En chimie
1 heure
Contrôle
fabrication
1 minute
Contrôle
stockage
1 seconde
10 ms Systèmes Robotique
1 ms vocaux Systèmes
Systèmes
radar Mesures
scientifiques
1 µs
100 ns
Application
Dynamique des procédés très différente suivant l'application :

milliseconde : Systèmes radar, …
seconde : Systèmes de visualisation, …
minutes : Chaîne de fabrication, …
heures : Contrôle de réactions chimiques, …
11
 Mais de quel temps s'agit-il ?

 2 entités :
 L'environnement ou le procédé à contrôler et
 Le système informatique Temps Réel
 => 2 temps : le temps de l'environnement et le temps du système Temps Réel
• Temps de l'environnement = temps Chronométrique (le temps réel exact)
• Temps du système informatique = temps Chronologique, constitué de la suite des
événements ou des instructions du système (pas le temps réel vu par le système)
 => Exigence du Temps Réel = Concordance entre le
Temps Chronométrique de l'environnement et le Temps Chronologique du système
 => Le système informatique doit mettre ses actions en phase avec le
Temps chronométrique de l'environnement
 où les actions du système seront en fait ses "tâches" et ses "messages"
 => Nécessité de Techniques d’Ordonnancement de tâches et de communications
12
 Deux notions de criticité face au manquement d'une échéance

– Contraintes temps réel strictes : le dépassement d'une échéance est catastrophique
– Contraintes temps réel relatives : le dépassement d'une échéance peut être toléré
(dans une certaine mesure)
 => Temps réel Dur / Temps réel Mou (ou Lâche) !

 => Dans le cas des systèmes Temps Réel Dur, on cherchera à obtenir un
comportement prévisible, déterministe et fiable
 => Utilisation de techniques mathématiques (ordonnancement, évaluation des pires cas …)
 => Dans le cas des systèmes Temps Réel Mou, on cherchera à minimiser la
probabilité de rater une échéance plusieurs fois de suite ...
13
 Quelques exemples :
– Commande et contrôle de chaînes de production
– Guidage des systèmes mobiles (robotique …)
– Systèmes embarqués (avion, train, automobile …)
– Surveillance de réactions ou phénomènes physiques (nucléaire, chimie, …)
– Contrôle de malades et assistance d'opérations médicales
– Systèmes de communication et multimédia …
– Systèmes dédiés (conduite d'expérience scientifique, traitement du signal …)
– Systèmes de production de l'électricité nucléaire …
– Systèmes de production de l'électricité par l'énergie éolienne …
14
– Robot de production : un robot, réalisant une activité spécifique (peinture, assemblage, tri) sur
une chaîne de production, doit effectuer son travail en des temps fixés par la cadence de
fabrication. S'il agît trop tôt ou trop tard, l'objet manufacturier traité sera détruit ou endommagé
conduisant aux conséquences financières ou humaines graves (oubli d'un ou plusieurs rivets
sur un avion …)
– Robot d'exploration (robot BIP) : ce robot doit se déplacer dans un environnement en principe
non connu (zone radioactive après un accident, planète, épave sous la mer, …). Il est important
qu'il puisse réagir aux obstacles fixes ou mobiles afin de ne pas conduire à sa perte.
– Téléphonie mobile : le système de contrôle-commande doit remplir plusieurs fonctions dont

certaines ont des contraintes temporelles fortes pour avoir une bonne qualité de service
(quality of service). Ainsi, la première fonction est de transmettre et de recevoir les signaux de la
parole (577 µs de parole émises toutes les 4,6 ms et 577 µs de parole reçues toutes les 4,6 ms).
En parallèle, il est nécessaire de localiser en permanence le relais le plus proche et donc de
synchroniser les envois par rapport à cette distance (plus tôt si la distance augmente et plus tard
si la distance diminue). Des messages de comptes rendus de la communication sont aussi émis
avec une périodicité de plusieurs secondes. Les contraintes temporelles imposées au système
doivent être imperceptibles à l'utilisateur.
15
– Système de vidéo-conférence : ce système doit permettre l'émission et la réception d'images
numérisées à une cadence de 30 images par seconde pour avoir une bonne qualité de service
(quality of service). Afin de minimiser le débit du réseau, une compression des images est
effectuée. D'autre part la parole doit être aussi transmise ; bien que correspondant à un débit
d'information moindre, la régularité de la transmission (gigue temporelle) est nécessaire pour
une reproduction correcte. De plus ce signal doit être synchronisé avec le flux d'images.
L'ensemble de ces traitements (numérisations images et parole, transmission, réception,
synchronisation, …) sont réalisés en cascade, mais avec une cohérence dans le temps
précise.
– Pilotage d'un procédé de fabrication (fonderie, laminoir, four verrier, …) : la fabrication d'une
bobine d'aluminium (laminage à froid) exige un contrôle en temps réel de la qualité (épaisseur
et planéité). Cette vérification en production de la planéité nécessite une analyse fréquentielle
(FFT) qui induit un coût important de traitement. Le système doit donc réaliser l'acquisition d'un
grand nombre de mesures (246 Ko/s) et traiter ces données (moyenne, FFT, …) à la cadence de
4 ms. Ensuite, il affiche un compte-rendu sur l'écran de l'opérateur toutes les 200 ms et enfin
imprime ces résultats détaillés toutes les 2 s. Un fonctionnement non correct de ce système de
contrôle de la qualité peut avoir des conséquences financières importantes, telle une production
non conforme à la spécification demandée.
BREF HISTORIQUE DU TEMPS REEL
16
• Fin des années 50 …
 Première apparition de machines numériques dans des applications temps réel (système
de commandes d'une unité de polymérisation d'une raffinerie Texaco)
• Années 60 …
 Les systèmes temps réel s'étendent à des secteurs critiques tel que l'aérospatiale
(système de contrôle de vol des capsules Apollo (NASA), système de commande de vol
du Concorde (Sud Aviation) …)
• Années 70 …
 L'arrivée des mini-calculateurs accélère l'insertion d'outils informatisés dans les
environnements temps réel (chaîne de production …)
• Depuis les années 80 …
 Invasion de tous les secteurs industriels par l'informatique temps réel grâce à la micro-
informatique, et au développement des techniques de communication
 => Systèmes temps réel distribués
 => Explosion de l'informatique embarquée (aérospatiale, nucléaire, télécom,
automobile, marine …)
PRINCIPE DE L’ARCHITECTURE ET DU FONCTIONNEMENT DU STR
17
 Principe :
 Quelle que soit la nature et la complexité du STR (Système Temps Réel), on le
décompose en :
• Système contrôlé &
• Système de contrôle Interface capteurs
Système Procédé
informatique
Interface actionneurs
Environnement
– Le système contrôlé = Environnement (procédé) équipé d'une instrumentation

qui réalise l'interface avec le système de contrôle
– Le système de contrôle = Eléments matériels (processeurs …) et logiciels dont

la mission est d'agir sur le procédé via les actionneurs en fonction de l'état de
ce procédé - indiqué par les capteurs - de manière à maintenir ou conduire le
procédé dans un état donné.
18
Interface capteurs
 Principe de fonctionnement : Système Procédé
– Interaction : informatique
 Via les mesures issues des capteurs, et Interface actionneurs
 Les commandes envoyées aux actionneurs Environnement
 => Acquisition des mesures périodiques à une cadence compatible avec la

dynamique du procédé
 => Elaboration et envoi des commandes dans un laps de temps compatible
avec la dynamique du procédé
 => Double rôle du système de contrôle

– Observateur : Acquisition des mesures
– Contrôleur : Mise en œuvre des lois de commandes et émission des commandes
vers des actionneurs spécifiques
19
 Fonctionnement général : boucle infinie
 Tant que TOUJOURS faire

 Acquisition des entrées (données capteurs, mesures …)
 Calcul des ordres à envoyer au procédé
 Émission des ordres
 Fin tant que
 Il existe ainsi 2 modes de fonctionnement :

– Fonctionnement Cyclique (Time driven)
– Fonctionnement Evénementiel (Event driven)
20
 Fonctionnement Cyclique :
– Scrutation d'une mémoire d'entrée périodiquement (Polling)
  Echantillonnage des entrées sur l'horloge du système
  Activation du système à chaque série de tops d'horloge
 A chaque série de tops d'horloge faire
 Lecture de la mémoire des entrées
 Calcul des ordres à envoyer au procédé
 Émission des ordres
 Fin
 Mais :
– Système Peu "Réactif", si l'environnement produit des informations à des
fréquences différentes
  Obligation à prévoir toutes les réactions du système dans la même boucle
  Problème de performance.
  Ou obligation à imbriquer des boucles de fréquences multiples
  Difficultés de réalisation, d'évolution et de lisibilité du code.
21
 Fonctionnement Evénementiel :
– Activation du système à chaque événement ( Notion d'Interruption)
 =>
 A chaque interruption faire
 Lecture de l'information arrivée
 Activation du traitement correspondant
 Émission des ordres issus de ce traitement
 Fin
 Mais : que faire si une interruption survient alors que le système est entrain de
traiter une interruption précédente
 => Notion de priorité des interruptions
 => Notion de "Tâche" associée à une ou plusieurs interruptions
 => Mécanisme de préemption et de reprise de tâche
(Capacité à traiter une tâche de haute priorité le plus rapidement possible après son apparition, alors
qu’une tâche de priorité inférieure est en cours de traitement).
 => Gestion de l'exécution concurrente des tâches (ordonnancement)
  Un STR est souvent un Système multitâches incluant un gestionnaire de tâches (Ordonnanceur)
NOTION DE "SYSTÈME MULTITÂCHES"
22
 Pour des raisons de facilité de conception, de mise en œuvre et d'évolutivité,

une application temps réel est un système multitâches :
 Tâche associée à : Système informatique du STR doit :

 Un ou des événements
 Une ou des réactions Gérer l'enchaînement et la concurrence des tâches
 Une entité externe à contrôler en optimisant l'occupation de l'unité centrale
 Un traitement particulier
 ……  Fonction d‘Ordonnancement.
programme temps réel
Coopération entre tâches
: tâche
NOTION DE "SYSTÈME MULTITÂCHES"
23
Architecture logicielle d'un STR
Application
Mesures Commandes
Tâche i Tâche j Tâche k Tâche x Tâche y
…
Requête Activation, …
Horloge Noyau ou Exécutif

temps réel Gestion 1/ Gestion des entrées/sorties
du temps Gestion …
des • Gestion des interruptions
Interruptions événements • Gestion des interfaces d'entrées/sorties
Gestion
… 2/ Ordonnancement des tâches
des interruptions
• Orchestration du fonctionnement normal
• Surveillance
Ordonnanceur • Changements de mode
3/ Relations entre les tâches
• Synchronisation, communication
• Accès à une ressource
• Gestion du temps (compteur, chien de garde)
Temps Réel
S2
Contraintes du temps d’un système
L. BOUHOUCH
2022/2023
PLAN
2
• Rappels ;
• Contraintes de temps faibles
• Algorithme adapté aux contraintes de temps ;
• Exemple : Programmation d'un terminal
• Contraintes de temps faibles avec qqs événements contraignants ;
• Algorithme adapté aux contraintes de temps ;
• Cas d'une seule interruption (I1) de récurrence f1=1/T1 ;
• Cas de plusieurs interruptions traités de façon séquentielles ;
• Cas d'interruptions emboîtées ;
• Exemple : Terminal avec réception de caractères à vitesse élevée
RAPPELS
3
 Multitâche = Exécution de fonctions de façon concurrente.

 Multi processus = Exécution de processus de façon concurrente.
 Tâches = Fonctions ou procédures exécutées de façon concurrente.
 Système Temps Réel = Système qui respecte les contraintes de temps.
 1 Tâche est exécutée en réponse aux sollicitations externes ou internes avec
contraintes de temps fixées par l'évolution du procédé à contrôler.
 Pour l’Evénement Ei (Etat d'un capteur ...)  Nécessité de calcul de l’ensemble des
fonctions Fj dépendantes de l'état Q de la commande.
 Durée de calcul tc : fonction des algorithmes utilisés et de la puissance du processeur.
 Procédé contrôlé fixe une Echéance de temps Te pour chaque calcul.
Echéance caractérisant le système temps réel.
On a des systèmes à :
 Contraintes de temps faible et variées : tc << Te  Temps réel Mou
 Contraintes de temps faible avec qqs événements contraignants,  Temps réel Dur
 Contraintes de temps fortes : tc ≈ Te.
CONTRAINTES DE TEMPS FAIBLES
4
 Algorithme adapté aux contraintes de temps

  Type de contrainte solutionné par une programmation en mode bouclé
(gestion des E/S par scrutation)
 Le programme scrute en permanence les entrées avec un temps ty < Te.
 Bouclages en arrière en attente d'événements interdits, car ils rallongent la durée du
cycle ty de façon indéterminée.
 Mode de programmation très utilisé essentiellement du fait de sa simplicité.
 Programmation simple à mettre en œuvre
Mais inconvénients :
 Difficile à maintenir et à faire évoluer.
 Lors de modifications ou d'ajouts de fonctions, les contraintes de temps peuvent ne plus être
respectées.
 Cohabitation des contraintes de temps faible avec des contraintes fortes.
 Alternative : Remplacer calculateur par un modèle plus puissant
 Evite la réécriture complète du programme.
5
 EXEMPLE : Programmation d'un terminal

 Un terminal ou périphérique de dialogue opérateur (clavier). Il
permet d'afficher sur sa sortie de dialogue (tube cathodique ou
écran LCD), les caractères arrivant sur son entrée de communication.
 Simultanément tout caractère frappé au clavier (entrée de dialogue) est
transmis sur sa sortie de communication.
Le cahier des charges fixe les contraintes de temps suivantes :

 Vitesse de frappe maxi : vf = 10 caractères/secondes ;
 Vitesse d'affichage constatée sur l'écran : 1000 caractères/secondes ;

 Vitesse de réception ou d'émission des caractères sur la ligne : 50 à 38400 Bauds;
 Format (10 bits au total) : 8 bits de données, 1 bit de start, 1 bit de stop.
6
 EXEMPLE : Programmation d'un terminal (suite)

 Diagramme SART (Structural Analysis Real Time) est donnée ci-dessous :  2 tâches :
 Tâche Lire : Effectue l'acquisition et l'envoi des caractères frappés sur clavier.
 Tâche déclenchée par la frappe d'un caractère.
 Tâche Afficher : Affiche le caractère présent sur le port série.
 Tâche déclenchée par la réception d'un caractère.
7

 Organigramme simplifié du programme terminal donné ci-dessous.
 Supposition : Un caractère a eu le temps d’être
Cahier des charges :
transmis entre deux frappes successives au clavier.
 Vitesse de frappe maxi :
vf = 10 caractères/secondes ;
 Détermination des contraintes de temps  Vitesse d'affichage constatée
sur l'écran :
Pour une vitesse de réception de 600 Bauds. 1000 caractères/secondes ;
 Échéances:  Vitesse de réception ou
 Tâche acquisition : Te1 = 0,1s [car vf = 10 car./s] d'émission des caractères sur
(indépendant de la vitesse de réception), la ligne : 50 à 38400 Bauds;
 Format (10 bits au total) :
 Tâche réception : Te2 = (1+8+1)/600 = 16,7.10-3s
8 bits de données, 1 bit start,
1 bit stop.
8

 Vérification du respect des contraintes de temps :
 Déterminer le temps de scrutation  Nécessité de prendre en compte le cas le plus
défavorable, c'est à dire lorsqu'un caractère doit être affiché sur l'écran et qu'un
caractère est lu au clavier.
 Simplification : Temps de scrutation (ty) est essentiellement lié à la vitesse d'affichage

(1000 caractères/secondes).
  Temps de cycle de : ty = 10-3s
  Contraintes de temps : Te1 = 0,1s et Te2 = 16,7.10-3s
  ty << Te2 << Te1 Vérifié

9

 Vérification du respect des contraintes de temps :
 Si vitesse réception = 19200 Bds
  Contrainte : Te2 = 10/19200 = 0,52.10-3s  Te2<ty = 10-3s avec Te1 = 0,1s
  ty << Te2 Non vérifiée
 Tout en satisfaisant ty << Te1
 Contrainte Te2 non satisfaite

  Le terminal perdra des caractères reçus sur la ligne série mais par contre ne perdra
aucun caractère frappé au clavier !
Programmation par scrutation non valable si les contraintes de temps sont hétérogènes.
Il faut dissocier les tâches à fortes contraintes de temps, de celles à faibles contraintes, par
un traitement hors de la boucle scrutation.
CONTRAINTES DE TEMPS FAIBLES AVEC QUELQUES
EVENEMENTS CONTRAIGNANTS
10
 Algorithme adapté aux contraintes de temps

 Si temps de cycle de boucle de scrutation ne permet pas de satisfaire un nombre réduit
de contraintes  Associer les fonctions concernées par ces contraintes à des
interruptions matérielles.
 Chaque interruption  liée à
un ou plusieurs événements. Si
événement se produit 
l'interruption arrête l'exécution
de la boucle de scrutation et
lance le programme tâche
matérielle.  Calculateur sera
ainsi synchronisé sur ces
événements et exécutera les
traitements liés aux
interruptions en suspendant le
programme en cours
d’exécution.
11
 Solution présentant plusieurs avantages :
 Evénements liés aux interruptions ne nécessitent aucune attention dans la boucle de
scrutation.
 Durée de boucle n'a pas d'importance par rapport à l'événement considéré si elle ne
gère pas un procédé possédant des contraintes de temps.
 Boucle de scrutation non ralentie par le test systématique de présence d'événements
 Efficacité accru du traitement réalisé.
 Rythme d'échange d’informations est fixé par le dispositif lié aux interruptions et non par
des contraintes de programmation de la boucle de scrutation.
 A retenir :
 Lorsque survient une interruption, la boucle de scrutation stoppe qqs s, pouvant même
s'arrêter complètement si plusieurs interruptions surviennent à un rythme très rapide.
 Phénomène pouvant être mis très facilement en évidence en pilotant une ligne
d'interruption à l'aide d'un générateur de signaux périodique.
 Programmation d’échanges de données entre boucle de scrutation et le(s) programme(s)
d'interruption peut être délicate.
 Réaliser des échanges fiables entre programmes fonctionnant de façon asynchrone
non trivial.
12
 Vérification des contraintes de temps :

 Traitement d'interruption rallonge le temps de cycle du programme interrompu.
  Contraintes temporelles devront être analysées avec soin.
Plusieurs cas à envisager selon que les interruptions sont ou non emboîtées.
 1. Cas d'une seule interruption (I1) de récurrence f1 = 1/T1
 Soient 2 procédés possédant des contraintes de temps hétérogènes :
- Traitement du procédé à forte contrainte (P1) géré par interruption, et

- Traitement du procédé à faible contrainte de temps (P0) géré dans la boucle de
scrutation :
 On a :
- T1 : Période de l’interruption I1
 Te1 : Echéance de temps fixé par le procédé à contrôler
- ty1 : Temps de calcul (continu) de la tâche P1
- ty0 : Durée de boucle de scrutation de la tâche P0
- Te0 : Echéance de temps du procédé géré par P0
13
  Afin de ne pas perdre des signaux d'interruptions ou pour éviter une récursion
infinie  ty1 < T1 (Durée de traitement d'interruption < sa périodicité)
T1
  Durée de traitement de P0 est multiplié par un facteur K tel que : K ≈
T1 – ty1
  Satisfaire la contrainte Te0  on doit avoir : K . ty0 < Te0
 Si le programme doit gérer plusieurs interruptions simultanées  2 cas à envisager:
- Interruptions traitées séquentiellement ou
- Interruptions emboîtées.
14
 2. Cas de plusieurs interruptions traités de façon séquentielles
 Soient :
- T1 : Période de l’interruption I1, fréq. f1 = 1/T1
- T2 : Période de l’interruption I2, fréq. f2 = 1/T2 et T2 < T1
- Te0 : Echéance de temps du procédé géré par P0
  Afin de ne pas perdre des signaux d'interruptions on doit avoir :
(ty1 + ty2) < T2 (avec T2 < T1)
T2
  Durée de traitement de P0 sera multiplié par le facteur K' tel que : K' ≈
T2 – (ty1 + ty2)
  Afin de satisfaire la contrainte Te0 on doit avoir : K' . ty0 < Te0
15
 3. Cas d'interruptions emboîtées (Notion de priorité)

 Dans ce modèle, une interruption peut être exécutée durant l'exécution d'une autre
interruption moins prioritaire.
 L'interruption la plus prioritaire doit être celle de récurrence la plus élevée (Faible T) ;
soient :
- T1 : Période de l’interruption I1
- T2 : Période de l’interruption I2 avec T2 < T1
- Te0 : Echéance de temps du procédé géré par P0o
16
  Afin de ne pas perdre des signaux

d'interruptions et pour éviter une
récursion infinie
 ty2 < T2 (Durée de traitement
d'interruption I2 < sa périodicité)
  Traitement de l'interruption I2
emboîtée dans T1 rallonge ty1 d'un
facteur K2 tel que : T2
K ≈
2
T2 – ty2
  Pour satisfaire la contrainte Te1  on doit avoir : K2 . ty1 < Te1

  Traitement de l'interruption I1 rallonge à son tour le temps de traitement de la boucle
T1
P0 d'un facteur K1 tel que : K1 ≈
T1 – (ty1 . K2)
  Pour satisfaire la contrainte Te0  on doit avoir : K1 . ty0 < Te0
17
 EXEMPLE : Terminal avec réception de caractères à vitesse élevée

 Diagramme à 3 tâches :
 Tâche Lire :  Exécution dépendant des conditions externes non liées à une
interruption (caractère frappé).
 Tâche Lire_ligne : Déclenchée par l'interruption de réception d'un caractère.  Place
le caractère reçu dans un tampon (FIFO). Pas de débordement du tampon envisagé.
 Tâche Afficher :  Exécution dépendant d'une condition interne (taux de remplissage
du tampon).
18
 EXEMPLE : Suite
 Algorithme simplifié du programme terminal :
P0
- T1 : Pér. I1 
P1
Echéance : Te1
de l’Interruption
- ty1 : Tcalc de P1
d’exécution
- ty0 : Durée boucle
scrut. P0
Durée
- Te0 : Echéance de P0
 Satisfaire contr. Te0

 K.ty0 < Te0
T1
K≈
T1 – ty1
Rappel : Cas d'1 Interruption

19
 EXEMPLE : Suite
 Hypothèses :
 Temps de cycle cumulé des tâches afficher et lire : ty0 = 2.10-3 s
 Echéance de temps fixée par la tâche lire : Te0 = 0,1 s
 Durée du programme d'interruption : ty1 = 0,255.10-3 s
 Exemple de réception à 9600 Bauds :
 f1 = 9600/10 bits = 960 Interruptions/secondes.
  Contraintes de temps :
 Te1 = 10/9600 = 1,04.10-3 s
 ty1 vérifie la contrainte Te1 (0,255.10-3 s < 1,04.10-3 s)
 Pire cas ty0 . Te1/(Te1 - ty1) = 2.10-3x1,04.10-3/(1,04.10-3 - 0,255.10-3) = 2,65.10-3 s
  Contrainte sur Te0 vérifiée : 2,65.10-3 s < 0,1 s

20
 EXEMPLE : Suite
 Réception à 19200 Bauds :
 Te1 = 10/19200 = 0,52.10-3 s
 Pire cas ty0 . Te1/(Te1 - ty1) = 2.10-3x0,52.10-3/(0,52.10-3 - 0,255.10-3) = 3,92.10-3 s
 Contrainte sur Te0 vérifiée : 3,92.10-3 s < 0,1 s
 Réception à 38400 Bauds :

 Te1 = 10/38400 = 0,26.10-3 s
 Pire cas ty0 . Te1/(Te1 - ty1) = 2.10-3x0,26.10-3/(0,26.10-3 - 0,255.10-3) = 0,104 s > 0,1 s
 Contrainte Te0 non satisfaite  Associer la frappe d'un caractère à une interruption
(priorité < à celle de réception).
21
 EXEMPLE : Suite
 Diagramme de flots de données
correspondant  4 tâches :
 Tâche matérielle Lire : Déclenchée par l'interruption due à la frappe d'un caractère
clavier.  Place le caractère reçu dans un autre tampon (FIFO). Pas de débordement
du tampon envisagé.
 Tâche matérielle Lire_ligne : Déclenchée par l'interruption de réception d'un caractère.
 Place le caractère reçu dans un tampon (FIFO). Pas de débordement du tampon
envisagé.
 2 Tâches logicielles Afficher et Emettre :  Exécution dépendant des conditions
internes (taux de remplissage des tampons d'émission et de réception).
22
 EXEMPLE : Suite ( Algorithme de programmation )

// Boucle de scrutation
Faire
Si Tampon de réception Non vide Alors
extraire, afficher le caractère en tête du tampon
Si Tampon clavier (d'émission) Non vide Alors
extraire, émettre le caractère en tête du tampon
Fin
// Programme d'interruption de réception d'un caractère
Début
Sauvegarder les registres utilisés
Lire le caractère, le mémoriser dans le tampon de réception
Restituer les registres utilisés
Acquitter l'interruption
Fin
// Programme d'interruption de lecture du clavier
Début
Sauvegarder les registres utilisés
Lire le code clavier et le transformer en code ASCII
Mémoriser le code ASCII dans le tampon d'émission
Restituer les registres sauvegardés
Acquitter l'interruption
Fin
23
Conclusion
 Lorsque les contraintes de temps sont nombreuses et variées, la programmation
peut devenir très complexe. On préfère alors contrôler les tâches à l’aide d'un
programme spécial appelé moniteur temps réel.
Celui-ci se charge de lancer, de synchroniser et d'arrêter les tâches. Il fournit en
outre de puissants moyens de communication entre les tâches concurrentes.
Temps Réel
S3
Systèmes multitâches et
Noyau temps réel
L. BOUHOUCH
2022/2023
PLAN
2
• Introduction
• Etats d’une tâche :
• Non créé ;
• Dormant ou Créé ;
• Prêt ou Eligible ;
• En exécution ;
• Bloqué ou Suspendu ;
• Transitions entre états d'une tâche ;
• Politiques d'ordonnancement ;
• Systèmes avec/sans réquisition du processeur :
• Noyau coopératif
• Noyau préemptif ;
• Temps de latence ;
• Temps réel dur & mou ;
INTRODUCTION
3
 Dans les procédés  Notion de tâches :

 Tâche matérielle (tâche liée aux interruptions) et
 Tâche logicielle (tâche de fond).
 Un moniteur temps réel et un système multitâche permettent d’exécuter

des fonctions de façon concurrente ( Tâches) en leur attribuant :
 Un niveau de priorité,
 Un quantum de temps processeur pour les systèmes monoprocesseur,
 Un processeur pour les systèmes multiprocesseurs.
ETATS D’UNE TACHE
4
 A un instant donné, chaque tâche se trouve dans l’un des états suivants :
 Passage d’1 état à 1 autre s'effectue à

l'aide d’appel de requêtes programmées
dans le noyau.
 Ensemble des requêtes forme les primitives
de l'exécutif temps réel ou de l'exécutif
multitâche.
ETATS D’UNE TACHE
5
 Propriétés des différents états :

 NON CREE
 Tâche inconnue de l'exécutif.
 DORMANT ou CREE
 Tâche connue par son identificateur et la zone de pile qui lui est attribuée. Elle reste dans
cet état tant qu'une requête d’activation ne la fait pas évoluer.
 PRET ou ELIGIBLE
  Tâche candidate pour l'exécution. Son lancement dépend de sa priorité par rapport
aux autres tâches éligibles ou en cours d'exécution.
Si elle est prioritaire, l'ordonnanceur lui attribue le processeur.
ETATS D’UNE TACHE
6
 Propriétés des différents états :

 EN EXECUTION
  Tâche en possession du processeur. Si système monoprocesseur, plusieurs tâches de
même priorité peuvent être en exécution mais 1 seule est en possession du processeur réel,
chaque tâche se voyant attribuer un quantum de temps processeur. Tant qu'elle est
prioritaire et qu'elle n’exécute pas une requête de suspension directe ou indirecte, une
tâche reste dans cet état.
 BLOQUE ou SUSPENDU
  Tâche ne possédant plus le processeur et son état est sauvegardé en vue de sa future
reprise.
TRANSITIONS ENTRE ETATS D’UNE TÂCHE
7
Franchissement des transitions = Conséquence

d'appels directs ou indirects aux primitives de
l'exécutif.
 CREATION D'UNE TACHE (CREER)
 Se faire connaître par l'exécutif  Fournir
adresse de début, taille de pile et niveau de
priorité. En retour : Noyau fournit un
identificateur référençant la tâche.
 Pile utilisée pour loger variables locales et
adresses de retour lors des appels de fonctions.
Sert aussi à mémoriser le contexte du processeur
lors de commutations de tâche.
 Pile insuffisante  Souvent cause des
dysfonctionnement mystérieux.
 Certains systèmes utilisent les mécanismes
d'exceptions du processeur pour déterminer les
débordements de pile et réallouer
automatiquement une pile supplémentaire.
8
 ACTIVATION D'UNE TACHE (ACTIVER)

  Demande d'exécution. L'activation peut être
immédiate, différée ou cyclique.
 Activation immédiate  Faire passer une tâche
de l'état dormant à l'état prêt, mais ne
correspond pas à l'appel direct de la fonction
tâche (lancement restant sous le contrôle de
l'ordonnanceur).
 Demandes d'activation généralement
mémorisées : Aux demandes d'activations
correspondent 3 cycles : DORMANT → PRET →
EXEC → DORMANT.
 Une activation différée consiste à lancer une
tâche après un délai précis.
 Une activation cyclique consiste à relancer une
tâche avec une période précise.
9
 ATTRIBUTION DU PROCESSEUR A LA TACHE

 Tâche lancée depuis son début. Ce début
d’exécution non forcément immédiat : Si
d'autres tâches (même priorité) sont déjà dans
cet état, la tâche attendra son tour suivant le
mécanisme du tourniquet.
 Transition non maîtrisée par le programme,
mais par l'ordonnanceur.
10
 SUSPENSION D'UNE TACHE (SUSPENDRE)

 Tâche stoppée  Son contexte est enregistré
de façon à pouvoir la reprendre exactement
à l'endroit ou elle s’est arrêtée.
 Suspension de tâche obtenu par appel direct
(instruction ou requête DORT) ou indirect à
travers une primitive et sur des conditions
particulières.
 REPRISE D'UNE TACHE BLOQUEE (REVEILLER)

 Transition non contrôlée directement.
 Si toutes les conditions sont réunies pour
continuer une tâche (priorité max. par rapport
aux autres, disparition des conditions de
blocage)
 Contexte de tâche est rechargé et celle-ci
est relancée à l'endroit où elle s'était arrêtée.
11
 FIN D'UNE TACHE ou DESTRUCTION D'UNE TACHE
(DETRUIRE)
 Tâche terminée ou détruite est replacée à l'état
dormant.
 Fin de tâche peut être obtenue par un appel
explicite au noyau ou implicite lors de la fin de
la tâche.
 SUPPRESSION D'UNE TACHE (SUPPRIMER)
 Optimiser l'usage des ressources  La requête
SUPPRIME remet la tâche à l'état Non CREE.
 ATTRIBUTION DU PROCESSEUR REEL
 Transition a lieu tous les quantums pour qu’une
tâche soit à l'état EXEC.
 Transition non maîtrisable directement.
 ATTRIBUTION DU PROCESSEUR VIRTUEL
 Transition ayant lieu chaque fois qu'une tâche a
utilisé le processeur réel durant un quantum.
POLITIQUES D'ORDONNANCEMENT
12
 La politique d'ordonnancement définit le critère utilisé par le noyau pour élire une tâche.
 Diverses politiques d'ordonnancement sont utilisées :
 1- Ordonnancement Circulaire ou Tourniquet :
 Les tâches possèdent la même priorité.
 Les tâches se partagent le processeur sans affinité particulière.
 Convient rarement pour les systèmes temps réel.
13
 Ordonnancement Circulaire ou Tourniquet :
Exemple tourniquet :
 Soit 3 tâche T1, T2, T3 de durées
respectives 6, 3, 4 démarrant à 0.
 En s’exécutant pendant 1 quantum
chacune, l’ordre d'exécution est :
 T1-T2-T3 - T1-T2-T3 - T1-T2-T3
- T1-T3-T1-T1
T3
T2
T1
14
 2- Ordonnancement à Priorité fixe :

 Chaque tâche possède un niveau de priorité différent.
 La tâche exécutée est toujours la plus prioritaire.
 Bien adapté aux systèmes temps réels.
15
 Ordonnancement à Priorité fixe :
Exemple de priorité Fixe :

 Soit 3 tâche T1, T2, T3 de durées
respectives 6, 3, 4 et de Priorités
respectives 2, 1, 2.
 En s’exécutant selon l’ordre des
priorités, l’ordre d'exécution est :
 T2-T2-T2 - T1-T3 - T1-T3 -
T1-T3 - T1-T3 - T1 - T1
T3
T2
T1
16
 3- Ordonnancement à Classe de priorités (Combinaison des deux politiques précédentes) :

 Tâches groupées par classe de priorité au sein desquelles l'ordonnancement est de type
circulaire.
 Système présentant le maximum de souplesse.
17
 4- Ordonnancement Par priorité avec Modification dynamique de la priorité en fonction de

l'âge de la tâche
 Politique faisant perdre progressivement la priorité aux tâches :
 Les tâches de courtes durées sont toujours exécutées en premier.
 Politique remplaçant le contrôle des tâches exercées par le programmeur, par celui
exercé par le noyau.
 Permet de faire fonctionner (mal) des programmes présentant des erreurs de
conception.
 Déconseillé pour la commande temps réel.
SYSTEMES AVEC OU SANS REQUISITION DU PROCESSEUR
18
Systèmes multitâches et Noyaux temps réels  2 catégories :

 Noyaux sans réquisition du processeur (No préemptive scheduling) : Systèmes Coopératifs.
 Le processus se termine complètement avant de rendre la main.
 Noyaux avec réquisition du processeur (Préemptive scheduling) : Systèmes Préemptifs.

 Le processus peut être interrompu pour rendre la main
 NOYAU COOPERATIF
  Au programmeur de décider de l’instant de commutation par un appel explicite.

 Type de noyau très efficace, mais moins tolérant aux erreurs de conception des
applications.
 Généralement utilisé dans les applications à très forte contrainte de temps.
 Si une tâche se bloque (erreur de programmation ou matérielle), l'ensemble des tâches se
bloque également.
 Exemple typique de système coopératif : Windows 3.1
19
 NOYAU PREEMPTIF
  Noyau avec réquisition du processeur alloue celui-ci de façon transparente aux tâches,
en fonction des priorités en cours.
 La tâche qui se trouve Préemptée n'a aucune possibilité de le savoir.
 Mécanisme réalisé par un programme d'interruption lancé par une interruption périodique
à forte priorité. Ce programme explore les files de tâches prêtes ou suspendues et
attribue le processeur à l'une d'elle selon une politique d'ordonnancement spécifique à
chaque noyau.
20
 Exemple simple où un ordonnaceur PRÉAMPTIF sera mis en Echec

(Th1 prioritaire sur Th2)
Th C P D
Th1 T1
1 1.8 4.3 4.3
T2
2 5.0 8.6 5.6
Non PREEMPTIF
Th2
Th1
PREEMPTIF
Th2
21
 Exemple simple où un ordonnaceur NON-PRÉAMPTIF sera mis en Echec

(Th1 prioritaire sur Th2)
Th C P D
Th1 T1
1 2.5 5.0 5.0
T2
2 6.8 15 15
Non PREEMPTIF
Th2
Th1
PREEMPTIF
Th2
22
 TEMPS DE LATENCE
 Sections de code non interruptibles perturbent le fonctionnement des systèmes

Coopératifs et Préemptifs.
 Ces sections doivent être très courtes.
 Diminuer le temps s'écoulant entre apparition d'une interruption et son traitement effectif.
 Temps appelé temps de Latence : L’un des critères distinguant les noyaux temps réels Mou
(systèmes multitâches), des noyaux temps réel Durs.
 Temps de latence est généralement < 50 µs.
 TEMPS REEL DUR, TEMPS REEL MOU
  Noyau temps réel Mou ne spécifie ni les temps de commutation de contexte, ni les temps
de latence.
 Un noyau temps réel Dur garanti un temps max. de commutation de contexte et un temps
de retard max. entre l'apparition d'interruption et son début de traitement.
 Les temps de commutation de contexte : de 1 à 100 µs (fonction du noyau et processeur),
soit 10000 commutations/secondes dans le cas le plus défavorable.
Temps Réel
S4
Noyau temps réel Mtr86-68K
L. BOUHOUCH
2022/2023
PLAN
2
• Services offerts par le noyau temps réel Mtr86-68K

• Structure d’une application Mtr86-68K
• Politique d’ordonnancement dans Mtr86-68K ;
• Création et activation d’instances multiples d’une même tâche ;
SERVICES OFFERTS PAR LE NOYAU TEMPS REEL Mtr86-68K
3
Mtr86 existe sous différentes formes :

 Mtr86-Dos : Noyau temps réel dur.
 Mtr86-68K pour EID210 : Noyau temps réel dur.
 Mtr86-Win32 : Noyau temps réel mou (dans sa forme actuelle)
 Mtr86-Win32 Objet : Noyau temps réel mou (dans sa forme actuelle)
 Linux-rt (Noyau Linux standard + patch PREEMPT-RT) : Noyau temps réel dur.
Traite :
 Gestion des tâches selon un Mécanisme approprié.
 Accès concurrent aux données partagées.
 Mécanismes de communications.
 Mécanismes de synchronisation.
Structure d’une application Mtr86-68K
STRUCTURE D’UNE APPLICATION Mtr86-68K
5
#include "mtr86.h" // Les fichiers à inclure dépendent de la cible ; ici le Mtr86-68K
// Prototype des fonctions – Parfois facultatif, cela dépend de l’emplacement de main() et init()
[TACHE init(void) ;] // Prototype de la tâche init. (Tâche d’initialisation) possédant la plus haute priorité.
// Aucune autre tâche ne s’exécute tant que celle-ci n’est pas terminée ou suspendue
[TACHE T(void) ;] // Prototype de la tache T.
TACHE init(void)
{
// Créer les sémaphores (variables permettent de compter le nombre de tâches endormies ou les réveils en
attente), tubes, et autres mécanismes
//...
// Créer et éventuellement activer les tâches
active(cree(T, 1, 512)) ; // crée et active la tâche T de priorité 1 et 512 octets de pile.
// Suspendre ou terminer la tâche
// La fin de l’application est obtenu par un appel à la primitive mtr86exit(0) dans une tâche quelconque
}
TACHE T(void)
{ // ...
}
main()
{
start_mtr(init, 512) ; // Lance la tâche init avec une taille de pile de 512 octets
}
Mise en évidence de la politique
d’ordonnancement dans le Mtr86-68K
MISE EN EVIDENCE DE LA POLITIQUE D’ORDONNANCEMENT DANS Mtr86
7
#include "mtr86.h"
TACHE T1(void)
{
long i, j ;
// Durant cette séquence T2 et T3 sont arrêtés
printf("T1: actif (priorité 1) et bloque T2 et T3 (priorité 2)\n") ;
for (j=0 ; j<1000000 ; j++) ;
// Remarque : cette séquence alloue le processeur pour un travail inutile (pour peut être effectuer une
// temporisation). Cette façon de procéder gaspille le temps CPU et ne doit jamais être utilisée.
// Durant la séquence suivante T2, T3 sont actifs à chaque appel de dort durant 1 quantum.
printf("T1: Se suspend périodiquement et libère du temps processeur pour T2 et T3\n\n") ;
for(j=0 ; j<250 ; j++)
{
for(i=0 ; i<10000 ; i++) ; // Simuler l'activité de la tâche
dort(1) ; // T2 et T3 actifs durant 1 quantum (≈1 ms)
}
MONITOR // Accès exclusif de T1 à la ressource écran
gotoxy(1,8) ; // Aller à colonne 1 et ligne 8
printf("T1 : Fin  Accélération de T2 et T3\n\n") ;
ENDM // Fin accès
} //  T1 est arrêté, ce qui alloue le processeur à T2 et T3 : l'affichage est accéléré
8
TACHE T2(void) // T2 est exécutée de façon concurrente avec T3
{ unsigned i, j ;
for(j=0 ; j<300 ; j++)
{
gotoxy(1, 6) ; // Aller à colonne 1 et ligne 6
cprintf("T2 : j= %d\n", j) ;
ENDM // Fin accès
}
} //  T2 est arrêté
TACHE T3(void) // T3 est exécutée de façon concurrente avec T2
{ unsigned i, j ;
for(j=0 ; j<500 ; j++)
{
gotoxy(1, 7) ; // Aller à colonne 1 et ligne 7
cprintf("T3 : j= %d\n", j) ;
ENDM // Fin accès
}
mtr86exit(0) ; // Le noyau est stoppé. Sortie après start_mtr() //jamais exécuté
}
9
// Tâche d'initialisation. Possède la priorité maximale. Aucune autre tâche ne peut s'exécuter tant que celle-ci
// n'est pas terminée ou suspendue
// La tâche init dans cet exemple crée et active 3 tâches.
// La tâche T1 est la plus prioritaire et préempte le processeur au détriment des tâches T2 et T3.
TACHE init(void)
{
printf("Init debut\n") ;
active(cree(T1, 1, 1024)) ; // Crée et active la tâche T1 ; Priorité 1 ; 1024 octets de pile
printf("Init fin\n") ; //  A partir d'ici la tâche T1 est lancée en 1er
}
main()
{
// Lance la tâche init avec une taille de pile de 1024 octets
clsscr() ;
printf(" --------------------- Exemple ---------------------\n") ;
start_mtr(init, 1024) ;
}
Création et activation d’instances
multiples d’une même tâche
CREATION ET ACTIVATION D’INSTANCES MULTIPLES D’UNE MEME TACHE
11
Si les tâches effectuent un travail similaire  Créer des instances multiples d’une même tâche.
Problème posé : Tâche doit pouvoir s’identifier.
 Exemple créant et activant 8 instances d’une même tâche, chacune affichant la valeur d’un
compteur sur un emplacement différent de l’écran.
#include "mtr86.h"
TACHE init(void) ; // PROTOTYPES DES TACHES
TACHE T(void) ;
TACHE init(void)
{
int j ;
dsp_stk() ; // Visualise les consumations en fin de prog
for(j=0 ; j<8 ; j++)
active (cree(T, 2, 1024)) ; // Créer et lance les instances de tâches
dort (cvrtic(10000)) ; // Temporisation : cvrtic convertit les 10000 ms en quantums
mtr86exit(0) ;
}
CREATION ET ACTIVATION D’INSTANCES MULTIPLES D’UNE MEME TACHE
12
TACHE T(void)
{ int j = 0;
int x, y, tache ;
for( ; ; )
{
tache = tache_c() - 2 ; // Lit le numéro de la tâche courante (1er N° = 2)
x = ((tache%10) + 1)*7 ;
y = (tache/10) + 1 ;
MONITOR
gotoxy(x, y+10) ; // Aller à colonne x et ligne y+10
printf("%d\n", j++) ;
ENDM
dort (10) ;
}
}
main() // Tâche principale
{
clsscr() ;
printf("Exemple de création d'instances multiples d'une même tache.\r\n"
"init() crée 8 taches T() identiques, chacune incrémente un compteur et l'affiche sur l'ecran.\r\n"
"Fin au bout d’environ 10s.\r\n") ;
start_mtr(init,1024) ;
}

Temps Reel Full Cours

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Temps Reel Full Cours

Transféré par

Droits d'auteur :

Formats disponibles

Temps Réel

Introduction aux Systèmes multitâches

• Introduction & définitions ;

• Bref historique du temps réel ;

• Principe de l’architecture & du fonctionnement du STR ;

• Notion de "Système Multitâches".

 Définition générale (CNRS 1988) :

Temps de réponse imposé par la Commandes

 Définition générale (CNRS 1988) :

Temps de réponse imposé par la Commandes

 Classification et autres points de vue du temps réel.

Dynamique des procédés très différente suivant l'application :

 Mais de quel temps s'agit-il ?

 Deux notions de criticité face au manquement d'une échéance

 => Temps réel Dur / Temps réel Mou (ou Lâche) !

– Téléphonie mobile : le système de contrôle-commande doit remplir plusieurs fonctions dont

– Le système contrôlé = Environnement (procédé) équipé d'une instrumentation

– Le système de contrôle = Eléments matériels (processeurs …) et logiciels dont

 Via les mesures issues des capteurs, et Interface actionneurs

 Les commandes envoyées aux actionneurs Environnement

 => Acquisition des mesures périodiques à une cadence compatible avec la

 => Double rôle du système de contrôle

 Fonctionnement général : boucle infinie

 Tant que TOUJOURS faire

 Il existe ainsi 2 modes de fonctionnement :

 Pour des raisons de facilité de conception, de mise en œuvre et d'évolutivité,

 Tâche associée à : Système informatique du STR doit :

programme temps réel

Coopération entre tâches

Horloge Noyau ou Exécutif

Contraintes du temps d’un système

 Multitâche = Exécution de fonctions de façon concurrente.

 Algorithme adapté aux contraintes de temps

 EXEMPLE : Programmation d'un terminal

Le cahier des charges fixe les contraintes de temps suivantes :

 Vitesse d'affichage constatée sur l'écran : 1000 caractères/secondes ;

 EXEMPLE : Programmation d'un terminal (suite)

 EXEMPLE : Programmation d'un terminal (suite)

 EXEMPLE : Programmation d'un terminal (suite)

 Simplification : Temps de scrutation (ty) est essentiellement lié à la vitesse d'affichage

  Temps de cycle de : ty = 10-3s

  Contraintes de temps : Te1 = 0,1s et Te2 = 16,7.10-3s

  ty << Te2 << Te1 Vérifié

 EXEMPLE : Programmation d'un terminal (suite)

  ty << Te2 Non vérifiée

 Tout en satisfaisant ty << Te1

 Contrainte Te2 non satisfaite

 Algorithme adapté aux contraintes de temps

 Vérification des contraintes de temps :

- Traitement du procédé à forte contrainte (P1) géré par interruption, et

 3. Cas d'interruptions emboîtées (Notion de priorité)

  Afin de ne pas perdre des signaux

  Pour satisfaire la contrainte Te1  on doit avoir : K2 . ty1 < Te1

 EXEMPLE : Terminal avec réception de caractères à vitesse élevée

 Satisfaire contr. Te0

Rappel : Cas d'1 Interruption

 ty1 vérifie la contrainte Te1 (0,255.10-3 s < 1,04.10-3 s)

 Pire cas ty0 . Te1/(Te1 - ty1) = 2.10-3x1,04.10-3/(1,04.10-3 - 0,255.10-3) = 2,65.10-3 s

  Contrainte sur Te0 vérifiée : 2,65.10-3 s < 0,1 s

 Réception à 38400 Bauds :

 EXEMPLE : Suite ( Algorithme de programmation )

 Dans les procédés  Notion de tâches :

 Un moniteur temps réel et un système multitâche permettent d’exécuter

 Passage d’1 état à 1 autre s'effectue à