Introduction

Un dispositif de traitement informatique consomme et  traite des données en entrée, puis délivre des résultats en sortie:

 

traitementlabv

 

Comme la plupart des langages de programmation, ces données doivent respecter un format ou une structure.

Structures des données

Dans LabVIEW, il existe plusieurs types de données :

Les données du type chaîne, les données du type numérique, les données du type booléen, les données du type dynamique, les données du type tableau, les données du type cluster, les données du type enums.

Chaque type de données se distingue par la couleur de la fonction qui la représente.

 

Données de type chaîne :  datachartyp

Sur le diagramme, les données chaîne sont représentées dans LabVIEW par du rose.

Une chaîne est une séquence de caractères ASCII affichables ou non (le caractère « espace » du clavier n’est pas affichable).

Certaines des applications  utilisant les chaînes offrent les fonctions suivantes :

  • La création de messages textuels simples.
  • Le contrôle d'instruments par l'envoi de commandes textuelles à l'instrument et le renvoi de valeurs de données sous forme de chaînes binaires ou ASCII que vous convertissez ensuite en valeurs numériques

Sur la face-avant, les chaînes apparaissent comme des tables, des boîtes d'entrée de texte et des étiquettes.

 

Données de type numérique : datanumtyp1 ou datanumtyp2

Dans LabVIEW, les données numériques sont représentées comme des nombres en virgule flottante, des nombres en virgule fixe, des entiers, des entiers non signés et des nombres complexes.

Sur le diagramme, les données numériques en double ou simple précision ou complexes sont représentées par du orange ; tous les nombres entiers sont représentés par du bleu.

Remarque : la différence entre les différents types de données numériques est le nombre de bits qu'ils utilisent pour stocker les données et les valeurs des données qu'ils représentent.

 

Données de type booléen : databooltyp

Sur le diagramme, les données booléennes sont représentées en vert.

Vous pouvez utiliser un booléen dans LabVIEW pour représenter un 0 ou un 1, ou un VRAI ou FAUX. LabVIEW enregistre les données booléennes sous forme de valeurs de 8 bits. Si la valeur 8 bits est zéro, la valeur booléenne est FAUX. Toute valeur non nulle est VRAI.  Les commandes de face-avant de type commutateur dont l'action mécanique est souvent utilisée pour contrôler une structure d'exécution, telle qu'une structure Condition sont du type booléen.

 

Données de type dynamique : datadyntyp

La plupart des VIs Express acceptent et/ou renvoient des types de données dynamiques, qui apparaissent comme des terminaux bleu foncé.

En utilisant les VIs Convertir en données dynamiques et Convertir des données dynamiques, on peut convertir des données numériques en virgule flottante ou des données booléennes, des types de données suivants :

  • Tableau 1D de waveforms
  • Tableau 1D de scalaires
  • Tableau 1D de scalaires - valeur la plus récente
  • Tableau 1D de scalaires - une seule voie
  • Tableau 2D de scalaires - les colonnes sont les voies
  • Tableau 2D de scalaires - les lignes sont les voies
  • Scalaire unique
  • Waveform unique

On doit câbler des données de type dynamique à l'indicateur capable de les présenter de la meilleure manière. Les indicateurs comprennent un graphe, un graphe déroulant, un indicateur numérique ou un indicateur booléen. Cependant, comme les données dynamiques doivent subir une conversion automatique pour correspondre à l'indicateur auquel elles sont câblées, les VIs Express risquent de ralentir l'exécution du diagramme.

Le type de données dynamique est prévu pour être utilisé avec les VIs Express. La plupart des autres VIs et fonctions livrés avec LabVIEW n'acceptent pas ce type de données ; pour pouvoir les utiliser avec, il convient d'abord de convertir ces données.

Les données de type tableau :

Un tableau est un ensemble d’éléments de même type. 

Un tableau est défini par des éléments et des dimensions. Les éléments sont les points de données qui constituent le tableau. Une dimension est la longueur, la hauteur ou la profondeur d'un tableau. Un tableau peut avoir une ou plusieurs dimensions.

