Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI

Initiation à LabVIEW 2010 – 2011

Exercices d'initiation à LabVIEW

Initiation .................................................................................................................................... 3
1. Utiliser un VI existant : .................................................................................................. 3
2. Faire une opération simple sur un nombre entré par l'utilisateur ; faire de ce
programme un VI ; l'utiliser depuis un autre programme : .................................................... 3
Mise au point d'un programme, utilisation de l'aide ............................................................ 4
3. Corriger une erreur : ....................................................................................................... 4
4. Suivre pas à pas une exécution :..................................................................................... 4
5. Utiliser l'aide : ................................................................................................................ 4
Les graphes ............................................................................................................................... 5
6. Tracer une courbe au cours du temps (Waveform Chart) : ............................................ 5
Les chaînes de caractères ......................................................................................................... 6
7. Manipuler des chaînes de caractères : ............................................................................ 6
8. Concaténer des chaînes de caractères : .......................................................................... 6
9. Transformer un entier en hexadécimal : ......................................................................... 6
Les booléens .............................................................................................................................. 6
10. Utiliser des indicateurs et contrôleurs booléens : ....................................................... 6
11. Les "Mechanical Actions" associés aux boutons booléens : ...................................... 6
La structure de choix Case, les menus .................................................................................... 7
12. Utiliser la structure case pour une question/réponse : ................................................ 7
13. Utiliser la structure case pour un choix dans un menu :............................................. 7
Les tableaux à une dimension ................................................................................................. 8
14. Faire un tableau de réels et le tracer : ......................................................................... 8
15. Faire un tableau de LEDS (booléens) représentant un entier en binaire : .................. 8
La structure For ....................................................................................................................... 8
16. Utilisation d'une boucle For : ..................................................................................... 8
17. Utilisation d'une boucle For pour un calcul incrémenté :........................................... 9
18. Générer un tableau de mesures et calculer la moyenne et l'écart type : .................... 9
La structure While .................................................................................................................... 9
19. Utilisation d'une boucle de type While : .................................................................... 9
La structure Sequence .............................................................................................................. 9
20. Utilisation d'une séquence : ........................................................................................ 9
Les agrégats (Clusters) ........................................................................................................... 10
21. Utilisation des agrégats (Clusters) : ......................................................................... 10
Les graphes XY....................................................................................................................... 10
22. Tracé de Y fonction de X : graphes XY : ................................................................. 10
23. Tracé de deux courbes (X, Y) : ................................................................................ 11
24. Tracé d'une courbe avec barre d'erreur : X, Y ± ∆Y : .............................................. 11
25. Graphes XY au cours du temps et pas à la fin de la boucle : ................................... 11
Les « Formula Node »............................................................................................................. 12
26. Utilisation du Formula Node pour écrire des formules mathématiques : ................ 12
Les variables locales et globales ............................................................................................ 12

1/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

27. Utilisation des variables locales dans un programme : ............................................ 12

28. Utilisation des variables globales ............................................................................. 12
Les fichiers .............................................................................................................................. 13
29. Les fichiers « texte » : .............................................................................................. 13
Simulation d’une mesure bruitée et filtrage ........................................................................ 14
30. Génération d’une mesure bruitée : ........................................................................... 14
31. Utilisation d’un filtre : ............................................................................................. 14
32. Traitement de données avec Kaléidagraphe ............................................................. 14
Mesure à intervalles fixes ou contrôlés par l’utilisateur..................................................... 14
33. Simulation d’une mesure :........................................................................................ 14
34. Prise d’une mesure à intervalles réguliers : .............................................................. 15
35. Prise d’une mesure à la demande : ........................................................................... 15
Flux et Nœuds ......................................................................................................................... 15
36. Gestion du flux d’informations : .............................................................................. 15

2/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Initiation
REMARQUE IMPORTANTE : Lors du déroulement des prochaines séances d’exercices,
vous trouverez une série de fichiers en partage sur le serveur. Afin de ne pas saturer ce
serveur, il est important de télécharger les fichiers sur vos ordinateurs respectifs avant de
commencer à travailler avec.

1. Utiliser un VI existant :

a) Sur le serveur Samba vous trouverez une bibliothèque d’exemples fournie

(DEMO.LLB).Ouvrez le programme VI_Simple.vi et essayez les divers boutons de
commande
b) Ouvrez le diagramme de ce VI (« Show Block Diagram » ou ctrl E) et comprenez ses
divers éléments.

2. Faire une opération simple sur un nombre entré par l'utilisateur ; faire de ce
programme un VI ; l'utiliser depuis un autre programme :

a) Ouvrir un nouveau VI

b) Afficher un contrôleur numérique Knob et un indicateur numérique Meter en

