Cours Labview

Formation complet de LabVIEW en pdf


Télécharger Formation complet de LabVIEW en pdf

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

Télécharger aussi :


Formation complet de LabVIEW avec exemples de pratique

...

II – ALGORITHME

Programmer, c’est écrire en respectant la syntaxe d'un langage, la suite des tâches devant être exécutées par l'ordinateur, de façon logique et structurée.

On ne se lance pas à écrire un programme sans avoir réfléchi au problème posé, et à la façon de le résoudre.

Il faut élaborer un algorithme :

Suite d'instructions qui une fois exécutées correctement conduit à u n résultat donné

Algorithmique

Science qui étudie la structure logique des programmes

L’algorithme est indépendant du langage :

LabVIEW             Visual Basic

L'algorithme se ramène à une combinaison de 4 familles d'instructions :

- Affectation de variables

- Lecture écriture

- Tests

- Boucles

III – QU’EST CE QUE LabVIEW ?

LabVIEW est un logiciel créé en 1985. C’est un logiciel de développement d’applications d’instrumentation plus particulièrement destiné à l’acquisition des données de mesure et à leur traitement.

Il utilise un langage de programmation graphique.

Cet enseignement a été mis en place en DUT MP à Montbéliard en 1995. La version utilisée en TP est la version 7.1 sous Linux ou Windows.

IV – STRUCTURE D’UN PROGRAMME LABVIEW

LabVIEW étant plus particulièrement destiné à l’instrumentation, un programme LabVIEW apparaît constitué comme un appareil de mesure :

Une face avant :                             La face avant est l’interface avec l’utilisateur.

Un diagramme :                              Le diagramme correspond aux circuits internes de l’appareil et constitue le cœur du programme

V – LES ENTREES SORTIES 1°/ DEFINITION

Un programme informatique manipule des données fournies par l’environnement extérieur :

- Entrées au clavier par l’utilisateur

- Acquises par une carte d’acquisition (mesure de Température par exemple)

- Délivrées par un appareil de mesure (Voltmètre, via une liaison informatique) - Tirées d’un fichier tableur

-              Etc...

Ces données constituent des variables d’entrée.

Leur traitement (par exemple : filtrage, analyse fréquentielle ...) donne naissance à des résultats (affichage d’un graphe d’évolution de la température mesurée) ou engendre des actions de commande délivrées par l’ordinateur (commande d’arrêt de chauffage).

Ces informations constituent des variables de sortie.

L’élaboration d’un algorithme nécessite de bien identifier les entrées/sorties.

2°/ ENTREES SORTIE DANS LabVIEW

Les entrées sorties sont déposées sur la face avant sous la forme d’objets tels que :

                                               o             boutons poussoirs

o             interrupteurs

o             potentiomètres rotatifs ou à glissière

o             Afficheur numérique en lecture.

o             Etc ...

entrées                                                                            

sorties                 o             écrans d’oscilloscope

o             Afficheurs numériques en écriture (affichage)

o             Vu-mètres

o             Etc ...

Ces objets sont disponibles dans la palette de commandes qui apparaît par clic droit sur la face avant. On les place par « glissé déposé ».

VI – LE PROGRAMME LabVIEW

Le programme est écrit en langage graphique dans une deuxième fenêtre «diagramme » indissociable de la face avant.

Les entrées sorties apparaissent alors sous la forme de terminaux.

L’écriture du programme consiste à relier entre eux les terminaux d’entrées sorties en utilisant :

o             des opérateurs arithmétiques

o             des opérateurs booléens

o             des fonctions de calcul toutes prêtes

o             des structures de programmation (boucles, tests etc ...)

Ces outils sont disponibles dans la palette fonction apparaissant par clic droit dans le diagramme.

Les liaisons sont réalisées à l’aide de la bobine de la palette d’outils disponible par le menu Fenêtre/palette d’outils (Windows/tools palette).

L’ensemble face avant + diagramme constitue un programme LabVIEW encore appelé VI (Virtual Instrument).

Ce VI peut être «encapsulé » c’est à dire mis en boîte sous la forme d’une icône constituant un sous programme, une fonction pouvant être utilisée dans un autre diagramme.

Chapitre 2 – LES VARIABLES ARITHMETIQUES

I – DECLARATION DE VARIABLE

Un programme manipule des valeurs contenues dans des variables.

