Découvrez 10 fonctions de NI-DAQmx pour maîtriser 80 pour cent des applications d'acquisition de données

Contenu

La série de tutoriels d'introduction à NI-DAQmx de NI est conçue pour vous aider à vous familiariser avec les principes de base de la programmation NI-DAQmx. Vous serez guidé par les tutoriels vidéo et textuels de cette série, de la vérification du fonctionnement de votre périphérique dans Measurement & Automation Explorer (MAX) jusqu'à la programmation d'applications d'acquisition de données dans LabVIEW. Elle est conçue aussi bien pour le débutant qui veut apprendre à utiliser l'Assistant DAQ que pour l'utilisateur chevronné qui veut tirer parti des fonctionnalités avancées de NI-DAQmx.

NI-DAQmx : Accélérer le développement et améliorer les performances

Depuis la sortie de NI-DAQmx, les utilisateurs des matériels d'acquisition de données (DAQ) NI ont tiré parti de ses nombreuses fonctionnalités conçues pour accélérer le développement et améliorer les performances de leurs applications d'acquisition de données.

Une fonctionnalité qui réduit considérablement la durée du développement est l'interface de programmation d'applications (API) NI-DAQmx, qui reste la même pour toutes les fonctionnalités et toutes les familles de périphériques. Ceci permet de programmer toutes les fonctionnalités d'un périphérique multifonction avec le même jeu de fonctions (entrée analogique, sortie analogique, E/S numériques et compteurs). D'autre part, un périphérique d'E/S numérique et un périphérique de sortie analogique sont programmés avec ce même jeu de fonctions. Dans LabVIEW, ceci est possible grâce au polymorphisme. Un VI polymorphe accepte plusieurs types de données pour un ou plusieurs de ses terminaux d'entrée et/ou de sortie. L'API NI-DAQmx est également cohérente pour tous les environnements de programmation compatibles. Il vous suffit d'apprendre à utiliser ce jeu de fonctions pour pouvoir programmer la plupart des matériels d'acquisition de données NI dans de multiples environnements de programmation.

Une autre fonctionnalité de NI-DAQmx qui améliore votre expérience en matière de développement est l'Assistant DAQ. Cet outil vous aide à créer vos applications sans programmation grâce à une interface graphique permettant de configurer les tâches d'acquisition de données, qu'elles soient simples ou complexes. De plus, la synchronisation, un processus souvent difficile à implémenter car il faut acheminer manuellement les signaux de déclenchement et/ou d'horloge, se fait sans effort avec NI-DAQmx puisqu'il le fait automatiquement entre les différentes zones fonctionnelles d'un périphérique ou entre plusieurs périphériques.

Les applications d'acquisition de données construites avec NI-DAQmx bénéficient d'une architecture conçue pour optimiser les performances. Pour commencer, un modèle à états efficace élimine les reconfigurations superflues. Ceci permet d'optimiser aussi bien la configuration que l'acquisition. De plus, vous pouvez obtenir des vitesses d'E/S point par point de plus de 50 kÉch./s. Ce niveau de performances est possible grâce aux registres mappés en mémoire.

Une autre fonctionnalité importante de l'architecture NI-DAQmx est le multithread de la mesure. Comme NI-DAQmx est multithread, plusieurs opérations d'acquisition de données peuvent se faire simultanément, améliorant ainsi considérablement les performances des applications qui effectuent de multiples opérations. Ceci simplifie aussi énormément la programmation de ces applications.

Pour commencer à tirer parti de ces avantages, il vous suffit d'apprendre à utiliser quelques fonctions. En fait, 10 des fonctions NI-DAQmx fournissent les fonctionnalités nécessaires pour résoudre 80 % des application d'acquisition de données. Ces fonctions sont décrites en détail pour vous aider à comprendre aussi bien leurs fonctionnalités que les types d'applications dans lesquelles elles sont utilisées.

Remarque : Les exemples référencés dans ce document se trouvent aux emplacements indiqués dans cet article de la Base de connaissances.

 

Assistant DAQ

Tools»Create/Edit DAQmx Tasks [CVI]
Project»Add New Item»DAQmx Task [.NET]






 

L'Assistant DAQ est une interface graphique qui permet de créer, d'éditer et d'exécuter des voies virtuelles et des tâches NI-DAQmx de manière interactive. Une voie virtuelle NI-DAQmx est constituée d'une voie physique sur un périphérique DAQ et des informations de configuration de cette voie physique (la gamme d'entrée et la mise à l'échelle personnalisée, par exemple). Une tâche NI-DAQmx est un ensemble de voies virtuelles, d'informations sur le cadencement et le déclenchement, et d'autres propriétés concernant l'acquisition ou la génération. Dans la figure suivante, l'Assistant DAQ est configuré pour effectuer une mesure de déformation finie.

 