On peut construire des tableaux de données numériques, de booléens, de chemins, de chaînes, de waveforms et de clusters.

Les tableaux sont utiles pour stocker des données provenant de waveforms ou générées dans des boucles, où chaque itération d'une boucle produit un élément du tableau.

Remarque : les indices de tableau dans LabVIEW commencent à la valeur zéro, et ses éléments osnt ordonnés.  Pour un tableau de n éléments, le premier élément a pour indice 0 et le dernier élément a pour indice n-1.

Exemple de tableau à une dimension: tableau de commande numérique (tableau 1D)

Le premier élément visible dans ce tableau est à l’indice 1 et est 3.00 ; le second est 1.00 :

 

dataarraytyp1

 

Comment créer des commandes ou des indicateurs tableau sur la face avant ?

Créez une commande ou un indicateur tableau sur la face-avant en y plaçant un tableau vide, illustré dans la Figure suivante, et en y faisant glisser un élément ou un objet de données, lequel peut être une commande ou un indicateur numérique, booléen, chaîne, chemin, refnum ou cluster.

 

dataarraytyp2

 

Si on essaye de déplacer une commande ou un indicateur non valide dans l'enveloppe de tableau, il ne pourra pas être déposé dans l'enveloppe de tableau.

Avant d'utiliser un tableau sur le diagramme, il faut insérer un objet dans le tableau vide. Sinon, le terminal tableau est noir et aucun type de données n'apparaît entre les crochets.

Tableau à deux dimensions : tableau 2D

Il est représenté par son nombre de lignes et son nombre de colonnes :

Pour repérer un élément, on a besoin d'un indice de colonne et d'un indice de ligne, les indices commençant à zéro.

Pour ajouter un tableau multidimensionnel sur la face-avant, effectuez un clic droit sur l'afficheur d'indice et sélectionnez Ajouter une dimension dans le menu local. Vous pouvez aussi redimensionner l'afficheur d’indice (avec la souris) ;  jusqu'à ce que vous obteniez le nombre de dimensions souhaité.

Vous pouvez initialiser un tableau ou le laisser non initialisé.

Exemple de tableau non initialisé :

 

dataarraytyp3

Exemple de tableau initialisé avec neuf éléments :

 

dataarraytyp4

 

Comment créer une constante tableau sur un diagramme?

Pour créer une constante tableau sur le diagramme, sélectionner une constante tableau sur la palette Fonctions, positionner le tableau vide sur le diagramme et y placer une constante chaîne, une constante numérique, une constante booléenne ou une constante cluster. On peut utiliser une constante tableau pour enregistrer les données d'une constante ou pour effectuer une comparaison avec un autre tableau.

Auto-indexation des entrées de tableau autoindtunl

Si on câble un tableau à une boucle For ou une boucle While, on peut  associer chaque itération de la boucle à un élément de ce tableau en activant l'auto-indexation. Pour indiquer que l'auto-indexation est activée, l'image du tunnel passe d'un carré plein à l'illustration suivante. Pour changer l'état du tunnel, effectuez un clic droit sur le tunnel et sélectionnez Activer l'indexation ou Désactiver l'indexation dans le menu local.

Dans l’exemple de la figure qui suit, la boucle For s'exécute un nombre de fois égal au nombre d'éléments du tableau. Normalement, si le terminal de décompte de la boucle For n'est pas câblé, la flèche d'exécution est brisée. Cependant, dans ce cas-ci, la flèche d'exécution n'est pas brisée.

 

forloopautoindex

 

 

Les données de type cluster :

Les clusters regroupent des éléments de données de types différents. Le cluster d'erreur LabVIEW en est un exemple ; il comprend une valeur booléenne, une valeur numérique et une chaîne.

Ordre des éléments d’un cluster :

Bien que les éléments des clusters et des tableaux soient ordonnés, on peut désassembler tous les éléments d'un cluster en même temps en utilisant la fonction Désassembler. On peut utiliser la fonction Désassembler par nom pour désassembler les éléments d'un cluster d'après leur nom. Si on utilise la fonction Désassembler par nom, tous les éléments du cluster doivent avoir une étiquette.

