COURSTR

Cours d’STR Informatique Industrielle Sommaire
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 2 L'ENVIRONNEMENT TEMPS REEL 14

I- Introduction 14
II- Le génie logiciel et le temps réel 14
1- Le génie logiciel (Définition) 14
2- Cycle de vie d'un système 14
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 4 L'ASPECT INFORMATIONNEL 28

I- Introduction 28
II- La spécification des données composées 29
TAYARI Lassaad Page 1 ISET DE SFAX ~ A.U 97/98

Cours d’STR Informatique Industrielle Sommaire
III- La spécification des données primitives 30
Chapitre 5 L'ASPECT EVENEMENTIEL 31

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

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

Cours d’STR Informatique Industrielle
Introduction 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)
1. La synchronisation:
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
2. La communication:
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.
3. L'ordonnenceur (scheduler)
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
SELECTION DEBLOCAGE
(Dispatcher) DES PROCESSUS
Table des Table des Table des

processus processus événements
Eligibles Bloqués associés aux
processus
Bloqués
ROLE DE L'ORDONNENCEUR
INEXISTANT 1
2
HORS Service
3 7
14
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
ETAT DES PROCESSUS ET TRANSITIONS
01- Création d'un processus fils par son père

02- Destruction d'un processus
03- Activation d'un processus
04- Désactivation d'un processus
05- Sélection d'un processus par le dispatcher
06- Réquisition d'un processus par le dispatcher
07- Fin d'exécution du processus en cours
08- blocage sur accès à une ressource non disponible
09- Blocage sur attente de fin de délai
10- Blocage sur occurrence d'un événement (asynchrone)
11- Activation d'un processus forcé d'attendre l'écoulement d'un délai
12- Activation d'un processus forcé d'attendre un événement
13- Activation d'un processus forcé d'attendre la libération d'une ressource
14- Activation d'un processus suite à la libération de la ressource attendue
15- Activation d'un processus suite à l'écoulement d'un délai
16- Activation d'un processus à l'occurrence d'un processus
I-2 Les spécifications temps réel:
a- Définition:

Environnement
Action
SYSTEME Information sur PROCEDE A
INFORMATIQUE état COMMANDER
(é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.
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
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.
Exemple: f Scrutation sur une variable analogique.

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:
1- La validité des informations dans le temps:
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
2- L'urgence et les délais:

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
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
• 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.
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.
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)


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
1/ Le génie logiciel (définition)
"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.
2/ Cycle de vie d'un système:
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.
1. Expression des besoins:
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.
2. Développement d'un système:
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]

Cours d’STR Informatique Industrielle La
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:
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.

spécification
2- Exemple: (Exploitation de mesures acquises)
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
Diagramme de contexte d’une exploitation de mesure

spécification
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
ion rapport rapport de
demande r ess l’acquisition
mp 6.0
e d’i
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

spécification
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

spécification
3- Digrammes de flots de données: DFD

un DFD est un réseau de processus et de stocks de données connectés par des flots
de données.
3.1- Flots de données:
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.
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

spécification
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î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
3.3- Stockage de donnée:

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:
seuil de température mesures réelles
3.4- Bord de modèle:

spécification
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
4- LES REGLES DE FORMATION ET D'INTERPRETATION D'UN DFD

4.1- Connexions possibles
de vers processus stockage bord

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

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

spécification
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.
4.3- Abstraction et masquage

Le DFD d'un niveau ne contient que les informations nécessaires à la représentation
complète, mais sans détail, du processus qu'il décompose.(voir figure)
spécification
4.4- Conservation et interface entre niveaux

Chaque diagramme enfant comporte exactement les mêmes flots entrants et sortants
que son processus parent
5- SPECIFICATION DE PROCESSUS (MINISPECIFICATION)
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.
5.1- Spécification procédurale
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
sinon mettre COMPTE RENDU à échec
fournir COMPTE RENDU
5.2- Spécification par précondition/postcondition

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:
précondition1 NOM DE L'ACQUISITION est fourni

spécification
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.
5.3- spécification par équation (formule)

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

soit Vv = tension de commande de la vanne
e= température consigne - température courante
pour un temps de réponse de 0.5 s
0 si e > -2
Vv= 3e + 6 si |e| ≤ 2
12 si e < 2