« panneau avant » (menu Numeric de la palette Controls)

c) Dans le diagramme, écrire un programme tel que Meter affiche 2X+3 où X est la
valeur donnée de Knob (menu Numeric de Functions et des fils)

d) Sauver le programme (Save ou Save as) sous le nom Operation simple.vi

e) Tester le fonctionnement en mode Run puis Run Continuously

f) Modifier l’échelle de l’indicateur jusqu’à 35

g) Changer le bouton Knob par un bouton Slide : vérifier l'effet. Modifier les noms de
Knob et de Meter(par exemple : Entrée/Sortie)

h) Dans le panneau avant, cliquer, avec le bouton droit de la souris, sur le petit schéma
situé dans le coin du panneau avant, en haut à droite. Choisir Edit Icon, puis dessiner
un rectangle blanc et écrire Mult à l’intérieur puis presser OK. Choisir ensuite Show
Connector dans le menu apparaissant au même endroit que précédemment en
cliquant sur le bouton de droite de la souris, puis Pattern. Choisir la proposition
offrant deux rectangles verticaux correspondant à une entrée et une sortie. Cliquer
avec l'outil fil dans le rectangle de gauche, puis sur le contrôleur apparaissant dans le

3/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

diagramme, puis finalement cliquer n’ importe où pour confirmer l’affectation du

rectangle de gauche au contrôleur. La couleur du rectangle de gauche change alors.
Faites de même avec le rectangle de droite et l'indicateur : vous venez de définir les
entrées et sorties de l'icône qui représentera le programme Mult dans un autre
programme. Aller dans File/VI Properties/Documentation et entrer un texte clair qui
explique ce que fait ce VI. Sauver, et fermer.

i) Ouvrir un nouveau programme, introduire un contrôleur "X" et un indicateur

"RESULTAT", et mettre dans "RESULTAT" : 2X+3 en utilisant l'icône Mult
correspondant au VI Operation simple.vi Pour cela, dans le diagramme, faire appel
au VI Operation simple.vi via Functions et Select a VI.Remarquer qu’en approchant
la bobine de l’icône, on voit apparaître les noms des entrées/sorties de ce VI. Vérifier
que cela marche. Sauver sous le nom : Utiliser une icone.vi.

Mise au point d'un programme, utilisation de l'aide

3. Corriger une erreur :
Lorsqu'il y a une erreur (bug) dans un programme, LabVIEW offre différents outils
permettant d’en trouver l'origine. Ouvrir à nouveau le VI Operation simple.vi. Créez une
erreur volontaire en coupant un fil par exemple. Le symbole flèche du mode run change et
devient une flèche brisée. Voici les étapes possibles pour corriger ce programme :
Cliquer sur la flèche brisée : la liste des erreurs apparaît. Double-cliquez sur l'une d'elles,
LabVIEW vous renvoie vers le lieu de l'erreur (ici le fil cassé). Réparez.

4. Suivre pas à pas une exécution :

Parfois, votre programme vous renvoie un résultat inattendu, mais ne signale pas d'erreur.
Pour trouver d'où vient le problème, il faut suivre son exécution pas à pas et vérifier la
valeur des différentes variables au fur et à mesure de l'exécution. Ouvrir à nouveau
Operation simple.vi.
Pour mettre un point d'arrêt : utiliser l'outil en forme de rond rouge Set/Clear Breakpoint
accessible dans la palette d’outils. Placer un point d'arrêt dans le programme en cliquant ce
rond rouge sur un objet du programme qui s’entoure alors de rouge. Vérifier l'effet à
l'exécution du programme.
Utiliser également l'outil Probe Data (rond jaune avec un P dedans sur la palette d’outils) en
le plaçant sur des fils. Vérifier son effet à l'exécution.

5. Utiliser l'aide :
Lorsqu'on hésite sur l'utilisation d'un VI proposé par LabVIEW, enclencher l'aide
automatique que l’on obtient via les menus Help/Show Context Help ou par le raccourci
clavier CTRL-H. Vérifier par exemple son effet quand vous vous placez le curseur sur les
différents éléments d’un diagramme ou sur l’icône d’un VI. On observe ainsi tout l'intérêt,
dès qu'on écrit un VI, de bien décrire de façon claire le rôle de ce VI via les menus File/VI
Properties/Documentation.

4/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Parfois, on souhaite une aide plus complète, pour voir en détail le fonctionnement, les
options et des exemples associés à une fonctionnalité. Dans ce cas, aller dans les menus
Search the LabVIEW Help. A titre d’exemple, chercher l'aide sur les Waveform Charts.

Les graphes
6. Tracer une courbe au cours du temps (Waveform Chart) :

a) Placer dans le diagramme d’un nouveau VI un générateur de nombres aléatoires