Comment créer une commande ou un indicateur de type cluster  sur la face avant?

Créez une commande ou un indicateur cluster sur la face-avant en y plaçant un cluster vide, comme dans la face-avant suivante, et en y faisant glisser un élément ou un objet de données, comme une commande ou un indicateur numérique, booléen, chaîne, chemin, refnum ou cluster.

Lorsque vous déposez un cluster, vous pouvez le redimensionner en faisant glisser le curseur.

 

dataclustertyp1

Comment créer une constante cluster sur le diagramme ?

Pour créer une constante cluster sur le diagramme, sélectionnez une constante cluster sur la palette Fonctions, positionnez le cluster vierge sur le diagramme et mettez-y une constante chaîne, une constante numérique, une constante booléenne ou une constante cluster. Vous pouvez utiliser une constante cluster pour stocker les données d'une constante ou pour effectuer une comparaison avec un autre cluster.

On peut assembler pour modifier les éléments d’un cluster ou désassembler.

Exemple d’assemblage par nom :

 

databundlebyname

 

Exemple de désassemblage par nom :

 

dataunbundle1

 

 

Les données de type Enum :

Un énum (commande, constante ou indicateur énumération) est une association de types de données. Un énum représente une paire de valeurs (une chaîne et un numérique) qui peut faire partie d'une liste de valeurs. Par exemple, si vous avez créé un type d'énum appelé Mois, les paires de valeurs possibles pour une variable Mois sont janvier-0, février-1 et ainsi de suite jusqu'à décembre-11.

 

En résumé, le tableau ci-après représente quelques types de données possibles dans LabVIEW:

 

Type de données Représentation LabVIEW
Booléen repnumbr1
Nombre en double précision repnumbr2
Nombre entier repnumbr3
Nombre complexe en double précision repnumbr4
Tableau de double 1D repnumbr5
Tableau de double 2D repnumbr6
Matrice de double repnumbr7
Chaîne de caractères repnumbr8
Cluster repnumbr9
Cluster d'erreur repnumbr10
Données dynamique repnumbr11

LabVIEW identifie chque type de donnée par une couleur précise. Une distinction est aussi faite au niveau de l'épaisseur du trait qui constitue l'arc de liaison; par exemple un trait achémine des données multiples est plus épais (tableaux, clusters,...).

Structure d’un programme  LabVIEW

Le langage de programmation LabVIEW, possède deux structures de bases pour exprimer tous les algorithmes :  la structure conditionnelle et la structure de répétition.  Mais étant donné que les programmes flux de données entraînent un parallélisme implicite, une structure de séquencement a été ajoutée. Dans ce langage on trouve aussi une autre structure appelée la structure événements.

Quelques rappels d’algorithmique

Un algorithme est structuré de la façon suivante :

Nom_de_l_algorithme{données d’entrée / résultats de sortie}

Ici on déclare les variables utilisées avec leurs types

 

Début

          Ici le Pseudo code de l’algorithme

Fin

 

L’algorithme peut être présenté sous 2 formes :

Pseudo code                                                         Symbole (ou algorigramme)                         

Debut

FIN

 algorigramme1

 algorigramme2

L'affectation:

TENSION    ←     2.75

I      ←    I + 1

 algorigramme3

Entrées-sorties:

LIRE(variables)

ECRIRE(variables)

ECRIRE(‘Chaîne de caractères’)

ECRIRE(’Saisir un nombre :’,N)

 aligrigramme4

Le test:

SI Condition Vraie

                ALORS

                  Traitement 1

                SINON

                  Traitement 2

FINSI

 algorigramme5

La boucle repéter:

REPETER

                Traitement

JUSQU'A Condition Vraie  (do ...while)

 algorigramme6

La boucle tant que:

TANT QUE Condition Vraie FAIRE(While)

                Traitement

FINTANTQUE

 algorigramme7

La boucle POUR:

POUR V de Vi à Vf FAIRE (For)

                Traitement

FINPOUR

 algorigramme8

 

 

Structures de programmation 

La structure Séquence :

