UML

Mini Projet

Gestion d’un distributeur de carburant

Université Paul Sabatier

Année 2008-2009 Pierre-Alexandre GAUTIER

Gary LAGIN

2

Sommaire

Introduction .......................................................................................................................................3

Cahier des charges..............................................................................................................................4

Analyse...............................................................................................................................................5

1. Définition du contexte :...........................................................................................................5

2. Définition des cas d’utilisations et description des scénarios: ..................................................6

3. Description des objets : ...........................................................................................................9

4. Diagramme de séquence : .......................................................................................................9

5. Diagramme de classes ...........................................................................................................13

Conception .......................................................................................................................................14

6. Diagrammes de collaboration................................................................................................14

7. Diagramme de classe.............................................................................................................16

8. Principes de conception du programme principal ..................................................................17

Code source......................................................................................................................................18

Conclusion........................................................................................................................................38

Annexes............................................................................................................................................39

3

Introduction

UML (en anglais Unified Modeling Language, « langage de modélisation unifié ») est un langagegraphique de modélisation des données et des traitements. C'est une formalisation très aboutie etnon-propriétaire de la modélisation objet utilisée en génie logiciel.

L’objectif de ce mini projet est de concevoir à partir des méthodes UML un système informatiquerépondant à un cahier des charges précis.

Nous allons dans une première partie, analyser ce cahier des charges afin de définir le contexte duproblème posé. L’approche UML nous imposera donc de définir des cas d’utilisation (« Use Case »)qui nous permettra de décrire plusieurs scénarios possibles. Une description des objets sera donceffectué afin d’aboutir sur deux type de diagrammes : des diagrammes de séquence qui prennent encompte, pour chaque cas d’utilisation, les aspects temporels et dynamique du système, ainsi qu’uneébauche du diagramme de classes, qui ne prend en compte que les aspects dynamique du système.

Nous passerons ensuite à la phase de conception du système. Cette phase nous amènera à définir lesDiagrammes de collaboration du système ainsi que le diagramme de classes complet. Nous parleronsensuite des principes que nous avons utilisé pour la conception du programme principal.

Une troisième et dernière partie comportera le code source du programme, qui après compilationpermettra de mettre en œuvre le système informatique demandé.

4

Cahier des charges

Le système à concevoir doit gérer un distributeur automatique de carburant constitué d’un automaterelié à plusieurs pompes à essence, chacune délivrant un seul type de carburant. Ce distributeur n’estaccessible qu’à des abonnés disposant d’une carte et d’un code personnalisé.

Le pompiste à accès à l’automate à partir d’un terminal personnel qui lui permet de définir et mettreà jour la liste des abonnés. A chaque abonné est associé une fiche constitué par le nom, le numéro desa carte, son code secret et le montant des sommes dues.

Le pompiste peut accéder à l’automate pour modifier le prix des carburants. Ceci n’est possible quesi aucune livraison n’est en cours.

L’automate comprend :

- Un dispositif d’insertion de la carte abonné,- Un pupitre,- Un écran,- Un dispositif d’impression.

Chaque pompe possède :

- Un pistolet avec gâchette,- Des indicateurs numériques précisant le prix au litre et affichant en temps réel la

quantité de carburant délivrée et le montant total de la livraison.

Un client désirant se servir en carburant doit effectuer les opérations dans l’ordre suivant :

- Insérer sa carte dans le lecteur qui identifie l’abonné par le numéro de la carte,- Rentrer son code abonné à partir du clavier de l’automate qui vérifie sa validité.

Si le système l’identifie, il doit alors :

- Préciser le type de carburant souhaité,- Décrocher le pistolet de la pompe indiquée et activée par l’automate,- Se servir en appuyant sur la gâchette,- Raccrocher le pistolet lorsqu’il a terminé,- Retourner à l’automate qui lui indique le montant facturé et met à jour le montant des

sommes dues,- Récupérer sa carte

5

Analyse

Le cahier des charges défini plus haut nous amène à définir le contexte illustré ci-dessous :

1. Définition du contexte :

Diagramme de contexte

Ce diagramme met en évidence les services devant être mis en œuvre afin de répondre aux besoinsétablis par le cahier des charges.

En effet, le système autour des trois acteurs représentés (client, pompiste et pompe) doit répondreà trois cas d’utilisation bien distincts :

- Le système doit fournir le carburant au client par le biais de la pompe et d’un mécanismeinterne de gestion du client,

- Le système doit permettre au pompiste de gérer les prix des différents carburants,- Enfin, le système doit offrir la possibilité au pompiste de gérer la liste des clients.

Ceci nous amène donc à définir et décrire en détail ces trois cas d’utilisations mis en évidence ainsique le scénario décrivant les interactions acteurs/système.

Client

Pompiste

Pompe

