LabVIEW

LabVIEW (contraction de Laboratory Virtual Instrument Engineering Workbench) est le cœur d’une plate-forme de conception de systèmes de mesure et de contrôle, fondée sur un environnement de développement graphique de National Instruments.

LabVIEW

Informations

Développé par	National Instruments
Première version	1986
Dernière version	2024 Q3 (juillet 2024)
Système d'exploitation	Microsoft Windows, macOS et Linux
Environnement	Windows, Mac OS, Linux
Formats lus	LabVIEW Project (d), LabVIEW project Library (d), LabVIEW project Library (UTF-8) (d), LabVIEW binary Datalog (d), LabVIEW Measurement (d), LabVIEW Control data (d) et LabVIEW Local Project Settings (d)
Formats écrits	LabVIEW Project (d), LabVIEW project Library (d), LabVIEW project Library (UTF-8) (d), LabVIEW binary Datalog (d), LabVIEW Measurement (d), LabVIEW Control data (d) et LabVIEW Local Project Settings (d)
Langues	Français, Anglais, Allemand, Japonais
Type	Atelier de génie logiciel, Chaine d'acquisition, Traitement du signal, Système embarqué
Politique de distribution	Vendu dans le commerce
Licence	Propriétaire
Site web	www.ni.com/labview

Le langage graphique utilisé dans cette plate-forme est appelé « G ». Créé à l’origine sur Apple Macintosh en 1986, LabVIEW est utilisé principalement pour la mesure par acquisition de données, pour le contrôle d’instruments et pour l’automatisme industriel. La plate-forme de développement s’exécute sous différents systèmes d’exploitation comme Microsoft Windows, Linux et Mac OS X. LabVIEW peut générer du code sur ces systèmes d’exploitation mais également sur des plates-formes temps réel, des systèmes embarqués ou des composants reprogrammables FPGA. Depuis 2009, LabVIEW évolue au rythme d'une version majeure millésimée par an.

Un logiciel dédié à la programmation instrumentale

Les domaines d'application traditionnels de LabVIEW sont le contrôle/commande, la mesure, l'instrumentation ainsi que le test automatisé à partir d'un PC (acquisition de données, contrôle-commande, contrôle d'instruments de mesure, de dispositifs expérimentaux, de bancs de test). Cette vocation est consacrée par des bibliothèques de fonctions spécialisées (GPIB, VXI, PXI, cartes d'acquisition DAQ, traitement de données...), mais aussi par les particularités du langage G (parallélisme inhérent à l'exécution par flux de données) et de l'environnement de développement (pilotes de périphériques standards, assistants pour l'installation du matériel).

Le concept d'instrument virtuel qui a donné son nom à LabVIEW (Laboratory Virtual Instrument Engineering Workbench), se manifeste par la permanence d'une interface graphique pour chaque module (fonction) d'un programme. Les contrôles et les indicateurs de ce panneau avant constituent l'interface par laquelle le programme interagit avec l'utilisateur (lecture de commandes et de paramètres, affichage des résultats). Les fonctions de contrôle-commande de cartes ou d'instruments constituent l'interface par laquelle le programme interagit avec le montage.

Un programme LabVIEW permet donc d'automatiser un montage associant plusieurs appareils programmables, et réunit l'accès aux fonctionnalités de ce montage dans une interface utilisateur unique, véritable face avant d'un instrument virtuel.

Le langage G : programmation graphique par flux de données

Du schéma au programme

Le langage de programmation utilisé dans LabVIEW, nommé G, fonctionne par flux de données. L’exécution d’un code est déterminée par un schéma graphique, le diagramme, qui est le code source. Le programmeur connecte différentes fonctions sous forme d’icônes dans le diagramme par l’intermédiaire de fils dessinés entre les terminaisons des blocs d’icônes. Chaque fil propage les variables du code et chaque nœud s’exécute dès que toutes les entrées d’une fonction sous forme d’icône sont disponibles.

La coloration syntaxique, née comme LabVIEW au milieu des années 1980, est complétée dans l'éditeur du diagramme par des éléments de forme (épaisseur, motifs, symboles) et de géométrie (taille, alignement, disposition) qui affectent fortement la lisibilité du code, en bien comme en mal selon le soin apporté par le rédacteur.

