Cours TR

Sommaire Cours d’STR Informatique Industrielle
SOMMAIRE
1 Sommaire
3 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
4 c- Les appels systèmes
4 d- La communication et la synchronisation
8 II Les spécification temps réel
8 a- Définition
9 b- Système informatique
9 c- Procédé a commander
10 d- Les contraintes temps réel
11 e- Le facteur temps
14 Chapitre 2 L'ENVIRONNEMENT TEMPS REEL

14 I- Introduction
14 II- Le génie logiciel et le temps réel
14 Le génie logiciel (Définition) -1
14 Cycle de vie d'un système -2
18 Chapitre 3 LA SPECIFICATION
18 I- Aspect fonctionnel
18 Introduction -1
19 Exemple -2
22 Diagramme de flots de données -3
24 Les règles de formation et d'interprétation d'un DFD -4
26 La spécification de processus -5
28 Chapitre 4 L'ASPECT INFORMATIONNEL

28 I- Introduction
ISET DE SFAX ~ A.U 97/98 1 Page TAYARI Lassaad
Sommaire Cours d’STR Informatique Industrielle
29 II- La spécification des données composées
30 III- La spécification des données primitives
31 Chapitre 5 L'ASPECT EVENEMENTIEL

31 I- Introduction
31 II- Les composantes de l'aspect évènementiel
32 III- La représentation de l'aspect évènementiel
33 IV- La représentation graphique
33 Transformation de contrôle-1
33 Stockage d'évènements -2
34 Les règles de formation d'un schéma de transformation -3
35 V- Spécification de la logique de contrôle
35 Les composants -1
36 Les règles de formation -2
36 Les règles d'interprétation -3
VI- Les composnats d'un modèle essentiel
37
39 VII- Exemple complet (Commande d'ouverture de porte)
44 Chapitre 6 LE NOYAU TEMPS REEL (NTR)

44 I- Présentation graphique
44 II- Liste des primitives du noyau
46 III- Le mode d'ordonnancement
47 IV- Détails des primitives
60 Chapitre 7 TRAVEAUS PRATIQUES

Introduction Cours d’STR Informatique Industrielle
aux systèmes temps réel
Chapitre 1
INTRODUCTION AUX CONCEPTS

TEMPS REEL
:I- RAPPEL A LA NOTION DE MULTITACHE

I-1 Le principe de base
:a- Définition de multitâche
L'objectif principal de la notion de multitâche est d'exploiter le plus efficacement
.possible toutes les ressources d'un système informatique
Le système d'exploitation doit alors mettre en oeuvre les règles de possession et de partage de
ressources. Aussi, il doit définir les compétiteurs (processus) et les contrôler tout au long de
leurs exécutions. Donc, les programmes susceptibles de partager les différentes ressources
.doivent être indépendantes les uns des autres. Une telle approche caractérise le multitâche
:b- La notion de processus
Un processus est une entité dynamique qui met en oeuvre un ou plusieurs programmes
statiques en vue de la réalisation d'une activité donnée par un processeur. Un processus est
fonction du temps, il peut être créé, exécuté ou encore détruit. Un processus comporte
différentes zones, en général trois
Pointeur de données Pointeur de

programme
Zone Zone
données programme
Pointeur de pile
Zone de pile
Zone de programme: Contient les instructions du programme et certaines constantes. *
.Accessible en lecture seulement
Zone de pile: Permet de ranger des informations temporaires (variables locales, adresse de *
.retour de sous-programme, etc. ...). Accessible en lecture et écriture
Zone de données: contient les données variables et les données constantes ou initialisées. *
.Elle est accessible en écriture et en lecture
Le contexte d'un processus est caractérisé par les valeurs des registres du microprocesseur, de
l'état des pointeurs des zones mémoire associées au processus (instruction, données, pile) et
:des caractéristiques du processus. Parmi ces derniers, on trouve essentiellement
.le nom du processus •
La priorité, permettant de quantifier le degré d'urgence du processus. Cette priorité permet •
de déterminer l'ordre de l'allocation du processeur lorsque plusieurs processus sont en
.attente d'exécution
Un droit d'accès, spécifiant les ressources matérielles et logicielles accessibles par le •
.processus
?(Un identifiant de l'état instantané du processus (actif, en attente, bloqué •

Tous ce contexte attaché à un processus est mémorisé par le système dans un ordre fixé et •
.constitue le descripteur de processus
:C- Les appels systèmes
Un appel système est un service élémentaire fournis par le système pour accomplir
.certaines actions interdites en mode utilisateur
En ce qui concerne la gestion des tâches, un minimum de cinq primitives sont
:généralement mises en oeuvre
Créer_processus(): Elle retourne un identificateur de processus, ce qui permet d'identifier ♦
.le processus de manière exclusive
Détruire_processus(): permet de rendre un processus éligible (prêt) et peut-être même élu ♦
.selon sa priorité et celle du processus en cours
Désactiver_processus(): Consiste généralement à faire passer un processus à l'état hors- ♦
(service (bloqué
.Terminer_processus(): Permet de s'assurer de la fin cohérente du processus ♦
: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
La coopération temporelle: fait intervenir les notions de blocage et de déblocage de •
(processus. (Synchronisation
La coopération spatiale: se rapporte à l'échange d'information entre processus. •
((Communication
:La synchronisation .1
Le multitâche pose le problème de la gestion des relations entre l'ensemble des
processus qui communiquent avec le système informatique pour obtenir une cohérence
.maximale des informations par rapport au temps
:On distingue 4 ( quatre ) catégories de relations entre les processus
.Les processus indépendants ♦
.Les processus ayant accès à des ressources communes ♦
.Les processus liés ♦
.(Les processus à contrainte de temps/ (urgence de traitement ♦
Dans le cas des processus ayant accès à des ressources communes, on doit prévoir des
.mécanismes pour assurer le partage de ses derniers
:Solution
les sémaphores -
(les événements (signaux -
les rendez-vous -
:La communication .2
Il y a plusieurs méthodes de communication de données entre tâches. Les plus
: courantes sont
(les boîtes à lettres (messages -
les files d'attentes -
:E- Ordonnancement des ressources
Le déroulement des processus temps réel est dépendant des événements externes à
l'ordinateur. Plusieurs tâches peuvent se trouver en concurrence pour l'octroi de l'unité
centrale. Ce conflit est levé en accordant à chaque tâche un niveau de priorité. Ainsi
.celle de plus grande priorité est exécuté en premier
(L'ordonnenceur (scheduler .3
L'ordonnenceur d'un environnement temps réel est le responsable de la gestion de
l'allocation du processeur. Chaque fois qu'une modification intervienne sur l'ensemble
des tâches actives, l'odonnenceur sera invoqué. L'ordonnenceur a donc deux rôles
:essentiels
assurer la gestion des commutation de tâches de l'état bloqué à l'état éligible *
?
Processus ELU
DEBLOCAGE SELECTION
DES PROCESSUS )Dispatcher(
Table des Table des Table des

événements processus processus
associés aux Bloqués Eligibles
processus
Bloqués
ROLE DE L'ORDONNENCEUR
1 INEXISTANT
2
HORS
3
7 Service 14
4 13
Eligible 11
12 En Attente de
Ressource
5 6
15
8
9 En Attente de
Elu Délai
10 16
En Attente
événement
ETAT DES PROCESSUS ET TRANSITIONS
Création d'un processus fils par son père -01

Destruction d'un processus -02
Activation d'un processus -03
Désactivation d'un processus -04
Sélection d'un processus par le dispatcher -05
Réquisition d'un processus par le dispatcher -06
Fin d'exécution du processus en cours -07
blocage sur accès à une ressource non disponible -08
Blocage sur attente de fin de délai -09
(Blocage sur occurrence d'un événement (asynchrone -10
Activation d'un processus forcé d'attendre l'écoulement d'un délai -11
Activation d'un processus forcé d'attendre un événement -12
Activation d'un processus forcé d'attendre la libération d'une ressource -13
Activation d'un processus suite à la libération de la ressource attendue -14
Activation d'un processus suite à l'écoulement d'un délai -15
Activation d'un processus à l'occurrence d'un processus -16
:I-2 Les spécifications temps réel
:a- Définition
Environnement
Action PROCEDE A
SYSTEME
INFORMATIQUE Information sur
COMMANDER
état
)événement(
On ne peut parler d'un système temps réel (STR), que si on a un système

.informatique et un procédé à commander
Un système temps réel est composé d'un système informatique et d'un procédé à
commander. Ce système informatique doit répondre dans un temps garanti aux
événements en provenance du procédé. Donc le système informatique est asservi à
.l'évolution dynamique du procédé à commander
.Un système temps réel est alors un système ayant des états finis et stables
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
:Système d'exploitation temps réel *
Exemple: OS9
: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
T1 = temps d'acquisition Si
T2 = temps de traitement
T3 = temps mis pour fournir le résultat
.Tlim = le temps limite à respecter et
Il faut donc que T1 + T2 + T3 < Tlim pour que notre système fonctionne en temps
réel
Communication
Communication
Communication
Communication TACHE2
TACHE2
TACHE1-
TACHE1- TACHE3
TACHE3
Interruption
Interruption TACHE 1 TACHE
TACHE2
TACHE2 TACHE22 TACHE
TACHE33
périphérique TACHE 1
périphérique
Acquisistion
Acquisistionde
de Traitement
Traitementde Stockage
de Stockageetet
données
données données affichage
données affichagede
de
temps=T1
temps=T1 temps=T2
temps=T2 RESULTAT
RESULTAT
temps=T3
temps=T3
[Avec [ T1 + T2 + T3 <TEMPS LIMITE
: 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
.f Scrutation sur une variable analogique Exemple:

f information à durée de validité aléatoire (comptage des objets) passant
.devant un détecteur
:d- les contraintes temps réel
Le fonctionnement en temps réel d'un système impose des contraintes sur le
.système d'une manière générale et en particulier sur le matériel et sur les logiciels
f Sur le système: Les contraintes regroupent tous les problèmes liés à la sécurité et
.à la sûreté de fonctionnement et pouvant entraîner sa dégradation
.Il faut donc mémoriser l'effet de défaillance
:Exemple: chaîne de montage d'automobile
L'arrêt d'une machine ne doit pas arrêter le fonctionnement de toute la chaîne de
.production
:f Sur les logiciels

Les logiciels temps réel, doivent permettre une mise en oeuvre de la gestion des
relations entre les processus par la mise à la disposition de langages adaptés et
.d'instructions spécialisées à ces langages
Donc, le problème des contraintes de temps consistent à pouvoir traiter l'information
suffisamment vite pour que l'action résultante ait un sens, tout en restant dans les limites
.de fonctionnement normal de la machine
:e- Le facteur temps
:La validité des informations dans le temps -1
Le domaine de fonctionnement en temps réel des ordinateurs recouvre différentes
.(.applications (commandes de processus ... etc
Certaines informations ne sont valables qu'a l'instant où elles sont fournies, ou durant u
laps de temps déterminé. Ces informations n'ont d'utilité que lorsqu'elles sont vraies et
se dégradent dans le temps. Dans un système temps réel, il faudra les exploiter durant
.leurs périodes de validité
Pour fournir une réponse, un système doit reconnaître, traiter et sortir un résultat. Le
.temps de réponse TR est le suivant
TR = Tcalcul + TE/S
:L'urgence et les délais -2

:a- Définition
.Le phénomène de délai est associé au temps de réponse•
.Le phénomène d'urgence est lié à la rapidité de traitement•
:b- Le traitement d'urgence
L'urgence est le résultat de respecter le temps maximal autorisé pour réaliser un
.traitement
Dans un système temps réel, certains traitements ont besoin d'être effectués avant
.d'autres par ce qu'ils sont plus urgents
: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
.((processeur) utilisé et de l'exécutif temps réel (temps de commutation
Arrivée d'une
interruption
Traitement de
l'interruption
TACHE A
TACHE A
DELAI URGENCE
URGENCE ET DELAI
:Du côté processeur•

Temps total de traitement = (ΣTemps de chaque instruction) + temps associés au interruptions
.Donc le matériel est déterministe

:Du côté exécutif temps réel•
Un exécutif est dit déterministe s'il est indépendant de la charge du système et si
l'on peut répondre le plus vite possible à une requête externe et la traiter dans un temps
.maximum indépendant de l'environnement extérieur
:La préemption -3
: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
.Conséquence: La préemption ne s'applique qu'à la tâche de la plus haute priorité
t1 Tâche préemptive t1
t2 tn
t3
Multitâche Réquisition du Multitâche

processur pour une
)tâche (unique
Cours d’STR Informatique Industrielle
L'environnemenent temps réel
Chapitre2
L'ENVIRONNEMENT TEMPS REEL

I/ INTRODUCTION
L'environnement temps réel est tout outil se rattachant à la mise en oeuvre d'une
application temps réel. Ces outils découvrent les différentes étapes par lesquels passe
.(l'opération de développement d'un système temps réel (ou tout logiciel en général
.En effet on trouve des outils pour la spécification, la conception et le codage
Ces différentes étapes sont à l'issu des travaux de modélisation du processus de
.développement d'application informatique. C'est le génie logiciel
II/ LE GENIE LOGICIEL ET LE TEMPS REEL
(Le génie logiciel (définition /1
Le génie logiciel est l'ensemble de méthodes, outils et techniques, dont l'application "
permet un processus de réalisation de produits logiciels et de qualité industrielle. Cette
réalisation doit répondre à des impératifs de délais, coûts, qualité, fiabilité et réutilisabilité
malgré des difficultés inhérentes à la complexité du problème de l'environnement"
.A.DORSEUIL et P.PILLOT
:Cycle de vie d'un système /2
:La vie de tout système informatisé peut être décomposée en trois stades
.(L'expression du besoin auquel il doit répondre (cahier des charges•
.(son développement (spécification, conception, codage, intégration et test•
.son exploitation et sa maintenance•
.L'ensemble de ces trois stades constitue le cycle de vie d'un système
:Expression des besoins .1
: Cette étape se décompose en deux opérations
.l'identification des besoins -
.L'étude de faisabilité du système -
L'identification des besoins se manifeste par la forme de dialogue entre un•
demandeur et un réalisateur pour fixer un contrat de travail. Dans ce contrat on

trouve toutes les informations qui concernent le projet (besoins fonctionnel et

.(exigences de qualité et de temps de livraison
L'étude de faisabilité porte sur les aspects économiques, techniques, normatifs et•
.légaux mis en jeu pour développer le système
:Développement d'un système .2
Le développement d'un système comporte les phases de spécification, de conception, de
.construction, d'intégration et de validation
L'ensemble de ces phases porte le nom de cycle de développement d'un système. La
.réalisation technologique va de sa conception à son intégration
: La spécification
La spécification d'un système est l'expression technique du besoin auquel il doit
répondre. C'est une description standard du comportement et de l'environnement du système
.sans faire appel à des considérations informatiques
"?Donc, la spécification a pour but de répondre à la question "que faire
: La conception
La conception consiste à proposer une architecture informatique globale et une façon
.à suivre pour la construction
"?Donc, la conception a pour but de répondre à la question "comment faire
:On distingue deux phases
.f La conception préliminaire: fournit l'architecture globale du système
f La conception détaillée: fournit les détails à faire pour la partie logicielle et pour la
.partie matérielle
: La construction
C'est l'application de la conception détaillée, elle se décompose en phases spécifiques au
:logiciel et au matériel
.f Pour le logiciel : codage, tests unitaire et intégration
f Pour le matériel: fabrication du prototype, test et mesure
: Intégration
C'est la phase de l'unification du logiciel et du prototype matériel, en présence du processus à
.conduire
: La validation
La validation d'un système consiste à établir qu'il est conforme aux besoins exprimés par le
.demandeur

:Cycle de vie d'un système

"Cycle en v "
Spécification Conception Test et évaluation Fonctionnement

Développement et maintenance t
Besoin Produit
Cahier des charges CERTIFICATION Evaluation et test

opérationnel
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
Cycle de développement en cascade
[PEREZ[

La Cours d’STR Informatique Industrielle
spécification
Chapitre3
LA SPECIFICATION
La spécification d'un STR consiste en la modélisation de ses aspects fonctionnels,

.informationnel et événementiel
:I/ ASPECT FONCTIONNEL

:Introduction -1
: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

(Exemple: (Exploitation de mesures acquises -2
nom d
e l’ac
quisit
ion
Opérateur dem
and
Imprimante
e
co
m
pte n
isitio
ren
EXPLOITER acqu
du ort de l’
rapp co
ent ur
arge
m acquisition be
do
e ch
de d cu
o mman de
m
en
c tée
e ur e
at c
d ic sen
Système In pré Ecran
d’acquisition s iti
on graphique
ui
d ’ acq
i er
fich
Diagramme de contexte d’une exploitation de mesure
indicateur de presence fichier d’acquisition
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
compte rendu caractérisiques de l’acquisitiont

CONVERTIR
mesures
5.0 PRODUIRE
sio
n rapport rapport de
demande res l’acquisition
’imp 6.0
ed
nd
ma
de mesures réelles
SAISIR
demande opérateur VISUALISER
courbe
2.0
demande de visualisation 7.0 courbe documentée
DFD préliminaire d’une exploitation de mesures
18
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
DFD de PRODUIRE rapport
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
DFD de VISUALISER courbe
Digrammes de flots de données: DFD -3

un DFD est un réseau de processus et de stocks de données connectés par des flots
.de données
:Flots de données -3.1
Définition: un flot de donnée indique le chemin suivi par une donnée qui
circule entre des transformations. Il peut être constitué d'une donnée simple, dite primitive, ou
.d'un groupement de données
Représentation: une flèche simple ou double étiquetée avec L'identificateur
de la donnée. L'identificateur de la donnée ne doit impliquer aucun traitement, il ne comporte
.que des noms et des adjectifs
:Exemples
Rapport de l'acquisition boîtier
indicateur de présence énergie brute
vitesse signal sonore
 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
:Processus -3.2
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
donnée sur laquelle porte la transformation. La référence numérique traduit la place du
.processus dans une décomposition hiérarchique
:Exemple
boîtie
r énergie mesure brute
énergie CONTRO perdue
CONVERTI
brute BOUCHER LER R
boîtier énergie énergie de
mesure
boîtier 2.1 3.3 mesure réelle
bouchon contrôle
1.0
:Stockage de donnée -3.3
Définition: un stockage de donnée est un regroupement de données, ou une
donnée primitive, maintenu disponible et qui peut être utilisé par tout processus. Son contenu
.n'est pas changé par un processus qui y lit, il n'est modifié que par un processus qui y écrit
Représentation: deux lignes parallèles encadrant l'identificateur de la donnée
.stockée. Cet identificateur doit être composé de la même manière que celui d'un flot
:Exemples
mesures réelles seuil de température
:Bord de modèle -3.4

Définition: un bord du modèle représente une entité située dans
l'environnement externe au système, qui constitue la source ou la destination des flots de
données échangés entre le système et son environnement. Il peut être un périphérique, une
.partie opérative, une personne ou un autre système
Représentation: un rectangle entourant L'identificateur du bord.
L'identificateur d'un bord est composé de noms qui indiquent le rôle qu'il joue ou la place
.qu'il tient, par rapport au système
:Exemple
opérateur table traçante
robot
écran
LES REGLES DE FORMATION ET D'INTERPRETATION D'UN DFD -4

Connexions possibles -4.1
de vers processus stockage bord

processus X X X
stockage X
bord X
La hiérarchisation du modèle fonctionnel -4.2

Pour réduire la complexité d'un système en phase de modélisation on
opte à en hiérarchiser le modèle, de façon descendante, par niveaux de détail croissant, et de
.( complexité suffisamment limité pour pouvoir être facilement assimilable. (Voir exemple
Diagramme de contexte: Le diagramme de contexte est le sommet de la

hiérarchie. C'est un diagramme très abstrait qui représente le système à modéliser. Il ne
contient qu'un processus dont le nom traduit la fonction d'usage du système. Il est le seul
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
Hiérarchie Abstraction et masquage d’information
Repérage des niveaux et des processus: Chaque niveau porte le nom et le

numéro du processus parent qu'il décompose. Chaque processus du DFD d'un niveau, possède
.une référence numérique qui indique sa place dans la hiérarchie
.Processus primitif: Un processus est dit primitif s'il n'est plus décomposable
Abstraction et masquage -4.3

Le DFD d'un niveau ne contient que les informations nécessaires à la représentation
(complète, mais sans surdétail, du processus qu'il décompose.(voir figure
Conservation et interface entre niveaux -4.4
Chaque diagramme enfant comporte exactement les mêmes flots entrants et sortants
que son processus parent
(SPECIFICATION DE PROCESSUS (MINISPECIFICATION -5
La décomposition d'un processus s'arrête quand sa présentation par DFD ne peut plus
rendre compte de détails supplémentaires sur la production de flots sortants à partir de flots
entrants. Un processus en fin de décomposition est dit processus primitif. A ce stade il faut
.introduire d'autres outils pour introduire des détails supplémentaires
Il existe plusieurs manières de spécifier un processus, les plus importantes d'entre elles sont la
spécification procédurale, la spécification par précondition/postcondition et la spécification
.par équations
Spécification procédurale -5.1
Ce type de spécification se base sur une approche algorithmique. Chaque processus
.primitif sera décrit sous forme de procédure
:Exemple
:La spécification de "OBTENIR données acquisition" peut s'énoncer

émettre une COMMANDE DE CHARGEMENT de fichier correspondant au NOM DE
.L'ACQUISITION
Si INDICATEUR DE PRESENCE est vrai

alors
mettre COMPTE RENDU à succès
stocker FICHIER D'ACQUISITION comme DONNEES DE L'ACQUISITION
mettre COMPTE RENDU à échec sinon
fournir COMPTE RENDU
Spécification par précondition/postcondition -5.2

Une spécification de processus par précondition et postcondition, revient à mettre en
relation les flots d'entrée (préconditions), et les flots de sortie (postcondition) qui s'en
.déduisent, sans entrer dans la façon d'y procéder
:Exemple
:La spécification de "OBTENIR données acquisition" peut s'énoncer

NOM DE L'ACQUISITION est fourni précondition1
postcondition1 COMMANDE DE CHARGEMENT du fichier NOM DE L'ACQUISITION
est émise
& précondition2 INDICATEUR DE PRESENCE est vrai
FICHIER D'ACQUISITION est fourni
& postcondition2 COMPTE RENDU est mis à succès
DONNEES DE L'ACQUISITION contient FICHIER D'ACQUISITION
précondition3 INDICATEUR DE PRESENCE est faux
postcondition2 COMPTE RENDU est mis à échec
Une spécification par précondition/postcondition est complète si l'ensemble des préconditions
.couvre toutes les combinaisons possibles des valeurs des flots d'entrée
(spécification par équation (formule -5.3

Ce type de spécification décrit le comportement du processus par une ou plusieurs
.équations mathématiques
:Exemple
température consigne
:soit le processus primitif suivant
MAINTENIR
température commande de vanne
température
constante
5.4.3.1
Ce processus peut être spécifié de la façon suivante

Vv = tension de commande de la vanne soit
e= température consigne - température courante
pour un temps de réponse de 0.5 s
si e > -2 0
si |e| ≤ 2 3e + 6Vv=
si e < 2 12
L'apspect Cours d’STR Informatique Industrielle
informationnel
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
.f Le stockage des données

:Pour chaque composant il est nécessaire de connaître les informations suivantes
 Nom, rôle, signification
 Identificateur
 type
 Nombre d'itérations
 Domaine de validité
. Unité ...etc
Le dictionnaire des données est donc la base de données d'un système. Il est constitué par
l'ensemble des spécifications des flots des stockages qui figurent dans les DFD et les
.spécifications de processus
II/ LA SPECIFICATION DES DONNEES COMPOSEES

.La spécification des données composées utilise la notation de BACUS-NAUR
:Cette notation se base sur un ensemble de symboles définis comme suit

informationnel
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
..... + = nom de l'acquisition + date acquisition données de l'acquisition

fréquence d'échantillonnage +.....
= 1{@instant+mesure brute}4096 mesure brute
*= *mesure brutes converties en réelles mesures réelles
instant + mesures réelles}4096@}1
= courbe + cartouche écran courbe documentée
= nom acquisition + environnement acquisition cartouche écran
III/ LA SPECIFICATION DES DONNEES PRIMITIVES

Les données primitives sont spécifiées à l'aide des valeurs de leurs attributs, ou
caractéristiques, comme leurs types, leurs domaines de validité, leurs valeurs par défaut, leurs
.unités et leurs précisions
:Exemple : Spécification de données primitives
= JJ+MM+AA date d'acquisition
*= * jour JJ
* types : entier, intervalle 1-31 * Diagramme de flots
Spécification de Flots de données
* = * temps correspondant
processus à la lecture d'une mesure de données
instant
DFD
* type : entier, intervalle 1-4096, unité =µs *
IV LE ROLE D'UN DICTIONNAIRE DE DONNEES
 Un dictionnaire de données est la base de données d'un système, il réalise
donnéesle lien
.entre les différents niveaux d'un modèle fonctionnel
données Dictionnaire de
données
ISET DE SFAX ~ A.U 97/98 27 Page DD TAYARI Lassaad
Relation entre les composants d'un modèle

informationnel
 Le dictionnaire de données joue un rôle central dans la vérification de cohérence. Il

.constitue l'unique référence des données
 Le dictionnaire des données spécifie les performances d'un STR

évènementiel
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
II- LES COMPOSANTS DE L'ASPECT EVENEMENTIEL

:f Les événements
 Un événement est une information qui survient à un instant précis et qui traduit que
"quelque chose s'est passée". Un événement externe nécessite une réponse préétablie de la
.part du système
 Un événement est représente par une flèche interrompue. (--------->) avec L'identificateur
.de l'événement
:f Les actions
Les actions exercées par les événements sur les transformations de données sont internes et
.de type activation/désactivation
.Les événements sont appelés activeurs/désactiveurs de processus
:On distingue trois principaux activeurs/désactiveurs
. L'autorisation (A): initialise les activités d'une transformation
 L'inhibition (I): termine les activités d'une transformation
évènementiel
. Le déclenchement (D): lance les activités d'une transformation

Les actions réelles sur l'environnement sont à la charge des transformations activées, qui
.commandent des préactionneurs et des actionneurs et émettent des signaux
III- LA REPRESENTATION DE L'ASPECT EVENEMENTIEL

Les extensions de WM (MORD MELLOR) de l'analyse structurée à la modélisation des STR
consiste à représenter les événements qui contrôlent les processus, sous forme de
:diagrammes, comme pour les flots de données. Cette extension comporte
 une représentation graphique propre aux flots événements et à la logique de
contrôle qui les combines afin de distinguer les données des événements et les traitements de
.leur contrôle
. Une hiérarchisation de l'aspect événementiel qui suit celle de l'aspect fonctionnel
( Exemple: Régulation d'amplitude d'un signal sonore. (Voir schéma
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
VI- REPRESENTATION GRAPHIQUE

:Transformation de contrôle -1
évènementiel
: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
:stockage événement -2
: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
Etat des postes Ticket disponible
Remarque: un stockage événements peut recevoir directement des flots événements

en provenance de l'environnement sans qu'ils soient produits par des transformations
:EXEMPLE
évènementiel
sup
po
rt prè robot libre
te
Pièces présentes
CONTROLER
assemblage
as
rèt po sem
a nt p ss
pos ib bla
com le ge
(Les règles de formation d'un Schéma de Transformation (ST -3

La cohabitation des données et des événements, des traitements et des contrôles
.impose des règles spécifiques de formation des diagrammes qui s'ajoutent à celle des DFD
Une transformation de contrôle n'accepte que des flots événements en entrée et ne produit -�
.que des flots événements en sortie
Une transformation de contrôle peut avoir des activeurs/désactiveurs en entrée, c'est à dire -‚
.être activée par une autre transformation de contrôle
- Une transformation de contrôle peut avoir des activeurs/désactveurs en sortie, c'est à dire
.activer/désactiver des transformations de données ou de contrôle
Seuls les flots de données et des activeurs/désactiveurs sont acceptés en entrée des -„
transformations de données primitives, mais elles peuvent produire, en sortie, des flots de
.données ou événements
Toute transformation primitive de flots de données continus doit être explicitement activée -…
.ou désactivée
Une transformation de donnée primitive peut exercer un contrôle sur l'environnement à -†
.l'aide d'un flot événement en sortie
:Les connexions possible -4
Transformation Transformation de Stockage de Stockage Bord
de vers de données contrôle données événements
Transformation
de données
évènementiel
A/I/D Transformation interdit interdit

A/I/D de contrôle
Stockage de interdit interdit interdit interdit
données
Stockage interdit interdit interdit interdit
événements
Bord interdit interdit
:connexion autorisée par

A/I/D
:  activeur / désactiveur / inhibeur
:  flot événement
:  flot de donnée discret
:  flot de donnée continu
Connexions possibles entre éléments des ST
:V- SPECIFICATION DE LA LOGIQUE DE CONTROLE

: Plusieurs représentations sont possibles pour spécifier la logique de contrôle. On peut citer
 Les automates à états finis
 Les réseaux de pétri
 Les grafcets
*  Les diagrammes à état - transition
. La logique combinatoire ... etc
(Dans notre cas on utilisera les diagrammes états - transitions (SART - WM
:Les composants -1
:Un diagramme état - transition est composé de quatre éléments
f Les états : représentés par des rectangles contenant les noms des différents états
f Les transitions : représentées par des flèches qui représentent le passage d'un état
.à un autre, dans le sens indiqué par la flèche
f Les conditions qui sont les événements qui provoquent une transition
.f Les actions qui sont réalisées quand les transitions se produisent
:La représentation est donnée par le schéma suivant

Etat courant évènementiel
condition
action
Etat suivant
: Les règles de formation -2

:La représentation d'un diagramme état transition obéit à des règles de formation
f Un des états est désigné comme état de départ, ou état initial. Cet état représente
l'état du système au moment ou il est sollicité. Généralement cet état est désigné par
.REPOS
.f Un ou plusieurs états peuvent être terminaux

f Une transition peut exister entre deux états quelconques du système y compris entre
.un état et lui même
.f Il peut y avoir plusieurs transitions en entrée ou en sortie d'un état
f Plusieurs conditions peuvent être nécessaire à la réalisation d'une transition et
.plusieurs actions peuvent y être associées
.f Une condition peut provoquer une transition, sans qu'il y ait d'action associée
:Les règles d'interprétation -3
f Lorsqu'une transition boucle sur le même état, cela signifie qu'une condition est
.requise pour produire une action, mais n'influence pas l'état courant
f Le système étant dans un état donné, si une condition est réalisée, mais n'est pas
.associée à une transition en sortie de cet état, la condition est donc sans effet
f Une condition qui provoque une transition sans produire d'action correspond souvent
.à la sortie d'un état d'attente
f Lorsque plusieurs actions indépendantes ont lieu lors du même transition, elles
.s'exécutent simultanément, sauf si un ordre de déroulement est explicitement indiqué
Exemple: régulation d'amplitude d'un signal sonore

évènementiel
REPOS
marche . arrêrt .
<A> SAISIR SAISIR
seuil normal seuil normal
AMPLIFIER MAINTIEN REDUIRE

arrêrt .
arrêrt . seuil mini atteint REDUIRE
seuil maxi atteint
AMPLIFIER <A> AMPLIFIER SAISIR
<A> REDUIRE
 SAISIR
AMPLIFICATION REDUCTION
diagramme d’état transition
VI/ LES COMPOSANTS D'UN MODELE ESSENTIEL

: Un modèle essentiel est composé
, d'une représentation hiérarchisée de transformations
, des spécifications des transformations de données et de contrôle
 de la spécification des données et des événements dans un dictionnaire de
,données
. de la spécifications des exigences temporelles

Un modèle essentiel est donc constitué d'un modèle d'environnement et d'un modèle de
comportement. Le modèle d'environnement contient le schéma de contexte du système, et la
liste des événements en provenance de l'environnement auxquels le système doit répondre.
Le modèle de comportement contient les modèles des aspects fonctionnel, événementiel et
.informationnel du système
évènementiel
modèle
d’environnement spécification des liste des
temps de réponce évènements externes
schéma de contexte
Spécifications schéma de Spécifications

des des
transformation flots de transformations flots
d’év.ts transformation
de données données de contrôle
(ST)
données évènements
données dictionnaire de données évènements
modèle de
comportement Relations entre les composants du modèle de
spécification
( VI/ EXEMPLE COMPLET (Commande d'ouverture de porte
COMMANDE D'OUVERTURE DE PORTE

évènementiel
La commande d'ouverture de porte est réalisée à l'aide d'un lecteur de carte

.magnétique à passage manuel
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
événement en entrée événement indirect événement/action en temps de réponse

sortie
Passage de haut à bas carte détectée début de commande s maxi, pour une 1.5
du signal carte déblocage vitesse minimale de
présente carte de 10 cm/s
s mini, pour une 0.57
vitesse maximale de
carte de 150 cm/s
délai écoulée fin de commande s maxi 0.5
déblocage
:Travail demandé
donnez le diagramme de contexte -1
donnez le schéma préliminaire -2
détaillez la spécification des processus -3
donnez le dictionnaire de données -4
donnez la spécification de contrôle -5
:SOLUTION POSSIBLE
nte
ep rése
cart
COMMANDER commande
lecteur de carte déblocage
gâche électrique
top d’horloge
ouverture
magnétique
de porte
impu
lsion
Schéma de contexte d’une commande d’ouverture de porte
impul
sion
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
Schéma préliminaire de COMMANDER ouverture de porte
SPECIFICATION DES PROCESSUS

TESTER présence carte 2.0
précondition1
le signal CARTE PRESENTE passe de front haut à front bas
postcondition1
CARTE DETECTEE est produit
précondition2
le signal CARTE PRESENTE passe de front bas à front haut
postcondition2
CARTE LIBEREE est produit
CONSTITUER trame 3.0
précondition
aucune
postcondition
bit est rangé dans trame
VALIDER code 4.0
précondition1
& TRAME contient MARQUEUR DE FIN & CODE REFERENCE non vide
CODE extrait de TRAME & CODE dans CODE REFERENCE
postcondition1
CODE VALIDE est produit
précondition2
& TRAME contient MARQUEUR DE FIN & CODE REFERENCE non vide
CODE extrait de TRAME & CODE non dans CODE REFERENCE
postcondition2
CODE ERRONE est produit
précondition3
TRAME contient MARQUEUR DE FIN & CODE REFERENCE vide
postcondition3
CODE ERRONE est produit
DEBLOQUER gâche 5.0
précondition
aucune
postcondition
émettre COMMANDE DEBLOCAGE
LIMITER déblocage 6.0
remarque : DELAI COURANT variable privée
précondition
DELAI COURANT = DELAI DE GARDE
postcondition
DELAI ECOULE est produit
EFFACER trame 7.0
précondition
aucune
postcondition
TRAME est nulle
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> EFFACER trame
<D> TESTER présence carte
départ
carte détecté
<A> CONSTITUER trame
top horloge code erroné

saisie trame <D> EFFACER
trame
carte libérée délai écoulé

CONSTITUER trame DEBLOQUER
<D> VALIDER code gâche
attente
délai écoulé
<D>EFFACER trame
<A> DEBLOQUER gâche
<D> LIMITER déblocage
déblocage gâche
Le noyau Cours d’STR Informatique Industrielle
temps réel
Chapitre6
LE NOYAU TEMPS REEL

NTR
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
temps réel
: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
:définition et déclaration de tâches -1
:La déclaration d'un processus est identique à celle d'une fonction sans arguments
;(void tache(void
:structure du programme principal -2

(void main(void
/*initialisation du moniteur temps réel */ }
;(begin_ntr(SLEEP_OFF,WAITC_OFF, WAITSEMTO_OFF
/* start(tache1,100); /* activation de la tache1 avec la priorité 100
temps réel
/* /* remise en état des vecteurs et du masque d'interruption utilisés end_ntr();

{
Le tib de la tâche en cours d'exécution est pointé par le pointeur d'exécution "exec",
.variable globale du noyau
Le programme principal est une tâche comme les autres affectée en standard d'une
priorité nulle. Si on désire modifier cette priorité, on peut le faire à l'aide des primitives
.""set_priority" et "reset_priority
L'ordonnancement des processus utilise le critère "priorité fixe". Le numéro 0
correspond au processus le moins prioritaire. Plusieurs tâches peuvent avoir le même numéro
.de priorité; dans ce cas, leur gestion est du type FIFO
A chaque processus, le noyau réserve une pile dans le ts (Heap), sauf pour le
programme principal qui conserve sa pile en standard. La taille de chaque pile est de 4096
:octets. En conséquence
 Ne pas utiliser des variables locales au processus, les accès à ces variables se faisant
.par l'intermédiaire de la pile
 Ne pas "nettoyer" le tas dans le programme principal, ce qui détruirait et "planterai"
.irrémédiablement le système
Un problème peut survenir lorsqu'on utilise l'interruption du timer et les fonctions de
saisie clavier de la librairie standard de turboc (getchar, gerch ...), qui ne sont pas régentantes.
."Il vaut mieux donc utiliser les fonctions incar() et getcar() de "ntr
VII/ LISTE DES PRIMITIVES

temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
temps réel
"Fichier "ntr.lst
Publics by module
size = 777 BAL

new_bal _receive_bal_
receive_str_bal _send_bal_
send_str_bal_
size = 11377 COMM

COM _RX_Ready_
RX_car _RX_car_Error_
TX_Ready _TX_car_
buffer_e1 _buffer_e2 _
buffer_r1 _buffer_r2 _
calcul_CRC _calcul_LRC_
car_recu _data_ready_
deinstalle_vect_it_uart _delta_modem_
demasque_it_uart _devalide_RX_
devalide_TX _disable_it_err_recept_
disable_it_mod_mod _emet1_
emet1_on _emet2_
emet2_on _enable_it_err_recept_
enable_it_mod_mod _err_recept1_
err_recept2 _etat_CTS_
etat_DCD _etat_DSR_
etat_RI _flag_reception _
inhibe_it_err_recept _inhibe_it_mod_modem_
inhibe_it_recept_com _inhibe_it_transm_com_
init_port _init_port_it _
installe_vect_it_uart _it_uart1_
it_uart2 _masque_it_uart _
mod_modem1 _mod_modem2 _
new_trame _paccess1_
paccess2 _pbox1_
pbox2 _pbuff_e1_deb _
pbuff_e1_fin _pbuff_e2_deb _
pbuff_e2_fin _pbuff_r1_deb _
pbuff_r1_fin _pbuff_r2_deb _
pbuff_r2_fin _psemErr1_
psemErr2 _psemErrRecept1_
psemErrRecept2 _psemMod1_
psemMod2 _psemModMod1_
psemModMod2 _psemR1_
psemR2 _psemT1_
psemT2 _ptr_trame1_
ptr_trame2 _raz_RX_buffer_
read_aux _read_str_aux_
recept1 _recept1_on _
recept2 _recept2_on _
temps réel
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_
size = 6706 NTR

EOI _INTA00_
INTA01 _TIMER_
TIMER0 _TIM_CTL_
affich_etat _attach _
begin_ntr _compt_pid _
decremente _depot _
disable_its _enable_its_
end_ntr _exec_
gest_hor _getcar_
incar _inserer_
invalide_it_8259 _it_c_break_
it_stop _it_timer_
liberer _mask_
mutex_ecran _new_mailbox_
new_message _new_sem_
new_timer _newtib _
p_tib_desalloc _psemctrlc_
psemhor _psemutil_
psemwatch _psemwatchto _
psleep _ptibex_
putcar _pwatch_
pwatchto _ranger_
readcar _receive_
reset_priority _retrait_
savetib2_sched _savetibex_sched_
seminit _send_
set_priority _signalsem_
sleep_tr _st2_sched_
stack_sp _stack_ss_
start _stex_sched_
stop _suppr_
valide_it_8259 _waitc_
waitsem _waitsemto_
watchdog _watchto _
temps réel
/*** fichier : ntr.h ***/

<<stdio.h include#
/*()/*pour MK_FP(), FP_SEG(), FP_OFF(), enable(), disable <dos.h> include#
/*<alloc.h>/*pour calloc et free include#
/*<conio.h>/*pour getch include#
/*<process.h>/*pour exit include#
/*... <float.h>/*pour _control87, _clear87 include#
<<bios.h include#
<<string.h include#
/*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 undef#
ESC 27 define#
/*/*flag option, param d'entr‚e de begin_ntr 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#
/*define TOUJOURS 1 /*Pour faire une boucle sans fin #
/*/*num it de savetib2_sched 0xF0 define NIT_ST2SCHED#

/*/*num it de stop 0xF1 define NIT_STOP#
/*/*num it de stex_sched 0xF2 define NIT_STEXSCHED#
/*----Adresses et constantes du timer 8255 et du gestionnaire d'its 8259-----*/

/*/*cmd d'eff d'it du 8259 : gest d'it extern const unsigned char EOI;
/*;/*adr du port 0 du 8259extern const unsigned int INTA00
/*;/*adr du port 1 du 8259extern const unsigned int INTA01
/*;/*adr de base du timer 8254 ou 8253 extern const unsigned int TIMER
/*;/*adr du reg de ctrl du timer extern const unsigned int TIM_CTL
/*;/*adr du reg de chargement 0 du timer extern const unsigned int TIMER0
/*/*Cƒbl‚e sur IRQ0, prio max. Vect 8 0x01 define M_IT_TIMER#
/*/*IRQ1. Vect 9 0x02 define M_IT_CLAVIER#
/*/*IRQ2. Vect 10 0x04 define M_IT_LIBRE#
/*/*IRQ3. Vect 11 0x08 define M_IT_COM1#
/*/*IRQ4. Vect 12 0x10 define M_IT_COM2#
/*/*IRQ7. Vect 15 0x80 define M_IT_LPT#
/*/*No vect it pour COM1 0x0C define IT_COM1#
/*/*No vect it pour COM2 0x0B define IT_COM2#
/*-d‚claration du type "task informations block" de taille impos‚e TAILLE----*/

define TAILLE 4096/*dans un 1er tps on fixe la taille du tib. Pour une alloc #
/*dynamique de cette taille, on verra plus tard
TTIB struct
}
/*/*pointe sur le tib suivant *lien; TTIB struct
/*/*pointe le pointeur pr‚c‚dent struct TTIB *(*pprec);
temps réel
/*/*priorite de la tche prio; long

/*‚/*ancienne priorit oldprio; long
/*/*pour l'utilisation d'un chien de garde timeout; long
/*(/*indique le timer de surveillance (si !NULL struct TIMER *ptim;
/*/*num‚ro d'identification du process unsigned long pid;
/*/*pour sauvegarder sp unsigned stack_off;
/*/*pour sauvegarder ss unsigned stack_seg;
/*/*sauvegarde le SP unsigned short *sptib;
/*/*pile de la tache dim non modifiable pour le mom pile[TAILLE]; char
/*/*pointeur de pgm ( *pctib)(void); void
/*/*Pour sauvegarder le registre d'‚tat unsigned short flags;
;{
l'initialisation, aprŠs la cr‚ation du tib, sptib pointe sur le …*/
sommet du contexte m‚moris‚, lui-meme initialis‚ … 0, et pctib pointe sur la
/*.premiŠre instruction de la tache
/*extern unsigned long compt_pid;/*Compteur identificateur des process
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
;{
/*D‚claration de la structure de type TIMER, pour utiliser des d‚lais */

struct TIMER
}
/*struct TIMER *lien;/*pointe sur le timer suivant dans la liste
/*struct TIMER *(*pprec);/*pointe le pointeur pr‚c‚dent
/*long n;/*valeur du timer
/*struct TTIB *point;/*pointe sur le tib … surveiller
/*struct SEMAPHORE *psem;/*sem o— est ranger la tƒche … surveiller
;{
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 TIMER *psleep;/*pour pointer le debut de la liste des timers

/*extern struct TIMER *pwatch;/*liste des taches … surveiller avec le chien de garde
/*extern struct TIMER *pwatchto;/*liste taches … surveiller avec time out
extern struct SEMAPHORE *psemhor, *psemwatch, *psemwatchto,
/**psemutil;/*attach‚s … l'it timer
/*extern struct SEMAPHORE *psemctrlc; /*attach‚ … l'it ctrl-c
/*(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 */
temps réel
extern struct TTIB *ptibex;/*pour pointer momentan‚ment le tib actif : sert de

param d'entr‚e … la fonction "stex_sched" et "savetibex_sched", sauve ds tib
/*"d'‚x‚cution le contexte de la tache active, puis : "scheduler
/*extern struct TTIB *p_tib_desalloc;/*pt sur tib … d‚sallouer, p d'in de sched
/*extern void interrupt ( *old_vect[])(void);/*Pour sav vect de 8 … 15

/*extern void interrupt ( *old_vect_1C)(void);/*save old vect 1C
/**extern struct SEMAPHORE *semit[8];sem attach‚ … chaque it **/
/*extern unsigned char mask, maskin;/*maskin sauve l'ancien masque d'it du 8259
/*extern void interrupt ( *old_vect_stop)(void);/*save old vect
/*extern void interrupt ( *old_vect_st2sched)(void);/*save old vect
/*extern void interrupt ( *old_vect_stexsched)(void);/*save old vect
/*extern void interrupt ( *old_vect_timer)(void);/*save old vect timer
/*extern void interrupt (*old_vect_23)(void);/*vect du ctrl_c
/*extern REG8250 old_com1, old_com2;/*Pour sauver la conf des uart
/*struct TMESSAGE /*D‚claration du type message

}
;struct TMESSAGE *suivant
;char *pstr
;{
/*"struct TMAILBOX /*D‚claration du type "boŒte aux lettres

}
/*struct TMESSAGE *suivant;/*pointe sur le 1er mess de la boŒte
/*struct SEMAPHORE nbre;/*nbr de mess et indic nbre de consomm en att
/*struct SEMAPHORE mutex;/*exclusion mutuelle entre consom et product
;{
/*D‚claration de la structure de type BAL, boŒte aux lettres de taille fixe */

/*1024 /*dimension d'une boŒte aux lettres de taille fixe define DIM_BAL#
/*‚/*Ce type MESSAGE peut ˆtre modifi‚ … volont typedef char MESSAGE;
typedef struct
}
/*/*MESSAGE peut ˆtre de type quelconque buffer[DIM_BAL]; MESSAGE
/*struct SEMAPHORE places,messages;/*nbr de places et de messages
/*‚deb,fin;/*deb "pointe" le premier message d‚pos int
;struct SEMAPHORE mutex_producteur,mutex_consommateur
;BAL {
/*extern struct SEMAPHORE mutex_ecran;/*Pour l'int‚grit‚ des messages sur l'‚cran
/***"fonctions d‚finies ds "ntr.c" et "bal.c ***/
;(extern int attach(struct SEMAPHORE *psem, unsigned nit

/*extern void affich_etat(void);/*Pour afficher l'‚tat du processeur
;(extern void begin_ntr(int sleep_on, int waitc_on, int waitsemto_on
;(extern void interrupt it_c_break(void
/*extern void config_its(void);/*donne aux its la config d‚sir‚e
/*extern void decremente(struct TIMER *);/*ts les timers rang‚s derr psleep
temps réel
/*extern void depot(struct TMESSAGE *, struct TMAILBOX *);/*zone, pmailbox

/*extern void disable_its(void);/*inhibe les its au niveau du 8086 et du 8259
/*extern void enable_its(void);/*Valide toutes les its au niveau du 8086 et du 8259
/*extern void end_ntr(void);/*d‚finie dans ntr.c : fin moniteur tr
/*extern void gest_hor(void);/*gestion d'une horloge temps r‚el
/*/*saisie un caractŠre au clavier avec attente extern int getcar(void);
/*/*saisie d'un car au clavier ss attente extern int incar(void);
;(* extern void inserer(struct TTIB *(*), struct TTIB
;(extern void install_it_timer(void interrupt (*pfit)(), double ttick
;(extern void interrupt it_key(void
/*()extern void interrupt it_stop(void);/*associ‚e … stop
/*extern void interrupt it_timer(void);/*Interruption point‚e par le vect no 8
;(extern int invalide_it_8259(int nit
;(extern int liberer(unsigned nit
/*extern BAL *new_bal(void);/*alloc m‚m nouv boite aux lettres de taille fixe
/*extern struct TMAILBOX *new_mailbox(void);/*alloc m‚m nouv boŒte aux lettres
/*extern struct TMESSAGE *new_message(void);/*alloc m‚m d'un nouv message
/*extern struct SEMAPHORE *new_sem(void);/*alloc m‚m d'un nouveau s‚maphore
/*extern struct TTIB *newtib(void);/*allocation m‚m d'un nouveau tib
/*extern struct TIMER *new_timer(void);/*allocation m‚m d'un nouveau timer
;( extern int putcar( int ch
/*extern void ranger(struct TIMER *(*),struct TIMER *);/*range "ptim" ds psleep
;(extern int readcar(void
;(* extern char *receive(struct TMAILBOX
;(extern MESSAGE receive_bal(BAL *pbox
;(extern char *receive_str_bal(BAL *pbal
;(extern void reset_priority(void
;(* extern struct TMESSAGE *retrait( struct TMAILBOX
/*()extern void interrupt savetib2_sched(void);/*associ‚e … st2_schedl
/*()extern void interrupt savetibex_sched(void);/*associ‚e … stex_sched
/*extern void seminit(struct SEMAPHORE *, long);/*psem, valinit
/*extern void send(char *, struct TMAILBOX *);/*message, pmailbox
;(extern void send_bal(MESSAGE m, BAL *pbox
;(extern void send_str_bal(char *pm, BAL *pbal
/*‚extern void set_priority(long);/*nouvelle priorit
/*extern void signalsem(struct SEMAPHORE *);/*active une seule tache … la fois
/*extern void sleep_tr(long);/*n : paramŠtres = n ticks d'horloge
/*(extern void st2_sched(void);/*sav tib2, "scheduler"; f(exec, p_tib_desalloc
/* ‚extern int start( void (*)(void), long);/*cr‚e la "tache" avec sa priorit
/*"extern void stex_sched(void);/*sauve tib actif (d'‚x‚cution) puis "scheduler
/*/*primitive d‚finie ds ntr.c extern void stop(void);
/*extern void subroutine(void);/*Pour revenir au d‚but de main
;(extern void suppr(struct TIMER *ptim
;(extern int valide_it_8259(int nit
/*extern void waitc(struct SEMAPHORE *, long, long *);/*sem, nticks, *pt_out
/*extern void waitsem(struct SEMAPHORE *);/*mise en att si sem.compt==0
;(extern void waitsemto(struct SEMAPHORE *sem, long ntic, long *pt_out
;(extern void watchdog(void
;(extern void watchto(void
temps réel
/*"comm.h"/*d‚clarations pour les communications avec comx include#

ISET DE SFAX A.U: temps réel
1997/1998 Sem 2
TP N°1
II N4 Cours de Mr: TAYARI Lassaad
T P STR N°1
STR
SYSTEME DE MESURE DE FREQUENCE D'UN

SIGNAL ELECTRIQUE
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
A.U:1997/1998 Sem 2 ISET SFAX TP NTR Systèmes temps réel
é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
:Spécification du système -1
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
TP 65 Page M TAYARI.L
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
Schéma préliminaire de DONNER fréquence
temps d’acquisition
impulsions
GERER
COMPTER A/I temps
impulsions A/I 2.3
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
commande
<D> lire touche REPOS
touche=F3 touche=F1
<A> produire fréquence
MESURE touche=F2
calcul terminé
 produire fréquence
<D> affichage fréquence
commande
AFFICHAGE
<D> lire touche
touche=F3
FIN schéma état transition de DONNER fréquence
REPOS
A
impulsion =0
temps=0
<A> compter imulsion
<A> Gérer temps
ACQUISITION
temps achevé
 compter impulsion
 Gérer temps
<D> calculer fréquence
Diagramme état transision de MESURER fréquence
:Travail demandé
.trouver le diagramme de contexte du système -1
étudier et commenter le diagramme préliminaire -2
construire le dictionnaire des données -3
.faire la spécification des processus préliminaire en utilisant l'approche procédurale -4
En utilisant le Langage C essayez d'implanter le système -5
ANNEXE
<include <stdio.h #
<include <dos.h #
<include <conio.h #
/* /* The parallel port interrupt define INTR1 0X0F#

/* /* The clock tick interrupt define INTR2 0X1C#
/* /* The keyboard interrupt define INTR3 0X09#
define F1 59#
define F2 60#
define F2 61#
ifdef __cplusplus #
... define __CPPARGS#
else #
define __CPPARGS#
endif #
;(void interrupt ( *oldhandler1)(__CPPARGS

;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
}
;++temps
;()oldhandler2
{
/*--------------------------------------------------------------------*/
/* void interrupt handler3(__CPPARGS) /* if C++, need the the ellipsis
}
/* disable interrupts during the handling of the interrupt */
;()disable
;(Key=inportb(0x60
;Key=Key%128
/* reenable interrupts at the end of the handler */
;()enable
;()oldhandler3
{
/*-------------------------------------------------------------------*/
(int main(void
}
/* save the old interrupt vector */
;(oldhandler1 = getvect(INTR1
/* install the new interrupt handler */

;(setvect(INTR1, handler1
/* // outp(0x37a,0x15); /* autoriser l'interruption au niveau du port
/* outp(0x21,0x00); /* démasquer l'interruption du port // au niveau du 8259
;count1=100
((while ((nbr_impulsions<count1 )&& (Key!=1
}
;(printf("nbr_ impulsions %d temps écoulé is %d code key %d\n",count,countt,Key
/*(informer le 8259 de la fin d'interruption du port // (EOI */
/* ainsi on va lui permettre de mettre … jour ses registres IIR & ISR */
;(outportb(0x20,0x20
{
/* reset the old interrupt handler */

;(setvect(INTR1, oldhandler1
;return 0
{
Bon travail
ISET DE SFAX A.U: 1997/1998 Sem 2
TP N°2
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
/** Fichier EX1_NTR.C **/

/* .Essai du moniteur temps réel : start, stop */
"include "ntr.h #
/*"/*déclaration "en avant extern void tache1(void);

/*#######################################################################*/
(main(void void
}
/*begin_ntr(SLEEP_OFF, WAITC_OFF);/*initialisation du moniteur temps réel
;()clrscr
;("printf("Début du process principal ( EX1_NTR.C )\n
/*start(tache1, 100);/*armer la tache1 avec la priorité 100
;(start(tache2, 200
;(start(tache3, 300
;("printf("\nFin du process principal ( EX1_NTR.C)\n
/*end_ntr();/*remise en état des vect d'it
{
/*---------------------------------------------------------------------------------------------------------*/
/*tache1(void)/*priorité 100, dim tib = TAILLE void
}
;(printf("\n\nTache numero 1. Process numéro : %3lu. Priorite 100\n",exec->pid
;("<-------.printf("Sortie de la tache1 ; avant le stop
;()getcar
;()stop
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(printf("\n\n\tTache numero 2. Process numéro : %3lu. Priorite 200\n",exec->pid
;("<----------printf("\tSortie de la tache2 ; avant le stop
;()getcar
;()stop
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(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
{
/*---------------------------------------------------------------------------------------------------------*/
.Créer votre fichier projet TP2STR.prj -1

:Ce fichier doit contenir les lignes suivantes
((ntr.h comm.h EX1_NTR.C
ntr.lib
? Compiler puis exécutez votre programme. Que remarquez vous -2
Essayer de modifier l'ordre d'appel des fonctions start dans le programme principal. Que -3
? remarquez vous
Donner aux trois taches une même priorité. Que remarquez vous ? Expliquez -4
Essayer de lancer la tache2 a partir de la tache1 et la tache3 à partir de la tache2, puis à nouveau la -5
.tache1 à partir de la tache3. Quel la différence, expliquez
.Refaire l'étape 5, mais, maintenant, la tache2 a une priorité de 75 et la tache3 a une priorité de 50 -6
(Exercice N°2: (waitsem, signalsem

Dans cet exercice, le programme principal émet en permanence un signal sur le sémaphore
événement "semEV", tant que l'ordre de "fin de programme" ne lui est pas transmis. Cet ordre est
matérialisé par la valeur "ESCape" d'une variable globale de type caractère. "C" est donc une
variable partagée entre le programme principal et les autres tâches du système. Trois tâches dont le
rôle est d'afficher un message de présentation "Corps de la tâche x \n" et un message d'attente clavier
.pour saisir la variable partagée "c". Il faut que les trois tâches soient activées de façon cyclique
/*.Essai du moniteur temps réel : waitsem, signalsem*/
"include " ntr.h #
/*struct SEMAPHORE *semEV;/*pour utiliser un sem comme évènement

;char c
/*#######################################################################*/
(main(void
}
;c=0
/*semEV = new_sem();/*allocation mémoire du sémaphore
/*semEV->compt = 0; semEV->point = NULL;/*déjà fait par new_sem
;()clrscr
/*begin_ntr(SLEEP_OFF, WAITC_OFF, WAITSEMTO_OFF);/*init mon temps réel
;("printf("Début du programme principal (EX2_NTR.C)\n
;()printf("\nAvant le start tache1---->\n"); getch

/*start(tache2, 100);/*meme prio pour qu'elle passent à leur tour
;(start(tache3, 100
(while(c!=ESC
}
/*;()printf("\nAvant signal-->");/*getch
;(signalsem(semEV
{
;("printf("\nFin du Programme principal (EX2_NTR.C)\n
;()end_ntr
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(printf("\n\t\tTache 1, Process %3lu, priorite 100\n", exec->pid
(while(1
}
/*;()printf("\n\t\tt1 : avant waitsem -->");/* getch
;(waitsem(semEV
;("printf("\n\t\tCorps de la tache 1\n
;(" <-- printf("\t\tAny key
;()c = getch
{
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(printf("\n\t\t\t\tTache 2, process %3lu, priorite 100\n", exec->pid
(while(1
}
/*;()printf("\n\t\t\t\tt2 : avant waitsem -->");/* getch
;(waitsem(semEV
;("printf("\n\t\t\t\tCorps de la tache 2\n
;(" <-- printf("\t\t\t\tAny key
;()c = getch
{
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(printf("\n\t\t\t\t\tTache 3, process %3lu, priorite 100\n", exec->pid
(while(1
}
;()printf("\n\t\t\t\t\tt3 : avant waitsem -->"); getch
;(waitsem(semEV
;("printf("\n\t\t\t\t\tCorps de la tache 3\n
;(" <-- printf("\t\t\t\t\tAny key
;()c = getch
{
{
/*---------------------------------------------------------------------------------------------------------*/


?Est-il nécessaire de prévoir un mécanisme d'exclusion mutuelle sur la variable "c"? Pourquoi -3
?Que ce passe-il, si les tâches 1, 2 et 3 avaient une priorité respective de 100, 200 et 300 -4
.Donner aux trois tâches des priorités différentes, et voir l'effet sur le déroulement de l'exécution -5
(Exercice N°3: (gestion des interruptions

Dans cet exercice, trois tâches de même priorité (déroulement cyclique) doivent être éveillées
toutes les secondes par le timer. Chaque tâche se contentera d'afficher un message du type "Corps de
."la tâche x \n

/*.Essai du moniteur temps réel : utilisation d'une interruption, semit */
"include "ntr.h #
/*/*déclaration en avant extern void horloge(void);

/*struct SEMAPHORE *psem_te;/*Sémaphore événement de l'horloge diviseur

/*struct SEMAPHORE sem_it;/*Sémaphore événement de l'it timer
/*#######################################################################*/
(void main(void
}
;()clrscr
/*psem_te = new_sem();/*réinitialisé aussi à zéro
;("printf("Debut du process principal (EX3_NTR.C) \n
/*start(tache2, 100);/*meme prio pour qu'elle passe à leur tour
;(start(tache3, 100
/*start(horloge, 200);/*La plus forte priorité
/*while(getcar()!=ESC);/*Le pp ne fait rien ; sortie par ctrl_c
;("printf("Fin du process principal (EX3_NTR.C) \n
;()end_ntr
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(printf("\n\tTache 1, Process %3lu, priorite 100\n", exec->pid
;("printf("\tOn va se mettre en attente derriere \"*psem_te\"\n
(;;)for
}
;(waitsem(psem_te
;("printf("\tCorps de la tache 1\n
{
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(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
{
{
/*---------------------------------------------------------------------------------------------------------*/
}
;(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
/*/*1 seule tach éveillée if( --t==0 )

}
; t=20
;(signalsem(psem_te
{
{
{

.Modifier ce programme pour éveiller simultanément les trois tâches toutes les secondes -3
? Essayer l'exécution avec des priorités différentes. Que remarquez vous -4
-Fin de TP-
Bon travail
A.U: 1997/1998 Sem 2 ISET DE SFAX
TP N°3
Cours de Mr: TAYARI Lassaad II N4
STR Durée : 1h 30mn
(Exercice N°1: (Programmation directe d'une horloge

On dispose du timer pour génerer des interruptions toutes les 54.924 ms. On désire activer
.trois tâches à des intervalles réguliers égaux respectivement à 1s, 5s et 10s
Pour résoudre ce problème, il faut trois tâches tache1, tache5 et tache10. Une tâche matérielle
"it_timer" qui, toutes les 55 ms, envoie un signal pour assurer la synchronisation entre le sémaphore
.d'interruption les trois autres tâches
:Le schéma fonctionnel du système peut être le suivant
tache1
180
evt
1
it_timer semit HORLOGE evt5 tache5
150
evt10
tache10
130
*/
: 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#
/*"/*déclaration "en avant extern void horloge(void);
;struct SEMAPHORE evt1, evt5, evt10, semit
(main(void void
}
;("printf("Debut du process principal ( tpntr4_1 )\n
/*/*La plus grande priorité start(horloge ,1000);
/*/*Le pp ne fait rien while(incar()!=ESC) ;
;()end_ntr
;("printf("Fin du process principal ( tpntr4_1 ), retour au DOS\n
{

}
;("printf("\nTache numero 1, priorite 180\n
;("printf("On va se mettre en attente 1 seconde\n
(while(1
}
.
.
.
.
{
/*/*Jamais exécuté stop();
{

}
;("printf("On va se mettre en attente 5 secondes\n
(while(1
}
.
.
.
{
{

}
;("printf("On va se mettre en attente 10 secondes\n
(while(1
}
.
.
.
{
{
(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(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
.Terminer le programme suivant pour qu'il puisse répondre à notre problème -1
.Compiler puis exécutez votre programme -3
Bon travail
ISET DE SFAX A.U: 1997/1998 Sem 2
TP N°4
STR
TRANSFERT ENTRE TACHES PAR BOITE AUX LETTRES

(send & receive )
Une tache "demandeur" désire sous traiter une partie de son activité à une autre tache
"soustraitant" en ressource commune. Pour cela, elle transmet un message précisant le type de
.travail à effectuer, puis attend le message de réponse
Dans cet exercice, il n'y a qu'un seul demandeur et un seul soustraitant, mais on
.n'utilisera qu'une seule boite aux lettres pour la demande et la réponse
Si on veut que le CPU soit donné au sous traitant quand on a déposé le message, il
faut que la priorité du sous traitant soit >= à celle du "demandeur". Mais dans ce cas où il n'y
a qu'une boite aux lettres, il faut faire une priorité tournante entre le demandeur et le sous
traitant, si on veut que le demandeur puisse faire son travail. Donc prio( demandeur )
.( =prio(soustraitant
Pour la clarté de l'exercice, les affichages de la tache "sous1traitant" commenceront
.toujours par 4 tabulations afin d'apparaitre à droite de l'écran
Ordre Ordre
DEMONDEUR SOUS TRAITANT
Réponse Réponse
"include "ntr.h#
/*/*décl en avant extern void demandeur1(void);

/*/*décl en avant extern void soustraitant(void);
/*/*décl en avant extern void execute(char *);
;int car
/*struct TMAILBOX *pmail;/*Pointeur sur la b aux lettres
(main(void void
}
;()clrscr
.
.
.
.
.
.
;()end_ntr
{
/*------------------------------------------------------------------------------------------------------------*/
/*/*priorité 100, dim tib = TAILLE demandeur1(void) void
}
/*/*Pour transmettre l'ordre char ordre[256[;
;char *preponse
;car = 0
;("printf("\nDebut Tache demandeur1, priorite 100\n
(while( car != ESC
}
.
.
.
.
.
{
;()stop
{
/*------------------------------------------------------------------------------------------------------------*/
/*soustraitant(void)/*priorité 100, dim tib = TAILLE void
}
/*/*Pour recevoir l'ordre char *pordre;
;char *preponse
;"preponse = "\nLe travail est execute\n
;("printf("\n\t\t\t\tDebut tache de sous traitance, priorite 100\n
(while(1
}
.
.
.
.
.
{
{
/*------------------------------------------------------------------------------------------------------------*/
(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
Complétez ce programme pour qu'il puisse répondre au spécifications du problème -1
.Créer votre fichier projet TP4STR.prj puis compilez -2
Changer les priorités des tâches "demandeur" et "sous traitant". Voir l'effet de ce -3
.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
BIBLIOGRAPHIE
Le temps réel en milieu industriel [[

concepts, environnement, multitâches
A.DORSEUIL & P.PILLOT
Les bases de l'informatique industrielle [[

J.LERAY
Le temps réel et ses applications a la commande des processus industriels [[

ISET de Gabès et IUT de Grenoble
((seminaire de formation à l'ISET de Gabès , les 28 et 29 octobre 1996)
méthodologie de spécification et la conception pour les systèmes temps réels [[

PEREZ

Cours TR

Transféré par

Droits d'auteur :

Formats disponibles

Cours TR

Transféré par

Informations du document

Titre original

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

Cours TR

Transféré par

Droits d'auteur :

Formats disponibles

Sommaire Cours d’STR Informatique Industrielle

3 Chapitre 1 INTRODUCTION AUX SYSTEMES TEMPS REEL

14 Chapitre 2 L'ENVIRONNEMENT TEMPS REEL

28 Chapitre 4 L'ASPECT INFORMATIONNEL

31 Chapitre 5 L'ASPECT EVENEMENTIEL

44 Chapitre 6 LE NOYAU TEMPS REEL (NTR)

60 Chapitre 7 TRAVEAUS PRATIQUES

ISET DE SFAX ~ A.U 97/98 2 Page TAYARI Lassaad

INTRODUCTION AUX CONCEPTS

:I- RAPPEL A LA NOTION DE MULTITACHE

Pointeur de données Pointeur de

?(Un identifiant de l'état instantané du processus (actif, en attente, bloqué •

:D- La communication et la synchronisation

Table des Table des Table des

ETAT DES PROCESSUS ET TRANSITIONS

Création d'un processus fils par son père -01

On ne peut parler d'un système temps réel (STR), que si on a un système

:c- Procédés à commander

.f Scrutation sur une variable analogique Exemple:

:f Sur les logiciels

:L'urgence et les délais -2

:c- Le déterminisme = délai

:Du côté processeur•

.Donc le matériel est déterministe

.Conséquence: La préemption ne s'applique qu'à la tâche de la plus haute priorité

Multitâche Réquisition du Multitâche

L'ENVIRONNEMENT TEMPS REEL

ISET DE SFAX ~ A.U 97/98 13 Page TAYARI Lassaad

trouve toutes les informations qui concernent le projet (besoins fonctionnel et

ISET DE SFAX ~ A.U 97/98 14 Page TAYARI Lassaad

:Cycle de vie d'un système

Spécification Conception Test et évaluation Fonctionnement

Cahier des charges CERTIFICATION Evaluation et test

ISET DE SFAX ~ A.U 97/98 15 Page TAYARI Lassaad

Cycle de développement en cascade

ISET DE SFAX ~ A.U 97/98 16 Page TAYARI Lassaad

La spécification d'un STR consiste en la modélisation de ses aspects fonctionnels,

:I/ ASPECT FONCTIONNEL

:L'aspect fonctionnel d'un STR porte sur

ISET DE SFAX ~ A.U 97/98 17 Page TAYARI Lassaad

Diagramme de contexte d’une exploitation de mesure

indicateur de presence fichier d’acquisition

compte rendu caractérisiques de l’acquisitiont

DFD préliminaire d’une exploitation de mesures

DFD de PRODUIRE rapport

DFD de VISUALISER courbe

Digrammes de flots de données: DFD -3

Rapport de l'acquisition boîtier

indicateur de présence énergie brute

vitesse signal sonore

mesures réelles seuil de température

:Bord de modèle -3.4

opérateur table traçante

LES REGLES DE FORMATION ET D'INTERPRETATION D'UN DFD -4

de vers processus stockage bord

La hiérarchisation du modèle fonctionnel -4.2

Diagramme de contexte: Le diagramme de contexte est le sommet de la

Hiérarchie Abstraction et masquage d’information

Repérage des niveaux et des processus: Chaque niveau porte le nom et le

/* fichier : ntr.h */

//num it de savetib2_sched 0xF0 define NIT_ST2SCHED#

/----Adresses et constantes du timer 8255 et du gestionnaire d'its 8259-----/

/-d‚claration du type "task informations block" de taille impos‚e TAILLE----/

//priorite de la tche prio; long

/extern unsigned long compt_pid;/Compteur identificateur des process

/D‚claration de la structure de type TIMER, pour utiliser des d‚lais /

/extern struct TIMER psleep;/*pour pointer le debut de la liste des timers

extern struct TTIB ptibex;/pour pointer momentan‚ment le tib actif : sert de

/extern void interrupt ( old_vect[])(void);/*Pour sav vect de 8 … 15

/struct TMESSAGE /D‚claration du type message

/"struct TMAILBOX /D‚claration du type "boŒte aux lettres

/D‚claration de la structure de type BAL, boŒte aux lettres de taille fixe /

/extern struct SEMAPHORE mutex_ecran;/Pour l'int‚grit‚ des messages sur l'‚cran

/"fonctions d‚finies ds "ntr.c" et "bal.c /