A chaque variable correspond un emplacement mémoire repéré par une adresse précise, et dont le contenu est la valeur prise par la variable au cours de l’exécution du programme.

LA MEMOIRE :

Un contenu (valeur) variable

Lorsque l’on dépose une variable d’entrée ou sortie sur la face avant d’un VI, on définit :

o             Le nom de la variable : son étiquette

o             La représentation ou le type de la variable : la place en octet occupée par la variable et le mode de codage.

II – ENTREES SORTIES DANS LabVIEW

III – INITIALISATION

Initialiser la variable, c’est lui donner une valeur qu’elle prendra dès le début du programme. Pour cela un clic droit sur l’objet, puis opérations sur les données puis valeur actuelle par défaut.

IV – TYPE DE VARIABLE

1°/ CODAGE DES NOMBRES ENTIERS

a – Codage sur un octet

b - Comment changer la représentation dans LabVIEW ?

c – Codage sur 2 octets

Complément à deux

2°/ NOMBRES A VIRGULE FLOTTANTE

Un nombre à virgule flottante peut toujours s'écrire :

+ 0,662 * 2 - 26

Signe : 1 bit        Mantisse : 23 bits

Exposant :8 bits

Valeurs extrêmes possibles :

Nombre nul : 0

Nombre positifs de : 1,21 10 -38 à 3,40 10 38 Nombres négatifs de : - 1,21 10 -38 à - 3,40 10 38

Type : Float en C, Type SGL en LabVIEW

3°/ VARIABLES BOOLEENNES

Codage sur 1 seul bit

N'existe pas dans tous les langages :

OK en labVIEW mais pas en C !

V – FORMATS D’AFFICHAGE

Exemples de formats d’affichages :

Chapitre 3 – LES TESTS

I – DEFINITION

Suivant le résultat d’un test, on réalise une série d’instructions ou une autre

II – REPRÉSENTATION

REMARQUES :

- Pas de règle sur le choix gauche ou droite du côté OUI et du coté NON.

- Un des blocs Instructions 1 ou 2 peut être vide (ne rien faire). Il suffit de ne pas faire apparaître le cadre.

III – LE TEST

Le test est la relation permettant de réaliser l’aiguillage.

Le test met en œuvre des opérateurs de comparaison <, >, ≤, ≥, =, ≠.

Il peut être aussi l’évaluation d’une simple variable booléenne (test de l’appui sur un bouton poussoir)

Le résultat du test est un booléen : il ne peut prendre que 2 valeurs : OUI ou NON. Le test peut être simple du type a < b ou plus complexe : (a < b) ET (a < c)

Les relations de comparaisons sont alors reliées entre elles par des opérateurs logiques : ET, OU, NON ET, NON OU, OU Exclusif, etc ...

La relation correspondant au test est écrite dans le losange. IV – EXEMPLE

Saisir une note N au clavier.

Afficher sur une chaîne de caractère le message «c’est bien » si N >_ 12 Afficher «c’est assez bien » si 9 ≤ N < 12

Afficher «c’est insuffisant » si N < 9

ENTREES SORTIES :

- Une entrée nommée N de type commande numérique. - Une sortie nommée C afficheur chaîne de caractère.

Cet organigramme montre que les structures conditionnelles peuvent être imbriquées.

V – STRUCTURE CONDITIONNELLE DANS LabVIEW

Un clic droit dans le diagramme permet d’ouvrir la palette de fonctions. Cliquer sur l’icône contrôle d’exécution. On trouve alors la structure condition.

Le résultat booléen du test est connecté sur le point d’interrogation vert.

Les instructions réalisées si le résultat du test est OUI sont écrites à l’intérieur de la structure lorsque VRAI apparaît en haut du rectangle délimité.

Les instructions réalisées si le résultat du test est NON sont écrites à l’intérieur de la structure lorsque FAUX apparaît en haut du rectangle délimité.

Un seul cas est visible simultanément, cliquer sur les triangles pour passer de l’un à l’autre.

EXEMPLE :

Chapitre 4 – LA BOUCLE WHILE

I – DEFINITION

La boucle While permet de répéter une suite d’instructions en fonction du résultat d’un test.

Un tour de boucle est appelé «itération".

Les instructions se répètent à chaque itération c’est à dire à chaque tour de boucle.

Dans LabVIEW, on peut régler la répétition en fonction du résultat VRAI ou FAUX du test.

Par défaut c’est le résultat FAUX qui permet la répétition.