Gérer liste

Gérer prix

Fournir carburant

6

2. Définition des cas d’utilisations et description des scénarios:

Nous détaillerons ici les différents cas d’utilisation du système :

1.1.Gérer liste- Acteur : pompiste- Type : principal- Description :

§ Le pompiste se connecte au système pour créer, supprimer ou modifier unclient.

§ Ceci n’est possible que s’il n’y a pas de livraison en cours.

Acteurs Système1/ Le pompiste accède à la console pompiste

5/ Le pompiste effectue son choix (créer,modifier ou supprimer)

7/ Le pompiste saisit les informations

10/ Le pompiste se déconnecte du système

2/ Le système vérifie si un client accède à lapompe

3/ Le système interdit l’accès client si il n’y a pasde client en cours

4/ La console donne la possibilité de créer,modifier ou supprimer un client dans la liste

6/ La console demande au pompiste lesinformations relatives au client à traiter

8/ Le système crée, modifie ou supprime leclient

9/ Le système valide l’action par le biais d’unmessage

11/ Le système rend l’accès possible aux clients.

7

Scénario alternatif :

3.1/ Un client est en cours de livraison, le pompiste ne peut donc pas accéder à la console.

1.2.Gérer prix

- Acteur : pompiste- Type : principal- Description :

§ Le pompiste se connecte sur le système pour modifier le prix affiché sur lespompes.

§ Possible que si aucune livraison n’est en cours.

Acteurs Système1/ Le pompiste accède à la console pompiste

5/ Le pompiste sélectionne le menu demodifications des prix

7/ Le pompiste saisit le prix des carburants

10/ Le pompiste se déconnecte du système

2/ Le système vérifie si un client accède à lapompe

3/ Le système interdit l’accès client si il n’y a pasde client en cours

4/ La console propose de modifier les prix descarburants

6/ La console demande au pompiste lesinformations relatives aux prix des différentscarburants

8/ Le système modifie les prix précédemmentenregistrés et met à jour l’affichage des prix surles pompes

9/ Le système valide l’action par le biais d’unmessage

11/ Le système rend l’accès possible aux clients.

8

Scénario alternatif :

3.1/ Un client est en cours de livraison, le pompiste ne peut donc pas accéder à la console.

1.3.Fournir carburant

- Acteur : Client, pompe- Type : principal- Description :

§ Le client se connecte au système, et après vérification, il est fourni encarburant.

§ Possible que si le pompiste n’est pas connecté au système (cas d’utilisation1et 2)

Acteurs Système1/ Le client insère sa carte

5/ Le client entre le code (pupitre)

8/ Le client choisit le carburant

10/ Le client décroche le pistolet choisi

11/ Le client se sert

13/ Le client raccroche le pistolet

16/ Le client récupère la carte.

2/ Le lecteur de carte lit la carte

3/ Le système vérifie l’identité de l’abonné

4/ Le système demande le code (automate)

6/ Le système vérifie le code

7/ Choix du carburant

9/ La pompe choisie est activée

12/ Le système affiche en temps réel le volume et leprix

14/ Mise à jour du montant total et du montantfacturé

15/ Impression de la facture

9

Scénario alternatif :

2.1/ Le système est utilisé par le pompiste

4.1/ Le client n’est pas reconnu

7.1/ Le code est mauvais

3. Description des objets :

Le système que nous esquissons au travers des cas d’utilisations précédemment décris s’articule telque le décris le cahier des charges autour des objets physiques suivant:

- Un lecteur de cartes,- Un pupitre (clavier + écran),- Une pompe,- Une imprimante.

La méthode de modélisation UML nous amène à associer ces objets physiques à des objets logiciels.En plus de cela nous ajoutons un objet « Service » permettant d’organiser les interactions entre lesdifférents objets. De plus nous introduisons les objets « Console Pompiste » et « Liste Clients ».Nous en arrivons donc dans un à la définition de sept objets logiciels (Classes) :

- Lecteur de cartes,- Pupitre,- Pompe,- Imprimante,- Service (système),- Console Pompiste,- Liste Clients.

4. Diagramme de séquence :

A partir des descriptions des scénarios et des objets définis précédemment nous pouvons désormaisdétailler temporellement les interactions acteurs/objets et objets/objets par des diagrammes deséquence pour chaque cas d’utilisation.

10

Diagramme de séquence de « Fournir carburant »

Imprime facture

Fin distribution

Raccroche pistolet

Gâchette i

Pompe iPistolet i

Type carburant

Décrocher pistolet i

Type carburant

Choix du carburant

Client ok

Carte

Client

PupitreLecteur

carteService

Pompe

Imprimante

Taper code

Code

Pistoletdécroché

Affichage

Retirer carte

Carte retirée

11

Diagramme de séquence de « gérer liste »

