Mod´elisation de la partie discr`ete

La partie discr`ete de notre mod`ele est un programme ´ecrit dans une extension du langage SIMPLE d´ecrit `a la section 2.2.1. En plus des expressions arithm´etiques et des instructions discr`etes classiques, nous introduisons un nouveau type de variables, les variables continues (CV ar), et trois instructions hybrides (HStmt dans la figure 5.2). Ces trois instructions sont :

5.2. DESCRIPTION DU MOD`ELE 81

– sens.y?X o`u y <sub>∈ CV ar est une variable continue et X ∈ V ar est une variable discr`ete.</sub> Cette instruction sert `a mod´eliser l’effet d’un capteur qui alloue `a la variable discr`ete X la valeur de la variable continue y `a l’instant o`u l’instruction est ex´ecut´ee.

– act.k!c o`u c<sub>∈ {0, 1} et k ∈ N. Cette instruction repr´esente l’effet du k-i`eme actionneur sur</sub> l’environnement physique : la dynamique du milieu continu va ˆetre modifi´ee et sera r´egie, apr`es l’ex´ecution de l’instruction, par la fonction Fl, o`u l ∈ Bm est telle que la k-i`eme

coordonn´ee de l vaut c.

– wait u o`u u ∈ R+. Cette instruction sera utilis´ee pour symboliser la dur´ee des autres

instructions discr`etes : on suppose en effet que chaque instruction est instantan´ee et on ajoute explicitement des instructions wait pour compenser le fait qu’elles ne l’´etaient pas. Remarque Dans l’instruction de d´elai wait, nous supposons que le d´elai est un valeur constante u<sub>∈ R</sub>+. Nous n’autorisons pas `a ce que le d´elai soit une variable ou une expression arithm´etique

pour empˆecher les effets Z´enon. En effet, en autorisant le d´elai `a ˆetre une expression arithm´etique, on pourrait ´ecrire le programme

while1 do ¡wait¡1/(n_{∗ n)}¢; act.1!0; n := n + 1;¢

qui effectue une infinit´e d’actions en un temps fini. ´Etant donn´e que l’instruction wait attend un constante u∈ R+ comme argument, et comme les programmes sont de tailles finies, il existe un

temps minimum τ > 0 telle que toutes les instructions wait augmentent le temps d’au moins τ secondes. La seule possibilit´e d’avoir une ex´ecution infinie qui ne dure qu’un temps fini est donc d’avoir une ex´ecution infinie n’ex´ecutant qu’un nombre fini d’instructions wait.

Donc, la seule possibilit´e d’obtenir un effet Z´enon est d’avoir une boucle infinie telle qu’aucune des it´erations de la boucle ne contienne d’instructions wait. Le programme effectuerait alors une infinit´e d’actions en un temps nul. Une condition n´ecessaire (mais pas suffisante) pour ne pas avoir d’effets Z´enon est donc qu’il y ait une instruction wait dans le corps de chaque boucle infinie. Cette condition n’est cependant pas suffisante (l’instruction peut ne pas ˆetre ex´ecut´ee), et une analyse de vivacit´e permettrait de prouver l’absence d’effet Z´enon : il faut montrer que l’instruction wait sera ex´ecut´ee une infinit´e de fois. Des outils comme Terminator [CPR06b, CGP+_{07] permettent}

de le faire.

Nous nommerons cette extension de SIMPLE pour le calcul hybride H-SIMPLE. Cette extension est tr`es proche du langage initial (sa syntaxe compl`ete est donn´ee `a la figure 5.2), de sorte qu’il est facile de traduire un programme ´ecrit en SIMPLE en un programme de H-SIMPLE (en particulier, tout programme de SIMPLE est un programme de H-SIMPLE). Les rajouts sont li´es aux caract´eristiques hybrides de ces programmes (communication avec le milieu ext´erieur et notion de temps d’ex´ecution), et sont en fait souvent pr´esent, sous forme de commentaires, dans les codes critiques g´en´er´es depuis un langage de sp´ecification. Il n’est en effet pas rare de voir, au d´ebut d’une boucle, un commentaire indiquant la fr´equence `a laquelle cette boucle s’ex´ecute. Dans ces cas, il est tr`es simple d’ajouter une instruction wait `a la fin de la boucle pour simuler ce temps d’ex´ecution.

Remarquons que les choix que nous avons effectu´es pour encoder les ´echanges entre le pro- gramme et l’environnement continu ne sont pas anodins. Nous voyons en effet le programme et l’environnement comme deux processus dynamiques s’ex´ecutant en parall`ele, les capteurs et les actionneurs ´etant les canaux de communication entre les deux. Parmi l’ensemble des mod`eles de processus communiquant existant, celui qui se rapproche le plus du type de comminucation consid´er´e ici est le langage CSP (Communicating Sequential Processes) de Hoare [Hoa85]. En effet, les canaux de communication sont connus `a l’avance et fixes (le syst`eme ne cr´ee pas de nouveaux actionneurs ou capteurs dynamiquement). Nous avons donc choisi des instructions qui utilisent la mˆeme syntaxe que les instructions CSP : le “ ?” mod´elise la r´eception de valeur, le “ !” l’envoi de message.

D´efinition 5.2 (Mod`ele de la partie discr`ete) Un mod`ele ∆ pour la partie discr`ete est un tripl´e (CV ar, m, P ) tel que :

f _{∈ F} X _{∈ V ar} AExp : a ::= f _{| X | a + a | a − a | a × a | a/a}

BExp : b ::= true| false | a = a | a ≤ a

Stmt : s ::= X := a_{| s; s | if b then s else s | while b do s | hs}

u_{∈ R}+ X ∈ V ar y ∈ CV ar k ∈ N c ∈ {0, 1}

HStmt : hs ::= sens.y?X _{| act.k!c | wait u}

Fig._{5.2 – Syntaxe du langage H-SIMPLE.}

1. CV ar est un ensemble de variables continues ; 2. m∈ N est le nombre d’actionneurs disponibles ;

3. P est un programme ´ecrit dans le langage H-SIMPLE n’utilisant que des variables continues de CV ar pour les actions sens et que des entiers k∈ [1, m] pour les actions act.

Exemple 5.3 (Probl`eme des deux r´eservoirs.) La partie discr`ete du probl`eme des deux r´eservoirs (c’est-`a-dire le contrˆoleur) s’encode tr`es simplement en H-SIMPLE (figure 5.3). Le contrˆoleur mesure les hauteurs d’eau h1 et h2 (lignes 4 et 5), puis, si les niveaux critiques

ont ´et´e franchis, il actionne les vannes et d´eclenche une alarme indiquant un probl`eme critique dans le syst`eme. On a rajout´e dans le programme de la figure 5.3 deux fonctions d’anticipation (anticipate h1 et anticipate h2, lignes 14 et 15) qui permettent de pr´edire la hauteur d’eau dans chacun des deux r´eservoirs deux secondes dans le futur. On ne pr´ecise pas l’impl´ementation de cette fonction d’anticipation, on peut utiliser par exemple une extrapolation lin´eaire. En utili- sant les valeurs calcul´ees, on peut alors contrˆoler plus finement les niveaux d’eau en anticipant sur le temps de fermeture des vannes. On va donc ouvrir (ou fermer) les vannes si la valeur pr´edite d´epasse les seuils critiques (lignes 16 `a 23). En fin de boucle, l’instruction wait permet de simuler la dur´ee d’ex´ecution des instructions pr´ec´edentes (ici, 0.01 secondes).