II – ORGANIGRAMME

Suite     On peut permuter dans LabVIEW

III– LE TEST

Comme pour la structure conditionnelle :

Le test est la condition permettant de réaliser la répétition. Il est évalué après chaque itération.

Le test met en œuvre des opérateurs de comparaison <, >, ≤, ≥, =, ≠.

Il peut être aussi l’évaluation d’une simple variable booléenne (test de l’appui sur un bouton poussoir)

Le résultat du test est un booléen : il ne peut prendre que 2 valeurs : OUI ou NON.

Le test peut être simple du type a < b ou plus complexe : (a < b) ET (a < c)

Les relations de comparaisons sont alors reliées entre elles par des opérateurs logiques : ET, OU, NON ET, NON OU, OU Exclusif, etc ...

La relation correspondant au test est écrite dans le losange. REMARQUES :

Le test est répété à la fin de chaque tour de boucle. Il est donc nécessairement placé à l’intérieur de la boucle.

La boucle réalise nécessairement au minimum un tour de boucle : Le bloc d’instructions à répéter est réalisé au moins une fois.

IV – EXEMPLE

1°/ LA BOUCLE D’ATTENTE

Attendre l’appui sur un bouton poussoir BP pour allumer une led L. ENTREES SORTIES :

- Une Entrée booléenne : bouton poussoir nommé BP. Action mécanique : BP sans verrouillage.

- Une sortie booléenne : Led L.

ORGANIGRAMME :

V – BOUCLE WHILE SOUS LabVIEW

Chapitre 5 - LA BOUCLE FOR

I – DEFINITION

La boucle for permet de répéter une suite d’instructions un nombre prédéterminé de fois.

Avec la boucle While, on ne connaît pas à l’avance le nombre d’itérations qui seront réalisées.

Pour compter le nombre de répétitions, la boucle for utilise un compteur d’itérations. C’est une variable entière i variant de 0 à N-1 lorsque la boucle se répète N fois.

La boucle for utilise donc aussi une variable N entière donnant le nombre de tour de boucle.

II – ORGANIGRAMME

i = 0

III - AFFECTATION

L’écriture i = 0 ne peut pas s’écrire 0 = i.

En effet il ne s’agit pas d’une égalité au sens mathématique.

Cette instruction est une affectation : On affecte la valeur 0 à la variable i.

Une affectation en informatique s’effectue toujours de la droite vers la gauche.

De même l’écriture        i = i + 1 n’est pas non plus une égalité au sens mathématique.

En effet une telle écriture en mathématique conduit à 0 = 1 ! ! ! !

C’est une également une affectation : On prend la valeur de la variable i, on lui ajoute 1. La nouvelle valeur obtenue est alors redonnée à la même variable i.

IV – AUTRE ORGANIGRAMME POUR LA BOUCLE FOR Pour simplifier, on peut représenter la boucle for ainsi :

Pour i = 0 à N-1

VI - EXEMPLE



Compter toutes les deux secondes de 5 en 5 jusqu’à 50, le résultat étant affiché sur un afficheur numérique.

ENTREES SORTIES :

- Pas d’entrée

- Une sortie S, afficheur numérique.

ORGANIGRAMME

VII – BOUCLE FOR EN LabVIEW

Clic droit dans le diagramme, puis étendre la palette. Aller sur programmation puis structures.

Diagramme :

REMARQUE :

VIII – COMMANDES ET INDICATEUR DANS OU HORS DE LA BOUCLE

Chapitre 6 – LES TABLEAUX

I – DEFINITION

Un tableau permet de regrouper plusieurs variables numériques de même type sous une même appellation.

Les différents éléments du tableau (array) sont alors repérés par un indice (index).

Le nombre N d’éléments du tableau constitue sa taille (array size)

Chaque élément du tableau est repéré par un indice i allant de 0 à N-1

Les trois éléments se retrouvent à trois adresses différentes qui se suivent

II – TABLEAUX DANS LabVIEW

Quand  on dépose          le tableau sur la face avant, il est vide.

Il             convient donc de le remplir       à l’aide du type de variable choisi : tableau         de variables numériques, tableau de booléens, tableaux de chaînes          de caractères etc...

III – OPERATIONS SUR LES TABLEAUX

En plus des opérations arithmétiques classiques, il existe des fonctions spéciales :

