5.3.1 Automates temporis´es
La figure 5.1 pr´esente la mod´elisation d’une des voies parall`eles et celle des barri`eres
au moyen d’automates temporis´es. Les automates pr´esent´es ici peuvent ˆetre directement
implant´es pour UPPAAL ; afin de les tester avec Kronos, un travail d’adaptation est
n´ecessaire et nous obtenons des automates plus complexes qu’il ne nous paraˆıt pas utile
de pr´esenter ici.
.
.
Far
t≤aM
Before
t≤eM
Inside
·|app!|t:=0
t≥am|·|t:=0
t≥em|exit!|·
clock t
.
.
Open
g≤gM
GoDown
Closed
g≤gM
GoUp
·|down?|g:=0
g≥gm|·|·
·|up?|g:=0
g≥gm|·|· ·|down?|g:=0
−|down?|·
·|down?|·
clock g
Figure 5.1 — A gauche, l’automate` Train, mod´elisant une voie et le train
associ´e, qui utilise un chronom`etret. `A droite, l’automateGates, repr´esentant
les barri`eres ; il utilise un chronom`etreg.
L’automate pour une voie d´emarre dans l’´etat Far(les ´etats initiaux sont dessin´es en
gras). Lorsqu’un train passe au niveau du premier capteur, l’automate passe dans l’´etat
Beforeen ´emettant le signal app! et en remettant `a z´ero le chronom`etret. Il peut rester
dans cet ´etat tant quet≤aM; `at=aM au plus tard, il doit passer dans l’´etatInsidequi
mod´elise le fait que le train se trouve entre les barri`eres ; cette transition n’est possible
que sit≥am et remett`a z´ero sans ´emettre aucun signal. De mˆeme, l’automate passe `a
nouveau `a l’´etatFar pourt∈[em, eM] en ´emettant le signal exit!.
Le fonctionnement de l’automate sp´ecifiant les barri`eres est similaire. Remarquons
que cet automate peut recevoir un signal down? depuis n’importe lequel de ses ´etats.
Par contre, il ne peut recevoir up? que lorsque la barri`ere est ferm´ee. Le nom des ´etats
indique sans ambigu¨ıt´e ce qu’ils repr´esentent au niveau du syst`eme concret. Ceci n’est
pas r´ealiste du point de vue de la mod´elisation mais constitue plutˆot une propri´et´e qu’on
devrait v´erifier. Dans ce cas et dans celui du contrˆoleur, certains signaux incontrˆolables
ne sont pas pris en compte dans tous les ´etats (alors qu’ils devraient l’ˆetre). Nous avons
fait le choix de cette version peu r´ealiste afin de garder une sp´ecification simple nous
permettant d’illustrer notre propos sans alourdir l’aspect technique.
Le contrˆoleur doit tenir compte des sp´ecificit´es de la barri`ere au niveau de la r´eception
des signaux. Son fonctionnement est assez simple : chaque fois qu’il re¸coit un signalapp?
(qui se synchronise avec leapp! ´emis par un automateTrain), il incr´emente un compteur
et envoie un signal down! aux barri`eres dans un d´elai compris dans [cm, cM]. Lorsqu’il
re¸coit un signalexit?, le contrˆoleur d´ecr´emente la mˆeme variable, si elle tombe `a z´ero, le
dernier train vient de quitter les barri`eres et un signalup! leur est envoy´e. La figure 5.2
donne l’automate mod´elisant le contrˆoleur.
.
.
Idle
c≤cM AppDown
c≤cM ExitUp
·|app?|c:=0 c≥cm|down!|n:=n+1
n=1|exit?|c:=0
c≥cm|up!|n:=0
n>1|exit?|n:=n−1
clock c, int n:=0
Figure 5.2 —L’automate temporis´eController repr´esentant le contrˆoleur. Il
utilise une variable enti`ereninitialis´ee `a z´ero et un chronom`etrec.
Le syst`eme complet est obtenu comme le produit synchronis´e dencopies de l’automate
Train (nomm´ees Traini, pour 1 ≤ i ≤n) et des automates Gates et Controller. Nous
obtenons un automate permettant l’ex´ecution entrelac´ee de tous ceux qui le composent
avec synchronisation sur les actions telles que app! etapp?.
La propri´et´e de s´ecurit´e et d’absence de blocage peut s’exprimer par une formule de
logique temporelle (dans une variante de CTL) :
∀¤³
¬deadlock´
∧³
(Train1.Inside∨ · · · ∨Trainn.Inside)⇒Gates.Closed´
,
qui peut se traduire ainsi :« Il est toujours vrai que le syst`eme n’est pas bloqu´e et que
si l’un des automatesTraini est dans l’´etatInsidealors l’automate Gates est dans l’´etat
5.3.2 M-nets
La sp´ecification avec des M-nets est calqu´ee sur celle avec les automates temporis´es
donn´ee plus haut. Pour chaque ´etat, nous aurons une place (un jeton dans celle-ci
cor-respondant `a l’activation de l’´etat) et pour chaque transition de l’automate, nous aurons
une transition d’un M-net d´epla¸cant un jeton d’une place `a une autre. Les transitions
portent les mˆemes actions et les mˆemes gardes. Il existe quand mˆeme quelques diff´erences
notables :
• nous pouvons repr´esenter toutes les voies (avec les trains) par un seul M-net, les
diff´erents trains ´etant repr´esent´es par diff´erents jetons ;
• le contrˆoleur n’utilise pas une variable enti`ere mais stocke le nombre de trains
dans ses places (ce qui a le mˆeme effet) ;
• nous avons en plus une horloge causale et les transitions portent des actions pour
communiquer avec elle ;
• les contraintes de temps sp´ecifi´ees dans les ´etats avec les automates sont ici
sp´e-cifi´ees au niveau de l’horloge ;
• les M-nets devant ˆetre ex-restreints, le syst`eme global d´emarre avec une action
silencieuse synchronisant l’initialisation de tous les M-nets le composant.
Nous utilisons une horloge causale tr`es similaire `a celle pr´esent´ee figure 4.2 (page 67)
mais l´eg`erement adapt´ee `a notre probl`eme. En particulier, puisque le syst`eme n’est pas
destin´e `a s’arrˆeter, l’horloge n’a pas de transition pour terminer, et sa transition
d’ini-tialisation est synchronis´ee avec les transitions initialisant les autres M-nets composant
le syst`eme. De plus, nous fixons le nombre de compteurs que l’horloge peut manipuler
et nous les assignons de la fa¸con suivante :
• le M-net repr´esentant le contrˆoleur `a l’identificateur 0, nous fixons doncm0=df cM;
• le M-net mod´elisant les barri`eres utilise l’identificateur 1 et nous posonsm1 =df gM;
• chaque train utilise deux identificateurs puisqu’il n´ecessite deux maximums (aM
eteM) qui sont fix´es dans l’horloge. Les trains ´etant num´erot´es de 1 `a n, le train
iutilise le compteur 2ipour son approche et le compteur 2i+ 1 pour son d´epart,
ce qui implique m2i
df
=aM etm2i+1=df eM.
L’horloge causale que nous utilisons est donn´ee figure 5.3.
.
.
⇐
⇒
gates,trains,ctrl Time
tic
V
i≤ncci6=mi
[
clock(id,c,c0)
{(0,ω),...,(nc,ω)}
{(0,c0),...,(nc,cnc)} {(0,c0+1),...,(nc,cnc+1)}
(id,c)
(id,c0)
Figure 5.3 — L’horloge causaleHr utilis´ee pour le passage `a niveau. Nous
avonsnc
df
= 2n+ 1 o`unest le nombre de voies parall`eles et le type de la place
interne est{(id, iid)|1≤id ≤nc, iid ∈ {0,1, . . . , mid, ω}}.
Les autres ´el´ements de la sp´ecification sont donn´es sur la figure 5.4. Nous pouvons y
reconnaˆıtre les automates transform´es comme nous l’avons d´ecrit plus haut.
.
.
⇒
⇐
[
gates Open \down,clock(1,g,0) GoDown \down
clock(1,g,ω)
g≥gm
Closed
\
down
c
up,clock(1,g,0)
GoUp
clock(1,g,ω) g≥gm
\
down,clock(1,g,0)
.
.
⇐
⇒
\
trains Far app,clock(y,t,0)
y=2i
Before
clock(y,t,ω),clock(y0,t0,0)
(t≥am)∧(y=2i)∧(y0=2i+1)
Inside
exit,clock(y0,t0,ω)
(t0≥em)∧(y0=2i+1)
{1,...,n}
i i
i
i
i
i
.
.
⇐
⇒
d
ctrl
Idle
d
app,clock(0,c,0)
AppDown
down,clock(0,c,ω)
c≥cm
d
exit,clock(0,c,0)
ExitUp
up,clock(0,c,ω)
c≥cm
d
exit
x≥2
0
x
x−1
x
x x
x+1
1
0
Figure 5.4 — De haut en bas, les M-nets Ng,Nt et Nc sp´ecifiant
respecti-vement les barri`eres, les voies avec leurs trains et le contrˆoleur. Les places
Far, Beforeet Inside ont le type{1, . . . , n}et les places AppDownet Idleont
le type {0, . . . , n}.
Nous obtenons le syst`eme complet en composant en parall`ele tous ces r´eseaux et en
synchronisant sur toutes les actions visibles :
Nr= (NgkNtkNckHr)sc{clock,down,up,app,exit,gates,trains,ctrl} .
Par rapport `a la sp´ecification `a base d’automates temporis´es, celle-ci peut sembler plus
des r´eseaux de Petri, pour lesquels les transitions sont des nœuds alors qu’il ne s’agit
que d’arcs dans les automates. Cependant, il est vrai qu’il faut ajouter les actions pour
communiquer avec l’horloge et que les valeurs des param`etres sont calcul´ees dans les
gardes. La mod´elisation est donc un peu plus complexe avec les M-nets ; en revanche
nous pouvons repr´esenter la concurrence (et non seulement l’entrelacement) alors que
c’est impossible avec les automates. Cet exemple n’exploite pas cette possibilit´e car nous
avons cherch´e `a calquer les M-nets sur les automates correspondants pour mettre en
valeur la ressemblance des sp´ecifications.
Nous v´erifions la s´ecurit´e du syst`eme en testant qu’il n’existe pas de marquage M
accessible `a partir du marquage d’entr´ee deNr tel que
(M(Inside)6=∅)∧(M(Closed) =∅) ,
ce qui s’exprime dans le formalisme de MARIA par :
reject !(place Inside equals empty)
&& (place Closed equals empty) && fatal;
L’absence de blocage peut aussi ˆetre directement exprim´ee par la clause :
deadlock fatal;
Ces deux clauses sont test´ees `a mesure que le graphe de marquage est g´en´er´e ; si l’une
ou l’autre est viol´ee, la g´en´eration est stopp´ee et l’erreur est signal´ee (c’est l’utilit´e du
mot-cleffatal).
Dans le document
Modèles composables et concurrents pour le temps-réel
(Page 85-89)