(Functions, Numeric, Random Number) qui va simuler une mesure physique. Lui
appliquer à nouveau l'opération 2X+3 et envoyer le résultat dans un indicateur.
Sauver sous Simulation manip.vi. Editer l’icône de ce VI et écrire ‘Simul Manip’,
puis choisir un seul rectangle dans pattern et la connecter à le sortie correspondant au
une nombre aléatoire 2X+3. Sauvegarder.

b) Afficher sur le panneau avant d’un nouveau VI, un Waveform chart(obtenu depuis le
panneau avant, via Control, Graph, et WaveformChar,) et le relier en parallèle à un
autre indicateur. Mettre Simulation Manip.vi en entrée de ces 2 indicateurs. Exécuter
en mode Run continuously et observer le résultat.Sauver ce VI sous le nom Exemple
waveform.vi.

c) Tester les options du Chart :

a. Cliquer sur le bouton droit de la souris sur le Chart, choisir Visible Items,
essayer les différentes options et visualiser les changements.

b. Changer l'échelle du chart en ordonnée en remplaçant un nombre par un

autre, via l'outil Texte et en cliquant sur le nombre.

c. Essayer l'option Autoscale X et Y.

5/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Les chaînes de caractères

7. Manipuler des chaînes de caractères :

Afficher sur un indicateur chaîne de caractères (Controls, String & Path), une chaîne de
caractères fournie par un Contrôleur chaîne de caractères, et donner sa longueur
correspondant au nombre de caractères qu’elle contient, sur un indicateur numérique.
Utiliser pour cela l’opérateur String Length obtenu via les menus Functions,String. Sauver
ce VI sous le nom Chaines de caractères.vi

8. Concaténer des chaînes de caractères :

Afficher une unique chaîne de caractères résultant de la concaténation (réunion au sens des
chaînes de caractères) de 3 chaînes de caractères entrées au clavier sur le Panneau Avant
dans 3 contrôleurs chaîne de caractères différents. Utiliser pour cela l’opérateur Concatenate
Strings obtenu via les menus Functions, String. Sauver ce VI sous le nom Concatenation de
Chaines.vi.

9. Transformer un entier en hexadécimal :

Sur le panneau avant d’un nouveau VI, installer un contrôleur numérique correspondant à un
entier positif inférieur à 256. Afficher ce nombre en représentation hexadécimale, octale et
binaire dans 3 indicateurs numériques différents et dans un indicateur chaîne de caractères.
Utiliser pour cela l’opérateur Number To Hexadecimal String obtenu via les menus Functions,
Programming, String, String/Number Conversion. Sauver ce VI sous le nom Entier a Chaine
hexadecimale.vi.

Les booléens
10. Utiliser des indicateurs et contrôleurs booléens :

Afficher un contrôleur (Slide Switch) et un indicateur (Round LED) booléens. Changer leurs
labels (en général, par défaut, ON/OFF) de telle sorte que le contrôleur donne le choix
STOP/MARCHE et l'indicateur ROUGE/VERT. Les relier correctement afin que lorsqu'on
clique sur STOP, l'indicateur affiche ROUGE sur fond rouge et que lorsque l’on clique sur
MARCHE, l'indicateur affiche VERT sur fond vert). Utiliser pour cela les menus Controls,
Boolean etcliquer sur les booleens avec l'outil en forme de main pour chnager l’état des
boutons. Sauver ce VI sous le nom Booleens.vi

11. Les "Mechanical Actions" associés aux boutons booléens :

On associe à tout bouton booléen une mechanical action qui est accessible en cliquant sur le
booléen dans le panneau avant avec le bouton droit de la souris. Cet actionmécanique définit
le type d'interrupteur qu'on utilise. Par exemple, certains interrupteurs reviennent à leur

6/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

position initiale quand on les a pressés, d'autres restent dans la position dans laquelle on les a
placés. Reprendre le VI précédent et tester les différents mechanical action possibles en
observant attentivement en mode run continuously ce qui se passe pendant que vous
appuyez sur le bouton, puis quand vous relâchez la pression.

La structure de choix Case, les menus

Attention, pour la suite, ne surtout pas utiliser l'option run continuously

12. Utiliser la structure case pour une question/réponse :

Réaliser un programme qui pose à l’utilisateur une question et lui demande de répondre par
OUI ou NON, puis qui affiche un commentaire correspondant. Utiliser un contrôleur
booléen pour que l'utilisateur donne sa réponse, dont vous changerez le texte ON/OFF. Le
relier à la structure Case, accessible depuis Functions, Structure. Utiliser dans les deux
fenêtres de case (false/true) un "One Button Dialog" dont vous choisirez le message
correspondant (dans Functions/Dialog & User Interface). Sauver sous le nom Question
Reponse.vi.

