Introduction LabVIEW

Capteurs

Signal numris (octets)

Signal lectrique exploitable

par carte DAQ/priphrique DAQ

Signal lectrique

Grandeur physique

Premiers pas vers lexprience

Programme (Diagramme)

Interface graphique (Face avant)

Conditionnement
Acquisition/commande

Enregistrement

Rseau

Dispositif
Tiers

Novembre 2007
Emmanuel Grolleau

Table des matires

TABLE DES MATIERES .................................................................................................................................... 3
TABLE DES EXERCICES .................................................................................................................................. 4
1

ORIGINES DE LABVIEW ........................................................................................................................ 5

LE CONCEPT DINSTRUMENT VIRTUEL .......................................................................................... 5

PREMIER PAS............................................................................................................................................ 6

CREER UN NOUVEAU VI........................................................................................................................ 7

4.1
LES PALETTES ....................................................................................................................................... 8
4.1.1
Palette de commandes..................................................................................................................... 8
4.1.2
Palette doutils .............................................................................................................................. 10
4.1.3
Palette de fonctions ....................................................................................................................... 12
4.2
CREATION DU DIAGRAMME................................................................................................................. 13
4.2.1
Programmation flots de donnes................................................................................................... 15
4.2.2
Correction syntaxique ................................................................................................................... 16
4.2.3
Typage........................................................................................................................................... 17
4.2.3.1
Types de base.......................................................................................................................................17
4.2.3.2
Types composs ...................................................................................................................................19
4.2.3.2.1
Cluster.............................................................................................................................................19
4.2.3.2.2
Tableaux .........................................................................................................................................21
4.2.3.2.3
Waveforms......................................................................................................................................22
4.2.3.2.4
Types strictes ..................................................................................................................................23
4.2.3.2.5
Classes ............................................................................................................................................23

4.2.4

Encapsulation (notion de sous-programme) ................................................................................. 23

4.2.4.1
4.2.4.2
4.2.4.3
4.2.4.4

4.2.5

Etape indispensable : crer les connecteurs..........................................................................................24

Etape conseille : crer une icne personnalise..................................................................................25
Etape conseille : crer une documentation .........................................................................................26
Utiliser un sous-vi personnel dans un vi ..............................................................................................26

Structures de contrle ................................................................................................................... 28

4.2.5.1
4.2.5.1.1
4.2.5.1.2
4.2.5.2
4.2.5.2.1
4.2.5.2.2
4.2.5.2.3
4.2.5.3
4.2.5.4

La structure conditionnelle...................................................................................................................28
La structure de choix if/then/else ....................................................................................................28
La structure choix multiple ..........................................................................................................30
La boucle For .......................................................................................................................................31
Indexation ou non des sorties..........................................................................................................32
Indexation des entres.....................................................................................................................32
Registre dcalage .........................................................................................................................33
La boucle faire tant que/faire jusqu...................................................................................................35
La squence..........................................................................................................................................37

4.3
UTILISATION AVANCEE ....................................................................................................................... 37
4.3.1
Utilisation de graphes ................................................................................................................... 37
4.3.1.1
4.3.1.2
4.3.1.3

4.3.2

Gestion de fichiers......................................................................................................................... 41

4.3.2.1
4.3.2.2
4.3.2.3

4.3.3

Graphe droulant..................................................................................................................................37
Graphe..................................................................................................................................................38
Graphe XY...........................................................................................................................................40
Utilisation de fichiers textes.................................................................................................................42
Utilisation de fichiers binaires..............................................................................................................43
Utilisation de fichiers pour grer une configuration.............................................................................43

Interface graphique....................................................................................................................... 46

4.3.3.1
Ractions aux vnements ...................................................................................................................46
4.3.3.2
IHM dapplication / bote de dialogue .................................................................................................48
4.3.3.3
Interface graphique dynamique............................................................................................................50
4.3.3.3.1
Nuds de proprits .......................................................................................................................50
4.3.3.3.2
Face-avant secondaire.....................................................................................................................51
4.3.3.3.3
Utilisation de rfrences sur les terminaux .....................................................................................52

4.3.4
4.3.5
5

Cration de fichier excutable ...................................................................................................... 53

Quelques petits trucs ..................................................................................................................... 54

CONCLUSION .......................................................................................................................................... 54

Table des exercices

Exercice d'application 1 : comprendre la notion de diagramme et face-avant, savoir trouver les
palettes...................................................................................................................................... 13
Exercice d'application 2 : comprendre le principe du cblage, utiliser laide contextuelle, crer
et personnaliser une face-avant simple. Utiliser laide en ligne............................................... 14
Exercice d'application 3 : comprendre le fonctionnement des tableaux, voir la correspondance
avec un fichier tableur. Prendre conscience des problmes de localisation du sparateur
dcimal (utilisation du . ou de la , comme sparateur dcimal dans le tableur).
Comprendre la faon dont LabVIEW gre les noms de fichier et les vi de manipulation de
noms de fichiers. ...................................................................................................................... 22
Exercice d'application 4 : manipuler les types de donnes, rechercher des vis, raliser un test
unitaire...................................................................................................................................... 23
Exercice d'application 5 : rendre un vi utilisable en tant que sous-vi....................................... 25
Exercice d'application 6 : crer licne dun vi ........................................................................ 25
Exercice d'application 7 : crer la documentation dun vi ....................................................... 26
Exercice d'application 8 : connatre larborescence des fichiers LabVIEW ............................ 27
Exercice d'application 9 : crer une structure conditionnelle, utiliser Animer lexcution 30
Exercice d'application 10 : utiliser une structure conditionnelle, utiliser un sous-vi personnel,
utiliser une bote de dialogue.................................................................................................... 30
Exercice d'application 11 : comprendre le fonctionnement dune boucle For......................... 32
Exercice d'application 12 : utiliser une boucle For .................................................................. 33
Exercice d'application 13 : manipuler un registre dcalage, et un nud de rtroaction ....... 35
Exercice d'application 14 : crer une boucle While, comprendre le fonctionnement du tunnel
dentre, comprendre laction mcanique des boutons ............................................................ 36
Exercice d'application 15 : utiliser une boucle While, comprendre les problmes lis
labsence de squencement ...................................................................................................... 36
Exercice d'application 16 : utiliser une structure squence, utiliser un point darrt............... 37
Exercice d'application 17 : crer un graphe droulant multicourbe, personnaliser laffichage 38
Exercice d'application 18 : crer un graphe, crer un histogramme......................................... 39
Exercice d'application 19 : rechercher des exemples, utiliser un fichier .tdms........................ 42
Exercice d'application 20 : manipuler un fichier texte, formater des chanes, convertir en
chane ....................................................................................................................................... 42
Exercice d'application 21 : crer un type strict ........................................................................ 45
Exercice d'application 22 : crer un vi non rentrant de stockage de valeur globale, utiliser un
type strict .................................................................................................................................. 46
Exercice d'application 23 : utiliser un vi non rentrant de stockage, utiliser un fichier .ini..... 46
Exercice d'application 24 : crer et personnaliser une bote de dialogue, grer une IHM par
vnements ............................................................................................................................... 49
Exercice d'application 25 : crer une IHM dynamique laide des nuds de proprits,
utiliser des onglets .................................................................................................................... 50
Exercice d'application 26 : utiliser les rfrences, modifier un type strict............................... 53
Exercice d'application 27 : crer un excutable ....................................................................... 53

1 Origines de LabVIEW
LabVIEW pour Laboratory Virtual Instrumentation Engineering Workbench est un
environnement de dveloppement en langage G. Notons que lon crit LabVIEW et non pas
LabView ou Labview, etc.
Il a t cr en 1986, initialement pour Apple Macintosh, qui tait lpoque lun des
seuls ordinateurs proposant une interface graphique native. Lhistoire de LabVIEW explique
un vocabulaire spcifique, et explique encore certaines actions. A lorigine, LabVIEW
sexcute sur des crans noir et blancs, puis sur des crans 16 couleurs, 256, etc.
LabVIEW est un environnement de dveloppement propritaire (par opposition un
environnement ouvert, permettant plusieurs personnes de dvelopper des compilateurs
compatibles, comme pour C/C++, Ada, Java, Fortran, etc.) dvelopp et vendu par la socit
National Instruments (NI). Le premier mtier de NI est de fabriquer du matriel
dacquisition (notamment sur le protocole GPIB au dbut des annes 80) rapidement destin
au march des micro-ordinateurs (IBM PC, Apple Macintosh). Ainsi, la premire version de
LabVIEW sattache offrir un environnement de dveloppement dont le rle est de permettre
simplement lutilisateur de crer des instruments virtuels (virtual instrument, ou vi)
utilisant le matriel dacquisition NI pour reproduire sur un micro-ordinateur le comportement
dun instrument personnalis et personnalisable volont.

2 Le concept dinstrument virtuel

Signal lectrique exploitable

par circuit lectronique

Signal lectrique

Grandeur physique

Lide de base est dutiliser une carte dacquisition ou un priphrique dacquisition,

dont le rle est dacqurir un signal lectrique provenant de lextrieur, gnralement un
capteur (thermocouple, dbitmtre, voltmtre, etc.) ou un ensemble de capteurs, effectuer un
traitement, un enregistrement dans un fichier ou une base de donnes, une restitution lcran
via une interface graphique, et ventuellement effectuer un ensemble dactions sur le monde
extrieur laide dactionneurs (lectrovanne, moteur, etc.). Les variations possibles sont
infinies en fonction des besoins et de leurs volutions.
Lavantage de linstrument virtuel sur linstrument rel est indniable, puisquil est du
ressort du programmeur de linstrument virtuel (par consquent vous) de faire voluer
linstrument virtuel en fonction des besoins (interrogation via le rseau, tolrance aux pannes,
gestion de diffrentes vues, calculs, etc.).
La Figure 1 prsente les tapes classiques du phnomne physique sa visualisation
sur un instrument rel.

Circuit lectronique

Capteurs

Conditionnement

Figure 1 : de la grandeur physique linstrument rel

Face avant dinstrument

Capteurs

Signal numris (octets)

Signal lectrique exploitable

par carte DAQ/priphrique DAQ

Signal lectrique

Grandeur physique

La Figure 2 montre que linstrument virtuel diffre dans les dernires tapes : en effet,
un dispositif dacquisition (carte dacquisition, priphrique) permet au micro-ordinateur
dacqurir le signal. En LabVIEW, nous verrons que 2 parties sont utilises lorsque lon
programme : le programme (diagramme dans la terminologie LabVIEW), qui reprsente le
traitement qui sur un instrument rel est pris en charge par un circuit lectronique, et
linterface graphique (face avant pour LabVIEW) qui, linstar de la face avant dun
instrument rel, permet dafficher lutilisateur et dinteragir avec lui. Le programme permet
deffectuer tout traitement automatisable (de lenregistrement, lutilisation dun rseau, en
passant par la commande).

Programme (Diagramme)

Interface graphique (Face avant)

Conditionnement
Acquisition/commande

Enregistrement

Rseau

Dispositif
Tiers

Figure 2 : de la grandeur physique linstrument virtuel

3 Premier pas
Lorsquon lance LabVIEW
, lcran de dmarrage permet de dmarrer toutes les
oprations proposes par cet environnement de dveloppement (voir Figure 3).

Crer un nouveau programme

Crer un nouveau projet

Projet partir dun assistant
Divers :
- partir dun modle
- polymorphe
- vers une cible spcifique
- classe, variable globale,
Ouvrir un fichier/projet
rcemment ouvert

Ouvrir un fichier/projet

Assistant pour une cible

spcifique

Figure 3 : cran daccueil de LabVIEW

Pour crer un nouveau programme on slectionnera VI vide . LabVIEW utilise le

nom de vi (virtual instrument), prononcer langlaise, vi-ae pour les programmes et
sous-programmes. Les programmes ou sous-programmes auront lextension .vi et seront
donc nomms vi. Nous verrons quil y a peu de diffrences entre un programme et un sousprogramme, on pourra donc parfois utiliser spcifiquement le terme de sous-vi pour sousprogramme, mais cela ne sera pas toujours le cas.
Sur lcran de dmarrage, la partie gauche permet de crer ou douvrir un vi ou un
projet (nous verrons la notion de projet, rcente dans LabVIEW, plus loin dans la formation).
La partie droite, sur laquelle nous reviendrons bientt, permet daccder la documentation
extrmement riche, incluant notamment divers tutoriaux. De plus, elle donne un pointeur vers
les nouveauts de la version courante par rapport la version prcdente, ainsi que vers des
sites internets (ainsi Zone LabVIEW est une zone dchange dexprience trs active). Enfin,
cet cran donne un lien vers un outil de recherche dexemples trs varis. Nous aurons
loccasion dutiliser cet outil indispensable ds que lon souhaite satteler un type de
problme nouveau.