Cours d’STR Informatique Industrielle L'apspect
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:
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
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:
date d'acquisition = JJ+MM+AA
JJ = * jour*
* types : entier, intervalle 1-31 * Diagramme de flots
Spécification de Flots de données
instant de données
= * temps correspondant à la lecture d'une mesure *
processus* type : entier, intervalle 1-4096, unité =µs * DFD
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 le lien
données
entre les différents niveaux d'un modèle fonctionnel.
données Dictionnaire de
données
TAYARI Lassaad Page 29
DDISET DE SFAX ~ A.U 97/98
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.

évènementiel
 L'inhibition (I): termine les activités d'une transformation

 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

évènementiel
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:
Ticket disponible Etat des postes
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

évènementiel
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
3- Les règles de formation d'un Schéma de Transformation (ST)

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.
4- Les connexions possible:
évènementiel
Transformation Transformation de Stockage de Stockage Bord

de vers de données contrôle données événements
Transformation
de données
Transformation A/I/D interdit interdit
de contrôle A/I/D
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)
1- Les composants:
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:

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

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.
3- Les règles d'interprétation:
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 1.5 s maxi, pour une
du signal carte déblocage vitesse minimale de
présente carte de 10 cm/s
0.57 s mini, pour une
vitesse maximale de
carte de 150 cm/s
délai écoulée fin de commande 0.5 s maxi
déblocage
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

évènementiel
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
Schéma de contexte d’une commande d’ouverture de porte
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
Schéma préliminaire de COMMANDER ouverture de porte

évènementiel
SPECIFICATION DES PROCESSUS

2.0 TESTER présence carte
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
3.0 CONSTITUER trame
précondition
aucune
postcondition
bit est rangé dans trame
4.0 VALIDER code
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
5.0 DEBLOQUER gâche
précondition
aucune
postcondition
émettre COMMANDE DEBLOCAGE
6.0 LIMITER déblocage
remarque : DELAI COURANT variable privée
précondition
DELAI COURANT = DELAI DE GARDE
postcondition
DELAI ECOULE est produit
7.0 EFFACER trame
précondition
aucune
postcondition
TRAME est nulle

évènementiel
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

évènementiel
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

Cours d’STR Informatique Industrielle Le noyau
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
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);
2- structure du programme principal:

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

end_ntr(); /* remise en état des vecteurs et du masque d'interruption utilisés */
}
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
BAL size = 777

_new_bal _receive_bal
_receive_str_bal _send_bal
_send_str_bal
COMM size = 11377

_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

temps réel
_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
NTR size = 6706

_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 ***/

#include <stdio.h>
#include <dos.h> /*pour MK_FP(), FP_SEG(), FP_OFF(), enable(),
disable()*/
#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>
#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*/
#define NIT_ST2SCHED 0xF0 /*num it de savetib2_sched*/

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

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

temps réel
struct TTIB *lien; /*pointe sur le tib suivant*/

struct TTIB *(*pprec); /*pointe le pointeur pr‚c‚dent*/
long prio; /*priorite de la tche*/
long oldprio; /*ancienne priorit‚*/
long timeout; /*pour l'utilisation d'un chien de garde*/
struct TIMER *ptim; /*indique le timer de surveillance (si !NULL)*/
unsigned long pid; /*num‚ro d'identification du process*/
unsigned stack_off; /*pour sauvegarder sp*/
unsigned stack_seg; /*pour sauvegarder ss*/
unsigned short *sptib; /*sauvegarde le SP*/
char pile[TAILLE]; /*pile de la tache dim non modifiable pour le mom*/
void ( *pctib)(void); /*pointeur de pgm*/
unsigned short flags; /*Pour sauvegarder le registre d'‚tat*/
};
/*… 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*/

temps réel
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()*/
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*/

#define DIM_BAL 1024 /*dimension d'une boŒte aux lettres de taille fixe*/
typedef char MESSAGE; /*Ce type MESSAGE peut ˆtre modifi‚ … volont‚*/
typedef struct
{
MESSAGE buffer[DIM_BAL]; /*MESSAGE peut ˆtre de type quelconque*/
struct SEMAPHORE places,messages;/*nbr de places et de messages*/
int deb,fin;/*deb "pointe" le premier message d‚pos‚*/
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"***/

temps réel
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*/
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*/
extern int getcar(void); /*saisie un caractŠre au clavier avec attente*/
extern int incar(void); /*saisie d'un car au clavier ss attente*/
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"*/
extern void stop(void); /*primitive d‚finie ds ntr.c*/
extern void subroutine(void);/*Pour revenir au d‚but de main*/
extern void suppr(struct TIMER *ptim);

temps réel
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);
#include "comm.h"/*d‚clarations pour les communications avec comx*/