Les documents suivants décrivent l'utilisation de l'Assistant DAQ dans LabVIEW, LabWindows/CVI et .NET:

Tutoriel sur les VIs Express de NI-DAQmx
Utilisation de l'Assistant DAQ sous LabWindows/CVI
Utilisation de l'Assistant DAQmx sous Measurement Studio

L'Assistant DAQ peut aussi générer du code pour configurer et/ou effectuer l'acquisition ou la génération spécifiée. Pour LabVIEW, cette procédure est décrite dans l'Aide Assistant DAQ et dans le document Utilisation de l'Assistant DAQ pour générer automatiquement du code LabVIEW. La figure suivante représente une instance de l'Assistant DAQ ainsi que la configuration et un exemple de code LabVIEW résultants générés automatiquement.


Certaines applications d'acquisition de données ont des besoins de flexibilité et/ou de performances trop élevés pour pouvoir utiliser l'Assistant DAQ. Pour ces applications, vous devez utiliser les fonctions NI-DAQmx, simples mais puissantes, décrites ci-dessous.

 


NI-DAQmx - Créer une voie virtuelle



Library»NI-DAQmx»Channel Creation/Configuration [CVI]

Propriété Task.Channel.CreateChannel [.NET]








La fonction DAQmx - Créer une voie virtuelle crée une voie et l'ajoute à une tâche. Elle peut aussi être utilisée pour créer plusieurs voies virtuelles et les ajouter toutes à une tâche. Si aucune tâche n'est spécifiée, la fonction en crée une. La fonction NI-DAQmx - Créer une voie virtuelle a de nombreuses instances. Ces instances correspondent au type de mesure ou de génération effectué par les voies virtuelles.

Création d'une voie dans LabVIEW

La figure suivante montre quatre exemples d'instances du VI NI-DAQmx - Créer une voie virtuelle.


Les entrées de la fonction NI-DAQmx - Créer une voie virtuelle sont différentes pour chaque instance de la fonction. Cependant, certaines entrées sont communes à la plupart, voire toutes, des instances de la fonction. Par exemple, il faut une entrée pour spécifier les voies physiques (entrée analogique et sortie analogique), les lignes (numériques) ou le compteur qui seront utilisés par les voies virtuelles. De plus, les opérations d'entrée analogique, de sortie analogique et de compteur utilisent des entrées valeur minimale et valeur maximale pour configurer et optimiser les mesures et les générations en fonction des valeurs minimale et maximale attendues dans les signaux. Par ailleurs, il est possible d'appliquer une échelle personnalisée à bon nombre de types de voies virtuelles. Dans le diagramme LabVIEW suivant, le VI NI-DAQmx - Créer une voie virtuelle est utilisé pour créer une voie virtuelle de thermocouple.

 

Création d'une voie dans .NET

La plupart des classes de la bibliothèque NI-DAQmx .NET ne peuvent pas être instanciées directement. Ces classes sont utilisées comme sous-objets de la classe .

Ces classes contiennent des propriétés spécifiques à un type de voie particulier. Par exemple, les propriétés telles que Count ne s'appliquent qu'aux compteurs et ne sont disponibles que pour les classes CIChannel et COChannel. Vous pouvez associer les types de voies suivants à une dans la bibliothèque de classes NI-DAQmx .NET :

Voies d'entrée analogique — classe

Voies de sortie analogique — classe

Voies d'entrée numérique — classe

Voies de sortie numérique — classe class

Voies d'entrée compteur — classe

Voies de sortie compteur — classe

La classe Task a une propriété de collection de voies pour chacun des six types de voies — , , , , et . Pour créer une voie, vous pouvez utiliser une des nombreuses méthodes de création de voie sur les collections de voies.

Après avoir instancié un nouvel objet Task, vous pouvez créer et assigner un objet AIChannel en appelant la fonction membre appropriée dans la classe Channel. L'extrait de code suivant crée une voie de tension d'entrée analogique simple :

analogInTask = new Task();

AIChannel maVoie;

maVoie = analogInTask.AIChannels.CreateVoltageChannel(

    "dev1/ai1", //Le nom physique à associer à la voie

    "maVoie", //Le nom à associer à cette voie

    AITerminalConfiguration.Differential, //Câblage différentiel

    -10, //-10V minimum

    10, //10V maximum

    AIVoltageUnits.Volts //Utiliser des volts
);

 

