Cours Labview

LabVIEW Manuel de cours en pdf


Télécharger LabVIEW Manuel de cours en pdf

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


LabVIEW Manuel de cours avec exemples

LabVIEW se programme en glissant des icones depuis une palette

Connection

Pane

Equivalent en C

double function C2F (double deg_cel)

{

 return deg_cel * 1.8 + 32;

 }

Programmation par flot de données

L'écoulement des données rythme l'éxécution du programme

C'est comme pour les petits ruisseaus qui se réunissent pour former de grandes rivières et peuvent ensuite se séparer en plusieurs rivières

L'ecoulement des données est comparable à l'écoulement de l'eau ou des electrons dans un circuit électrique

Un noeud est executé seulement quand toutes les entrées sont connues

Z = (a * b) + 3 * (c – d)

Programmation par flot de données

L'écoulement des données rythme l'éxécution du programme

C'est comme pour les petits ruisseaus qui se réunissent pour former de grandes rivières et peuvent ensuite se séparer en plusieurs rivières

L'ecoulement des données est comparable à l'écoulement de l'eau ou des electrons dans un circuit électrique

Un noeud est executé seulement quand toutes les entrées sont connues

Z = (a * b) + 3 * (c – d)

X = e + f

Programmation par flot de données

S'il n'y a pas de dépendance entre les nœuds, ils s'exécutent de manière concurrente (en parallèle) à leurs propre vitesse

Il n'y a pas d'ordre de préférence pour l'exécution à par le flot des données

La notion de parallélisme est comprise dans le langage lui-même, par défaut tout ce qui peut être

W = (a * b) + 3 * e exécuter en parallèle l'est.

Y = (c-d) + f

Programmation par flot de données

L'écoulement des données rythme l'exécution du programme!

Programmation par flot de données

L'écoulement des données rythme l'exécution du programme!

Les parties du diagram peuvent s'exécuter en parallèle

LabVIEW - environment

  • LabVIEW IDE est un environment complet:

– GUI builder – front panel

– G code editor - diagram

– Debugger

– Project manager

– Wizards

– Code structure generator (state diagram, OOP)

– Compiler, cross-compiler

– Code analysis/metrics

– Code coverage

– Source versioning, diff tools

– etc.

 … and a lot of examples

Dessiner votre interface utilisateur (GUI) comme vous le feriez avec un programme de dessin (illustrator, powerpoint, etc.)

Les Controls et indicators sont accessibles via la palette Controls

Utilisez le right-click et/ou drag&drop pour placer vos controls/indicators

Utilisez le right-click sur un objet vous permet de spécifier les options d'affichage de vos controls/indicators

Les propriétes sont toutes accessibles au travers d'un dialogue

Controls - indicators

  • Le chevauchement de controls/indicators ralenti la mise à jour de l'interface utilisateur!
  • Les controls/indicators peuvent être cachés/invisibles
  • Toutes les propriétés des controls/indicators peuvent être changées programmatiquement via les attributes nodes
  • Les controls/indicators peuvent être customisés en sélectionnant editcustomize control
  • Le comportement des controls/indicators peut être customisé en utilisant des XControls (à la OOP)
  • La mise à jour des controls/indicators peut être retardée
  • La mise à jour des controls/indicators est assuré par la thread de l'interface

GUI design is very important - Spend time in the (main) VI GUI!

  • Glisser/déposez les noeuds/fonctions
  • Connectez les avec la wiring tool compilation error
  • G est le language graphique pour programmer LabVIEW
  • La programmation de LabVIEW se fait en déposant et connectant des nœuds représentants des fonctions dans le digram du VI
  • Toutes les structures classiques existe en G
  • G est polymorphique (=auto adaptation)
  • G supporte les objets et méthodes associées
  • Il est possible de compiler du G en G (ex. Lego Mindstorm)
  • La vérification syntaxique se fait en continu avec un feedback direct (broken arrow & dotted wires)
  • Le compilateur LabVIEW génère du code machines et cross-compile pour C, VHDL, DSP, etc.
  • Le compilateur LabVIEW génère du code multithreaded, multi-cores et temps réel double function C2F (double deg_cel)

 { return deg_cel * 1.8 + 32;

 }