Elle permet de donner un ordre bien précis d’exécution à un nombre de « sous-diagrammes » ou étapes (Frames). Effectivement cette structure exécute le « sous-diagramme » contenu dans l’étape numéro « 0 », suivi de celui de l’étape numéro « 1 », et ainsi de suite.

On a deux modes de représentation :

> Séquence déroulée

 

structureseq1

 

Pour ajouter une étape après, il faut placer la souris sur le bord de la séquence puis chisir « Add frame after (Ajouter étape après)

 

structureseq2

 

 

On a la structure à 3 séquences ci-après:

 

structureseq3

 

 

> Séquence empilée

La séquence déroulée précédente peut être remplacée par une séquence empilée, il suffit de faire un clic droit sur la séquence puis sélectionner le menu Replace with stacked Sequence (Remplacer par une séquence empilée) ; on a la figure ci-après :

 

structureseq5

 

Les étapes sont superposée ; pour afficher l’étape qui suit ou afficher une étape, utiliser les flèches horizontales ou verticales qui sont en haut à côté du numéro de l’étape.

 

Les données peuvent entrer ou sortir des cette structure par l’intermédiaire de tunnels.

La structure Condition ou Test :

Une structure Condition possède au moins 2 « sous-diagrammes » ou conditions. Ce type de structure se présente souvent de façon empilée et il n’est possible de visualiser les « sous-diagrammes » qu’un seul à la fois.

Il existe deux principales structures Condition :

Condition de type booléen : les sous-diagrammes sont associés à une condition « Vrai » (True)  ou « Faux » (False) ;

Condition de type numérique ou énumérée : les « sous-diagrammes » sont associés aux différentes valeurs de l’entrée. Pour cette structure, il est nécessaire de définir une valeur par défaut au cas où la valeur présente à l’entrée de la case condition n’est pas traitée.

Des données peuvent aussi sortir ou entrer dans cette structure par l’intermédiaire des tunnels.

 

Exemple de structure avec un contrôle de type booléen :

 

structuretest1

 

Exemple de structure de contrôle avec une condition de type numérique :

 

structuretest3   structuretest4

Chacune de ces diagrammes sera exécuté, si la valeur numérique vaut 0, 1 ou 2 respectivement.

Structure Boucle (Boucle For)

La boucle For est une structure de répétition qui se comporte de manière classique comme dans d’autres langages de programmation.  Elle a sa valeur initiale 0 et sa valeur finale N-1 de l’indice fixée par le terminal d’entrée N. La valeur du pas est fixée à 1, et l’indice courant est disponible dans le terminal interne appelé « i ».

Pour mémoriser les valeurs intermédiaires calculées lors des différentes itérations de la boucle, on dispose de mémoires locales appelées Registres à Décalages (Shift Register).

Le registre à décalage stocke la variable calculée à un instant donnée (indice de boucle i), et conserve la valeur précédente de cette même variable (indice de boucle i – 1).

 

structurebouclefor

 

Les données peuvent entrer ou sortir de la boucle par des tunnels.

Structure Boucle (Boucle While)

La boucle While est une structure de répétition qui se comporte de manière classique comme la structure « Tant Que » dans d’autres langages, avec une condition d’arrêt et un indice partant de 0. Le pas est fixé à 1. L’arrêt de l’exécution de cette boucle se fait sur l’état d’une variable de type booléenne. Le type de condition d’arrêt (Vraie ou Fausse), peut être changé sur le terminal correspondant par un menu contextuel.

On utilise aussi des registres à décalages pour mémoriser des variables.

Un autre exemple de calcul de la factorielle avec une boucle While.

 

structurebouclewhile

 

Les données peuvent entrer ou sortir de la boucle par des tunnels.

Variables Globales  - Variables locales

Variable Globale 

L’unité de mémorisation employée dans les exemples sur les boucles existe dans les bibliothèques de LabVIEW, sous la dénomination de « Variable globale ». La création d’une variable globale s’effectue dans le diagramme ou par menu contextuel; mais la variable crée ainsi crée est une structure vide ; il faudrait créer les différentes données dont sera composée cette variable globale.

Variable locale