13. Utiliser la structure case pour un choix dans un menu :

On veut réaliser un programme qui propose plusieurs choix à l’utilisateur, et qui fasse une
action précise suivant le choix qui a été fait.

a) Sur le panneau avant d’un nouveau diagramme, créer un menu déroulant qui propose
plusieurs choix (questions, compositeurs, hommes célèbres, etc…) grâce au
contrôleur numérique Ring & Enum/Menu Ring. Entrer les différents choix de ce
menu (au minimum trois) dans ce contrôleur. Pour cela, avec l'outil texte, entrer dans
le Menu Ring un premier choix. Attention à ne pas faire un retour chariot après avoir
écrit le texte du premier choix, cela correspondrait au premier choix avec un intitulé
de plusieurs lignes. Après écriture du texte d’un choix, il faut ressortir du menu, puis
cliquer sur le bouton droit de la souris et choisir dans le menu Properties/Edit
Item/Insert, et recommencer. LabVIEW considère le menu comme un nombre entier
qui vaut 0 si c'est le premier choix, 1 si c'est le deuxième, etc.

b) Relier dans le diagramme ce contrôleur de type menu déroulant à une structure Case.

c) Pour chaque choix, faire apparaître dans uneboîte de dialogue, la réponse à la

question, un titre correspondant à un compositeur, etc. Sauver ce VI sous le nom
Choix menu.vi.

7/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Les tableaux à une dimension

14. Faire un tableau de réels et le tracer :

a) Afficher un tableau sur le panneau avant d’un nouveau VI via Array, Matrix &
Cluster/Array et y placer à l’intérieur un contrôleur numérique : cela permet de définir
le type d’éléments constituant ce tableau, ici le tableau est constitués de réels.
b) Entrer 4 valeurs dans le tableau. On peut décaler la visualtion d’un élement du tableau
en agissant sur le curseur visible sur la gauche du tableau. On peut aussi visualisé
plusieurs élément du tableau en agrandissant celui-ci avec la souris.
c) Multiplier ces 4 éléments par 2. On remarquera que l’on peut faire une opération
arithmétique sur l'ensemble du tableau, d'un seul coup. Les fils sont alors plus épais,
indiquant que l’on travaille avec un tableau.
d) Tracer le tableau dans un Waveform Chart et sauver ce VI sous le nom Tableau de
réels.vi.

15. Faire un tableau de LEDS (booléens) représentant un entier en binaire :

Afficher, à l’aide d’un tableau d’indicateurs « LED », l’état des bits (bit à 0 ⇔ diode éteinte ;
bit à 1 ⇔ diode allumée) de l’octet représentant un nombre entier positif inférieur à 256.
Présenter les bits de poids faibles à droite (comme en écriture binaire). On utilisera pour cela
l’opérateur Array,Reverse 1D Array.Functions,que l’on trouvera via les menus Numeric,
Conversion, Number To Boolean Array et Functions. Sauver ce VI sous le nomTableau de
booléens.vi.

La structure For
16. Utilisation d'une boucle For :
a) Réaliser un programme qui affiche sur deux indicateurs différents dans le panneau
avant d’un nouveau VI, l’indice d’une boucle For. Sur le diagramme, l’un de ces 2
indicateurs sera placé, à l’intérieur de la boucle For, l’autre à l’extérieur de cette
même boucle. Pour pouvoir connecter l’indice de la boucle à l’indicateur situé à
l’extérieur de la boucle, il faudra utiliser l’option Enable/Disable indexing du fil en
cliquant sur le bouton droit de la souris sur le petit carré apparaissant au passage du
fil au travers de la boucle.Cette option permet soit de faire sortir de la boucle un
tableau (fil épais) de tous les indices ayant circulé sur le fil, soit de faire sortir de la
boucle la dernière valeur (fil fin). Ajouter une fonction Wait que l’on trouve via les
menus Functions, Timing, dans la boucle, pour ralentir le processus en indiquant sur
un contrôleur numérique relié à la fonction Wait, le nombre de millisecondes
souhaitées entre chaque tour de boucle. Sauver ce VI sous le nom Boucle For
simple.vi.
b) Changer ensuite l'option Enable/Disable indexing et relier l’indice de la boucle à un
tableau d’entier situé à l’extérieur à la boucle For. Observer le changement de
l’épaisseur du fil de sortie : un tableau (fil épais) sort cette fois-ci de la boucle.
Sauver ce VI sous le nom Boucle For et tableau.vi.

8/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

17. Utilisation d'une boucle For pour un calcul incrémenté :