void function C2F (void)

 { double deg_cel, deg_far;

 deg_far = deg_cel * 1.8 + 32;

 }

void function C2F (void)

 {

 double deg_cel, deg_far; }

Name

Code

Params.

G data types

  • G est fortement typé, comme le C/C++
  • Le type est défini par la couleur et la taille
  • En positionnant la wiring tool sur un fil, le type et l'unité du fil sont affichés dans l'aide contextuelle

boolean;

fixed_pt;

ulong;

long;

double;

cdouble;

string;

path;

long[];

long[][];

long[][][];

struct{};

refnum;

waveforn;

variant;

object;

arrays

cluster

  • Un point rouge indique une conversion automatique
  • Les conversions sont différentes du C/C++ , elles suivent la norme IEEE 754
  • Une conversion de type peut être forcée
  • Conversion de type ≠ typecast typecast

out=*(type*)∈

out = RoundtoInt (in);

double in;

out = *(int32*)∈ ≠

automatic conversion

2.5 -> 2

3.5 -> 4

2.5 -> 1074003968

Tableau (Array) -> structure contenant des éléments du même type

  • Arrays à plusieurs dimension (≤ 64)
  • Arrays de n'importe quels types composés
  • Arrays sont dynamiques, leur taille peut être changée automatiquement durant l'exécution
  • La largeur des ‘[]’ indique sur les dimensions du tableau
  • Ils existe un grand nombre de fonctions prédéfinies travaillant sur les tableaux, ex. algèbre linéaire

Bool[];

long[];

long[][];

long[][][];

float[][][][][]..

struct[];

Str[];

waveform;

matrix; array

indexes

array element

Array[0][0] = 1

G data types - cluster

Cluster-> structure avec des éléments de types différents

  • Equivalent des struct en C/C++
  • Le nombre d'éléments des clusters est fixe
  • La couleur des clusters indique si les éléments sont de taille fixe (brun) ou non (rose)
  • Il est possible de mettre un Cluster dans un Cluster
  • Les éléments (champs) du Cluster peuvent être accédés par leur nom (recommendé) ou leur

position

struct {

 double f;

 char[] s;

 bool b;

} c;

c.f = c.f + 0.5;

Les references sont similaires aux pointeurs/références en c++

  • Mémorise une référence à un objet/donnée de LabVIEW
  • Les references ne peuvent pas être observées (code hexa)
  • Utilisée pour les accès fichiers, réseau, etc.

FILE *f;

char[255] c;

f= fopen(”a”);

e= fread(f,c);

Path

reference

Enumeration

  • Ensemble de noms représentés par des nombres enum {

 one,

 two,

 banana

}

where

 one is 0

 two is 1

 banana is 2

U16 = 1



Conteneur générique

  • Stock tout type de données LabVIEW
  • Stock des données et leurs descriptions
  • Peuvent être "sérialisés"
  • Les descriptions des variants peuvent être éditées (add, remove)

struct {

 int i;

 char s[255];

} S1;

struct {

 double b;

 int j;

} S2;

void* V1, V2;

V1= &S1;

V2= &S2;

Objet pour la programmation Object Oriented Programming

  • Différentes implémentations (NI, others)

class CRectangle {

 int x, y, e;

public:

void set_center

 (int,int,int);

void set_edge(int);

int area (void);

} rect;

rect.set_edge(2);

int a = rect.area();

CRect private data

  • Les fonctions/noeuds de base ont un fond jaune
  • Elles ne peuvent pas être modifiées
  • Elles sont regroupée par type dans des sous-palettes
  • La pluspart des fonctions sont polymorphiques, i.e. s'adaptent au type de données connectées