Les fils de liaisons            des données tableaux sont en traits épais de la couleur du type de la variable : ici, on a des tableaux              de variables numériques à virgule flottante, les connexions sont donc de couleur orange. Indice et taille du tableau sont des            entiers donc couleur bleue.

Chapitre 7 - LES GRAPHES

I – LES ECHELLES

10/ ECHELLE LINEAIRE

N+1 points régulièrement espacés ième point

i+1 ème point

a             b

Pas : distance entre deux points. On a : pas = (b – a) / N

Passage d'un point à l'autre :                     xi = x i-1 + pas

Ainsi :                   xi = a + i . pas

On a une suite arithmétique de premier terme x0 = a et de raison q = pas

20/ ECHELLE LOGARITHMIQUE

N+1 points régulièrement espacés ième point

log a      i+1 ème point   log b

Pas : distance entre deux points. On a : pas = (log b – log a) / N = log (b/a)1/N Passage d'un point à l'autre : log xi = log x i-1 + pas

Ainsi : log xi = log a + i . pas = log a + i log (b/a)1/N = log a + log (b/a)i/N

= log [ a . (b/a)i/N ]

Donc : xi = a . (b/a)i/N <=> xi = a . (b/a)i-1/N . (b/a)1/N

xi =         xi-1 . (b/a)1/N ou xi = a . [(b/a)1/N ] i

On a une suite géométrique de premier terme x0 = a et de raison q = (b/a)1/N

II – LES DIFFERENCES

Boucle While

Terminal              graphe

déroulant équivalent à un indicateur numérique

Graphe dans la boucle

Boucle For

Terminal              graphe

équivalent à un tableau

Graphe hors de la boucle

Boucle For

Terminal graphe XY reçoit 2 tableaux

Graphe hors de la boucle

Une nouvelle ordonnée est calculée à chaque itération et est transmise au graphe qui déroule tant que l’on ne met pas fin à la boucle (appui sur stop par exemple)

La boucle while peut être cadencée par l’utilisation d’une attente.

Le graphe peut être gradué en temps.

Toutes les ordonnées des points sont calculées dans la boucle for.

Une fois la boucle terminée, les valeurs sont envoyées sous forme de tableau d’ordonnées

En abscisse du graphe on retrouve l’indice de chaque point : 0, 1, 2, 3 etc ...

Toutes les ordonnées et abscisses sont calculées dans la boucle for.

Une fois la boucle terminée, les valeurs sont envoyées sous forme de tableaux distincts :

- un tableau d’ordonnées

- un tableau d’abscisses.

III - PERIODE D’ECHANTILLONNAGE

Quelle que soit la représentation graphique, il faut définir un pas entre deux points de calcul ou d’acquisition. Dans le cas d’une représentation temporelle, on parle de période d’échantillonnage.

Echelle linéaire :

Δx = [ Xmax – Xmin ] / (N-1)

Echelle log :

Δx = [ Xmax/Xmin] 1/ (N-1)

Il faut suffisamment de points pas période ! ! !

ΔT = Te = T/N Cela entraîne :

Te << T <* Fe >> F

Chapitre 8 – GRAPHES DANS LABVIEW I – GRAPHE DEROULANT : Waveform Chart

Le rôle du graphe déroulant : Waveform Chart est d'afficher l'évolution temporelle d'une donnée variable dans le temps.

A chaque instant le graphe ne reçoit qu'une donnée à la fois : Ce n'est pas un tableau de valeurs.

Par programmation, il faut donc répéter l'envoi

des données au graphe, le terminal graphe

doit donc être dans une boucle while.

Exemple dans LabVIEW :

Certains paramètres du graphe peuvent être ajustés : clic droit sur l’objet graphe dans la face avant.

II – GRAPHES : Waveform Graph

Le rôle du graphe est de représenter graphiquement un tableau de données.

 donnée

0             5

1             10

2             15

3             20

4             25

5             30

6             35

7             40

Par programmation, il ne faut envoyer les données au graphe qu'une seule fois, le terminal graphe doit donc être hors de la boucle.

Exemple dans LabVIEW :

III – GRAPHE XY

Le rôle du graphe XY est de représenter graphiquement un tableau de données Y en fonction d'un tableau de données X

Donnée X

Donnée Y

0,1          5

0,2          10

0,3          15

0,4          20

0,5          25

0,6          30

0,7          35

0,8          40

Par programmation, il ne faut envoyer les données au graphe qu'une seule fois, le terminal graphe XY doit donc être hors de la boucle.

