Discussion :

[Daka]

Bonjour à tous,

Je dois faire arriver un paramètre à une certaine valeur, et quand il y est, le faire redescendre, et ceci un certain nombre de fois.

J'ai donc utilisé une boucle FOR qui prend en paramètre le nombre de cycle choisi.
Dans cette boucle, il y a une structure séquence déroulée, pour être sûr que la première partie (augmentation de la valeur du paramètre) s'effectue avant la seconde (baisse de sa valeur).
Et dans chacune des séquence, une boucle WHILE dans laquelle je multiplie le temps par une vitesse de montée définie sur la face avant. La boucle tourne tant que le paramètre n'a pas atteint une certaine valeur.

Dans mon programme j'ai utilisé deux afficheurs et deux graphes (un pour chaque séquence) pour la valeur du paramètre.
Et récupère la valeur du paramètre à la fin de la première séquence pour l'utiliser dans la seconde.

Mes problèmes sont les suivants :
- Comment faire pour qu'un seul graphe déroulant et un seul afficheur mis à jour en continu, récupère la valeur du paramètre de la première séquence et de la deuxième ?
- Ce petit programme doit être intégré à un programme plus important. Comment faire pour que les données non utilisées dans la boucle while soit toujours mises à jour (par DAQ) même quand on entre dans la boucle while ?

Est-ce que vous avez une idée sur la façon de gérer ça ?

En gros, j'ai vraiment l'impression que quelque chose m'échappe dans la philosophie LABVIEW

Merci en tout cas

[Daka]

Bon, j'ai un peu avancé quand même.

Je m'en suis sorti avec un noeud de propriété sur la valeur du graphe pour n'en avoir qu'un.
Quand je teste ce programme seul, il fonctionne correctement.

Par contre si j'essaie de l'intégrer en tant que sous-VI dans un programme maître, je n'arrive pas à récupérer en temps réel les infos que j'ai cablé en sortie de mon sous-VI.
En gros, le programme principal est muet pendant toute la durée d'exécution du sous-VI et ne prend des valeurs qu'à la fin de celui-ci.

D'où, problème
Est-ce le cas pour tous les sous-VI (attendre la fin de l'exécution avant d'envoyer les valeurs câblée en sortie) ou est-ce dû à l'utilisation des structures séquences ?
Sinon, comment récupérer mes valeurs en cours ? Avec des variables globales ?

Merci de votre aide.