Création d'une tâche en C/C++

Utilisez la fonction DAQmxCreateTask() pour créer une tâche et DAQmxCreateAIVoltageChan() pour créer une voie de tension d'entrée analogique. Pour en savoir plus sur la création de voies pour différents types de mesures, consultez l'aide NI-DAQmx C Reference Help. L'extrait de code suivant montre comment utiliser les deux fonctions :

TaskHandle  taskHandle=0;
char        chan[256] = "Dev1/ai0";
float64     min = -10, max = 10;

DAQmxCreateTask("",&taskHandle);

DAQmxCreateAIVoltageChan(taskHandle ,chan ,"", DAQmx_Val_Cfg_Default, min, max, DAQmx_Val_Volts, NULL);

 

Exemples à étudier :

LabVIEW Numérique - Sortie finie
Thermocouple - Entrée continue
CVI Write Dig Port
Cont Thrmcpl Samples-Int Clk
.NET WriteDigPort
ContAcqThermocoupleSamples_IntClk

 

NI-DAQmx - Déclenchement


Library»NI-DAQmx»Triggering [CVI]

Propriété Task.Triggers [.NET]

 

La fonction NI-DAQmx - Déclenchement configure un déclenchement pour effectuer une action spécifique. Les actions les plus courantes sont un déclenchement de démarrage et un déclenchement de référence. Un déclenchement de démarrage lance une acquisition ou une génération. Un déclenchement de référence établit l'emplacement, dans un ensemble d'échantillons acquis, de la fin des données de pré-déclenchement et du début des données de post-déclenchement. Ces deux types de déclenchements peuvent être configurés pour avoir lieu sur un front numérique, un front analogique, ou lorsqu'un signal analogique entre dans une fenêtre ou la quitte.

Création d'un déclenchement dans LabVIEW

Dans le diagramme LabVIEW suivant, le VI NI-DAQmx - Déclenchement est utilisé pour configurer à la fois un déclenchement de démarrage et un déclenchement de référence sur les fronts numériques pour une opération d'entrée analogique.


Bon nombre d'applications d'acquisition de données requièrent la synchronisation de plusieurs zones fonctionnelles d'un même périphérique (sortie analogique et compteurs, par exemple). D'autres requièrent la synchronisation de plusieurs périphériques. Pour implémenter cette synchronisation, il faut acheminer les signaux de déclenchement entre les différentes zones fonctionnelles du même périphérique ou entre les différents périphériques. NI-DAQmx effectue ce routage automatiquement. Lorsque vous utilisez la fonction NI-DAQmx - Déclenchement, tous les signaux de déclenchement valides sont disponibles à l'entrée source de la fonction. Par exemple, dans le VI NI-DAQmx - Déclenchement suivant, le signal du déclenchement de démarrage pour le périphérique 2 est disponible comme source du déclenchement de démarrage pour le périphérique 1 sans avoir besoin d'effectuer un routage explicite.

 

Création d'un déclenchement dans .NET

Après avoir créé un objet Task et une voie, vous pouvez ajouter un déclenchement à la tâche en appelant les méthodes de la collection Task.Triggers. L'extrait de code suivant crée un déclenchement de démarrage sur front numérique :

analogInTask = new Task();

DigitalEdgeStartTriggerEdge triggerEdge = DigitalEdgeStartTriggerEdge.Rising;

analogInTask.AIChannels.CreateVoltageChannel( ... );

analogInTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger("PFI0", triggerEdge);

En fonction des paramètres envoyés à la fonction ConfigureDigitalEdgeTrigger, le périphérique recherchera un front montant ou descendant sur une ligne interne ou externe avant de commencer l'acquisition de données. L'extrait de code précédent configure le périphérique pour qu'il recherche un déclenchement sur front numérique montant sur PFI 0.

 

Création d'un déclenchement en C/C++

Utilisez la fonction DAQmxCfgDigEdgeStartTrig() pour créer un déclenchement de démarrage sur front numérique. Pour en savoir plus sur la création de différents déclenchements, consultez l'aide NI-DAQmx C Reference Help. L'extrait de code ci-dessous montre comment utiliser la fonction pour effectuer un déclenchement de démarrage numérique sur PFI0 et détecter un front montant sur cette ligne.

char        startTrigger[256] = "Dev1/PFI0";
int         startEdge = 0; // front montant

DAQmxCreateTask("",&taskHandle));