Chapitre 9 – LES REGISTRES A DECALAGE OU NŒUDS DE RETROACTION

I – EXEMPLE D’UTILISATION

EXEMPLE : Programmer n! On sait que n! = (n-1)! . n

II – REGISTRE A DECALAGE DANS LabVIEW

Exemple : factorielle n avec registre à décalage :

III – DECALAGES MULTIPLES 1°/ EXEMPLE

Exemple : Calculer et mettre à jour la moyenne M des 3 dernières mesures mi

On a M

i               = ( m+ m+ mi – 2 ) / 3

i               i -1

... ... ...

IV – UTILISATION EN INFORMATIQUE D’INSTRUMENTATION

Cette structure est souvent utilisée

en informatique d'instrumentation

Étape 1

Configuration

carte d'acquisition          Étape 2

Acquisition

Sortie Commande          Étape 3

RAZ carte daq

Cette structure peut également être utilisée également pour commander un système séquentiel (feux de carrefour)

V – PASSAGE DE VALEURS DANS LA SEQUENCE

Le passage de valeurs d’une étape à l’autre d’une séquence déroulée se fait naturellement au moyen d’un tunnel.

Par contre dans une séquence empilée, il faut utiliser variable locale de séquence : clic droit sur le bord de la séquence. On dispose alors d’une flèche entrante distribuant la donnée dans les autres étapes de la séquence.

Chapitre 10 – COMPLEMENTS I – VARIABLES LOCALES

Pour simplifier le câblage (éliminer des fils de trop grande longueur), on peut avoir recours à une variable locale. La variable locale créée prend le nom de la variable d’origine, et peut être utilisée en lecture ou en écriture, forçant ainsi la donnée à changer de valeur.

Dans l’exemple ci-dessous, la variable locale est en lecture (variable d’entrée) et apparaît comme une copie de a. Le terminal de sortie affichera donc (10+a)*a.

Dans l’exemple ci dessous, la variable locale est en écriture. Si la valeur de a était 1 au lancement du programme, elle se transforme en 11 lors de son arrêt.

II – SOUS PROGRAMMES : ENCAPSULATION

Nous souhaitons créer un sous programme encore qualifié de sous VI, de calcul du discriminant de l’équation du second degré.

Un Clic droit en haut à gauche sur l’icône LabVIEW permet d’ouvrir le menu local donné ci-dessous. Choisir Visualiser le connecteur.

LabVIEW sait que le programme manipule trois variables d’entrée et une sortie, et propose le connecteur correspondant. Il peut cependant être changé. Il convient ensuite d’associer à chaque rectangle du connecteur une variable d’entrée ou sortie. Pour cela il faut cliquer à l’aide de l’outil bobine, d’abord sur l’objet de la face avant correspondant à la variable, puis sur le rectangle de l’icône.

Ensuite, on peut modifier l’icône correspondant à ce sous programme : Choisir modifier l’icône dans le menu local obtenu par clic droit sur le connecteur.

 Il convient ensuite de sauvegarder ce sous VI à l’emplacement désiré.

Appel au sous dans un programme principal :

Dans le diagramme du programme principal, on utilise la palette de fonction :

Une boîte de dialogue invite à ouvrir le sous VI souhaité.

On dépose ainsi l’icône correspondante dans le diagramme et elle peut être utilisée comme n’importe quel VI LabVIEW. (Voir ci-dessous).

TP n° 1 et 2 – ENTREES SORTIES, OPERATEURS (Ch1 et Ch2)

EXERCICE 1.1

Soient 2 variables a et b numériques placées en face avant.

Afficher sur 4 sorties différentes : s1 = a+b, s2 = a – b, s3 = a*b et s4 = a / b

EXERCICE 1.2

Soit a une variable d’entrée de type entier.

Sur un afficheur numérique, afficher a sous le format binaire, hexadécimal et décimal. (Cf page 12)

Changer la représentation de a et s : U8, I8, U16, I16 et observer les valeurs extrêmes prises en charges par ces différentes représentations. (Cf page 10)

EXERCICE 1.3

Dans l’exercice précédent, ajouter une deuxième variable entière d’entrée b et afficher a+b. Donner les valeurs limites des différentes représentations U8, I8, U16, I16. Que se passe t-il quand le résultat dépasse les valeurs extrêmes ?

EXERCICE 1.4 – Réalisation d’un calcul 1°/ Utilisation d’opérateurs