Une variable locale c’est tout simplement la duplication des terminaux qui peuvent être soit des commandes (entrées) , soit des indicateurs (sorties). La création d’une variable locale s’effectue dans le diagramme, ou alors par menu contextuel.

Les fichiers

Dans la sous palette Files i/O (E/S sur Fichiers), on trouv toutes es fonctions de base pour gérer les fichiers.  On peut gérer des fichiers binaires, des fichiers tableurs, des fichiers de mesures,  configurer des fichiers …

 

importexportfichiers

Les boîtes de calcul

Une boîte de calcul (Formula Node), est un élément de programmation qui se présente comme les autres structures de LabVIEW,  elle comprend les lignes de formules de calcul à la place des fonctions graphiques du diagramme. Les formules sont délimitées par des points virgules ; et les variables utilisées dans la boîte de calcul doivent être obligatoirement déclarée en entrée et en sortie.

 

boitedecalcul 

Pour déclarer une variable, il faut faire un clic droit sur le bord de la boite, puis choisir Add input (Ajouter une entrée) ou Add output (Ajouter une sortie).

Gestion du temps

Cette sous-palette intègre les fonctions de gestion du temps de manière absolue ou relative.

Gestion de temps relative : Comptage d’impulsions d’horloge (Ticks count), Attendre en ms (Wait (ms)),  Attendre multiple de ms (Wait Until Next ms Multiple)…

Gestion de temps absolu : Formater chaîne de date/heure (Format Date/string),…

 

gestiontemp

 

Exemple de programme:

On se propose de résoudre une équation du second degré à une inconnue, ax²+bx+c, en supposant que a, b et c sont différents de zéro.

Créer une face avant sur laquelle l'utilisateur devra saisir les nombres a, b et c; le résultat des solutions X1 et X2 sera affiché. Il faudra aussi indiquer sur un afficheur si les solutions sont réeles ou complexes.

Ce programme devra respecter l'algorithme suivant:

 

DEBUT

LIRE a, b, c;

Delta <--- b2 - 4*a*c;

SI  Delta ≥ 0

X1 = (-b + √Delta)/(2*a);

X2 = (-b - √Delta)/(2*a);

ECRIRE('Solutions réelles');

SI NON

X1 = (-b + i√Delta)/(2*a);

X2 = (-b - i√Delta)/(2*a);

ECRIRE('Solutions complexes');

FIN

 

Pour résoudre notre équation on va procéder en deux étapes: en premier on va calculer Delta, puis on encapsulera le VI obtenu dans un sous-VI, et en second lieu on pourra créer le VI de résolution de l'équation qui calculera X1 et X2 selon les valeurs de Delta.

 

Etape 1: Calcul de Delta.

Delta = b2 - 4*a*c.

Créer un nouveau VI, dans la face avant placer trois commandes a, b et c, et un indicateur Delta. Dans le diagramme, ajouter les fonctions nécessaires pour effectuer le calcul du discriminant.

Ce VI ressemblera à celui-ci:

 

Face avant:

discriminant faceav

 

Diagramme:

discriminant diagr

 

Création du sous-VI qui va encapsuler le discriminant Delta:

Pour des raisons de lisibilité du VI, on peut encapsuler (ou créer un sous-VI) d'un programme LabVIEW. Cette étape n’est pas obligatoire, mais elle offre aussi la possibilité de réutiliser ce sous-VI comme un module à part entière dans un autre programme.

Lorsqu’un VI est terminé et testé, l’encapsulation de celui-ci se fait en trois phases :

 

  1. L’édition de l’icône du VI ;
  2. La définition des terminaux ou points d’entrées et de sorties du VI ;
  3. La définition des paramètres ou des propriétés du VI.

 

Le VI du calcul du discrimant a été testé et fonctionne correctement.

 

Edition de l'icône du sous-VI:

Dans cette étape on va créer une icône personnalisée qui sera associée à notre VI.Pour accéder à l’éditeur d’icône, faire un clic droit sur l’icône du VI, puis sélectionner Edit Icon (Editer Icône). La fenêtre qui s’ouvre ensuite représente l’éditeur d’icônes. 

 

exple2 editeursousvi1

 