+ And >=

r*e^(i*theta)

exp

enqueue

find in array

find str

millisecond

show dialog

read text file

parse string for float

  • Fonctions avancées sont des VIs dont le code peut être visualisé/modifié
  • Les VIs Express sont des fonctions avancées, ex: générer un signal, écrire dans un fichier
  • Ils sont configurables au travers d'un dialogue

EditParam(p);

FS=Filter(p,S);

  • Polymorphism: une fonction/noeud supporte plusieurs types de donnée

int32, double, bool, 2D array, ..

  • La plupart des fonctions/nœuds sont polymorphiques
  • LabVIEW peut faire un conversion automatique de type (point rouge)

G-polymorphism

z = x + y

for (i=0;i<sz(A);i++)

 C[i] = A[i] + b;

  • Polymorphisme avec les tableaux
  • operations are performed element by element, not vector/matrix

G-polymorphism

for (i=0;i<Size(A1);i++)

 Out1 = A1[i] + D;

n=min(size(A2),size(A3));

for (i=0;i<n;i++)

 Out2 = A2[i] + A3[i];

n=min(size(A2),size(A3));

for (i=0;i<n;i++)

 Out2 = A2[i] * A3[i];

Out4 = Dot(A4,A5);

A1[] = {1, 2, 3}

D = 2

A2[] = {1, 2, 3}

A3[] = {5, 6}

A4[] = {1, 2, 3}

A5[] = {4, 5, 6}

A4[] = {1, 2, 3}

A5[] = {4, 5, 6}

Out1[] = {3,4,5}

Out2[] = {6,8}

Out3[] = {4,10,18}

 Out4[] =32

for (i=0;i<N;i++) {

}

i:=0;

do {

} while (cond; i++)

switch(cond) {

 case:

 break;

 default

}

Sequence1;

#ifdef cond

#endif

Formula node

Mathscript node

Event node

Les structures définissent l'équivalent d'un bloc C/C++ { … }

G - structures

  • Le contenu des structures définissent

l'équivalent d'un bloc C/C++ { … }

  • Les données (fils) qui entrent dans les structures sont évalués aux limites de la structure
  • Un indicator/control à l'intérieur d'une structure sera évalué/mis à jour à chaque itération
  • Un indicator/control à l'extérieur d'une structure sera évalué/mis à jour avant ou après l'exécution de la structure

Exécute le contenu un nombre de fois donné

  • de 0 à9 ( - 1)

L'exécution peut être stopée (≥ LV 8.6)

  • Arrêt si est vrai

Boucle - for

for (i=0;i<N;i++)

 {

 …

 }

for (i=0;i<N;i++)

 {

 …

 if () break;

 }

Exécute le contenu un nombre de fois donné

i va de 0 à 9

Le dernier i (last i) vaut 9

Boucle - for

N=10;

for (i=0;i<N;i++)

 {

 i;

 }

Auto indexing

 La boucle for sauve en interne toutes les valeurs de i

i va de 0 à 9

Le dernier i (last i) vaut 9

all_i = [0,1,2,3,4,5,6,7,8,9]

Boucle - indexing

N=10;

for (i=0;i<N;i++)

 {

 i;

 all_i[i]=i;

 }

last_i = i;

50

0 1

019

… 9

Auto indexing

  • nombre d'itérations definie par la taille du tableau d'entrée (in:3)
  • auto indexing
  • no auto-indexing
  • Accède au ième élément du tableau d'entrée
  • out[] = {1, 2, 3}
  • e = 3
  • = 2, = 3

Boucle – auto-indexing

for(i=0;

 i<sizeof(in[]);

 i++)

 {

 out[i] = in[i];

 e = in[i];

 }

Execute le contenu jusqu'à ce que la condition soit valide (v ou F)

  • La boucle while est exécutée 7 x
  • va de 0 à6

Loops - while

i = 0;

do {

 …

 }

 while(5 < i; i++);

