notice labview
Post on 08-Feb-2016
35 Views
Preview:
TRANSCRIPT
Initiation à Labview
MASTER Optique,Image et Vision
1ème année
1. GENERALITES ............................................................................................................................................ 3
1.2 Les palettes...................................................................................................................................... 4 2. REALISATION D'UNE APPLICATION SIMPLE....................................................................................................... 5
2.1 Barre d'outil du diagramme............................................................................................................ 5 2.2 Documenter un VI ........................................................................................................................... 5 2.3 Sauvegarder un VI .......................................................................................................................... 6
3. CREER UN SOUS VI .................................................................................................................................... 8 4. VISUALISATION DE SIGNAUX ..................................................................................................................... 8 5. STRUCTURES DE CONTROLE DE L'EXECUTION D'UN PROGRAMME............................................................... 9 6. ARRAYS ET CLUSTERS (TABLEAUX ET GROUPES)..................................................................................... 10
6.1 Les tableaux (Arrays) .................................................................................................................... 11 6.2 Les groupes (Clusters) .................................................................................................................. 12
7. CHAINES DE CARACTERES ET ENTREES/SORTIES ............................................................................................ 13 7.1 Manipulation des chaînes de caractères ............................................................................................... 14 7.2 Les commandes et les indicateurs de liste et de menu rotatif................................................................ 14 7.3 Fichiers d'entrée sortie.......................................................................................................................... 15
8. STRUCTURES : NŒUD FORMULE, CONDITION ET SEQUENCE............................................................................ 16 8.1 Le noeud formule : Formula node......................................................................................................... 16 8.2 La structure condition : Case structure................................................................................................. 16 8.3 La structure séquence............................................................................................................................ 17
9. LES REGISTRES A DECALAGE ......................................................................................................................... 18 10. ACQUISITION DE DONNEES ET CONTROLE D'INSTRUMENTS .......................................................................... 19
10.1. Généralités ......................................................................................................................................... 19 10.2 Bus GPIB............................................................................................................................................. 19 10.3 Les ports série ..................................................................................................................................... 20 10.4 Cartes d'acquisition de données.......................................................................................................... 21
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 3
1. Généralités
Labview (Laboratory Virtual Instrument Engineering Workbench) est un logiciel de la
société National Instruments qui permet facilement de configurer des instruments, piloter des
manipulations, recueillir et traiter des données. Toute application Labview est appelée un
instrument virtuel que nous noterons VI. Le mode de programmation est graphique (appelé
langage G) mais il est basé sur la notion de programmation orientée objet. Le contrôle est
effectué par flux de données (les opérations contenues dans un bloc seront exécutées quand
toutes les données seront présentes à l'entrée du bloc qui représente un noeud du graphe).
Pour chaque instrument ou bus ou carte d'acquisition, il existe une bibliothèque de
programmes de configuration qui fournit la face avant de l'instrument et convertit les
commandes et les mesures. Labview permet ainsi de commander par programmation des
manipulations et de recueillir et traiter les données.
Notations. Les caractères en italique désignent des commandes Labview.
Un VI est représenté des trois manières complémentaires suivantes que l'on utilise
généralement dans cet ordre lors de la conception.
• La face avant qui est interactive parce qu'elle simule la face d'un instrument physique.
Elle comporte des contrôles (interrupteurs, curseurs...c'est à dire des entrées) et des
indicateurs (écrans, cadrans, voyants ...des sorties).
• A chaque VI correspond un bloc diagramme. Il décrit le traitement des données à
effectuer entre les commandes et les indicateurs. On le construit en langage G. C'est la
solution graphique d'un problème de programmation. Ce diagramme correspond au code
source du traitement interne à l'appareil.
• L'icône/Connecteur facultatif qui permet de remplacer le VI
par une icône et de le connecter à d'autres VI. En effet tout VI
peut être un sous VI d'un VI plus complexe (comme un sous-
programme, une fonction ou une procédure dans un programme
textuel).
Avec ces supports, on a accès au concept de programmation
modulaire. On divise une application en une série de taches qui
peuvent être elles-mêmes subdivisées en taches élémentaires. Comme
on peut exécuter chaque sous VI indépendamment, le débogage est Figure 1 : Palette
des outils
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 4
plus aisé. Une fois que l'on a constitué une bibliothèque de ses applications les plus courantes,
toute nouvelle application proche est vite développée.
1.2 Les palettes
Sous Labview, on dispose d'une série de palettes pour décrire ou contrôler les différents
aspects des VIs.
La palette des outils (Tools palette)
Elle est utilisée pour éditer et déboguer un VI. On la fait apparaître en sélectionnant Windows
>>Show Tools Palette (figure 1).
Le doigt (operate value) permet de manipuler le VI même en cours de fonctionnement.
La flèche (position/size/select) permet de sélectionner, positionner et redimensionner les
objets.
La lettre A (edit text) est l'outil d'étiquetage pour éditer du texte.
La bobine de fil (connect wire) permet de relier les objets dans le bloc diagramme.
Le menu local (object popup) permet d'avoir accès au menu déroulant d'un objet. On
peut ainsi changer les propriétés d'un objet. Lorsqu'on dit "dérouler le menu objet", il
faut sélectionner le menu local puis cliquer sur l'objet.
La main (scroll window) permet de déplacer l'ensemble des objets dans la fenêtre.
Le stop (set/clear breakpoint) permet de mettre des
points d'arrêt.
La sonde (probe data) permet d'effectuer des
prélèvements sur les liaisons.
La pipette (get color) copie les couleurs.
Le pinceau (set color) établit les couleurs de fond et
de premier plan.
La palette des contrôles (controls palette)
Elle s'ouvre automatiquement lorsqu'on lance Labview
(sinon la sélectionner dans windows). Malgré son nom, elle
permet de placer des contrôles et/ou des indicateurs sur la
face avant d'un VI (figure 2). Chaque icône contient des
sous palettes. Les deux premiers contrôles (en haut à
gauche) sont:
Figure 2 : Palette des
contrôles
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 5
Les indicateurs et contrôles numériques pour entrer
ou afficher des grandeurs numériques.
Les indicateurs et contrôles booléens pour des entrées
ou sorties tout ou rien.
Nous détaillerons les autres contrôles au fur et à mesure des
besoins.
La palette des fonctions
Elle s'affiche lorsqu'on visualise le bloc diagramme (figure 3).
Chaque icône contient également des sous palettes. Elle
permet de placer des noeuds (opérateurs, VIs, constantes...)
dans le bloc diagramme.
2. Réalisation d'une application simple
2.1 Barre d'outil du diagramme
Elle permet de contrôler le mode d'exécution du VI. Les
boutons de gauche à droite ont les actions suivantes :
Flèche simple ; exécuter une fois.
Flèche double ; exécuter en continu.
Bouton rouge ; arrêter l'exécution.
Ampoule ; afficher les données passant dans les fils (exécution lente).
Exécution détaillée (pas à pas y compris à l'intérieur des sous VI)
Exécution semi détaillée.
Pour rendre la face avant active, il suffit de cliquer dans la fenêtre correspondante. Lorsqu'on
a lancé l'application, on peut ensuite manipuler le VI avec l'outil doigt comme un instrument
réel. On peut visualiser en même temps la face avant et le diagramme avec windows>up/down
Observer les quatre premiers modes de fonctionnement.
2.2 Documenter un VI
Il peut être utile de documenter un VI comme un programme lorsqu'il est complexe. Pour
cela, sélectionner windows>>show VI info. On peut alors entrer des commentaires.
Figure 3 : Palette des
fonctions
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 6
2.3 Sauvegarder un VI
Avec file>>save as, affecter un nom et un chemin d'accès à ce fichier qui aura l'extension .vi
Exercice 1 :
On se propose de tirer une suite de nombres aléatoires compris entre 0 et 1, de les multiplier
par un coefficient fixé par un contrôle, d'afficher le résultat sur un vumètre à aiguille, de
comparer ce résultat à un seuil et d'allumer une Led si le résultat dépasse le seuil.
Ouvrir une nouvelle face avant en sélectionnant file>>new ou le bouton new VI dans la boîte
de dialogue.
Figure 4 : Face avant de l’exercice 1
Constitution de la face avant
On désire réaliser la face avant de la figure 4, après avoir fait apparaître la palette de
contrôles :
a. Choisir un potentiomètre vertical dans controls>>numeric>>vertical slide et le placer
dans la face avant. Taper immédiatement le texte 'gain' dans la boîte étiquette puis
cliquer à l'extérieur. Pour fixer la plage du potentiomètre entre 0 et 100, à l'aide de
l'outil étiquette A, double cliquer sur 10. Il doit alors apparaître en surbrillance. Taper
100,0 et cliquer à l'extérieur.
b. Faire de même avec un deuxième potentiomètre et le nommer 'seuil'.
c. Placer un vumètre disponible dans numeric>>meter. Le nommer 'affichage' et régler sa
plage.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 7
d. Placer une led (Boolean>>round led) et la nommer 'dépassement'.
Constitution du bloc diagramme
Figure 5 : Bloc diagramme de l’exercice 1
Ouvrir la fenêtre diagramme (Ctrl+E), les contrôles et indicateurs de la face avant s'y trouvent
déjà. Observer la différence de cadres. DBL et SGL signifient double et simple précision.
Choisir les objets suivants dans la palette fonctions et les placer dans le bloc diagramme
comme sur la figure 5.
a. La function nombre aléatoire représentée par des dés dans functions >>numeric
>>random.
b. La fonction multiplication (functions>>numeric) pour multiplier la valeur générée par
le coefficient.
c. La fonction supérieur dans functions>>comparison.
d. Relier les différents blocs en utilisant la bobine.
Pour relier deux points, il suffit de cliquer une fois sur chaque point dans n'importe quel ordre
(ne pas maintenir le bouton de la souris appuyé). Labview affecte une couleur à chaque
liaison suivant le type de données : bleu pour les entiers, orange pour les flottants, vert pour
les booléens et rose pour les chaînes de caractères. En déroulant le menu d'un objet, l'option
show>>terminals peut aider à visualiser les connecteurs. Le connecteur clignote lorsqu'on est
bien positionné. En cliquant une, deux ou trois fois sur une liaison, on sélectionne un
segment, une branche ou toute une liaison. Une liaison peut être mauvaise pour différentes
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 8
raisons ( souvent incompatibilité de formes ou de types de données) ; elle apparaît alors en
tirets (ne pas confondre avec les pointillés des booléens). Pour finir lancez l'application et
vérifiez son bon fonctionnement.
3. Créer un sous VI
On peut utiliser autant de sous VI que l'on veut et chaque sous VI peut appeler d'autres sous
VI, etc. Pour utiliser un VI comme sous VI, il faut créer une icône pour le représenter et un
connecteur pour relier ses entrées et ses sorties.
Exercice 2
On se propose de créer un sous VI à partir du VI précédent.
a. Ouvrir le VI précédent si vous l'avez fermé.
b. Appeler l'éditeur d'icône en déroulant le menu local dans le coin supérieur droit de la
face avant et sélectionner Edit icon. Vous disposez alors de différents outils de dessin
dans une fenêtre à gauche pour personnaliser votre icône. Effacer l'icône existante par
défaut. Dessiner un dé et/ou taper du texte (DE par exemple). Fermer en cliquant sur
OK.
c. Créer le connecteur en utilisant show connector (menu objet de l'icône). Labview
sélectionne automatiquement le nombre de connecteurs suivant le nombre de contrôles
et d'indicateurs (deux entrées-contrôles et deux sorties-indicateurs). Les entrées sont à
gauche et les sorties à droite. Cliquer sur le connecteur et sur l'indicateur ou le
contrôle correspondant pour les connecter. Le connecteur relié est alors grisé.
Il faut évidemment enregistrer ce sous-VI avec un nom distinct puisqu'il peut être utilisé dans
d'autres applications. Pour l'utiliser par la suite, ouvrir un nouveau VI, et dans le diagramme
sélectionner le sous-VI avec functions>>select a VI.
Remarque :Lors du développement d'un VI, le diagramme peut s'avérer plus complexe que
prévu ou deux parties peuvent être identiques. On transforme alors en sous VI une
partie du diagramme. Il suffit de sélectionner le bloc que l'on veut mettre en sous-
VI et de choisir Edit>>SubVI from selection. Labiew réalise alors lui-même les
connexions.
4. Visualisation de signaux
Labview permet de représenter un ou plusieurs signaux sur un même graphe de plusieurs
manières dans control>>graph. Le mode waveform graph (graphe oscilloscopique) est de la
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 9
forme y(n) où n représente le numéro du point. Le mode waveform chart (traceur) est de la
forme y(x) avec des valeurs de x régulièrement espacées de ∆x et débutant à x0
(respectivement 1 et 0 par défaut). Le mode XYgraph trace le tableau y en fonction du tableau
x.
Exercice 3
Remplacer le Vumètre précédent par un traceur (waveform chart), retourner dans le
diagramme pour relier la valeur de sortie au traceur.
Les valeurs de ces graphes sont contenues dans des tableaux dont le nombre de valeurs peut
évoluer. Le graphe affiche un certain nombre des dernières valeurs et se met à jour de 3
manières différentes accessibles dans le menu objet de l'écran avec Data operation>>Update
mode.
Le mode strip chart qui affiche en permanence les dernières valeurs (comme un
enregistreur papier)
Le mode scope chart qui fonctionne comme un oscillo (il efface lorsqu'il arrive au
bout et recommence du début un nouveau graphe)
Le mode sweep chart qui fonctionne un peu comme un oscillo à mémoire (il
n'efface que la partie où il retrace ; un curseur permet de repérer cette position).
Observer ces différents modes de rafraîchissement.
Remarques :Un certain nombre de points antérieurs se trouvent dans une mémoire tampon
même s'ils ne sont plus affichés. On peut les afficher de nouveau (remonter le
temps) avec show>>scrollbar du menu objet de l'écran du traceur. Le menu
objet de plot permet de choisir différents modes de représentation des points et
lignes.
5. Structures de contrôle de l'éxécution d'un programme
Lors d'expérimentations, il est indispensable de contrôler le début, la fin et le nombre
d'exécutions d'une application sinon elle débute immédiatement avec run, s'exécute le plus
rapidement possible et se termine avec stop sous notre contrôle comme nous l'avons fait
précédemment. Labview dispose des boucles For et While comme en programmation
classique. Elles se situent dans functions>>structures.
La boucle For exécute N fois le sous-diagramme contenu dans les limites de la
boucle représentée par un cadre. Elle fait apparaître la valeur N et l'indice i qui
varie de 0 à N-1.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 10
La boucle While exécute le sous-diagramme contenu dans les limites de la boucle
jusqu'à ce que la condition terminale qui doit être un booléen soit fausse. La
stucture fait apparaître l'indice (il démarre à 0 et s'incrémente à chaque exécution de
la boucle) et la condition terminale.
Attention :Contrairement à la plupart des langages de programmation, la boucle while de
Labview est éxécutée au moins une fois.
Il existe trois autres structures que nous verrons plus tard : sequence, case et node.
Exercice 4
Utilisation d'une structure de contrôle répétitive et visualisation de signaux.
a. Ouvrir la fenêtre face avant du VI précédent et placer un bouton (controls>>boolean)
que vous nommerez 'M/A'.
b. Ouvrir le bloc diagramme et placer une boucle While (function>>structure) autour de
l'ensemble des objets.
c. Relier M/A à la condition terminale de la boucle.
d. Retourner dans la face avant et cliquer sur le bouton M/A avec le doigt (operate tool).
e. Lancer le VI (run normal). Une nouvelle action sur le bouton M/A arrêtera
l'acquisition en terminant la boucle.
Ajout d'une synchronisation.
Il est souvent utile de contrôler les instants de traitement (dans notre exemple, le temps de
redémarrage d'une nouvelle boucle). Placer l'icône function >>Time &Dialog>>Wait until
next ms multiple dans la boucle. Ouvrir le menu objet (Clic droit), sélectionner create
constant et taper 500 pour deux acquisitions par seconde. Visualiser la courbe en changeant
cette valeur.
Remarque :Il est préférable d'utiliser cette dernière méthode (menu objet du noeud) pour
relier des constantes, des indicateurs ou des contrôles aux entrées et sorties ; les
connexions s'établissent toutes seules et les types de données correspondent
obligatoirement.
6. Arrays et clusters (Tableaux et groupes)
Jusqu'à maintenant nous avons manipulé des scalaires (nombres individuels). Il est possible et
souvent intéressant de manipuler des tableaux à une, deux ou n dimensions. Les graphes
manipulés précédemment utilisaient des tableaux pour mémoriser les valeurs à tracer ; de
même, si des signaux proviennent de plusieurs canaux d'une carte d'acquisition, ils seront
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 11
stockés en tableaux 2D (une colonne par canal et une acquisition par ligne). Il existe deux
manières de grouper les données :
En arrays (tableaux) si les données sont de même type.
En clusters (groupes) si les données sont de nature différente.
Ils sont caractérisés tous deux par leur forme 1D, 2D ou nD, leur taille (nombre de lignes,
nombre de colonnes, nombre de plans, etc...) et leur contenu (type de données). Un élément
de tableau est repéré par ses indices qui débutent toujours à 0. Contrairement aux arrays qui
peuvent changer de taille de manière dynamique (autoindexation), les clusters ont des tailles
fixes. Pour augmenter les dimensions, dérouler le menu objet en cliquant sur l'affichage de
l'indice et sélectionner add dimension.
6.1 Les tableaux (Arrays)
On crée un tableau en deux étapes : en définissant d'abord le nombre de dimensions et
éventuellement leurs valeurs maximales puis en définissant le type de données qui peut être
d'une part un contrôle ou un indicateur et d'autre part numérique, booléen ou chaîne. Quand
on pose un tableau pour la première fois dans la face avant, il apparaît noir ce qui signifie que
le type de données est indéfini. Il prendra ensuite la couleur correspondant au type de
données.
Il existe de nombreuses fonctions pour manipuler les tableaux dans functions>>array.
Exercice 5. Utilisation de tableaux
On se propose de remplir un tableau de réels à une dimension à l'aide d'une boucle For. Dans
une nouvelle face avant, créer un tableau avec array cluster>>array. Pour définir le type de
données placer un indicateur digital (nb éléments) dans la zone d'affichage du tableau en
ouvrant le menu objet de cette zone et en sélectionnant numeric>>digital indicator. Nous ne
définissons pas la dimension du tableau, l'autoindexation de la boucle For l'effectue
automatiquement.
Dans le diagramme positionner un générateur de nombres aléatoires. L'entourer d'une boucle
For (structures >>For loop). En ouvrant le menu objet de la valeur terminale N, sélectionner
create constant ou control si vous voulez fixer N dans la face avant. Relier le dé au tableau.
Cette connexion, dans sa partie extérieure à la boucle, doit alors apparaître épaisse indiquant
un transfert de tableau à une dimension.
Fixer la valeur de N et lancer l'application. Observer le fonctionnement détaillé à l'aide de
l'option ampoule de la barre d'outil du diagramme.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 12
Effectuer le même travail pour un tableau 2D à l'aide de deux boucles For imbriquées. Les
liaisons véhiculant des tableaux à plusieurs dimensions sont représentées par des doubles
traits.
Passer éventuellement à 3D. Dans chaque cas, dans la face avant, repérer les numéros de
lignes, colonnes, etc...
Remarque :L'autoindexation est validée par défaut pour les boucles For et inhibée par défaut
pour les boucles While. On peut changer les validations par défaut à l'aide du
menu local sur le point d'entrée ou de sortie de la boucle ; ces points définissent
un tunnel.
6.2 Les groupes (Clusters)
Un cluster est une structure qui regroupe des données éventuellement de nature différente
contrairement aux arrays. Le principal avantage est au niveau des connexions car on peut
relier plusieurs noeuds avec une seule liaison regroupant plusieurs types de données. Le
regroupement et 'dégroupement' de données peut être réalisé par les fonctions bundle et
unbundle de cluster. Les mêmes fonctions by name permettent d'agir sur une partie du cluster
seulement.
Exercice 6. Création d'un cluster, dégroupement, regroupement et affichage dans un
autre cluster
a. Ouvrir une nouvelle face avant
b. Placer un cluster (control>>Array&cluster) ; le nommer 'cluster d'entrée'.
c. Elargir le cadre et placer à l'intérieur deux contrôles digitaux (boolean switches), une
chaîne de controle (string) et un contrôle numérique.
d. Créer un cluster de sortie en clonant celui d'entrée (le sélectionner puis le déplacer
avec la souris en appuyant sur la touche contrôle du clavier).
e. Cliquer sur la bordure du cluster à l'aide du menu objet et sélectionner Change to
indicator.
f. Changer l'étiquette du nouveau cluster en 'cluster de sortie'. Vérifier éventuellement
que les deux clusters ont le même ordre en déroulant un menu sur la bordure et en
choisissant Cluster order.
g. Placer un bouton stop rectangulaire (boolean). Noter que ce bouton est faux par
défaut.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 13
h. Construire un diagramme dans une boucle While en intercalant un Unbundle et un
bundle (fonctions>>cluster) entre le cluster d'entrée et celui de sortie. Pour pouvoir
les câbler correctement il est nécessaire de redimensionner ces deux éléments (cliquer
avec l'outil flèche en bas à droite de l'icône et faire glisser jusqu'à ce qu'une quatrième
broche apparaisse).
i. Contrôler la boucle par le complément du bouton en intercalant une fonction Not
(fonctions>>boolean).
Remarque : Cet exercice est purement pédagogique car on peut relier directement deux
clusters).
Exercice 7. Array, bundle and graph
On se propose de construire un VI qui génère un tableau et en trace un graphe représentatif.
Dans une nouvelle face avant, placer
a. Un graphe (waveform graph) auquel vous affectez une étiquette.
b. Un tableau (id). Sélectionner un indicateur numérique et le placer dans la zone
d'affichage des données afin d'en définir le type.
Construire le diagramme de la figure. Le bloc generate wave... est un VI situé dans
functions>>tutorial. Placer deux constantes numériques et les relier aux entrées du bundle.
Relier la sortie du bundle à l'entrée du graphe. La signification de x0 et delta x est obtenue en
sélectionnant au préalable help show help (ceci est valable pour tout noeud dont on ne connaît
pas le brochage). Si une étiquette n'est pas disponible, on peut en affecter une en ouvrant un
menu local et en sélectionnant show label.
Retourner dans la face avant et exécuter le VI. L'échelle automatique des ordonnées peut être
désactivée par Yscale>>autoscale Y du menu local ouvert sur le graphe. En double cliquant
sur le mini et le maxi, on peut les modifier à volonté.
7. Chaînes de caractères et entrées/sorties
Jusqu'à présent, nous n'avons utilisé que des entrées et des sorties numériques respectivement
à l'aide de contrôleurs et d'indicateurs. Lorsqu'on observe le diagramme d'un driver
d'instrument, on s'aperçoit que la manipulation de chaînes de caractères constitue l'essentiel
des fonctions et les menus rotatifs l'essentiel des contrôles. Enfin, le recueil de nombreuses
données nécessite souvent le transfert dans un fichier pour un traitement ultérieur.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 14
7.1 Manipulation des chaînes de caractères
Les VIs de manipulation de chaînes se trouvent dans functions>>string et nous allons citer
les plus couramment utilisées. Une description "détaillée" est obtenue avec Help show help.
Quelques exercices illustreront leur utilisation.
Concatenate string assemble plusieurs chaînes en entrée en une seule chaîne de
sortie.
Pick line & append choisit une ligne dans une chaîne multiligne et ajoute cette
ligne à la chaîne d'entrée.
Select & append sélectionne une chaîne "faux" ou une chaîne "vrai" suivant un
sélecteur booléen puis l'ajoute à la chaîne d'entrée.
Match pattern recherche une chaîne de caractère dans une expression à partir d'un
indice (numéro de caractère) et ressort trois sous-chaînes.
Le sous menu Aditional String to number function contient de nombreuses
fonctions de conversions de chaînes en nombres.
7.2 Les commandes et les indicateurs de liste et de menu rotatif
La palette controls >> List & Ring contient huit commandes. Ils associent des entiers non
signés à des chaînes de caractères, à des images ou aux deux à la fois. Ils sont utiles lors de la
sélection d'options dans un menu sans connaître la valeur numérique correspondante.
Les menus rotatif de menus (menu ring) ou de dialogue (dialog ring) permettent de
sélectionner un menu parmi plusieurs qui s'affichent simultanément.
Les commandes de liste servent à présenter aux utilisateurs une liste d'options. Single
selection permet un choix unique alors que multiple selection permet un choix multiple.
Les commandes de type énumération (enumerated type) s'apparentent à une commande de
menu rotatif textuel sauf que lorsque les données de l'énumération sont reliées à une structure
condition, la condition affiche la chaîne de caractères ou le texte de l'élément au lieu d'un
nombre.
A titre d'exercice de compréhension, reproduire les diagrammes contenant des string
functions issus de configure sensor et triggering (p23-26) et ajouter un indicateur de chaîne à
la fin de chaque diagramme. Le text ring "sensor channel" comporte deux lignes : "channel
A" et "channel B". Ne pas faire figurer les visa.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 15
7.3 Fichiers d'entrée sortie
Les functions>>file I/O servent non seulement à lire ou écrire dans des fichiers mais
également à déplacer ou renommer des fichiers ou des chemins d'accès. Il existe trois modes
de stockage
Fichiers ASCII. Il faut convertir toutes les données en chaîne ASCII. Le gros
avantage est de pouvoir les réutiliser avec d'autres programmes ou logiciels tels les
tableurs ou les éditeurs de texte. Nous n'étudierons que ce mode.
Fichiers Datalog. Seul Labview peut lire ces fichiers.
Fichiers binaires. Cette méthode est la plus rapide et la plus compacte mais il faut
bien connaître la manière dont on a organisé les données.
La plupart des opérations d'entrée sortie fichiers comprend les trois opérations de base : ouvrir
un fichier existant ou le créer, lire ou écrire dans le fichier, fermer le fichier. Les Vis suivants
éxécutent une ou plusieurs des opérations précédentes pour les fichiers ASCII.
Write characters to file écrit une chaîne de caractères dans un nouveau fichier ou
ajoute la chaîne dans un fichier existant. Il referme le fichier.
Read characters from file effectue l'opération inverse.
Read lines from file lit un nombre donné de lignes à partir d'un caractère spécifié.
Write to spreadsheet file convertit un tableau 1D ou 2D de nombres simple
précision en une chaîne et les écrit dans un fichier (A utiliser pour relire les
données avec un tableur).
Read from spreadsheet file effectue l'opération inverse.
Exercice 8
Ajouter au VI de l'exercice 7 une fonction sinus pour générer un deuxième tableau 1D. A
l'aide d'un Build array, former un tableau 2D. Le sauvegarder dans un fichier ; relire le
tableau hors labview et tracer la courbe correspondante à l'aide d'un tableur (Excel par
exemple).
Quelques raccourcis :Maintenant que vous maîtrisez Labview vous pouvez prendre des
raccourcis pour gagner du temps de manipulation. Pour dérouler un
menu objet, par exemple, on peut se positionner sur l'objet et cliquer
sur le bouton droit de la souris. Pour effacer des liaisons mauvaises
CTRL-b (bad).
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 16
8. Structures : nœud formule, condition et séquence
Nous allons maintenant étudier les autres Vis contenus dans function>>structure qui
permettent de mettre en place des structures de programmation.
8.1 Le noeud formule : Formula node
On peut réaliser n'importe quel calcul avec un diagramme, mais cette solution n'est pas
toujours la plus concise ou la plus lisible. Le noeud formule permet d'écrire des séquences de
calcul comme en programmation classique. L'exercice suivant va illustrer son utilisation.
Exercice 9
On va utiliser un noeud formule pour calculer la fonction y = x^2 + x + 1 pour x variant de 0
à 2 avec un pas de 0.1 et représenter son graphe. Dans une nouvelle face avant, positionner un
graphe xy. Dans le diagramme, positionner un noeud formule
(function>>structure>>formula node). Agrandir le cadre et taper la formule (terminée par ; ).
En déroulant un menu objet sur la bordure, choisir add input et add output, puis entrer le noms
des variables x et y dans les cases (ce doit être les mêmes noms que dans la formule).
Ajouter une deuxième formule de votre choix et tracer les deux courbes en fonction de x.
8.2 La structure condition : Case structure
Cette structure réalise approximativement l'équivalent du if then et du case de turbopascal.
Elle possède un terminal de sélection (selection terminal) qui selon sa valeur fait exécuter un
sous diagramme (condition = case) parmi plusieurs. Si un booléen est connecté au terminal, il
existe un sous diagramme exécuté si la condition est true et un autre si elle est false. Si on
connecte un numérique, on peut envisager au maximum 215-1 sous diagrammes numérotés à
partir de 0 et exécuter celui dont le numéro correspond au terminal. On ne peut afficher
qu'une seule condition à la fois dans le diagramme; pour passer de l'une à l'autre, cliquer sur
l'une des flèches en haut de la structure.
Exercice 10
Réaliser un VI qui calcule la racine carrée d'un nombre si celui-ci est positif et signale une
erreur s'il est négatif en affichant la valeur -99.
Dans une face avant placer un contrôleur digital pour entrer le nombre et un indicateur digital
pour afficher la racine carrée.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 17
Dans le diagramme, placer une structure condition (functions>>structure>>case). L'agrandir
en tirant sur un coin. La fonction one button dialog se trouve dans time & dialog et permet
d'afficher une boîte de dialogue.
Remarque :Les cas simples du type if then else de cet exercice peuvent être résolus plus
simplement par la fonction select dans comparison. Voir description avec Help
>>show help.
8.3 La structure séquence
Cette structure est très importante car elle permet de dérouler plusieurs séquences les unes
après les autres à la manière des images d'un film comme le rappelle la représentation. Cette
structure n'a pas d'équivalent en programmation classique puisque les instructions sont
exécutées dans l'ordre. Par contre elle est nécessaire dans le cas du contrôle par flux de
données.
Exercice 11
A titre d'exemple, on va réaliser un VI qui par tirage aléatoire va chercher un nombre entré
dans la face avant. On calculera en même temps le nombre d'itérations et le temps mis pour
trouver le nombre.
Dans une face avant, placer un contrôleur et trois indicateurs que vous nommerez 'nombre à
chercher', 'nombre tiré', 'nombre d'itérations' et 'temps mis'.
Changer la précision des trois premiers en sélectionnant format&precision dans leur menu
objet et en tapant 0 pour le nombre de décimales.
Réaliser le diagramme de la manière suivante.
Placer et agrandir une structure séquence ; elle a implicitement le numéro 0. Placer à
l'intérieur la fonction tick count (ms). Créer une variable locale en déroulant le menu objet sur
le bord inférieur du cadre et en choisissant add sequence local. Cette variable locale est
initialement représentée par un carré qui comporte une flèche lorsqu'il est connecté, elle sera
disponible dans les autres séquences.
Créer un nouveau cadre avec le menu objet en choisissant add frame after (séquence 1).
Placer une structure While, les indicateurs et controleurs utiles ainsi que les fonctions
numériques. La fonction [] (round to nearest) arrondit.
Dans la dernière séquence, on désire calculer le temps mis pour la détermination du nombre
en faisant la différence des instants d'horloge de début et de fin.
Entrer une valeur dans la face avant, éxécuter le VI et l'enregistrer.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 18
9. Les registres à décalage
Ils sont disponibles pour les boucles For et While et permettent de transférer des valeurs d'une
itération à la suivante. On les crée en ouvrant un menu local sur la bordure droite ou gauche et
en choisissant Add shift register. Il apparaît alors une flèche montante à droite et une
descendante à gauche au même niveau qui symbolisent respectivement le stockage des
données pendant l'itération et la restoration de ces données pendant l'itération suivante. On
peut stocker les éléments de plusieurs itérations en choisissant add element. Il apparaît alors
plusieurs flèches à gauche. On peut créer plusieurs registres à décalage. Ce registre peut être
un nombre, un tableau ou un cluster.
Exercice 12
Réaliser un VI qui trie les nombres d'un tableau suivant leur signe et place les positifs et les
négatifs dans deux tableaux différents.
Dans une nouvelle face avant, placer trois tableaux indicateurs d'entiers à une dimension et
les nommer 'tableau aléatoire', 'tableau des positifs' et 'tableau des négatifs'.
Commencer par générer le tableau initial de nombres entiers aléatoires compris entre -5 et +5
à l'aide d'une boucle For.
Placer une seconde boucle For indépendante de la précédente et créer deux registres à
décalages. A l'intérieur de la boucle placer une structure condition dont le terminal de
sélection est relié au signe du nombre du tableau aléatoire. A l'intérieur de chaque condition
(true or false) placer un build array. L'agrandir à 2 éléments et changer l'élément d'entrée en
array (menu objet). La méthode consiste à ajouter chaque nombre positif (négatif) au tableau
des positifs (négatifs) qui revient en début de diagramme grâce au registre. Il faut initialiser le
tableau par un initialize array.
Remarque : Observer l'effet de l'auto-indexation au bord de la boucle For qui transforme, en
sortie, une série de valeurs en tableau et le processus inverse en entrée.
Exercice 13
On se propose de calculer la valeur moyenne, maximale et minimale d'une suite de N valeurs
générées de manière aléatoire. Cet exercice est encore purement pédagogique car ces
fonctions existent pour les tableaux dans les Vis d'analyse. Vous pouvez cependant utiliser le
VI Max Min dans function>>comparison.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 19
10. Acquisition de données et contrôle d'instruments
10.1. Généralités
Le principal intérêt de Labview est de pouvoir communiquer avec le monde extérieur (à
l'ordinateur) via des Bus, des ports séries ou des cartes d'entrée-sortie. Cette communication
est aisée car il existe des VIs qui contrôlent les différents bus, cartes ou instruments. La
difficulté au niveau de cette formation réside dans la connaissance préalable de ces différentes
notions. Nous donnerons les outils nécessaires aux développements de telles applications et
quelques exemples de Vis qui ne pourront être exécutés qu'en présence du matériel adéquat.
Contrôle d'instrumentation VISA
Visa est une bibliothèque d'interfaces qui permet de contrôler des instruments sous bus GPIB
ou autre. A l'aide de ces fonctions, on peut construire un VI de driver d'instrument qui
contrôle un modèle particulier d'instrument au moyen de différents supports d'entrée sortie.
Une chaîne de caractère est transmise à la fonction Open de Visa afin de choisir le type d'E/S
à utiliser pour communiquer avec l'instrument. Une fois que la session Visa est ouverte, les
fonctions Visa telles que read et write exécutent les E/S de manière générique. Le driver
d'instrument Visa est alors indépendant de l'interface.
Nous allons donner des exemples de VIs des différents moyens d'E/S. A défaut de pouvoir les
exécuter sans générer de signal d'erreur à cause de l'absence de la carte ou de l'appareil, il est
plus intéressant d'observer leur structure et les éléments qui les composent. Il peut être utile
d'en reproduire une partie pour observer l'exécution détaillée comme on l'a déjà fait au
paragraphe 7.
10.2 Bus GPIB
Le bus le plus courant est le GPIB (General Purpose Interface Bus) également appelé IEEE
488. A l'aide d'une carte d'interface GPIB installée dans l'ordinateur, on peut communiquer
avec plusieurs appareils connectés à l'aide de câbles GPIB.
Les figures en annexes (p23-26) représentent le driver d'un chassis HP 8153A dans lequel on
peut placer deux tiroirs (radiomètres ou sources). Nous ne nous occuperons pas des VIs visa
qui n'ont pas de rôle fonctionnel.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 20
La face avant représente les différents contrôles et indicateurs : le choix du canal A ou B, le
mode de déclenchement, le type de "mesure" (lecture pour un radiomètre ou "envoi" pour une
source), la longueur d'onde, la valeur lue et les différents messages d'erreur éventuels.
Le diagramme correspondant est constitué de trois sous-VI : configuration du capteur, mode
de déclenchement et lecture ou envoi de valeurs. Le diagramme de chacun est détaillé ensuite.
Le diagramme configure sensor (p24) est constitué d'un pick line & append qui définit la
chaîne de caractère relative au canal de mesure et de deux string to number function qui
spécifient le format des nombres relatifs au temps de mesure et à la longueur d'onde. Par
exemple, si on choisit le canal 2, un temps de mesure de 0.5s et une longueur d'onde de 980
nm, il formera la chaîne :
sense2:pow:atime0.500;wave980.00nm
Le diagramme configure triggering (p25) ajoutera à la chaîne précédente la chaîne suivante
(par l'intermédiaire de visa) si on fonctionne en déclenchement continu.
init2:cont on
Enfin, si on fait une lecture, le diagramme read/fetch value (p26) ajoutera la chaîne
read2:scal:pow:dc?
La chaîne complète sera envoyée à l'appareil par l'intermédiaire du write visa. Le read visa
accomplira la lecture, puis la chaîne de caractère sera convertie en nombre pour l'afficher
dans l'indicateur reading.
10.3 Les ports série
La liaison série est un moyen de communication très répandu car la plupart des ordinateurs
possède au moins un port série. Il permet d'entrer ou sortir des données, en série, bit par bit.
L'inconvénient est l'impossibilité de connecter plusieurs appareils. Les VIs de liaison série se
trouvent dans functions >> Instrument I/O >> serial. Ils sont au nombre de cinq : serial port
init, serial port write, serial port read, bytes at serial port et serial port break.
Un exemple de VI de lecture et écriture est donné sur les figures en annexes (p27).
La face avant comporte un text ring indiquant le numéro du port, un enumerated type qui
spécifie l'action et un contrôle digital qui définit le nombre d'octets à lire. Elle comporte
également un contrôle et un indicateur de chaîne contenant la chaîne écrite ou lue sur le port.
Le diagramme comporte une structure condition sélectionnée par l'action read ou write.
La condition write comporte principalement un VI serial port write qui envoie la chaîne
serial write. Le reste concerne la gestion des erreurs.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 21
La condition read est plus complexe. Elle comporte une boucle while dans laquelle on teste
le nombre d'octets présents dans le buffer d'entrée (bytes at serial port). On sort de la boucle
lorsque ce nombre est supérieur ou égal à bytes to read ou en présence d'une erreur. On les lit
alors avec un VI serial port read et on les affiche dans l'indicateur serial read.
10.4 Cartes d'acquisition de données
Un autre moyen de communication est la carte d'entrée-sortie analogique-digitale. Labview
fournit des Vis facilitant l'utilisation de telles cartes. La sous-palette function >> Data
acquisition contient dans l'ordre les sous-palettes suivantes : Analog input ; Analog output ;
digital I/O ; Counter ; Calibration and configuration et Signal conditionning. Chacune de ces
sous-palettes contient encore une sous-palette organisée comme suit ; la première ligne
contient des Vis simples, la seconde des Vis intermédiaires et la dernière des Vis avancés.
Vis d'acquisition de données
Observer les Vis simples et ouvrir les sous-Vis qui les composent. Utiliser le show help pour
visualiser les connexions.
Ouvrir et analyser le fonctionnement du VI situé dans examples \daq \anlogin \analogin.llb
\Acquire-n-multi-start (p28). La face avant comporte des contrôles : numéro de la carte
(device), numéro du ou des canaux à acquérir sous forme de chaîne (channels), nombre
d'échantillons et fréquence d'échantillonnage et éventuellement limites de variation du signal
à acquérir. Elle comporte également un bouton start et un stop. Un indicateur (voltage data)
permet de lire les valeurs acquises et un écran d'afficher les courbes.
Le diagramme est constitué de deux boucles while imbriquées. L'une comporte le VI
d'acquisition (Al wave) qui fournit un tableau des valeurs acquises. L'autre est la logique de
contrôle. On relance une acquisition chaque fois que l'on appuie sur start. On allume un
voyant quand l'acquisition est terminée. Une action sur stop arrête le VI par Al clear.
Regarder le menu local d'un bouton pour voir les différentes possibilités d'action mécanique.
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 22
HP8153A Example
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 23
Configure Sensor Averaging Time and Wavelength
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 24
Sensor Trigger
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 25
Sensor Read/Fetch value
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 26
Port Série
Université Jean Monnet Saint-Etienne
Master OIV 1 – Initiation à Labview 27
Carte d’acquisition
top related