Pompiste

Se déconnecte

Service en cours

Action

Choix

Choix

Fin

Fin

Frappe

Affiche menu

Accède

ConsolePompis

Listeclients

Service

Pour chaqueélément de la

liste gérerclient (nom,prénom...)

12

Diagramme de séquence de « gérer prix »

Se déconnecte

Service en cours

Action

Choix

Choix

Fin

Fin

Frappe

Affiche menu

Accède

ConsolePompis

Pompe Service

Pour chaquetype de

carburant

13

5. Diagramme de classes

A partir des diagrammes de séquence nous pouvons remarquer l’interaction entre les différentesclasses dans le temps. Nous pouvons à partir de ces diagrammes créer un nouveau diagramme qui netient compte que des interactions entre classes, mais cette fois ci en regroupant toutes les classes.Ceci nous permet d’avoir une vision globale du système et de bien repérer les liens entre les classes.Dans une première étape nous ne ferons qu’une ébauche de ce diagramme.

Ebauche du diagramme de classes

Authentifie

Informe fin

Commande les

Fourni infoEnvoie des messages à

Gère accès

Gère

Fixe les prix

Fourni num. Carte au 1

1

1…3

1…31

11

1

1

1

1

1

1

1

1

1

Service

Pupitre/Ecran

Liste ClientsConsole Pompiste

Lecteur Carte Pompes

Imprimante

14

Conception

Dans cette partie du rapport de conception, nous préciserons dans un premier temps les diagrammesde collaboration des trois cas d’utilisations. Puis, dans un deuxième temps nous complèterons lediagramme de classe établi dans la phase d’analyse.

6. Diagrammes de collaboration

Le diagramme de collaboration est une représentation des collaborations à partir d’un diagrammed’objet. Ce diagramme nous montre les interactions entre les différentes classes du système définis.

1.1 Fournir carburant

11 :=ObtenirInfosClient(NumCarte, InfosFacturation)

2 .1 : OK=pompiste_en_cours()

4.2 : acces_service(vrai)

3 : OK=Authentifier(NumCarte, Code)

2.2 : Code :=Saisir()

4.1 : Activer(NumCarte)

5 : Choix :=Saisir(TypeCarbu)

6 : Afficher(Décrocheri)

7a : Pompei :=Allouer(choix)

8 : Reinitialiser(Pompei)

9 : Conso :=Servir(Pompei)

10 :=Facturer(NumCarte, Conso)

12 : Imprimer(InfosFacturation)

1 : LireCarte()LecteurCarte

Imprimante

Pompes

Pupitre

Service

ConsolePompiste

ListeClient

13 : acces_service(faux)

13 : Afficher(‘Au Revoir’)

15

1.2.Gérer liste

Diagramme de collaboration de « Gérer liste »

1.3.Gérer prix

Diagramme de collaboration de « Gérer prix »

5.1 : ModifierClient(InfosClient)5.2 : AjouterClient(InfosClient)5.3 : SupprimerClient(NumCarte)

4 : NumCarte :=LireNumCarte()

1 : acceder()

2.a : SelectionnerDemande()

ConsolePompiste

LecteurCarte

ListeClient

3.1 : ModifierClient()3.2 : AjouterClient()3.3 : SupprimerClient()6 : Afficher(‘Action effectuée’)

3 : GererPrix()5 : Afficher(‘Action effectuée’)

4 : FixerPrix(Prix)1 : acceder() Pompe

2.a : SelectionnerDemande()

ConsolePompiste

16

7. Diagramme de classe

Diagramme de Classes complet

CodeNumCarte

OK :=authentifier(NumCarte, Code)Client :=rechercher_client(NumCarte)OK :=facturer(NumCarte, Conso)charger_liste_client()enregistrer_liste_client()ajouter_client(InfoClient)supprimer_client(NumCarte)InfoClient :=obtenir_info_client (NumCarte)

AuthentifieInforme fin

Commande les

Fourni infoEnvoie des messages à

Gère accès

Gère

Fixe les prix

1

1

1…3

1…31

11

1

1

1

1

1

1

1

1

Imprimante

Console Pompiste

AccesPompisteEtatService

OK :=Pompiste_en_cours()selectionner_demande()acceder()modifier_client();ajout_client();supprimer_client()gerer_prix();

Liste Clients

Service

NumCarteCode

initialiser()lire_carte()carte_inseree()attente_retrait_carte()NumCarte :=lecture_numero_carte()

Lecteur Carte

Fourni num. Carte au

1 EtatService

activer(NumCarte)set_acces_service(bool)read_acces_service()

Pupitre/Ecran

CodeTypeCarbu

Code :=saisir ()initialiser();afficher(texte)

Pompes

ChoixCarburant

