TP Visual Basic Séance 1 – 2h00 Découverte de l ...sebastien.aranda.free.fr/cours/info/fichiers_tp/TP 2010r1.pdf · Séance 1 - TP Visual Basic : Découverte de l’environnement

ARANDA Sébastien – v10 1 / 57

TP Visual Basic

Séance 1 – 2h00

Découverte de l’environnement (série 1)



Séance 1 - TP Visual Basic : Découverte de l’environnement (série 1)

Objectif : Prise en main de l’interface VB .net. Durée : 2 x 1h Objectif : Prise en main, ajout et création de code, exécution et bases du déboguage. 1. Chargement de l’environnement VB Visual Studio .net est un environnement de développement (IDE). A ce titre, il fournit un ensemble d’outils nécessaires au développement et à la distribution d’applications écrites en VB, en C++ ou en Java. Pour commencer, il vous faut donc lancer cet environnement par le biais du menu démarrer. Sélectionnez successivement Programmes, Microsoft Visual Studio .NET puis Microsoft Visual Studio .NET. La figure suivante illustre ce que vous devriez voir apparaître plus ou moins rapidement.

Figure 1

Si Visual Studio s’est bien lancé mais que l’écran ne correspond pas à l’image de la figure 1, cliquez sur le bouton Accueil ou passez par le menu en choisissant successivement Affichage, Navigateur Web puis Accueil. La seconde étape va maintenant consister à personnaliser l’interface de développement pour la création de code VB. Pour ce faire, commencez par cliquer sur la rubrique profil du menu situé à gauche, puis une fois la page de sélection du profil chargée, sélectionnez Développeur Visual Basic dans la liste déroulante (figure 2).


Figure 2

Une fois le choix du profil effectué, votre interface devrait ressembler à l’image de la figure 3. La mise à jour de l’interface peut prendre jusqu’à une minute et il est donc normal que les changements ne soient pas instantanés.

Figure 3

L’interface VB se compose comme tout programme Windows : d’un menu, d’une barre d’outils et d’une barre d’état auxquels viennent s’ajouter des éléments spécifiques à Visual Studio. Parmi ces éléments spécifiques, on retiendra :

1. La boite à outils où sont regroupés les différents contrôles et outils que VB met à votre disposition pour la création d’applications.

2. La fenêtre principale, nommée aussi fenêtre d’édition, qui vous permettra d’afficher le code et les différentes vues de votre solution.

1

2

4

3


3. L’explorateur de solution, qui vous permettra de gérer votre solution. C’est ici que seront affichés l’ensemble des fichiers qui composeront l’application.

4. La table des propriétés, qui vous permettra de visualiser et de modifier les différentes propriétés de l’élément qui est sélectionné dans la fenêtre principale ou dans l’explorateur de solution.

2. Création d’une application Avec Visual Studio, tout commence par la création d’un nouveau projet. Pour ce faire, vous pouvez, soit cliquer sur le bouton nouveau projet , soit sélectionner successivement Fichier, Nouveau et Projet depuis le menu. Une fois ceci fait, un dialogue de création de projet similaire à celui de la figure 4 s’ouvrira. Il faut y renseigner au moins quatre champs pour spécifier les propriétés du projet, ou programme, qui va être créé.

Figure 4

Passons en revue les quatre choix à effectuer :

a. Types de projets : ce champ permet de choisir le langage de programmation qui sera associé au projet. Dans notre cas, il faut évidement sélectionner Projet Visual Basic.

b. Modèles : ce champ permet de choisir le type de projet qui sera créé. Le type d’application sélectionné par défaut est Application Windows. Ce choix ne convenant pas, vous devez donc le modifier en sélectionnant Application Console dans le bas de la liste.

c. Nom : ce champ permet de définir le nom du projet. Tapez-y PremiereApplication. J’insiste lourdement sur l’importance de prendre le temps nécessaire pour nommer vos projets car les noms ne pourront pas être modifiés par la suite.

d. Emplacement : ce champ permet de sélectionner l’emplacement de sauvegarde du projet et des différents fichiers qui le composeront. Tout comme pour le nom, ce choix est lui aussi définitif.

Une fois les quatre champs correctement remplis, la boite de dialogue doit correspondre à celle de la figure 5. Lorsque tel est le cas, vous pouvez alors valider la création du projet en cliquant sur OK.

a b

c

d


Figure 5

3. Ajout du code A titre de premier programme, vous allez vérifier l’algorithme de calcul de la somme des n premiers nombres impairs que nous avons vu en cours. Pour l’instant votre code devrait correspondre à la déclaration d’un module nommé Module1 et contenant seulement la déclaration de la procédure Main (figure 6a).

Figure 6a

Si ce code n’apparaît pas sur votre écran vous devez double cliquer sur l’élément Module1 qui est situé dans la fenêtre de l’explorateur de solution (figure 6b). Si toute fois l’explorateur de solutions, lui même, n’apparaissait pas vous pouvez l’afficher en cliquant sur le bouton associé ou en sélectionnant successivement Affichage puis Explorateur de solutions par le biais du menu.

Figure 6b

Pour le moment, cette ébauche de code ne fait rien. Afin que le programme puisse réaliser quelque chose, il faut impérativement ajouter du code à la procédure Main. Je rappelle que la procédure Main a la particularité d’être appelée à chaque lancement du programme. Comme il s’agit de votre premier programme et que vous n’êtes pas encore un pro du codage, je vous


propose de commencer tranquillement en recopiant la solution présentée à la figure 7. La mise en page étant automatique, vous n’avez donc qu’à vous soucier de la saisie du code brut.

Figure 7

Remarque très importante: Pensez régulièrement à sauver votre projet, surtout avant de l’exécuter. Faites le exclusivement à l’aide du bouton ou de la commande Sauvegarder tout, afin de ne pas perdre d’information si votre programme venait à faire planter le PC. 4. Aide à la saisie Vous avez, ou allez, certainement remarquer en tapant votre code, qu’un mécanisme d’aide à la saisie intervient régulièrement afin de vous en faciliter l’écriture. Bien utilisé, ce mécanisme peut même vous épargner de nombreuses erreurs. Je ne vais pas en détailler toutes les caractéristiques mais simplement vous présenter l’IntelliSense, car derrière ce nom se cache l’une des plus puissantes fonctions de Visual Studio. a. IntelliSense et les variables

Chaque fois qu’un type de variable doit être déclaré, Visual studio affiche automatiquement une liste déroulante qui spécifie tous les types de variables et d’objets disponibles (figure 8). Si cela est possible, il vous indique même la définition du type sélectionné. Vous restez libre de continuer à taper sans vous en préoccuper ou d’aller piocher dans cette liste. Si le type saisi ne correspond à aucun des types reconnus par VB, il sera alors souligné en bleu.

Figure 8

La meilleure façon d’exploiter cette fonction, consiste à taper les premières lettres du type choisi jusqu’à ce que ce dernier soit mis en surbrillance, puis à le valider par la touche tabulation. Cela vous permettra de gagner du temps car vous n’aurez pas à utiliser la souris et vous éviterez de nombreuses fautes de frappe.


b. IntelliSense et les fonctions

L’IntelliSense intervient aussi lors de l’appel d’une fonction. Si cette dernière est reconnue par VB ou qu’elle correspond à une fonction que vous avez vous-même déclarée, alors une bulle d’information apparaît automatiquement à l’ouverture des parenthèses pour vous en rappeler le prototype (figure9). A titre de rappel, le prototype d’une fonction correspond à la première ligne de sa déclaration. Il indique donc le nom de la fonction, les noms et types de ses arguments et le type retourné. Comme pour les variables, si le nom saisi ne correspond à aucune fonction reconnue, il est souligné en bleu. La figure suivante illustre ces propos dans le cadre d’un appel de la fonction InputBox. Vous ne manquerez peut être pas de remarquer, que contrairement à ce que nous avons vu en TD cette fonction admet cinq arguments. Comme leurs noms l’indiquent, les second et troisième arguments permettent de spécifier le titre de la fenêtre d’interrogation et la réponse qui doit être affichée par défaut. Quand aux deux derniers, ils permettent de préciser la position de la fenêtre sur l’écran. Ces quatre arguments dont je ne vous avez sciemment pas parlé sont marqués entre crochets pour indiquer qu’ils sont facultatifs. Vous pouvez donc utiliser cette fonction exactement comme nous l’avons vu au cours des TD.

Figure 9

5. Exécution et déboguage du code Une fois votre code saisi, vous pouvez enfin tenter d’exécuter votre programme. Pour ce faire, vous pouvez soit utiliser le bouton démarrer, soit passer par le menu Déboguer en choisissant la commande Démarrer. Si votre code ne contient pas d’erreur :

Il va alors s’exécuter et vous allez voir apparaître la boite de dialogue d’interrogation correspondant à la figure suivante.

Figure 10

Une fois votre réponse saisie et validée, le code continuera son exécution et vous affichera la boite de dialogue de réponse (figure 11).

Figure 11


En revanche, si votre code contient une ou plusieurs erreurs :

Vous verrez s’afficher le message représenté sur la figure suivante. Dans tous les cas, vous devez répondre non afin d’accéder au gestionnaire d’erreurs. Répondre oui ne servirait à rien car votre code ne serait pas compilé. Même si vous avez bien tapé votre code et qu’il s’est exécuté du premier coup, je vous conseille quand même de lire la fin de ce chapitre car tôt ou tard vous aurez à corriger vos propres erreurs.

Figure 12

Le gestionnaire d’erreurs se trouve généralement dans la partie inférieure de l’interface (figure 13). Normalement, il apparaît automatiquement dès lors que vous tentez d’exécuter votre code. Si ce n’est pas le cas vous pouvez l’afficher en passant par le menu. Pour ce faire, choisissez successivement Affichage, Autres fenêtres, et Liste des tâches.

Figure 13

Le gestionnaire regroupe, ligne par ligne, toutes les erreurs contenues dans le code. Il est mis à jour dynamiquement à chaque fois que celui-ci est édité ou compilé. Si vous double cliquez sur une erreur, le curseur ira alors automatiquement se positionner sur celle-ci. De plus, toutes les instructions erronées ou proches d’une incohérence sont systématiquement soulignées en bleu afin de vous aider. Prenons par exemple, le gestionnaire représenté ci-dessus et voyons comment l’utiliser efficacement pour corriger le code auquel il correspond. Il s’agit du code représenté sur la figure 14.

Figure 14

Erreur 3

Erreur 1

Erreur 2


Ce code comporte trois erreurs :

