Editeur d'architectures logicielles et générateur de spécifications formelles - Manuel Utilisateur
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Editeur d’architectures logicielles et
générateur de spécifications formelles
Manuel Utilisateur
AMDJAR Hafid SOULA Mehdi
« Dans la mythologie grecque, Pégase (du grec Pegasus) est un cheval ailé. Il est
censé avoir fait jaillir, en frappant de son sabot le mont Hélicon, la source
Hippocrène où s'abreuvent les poètes. Pégase est donc la symbolisation de
l’inspiration poétique et de la créativité.»
Sommaire
1 – Introduction……………………………………………………………….. 4
1.1 Objectif…………………………………………………………………………………….4
1.2 Installation……………………………………………………………………………… 4
2 - Présentation générale…………………………………………………… 5
2.1 Aire de travail…………………………………………………………………………. 5
2.2 Menus……………………………………………………………………………………… 5
2.2.1 Menu Fichier………………………………………………………………. 5
2.2.2 Menu Architecture……………………………………………………… 6
2.2.3 Menu Edition……………………………………………………………….6
2.2.4 Menu Vue…………………………………………………………………… 6
2.2.5 Menu Ordre………………………………………………………………… 6
2.3 Barre d’Outils…………………………………………………………………………. 7
2.4 Panel de Création/Exportation………………………………………………. 7
2.5 Panel de Spécification……………………………………………………………. 8
3 - Fonctionnalités de Pegasus…………………………………………….9
3.1 Création d’une architecture…………………………………………………….9
3.1.1 Ajout de composants………………………………………………….9
a) Création d’un composant……………………………………… 9
b) Création d’un port…………………………………………………. 10
c) Création d’un port en entrée………………………………… 10
d) Création d’un port en sortie…………………………………. 10
e) Suppression des ports…………………………………………… 10
f) Création de liens……………………………………………………. 11
g) Suppression de liens………………………………………………11
h) Propriétés du composant……………………………………… 12
i) Les sous-architectures…………………………………………… 12
3.1.2 Editions des contraintes formelles……………………………. 13
3.2 Exportation……………………………………………………………………………… 14
3.2.1 Exportation des machines B……………………………………… 14
3.2.2 Export de l’architecture………………………………………………14
3.3 Documentation de l’architecture……………………………………………. 14
3.4 Propriétés de l’architecture……………………………………………………. 15
3.5 Sauvegarde et restauration…………………………………………………… 16
3.6 Impression……………………………………………………………………………… 16
4 - Le Langage B……………………………………………………………….. 17
5 - Exemple concret d’architecture……………………………………… 18
5.1 Le contrôle d’accès aux bâtiments………………………………………… 18
5.1.1 Présentation du sujet………………………………………………… 18
5.1.2 Modélisation avec Pegasus……………………………………….. 20
Introduction Ce manuel a pour but de faciliter la prise en main du logiciel Pegasus. Vous y trouverez l’explication de l’ensemble de ses fonctionnalités et ainsi que quelques exemples concrets d’utilisation. 1.1 - Objectifs A ce jour, peu de logiciels modélisant des architectures créées par des concepteurs ont vu le jour, Pegasus a été conçu dans le but de palier à cette lacune. Il propose aux concepteurs une solution à la fois complète et ergonomique, regroupant l’édition d’architectures et des contraintes formelles associées. Ce type d’application présente un intérêt non négligeable. En effet, elle fournie au concepteur une vue globale d’un système et des éléments qui le composent, à chaque étape du développement. Chaque décision prise sur l’ensemble de l’architecture pourrait ainsi être répercutée sur le schéma, et ainsi maintenir un modèle fiable à chaque instant. Pegasus apportera à chaque utilisateur un outil d’édition simple et efficace, adapté à ses besoins. Ses fonctionnalités avancées, notamment au niveau de l’ajout de spécifications en B, en font une application complète et performante. 1.2 - Installation Pegasus a été développé en Java et est ainsi portable sur la majorité des machines pc et compatibles, fonctionnant sous Microsoft Windows (9X/NT/2000/XP) et Linux intégrant la machine virtuelle de Sun (au minimum, la version 1.4.2 est requise). L’application fonctionne sur la majorité des configurations disponibles sur le marché. Voici la configuration minimale recommandée : PII 350 Mhz, 128 Mo de Ram, 3 Mo d’espace disque. 1.3 – Copyrights Ce logiciel est protégé par les lois sur le copyright. AMDJAR & SOULA en sont les uniques propriétaires. Il ne peut être utilisé, copié, enregistré ou distribué d'une manière quelconque sans autorisation écrite préalable. Son utilisation est aux risques et périls de l'utilisateur, nous ne sommes pas responsable de dommages et pertes de données ayant pu survenir lors de l'utilisation de ce logiciel. 4/22 Pegasus – Manuel Utilisateur
Présentation générale
2.1 - Aire de travail
L’environnement graphique de Pegasus s’organise comme suit :
L’application est divisée en deux parties :
- Une partie graphique permettant la création des architectures
- Un panel d’outil permettant la création des spécifications en
Langage B.
2.2 - Menus
2.2.1 - Menu Fichier :
• Nouvelle architecture : Efface l’architecture courante afin d’en éditer
une nouvelle.
• Ouvrir une architecture : Permet d’importer dans l’application une
architecture préalablement enregistrée.
5/22 Pegasus – Manuel Utilisateur• Enregistrer l’architecture : Permet d’enregistrer l’architecture courante
dans un fichier d’extension « pgs » (flux XML).
• Enregistrer l’architecture sous : Enregistre l’architecture courante à un
endroit spécifique.
• Imprimer l’architecture : Impression de l’architecture courante.
• Quitter : Ferme l’application.
2.2.2 - Menu Architecture :
• Générer les spécifications formelles (Langage B) : Exporte sous forme
de machines abstraites, les spécifications de chacun des composants de
l’architecture et de toutes les sous architectures.
• Exporter l’architecture au format JPEG : Exporte l’architecture courante
ou l’ensemble des architectures au format JPEG.
• Exporter l’architecture au format PDF : Offre la possibilité d’exporter
l’architecture ou l’ensemble des architectures dans un fichier PDF.
• Générer la documentation HTML : Permet de générer une
documentation complète et claire de l’ensemble des architectures, avec
pour chacun des composants, l’affichage de ses spécifications B.
2.2.3 - Menu Edition :
• Sélectionner tout : Sélectionne l’ensemble des composants de
l’architecture courante.
• Inverser la sélection : Inverse la sélection courante.
• Suppression : Supprime les composants sélectionnés.
2.2.4 - Menu Vue :
• Ajuster la grille : Ajuste la taille de la grille de l’éditeur d’architecture.
• Ajuster la taille des cellules de la grille : Ajustement des cellules pour le
placement des composants
• Afficher les limites de la page : Affiche les limites de la page à imprimer
2.2.5 - Menu ordre :
Le menu ordre permet de gérer l’affichage des composant et leur position
dans l’éditeur d’architecture.
6/22 Pegasus – Manuel Utilisateur2.3 - Barre d’outils
La barre d’outils offre la possibilité d’accéder rapidement à certaines
fonctionnalités de l’application.
: Efface l’architecture actuelle pour permettre l’édition d’une nouvelle
: Ouverture d’une architecture préalablement enregistrée
: Enregistrement de l’architecture courante
: Impression de l’architecture
: Génération des machines abstraites (Langage B)
: Outil de sélection
: Broom, outil permettant de déplacer de manière linéaire plusieurs composants.
: Alignement à gauche des composants sélectionnés
: Alignement vers le haut des composants sélectionnés
: Alignement vers le bas des composants sélectionnés
: Alignement à droite des composants sélectionnés
: Alignement vertical des composants sélectionnés
: Alignement horizontal des composants sélectionnés
: Espacement vertical des composants sélectionnés
: Alignement horizontal des composants sélectionnés
: Ajustement de la grille de l’éditeur
: Affichage de l’architecture mère du composant
2.4 - Panel de Création/Exportation
Ce panel permet d’ajouter des composants à l’architecture, d’exporter
l’architecture sous différents formats et d’afficher les propriétés des
architectures.
Ajout d’un composant à ports variables à l’architecture courante.
Export de l’architecture courante ou de l’ensemble des architectures au
format JPG
Export de l’architecture courante ou de l’ensemble des architectures dans
un fichier PDF
Génération de la documentation HTML de toutes les architectures
Affichage des propriétés de l’architecture courante
Affichage des propriétés de l’ensemble des architectures
7/22 Pegasus – Manuel Utilisateur2.5 - Panel de spécification
Ce panel regroupe un certain nombre d’outils permettant à l’utilisateur
d’éditer de manière intuitive les spécifications des composants crées.
L’utilisateur peut également par le biais de ce panel, insérer à chacun de
ses composants des contraintes de qualité. En effet, celles-ci lui
permettront d’identifier clairement les caractéristiques de tels éléments, le
rôle qu’ils devront jouer dans le système modélisé, et donc la place qu’ils
occuperont dans l’architecture. Ces paramètres détermineront la priorité
et l’importance de chaque composant, au sein du système modélisé.
Les différents boutons constituent
les différents champs existants
dans une machine abstraite.
En cliquant sur l’un d’eux,
l’utilisateur peut en éditer le
contenu, puis le sauvegarder par
le biais du bouton Enregistrer ou
bien en changeant tout
simplement de champ
(l’enregistrement se fait de
manière automatique).
8/22 Pegasus – Manuel UtilisateurFonctionnalités de Pegasus
3.1 - Création d’une architecture
La fenêtre d’édition graphique est la zone dans laquelle l’utilisateur va
créer son architecture. Elle constitue ce que l’on peut appeler la « planche
à dessin », où les composants vont êtres placés.
Il n’y a aucune restriction quant à l’endroit où les positionner : chaque
élément peut être inséré n’importe où dans la zone d’édition. De plus,
l’architecture ainsi créée n’est pas fixe. L’utilisateur peut très bien la
réorganiser en déplaçant les composants qui la constitue, ou en utilisant le
« broom » : cette option est particulièrement utile lorsqu’il est nécessaire
d’avoir une architecture claire, avec des composants alignés et
régulièrement espacés. Le broom fonctionne aussi bien en vertical qu’en
horizontal.
La première chose que pourra remarquer l’utilisateur est qu’il n’a pas à se
soucier de l’attribution d’un numéro à chaque composant. En effet, le
logiciel gère de lui-même l’insertion d’un nouvel élément, en lui affectant
un numéro et un nom par défaut Composant_ « numéro ». Ce nom est
visible à droite de la zone d’édition, et sera par défaut celui de la machine
B correspondant au composant. L’utilisateur pourra ensuite le modifier à
sa guise.
Remarque : L’application exécutera chaque action commandée par l’utilisateur, sans
vérifier la cohérence de son schéma. Ainsi, une architecture doit comporter des ports
d’entrées et de sorties, afin de communiquer avec son environnement.
3.1.1 - Ajout de composants
Une des fonctionnalités de Pegasus est d’offrir à l’utilisateur la possibilité
d’éditer ses propres composants en leur ajoutant le nombre de ports en
entrée et en sortie qu’il désire. Les différentes étapes de création sont
présentées ci-dessous.
a) Création d’un composant :
L’utilisateur a la possibilité de créer un composant, auquel il peut
ajouter autant de ports d’entrées et de sorties qu’il le désire. Lorsque l’on
clique sur le composant ainsi créé, un menu contextuel apparaît, indiquant
tous les différentes actions qui peuvent être effectuées :
9/22 Pegasus – Manuel UtilisateurSous menu Ajout
Sous menu Suppression
b) Création d’un port :
Cette fonction permet à l’utilisateur de définir des ports de
communications qui peuvent être utilisés pour les transferts entre
composants. Ces ports sont utilisables sans restriction, cependant un port
ne peut disposer de plus de 50 ports en entrées ou en sortie.
c) Création d’un port en entrée :
Ce port ne peut être positionné qu’en entrée d’un composant.
L’utilisateur à la possibilité d’en ajouter au fur et à mesure ou bien
plusieurs ports simultanément.
d) Création d’un port en sortie :
Ici, on a exactement le même type de port que développé
précédemment, ce port est lui destiné aux transferts des données des flux
de sortie.
e) Suppression des ports.
Il est possible de supprimer, au même titre que les composants, les
ports créés. Cependant, il revient à l’utilisateur de vérifier la cohérence de
son architecture après la suppression. Celle-ci se fait en cliquant sur le
composant concerner, et en sélectionnant le port à supprimer (entrée ou
sortie).
10/22 Pegasus – Manuel UtilisateurRemarque : L’utilisateur dispose de raccourcis clavier pour créer ou supprimer des ports
sur un composant sélectionné :
- F1 : Ajout d’un port en entrée
- F2 : Ajout d’un port en sortie
- F3 : Suppression d’un port en entrée
- F4 : Suppression d’un port en sortie
f) Création de liens :
A tout moment, l’utilisateur a la possibilité de compléter son
schéma en ajoutant des liens entre les différents composants.
Pour cela, il suffit de cliquer sur un port d’un des composants (le curseur
doit se transformer en croix), et de cliquer sur le port d’un autre
composant. Un lien doit apparaître entre les deux composants, orienté par
une flèche.
Chaque lien peut se voir affecter une valeur (limitée à 20 caractères) par
le biais d’un menu contextuel accessible grâce à un click droit sur le lien.
L’orientation des flèches est toujours du port de sortie vers le port
d’entrée.
Remarque : Deux liens ne peuvent être issus d’un même port. En effet, tous les ports
sont considérés comme unidirectionnels par le logiciel, de façon à décrire des surjections
partielles en langage B. L’utilisateur devra donc modifier son architecture en
conséquence.
g) Suppression de Liens :
Pour supprimer un lien, il suffit de cliquer à l’aide du bouton gauche
sur le lien correspondant, et d’appuyer sur la touche « Suppr » ou en
choisissant l’option « Supprimer le lien » du menu contextuel de ce
dernier. L’élément se trouve alors effacé de l’architecture.
11/22 Pegasus – Manuel Utilisateurh) Propriétés du composant :
L’affichage des propriétés se fait par le biais du même menu
contextuel que pour l’ajout de ports. Les propriétés permettent d’indiquer
à l’utilisateur les principales informations du composant tels que le
nombre de ports ou encore le pourcentage de spécifications effectuées.
i) Les sous-architectures :
L’utilisateur peut créer une sous-architecture associée à chaque
composant dessiné. En double cliquant sur ce composant, une nouvelle
fenêtre d’édition apparaît, vierge, sur laquelle il peut effectuer les mêmes
opérations que précédemment (ajout de composants, modification du
nom,…). L’accès à l’architecture supérieure se fait par le biais du bouton
de la barre d’outils.
Remarque : Le logiciel gère un nombre conséquent d’architecture ; ainsi, si l’utilisateur
le désire, il peut ajouter des sous-architectures, situées à un niveau hiérarchique
inférieur, de plus à chaque création d’une sous architecture, un carré de couleur rouge
est affiché sur le composant contenant cette dernière.
Composant disposant d’une sous architecture
12/22 Pegasus – Manuel Utilisateur3.1.2 - Edition des contraintes formelles
Il est également possible d’éditer les contraintes formelles associées à
l’architecture en cours de création. L’édition de telles contraintes se fait
sous la forme d’édition de spécifications B, ainsi que de contraintes de
qualité.
L’utilisateur peut choisir d’éditer les spécifications B de chacun des
composants de son architecture. Pour cela, il utilise la zone de saisie
situées sur la droite, en cliquant auparavant sur l’aspect qu’il souhaite
modifier (machine, sees, sets,…). D’autre part, il peut choisir de générer
directement le code B associé à son architecture. En effet, le logiciel peut
générer de lui-même un ensemble de fichiers « .mch » contenant les
spécifications formelles de l’architecture représentée, complétée par les
propriétés saisies par l’utilisateur.
Les outils suivants sont à la disposition du développeur dans la partie
située à l’extrême droite de l’interface:
• Un ensemble de bouton permettant de naviguer facilement entre les
différentes parties des machines B.
• Une barre d’outil permettant la spécification de contraintes de
qualité. Ces contraintes définissent un paramètre supplémentaire
dans la spécification des composants : il s’agit de leurs attributs de
qualité :
( + ) sert à ajouter de telles contraintes, à définir un seuil de
qualité pour le composant.
( - ) à les supprimer, par exemple, si un composant ne doit
plus répondre à des critères de qualité précis.
• Une fenêtre de saisie, dans laquelle il pourra éditer ses propres
spécifications.
Pegasus offre également la possibilité de créer automatiquement des
machines B génériques comprenant déjà toutes les caractéristiques des
composants désirés (ports, liens, etc.…). L’utilisateur peut ensuite
compléter à sa guise ces machines pour les faire répondre à ses propres
critères. Cette fonctionnalité est destinée à simplifier la tâche de
l’utilisateur désireux de développer des architectures conformes à la
méthode B. Nous allons voir ici que le développeur peut maintenant
compléter ces machines à sa guise.
Un des points forts de Pegasus est effectivement de proposer un éventail
d’outils pour générer des machines B de manière intuitive. Pour ce faire,
sur la partie droite de l’interface, juste en dessous du nom du composant
13/22 Pegasus – Manuel Utilisateuractuellement sélectionné, vous apercevrez différents boutons dont les
intitulés correspondent aux différentes parties du corps d’une spécification
en B. L’utilisateur peut cliquer sur chacun de ces mots clef pour éditer la
partie de code concerné. Ensuite, il pourra choisir, dans le menu
« Architecture» d’exporter les machines B ainsi générées.
3.2 - Exportation
3.2.1 – Export des machines B
L’utilisateur peut choisir de sauvegarder les spécifications précédemment
écrites, parallèlement à la sauvegarde de son architecture à proprement
parler. L’interface de Pegasus offre, dans le menu « Architecture », une
option « Générer le code source ».
En choisissant cette option, un ensemble de fichiers MCH sera
automatiquement généré. Ces fichiers contiendront toutes les
spécifications précédemment définies, dans une mise en page claire, ce
fichier étant compatible avec les autres outils de création et de vérification
B existants. Ces fichiers peuvent être récupérés et éditer afin d’y effectuer
des modifications.
3.2.2 – Export de l’architecture
Pegasus offre la possibilité d’exporter une architecture ou l’ensemble des
architectures en JPG ou bien alors dans un fichier PDF offrant ainsi la
possibilité à l’utilisateur d’avoir une vue générale de toutes ses
architectures.
3.3 – Documentation de l’architecture
Une option non négligeable de Pegasus est la génération de documentions
relatives à un ensemble d’architectures offrant ainsi une vue claire et
globale du système à modéliser. Chacune des architectures y est
représentée avec la liste des composants contenus dans celle-ci. Pour
chacun des composant, il est possible d’afficher ses spécifications.
14/22 Pegasus – Manuel UtilisateurDocumentation HTML d’un système
L’utilisateur peut alors parcourir l’ensemble de son système de manière
simple et intuitive.
3.4 – Propriétés de l’architecture
Lorsque le nombre de composants et de sous architectures est
conséquent, il peut s’avérer nécessaire d’avoir accès aux propriétés de ces
derniers. Pegasus offre cette possibilité, l’utilisateur peut alors à tout
moment consulter les propriétés de l’architecture courante ou bien de
l’ensemble des architectures qu’il à crée.
Propriétés d’une architecture courante
15/22 Pegasus – Manuel UtilisateurPropriétés de l’ensemble des architectures 3.5 – Sauvegarde et restauration L’éditeur d’architectures intègre un module de sauvegarde du travail en cours. Dans Pegasus, cette opération consiste en l’exportation d’un fichier d’extension « PGS » de flux XML. De cette manière, l’utilisateur peut sauvegarder les détails de son architecture sous la forme d’un fichier XML, décrivant de manière structurée l’ensemble de son architecture, avec les mêmes champs que dans le cas de l’export B. Il s’agit ici de parcourir toute l’architecture créée pour cataloguer tous les éléments de cette dernière. Le fichier XML rendra également compte des différents champs que l’on peut spécifier avec l’éditeur B. En ce qui concerne la restauration d’une architecture, il suffit d’importer le fichier PGS désiré pour retrouver son travail en cours. 3.6 - Impression L’utilisateur peut choisir d’imprimer une architecture ou chaque niveau de l’architecture. Pour cela, il lui suffit de cliquer dans le menu « Fichier » (« Alt – f ») et de choisir l’option « Imprimer » (« Ctrl – p »). Une fenêtre s’ouvre alors, présentant les différents paramètres d’impression, tels que l’imprimante sélectionnée, le format du papier, etc.… Remarque : L’utilisateur a le choix d’imprimer uniquement l’architecture sur laquelle il est positionné, ou bien l’ensemble des architectures et sous architectures. 16/22 Pegasus – Manuel Utilisateur
Le langage B
Successeur de la notation Z, le langage B est la partie « représentation »
de la méthode B (la seconde partie étant la preuve formelle).
Il permet aussi bien de spécifier des machines abstraites à l'aide d'un
formalisme mathématique de haut niveau, que de décrire des données et
traitements basiques pouvant être traduits en un autre langage de
programmation.
Pegasus permet l’édition de telles spécifications par le biais d’un menu
simple et intuitif, sans pour autant en vérifier la syntaxe. L’utilisateur
peut, une fois les machines abstraites exportées, les valider et les vérifier
avec les outils du marché le permettant (l’Atelier B1 ou le B-ToolKit2) ou
encore les traduire en un autre langage de programmation toujours par le
biais de ces outils.
Nous décrivons ici brièvement les spécificités de chacune des clauses
d’une machine abstraite.
• Description : Description du composant
• Sees : Cette clause permet de référencer une machine abstraite
afin de consulter ses composants sans la modifier. Cette clause est
généralement utilisée pour partager la définition d'ensembles ou de
constantes entre plusieurs machines à l'intérieur d'un même projet
B.
• Includes : Il s’agit d’une clause de composition permettant de
construire de manière modulaire des machines abstraites ou des
raffinements. Lorsqu'une machine est incluse : Son contenu est
implicitement ajouté à la machine qui l'inclue (excepté ses
paramètres et ses opérations) et Les opérations de la machine
incluante peuvent utiliser (appeler) les opérations de la machine
incluse.
• Sets : Cette clause représente les ensembles introduits par la
machine. Ceux sont soit des ensembles abstraits, soit des ensemble
énumérés définis par la liste de leurs éléments.
• Constants : Clause déclarant une liste d'éléments dont la valeur ne
peut être modifié.
1
http://www.atelierb.societe.com
2
http://www.b-core.com/btoolkit.html
17/22 Pegasus – Manuel Utilisateur• Properties : Elle définit un prédicat P qui permet, d'une part, de
typer les constantes, et d'autre part de spécifier des conditions sur
les ensembles et les constantes.
• Variables : Elle introduit la liste de variables de la machine. Elles
représentent l'état de la machine. Les variables sont les seuls objets
qui peuvent être modifiés dans l'initialisation et les opérations de la
machine.
• Invariant : Clause regroupant un ensemble de prédicats. Ces
prédicats définissent les propriétés mathématiques des variables et
permettent de typer celles-ci. Ils définissent également les
contraintes (autre que le typage) que doit vérifier l'état de la
machine à tout moment.
• Initialisation : Cette clause se compose des substitutions qui
définissent les valeurs initiales de chaque variable propre à la
machine. Toute variable propre à la machine doit être initialisé.
L'initialisation doit satisfaire l'invariant de la machine.
• Operations : Clause définissant la liste d'opérations d'une machine.
Ces opérations peuvent être paramétrées en entrée et en sortie par
une liste de scalaires. Le corps d'une opération est constitué d'une
substitution généralisée définissant le comportement de l'opération.
Pour un descriptif plus détaillé du Langage B, nous invitons l’utilisateur à
consulter le manuel de référence du Langage B à cette adresse :
http://www.atelierb.societe.com/ressources/manrefb.185.fr.pdf
18/22 Pegasus – Manuel UtilisateurExemple concret d’architecture logicielle
5.1 – Le contrôle d’accès aux bâtiments (Fichier Controle_acc.pgs)
5.1.1 – Présentation du sujet
But du système
On désire construire un système chargé de contrôler l'accès de certaines
personnes aux divers bâtiments d'un "lieu de travail" : campus
universitaire, site industriel, enceinte militaire, centre commercial, etc.
Autorisation
Le contrôle s'effectue sur la base de l'autorisation que chaque personne
concernée est censée posséder. Cette autorisation doit lui permettre, sous
le contrôle du système, de pouvoir pénétrer dans certains bâtiments et
pas dans d'autres. Par exemple une certaine personne pe1 est autorisée à
pénétrer dans le bâtiment ba1 et pas dans le bâtiment ba2; par contre,
une autre personne pe2 a le droit de pénétrer dans ces deux bâtiments.
Ces autorisations sont données de façon "permanente": autrement dit,
elles ne changent pas durant le fonctionnement normal du système.
Lorsqu'une personne se trouve à l'intérieur d'un bâtiment, sa sortie doit
également être contrôlée par le système de façon à ce qu'il soit possible
de savoir à chaque instant qui se trouve dans un bâtiment donné.
Cartes magnétiques
Chaque personne reçoit une carte magnétique qui lui est assignée en
propre au moyen d'un identificateur unique gravé sur celle-ci. Des lecteurs
de cartes sont installés à chaque entrée et à chaque sortie de bâtiment. À
proximité de chaque lecteur, on trouve deux voyants : un voyant rouge et
un voyant vert. Chacun de ces voyants peut être allumé ou éteint.
Tourniquets
Les transferts des personnes d'un bâtiment à l'autre s'effectuent grâce à
des "tourniquets" qui sont normalement bloqués : personne ne peut les
franchir sans le contrôle du système. Lorsqu'un tourniquet est débloqué
par le système (voir le paragraphe ci-dessous), le passage éventuel d'une
personne est détecté par un capteur. Chaque tourniquet n'est affecté qu'à
une seule des deux tâches, entrer ou sortir, il n'existe pas de tourniquet
"double sens".
19/22 Pegasus – Manuel UtilisateurProtocole d'accès
L'entrée dans un bâtiment ou la sortie d'un bâtiment obéit à une
procédure systématique composée d'une suite d'événements qui sont les
suivants :
Une personne souhaitant entrer ou sortir d'un bâtiment introduit sa carte
dans le lecteur du tourniquet concerné.
On se trouve alors devant l'alternative suivante :
Si la personne est autorisée à pénétrer dans le bâtiment en question (elle
est toujours autorisée à sortir), le voyant vert s'allume et le tourniquet se
débloque pour 30 secondes. On se trouve alors en présence d'une
nouvelle alternative:
Dès que quelqu'un franchit effectivement le tourniquet avant la fin du laps
de temps de 30 secondes le voyant vert s'éteint aussitôt et le tourniquet
se bloque.
Si, par contre, 30 secondes passent sans que personne ne franchisse le
tourniquet, le voyant vert s'éteint alors et le tourniquet se bloque
également.
Si la personne n'est pas autorisée à pénétrer dans le bâtiment, le voyant
rouge s'allume pour deux secondes et, bien sûr, le tourniquet reste
bloqué.
5.1.2 – Modélisation avec Pegasus
Nous allons tout d’abord procéder à la spécification initiale de notre
système en construisant un premier modèle très abstrait dans lequel la
séparation entre le logiciel et le matériel n'est pas encore d'actualité.
Ensuite nous déterminerons quels sont les acteurs de ce système, acteurs
qui seront modélisés sous forme de composants dont les caractéristiques
et les spécifications seront précisées petit à petit.
a) Propriétés (P) et Décisions (D)
Nous définissons ici les principales propriétés et décisions de notre
système.
P1 : Le modèle comprend des personnes et des bâtiments
Le système est chargé de veiller à contrôler les autorisations permanentes
de rentrée des personnes dans les bâtiments.
P2 : Chaque personne est autorisée à pénétrer dans certains bâtiments
(et pas dans d'autres). Les bâtiments non consignés dans cette
20/22 Pegasus – Manuel Utilisateurautorisation sont implicitement interdits. Il s'agit d'une affectation
permanente.
Une propriété implicite, qu'il est important de mettre en évidence dès le
début de la construction du modèle, concerne l'impossibilité pour une
même personne de se trouver simultanément dans deux bâtiments
distincts.
P3 : À un instant donné, une personne se trouve dans un bâtiment au
plus.
Une simplification (et une généralisation) du modèle consiste à identifier
"l'extérieur" à un bâtiment (dans lequel toute personne à le droit de se
trouver!). Ceci se concrétise par la décision suivante, qui donne donc une
précision supplémentaire par rapport au Cahier des Charges initial.
D1 : Le système gère le passage des personnes d'un bâtiment à
l'autre.
Il vient alors la propriété complémentaire suivante :
P4 : À un instant donné, une personne se trouve dans un bâtiment au
moins.
Nous présentons enfin la propriété principale du système, qui manifeste
que le contrôle est correctement réalisée, à savoir que toute personne est
bien, à chaque instant, autorisée à se trouver dans le bâtiment dans
lequel elle se trouve.
P5 : Toute personne se trouvant dans un bâtiment est bien autorisée à
y être.
b) Composants du système
Nous identifions alors les composants suivants :
• PORTES : Les portes des bâtiments
• CTX : Il s’agit de l’appareil permettant de contrôle de l’entrée à un
bâtiment
• LOGICIEL : L’application gérant le processus d’authentification
• MATERIEL : Ensemble du matériel du système
• RESEAU : Opération de liaison entre le logiciel et le réseau
21/22 Pegasus – Manuel Utilisateurc) Système modélisé
Une fois les spécifications informelles réalisées et les composants du
système parfaitement identifié, l’architecture résultante donne lieu à ceci :
Architecture du système
d) Spécifications formelles
Les machines B correspondant à ce système se trouvent dans votre
dossier d’installation de Pegasus. Elles sont visualisable par le biais d’un
éditeur de texte ou en consultant la documentation HTML, toujours dans
ce même dossier d’installation.
22/22 Pegasus – Manuel UtilisateurVous pouvez aussi lire