initialiser()allouer(Pompei)Prix :=servir(Pompei)reinitialiser(Pompei)fixerprix(Pompei, Prix)

Imprimer(infoFacture)

17

8. Principes de conception du programme principal

La modélisation UML élaborée est mise en œuvre sur un système mono-processeur où une seuletâche au sens logiciel est disponible. De plus le logiciel est codé en langage C. Dans ce contexte ci, lesclasses sont implémentées par deux types de fichiers :

- un fichier déclaratif de type .h (interface),

- une fichier .c de codage de tous les corps de fonctions.

En définitive, avec le langage C il ne s’agit pas de classe, mais plutôt des instances de classes définiesdans la phase de conception de ce rapport.

Nous avons ainsi dans un premier temps crée tous les fichiers nécessaires à l’instanciation des classesà partir du diagramme de classes complet. Puis, toujours à partir de ce même diagramme, nousavons définis les méthodes dans les fichiers .h respectifs aux classes et codé les corps de fonctionsdans les fichiers .c. Enfin, nous avons utilisé les diagrammes de collaborations des trois casd’utilisations pour coder les fonctions nécessaires au fonctionnement des classes entre elles.

Nous avons ensuite crée un fichier Distributeur.c contenant le programme principal du logiciel(main). Ce « main » est chargé d’effectuer les initialisations de classes nécessaires au bonfonctionnement de celles-ci. Une fois l’initialisation effectuée, il donne la main au lecteur de carte quise charge lui-même de donner suite aux événement externes (insertion de carte, donner le contrôleà la console pompiste etc..)

Pour finir, la validation du logiciel développé à été faite avec l’aide du diagramme de séquence afinde s’assurer que l’ordre des actions a bien été respecté.

18

Code source

Vous trouverez en annexes tous les fichiers .h et .c faisant partie du code source.

Distributeur.c :

#include "lecteur_carte.h"#include "pupitre.h"#include "lcarte.h"#include "pompe.h"#include "ListeClient.h"

//######################################################################int main(void){

//initialisationspupitre_initialiser();

lecteur_carte_initialiser();

pompe_initialiser();

liste_client_charger_liste_client();

// Boucle principalewhile(1){

lecteur_carte_lire_carte();}

liberation_ports();return 0;

}

19

Lecteur_carte.c :

#include "GlobalDef.h"#include "lcarte.h"#include "pupitre.h"#include "lecteur_carte.h"#include "ListeClient.h"#include "service.h"#include "ConsolePompiste.h"#include <unistd.h>#include <string.h>

//######################################################################void lecteur_carte_initialiser(){

initialisations_ports();}

//######################################################################void lecteur_carte_lire_carte(){unsigned int CodeCarte;unsigned int NumCarte;unsigned int IsCodeOK;int NombreEssai;

// Verifie que la console pompiste n'est pas en cours defonctionnement

if(console_pompiste_pompiste_en_cours()==FALSE){

// Si la carte est inseree dans le lecteurif(lecteur_carte_carte_inseree()){

// Lis le numero client inscrit dans la carteNumCarte = lecteur_carte_lecture_numero_carte();// S'il existe un client associé au numéro de carte luif(liste_client_rechercher_client(NumCarte)){

// Le client a le droit a 3 essai de saisie de codemaximum

for(NombreEssai=0; NombreEssai<3; NombreEssai++){

pupitre_afficher("Saisir code");// Lis le code de la carte saisi au pupitreCodeCarte = pupitre_saisir();// Verifie que le code entré correspond bien

au numéro de carteIsCodeOK = liste_client_authentifier(NumCarte,

CodeCarte);if(IsCodeOK==TRUE){

pupitre_afficher("Code bon");// Passe la main à la classe Serviceservice_activer(NumCarte);break;

}else{

20

pupitre_afficher("Code errone");}

}pupitre_afficher("Sortir carte");lecteur_carte_attente_retrait_carte();

}else

pupitre_afficher("Carte invalide");}else

pupitre_afficher("Inserer carte"); }else{

// Si le pompiste à selectionné la console pompiste alorsafficher le menu console

pupitre_afficher("Service momentanement indisponible");console_pompiste_selectionner_demande();

}}

//######################################################################unsigned int lecteur_carte_lecture_numero_carte(){

return lecture_numero_carte();}

//######################################################################int lecteur_carte_carte_inseree(){

return carte_inseree();}

//######################################################################void lecteur_carte_attente_retrait_carte(){

attente_retrait_carte();}

21

Lecteur_carte.h :

#if !defined(lecteur_carte_h_)#define lecteur_carte_h_

void lecteur_carte_initialiser();void lecteur_carte_lire_carte();int lecteur_carte_carte_inseree();void lecteur_carte_attente_retrait_carte();unsigned int lecteur_carte_lecture_numero_carte();#endif

22