Cette manière de programmer propose une capacité intrinsèque à décrire des traitements indépendants et ainsi LabVIEW permet l’exécution de code en multitâche. Sur des machines multicœur, LabVIEW répartit ces tâches de manière automatique sur les différents cœurs tout en exploitant la capacité multithread des systèmes d’exploitation.

Les programmes sont souvent exécutés à partir de l'environnement de développement dans le cadre d'un développement fortement itératif. Les éditions les plus complètes du système de développement offrent néanmoins la possibilité de créer des fichiers exécutables ou des installeurs d’applications pour le déploiement sur d’autres machines. Un runtime doit alors être installé sur le système hôte aux côtés du fichier exécutable proprement dit.

L'instrument virtuel (VI), unité structurante du code

Le diagramme de LabVIEW est lié à une interface utilisateur graphique nommée face-avant. Les programmes et sous-programmes sous forme d’icônes sont appelés des instruments virtuels (VI) et les fichiers source enregistrés sur disque ont l’extension de nom de fichier .VI.

Chaque VI possède trois composants : un diagramme qui intègre le code graphique, une face-avant personnalisable par l’utilisateur et un panneau de connexions, qui prend le visage d'une petite icône carrée.

En associant certaines commandes et indicateurs de la face avant du VI avec les connecteurs de son panneau de connexion, le programmeur permet à un diagramme appelant d'échanger avec le VI des variables sous forme de fils. Une fois un VI écrit, il peut ainsi être posé et appelé dans le diagramme d'un autre VI, où il sera représenté par son icône et jouera le rôle de sous-programme, fonction ou procédure (on parle de sous-VI). Au même titre que son nom, l'icône d'un VI doit être personnalisée par un dessin ou un texte pour expliciter sa fonction à l'intention des relecteurs du code.