Réaliser un programme utilisant une boucle for pour calculer la somme des N premiers
nombres entiers, l'utilisateur choisissant la valeur de N dans un contrôleur numérique situé
en panneau avant. Pour cela, on doit utiliser ce que l’on appelle un Shift Register qui permet
de faire des calculs incrémentés. Ce Shift Register utilise, dans une case située sur le flan
gauche de la boucle et pour le tour de boucle i+1, la valeur d’un calcul obtenue au tour de
boucle précédent i et placée dans la case située sur le flanc droit de la boucle. Pour faire
apparaître un Shift Register, on se place sur un flan vertical de la boucle, on clique sur le
bouton droit de la souris et on sélectionne add Shift Register. Sauver ce VI sous le nom
Boucle For et Shift Register.vi. Exécuter ce VI et vérifier que la somme des n premiers
entiers est correcte.

18. Générer un tableau de mesures et calculer la moyenne et l'écart type :

Dans une boucle For, générer N mesures aléatoires via l'icône du VI Simulation manip.vi
que vous insérez dans le diagramme d’un nouveau VI. Placer un contrôleur numérique sur le
panneau avant permettant à l'utilisateur de choisir le nombre N de mesures à effectuer. Ce
programme revient à simuler un échantillonnage de N mesures. Tracer le tableau de ces N
mesures ainsi générées dans un Waveform Chart. Calculer et afficher la moyenne et l'écart
type de ce tableau de mesures en utilisant l’opérateur Standard Deviation que vous trouverez
via les menus Functions, Mathematics, Probability & Statistic. Sauver ce VI sous le nom
Simulation echantillonnage.vi. Que se passe-t-il si N = 0 ?

La structure While
19. Utilisation d'une boucle de type While :

a) Réaliser un programme qui affiche dans deux indicateurs différents situés sur le
panneau avant d’un nouveau VI, l’indice d’une boucle While. Dans le diagramme,
l’un de ces 2 indicateurs sera placé, à l’intérieur de la boucle While, l’autre à
l’extérieur de cette même boucle. Insérer une boucle While dans le diagramme de ce
VI, dont l'arrêt est commandé par un bouton booléen mis en panneau avant.Ajouter
une fonction Wait que l’on trouve via les menus Functions, Timing, dans la boucle,
pour ralentir le processus en indiquant sur un contrôleur numérique relié à la fonction
Wait, le nombre de millisecondes souhaitées entre chaque tour de boucle. Sauver ce
VI sous le nom Boucle While simple.vi.
b) Tester l’effet de différents choix de Mechanical Actions sur le bouton booléen
commandant l’arrêt de la boucle (voir l’exercice 8).

La structure Sequence
20. Utilisation d'une séquence :
Créer un programme qui multiplie dans un premier temps par 2, la valeur d’un nombre entré
sur le panneau avant dans un contrôleur numérique, puis qui attend dans un deuxième temps
2 secondes et finalement qui affiche dans un troisième temps la valeur du résultat obtenu
dans un indicateur numérique mis sur le panneau avant. Ce programme se fait en utilisant la

9/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

structure séquence que l’on trouve via les menus Functions, Structure, Stacked Sequence.
Comme au cinéma, une séquence permet de faire une succession d'actions dans un ordre
bien défini. Pour ajouter la deuxième et troisième étape à la première, cliquer sur le bouton
droit de la souris lorsque le curseur de la souris est placé sur le cadre de la Sequence, choisir
dans le menu proposé Add frame after (frame en anglais signifie « cadre »). Pour faire passer
le nombre généré par la première étape à la troisième étape, cliquer sur le bouton droit de la
souris lorsque que le curseur de la souris est placé sur le cadre de la séquence et choisissez
dans le menu proposé "Add sequence local" : cela crée une petite boîte dans laquelle on peut
stocker une valeur via un fil. Cette valeur peut être récupérée ensuite lors des étapes
suivantes de la séquence via la boîte. Sauver ce VI sous le nom Utilisation Sequence.vi.

Les agrégats (Clusters)

21. Utilisation des agrégats (Clusters) :

Un agrégat est un type de variable particulier, qui consiste en l'agrégation de plusieurs
variables, pas nécessairement du même type (donc ce n'est pas un tableau). Par exemple, une
mesure physique peut fournir une tension, une température, et un code d'erreur (ON si pas de
problème, OFF si la mesure est mauvaise). On peut avoir avantage à agréger ces trois
variables (2 réels et un booléen) en une seule pour simplifier la manipulation des données.
a) Construire un agrégat des trois variables susnommées (2 numériques et une
booléenne) en utilisant l’opérateur Bundle que l’on trouve via les menus Functions,
Cluster & Variant. Il faudra étirer l’opérateur bundle depuis sa base inférieure pour
faire apparaître 3 entrées, ou cliquer sur le bouton de droite de la souris lorsque le
curseur de celle-ci est situé sur l’opérateur bundle et utiliser le menu Add Input.
b) Extraire de cet agrégat la variable température et l’envoyer sur un indicateur
numérique situé sur le panneau avant. Pour cela, utiliser l'opérateur unbundle qui
désagrège l'agrégat et que l’on trouve via les mêmes menus que l’opérateurbundle.
Sauver ce VI sous le nom Agrégat Simple.vi.