ISET DE SFAX A.U:temps réel
1997/1998 Sem 2
II N4
TP N°1 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

Systèmes temps réel TP NTR ISET SFAX A.U:1997/1998 Sem 2
é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
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é:
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
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#define INTR1 0X0F /* The parallel port interrupt */

#define INTR2 0X1C /* The clock tick interrupt */
#define INTR3 0X09 /* The keyboard interrupt */
#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
II N4
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"
extern void tache1(void); /*déclaration "en avant"*/

/*#######################################################################*/
void main(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*/
}
/*---------------------------------------------------------------------------------------------------------*/
void tache1(void)/*priorité 100, dim tib = TAILLE*/
{
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();
}
/*---------------------------------------------------------------------------------------------------------*/
1- Créer votre fichier projet TP2STR.prj.

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

3- Est-il nécessaire de prévoir un mécanisme d'exclusion mutuelle sur la variable "c"? Pourquoi?
4- Que ce passe-il, si les tâches 1, 2 et 3 avaient une priorité respective de 100, 200 et 300?
5- Donner aux trois tâches des priorités différentes, et voir l'effet sur le déroulement de l'exécution.
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"
extern void horloge(void); /*déclaration en avant*/

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*/
if( --t==0 ) /*1 seule tach éveillée*/

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

3- Modifier ce programme pour éveiller simultanément les trois tâches toutes les secondes.
4- Essayer l'exécution avec des priorités différentes. Que remarquez vous ?
-Fin de TP-
Bon travail
TP N°3
II N4 Cours de Mr: TAYARI Lassaad
Durée : 1h 30mn
STR
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
evt1
semit evt5 tache5

it_timer HORLOGE
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"

extern void horloge(void); /*déclaration "en avant"*/
struct SEMAPHORE evt1, evt5, evt10, semit;
void main(void)
{
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");
}

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

{
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:
1- Terminer le programme suivant pour qu'il puisse répondre à notre problème.
3- Compiler puis exécutez votre programme.
Bon travail
II N4
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"
extern void demandeur1(void); /*décl en avant*/

extern void soustraitant(void); /*décl en avant*/
extern void execute(char *); /*décl en avant*/
int car;
struct TMAILBOX *pmail;/*Pointeur sur la b aux lettres*/
void main(void)
{
clrscr();
.
.
.
.
.
.
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)
{
.
.
.
.
.
}
}
/*------------------------------------------------------------------------------------------------------------
*/
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
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

COURSTR

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

COURSTR

Transféré par

Droits d'auteur :

Formats disponibles

Cours d’STR Informatique Industrielle Sommaire

Chapitre 2 L'ENVIRONNEMENT TEMPS REEL 14

Chapitre 4 L'ASPECT INFORMATIONNEL 28

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

Chapitre 5 L'ASPECT EVENEMENTIEL 31

Chapitre 6 LE NOYAU TEMPS REEL (NTR) 44

Chapitre 7 TRAVEAUS PRATIQUES 60

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

INTRODUCTION AUX CONCEPTS

Pointeur de données Pointeur de

* Zone de programme: Contient les instructions du programme et certaines constantes.

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

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

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

Table des Table des Table des

ETAT DES PROCESSUS ET TRANSITIONS

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

I-2 Les spécifications temps réel:

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

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

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

Avec [ T1 + T2 + T3 <TEMPS LIMITE ]

Exemple: f Scrutation sur une variable analogique.

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

2- L'urgence et les délais:

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

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

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

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

L'ENVIRONNEMENT TEMPS REEL

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

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

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

Cycle de vie d'un système:

Spécification Conception Test et évaluation Fonctionnement

Cahier des charges CERTIFICATION Evaluation et test

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

Cycle de développement en cascade

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

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

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

2- Exemple: (Exploitation de mesures acquises)

Diagramme de contexte d’une exploitation de mesure

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

indicateur de presence fichier d’acquisition

compte rendu caractérisiques de l’acquisitiont

DFD préliminaire d’une exploitation de mesures

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

DFD de PRODUIRE rapport

DFD de VISUALISER courbe

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

3- Digrammes de flots de données: DFD

Rapport de l'acquisition boîtier

indicateur de présence énergie brute

vitesse signal sonore

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

donnée sur laquelle porte la transformation. La référence numérique traduit la place du

3.3- Stockage de donnée:

seuil de température mesures réelles

3.4- Bord de modèle:

Définition: un bord du modèle représente une entité située dans

opérateur table traçante