La face-avant est construite en utilisant des objets dénommés commandes et indicateurs. Les commandes sont des entrées qui servent à saisir des valeurs à l’écran et les indicateurs sont des sorties qui servent à afficher des variables ou des résultats. Des éléments décoratifs (formes, texte libre, images...) peuvent enrichir visuellement l'interface graphique utilisateur. Ces derniers n'existent que sur la face avant du VI. Les commandes et indicateurs en revanche, apparaissent à la fois en face avant et sur le diagramme (terminal sous forme d'icône) pour qu'on puisse les relier aux opérations qui échangent des données avec eux.

Le diagramme contient enfin des structures de contrôle (boucles, conditions, événements, séquence...) pour déterminer l'exécution ou l'ordre des opérations comme dans tous les langages de programmation. Tous les objets de commandes, indicateurs, fonctions, structures sont accessibles au programmeur via des palettes, des menus ou des combinaisons de touches du clavier (Quick Drop). Les icônes de fonctions placées sur le diagramme deviennent des nœuds interconnectés par des fils d’entrées et de sorties. Par exemple la fonction addition offre deux connecteurs d'entrée et un connecteur de sortie pour le résultat. Chaque sous-VI d'un programme plus vaste conserve la capacité d'être exécuté indépendamment par l'utilisateur au moyen de sa face avant.

Intérêt du langage G pour la programmation multiprocessus

Pour le lecteur, un programme en langage G se présente comme un schéma, le diagramme, réunissant différentes icônes reliées par des fils de couleur. Chaque fil symbolise le passage d'une donnée depuis une source dont elle sort (comme résultat), vers une cible où elle entre (comme paramètre).

Les diagrammes du langage G ont donc une signification bien différente de celle des schémas électroniques qu'ils évoquent parfois. Dans un diagramme LabVIEW, la donnée ne transite dans le fil qu'au moment où elle est générée par son icône source. L'icône cible ne commencera son exécution que lorsque toutes ses données d'entrée seront disponibles. Ce modèle d'ordonnancement par flots de données détermine l'ordre d'exécution par défaut des traitements du programme. Une conséquence importante de cette règle est que les traitements qui n'échangent pas de données sont libres de s'exécuter en parallèle. Cette propriété du langage G facilite le développement d'applications multiprocessus, particulièrement intéressantes dans le cadre du contrôle de systèmes réactifs (embarqués ou non).

La conception des programmes en langage G conserve une approche essentiellement procédurale. Mariée à l'exécution par flots de données, cette approche procure de bons résultats dans le domaine de l'instrumentation. Elle est aussi la plus intuitive pour des ingénieurs ou des chercheurs souvent plus familiers des protocoles expérimentaux que des concepts informatiques.

Évolution du langage

Le support de la conception orientée objet s'est développé de façon confidentielle au cours des années 1990 dans LabVIEW, pour aboutir en 1999 à la commercialisation par la société suédoise Endevo d'un kit "GOOP" , puis un support natif à partir de 2006 (version 8.2) . De nombreux éléments sont manipulés par méthodes et propriétés .

Le concept de projet est apparu dans l'éditeur à partir de 2005 (version 8.0) pour la configuration, en particulier, des nouvelles cibles de compilation devenues accessibles à cette époque (systèmes temps réel, FPGA, micro-processeurs).

Depuis 2018, l'influence de Python se fait sentir avec la possibilité d'appeler des scripts dans ce langage , puis le support natif des concepts d'ensemble et de tableau associatif .

Force de l'intuitivité, nécessité des bonnes pratiques

La programmation graphique de LabVIEW est prisée par les non-informaticiens, auxquels il permet de construire par simple glisser-déposer des programmes et des interfaces graphiques virtuelles évoquant les faces avant des vrais instruments de laboratoire . Cette approche du développement par programmation est soutenue par un environnement intuitif, riche en documentation et en exemples.

Un défaut de rigueur, de connaissance des bonnes pratiques et des particularités du compilateur met néanmoins en péril la qualité et la performance des programmes, comme avec n'importe quel langage de programmation . Pour réaliser des algorithmes plus complexes ou plus performants, des connaissance approfondies sont déterminantes (par exemple sur la gestion de la mémoire, qui est par défaut allouée de manière automatique, et le compilateur ). Des outils de génie logiciel existent également pour créer des applications LabVIEW de grande ampleur en équipe.

Histoire

C'est en 1986 que la première version de LabVIEW, créé par Jeff Kodosky, voit le jour sur Macintosh . Il s'ensuit un travail incessant pour améliorer l'environnement de programmation (ergonomie de l'éditeur, support de nouveaux concepts, améliorations du compilateur), mais aussi pour l'adapter à l'évolution de son environnement matériel (instruments, cartes d'acquisition de données, liaisons de communication, cibles de compilation) et logiciel (standards d'échange de données, connectivité avec d'autres logiciels et d'autres langages de programmation). Depuis 2009, LabVIEW évolue au rythme d'une version majeure millésimée par an.

En 2017 , National Instruments a opéré un fork stratégique et développe son produit selon deux branches : la branche "classique" et la branche "NXG" (NeXt Generation). LabVIEW NXG est présenté comme l'avenir de LabVIEW. Deux ans après sa sortie, la compatibilité de LabVIEW NXG avec les autres produits logiciels et matériels de National Instrument était encore en retrait par rapport à celle de la branche classique. Mais il offre aussi de nouvelles fonctionnalités exclusives et l'entreprise travaille à inverser le rapport de force entre les deux branches.