Les graphes XY

22. Tracé de Y fonction de X : graphes XY :

On a déjà vu l'utilisation des Waveform Charts qui tracent des valeurs en fonction du temps.
On veut maintenant tracer un tableau Y en fonction d'un tableau X.

a) Utiliser une boucle For pour générer un tableau des N premiers entiers, et un
tableau des N premiers entiers au carré.

b) Envoyer ces deux tableaux vers un Express XY Graph. Sauver ce VI sous le nom
Tracé d'une courbe XY.vi.

c) On veut pouvoir utiliser les différents outils graphiques : zoom, curseur… Pour
cela, avec le bouton droit de la souris sur le Graph, faire Cursor Legend et Graph
Palette :

10/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

a. Sur la palette, essayer de faire des zooms en jouant aussi sur l'Autoscale X
et Y.

b. Les curseurs : avec l'outil main, cliquer sur le curseur display pour
l'activer. Essayer avec la souris les différentes options (cliquer sur le
cadenas pour accrocher ou non le curseur au graphe, essayer de le centrer
dans l'image avec l'option bring to center, essayer de faire apparaître un
deuxième curseur, …)

23. Tracé de deux courbes (X, Y) :

Pour tracer plusieurs graphes XY sur un même graphe, il faut cette fois-ci faire un tableau
des différents agrégats XY.

a) Utiliser une boucle For pour générer un tableau des N premiers entiers, un
tableau des carrés des N premiers entiers, et un tableau des cubes des N premiers
entiers. Utiliser deux opérateurs Bundle que l’on obtient via les menus Functions,
Cluster & Variant pour agréger les N premiers entiers (X) aux carrés et aux
cubes des N premiers entiers (Y1 et Y2).

b) Utiliser ensuite l’opérateur Build Array via le menu Functions, Array, pour faire
un tableau à partir des deux agrégats précédents (quand l'outil Build Array
apparaît, il n'a qu'une entrée, et il faut donc l'étirer avec la souris pour faire
apparaître les deux entrées nécessaires).

c) Envoyer le tableau d'agrégats ainsi construit vers le graphe XY.

d) Sur le graphe XY en panneau avant, étirer la légende en haut à droite du graphe,

pour voir les deux légendes, puis choisir une autre couleur et un autre tracé pour
la deuxième courbe (bouton droit de la souris sur sa légende).

e) Sauver ce VI sous le nom Tracé de 2 courbes XY.vi.

24. Tracé d'une courbe avec barre d'erreur : X, Y ± ∆Y :

Reprendre l'exercice précédent, le sauver sous le nom Tracé avec barres d'erreur.vi. Pour le
deuxième tableau, remplacer le calcul du cube d'un entier par un tableau donnant une barre
d'erreur (choisir une erreur constante pour commencer, ou bien un nombre aléatoire). On
veut tracer (X, Y), et (X, Y+erreur), et (X, Y-erreur). Reprendre la même construction que
précédemment pour générer et tracer ces 3 courbes. Choisir astucieusement leur apparence
(le graphe XY en points et les enveloppes en trait fin par exemple). Sauver de nouveau ce
VI.

25. Graphes XY au cours du temps et pas à la fin de la boucle :

Ouvrir le VI XY_Online.vi de la bibliothèque Demo.llb. Ce VI permet de tracer un graphe
XY non pas à la sortie de la boucle mais à chaque tour de boucle. L'utiliser, comprendre son
fonctionnement et son intérêt (c’est très important pour la suite).

11/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Les « Formula Node »

26. Utilisation du Formula Node pour écrire des formules mathématiques :

Ouvrir le VI Operation Simple.viet le sauver sous le nouveau nom Operation avec Formula
Node.vi. On va remplacer les opérateurs arithmétiques par un Formula Node, accessible via
les menus Functions, Structure. Placer une entrée et une sortie en positionnant le curseur de
la souris sur le cadre du Formula Node et en cliquant sur le bouton droit de la souris.
Ecrivez dedans le nom des variables (par exemple X en entrée et Y en sortie). Ecrire dans le
cadre la formule à effectuer suivie d'un point virgule comme sur l’exemple Y=2*X+3; et
tester son fonctionnement. Essayer ensuite une formule à plusieurs variables d'entrées et
calculer par exemple z=cos(2*pi*sqrt(y^2+x^2)).

