COURSTR
COURSTR
COURSTR
SOMMAIRE
Sommaire 1
Chapitre 1 INTRODUCTION AUX SYSTEMES TEMPS REEL 3
I- Rappel à la notion de multitâches 3
a- Définition de multitâche 3
b- La notion de processus 3
c- Les appels systèmes 4
d- La communication et la synchronisation 4
II Les spécification temps réel 8
a- Définition 8
b- Système informatique 9
c- Procédé a commander 9
d- Les contraintes temps réel 10
e- Le facteur temps 11
Chapitre 3 LA SPECIFICATION 18
I- Aspect fonctionnel 18
1- Introduction 18
2- Exemple 19
3- Diagramme de flots de données 22
4- Les règles de formation et d'interprétation d'un DFD 24
5- La spécification de processus 26
Chapitre 1
Zone Zone
données programme
Pointeur de pile
Zone de pile
D- La communication et la synchronisation:
En environnement multitâches, les processus coopèrent en vue de la réalisation d'une
activité commune.
On distingue deux sortent de coopérations:
?
Processus ELU
SELECTION DEBLOCAGE
(Dispatcher) DES PROCESSUS
ROLE DE L'ORDONNENCEUR
INEXISTANT 1
2
HORS Service
3 7
14
TAYARI Lassaad Page 6 ISET DE SFAX ~ A.U 97/98
Cours d’STR Informatique Industrielle
Introduction aux systèmes temps réel
13 4
11 Eligible
En Attente de 12
Ressource
6 5
15
8
En Attente de 9
Délai Elu
16 10
En Attente
événement
a- Définition:
Action
SYSTEME Information sur PROCEDE A
INFORMATIQUE état COMMANDER
(événement)
ETAT1
événement 1
action 1
ETA2
b- Système informatique :
Généralement le système informatique est un système multitâches. Plusieurs
solutions sont envisageables:
* PC++[(NTR) ou Carte NTR]
* UNIX + NTR (Noyau temps réel)
Exemple: NTR ou A6RMTR ou PSOS ou Vxworks
c- Procédés à commander:
* Moteur : Axe d'un robot
* Robot: N Axes à commander
* Four électrique
* Avion
* Militaire (guidage de missile ... etc.)
* Télécommunication (Gestion des engorgement ... etc.)
Exemple:
Soit un système embarqué à bord d'avion, qui a pour but de fournir la position
instantanée de celui-ci, par rapport à un point de référence, en fonction des différents
paramètres d'entrées à partir d'un certain nombre de capteurs.
Le temps de traitement global est le temps mis pour:
- acquérir: toutes les données fournies par les capteurs
- traiter: ces données
- fournir: un résultat.
On peut ainsi décomposer ces trois traitements en trois tâches distinctes et
indépendantes.
Si T1 = temps d'acquisition
T2 = temps de traitement
T3 = temps mis pour fournir le résultat
et Tlim = le temps limite à respecter.
Il faut donc que T1 + T2 + T3 < Tlim pour que notre système fonctionne en temps
réel Communication
Communication
Communication
Communication TACHE2
TACHE2 TACHE3
TACHE3
TACHE1-TACHE2
TACHE1-TACHE2
Interruption
Interruption TACHE 1 TACHE
TACHE22 TACHE
TACHE33
périphérique TACHE 1
périphérique
Acquisistion
Acquisistionde Traitement Stockage
Stockageetet
de Traitementde
de affichage
données affichagede
de
TAYARI Lassaad données
temps=T1 Page 9 données
données ISET DE RESULTAT
SFAX ~ A.U 97/98
temps=T1 temps=T2
temps=T2 RESULTAT
temps=T3
temps=T3
Donc :
La définition d'une application temps réel est caractérisée avant tout par la
synchronisation entre le traitement de l'information et la génération de données issues
du monde extérieur.
Un programme temps réel fonctionne donc sous contrôle des sollicitations du monde
extérieur, par opposition à un programme classique linéaire qui commande les flots de
données en entrée et/ou en sortie.
TR = Tcalcul + TE/S
c- Le déterminisme = délai:
Le phénomène de délai (déterminisme) impose l'exécution d'un traitement dans un
temps maximal qu'on définit. Ce délai est déterminé en fonction du matériel
Arrivée d'une
(processeur) utilisé et de l'exécutif temps réel (temps de commutation).
interruption Traitement de
l'interruption
TACHE A
TACHE A
DELAI URGENCE
URGENCE ET DELAI
Cours d’STR Informatique Industrielle
Introduction aux systèmes temps réel
• Du côté processeur:
Temps total de traitement = (ΣTemps de chaque instruction) + temps associés au interruptions
3- La préemption:
a- Définition:
La préemption est la réquisition du processus pour l'exécution d'une tâche et d'une
seule pendant un temps déterminé.
Donc la préemption est le fait de tenir compte du critère d'urgence du traitement.
t1 Tâche préemptive t1
t2 tn
t3
Chapitre2
Spécification
système
VALIDATION Tests d’intégration
système
Spécification
logiciel/performance VALIDATION Tests de
performance
Spécification
Validation
Conception VERIFICATION
préliminaire Tests d’intégration
Conception Réalisation
Conception Tests unitaires
détaillée
Codage
programmation [CALVEZ]
"cycle en cascade"
Conception
détaillée du
logiciel
Expression
du besoin
Spécification
Conception système Conception
détaillée du détaillée du
logiciel matériel
Système
final
Validation
système
Construction Construction
du logiciel du matériel
Système intégré
Logiciel de Prototype
référence matériel
Intégration
système
Axe de symétrie
[PEREZ]
Chapitre3
LA SPECIFICATION
I/ ASPECT FONCTIONNEL:
1- Introduction:
L'aspect fonctionnel d'un STR porte sur:
f les fonctionnalités que le système doit satisfaire
f les informations qu'il doit traiter au niveau logique. Cette étape ne doit pas tenir
compte de la manière de réalisation.
Le modèle fonctionnel prend en considération:
Les données porteuses de traitement
- leur provenance
- leur destination
- leur stockage intermédiaire
Les transformations qu'elles subissent.
Le SA (Structered Analysis ) permet de modéliser, de façon statique, l'activité d'un système
sous forme de flots de données circulant entre les processus.
Un outil de modélisation de l'aspect fonctionnel d'un système doit permettre de:
f représenter le travail de transformation que le système opère sur les données
f spécifier les processus qui transforment les données.
nom d
e l’acqu
isition
Opérateur dem
a nd
Imprimante
e
co
m
pte n
isitio
ren
EXPLOITER acqu
du de l’
ort
rapp co
nt ur
a r g eme acquisition be
do
e ch
de d cu
o mman de
m
en
c t
e ur e ée
at c
dic sen
Système In pré Ecran
d’acquisition isi tion graphique
’a cqu
i er d
fich
commande de
chargement données de l’acquisition
OBTENIR
OBTENIR EXTRAIRE
données mesures brutes IDENTIFIER
données
nom de acquisistion acquisition
acquisistion 3.0
l’acquisition
1.0 4.0
1.0
mesures brutes
caractéristiques de demande
l’acquisition d’impression
mesures réelles
IMPRIMER
rapport
6.2
CALCULER
résultats
6.1 rapport de
l’acquisition
resultats
demande de
caractéristiques de visualisation
dimensions écran
l’acquisition
FORMATER
cartouche écran
7.1
cart
ouc
he é
cran
mesures réelle dimension fenêtre
u rbe courbe
co documentée
PRODUIRE
CALCULER courbe
maximum
7.2
7.3
demande de
mesure réelle maxi visualisation
Une flèche simple indique qu'il s'agit d'un flot de données discrets dans le temps. Ce flot
de données a un nombre de valeurs limitées et il est définis en des points isolés du temps, et
indéfinis en dehors de ses points.
Exemple: le code d'une carte DAB n'est valable que si la carte est insérée dans le lecteur.
Une flèche double indique qu'il s'agit d'un flot de données continu. Ce flot de données a
des valeurs définies en tout point du temps.
Exemple: température livrée par un capteur.
3.2- Processus:
Définition: un processus est une unité d'activité réalisée par le système, qui
change un ou plusieurs flots de données entrants en un ou plusieurs flots de données sortants.
Un processus accepte, stocke et/ou produit des flots de données.
Présentation: un cercle entourant L'identificateur du processus et un numéro
de référence. L'identificateur du processus décrit la transformation opérée à l'aide d'un verbe
d'action à l'infinitif, suivi, éventuellement, d'un complément d'objet direct, qui concerne la
boîtier
mesure brute
CONVERTI BOUCHER
R boîtier
mesure 2.1 boîtier bouché
1.0 mesure réelle
bouchon
énergie
CONTROL perdue
énergie brute ER
énergie énergie de
3.3 contrôle
robot
écran
diagramme dans lequel sont représentées les interfaces entre le système et l'environnement
(les bords).
Niveaux de décomposition: Un DFD de premier niveau, appelé diagramme
préliminaire, fait la décomposition des systèmes qui correspondent aux fonctions principales
du système et à leurs interfaces.
Chaque sous système est considéré à son tour comme système et il est décomposé
itérativement en sous systèmes.
La décomposition d'un processus s'accompagne de celle du contexte qui lui est associé, c'est-
à-dire des flots des données qui y entrent et qui en sortent.
A
3.2
B
3.1 C
3.3
A
B C
3.1.2
3.1.1
3.1.3
MAINTENIR
température commande de vanne
température
constante
5.4.3.1
0 si e > -2
Vv= 3e + 6 si |e| ≤ 2
12 si e < 2
Chapitre4
L'ASPECT INFORMATIONNEL
(Dictionnaire de donnees)
I/ INTRODUCTION
L'aspect informationnel contient la spécification de toutes des données du modèle.
On distingue deus types de données:
f les flots de données: constitués par des données composées et des données
primitives.
SYMBOLE SIGNIFICATION
= données composées de
+ regroupement sous ordre
[/] ou [!] Sélection, ou exclusif
{} Itération non bornée
n{}p Itération de n à p
n{},{}p Itération d'au moins, d'au plus p
n{}n Itération exacte de n
() Optionnel équivalent à {}1
"" Délimiteur d'expression littérale
** Délimiteur de commentaire
@ Clé d'accès
Exemple : Spécification de données composées:
données de l'acquisition = nom de l'acquisition + date acquisition + .....
.....+ fréquence d'échantillonnage
mesure brute = 1{@instant+mesure brute}4096
mesures réelles = *mesure brutes converties en réelles *
1{@instant + mesures réelles}4096
courbe documentée = courbe + cartouche écran
cartouche écran = nom acquisition + environnement acquisition
données Dictionnaire de
données
TAYARI Lassaad Page 29
DDISET DE SFAX ~ A.U 97/98
Chapitre5
L'APSPECT EVENEMENTIEL
I- INTRODUCTION
L'aspect événementiel prend en considération :
f Les conditions opératoires des processus, c'est à dire les événements qui les activent et les
désactivent.
f La façon dont les événements influencent le comportement du système.
L'aspect événementiel est spécifique aux systèmes temps réel.
Un outil de modélisation de l'aspect événementiel d'un STR doit permettre de:
représenter les événements qui conditionnent l'état d'un système.
Spécifier la logique de contrôle qui produit les actions et les événements en
fonction d'événements en entrée et fait changer l'état du système.
AMPLIFIER
amplitude
REDUIRE
amplitude
A/I marche
A/I
SAISIR A/I CONTROLER
signal amplitude
signal signal
sonore seuil mini arrêt
atteint signal
signaux saisis seuils seuil maxi D
normal
atteint
DETECTER signal
seuil
RESTITUER sonore
signal réstitué
Schéma préliminaire de Régulation d’amplitude d’un signal sonore
1- Transformation de contrôle:
f Définition:
Une transformation de contrôle est une unité de contrôle qui fait correspondre
des flots événements en sortie à des flots événements en entrée. Elle produit des événements
en sortie à partir d'événements en entrée, selon une logique principalement séquentielle.
f représentation:
Elle est représentée par un cercle en pointillé entourant l'identificateur de la transformation et
un numéro de référence.
Exemple:
CONTROLER
Pièce présente Présence pièce Usinage permis
1.1
2- stockage événement:
f Définition:
Un stockage événement est une mémorisation d'un ou plusieurs flots événement.
f représentation:
Il est représenté par deux lignes parallèles en pointillé, encadrant L'identificateur des
événements stockés.
Exemple:
EXEMPLE:
sup
po
rt prè robot libre
te
Pièces présentes
CONTROLER
assemblage
as
prèt po sem
a nt ss
ompos ib bla
c le ge
Etat courant
condition
action
Etat suivant
REPOS
marche . arrêrt .
modèle
d’environnement spécification des liste des
temps de réponce évènements externes
schéma de contexte
données évènements
modèle de
comportement Relations entre les composants du modèle de
spécification
Une gâche électrique est débloquée par envoie d'une tension et se rebloque dès que cette
tension cesse; un certain délai est laissé pour l'ouverture de la porte.
Exigences temporelles
Travail demandé:
1- donnez le diagramme de contexte
2- donnez le schéma préliminaire
3- détaillez la spécification des processus
4- donnez le dictionnaire de données
5- donnez la spécification de contrôle
SOLUTION POSSIBLE:
nte
ep rése
cart
COMMANDER commande
lecteur de carte déblocage
top d’horloge
ouverture gâche électrique
magnétique
de porte
impu
lsion
impul
s ion
commande
CONSTITUER DEBLOQUER déblocage
trame gâche
3.0 5.0
top d’horlage A/I
EFFACER A/I
LIMITER
trame délai écoulé
D CONTROLER déblocage
7.0 ouverture de 6.0
D
D porte
carte
code 1.0 libérée
valide carte
trame
VALIDER détéctée délai de garde
code code D
erroné TESTER
4.0 presence carte
2.0
code référence
carte présente
DICTIONNAIRE DE DONNEES
bit = [0|1]
bit parité = [0|1]
* parité impaire*
caractère contrôle = bit parité + caractère numérique
caractère numérique = 4{bit]4
* type:caractère, intervalle : '0'-'9', codage BCD*
carte détectée = *événement traduisant l'introduction d'une carte dans le lecteur*
carte présente = *signal externe, en provenance du lecteur *
* début: passage d'un front haut à un front bas,
fin : passage de front inverse*
carte retirée = * événement signalant le retrait d'une carte introduite dans le lecteur, déduit la
carte présente *
code = 5{caractère numérique}5
code erroné = * événement produit dans un code n'est pas reconnu *
codes référence = * code autorisés*
{code}
code valide = * événement produit quand un code est reconnu *
commande déblocage = * tension provoquant le déblocage de la gàche*
* type: entier, valeurs:0-12, valeur par défaut 0, pour le blocage, et 12
pour le déblocage, unité : v *
délai de garde = * délai pendant lequel la porte peut être ouverte*
délai écoulé = * événement produit après le déblocage de la gâche, afin de la rebloquer*
impulsion = * impulsion du signal de données lues sur la piste de la carte
magnétique *
marqueur de début = **
*type : caractère, valeur:';', codage:010111*
marqueur de fin = **
*type:caractère, valeur:'?', codage : 11111 *
message = 5{caractère contrôlé}5
top horloge = * signal utilisé pour échantillonner les données lues sur la carte *
* période: de3.4 ms à 226µs, pour une densité moyenne de bit de 75 bpi (ou
2.95 bits par mm)*
trame = marqueur de début + message + marqueur de fin
SPECIFICATION DE CONTROLE
départ
carte détecté
<A> CONSTITUER trame
attente
délai écoulé
<D>EFFACER trame
<A> DEBLOQUER gâche
<D> LIMITER déblocage
déblocage gâche
Chapitre6
I/ PRESENTATION GENERALE
Cet exécutif temps réel est prévu pour être exécuté sur un IBM PC. Il se présente sous
la forme d'une librairie de fonctions et de primitives : "ntr.lib". tous les symboles de cette
librairie sont indiquées dans le fichier "ntr.lst".
les prototypes des fonctions et des déclaration des variables globales se trouvent dans le
fichier "ntr.h".
Par rapport à un projet quelconque, il suffit de rajouter la librairie "ntr.lib" dans votre
fichier projet ".prj".
Cette librairie a été compilée dans le modèle de mémoire "large".
Dans les manipulations de contexte, le noyau temps réel ""NTR" modifie la pile. Il ne faut
donc pas générer le code qui teste le débordement de pile:
option/code generation/ test stackoverflow : off.
II/ LISTE DES PRIMITIVES DU NOYAU
Les primitives proposées par ce noyau temps réel permettent la gestion des processus,
la gestion des synchronisations, la gestion des communications par boîtes aux lettres, la
gestion des interruptions matérielles et la gestion du temps. La technique utilisée pour la
synchronisation est la techniques des sémaphores.
Pour la définition des différents objets manipulés, nous avons privilégié la technique
d'allocation dynamique de mémoire afin d'avoir une gestion plus efficace de celle ci. De plus,
cette technique est mieux adaptée à la "philosophie" du langage C.
Table de primitives:
Gestion des processus (ou des tâches)
start pour rendre un processus activable (ou prêt)
stop arrêt d'un processus
set_priority modification de la priorité initiale
Synchronisation sur sémaphore
waitsem mise en attente d'événement d'un processus
signalsem signalisation d'un événement
seminit initialisation d'un compteur de sémaphore
new_sem allocation mémoire d'un nouveau sémaphore
Gestion des boites aux lettres
send envoie d'un message dans une boîte aux lettres
receive retrait d'un message d'une boîte aux lettres
new_mailbox allocation mémoire et initialisation d'une boîte aux lettres
new_message allocation mémoire d'un nouveau message
Gestion des interruptions
enable_ints valide les interruptions
disable_its inhibe les interruptions
attach attache un sémaphore à un niveau d'interruption
liberer libération d'une entrée d'interruption précédemment attachée.
Gestion du temps
new_timer allocation mémoire d'un nouveau timer
sleep mise en sommeil d'un process pendant un temps prédéfini
gest_hor tâche système de gestion des horloges
waitc attente conditionnelle derrière un sémaphore
watchdog tâche système de gestion des chiens de garde
Pour supprimer un objet qui a été alloué en mémoire il faut utiliser la fonction "free"
de la librairie standard du langage C.
III/ MODE D'ORDONNANCEMENT ET PRECAUTIONS
1- définition et déclaration de tâches:
La déclaration d'un processus est identique à celle d'une fonction sans arguments:
void tache(void);
Fichier "ntr.lst"
Publics by module
_recept2 _recept2_on
_reg_LSR1 _reg_LSR2
_reg_MSR1 _reg_MSR2
_reset_DTR _reset_RTS
_restaure_reg_uart _rswrite
_sauve_reg_uart _set_DTR
_set_RTS _status_ligne
_trame1_vide _trame2_vide
_valide_RX _valide_TX
_valide_it_err_recept _valide_it_mod_modem
_valide_it_recept_com _valide_it_transm_com
#undef inportb/*Cette fct, d‚f ds dos.h, est une fct et non une macro*/
#undef outportb/*Cette fct, d‚f ds dos.h, est une fct et non une macro*/
#define ESC 27
#define SLEEP_ON 1 /*flag option, param d'entr‚e de begin_ntr*/
#define SLEEP_OFF 0 /*flag option, param d'entr‚e de begin_ntr*/
#define WAITC_ON 1 /*flag option, param d'entr‚e de begin_ntr*/
#define WAITC_OFF 0 /*flag option, param d'entr‚e de begin_ntr*/
#define WAITSEMTO_ON 1 /*flag option, param d'entr‚e de begin_ntr*/
#define WAITSEMTO_OFF 0 /*flag option, param d'entr‚e de begin_ntr*/
#define TOUJOURS 1 /*Pour faire une boucle sans fin*/
struct SEMAPHORE
{
long compt;/*compteur du semaphore = nbr de place dispo ds la
ressource associ‚e au s‚maphore*/
struct TTIB *point;/*pointe sur la liste des taches en attente*/
};
typedef struct
{
unsigned char r_ier, r_lcr, r_mcr, r_dll, r_dlm;/*les reg … sauver*/
void interrupt (*it_uart)(void);/*Pour sauver le vect d'it*/
}REG8250;/*uart ‚quivalent : le 16450 de chez NS*/
extern struct TTIB *exec;/*pte la file des taches activables (list d'‚x‚c)*/
/*d‚fini ds "ntr.c" et initialis‚ sur le tib du pp par la fct begin_ntr()*/
T P STR N°1
STR
Objectifs
Aider les étudiants à réaliser une application en appliquant la méthode de
spécification SART (WM).
Apprendre la programmation des interruptions pour l'interface parallèle, le clavier
et le timer.
Equipements
f Matériel
Micro ordinateur de type PC
Générateur de basses fréquences (GBF)
Câble de connexion avec le port parallèle
f Logiciel
Langage C
Système d'exploitation DOS
Prérequis
f Matériel et système
f Programmation C
f Algoritmique
f Systèmes de communication
énoncé
Notre système de mesure de fréquence consiste consiste a mesurer la fréquence d'un signal
TTL (carré par exemple). Donc il joue le rôle d'un fréquence mètre.
1- Spécification du système:
Il s'agit d'un micro-ordinateur relié a un générateur de basses fréquences de la manière
suivante:
le signal a mesurer est injecté à l'entrée ACK du port de l'interface parallèle. Le passage du
niveau électrique du signal de 0 a 1 logique déclenche une interruption. Ce déclenchement
d'interruption doit incrémenter un compteur.
En se servant de l'horloge interne de système, on peut donc calculer le nombre de périodes du signal
d'entrée par unité de temps, donc on peut déduire facilement la fréquence de ce signal. En se basant
sur cette idée on peut donc réaliser un fréquence mètre.
En appuyant sur la touche "F1", le système doit compter le nombre d'impulsions du signal a mesurer
pendant N tops d'horloge (N est un paramètre à fixer). La formule de calcul sera la suivante:
fréquence=(nombre d'impulsions/N)*18.2
En appuyant sur la touche "F2" le système doit afficher la fréquence du signal puis il retourne au
repos.
En appuyant sur "F3" le système doit se terminer.
On donne le schéma préliminaire, les machines à étant correspondants et les routines d'interruption
qu'on peut utiliser.
M TAYARI.L Page 67 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
Commande
Impulsion
LIRE
touche
MESURER A/I
Horloge D 3.0
fréquence
2.0
Cal CONTROLER
cul
_ter
min fréquence touche
é
fréquence
1.0
AFFICHER
fréquen
ce form
fréquence atée
4.0
temps d’acquisition
impulsions
GERER
2.2 A/I é
CONTROLER ev
ch Horloge
p sa
impulsions
tem
nombre d’impulsion 2.1
CALCULER
fréquence
2.4
fréquence
calcul terminé
MESURER fréquence
M TAYARI.L Page 68 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
commande
<D> lire touche REPOS
touche=F3 touche=F1
<A> produire fréquence
MESURE touche=F2
calcul terminé
<I> produire fréquence
<D> affichage fréquence
commande
AFFICHAGE
<D> lire touche
touche=F3
M TAYARI.L Page 69 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
REPOS
A
impulsion =0
temps=0
<A> compter imulsion
<A> Gérer temps
ACQUISITION
temps achevé
<I> compter impulsion
<I> Gérer temps
<D> calculer fréquence
Travail demandé:
1- trouver le diagramme de contexte du système.
2- étudier et commenter le diagramme préliminaire
3- construire le dictionnaire des données
4- faire la spécification des processus préliminaire en utilisant l'approche procédurale.
5- En utilisant le Langage C essayez d'implanter le système
ANNEXE
M TAYARI.L Page 70 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#define F1 59
#define F2 60
#define F2 61
#ifdef __cplusplus
#define __CPPARGS ...
#else
#define __CPPARGS
#endif
int nbr_impulsions=0,temps,countt,Key,Lo_Key;
/*-------------------------------------------------------------------------*/
void interrupt handler1(__CPPARGS)
{
/* increase the global counter */
nbr_impulsions++;
/* call the old routine */
oldhandler1();
}
/*----------------------------------------------------------------------*/
void interrupt handler2(__CPPARGS)
{
/* increase the global counter */
temps++;
/* call the old routine */
oldhandler2();
}
/*--------------------------------------------------------------------*/
void interrupt handler3(__CPPARGS) /* if C++, need the the ellipsis */
{
/* disable interrupts during the handling of the interrupt */
disable();
/* increase the global counter */
Key=inportb(0x60);
Key=Key%128;
/* reenable interrupts at the end of the handler */
enable();
/* call the old routine */
oldhandler3();
}
/*-------------------------------------------------------------------*/
int main(void)
{
/* save the old interrupt vector */
oldhandler1 = getvect(INTR1);
oldhandler2 = getvect(INTR2);
oldhandler3 = getvect(INTR3);
M TAYARI.L Page 71 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
return 0;
}
Bon travail
M TAYARI.L Page 72 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
ISET DE SFAX A.U: 1997/1998 Sem 2
II N4
TP N°2 Cours de Mr: TAYARI Lassaad
STR
Exercice N°1: (start, stop)
Dans cet exemple on se propose de démarrer trois taches "tache1", "tache2" et "tache3", avec
respectivement les priorités 100, 200, et 300. L'action de chaque consiste à afficher un message de
présentation, faire une attente clavier et exécuter une primitive "stop" pour désactiver définitivement
la tache.
M TAYARI.L Page 73 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
{
printf("\n\n\t\tTache numero 3. Process numéro : %3lu. Priorite 300\n",exec->pid);
printf("\t\tSortie de la tache3 ; avant le stop--------->");
getcar();
stop();
}
/*---------------------------------------------------------------------------------------------------------*/
char c;
/*#######################################################################*/
main(void)
{
c=0;
M TAYARI.L Page 74 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
waitsem(semEV);
printf("\n\t\t\t\t\tCorps de la tache 3\n");
printf("\t\t\t\t\tAny key --> ");
c = getch();
}
}
/*---------------------------------------------------------------------------------------------------------*/
M TAYARI.L Page 76 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
for(;;)
{
waitsem(psem_te);
printf("\tCorps de la tache 1\n");
}
}
/*---------------------------------------------------------------------------------------------------------*/
void tache2(void)/*priorité 100, dim tib = TAILLE*/
{
printf("\n\t\tTache 2, process %3lu, priorite 100\n", exec->pid);
printf("\t\tOn va se mettre en attente derriere \"*psem_te\"\n");
for(;;)
{
waitsem(psem_te);
printf("\t\tCorps de la tache 2\n");
}
}
/*---------------------------------------------------------------------------------------------------------*/
void tache3(void)/*priorité 100, dim tib = TAILLE*/
{
printf("\n\t\t\tTache 3, process %3lu, priorite 100\n", exec->pid);
printf("\t\t\tOn va se mettre en attente derriere \"*psem_te\"\n");
for(;;)
{
waitsem(psem_te);
printf("\t\t\tCorps de la tache 3\n");
}
}
/*---------------------------------------------------------------------------------------------------------*/
void horloge(void)
{
int t;/*Sert de compteur*/
t = 20;/* 20x50 ms = 1 s */
seminit(&sem_it , 0);/*C'est un sémaphore "événement"*/
attach(&sem_it, 0x1C);
printf("Début de la tâche horloge.\n"
"On va se mettre en attente derrière \"sem_it\"\n");
for(;;)
{
waitsem(&sem_it);/*sem attachée à l'it timer*/
-Fin de TP-
Bon travail
M TAYARI.L Page 78 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
ISET DE SFAX A.U: 1997/1998 Sem 2
TP N°3
II N4 Cours de Mr: TAYARI Lassaad
Durée : 1h 30mn
STR
tache1
180
evt1
/*
HORLOGE DE SYNCHRONISATION DE PLUSIEURS TACHES :
Solution plus directe que l'utilisation de la primitive "sleep".
Essai du moniteur temps réel : synchro par sem, exercice no 2.
Dans le noyau temps réel "ntr", on dispose d'une horloge à 55 ms
(timer de la carte mère), pour générer des interruptions.
On désire calculer 3 équations à des intervalles réguliers égaux
respectivement à 1,1s, 5,5s, 11s.
On ne dispose que d'un seul processeur.
SOLUTION : Il faut 3 taches T1, T2, T3, la tache matérielle "it_timer"
qui génère un "signalsem(sem_it)" (cette tâche est gérée par "ntr"),
la tache "horloge" pour assurer la synchronisation avec les 3 autres.
IMPLANTATION "STATIQUE" D'UN SEMAPHORE : Dans les exercices précédents, tous les
sémaphores manipulés étaient alloués dynamiquement par la fonction "newsem".
Ici, nous avons un exemple de sémaphores définis de manière statique.
*/
#include "ntr.h"
M TAYARI.L Page 79 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
void main(void)
{
begin_ntr(SLEEP_OFF, WAITC_OFF, WAITSEMTO_OFF);/*init mon temps réel*/
printf("Debut du process principal ( tpntr4_1 )\n");
start(horloge ,1000); /*La plus grande priorité*/
while(incar()!=ESC) ; /*Le pp ne fait rien*/
end_ntr();
printf("Fin du process principal ( tpntr4_1 ), retour au DOS\n");
}
.
.
}
stop(); /*Jamais exécuté*/
}
void horloge(void)
{
int t1, t5, t10;/*Pour fixer le délai*/
t1 = 20; t5 = 100; t10 = 200;/* 1,1s, 5,5s et 11s*/
.
.
.
start(tache1, 180);/*armer la tache1 avec la priorité 180*/
start(tache5, 150);
start(tache10, 130);/*Ce sont des taches filles de horloge*/
attach(&semit, 0x1C);/*l'it timer de vect 0x1C exécute signalsem(&semit)*/
do
{
.
.
.
.
}while(1);
}
Questions:
1- Terminer le programme suivant pour qu'il puisse répondre à notre problème.
2- Créer votre fichier projet TP3STR.prj.
3- Compiler puis exécutez votre programme.
Bon travail
M TAYARI.L Page 81 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
ISET DE SFAX A.U: 1997/1998 Sem 2
II N4
TP N°4 Cours de Mr: TAYARI Lassaad
STR
Ordre Ordre
Réponse Réponse
#include "ntr.h"
int car;
struct TMAILBOX *pmail;/*Pointeur sur la b aux lettres*/
void main(void)
M TAYARI.L Page 82 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
{
clrscr();
begin_ntr(SLEEP_OFF, WAITC_OFF, WAITSEMTO_OFF);/*init mon temps réel*/
.
.
.
.
.
.
end_ntr();
}
/*------------------------------------------------------------------------------------------------------------
*/
void demandeur1(void) /*priorité 100, dim tib = TAILLE*/
{
char ordre[256]; /*Pour transmettre l'ordre*/
char *preponse;
car = 0;
printf("\nDebut Tache demandeur1, priorite 100\n");
while( car != ESC)
{
.
.
.
.
.
}
stop();
}
/*------------------------------------------------------------------------------------------------------------
*/
void soustraitant(void)/*priorité 100, dim tib = TAILLE*/
{
char *pordre; /*Pour recevoir l'ordre*/
char *preponse;
preponse = "\nLe travail est execute\n";
printf("\n\t\t\t\tDebut tache de sous traitance, priorite 100\n");
while(1)
{
.
.
.
.
.
}
}
M TAYARI.L Page 83 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
/*------------------------------------------------------------------------------------------------------------
*/
void execute(char *pordre)
{
printf("\n\t\t\t\tJ'execute le travail %s\n", pordre);
printf("\t\t\t\tPour continuer : touche quelconque-->");
getcar();
printf("\n\t\t\t\tFin de la fonction execute\n");
}
TRAVAIL DEMANDE
PARTIE I
1- Complétez ce programme pour qu'il puisse répondre au spécifications du problème
2- Créer votre fichier projet TP4STR.prj puis compilez.
3- Changer les priorités des tâches "demandeur" et "sous traitant". Voir l'effet de ce
changement.
PARTIE II
- Reprendre le même exercice en prévoyant une boite aux lettre pour les ordres et une boite
aux lettres différente pour les compte rendus.
PARTIE III
- Reprendre le même exercice avec deux boites aux lettre, mais en prévoyant deux
demandeurs et un sous traitant.
-Fin de TP-
Bon travail
M TAYARI.L Page 84 TP
Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
BIBLIOGRAPHIE
M TAYARI.L Page 85 TP