DAQmxCreateAIVoltageChan(taskHandle ,chan ,"", DAQmx_Val_Cfg_Default, min, max, DAQmx_Val_Volts, NULL);

DAQmxCfgDigEdgeStartTrig(taskHandle, startTrigger, startEdge);
 

 

Le document Fonctionnalités de cadencement et de synchronisation de NI-DAQmx fournit des informations supplémentaires sur l'utilisation de la fonction NI-DAQmx - Déclenchement pour effectuer une synchronisation avec NI-DAQmx.
Exemples à étudier :

LabVIEW Tension - Entrée finie
Tension - Entrée continue
CVI Acq-Int Clk-Dig Start&Ref
Cont Acq-Int Clk-Anlg Start
.NET AcqVoltageSamples_IntClkDigStartAndRef
ContAcqVoltageSamples_IntClkAnalogStart

 

NI-DAQmx - Cadencement


Library»NI-DAQmx»Timing [CVI]

Propriété Task.Timing [.NET]







La fonction NI-DAQmx - Cadencement configure le cadencement pour les opérations d'acquisition de données à cadencement matériel. Spécifier si l'opération sera continue ou finie, sélectionner le nombre d'échantillons à acquérir ou à générer pour les opérations finies, et créer un buffer si besoin est font partie de la configuration.

Pour les opérations qui ont besoin d'un cadencement d'échantillonnage (entrée analogique, sortie analogique et compteur), l'instance Horloge d'échantillonnage de la fonction NI-DAQmx - Cadencement définit à la fois la source de l'horloge d'échantillonnage (qui peut être interne ou externe) et sa fréquence. L'horloge d'échantillonnage contrôle la vitesse d'acquisition ou de génération des échantillons. Chaque impulsion de l'horloge initialise l'acquisition ou la génération d'un échantillon pour chacune des voies virtuelles de la tâche.

 

Configuration du cadencement d'une tâche dans LabVIEW


Le diagramme LabVIEW suivant montre comment utiliser l'instance Horloge d'échantillonnage du VI NI-DAQmx - Cadencement pour configurer une génération de sortie analogique continue avec une horloge d'échantillonnage externe.


Pour synchroniser des applications d'acquisition de données, les signaux doivent être acheminés de la même manière que les signaux de déclenchement entre les différentes zones fonctionnelles d'un même périphérique ou entre plusieurs périphériques. NI-DAQmx effectue aussi ce routage automatiquement. Tous les signaux de cadencement valides sont disponibles à l'entrée source de la fonction NI-DAQmx - Cadencement. Par exemple, dans le VI DAQmx - Cadencement suivant, le signal de l'horloge d'échantillonnage de sortie analogique est disponible comme source de l'horloge d'échantillonnage pour les voies d'entrée analogique sans avoir besoin d'effectuer un routage explicite.


Le document Fonctionnalités de cadencement et de synchronisation de NI-DAQmx fournit des informations supplémentaires sur l'utilisation de la fonction NI-DAQmx - Cadencement pour effectuer une synchronisation avec NI-DAQmx.
La plupart des opérations de compteur n'ont pas besoin de cadencement d'échantillonnage car le signal mesuré fournit le cadencement. Utilisez l'instance Implicite de la fonction NI-DAQmx - Cadencement pour ces applications. Dans le diagramme LabVIEW suivant, l'instance Implicite du VI NI-DAQmx - Cadencement est utilisé pour configurer une acquisition à largeur d'impulsion bufférisée finie avec un nombre d'échantillons spécifié.


Configuration du cadencement d'une tâche dans .NET

Pour définir la source et la fréquence de l'horloge d'échantillonnage, et le nombre d'échantillons à acquérir ou à générer, utilisez la fonction Channel.Timing.ConfigureSampleClock(). L'extrait de code suivant crée une acquisition continue basée sur une horloge d'échantillonnage externe connectée à PFI 0 sur le périphérique.

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

analogInTask.Timing.ConfigureSampleClock(

"/Dev1/PFI0", // ligne source de l'horloge externe ou utilisez "" pour l'horloge interne

10000, // fréquence attendue de l'horloge externe ou fréquence réelle de l'horloge interne

SampleClockActiveEdge.Rising, // acquérir sur le front montant ou descendant des tops

SampleQuantityMode.ContinuousSamples, // échantillons continus ou finis

1000 // nombre d'échantillons finis à acquérir, ou utilisés pour la taille du buffer si continus

);

 

Configuration du cadencement d'une tâche en C/C++

