Un conduit est un fil de liaison dans LabVIEW qui exprime une communication asynchrone entre deux sections de code parallèles sans forcer un ordre d'exécution particulier. L'utilisation d'un conduit est similaire à celle d'un refnum ou d'une variable dans laquelle une boucle écrit des données alors qu'une autre boucle en lit les données. Au lieu d'utiliser un refnum ou une variable, vous représentez le transfert de données graphiquement par un fil.

La figure suivante montre que vous pouvez utiliser des conduits pour construire votre diagramme et obtenir les mêmes fonctionnalités qu'en utilisant des refnums de files d'attente.

Chaque conduit doit avoir au moins deux extrémités : un scripteur et un lecteur. Les extrémités sont les endroits du code où l'échange de données s'effectue. Les extrémités scripteurs écrivent des données dans le conduit. Les extrémités lecteurs lisent les données du conduit. En connectant l'extrémité scripteur à l'extrémité lecteur avec un conduit, vous activez la communication asynchrone des données entre des sections de code parallèles.

LabVIEW fournit les modèles de conduits suivants pour construire des applications. Chaque modèle exprime un protocole de communication différent. Vous pouvez choisir parmi les modèles suivants en fonction des besoins de communication de votre application :

LabVIEW Module Real-Time Module FPGA*
Flux Tag Messager Tag Accumulateur Messager d'événements Flux haute vitesse Flux à pertes Flux à un élément Flux Tag Messager Tag Accumulateur Messager d'événements Flux haute vitesse Flux à pertes Flux à un élément Flux temps réel Flux Tag Tag Accumulateur Flux à pertes Flux à un élément
*Pour chaque modèle de conduit supporté, le module FPGA ne supporte qu'un sous-ensemble d'extrémités.

Vous pouvez créer une extrémité scripteur de conduit ou une extrémité lecteur de conduit en cliquant avec le bouton droit sur un terminal ou un fil de liaison et en sélectionnant Créer»Scripteur de conduit ou Créer»Lecteur de conduit. Dans la boîte de dialogue Sélectionner l'extrémité de conduit qui apparaît, vous pouvez changer une extrémité lecteur en scripteur et vice versa en cliquant sur Inverser Lecture/Écriture. Lorsque vous créez une extrémité à partir d'un terminal, vous créez une instance du modèle de conduit ayant ce type de données comme type de transmission.

Vous ne pouvez pas créer de branches sur les conduits Flux ; autrement dit, ils ne peuvent connecter qu'une seule extrémité scripteur à une seule extrémité lecteur. Vous pouvez créer des branches sur tous les autres conduits pour avoir plusieurs scripteurs ou lecteurs sur un même conduit.

Comprendre la durée de vie des conduits

Le diagramme appellant d'un conduit contrôle l'exécution du conduit. Un diagramme appelant est le diagramme de plus bas niveau qui contient toutes les extrémités d'un conduit ou tous les nœuds qui appellent ces extrémités.

Un conduit s'initialise lorsque son diagramme appelant commence à s'exécuter. Un conduit se ferme lorsque l'entrée dernier élément? ou abandonner d'une de ses extrémités est VRAI. Si un conduit se ferme, il ignore toutes les écritures ultérieures. Le conduit se réinitialise lorsque son diagramme appelant commence une nouvelle exécution. Un diagramme appelant peut être un nœud de structure, le diagramme de niveau principal d'un VI ou un diagramme de plus haut niveau qui appelle le VI de niveau principal actuel.

Dans la figure suivante, le diagramme appelant du conduit est le diagramme de niveau principal de ce VI. Le conduit s'initialise lorsque le diagramme appelant commence à s'exécuter, ce qui signifie qu'il s'initialise à chaque fois que le VI de niveau principal commence à s'exécuter ou est appelé comme sous-VI.

Dans la figure suivante, le diagramme appelant du conduit est la boucle While. Le conduit s'initialise lorsque la boucle While commence à s'exécuter, ce qui signifie qu'il s'initialise à chaque itération de la boucle While.

Dans la figure suivante, le diagramme appelant du conduit n'est pas le VI de niveau principal mais est à un niveau supérieur au diagramme de niveau principal actuel. Le conduit s'initialise lorsque le diagramme de niveau supérieur commence à s'exécuter, ce qui signifie qu'il s'initialise à chaque fois que le diagramme de niveau supérieur commence à s'exécuter ou est appelé comme sous-VI. Le conduit ne s'initialise pas aux itérations de la boucle While car elle ne contient pas toutes les extrémités du conduit.

Dans toutes les instances de conduit précédentes, l'extrémité d'Écriture écrit les trois premières valeurs dans le conduit mais ignore les deux dernières car l'entrée dernier élément? est VRAI quand le nombre d'éléments qui n'ont pas encore été écrits dans le tableau est égal à 2.

Arrêt d'une d'extrémité Dupliquer

Lorsque vous créez un lecteur ou un scripteur de conduit, sélectionnez Avec abandon pour créer une extrémité avec une entrée booléenne abandonner. Lorsque la valeur est VRAI, abandonner alerte toutes les extrémités pour qu'elles produisent une sortie abandonné ?. N'importe quelle extrémité peut envoyer le signal d'abandon. Si vous avez des boucles qui incluent des conduits, câblez toutes les boucles à la sortie abandonné ? des extrémités pour arrêter les boucles lorsqu'une extrémité envoie le signal d'abandon. Aucune variable locale n'est nécessaire pour ce mécanisme. Si vous utilisez une extrémité Dupliquer, le conduit d'origine doit fournir la valeur d'abandon. L'extrémité Dupliquer arrête sa boucle interne et propage la valeur d'abandon aux conduits dupliqués.

Avantages des conduits par rapport aux refnums et aux variables

L'utilisation de conduits a les avantages suivants :

  • Avec des conduits, vous n'avez pas besoin de créer et de détruire des refnums comme c'est le cas avec les files d'attente.
  • Les conduits requièrent moins de nœuds sur le diagramme que les files d'attente.
  • Les conduits indiquent d'où les données proviennent et où elles vont, ce qui améliore la visibilité et facilite la mise au point par rapport aux refnums et aux variables.
  • Les conduits peuvent incorporer des signaux d'arrêt et d'abandon avec les données, ce qui produit une application plus fiable que si vous deviez créer de tels signaux avec des refnums ou des variables.
  • Les conduits vous permettent de créer des co-routines qui jouent le rôle des fermetures des autres langages de programmation. Reportez-vous à labview\examples\Channels\Replacing The Function At The Heart Of An Algorithm At Run Time\Replacing The Function At The Heart Of An Algorithm At Run Time.lvproj pour voir un exemple d'utilisation de conduits pour créer des sous-programmes.