Erreur 1 : la structure For … to … est suivie d’un do qui ne devrait pas exister. En conséquence le gestionnaire indique « fin d’instruction attendue ». La correction consiste à supprimer le do.

Erreur 2 : l’appel à la procédure MsgBox n’est pas complet. Il manque une parenthèse. Dans ce cas le gestionnaire d’erreur indique clairement la correction à apporter, qui consiste à rajouter la parenthèse manquante.

Erreur 3 : la dernière erreur est moins évidente mais tellement courante que j’ai préféré vous la présenter. Elle provient du fait que le module, initialement renommé Module1, a été rebaptisé PremiereApplication. Il en résulte que le gestionnaire indique qu’il lui est impossible de trouver la procédure Main dans ce dernier. La correction consiste à indiquer au compilateur que le module où il doit rechercher la procédure Main est désormais devenu PremiereApplication. Pour ce faire, il faut double cliquer sur le message d’erreur, afin de faire apparaître le dialogue de sélection de l’objet de démarrage (figure 15), y sélectionner le module PremiereApplication et terminer en validant le choix par Ok.

Figure 15

Une fois toutes les corrections apportées, le gestionnaire d’erreur se trouve vide et l’on peut de nouveau tenter de relancer l’éxecution du programme : commande Démarrer du menu Déboguer . 6. Maîtrise de l’exécution Outre l’exécution de l’ensemble du code d’un seul bloc qui reste l’objectif principal, Visual Studio propose aussi une option d’exécution pas à pas. Il s’agit d’une fonction très intéressante car elle permet de visualiser, ligne par ligne, tout ce qu’il se passe lors de l’exécution. Tôt au tard, vous serez confrontés à un résultat inattendu et vous n’aurez d’autre solution que d’utiliser cette fonctionnalité afin d’en trouver la cause. La figure 16 résume les principales commandes qui permettent de contrôler l’exécution du code. Dans le cadre de ce TP, vous allez en découvrir et en utiliser une : le pas à pas détaillé .

Démarre ou poursuit l’exécution du code. Interrompt l’exécution. Reprend l’exécution depuis le début. Démarre ou poursuit l’exécution d’un pas en parcourant aussi les fonctions. Démarre ou poursuit l’exécution d’un pas sans parcourir les fonctions. Poursuit l’exécution d’un pas en sortant de la fonction en cours d’exécution.

Figure 16 : Liste des fonctions de contrôle de l’exécution


Commencez par lancer votre programme à l’aide de la commande Pas-à-pas détaillé et non par la commande démarrer. Elle est accessible par le biais du menu Déboguer. Une fois la compilation réalisée et l’exécution lancée vous devriez voir apparaître une flèche jaune dans la marge de la fenêtre d’édition (figure 17). Cette flèche indique la ligne qui sera exécutée au prochain pas.

Figure 17

On vérifie, comme vu en cours, que la première action effectuée par le compilateur consiste bien à appeler la procédure Main. Pour exécuter cette ligne et passer à la suivante, il faut de nouveau employer la commande Pas à pas détaillé du menu Déboguer. Cette commande est aussi accessible depuis un raccourci clavier qui est F8 ou F11 selon le PC. Utilisez ce raccourci pou exécuter le code en pas-à-pas jusqu’à atteindre la ligne indiquée à la figure 18 et arrêtez vous y afin d’observer les valeurs prises par les variables somme, nb et i à l’aide de l’ explorateur de mémoire.

Figure 18

Si l’exploreur de mémoire n’était pas visible, vous pouvez le faire apparaître à l’aide de menu en sélectionnant successivement Déboguer, Fenêtres puis Variables locales. Cet outil est extrêmement pratique lorsque l’on cherche l’origine d’une erreur dans un programme. On peut y visualiser l’ensemble des variables créées et l’évolution de leurs contenus à chaque étape de l’exécution. La figure 19 représente l’état de l’explorateur avant l’exécution de la troisième ligne. On y retrouve les trois variables créées à la seconde ligne de la procédure Main (les lignes de commentaires ne sont jamais comptées). Etant donné que ces variables sont de type numérique, elles ont toutes zéro pour valeur initiale.

Figure 19


Employez une nouvelle fois la commande Pas à pas détaillé, afin d’atteindre la quatrième ligne. On s’aperçoit alors que l’exploreur de mémoire à été mis à jour et que la variable nb a bien été affectée en fonction de la valeur entrée au clavier (figures 20 te 21). La troisième ligne s’est donc bien exécutée.

Figure 20

Figure 21

7. A vous de jouer Exercice a : Créer un nouveau projet d’application console nommé Cnp et ajouter le code nécessaire pour pouvoir afficher la factorielle de n, de p et la combinatoire Cnp.

• Combinatoire n, p :