Pupitre.c :

#include "pupitre.h"#include "donnees.h"#include "mem_sh.h"#include <unistd.h>#include <string.h>

entrees *Valeurs;

//######################################################################void pupitre_initialiser(){int shmid;

Valeurs = acces_memoire(&shmid);}

//######################################################################void pupitre_afficher(char *Message){

// Copie le message à afficher dans le buffer adéquatstrcpy(Valeurs->message, Message);// Demande à l'interface son affichageValeurs->ecrire_message = 1;sleep(1);

}

//######################################################################int pupitre_saisir(){int Code;

// Tant que le client n'a pas appuyé sur Valider, on attendwhile (Valeurs->validation == 0)

usleep(100);

Valeurs->validation = 0;// Retourne la valeur saisie au pupitreCode = Valeurs->code;return (Code);

}

23

Pupitre.h :

int pupitre_saisir ();void pupitre_initialiser();void pupitre_afficher(char *);

24

Service.c :

#include "service.h"#include "GlobalDef.h"#include "pupitre.h"#include "pompe.h"#include "ListeClient.h"#include "imprimante.h"#include <stdio.h>#include <unistd.h>

unsigned int EtatService = FALSE;

//######################################################################void service_activer(unsigned int NumCarte){int Choix_Pompe, Pompei;char Texte[50];float PrixTotal;

service_set_acces_service(TRUE);

// Selection du carburant par le client sur le pupitre

pupitre_afficher("0-SP95 1-gasoil 2-Super");Choix_Pompe = pupitre_saisir();

// Valide visuellement que le client peut se servirsprintf(Texte, "Decrochez pompe %d", Choix_Pompe);pupitre_afficher(Texte);

// Reserve l'utilisation de la pompePompei = pompe_allouer(Choix_Pompe);

// Remet les compteur à zéropompe_reinitialiser(Pompei);

// Autorise le client à se servirPrixTotal = pompe_servir(Pompei);

// dès qu'il a fini (pistolet raccroché), la facturation estappliquée au client

liste_client_facturer(NumCarte, PrixTotal);

// Imprime la facture clientimprimante_imprimer_facture(NumCarte, PrixTotal);

service_set_acces_service(FALSE);

}

//######################################################################void service_set_acces_service(unsigned int Etat){

25

EtatService = Etat;}

//######################################################################int service_read_acces_service(void){

return EtatService;}

Service.h :

void service_activer(unsigned int);void service_set_acces_service(unsigned int);int service_read_acces_service(void);

26

ConsolePompiste.c :

#include "ConsolePompiste.h"#include "ListeClient.h"#include "lecteur_carte.h"#include "pompe.h"#include "service.h"#include "GlobalDef.h"#include "donnees.h"#include "mem_sh.h"#include <stdio.h>

entrees *Valeurs;

//######################################################################int console_pompiste_pompiste_en_cours(void){int shmid;

Valeurs = acces_memoire(&shmid);return (Valeurs->acces_pompiste);

}

//######################################################################void console_pompiste_selectionner_demande(void){int Choix;

// Interface homme machine permettant l'acces aux differentesfonctions mises au point

printf("Choix :\n1: Lister clients\n2: Ajout client\n3: Supprimerclient\n4: Gerer prix\n5: Fermer console\nChoix: ");

scanf("%d", &Choix);switch(Choix){case 1:

console_pompiste_modifier_client();break;

case 2:console_pompiste_ajout_client();break;

case 3:console_pompiste_supprimer_client();break;

case 4:console_pompiste_gerer_prix();break;

case 5:if(console_pompiste_pompiste_en_cours())

printf("Decochez l'acces pompiste avant de sortir!\n");break;

}}

//######################################################################void console_pompiste_modifier_client(){

}

27

//######################################################################void console_pompiste_ajout_client(void){char Nom[30], Prenom[30];unsigned int NumCarte, Code;

// Demande la saisi des infos clientprintf("Informations client:\n");printf("Nom: ");scanf("%s", Nom);

printf("Prenom: ");scanf("%s", Prenom);

printf("Inserer la carte du nouveau client\n");

// Lis le numéro de carte alloué au clientwhile(!lecteur_carte_carte_inseree());printf("Lecture de la carte..\n");NumCarte = lecteur_carte_lecture_numero_carte();printf("Numero de carte: %d\nRetirer la carte...\n", NumCarte);while(lecteur_carte_carte_inseree());

printf("Saisir le code client: ");scanf("%d", &Code);

// Ajoute le client à la liste de client déjà existanteliste_client_ajouter_client(Nom, Prenom, NumCarte, Code, 0);

// Enregistre la nouvelle liste de client dans la base de donneesliste_client_enregistrer_liste_client();

printf("Client ajoute\n");

}