Utilisez la fonction DAQmxCfgSampClkTiming pour configurer le cadencement d'une tâche en C ou C++. L'extrait de code suivant montre l'utilisation de cette fonction pour une horloge interne à 10000 Hz.

char        clockSource[256] = "";
float64     rate = 10000;

DAQmxCfgSampClkTiming(taskHandle, clockSource, rate, DAQmx_Val_Rising, DAQmx_Val_ContSamps, 1000);

 

Certains périphérique d'acquisition de données utilisent les handshakes pour cadencer leurs opérations d'E/S numériques. Les handshakes utilisent l'échange d'un signal de requête de cadencement et d'un signal d'accusé de réception avec un périphérique externe pour transférer chaque échantillon. L'instance Handshake de la fonction NI-DAQmx - Cadencement configure le cadencement par handshake pour les opérations d'E/S numériques.

Exemples à étudier :

LabVIEW Tension - Sortie continue
Compteur - Lecture de largeur et fréquence d'impulsion (finie)
CVI Cont Gen Volt Wfm-Ext Clk
Buff Semi-Period-Finite
.NET ContGenVoltageWfm_ExtClk
MeasBuffered_SemiPeriodFinite

 

NI-DAQmx - Démarrer une tâche


Library»NI-DAQmx»Task Configuration/Control»Start Task [CVI]

Méthode Task.Start [.NET]


Comme mentionné dans l'introduction, le modèle à états utilisé par NI-DAQmx élimine les configurations superflues pour atteindre un haut niveau d'efficacité et optimiser les performances. Ce modèle à états est composé des cinq états dans lesquels une tâche peut se trouver. Vous trouverez des informations détaillées sur chacun de ces états dans l'Aide NI-DAQmx, sous Concepts clés de NI-DAQmx»Voies et tâches dans NI-DAQmx»Tâches dans NI-DAQmx»Modèle de tâche à états.

La fonction NI-DAQmx - Démarrer une tâche fait passer explicitement une tâche à l'état En cours d'exécution. Dans l'état En cours d'exécution, la tâche effectue la génération ou l'acquisition spécifiée. Si la fonction NI-DAQmx - Démarrer une tâche n'est pas utilisée, une tâche passera implicitement à l'état En cours d'exécution et démarrera automatiquement) quand la fonction NI-DAQmx - Lire s'exécute. Cette transition implicite a également lieu si la fonction NI-DAQmx - Démarrer une tâche n'est pas utilisée et que la fonction NI-DAQmx - Écrire s'exécute avec son entrée démarrage auto spécifiée de manière appropriée.

Bien que ce ne soit pas toujours requis, il est conseillé d'utiliser la fonction NI-DAQmx - Démarrer une tâche pour démarrer explicitement une tâche qui comprend une acquisition ou génération à cadencement matériel. De plus, si la fonction NI-DAQmx - Lire ou NI-DAQmx - Écrire s'exécutera de nombreuses fois (dans une boucle, par exemple), vous devriez aussi utiliser la fonction NI-DAQmx - Démarrer une tâche Sinon, le fait de démarrer et d'arrêter la tâche de manière répétée nuira aux performances de la tâche. Vous trouverez des informations supplémentaires sur l'utilisation de la fonction NI-DAQmx - Démarrer une tâche dans l'article Quand utiliser les VIs DAQmx - Démarrer une tâche et DAQmx - Arrêter une tâche.

 

Démarrage d'une tâche dans LabVIEW

Le diagramme LabVIEW suivant représente un cas où il n'est pas nécessaire d'utiliser la fonction NI-DAQmx - Démarrer une tâche car la génération de sortie analogique ne comprend qu'un seul échantillon à cadencement logiciel.


Inversement, le diagramme LabVIEW suivant représente un cas où il faut utiliser la fonction NI-DAQmx - Démarrer une tâche car la fonction NI-DAQmx - Lire s'exécute plusieurs fois pour lire le compteur.

 

Démarrage d'une tâche dans .NET

Pour démarrer une tâche, utilisez la fonction Start() dans l'objet Task. L'extrait de code suivant montre comme utiliser la fonction Start().

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

analogInTask.Timing.ConfigureSampleClock( ... );

analogInTask.Start();

 

Démarrage d'une tâche en C/C++

Pour démarrer une tâche, utilisez la fonction DAQmxStartTask(). L'extrait de code suivant montre comment l'utiliser.

DAQmxStartTask(taskHandle);

 

Exemples à étudier :

