« LabVIEW : programmation et applications
» ou comment apprendre à utiliser LabVIEW
Par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - M...
Prochain SlideShare
Chargement dans…5
×

« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW

533 vues

Publié le

J'ai publié un extrait de mon livre intitulé LabVIEW - Programmation et applications. Vous pouvez retrouver l'extrait en cliquant sur le lien ci-dessous :
« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW
N'hésitez pas à me donner votre avis sur cet extrait et également sur le livre.
Merci.

Publié dans : Logiciels
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
533
Sur SlideShare
0
Issues des intégrations
0
Intégrations
3
Actions
Partages
0
Téléchargements
19
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

« LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW

  1. 1. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW Par Luc Desruelle - Francis Cottet - Michel Pinard Date de publication : 30 septembre 2015 Cet article est un ensemble d'extraits du livre « LabVIEW, programmation et applications ». Retrouvez le livre sur Amazon ! Vous pouvez commenter cet extrait sur le forum LabVIEW : Commentez
  2. 2. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 2 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ I - Avant-propos : extrait du livre.................................................................................................................................3 II - Introduction.............................................................................................................................................................3 II-A - LabVIEW ? Vous avez dit LabVIEW ? Le flux de données ?....................................................................... 3 II-B - LabVIEW dans le monde de l'instrumentation..............................................................................................4 III - Les bases de la Programmation...........................................................................................................................5 III-A - Instrument virtuel (VI) sous LabVIEW......................................................................................................... 5 III-B - Les dix commandements du développeur LabVIEW...................................................................................6 IV - Méthodologie pour trouver de l'aide sous LabVIEW............................................................................................7 IV-A - Recherche dans l'aide contextuelle.............................................................................................................7 IV-B - Recherche dans l'aide LabVIEW.................................................................................................................7 IV-C - Recherche d'exemples................................................................................................................................ 7 IV-D - La communauté travaille pour vous............................................................................................................7 IV-E - Contacter un partenaire certifié du « Programme Alliance »...................................................................... 8 V - La Gestion des erreurs sous LabVIEW................................................................................................................ 8 V-A - Définition....................................................................................................................................................... 8 V-B - Comprendre l'origine et la raison de l'erreur................................................................................................9 V-C - Gestion dans les VI......................................................................................................................................9 VI - Création d'un objet personnalisé : exemple d'un GIF animé............................................................................. 10 VII - Gestion avancée des données..........................................................................................................................11 VII-A - Indicateur VS Locale VS Globale VS Nœud de propriété....................................................................... 11 VII-B - Variable Globale Fonctionnelle ou VGF (FGV)........................................................................................ 13 VII-B-1 - Histoire............................................................................................................................................. 13 VII-B-2 - Principe et bénéfice......................................................................................................................... 13 VIII - Structure de programme (FrameWork)............................................................................................................ 14 VIII-A - Les règles d'architecture pour les applications et les modèles de conceptions les plus utilisées............14 VIII-B - Machine à états....................................................................................................................................... 15 VIII-B-1 - Définition générale.......................................................................................................................... 15 VIII-B-2 - Transcription en LabVIEW.............................................................................................................. 15 VIII-C - Bien démarrer un projet LabVIEW avec le GMF (QMH)........................................................................ 16 IX - Construire et piloter un système de mesure (DAQmx et VISA).........................................................................19 IX-A - Comprendre les architectures logicielles des instruments d'E/S...............................................................19 IX-B - Pilotage des cartes d'acquisition et de génération de signaux de National Instruments avec le driver NI- DAQmx..................................................................................................................................................................19 IX-C - Utilisation de Measurement And Automation Explorer (MAX), (configurer, créer, tester et diagnostiquer le matériel)................................................................................................................................................................ 21 IX-D - Utilisation du driver VISA pour piloter les instruments depuis LabVIEW.................................................. 23 IX-D-1 - Trouver un driver d'instrument : IDNet..............................................................................................23 IX-D-2 - Zoom sur les fonctionnalités de VISA.............................................................................................. 24 X - Réaliser rapidement des rapports Microsoft Office Word et Excel avec LabVIEW et le Report Generation toolkit.......................................................................................................................................................................... 25 XI - Accélérer votre productivité : les outils gratuits et indispensables à vos développements LabVIEW.................26 XI-A - Indispensable aux développeurs............................................................................................................... 27 XI-B - Les bibliothèques OpenG, les indispensables à télécharger.................................................................... 28 XI-C - Les sondes SAPHIR, incontournables pour la mise au point du code..................................................... 29 XII - Conclusion......................................................................................................................................................... 30 XIII - Annexe : Le sommaire du Livre : LabVIEW - Programmation et applications (3e édition) - Luc Desruelle.......30
  3. 3. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 3 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ I - Avant-propos : extrait du livre L'ouvrage est divisé en six chapitres. Le premier présente les concepts et l'intérêt de la programmation graphique. Le flux de données qui est une notion fondamentale à comprendre sous LabVIEW est défini, ainsi que les éléments nécessaires à sa propagation et son exploitation. Le chapitre 2 permet de décrire les éléments de base de l'environnement de programmation, illustrés avec des exemples simples. Le lecteur apprend à utiliser les objets pour réaliser une interface utilisateur, mais aussi les structures de programmation et les bibliothèques de fonctions. Le langage de développement graphique LabVIEW est intuitif, mais cela ne doit pas faire oublier que, comme avec tous les langages, il faut respecter des règles. Le chapitre 3 aborde des aspects plus avancés de l'utilisation de l'environnement en définissant des techniques permettant au code d'être maintenable, évolutif, performant et compréhensible par d'autres utilisateurs. Il permet de décrire par des exemples concrets et détaillés les structures de programme à utiliser afin de permettre au lecteur de réaliser une application. L'utilisateur sera capable à la suite de ce chapitre de préparer la certification LabVIEW développeur. Les trois derniers chapitres abordent les capacités spécifiques de LabVIEW pour l'acquisition, l'analyse et la présentation des données. Il est le langage de développement le plus efficace pour réaliser un tel système. Dans le chapitre 4, le lecteur apprendra à construire un système de mesure ou de génération de signal, à base de carte d'acquisition (DAQ), d'instrument (IVI, VISA), de système Temps Réel (RT) ou de FPGA. Différentes méthodes de connexion seront envisagées (Série, GPIB, Ethernet, PCI, etc.), ainsi que la réalisation de drivers dans les règles de l'art. Après cette collecte des données, dans le chapitre 5 l'utilisateur pourra à partir de bibliothèques intégrées réaliser un traitement du signal, une analyse mathématique ou un filtrage de l'information. Dans le dernier chapitre, nous illustrerons comment archiver et échanger les données ainsi traitées. Nous verrons comment finaliser son développement, en générant un exécutable autonome et en réalisant un rapport professionnel sous Microsoft Office, pour présenter ses données. II - Introduction II-A - LabVIEW ? Vous avez dit LabVIEW ? Le flux de données ? LabVIEW est un environnement de développement complet, graphique, compilé et particulièrement bien adapté au domaine de l'acquisition et de la mesure. Son approche totalement graphique offre une souplesse et une dimension intuitive inégalée. Comparativement aux langages textuels, il offre la même puissance de programmation, mais sans le côté abstrait et complexe lié à la syntaxe. Orienté tests et mesures, il dispose de nombreuses fonctions permettant de piloter facilement des cartes d'acquisition et autres instruments, mais aussi de filtrer, d'analyser et de présenter les données. Ce langage est également appelé code G. Le code est représenté par un schéma composé de fonctions, de structures et de fils qui propagent les données. L'approche visuelle, l'interface entre le code et le développeur s'opposent sur la forme et la philosophie aux langages textuels, comme le C. LabVIEW est redoutable de puissance et n'a rien à envier aux autres langages. Une des différences fondamentales de LabVIEW (par rapport aux langages classiques) est que ce langage suit un modèle de flux de données, et non de flux d'instructions. Cela signifie que pour un langage textuel, ce sont les instructions qui ont la priorité, alors qu'avec LabVIEW, ce sont les données. Une fonction s'exécutera donc à partir du moment où elle dispose à ses entrées de toutes les données dont elle a besoin. L'exemple suivant, grâce à l'animation, illustre le principe du flux de données. Il réalise un calcul mathématique très simple a x b + c. 1 La fonction « Multiply » s'exécute lorsqu'elle dispose des données à ses entrées (a=1 et b=2), donc dès le départ.
  4. 4. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 4 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ 2 La fonction « Add », dispose de l'entrée « c = 3 », mais elle est en attente du résultat de la fonction « Multiply ». Dès que la valeur « 2 » est calculée en sortie de la fonction « Multiply », elle devient disponible pour la fonction « Add » qui va pouvoir être calculée. 3 La fonction, en bas à droite de l'image, permet d'attendre une seconde. Il est très important de constater que cette attente s'exécute en même temps que la fonction qui calcule a x b + c. Lorsqu'un langage classique est ainsi séquentiel, LabVIEW est naturellement prédisposé au parallélisme. Ce qui augmente encore sa puissance et la rapidité d'exécution du code. La fenêtre qui contient le code est appelée le diagramme. Cette notion sera développée par la suite. II-B - LabVIEW dans le monde de l'instrumentation LabVIEW est un des premiers langages de programmation graphique destinés au développement d'applications d'instrumentation. Un logiciel d'instrumentation pourrait être défini comme un programme permettant de contrôler depuis un ordinateur, un système allant du capteur à la chaîne d'acquisition ou de commande jusqu'à l'édition du rapport final. Couplé à des cartes d'entrées/sorties, il permet de gérer des flux d'informations numériques ou analogiques et de créer ou de simuler des instruments de mesure (oscilloscope, compteur, multimètre, etc.). Le temps nécessaire à l'assemblage des composants de ce type de système est négligeable par rapport à celui nécessaire à sa programmation dans un langage classique (C, Pascal, Ada, etc.). Les interfaces utilisateur, développées avec ces langages, sont le plus souvent obscures et incompréhensibles. Les utilisateurs disposent avec LabVIEW d'un puissant outil intégré d'acquisition, d'analyse et de présentation des données, une solution qui entraîne un gain notable de productivité comparable à celui obtenu par l'introduction des tableurs dans les logiciels financiers. Pour cela, le langage utilise toute la convivialité des interfaces interactives des ordinateurs actuels en fournissant des objets proches graphiquement des objets réels (voyants, curseurs, interrupteurs, boutons, graphes, etc.), mais aussi des commandes système (pour une représentation plus standard) ainsi que des outils familiers et simples d'utilisation pour la programmation (structures de programmation, fonctions arithmétiques, fonctions logiques, comparateurs, etc.).
  5. 5. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 5 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 1 - Bibliothèques logicielles proposées dans l'environnement LabVIEW. III - Les bases de la Programmation Une grande partie du livre (200 pages sur 450) couvre la découverte de l'environnement de développement intégré LabVIEW ou EDI, puis les bases de la programmation pour pouvoir réaliser des programmes « simples ». Il existe de nombreux tutoriels sur Internet sur les bases de la programmation LabVIEW (sur developpez.com ou ni.com). Je fais le choix de restreindre cette « initiation » dans ce tutoriel. Le but est de plus développer les « techniques avancées » qui sont rarement évoquées sur Internet. Le principe important à comprendre dans l'environnement de développement LabVIEW, est que le langage G ainsi écrit suit un modèle flux de données. Une fonction s'exécute à partir du moment où elle dispose en ses entrées de toutes les données dont elle a besoin. LabVIEW est donc prédisposé au parallélisme. Deux fonctions indépendantes s'exécutent en parallèle. III-A - Instrument virtuel (VI) sous LabVIEW Historiquement, un logiciel de mesure est un instrument de mesure qui est contrôlé depuis un ordinateur à la place des boutons sur sa face-avant. Cette logique conduit à la notion d'instrument virtuel: instrument réel contrôlé depuis un ordinateur. Un instrument virtuel est donc un programme qui présente une interface sous forme graphique (IHM) pour l'apparenter à un instrument physique. Les utilisateurs manipulent alors des instruments depuis l'ordinateur (virtuels) comme s'il s'agissait d'instruments physiques sur «étagère» (réels). Comme historiquement l'environnement de développement (IDE) est orienté «instrumentation», les inventeurs de LabVIEW ont donné l'extension .vi (Virtual Instrument: VI) au programme développé avec cet environnement pour faire le lien avec le pilotage d'instrument depuis l'ordinateur. C'est donc l'extension du fichier sur le disque « MonCode.vi », comme un document Word est de type « MonDocument.docx ». Un programme ou VI, développé dans l'environnement LabVIEW, se compose principalement de deux éléments étroitement associés et regroupés sous le même nom « nom_application.vi » (l'extension .vi permet une reconnaissance immédiate par l'environnement LabVIEW). Ainsi nous avons : · La « face-avant » (Front panel) qui est l'interface utilisateur du programme au sens génie logiciel: définition des entrées/sorties de données accessibles par l'utilisateur du programme (figures 1.4, 1.5 et 1.18). Cette notion sera reprise en détail dans le chapitre 3.
  6. 6. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 6 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Exemple d'une« face-avant » réaliséeavec LabVIEW (application développée par Luc DESRUELLE société MESULOG) Le « Diagramme » (diagram) qui est le programme de l'application ou code source. Il écrit sous la forme d'un diagramme flux de données en langage G : ensemble des icônes et des liaisons entre ces icônes utilisées (figure 1.19). Cette partie de l'application est ce que l'on appelle le code source par opposition à l'interface utilisateur. Exemple d'un diagramme LabVIEW, qui est le code en langage G III-B - Les dix commandements du développeur LabVIEW Le développeur LabVIEW devra suivre la synthèse des commandements suivants pour s'assurer que son code est conforme aux règles de développement. 1. Sur un seul écran ton code tiendra. 2. De gauche à droite tu coderas. 3. Les fils tu ne croiseras pas. 4. La gestion de l'erreur tu ne transgressas pas. 5. Le connecteur de type 4x4 toujours tu utiliseras. 6. Les contrôles, indicateurs et sous-VI judicieux tu nommeras. 7. Le flux de données tu respecteras.
  7. 7. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 7 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ 8. Ton code toujours et immédiatement tu documenteras. 9. Des sous-VI tu feras. 10. La structure séquence empilée tu refuseras. Plus d'informations sur les règles de style à respecter avec LabVIEW dans le livre. IV - Méthodologie pour trouver de l'aide sous LabVIEW Lorsqu'un développeur débute, il est normal qu'il se pose de nombreuses questions et qu'il ait besoin d'aide. S'il est seul, comme c'est souvent le cas, il peut rapidement se trouver dans une impasse et perdre beaucoup de temps. Il est très important de connaître les bonnes méthodologies à appliquer pour trouver les bonnes réponses. IV-A - Recherche dans l'aide contextuelle Sur une fonction de la palette, le moyen le plus simple est d'utiliser la fenêtre d'aide contextuelle : menu Aide, puis Visualiser l'aide ou Ctrl-H : si cette aide est active, il suffit de placer le curseur sur un élément pour avoir une aide simplifiée. Dans la fenêtre, il est possible d'accéder à une aide plus détaillée en cliquant sur le lien hypertexte. IV-B - Recherche dans l'aide LabVIEW Pour vous procurer des informations sur les concepts de programmation LabVIEW, des instructions détaillées : sélectionnez Aide puis Rechercher dans l'Aide LabVIEW. IV-C - Recherche d'exemples Pour développer une nouvelle fonction, vous pouvez modifier un VI d'exemple pour l'adapter à votre application : Sélectionnez Aide puis Recherche d'exemples pour parcourir des centaines de VI d'exemple (chapitre 4). IV-D - La communauté travaille pour vous Internet et surtout le site de National Instruments, www.ni.com, regroupent des liens vers des cours et formations, solutions utilisateur (voir paragraphe 6.6), VI d'exemple, support technique, groupes d'utilisateurs et forum. Il est très riche en contenu et constitue une réelle source d'inspiration. À noter qu'il existe en langue française : • deux forums de discussions pour NI LabVIEW et autres sujets, avec des experts qui répondent rapidement à toutes les questions. Les forums francophones sont d'une très grande qualité. Pour les trouver, le plus simple est de faire une recherche sur Internet avec les mots-clés : « Discussions au sujet de NI LabVIEW » . J'interviens régulièrement sur le forum : http://forums.ni.com/t5/Discussions-au-sujet-de-NI/bd-p/4171; • une communauté très dynamique qui organise des rencontres développeurs pour le partage de techniques, d'informations et de convivialité ; • les blogs des développeurs certifiés, par exemple blog du développeur certifié LabVIEW, Luc DESRUELLE, pour plus d'exemples
  8. 8. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 8 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 3.10 -Pour trouver de l'aide, allez dans l'aide contextuelle, le site NI France, les deux forums francophones ainsi que les blogs. IV-E - Contacter un partenaire certifié du « Programme Alliance » Pour une expertise, un besoin ponctuel ou pour sous-traiter un développement, nous vous conseillons de faire appel aux partenaires National Instruments du Programme Alliance. Ces partenaires ont reçu, après évaluation, l'agrément certifiant de leurs compétences en matière de programmation et de connaissances générales sur le logiciel LabVIEW. La liste est disponible sur le site de National Instruments. Vous aurez ainsi accès à des professionnels disposant des niveaux Certifié LabVIEW Développeur (CLD), voire Certifié LabVIEW Architecte (CLA). Ils seront les garants de la réussite de vos projets, avec un développement dans les règles de l'art. Pour les trouver, le plus simple est de faire une recherche sur Internet avec les mots-clés « partenaire alliance national instruments ». Moi, Luc DESRUELLE, l'auteur du livre LabVIEW et de ce tutoriel, serait ravi de vous apporter mon expertise en tant que Certifié LabVIEW Architecte (CLA), au travers de la société MESULOG qui est partenaire National Instruments. Mais aussi l'ensemble de mes confrères… V - La Gestion des erreurs sous LabVIEW V-A - Définition La gestion de l'erreur n'est jamais une option, mais une obligation. Elle consiste à anticiper, détecter et résoudre les mises en garde et les erreurs. Sans cette gestion, le programme peut avoir un comportement incohérent, mais sans pouvoir en identifier la cause. Par exemple, sans gestion d'erreur, un programme pourrait réaliser une acquisition sur un instrument éteint, et sauvegarder sans problème les données sur un disque dur réseau qui n'existe pas. Un miracle ? Non un calvaire. La structure de la donnée « erreur » au niveau de LabVIEW est un cluster formé des trois éléments suivants (figure 3.22) :
  9. 9. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 9 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ • Etat : un booléen qui est à l'état « Vrai » si une erreur s'est produite ; • Code, un entier de 32 bits, qui contient le numéro de l'erreur ou « 0 » s'il n'y a pas d'erreur. Un code d'erreur différent de zéro avec un état « Faux » signale une mise en garde. Une mise en garde n'empêche pas le code de tourner, mais LabVIEW attire votre attention sur un point qu'il lui semble anormal. • Source : une chaîne de caractères identifiant l'endroit où l'erreur s'est produite. Figure 3.22 - Type de représentation de la donnée « erreur » (cluster) et extraction des différents éléments avec la fonction Désassembler par nom, utilisée dans le « Diagramme ». V-B - Comprendre l'origine et la raison de l'erreur En code source, pour résoudre le problème, il est possible de faire un clic droit sur le bord du cluster d'erreur et de sélectionner Expliquer l'erreur (figure 3.23). Une boite de dialogue de gestion de l'erreur va s'ouvrir permettant de : • expliquer l'origine en visualisant le nom du VI qui a généré l'erreur, dans notre exemple « Mon Code Acquisition.vi » ; • proposer une ou des raisons possibles par rapport au code d'erreur, dans notre exemple LabVIEW propose la raison suivante : « La tâche spécifiée n'est pas valide ou n'existe pas », ce qui est le cas ; • l'origine et la cause permettent en général de comprendre le problème et de le résoudre. Si cela n'est pas le cas, il faut utiliser les outils de débogage, comme les sondes et les points d'arrêt. Figure 3.23 - Comprendre l'origine de l'erreur et la raison pour corriger le problème. V-C - Gestion dans les VI Tous les VI posséderont donc obligatoirement un « cluster d'entrée erreur » et un « cluster de sortie erreur ». Une exception peut être faite concernant les VI qui ne génèrent aucune erreur. Par exemple, un VI qui réalise le calcul « a²+b² ». Ce calcul est réalisé par des fonctions natives de LabVIEW qui ne génère pas d'erreur, le VI qui réalise ce code ne générera donc pas d'erreur. Cependant, même dans ce cas, il est intéressant d'ajouter à ce VI une entrée
  10. 10. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 10 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ et une sortie « cluster d'erreur ». Cette entrée et cette sortie seront directement reliées entre elles. Ce « dispositif » permettra de positionner le VI dans le flux d'erreur global et donc de séquencer le code de la bonne façon. Plus d'informations sur la gestion des erreurs avec LabVIEW dans le livre. VI - Création d'un objet personnalisé : exemple d'un GIF animé Pour d'autres exemples de personnalisation d'objets LabVIEW, voir le livre chapitre 3. Pour un aspect plus ergonomique, il est possible de personnaliser les « objets graphiques » de la face-avant. Par exemple, il est possible d'importer des images, par exemple en utilisant un objet de type menu déroulant d'images (picture Ring). Il est conseillé d'utiliser la fonction Édition → Importer une image dans le presse-papier afin de ne pas dégrader l'image, puis de sélectionner Ajouter un élément après par un clic droit sur le contrôle. L'état à afficher est disponible via la valeur de l'indicateur (figure 3.39). Il est également possible d'ajouter une image animée pour signaler le déroulement d'une action en cours sans avoir besoin de saisir du code (figure 3.40). Par exemple, pour afficher une mise à jour, nous allons insérer un GIF animé dans l'état « vrai » d'un bouton, et aucune image dans l'état « faux ». Cela permettra de visualiser cette mise à jour en affichant l'état « vrai » du bouton. La fin de la mise à jour correspondra à l'état « faux » du même bouton. Après avoir réalisé ou téléchargé une image libre de droits au format Gif animé, positionnez une commande de type Classique → Booléen → Bouton carré plat de la palette sur la « face-avant ». Sélectionnez Personnaliser la commande (Customize Control…) du menu Édition (Edit). La fenêtre de l'éditeur de commande apparaît. Sélectionnez dans le menu : Édition → Importer une image dans le presse-papier afin de ne pas dégrader l'image, et sélectionnez l'image animée. Faites un clic droit sur le contrôle et sélectionnez Importer une image du presse-papier → Vrai, nous avons modifié l'image du bouton pour l'état « Vrai ». Figure 3.39 - Exemple d'une personnalisation simple d'un objet indicateur.
  11. 11. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 11 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 3.40 - Exemple d'une personnalisation des images d'un objet. L'utilisation d'images et de couleurs permet de mieux respecter les critères subjectifs comme les conventions et la culture. Plus d'exemples d'objets personnalisés dans le livre et sur le blog une image pour éviter de faire du code Cliquer sur ce lien pour lancer l'animation VII - Gestion avancée des données VII-A - Indicateur VS Locale VS Globale VS Nœud de propriété Savez-vous répondre à la question (simple) suivante ? (niveau CLAD…) Indicateur VS locale VS globale VS Nœud de propriété L'explication n'est pas si simple. Par définition les nœuds de propriété se synchronisent dans le thread « interface utilisateur »
  12. 12. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 12 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ • seul système d'exécution pas multithread, donc si occupé provoque des lenteurs ; • la face-avant du VI sera chargée en mémoire. Or les commandes et indicateurs, sur une face-avant chargée en mémoire, ont leur propre copie des données. Il en résulte trois copies (buffer) des variables pour la mise à jour entre le diagramme et l'IHM. Les commandes et indicateurs, sur une face-avant chargée en mémoire, ont leur propre copie des données. Mettre à jour une variable locale est « plus rapide », mais n'est pas forcement « la meilleure » solution. La comparaison avec la variable globale engendre la même conclusion. Au final Conclusion? Mais même si ces techniques sont simples à mettre en œuvre, il est conseillé d'éviter l'utilisation des variables Locale - Globale - nœud de propriété, car elles engendrent : • copie de données ;
  13. 13. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 13 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ • pas de protection contre les « Race Conditions » ; • pas de gestion d'erreur. Les mises à jour des nœuds de propriétés sont réalisées via le thread de l'interface utilisateur, ce qui peut engendrer des ralentissements. Pour transmettre les données, il est conseillé d'utiliser : • l'indicateur ; • un fil de liaison ; • des techniques spécifiques à LabVIEW comme la FGV, AE, DVR. Pour des explications détaillées, vous référer au chapitre 3 du livre. VII-B - Variable Globale Fonctionnelle ou VGF (FGV) VII-B-1 - Histoire Ce n'est qu'à partir de la version 2 que l'équipe de développement du logiciel LabVIEW a défini que la valeur d'un registre à décalage non initialisé conserverait sa valeur précédente. L'autre option aurait été qu'elle reprenne sa valeur par défaut. À cette époque il n'y avait pas de globale « native » dans le logiciel. Cette technique s'est logiquement imposée comme la méthode pour partager des données dans une application sous le nom de « Globale LV2 », pour LabVIEW version 2, ou « Variable Globale Fonctionnelle (VGF) ». Mais son appellation la plus communément répandue est son nom anglais Functional Global Variable (FGV). Même avec l'arrivée des globales dans la version 3 de LabVIEW, cette méthode de développement a été conservée, car elle permet d'apporter des solutions aux problèmes des locales et globales que nous avons exposés au paragraphe précédent. Pour reprendre la définition, une VGF (FGV) est composée : • d'une boucle While, avec la condition d'arrêt qui est une constante « vraie » pour qu'elle ne s'exécute qu'une seule fois ; • d'un registre à décalage non initialisé, qui mémorise la valeur précédente de la donnée ; • d'une structure « condition », avec deux états « Écriture » et « Lecture » ; • d'une commande de type énumération (ou énum), avec deux valeurs « Écriture » et « Lecture ». VII-B-2 - Principe et bénéfice Une FGV est donc un registre à décalage non initialisé d'un VI non réentrant, qui permet de mémoriser une valeur dans le registre lors d'une commande « Écriture » (noté souvent « Set »), et de la retourner sur un « Lecture » (noté souvent « Get »), comme illustré à la figure 3.51.
  14. 14. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 14 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 3.51 - Représentation symbolique et par le code du principe de la FGV, un registre à décalage non initialisé. Les bénéfices apportés par cette technique - Une meilleure gestion des données en mémoire, car le stockage de l'information est unique, soit dans le registre à décalage du VI. Il supprime ainsi toutes les copies mémoires ou buffer, engendrées par la présence des globales et/ou locales. Cette méthode est d'un grand intérêt, surtout pour des structures de données complexes comme des tableaux de cluster. - Possibilité d'ajouter une gestion de l'erreur, via le cluster d'erreur standard de LabVIEW et une structure condition. Il est ainsi possible d'éviter toute opération sur la FGV si une erreur est présente à son entrée. Il est à noter que cela est optionnel, mais conseillé. Plus d'informations sur la gestion des données, notamment FGV, AE, DVR, programmation objet (OOP) sous LabVIEW dans le livre et le blog de Luc Desruelle. VIII - Structure de programme (FrameWork) VIII-A - Les règles d'architecture pour les applications et les modèles de conceptions les plus utilisées Nous venons de voir que la gestion des données met en place des techniques de programmation particulières, type « globale fonctionnelle » ou Moteur d'action, afin d'optimiser la gestion mémoire, le flux de données et surtout la protection des ressources. Pour faire un programme, nous allons devoir assembler les sous-fonctions, gérer l'erreur, ajouter des structures, et autres. Que ce soit pour une boite de dialogue ou un programme d'acquisition, il y a des techniques à connaître spécifiques au logiciel LabVIEW. Ce chapitre aborde les modèles de conception, en anglais design pattern. Il s'agit de techniques reconnues et éprouvées comme étant les bonnes façons de résoudre des problèmes donnés. Ce sont des solutions standard et indépendantes du logiciel de développement. La plate-forme LabVIEW fournit des exemples en code G des conceptions les plus courantes. Elles sont à connaître pour permettre une lecture plus rapide du code. Les respecter permettra d'obtenir une implémentation plus rapide, standard, évolutive et maintenable par d'autres développeurs. Les modèles de conceptions les plus connus et leurs transcriptions en langage LabVIEW (ou à connaître) sont : • ensemble de VI simples ; • général ; • boite de dialogue ; • producteur / consommateur ; • Machine à états. Les structures sont toutes détaillées dans le livre, avec des exemples téléchargeables. Dans le tutoriel, nous n'aborderons que la machine à états, ou States Machine.
  15. 15. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 15 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ VIII-B - Machine à états VIII-B-1 - Définition générale Le modèle « Machine à états », appelé machine de Moore, est basé sur l'existence d'un diagramme états-transitions. Chaque section de code détermine la « transition » suivante et donc l'état suivant à réaliser. Ce modèle permet un découpage et un séquençage clair des tâches à effectuer conformément au diagramme des états-transitions. Il facilite l'insertion de nouvelles sections de code (état) ou le changement de l'ordre d'exécution des sections, le tout sans devoir modifier considérablement la structure de l'application. C'est un modèle fondamental du développement logiciel, surtout en LabVIEW. VIII-B-2 - Transcription en LabVIEW Nous allons reprendre notre exemple précédent qui réalise une série de mesures de température, à la fréquence d'un point toutes les 5 secondes. Mais contrairement à l'exemple précédent, nous voulons que notre application réagisse en 125 ms à l'appui sur le bouton Stop, pour arrêter le programme. Nous voulons donc traduire le diagramme fonctionnel de la figure 3.61. Figure 3.61 - Diagramme fonctionnel du programme de pilotage de l'instrument de mesure avec une mesure toutes les 5 secondes. Il existe plusieurs versions pour traduire ce concept en langage G, nous les verrons au fur et à mesure dans ce chapitre. Elle est composée par : 1. Une boucle While, pour permettre l'exécution en continu du code ; 2. Une structure Condition : chacun de ses états va reprendre par complète analogie un état du diagramme fonctionnel (figure 3.61) : « Démarrage ; Attente ; Mesure Arrêter ». 3. La liste des états est représentée par les valeurs d'une énumération, qui sera déclarée comme une définition de type. Ce qui signifie : Ø Définition de type, la mise à jour du modèle sera répercutée sur toutes ses instances dans le code. Donc des états pourront être rapidement ajoutés et appliqués partout dans le code, par exemple dans des constantes (figure 3.17). Pour éditer la définition de type, faites un clic droit sur l'énumération et sélectionnez Ouvrir la déf. de type ; Ø La commande de type énumération, ou énum, lorsqu'elle est câblée au terminal de sélection d'une structure Condition, fait correspondre les conditions à la liste des éléments de l'énum (ou énumération). Le code est donc autodécrit. Si un état n'est pas présent dans la structure, le code ne sera pas exécutable ; 4. Un registre à décalage, qui permet d'implémenter « chaque état définit l'état suivant ». Il est câblé au terminal de sélection de la structure condition, soit le symbole « ? ». À chaque itération de la boucle While, le contenu du registre à décalage définira donc, via la structure condition, l'état courant à exécuter. À la fin de l'exécution de chaque état, une constante de l'énumération d'états est câblée sur la sortie du registre à décalage, définissant ainsi le prochain état à exécuter.
  16. 16. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 16 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 3.62 - Structure symbolique d'une Machine à états qui permet d'exécuter des sections code par des transitions. Figure 3.63 - Code LabVIEW de la Machine à états, pour le programme de pilotage de l'instrument de mesure avec une mesure toutes les 5 secondes. VIII-C - Bien démarrer un projet LabVIEW avec le GMF (QMH) Plus d'informations sur les modèles de conceptions avec LabVIEW dans le livre, mais aussi la présentation d'un modèle professionnel de projet « prêt à l'emploi » de type producteur consommateur avec structure événementielle, dont le code est disponible gratuitement en téléchargement. Pour rappel avec LabVIEW 2012 sont arrivés les modèles de projet LabVIEW via le gestionnaire de projet. Il est livré quelques modèles, ou Framework, avec LabVIEW, dont les fameux QMH (Queue Driven Message Handler) ou modèle Gestionnaire de messages dans une file d'attente (GMF) en françaiset l'Actor Framework. Même si l'Actor Framework est passionnant, il reste difficile à utiliser pour les non-spécialistes. Le Queue Driven Message Handler, plus connu sous le petit nom de QMH ou QDMH, est un incontournable qui est très simple d'utilisation.
  17. 17. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 17 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ La structure proposée par le modèle QMH repose sur un modèle éprouvé d'une structure producteur - consommateur, dans lequel : • (la boucle productrice) la structure événementielle capture les actions utilisateurs, sur la face-avant, et produit le « message » via une FIFO ; • le message est un cluster composé d'un état « case » et une donnée facultative Data de type variant ; • (la boucle consommatrice) la structure consommatrice, basée sur un modèle de machine à états, dépile sur apparition les données de la FIFO. Le message définit une transition vers l'état avec la donnée associée. Le « case » de la structure « Message » est une chaîne qui correspond à un des sous-diagrammes de la structure Condition. Par conséquent, la lecture du message provoque l'exécution du sous-diagramme correspondant de la structure Condition. Ce sous-diagramme est appelé diagramme de message, car il correspond à un message ; • ces boucles s'exécutent en parallèle et sont connectées par la file d'attente de messages, qui facilite la communication entre les boucles ; • votre application peut avoir plusieurs « Boucle Consommatrice », QMH = Actor, chaque boucle correspond à une tâche effectuée par l'application. Alors, pourquoi utiliser un modèle personnalisé ? Le modèle proposé par National Instruments est un modèle, qui mérite des améliorations, vos améliorations, mais la structure « Message et file d'attente FIFO » est à garder. Je vous conseille donc de générer VOTRE projet, MAIS sur la base du QMH, de regarder la très bonne documentation HTML livrée avec le projet, et de modifier le code. Gestionnaire de messages dans une file d'attente : Depuis LabVIEW 2012 des modèles de projets sont livrés Sélectionner le Gestionnaire de messages dans une file d'attente, GMF ou QMH (anglais)
  18. 18. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 18 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Le nouveau code sera la base de construction de votre modèle personnalisé « simple » L'exemple donné par le QMH : • quitte l'application sur « erreur » -> remplacer « Exit » par « Error »« et ajouter un état dans la »Boucle de gestion de messages« . Remarque : la « Message Queue.lvlib » est distribuée en « support VI ». Elle n'est pas dans la vi.lib ni la user.lib. Vous pouvez donc la modifier. Je vous propose de renommer la lvlib, pour faire la différence avec la lvlib d'origine. Ne plus quitter sur erreur • ne sauvegarde pas ni ne gère l'erreur, qui est donc fatale -> dans l'état « Error » ajouter un affichage de l'erreur ainsi que la sauvegarde et le filtrage si l'utilisateur le décide ; • n'affiche pas la version du logiciel -> ajouter les VI de gestion de version de LabVIEW ; • la structure event driven sort sur erreur -> remplacer par un VI qui transfère l'erreur à la « Boucle de gestion de messages » via la FIFO
  19. 19. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 19 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ La structure événementielle devrait transférer l'erreur à la boucle de gestion de messages. • supprimer le code « exemple » ; • n'a pas votre personnalisation! Ajouter votre logo ; • autres… IX - Construire et piloter un système de mesure (DAQmx et VISA) IX-A - Comprendre les architectures logicielles des instruments d'E/S Les architectures des instruments E/S (figure 4.8) et des cartes DAQ (figure 4.7) font apparaître deux éléments communs que sont le driver et le logiciel d'application. Aucun système de mesure par ordinateur n'est complet sans logiciel. L'application est le code réalisé pour permettre à l'utilisateur de piloter la chaîne d'instrumentation, analyser, sauvegarder et présenter les données. Le driver est le programme qui fait le lien entre le logiciel d'application et le matériel. Il est chargé de traduire les commandes LabVIEW pour les rendre compréhensibles par la carte ou l'instrument. Il facilite le travail des développeurs en évitant une programmation fastidieuse et spécifique dans les registres bas niveau de la carte. Voici quelques exemples. • Les cartes d'acquisition et génération de signaux : National Instruments fournit un driver unique qui est compatible avec toutes les cartes, qui est NI-DAQmx. Nous détaillerons ses fonctionnalités dans le chapitre 4.2. • Les instruments autonomes sur table : nous utiliserons le driver VISA ou IVI. Nous détaillerons ses fonctionnalités dans le chapitre 4.3. • Les instruments modulaires : nous utiliserons le driver VISA ou IVI ou un driver spécifique livré par le fabricant avec le matériel. Après avoir analysé l'ensemble de la chaîne d'instrumentation physique, il reste un élément à sélectionner : l'ordinateur et sa cible d'exécution. En effet, prenons l'exemple d'une machine de surveillance d'un laser effectuant une intervention chirurgicale sur la rétine d'un œil humain. Personne n'acceptera une telle intervention si l'ordinateur fonctionne sous un système d'exploitation Windows, alors que l'antivirus réalise une mise à jour. La mise à jour n'est bien évidemment qu'un exemple et permet de mettre en évidence que le système est susceptible d'être interrompu à tout moment. Un arrêt d'urgence ne peut pas être géré par un système « standard ». Pas plus qu'un système de surveillance réalisant une analyse pendant plusieurs mois et qui ne devra pas être redémarré par le service informatique de l'entreprise. IX-B - Pilotage des cartes d'acquisition et de génération de signaux de National Instruments avec le driver NI-DAQmx Les cartes d'acquisitions de National Instruments sont pilotées via les VI NI-DAQmx dans LabVIEW. Le driver NI-DAQmx installe sous LabVIEW une API, Application Programming Interface, qui est une bibliothèque de fonctions, constituée de VI et de propriétés. Cette API va permettre d'utiliser les fonctions du driver. La palette est disponible sous E/S de mesures → DAQmx (figure 4.12). Elle est très intuitive et contient un nombre réduit de VI qui correspondent aux fonctionnalités principales, approximativement 90 % des besoins : lecture, écriture, cadencement,
  20. 20. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 20 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ déclenchement. Ce sont les mêmes fonctions qui sont utilisées pour les signaux analogiques et numériques. Pour les fonctionnalités avancées, il faut utiliser les propriétés, mais nous n'en aurons pas besoin dans les exemples du livre. Figure 4.12 - La sous-palette « DAQmx » permet de piloter très facilement les cartes d'acquisition et de génération de signaux. La bibliothèque a un nombre limité de VI, car ils sont polymorphes, c'est-à-dire qu'ils s'adaptent à des types de données différents. C'est un ensemble de VI qui a le même modèle de connecteur. Par exemple, il n'y a qu'une seule fonction « Lecture DAQmx », car elle s'adapte à la lecture des données de signaux de type analogique, numérique ou compteur, pour une voie unique ou multiple, en retournant un échantillon unique ou multiple, sous la forme d'un nombre ou d'une Waveform. Cette liste est accessible en cliquant dans le menu sous l'icône du VI (figure 4.13). Quelques exemples des possibilités des VI LabVIEW DAQmx pour les fonctions lecture et écriture sont présentés dans les tableaux 4.6 et 4.7. Les données E/S sont soit une valeur scalaire, un tableau 1D, un tableau 2D, ou une Waveform. Figure 4.13 - Une seule fonction de lecture grâce aux possibilités de la fonction « Lecture DAQmx » pour les signaux analogique, numérique et compteur. Tableau 4.6 - La fonction « Lecture » s'adapte à de nombreux formats. Il y a plusieurs techniques de mesure. L'acquisition de données « point à point » est la plus simple : acquérir un seul échantillon sur demande, attendre, de nouveau acquérir un seul échantillon et ainsi de suite. Dans cette opération, le
  21. 21. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 21 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ driver NI-DAQmx acquiert une valeur d'une voie en entrée et renvoie immédiatement cette valeur exemple de code de pilotage… Exemple d'un code LabVIEW qui permet d'effectuer une mesure analogique sur une carte d'acquisition Synthèse DAQmx DAQmx est le driver de pilotage des cartes d'acquisition de National Instruments. Il installe sous LabVIEW une API qui est une bibliothèque de VI très simple à utiliser. Une voie virtuelle est un ensemble de paramètres comprenant un nom, une voie physique, des connexions, le type de mesure ou de génération et optionnellement des informations de mise à l'échelle. Il faudra soit la créer dans MAX, soit dans le programme LabVIEW. Il existe trois types de tâches : - point à point : acquisition d'un seul échantillon sur demande avec un cadencement logiciel ; - fini : acquisition de plusieurs échantillons avec le cadencement matériel de la carte ; - continu : acquisition de plusieurs échantillons avec le cadencement matériel de la carte ; recommencer cette acquisition en continu. Les données sont mises à disposition dans un buffer circulaire qu'il convient de lire périodiquement depuis l'application. Il est possible de créer un système d'acquisition et de génération simultanée de données en combinant les tâches DAQmx. Les techniques de programmation des tâches, configuration, paramétrage depuis MAX et utilisation depuis LabVIEW sont toutes détaillées dans le livre, avec des exemples téléchargeables. IX-C - Utilisation de Measurement And Automation Explorer (MAX), (configurer, créer, tester et diagnostiquer le matériel) Measurement And Automation Explorer, abréviation MAX, est un logiciel complémentaire qui s'installe avec le driver NI-DAQmx. Il va permettre de configurer, créer, tester et diagnostiquer l'ensemble du système d'entrées/sorties de données (figure 4.19). Il donne accès à l'ensemble du matériel et logiciels de National Instruments. Son utilisation est donc beaucoup plus large que celle décrite dans ce chapitre. L'accès à ce logiciel de configuration se fait soit directement par l'icône du logiciel, soit dans une fenêtre LabVIEW à partir du menu Outils, puis Measurement And Automation Explorer (figure 4.18).
  22. 22. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 22 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 4.18 - Accès au logiciel MeasurementAndAutomation Explorer (MAX). L'utilitaire présente sous forme d'une arborescence les éléments de configuration de votre ordinateur. Lors de la sélection d'un élément de l'arborescence, la partie droite de l'utilitaire présente des panneaux additionnels de configuration et/ou d'information. Les éléments qui nous intéressent ici sont : • Périphériques et interface : le matériel connecté à votre ordinateur est listé sous cette rubrique ; • Voisinage de données : les tâches et voies virtuelles DAQmx configurées sur cet ordinateur ; • Échelles : les échelles DAQmx qui sont configurées sur cet ordinateur. Figure 4.19 - Listes des fonctions accessibles avec le logiciel MAX. Définitions paramètres DAQmx sous MAX - Une voie physique est un terminal ou broche sur lequel vous pouvez mesurer ou générer un signal analogique ou numérique. Chaque voie physique a un nom unique. - Une voie virtuelle est un ensemble de paramètres qui peuvent inclure un nom, une voie physique, des connexions d'entrée, le type de mesure ou de génération et des informations de mise à l'échelle. - Une tâche se compose d'un ensemble d'une ou de plusieurs voies virtuelles et comprend le cadencement, le déclenchement et d'autres propriétés. Une tâche représente la mesure ou la génération que vous voulez réaliser. Tester le fonctionnement de la carte
  23. 23. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 23 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ La première action consiste à vérifier le bon fonctionnement de la carte d'entrées/sorties, dans Périphériques et interfaces, qui permet de : • Visualiser la configuration d'un périphérique existant ; • Diagnostiquer son fonctionnement via « Panneaux de test » ; • Créer un périphérique simulé. Cette possibilité est très utile pour le développeur quand le matériel n'est pas disponible. Il est donc possible de simuler le matériel que nous utilisons dans le livre et de réaliser tous les exemples ; • Accéder au « Brochage du périphérique » pour connaître le câblage des voies sur la carte. Figure 4.20 - Vérifier le bon fonctionnement de la carte via le panneau de test de MAX. Plus d'informations et d'astuces de développeur pour utiliser « MAX » dans le livre MAX, un outil très puissant facilitant le travail du développeur. Grâce à MAX, l'utilisation de la carte est transparente pour le développeur. Son intervention se situe au niveau de la définition des « Voies Globale » utilisées et de leur configuration. Il permet ainsi de séparer la configuration de l'acquisition du programme. Il est alors possible d'ajuster les différentes voies constituant une tâche sans modifier le code. L'utilisateur expérimenté, qui développe des applications complexes, va pouvoir améliorer sa productivité en exploitant la génération automatique de programme. Plus d'informations dans le livre sur l'utilisation de l'assistant DAQ qui est un très bon point de départ pour découvrir l'acquisition de données. En générant le code G, la configuration peut être modifiée indépendamment de l'acquisition, notamment au travers du logiciel Measurement And Automation Explorer, dit MAX IX-D - Utilisation du driver VISA pour piloter les instruments depuis LabVIEW IX-D-1 - Trouver un driver d'instrument : IDNet Lorsque vous avez besoin d'un driver d'instrument, la méthode la plus simple consiste à utiliser l'assistant de recherche de drivers d'instruments qui va se connecter sur l'Instrument Driver Network, noté IDNet. Avant de passer du temps à développer un driver d'instrument, faites une recherche sur le réseau IBNet. Plus d'informations dans le livre sur le téléchargement de plus de 9 000 drivers sur le réseau IDNet.
  24. 24. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 24 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ IX-D-2 - Zoom sur les fonctionnalités de VISA L'API du driver VISA, Virtual Instrumentation Software Architecture, installe sous LabVIEW une bibliothèque de fonctions constituées de VI et de propriétés. Elle va servir à créer des applications pour les instruments de mesure. Cette bibliothèque est très intuitive, mais contrairement à la bibliothèque NI-DAQmx, elle contient un nombre important de VI, avec des sous-bibliothèques spécifiques à chaque bus de communication. Dans la réalité, seulement six fonctions sont nécessaires pour écrire la très grande majorité des drivers (figure 4.54 et 4.55). Figure 4.54 - La bibliothèque VISA contient un nombre important de VI, mais la très grande majorité des drivers s'écrivent avec seulementsixfonctions. Ouverture, Fermeture de la communication et Timeout Ces trois fonctions (ouverture, fermeture et timeout) sont disponibles dans la palette VISA avancée. Ce sont les trois paramètres de base de la communication avec un instrument de mesure : N° 1 un driver commence toujours par un VISA Open qui permet d'ouvrir une session sur le périphérique spécifié, à faire une seule fois en début de programme ; N° 2 la fonction d'ouverture est toujours suivie par la configuration du TimeOut, qui est le temps d'attente maximum lors d'une interrogation sur l'instrument, par défaut 10 secondes. Elle est disponible au travers d'une propriété ; N° 3 le code du driver se termine toujours par un VISA Close qui permet de fermer la session sur le périphérique (à faire une seule fois uniquement en fin de programme). Écriture des données dans l'instrument N° 4 Pour écrire des données dans l'instrument, on utilise VI VISA Write. Nous utiliserons uniquement la communication basée sur des messages, c'est-à-dire avec l'envoi de chaînes de caractères ASCII, et pas celle basée sur l'écriture de registre. Lecture des données dans l'instrument N° 5 Pour la lecture des données retournées par l'instrument, on utilise VI VISA Read. Il est très important de comprendre que cette fonction retourne les données contenues dans le buffer dès qu'une de ces trois conditions est présente :
  25. 25. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 25 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ • un caractère de terminaison est arrivé, par exemple dans le cas d'une communication sur un bus série (voir figure 4.57) ; • le nombre d'octets dans le buffer de réception est égal à celui passé en paramètre à la fonction VISA Read (voir figure 4.56) ; • le temps d'attente a dépassé le TimeOut configuré par la fonction VISA Open. Dans ce cas LabVIEW retourne un code d'erreur, 0xBFFF0015, le délai d'attente (timeout) a expiré avant que l'opération ne soit achevée. Plus d'informations sur la création de drivers d'instrument avec LabVIEW dans le livre, avec des exemples concrets et détaillés. X - Réaliser rapidement des rapports Microsoft Office Word et Excel avec LabVIEW et le Report Generation toolkit Si vous avez besoin de réaliser des rapports plus complexes, il est possible d'ajouter des fonctionnalités grâce au « Toolkit Report Generation for Microsoft Office ». Il ajoute un ensemble étendu de VI haut niveau pour générer des rapports par programmation dans Microsoft Word ou Excel. Un VI Express Microsoft Office Report permet de rapidement découvrir l'ensemble des possibilités. Il est également très facile de réaliser un classeur modèle sous Microsoft Excel, qui contient la présentation finalisée du rapport d'essai, et d'importer directement depuis LabVIEW au bon emplacement les mesures. Une autre possibilité est d'utiliser les fonctions bas niveau pour générer complètement l'apparence du rapport. Cette méthode nécessite plus de code. Un exemple très simple peut être rapidement construit en réalisant un classeur Excel modèle, à partir des mesures figures 6.5 et 6.8, dans lequel nous réalisons toute la mise en page (figure 6.26). La figure 6.27 présente le « Diagramme » d'une application qui permet d'importer les mesures dans ce classeur Modèle. Les fonctions utilisées sont « copier » un fichier, de la palette d'E/S sur fichier afin de dupliquer le classeur Excel modèle sous un nouveau nom. Les mesures sont dans un tableau à deux dimensions de numérique, qui doit être converti en tableau de chaînes de caractères par la fonction « Nombre en chaîne fractionnaire ». Pour insérer les données dans le classeur, la fonction de haut niveau « nouveau Rapport », avec le paramètre « Excel », permet d'ouvrir le fichier. Puis la fonction spécifique « Excel insérer un tableau » copie les mesures à l'emplacement désiré, soit dans les cellules de coordonnées [2 ; 25]. L'appel de la fonction « Fermer le rapport » avec le paramètre « sauvegarder le classeur » finalise l'importation des données. Le rapport est alors complet, échangeable par e-mail et peut être directement imprimé.
  26. 26. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 26 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 6.26 - Exemple de la génération d'un rapport Microsoft Excel en créant un modèle qui va être copié. Figure 6.27 -Exemple d'importation des mesures dans un classeur Microsoft Excel modèle, afin de générer automatiquement le rapport. XI - Accélérer votre productivité : les outils gratuits et indispensables à vos développements LabVIEW Ce paragraphe permet de mettre en avant des outils indispensables, souvent gratuits, qui feront gagner beaucoup de temps de développement. Le réseau des outils LabVIEW (LabVIEW Tools Network) offre la possibilité de rechercher, de parcourir et d'acheter des compléments logiciels et des applications de la société National Instruments ou d'entreprises tierces. Ces produits vous permettent d'optimiser vos développements en étendant la fonctionnalité de la plate-forme LabVIEW. Tous les produits sont certifiés compatibles, ce qui garantit qu'ils ont été soumis à des essais et qu'ils s'intègrent bien avec les matériels et logiciels de NI. Les compléments logiciels et les applications couvrent un large éventail de produits allant des outils d'usage général jusqu'aux produits hautement spécialisés mis au point par des experts de l'industrie. Le réseau des outils est directement intégré à l'environnement de développement LabVIEW, au travers du logiciel gratuit « VI Package Manager » ou VIPM, qui permet de rechercher, gérer et évaluer des compléments logiciels sans fermer l'environnement de développement. Il est accessible depuis le menu Outils -> Rechercher les compléments logiciels de LabVIEW (figure 6.35). Une fenêtre s'ouvre permettant de sélectionner et télécharger directement les outils. Il y a tellement d'outils qu'il n'est pas recommandé de tous les télécharger.
  27. 27. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 27 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ XI-A - Indispensable aux développeurs De nombreux outils gratuits de ce réseau sont devenus indispensables au développeur LabVIEW, car ils permettent de gagner beaucoup de temps. Après téléchargement depuis le VIPM, ils seront directement disponibles dans la palette LabVIEW Figure 6.35 - Fenêtre de recherche des outils du LabVIEW Tools Network via le logiciel VI Package Manager ou VIPM.
  28. 28. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 28 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 6.36 - Fenêtre d'installation des outils du LabVIEW Tools Network via le logiciel VI Package Manager ou VIPM. XI-B - Les bibliothèques OpenG, les indispensables à télécharger Les bibliothèques OpenG contiennent des centaines de VI en open source créés par la communauté OpenG et partagés dans le cadre de la licence BSD-3-Clause (approuvée par Open Source Initiative). Cela permet une utilisation commerciale dans vos applications propriétaires. Ces bibliothèques sont indispensables pour vos projets LabVIEW, à télécharger gratuitement, elles contiennent des VI réutilisables couvrant tous les domaines d'applications. Elles incluent : • la manipulation de tableaux ; • la manipulation de chaînes de caractères ; • la gestion de fichiers ; • la manipulation de données variant et aplaties ; • etc. La figure 6.36 montre comment télécharger directement dans LabVIEW ces bibliothèques, en les sélectionnant depuis le logiciel VIPM, clic droit et installer.
  29. 29. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 29 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 6.37 - Exemples de bibliothèques OpenG installées depuis le VIPM, comme la manipulation de tableau, de booléen, déclenchement et horloge XI-C - Les sondes SAPHIR, incontournables pour la mise au point du code Comme évoqué au chapitre 2.3.3, lors de la mise au point du code, l'utilisation de l'outil « Sonde » (probe) de la palette Outils permet de vérifier des valeurs intermédiaires dans un diagramme flux de données. LabVIEW propose un grand nombre de sondes pour permettre cette mise au point de votre code. Elles sont bien entendu très utiles, mais restent souvent basiques. Les sondes personnalisées proposées par l'équipe des développeurs de la société SAPHIR proposent de nombreuses sondes alternatives. Installées facilement au travers du VIPM, elles permettent d'étudier le comportement de votre code en cours d'exécution de manière plus appropriée. Nous allons détailler quelques exemples des sondes les plus utilisées : • la sonde « History » stocke les valeurs d'une chaîne de caractères. À chaque appel de la sonde, la valeur de la chaîne surveillée est ajoutée à une table, avec l'affichage de l'heure à laquelle la chaîne a été lue. La sonde History permet à l'utilisateur de définir des filtres d'affichage à l'aide d'expressions rationnelles. Elle offre la possibilité de mettre en pause l'exécution du programme si la chaîne de caractères remplit certaines conditions : contenir un motif particulier, atteindre une certaine longueur, etc. Cette sonde est utilisée pour la mise au point d'une machine à état pilotée par chaîne de caractères, voir chapitre 3.4.3, ou la surveillance de données renvoyées par un instrument de mesure ; • la sonde « Delta » affiche sur un graphique déroulant l'évolution d'une valeur, ainsi que son écart avec la valeur précédente. De plus elle permet de mettre en pause l'exécution du programme si la valeur mesurée et/ ou l'écart calculé dépassent un seuil défini par l'utilisateur. Cette sonde est utilisée pour la vérification de l'évolution d'une valeur (par exemple un delta temporel) au cours du temps ; • la sonde « Chronographe » fournit des informations relatives aux durées d'exécution de vos programmes. Elle mesure les durées entre chaque appel de cette sonde ou entre les appels d'autres sondes du Toolkit VIBox Probes. Cette sonde est utilisée pour la vérification du cadencement d'une boucle ou la détection des parties de code consommatrice en temps processeur. Plus d'informations au sujet des sondes SAPHIR via le LabVIEW Tools Network et en téléchargement sur le VI Package Manager.
  30. 30. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 30 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ Figure 6.38 - Exemples d'une autre manière de visualiser les données en cours d'exécution via les sondes « History » et « Delta » de la vibox SAPHIR. XII - Conclusion Retrouvez plus de détails sur le Livre. En lisant ce livre, vous pourriez avoir le sentiment que LabVIEW est un outil uniquement dédié à l'acquisition et à la mesure. Certes, il propose un environnement qui facilite grandement cela, et les auteurs de ce livre ont fait délibérément le choix de mettre cette facilité à l'honneur. Mais ne vous y trompez pas, LabVIEW est infiniment plus que cela. C'est un langage à part entière manipulant une grande variété de concepts tels que le flux de données, la programmation objet, la gestion événementielle, l'encapsulation, la modularité, le typage des données, etc. Il peut vous permettre d'implémenter n'importe quel type d'application. En l'utilisant vous pourrez mesurer les données d'un capteur relié à une carte d'acquisition, analyser les informations provenant d'un instrument connecté par une liaison série, réaliser un rapport de test sous Microsoft Office, implémenter un PID sur une cible FPGA, contrôler précisément un procédé physique complexe dans une tâche déterministe sur une cible Temps Réel, trouver par le calcul matriciel la distance de Mahalanobis… mais également solutionner un Rubik's cube, un Sudoku et même jouer aux échecs (un exemple de jeu d'échecs implémenté en langage G est abordé dans le livre). XIII - Annexe : Le sommaire du Livre : LabVIEW - Programmation et applications (3e édition) - Luc Desruelle CH1 LES CONCEPTS ET L'ENVIRONNEMENT DE PROGRAMMATION LABVIEW 1.1 CONCEPTS DE BASE DE LA PROGRAMMATION GRAPHIQUE 1.2 ENVIRONNEMENT DE LA PROGRAMMATION LABVIEW CH2 LES BASES DE LA PROGRAMMATION LABVIEW 2.1 ÉDITION ET EXÉCUTION D'UN PROGRAMME SIMPLE 2.2 LES PRINCIPAUX ÉLÉMENTS DU LANGAGE LABVIEW
  31. 31. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 31 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ 2.3 L'ENVIRONNEMENT D'ÉDITION ET D'EXÉCUTION 2.4 EXEMPLES DE PROGRAMMES 2.5 NOTION DE PROJET CH3 PROGRAMMATION AVANCÉE EN LABVIEW 3.1 ENVIRONNEMENT DE DÉVELOPPEMENT LABVIEW 3.2 RÈGLES DE STYLE (STYLE DU DIAGRAMME + STYLE DE LA FACE- AVANT + STYLE DES VI + ZOOM SUR LA GESTION DES ERREURS) 3.3 GESTION DES DONNÉES, DE LA LOCALE VERS LA DVR INDICATEUR VS LOCALE VS GLOBALE VS NŒUD DE PROPRIÉTÉ + VARIABLE GLOBALE FONCTIONNELLE OU VGF (FGV) + MOTEUR D'ACTION OU ACTION ENGINE (AE) POUR ALLER PLUS LOIN DVR ET PROGRAMMATION OBJET 3.4 LES RÈGLES D'ARCHITECTURE POUR LES APPLICATIONS ET LES MODELÉS DE CONCEPTIONS LES PLUS UTILISÉES ENSEMBLE DE VI SIMPLES + VI GÉNÉRAL + MACHINE A ÉTATS + PRODUCTEUR/CONSOMMATEUR + BOITE DE DIALOGUE OU INTERFACE UTILISATEUR BIEN DÉMARRER UN PROJET LABVIEW AVEC LE GMF (QMH) CH4 APPLICATIONS : CONSTRUIRE ET PILOTER UN SYSTÈME DE MESURE 4.1 LES ÉLÉMENTS D'UN SYSTÈME DE MESURE / GÉNÉRATION 4.2 ACQUISITION ET RESTITUTION DES DONNÉES 4.2.1 PROGRAMME DE PILOTAGE DES CARTES : NI-DAQMX 4.2.2 L'ASSISTANT DAQ 4.2.3 L'UTILITAIRE MEASUREMENT AND AUTOMATION EXPLORER (MAX) VUE D'ENSEMBLE + TESTER LE FONCTIONNEMENT DE LA CARTE CRÉATION D'UNE VOIE VIRTUELLE + CRÉATION D'UNE ÉCHELLE PERSONNALISÉE VIA MAX CRÉER UNE TÂCHE D'ACQUISITION QUI UTILISE UNE VOIE GLOBALE + GENERER LE CODE G, MAIS LAISSER LA CONFIGURATION DANS MAX 4.2.4 ACQUISITION ET RESTITUTION DE SIGNAUX ANALOGIQUES (ACQUISITION ANALOGIQUE « POINT À POINT » « FINIE » « CONTINUE ») 4.2.5 ACQUISITION ET RESTITUTION DE SIGNAUX NUMÉRIQUES 4.2.6 UTILISATION DES COMPTEURS 4.3 LE PILOTAGE DES INSTRUMENTS 4.3.1 LES DRIVERS D'INSTRUMENTS (DRIVER D'INSTRUMENT + IVI + LABVIEW PLUG ET PLAY DRIVERS - VISA) 4.3.2 TROUVER UN DRIVER D'INSTRUMENT : IDNET 4.3.3 ZOOM SUR LES FONCTIONNALITÉS DE VISA OUVERTURE, FERMETURE DE LA COMMUNICATION ET TIMEOUT + ÉCRITURE/LECTURE DES DONNÉES DANS L'INSTRUMENT + PARAMÉTRAGE DU PORT SÉRIE 4.3.4 CRÉER UN DRIVER D'INSTRUMENT DANS LES RÈGLES DE L'ART 4.4 PILOTAGE D'INSTRUMENTS SUR CIBLES RT ET FPGA CH5 TRAITEMENT DE DONNÉES 5.1 TRAITEMENT DU SIGNAL 5.1.1 INTRODUCTION 5.1.2 SYNTHÈSE DE SIGNAUX 5.1.3 ANALYSE FRÉQUENTIELLE ET FENÊTRAGE TEMPOREL 5.1.4 CORRÉLATION ET EXTRACTION DE SIGNAUX NOYÉS DANS LE BRUIT 5.1.5 FILTRAGE NUMÉRIQUE 5.2 APPLICATION À L'ANALYSE DE DONNÉES (TRAITEMENTS MATHÉMATIQUES) 5.2.1 INTRODUCTION 5.2.2 RÉSOLUTION D'ÉQUATIONS COMPLEXES 5.2.3 EXEMPLES DE TRAITEMENTS MATHÉMATIQUES DE DONNÉES 5.2.4 EXEMPLES DE TRAITEMENTS STATISTIQUES DE DONNÉES
  32. 32. « LabVIEW : programmation et applications » ou comment apprendre à utiliser LabVIEW par Luc Desruelle - Francis Cottet - Michel Pinard - 32 - Copyright ® 2015 Luc Dessruelle. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://luc-desruelle.developpez.com/tutoriels/labview/extrait-livre-programmation-application/ CH6 APPLICATIONS : SAUVEGARDE, PRESENTATION ET ECHANGE DE DONNEES 6.1 SAUVEGARDE ET CONFIGURATION : FICHIERS ET BASE DE DONNÉES (TEXTE : ASCII, TABLEAU ET INI + FICHIER BINAIRE + BASES DE DONNÉES ODBC) 6.2 GÉNÉRATION DE RAPPORTS (STANDARD + AVANCE POUR MICROSOFT OFFICE WORD ET EXCEL) 6.3 CONTRÔLER SON APPLICATION ET LES OUTILS INDISPENSABLES 6.4 ÉCHANGE DE DONNÉES ENTRE APPLICATIONS (DATASOCKET ET VARIABLES PARTAGÉES + ACTIVEX OU .NET +TCP) 6.5 UTILISATION D'OUTILS MATHÉMATIQUE DANS LABVIEW 6.6 EXEMPLE D'UNE APPLICATION : NI LABVIEW PERMET LA NANOCARACTERISATION DE MATÉRIAUX AU CEA

×