Exécute le contenu jusqu'a ce que la condition soit atteinte

  • La boucle while est exécutée 7 fois
  • 5 < i est vrai quand i = 6
  • va de 0 à 6
  • out[] = {0,1,2,3,4,5,6}

Loops - while

i = 0;

do {

 out[i]= i;

 }

 while(5 < i; i++);

Les fils sont évalués à l'entrée de la boucle, l'intérieur de la boucle est similaire à un bloc en c

  • Stop1 est évalué une fois avant l'entrée dans la boucle
  • Stop2 est évalué à chaque itérations de la boucle
  • La boucle s'arrête après une itérations si Stop1 est False
  • Si Stop1 est True, la boucle s'arrête quand Stop2 est False

Loops - while

tmp = Stop1;

do {

 ...

 }

 while( tmp & Stop2 );

Internal temp. var.

Dataflow & Shift register

J



int tmpJ_k_1 = 0; // default

 // tmpJ_k_2 = 0;

int tmpJ, J, Stop;

do {

 J = tmpJ_k_1;

 tmpJ = i;

 tmpJ_k_1 = tmpJ;

 } while (!Stop);

tmp(k-1) tmp(k)

default

when k=0

J = 0,0,1,2,3, ...

Les shift registers sont des variables dépendantes du temps qui mémorisent la (les) valeur(s) précédente(s)

tmpL(k-1)

Dataflow & Shift register

Si aucune valeur par défaut n'est définie (connectée) la dernière valeur est utilisée

tmpL(k)

NO default

 =>

keep the value

of the previous

run!

L = 1

L = 2

double tmpL_k_1; // NO default

double tmpL, L;

do {

 L = tmpL_k_1 + 1;

 tmpL = L;

 tmpL_k_1 = tmpL;

 } while (!Stop);

L = 3

Shift registers (registres à décalage)

  • fixe la valeur pour l'itération i
  • récupère la valeur de l'itération i-1

Boucle – Shift register

for(i=0;

 i<sizeof(in[]);

 i++)

 {

 if (i==0)

 out[i] = -1;

 else

 out[i] = in[i-1];

 }

out[] = {-1, 1, 2}

  • Les shift registers (registres à décalage) permettent de mémoriser les valeurs entre les itérations, c'est comme une variable locale
  • S'ils ne sont pas initialisés, il garde la valeur de la dernière exécution ceci tant qu'ils restent en mémoire
  • Ils peuvent être agrandis pour récupérer les k-n valeurs de la variable

Shift registers

i = 0;

do {

 sr1[i]=sr1[i-1]+1;

 if (i==0)

 sr2[i] = 0;

 else

 sr2[i]=sr2[i-1]+1;

 if (i<=2)

 A[i]= 0;

 else

 A[i]=sr2[i-2];

 }

 while(i < 5; i++);

A[] = {0, 0, 0, 1, 2, 3, 4}

1st iteration

sr1 = 7

sr2 = 7

2nd iteration

sr1 = 14

sr2 = 7

Execute le contenu jusqu'a ce que la condition soit atteinte

  • La boucle while est exécutée 7 fois
  • 5 < i est vrai quand i = 6
  • va de 0 à 6
  • e=7
  • out[] = {1,2,3,4,5,6,7}

Loops - while

i = 0;

do {

 if (i==0)

 sr[i] = 0;

 else

 sr[i]=sr[i-1]+1;

 out[i]=sr[i];

 }

 while(5 < i; i++);

e = sr;

Les fils sont évalués à l'entrée de la boucle, l'intérieur de la boucle est similaire à un bloc en c

  • Stop1 est évalué une fois avant l'entrée dans la boucle
  • Stop2 est évalué à chaque itérations de la boucle
  • La boucle s'arrête après une itérations si Stop1 est False
  • Si Stop1 est True, la boucle s'arrête quand Stop2 est False

Loops - while

tmp = Stop1;

do {

 ...

 }

 while( tmp & Stop2 );

  • Si la condition est True