LabVIEW Compteur - Sortie continue
Courant - Entrée continue
CVI Dig Pulse Train-Cont
Cont 0-20mA Samps-Int Clk
.NET GenDigPulseTrain_Continuous
ContAcq0_20mACurrentSamples_IntClk

 

NI-DAQmx - Lire


Library»NI-DAQmx»Read Functions [CVI]

Classe ChannelReader [.NET]



La fonction NI-DAQmx - Lire lit les échantillons de la tâche d'acquisition spécifiée. Les différentes instances de la fonction permettent de sélectionner le type d'acquisition (analogique, numérique ou compteur), le nombre de voies virtuelles, le nombre d'échantillons et le type de données. Lorsque le nombre d'échantillons spécifié a été transféré de la FIFO de la carte DAQ au buffer de l'ordinateur dans la RAM, la fonction NI-DAQmx - Lire transfère les échantillons du buffer de l'ordinateur à la mémoire du logiciel de développement (ADE).

Lecture de données dans LabVIEW

Les figures suivantes montrent quatre exemples d'instances du VI NI-DAQmx - Lire.


Les instances de la fonction NI-DAQmx - Lire capables de lire plusieurs échantillons ont une entrée pour spécifier le nombre d'échantillons par voie à lire lorsque la fonction s'exécute. Pour les acquisitions finies, si vous spécifiez -1 pour le nombre d'échantillons par voie, la fonction attend que tous les échantillons demandés aient été acquis puis les lit. Si vous spécifiez -1 pour le nombre d'échantillons par voie pour une acquisition continue, la fonction lit tous les échantillons disponibles dans le buffer au moment où elle s'exécute. Dans le diagramme LabVIEW suivant, le VI NI-DAQmx - Lire a été configuré pour lire plusieurs échantillons de plusieurs voies virtuelles d'entrée analogique et renvoyer les données sous forme de waveforms. De plus, comme l'entrée nombre d'échantillons par voie a été câblée à la valeur constante 10, le VI lira 10 échantillons sur chaque voie virtuelle à chaque fois qu'il s'exécute.

 

Lecture de données dans .NET

Pour lire avec la bibliothèque NI-DAQmx .NET, utilisez les objets reader et stream. Ce modèle de programmation est semblable au modèle utilisé dans tout le framework .NET pour les E/S sur fichiers et réseau.

La classe a des propriétés pour les E/S, telles que , et des méthodes pour les E/S brutes. Pour qu'une instance de la classe DaqStream corresponde à une particulière, utilisez la propriété . Vous ne pouvez pas créer directement une instance de la classe DaqStream.

Pour effectuer une lecture dans la bibliothèque NI-DAQmx, créez une instance d'un lecteur et passez une instance de la classe DaqStream dans le constructeur. Ensuite, appelez une méthode sur la classe du lecteur pour lire les données, comme le montre l'extrait de code suivant :

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

//Créer le lecteur et l'attacher au flux
AnalogSingleChannelReader reader = new AnalogSingleChannelReader(analogInTask.Stream);

//Effectuer la lecture
double[] data = reader.ReadMultiSample(100);

 

Lecture de données en C/C++
Utilisez la fonction DAQmxReadAnalogF64() pour lire des données analogiques à partir d'une tâche d'entrée analogique en C ou C++. Pour en savoir plus sur les fonctions de lecture, consultez l'aide NI-DAQmx C Reference Help. L'extrait de code suivant montre comme lire 1000 échantillons d'une seule voie.

int numRead = 0;

DAQmxReadAnalogF64(taskHandle, 1000, 10.0, DAQmx_Val_GroupByScanNumber, data, 1000, &numRead, NULL);

 

Exemples à étudier :

LabVIEW Tension - Entrée à cadencement logiciel
Numérique - Entrée finie
CVI One Sample
Read Dig Chan
.NET AcqOneVoltageSample
ReadDigChan

 

NI-DAQmx - Écrire


Library»NI-DAQmx»Write Functions [CVI]

Classe ChannelWriter [.NET]





La fonction NI-DAQmx - Écrire écrit des échantillons dans la tâche de génération spécifiée. Les différentes instances de la fonction permettent de sélectionner le type de génération (analogique ou numérique), le nombre de voies virtuelles, le nombre d'échantillons et le type de données. La fonction NI-DAQmx - Écrire transfère les échantillons de la mémoire du logiciel de développement (ADE) au buffer de l'ordinateur dans la RAM. Ces échantillons sont ensuite transférés du buffer de l'ordinateur à la FIFO de la carte DAQ pour être générés.