4 Crer un nouveau vi
Que lon souhaite crer un programme ou un sous-programme, on cre un vi. Pour
LabVIEW tout vi est considr comme un instrument virtuel. Par consquent il a un
comportement (voir Figure 4) donn sur le diagramme (fentre blanche) et une interface
utilisateur nomme face-avant (fentre grise). De plus, un vi sera symbolis par son icne. Il
est important de retenir quun vi est stock dans un unique fichier .vi : 2 fentres, mais 1 seul
fichier.

Icne
Diagramme

Face avant

Figure 4 : un vi LabVIEW est compos dun diagramme (fentre blanche) et dune face avant (fentre
grise) et reprsent par une icne

Sur la face-avant, nous serons donc amens placer des lments graphiques (entres
du programme, linstar des boutons dun instrument, sorties linstar des lments affichs
sur un instrument, lments de dcoration,), alors que sur le diagramme nous placerons la
logique du programme, en gnral logique qui relie les entres aux sorties : comment calculer
les sorties partir des entres.

4.1 Les palettes

En LabVIEW, toute la programmation se passe de faon graphique, il ny a pas de
syntaxe connatre (pas de begin, end, for, etc.). Quand on dbute, on commence souvent par
crer la face-avant, puis on passe au diagramme pour reprsenter la logique du programme.
Nous verrons par la suite quil est souvent plus rapide de faire linverse (sauf pour le vi
correspondant ce qui sera montr finalement lutilisateur).

4.1.1 Palette de commandes

Commenons donc comme tout dbutant par crer linterface graphique : supposons
que le programme prenne 2 numriques en entre, et calcule un rsultat sous forme dun
numrique. Il nous faudra donc crer 2 entres numriques, et 1 sortie numrique (affichage).
Dans le jargon LabVIEW, les entres sappellent des commandes et les sorties des
indicateurs (toujours par analogie avec un instrument). Les commandes, indicateurs et
dcoration sont disponibles partir de la palette de commandes (voir Figure 5) de
LabVIEW. Il y a plusieurs faons dafficher la palette de commandes :
Faire un click droit sur la face-avant (attention, un click droit sur le diagramme
affiche la palette de fonctions dont nous discuterons aprs). Remarquer la
punaise en haut gauche de la palette qui apparat sous la forme dun menu : en
cliquant sur celle-ci, la palette reste affiche sous forme dune fentre.
Dans le menu droulant de la face-avant, cliquer sur Affichage , puis
slectionner Palettes des commandes . Cela a pour effet dafficher la palette
sous forme dune fentre (quivalent utiliser la punaise).
Remarquer que mme si elle est affiche, la palette de commandes devient invisible
lorsque la fentre de la face-avant nest pas active.

Punaise transformant la palette en fentre

Figure 5 : palette de commandes : gauche sous forme de menu (click droit sur la face-avant), droite
sous forme de fentre (via menu droulant de la face avant, ou bien laide de la punaise)

Plusieurs palettes existent ( Moderne , Systme , Classique , Express ,

Commandes utilisateur , .NET et ActiveX , les autres palettes dpendant des modules
supplmentaires installs). La plupart du temps nous utiliserons la palette Moderne .
Cette palette organise les lments par catgorie :
Numrique : offre des commandes et indicateurs permettant de saisir ou afficher
un numrique. Noter que par dfaut, ce numrique est en gnral un nombre rel (par
opposition un nombre entier). Nous parlerons plus tard de la notion de type.
Boolen : commandes et indicateurs boolens (lalgbre de Boole, dite algbre
boolenne est lalgbre de la logique, dans laquelle les variables peuvent prendre la
valeur vrai ou la valeur faux). Les boolens correspondent aux boutons 2 tats et aux
indicateurs 2 tats (LED, etc.).
Chane et chemin : commandes et indicateurs permettant de saisir ou dafficher des
chanes de caractres (par chane de caractres, on entend des mots ou phrases, i.e.
suite de caractres). De mme, on trouve ici ce qui permet de saisir ou afficher un nom
de fichier ou de rpertoire (chemin).
Graphe : propose diffrents indicateurs de graphes.
Ces quatre sous-palettes sont les plus frquemment utilises. Vous tes invit bien entendu
ouvrir les menus afin de dcouvrir les lments que proposent les diffrentes palettes et sous
palettes (par exemple la palette systme offre des lments au look du systme
dexploitation sous-jacent comme Windows, Mac OS,).
Il est important de comprendre que lapparence dune commande, par exemple pour un
numrique, na pas de relle importance : une commande numrique et un bouton

rotatif ont la mme fonction pour le programme : permettre dentrer un numrique. Le choix
dune apparence na donc strictement aucune importance pour un vi qui sera utilis comme un
sous-programme (sa face-avant ne sera pas vue par lutilisateur). Ce choix aura bien entendu
son importance sur le ou les vi qui seront vus par lutilisateur du programme final.
La Figure 6 montre le vi aprs cration de deux commandes numriques ( Numrique
et Bouton rotatif ) et dun indicateur numrique ( vumtre ) sur la face-avant. On peut
voir qu chaque commande ou indicateur de la face-avant correspond une reprsentation
logique sur le diagramme. La diffrence entre une commande et un indicateur est
fondamentale : la commande fournit une donne au diagramme. Noter sur licne de la
commande dans le diagramme la flche droite allant vers lextrieur et reprsentant le
cheminement de la donne (de la commande vers le programme). Lindicateur, quant lui,
permet dafficher une donne, qui lui est fournie par le programme : noter sur son icne la
flche gauche de lextrieur vers licne (du programme vers lindicateur). Une autre
diffrence graphique utile dans les versions plus anciennes de LabVIEW (version 6 et
antrieure) est que le bord dun indicateur est en trait gras dans le diagramme, alors que celui
dune commande est en trait fin.
Reprsentation graphique et logique
dune commande numrique

Reprsentation graphique et logique

dun indicateur numrique
Figure 6 : 2 commandes et un indicateur numriques

4.1.2 Palette doutils

Avant de rentrer dans la faon dlaborer le programme (diagramme), il est bon de
comprendre la faon dont on donne certaines fonctionnalits la souris. En effet, tout ou
presque tant fait la souris, il faut comprendre que lutilisation seule de la souris pourra
avoir pour effet de redimensionner, dplacer, actionner (tourner un bouton, cliquer sur un

10

menu, etc.), colorier, slectionner du texte, etc. Les principales fonctions de la souris sont les
suivantes :

la main (plus formellement la fonctionnalit souris Actionner les

commandes ) permet dactionner les commandes comme pendant lexcution
du vi. Il est ainsi possible de tourner un bouton, bouger une aiguille, cliquer sur
une barre de dfilement, etc.
la
flche
(plus
formellement
la
fonctionnalit
souris

Positionner/Dimensionner/Slectionner ) permet de dplacer