passer la valeur connectée à T

sinon

passer la valeur connectée à F

  • Si x vaut 5 -> S = “x is 5”, sinon S =“x different than 5”

Conditional - if

if (x==5)

 S = “x is 5”;

 else

 S = “x different

 than 5”;

  • Les case structures sont similaires au switch en C/C++
  • indique que tous les cas sont définis
  • indique que certains cas ne sont pas définis et que la valeur par défaut

 sera utilisée

  • S= “one” quadn x==1, and S=“default” pour toutes les autres valeurs de x
  • out = -1 or 0

Conditional - case

out = -1; //default val.

switch (x)

 case 1:

 S=“one”;

 break;

 case 0:

 default:

 S = “default”;

 out = -1;

  • Le type du case s'adapte automatiquement au format du fil connecté
  • Les cas (cases) peuvent contenir des intervalles avec “..” ou séparé par des

“,”

  • Chaque case exécute un bloc de code spécifique
  • Quand x vaut [2,5,6,7,8,9,10]

S= “2,5,6,7,8,9,10”

out = x+1

Conditional - case

out = -1; //default val.

switch (x)

 ..<skipped>..

 case 2:

 case 5..10:

 S = “2,5,6,7,8, \

 9,10” ”;

 out = x+1;

 break

  • Il est possible de forcer l'ordre d'exécution de LabVIEW à l'aide de séquences
  • A éviter, car cela enlève à LabVIEW la possibilité de générer de code performant!
  • Usage principal: mesure du temps d'exécution
  • Dans l'exemple ci-dessus d = 4 [ms] sur un Mac

Sequence

t1=millisec();

for (i=0;i<1000000;i++)

 sin(i)

t2=millisec();

d= t2 – t1;

  • Les Flat sequences peuvent être empilées
  • Les résultat intermédiaires peuvent être sauvés dans des variables locales

Sequence

t1=millisec();

for (i=0;i<1000000;i++)

 sin(i)

t2=millisec();

d= t2 – t1;

  • Permet de définir un calcul sous la forme de texte
  • Expression node: une seule ligne de calcul
  • Formula node: lignes multiple, code proche du C

Expression/Formula node

DegF = DegC * 1.8 + 32;

expression node

formula node

  • La syntaxe très proche du C
  • Le code est compilé et exécuté en un bloc
  • Le code ne peut pas être changé durant l'exécution, employer la toolbox

Gmath si vous avez besoin de changer votre code

  • A=[1, 3, 2] with n=3
  • S^2 = 36
  • max=3

Formula node

int32 A[]={1, 3, 2};

int32 n= sizeof(A);

 int32 tmp=0;

 int32 i;

 Max =0;

 for (i=0;i<n;i++){

 tmp+=A[i];

 if (A[i]>Max)

 Max = A[i];

 }

 S2=tmp*tmp;

S^2 = S2;

max = Max;

Mon premier VI

  • Dessiner l'interface utilisateur (controls & indicators)
  • Câbler le programme (diagram)
  • Tester et debugger
  • Ajouter la documentation du VI
  • Définir le prototype/interface (connector pane)
  • Dessiner l'icone

Spécifications:

  • Calculer la moyenne de 4 valeurs
  • Si le résultat est plus petit que 0, le forcer à 0

Mon premier VI - Moyenne



av = (in1+in2+in3+in4);

if (av>0)

 result = av;

 else

 result = 0;

  • Test and debug

Mon premier VI - Debug

function Average_4Pos {

 av = (in1+in2+in3+in4);

 if (av>0)

 result = av;

 else

 result = 0;

 }

break point

probe

av>0 FALSE

Variables            

run

Highlight execution

  • fix and test again

Mon premier VI - Modification

function Average_4Pos {

 av = (in1+in2+in3+

 in4)/4;

 if (av>0)

 result = av;

 else

 result = 0; ✔ }

  • Définir l'interface (prototype)
  • Dessiner l'icone