Cet outil a été enrichi dans les nouvelles versions de LabVIEW, par des petits « Glyphs » prédéfinis que l’on peut insérer dans une icône.  C’est outil simplifié de DAO de type « Bitmap » (Pixel).

Passons rapidement en revue les principaux outils de cet éditeur, situés à droite de l'icône par défaut:

L’outil Crayon : Il dessine pixel par pixel ;

L’outil Ligne : Il trace des lignes droites ;

L’outil  Pipette : il copie une couleur prise dans l’icône dans la couleur de premier plan ;

L’outil Pot de peinture : il colorie une zone limitée avec la couleur de premier plan ;

L’outil Rectangle : il trace un rectangle dont le contour est dessiné avec la couleur de premier plan ;

L’outil Rectangle plein : il trace un rectangle dont le contour est dessiné de la couleur de premier plan et la couleur intérieure est la couleur de fond ;

L’outil Cercle et Cercle plein ont les mêmes fonctionnalités que l’outil rectangle mais appliquées à un cercle

L’outil Sélection (Rectangle en pointillés) : il permet de sélectionner une zone pour la déplacer, la copier ou la supprimer ;

L’outil Flèche : permet de déplacer une zone préalablement sélectionnée par l’outil rectangle ;

L’outil Couleur : permet de définir la couleur de premier plan ;

L’outil Texte (T) : permet d’ajouter du texte au format pixel dans l’icône avec la couleur de premier plan ;

 

Sélectionner le dessin proposé par défaut dans l’éditeur, puis supprimer le. Créer une zone de couleur orange, dans laquelle on écrira DELTA; puis choisir un "Gliph" pour orner l'icône.

Au final on devra obtenir ceci:

exple2 editeursousvi5 

Il ne reste plus qu'à définir les terminaux de l'icône:

Dans la face avant, faire un clic droit sur l’icône des terminaux à côté de la nouvelle icône du Vi crée, choisir des gabarits (Patterns) parmi la liste proposée.  On va choisir dans cette même figure un terminal  à trois entrée une sortie comme celui de la figure:

 

exple2 editeursousvi3

 

Ceci fait, cliquer avec l’outil Bobine sur la première entrée du terminal, puis sur la commande « a » de la face avant, ensuite on clique sur la deuxième entrée du terminal puis sur la commande « b » de la face avant, puis sur la dernière entrée et sur la commande « c » de la face avant ; enfin on clique sur la sortie du terminal et sur l’indicateur « Delta » de la face avant.  Le terminal  ressemblera à celui de la figure ci-après :

 

exple2 editeursousvi4

 

On peut définir les propriétés du sous-VI:

Faire un clic droit sur la nouvelle icône puis sélectionner le menu VI Properties (Propriétés du VI), dans la figure qui suivra, aller dans l'onglet Documentation pour mettre des informations de description de votre sous-VI.

Enregistrer le sous-VI dans votre répertoire de travail.

Si on veut placer ce module dans un nouveau programme, il suffit de le récupérer à partir du menu Select a VI (Sélectionner un VI).

 

Pour finir, on va créer le programme principal. Sur la face avant placer les commandes a, b, c et les indicateurs X1, X2, et l'indicateur "Type de solutions". Puis dans le diagramme à l'aide de la palette de fonctions effectuer les liaisons entres les fonctions choisies et les E/S, pour répondre à l'algorithme proposé précédemment.

On obtiendra le diagramme ci-dessous dont les deux figures représentent le contenu des fonctions llorsque le TEST est vrai ou faux:

exple2 diagramme1

 

exple2 diagramme2

 

La face avant aura l'allure suivante:

exple2 faceavant

 

On peut aussi créer de nouveau un sous-VI, du VI précédent que l'on peut appeler équation du second degré par exemple.

LabVIEW offre de très grandes possibilités de programmation, car a en croire à l'éditeur, tout ce qui peut être fait en programmation textuel, comme le langage C, peut l'être aussi en langage LabVIEW. L'inconvénient réside uniquement sur l'affichage lorsqu'un diagramme devient immense; pour éviter cela, il est très pratique d'utiliser l'encapsulation.