//######################################################################void console_pompiste_supprimer_client(void){unsigned int NumCarte;

printf("Inserer la carte du client a supprimer\n");

// Lis le numéro de carte associé au clientwhile(!lecteur_carte_carte_inseree());printf("Lecture de la carte..\n");NumCarte = lecteur_carte_lecture_numero_carte();printf("Numero de carte: %d\nRetirer la carte...\n", NumCarte);while(lecteur_carte_carte_inseree());

// Demande la suppressionliste_client_supprimer_client(NumCarte);

// Sauvegarde le resultat dans la base de donneesliste_client_enregistrer_liste_client();

printf("Client supprime\n");}

28

//######################################################################void console_pompiste_gerer_prix(void){FILE *pFile;float Prix[3];int i;

// Crée le fichier contenant les prix des carburantspFile = fopen("prix.txt","w");if(pFile){

// Enregistre les prix saisis dans le fichier prix.txtprintf("Prix du SP95 :");scanf("%f", &Prix[0]);fprintf(pFile, "Prix SP95 = %f\n", Prix[0]);

printf("Prix du Super :");scanf("%f", &Prix[1]);fprintf(pFile, "Prix gasoil = %f\n", Prix[1]);

printf("Prix du gasoil :");scanf("%f", &Prix[2]);fprintf(pFile, "Prix super = %f\n", Prix[2]);

// Affiche les prix au niveau des pompesfor(i=0; i<3; i++)

pompe_fixerprix(i, Prix[i]);

printf("Prix carburants modifies");// Libère le fichier créefclose(pFile);

}else

printf("Impossible de créer le fichier Prix.txt\n");}

//######################################################################void console_pompiste_acceder(void){

// Si le pompiste a coché l'accès pompiste, affiche le menu consoleif(service_read_acces_service()==FALSE)

console_pompiste_selectionner_demande();else

printf("Service en cours\n");}

ConsolePompiste.h :

int console_pompiste_pompiste_en_cours(void);void console_pompiste_selectionner_demande(void);void console_pompiste_modifier_client();void console_pompiste_ajout_client(void);void console_pompiste_gerer_prix(void);void console_pompiste_acceder(void);void console_pompiste_supprimer_client(void);

29

Imprimante.c :

#include "ListeClient.h"#include "pupitre.h"#include "imprimante.h"#include <stdio.h>

char Texte[] = "Client: %s %s\nNuméro de carte: %d\nPrix TTC:%.2lf\nConsommation: %.2lf\n\nMerci de votre visite\n";

int FonctionImprimer(){

return 0;}//######################################################################void imprimante_imprimer_facture(unsigned int NumCarte, floatPrixTransaction){FILE *pFile;FILE *pPrinter;char Nom[30], Prenom[30];unsigned int Code;float Conso;

// Obtient les infos relatives au client via son numéro de carteif(liste_client_obtenir_info_client_par_numero_carte(NumCarte, Nom,

Prenom, &Code, &Conso)){

// Creation d'un fichier texte représentant la facture Ãimprimer

pFile = fopen("facture.txt", "w");fprintf(pFile, Texte, Nom, Prenom, NumCarte, PrixTransaction,

Conso);fclose(pFile);

// Demande l'impression du fichierpPrinter = popen("lpr -P imp3 facture.txt", "w");pclose(pPrinter);

}else

pupitre_afficher("Impossible d'imprimer la facture..\n");}

30

ListeClient.c :

#include "ListeClient.h"#include "GlobalDef.h"#include <stdio.h>

#include <stdlib.h>#include <string.h>

CLIENT *RootClient=0;

//######################################################################void liste_client_charger_liste_client(void){FILE *pFile;CLIENT *CurClient;

// Ouvre la base de donnée client en lecturepFile = fopen("ListeClient.dat", "r");if(pFile){

// Alloue l'espace mémoire necessaire au stockage des donnéesclient

CurClient = malloc(sizeof(CLIENT));if(CurClient){

while(!feof(pFile)){

// Lis les données client dans la base de donnéesfscanf(pFile, "%s %s %d %d %f\n", CurClient->Nom,

CurClient->Prenom, \&CurClient->NumCarte, &CurClient->Code,

&CurClient->Conso);

// Ajoute le client à la liste chainée enmémoire

liste_client_ajouter_client(CurClient->Nom,CurClient->Prenom, \

CurClient->NumCarte, CurClient->Code,CurClient->Conso);

}free(CurClient);

}// Libère la base de donnéesfclose(pFile);

}else

printf("ListClient.dat n'existe pas...\n");}

//######################################################################void liste_client_enregistrer_liste_client(){FILE *pFile;CLIENT *CurClient;

// Crée la base de donnéespFile = fopen("ListClient.dat", "w");

31