Le gain en dB d’un circuit RC est donné par G = 20 log [ 1/√(1 + RC2nf)2 ) ]

Afficher sur un indicateur numérique le résultat de calcul de G pour les valeurs de R, C et f affichées sur des contrôleurs numériques en face avant.

Exemple de valeurs réalistes : R = 4,7 kÙ, C = 10 nF, f ≈ 1000 Hz.

2°/ Utilisation d’une boite de formule

Même question en utilisant la boite de formule (express/arithmétique)

3°/ Utilisation d’une boite de calcul

Même question en utilisant la boite de calcul (programmation/boîte de calcul)

EXERCICE 1.5

On veut également afficher le déphasage : ϕ = - arctan (RC2ðf)

1°/ Modifier le programme de l’exo 4 1°/ pour afficher le gain et le déphasage

2°/ Idem avec les boites de formules

3°/ Idem avec une boite de calcul unique.

EXERCICE 1.6 – Opérateurs booléens Réaliser un programme qui :

- allume un afficheur booléen L1 si deux interrupteurs K1 et K2 sont enfoncés. - allume un afficheur booléen L2 si deux interrupteurs K1 ou K2 sont enfoncés.

- allume un afficheur booléen L3 si deux interrupteurs K1 ou K2 sont enfoncés, mais pas les deux.

EXERCICE 1.7 – Nombres complexes

Réaliser un programme qui calcule les racines d’une équation du second degré (ax2+bx+c = 0) en utilisant deux afficheurs numériques de représentation complexe double précision (CDB).

Les coefficients a, b et c sont des contrôleurs numériques sur la face avant, représentation nombre à virgule flottante double précision (DBL).

EXERCICE 1.8 – Opérateur division euclidienne



1°/ Réaliser un programme qui convertit un nombre de mois, de jours, d’heures, de minutes et de secondes en secondes.

2°/ Réaliser un programme qui convertit un nombre de secondes en mois, jours, heures, minutes et secondes.

EXERCICE 1.9 – Chaînes de caractères

Réaliser un programme qui affiche sur un indicateur chaîne de caractère unique le contenu deux commandes de chaînes de caractère.

TPn°3 – TESTS ET STRCTURE CONDITIONNELLE (Ch3)

EXERCICE 3.1

On place 2 potentiomètres à glissière a et b sur la face avant. Si a > b allumer une led, si a <— b éteindre la led

EXERCICE 3.2

On place 2 potentiomètres à glissière a et b sur la face avant et un afficheur numérique s

Si a > b alors s = a + (b-a)/2 Si a <— b alors s = b + (a – b)/2

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 3.3 - Testeur de batterie

La tension d’une batterie 12 V est simulée par un potentiomètre U à glissière en face avant. Le résultat du test de la batterie est affiché sur 3 leds différentes.

Si 10 < U < 12 => Led Verte allumée Si 8 < U < 10 => Led Orange allumée Si 0 < U => Led Rouge allumée

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

TPn°4 – BOUCLE WHILE (Ch4) EXERCICE 4.1 – Boucle d’attente

Réaliser un programme qui attend l’appui sur un bouton poussoir avant d’afficher le résultat de a+b. N. B : On ne lancera pas l’exécution du vi par l’exécution récurrente !

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 4.2 – Lecture un point

Ecrire un programme qui lit en permanence un potentiomètre placé en face avant et affiche la partie entière de la valeur prise. L’arrêt du programme est réalisé par appui sur un bouton poussoir stop placé en face avant. On ne lancera pas l’exécution du vi par l’exécution récurrente !

La valeur lue sera actualisée toutes les N s (N est une commande numérique en face avant)

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 4.3 - Suite arithmétique

Réaliser un programme qui affiche successivement toutes les secondes les valeurs de la suite géométrique définie par son premier terme u0 et sa raison r. Le programme s’arrête par appui sur un bouton stop. Rappel : un = u0 + n r

U0 et n sont des contrôleurs numériques sur la face avant.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille

3°/ Réaliser le VI

4°/ Examiner l’influence de la position des terminaux de U0 et q dans la boucle ou hors de la boucle.

Quelle est la bonne solution ?

EXERCICE 4.4 – Nombre aléatoire

Réaliser un programme qui affiche sur un indicateur numérique un nombre aléatoire compris entre 0 et 20 généré périodiquement toutes les 0,5 s. Le programme s’arrêtera par appui sur un bouton stop.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