• 1986 : LabVIEW 1.0, sous Mac OS
• 1990 : LabVIEW 2.0, Langage compilé, optimisation des performances
• 1992 : LabVIEW 2.5, sous Windows 3.1 et Solaris
• 1993 : LabVIEW 3.0
• 1994 : LabVIEW 3.0.1, sous Windows NT
• 1994 : LabVIEW 3.1
• 1995 : LabVIEW 3.1.1, intégration de l'Application Builder
• 1996 : LabVIEW 4.0
• 1997 : LabVIEW 4.1
• 1998 : LabVIEW 5.0, multitâche, conteneurs ActiveX, assistant pour les cartes d'acquisition (DAQ) et assistant pour le contrôle d'instrument
• 1999 : LabVIEW 5.1, portage sous Linux; première version de LabVIEW temps réel
• 2000 : LabVIEW 6.0i, optimisation pour le partage d'interfaces sur internet, contrôles au look 3D, référence d'un contrôle
• 2001 : LabVIEW 6.1, optimisation et corrections
• 2003 : LabVIEW 7.0, VI Express, première version des toolkits pour FPGA, pour Palm OS et pour Windows Mobile
• 2004 : LabVIEW 7.1, traduit en Français, Allemand et Japonais
• 2005 : LabVIEW 8.0, Explorateur de projet, XControls, variables partagées
• 2006 : LabVIEW 8.20, programmation orientée objets
• 2007 : LabVIEW 8.5, première version du toolkit Statechart, gestion optimisée des machines multicœur
• 2008 : LabVIEW 8.6, nettoyage automatique des diagrammes, quick drop (déposé rapide), services Web
• 2009 : LabVIEW 2009 (9.0), extraits de VIs, récursivité native, nouvel éditeur d'icônes, boucles For parallélisables
• 2010 : LabVIEW 2010, Bibliothèques de projet empaquetées, Fonctions de flux réseau (Transfert de données en continu)
• 2011 : LabVIEW 2011
• 2012 : LabVIEW 2012
• 2013 : LabVIEW 2013
• 2014 : LabVIEW 2014
• 2015 : LabVIEW 2015
• 2016 : LabVIEW 2016
• 2017 : LabVIEW 2017 ; LabVIEW NXG 1.0
• 2018 : LabVIEW 2018 ; LabVIEW NXG 3.0
• 2019 : LabVIEW 2019, première version avec formalisme pour Sets and Maps

Toolkits

Il est possible d'étendre les fonctionnalités de LabVIEW en ajoutant des toolkits qui sont distribués séparément. La liste ci-dessous donne un inventaire non exhaustif de ses compléments :

• FPGA : pour la programmation de cartes FPGA
• myRIO : pour programmer sur matériel embarqué NI myRIO
• Real Time : module pour la programmation temps-réel
• Applications embarquées : pour les DSP, ARM, ADI Blackfin
• Datalogging and Supervisory Control : pour le développement de superviseur pour les automates programmables industriels (Siemens, Télémécanique, Mitsubishi...)
• Touch Panel : gestion avancée des écrans tactiles
• Vision : traitement des images, reconnaissance de formes, OCR
• Statechart : génération de code à partir de diagrammes d'états
• Lego Mindstorms NXT : programmation des robots Mindstorms NXT de Lego sous LabVIEW

Rétrocompatibilité des VIs et plateformes supportées

Rétrocompatibilité des VIs

L'ouverture d'un VI avec une version de LabVIEW plus ancienne que celle utilisée pour le produire n'est généralement pas possible. Chaque version peut en revanche enregistrer le code pour un nombre limité de versions antérieures, afin qu'il puisse être ouvert dans celles-ci.

Le code produit à partir de LabVIEW 6 peut être ouvert avec n'importe quelle version plus récente de LabVIEW.

Compatibilité avec Windows

LabVIEW est disponible pour Windows depuis sa version 2.5 (1992, Windows 3.1).

Compatibilité LabVIEW / Windows (tableau non exhaustif)

LabVIEW	Win 95	Win NT	Win 98	Win Me	Win 2000	Win XP	Win Vista	Win 7	Win 8	Win 10	Win 11
5.1.1 (2000)	X	X	X	-	X	-	-	-	-	-
6.0.2 (2001)	X	X	X	-	X	-	-	-	-	-
6.1 (2002)	X	X	X	X	X	X	-	-	-	-
7.0 (2003)	-	X	X	X	X	X	-	-	-	-
7.1 (2004)	-	X	-	-	X	X	-	-	-	-
8.0.1 (2006)	-	-	-	-	X	X	-	-	-	-
8.2 (2006)	-	-	-	-	X	X	-	-	-	-
8.5.1 (2008)	-	-	-	-	X	X	X	-	-	-
8.6.1 (2008)	-	-	-	-	X	X	X	-	-	-
2009	-	-	-	-	X	X	X	-	-	-
2009 SP1	-	-	-	-	X	X	X	X	-	-
2010	-	-	-	-	-	X	X	X	-	-
2010 SP1	-	-	-	-	-	X	X	X	-	-
2011	-	-	-	-	-	X	X	X	-	-
2011 SP1	-	-	-	-	-	X	X	X	-	-
2012	-	-	-	-	-	X	X	X	-	-
2012 SP1	-	-	-	-	-	X (SP3)	X	X	X	-
2013	-	-	-	-	-	X (SP3)	X	X	X	-
2013 SP1	-	-	-	-	-	X (SP3)	X	X	X	-
2014	-	-	-	-	-	X (SP3)	X	X	X	-
2014 SP1	-	-	-	-	-	X (SP3)	X	X	X	-
2015	-	-	-	-	-	X (SP3)	X	X	X	X
2015 SP1	-	-	-	-	-	X (SP3)	X	X	X (8.1)	X
2016	-	-	-	-	-	-	-	X	X (8.1)	X
2017	-	-	-	-	-	-	-	X	X (8.1)	X
2018	-	-	-	-	-	-	-	X	X (8.1)	X
2019								X	X (8.1)	X
2020								X	X (8.1)	X
2021										X
2022 Q3										X	X
2023 Q1										X	X
2023 Q3										X	X
2024 Q1										X	X
2024 Q3										X	X