if(pFile){

// Scanne les differents maillons de la chainesCurClient = RootClient;while(CurClient){

// Ecris sur le disque les infos relatives au clientfprintf(pFile, "%s %s %d %d %f\n", CurClient->Nom,

CurClient->Prenom, \&CurClient->NumCarte, &CurClient->Code,

&CurClient->Conso);// Passe au prochain clientCurClient = CurClient->Flink;

}

fclose(pFile);}else

printf("Impossible de créer le fichier ListeClient.dat\n");}

//######################################################################void liste_client_ajouter_client(char *Nom, char *Prenom, unsigned intNumCarte, unsigned int Code, float Conso){CLIENT *NewClient;FILE *pFile;

// Alloue l'espace mémoire necessaire à l'introduction d'un clientdans la liste chainée de client

NewClient = malloc(sizeof(CLIENT));

// Initialisation des liens avec les autre maillonsNewClient->Flink = 0;NewClient->Blink = 0;

// Si le RootClient n'est pas defini, on defini le nouveau clientcomme RootClient

if(!RootClient){

RootClient = NewClient;}// Ajoute le maillon NewClient dans la liste chainée des clientsif(RootClient->Blink){

NewClient->Blink = (RootClient->Blink);((CLIENT *)(NewClient->Blink))->Flink = NewClient;

}// Lie le nouveau client au client racineRootClient->Blink = NewClient;

// Remplissage de la structure CLIENT nouvellement ajoutée à laliste chainée

strcpy(NewClient->Nom, Nom);strcpy(NewClient->Prenom, Prenom);NewClient->NumCarte = NumCarte;NewClient->Code = Code;NewClient->Conso = Conso;

32

/*if ((NewClient=fopen("ListeClient.txt","a"))==NULL) //ouverture dufichier en mode ajout.

{printf("erruer d'ouverture du fichier \n");exit(1);

}

else

{ fprintf(NewClient->NumCarte, NewClient->Prenom,NewClient->NumCarte, NewClient->code, NewClient->Conso);

fprintf(NewClient,"\n");fclose(NewClient);

}*/

char Texte[] = "Client: %s %s\nNuméro de carte: %d\n Codesecret: %ld\n";

pFile = fopen("ListeClient.txt", "w");fprintf(pFile, Texte, Nom, Prenom, NumCarte, Code);fclose(pFile);

}

//######################################################################void liste_client_supprimer_client(unsigned int NumCarte){CLIENT *CurClient;

// Cherche la structure client associée au numéro de carte donnéen paramètre

CurClient = liste_client_rechercher_client(NumCarte);// Si le client existeif(CurClient){

// Supprime le maillon relatif au client de la chaine de clientif(CurClient->Flink){

// Blink du maillon n+1 pointe vers n-1((CLIENT *)(CurClient->Flink))->Blink = (CurClient-

>Blink);// Flink du maillon n-1 pointe vers n+1((CLIENT *)(CurClient->Blink))->Flink = (CurClient-

>Flink);}else{

RootClient->Blink = CurClient->Blink;((CLIENT *)(CurClient->Blink))->Flink = 0;

}// Libère l'espace mémoire allouée pour cette structure

CLIENTfree(CurClient);printf("Client supprimé\n");

}else

printf("Le numéro de client n'existe pas dans la liste\n");}

//######################################################################

33

int liste_client_authentifier(int NumCarte, int CodeCarte){CLIENT *CurClient;int Result=FALSE;

// Recherche la structure CLIENT dans la liste en fonction du numérode carte

CurClient = liste_client_rechercher_client(NumCarte);

// Si le client existe alors et que le code correspond, alors onvalide l'authentification

if(CurClient && CurClient->Code==CodeCarte)Result = TRUE;

return Result;}

//######################################################################void liste_client_facturer(unsigned int NumCarte, float PrixConso){CLIENT *CurClient;

// Recherche la structure CLIENT dans la liste en fonction du numérode carte

CurClient = liste_client_rechercher_client(NumCarte);// Si le client existe alors on ajoute le prix de la consommation Ã

la factureif(CurClient)

CurClient->Conso += PrixConso;else

printf("Client non existant dans la liste");}

//######################################################################CLIENT * liste_client_rechercher_client(unsigned int NumCarte){CLIENT *CurClient;

CurClient = RootClient;// Tant qu'il y a un client..while(CurClient){

// Si le numéro de carte correspond au maillon exploré alorson sort de la boucle

if(CurClient->NumCarte==NumCarte)break;

// Sinon on continue le scan de la listeCurClient = CurClient->Flink;

}// CurClient = 0 si le client n'est pas trouvé dans la liste, sinon

CurClient pointe vers la structure du clientreturn CurClient;

}

//######################################################################int liste_client_obtenir_info_client_par_numero_carte(unsigned intNumCarte, char *Nom, char *Prenom, unsigned int *Code, float *Conso){int Result = FALSE;CLIENT *CurClient;