1!00123)2()1(!

1,)!(!

!

=≥⋅⋅⋅⋅−⋅−⋅=

≥≥−

=

etnavecnnnn

ppnavecpnp

nCn

p

K

• Produit de n termes : p = 1

pour i=1 à n faire t = nième terme du produit p = p * t

fin pour Exercice b : Créer un nouveau projet d’application console nommé Classement et ajouter le code nécessaire pour pouvoir saisir, trier par ordre croissant et enfin afficher une liste de n notes.


Séance 1 - TP Visual Basic : Découverte de l’environnement (série 1)

Objectif : Prise en main de l’interface VB .net. Durée : 2 x 1h – 3 exercices obligatoires Objectif : Prise en main, ajout et création de code, exécution et bases du débogage. Consigne :

Pour chaque application, il vous est demandé de réaliser et de tester un nouveau projet d’application console répondant à la problématique proposée. Les projets devront impérativement être testés et enregistrés sur votre dossier réseau.

Application 1.1 : Résolution de l'équation 0. =+ bxa

Réaliser une application console capable de résoudre l’équation 0. =+ bxa où a et b sont les données d’entrée et x la donnée de sortie. Penser au cas où0=a .

L’exercice nécessite l’utilisation d’une structure de test If

Application 1.2 : Résolution de l’équation 0². =++ cbxxa

Réaliser une application console capable de résoudre l’équation 0². =++ cbxxa où a ,b et c sont les données d’entrée et les différentes valeurs de x sont les données de sortie. Tester l’application avec :

- 1-3,7320508,9-0,26794910,1,4,1 21 ==⇒>∆⇒=== xxcba - 1-0,1,2,1 =⇒=∆⇒=== xcba

- i--1,-10,22,1 21 =+=⇒<∆⇒=== xixcba Rappel : 3 cas sont possibles en fonction de la valeur de acb 4² −=∆

- si 0>∆ alors a

bx

21

∆+−= et a

bx

22

∆−−=

- si 0=∆ alors a

bx

2

−=

- si 0<∆ alors iaa

b

a

ibz ⋅

∆+−=

⋅∆+−=

2221 et iaa

b

a

ibz ⋅

∆−−=

⋅∆−−=

2222

Remarque :

- ne pas oublier les parenthèses car ( )abab *2/*2/ −≠− ou encore ( )21^21^ ∆≠∆

- si les solutions sont complexes, il n’est pas possible d’utiliser i car VB ne gère pas les nombres imaginaires. Il faut donc dissocier la partie réelle et imaginaire du nombre complexe 1z et les afficher séparément à l’aide de deux variables 1rz et 1iz par

exemple (idem pour la seconde solution complexe iizrzz ⋅−= 222 ).

)iz&"z de imaginaire PartieMsgBox("

)rz&"z de réelle PartieMsgBox("

2

2

11

11

1

1

111 ==

⇒∆=

−=⋅+=

aiz

abrzaveciizrzz

L’exercice nécessite l’utilisation de plusieurs structures de test If enchainées


Application 1.3 : Calcul du PGCD de deux nombres Réaliser une application console qui calcule et affiche automatiquement le Plus Grand Diviseur Commun (PGCD) de deux nombres A et B qui auront été demandés à l’utilisateur. Tester l’application avec : A=124 et B=42 dont le PGCD est égal à 2 Rappel : algorithme de recherche du PGCD de A et B

- on demande A et B à l’utilisateur. - on compare A àB :

o si BA > alors BAA −= et on recommence à comparer BAet , o si BA < alors ABB −= et on recommence à comparer BAet , o si BA = alors on s’arrête car BAou est le PGCD.

- on affiche A ou B à l’utilisateur. Exemple de mise en œuvre de l’algorithme proposé pour A=124 et B=42 Etape 1 Etape 2 Etape 3 Etape 4 Etape 5 Etape 6 Etape 7 … Etape finale A 124 82 (124-42) 40 (82-42) 40 38 (42-2) 36 (42-2) 34 (42-2) … 2

B 42 42 42 2 (42-40) 2 2 2 … 2

L’exercice nécessite l’utilisation de plusieurs structures de test If au sein d’une boucle Do / Loop ou While / End while

Application 1.4 : Interpolation linéaire (facultatif) Une interpolation linéaire consiste à définir la coordonnée cy qui est l’image de cx par une

fonction ( )xf linéaire qui passe par deux points connu A et B (voir figure suivante). On parle d’extrapolation dès lors que le point C n’appartient pas au segment AB. La fonction

permettant de calculer cy est : ( ) ( ) aabab

acbacba yyy

xx

xxyyxxxf +−⋅

−−

=,,,, .

Faire une application console permettant de calculer ( )bacbac yyxxxfy ,,,,= à l’aide d’une

interpolation linéaire. Les variables bacba yyxxx ,,,, sont les données d’entrée et la variable

cy est la donnée de sortie. Votre application devra refuser d’effectuer une extrapolation et en

avertir l’utilisateur.

Tester l’application avec : - 6,2,2,3,1 ===== bacba yyxxx qui amène à 4=cy ,

- 4,3,1 === cba xxx qui entraine une extrapolation (donc peu importe ay et by ).

A

B

C

y

xa xc xb

yb

yc

ya

f(x)

x


TP Visual Basic

Séance 2 – 2h00

Pratique de la programmation (série 1)



Séance 2 – TP Visual Basic: Pratique de la programmation (série 1)

Objectif : Prise en main de l’interface VB .net et pratique de la programmation Durée : 2h – 2 exercices obligatoires Objectif : Gestion de projet, utilisation de variables indicées, calcul de moyenne et

actions conditionnelles. Application 2.1 : Rebonds d’une balle (d’après S. Courtois) On lâche une balle d’une hauteur initiale notée ho. A chaque rebond, la balle perd de l’énergie et ne remonte qu’à 80 % de sa hauteur de chute. Ecrire une application console qui détermine le nombre de rebonds nécessaires pour que la balle n’arrive plus à remonter au dessus d’une hauteur consigne notée hc. Les paramètres d’entrée seront la hauteur de chute initiale et la hauteur consigne. Le paramètre de sortie sera le nombre rebond réalisé par la balle.

Tester l’application avec : h0 = 1000, hc = 50 qui donnent n = 14 (pour h = 43.98).

L’exercice nécessite l’utilisation d’une boucle Do / Loop ou While / End while et la mise en place d’un compteur (ex : n = n + 1) au sein de la boucle.

Application 2.2 : Contrôle qualité L’étude porte sur le suivi des approvisionnements d’un atelier de montage en bagues en bronze de diamètre 024,040± . Ces bagues sont produites dans deux usines différentes que nous nommerons usine n°1 et usine n°2. Elles arrivent par cartons de 10 à 50 pièces, contenant aléatoirement des pièces provenant d’une usine ou de l’autre.

h0

hc

h1

h2

h i+1 = 80 % de h i

Usine 1

Usine 2

2

1

Carton

Carton

CONTROLE DE RECEPTION

2

Exemple de relevé

Pièce 1 2 Alésage 40,052 … N° usine 2 …


Dans le cadre de la politique de contrôle qualité appliquée par l’entreprise, les cartons de bagues sont régulièrement contrôlés par un opérateur lors de leur réception. Ce contrôle consiste à ouvrir le carton afin de consigner pour chaque pièce, le diamètre réel de son alésage et le numéro de l’usine qui l’a produite. Le diamètre est obtenu par une mesure au micromètre d’intérieur à trois touches tandis que le numéro de l’usine est déduit du numéro de série frappé sur la collerette.

Les informations collectées par l’opérateur au cours de l’opération contrôle sont consignées dans un tableau tel que celui-ci :

Pièce 1 2 3 4 5 6 7 8 9 … Alésage N° usine

L’opération de contrôle se termine par la rédaction d’un rapport précisant :

- La valeur de l’alésage moyen, - le nombre de pièces non-conformes présentes dans le carton, - le nombre de pièces non-conformes provenant de l’usine 1, - le nombre de pièces non-conformes provenant de l’usine 2, - les taux de rebus respectifs de l’usine 1 et 2, - l’usine présentant la moins bonne rentabilité.

L’usage montre, que la détermination par l’opérateur de l’alésage moyen, des nombres de pièces non-conformes et des taux de rebus engendre une perte de temps. Pour augmenter la productivité de l’opération de contrôle, il a été décidé de munir l’opérateur d’un logiciel facilitant son travail en réalisant automatiquement tous les calculs nécessaires. Compte-tenu de vos connaissances en VB, c’est à vous qu’a été confiée la réalisation du logiciel. Le cahier des charges du logiciel stipule qu’il devra :

a. demander à l’opérateur le nombre de pièces contrôlées sachant que celui-ci peut varier entre 10 et 50 ;

b. assurer, pièce par pièce, la saisie des informations : alésage mesuré et numéro de l’usine ayant produit la bague ;

c. afficher à l’opérateur, en fin de saisie, les informations devant être portées sur le rapport (alésage moyen, nombre total de pièces non-conformes, nombre de pièces non-conformes provenant de chaque usine et taux de rebus respectifs des usines).

Tester votre application avec le lot de pièces ci-dessous :

Pièce 1 2 3 4 5 6 7 8 9 10 Alésage 40,005 40,028 40,014 40,011 39,996 40,025 40,023 40,027 40,002 40,021 N° usine 1 2 2 2 1 1 1 2 1 2

Extrait du rapport relatif à ce lot de pièces : - la valeur moyenne de l’alésage toutes usines confondues est de : 40.0152 - le nombre de pièces non-conformes présentes dans le carton est de : 3 - le nombre de pièces provenant de l’usine numéro 1 est de : 5 - le nombre de pièces provenant de l’usine numéro 2 est de : 5 - le nombre de pièces non-conformes provenant de l’usine 1 est de : 1 - le nombre de pièces non-conformes provenant de l’usine 2 est de : 2 - le taux de rebus de l’usine numéro 1 est de : 0.2 - le taux de rebus de l’usine numéro 2 est de : 0.4 - l’usine la moins rentable est l’usine numéro : 2

Remarques :

- En VB, la condition 024,40976,39 << d s’écrie 39,976 < d And d < 40,024 - Le taux de rebus est obtenu en divisant pour chaque usine le nombre de pièce

rebutées par le nombre totales de pièces produites, soit nbpiècesnbrebustr =


a. La méthode de calcul d’une moyenne est présentée dans le cours

b. Procéder par étapes si la détermination du taux de rebus vous semble difficile 1. Faire afficher un message pour chaque mauvais alésage quelque soit l’usine.

� nécessite de mettre en place une boucle For, un If et une MsgBox 2. Faire afficher un message pour chaque mauvais alésage de la seule usine 1.

� nécessite l’ajout d’un test If supplémentaire dans le code précédent 3. Remplacer les messages par des incrémentations de compteurs : p1 = p1 + 1…

L’exercice nécessite : des boucles For, des If et l’emplois de listes (Dim Alesages() as …) Application 2.3 : Intégration numérique (facultatif) L’informatique offre un moyen simple et puissant d’estimer l’intégrale d’une fonction. La technique la plus simple consiste à découper l’intégrale de la fonction f(x) en une série de n rectangles. Chaque rectangle est centré sur xi, possède une largeur h = (b - a)/n et a une hauteur f(xi). L’estimation de l’intégrale est donnée par la somme des aires des rectangles. Evidement, la qualité de cette estimation dépend fortement de la valeur de n et donc du temps de calcul. Plus le nombre d’intervalles n sera grand, plus l’erreur commise ε sera faible.

Erreur commise : ( )∑∫=

⋅−=−=n

ii

b

a

xfhdxxfEstimationrèelleIntégrale1

)(ε

Il est demandé de : 1 - Réaliser une application console qui calcule l’intégrale de xp entre a et b. Les données d’entrée sont a, b, p, n et la donnée de sortie est la valeur l’intégrale. 2 - Vérifier l’application avec les valeurs du tableau suivant.

a b p Intégrale de a à b n pour ε ≤ 10-4

0 1 1 1/2 1 2 1 3/2 0 3 2 9

3 - Utiliser votre application afin de détermine,r pour chaque ligne du tableau, à partir de quelle valeur de n l’erreur commise par l’estimation numérique est inférieure à 10-4.

L’exercice nécessite l’utilisation d’une boucle For et la mise en place d’une somme (ex : som = som + terme) au sein de celle-ci.

f(x) = x²

x

y

a xi

h

b

f(xi)

( )∑∫=

⋅=n

ii

b

a

xfhdxxf1

)(



TP Visual Basic

Séance 3 – 2h00

Pratique de la programmation (série 1)



Séance 3 – TP Visual Basic : Pratique de la programmation (série 1)

Objectif : Prise en main de l’interface VB .net et pratique de la programmation Durée : 2h – 2 exercices obligatoires Objectif : Gestion de projet, utilisation de variables indicées, calcul de moyenne,

recherche d’extremum et classement, manipulation de strings. Application 3.1 : Quelle est la liaison mécanique Réaliser une application console qui demande à l’utilisateur les degrés de liberté d’une liaison mécanique (translations X, Y, Z et rotations L, M, N) et lui affiche son nom. Aucune question supplémentaire ne devra être posée à l’utilisateur. Si la liaison saisie n’appartient pas aux dix liaisons de base définies dans le tableau ci-dessous, le programme devra le signaler. Tableau récapitulatif des mobilités associées au 10 liaisons de bases :

Mobilité X Y Z L M N Encastrement 0 - - - - - - Pivot 1 - - - 1 - - Glissière 1 1 - - - - - Pivot glissant 2 1 - - 1 - - Rotule à doigt 2 - - - 1 1 - Appui plan 3 1 1 - - - 1 Rotule 3 - - - 1 1 1 Linéaire annulaire 4 1 - - 1 1 1 Linéaire rectiligne 4 - 1 1 1 1 - Ponctuelle 5 1 1 - 1 1 1 Remarques :

- Ne pas oublier que la présence de deux mobilités, dont une en rotation et une en rotation, n’est pas suffisante pour déterminer s’il s’agit d’une liaison pivot glissant. Il faut de surcroit que la rotation et la translation soit sur le même axe.

- Les conditions d’un test doivent impérativement êtres séparées par des opérateurs logiques. Exemple : If (L=1 Or M=1 Or N=1) And (X+Y+Z=0) Then …

La structure complète d’un If s’écrie :

If condition1 Then ] Instructions réalisées si condition1 est vraie ElseIf confition2 Then ] Instructions réalisées si condition2 est vraie ElseIf confition3 Then ] Instructions réalisées si condition3 est vraie ElseIf … ] Autant de ElseIf que nécessaires Else ] Instructions réalisées si aucune condition vraie End If

a. Une solution simple pour parvenir à réaliser cette application consiste à employer une succession de tests If / Then / EndIf ou une seule et unique structure If / Then / ElseIf / EndIf telle que présentée ci-dessus.

b. Il peut s’avérer judicieux, afin de simplifier les conditions de test, de déterminer et de stoker dans des variables les nombres de mobilités en rotation, en translation ainsi que la mobilité totale de la liaison.


Application 3.2: Etalonnage d’accéléromètres pour module de commande AIRBAG L’étude porte sur un système d’étalonnage d’accéléromètres destinés à être montés dans des modules de commande d’Airbags. La procédure d’étalonnage consiste à faire subir à chaque capteur une série de 50 décélérations afin de déterminer son temps de réponse moyen et son temps de réponse à 80%. Une fois évaluées, ces données sont consignées par un opérateur sur le certificat d’étalonnage de l’accéléromètre, puis il est déclaré conforme ou non-conforme.

Le service en charge du système d’étalonnage souhaite passer de 100 à 150 étalonnages quotidiens. Or, une étude à montré que la rapidité de la procédure d’étalonnage est fortement pénalisée par la nécessité de devoir systématiquement transférer les temps de réponse mesurés par le banc de test dans le logiciel de contrôle et d’édition des certificats. Afin d’y remédier, il est envisagé de faire réaliser directement le calcul des temps de réponse moyen et à 80% par l’API (Automate Programmable Industriel) du banc et de doter celui-ci d’une imprimante de sorte que l’opérateur n’ait plus qu’à coller une étiquette sur le certificat d’étalonnage.

L’API devant être programmé en VB, il a été décidé de vous confier l’écriture d’une partie du nouveau programme de l’API. Vous devez concevoir une application console qui demande à l’utilisateur une liste de temps de réponse compris entre 10 et 250 ms et qui lui affiche en retour le temps de réponse moyen et le temps de réponse à 80%. Si votre code donne satisfaction, la partie calcul sera retravaillée et intégrée au programme de l’API. Le cahier des charges défini :

- le temps de réaction moyen comme la moyenne des différents temps de réaction, - le temps de réaction à 80 % comme la limite à partir de laquelle 80% des temps

mesurés lui sont strictement sont inférieurs ou égaux (limite de 8 premiers déciles). Tester le code à l’aide du relevé suivant :

temps de réponse mesurés (ms) temps moyen 20 24 17 27 20 26 32 19 16 22 22,3

temps de réponse mesurés et triés (ms) ≤ 80% temps à 80 %

16 17 19 20 20 22 24 26 27 32 26

Précisons sur la détermination du temps à 80 % :

- Commencer par stoker les temps de réponse dans une liste, - Trier la liste des temps par ordre croissant (voir principe de tri p.27), - Déterminer le temps tel que 80% des autres temps lui soient inférieurs ou égaux. Si

la liste contient 10 temps, il s’agira du 0,8x10 = 8ème temps, si elle contient 20, il s’agira du 0,8x20 = 16ème, si elle contient 0,8x50 = 50, il s’agira du 40ème…

La réalisation d’un tri nécessite l’utilisation d’une liste (ou d’un tableau), de deux boucles For imbriquées, d’un test If au sein des boucles For et d’une permutation de données conditionnée par le test If .

Les différentes techniques de tri sont rappelées dans la suite du poly de TP

Réponse de l’accéléromètre (V)

Décélération (m.s-2)

t

t

Temps de réponse (s)


Application 3.3 : Comparaison de dates (facultatif)

L’objectif et de réaliser une application comparant 2 dates saisies au clavier et affichant : - "Egales" si les deux dates sont identiques - "Date 1 inférieure" si la première date est inférieure à la seconde - "Date 2 inférieure" si la première date est supérieure à la seconde

Le cahier des charges de l’application stipule que chaque date sera entrée par l’utilisateur au format jour/mois/année dans une seule boite de dialogue inputbox.

Travail demandé :

1. Copier le code suivant dans la procédure Main() d’une application console et analyser son fonctionnement en surveillant l’évolution de la mémoire lors d’une exécution pas à pas.

Dim maDate, maListe() as String Dim jour, mois, annee as Byte maDate = “14.07.45” maListe = Strings .Split(maDate, “.” ) jour = maListe(0) mois = maListe(1) annee = maListe(2)

2. Personnaliser ce code afin de répondre à l’objectif en respectant le cahier des charges Fonction Split de la bibliothèque Strings :

Cette fonction sépare une chaîne de texte en plusieurs sous chaînes en la coupant à chaque fois qu’elle rencontre un caractère de séparation. Elle accepte plusieurs arguments dont un premier de type String qui définit la chaîne à découper et second aussi de type String qui représente le caractère de séparation. Elle renvoi un tableau de String contenant les sous chaînes issues du découpage.

Exemple : Contenu de la mémoire DateCoupee() Dim maDate, DateCoupee() As String 31 maDate = "31-12-99" 12 DateCoupee = Strings.Split(maDate , "-") 99

La réalisation de cette application nécessite l’utilisation de plusieurs structures de test If imbriqués, de deux listes de types String et de la fonction Strings.Split(…)

Application 3.4 : Calcul de Π par une méthode statistique (facultatif)

Par démonstration, il est possible de montrer que le rapport entre l’aire du carré et celle du quart de disque (figure ci-contre) est :

421

1 π=+ AA

A (1)

Si l’on choisit au hasard des points dans le carré et que l’on compte le nombre d’entre eux (n ) qui se situent dans le quart de disque on obtient une estimation de Pi. En effet, compte tenu de la relation (1) et en faisant l’hypothèse que les points choisis au hasard sont répartis uniformément sur le carré, on a : n4=π

Réaliser une application contenant une fonction PiVal qui retourne une valeur approchée de π obtenue en exploitant la méthode proposée ci-dessus méthode.

A1

A2

R


Remarque : génération de nombres aléatoires

Pour obtenir des nombres aléatoires il est possible d’utiliser la fonction Rdn(), qui renvoie au hasard un nombre compris entre zéro et un lorsqu’elle est initialisée par la fonction Randomize(). Attention à ne pas oublier cette initialisation car sinon la fonction Rnd() renverra systématiquement la même série de nombres !

Exemple d’utilisation : Randomize() a = Rnd()

Cette application nécessite l’utilisation d’un boucle For, d’un test If et de un ou deux compteurs (par exemple : n = n +1 et N = N + 1).

Application 3.5 : Etude d’une population : minimum, maximum et médiane (facultatif) Réaliser une application console qui permet de saisir une liste d’âges et qui en affiche l’âge médian. L’âge médian correspond à l’âge qui laisse autant d’individus au dessus qu’au dessous. Si le nombre d’individus pris en compte est impair, alors il s’agit de l’âge d’un individu. Si le nombre d’individus est pair, alors il s’agit d’une estimation qui est obtenue en calculant la moyenne des âges des deux individus les plus proches de la médiane.

Technique de recherche de la médiane d’une population :

- Commencer par saisir les âges de la population étudiée dans une liste, - Trier la liste des âges par ordre croissant ou décroissant (voir principe de tri p.27), - En déduire l’âge de l’individu qui est au milieu de la liste, si l’on est dans le cas

impair ou calculer l’âge moyen des deux individus situés en milieu de liste, si l’on est dans le cas pair.

Remarque : Déterminer si un nombre est pair ou impair

Une solution simple et efficace pour déterminer si un nombre est pair ou impair, consiste à utiliser l’opérateur modulo. D’un point vue pratique cela se traduit par :

If (x Mod 2) = 1 Then ‘Le nombre est impair (par exemple 5 Mod 2 = 1)

] Instructions réalisées si le nombre est impair Else ‘Le nombre est pair (par exemple 4 Mod 2 = 0)

] Instructions réalisées si le nombre est pair End If

Vérifier votre application à l’aide des deux populations test suivantes :

Population 1 : Ages (cas pair) Médiane 60 15 11 36 33 39 55 33 30 49 34,5

Population 2 : Ages (cas impair) Médiane

17 13 4 42 22 60 47 20 13 48 46 22

Cas où le nombre d’individus est impair : (la médiane est l’âge d’un individu)

âge Médiane m individus m individus

Cas où le nombre d’individus est pair : (la médiane est un âge estimé)

âge Médiane m individus m individus


TP Visual Basic – How to : Classement de données

1. Tri ordonné

On compare successivement le premier élément du tableau aux autres (les éléments comparés sont grisés sur l’exemple ci-dessous). Si l’élément le plus grand est en bas, alors on permute les deux éléments (voir flèches ci-dessous). A l’issue de cette étape qui est représentée par les tableaux 1 à 7 de la figure ci-dessous, le premier élément est devenu le plus grand.

Etape 1 : 1 2 3 4 5 6 7

12 12 15 15 15 18 18 8 8 8 8 8 8 8 15 15 12 12 12 12 12 7 7 7 7 7 7 7 18 18 18 18 18 15 15 11 11 11 11 11 11 11

On répète l’opération, en comparant ce coup-ci le second élément aux autres (voir tableaux 8 à 13 ci-dessous), puis on continu avec le troisième (étape 3), le quatrième (étape 4), le cinquième… jusqu’à ce que l’on atteigne le dernier élément.

Etape 2 : 8 9 10 11 12 13

18 18 18 18 18 18 déjà classé 8 12 12 12 15 15 12 8 8 8 8 8 7 7 7 7 7 7 15 15 15 15 12 12 11 11 11 11 11 11

Etape 3 : 14 15 16 17

18 18 18 18 déjà classé 15 15 15 15 déjà classé 8 8 12 12 7 7 7 7 12 12 8 8 11 11 11 11

Etape 4 : 18 19 20 21

18 18 18 18 déjà classé 15 15 15 15 déjà classé 12 12 12 12 déjà classé 7 8 8 11 8 7 7 7 11 11 11 8

….

Lorsque l’on arrive à l’étape se basant sur le dernier élément, le tableau est trié.


2. Tri bulle

On compare deux à deux les éléments du tableau (les éléments comparés sont grisés sur l’exemple ci-dessous). Si l’élément le plus grand est en bas, alors on permute les deux éléments (voir flèches) et l’on incrémente un compteur de permutation (ici k). On continu ainsi jusqu’à atteindre la fin du tableau (comme indiqué par les tableaux 1 à 7 ci-dessous).

Etape 1 : k=3 permutations 1 2 3 4 5 6 7 8

12 12 12 12 12 12 12 12 8 8 15 15 15 15 15 15 15 15 8 8 8 8 8 8 7 7 7 k=k+1 7 7 18 18 18 18 18 18 18 18 7 7 11 11 11 11 11 11 11 k=k+1 11 7

On répète l’opération détaillée ci-dessus (parcours du tableau et permutations) jusqu'à ce que plus aucune permutation ne soit nécessaire, c'est-à-dire k = 0 :

Etape 2 : k=3 permutations 9 10 11 12 13 15 16 17

12 15 15 15 15 15 15 15 15 12 12 12 12 12 12 12 8 8 k=k+1 8 8 18 18 18 18 18 18 18 18 8 8 11 11 11 11 11 11 11 k=k+1 11 8 8 7 7 7 7 7 7 7 k=k+1 7

Etape 3 : k=1 permutation 18 19 20 21 22 23

15 15 15 15 15 15 12 12 18 18 18 18 18 18 12 12 12 12 11 11 11 k=k+1 11 11 11 8 8 8 8 8 8 7 7 7 7 7 7

Etape 4 : k=1 permutation 24 25 26 27 28 29

15 18 18 18 18 18 18 15 15 15 15 15 12 12 k=k+1 12 12 12 12 11 11 11 11 11 11 8 8 8 8 8 8 7 7 7 7 7 7

Etape 5 : k=0 permutation 30 31 32 33 34

18 18 18 18 18 15 15 15 15 15 12 12 12 12 12 11 11 11 11 11 8 8 8 8 8 7 7 7 7 7

Le tableau est alors trié.

k=k+1


TP Visual Basic

Séance 4 – 2h00

Utilisation des fichiers (série 2)



Séance 4 – TP Visual Basic : Utilisation des fichiers (série 2)

Objectif : Utilisation des fichiers. Durée : 2 x 1h – 2 exercices obligatoires Objectif : Notions sur le stockage de données et utilisation de fichiers en mode in/output. 1 Introduction La gestion des documents électroniques représente une fonction importante de la plupart des logiciels. En effet, le fichier est la seule solution technique permettant de stoker de l’information lorsque le logiciel est arrêté et que la mémoire vive qui lui a été octroyée est détruite. Visual Basic .Net fournit de nombreux outils pour travailler avec les différents types de documents et manipuler l’information qu’ils contiennent. Le type de document le plus simple est le document texte. Il est non formaté et se compose d’une suite de mots séparés par des espaces, des ponctuations et de sauts de lignes. Sous Windows ce type de document peut être édité à l’aide Bloc-notes et son extension est le .txt. Vous trouverez le bloc-notes dans le sous-menu Accessoires du menu Programmes du bouton Démarrer. 2 Utilisation d’un fichier en VB L’utilisation d’un fichier texte en VB se décompose, comme dans la plupart des langages de programmation, en trois étapes :

• La première consiste à ouvrir le fichier. Il peut être ouvert en mode lecture ou en mode écriture. Selon le mode d’ouverture choisi, certaines commandes de gestion des fichiers seront autorisées et d’autres seront interdites.

• La seconde correspond aux opérations de lecture ou d’écriture. Les opérations de lecture peuvent avantageusement remplacer l’utilisation des fameuses fonctions InputBox.

• Enfin, la troisième étape consiste à fermer le fichier afin d’en libérer les ressources et de le rendre disponible à d’autres programmes.

La figure suivante illustre ces propos en précisant les principales commandes VB qui sont associées à la gestion de fichier et que nous allons détailler dans cette séance.

Ouverture

Lecture

Ecriture

Fermeture

mode lecture

mode écriture

FileOpen Input

Write WriteLine

EOF

FileClose

Commande VB associées


3 Objectif : Note d’Eléonore Durant cette séance, vous allez découvrir toutes les instructions de gestion de fichiers à travers la réalisation d’une l’application nommée Note d’Eléonore. Cette application, que nous allons créer ensemble, devra être capable d’ouvrir le fichier EssaiInfo.txt, d’en extraire la note d’Eléonore et d’afficher cette dernière à l’aide d’une instruction MsgBox. Chaque instruction sera d’abord présentée puis ensuite appliquée à la recherche de la note d’Eléonore. Vous devez donc créer une application console sur votre poste et y recopier le code proposé afin de pouvoir l’exécuter.

4 La fonction FileOpen Comme son nom l’indique, cette fonction permet d’ouvrir un fichier. Sa syntaxe abrégée est :

FileOpen (numérodefichier, chemind’accès, mode) Vous trouverez la liste complète des arguments dans l’aide en ligne de Visual Basic. Les plus importants sont les suivants :

• numérodefichier : entier compris entre 1 et 255,

• chemind’accès : chaîne de texte représentant un chemin d’accès Microsoft Windows valide,

• mode : mot clé indiquant le mode d’ouverture du fichier. Nous utiliserons exclusivement OpenMode.Input et OpenMode.Outpout qui correspondent respectivement aux modes de lecture et d’écriture.

Le numéro de fichier sera associé au fichier lorsqu’il sera ouvert. Vous utiliserez ensuite ce numéro dans votre code à chaque fois que vous devrez vous référer au fichier en question. Cette association mise à part, les numéros de fichier n’ont rien de spécial. Visual Basic, les utilise simplement pour conserver la trace des fichiers que vous avez ouverts dans votre programme. Si vous choisissez d’ouvrir un fichier en mode écriture et que celui-ci n’existe pas, il sera créé. En revanche, si vous ouvrez dans ce mode un fichier existant, alors il sera entièrement effacé.

Note d’Eléonore FileOpen(1, "C:\TP info\Notes.txt", OpenMode.Input)

5 La fonction FileClose Toute utilisation de la fonction FileOpen doit toujours être suivie de la fonction FileClose. La meilleure façon de ne pas l’oublier est donc de l’écrire juste après et avant même de songer à employer les commandes de lecture et d’écriture. La syntaxe de la fonction FileClose est :

FileClose (numérodefichier) Cette fonction n’admet qu’un seul argument :

• numérodefichier : entier compris entre 1 et 255 qui indique le numéro du fichier à fermer.

Note d’Eléonore FileOpen(1, "C:\TP info\Notes.txt", OpenMode.Input) FileClose(1)


6 La fonction Input La fonction Input sert à lire les données présentes dans un fichier. Elle ne peut être utilisée qu’à la condition que le fichier ai été ouvert en mode Input et que les différentes données qui y sont inscrites soient séparées par des virgules et/ou des sauts de lignes. L’illustration suivante, qui représente la liste de notes de TP info d’un groupe de six étudiants, est conforme à ce format.

Voici la syntaxe de la fonction Input :

Input(numérofichier, donnéeàlire) Elle nécessite la définition de deux arguments :

• numérodefichier : entier compris entre 1 et 255 et qui indique le numéro du fichier à lire.

• donnéeàlire: nom de la variable qui doit être lue. La fonction input possède plusieurs définitions et accepte ainsi quasiment n’importe quel type de variable. Les types : integer, long, single, double, string et boolean que nous avons utilisé jusqu’ici sont évidement acceptés. Cependant, il vous faudra toujours faire attention à ce que le type de donnéeàlire corresponde bien au type de la donnée inscrite dans le fichier. Si ce n’est pas le cas, vous aurez droit au joli message d’erreur : "Cast non valide".

Note d’Eléonore

Dim EtudNom as String Dim EtudNote as Double

FileOpen(1, "C:\TP info\Notes.txt", OpenMode.Input) Input(1, EtudNom) Input(1, EtudNote) If EtudNom = “Eleonore” Then Msgbox(EtudNote) End If FileClose(1)

Voyons ce que réalise le code ci-dessus :

• On commence comme toujours par dimensionner les variables dont on aura besoin dans notre code.

• Ensuite on ouvre le fichier EssaiInfo en mode lecture à l’aide de l’instruction FileOpen. Dès que le fichier est ouvert, un curseur de lecture lui est associé et il est placé sur la première donnée du fichier qui est "Laurent".

• On utilise alors l’instruction Input en faisant référence au fichier numéro 1 et en demandant de copier la valeur dans EtudNom. Visual Basic effectue le travail demandé : il lit la donnée pointée par le curseur de lecture ; puis il le déplace automatiquement sur la donnée suivante.

• On emploie la même syntaxe afin de lire la note que l’on stocke dans EtudNote.

• Puis on utilise un If pour tester s’il s’agit de "Eleonore". Si le test est concluant on affiche sa note à l’aide d’un MsgBox. Sinon, on ne fait rien.


7 La fonction EOF (End of File) Voici une fonction très utile qui permet de savoir, à tout instant, si le curseur de lecture a ou n’a pas encore atteint la fin d’un fichier. Si la fin du fichier est atteinte, EOF renvoie True. Sinon elle revoie False. Voici sa syntaxe :

EOF(numérodefichier ) Tout comme la fonction FileClose, elle n’admet qu’un seul argument :

• numérodefichier : entier compris entre 1 et 255 qui indique le numéro du fichier à tester. Cette fonction va nous permettre de terminer notre application de Note d’Eléonore en y ajoutant une boucle qui répétera les opérations de lecture et de test jusqu’à ce que le curseur de lecture atteigne la fin du fichier.

Note d’Eléonore Dim EtudNom as String Dim EtudNote as Double

FileOpen(1, "C:\TP info\Notes.txt", OpenMode.Input) While EOF(1) = False

Input(1, EtudNom) Input(1, EtudNote) If EtudNom = “Eleonore” Then

Msgbox(EtudNote) End If

End While FileClose(1)

8 La fonction Write (et WriteLine) La fonction Write n’est ni plus ni moins que le pendant de la fonction Input. Elle permet d’écrire des données dans un fichier qui a précédemment été ouvert en mode écriture. Lors de leur écriture, les données sont automatiquement séparées par des virgules afin qu’elles soient lisibles par la fonction Input. L’utilisation de cette fonction est très souple étant donné qu’elle admet un nombre variable d’arguments. Voici sa syntaxe :

Write(numérofichier, var1, var2, … , varn) Au moins deux arguments :

• numérodefichier : entier qui indique le numéro du fichier dans lequel écrire.

• var1, var2, …, varn : liste de n variables séparées par des virgules. Il est évidement possible de ne préciser qu’une seule variable. Dans le cas où plusieurs variables sont passées en arguments, elles sont écrites les une à la suite des autres sur une même ligne. Notez qu’elles peuvent être de types différents (comme illustré ci-dessous).

FileOpen(1, "C:\TP info\EssaiWrite.txt", OpenMode.Output) Write(1, "Laurent", 13) Write(1, "Benjamin", 14) Write(1, "Mathilde",11) Write(1, "Magalie", 15) Write(1, "Antoine", 9) Write(1, "Eleonore", 12) Write(1, "Maxime", 5) FileClose(1)


Cet exemple :

• ouvre le fichier "C:\TP info\EssaiWrite.txt" en mode écriture,

• y copie la liste des étudiants accompagnés de leurs notes respectives,

• et le ferme. Une fois ce programme exécuté, le fichier "C:\TP info\EssaiWrite.txt" se présentera ainsi :

Si vous souhaitez sauter la ligne entre chaque étudiant pour des raisons de présentation, il suffit de remplacer l’instruction Write par l’instruction WriteLine et le tour est joué. La seule différence entre ces deux fonctions est que la seconde ajoute un saut de ligne après avoir copié les valeurs qui lui ont été passées en arguments.

FileOpen(1, "C:\TP info\EssaiInfo.txt", OpenMode.Output) WriteLine(1, "Laurent", 13) WriteLine (1, "Benjamin", 14) WriteLine (1, "Mathilde",11) WriteLine (1, "Magalie", 15) WriteLine (1, "Antoine", 9) WriteLine (1, "Eleonore", 12) WriteLine (1, "Maxime", 5) FileClose(1)

Une fois le programme modifié et exécuté, le fichier "C:\TP info\EssaiWrite.txt" se présentera ainsi :

9 A vous de jouer Application 4.1 : Le fichier PileOuFace.txt contient le résultat de 100 tirages d’une pièce de monnaie. Réaliser une application console qui ouvre le fichier en mode input et qui :

• compte le nombre de tirages (de lignes),

• affiche la probabilité de tirer Face avec cette pièce (réponse P=0.58),

• affiche le plus grande nombre de tirages successifs de Face qui a eu lieu (réponse n=7).

Attention : ne pas oublier que la comparaison de chaines est sensible à la casse ⇒ "Pile" ≠ "pile"


Séance 4 – TP Visual Basic : Utilisation des fichiers (série 2)

Objectif : Utilisation des fichiers et pratique de la programmation Durée : 2 x 1h Objectif : Gestion de projet, calcul de moyenne, recherche d’extremum et utilisation de

fichiers en mode input et output. Application 4.2 : Le fichier "Température.txt" contient le relevé de la température de la puce (GPU) d’une carte graphique pendant l’exécution d’un Benchmark. Chaque ligne indique seconde après seconde l’instant du relevé (string), la température du CPU (integer) et la température du GPU (integer). Voici un aperçut du fichier en question :

Il vous est demandé de réaliser une application console qui :

• recherche et affiche la température minimale (réponse 46 °C),

• recherche et affiche la température maximale (réponse 79 °C),

• affiche l’élévation de température durant le test (réponse 33 °C),

• calcule et affiche la température moyenne durant le test (réponse 69.39 °C),

• calcule et affiche l’histogramme des températures relevées durant le test. Afin de simplifier le problème, les classes de l’histogramme s’étendront de 46 °C à 80 °C par palier de 2 °C (exemple 46-48 inclus, 48-50 inclus, 50-52 inclus…).

• génère un rapport avec tous les résultats calculés dans le fichier C:\INFO\rapport.txt.

0

64 3 3

03

1012

6 5 58 9 10

38

42

29

6

00

5

10

15

20

25

30

35

40

45

50

44 48 52 56 60 64 68 72 76 80

Classes

Fré

quen

ce

- +


TP Visual Basic

Séance 5 – 2h00

Interface fenêtrées (série 3)



Séance 5 – TP Visual Basic: Interface fenêtrées (série 3)

Objectif : Création de projet Windows Form Durée : 2 x 1h Objectif : Création de projets Form, gestion de l’interface utilisateur et des événements. Jusqu’à présent, nous avons fait uniquement des applications de type console. Mais ce type d’application présente, au moins, deux gros inconvénients. Le premier est lié à l’interface : une fenêtre toute noire avec du texte en blanc et des fenêtres qui n’arrêtent pas d’apparaître. Disons le franchement c’est moche ! Le second vient du manque d’interactivité. L’utilisateur est cantonné à répondre à une suite de questions dans un ordre bien déterminé et toujours identique. Heureusement VB.net permet aussi de réaliser d’autres types d’applications bien plus sympathiques. Il s’agit des applications de type Windows que nous allons étudier aujourd’hui. Mais peur être vous demandez vous ce qu’est une application Windows ? Il s’agit d’une application qui dialogue avec l’utilisateur à l’aide de fenêtres. Les fenêtres comprennent généralement du texte, des boutons, des cases à cocher, des dessins, des menus… En fait, il s’agit du type d’application que vous utilisez tous les jours sur votre PC. 1. Création d’une application Windows

Si vous ne l’avez pas déjà fait, commencez par lancer Microsoft Visual Studio .net puis ouvrez la fenêtre de création projet : - Fichier, Nouveau, Projet La fenêtre suivante s’ouvre alors. Dans le cadre de droite ne choisissez pas Application console mais Application Windows puis nommez le projet Calculatrice. Validez enfin en cliquant sur OK et patientez le temps que le nouveau projet soit créé.


2. Présentation de l’interface

Vous commencez à connaître l’interface de VB.net mais un petit rappel n’est jamais inutile. Outre les menus et les barres d’outils, l’interface se décompose en 4 parties. La première partie, située à gauche, est nommée la boite à outils. Nous l’étudierons par la suite. La seconde partie, située en haut à droite, est nommée l’explorateur de solution. Elle présente les différents fichiers et paramètres de votre projet. La troisième partie, située en bas à droite, est nommée l’explorateur de propriétés. Nous l’étudierons aussi par la suite. Enfin, la dernière partie, située au centre, est nommée la fenêtre principale. Elle permet entre autre de consulter le code de vos projets et d’afficher la fenêtre qui sera associée à votre application Windows. Cette dernière est nommée la vue.

Interface de VB.net

Lorsque la fenêtre principale affiche la vue (fenêtre associée a votre application) on parle alors de mode concepteur ou encore de mode design. En revanche, lorsque la fenêtre principale affiche le code on parle de mode éditeur ou plus simplement de mode code. La capture d’écran ci-dessus représente donc la vue de votre application et correspond au mode concepteur. Nous passerons notre temps à afficher le code, puis la vue, puis le code, puis la vue… alors inutile de vous dire qu’il vaut mieux vous assurez de bien avoir compris et retenu de quoi il s’agit avant de continuer.

Maintenant que vous connaissez le vocabulaire, voyons comment faire pour afficher successivement les modes code et concepteurs.

Pour afficher le mode code : • Sélectionnez la fenêtre de votre application dans

l’explorateur de solution. • Cliquez sur Code dans le menu Affichage.

Pour afficher le mode concepteur :

• Sélectionnez la fenêtre de votre application dans l’explorateur de solution.

• Cliquez sur Concepteur dans le menu Affichage.

1

2

3 4


3. Mise en forme de l’application : premiers pas

Notre application est un peu basique pour l’instant. On ne sait même pas qu’il s’agit d’un embryon de calculatrice. Commençons donc par modifier le nom de sa fenêtre. Pour ce faire : - Passez en mode concepteur - Sélectionnez la fenêtre en cliquant une fois sur celle-ci. - Repérez la propriété Text dans l’explorateur de

propriétés. - Sélectionnez le texte actuel, "Form1", et remplacez le

par "Calculatrice" - Valider avec la touche Entrée.

Votre projet doit maintenant ressembler à cela :

Maintenant que notre fenêtre porte un nom, nous allons lui ajouter des contrôles. Les contrôles sont des objets interactifs que l’on peut disposer dans une fenêtre tels que des boutons, des zones de texte modifiables ou non, des cases à cocher… Les différents contrôles qui vous sont proposés se trouvent tous dans la boite à outils. Si celle-ci n’est pas affichée, cliquez sur Boite à outils dans le menu Affichage pour la faire apparaître.

Commençons par ajouter un bouton. Les boutons permettent à l’utilisateur d’indiquer à l’application qu’il désire effectuer une opération. - Localiser le bouton dans la boite à outils - Double cliquez sur celui-ci

Le contrôle est maintenant ajouté à votre feuille qui devrait ressembler à cela :


Comme pour la fenêtre il est possible de modifier les propriétés du bouton que vous venez d’insérer. Et comme par hasard la propriété qui défini le texte afficher par le bouton s’appelle Text. - Passez en mode concepteur si besoin - Sélectionnez le bouton - Repérez la propriété Text - Modifiez la afin que le bouton afficher "Addition" - Valider avec la touche Entrée. Profitez-en pour modifier la propriété Name du bouton. La propriété Name indique le nom que nous souhaitons attribuer à notre objet bouton dans la suite du programme. - Repérez la propriété Name - Modifiez-la en "Bouton_Addition" - Valider avec la touche Entrée. Votre projet doit maintenant ressembler à cela :

L’étape suivante consiste à positionner le bouton en bas à gauche de la forme. Pour ce faire vous pouvez modifier la propriété location du bouton ou bien directement l’attraper et le faire glisser à sa place à l’aide de la sourie. La propriété location définie la position du coin haut gauche du bouton dans le repère de la fenêtre qui est représenté sur la figure suivante.

Pour finir nous allons agrandir un peu le bouton afin qu’il fasse moins ridicule. Pour ce faire vous pouvez modifier la propriété size du bouton ou bien directement attraper et manipuler les poignées de dimensionnement du bouton à l’aide de la sourie. Les poignées de dimensionnement correspondent aux carrés blancs situés autour du bouton. Elles n’apparaissent que si le bouton est sélectionné.

Coordonnée en y

Coordonnée en x y

x (0, 0)

(112, 224)

Poignée de dimensionnement


Votre fenêtre terminée doit avoir cette allure :

4. Mise en forme de l’application : à vous de jouer

Faites en sorte que votre fenêtre ressemble le plus possible a ceci :

Trois type de contrôles doivent être employés afin d’y parvenir. Le contrôle bouton que vous connaissez déjà et deux nouveaux : label qui représente une zone de texte non modifiable, textbox qui représente une zone de texte modifiable. Je vous laisse deviner quelle propriété définie comme par hasard le texte affiché par les zones de texte… Pensez à donner des noms intelligibles à vos contrôles (propriété Name) lorsque vous les ajoutez. Il serait d’ailleurs judicieux pour la suite de nommer vos textbox OperandeA, OperandeB et Resultat. Exécuter enfin votre application pour vérifier si tout fonctionne correctement. 5. Gérer les événements

Si vous avez été curieux, vous aurez peut être exécuté l’application et remarqué que rien ne se passe lorsque l’on clique sur le bouton addition. Flûte alors, VB.net pourrait quand même comprendre tout seul ce qui faut faire lorsque j’appuis sur le bouton addition ! Puisqu’il n’est pas doué il va encore falloir que nous nous en occupions nous même. Mais pour y parvenir, il me faut commencer par vous parler brièvement des événements.

Les événements sont des messages que les contrôles et Windows envoient à votre application. Par exemple lorsque l’utilisateur va cliquer sur bouton Addition la suite d’événements suivante est générée :

• Sourie bouge • Sourie entre Bouton _Addition • Sourie entrée Bouton _Addition • Appuis sur le bouton gauche de la sourie • Appuis sur Bouton _Addition • Relâchement du bouton gauche de la sourie • Relâchement de Bouton _Addition • Clique sur le bouton gauche de la sourie • Clique sur Bouton _Addition


Heureusement nous n’avons pas à traiter tous ces événements pour que notre application fonctionne. Si nous ne traitons pas un événement celui-ci est automatiquement renvoyé à Windows pour qu’il s’en charge. Mais nous pouvons cependant préciser que nous désirons traiter nous même un événement particulier, comme par exemple le clique sur le bouton Bouton _Addition. Pour ce faire il faut commencer par basculer en mode Code et voici à quoi votre affichage devrait ressembler, à quelques choses près :

Au miracle, il s’agit de la définition d’une classe nommée Form1. Les cours sur la Programmation Orientée Objet n’étés donc pas inutiles… L’instruction Inherits System.Windows.Forms.Form indique que la classe Form1 hérite de la définition de tous les membres de la classe Form qui modélise les objets du type fenêtre Windows. Nous ne nous attarderons pas sur cette instruction mais retenez que grâce à elle nous n’aurons pas à écrire tout le code nécessaire pour que notre fenêtre s’affiche à l’écran. Notons aussi au passage qu’exécuter le projet revient tout simplement à créer une instance de la classe Form1.

Ajout de la gestion de l’événement Clique relatif au bouton Bouton_Addition : - Sélectionnez Bouton_Addition dans la liste en haut à gauche de la fenêtre principale - Sélectionnez ensuite Click dans la liste en haut à droite de la fenêtre principale

La procédure nommée Addition_Click qui est représentée ci-dessous devrait normalement avoir été ajoutée à votre code.

Cette procédure sera appelée à chaque fois qu’un événement clique sur le bouton sera envoyé à votre application. C’est l’expression "Handles Bouton_Addition.Click ", situé juste après les parenthèses qui permet d’indique que la procédure intercepte les événements clique relatifs au bouton Bouton_Addition. Il ne nous reste donc plus qu’à la compléter afin d’indiquer ce qui doit se produire à ce moment là.

1

2

OperandeA OperandeB Resultat


Il s’agit de récupérer les valeurs situées dans les contrôles OperandeA et OperandeB, de les additionner, puis de copier le résultat dans Resultat. Les contrôles étant des objets on peut naturellement accéder à leur contenu en mettant un point à la fin de leurs noms et en précisant le nom du membre qui nous intéresse (en l’occurrence la propriété Text).

L’expression à ajouter et donc : Resultat.Text = OperandeA.Text + OperandeB.Text

Sans oublier de convertir les textes en chiffre avant de les additionner, cela devient : Resultat.Text = Val(OperandeA.Text) + Val(OperandeB .Text)

Et en pensant à reconvertir le résultat de l’addition en texte, il vient : Resultat.Text = Str(Val(OperandeA.Text) + Val(Opera ndeB.Text))

Complétez la procédure Addition_Click comme indiqué ci-dessous :

NB : Si les propriétés Name de vos TextBox ne sont pas OperandeA, OpernadeB et Resultat, modifier l’expression obtenue avec les Noms correspondants à votre cas. Faîtes de même pour gérer l’événement Clique lié au bouton "Remise à zéro" : - Sélectionnez le bouton dans la liste en haut à gauche de la fenêtre principale - Sélectionnez ensuite Click dans la liste en haut à droite de la fenêtre principale - Complétez la procédure comme indiqué ci-dessous :

Exécutez enfin votre application pour vérifier si tout fonctionne correctement.

6 Amélioration de la calculatrice

Application 5.1 :

Modifier votre calculatrice afin d’ajoutez les fonctions soustraction, multiplication et division à votre calculatrice. L’application finale doit se rapprocher le plus possible de la figure suivante et doit bien évidement effectuer toutes les opérations lorsque l’on clique sur le bouton Exécuter.


Séance 5 – TP Visual Basic: Interface fenêtrées (série 3)

Objectif : Création de projet Windows Form Durée : 2 x 1h – 2 exercices obligatoires Objectif : Création de projets Form, gestion de l’interface utilisateur et des événements.

Application 5.2 : L’objectif de ce TP est la création d’une véritable calculatrice sous VB.net :

1 – Création de l’interface 2 – Gestion des événements

Aide pour la création du code

Le fonctionnement de la calculatrice peut être décomposé en deux phases qui succèdent indéfiniment jusqu’à une phase terminale qui correspondant à l’élément Egal. Exemple de fonctionnement souhaité pour réaliser l’opération : 12 + 4 - 3 … = Phase 1 : saisie d’un nombre

La première phase consiste dans la saisie d’un nombre. L’utilisateur clique successivement sur les chiffres et/ou le point. A chaque clique le caractère correspondant est rajouté à la fin de l’affichage. Dans notre cas 1 puis 2 seront accolés pour former 12.

aff = aff & 1 aff = aff & 2

Phase 2 : saisie d’un opérateur

La seconde phase consiste dans la saisie d’un opérateur. Il est important de bien comprendre que dans ce cas il ne faut surtout pas faire l’opération mais simplement la stocker en mémoire. En effet imaginons la séquence 12+4, lorsque l’utilisateur saisi le + on ne connaît pas encore le 4. On va donc stocker en mémoire le chiffre 12 qui contenu dans l’affichage et l’opérateur +. Enfin, il faut penser à effacer l’affichage afin de permettre la saisie du chiffre suivant.

memC = aff memO = + aff=""


Nouvelle phase 1 : saisie d’un nombre

Suit une phase nouvelle phase de saisie d’un nombre. Dans notre exemple le 4 est saisie. aff = 4 Nouvelle phase 2 : saisie d’un opérateur

Suit une nouvelle phase de saisie d’un opérateur. On peut maintenant effectuer le calcul précédent : 12+4. Cela correspond à aller chercher le contenu de memC et à l’ajouter ou le soustraire ou le multiplier ou encore le diviser par aff selon la valeur stocké dans memO puis à le stocker dans memC Selon memO : memC = memC + Aff ou – ou * ou / On mémorise ensuite le nouvel opérateur et l’on vide l’affichage :

memO = + aff=""

Dans le cadre de l’exemple d’opération choisi (12 + 4 - 3 …) cela correspond à réaliser : memC = 12+4

memO= - Nouvelle phase 1 : saisie d’un nombre

Suit une nouvelle phase de saisie correspondant au chiffre 3 Succession de Phase 1 et Phase 2 … Phase Terminale : saisie de l’opérateur =

Lorsque l’on appuie sur le signe égal il suffit enfin d’effectuer les mêmes opérations que pour la saisie d’un opérateur et d’afficher le résultat à l’écran.

Selon memO : memC = memC + Aff ou – ou * ou /

Aff = MemC


TP Visual Basic

Séance 6 – 2h00

VBA et macros Excel (série 4)



Séance 6 – TP Visual Basic: VBA et Macros Excel (série 4)

Objectif : Création de macros sous Excel Durée : 2h Objectif : Programmation en VBA et création de macros Excel

Visual Basic for Applications (VBA) est une implémentation de Microsoft Visual Basic qui est intégrée dans toutes les applications de Microsoft Office et au moins partiellement dans quelques autres applications comme CATIA, SOLIDWORKS... Il peut être utilisé pour contrôler la quasi-totalité de l'Interface Homme-machine (IHM) des applications hôtes, ce qui inclut la possibilité de manipuler les fonctionnalités de l'interface utilisateur comme les menus, les barres d'outils et le fait de pouvoir personnaliser les boîtes de dialogue et les formulaires utilisateurs.

Comme son nom l'indique, VBA est très lié à Visual Basic : les syntaxes et concepts des deux langages se ressemblent. VBA est fonctionnellement riche et extrêmement flexible, mais il possède d'importantes limitations, comme son support de rappel limité des fonctions (callbacks), ainsi qu'une gestion des erreurs archaïque. Même si ces limitations rendent ce langage très peu utilisé par les développeurs informaticiens soucieux d'utiliser des outils avant tout performants, sa simplicité et sa facilité d'accès ont séduit de nombreuses professions et sa maîtrise est extrêmement appréciée par de nombreuse entreprise du génie mécanique.

1. Présentation de la séance

1.1 Objectif

Au cours de cette séance, vous allez acquérir les connaissances et les savoirs-faires de bases qui sont nécessaires à l’élaboration de programmes VBA, aussi nommés macros, au sein de l’application hôte Excel.

L’ensemble de la séance sera articulée autour de la réalisation d’une interface de génération de cartes de contrôles qui pourra par la suite être utilisée lors des TP de fabrication.

Figure 1 : exemple de carte de contrôle à la moyenne

Carte de contrôle à la Moyenne en petite série

24,77

24,87

24,97

25,07

25,17

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Echantillon

Moy

enne

en

petit

e sé

rie

LCS (Contrôler toutes les pièces)

LCI (Contrôler toutes les pièces)

Détection d’un risque de non conformité


1.2 Cartes de contrôle : Quèsaco ?

Une carte de contrôle est un outil permettant de déterminer le moment où apparaît une cause assignable entraînant une dérive du processus de fabrication. Ainsi, le processus sera arrêté au bon moment, c’est-à-dire avant qu'il ne produise des pièces non conformes (hors de l'intervalle de tolérance).

Les cartes de contrôle les plus utilisées sont les cartes par mesure de la moyenne et de l’écart-type (dispersion). Ces deux paramètres sont indépendants et complémentaires car la valeur moyenne peut varier sans que la dispersion ne varie et inversement. Les cartes de contrôle sont établies et interprétées en partant du principe que la distribution des dimensions fabriquées peut être modélisée par une loi Normale qui est caractérisée par sa moyenne et son écart type. Cet outil se présente comme un graphique (figure 1) dont les points représentent le suivi dans le temps d'une caractéristique du processus dont la valeur cible est représentée par une ligne horizontale et encadrée par la limite de contrôle inférieure (LCI ), et la limite de contrôlé supérieure (LCS).

Les valeurs LCI et LCS définissent les limites à l'intérieur desquelles le processus est sous contrôle. L’apparition de valeurs de la caractéristique contrôlée se trouvant à l’extérieur de ces limites indique que la production n’est plus sous contrôle et que les réglages machine doivent être examinées. Les valeurs des LCI et LCS sont déterminée en fonction de l’écart type et éventuellement de la valeur cible. Dans le cas d’une carte de contrôle à la moyenne :

constanttcoéfficienun:avec AAcibleLCS

AcibleLCI

machine

machine

⋅+=⋅−=σσ

Il existe différents type de cartes de contrôle en fonction du cas de figure :

− Moyenne – écart type (que nous venons de décrire), − Médiane – étendue, − Moyenne – étendue pour les petites séries.

1.3 Construction d’une carte de contrôle

La construction d’une carte de contrôle nécessite de connaître 5 paramètres :

− la valeur cible attendue (cible)

− l’écart-type du procédé de fabrication (machineσ )

− le nombre de pièces prélevées pour estimé la valeur mesurée (n ),

− la cadence de production en pièce par heure (C )

− le nombre de pièces fabriqué par série (N )

Une fois ces paramètres spécifiés par le BM, il est possible de déterminer :

− la fréquence d’échantillonnage : nNC

f ⋅⋅= 60 ou 1=f pour les petites séries,

− les valeurs des limités de contrôle LCI et LCS en fonction du type de carte :

Etendue: LCS=D4xW0

LCI=D3xW0

Médiane: LCS=Cible+Ã2xW0

(W0=d2xσ) LCI=Cible-Ã2xW0

Médiane/Etendue

Ecart type: LCS=B4xσLCI=B3xσ

Moyenne: LCS=Cible+A3xσLCI=Cible-A3xσ

Moyenne/Ecart type

Etendue: LCS=D4xW0

(W0=d2xσ) LCI=D3xW0

Moyenne: LCS=Cible+3xσ/√nLCI=Cible-3xσ/√n

Petite série (n variable)

Etendue: LCS=D4xW0

LCI=D3xW0

Médiane: LCS=Cible+Ã2xW0

(W0=d2xσ) LCI=Cible-Ã2xW0

Médiane/Etendue

Ecart type: LCS=B4xσLCI=B3xσ

Moyenne: LCS=Cible+A3xσLCI=Cible-A3xσ

Moyenne/Ecart type

Etendue: LCS=D4xW0

(W0=d2xσ) LCI=D3xW0

Moyenne: LCS=Cible+3xσ/√nLCI=Cible-3xσ/√n

Petite série (n variable)

* voir valeur des coefficients A3, B3, B4, … donnés en annexe en fin de sujet.

Vous et les cartes de contrôles étant désormais présentés, passons à la programmation.


2. Présentation de l’interface VBA

L’interface VBA ressemble pour beaucoup de point à celle de Visual Studio. Pour y avoir accès, il faut démarrer l’application Excel et aller chercher dans le menu la commande de lancement de l’éditeur.

Pour ce faire, vous allez donc :

− Récupérer sur le réseau le fichier Cartes.xls et le copier sur votre bureau ; − Ouvrir ce fichier à l’aide d’Excel ; − Cliquer dans le menu comme illustré ci-dessous (figure 2) sur Outil, puis Macro…

puis enfin Visual Basic Editor :

Figure 2 : lancement de l’éditeur VBA

Une fois l’éditeur lancé, vous devriez voir apparaître à l’écran la fenêtre représenté ci-dessous (figure 3), qui comporte 3 éléments important :

1. L’ explorateur de projet ou seront listés les modules, formulaires… 2. La zone d’édition du code (ici vide) ; 3. la barre d’outils de gestion de l’exécution du code.

Figure 3 : interface de l’éditeur VBA

Tout le travail d’édition ne sera pas réaliser sur l’éditeur, une partie de l’édition de l’interface pouvant être aussi réalisée sou Excel pour ajouter des boutons de commande par exemple.

1

2

3

ZOOM


Pour ce faire, il faut repasser sur Excel (toujours ouvert) et faire apparaître les barres d’outils associées à l’éditeur VBA (figure 4) :

1. la première s’obtient à partir du menu Affichage en sélection Barre d’outils puis Visual Basic,

2. et la seconde s’obtient en cliquant sur le bouton Outil de la barre d’outils apparue.

Figure 4 : barres d’outils associées à l’interface de l’éditeur VBA

L’affichage et le paramétrage de l’environnement de développement étant terminé, il est temps de s’intéresser à la création de votre première macro. 3. Création de macros

Pour pouvoir créer une macro qui n’est rien d’autre qu’une procédure, il faut commencer par créer, comme dans tout environnement de programmation VB, un module.

Commençons donc par créer un module :

− Afficher l’éditeur VBA, − Localiser dans l’éditeur de macros le dossier des modules, − Effectuer un clique-droit sur ce dossier et sélectionner Insertion, puis Module comme

cela est illustré ci-dessous (figure 5),

Figure 5 : création d’un nouveau module, ajout d’une macro nommé Exemple et d’une variable globale VarGlobale

ZOOM

1

2


Le module étant créé, il est maintenant possible d’y ajouter la macro en tapant code suivant :

Dim VarGlobale As Double Sub Exemple() MsgBox("Bonjour") End Sub

Une fois saisi, il ne reste plus qu’a exécuter ce code en utilisant le bouton « Exécuter Sub/UserForm » de la barre d’outils de gestion de l’exécution pour que s’affiche la désormais traditionnelle boite de dialogue :

Figure 6 : boite de dialogue affichée par l’instruction MsgBox("Bonjour")

Remarques :

− Contrairement au langage VB.net, le VBA n’indique pas clairement que l’on se trouve dans un module puisque les mots clés Module et End Module n’apparaissent pas.

− La variable VarGlobale n’est pas utilisée dans cet exemple. Elle a uniquement été ajoutée afin d’illustrer l’utilisation de variables globale au sein de VBA.

Le langage VBA ne se limite pas à l’affichage de boite de dialogue. Son principal intérêt provient de sa faculté à interagir avec l’intégralité des fonctionnalités et des informations de l’application Excel.

La procédure « ExempleManipulation » proposée ci-dessous permet d’illustrer ceci :

Sub ExempleManipulation() Dim coeff As Double coeff = Sheets("Coeffs").Cells(10, 3).Value Sheets("Feuil1").Cells(1, 1) = coeff End Sub

Pour bien en comprendre l’intérêt, il est demandé de :

− copier la procédure « ExempleManipulation » à la suite de la macro « Exemple », − d’exécuter cette procédure, − d’observer les feuilles de l’application Excel.

Si vous avez correctement copié et exécuté la procédure vous aurez remarqué la valeur située à la ligne 10 et la colonne 3 de la feuille nommé « Coeffs », soit 0,975, a été recopiée dans la cellule située à la ligne 1 et à la colonne 1 de la feuille nommée « Feuil1 ». Décryptons, ligne par ligne, les raisons de cette modification:

− la première ligne de la procédure déclare simplement un variable nommée coeff , − la seconde ligne assure la copie de la valeur 0,975 dans la variable Coeff en procédant

ainsi : Sheets("Coeffs") permet d’accéder à la feuille nommé "Coeffs" si celle-ci existe, puis .Cells(10, 3) permet d’accéder à la cellule située ligne 1 / colonne 3 de cette feuille et enfin .Value permet d’indiquer que l’on souhaite en récupérer la valeur qui sera stockée dans Coeff par le biais de l’instruction d’affectation Coeff= .


− la troisième ligne assure la recopie de la valeur 0,975 depuis la variable Coeff en procédant ainsi : Sheets("Feuil1") permet d’accéder à la feuille nommé "Feuil1"

si celle-ci existe, puis .Cells(1, 1) permet d’accéder à la cellule située ligne 1 / colonne 1 de cette feuille et enfin l’instruction d’affectation =Coeff permet de réaliser la copie depuis la valeur contenue dans Coeff.

Ceci ne représente qu’un petit exemple des innombrables possibilités d’interaction avec Excel qu’offerte le langage VBA. De nombreux ouvrages qu’il est impossible de résumer ici peuvent être consultés pour aller plus loin. 3. Création d’interfaces utilisateur

Tout comme en VB.net, il est aussi possible de créer des interfaces utilisateurs fenêtrées.

Pour ce faire, il faut :

− Afficher l’éditeur VBA, − Localiser dans l’éditeur de macros le dossier des Feuilles, − Effectuer un clique-droit sur ce dossier et sélectionner Insertion, puis UserForm

comme cela est illustré ci-dessous (figure7),

Figure 7 : création d’une interface utilisateur fenêtrée (étape 1)

Une fois l’interface utilisateurs ainsi créée, il ne reste plus qu’a la mettre en forme en utilisant les contrôles (textes, labels, boutons…) disponibles dans la boite à outils (figure 8) :

− Ajouter l’ensemble des contrôles nécessaire pour que votre formulaire soit semblable à celui présente ci-dessous,

− Modifier ensuite les textes… des éléments ajoutés en faisant un clique-droit et en choisissant propriété dans le menu contextuel qui apparait alors.

Figure 8 : création d’une interface utilisateur fenêtrée (étape 2)


4. Création de macros par l’enregistrement des actions

VOIR DEMONSTRATION PAR LE PROFESSEUR POUR CETTE PARTIE

Figure 9 : préparation de la feuille des données pour créer le graphique de la carte de contrôle

Figure 10 : résultat présentant le graphique de la carte de contrôle générée

Figure 11 : code VBA automatiquement généré lors la création du graphique de la carte de contrôle


5 A vous de jouer

Application 6.1 :

Il vous est demandé de terminer le travail commencé afin que votre fichier Excel puisse automatiquement générer une carte de contrôle répondant aux critères précisés par l’utilisateur dans le formulaire de génération. Ce dernier devra par ailleurs être automatiquement affiché lorsque l’utilisateur cliquera sur le bouton « Générer une carte » situé sue la feuille « Coeffs ».

7 ANNEXE : Valeurs des coefficients entrant dans la définition des limites LCI et LCS

1.5850.4153.7351.4900.5100.68020

1.5970.4033.6891.5030.4970.69819

1.6080.3913.6401.5180.4820.71818

1.6220.3783.5881.5340.4660.73917

1.6370.3633.5321.5520.4480.76316

1.6530.3473.4721.5720.4280.78915

1.6720.3283.4071.5940.4060.81714

1.6930.3073.3361.6180.3820.85013

1.7170.2873.2581.6460.3540.88612

1.7440.2563.1731.6790.3310.92711

1.7770.2233.0781.7160.2840.9750.36210

1.8160.1842.9701.7610.2391.0320.4129

1.8640.1362.8471.8150.1851.0990.4338

1.9240.0762.7041.8820.1181.1280.5087

2.004X2.5341.9700.0301.2870.5486

2.114X2.3262.089X1.4270.6915

2.282X2.0592.266X1.6280.7964

2.574X1.6932.568X1.9541.1873

3.267X1.1283.267X2.6591.8802

D4D3d2B4B3A3Ã2n

1.5850.4153.7351.4900.5100.68020

1.5970.4033.6891.5030.4970.69819

1.6080.3913.6401.5180.4820.71818

1.6220.3783.5881.5340.4660.73917

1.6370.3633.5321.5520.4480.76316

1.6530.3473.4721.5720.4280.78915

1.6720.3283.4071.5940.4060.81714

1.6930.3073.3361.6180.3820.85013

1.7170.2873.2581.6460.3540.88612

1.7440.2563.1731.6790.3310.92711

1.7770.2233.0781.7160.2840.9750.36210

1.8160.1842.9701.7610.2391.0320.4129

1.8640.1362.8471.8150.1851.0990.4338

1.9240.0762.7041.8820.1181.1280.5087

2.004X2.5341.9700.0301.2870.5486

2.114X2.3262.089X1.4270.6915

2.282X2.0592.266X1.6280.7964

2.574X1.6932.568X1.9541.1873

3.267X1.1283.267X2.6591.8802

D4D3d2B4B3A3Ã2n

Carte de contrôle à la Moyenne en petite série

24,77

24,87

24,97

25,07

25,17

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Echantillon

Moy

enne

en

petit

e sé

rie

LCS (Contrôler toutes les pièces)

LCI (Contrôler toutes les pièces)

Documents

TP Visual Basic Séance 1 – 2h00 Découverte de l ...sebastien.aranda.free.fr/cours/info/fichiers_tp/TP 2010r1.pdf · Séance 1 - TP Visual Basic : Découverte de l’environnement