un lment,
le redimensionner
(lorsque lon passe la souris sur une poigne qui est
reprsente par un point bleu). Au repos (quand aucune action nest possible
lemplacement courant de la souris, typiquement parce-quaucun objet nest
lemplacement courant de la souris, le curseur de la souris est .

ldition de texte permet de modifier le texte (typiquement le nom des

lments affichs, les valeurs numriques des chelles, etc.) ou bien dcrire
librement du texte. Noter quun texte crit librement correspond, sur la face
avant, de la dcoration (ce nest pas un lment actif), et sur le diagramme du
commentaire (attention ne pas le confondre avec une chane de caractres). L
encore, lallure du curseur permet de savoir ce qui sera fait : si lon clique avec

, on crera un nouveau texte libre. Si le curseur est au dessus dun

le curseur
texte, il prendra la forme , montrant ainsi quun click permettra dditer le
texte situ sous le curseur.

la bobine (plus formellement Connecter les terminaux ) permet de crer

un cble entre deux terminaux (lments connectables ). Notons pour le
moment que cette fonctionnalit nest pas utilise sur la face avant, mais que
cest une fonctionnalit primordiale au niveau du diagramme.
On peut faire en sorte que le changement de fonctionnalit de la souris sopre
automatiquement (cest le cas si lorsque le pointeur nest pas au dessus dun objet, son
apparence est ). Pour cela, ou pour changer de fonctionnalit, on utilise la palette doutils
(voir Figure 7). La palette doutils apparat laide du menu droulant Affichage
Palette doutils . Lutilisation de la slection automatique est conseille : dans ce cas, en
fonction du placement de la souris, LabVIEW choisit automatiquement la fonctionnalit
(l outil ) adquat. Dplacez votre souris lentement au-dessus des objets, et voyez comme
son aspect change en fonction de loutil choisi par LabVIEW. La seule subtilit concerne la
saisie de texte : dans ce cas, double-cliquer sur un texte existant permet de lditer et doublecliquer nimporte o dans la fentre permet de crer un texte libre.
Slection automatique
en fonction du placement
de la souris (conseill)

Edition de texte

Actionner les commandes (main)

Positionner/Dimensionner/Slectionner (flche)
Cbler (bobine)
Placer un point darrt
Placer une sonde
Colorier (pinceau)
Figure 7 : la palette doutils permet de choisir la fonctionnalit de la souris

11

La fonctionnalit pinceau permet de colorier les diffrents lments de la face-avant et

du diagramme. Son utilisation manque, contrairement au reste, dintuitivit. Pour lutiliser,
slectionner loutil pinceau dans la palette doutils, puis faire un click droit sur lobjet ou la
partie de lobjet colorier. Chaque partie dobjet peut avoir une seule couleur, ou 2 (une
couleur davant plan et une couleur darrire plan). Si lobjet possde 2 couleurs, lappui sur
la barre espace permet de contrler la partie quon colorie (avant-plan, arrire-plan, les 2
simultanment).

4.1.3 Palette de fonctions

Lorsque la face avant est prte, on peut passer la dfinition du programme en luimme. Notre attention va donc maintenant se focaliser sur le diagramme. Supposons que nous
souhaitions raliser un convertisseur dunit de temprature de C vers F en utilisant la
formule F=1,8xC+32. Nous commenons par crer la face avant (une commande numrique,
un indicateur numrique, sous forme dun thermomtre). Quelques modifications (police,
ajout de texte libre, dcorations, couleurs) permettent dobtenir une face avant telle que celle
prsente sur la Figure 8.

Figure 8 : face avant et diagramme vide dun convertisseur dunits

A linstar de la palette de commandes utilise pour la face-avant, le diagramme offre

lui aussi une palette : la palette de fonctions (voir Figure 9). Cette palette peut-tre obtenue
de manire analogue la palette de commandes (menu droulant Affichage de la fentre
du diagramme, ou bien click droit dans le diagramme).
Chaque fonction (sous-vi) en LabVIEW est reprsente par une icne. Les fonctions
sont regroupes par catgories : Structures , Tableau , Cluster et variant ,
Numrique , Entres/Sorties sur fichier , Boolen , Chane de caractre ,
Comparaison , etc. Nous aurons loccasion de les explorer ensemble.
Lune des fonctionnalits importantes de cette palette est le bouton Rechercher .
En effet, la bibliothque de fonctions est importante, dautant plus si diffrents modules
optionnels sont installs. La recherche permet une recherche rapide de vi laide dun mot
cl. Ainsi, avant de se lancer dans le convertisseur, aurait-il t utile de rechercher conver
pour sapercevoir que LabVIEW peut grer lui-mme les conversions dunits.

12

Figure 9 : la palette de fonctions

Exercice d'application 1 : comprendre la notion de diagramme et face-avant, savoir trouver les palettes.

A faire : Lancer LabVIEW, crer un nouveau vi. Afficher la palette doutils, et slectionner
Slection automatique de loutil . Afficher sous forme de fentre la palette de commandes
et la palette de fonctions. Fermer la fentre diagramme du vi. La faire rapparatre en utilisant
le menu Fentre de la fentre face-avant ou bien le raccourci clavier Ctrl+E.

4.2

Cration du diagramme

Il nous faut commencer, pour le convertisseur, placer les fonctions ncessaires : une
addition, et une multiplication (F=1,8xC+32). Toutes les deux sont dans la palette
Numrique (tape 1 de la Figure 10). Ensuite, on utilise loutil
bobine pour cbler
lentre (la commande) C une entre de la fonction multiplication (tape 2). Il nous faut
alors multiplier cela la constante 1,8. Il y a diffrents moyens de crer une constante, mais le

13

plus simple, utiliser dans 99% des cas (sauf dans le cas de vi polymorphe), est de faire un
click droit sur lentre, puis de choisir Crer Constante . Une constante, du bon
type, est alors cre et relie cette entre. Le diagramme est enfin complt comme ltape
3. Pour excuter le vi, il faut cliquer sur le bouton Excuter
. Certains utiliseront
Excuter en continu , qui a pour effet dexcuter le vi sans arrt jusqu lappui sur le
bouton Abandonner lexcution
. Cependant, je dconseille de prendre cette habitude :
un programme bien fait contient une boucle dexcution au niveau le plus haut, et son propre
bouton darrt sur la face-avant

3
Figure 10 : tapes de la construction du diagramme

A partir dici, il convient dutiliser la fentre daide contextuelle (menu droulant Aide
Afficher laide contextuelle ou raccourci clavier Ctrl+H) afin dobtenir des
descriptions rapides des fonctions, ou bien savoir quel type de donnes passe sur un fil. Le
contenu de laide est mis jour en fonction de llment se trouvant sous le curseur de la
souris. Ainsi, si lon place la souris sur le nud x de la Figure 10, on obtient laide
contextuelle donne sur la Figure 11.

Vers une aide complte

Affichage des entres optionnelles ou non
Figure 11 : aide contextuelle
Exercice d'application 2 : comprendre le principe du cblage, utiliser laide contextuelle, crer et
personnaliser une face-avant simple. Utiliser laide en ligne.

14

A faire : Crer le vi de conversion donn sur la Figure 10. Pour cela, sassurer que laide
contextuelle est active. Personnaliser sa face avant comme sur la Figure 8. Rechercher dans
laide dtaille ce qui se rapporte la gestion dunits. Modifier le vi afin dutiliser les units
de mesure et la conversion automatique par LabVIEW.
Note : on peut faire une diffrence entre vi standard et vi express. Les vi express sont

reprsents par une icne dans un carr bleu ciel comme

. Les vi express
permettent de programmer trs simplement une tche commune. Cependant, je ne saurais les
conseiller : gnralement plus lents lexcution que des vi programms quivalent, lents
charger, et surtout, en cas de gnration de fichier excutable partir dun vi, les vi express
augmentent considrablement la taille de lexcutable gnr. Enfin, ils ont des
fonctionnalits limites aux tches communes : si le besoin diffre un peu des besoins prvus,
alors il faudra de toute faon faire sans. Dans cette formation, il ne sera donc fait aucun cas de
vi express.

4.2.1 Programmation flots de donnes

Intuitivement, le comportement est le suivant : lorsque le vi est excut, les commandes
(entres de donnes sur la face avant) et les constantes fournissent leur valeur. Les
commandes sont dailleurs appeles terminaux dentre du diagramme. Tout fil sortant dun
de ces lments transporte donc sa valeur vers lentre du prochain nud. Lorsquun nud
possde une donne sur chacune de ses entres, il devient excutable. A chaque tape de
lexcution, le runtime (moteur dexcution LabVIEW) choisit parmi tous les nuds
excutables un nud excuter. En sexcutant, un nud consomme ses entres, et gnre
des sorties sur chacun des fils en sortie. En gnral, les flots se terminent dans un indicateur,
appel terminal de sortie (ici F ). Cela a pour effet dafficher la valeur contenue sur le
fil. Afin de bien voir le droulement de lexcution dun vi, on pourra actionner
lanimation de lexcution : cela permet de visualiser les transits des donnes sur les fils.
Ce type de programmation sappelle de la programmation flots de donnes. Chaque fil
supporte un flot de donnes, comme si les donnes scoulaient sur les fils de mme quune
rivire scoulerait dans un lit. La programmation flot de donnes est une philosophie trs
diffrente des types de programmations que vous connaissez peut-tre, comme la
programmation imprative (Fortran, C/C++, Ada, Java, Javascript, PHP, etc. en fait la plus
grande majorit des langages de programmation), ou la programmation fonctionnelle (comme
caml ou XSLT) ou encore de la programmation dclarative (Prolog, SQL). Ce type de
programmation correspond au langage G. Trs souvent, on confond langage G et LabVIEW
puisque cet environnement est le seul reprsentant trs connu du langage G.
La diffrence majeure par rapport un langage plus classique (impratif) est que le
langage G ne dispose de squencement implicite. Ainsi, dans un langage impratif, lordre des
instructions implique un squencement de celles-ci. En G, il nen est rien : seule la
dpendance lie aux flots de donnes (une entre dpendant du flot de sortie) entrane une
notion de squencement (laction A a lieu avant laction B). Cependant, lorsque plusieurs
portions de programmes sont indpendantes (pas de dpendance de flots de donnes), elles
peuvent tre excutes en parallle. Ce paralllisme peut tre rel si la machine dispose de
plusieurs processeurs ou dun processeur plusieurs curs, ou bien il se traduit par de
lentrelacement temporel. Ainsi, si laction A et laction B ont lieu en parallle, alors il est
possible, par exemple, que le runtime commence A, puis commence B, puis continue A, puis
15

continue B, puis termine A, puis termine B. En fait, le programme est excut par diffrentes
tches du systme dexploitation (on parle de threads) ce qui fait de G un langage parallle
naturel.
Lune des rserves que certains opposent LabVIEW est la lenteur que ce type
dexcution graphique et parallle peut entraner. En ralit, lexcution, LabVIEW compile
les vi en code excutable. Lors de lexcution, part quelques optimisations qui pourraient
amliorer la vitesse, sa vitesse dexcution est tout fait comparable la vitesse dexcution
dun programme crit en C++. Il est dailleurs possible, afin dviter une compilation des vi et
ainsi acclrer le temps de chargement de compiler tous les vi dun rpertoire (menu
Outils Avanc Recompiler .

4.2.2 Correction syntaxique

Vous aurez peut-tre remarqu lors de la cration de votre vi que la flche dexcution
est parfois brise
. Comme tout langage de programmation, LabVIEW vrifie la syntaxe
des vi. La diffrence par rapport nombre dautres langages est que la vrification a lieu
pendant ldition des vi. Les erreurs les plus classiques, ce stade, sont :
Plusieurs flots sont regroups (un fil connecte plus dune source de donnes) :
en LabVIEW, un flot de donnes peut se dcomposer, mais on ne peut pas
regrouper 2 flots dans un seul, sauf si lon utilise un constructeur de type (nous
verrons cela par la suite). Dans le cas contraire, le flot apparat en pointills
comme sur la Figure 12.
On a connect 2 entres ensemble ou bien 2 sorties ensemble. Il ne faut pas
oublier que chaque connecteur de nud est orient. Par convention, cest
orient de gauche droite (entres gauche, sorties droite).
On a connect des connecteurs de type incompatible (nous verrons trs bientt
la notion de type).
Des entres obligatoire nont pas t cbles (ainsi, si le nud + ne possde
quune entre, une erreur de syntaxe a lieu). Chaque entre de nud peut tre
obligatoire ou non (dans le cas o une entre nest pas obligatoire et que rien
nest donn en entre, une valeur par dfaut est prise).

Figure 12 : erreur de syntaxe, des flots sont regroups

Quand elle concerne des flots de donnes, une erreur de syntaxe se traduit par le fait
que les fils concerns sont briss. Une commande trs utile se trouve dans le menu Edition
Supprimer les fils briss , ou raccourci clavier Ctrl+B. Sur la Figure 12 cela aura pour
effet de supprimer tous les fils briss.
En cliquant sur la flche brise, on obtient une fentre donnant la liste des erreurs (voir Figure
13).

16

Figure 13 :affichage de la liste des erreurs

4.2.3 Typage
LabVIEW est un langage typage fort. Toute donne a un type.

4.2.3.1 Types de base

A chaque type de base correspond une couleur (voir Figure 14). Notons que diffrents
types peuvent tre reprsents par une mme couleur. Ainsi, par exemple les types
numriques discrets sont bleus (entiers signs, non signs, sur 8, 16, 32 ou 64 bits, ainsi que
les types numrs).
Reprsentation Couleur
Type
Nombre entier : U8, U16, U32, U64 (U pour unsigned) non
bleu
sign sur 8, 16, 32 ou 64 bits
I8, I16, I32, I64 (I pour integer) sign sur 8, 16, 32 ou 64 bits
Valeur numre, correspond des entiers de 0 n-1 (n tant le
bleu
nombre de valeurs du type)

orange

Nombre flottant (norme IEEE 764) : SGL (simple prcision,

code sur 32 bits), DBL (double prcision code sur 64 bits),
EXT (prcision tendue dpendant de la plateforme)

17

Boolan : prend les valeurs T (true vrai) ou F (false faux)

vert
Chane de caractres
rose

violet

Variant : reprsentation de nimporte quel type, sous forme des

octets de donnes correspondant et dun identifiant de type.
Toute donne dun type donn peut tre transforme en variant.
Le variant pourra tre re-transform en son type initial,
condition de connatre le type initial.
Date.

marron
Figure 14 : types de base

On peut remarquer que lorsquon cre un numrique, on ne contrle pas son type : il
sagit gnralement dun flottant double prcision quand on cre une commande ou un
indicateur sur la face-avant, et dun entier sign sur 32 bits lorsque lon place une constante.
On doit alors faire un click droit sur llment, et choisir le menu Reprsentation pour
changer son type en un autre type numrique (voir Figure 15).

Figure 15 : changement de reprsentations pour un numrique

Lorsque lon connecte deux terminaux de type diffrent mais compatibles

(typiquement, deux numriques), le flot entrant va sadapter automatiquement au type de
donne du connecteur. Cela sappelle une coercion de type. LabVIEW montre graphiquement
les coercions laide dun point rouge (dans les versions antrieures de LabVIEW il tait gris)
au niveau du connecteur. La Figure 16 montre une coercion : pour sadapter la
18

multiplication, la donne venant de C , qui est un entier, est convertie en flottant double
prcision (type le plus large de lopration).
coercion
Flottant DBL

Entier I32
Flottant DBL
Figure 16 : coercion de type

4.2.3.2 Types composs

Les types peuvent tre composs en utilisant des constructeurs : le cluster et le
tableau.

4.2.3.2.1 Cluster
Le cluster correspond un type enregistrement (nomm record ou struct dans dautres
langages de programmation). Il sagit de grouper dans une seule donne diffrentes donnes
(appeles champs) pouvant tre de type diffrent. Lun des clusters qui est trs souvent utilis
est le cluster derreur. En effet LabVIEW utilise 3 valeurs pour caractriser une erreur :
un boolen status vrai si une erreur a eu lieu, faux sinon,
un entier code donnant le numro derreur, permettant dobtenir de plus amples
informations sur lerreur,
une chane de caractre source contenant gnralement le nom du vi dans lequel
lerreur sest produite.
La Figure 17 montre une utilisation typique du cluster derreur, et par cet exemple la
faon dont on extrait un champ dun cluster. Un fichier est ouvert ou cr, et son contenu est
remplac par le texte test . Ensuite le fichier est ferm. Tout ceci sil ny a pas eu derreur :
en effet, il y a de multiples possibilits derreurs lors de louverture, de lcriture, de la
fermeture : le fichier nest pas accessible, lutilisateur annule le choix du nom de fichier,
droits insuffisants pour modifier le fichier, dconnexion du rseau si le fichier est sur le
rseau, etc. Ainsi, si par exemple, louverture du fichier (premier vi de la chane de traitement)
dclenche une erreur, lcriture et la fermeture ne doivent rien faire puisque le fichier na pas
t ouvert. Cest le cas puisque les vi de LabVIEW ayant une entre Entre derreur
fonctionnent de la faon suivante : si il y a erreur, ne rien faire et propager lerreur (i.e.
recopier lentre derreur sur la sortie derreur). Sinon, faire le traitement, mais si erreur il y a
lenvoyer sur la sortie derreur, dans le cas contraire (aucune erreur en entre, aucune erreur
lors du traitement) renvoyer pas derreur (i.e. le champ status est la valeur faux) sur la
sortie derreur.

Figure 17 : utilisation typique du cluster derreur

19

Pour ceux qui connaissent dautres langages de programmation, ce type de gestion

derreurs peut paratre nouveau. En effet, dans les langages bass sur C, il est frquent davoir
tester la valeur de retour derreur aprs chaque action, afin dinterrompre la chane de
traitement. En Ada ou dans dautres langages proposant les exceptions (Java, C++) le
traitement est interrompu par une exception et un bloc traite exception peut alors tre excut.
Le traitement des erreurs propos par LabVIEW est moins poussant que les exceptions, mais
plus pratique quun traitement la C.
On peut noter sur la Figure 17 la faon dont on extrait le champ boolen status du
cluster derreur : celui-ci est faux si et seulement si aucune erreur na eu lieu pendant le
traitement. Sa ngation est donc vrai si et seulement si il ny a pas eu derreur, et allume une
LED place sur la face-avant. On utilise pour extraire le champ qui nous intresse le nud
Dsassembler par nom trouv dans la palette Cluster . Le vi Dsassembler par nom ,
ainsi que les autres vi permettant dassembler ou de dsassembler les cluster sont
redimensionnables (en terme de nombre dentres/ou de sorties).
Noter aussi que le fait que les vi de la chane de traitement dpendent de leurs
prdcesseur (dpendance en terme de flots de donnes) implique un squencement des
actions : ouvrir puis crire puis fermer puis afficher la LED.
La cration dun cluster se fait laide d assembler (voir Figure 18) ou
Assembler par nom (voir Figure 19). Lavantage d Assembler par nom est la lecture
trs claire que lon pourra faire lorsque lon dsassemblera. Cependant, Assembler par
nom ncessite de donner un cluster du mme type que celui que lon veut assembler en
entre ( entre derreur sur lexemple donn sur la Figure 19).

Figure 18 : cration dun cluster laide d Assembler

Figure 19 : cration dun cluster laide d Assembler par nom

20

Bien que les exemples donns portent sur le cluster derreur (cest bien souvent le
premier cluster manipul), on peut assembler nimporte quelles donnes dans un cluster.
LabVIEW est trs souple quant lutilisation de clusters. Ainsi, lorsque des clusters ne sont
composs que de numriques, ils gardent la proprit numrique. Les oprations
arithmtiques sont alors possibles sur le cluster. Ainsi, sur la Figure 20, on additionne
directement deux clusters. Noter que les clusters numriques ont une couleur marron, alors
que les clusters non numriques (comme le cluster derreur) ont une couleur tirant vers le
kaki.

Figure 20 : opration arithmtique sur cluster (addition de 2 clusters)

Il est aussi possible deffectuer une opration cluster/variable numrique (voir Figure
21) : dans ce cas, en ralit, une coercion du numrique est effectue et cest le mme type
dopration que sur la Figure 20.

Coercion en cluster 23|23,0

Figure 21 : opration arithmtique sur cluster (cluster plus scalaire)

4.2.3.2.2 Tableaux
Les tableaux regroupent un nombre variable dlments du mme type sur 1 ou
plusieurs dimensions. Toutes les oprations de manipulation des tableaux se trouvent dans la
Taille dun tableau . Notons que
palette tableau. La taille dun tableau est donne par
ce vi est polymorphe : il peut avoir nimporte quel tableau en entre (quel que soit le type des
lments contenus) 1 ou plusieurs dimensions. Si le tableau en entre a une dimension,
Taille dun tableau renvoie un entier (nombre dlments du tableau) alors que sil
possde plusieurs dimensions, il renvoie un tableau dentiers (1 entier par dimension, donnant
sa taille).
Les tableaux sont indexs de 0 taille_dimension-1 pour chaque dimension.
Ainsi, pour obtenir le 1er lment dun tableau 1 dimension, on utilise
Indexer un
tableau en demandant llment dindex 0. Notons que ce vi change dapparence en fonction
de la dimension du tableau donn en entre. Ainsi, pour un tableau 2 dimensions, son
, ce qui permet de donner lindice de la 1re et de la 2nde dimension. Si lon
apparence est
ne donne en entre que lindice de la 1re dimension, alors LabVIEW comprend que lon veut
accder au tableau. Cela est gnralisable un tableau de dimension n : si lon donne
uniquement la 1re valeur dindice (ou rien, ce qui quivaut entrer la valeur 0), on obtient le
tableau n-1 dimensions contenu cet indice.

21

En LabVIEW, labsence de valeur nexiste pas : si un flot est suppos sortir dun vi,
alors il y aura une valeur sur le flot. Pour les tableaux, cela signifie quaccder un tableau
dlments de type T au-del de la taille du tableau (aprs lindice taille_dimension-1), une
valeur sera tout de mme renvoye par Indexer un tableau . Cette valeur sera la valeur par
dfaut du type (par exemple, 0 pour un numrique, tableau vide si cest un tableau, etc.).
Un flot de donnes de type tableau est reprsent en fil pais (pour un tableau
unidimensionnel) et en double pour un tableau multidimensionnel. La couleur de base du trait
est celle du type dlment du tableau (exemple : orange pais signifie tableau 1 dimension
de nombres flottants).
Exercice d'application 3 : comprendre le fonctionnement des tableaux, voir la correspondance avec un
fichier tableur. Prendre conscience des problmes de localisation du sparateur dcimal (utilisation du
. ou de la , comme sparateur dcimal dans le tableur). Comprendre la faon dont LabVIEW gre
les noms de fichier et les vi de manipulation de noms de fichiers.

A faire : lancer une application tableur (MS Office, Ou StarOffice), et crer une feuille de
calcul avec 2 colonnes de nombres rels, qui sera enregistre sous le nom essai tableau 1.csv.
Le but du vi est dafficher sur un indicateur combien il y a de lignes et de colonnes, et
dafficher la moyenne des nombres de la 1re colonne.
Pour la lecture, on utilisera Lire un fichier tableur . Attention, peut entraner le remplissage
du tableau par ligne ou par colonne. Utiliser laide dtaille pour ce vi. Pour trouver un vi de
calcul de moyenne, utiliser la fonction rechercher de la palette de fonctions.
Lorsque le traitement fonctionne, essayer de mettre le nom du fichier tableur utilis en entre
sous la forme dune constante : il sagit dexprimer dans le diagramme que le fichier tableur
sappelle essai tableau 1.csv et se trouve dans le mme rpertoire que le vi (quil conviendra
donc denregistrer au mme endroit).
Remarque : le vi Lire un fichier tableur est polymorphe. En effet, il peut lire des
flottants (Double), des entiers, ou des chanes de caractres dans le fichier et ainsi slectionner
le type de donnes fournies en sortie (le tableau bidimensionnel de valeurs). Certains vi
polymorphes comprennent la forme quils doivent choisir grce leur entre (cest le cas par
exemple d indexer un tableau ), dautres, au contraire, ne peuvent la dterminer partir de
leur entre. Avant la version 8 de LabVIEW, il fallait faire un click droit sur un tel vi
polymorphe afin de trouver le menu et de slectionner la forme utiliser. Depuis la version 8,
le polymorphisme dun tel vi se traduit par un petit menu droulant se situant sous licne
(voir ).

Montre que le vi est polymorphe

Choisit la forme voulue
Figure 22 : un vi polymorphe ne pouvant dfinir sa forme partir du type de ses entres

4.2.3.2.3 Waveforms
Le type waveform est un type correspondant un cluster possdant un champ date
(absolue ou relative) t0, un champ flottant reprsentant lintervalle de temps dt sparant
chaque valeur, et un tableau de valeurs relles Y. Dans les versions rcentes de LabVIEW, un
champ additionnel de type variant permet certains priphriques dajouter des donnes
spcifiques. Nous verrons les waveforms lors de la partie acquisition de donnes. A notre

22

niveau actuel, ce qui est intressant est de voir que LabVIEW utilise lui-mme des types
composs qui pourront, comme les types de base, tre utiliss pour vrifier la cohrence du
diagramme.

4.2.3.2.4 Types strictes

A linstar du waveform de LabVIEW, le programmeur peut lui aussi crer ses types de
la mme faon que lon cre des types dans des langages de programmation autres. Nous nen
parlerons pas en dtail lors de cette formation.

4.2.3.2.5 Classes
La version 8 de LabVIEW a apport une rvolution attendue depuis longtemps par
nombre de programmeurs LabVIEW. Il sagit de la notion de classes. Il est possible de dfinir
un type comme tant une classe (on peut voir cela comme une sorte de cluster avec des
champs). On dfinit ensuite des mthodes comme des vis qui permettent de manipuler ce type.
Le type nest accessible que par les mthodes donnes, ce qui permet de contrler la faon
dont les variables de ce type (les objets) seront manipules. On parle de programmation objet.
Lavantage de la programmation objet est la notion dhritage et de polymorphisme de classe.
Illustrons le concept dhritage par un exemple : supposons quon dfinisse une classe
vhicule, avec un certains nombre dattributs (en fait les champs du cluster utilis pour
reprsenter un vhicule) et de mthodes (calculer le poids, le nombre de roues, etc.). On peut
crer une classe automobile et une classe avion qui hritent de la classe vhicule : il est alors
inutile dans chacune de ces classes de redfinir les attributs prsents dans vhicule puisquils
sont hrits de la classe mre. Les mthodes peuvent tre redfinies si besoin est, ou tout
simplement hrites de la classe vhicule. Des attributs et mthodes spcifiques un avion ou
une voiture seront ajouts. Le polymorphisme de classe consiste alors pouvoir dfinir des vi
prenant un vhicule en entre : lexcution, on pourra en fait passer une automobile en
entre, ou bien un avion, puisque tout ce qui existe, tout ce dont on pourrait avoir besoin, est
dfini sur ces classes. On peut donc passer indiffremment un vhicule, une automobile ou un
avion, ou tout classe qui hrite de vhicule la place du vhicule : do le polymorphisme.
Nous ne parlerons pas de programmation objet pendant cette formation, mais le lecteur
intress est invit lire la documentation et regarder les exemples fournis dans LabVIEW 8.

4.2.4 Encapsulation (notion de sous-programme)

Les vi que nous avons utiliss jusqu prsent ont un point commun : ils possdent un
certain nombre dentres, et un certain nombre de sorties, on un nom, une icne illustrant leur
fonction, et une documentation. Cette partie montre comment crer un sous-programme, lui
donner un nom, une icne et le documenter. Pour cela, nous prendrons un exemple de
gnrateur alatoire.
Exercice d'application 4 : manipuler les types de donnes, rechercher des vis, raliser un test unitaire

A faire : rechercher les vi existant dans LabVIEW concernant le mot alatoire . Cette
fonction gnre un nombre pseudo-alatoire uniforme sous forme dun flottant compris entre
0 et 1. Nous souhaitons crer un gnrateur alatoire qui prend en entre deux nombres entiers
I32 que nous appellerons min et max, et gnre un nombre pseudo-alatoire uniforme sur
lintervalle [min..max].
La formule mathmatique utiliser est :
nombre_alatoire = arrondi(nombre_aleatoire_entre_0_et_1*(max-min) )+ min
Sauvegarder le vi obtenu sous le nom Alatoire.vi (pas indispensable, mais toujours
bon).
Faire des tests avec diffrentes valeurs : min et max positifs, ngatifs, min positif, max
ngatif, min=max, max>min
23

Remarque : le but est de transformer ce vi tel quil soit utilisable en sous-vi, il serait donc
superflu de travailler outre mesure sur lapparence de la face-avant.

4.2.4.1 Etape indispensable : crer les connecteurs

Il ny a quune tape indispensable la cration dun sous-vi (bien que 2 autres tapes
soient fortement conseilles) : la cration des connecteurs du vi. Il sagit en effet de dfinir par
quel biais un vi utilisant notre sous-vi lui passera les donnes dentres, et obtiendra les
donnes de sorties. Le plus souvent, les donnes dentres sont les commandes dfinies sur la
face-avant (dans notre exemple, min et max), et les donnes de sortie correspondent le plus
souvent aux indicateurs de la face-avant (pour notre exemple, le rsultat).
Pour cela :
se placer sur la face-avant,
faire un click droit sur licne, choisir Visualiser le connecteur (voir Figure 23),
licne est alors remplac par les connecteurs (vierges au dbut) du vi (voir Figure 24),

Figure 23 : visualiser le connecteur

Figure 24 : connecteur dun vi

le cas chant choisir un autre modle de connecteur (plus ou moins dentres et

sorties), se souvenir que par convention, les entres sont gauche, les sorties droite,
pour cela faire un click droit sur licne/connecteur et choisir dans Modles le
modle de connecteur adquat. Remarque importante : lorsque le sous-vi est utilis par
dautres vi, il est ennuyeux de changer de modle de connecteur, donc il vaut mieux
prvoir (sauf si lon est absolument sr de ne pas avoir ajouter dentres ou sorties
par la suite) plus dentres et sorties que celles quon utilise. Pour notre exemple, ce ne
sera pas le cas : on peut donc choisir un modle 2 entres et une sortie,
il reste relier les commandes et indicateurs de la face-avant avec les connecteurs :
pour chacun, faire un click sur un connecteur libre, puis un click sur llment de face
avant correspondant : la couleur correspondant au type de la commande ou du
connecteur apparat dans le connecteur, montrant quils sont lis.

24

A partir dici, le vi peut tre utilis en tant que sous-vi. Cependant, il est fortement
conseill de lui donner une icne et une documentation.
Exercice d'application 5 : rendre un vi utilisable en tant que sous-vi

A faire : diter les connecteurs d Alatoire.vi , et les rendre obligatoires.

4.2.4.2 Etape conseille : crer une icne personnalise

LabVIEW permet dutiliser un petit outil de dessin dicnes. Pour cela, il faut faire un
click droit sur licne, et choisir Editer licne . Cet outil est malheureusement peu
puissant et peu intuitif (voir Figure 25).

Entre de texte
Couleurs courantes
davant et darrire plan

Slectionner pour diter licne en 256 couleurs

Figure 25 : dition dicne

Commencer par diter licne en 256 couleurs. Un conseil : on peut utiliser le

copier/coller, donc ce qui donne de bons rsultats en peu de temps consiste sinspirer
dicnes existantes et les modifier. Ainsi, pour notre vi, on pourrait copier licne du
gnrateur alatoire de LabVIEW : le truc consiste slectionner le vi dans le diagramme,
faire Edition Copier ou bien Ctrl-C, puis douvrir un diteur dimages (Paint par
exemple), de Coller dans lditeur dimage puis de copier cela partir de lditeur dimages.
Enfin, douvrir lditeur dicne, et de coller limage. En rsum, cela donne copier licne du
diagramme, coller dans lditeur dimages, copier partir de lditeur dimages, coller dans
lditeur dicnes de LabVIEW Vous vous demandez sans doutes pourquoi le copier/coller
du diagramme vers lditeur dicnes ne fonctionne pas Moi aussi (en ralit il y a une
explication un peu complexe due au type dlment prsent dans le presse-papier, qui nest
pas exactement une image quand on copie partir du diagramme LabVIEW, alors que cest
exactement une image lorsquon copie partir de lditeur dimage)
Noter que le style de texte courant (taille, alignement, police) peut tre modifi en
double-cliquant sur le bouton Entre de texte .
Lorsque licne est satisfaisante, on peut lutiliser aussi pour le mode 16 couleurs et le
mode noir et blanc. Ces icnes seront utilises dans le cas o le vi est visualis sur un cran ne
disposant que de 16 couleurs ou tant noir et blanc. Pour cela, il suffit de cliquer sur 16
couleurs puis Copier partir de 256 couleurs . Licne 256 couleurs est alors recopi
avec une diminution du nombre de couleurs dans 16 couleurs . Procder de la mme faon
pour licne noir et blanc.
Voil, licne, qui est l pour suggrer la fonction du vi, est cre : voici la mienne
Exercice d'application 6 : crer licne dun vi

25

A faire : crer licne du vi Alatoire.vi .

4.2.4.3 Etape conseille : crer une documentation

Lorsquon passe la souris sur licne du vi, on peut voir sa documentation par dfaut
dans la fentre daide contextuelle (voir Figure 26).

Figure 26 : documentation par dfaut dun vi

Une petite description supplmentaire est la bienvenue. Par exemple, au laboratoire,

on appelle cela une spcification et au minimum, cela a la forme suivante :
Ncessite : nant (cela pourrait tre max>min>=0)
Entrane : Valeur alatoire est une valeur alatoire dans lintervalle [min..max] tire de
faon uniforme.
Pour entrer cette documentation, faire un click droit sur licne du vi, et choisir
Proprits du VI , pour la catgorie, choisir Documentation , et entrer le texte. A partir
de maintenant, passer la souris sur notre icne (en particulier quand il est utilis en tant que
sous-vi) affichera une aide contextuelle trs utile (voir Figure 27).

Figure 27 : documentation dun vi

Exercice d'application 7 : crer la documentation dun vi

A faire : crer la documentation du vi Alatoire.vi .

4.2.4.4 Utiliser un sous-vi personnel dans un vi

Il y a diffrentes faons de placer licne dun sous-vi dans le diagramme dun autre
vi :

utiliser loutil flche de la souris pour dplacer (glisser-dposer) licne du vi dans un

autre diagramme,
prendre le fichier (par exemple Alatoire.vi ) dans lexplorateur de fichiers et faire
un glisser-dposer sur le diagramme,
dans le diagramme, utiliser la palette de fonctions et choisir Slectionner un vi ,
bien entendu, faire un copier-coller du vi dans un diagramme fonctionne aussi.

26

Notons au passage que LabVIEW nautorise pas la rcursivit, ainsi un vi ne peut sappeler
lui-mme. Il existe des moyens dtourns mais assez complexes de contourner cette
limitation.
Il peut tre intressant, lorsquon utilise souvent certains vi personnels, de les avoir toujours
porte de main. On pourrait ainsi les placer dans la palette de fonctions. On peut personnaliser
de deux faons la palette de fonctions :
la faon la plus simple consiste faire apparatre son vi dans la palette Bibliothques
utilisateur . Pour ce faire, il suffit denregistrer son vi dans le dossier user.lib de
LabVIEW (LabVIEW se trouve gnralement, sous Windows, lemplacement
C:\Program Files\National Instruments\LabVIEWx.y o x.y est la version (en ce
moment 8.2). Noter quil faut pour cela avoir les permissions dcriture dans ce
dossier. LabVIEW doit tre redmarr pour que la palette soit mise jour, et prsente
les vi prsents dans ce dossier (voir Figure 28).

Figure 28 : dposer un vi dans user.lib le fait apparatre dans la palette Bibliothque utilisateur

une seconde manire, plus avanc (niveau expert) est utilise lorsque lon a cr
compltement une bibliothque. Elle consiste regrouper sa bibliothque dans une
arborescence de dossiers. Le dossier racine de cette arborescence est alors mis dans le
dossier vi.lib\addons du dossier de LabVIEW. Ensuite, on pourra utiliser ldition
de menus pour personnaliser le rsultat.
Par consquent, en gnral, on se contente de dposer les vi personnels dans user.lib
jusqu ce quon ait se poser la question de crer une bibliothque personnelle lorsque la
Bibliothque utilisateur contient trop de vi.
Exercice d'application 8 : connatre larborescence des fichiers LabVIEW

A faire : trouver le dossier LabVIEW avec lexplorateur de fichiers. Regarder ce qui se trouve
dans user.lib , et dans vi.lib .

27

4.2.5 Structures de contrle

Tout langage de programmation propose des structures de contrle : lalternative
(structure conditionnelle), des boucles nombre ditration connue (boucle Pour), et des
boucles conditionnes par une condition darrt (rpter jusqu/rpter tant que).
LabVIEW propose ces structures de contrle, mais il est important de noter quil ne propose
pas de boucle de type while (Faire tant que ). La structure de contrle inhrente la
programmation flot de donnes est la squence, dont nous avons parl auparavant.
Toutes les structures de contrle se trouvent dans la palette Programmation
Structures .
Afin dillustrer et dutiliser ces structures de contrle, nous crerons un petit jeu de
hasard au fil des explications, qui utilisera le gnrateur pseudo-alatoire fait en section 4.2.4.

4.2.5.1 La structure conditionnelle

La structure conditionnelle peut correspondre un if then else ou bien un
case is.

4.2.5.1.1 La structure de choix if/then/else

La Figure 29 montre une structure de choix de type if/then/else. Dans un langage de
programmation textuel, cela correspondrait (avec || oprateur faire en parallle) :
Saisir A || Saisir B
Si A = B alors
Txt "A et B sont gaux"
Sinon
Txt "A et B sont diffrents"
Fin si
Afficher Txt
LabVIEW reprsente lalternative laide de plusieurs diagrammes alternatifs (ici le
diagramme pour le cas vrai sera excut quand le boolen entre sur le ? est vrai, alors que
celui du cas faux sera excut quand ce boolen est faux).
Important :
Cest le type de la donne arrivant sur la condition ( ? ) qui fait que lon a un
if/then/else dans le cas o ce type est boolen,
on peut faire entrer nimporte quelle donne dans cette structure,
si une donne sort, alors elle doit avoir une valeur quel que soit le cas (ici, une chane
de caractres sort de la structure : on lui a donn une valeur dans le cas vrai, et une
valeur dans le cas faux), si un cas ne donne pas de valeur une sortie (voir Figure 30)
cest une erreur de syntaxe. Notons quen sortie dune structure de contrle, le
carr sappelle un tunnel. Lerreur de syntaxe associe sappelle il manque un
lment reli au tunnel ,
toute structure est considre comme un nud (comme si ctait un sous-vi) avec des
entres et des sorties : le nud devient excutable quand toutes ses entres sont
disponibles, et ses sorties sont gnres quand lexcution du nud (donc de tout ce
quil contient) est termine. Ainsi, sur la Figure 31, lexcution de la structure
conditionnelle ne se fait que lorsque toutes les valeurs en entre sont disponibles, c'est-dire aprs excution parallle de Saisir A||Saisir B||Attendre 3 secondes. Dans ce
cas, la structure conditionnelle ne sexcutera au mieux que 3 secondes aprs le
lancement. Noter quon peut utiliser si on le souhaite toute valeur donne en entre (y
compris la valeur cble sur ? considre elle aussi comme un entre).

28

Cas visualis
(ici cas o le boolen en entre est vrai)

Condition du test
(ici boolen => if/then/else)

Une sortie doit prendre une valeur

dans tous les cas

Cliquer ici permet de visualiser

les autres cas

Figure 29 : la structure de choix avec une condition boolenne en entre est un if/then/else

Cette couleur (blanc lintrieur) indique que cette sortie

na pas de valeur dans tous les cas: erreur syntaxique
Figure 30 : erreur de syntaxe typique dans une structure conditionnelle : un cas ne donne pas de valeur
une sortie

29

Figure 31 : une structure est comme tout nud LabVIEW, elle ne sexcute que lorsque toutes ses entres
sont disponibles
Exercice d'application 9 : crer une structure conditionnelle, utiliser Animer lexcution

A faire : implmenter le vi donn sur la Figure 31, excuter en mode Animer lexcution .
Les valeurs de A et B sont-elles lues ds le dbut, ou aprs 3 secondes ?
Exercice d'application 10 : utiliser une structure conditionnelle, utiliser un sous-vi personnel, utiliser une
bote de dialogue

A faire : crer un nouveau vi utilisant Alatoire.vi . Il doit implmenter le code suivant :

Saisir entier Proposition||Tirer un nombre alatoire entre 1 et 12
Si ces entiers sont gaux alors
Text "Vous avez gagn"
Sinon
Text "Vous avez perdu"
Fin si
Afficher Text dans une bote de dialogue
Pour la bote de dialogue on utilisera la fonction de recherche de la palette de fonctions.

4.2.5.1.2 La structure choix multiple

La seconde forme dutilisation de la structure de choix est la structure choix
multiple. La seule diffrence par rapport la structure conditionnelle est le type de donne
cbl en entre : cela peut tre un type scalaire (numrique, type numr, chane de
caractres). Sur la Figure 32, on a plac une chane de caractres en entre de la structure, elle
fonctionne donc comme une structure de choix, noter quil y a alors un cas Par dfaut qui
sera le cas choisi si aucune des autres conditions nest satisfaite. Pour ajouter/enlever des
conditions ou bien dfinir la condition par dfaut, il suffit de faire un click droit au niveau des
choix (en haut de la structure).

30

Figure 32 : une structure choix multiple

4.2.5.2 La boucle For

La boucle For (boucle pour) correspond en langage de programmation textuelle
Pour i de 0 N-1 faire Ainsi, sur la Figure 33, on peut voir le dcompte N du nombre
ditrations de la boucle, et lindice ditration i donnant le numro ditration en cours
(variant de 0 N-1).

31

Nombre ditrations

Indexation automatique, la sortie sera

un tableau {0,1,2}

Pas dindexation: la valeur sortie est celle

de la dernire itration: 2

Indice de litration en cours (varie de 0 N-1)

Figure 33 : une boucle For

4.2.5.2.1 Indexation ou non des sorties

Le diagramme contenu dans une boucle est excut N fois, et les sorties ne sont
gnres qu la terminaison de la boucle, c'est--dire la fin de la 3me itration pour
lexemple donn ici. On a le choix entre indexer une sortie (chaque lment obtenu chaque
itration est mis dans un tableau, la fin de lexcution de la boucle, cest donc le tableau de
tous les lments calculs qui sort de la boucle) et ne pas indexer une sortie (dans ce cas, la
valeur sortie est la dernire valeur calcule, i.e. celle obtenue lors de la dernire itration).
Graphiquement, le diagramme reprsente le tunnel de sortie indexe avec des crochets []alors
quune sortie non indexe est reprsente par un tunnel (carr) plein. Pour changer le mode
dun tunnel (quil soit en entre ou en sortie) dindex non index, faire un click droit sur le
tunnel (voir Figure 34).

Figure 34 : activer/dsactiver lindexation

Exercice d'application 11 : comprendre le fonctionnement dune boucle For

A faire : implmenter le vi donn sur la Figure 33, excuter en mode Animer lexcution :
constater que les valeurs ne sortent de la boucle qu la fin de son excution.

4.2.5.2.2 Indexation des entres

De la mme faon, les entres peuvent tre automatiquement indexes : ainsi, si un
tableau de dimension n est index en entre dune boucle, cest un tableau de dimension n-1
quon retrouve lintrieur de la boucle : litration i, la valeur dentre est le ime lment
du tableau index en entre. Ainsi, sur la Figure 35, chaque itration i de la boucle, le ime
lment du tableau donn en entre est utilis. Noter que dans le cas o un tableau seul est
donn en entre dune boucle For, il nest pas ncessaire de cbler le nombre ditrations
N : LabVIEW comprend alors que la boucle consiste indexer tout le tableau (donc
implicitement, N est la taille du tableau index en entre). Dans notre exemple, chaque
itration on prend un lment du tableau, auquel on ajoute 5, puis on le met en indexation en

32

sortie. A la fin de la boucle, le tableau de sortie contient chaque lment du tableau dentre
auquel on a ajout 5.

Figure 35 : indexation automatique dun tableau en entre

Notons que lexemple donn ici est stupide puisque LabVIEW autorise les oprations
arithmtiques entre scalaires et tableaux (on peut donc directement ajouter 5 un tableau).
Exercice d'application 12 : utiliser une boucle For

A faire : prendre le vi de lExercice d'application 10. Le modifier afin de tirer 3 fois un

nombre alatoire, chaque tirage est espac d1 seconde, et affich. Le dernier tirage est alors
celui compar au nombre donn par lutilisateur.

4.2.5.2.3 Registre dcalage

Daprs la philosophie flots de donnes, il ne peut y avoir aucun cycle dans le flot : en
effet, puisquun nud ne sexcute que lorsque toutes ses entres sont disponibles, et ne
fournit ses sorties quaprs avoir t excut, un diagramme contenant un cycle ne serait pas
excutable. Cependant, supposons que lon souhaite calculer la moyenne des lments dun
tableau (bien entendu, on pourrait utiliser un vi de calcul de moyenne, mais nous supposerons
que nous voulons programmer cela). Dans un langage textuel, on crirait :
Moyenne 0
Pour i de 0 taille(tableau)-1 faire
Moyenne ((Moyenne * i)+tableau[i])/(i+1)
Afficher Moyenne
Fait
Si on souhaite exprimer le fait que la moyenne litration i-1 est la moyenne utilise
litration i comme on souhaiterait le faire sur la Figure 36, on commet une erreur syntaxique
puisquon cre un cycle. Cest une erreur de syntaxe, certes, mais ce nest pas une erreur de
raisonnement : en effet, nous nexprimons pas ainsi un cycle. Noublions pas quune boucle
correspond la reprsentation superpose dun diagramme qui doit tre excut plusieurs fois.

33

Si cela est exprim par un flot de donnes

Erreur de syntaxe

Figure 36 : la rtroaction dans une boucle ne peut se faire via un flot de donnes classique

En ralit, ce que nous souhaitons reprsenter correspond la vue qui est donne sur la
Figure 37. Il ny a pas de cycle : le calcul dune itration est donn en entre de la suivante,
comme si le tunnel de sortie de litration tait reli au tunnel dentre de lautre. Cependant,
un tunnel ne sort pas de valeur aux la fin de chaque itration mais uniquement la fin de la
dernire itration.
1er lment

dernier lment

2me lment

N-1

Figure 37 : reprsentation figure dune boucle droule

LabVIEW offre pour pallier cela le registre dcalage. Sous ce nom barbare ne se
cache que relier la sortie dune itration lentre de la suivante . Dun point de vue
pratique, il suffit pour crer un registre dcalage de faire un click droit sur le tunnel quon
souhaite transformer en registre dcalage et de choisir Remplacer par un registre
dcalage . On est alors amen dsigner le tunnel correspondant (lentre si on a remplac la
sortie par un registre dcalage, la sortie si on a remplac lentre). Le vi correct de calcul de
moyenne est donn sur la Figure 38.

34

Figure 38 : utilisation dun registre dcalage

Notons au passage que le 0 en entre du registre dcalage donne sa valeur initiale, et que la
valeur du registre en sortie de boucle est la dernire valeur calcule (comme si ctait un
tunnel classique). Il est important de toujours donner une valeur initiale un registre
dcalage (sauf dans certains cas spcifiques). En effet, si on ne donne pas de valeur initiale, le
comportement est le suivant : lorsque le registre na jamais pris de valeur auparavant, il prend
la valeur par dfaut du type comme valeur initiale. Par contre, si le vi est appel plusieurs fois,
sa valeur initiale est la dernire valeur inscrite (c'est--dire lors de lappel prcdent).
Exercice d'application 13 : manipuler un registre dcalage, et un nud de rtroaction

A faire : sinspirer du vi donn sur la Figure 38 pour vrifier que la moyenne du gnrateur
alatoire est bien au milieu de lintervalle min..max (faire 1000 itrations). Remplacer le
registre dcalage par un nud de rtroaction (cest juste une reprsentation alternative du
registre dcalage). Ensuite, afin davoir le temps de voir Moyenne courante converger,
temporiser la boucle. Le principe est le suivant : une itration ne peut avoir lieu avant que
litration prcdente ne soit termine, il suffit donc de ralentir lexcution dune itration en
mettant une attente (voir Figure 31) en parallle du reste de litration.

4.2.5.3 La boucle faire tant que/faire jusqu

Le second type de boucle est la boucle While (faire tant que ou faire jusqu).
Noter quil nexiste pas de boucle faire tant que , c'est--dire quen LabVIEW au moins une
itration dune telle boucle a lieu (on peut toujours utiliser une structure conditionnelle afin de
ne rien faire si la condition de boucle nest pas satisfaite). La plus typique des boucles tant
que est la boucle que lon trouve en gnral au niveau du programme lui-mme. En effet,
comme cela a t dit prcdemment, lexcution en continu dun vi est proscrire. Si lon
souhaite faire une excution en continu jusqu ce que lutilisateur souhaite arrter, alors
on place une boucle While comme sur la Figure 39. Cette figure met en vidence les deux
modes darrt possibles pour une boucle While : arrter sur une condition vraie, et continuer
sur une condition vraie. Typiquement, si on souhaite conditionner larrt lappui sur un
bouton stop , tant donn quun tel bouton renvoie faux quand il nest pas appuy, et vrai
sinon, la boucle doit sarrter lorsque le bouton renvoie vrai.

35

Numro ditration comme

pour la boucle For

Fonctionnement
identique

Figure 39 : un boucle While possde deux possibilits de programmer larrt

Exercice d'application 14 : crer une boucle While, comprendre le fonctionnement du tunnel dentre,
comprendre laction mcanique des boutons

A faire : Implmenter le vi de la Figure 39. Passer en mode Animer lexcution et tester

que larrt seffectue comme il faut. Sortir le bouton Stop de la boucle, et observer le
comportement. Quen dduisez-vous ?
Aller sur la face avant, faire un click droit sur le bouton, et tester les diffrentes actions
mcaniques possibles (toujours en mode Animer lexcution ).
Exercice d'application 15 : utiliser une boucle While, comprendre les problmes lis labsence de
squencement

A faire : Placer le contenu de lExercice d'application 12 dans une boucle While. La condition
darrt est donne par la rponse de lutilisateur une bote de dialogue 2 boutons lui
demandant sil souhaite recommencer. Le comportement nest pas le comportement attendu,
pourquoi ?

36

4.2.5.4 La squence
La structure squence sert dans des cas comme celui de lExercice d'application 15 :
lorsque lon souhaite obliger un certain ordre dans les actions, mais quil ny a pas moyen
dutiliser les flots de donnes pour le forcer.
LabVIEW propose 2 structures squence : lune empile, lautre droule. Il ny a pas
de diffrence smantique, mais uniquement des diffrences de reprsentation entre les 2. La
squence droule tant plus lisible, et plus simple dutilisation, je conseillerais de lutiliser
dans toute situation. Pour crer une telle squence, on place une premire tape de squence,
puis laide dun click droit sur le bord de celle-ci (voir Figure 40) on peut ajouter dautres
tapes. Lide est quune tape ne peut commencer avant que ltape prcdente ne soit
termine.

Figure 40 : cration dune structure squence droule

Exercice d'application 16 : utiliser une structure squence, utiliser un point darrt

A faire : modifier le vi de lExercice d'application 15 afin que laffichage de la bote de

dialogue demandant si lon veut continuer se fasse aprs quon ait affich le rsultat du tirage.
Placer un point darrt sur le cas vrai de la structure conditionnelle et excuter le vi (sans tre
en mode Animer lexcution ). Excuter quelques pas pas--pas .

4.3 Utilisation avance

Nous avons maintenant vu les lments de base de la programmation LabVIEW. Cette
partie propose de voir quelques graphes proposs par LabVIEW, la faon dont il gre les
fichiers, et surtout la faon dont on peut crer une interface graphique. Au passage, divers
autres lments de programmation seront abords.

4.3.1 Utilisation de graphes

Les 3 principaux types de graphe proposs par LabVIEW sont le graphe droulant
(affiche des courbes point par point), le graphe (affiche les courbes partir du/des tableaux
contenant tous les points), et le graphe XY (courbes paramtriques).

4.3.1.1 Graphe droulant

Le graphe droulant est un indicateur 2D reprsentant une courbe (ou plusieurs
courbes) dont les points sont donns point par point (i.e. on ne donne pas tous les points dune
courbe en une seule fois).

37

Figure 41 : un graphe droulant

La Figure 41 reprsente un graphe droulant : en abscisse le temps (par dfaut, mais

tous les lments peuvent tre dits), en ordonne, lamplitude. Le nom dune courbe par
dfaut est Trac 0 , 1, 2, etc. Mais bien entendu tout ceci peut tre modifi. Pour modifier
lapparence et le comportement dun graphe, on fait un click droit sur le graphe, ou sur le
trac concern. Ainsi, par exemple, on peut mettre une barre de dfilement (attention, on ne
peut dfiler que sur la longueur de lhistorique que lon a dfinie), le graphe peut se mettre
lchelle automatiquement (pour les X et les Y), etc. Etant donn quun graphe droulant
conserve son contenu, on peut leffacer en faisant click droit sur le graphe Oprations sur
les donnes Effacer le graphe droulant .
cluster

Figure 42 : graphe droulant multi-courbes

On peut afficher plusieurs courbes comme sur la Figure 42 en plaant les points de
chaque courbe afficher dans un cluster.
Exercice d'application 17 : crer un graphe droulant multicourbe, personnaliser laffichage

A faire : Implmenter le vi de la Figure 42. Afficher la barre de dfilement de laxe X,

configurer lhistorique 10000 valeurs, changer le style de courbes, et leur couleur, donner un
nom personnel aux courbes.

4.3.1.2 Graphe
Un graphe ncessite un tableau de points ou un waveform par courbe affiche. Sur la
Figure 43, on utilise un vi de la palette Traitement du signal Gnration de signaux
qui donne un tableau de flottants en sortie.

38

Figure 43 : un graphe

La gestion de plusieurs courbes peut tre faite en envoyant un tableau plusieurs

dimensions ( Concatner des tableaux prenant les diffrentes courbes afficher, voir ).

Figure 44 : un graphe multi-courbes

Exercice d'application 18 : crer un graphe, crer un histogramme

A faire : reprendre le vi de lExercice d'application 13, sortir le tableau des tirages de la

boucle, en faire un histogramme gnral (utiliser la recherche dans la palette de fonctions), et
afficher cet histogramme dans un graphe (on choisira bien entendu un trac de type
histogramme). Peut-on en dduire que le gnrateur alatoire fonctionne bien ?
Nous pouvons constater que les points sont supposs avoir un espacement dune unit
de temps sur laxe des X (temps), ce qui nest pas le cas lors de mesures. Trs souvent, les
mesures sont horodates, et la dure sparant 2 mesures est connue. Un groupe constitu dun
ensemble de points, dune date de dbut de mesure, et dune dure entre 2 mesures est
gnralement exprime sous forme de waveforms. La Figure 45 reprsente lutilisation dun
waveform, notez leffet sur le graphe, qui affiche alors des dates on non plus des units de
temps. Dans lexemple donn, chaque point est suppos tre distant dune seconde du
prcdent, avec le 1er point ayant liu la date courante. De nombreux vi dacquisition de
donnes donnent directement les mesures sous forme de waveforms.

39

Figure 45 : un graphe construit partir dun waveform

4.3.1.3 Graphe XY
Le graphe XY permet de tracer des courbes paramtriques. Pour ce faire, il faut
envoyer un cluster contenant les points pour X, et les points pour Y sur chaque composante
du cluster en entre du graphe (voir Figure 46).

Figure 46 : un graphe XY

Pour afficher plusieurs courbes, on placera les clusters de chaque courbe dans un
tableau quon envoie sur le graphe XY (voir Figure 47).

40

Figure 47 : un graphe XY multi-courbes

4.3.2 Gestion de fichiers

LabVIEW propose plusieurs niveaux de gestion de fichiers dans la palette et les souspalettes E/S sur fichiers . Dans nimporte quel langage de programmation, la gestion de
fichier ncessite les tapes suivantes :
Ouverture du fichier : pour cela il est ncessaire de connatre le nom du fichier pour
le systme (par exemple sous Windows c:\dossier\fichier.csv ). Il y a deux
possibilits daction : soit lon connat le nom du fichier au moment de louverture,
soit on ne le connat pas et on le demande lutilisateur en ouvrant une bote de
dialogue de slection du fichier. Lors de louverture, on doit choisir le mode
douverture parmi :
o Lecture seule
o Lecture/criture
o Ecriture seule
De mme, le fichier sil est inexistant peut tre cr, ou bien sil est existant, on
peut choisir de le remplacer, ou dajouter des choses la fin du fichier (append) ou
plus rarement de remplacer des octets contenus. Noter quon insre pas dans un
fichier : si lon souhaite insrer des donnes partir de loctet n, alors, on doit
ouvrir le fichier, se placer la position n, lire les donnes restantes, inscrire la
position n les donnes insrer suivies des donnes restantes (qui sont donc
rinscrite).
On peut noter quau plus un processus peut possder un droit dcriture sur un
fichier ouvert.
Aprs louverture, on dispose dun descripteur de fichier ou identificateur de
fichier ou rfrence de fichier. Ce descripteur est en gnral utilis pour toutes les
oprations suivantes (lecture/criture/fermeture). LabVIEW appelle cela un refnum.
Donc un refnum est obtenu aprs ouverture dun fichier, et est valide jusqu sa
fermeture.
Les oprations de lecture ou dcriture se font sur le refnum. En gnral, on
distingue 2 types de fichiers : les fichiers binaires et les fichiers textuels. Les fichiers
binaires sont par exemple des images, des vidos, des archives compresses (mais il
y a peu de chance que lon dite de tels fichiers sans utiliser des vi spcialiss dans
41

ces traitements) ou encore des donnes pures (par exemple, sauvegarde des donnes
dun programme sous forme de leur type). Les fichiers textuels reprsentent la
plupart des fichiers utiliss couramment (fichier .csv, fichier texte, fichier de
configuration, etc.).
A la fin, on ferme le fichier. Si lon souhaite lutiliser ultrieurement, il faudra le rouvrir afin dobtenir un nouveau refnum.
On retiendra donc quil y a 3 tapes lors de la gestion dun fichier : ouverture, lecture/criture,
fermeture. Etant donn que LabVIEW sadresse diffrents types de programmeur, de
nombreux vi cachent ces 3 tapes en les intgrant directement (cest le cas de celui que nous
avons utilis dans lExercice d'application 3). De plus, LabVIEW propose plus que les
fichiers binaires ou textuels afin de faciliter les oprations courantes de manipulation des
fichiers :
Fichier tableur : lecture/criture de/vers le format .csv
Fichier de configuration : manipulation de fichiers au format .ini (comme par exemple
c:\windows\win.ini). Ces fichiers sont assez typiques pour grer la configuration des
programmes, bien quon commence utiliser le format XML de plus en plus pour
cela. Voici un exemple de fichier de configuration :
; ceci est un commentaire
[General]
; entre crochet on nomme une section
Language = fr
; les valeurs sont donnes sous la forme cl = valeur
BackGroundColor = red
Font = Times
Fontsize = 12
[Graph]
HistorySize = 10000

Fichier de waveforms enregistrs au format binaire .tdms : permet de grer

simplement des fichiers de mesures. Format de fichier propritaire LabVIEW (le
format .tdm remplace dornavant le format .tdm).

Exercice d'application 19 : rechercher des exemples, utiliser un fichier .tdms

A faire : ouvrir la fentre de dmarrage LabVIEW et rechercher un exemple concernant les

fichiers .tdms (un exemple dcriture et un exemple de lecture). Lexcuter.
Fichier de waveforms enregistrs au format textuel .lvm : permet de grer simplement
des fichiers de mesures, de faon moins efficace quau format .tdms car tout est
converti au format texte. Ces fichiers sont cependant lisibles par un humain, ou un
tableur.
Fichier journal (datalog) : version de fichier binaire compatible avec des plateformes
simples (PocketPC). Manipulation similaire la manipulation de fichiers binaires.
Notons aussi lexistence dun module (toolkit) nomm Entreprise Connectivity qui
permet dutiliser des base de donnes (MS Access, MySql, DBase) et dy accder
via lODBC. Lutilisation est extrmement puissante mais require des connaissances
en bases de donnes (notamment le langage SQL).

4.3.2.1 Utilisation de fichiers textes

Afin dillustrer le fonctionnement dun fichier texte, et de comprendre les chanes de
format (communes beaucoup de langages bass sur le langage C), cette partie propose
dexplorer un peu le fonctionnement de la gestion de ces fichiers.
A partir dici, les fonctions de recherche de vi et dexemples doivent tre assimiles,
ce qui devrait faciliter dornavant la prsentation des exercices dapplication.
Exercice d'application 20 : manipuler un fichier texte, formater des chanes, convertir en chane

42

A faire : crer un vi possdant sur sa face avant les lments suivants :

- une entre chane de caractres c
- une entre flottant f
- une entre entier i
- une sortie chane de caractres c_sortie
- une sortie flottant f_sortie
- une sortie entier i_sortie
Le but est le suivant : enregistrer dans un fichier texte ces lments (donc transforms en
chanes de caractres, avec 8 chiffres aprs la virgule pour le flottant) puis de lire le fichier et
de les afficher.
Pour cela nous utiliserons 2 mthodes :
Mthode 1 : utilisation de chanes de format (utilisation de Formater dans un fichier ,
Balayer un fichier ). Pour les premiers essais, ne pas mettre despace dans c, puis tenter en
insrant des espaces. Modifier la chane de format pour insrer un retour chariot entre chaque
donne.
Mthode 2 : convertir les entres, puis concatner les chanes obtenues afin de les enregistrer.

4.3.2.2 Utilisation de fichiers binaires

Les fichiers binaires se comportent de la mme faon que les fichiers textes avec
lexception quils sont typs. Cela signifie que lorsquon crit des lments, LabVIEW
connat leur type et les transforme en octets (par exemple, un tableau dentiers I16 aura une
taille de 4 octets (taille du tableau)+2 octets (taille des lments)*nombre dlments).
A la lecture, il faut passer un lment du bon type LabVIEW afin quil sache
combien doctets il doit lire, et comment leur redonner leur type (voir ).

Figure 48 : utilisation de fichier binaire

4.3.2.3 Utilisation de fichiers pour grer une configuration

Dans ce paragraphe, nous verrons non seulement comment grer les fichiers de
configuration, mais aussi comment conserver une variable globale en utilisant quelque
chose de plus sr quune variable globale. De plus, nous utiliserons un projet, et la notion de
types stricts.
Nous supposons que nous travaillons sur une application qui risque de crotre en terme
de nombre de vi. Nous utiliserons donc un projet.
Nous supposons que nous avons une application, qui, lheure actuelle, possde des
paramtres que nous souhaitons conserver et lire dans un fichier .ini . Nous prendrons
comme paramtres le cluster compos de deux entiers et une couleur donn sur la Figure 49.

43

Figure 49 : cluster contenant des paramtres de configuration

Nous savons que ce cluster risque fortement dvoluer au cours du dveloppement de

lapplication (ajout de champs). De plus, il sera utilis dans beaucoup de vi et il est
inconcevable davoir tous les modifier si on le modifie. Nous allons donc dfinir un type. Si
nous sommes dans un projet, il faut pour cela crer une nouvelle commande (extension
.ctl ), comme sur la Figure 50.

Figure 50 : cration dune nouvelle commande dans un projet

Une commande ne possde quune face avant, et permet de crer des commandes
lallure personnalise. Elle permet aussi et surtout de crer des types : lorsquun type strict
est utilis dans un vi, que ce soit sous forme de constante, de commande ou dindicateur, il
sera mis jour si le type est modifi. Cest exactement ce que nous voulons. La Figure 51
montre la dfinition dun tel type.

44

Icne personnalise
(conseil: choisir une icne homogne
pour les types)

Dfinition de type strict

Figure 51 : dfinition dun type strict

Exercice d'application 21 : crer un type strict

A faire : crer un projet, et y crer le type strict de la Figure 51.

A diffrents endroits du programme, nous aurons lire la configuration, et la
modifier. Certains utiliseraient une variable globale pour y stocker la configuration.
Cependant, cela pose des problmes daccs concurrent (si une criture interrompt une
lecture, on peut lire des donnes inconsistante). Lune des mthodes est dutiliser une
proprit du registre dcalage. Une variable globale serait conserve dans un registre
dcalage. En effet, si il nest pas initialis, le registre dcalage contient la dernire valeur
inscrite (lors dun appel prcdent). La Figure 52 reprsente un vi permettant de lire ou
stocker la configuration (sans problme de concurrence puisque les vi sont non-rentrants par
dfaut). Remarquer que la boucle While sarrte immdiatement aprs sa premire instance
(valeur Faux connecte la condition darrt). Par consquent, elle nest l que pour servir de
support au registre dcalage. Le vi possde 2 entres : lune, Config in , optionnelle, tant
la configuration stocker dans le registre dcalage, lautre, Action , obligatoire, est
lopration effectuer : lire la configuration courante, ou bien la stocker (Ecrire). Noter quil
pourrait y avoir plus doprations (initialiser, appliquer, etc.) par consquent il est trs
conseill de crer un type strict pour Action .

Figure 52 : utilisation du registre dcalage la place dune variable globale

45

Dans tous les cas, la valeur actuelle est envoye sur Config out . Un autre avantage
de cette technique est quen ouvrant la face avant de ce vi lexcution, on peut voir son
contenu (valeur de Config out ).
Exercice d'application 22 : crer un vi non rentrant de stockage de valeur globale, utiliser un type strict

A faire : crer un type strict numr dans le projet, contenant les valeurs lire et crire. Utiliser
les deux types stricts crs pour implmenter le vi de la Figure 52 qui sera aussi intgr au
projet. Le transformer en sous-vi tel que Action est une entre ncessaire.
La Figure 53 montre lenregistrement de la configuration dans un fichier appli.ini se
trouvant dans le mme dossier que le vi. Remarquer lutilisation du vi de stoackage.

Figure 53 : enregistrement du fichier .ini

Le contenu du fichier ainsi cr est :

[Graph]
TailleHistorique=0
Couleur graphe=0
Taille police=0
Exercice d'application 23 : utiliser un vi non rentrant de stockage, utiliser un fichier .ini

A faire : Implmenter le vi donn sur la Figure 53, ainsi que le vi symtrique qui lit le fichier
appli.ini et, sil ny a pas derreur, crit la configuration dans le vi non-rentrant de stockage.
Notons que ce type de vi peut-tre utilis aussi pour faire communiquer deux parties parallles
dun programme : lun crirait des donnes, son rythme, et lautre les lierait. Cest ce type
de vi qui est utilis pour faire de la communication asynchrone.

4.3.3 Interface graphique

Cette partie se focalise sur la cration dinterfaces homme-machine (IHM) en
LabVIEW. La premire partie parle du traitement par scrutation et du traitement par
vnement des entres utilisateur. La seconde partie traite de la faon dont on cre des IHM
dynamiques laide des nuds de proprit.

4.3.3.1 Ractions aux vnements

Gnralement, lorsquon programme ses premires interfaces graphiques, on utilise de
la scrutation : il sagit, dans une boucle While, temporise (par exemple toutes les 100 ou 200
ms), de lire ltat des boutons/entres et de les traiter. Cela a pour effet de gaspiller pas mal de
temps processeur. Des IHM efficaces se basent sur le traitement des vnements utilisateur :
quand lutilisateur clique sur un lment dune application, ou bien bouge sa souris, ou tape
une touche, lapplication qui possde le focus se voit avertie par le systme dexploitation
grce un vnement. La programmation dIHM se basant sur les vnements utilise ce
principe : grce la structure vnement, LabVIEW peut les transmettre notre application.

46

Le moyen le plus simple de crer une IHM utilisant les vnements est dutiliser le
modle propos ( Fichier Nouveau puis choisir Application de haut niveau
utilisant les vnements ). Le vi obtenu est alors celui de la Figure 54.
Timeout

Evnement trait

Type de lvnement (ici valeur change)

Nombre de ms coules depuis le dmarrage de lordinateur

Rfrence de la commande ayant gnr lvnement (ici
rfrence du bouton stop)
Valeur avant et aprs lvnement

Bouton stop conditionnant larrt

de lapplication
Figure 54 : application de haut niveau utilisant les vnements

La boucle montre est la boucle principale de lapplication (on aura la mme boucle
pour une bote de dialogue). La structure vnement attend quun vnement pris en compte
arrive, le vi est donc bloqu en labsence dvnement. Si lon souhaite faire quelque chose
mme en labsence dvnement, on cblera le Timeout de sorte quau bout du nombre de
millisecondes en entre, lvnement timeout aura lieu.
On peut rcuprer tout vnement : click sur un bouton, dplacement de la souris,
fermeture de fentre, de lapplication, etc. On peut diter et ajouter des vnements traiter
partir dune bote de dialogue comme celle prsente sur la Figure 55.

47

Evnements grs
Par la condition

Une entre par lment

de face avant + temps

Mise en file dattente

des vnements arrivant
pendant un traitement
ou verouillage
Figure 55 : dition dun vnement

4.3.3.2 IHM dapplication / bote de dialogue

Auparavant, nous avons utilis des botes de dialogue standard dans lapplication du
jeu de hasard. Nous allons voir ici comment remplacer cela par une bote de dialogue
personnalise.
Une bote de dialogue (voir Figure 56) correspond un sous-vi de lapplication dont la
proprit d Apparence de la fentre est une bote de dialogue (ou encore avec les
proprits personnalises Afficher la face-avant lappel et Fermer aprs lexcution
coche, et surtout un comportement Modale ).
Attention, si une fentre est modale, elle est au-dessus de toute autre fentre de
lapplication et conserve le focus (i.e. les autres fentres de lapplication ne reoivent pas les
vnements). Par consquent lorsquon lance une application comportant des fentres
modales, il faut que celles-ci soient fermes avant lancement ou bien elles resteront modales
ds le lancement.

48

Figure 56 : personnalisation de lapparence dune fentre

Exercice d'application 24 : crer et personnaliser une bote de dialogue, grer une IHM par vnements

A faire : placer les vi Alatoire.vi et le programme de test que nous avions fait lors de
lExercice d'application 18 (celui avec lhistogramme) dans le projet cr pour grer des
configurations. Ajouter dans le projet un nouveau vi cr partir du modle Bote de
dialogue utilisant les vnements , et le modifier de sorte quil soit similaire la Figure 57.
Le fonctionnement sous-jacent doit tre pour Recharger de remettre la valeur de
Configuration la configuration courante ( laide du vi non rentrant). Lors de lappui
sur le bouton Ok , on modifie la configuration courante, et on lenregistre dans le fichier
.ini.
Remarque : Configuration tant une commande, on pourra le modifier en utilisant une
variable locale.

49

Fermeture dsactive

Type configuration (on peut

bien sr faire plus esthtique)

Figure 57 : face-avant de la bote de dialogue crer

4.3.3.3 Interface graphique dynamique

4.3.3.3.1 Nuds de proprits
Pour lheure, on ne sait pas comment utiliser le fichier de configuration pour quil ait
un impact sur linterface graphique du vi. Ceci ncessite daccder par programme aux
proprits que nous avons jusqu prsent modifies la main. On peut y accder en crant
des nuds de proprits. Pour ce faire, on fait un click droit dans le diagramme sur le
terminal, on choisit Crer Nud de proprit la proprit qui nous intresse. Il
nest pas ais au dbut de trouver la bonne proprit et le dbutant ttonnera souvent sa
recherche.
Par exemple, pour rendre visible ou invisible un lment de face-avant, on utilisera la
proprit Visible
. On peut voir sur cette icne que la flche va vers la droite,
montrant quon accde la proprit en lecture. Si on veut la modifier, il nous faut faire un
click droit sur la proprit et la changer en criture
. Il nous suffit alors denvoyer la
valeur voulue pendant le fonctionnement du programme. Un click gauche sur la proprit
permet den slectionner une autre, de plus le vi est redimensionnable (permettant daccder
plusieurs proprits la fois).
Exercice d'application 25 : crer une IHM dynamique laide des nuds de proprits, utiliser des onglets

A faire : dans le projet utilis dans lexercice prcdent, se baser sur le vi de lExercice
d'application 18 (histogramme) afin de crer une application base sur les vnements dont la
face avant est donne sur la Figure 58. Noter quelle possde un titre personnalis, pas de
barre doutils (mais conserve un menu droulant pour pouvoir larrter en cas de
plantage ). Appuyer sur le bouton Calculer lance un test du gnrateur alatoire, et
lappui sur le bouton Options ouvre la popup (fentre modale) de configuration faite lors
de lexercice prcdent. Attention, si le bouton Ok est appuy pour fermer cette fentre,
on utilise les nuds de proprit pour changer la couleur de la courbe et la taille de la police
de ltiquette de nom de laxe des X et des Y en fonction de la configuration (on ignorera le
paramtre TailleHistorique . La mme chose (appliquer les options lues dans le fichier .ini)
doit tre faite ds le lancement de lapplication.

50

Ajouter ensuite des onglets : le premier panneau affiche le contenu de la face-avant actuelle,
alors que le second affiche des lments statiques A propos de possdant des
informations sur le programme et son auteur.

Figure 58 : face-avant de lapplication

Le problme est que trs rapidement, lorsque beaucoup dlments sont configurables,
le vi possdant lIHM de lapplication devient trs volumineux et presque inextricable. Nous
allons donc voir 2 techniques permettant de passer par des sous-vi : la premire consiste
utiliser un conteneur de face-avant secondaire, la seconde consiste utiliser des rfrences sur
les terminaux.

4.3.3.3.2 Face-avant secondaire

(voir Figure 59). Ce qui peut tre droutant est lutilisation dune rfrence de vi : il sagit
dune rfrence que lon peut crer dynamiquement en ouvrant une rfrence sur un vi (par
exemple en passant son nom), ou bien de faon constante comme sur la figure. Dans ce cas,
on cre une rfrence de vi statique sur laquelle on fait un glisser-dposer du vi dont on veut
afficher la face-avant. Cependant, cela reste assez complexe manipuler, et souffre
dinconvnients (notamment le fait quil faut penser excuter le vi, ce qui nest pas le cas sur
la Figure 59).

51

Figure 59 : utilisation dune face-avant secondaire

On est donc amen utiliser un nud de mthode prenant en entre la rfrence du vi

dont on affiche la face-avant, afin de lexcuter comme cela est montr sur la Figure 60. Noter
sur la face-avant labsence des barres de dfilement (elles taient prsentes sur la Figure 59,
tmoignant du fait que la face-avant secondaire tait visible mais non excute). On peut
remarquer comment on excute ce vi : le paramtre important est AttendreLaFin qui
prcise si le vi doit tre excut de faon synchrone (le vi appelant doit attendre la fin) ou
asynchrone.

Figure 60 : utilisation correcte dune face avant secondaire en appel synchrone

4.3.3.3.3 Utilisation de rfrences sur les terminaux

Les rfrences permettent dutiliser des nuds de proprit et donc agir dynamiquement
sur une face-avant partir dautres vi auxquels les rfrences seraient passes. Une rfrence
(comme
) est obtenue en faisant un click droit sur un terminal comme sur la Figure
61. Le but tant de crer un sous-vi prenant cette rfrence en paramtre, il nous faut crer une
commande partir de cette rfrence (qui pour linstant est une constante). Il y a deux faons
de procder : faire un click droit sur la rfrence, pour crer une commande, qui pourra tre
copie/colle sur la face-avant du sous-vi. La seconde faon consiste tout simplement faire
un glisser-dposer de la rfrence sur la face-avant du sous-vi. La commande obtenue

ressemble

pour un graphe.
52

Figure 61 : crer une rfrence

Il suffit ensuite dutiliser des nuds de proprits acceptant des rfrences en entre
(palette Contrle dapplications ), c'est--dire des nuds qui ne sont attachs aucun
lment de face-avant. La modification des proprits du graphe peut donc tre effectue dans
un sous-vi comme sur la Figure 62.

Figure 62 : utilisation dune rfrence

Exercice d'application 26 : utiliser les rfrences, modifier un type strict

A faire : modifier le programme de lExercice d'application 25 afin que la modification des

proprits du graphe seffectue dans un sous-vi tel que celui de la Figure 62.
Modifier le type Configuration afin dajouter un paramtre NombreItrations (inutile de
modifier le chargement/enregistrement dans les fichiers de configuration). Ce paramtre sera
utilis comme entre N de la boucle For.

4.3.4 Cration de fichier excutable

LabVIEW professionnel peut crer des fichiers excutables. Ils sexcuteront sur une
machine qui na besoin que du LabVIEW runtime qui est gratuit. Le fonctionnement en est
simple, partir de la fentre projet, on peut faire un click droit sur Spcification de
construction (voir Figure 63).

Figure 63 : cration dexcutable

Ltape importante se trouve dans longlet Fichiers sources , dans laquelle on va

dfinir le vi de dmarrage, c'est--dire celui qui serait lanc pour lancer lapplication.
Exercice d'application 27 : crer un excutable

A faire : crer lexcutable de lapplication.

53

Noter que laccs au fichier de configuration ne fonctionne pas et que lapplication ne se

ferme pas la fin de lexcution.
Pour que lapplication se ferme, il faut utiliser le Quitter LabVIEW la fin de
lapplication.
Pour que le fichier puisse tre accd, il faut savoir une chose : lorsque des vi sont dans un
excutable, tout se passe comme sils taient dans un sous-dossier au nom de lexcutable. Par
consquent, il faut remonter dun cran de plus dans larborescence pour le nom de fichier.
Problme : lexcutable et la version LabVIEW ne sont pas compatibles, car il serait plus
quennuyeux de voir LabVIEW se fermer chaque fois que lon ferme lapplication, et le
fichier de configuration Appli.ini ne serait pas dans le mme dossier. Pour grer les 2 cas
de faon homogne, on est donc amens tester dans le programme sil sexcute dans
LabVIEW ou bien dans un excutable, et de calculer les chemins vers les fichiers ou de
quitter LabVIEW la fin ou non en fonction de cela. Un moyen simple de savoir si on se
trouve dans lexcutable est de tester lextension du dossier parent dun vi (voir Figure 64) : si
cest .exe alors on se trouve dans lexcutable, sinon, on est dans lenvironnement
LabVIEW.

Figure 64 : savoir si lon est ou non dans un excutable

4.3.5 Quelques petits trucs

Quelques petits trucs :
Un double click sur un lment de face-avant amne au terminal du diagramme
directement et vice-versa.
On peut demande LabVIEW d Arranger le cblage en faisant un click droit
sur le cble.
On peut dfinir les valeurs par dfaut des lments dune face avant (click droit
sur llment, puis Oprations sur les donnes Dsigner la valeur
actuelle par dfaut .
Lorsquon a un programme important, les outils du menu droulant Outils
Profil Performances et mmoire permettront de voir sur quel vi
focaliser ses efforts en terme doptimisation du temps de traitement ou de la
mmoire utilise (ainsi, trs souvent les temps de traitement longs sont lis
lutilisation de la concatnation de tableaux dans des boucles, avantageusement
remplaces par une cration initiale dun tableau de taille suffisante, puis
Insrer dans un tableau la place de concatner).

5 Conclusion
Jespre que ces explications et exercices auront aid le lecteur, dbutant, ou
intermdiaire, progresser dans lutilisation du langage LabVIEW. De nombreux domaines
restent explorer : utilisation du rseau, optimisations, intgration dans le systme
(ActiveX,), cration et utilisation de DLL, cration de bibliothques compltes, utilisation
des classes, gestion fine du multitche, gestion des proprits dexcution des vi, cibles
spcifiques, gestion des sources et versions, etc. mais jespre que laccent port sur
lutilisation de la documentation et des recherches dexemples pousseront les curieux
trouver relativement simplement ce dont ils auront besoin lavenir.

54

Il y a malheureusement relativement peu douvrages en franais traitant de LabVIEW.

Jencourage le lecteur se procurer le livre de Francis Cottet LabVIEW : Programmation et
applications chez Dunod. Il a t crit la sortie de la version 6 de LabVIEW, et manque les
fonctionnalits introduites aux versions 7 et 8, mais il reste un ouvrage de rfrence pour les
bases de programmation en LabVIEW. Nous travaillons actuellement la rdaction de la
nouvelle version.
De plus, le lecteur intress par les aspects programmation multitche en LabVIEW
pourra se procurer le livre de Francis Cottet et moi-mme Systmes temps rel de contrlecommande : Conception et Implmentation , chez Dunod. Il est ma connaissance le seul
ouvrage parlant de la faon dont on peut concevoir et programmer un systme multitche
but temps rel en LabVIEW (il traite paralllement LabVIEW, C et Ada).

55