34

// Recherche la structure CLIENT dans la liste en fonction du numérode carte

CurClient = liste_client_rechercher_client(NumCarte);if(CurClient){

// Si le client existe alors on retourne les données clientstrcpy(Nom, CurClient->Nom);strcpy(Prenom, CurClient->Prenom);*Code = CurClient->Code;*Conso = CurClient->Conso;// Notifie que le client existeResult = TRUE;

}

return Result;}

//####################################################################

ListeClient.h :

#if !defined(ListeClient_h_)#define ListeClient_h_

typedef struct CLIENT_{void *Blink;void *Flink;char Nom[30];char Prenom[30];unsigned int NumCarte;unsigned int Code;float Conso;

}CLIENT;

int liste_client_authentifier(int, int);CLIENT * liste_client_rechercher_client(unsigned int);void liste_client_facturer(unsigned int, float);void liste_client_charger_liste_client(void);void liste_client_enregistrer_liste_client();void liste_client_ajouter_client(char *, char *, unsigned int, unsignedint, float);void liste_client_supprimer_client(unsigned int);int liste_client_obtenir_info_client_par_numero_carte(unsigned int, char *,char *, unsigned int *, float *);

#endif

35

Pompe.c :

#include "pompe.h"#include "donnees.h"#include "mem_sh.h"#include "GlobalDef.h"#include "pupitre.h"#include <stdio.h>#include <unistd.h>

entrees *Valeurs;

//######################################################################void pompe_initialiser(){int shmid;int i;float ListePrix[3];FILE *pFile;

Valeurs = acces_memoire(&shmid);

// Lecture des prix carburants enregistréspFile = fopen("prix.txt","r");if(pFile){

fscanf(pFile, "Prix SP95 = %f\n", &ListePrix[0]);fscanf(pFile, "Prix gasoil = %f\n", &ListePrix[1]);fscanf(pFile, "Prix super = %f\n", &ListePrix[2]);fclose(pFile);

}else

ListePrix[0] = ListePrix[1] = ListePrix[2] = 0;

for(i=0; i<3; i++){

// Initialise toutes les pompesValeurs->pistolet_decroche[i] = FALSE;Valeurs->pompe_validee[i] = FALSE;Valeurs->gachette[i] = FALSE;pompe_reinitialiser(i);

// Affiche le prix des différents carburantpompe_fixerprix(i, ListePrix[i]);

}}

//######################################################################int pompe_allouer(int Choix){

Valeurs->pompe_validee[Choix] = TRUE;return (Choix);

}

//######################################################################int pompe_servir(int Pompei){

// Attend que le client décroche le pistoletwhile((Valeurs->pistolet_decroche[Pompei])==FALSE)

36

usleep(100);

pupitre_afficher("Veuillez vous servir");

// Service effectué tant que le pistolet est decrochédo{

// Si la gachette est appuyéeif(Valeurs->gachette[Pompei]==TRUE){

Valeurs->gachette[Pompei] = FALSE;// Incrémente le volume à chaque appui de gachetteValeurs->volume[Pompei] += 0.1;// Demande au pupitre d'afficher cet incrémentValeurs->affiche_volume[Pompei] = 1;

}}while((Valeurs->pistolet_decroche[Pompei])==TRUE);

// Retourne le prix du carburant prélevéreturn (Valeurs->prix[Pompei]*Valeurs->volume[Pompei]);

}

//######################################################################void pompe_reinitialiser(int Pompei){

// Remise à zéro du volume de carburant pompéValeurs->volume[Pompei] = 0;Valeurs->affiche_volume[Pompei] = TRUE;

}

//######################################################################void pompe_fixerprix(int Pompei, float Prix){

// Fixe le prix du carburant de la pompe iValeurs->prix[Pompei] = Prix;// Et demande son affichage à l'interfaceValeurs->affiche_prix[Pompei] = TRUE;

}

37

Pompe.h :

void pompe_initialiser(void);int pompe_allouer(int);int pompe_servir(int);void pompe_reinitialiser(int);void pompe_fixerprix(int, float);

38

Conclusion

L’approche UML nous a donc permis de concevoir un système informatique qui répondait bien aucahier de charge.

De plus la structuration du code source à partir des diagrammes UML nous permet de repérerrapidement les diverses classes et interactions entre ces classes. Pour un système logiciel qui évoluedans le temps ceci est très important car l’approche de conception (qui est très visuelle) ainsi quecelle de conception et codage du logiciel sont très cohérentes.

Si au cours du temps le logiciel doit évoluer, il sera facile, à l’aide des diagrammes déjà existant ainsique du code déjà réalisé, d’effectuer les modifications prévues.

39

Annexes