Vous êtes sur la page 1sur 35

Semestre 3 – Pilotage Instruments

Programmation graphique
sous LabVIEW

E. DAVID
N. BERNARD
TABLE DES MATIERES :

INTRODUCTION ........................................................................................................................................................................ 1
CHAPITRE 1. - RAPPELS : VI ET SOUS-VI ..................................................................................................................... 2
CHAPITRE 2. - LES STRUCTURES DE PROGRAMMATION ...................................................................................... 5
CHAPITRE 3. - VARIABLES LOCALES, NŒUDS DE PROPRIETE ET GRAPHES ................................................. 9
CHAPITRE 4. - TABLEAUX .............................................................................................................................................. 13
CHAPITRE 5. - CHAINES DE CARACTERES ............................................................................................................... 16
CHAPITRE 6. - LES ENTREES/SORTIES SUR FICHIERS .......................................................................................... 19
CHAPITRE 7. - ACQUISITION DE DONNEES SOUS LABVIEW ............................................................................... 29

Introduction
LabVIEW (Laboratory Virtual Instrument Engineering Workbench) est un puissant langage de
programmation pour le contrôle d’instruments et l’analyse.

Contrairement à la nature séquentielle des langages, LabVIEW est basé sur un environnement de
programmation traditionnel et y ajoute un environnement de programmation graphique ainsi que tous les outils
nécessaires pour l’acquisition, l’analyse et la présentation de données.

Grâce à ce langage de programmation graphique, appelé “G”, vous pouvez créer un programme sous forme de
diagramme, ce qui correspond à la conception usuelle des scientifiques et des ingénieurs. Une fois que l’utilisateur
a créé un diagramme, LabVIEW le compile en code machine.

LabVIEW intègre l’acquisition, l’analyse et la présentation de données en un seul système. Pour l’acquisition
de données et le contrôle d’instruments, LabVIEW supporte les standards RS-232/422, IEEE 488 (GPIB) et VXI,
incluant les fonctions VISA (Virtual Instrument Software Architecture), ainsi que les cartes d’acquisition de
données (DAQ).

Une bibliothèque dotée de drivers pour des centaines d’instruments simplifie les applications de contrôle
d’instruments. Pour l’analyse de données, la bibliothèque d’analyse étendue contient les fonctions pour la
génération et le traitement de signaux, les filtres, les fenêtres, les statistiques, la régression, l’algèbre linéaire et
l’arithmétique matricielle.

De part sa nature graphique, LabVIEW est un incontournable instrument de présentation de données.