Chaque instance de la fonction NI-DAQmx - Écrire a une entrée démarrage auto qui permet de déterminer si la fonction démarrera la tâche implicitement si elle n'a pas été démarrée explicitement. Comme mentionné plus tôt dans la section NI-DAQmx - Démarrer une tâche de ce document, la fonction NI-DAQmx - Démarrer une tâche devrait être utilisée pour démarrer de manière explicite une tâche de génération qui utilise un cadencement matériel. Elle devrait aussi être utilisée pour optimiser les performances si la fonction NI-DAQmx - Écrire sera exécutée plusieurs fois.

Écriture de données dans LabVIEW

Les figures suivantes montrent quatre exemples d'instances du VI NI-DAQmx - Écrire.


Le diagramme LabVIEW suivant, pour une génération de sortie analogique, inclut une constante booléenne "Faux" câblée à l'entrée démarrage auto du VI NI-DAQmx - Écrire car la génération a un cadencement matériel. Le VI NI-DAQmx - Écrire a été configuré pour écrire plusieurs échantillons de données de sortie analogique pour une voie de la tâche sous forme de waveform analogique.


Écriture de données dans .NET

Pour écrire avec la bibliothèque NI-DAQmx .NET, utilisez les objets writer et stream. Ce processus est semblable à la lecture de données décrites plus tôt.

Pour effectuer une écriture, créez une instance d'un scripteur et passez une instance de la classe DaqStream dans le constructeur. Ensuite, appelez une méthode sur la classe du scripteur pour écrire les données, comme le montre l'extrait de code suivant :

analogOutTask = new Task();

analogOutTask.AOChannels.CreateVoltageChannel( ... );

//Créer le scripteur et l'attacher au flux
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogOutTask.Stream);

//Effectuer l'écriture
double[] data = writer.WriteMultiSample(100);

 

Écriture de données en C/C++
Pour écrire des données analogiques, utilisez la fonction DAQmxWriteAnalogF64(). Pour en savoir plus sur l'écriture d'autres formes de données, consultez l'aide NI-DAQmx C Reference Help. L'extrait de code suivant montre comment écrire 1000 échantillons de données analogiques.

int written = 0;

DAQmxWriteAnalogF64(taskHandle, 1000, 0, 10.0, DAQmx_Val_GroupByChannel, data, &written, NULL);

 

Exemples à étudier

LabVIEW Tension - Sortie finie
Numérique - Sortie finie
CVI Volt Update
Write Dig Chan
.NET GenVoltageUpdate
WriteDigChan

 

NI-DAQmx - Attendre jusqu'à la fin


Library»NI-DAQmx»Task Configuration/Control»Wait Until Task Done [CVI]

Méthode Task.WaitUntilDone [.NET]


La fonction NI-DAQmx - Attendre jusqu'à la fin attend que l'acquisition de données soit terminée avant de rendre la main. Vous devriez utiliser cette fonction pour que la tâche ne s'arrête que lorsque l'acquisition ou la génération spécifiée est terminée. En général, la fonction NI-DAQmx - Attendre jusqu'à la fin est utilisée pour les opérations finies. Lorsque cette fonction a fini de s'exécuter, l'acquisition ou génération finie est terminée et la tâche peut être arrêtée sans perturber l'opération. De plus, l'entrée timeout permet de spécifier une attente maximale. Si l'acquisition ou la génération ne se termine pas dans ce délai, la fonction rend la main et une erreur appropriée est générée.

Attendre jusqu'à la fin dans LabVIEW

Le VI NI-DAQmx - Attendre jusqu'à la fin est utilisé dans le diagramme LabVIEW suivant pour vérifier que l'opération de sortie numérique finie est terminée avant de supprimer la tâche.


Attendre jusqu'à la fin dans .NET

Pour en savoir plus sur l'utilisation de cette fonctionnalité dans .NET, reportez-vous à l'exemple GenMultVoltUpdates_IntClk.

Attendre jusqu'à la fin en C/C++

La fonction DAQmxWaitUntilTaskDone() est utilisée pour attendre que tous les échantillons du buffer soient générés. Appelez-la après une fonction d'écriture ou de démarrage.

 

Exemples à étudier

LabVIEW Numérique - Sortie finie
Tension - Sortie finie
CVI Dig Pulse
Mult Volt Updates-Int Clk
.NET GenDigPulse
GenMultVoltUpdates_IntClk

 

NI-DAQmx - Supprimer une tâche


Library»NI-DAQmx»Task Configuration/Control»Clear Task [CVI]