4°/ Compléter le vi de l’exo précédent de façon à afficher :

  1. a)            Le n° de l’itération (n° du tour de boucle en cours de réalisation).
  2. b)           Le nombre total d’itérations réalisées après appui sur le bouton stop.

TPn°5 – BOUCLE FOR (Ch5)

EXERCICE 5.1 – Nombre aléatoire

Réaliser un programme qui affiche sur un indicateur numérique trente nombres aléatoires compris entre 0 et 20 générés toutes les 0,5 s.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 5.2 - Suite géométrique

Réaliser un programme qui affiche successivement toutes les secondes les 20 premières valeurs de la suite géométrique définie par son premier terme u0 et sa raison q. Rappel : un = u0 * q n U0 et q sont des contrôleurs numériques sur la face avant.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille

3°/ Réaliser le VI

4°/ Examiner l’influence de la position des terminaux de U0 et q dans la boucle ou hors de la boucle.

Quelle est la bonne solution ?

TPn°6 – TABLEAUX (Ch6)

EXERCICE 6.1

Réaliser un programme qui génère automatiquement un tableau de 10 nombres entiers compris entre 0 et 20.

Modifier ce programme pour afficher successivement toutes les secondes les éléments du tableau sur un afficheur numérique.

EXERCICE 6.2

Réaliser un programme qui génère automatiquement un tableau de 10 nombres entiers compris entre 0 et 20. (faire un copier coller de la 1ère partie de l’exercice précédent).

Une fois le tableau généré, on souhaite éliminer les 5 éléments les plus petits sans les remplacer, et afficher sur un afficheur numérique la moyenne des éléments du tableau.

  1. a)            Après avoir réaliser le tri du tableau
  2. b)           Sans trier préalablement le tableau et sans changer l’ordre des éléments

EXERCICE 6.3 – Indexation en sortie

Ecrire un programme qui génère un nombre aléatoire entier compris entre 0 et 100 toutes les 0,5 s et qui s’arrête par appui sur un bouton stop.

Afficher alors dans 2 tableaux distincts les nombres pairs et impairs générés. EXERCICE 6.4 – Tableaux et boucles imbriquées

Générer un tableau de 15 lignes et 10 colonnes à l’aide de nombres entiers aléatoires compris entre – 10 et +10.

Modifier le programme pour remplacer les nombres pairs par 0.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

TPn°7 – TABLEAUX GRAPHES (Ch6, 7, 8)

EXERCICE 7.1 – Abscisses d’une échelle linéaire (Cf p 32-35)

Générer un tableau de N+1 points d’abscisse x compris entre a et b d’une graduation linéaire. N, a et b sont des commandes numériques saisies par l’utilisateur du programme.

EXERCICE 7.2 – Graphe déroulant

Ecrire un programme qui génère et visualise sur un graphe déroulant une sinusoïde d’amplitude 10 V modifiable en face avant, de fréquence 1 Hz modifiable par une commande en face avant.

La période d’échantillonnage (intervalle de temps servant à cadencer la boucle) sera compatible avec la période de la sinusoïde et modifiable en face avant.

On affichera également la période de la sinusoïde sur un indicateur numérique.

La fonction sinus est disponible dans la palette de fonctions mathématiques.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille

3°/ Réaliser le VI

4°/ Est-il préférable de placer les commandes d’amplitude et de fréquence dans ou hors de la boucle ?

EXERCICE 7.3 - Graphe

Ecrire un programme qui génère un tableau de N valeurs de la fonction y(t) = 10 sin (2 ð f t).

f sera réglable par un terminal en face avant mais ne doit pas être modifiable pendant le calcul des points.

On représentera deux périodes de cette fonction avec N points pour la représentation.

N sera réglable en face avant mais doit être tel qu’il y ait suffisamment de points calculés dans une période !

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille

3°/ Réaliser le VI

4°/ Doit-on placer la commande de fréquence dans ou hors de la boucle ?

EXERCICE 7.4 – Graphe XY

Modifier le programme précédent pour générer également un tableau des valeurs d’abscisse t de façon à afficher la courbe y(t) sur un graphe XY gradué en temps.

EXERCICE 7.5 - Abscisses d’une échelle logarithmique (Cf p 32-35)

Générer un tableau de N+1 points d’abscisse x compris entre a et b d’une échelle logarithmique. N, a et b sont des commandes numériques saisies par l’utilisateur du programme.