Compatibilité avec Linux

LabVIEW est disponible pour Linux depuis sa version 5.1 (1999). Sa compatibilité reste toutefois limitée ainsi que celle des toolkits et surtout des drivers matériels, qu'il convient de vérifier au cas par cas.

Compatibilité LabVIEW / Linux (tableau non exhaustif)

LabVIEW pour Linux	Run-Time Engine	Development Environment
2014 SP1	Linux kernel 2.4x, 2.6x ou 3.x et GNU C Library (glibc) Version 2.5.1 ou plus récent pour architecture Intel x86 (32-bit) ; Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.5.1 ou plus récent pour architecture Intel x86_64 (64-bit)	Red Hat Enterprise Linux Desktop + Workstation 6 ou plus ; openSUSE 12.3 ou 13.1 ; Scientific Linux 6 ou plus
2015 SP1	Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86 (32-bit) ; Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86_64 (64-bit)	Red Hat Enterprise Linux Desktop + Workstation 6.5 ou plus ; openSUSE 13.2 ou Leap 42.1 ; Scientific Linux 6.5 ou plus
2016	Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86_64	Red Hat Enterprise Linux Desktop + Workstation 6.5 ou plus ; openSUSE 13.2 ou LEAP 42.1 ; Scientific Linux 6.5 ou plus ; CentOS 7
2017 SP1	Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86_64	openSUSE LEAP 42.1 et 42.2 ; Red Hat Enterprise Linux Desktop + Workstation 6.x et 7.x ; Scientific Linux 6.x ; CentOS 7
2018 SP1	Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86_64	openSUSE LEAP 15.0, 42.2 et 42.3 ; Red Hat Enterprise Linux Desktop + Workstation 6.x et 7.x ; CentOS 7
2019	Linux kernel 2.6x ou 3.x, et GNU C Library (glibc) Version 2.11 ou plus récent pour architecture Intel x86_64	openSUSE Leap 42.3 et 15.0 ; Red Hat Enterprise Linux 7 et 8 ; CentOS 7 et 8

Alternatives à LabVIEW

En ce qui concerne le contrôle, le test et la mesure, on peut développer avec des logiciels tels que :

• LabWindows/CVI, de National Instruments, qui est un environnement de développement pour le langage C et qui offre les mêmes bibliothèques logicielles de fonctions.
• Measurement Studio, de National Instruments, qui est un ensemble de bibliothèques de fonctions et de contrôles graphiques pour Visual Studio, permettant ainsi de la programmation en C++, Visual Basic ou C sharp tout en profitant de fonctionnalités destinées au contrôle, test et mesure.
• TestStand et VeriStand, de National Instruments (plutôt complément que alternative : séquenceur de tâches).

Il est bien sûr possible de programmer les logiciels de test et mesure dans tous langages de programmation sans bénéficier des fonctions destinées à ce domaine. Le développement s'en trouvera plus long mais il pourra avoir le mérite d'être indépendant d'un produit commercial et fermé.

Voir aussi

Articles connexes

• TestStand

Liens externes

• Site officiel
• Notices d'autorité :

  • Tchéquie
• Site web National Instrument
• (en) « LabVIEW Advanced Virtual Architects », sur lavag.org
• (fr) « Développez.com : Club des Développeurs et IT-Pro »