Les variables locales et globales

27. Utilisation des variables locales dans un programme :

Ouvrir à nouveau le VI Utilisation Sequence.vi. Le sauver sous le nouveau nom Utilisation
variables locales.vi. On veut maintenant ne plus utiliser une Sequence Local pour
transmettre une valeur d’une séquence à une autre mais plutôt une variable locale. En effet,
quand un programme commence à être volumineux, il peut être parfois utile de ne pas trop
utiliser de fils. On va donc stocker une donnée parcourant un fil dans une variable dite locale
(en mode Write) qu'on pourra ensuite utiliser ailleurs, dans une autre partie du programme
(en mode Read) sans utiliser un fil. Dans ce VI, commencer par placer sur le panneau avant,
en plus du contrôleur et de l’indicateur déjà présents, un autre indicateur numérique que
vous nommez X. Envoyer, dans la 1ère étape de la séquence, le résultat de l’opération (fois 2)
dans le nouvel indicateur numérique X et l’associer à une variable locale via Fonction,
Structure, Local puis « clic gauche » dessus pour choisir la variable attribuée). Un clic droit
sur la variable locale permet de changer ses attributs « Read » et « Write ». Ainsi, dans la
3ème étape, faire apparaître la variable locale associée à cet indicateur X en mode Readvia les
menus Fonction, Structure, Localpuis Select Item. Envoyer la valeur contenue dans cette
variable locale dans l’indicateur numérique déjà présent. Pour que ce VI soit totalement
équivalent à Utilisation Sequence.vi, il faut faire disparaître du panneau avant l’indicateur
numérique X, pour cela utiliser l’option Hide/Show Indicator depuis le diagramme.

28. Utilisation des variables globales

Parfois, on veut pouvoir appeler depuis différents programmes des variables dites
"globales". Par exemple, quand on initialise une carte d’acquisition, on entre ses paramètres
depuis un programme qui l'initialise. On veut pouvoir réutiliser ces paramètres ensuite
depuis un autre programme qui utilise la carte pour mesurer une tension. Pour cela, les
variables sont mises dans un troisième programme spécial, qui ne contient qu'un panneau
avant sans diagramme, et dans lequel on place les variables. Voici comment faire :

a) Ouvrir un nouveau programme et le sauver sous Modifie Variables Globales.vi.

Afficher une variable globale dans son diagramme via Functions, Structures, Global.

12/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

Double cliquer dessus. Vous êtes envoyés vers un nouveau VI (ne contenant pas de
diagramme) nommé Global 1.

b) Sauvez Global 1 sous un autre nom : Mes variables globales.vi. Placer dedans deux
contrôleurs numériques X et Y. Sauver.

c) Revenir sur Modifie Variables Globales.vi. Dans le diagramme, faire les opérations
X = X*X+3, et Y=Y+1 (en C, ces deux instructions seraient
« X=X*X+3 ;Y=Y+1 ; »). Pour appeler X et Y sur le diagramme, il faut utiliser
Functions/Select a VI … et appeler Mes variables globales.vi. Avec le bouton droit
de la souris sur la variable globale, choisissez Select Item et choisissez la variable à
manipuler (X ou Y) ainsi que son état (contrôleur ou indicateur). Une fois que ceci
est terminé, supprimer du diagramme la variable globale non affectée.

d) Créer un nouveau VI appelé Utilisation Variables Globales.vi. Y mettre une

séquence à 3 étapes. Dans la première étape, faire afficher le contenu des variables
globales X et Y. Dans la 2ème étape, appeler Modifie Variables Globales.vi.

e) Dans la 3ème étape, afficher à nouveau le contenu des variables globales X et Y sur
deux autres indicateurs.

Les résultats affichés dans Utilisation Variables globales.vi prennent en compte les
modifications effectuées dans Modifie Variables Globales.vi : c’est la raison d’être des
variables globales.

Les fichiers
29. Les fichiers « texte » :
a) Ouvrir Fichier_Texte_Write.vi dans Demo.llb. Modifier « MonBinome » dans la
constante Path pour que le chemin d’accès soit dirigé sur votre répertoire (voir le
paragraphe du manuel correspondant à ce sujet). Comprendre le programme et
l’utiliser pour créer le fichier MonPremierEssai.txt constitué d’enregistrements de
deux nombres réels (attention, le suffixe « .txt » est important).

b) Ouvrir Fichier_Texte_Read.vi dans Demo.llb. Comprendre le programme et

l’utiliser pour relire le fichier MonPremierEssai.txt créé précédemment.

c) Ouvrir Fichier_Texte_Write_Seq.vi dans Demo.llb. Modifier « MonBinome » dans