Mon premier VI -> fonction()

double

function Average_4Pos(

 double in1,in2,in3,in4) {

 av = (in1+in2+in3+

 in4)/4;

 if (av>0)

 result = av;

 else

 result = 0;

 return result;

}

  • Ecrire la documentation
  • Elle apparaîtra dans la fenêtre d'aide (context help window)

Mon premier VI - Documentation

/*

 This Vi computes the average of the 4

input values. If not connected the

input is considered set to '0'. If the

resulting average is less than 0, the

result is cohered to 0.

*/

double

function Average_4Pos(

 double in1,in2,in3,in4) {

 av = (in1+in2+in3+

 in4)/4;

 if (av>0)

 result = av;

 else

 result = 0;

 return result;

}

  • Créer un nouveau vi
  • Glisser/déposer the Avrage_4Pos.vi depuis l'OS (the finder), le connector pane, ou la palette (select a vi …)
  • Créer un control pour le bouton Stop
  • Ajouter un shift register, initialiser le à 0
  • Connecter le générateur de nombre aléatoire

Mon premier VI – Appel

void function CallAvr(void) {

 sr1=0;

 sr2=0;

 sr3=0;

 While (!Stop) {

 sr=rand();

 sr1=sr;

 sr2=sr1;

 sr3=sr2;

 Avrage_4Pos(sr,sr1,

 sr2,sr3);

 };

}

  • Ajouter un Waveform chart pour afficher les resultats
  • Utiliser un bundle pour combiner les 2 valeurs à afficher

void function CallAvr(void) {

 float r;

 sr1=0;

 sr2=0;

 sr3=0;

 While (!Stop) {

 sr=rand();

 sr1=sr;

 sr2=sr1;

 sr3=sr2;

 r=Avrage_4Pos(sr,sr1,

 sr2,sr3);

 plot(Chart,sr,r);

 };

}

  • Customisez l'affichage
  • Pour cela utiliser le dialogue properties ou le menu contextuel (popup menu)

Mon premier VI – Appel

Graph Palette

X Scrollbar

Plot Legend

  • Rythmer l'exécution (toutes les 10 ms)
  • Initialiser le Chart via un property node

Mon premier VI – Appel

void function CallAvr(void) {

 float r;

 struct {double:a,b} BLD2;

 BLD2 _a[]={};

 sr1=0;

 sr2=0;

 sr3=0;

 SetHistory(Chart,_a);

 While (!Stop) {

 sr=rand();

 sr1=sr;

 sr2=sr1;

 sr3=sr2;

 r=Avrage_4Pos(sr,sr1,

 sr2,sr3);

 plot(Chart,sr,r);

 WaitUnitlNextMS(10);

 };

}

Pace at 10 ms

Set execution

order

Property node

Tools bars - front panel

Execution

fonts align distribute resize order/group/lock

text

pos/size/select

operate scroll

color

Auto. tool

Tools bars - diagram

Execution

Highlight execution

retain wire values

debug

clean up diagram

SPACE

TAB next tool

operate <-> pos/size/select

Alt duplicate

drag

run

 E front panel <-> diagram

Recap: Virtual Instrument (VI)

Front Panel (UI)

Diagram (Program)

Connector Pane (Interface)

  • Data paces the program execution
  • Data flows from sources to sinks
  • Data flows in parallel
  • Wires are like variables' name

float function A_B(float A, float B)

 { return A*B;

 }

A VI is like a function with its parameters defined in the connector pane

Recap

  • Virtual Instrument & data flow programming

– Vi is made of a front panel, a diagram, a connector pane and some documentation

– The execution of a node is only possible when all the needed data are ready

  • G is strongly typed, wire color indicate its type, wire thickness indicates its dimension
  • All classical structures are available in G
  • In loops (For/While) wires are evaluated once at the loop border
  • Shift registers hold their values until the VI is removed from memory (= no reference to it, as in sub-vi)



612