(j'ai édité le sujet du topic pour mieux coller à ma nouvelle question)

[Scyrius]

Hello,

Tu oublies un petit détail de programmation: tu ne peux pas continuer un code appelant une fonction si cette fonction n'est pas terminée...
Si tu veux le faire, il faut lancer cette fonction séparément via un thread pour qu'elle soit autonome.

voili,

[BrunoIRM]

Salut,

Je complète la réponse pertinente de Scyrius. Effectivement, en programmation par flux de données, un peu comme en programmation "structurée" (C, C++, ...), tu es obligé d'attendre qu'une fonction soit terminée pouvoir récupérer les valeurs qu'elle est sensée calculer/renvoyer.

LabVIEW pouvant exécuter les processus en parallèle, il est possible d'accéder à certaines données d'un VI en train de s'exécuter. En fait, c'est un peu différent : il faut que tu définisses ces données comme des données "globales" : il ne s'agit pas d'accéder aux données d'un sous-VI pendant que celui-ci s'exécuter, mais il s'agit de lui faire accéder à des données (variables) qui lui sont extérieures.

Il s'agit en fait de l'utilisation des variables globales.

Avec un gros hic : la programmation à l'aide de variables globales ne respecte plus le paradigme de la programmation par flux de données. Ce qui est le fondement de LabVIEW.

A toi de voir.

Pour en savoir plus sur les variables globales :

http://zone.ni.com/devzone/cda/tut/p/id/7585

Désolé, c'est en anglais, mais c'est exactement ce que tu cherches à faire (me semble-t-il).

A+

B.

[Daka]

Merci pour ces informations. et pour la précision. Je voyais les sous-VI plus comme des parties de programmes que comme des fonctions. Ceci explique cela.

Il reste que tout ça me parait bien compliqué pour moi, alors peut-être que je m'y suis mal pris dès le début dans mon programme (espoir, espoir...).
Je vais essayer de vous expliquer ce que je dois faire avec plus de détails.

0. J'ai une machine dans laquelle je coince un bout de métal entre deux mors. Un des mors est fixe, et l'autre relié à un levier. Quand je tire le levier, j'applique une force sur le bout de métal qui le fait s'allonger. Jusque là, c'est pas compliqué.

1. Je reçois deux signaux d'une carte d'acquisition : la FORCE appliquée et l'ALLONGEMENT résultant.

2. L'essai à réaliser consiste à piloter la FORCE pour la faire monter à 100 à la vitesse de 1 par seconde, puis la faire redescendre à 0 à la même vitesse et ceci 5 fois.

3. Je dispose pour ça d'une entrée CONSIGNE sur la machine de test qui me permet, en y envoyant un signal, de mettre en route un moteur qui va tirer sur le levier pour que la valeur de la FORCE appliquée aille rejoindre la valeur de la CONSIGNE.

4. Je dois donc générer un signal qui évolue dans le temps suivant la formule et l'envoyer par une sortie de la carte d'acquisition dans l'entrée CONSIGNE.

5. Et bien sûr, enregistrer la réponse du système : la FORCE et l'ALLONGEMENT

6. Une fois que je suis arrivé à la valeur de FORCE maximum (et non pas à la valeur de CONSIGNE maximum, puisque la réponse du système n'est pas immédiate), je passe à une seconde étape dans laquelle la valeur de CONSIGNE baisse cette fois jusqu'à ce que la FORCE ait atteint 0.

7. Et ça 5 fois.

Ce que je voudrais, et c'est peut-être là que j'en demande trop, c'est avoir une interface sur laquelle j'ai en affichage continu et temps réel les valeurs FORCE et ALLONGEMENT sans qu'elles s'enregistrent, pouvoir paramétrer les cycles (le nombre, la vitesse...), enregistrer les paramètres, puis lancer les cycles quand je l'ai décidé en enregistrant cette fois les données FORCE et ALLONGEMENT dans un fichier.

J'ai commencé de la façon suivante :
1. une boucle WHILE qui englobe tout
2. une structure ÉVÈNEMENT qui teste si j'appuie sur le bouton "enregistrer les paramètres" ou "charger les paramètres", ou "lancer les cycles"
3. quand j'appuie sur "lancer les cycles", j'ai une boucle FOR avec comme paramètres le nombre de cycles à faire
4. Dans cette boucle FOR, j'ai une structure SÉQUENCE DÉROULÉE en deux étapes.
5. Chacune des étapes a une boucle WHILE avec comme condition de fin que la FORCE arrive à une certaine valeur (100 dans un cas, 0 dans l'autre) et à l'intérieur, l'évolution de la CONSIGNE en fonction du temps.

Comment auriez-vous procédé ?

La problème de toutes ces boucles c'est que je ne peux pas acquérir en continu les données et surtout les faire interagir entre elles, puisque c'est la valeur CONSIGNE qui évolue dans la boucle while, mais c'est la valeur FORCE qui la fait s'arrêter.
Si j'ajoute que je n'ai pas la possibilité pour l'instant d'être au pied de la machine à acquérir les vrais signaux, et que j'essaie donc de travailler sans, vous comprendrez peut-être mon état

En tout cas, désolé pour toutes ces questions, et pour le pavé. Merci de m'avoir lu jusque là et merci de votre aide si vous avez quelques conseils.

[Daka]

Pour en savoir plus sur les variables globales :

http://zone.ni.com/devzone/cda/tut/p/id/7585

Merci pour l'exemple.
Je n'arrive pas à comprendre comment une simple variable locale "force" Labview à exécuter deux boucles en même temps.