la constante Path pour que le chemin d’accès soit dirigé sur votre répertoire.
Comprendre le programme. Quelle est la différence par rapport à
Fichier_Texte_Write.vi ? Modifier-le, après l’avoir sauvegardé sous le nouveau nom
Mon_Fichier_Texte_Write_Seq.vi pour qu’il enregistre en plus, en première
colonne, l’indice i de la boucle. Utiliser ce VI pour créer MonDeuxièmeEssai.txt.

d) Tout l’intérêt du format d’enregistrement « texte » est de pouvoir relire simplement

les fichiers avec n’importe quel autre logiciel. Essayer de relire
MonDeuxièmeEssai.txt avec le Notepad de Windows. Utiliser maintenant le logiciel

13/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

d’analyse de données Kaleidagraph™ pour tracer la troisième colonne de

MonDeuxièmeEssai.txt en fonction de la seconde.

Simulation d’une mesure bruitée et filtrage

30. Génération d’une mesure bruitée :
Ecrire un programme qui simule une mesure de tension fluctuant de manière aléatoire entre -
2 et +2 V, à laquelle se rajoute un signal sinusoïdal de 50 Hz et d’amplitude variable.
Chaque signaux (la tension et le signal à 50 Hz) seront écrits dans un fichier texte. Sauver ce
programme sous le nom SimuleBruit.vi.

31. Utilisation d’un filtre :

Relire les données précédentes et utiliser un filtre (Functions, Signal Processing, Filters)
pour supprimer le 50 Hz. Comparer graphiquement le signal originel non bruité et le signal
réel filtré. Sauver le programme sous le nom UtilisationFiltre.vi.

32. Traitement de données avec Kaléidagraphe

Vous allez maintenant simuler un signal expérimental « bruyant » et effectuer un traitement
de celui-ci avec le logiciel Kaléidagraphe qui vous est fourni pour les futurs projets. Vous
trouverez une aide pour l’utilisation du logiciel en annexe du poly.

En vous inspirant des exercices précédents, générez un signal qui comprend :

• un partie oscillante à une fréquence déterminée f0 d’amplitude A0 (signal physique)
• un bruit blanc
• un signal parasite de 50 Hz et d’amplitude variable
Tracez ce signal en fonction du temps grâce à labview puis enregistrez le résultat (signal et
temps) dans un fichier texte.
Utilisez Kaléidagraphe et ses fonctions de fit pour extraire la fréquence et l’amplitude du
signal physique. Comparez aux valeurs connues pour f0 et A0. Etudiez la précision de ces
résultats en fonction de l’amplitude du bruit et du 50 Hz qui se rajoute au signal physique.
Vous pourrez également essayer différents filtres et voir si cela améliore la détermination de
A0 et f0.

Mesure à intervalles fixes ou contrôlés par l’utilisateur

33. Simulation d’une mesure :
Ecrire un programme simulant une mesure de température fluctuant de manière sinusoïdale
autour d’une valeur moyenne qui augmente linéairement de 300K à 1500K. A chaque

14/15
Magistère et M1 de Physique Fondamentale et Appliquée – Université Paris XI
Initiation à LabVIEW 2010 – 2011

température, on associe une mesure de tension fictive V = 4*T+5. Sauver ce programme

sous le nom TempeCroiss.vi..

34. Prise d’une mesure à intervalles réguliers :

Ecrire un programme qui simule une mesure de température (à l’aide de TempeCroiss.vi) et
qui sauvegarde régulièrement les mesures de température (1 mesure sur 5 par exemple) dans
un fichier.Sauver ce programme sous le nom Acquisition Reguliere.vi.

35. Prise d’une mesure à la demande :

Ecrire un programme qui simule une mesure de température (à l’aide de TempeCroiss.vi)
lorsque l’utilisateur appuie sur un bouton « MESURE ». Prévoir également un bouton
« ARRET » pour quitter le programme.Sauver ce programme sous le nom Acquisition a la
demande.vi.

Flux et Nœuds
36. Gestion du flux d’informations :
Écrire un programme qui incrémente une valeur initiale (choisie en face avant par
l’utilisateur) toute les secondes. Le résultat de l’incrément devra apparaître en face avant, en
utilisant le "numeric" qui contenait la valeur initiale. Utilisez une boucle "while" et un
bouton stop pour arrêter le programme. Puis créer une deuxième boucle while, parallèle à la
première, pour faire un affichage asynchrone : un indicateur placé dans cette boucle devra
afficher la valeur du résultat toutes les deux secondes. Le bouton stop devra arrêter les deux
boucles en même temps. Rem : pour pouvoir utiliser un booléen en variable locale, il faut
paramétrer sa « Mechanical Action » sur « Switch ».

15/15