EXERCICE 7.6 - Graphe XY échelle logarithmique

Ecrire un programme permettant d’afficher sur un graphe la courbe de réponse en fréquence d’un circuit RC :

G (f) = 20 log [ 1 / √ ( 1 + (RC.2ðf) 2 ) ]

R et C sont modifiables grâce à une commande numérique.

Le nombre de points N est modifiable également sur la face avant. La courbe sera tracée de fa = 10 Hz à ff = 100000 Hz

On prendra R = 4700 Ù, C = 10 nF.

Le graphe utilisera en abscisses une échelle logarithmique (points régulièrement espacés) qui sera graduée en Hz.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

TP n°8 et 9 – BOUCLES ET REGISTRES A DECALAGE (Ch 8, Ch 9)

EXERCICE 8.1

Réaliser un programme qui affiche successivement toutes les secondes les 20 premières valeurs de la suite géométrique définie par son premier terme u0 et sa raison q entrés au clavier sur des afficheurs numériques. Rappel : un = un-1 * q

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 8.2

Tracer sur un graphe la courbe représentant les 10 premières valeurs de la suite récurrente définie par : u0 = -0,5 et un+1 = √ ( un + 1)

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

EXERCICE 8.3

Soit un filtre numérique défini par son équation de récurrence :

Filtre numérique

y(n) = x(n) - 1,6180x(n- 1) + x(n- 2) + 1,5161y(n - 1) - 0,8780y(n - 2)

Initialement on a : y -1 = 0 et y –2 = 0

Tracer sur un graphe la courbe représentant la suite des valeurs de yn en réponse à une séquence d’entrée échelon : xn = {1,1,1 .... } pour n > 0. xn = 0 pour n <0.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme correspondant sur feuille 3°/ Réaliser le VI

TP n° 10 – LES SEQUENCES (Ch 10)

EXZECICE 10.1

La marche avant est simulée par l’allumage d’une led verte (led1) La marche arrière est simulée par l’allumage d’une led rouge (led2).

Le wagon étant en position initiale, l’appui sur le bouton DCy (départ cycle) lancera la marche avant. Le contact avec le mur est simulé par appui sur un bouton poussoir BP1

Simuler le fonctionnement du chariot qui attend l’appui sur DCy pour avancer et qui doit faire marche arrière quand le bouton poussoir BP1 est enfoncé. Le retour en position initiale est détecté par le contact simulé par un bouton poussoir BP2.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme sur feuille

3°/ Réaliser le vi en utilisant la structure séquence.

  1. B : On ne lancera pas l’exécution du vi par l’exécution récurrente !

Led 1 = Vrai

Attente 3s

Led 1 = Faux

1°/ Quelles sont les variables d’entrées et sorties apparaissant dans cet organigramme ? 2°/ Expliquer la fonction réalisée par cet organigramme 3°/ Transcrire cet organigramme en diagramme LabVIEW.

EXERCICE 10.3

Même dispositif. Simuler le fonctionnement du chariot qui attend l’appui sur DCy pour avancer et qui effectue 10 aller-retour détectés par appui sur le bouton poussoir BP. Le retour en position initiale est signalé par le capteur simulé par un bouton poussoir BP2 en face avant.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme sur feuille

3°/ Réaliser le vi en utilisant la structure séquence.

EXERCICE 10. 4 – Jeu de lumières

On utilise un chenillard constitué d’un tableau de 10 leds.

Dans un premier temps, les leds s’allument successivement. Ce cycle recommence trois fois consécutives.

Dans un deuxième temps les 10 leds clignotent 4 fois simultanément (allumage pendant 1/4 seconde).

Dans un troisième temps, pendant 1/4 s les leds de n° impair sont allumées pendants que les n° pairs sont éteintes puis inversement pendant 1/4 s, ce cycle recommençant 3 fois.

Les trois phases doivent se succéder jusqu’à l’arrêt par appui sur un bouton Stop.

EXERCICE 10. 5 – Mesure d’un temps d’exécution

Réaliser un programme qui mesure le temps d’exécution d’une boucle for qui réalise 1000 fois la génération d’un nombre aléatoire.

On utilisera obligatoirement la structure séquence.

1°/ Donner l’organigramme.

2°/ Dessiner le diagramme sur feuille

3°/ Réaliser le vi en utilisant la structure séquence.



510