• Aucun résultat trouvé

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