Méthode Task.Dispose [.NET]


 

La fonction NI-DAQmx - Supprimer une tâche efface la tâche spécifiée. Si la tâche est en cours d'exécution, la fonction commence par l'arrêter puis libère toutes ses ressources. Une fois une tâche supprimée, elle doit être recréée pour être utilisée. Par conséquent, si une tâche sera réutilisée, il faut utiliser la fonction NI-DAQmx - Arrêter une tâche pour l'arrêter sans la supprimer.

Pour les opérations continues, la fonction NI-DAQmx - Supprimer une tâche devrait être utilisée pour arrêter l'acquisition ou la génération.

Suppression d'une tâche dans LabVIEW

Dans le diagramme LabVIEW suivant, un train d'impulsions continu est généré avec un compteur. Le train d'impulsions est renvoyé en sortie jusqu'à ce que la boucle While rende la main et que le VI NI-DAQmx - Supprimer une tâche s'exécute.


Suppression d'une tâche dans .NET

Lorsqu'une tâche a fini de lire ou d'écrire des données, il suffit d'appeler la méthode Task.Dispose.

Suppression d'une tâche en C/C++

Lorsqu'une tâche a fini de lire ou d'écrire des données, utilisez la fonction DAQmxClearTask().

Exemples à étudier

LabVIEW Tension - Sortie continue
Compteur - Comptage de fronts (horloge continue)
CVI Cont Gen Volt Wfm-Int Clk
Cnt Dig Events
.NET ContGenVoltageWfm_IntClk
CountDigEvents

 

Propriétés NI-DAQmx

Attribut [CVI]

Propriété [.NET]

Les propriétés NI-DAQmx permettent d'accéder à toutes les propriétés associées à une opération d'acquisition de données. Les Propriétés NI-DAQmx permettent aussi bien de définir les propriétés (avec une écriture) que de lire les valeurs de ces propriétés.

Bon nombre de propriétés peuvent être définies avec les fonctions NI-DAQmx décrites ci-dessus. Par exemple, les propriétés Source d'horloge d'échantillonnage et Front actif de l'horloge d'échantillonnage peuvent être définies avec la fonction NI-DAQmx - Cadencement. Cependant, certaines des propriétés moins courantes ne sont accessibles qu'avec les Propriétés NI-DAQmx.

Utilisation de propriétés dans LabVIEW (nœuds de propriété)


Dans LabVIEW, vous pouvez utiliser un nœud de propriété NI-DAQmx pour écrire et/ou lire les valeurs de plusieurs propriétés. Par exemple, le nœud de propriété LabVIEW NI-DAQmx - Cadencement suivant définit la source de l'horloge d'échantillonnage. Puis la source de l'horloge d'échantillonnage est lue. Et finalement, le front actif de l'horloge d'échantillonnage est défini.


Dans le diagramme LabVIEW suivant, un nœud de propriété NI-DAQmx - Voie est utilisé pour activer le filtre passe-bas du matériel puis pour définir la fréquence de coupure à utiliser pour une mesure de jauge de contrainte.


 

Utilisation de propriétés dans .NET

Comme mentionné dans la section Cadencement, bon nombre de propriétés sont définies à partir de sous-classes et de collections de l'objet Task. L'extrait de code suivant montre l'utilisation d'une propriété NI-DAQmx courante :

//Créer une nouvelle tâche NI-DAQmx
Task t = new Task();

//Accéder aux propriétés du sous-objet de la classe Task
t.Timing.SamplesPerChannel = 1000;

 

Utilisation de propriétés en C/C++

Il existe des fonctions d'obtention et de définition pour obtenir ou définir chaque propriété d'une tâche. Pour en savoir plus, consultez la liste de propriétés et de leurs fonctions dans l'aide NI-DAQmx C Reference Help, sous NI-DAQmx C Properties.

Exemples à étudier

LabVIEW Strain - Continuous Input.vi
Thermocouple (avec DTCO) - Entrée continue
CVI Cont Strain Samples
Cont Accel Samps-Int Clk-Anlg Start
.NET AcqStrainSamples
ContAcqAccelSamp_IntClk_AnalogStart

 

Conclusion

NI-DAQmx accélère le développement tout en améliorant les performances des applications d'acquisition de données. NI-DAQmx vous fait gagner du temps au développement, entre autres, grâce à une API qui ne requiert que quelques fonctions pour implémenter la majorité de ses fonctionnalités. En fait, il est possible de créer 80 % des applications d'acquisition de données en ne connaissant que les 10 fonctions traitées dans ce document.