LabVIEW permet de générer des graphes déroulants, des graphes et des représentations personnalisés pour
l’utilisateur.
Chapitre 1. - Rappels : VI et sous-VI
Les programmes LabVIEW s’appellent des Instruments Virtuels (VI : prononcer "Vi-Aïlle" pour "Virtual
Instruments"). Les VI sont constitués de 2 parties principales : la face-avant et le diagramme.

On construit la face-avant à l’aide d’une combinaison de commandes et d’indicateurs :


- les commandes sont des objets qui permettent de fournir des données dans un VI de façon interactive.
- Les indicateurs sont des objets pour afficher des données que votre VI génère.

Le diagramme est composé de nœuds, de terminaux et de fils de liaison :


• Les nœuds sont des éléments d’exécution du programme.
• Les terminaux sont des ports à travers lesquels les données sont transmises entre le diagramme et la face-
avant et entre les nœuds du diagramme.
• Les fils de liaison sont les chemins des données entre terminaux. Les données circulent dans une direction
unique à partir du terminal source vers un ou plusieurs terminaux de destination. Chaque type de donnée
apparaît dans une couleur distincte pour souligner leur différence.

1.1. Le câblage

Les fils de liaison sont les chemins des données entre terminaux. Des motifs et des couleurs de fils différents
représentent des types de données différents. Les exemples des types de fils de liaison les plus courants sont
présentés ci-dessous :

Sous LabVIEW, chaque type de données est identifié par une couleur :
Bleu pour les entiers,
Orange pour les réels (nombres à virgule flottante),
Vert pour les booléens,
Rose pour les chaînes de caractères.

1.2. Les palettes

LabVIEW dispose de palettes graphiques et de palettes flottantes pour vous aider dans la création et l’exécution des
VIs. Les trois palettes sont les palettes Outils, Commandes et Fonctions.

La palette d’outils

Vous pouvez créer, modifier et mettre au point les VIs en utilisant les outils situés dans la
palette flottante Outils.

Si la palette Outils n’est pas visible, sélectionnez Palette d’outils du menu Fenêtres pour faire
apparaître la palette.

- 2/ 34 -
La palette Commandes (face-avant)
Vous ajoutez des commandes et des indicateurs à la face-avant via la palette Commandes.

Si la palette de Commandes n’est pas visible, vous pouvez ouvrir la palette en


sélectionnant Palette des Commandes dans le menu Affichage de la face-
avant.

La palette Commandes apparaît également lorsque vous faites un clic-droit


sur la face-avant.

Remarque :
La palette Commandes est visible uniquement quand la fenêtre de la face-
avant est active.

La palette Fonctions (diagramme)


Vous construisez des diagrammes avec la palette Fonctions.

Si la palette Fonctions n’est pas visible, vous pouvez ouvrir la palette en sélectionnant Palette des fonctions du
menu Affichage.

La palette Fonctions apparaît également lorsque vous faites un clic-droit sur le diagramme.

Remarque : la palette Fonctions est valide uniquement si la fenêtre du diagramme est active.

1.3. La fenêtre d’aide (très important !!)

Pour afficher la fenêtre d’aide, choisissez Aide contextuelle


dans le menu Aide (ou cliquez sur ).

Il suffit ensuite de positionner la souris sur un élément du


diagramme pour obtenir l’aide sur cet élément.

Une aide plus complète est disponible en cliquant sur le lien en


bas de la fenêtre d'aide contextuelle.

- 3/ 34 -
Principaux raccourcis clavier :
- ctrl+E : permet de passer de la face-avant au diagramme et inversement
- ctrl+B : permet d'éliminer tous les fils de liaison coupés ou comportant une erreur (pointillés)
- ctrl+X, C, V : couper, copier, coller
- ctrl+Z : annuler la dernière action

Le clic droit ; raccourci souris :


En faisant un clic droit avec l'outil bobine sur une entrée ou une sortie non câblée d'un terminal, le menu contextuel
propose de créer une constante, un contrôle ou un indicateur selon les cas, adapté au terminal. C'est une manière
très pratique de créer des terminaux en étant sûr de ne pas se tromper de type de donnée.

Commentaires :
Lorsque le diagramme devient compliqué, il est très conseillé de rajouter des commentaires pour faciliter la
lecture de votre programme.
Il suffit de cliquer avec l'outil texte là où vous souhaitez ajouter un commentaire dans votre diagramme

Exercice 1 : Generateur_temperature_aleatoire.vi
Construisez un VI qui génère un nombre aléatoire compris entre 10,0 et 30,0.

Le générateur aléatoire est situé dans Fonctions → Numérique → Nombre aléatoire


Ce générateur aléatoire génère des nombres compris entre 0 et 1.

Créer un sous-VI correspondant au générateur de température aléatoire

Dessinez l’icône suivante (rien ne vous empêche de dessiner une icône plus jolie !!)

Enregistrer ce sous-VI sous "Generateur_temperature_aleatoire.vi"

- 4/ 34 -
Chapitre 2. - Les structures de programmation

Les structures contrôlent le flux des données dans un VI. Sous LabVIEW, il existe quatre structures qui contrôlent
ce flux : la boucle While, la boucle For, la structure Condition et la structure Séquence.

Les structures sont accessibles grâce aux icônes de la palette Fonctions → Structures

2.1. La boucle While (tant que …)

Terminal d’itération

Terminal conditionnel (action modifiable)

Une boucle While exécute son code tant que la valeur booléenne que vous câblez au terminal conditionnel est à
l’état Vrai. Le VI contrôle la valeur du terminal conditionnel à la fin de chaque itération, la boucle While s’exécute
donc au moins une fois.

Le terminal d’itération est une sortie numérique qui contient le numéro de l’itération en commençant à zéro. Il est
incrémenté de 1 à chaque itération.

Le diagramme ci-contre réalise l’algorithme suivant :

i=0
Tant que i < 10
Afficher i
• i=i+1
•Fin Tant que

• L’exécution de la boucle dépend de la variable booléenne (Vrai-Faux) attachée à l’icône en bas à droite. La
boucle continue tant que cette variable est fausse. Il est possible de changer la condition d'arrêt de la boucle
en faisant un clic droit sur le terminal conditionnel (Arrêter ou Continuer sur condition Vraie).
• Dans une boucle while, la condition est évaluée à la fin de chaque itération : la boucle est donc
toujours exécutée au moins une fois.

- 5/ 34 -
2.2. La boucle For (Pour…)

Une boucle For exécute une section de code un nombre défini de fois. Pour placer une boucle For sur le
diagramme, sélectionnez-la dans la sous-palette Structures de la palette Fonctions, puis englobez le code que vous
souhaitez répéter dans la bordure de la boucle.

Terminal conditionnel

Terminal de comptage

Le terminal de comptage spécifie le nombre de fois qu’il faut exécuter la boucle. Le terminal d’itération contient le
nombre de fois que la boucle a été exécutée.

La différence entre la boucle For et la boucle While est que la boucle For s’exécute un nombre prédéfini de fois.
Une boucle While arrête de répéter le code qu’elle contient seulement si la valeur du terminal de condition devient
FAUX.

La boucle For est équivalente au pseudo-code suivant :


Pour i = 0 à N-1
Exécuter le diagramme à l’intérieur de la boucle

Le diagramme ci-contre réalise l’algorithme suivant :

Pour i=0 à 9
Afficher i
Fin Pour

2.3. La structure Condition


Test booléen « Vrai/Faux »

Si le booléen câblé au terminal de sélection est Vrai, le VI additionnera les deux nombres, sinon, le VI les
soustraira.

Une seule
structure
condition

- 6/ 34 -
Cas multiples

Bien qu’il n’existe qu’une seule icône pour les conditions, elle permet de traiter les cas multiples. On passe de la
valeur par défaut (deux cadres, Vrai-Faux) à une structure à cas multiples en changeant le type du sélecteur. Le
sélecteur peut être un booléen (valeur par défaut), un entier ou une chaîne de caractères (entre guillemets " ").
Le type du sélecteur change automatiquement en fonction de la valeur qui est affectée au terminal du sélecteur :
booléen, entier ou chaîne de caractères.

Dans une condition à cas multiples, il faut un cadre pour chaque cas valeur possible du sélecteur. Vous avez la
possibilité de définir une condition sur un intervalle, par exemple pour un sélecteur de type entier :
..0 tout entier inférieur ou égal à 0
1..9 tout entier entre 1 et 9
10.. tout entier supérieur ou égal à 10
Par défaut tous les autres cas non définis

Une structure Condition doit avoir une condition associée à chaque valeur possible du sélecteur. Un moyen facile
de remplir cette obligation est de spécifier une condition par défaut (clic droit "Désigner cette condition comme
défaut").
Le sélecteur peut aussi être du type chaîne de caractères ; les conditions s'écrivent alors entre guillemets ("toto" par
exemple).

2.4. La structure Séquence

Dans la plupart des langages de programmation, les instructions s’exécutent dans l’ordre d’apparition dans le
programme. La structure Séquence, qui ressemble à des plans de film permet d’exécuter un diagramme de
manière séquentielle.

Dans un langage graphique, en revanche, l’ordre d’exécution des tâches n’est pas défini. Il faut en effet raisonner
en terme de flux de données. Autrement dit, le déroulement du programme s’effectue au rythme d’arrivée des
données. Cette approche peut présenter dans certains cas quelques difficultés car elle augmente le temps
d’exécution d’un VI.

- 7/ 34 -
2.5. Les registres à décalage

Les registres à décalage (disponibles pour les boucles While et les boucles For) transfèrent des valeurs d’une
itération de boucle à la suivante. Vous pouvez créer un registre à décalage en cliquant sur la boucle et en
sélectionnant Ajouter un registre à décalage.
Le registre à décalage contient une paire de terminaux situés sur chacun des côtés verticaux de la bordure de la
boucle.

Le terminal de droite enregistre les données à la fin d’une itération. A la fin de l’itération, ces données se déplacent
et apparaissent dans le terminal de gauche au début de l’itération suivante, comme indiqué dans l’illustration ci-
dessous. Un registre à décalage peut transmettre tout type de données :
- numérique, booléen, chaîne de caractères, tableau, etc.

Le registre à décalage s’adapte au type de données du premier objet que vous lui câblez.

Vous pouvez configurer le registre à décalage de façon à voir les valeurs provenant de plusieurs itérations
précédentes. Cette fonction est utile pour faire la moyenne de points. Pour accéder à des valeurs provenant
d’itérations précédentes, créez des terminaux supplémentaires en ouvrant le menu local sur le terminal de gauche
ou de droite et en choisissant Ajouter un élément.
Par exemple, si un registre à décalage contient trois éléments dans le terminal de gauche, vous pouvez accéder aux
valeurs provenant des trois dernières itérations.

- 8/ 34 -
Chapitre 3. - Variables locales, Nœuds de propriété et
Graphes

3.1 Les variables locales

Sous LabVIEW, comme dans d’autres langages de programmation tels que le C/C++, toute variable utilisée est
locale c’est à dire qu’elle n’existe que dans le VI dans lequel elle est définie.
Néanmoins, la palette Fonctions → Structure possède un objet « Local » qui permet de créer une variable locale.
Grâce à cet objet, vous pouvez créer plusieurs copies d’une même variable à des endroits différents d’un VI ou
d’un sous-VI.

Ceci sera particulièrement utile dans deux situations :


si le diagramme est important et que vous avez besoin de la même variable en deux endroits distants (éviter
les fils longs qui croiseraient trop de fils),
si la même variable sert en entrée et en sortie.

Dans LabVIEW, les entrées sont définies par des commandes et les sorties par des indicateurs. Ce sont des objets
distincts : il n’est pas possible par exemple de câbler un indicateur sur l’entrée d’une fonction.
Or il est courant dans un programme d’utiliser la même variable en entrée et en sortie. On calcule la somme des N
premiers nombre entiers par :

s=0
for i=1 to N
s=s+i
next i
Afficher s

Dans l’instruction s=s+i, le s de s+i est l’une des entrées de la somme alors que le résultat s est une sortie. Ceci
signifie simplement que on ajoute i à la valeur lue à l’adresse mémoire s puis que le résultat de la somme est écrit à
cette même adresse.
Pour créer ce code dans LABVIEW, on peut utiliser une variable locale.

Quand on dépose sur le diagramme l’icône « Local », la boite qui


s’affiche contient ? ce qui signifie que cette variable est alors non
définie. Un clic droit sur cette boite fait apparaître l’option
« Sélectionner un élément ».

En cliquant sur cette option, on obtient la liste de tous les indicateurs


et commandes définis dans le VI. Il suffit de cliquer sur celui dont on
veut que la variable locale soit une copie.

- 9/ 34 -
3.2 Les nœuds de propriétés

Un nœud de propriété permet d’obtenir ou de définir les propriétés d'une application, d'un objet ou d'un
VI. On peut ainsi initialiser une variable, définir des attributs …

Par exemple, pour l’indicateur « Nombre » ci-dessous, en cliquant droit sur l’indicateur puis Créer →
Nœud de propriété, on obtient les attributs ci-dessous du nœud de propriété de l’indicateur.

3.3 Graphe déroulant multi courbes

Un graphe déroulant peut afficher plus d’une courbe. Pour cela, vous devez assembler les
données en utilisant la fonction Assembler (sous-palette Cluster).

Dans l’exemple ci-dessous, cette fonction “assemble” ou regroupe dans une structure appelée cluster les données en
sortie de trois sous-VIs qui mesurent la température pour les afficher dans un graphe déroulant.

On remarque que le graphe déroulant s’adapte au type de


données qu’elle reçoit.
Pour rajouter d’autres courbes, augmentez simplement le
nombre de terminaux d’entrées de la fonction Assembler en
redimensionnant la fonction avec l’outil Flèche.

- 10/ 34 -
Exercice 2 : Moyenne_aleatoire.vi
Vous allez construire un VI qui affiche deux courbes sur un graphe déroulant. Les courbes seront :
- La valeur de la température du VI « générateur température aléatoire »,
- La valeur de la moyenne des quatre dernières températures (utiliser un registre à décalage)

Dans cet exercice, vous utiliserez une boucle For (N = 200) au lieu d’une boucle While. Essayez de construire un
graphe déroulant semblable à celui représenté ci-dessous.

3.4 Effacement d’un graphe par programme

L’attribut «Historique » d’un graphe déroulant permet d’effacer automatiquement un graphe en début de
programme.

Pour que dans le programme précédent le graphe s’efface automatiquement au début du programme, il faut inclure
le diagramme précédent dans l’étape 1 d’une séquence dont l’étape 0 est donnée ci-contre.

Pour créer ce diagramme :


• créer la séquence et visualiser l’étape 0
• dans le diagramme, faire un clic droit sur le graphe
• sélectionner Créer → Nœud de propriété → données
d'historique
• placer l’icône à l’intérieur de l’étape 0
• changer la propriété en écriture

- 11/ 34 -
Quand on crée un « Nœud de propriété» (dans Fonctions → Contrôle d'applications), il faut :
• Clic droit sur le nœud de propriété → Sélectionner un terminal dont on veut contrôler une propriété
(lier à…)
• Cliquer sur la propriété à définir, ici « Historique »
• Créer la constante ou la commande à affecter à cet attribut.

Il est plus simple de créer un nœud de propriété en faisant un clic droit sur l'élément dont on veut programmer
la propriété (clic droit sur un graphe par exemple).

La meilleure façon de ne pas se tromper de type de donnée est de laisser LabVIEW créer cette constante, en
utilisant « Créer une constante » après un clic droit sur la propriété.

3.5 Créer un graphe XY

L’icône permettant de créer ces graphes est dans la palette Commandes → Graphe → Graphe XY Express

Le diagramme ci-dessous trace la courbe y=2x+1.

Ajout automatique : conversion des données en dynamique

On utilise l’auto-indexation pour construire les deux listes x et y (tunnels de sortie non pleins).

- 12/ 34 -
Chapitre 4. - Tableaux
Un tableau regroupe des éléments de données de même type. Il possède une ou plusieurs dimensions, avec jusqu’à
231 éléments par dimension si la mémoire le permet. Les tableaux de LabVIEW peuvent être de tout type.
Cependant, il n’est pas possible de créer un tableau de tableaux, de graphes déroulants ou de graphes.

On accède à chaque élément d’un tableau grâce à son indice. L’indice s’inscrit entre 0 et N-1, où N représente le
nombre d’éléments du tableau. Le tableau à une dimension (1D) suivant illustre cette structure. Notez que le
premier élément possède l’indice 0, le deuxième l’indice 1 et ainsi de suite.

Note : Un tableau à une dimension (1D) peut être représenté indifféremment en ligne ou en colonne.

4.1 Créer des commandes et des indicateurs de type tableau

Vous créez une commande ou un indicateur de type tableau en combinant un tableau vierge avec un élément
valide, qui peut être un nombre, un booléen, une chaîne de caractères ou un cluster.
Quand vous placez un tableau sur la face avant, ce n’est qu’un cadre (une structure de données) mais le type de ces
données n’est encore pas défini. C’est en plaçant dans ce cadre un objet du type adéquat, sélectionné dans C
Commandes que le tableau sera totalement défini.

Etape 1 : Sélectionnez un tableau vierge dans la palette Tableau & Cluster de la palette Commandes.

Etape 2 : Pour créer un tableau, glissez un élément valide (Numérique ou booléen ou chaîne de caractère,
commande ou indicateur) dans la fenêtre du tableau vide.

Exemple : si on glisse une « commande numérique » dans un tableau vierge, on obtiendra un tableau de
commandes numériques.

Tableaux à 2 dimensions
Un tableau à deux dimensions (2D) comporte deux indices : un indice de colonne et un indice de ligne (les deux
débutant à zéro) afin de pouvoir localiser un élément. L’exemple ci-dessous est un tableau de N-lignes par
M-colonnes, où N=5 et M=7.

Vous ajoutez une dimension à un tableau en ouvrant le


menu local de l’affichage de l’indice et en sélectionnant
l’élément Ajouter une dimension.

- 13/ 34 -
4.2 L’auto-indexation

Les structures de boucle For et de boucle While peuvent indexer et accumuler automatiquement des tableaux à
leurs frontières. Ceci s’appelle l’auto-indexation. L’illustration ci-dessous montre une boucle For auto-indexant un
tableau.

Chaque itération de la boucle crée l’élément suivant du tableau. Quand la boucle est achevée, le tableau est passé à
l’indicateur.
Le fil de liaison devient plus épais quand il véhicule un tableau à la limite de la boucle.

Exemple : on souhaite afficher les nombres entiers (0 à 9) généré par une boucle for :
Tunnel de boucle

Indicateur numérique avec activation de l’auto-


indexation sur le tunnel de boucle

Indicateur numérique avec activation de


l’auto-indexation sur le tunnel de boucle

Tableau d’indicateur numérique avec activation


de l’auto-indexation sur le tunnel de boucle

Tableau d’indicateur numérique avec


désactivation de l’auto-indexation sur le tunnel
de boucle

Explications :
L’auto-indexation est le mode par défaut de LabVIEW quand vous exportez des données d’une boucle. Les
données sont stockées pendant la durée de la boucle ; à la fin de la boucle, elles sont exportées sous forme d’un
tableau.
C’est pour cela que le premier diagramme est incorrect : on ne peut affecter un tableau à un indicateur simple (et
inversement pour le quatrième diagramme).

- 14/ 34 -
4.3 Les tableaux et les graphes

Un graphe est une représentation graphique à deux dimensions d’un ou de plusieurs tableaux de données appelés
tracés. LabVIEW fournit deux types de graphes : les graphes et les graphes XY.

Clusters : Pour utiliser les graphes, il est important d’avoir une connaissance rudimentaire d’une autre structure
de LabVIEW : le cluster.

Un cluster est une structure de données pouvant contenir des données de différents types. Vous pouvez imaginer un
cluster comme étant un paquet de fils de liaison, un peu comme un câble téléphonique. Chaque fil dans le câble
représente un élément différent du cluster.

Exercice 3 : Graphe_calcul_temperature.vi
Vous allez construire un VI qui mesure la température toutes les 0,2 secondes pendant 10 secondes (Utiliser le VI
generateur_temperature_aleatoire.vi).

Au cours de l’acquisition, le VI affiche les mesures en temps réel sur un graphe déroulant. Une fois l’acquisition
terminée, le VI trace les données sur un graphe et calcule les températures minimale, maximale et moyenne.

Le diagramme :

generateur_temperature_aleatoire.vi

la fonction « Max & Min d’un tableau » se trouve dans Fonctions → Tableau
l’opérateur « Moyenne » se trouve dans Fonctions → Mathématiques → Probabilités et statistiques

Exercice 4 : Graphe_calcul_temperature2.vi
Compléter le VI "Graphe_calcul_temperature.vi" afin :

1.- D’initialiser le graphe et les indicateurs numériques.


2.- Afficher sur un graphe déroulant les valeurs des différentes températures ainsi que les valeurs min et max.
3.- En utilisant un tableau à l’intérieur de la boucle, afficher, pour chaque exécution de boucle, les
différentes températures ainsi que la valeur max, la valeur min et la moyenne.

- 15/ 34 -
Chapitre 5. - Chaînes de caractères

5.1. Les fonctions de chaînes de caractères

- La fonction Longueur d’une chaîne de caractères retourne le nombre de caractères (octets) contenus
dans une chaîne de caractères.

- La fonction Concaténer des chaînes de caractères assemble des chaînes de caractères en entrée en une
chaîne de caractères simple de sortie.

- La fonction Sous-ensemble d’une chaîne de caractères retourne une sous-chaîne de la chaîne de


caractères d’origine, commençant à offset et comprenant le nombre de caractères définis par longueur.

- La fonction Rechercher une expression cherche une expression dans la chaîne de caractères à partir
d’offset. Si une correspondance est obtenue, cette fonction divise la chaîne de caractère en trois sous-
chaînes de caractères ; sinon, la sous-chaîne correspondante est vide et l’offset après correspondance
vaut -1.

Dans de nombreux cas, vous avez à convertir des chaînes de caractères en nombres et des nombres en chaînes de
caractères. La fonction Formater en chaîne de caractères convertit un nombre en chaîne de caractères et la
fonction Balayer une chaîne de caractères convertit une chaîne de caractères en nombres. Ces deux fonctions
permettent la gestion d’erreur.

- La fonction Formater en chaîne de caractères convertit des arguments d’entrée en une chaîne de
caractères dont le format est déterminé par la chaîne de format. Vous pouvez augmenter le nombre de
paramètres à convertir en une chaîne de caractères. Dans l’exemple suivant, la fonction convertit le
nombre à virgule flottante 1,28 en la chaîne de caractères à 6 octets “1.2800.”

- La fonction Balayer une chaîne de caractères convertit une chaîne de caractères contenant des
caractères numériques valides (0 à 9, +, -, e, E et période…) en un nombre. La fonction commence le
balayage de la chaîne de caractères d’entrée à la position de recherche initiale. Cette fonction balaye
la chaîne d’entrée et la convertit en divers types de données (par exemple nombres et booléens) selon la
chaîne de format. Cette fonction peut avoir plusieurs sorties.
Dans l’exemple ci-dessous, la fonction convertit la chaîne de caractères “VOLTS DC+1.28E+2” en
128.00. La fonction commence le balayage au neuvième caractère de la chaîne (qui correspond au +).
(L’offset du premier caractère vaut zéro).

- 16/ 34 -
Exercice 5 : Concatener_Chaines_caracteres.vi
Vous allez créer un sous-VI en utilisant les fonctions « Formater en chaîne de caractère », « Concaténer des
chaînes de caractères » et « Longueur d’une chaîne de caractères ».

Vous allez construire un VI qui convertit un nombre en chaîne de caractères et assemble celle-ci avec d’autres
chaînes de caractères pour former une chaîne de sortie.
Le VI détermine également la longueur de la chaîne de sortie.

La fonction va assembler les valeurs d’entrée des deux commandes de chaînes de caractères et de la commande
numérique (glissière à niveau verticale) pour former une chaîne de sortie et elle affichera cette dernière dans
l’indicateur de chaîne. L’indicateur numérique affichera la longueur de la chaîne.
Utiliser le menu contextuel sur la fonction "Formater en chaîne de caractères" (clic droit, Editer la chaîne de
format) afin de ne garder que deux chiffres après la virgule pour la valeur.

Le diagramme :

A partir de ce VI, créez le sous-VI permettant de concaténer une chaîne de caractères, une valeur et une autre
chaîne de caractères, en l'enregistrant sous le nom "Concatener_chaines.vi" (réutilisé par la suite). Pour cela,
sélectionner la partie utile du VI précédent, puis dans le menu Edition → Créer sous-VI. Il ne reste plus qu'à ouvrir
ce nouveau sous-VI (double cliquer dessus), créer l'icône et l'enregistrer.

Exercice 6 : Chaines_caracteres_choix_signal.vi
Vous allez reprendre l'exercice précédent et le modifier afin de permettre à l'utilisateur de choisir entre plusieurs
types de signaux (Grandeur physique et Unité).

Utilisez un Menu déroulant pour que l'utilisateur choisisse entre Tension (Volts), Intensité (Ampères) et
Résistance (Ohms). Utilisez une structure Condition pour traiter l'information venant du Menu déroulant et
remplacer les informations "en-tête" et "fin".

- 17/ 34 -
Exercice 7 : Decomposition_chaines_caracteres.vi
Un appareil de mesure (Multimètre par exemple) renvoie la chaîne de caractères « DC1,003V » lors d’une
transmission série.

Ecrire un VI permettant d’afficher dans un indicateur numérique la valeur de la tension mesurée à partir de la
chaîne de caractères reçue.

Exercice 8 : Chaines_caracteres_choix_signal.vi
En utilisant Concatener_chaines_caracteres.vi" et Decomposition_chaines_caracteres.vi", construire un
VI :

1.- Génère automatiquement un tableau de 10 chaînes de caractères « DC2,003V », « DC6,013V »,


« DC1,543V » … avec une tension aléatoire comprise entre 0,000V et 10,000V (avec 3 chiffres après
virgule).
2.- Décompose le tableau de 10 chaînes de caractères pour créer un tableau contenant uniquement les 10
valeurs des tensions.

- 18/ 34 -
Chapitre 6. - Les Entrées/Sorties sur fichiers

Les opérations de sauvegarde de données dans un fichier nouveau ou existant impliquent un processus en trois
étapes :
1- ouvrir ou créer un fichier,
2- écrire des données dans le fichier,
3- fermer le fichier.

Avec les VIs de fichiers, vous pouvez écrire tout type de données dans le fichier que vous avez ouvert ou créé. Si
d’autres utilisateurs ou applications doivent accéder au fichier, vous devez écrire les données en chaînes de
caractères au format ASCII dans le fichier.

Attention : ne sauvegardez jamais un fichier de données dans une librairie .llb. Vous la rendriez inutilisable.

Il y a deux façons d’accéder à un fichier : vous pouvez le faire par programme ou utiliser une boîte de dialogue.
Pour y accéder en utilisant une boîte de dialogue, vous ne câblez pas le champ chemin du fichier du VI
Ouvrir/Créer/Remplacer un fichier. Vous pouvez gagner du temps dans la méthode de programmation en
câblant le nom du fichier et son chemin au VI.

L’exemple ci-dessous indique les étapes pour lire des données dans un fichier existant en demandant le nom du
fichier à ouvrir :

Les différents sous-VIs sont dans Programmation → E/S sur fichiers


Programmation → Informations temporelles

Le VI Ouvrir/Créer/Remplacer un fichier ouvre une boîte de dialogue de fichiers (dont vous pouvez
modifier le titre) dans laquelle vous sélectionnez le fichier à ouvrir.
Il transmet le refnum, le cluster erreur et la taille du fichier à la fonction Lire un fichier.
Cette fonction lit alors le nombre d’octets de données en commençant au début du fichier.
La fonction Fermer un fichier ferme le fichier. Ensuite le VI Gestionnaire d’erreur simple détermine
s’il y a des erreurs.

Ces clusters représentent la méthode LabVIEW de gestion des erreurs et sont des outils puissants et intuitifs.
On remarque que erreur et refnum sont transmis d’un VI de fichier à l’autre. Du fait qu’un noeud ne peut
s’exécuter tant qu’il n’a pas reçu toutes ses entrées, le passage de ces deux paramètres oblige les VIs de fichiers à
s’exécuter dans l’ordre.

- 19/ 34 -
6.1. Lire un fichier texte

De nombreuses applications enregistrent les données au format du fichier texte.


LabVIEW permet très rapidement d’ouvrir un fichier au format .txt pour afficher les données dans un indicateur
texte

Voici un exemple de VI permettant de lire un fichier PointsMesures.txt contenant 5 mesures et de le copier dans un
tableau :

Figure 1 - FichierMesures.txt

Figure 2 - Face-Avant lecture FichierMesures.txt

Figure 3 - Diagramme lecture FichierMesures.txt

- 20/ 34 -
6.2. Lire un fichier texte au format tableur

Les fichiers tableur (MS Excel ou OpenOffice Calc) ont des formats de codage bien particulier. Il n’est pas possible
de les ouvrir simplement sous Excel.

Pour utiliser le VI « Lire un fichier tableur », vous devez convertir votre fichier de mesures dans un format
Type Texte (séparateur tabulation)

Par exemple, l’enregistrement du fichier tableur Excel FichierTableurMesure.xls dans ce format texte
avec séparateur tabulation génère le fichier suivant :

Figure 4 - Exemple VI pour lire fichier texte au format tableur

- 21/ 34 -
Exercice 9 : Concatenation_chaines_dans_fichier.vi
Créer le VI dont le diagramme est donné ci-dessous.
Vous utiliserez le sous-VI « concatener_chaines.vi » qui concatène deux chaînes de caractères d’entrée et une
valeur en une chaîne de caractères combinée.

Le diagramme :

1- Entrez des valeurs dans les commandes de la face-avant et exécutez le VI. Tapez fichier_ecriture.txt dans
la boîte de dialogue, puis cliquez sur OK.
2- Enregistrez ce VI sous concatenation_chaines_dans_fichier.vi

Exercice 10 : Lecture_affichage_caracteres.vi
Créer le VI dont le diagramme est donné ci-dessous.

Le diagramme :

1- Exécutez le VI. Une boîte de dialogue apparaît. Cherchez le fichier fichier_ecriture.txt et cliquez sur
Ouvrir ou OK.
2- Enregistrez ce VI sous lecture_affichage_caracteres.vi

- 22/ 34 -
6.3. Ecrire dans un fichier texte au format tableur

Une application très courante d’enregistrement des données dans un fichier est le formatage du fichier texte afin de
l’ouvrir dans un tableur. Dans la plupart des tableurs, des tabulations séparent les colonnes et des caractères « fin
de ligne » séparent les lignes.

Utilisez la fonction Concaténer des chaînes de caractères ou la fonction Formater en chaîne de caractères
pour insérer des tabulations entre chaque élément et un caractère de fin de ligne après le dernier élément.

Le diagramme ci-dessous crée le fichier dont le contenu est affiché en dessous. La fonction Formater en chaînes
de caractères convertit tout d’abord le compteur d’itération et le nombre aléatoire en chaînes de caractères. La
fonction inclut aussi une tabulation et un caractère de fin de ligne pour formater les données en une chaîne de
caractères de tableur avant de l’écrire dans le fichier.

Exercice 11 : Ecriture_fichier_tableur.vi
Créer le VI dont le diagramme est donné ci-dessous.

Le diagramme :

Contenu du fichier créé :


0 0,074748
1 0,005961
2 0,194692
3 0,073651
4 0,136096

- 23/ 34 -
Exercice 12 : temperature_tableur.vi
Vous allez enregistrer des données dans un fichier sous une forme accessible à un tableur ou à un traitement de
texte.

Utilisez le sous-VI "Generateur_temperature_aleatoire.vi" et créez un VI pour enregistrer l’heure et la


température dans un fichier.
Enregistrez ce VI sous le nom "Temperature_tableur.vi"

Le diagramme :

1- Exécutez le VI. Une boîte de dialogue apparaît, vous invitant à saisir un nom de fichier. Tapez
fichier_ecriture.txt et cliquez sur OK.

2- Utiliser un traitement de texte ou un tableur pour ouvrir le fichier que vous avez créé.

- 24/ 34 -
6.4. Ecrire dans un fichier Excel

Le logiciel LabVIEW met à disposition un VI Express (couleur bleue) permettant de générer un fichier Excel.

Figure 5 - VI permettant de générer un fichier Excel à partir d’un tableau de mesures

- 25/ 34 -
Exercice 13 : Temperature_application.vi
Dans cet exercice, vous allez appliquer ce que vous avez appris jusqu’ici dans ce cours.
Il s’agit de créer un VI qui offre les fonctions suivantes :
1- Il mesure une température une fois par seconde jusqu’à l’arrêt du VI.
2- Il affiche sur un graphe déroulant la température qui vient d’être mesurée ainsi que la moyenne des trois
dernières valeurs.
3- Si la température dépasse une limite prédéfinie, il allume un voyant lumineux sur la face-avant.
4- Après chaque mesure, il enregistre la date, l’heure (secondes incluses), la température, la moyenne des
trois dernières mesures et un message indiquant si la température est normale ou si elle dépasse la limite
(“Normale” ou “Dépassée”). L’enregistrement est tel que chaque élément apparaît dans une des colonnes
d’un tableur.
5- Après l’arrêt de l’acquisition, il trace les points de mesure brute de la température dans un graphe et
affiche les températures moyenne, maximale et minimale.

Conseil : commencez avec le VI "Temperature_tableur.vi" Pour l’étape 5, copiez et collez les portions
appropriées provenant du VI "graphe_calcul_temperature.vi".

- 26/ 34 -
6.5. Tables

Une table est une commande de la face-avant utilisée pour transmettre ou afficher des données au format
tabulaire. Le type de données d’une table correspond à un tableau de chaînes de caractères 2D ; les tables peuvent
être de toute taille, selon l’espace mémoire disponible.
La table de l’illustration ci-dessous se compose de 2 lignes et 4 colonnes. Les en-têtes optionnels des lignes et des
colonnes sont aussi affichés.

La commande ou l’indicateur de
table se situe dans Commandes →
Liste et table

L’indicateur (ou la commande) de table est un tableau de chaînes de caractères à deux dimensions. Par
conséquent, vous devez convertir les tableaux numériques 2D en tableaux de chaînes de caractères avant de
pouvoir les afficher dans un indicateur de table.

Les en-têtes des lignes et des colonnes n’apparaissent pas automatiquement comme dans un tableur. Vous devez
créer un tableau de chaînes de caractères 1D pour les en-têtes des lignes et des colonnes.

Exercice 14 : table.vi
Créer le VI dont le diagramme est donné ci-dessous.
Enregistrez ce VI sous table.vi

Le diagramme :

- 27/ 34 -
Exercice 15 : Table_excel.vi
Vous allez enregistrer un tableau 2D dans un fichier texte pour qu’un tableur puisse y accéder et que des
données numériques puissent s’afficher dans une table.
Dans l’exercice précédent, vous avez formaté la chaîne de caractères pour que des tabulations séparent les
colonnes et que des caractères de fin de ligne séparent les lignes. Ici, vous allez examiner un VI qui enregistre des
tableaux de nombres dans un fichier au format compatible avec un tableur.

La face-avant :

Le diagramme :

Le VI génère un tableau 2D (128 lignes x 3 colonnes). La première colonne contient les points d’une sinusoïde.
La seconde colonne contient les points d’une courbe cosinus.
Le VI trace chaque colonne dans un graphe et affiche les données obtenues dans un indicateur de table. Une fois
que le VI a affiché et tracé les courbes, il affiche une boîte de dialogue pour y entrer le nom du fichier. Tapez
wave.txt et cliquez sur OK ou Enregistrer. Vous examinerez ultérieurement le fichier que le VI vient de
créer.

Le sous-VI « Motif sinusoïdal » se trouve dans Analyse → Traitement du signal → Génération


de signaux
Le sous-VI « Nombre en chaîne fractionnelle » se trouve dans Chaîne → Conversions
Chaîne/nombre

- 28/ 34 -
Chapitre 7. - Acquisition de données sous LabVIEW

La bibliothèque d’Acquisition de données de LabVIEW contient les VIs pour contrôler les cartes
enfichables DAQ de National Instruments.
Une carte peut souvent avoir une variété de fonctions : conversion analogique-numérique (A/N), conversion
numérique-analogique (N/A), entrée/sortie numérique (E/S) et les opérations de compteur/timer.

Chaque carte supporte des vitesses d’acquisition et de génération du signal différentes. De plus, chaque carte
est destinée à une plate-forme matérielle et un système d’exploitation spécifiques.

7.1. Rappels sur l’acquisition d’un signal analogique


Quand vous mesurez des signaux avec une carte d’acquisition, vous devez considérer les facteurs qui affectent la
qualité du signal numérisé suivants :
le mode (entrées asymétriques ou différentielles), la résolution, la gamme,
la fréquence d’échantillonnage, la précision.

7.1.1. Mode asymétrique et mode différentielle

Systèmes de mesure asymétriques référencés et non référencés

Un système de mesure RSE (asymétrique référencé) mesure une tension par rapport à la masse, AIGND dans la
figure, qui est directement connectée à la masse du système de mesure. La figure montre un système de mesure
asymétrique référencé à 8 voies.

Les périphériques DAQ de National Instruments emploient souvent une variante de la technique de mesure
asymétrique référencée, la méthode NRSE (asymétrique non référencée).

Système RSE Système NRSE

- 29/ 34 -
Il est préférable d'utiliser un système de mesure différentiel ou NRSE pour mesurer une source de signal mise à
la terre. Si vous utilisez un système de mesure RSE avec une source mise à la terre, le résultat est généralement un
système de mesure bruité montrant souvent les composantes fréquentielles de la ligne de tension (60 Hz) dans les
mesures. Du bruit introduit par les boucles mises à la terre peut avoir à la fois des composants CA et CC,
introduisant des erreurs d'offset et du bruit dans les mesures. La différence de potentiel entre les deux masses
engendre un courant qui circule dans l'interconnexion. Ce courant s'appelle courant de boucle mise à la masse.

Toutefois, vous pouvez toujours utiliser un système de mesure RSE si les niveaux de tension du signal sont élevés
et que le câblage de l'interconnexion entre la source et le périphérique de mesure a une impédance basse. Dans ce
cas, la mesure de la tension du signal est altérée par la boucle mise à la masse, mais l'altération est acceptable.
Vous devez faire attention à la polarité de la source de signal mise à la masse avant de connecter le signal à un
système de mesure référencé à la masse car la source du signal peut être court-circuitée à la masse, ce qui peut
endommager la source du signal

Système de mesure différentiel

Un système de mesure différentiel n'a aucune de ses entrées liées à une référence fixe telle que la masse ou la
terre. Un système de mesure différentiel est semblable à une source de signal flottante étant donné que la mesure
est effectuée par rapport à la masse flottante qui est différente de la masse du système de mesure.

La figure ci-dessous montre l'implémentation d'un système de mesure différentiel à 8 voies utilisé dans un
périphérique NI classique. Les multiplexeurs analogiques sont utilisés sur le chemin du signal pour augmenter le
nombre de voies de mesure lorsqu'il n'y a qu'un seul amplificateur d'instrumentation. Pour ce périphérique, la
broche libellée AIGND, la masse de l'entrée analogique, est la masse du système de mesure.

Système Différentiel

Toutefois, si vous utilisez un système de mesure différentiel, assurez-vous que le niveau de tension en mode
commun du signal par rapport à la masse du système de mesure reste dans la gamme d'entrée en mode commun
du périphérique de mesure. Divers phénomènes, notamment les courants de polarisation d'entrée de
l'amplificateur d'instrumentation, peuvent déplacer le niveau de la tension de la source flottante hors de la gamme
valide de l'étage d'entrée d'un périphérique DAQ.

Les entrées asymétriques (single-ended) sont toutes référencées à un point de masse commun. Vous utilisez ces
entrées quand les signaux d’entrée sont de haut niveau (plus grand que 1 V), quand les fils conduisant le signal
source à l’entrée analogique sont courts (moins de 5 m) et que tous les signaux d’entrée partagent une référence à
la masse commune. Si les signaux ne répondent pas à ces critères, vous devez utiliser des entrées différentielles.

Avec des entrées différentielles, chaque entrée peut avoir sa propre référence. Les entrées différentielles réduisent
ou éliminent aussi les erreurs dues au bruit car le bruit en mode commun récupéré aux fils conduisant le signal
source est annulé.

- 30/ 34 -
7.1.2. Résolution – Gamme – Gain

La résolution (resolution) est le nombre de bits utilisés par le convertisseur analogique/numérique (A/N) pour
représenter un signal analogique. Plus la résolution est élevée, plus le nombre de divisions de la gamme du
convertisseur A/N est élevé, et plus les changements détectables sont faibles.

La figure ci-dessous montre un signal sinusoïdal et son image numérisée par un convertisseur A/N 3 bits. Un
convertisseur A/N 3 bits divise le signal d’entrée en 23 états distincts, soit 8 divisions. A chaque division
correspond un code binaire compris entre 000 et 111. Il apparaît clairement que le signal numérique ne représente
pas rigoureusement le signal initial à cause de la perte de données pendant la conversion. En augmentant la
résolution à 16 bits, le nombre de divisions passe de 8 à 65 536 (216). Le convertisseur A/N permet alors d’obtenir
une représentation beaucoup plus précise du signal analogique.

La gamme (range) fait référence aux niveaux de tension analogique minimum et maximum qu’un convertisseur
A/N est capable de numériser.
De nombreux périphériques DAQ sont dotés de gammes pouvant être sélectionnées (typiquement de 0 à 10 V ou -
10 à 10 V) pour adapter la gamme du convertisseur A/N à celle du signal afin d’utiliser au mieux la résolution
disponible.

Le gain (gain) constitue l’amplification ou l’atténuation d’un signal qui peut se produire avant que le signal ne
soit numérisé. En appliquant un gain au signal, vous pouvez diminuer efficacement la gamme d’entrée d’un
convertisseur A/N et ainsi permettre au convertisseur A/N d’utiliser autant de divisions que possible pour
représenter le signal.
Par exemple, en utilisant un convertisseur A/N 3 bits et une gamme du périphérique comprise entre 0 et 10 V, la
figure ci-dessous montre les effets du gain sur un signal qui fluctue entre 0 et 5V. Avec aucun gain, ou un gain=1,
le convertisseur A/N n’utilise que 4 des 8 divisions pour la conversion.
En amplifiant le signal avec un gain de deux avant numérisation, le convertisseur A/N utilise les huit divisions et
la représentation numérique est beaucoup plus exacte. La carte a alors accès à une gamme de 0 à 5 V, car tout
signal au-dessus de 5 V donne une entrée au convertisseur A/N supérieure à 10 V quand il est amplifié par un
facteur deux.

- 31/ 34 -
La gamme, la résolution et le gain d’une carte DAQ déterminent le plus petit changement détectable. Ce
changement de tension représente la valeur numérique du bit de poids faible : LSB (Least Significant Bit).
Par exemple, un périphérique DAQ 12 bits avec une gamme d’entrée de 0 à 10 V permet de détecter un
changement de 2,4 mV, alors que le même périphérique avec une gamme de tension d’entrée de -10 à 10 V ne
peut détecter qu’un changement de 4,8 mV.

7.1.3. Fréquence d’échantillonnage

La fréquence d’échantillonnage (sampling rate) détermine la fréquence de conversion A/N. Une fréquence
d’échantillonnage rapide acquiert davantage de points dans un temps donné et peut ainsi souvent donner une
meilleure représentation du signal original qu’une fréquence d’échantillonnage lente.
Tous les signaux d’entrée doivent être échantillonnés à une fréquence adéquate pour reproduire fidèlement le
signal analogique. Echantillonner trop lentement peut aboutir à une représentation de mauvaise qualité de votre
signal analogique.
La figure ci-dessous montre un signal échantillonné correctement, ainsi que les effets du sous-échantillonnage. Le
sous-échantillonnage fait apparaître le signal avec une fréquence fantôme différente de celle qu’il a réellement,
appelé aussi phénomène d’aliasing ou repliement.

La fréquence d’échantillonnage doit, selon le théorème de Nyquist, être supérieure au double de la fréquence la
plus élevée contenue dans le signal.
Par exemple, les signaux audio convertis en signaux électriques ont souvent une fréquence élevée de plus de 20
KHz ; vous avez donc besoin d’un périphérique DAQ avec une fréquence d’échantillonnage supérieure à 40 KHz
pour acquérir convenablement le signal.

- 32/ 34 -
7.2. Test de la carte NI-6024E avec MAX

MAX (Measurement Automation eXplorer) est un programme simple destiné à contrôler et configurer les
entrées et sorties disponibles de la carte NI6024E sans avoir à créer de programme sous LabVIEW. Vous lancez
MAX en cliquant sur l’icône disponible sur le bureau. MAX recherche alors les cartes NI présentes sur
l’ordinateur.

• Déployer l’arborescence de « Périphériques et interfaces → Périphériques NI-DAQmx »


→ Vous voyez alors apparaître la carte NI PCI-6024E : « Dev1 »
• Cliquer sur « Panneaux de test »
→ Sélectionner une voie sur laquelle envoyer une commande en tension (1 ou 2) puis définir la
tension à appliquer (dans l’étendue de mesure de la carte, [-10V,+10V]).
→ Vérifier, en la mesurant, la tension envoyée. (Pour que cette tension soit effectivement envoyée
sur la sortie, il faut cliquer sur « mise à jour de la sortie »).

7.3. Génération d’une tension continue en utilisant LabVIEW

Vous allez réaliser le VI suivant permettant de générer une tension sur la sortie analogique 0 (AO0) de la carte
d’acquisition.

Créer le diagramme ci-dessous en utilisant les VI de la bibliothèque « E/S de mesures → DAQmx –


Acquisition de données »
La tâche sera créée en faisant Créer → Commande à partir du VI « DAQmx – Démarrer une tâche ».

Paramétrage de la tâche : une tâche permet de définir et d’enregistrer toutes les informations de configuration
de la carte d’acquisition afin de l’utiliser dans une application de mesure ou de
génération. Une tâche est un ensemble d’une ou plusieurs voies virtuelles qui
comprend le cadencement, le déclenchement et d’autres propriétés.

Pour créer une tâche :


Faites « Parcourir » sur la commande de tâches de la face-avant puis faire « Créer un nouvel
objet → Tâche MAX ».
Faire ensuite « Sortie analogique → Tension ».
Choisir ensuite la voie physique ao0 de la carte PCI-6024E.
Appeler « TacheGenerationTension » le nom de cette tâche.

Expliquer le paramétrage de la tâche : paramètres de « Configuration de la tension d’entrée » et


« Cadencement de la tâche ».
Sauvegarder le VI sous generation_tension.vi

- 33/ 34 -
7.4. Mesure d’une tension continue en utilisant LabVIEW

• Le boîtier de connexion utilisé exige que toutes les entrées et sorties analogiques soient référencées par
rapport à la même masse.

Les entrées « limite haute-basse » permettent de définir les bornes entre lesquelles varie le signal mesuré. A
partir de cette information et de la configuration de la carte, LabVIEW règle automatiquement le gain à sa valeur
optimale.

Charger l’exemple « Acq&Graph Voltage-Int Clk.vi » à partir de « Aide → Recherche d’exemples


→ E/S Matérielles → DAQmx → Mesures analogiques → Tension ».
Enregistrer cet exemple dans votre répertoire sous le nom « mesure_tension.vi » et modifier-le
pour mesurer la tension générée par le VI précédent.
Expliquer le paramétrage du VI que vous avez choisi : Fréquence échantillonnage et Nombre
d’échantillons.

- 34/ 34 -