10 Funktionen in NI-DAQmx, die Sie kennen müssen, um 80 Prozent aller Datenerfassungsanwendungen zu meistern

Benutzer von DAQ-Datenerfassungshardware von NI haben seit der Veröffentlichung von NI-DAQmx von den vielen Funktionen zur Zeiteinsparung bei der Entwicklung profitiert und konnten die Leistung ihrer Datenerfassungsanwendungen verbessern.

Was besonders zur Verkürzung der Entwicklungszeit beiträgt sind die NI-DAQmx-VIs und -Funktionen, die universell über Gerätefunktionen und Gerätefamilien hinweg nutzbar sind. Das bedeutet, dass alle Funktionen eines Multifunktionsgeräts mit demselben Funktionensatz programmiert werden (analoge Eingabe, analoge Ausgabe, digitale I/O und Zähler). Darüber hinaus werden sowohl ein Gerät zur digitalen I/O als auch ein analoges Ausgabegerät unter Verwendung derselben Funktionen programmiert. In LabVIEW ist das aufgrund von Polymorphie möglich. Ein polymorphes VI kann verschiedene Datentypen für einen oder mehrere Eingangs- und/oder Ausgangsanschlüsse annehmen. Außerdem sind die NI-DAQmx-VIs- und Funktionen über alle anwendbaren Programmierumgebungen hinweg konsistent. Sie lernen, wie Sie mit Hilfe von nur einem Satz von Funktionen die meiste Datenerfassungshardware von NI in verschiedenen Programmierumgebungen programmieren können.

Der DAQ-Assistent ist eine weitere Funktion von NI-DAQmx, die Ihre Entwicklungserfahrung verbessert. Durch dieses Tool können Sie Anwendungen für einfache oder komplexe Datenerfassungsaufgaben mit Hilfe einer grafischen Oberfläche erzeugen, ohne programmieren zu müssen. Darüber hinaus ist die Synchronisation mit NI-DAQmx dank einer automatischen Signalübertragung zwischen den verschiedenen Funktionsbereichen eines Geräts und zwischen mehreren Geräten sehr einfach. Dieser Prozess war sonst schwierig zu implementieren, da die Routen von Triggern und/oder Sample-Takten manuell festgelegt werden mussten.

Die Datenerfassungsanwendungen, die Sie mit Hilfe von NI-DAQ erstellen, beruhen auf einer Architektur, die zur Leistungsmaximierung konzipiert ist. Diese Maximierung beginnt mit einem effizienten Zustandsmodell, das unnötige Neukonfigurationen eliminiert. Durch das Entfernen eines solchen Overheads werden sowohl Konfiguration als auch Erfassung optimiert. Zusätzlich können Einzelpunkt-I/O-Raten von mehr als 50 kS/s erzielt werden. Ein solches Leistungsniveau wird durch Register mit Memory Mapping ermöglicht.

Multithread-Messungen sind eine weitere wichtige Funktion, die in der NI-DAQmx-Architektur zu finden ist. Aufgrund von Multithreading in NI-DAQmx können mehrere Datenerfassungsvorgänge gleichzeitig durchgeführt werden, wodurch sich die Leistung Ihrer Anwendungen mit mehreren Operationen signifikant erhöht. Außerdem wird das Programmieren solcher Anwendungen vereinfacht.

Sie müssen nur einige wenige Funktionen kennen, um diese Vorteile in Anspruch nehmen zu können. Tatsächlich erhalten Sie mit nur 10 Funktionen in NI-DAQmx 80 % des Funktionsumfangs, den Sie für Ihre Datenerfassungsanwendungen benötigen. In den folgenden detaillierten Beschreibungen lernen Sie die Funktionen und die Art der Anwendungen, in denen sie verwendet werden, kennen.

HINWEIS: Die Beispiele, auf die in diesem Dokument verwiesen wird, befinden sich an den Speicherorten, auf die in diesem Dokument verwiesen wird: Speicherorte für NI-DAQmx-Beispiele für LabVIEW und textbasierte Entwicklungsumgebungen in Windows

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

Der DAQ-Assistent ist eine grafische Oberfläche, in der virtuelle NI-DAQmx-Kanäle und Tasks erzeugt, bearbeitet und ausgeführt werden können. Ein virtueller NI-DAQmx-Kanal besteht aus einem physikalischen Kanal auf einem DAQ-Gerät und aus den Einstellungen für diesen physikalischen Kanal, wie Eingangsbereich und benutzerdefinierte Skalierung. Ein NI-DAQmx-Task ist eine Sammlung von virtuellen Kanälen, Timing- und Trigger-Einstellungen und anderen Eigenschaften zur Erfassung oder Erzeugung von Daten. In der folgenden Abbildung sehen Sie einen DAQ-Assistenten, der für eine Dehnungsmessung mit einer bestimmten Sample-Anzahl konfiguriert ist.

Die folgenden Dokumente beschreiben die Verwendung des DAQ-Assistenten in LabVIEW, LabWindows/CVI und .NET:

NI-DAQmx Express VI Tutorial
Using the DAQ Assistant in LabWindows/CVI
Using the DAQ Assistant in Measurement Studio

Mit dem DAQ-Assistenten kann außerdem Programmcode zum Konfigurieren und/oder Durchführen einer bestimmten Erfassung oder Erzeugung erstellt werden. Der entsprechende Vorgang in LabVIEW wird in der Hilfe zum DAQ-Assistenten und im Dokument Using DAQ Assistant to Automatically Generate LabVIEW Code beschrieben. Die folgende Abbildung zeigt eine Instanz des DAQ-Assistenten und die resultierende, automatisch erzeugte Konfiguration sowie LabVIEW-Beispielcode.

Bestimmte Anwendungen zur Datenerfassung erfordern mehr Flexibilität und/oder höhere Leistung als der DAQ-Assistent bietet. Für solche Anwendungen benötigen Sie die folgenden einfachen, aber leistungsstarken NI-DAQmx-Funktionen.

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

Task.Channel.CreateChannel Property [.NET]

Die Funktion "NI-DAQmx - Virtuellen Kanal erzeugen" erstellt einen virtuellen Kanal und fügt diesen zu einem Task hinzu. Es können damit auch mehrere virtuelle Kanäle erstellt und zu einem Task hinzugefügt werden. Wenn kein Task angegeben ist, erzeugt die Funktion diesen. Die Funktion "NI-DAQmx - Virtuellen Kanal erzeugen" hat viele Instanzen. Diese Instanzen entsprechen dem bestimmten Typ von Messung oder Erzeugung, die der virtuelle Kanal ausführt.

Erzeugen eines Kanals in LabVIEW

Die folgende Abbildung zeigt vier Beispiele mit verschiedenen Instanzen des VIs "NI-DAQmx - Virtuellen Kanal erzeugen".

Die Eingänge der Funktion "NI-DAQmx - Virtuellen Kanal erzeugen" sind für jede Instanz der Funktion anders. Die meisten (manchmal sogar alle) Instanzen einer Funktion haben jedoch bestimmte Eingänge gemeinsam. Beispielsweise ist zum Festlegen der physikalischen Kanäle (analoge Eingabe und analoge Ausgabe) ein Eingang erforderlich, sowie für Verbindungen (digital) oder Zähler, die der virtuelle Kanal verwendet. Zusätzlich verwenden die analoge Eingabe, analoge Ausgabe und Zähleroperationen die Eingänge Mindestwert und Höchstwert, um die Messungen und Ausgaben basierend auf den erwarteten Mindest- und Höchstwerten für das Signal zu konfigurieren und zu optimieren. Außerdem kann auf viele Arten von virtuellen Kanälen eine benutzerspezifische Skalierung angewandt werden. Im folgenden LabVIEW-Blockdiagramm wird das VI "NI-DAQmx - Virtuellen Kanal erzeugen" zum Erzeugen eines virtuellen Thermoelement-Kanals verwendet.

Erzeugen eines Kanals in .NET

Die meisten Klassen in der NI-DAQmx-.NET-Bibliothek können nicht direkt erzeugt werden. Diese Klassen werden als Unterobjekte der Klasse verwendet.

Diese Klassen enthalten spezifische Eigenschaften für eine bestimmte Art von Kanälen. Beispielsweise sind Eigenschaften wie Zähler nur auf Zähler anwendbar und nur in den Klassen CIChannel und COChannel verfügbar. Die folgenden Arten von Kanälen können in der NI-DAQmx .NET-Klassenbibliothek mit einem assoziiert werden:

Analoge Eingangskanäle— -Klasse

Analoge Ausgangskanäle— -Klasse

Digitale Eingangskanäle— -Klasse

Digitale Ausgangskanäle— -Klasse

Zählereingangskanäle— -Klasse

Zählerausgangskanäle— -Klasse

Die Klasse Task hat eine Kanal-Sammeleigenschaft für jede der sechs Kanalarten — , , , , und . Beim Erzeugen von Kanälen mit Hilfe von Sammeleigenschaften stehen Ihnen viele Methoden zur Kanalerstellung zur Verfügung.

Nach dem Erzeugen eines neuen Task-Objekts kann ein AlChannel-Objekt durch Aufrufen der entsprechenden Funktion in der Klasse erzeugt und zugewiesen werden. Mit dem folgenden Codeausschnitt wird ein einfacher Spannungseingangskanal erzeugt:

analogInTask = new Task();

AIChannel meinKanal;

meinKanal = analogInTask.AIChannels.CreateVoltageChannel(

    "dev1/ai1", //Der physikalische Name des Kanals

    "meinKanal", //Der mit diesem Kanal assoziierte Name

    AITerminalConfiguration.Differential, //differentielle Verbindung

    -10, //-10v minimum

    10, //10v maximum

    AIVoltageUnits.Volts //Verwendete Volt
);

Erzeugen eines Tasks in C/C++

Verwenden Sie die Funktion "DAQmxCreateTask()" zum Erzeugen eines Tasks und "DAQmxCreateAIVoltageChan()" zum Erzeugen eines analogen Spannungseingangskanals. Mehr Informationen zum Erzeugen von Kanälen für verschiedene Arten von Messungen finden Sie in der Dokumentation zu NI-DAQ unter "NI-DAQmx C Reference Help". Hier sehen Sie einen Codeausschnitt zur Verwendung der zwei Funktionen:

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);

Beispiele zur Illustration:

Library»NI-DAQmx»Triggering [CVI]

Task.Triggers Property [.NET]

Mit der NI-DAQmx-Trigger-Funktion wird ein Trigger zum Durchführen einer bestimmten Aktion konfiguriert. Die am häufigsten verwendeten Aktionen sind ein Start-Trigger und ein Referenz-Trigger. Mit einem Start-Trigger wird die Signalerfassung oder -ausgabe ausgelöst. Mit dem Referenz-Trigger wird in einem Satz erfasster Samples ein Punkt festgelegt, an dem die Samples vor dem Trigger enden und die Nach-Trigger-Samples beginnen. Sie können diesen Trigger so konfigurieren, dass er bei einer digitalen einer analogen Flanke auftritt oder wenn ein analoges Signal in ein Fenster eintritt oder es verlässt.

Erzeugen eines Triggers in LabVIEW

Im folgenden LabVIEW-Blockdiagramm wurden mit Hilfe des VIs "DAQmx - Trigger" sowohl ein Start- als auch ein Referenz-Trigger konfiguriert, die bei einer analogen Eingangsoperation an digitalen Flanken ausgelöst werden.

Viele Anwendungen zur Datenerfassung erfordern die Synchronisation der verschiedenen funktionalen Bereiche eines Geräts (z. B. analoge Ausgabe und Zähler). Andere erfordern die Synchronisation mehrerer Geräte. Für eine solche Synchronisation müssen Trigger-Signale zwischen den verschiedenen funktionalen Bereichen eines Geräts geroutet werden, und bei Bedarf auch zwischen mehreren Geräten. NI-DAQmx führt dieses Routing automatisch durch. Beim Verwenden der NI-DAQmx-Trigger-Funktion sind alle gültigen Trigger-Signale als Quelle-Eingang der Funktion verfügbar. Beispielsweise ist im folgenden VI "DAQmx - Trigger" das "StartTrigger"-Signal für Gerät 2 als Quelle des Start-Triggers für Gerät 1 verfügbar, ohne dass ein spezielles Routing durchgeführt wird.

Erzeugen eines Triggers in .NET

Nach dem Erzeugen eines Task-Objekts und eines Kanals können Sie einen Trigger zum Task hinzufügen, indem Sie die Methoden innerhalb der Task.Triggers-Sammlung aufrufen. Mit dem folgenden Codeausschnitt wird  ein Start-Trigger bei digitalen Flanken erstellt:

analogInTask = new Task();

DigitalEdgeStartTriggerEdge triggerEdge = DigitalEdgeStartTriggerEdge.Rising;

analogInTask.AIChannels.CreateVoltageChannel( ... );

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

Basierend auf den Parametern, die an die "ConfigureDigitalEdgeTrigger"-Funktion gesandt werden, sucht das Gerät in einer internen oder externen Leitung nach einer steigenden oder fallenden digitalen Flanke, bevor es mit dem Erfassen von Daten beginnt. Mit dem Codeausschnitt oben wird das Gerät für die Suche nach einem Trigger bei steigender digitaler Flanke auf PFI 0 konfiguriert.

Erzeugen eines Triggers in C/C++

Sie können mit Hilfe der Funktion "DAQmxCfgDigEdgeStartTrig()" einen Start-Trigger bei einer digitalen Flanke erzeugen. Mehr Informationen zum Erzeugen von verschiedenen Triggern finden Sie in der Dokumentation zu NI-DAQ unter "NI-DAQmx C Reference Help". Nachstehend sehen Sie einen Codeausschnitt, der zeigt, wie die Funktion für einen digitalen Start-Trigger auf PFI0 verwendet wird, der auf der Leitung nach einer steigenden Flanke sucht.

char        startTrigger[256] = "Dev1/PFI0";
int         startEdge = 0; // steigende Flanke

DAQmxCreateTask("",&taskHandle));

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

DAQmxCfgDigEdgeStartTrig(taskHandle, startTrigger, startEdge);  

Das Dokument Timing and Synchronization Features of NI-DAQmx enthält zusätzliche Informationen zur Verwendung der NI-DAQmx-Trigger-Funktion zum Synchronisieren mit NI-DAQmx.

Beispiele zur Illustration:

Library»NI-DAQmx»Timing [CVI]

Task.Timing Property [.NET]







Mit der NI-DAQmx-Timing-Funktion wird das Timing für hardwaregetaktete Datenerfassungsoperationen konfiguriert. Unter anderem wird festgelegt, ob die Operation kontinuierlich oder endlich ist, die zu erfassende Sample-Anzahl wird festgelegt (oder die endlichen Operationen) und es werden Puffer erzeugt, falls notwendig.

Für Operationen, die ein Sample-Timing erfordern (analoge Eingabe, analoge Ausgabe und Zähler), legt die Sample-Takt-Instanz der NI-DAQmx-Timing-Funktion sowohl die Quelle des Sample-Takts fest (interne oder externe Quelle), als auch die Sample-Rate. Der Sample-Takt steuert die Rate, mit der Samples erfasst oder erzeugt werden. Jeder Takt-Impuls initiiert die Erfassung oder Erzeugung eines Samples für jeden virtuellen Kanal, der im Task enthalten ist.

Konfigurieren von Timing-Tasks in LabVIEW

Das folgende LabVIEW-Blockdiagramm zeigt die Verwendung der Sample-Takt-Instanz des VIs "NI-DAQmx - Timing" zum Konfigurieren einer kontinuierlichen analogen Ausgabe mit externem Sample-Takt.

Um Synchronisation in Datenerfassungsanwendungen zu erreichen, müssen Timing-Signale genau wie Trigger-Signale zwischen den verschiedenen funktionalen Bereichen eines Geräts bzw. zwischen mehreren Geräten geroutet werden. NI-DAQmx führt dieses Routing ebenfalls automatisch durch. Alle gültigen Timing-Signale sind als Eingangsquelle für das VI "NI-DAQmx - Timing" verfügbar. Beispielsweise ist im folgenden VI "DAQmx - Timing" die analoge Ausgabetaktrate des Geräts als Quelle für den Sample-Takt für die analogen Eingangskanäle verfügbar, ohne dass ein spezielles Routing durchgeführt werden muss.

Das Dokument Timing and Synchronization Features of NI-DAQmx enthält zusätzliche Informationen zur Verwendung der NI-DAQmx-Timing-Funktion zum Synchronisieren mit NI-DAQmx.

Die meisten Zähleroperationen erfordern keine Sample-Taktung, da das Timing durch das gemessene Signal bereitgestellt wird. Für solche Anwendungen sollte die Implizit-Instanz der Funktion "NI-DAQmx - Timing" verwendet werden. Im folgenden LabVIEW-Blockdiagramm wird die "Implizit"-Instanz des VIs "DAQmx - Timing" verwendet, um eine gepufferte Impulsbreitenmessung als endlich und mit einer festgelegten Sample-Anzahl zu konfigurieren.

Konfigurieren von Task-Timing in .NET

Verwenden Sie zum Bestimmen der Quelle des Sample-Takts, der Rate des Sample-Takts und der Anzahl der zu erfassenden oder erzeugenden Samples die Funktion "Channel.Timing.ConfigureSampleClock()". Mit dem folgenden Codeausschnitt wird eine kontinuierliche Erfassung basierend auf einem externen Sample-Takt erzeugt, der mit PFI 0 auf dem Gerät verbunden ist.

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

analogInTask.Timing.ConfigureSampleClock(

"/Dev1/PFI0", // externe Taktquellenleitung oder Verwenden von "" für internen Takt

10000, // erwartete Rate für externen Takt oder tatsächliche Rate des internen Takts

SampleClockActiveEdge.Rising, // an steigender oder fallender Flanke von Takteinheit (Tick) erfassen

SampleQuantityMode.ContinuousSamples, // kontinuierliche oder endliche Samples

1000 // Anzahl endlicher zu erfassender Samples oder wird für Puffergröße verwendet, wenn kontinuierlich

);

Konfigurieren von Task-Timing in C/C++

Verwenden Sie die Funktion "DAQmxCfgSampClkTiming" zum Konfigurieren von Task-Timing in C oder C++. Der folgende Codeausschnitt zeigt die Verwendung für eine interne Taktfrequenz von 10000 Hz.

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

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

Manche Datenerfassungsgeräte verwenden Handshaking als Taktgeber für digitale I/O-Operationen. Mit dem Handshaking werden zum Übertragen jedes Samples Taktsignale von einem externen Gerät einzeln angefordert und der Empfang wird bestätigt. Mit der Handshaking-Instanz der Funktion "NI-DAQmx - Timing" wird das Handshake-Timing für digitale I/O-Operationen konfiguriert.

Beispiele zur Illustration:

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

Task.Start Method [.NET]

Wie bereits in der Einführung erwähnt, eliminiert das von NI-DAQmx verwendete Zustandsmodell unnötige Neukonfigurationen, wodurch die Leitung maximiert wird und höhere Effizienz erreicht wird. Dieses Zustandsmodell besteht aus fünf Zuständen, in denen sich ein Task befinden kann. Detaillierte Informationen zu jedem dieser Zustände finden Sie in der Hilfe zu NI-DAQmx unter NI-DAQmx-Grundlagen»Kanäle und Tasks in NI-DAQmx»Tasks in NI-DAQmx»Modell der Task-Zustände.

Mit der Funktion "NI-DAQmx - Task starten" wird der Task in einen Betriebszustand versetzt. Während der Ausführung führt der Task die festgelegte Erfassung oder Erzeugung durch. Ein Task wird beim Ausführen der Funktion "NI-DAQmx - Lesen" implizit in den ausführenden Zustand übertragen und automatisch gestartet, selbst wenn die Funktion "NI-DAQ - Task starten" nicht verwendet wird. Dieser implizite Übergang findet auch dann statt, wenn die Funktion "NI-DAQmx - Task starten" nicht verwendet wird und die Funktion "NI-DAQmx - Schreiben" mit dem Eingang Autostart konfiguriert ist.

Obwohl nicht immer erforderlich, ist es dennoch besser, einen Task für eine hardwaregetaktete Erfassung oder Erzeugung explizit mit der Funktion "NI-DAQmx - Task starten" zu initiieren. Darüber hinaus sollte die Funktion "NI-DAQmx - Task starten" auch verwendet werden, wenn die Funktion "NI-DAQmx - Lesen" oder "NI-DAQmx - Schreiben" mehrmals ausgeführt wird, wie es in einer Schleife der Fall ist. Andernfalls wird die Task-Leistung durch wiederholtes Starten und Stoppen reduziert. Zusätzliche Informationen zur Verwendung der Funktion "NI-DAQmx - Task starten" finden Sie im Artikel When to Use the DAQmx Start Task and DAQmx Stop Task VIs.

Starten eines Tasks in LabVIEW

Das folgende LabVIEW-Blockdiagramm zeigt eine Situation, in der das VI "DAQmx - Task starten" nicht verwendet werden muss, weil die analoge Ausgabe nur aus einem einzelnen, softwaregetakteten Sample besteht.

Dagegen zeigt das folgende LabVIEW-Blockdiagramm eine Situation, in der das VI "DAQmx - Task starten" verwendet werden sollte, weil die das "DAQmx - Lesen" zum Auslesen aus dem Zähler mehrmals ausgeführt wird.

Starten eines Tasks in .NET

Verwenden Sie zum Starten eines Tasks die Funktion "Start()" im Task-Objekt. Der folgende Codeabschnitt zeigt die Verwendung der Funktion "Start()".

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

analogInTask.Timing.ConfigureSampleClock( ... );

analogInTask.Start();

Starten eines Tasks in C/C++

Verwenden Sie zum Starten eines Tasks die Funktion "DAQmxStartTask()" Nachfolgend sehen Sie den entsprechenden Codeausschnitt.

DAQmxStartTask(taskHandle);

Beispiele zur Illustration:

Library»NI-DAQmx»Read Functions [CVI]

ChannelReader Class [.NET]

Die Funktion " NI-DAQmx - Lesen" liest Samples aus dem angegebenen Erfassungs-Task aus. Die verschiedenen Instanzen der Funktion ermöglichen das Auswählen der Erfassungsart (analog, digital oder Zähler), der Anzahl virtueller Kanäle, der Sample-Anzahl und des Datentyps. Nachdem die angegebene Anzahl von Samples vom FIFO auf der DAQ-Karte an den PC-Puffer im RAM übertragen wurde, verschiebt die Funktion "NI-DAQmx - Lesen" Samples aus dem PC-Puffer in den Speicher der Entwicklungsumgebung (ADE).

Lesen von Daten in LabVIEW

Die folgende Abbildung zeigt vier Beispiele mit den verschiedenen Instanzen des VIs "DAQmx - Lesen".

Zu den Instanzen der Funktion "NI-DAQmx - Lesen", die in der Lage sind, mehrere Samples auszulesen, gehört ein Eingang zum Bestimmen der Anzahl der Samples pro Kanal, die beim Ausführen der Funktion gelesen werden sollen. Für endliche Erfassungen wird durch das Festlegen von "-1" im Eingang Anzahl Samples pro Kanal erreicht, dass die Funktion wartet, bis alle angeforderten Samples erfasst wurden und diese daraufhin ausliest. Das Festlegen von "-1" im Eingang Anzahl Samples pro Kanal bei einer kontinuierlichen Erfassung hat zum Resultat, dass die Funktion während der Ausführung alle der derzeit im Puffer verfügbaren Samples ausliest. Im folgenden LabVIEW-Blockdiagramm wurde das VI "DAQmx - Lesen" so konfiguriert, dass mehrere Samples aus verschiedenen analogen virtuellen Eingangskanälen ausgelesen werden und die Daten als Signalverläufe ausgegeben werden. Weiterhin liest das VI bei jeder Ausführung 10 Samples aus jedem virtuellen Kanal aus, da der Eingang Anzahl Samples pro Kanal mit der Konstante 10 verbunden wurde.

Lesen von Daten in .NET

Verwenden Sie die Lese- und Stream-Objekte, um mit der NI-DAQmx-.NET-Bibliothek Daten zu lesen.  Diese Programmierung ähnelt dem Muster, das im .NET Framework für die Datei- und Netzwerk-I/O verwendet wurde.

Die -Klasse besitzt mit der I/O verwandte Eigenschaften wie " " und Methoden für eine rohe I/O. Um eine Instanz der DaqStream-Klasse zu erhalten, die mit einem bestimmten übereinstimmt, verwenden Sie die Eigenschaft " ". Eine Instanz der DaqStream-Klasse kann nicht direkt erzeugt werden.

Um einen Lesevorgang in der NI-DAQ-Bibliothek durchzuführen, erzeugen Sie ein Exemplar eines lesenden Endpunkts und übergeben Sie ein Exemplar der DaqStream-Klasse an den Konstruktor. Rufen Sie dann eine Methode auf der Empfängerklasse zum Lesen der Daten auf, wie im folgenden Ausschnitt gezeigt:

analogInTask = new Task();

analogInTask.AIChannels.CreateVoltageChannel( ... );

//Erzeugt den Empfänger und fügt diesen dem Stream hinzu
AnalogSingleChannelReader reader = new AnalogSingleChannelReader(analogInTask.Stream);

//Führt das Auslesen durch
double[] data = reader.ReadMultiSample(100);

Lesen von Daten in C/C++
Lesen Sie mit Hilfe der Funktion "DAQmxReadAnalogF64()" analoge Daten aus einem analogen Eingangstask in C or C++ aus. Mehr zu Lesefunktionen finden Sie in der Hilfe "NI-DAQmx C Reference help". Es folgt ein Codeausschnitt, der zeigt, wie 1000 Samples aus einem einzelnen Kanal ausgelesen werden.

int numRead = 0;

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

Beispiele zur Illustration:

Library»NI-DAQmx»Write Functions [CVI]

ChannelWriter Class [.NET]

Die Funktion " NI-DAQmx - Schreiben" sendet Samples an den angegebenen Task zur Erzeugung. Die verschiedenen Instanzen der Funktion ermöglichen das Auswählen der Erzeugungsart (analog, digital), der Anzahl virtueller Kanäle, der Sample-Anzahl und des Datentyps. Die Funktion "NI-DAQmx - Schreiben" verschiebt Samples aus dem Speicher der Entwicklungsumgebung in den PC-Puffer im RAM. Diese Samples werden dann zur Erzeugung vom PC-Puffer an den FIFO auf der DAQ-Karte übertragen. 

Jede Instanz der Funktion "NI-DAQmx - Schreiben" hat einen Autostart-Eingang, an dem festgelegt wird, ob die Funktion den Task startet, wenn dieser nicht schon manuell gestartet wurde. Wie schon zuvor im Abschnitt "DAQmx - Task starten" erwähnt, sollte die Funktion zum Startes des Tasks nur verwendet werden, um einen hardwaregetakteten Task zur Erzeugung zu starten. Die Funktion dient darüber hinaus zur Leistungsmaximierung, wenn die Funktion "NI-DAQmx - Schreiben" mehrmals ausgeführt werden soll.

Schreiben von Daten in LabVIEW

Die folgende Abbildung zeigt vier Beispiele mit den verschiedenen Instanzen des VIs "DAQmx - Schreiben".

Das folgende LabVIEW-Blockdiagramm enthält zur Erzeugung einer endlichen analogen Ausgabe eine boolesche "False"-Konstante, die mit dem Autostart-Eingang des VIs "DAQmx - Schreiben" verbunden ist, da es sich um eine hardwaregetaktete Erzeugung handelt. Das VI "DAQmx - Schreiben" wurde zum Schreiben von mehreren Samples analoger Ausgangsdaten eines Kanals an den Task in Form eines analogen Signalverlaufs konfiguriert.

Schreiben von Daten in .NET

Verwenden Sie die Schreiben- und Stream-Objekte, um mit der NI-DAQmx-.NET-Bibliothek Daten zu schreiben.  Dieser Prozess funktioniert ähnlich wie das zuvor behandelte Lesen von Daten.

Erzeugen Sie für einen Schreibvorgang ein Exemplar eines schreibenden Empfangsendpunkts  und übertragen Sie ein Exemplar der Klasse DaqStream an den Konstruktor. Rufen Sie dann eine Methode auf der "Schreiben"-Klasse zum Schreiben der Daten auf, wie im folgenden Codeausschnitt gezeigt:

analogOutTask = new Task();

analogOutTask.AOChannels.CreateVoltageChannel( ... );

//Erzeugt den schreibenden Endpunkt und fügt diesen dem Stream hinzu
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogOutTask.Stream);

//Führt Schreibvorgang durch
double[] data = writer.WriteMultiSample(100);

Schreiben von Daten in C/C++
Verwenden Sie zum Schreiben von analogen Daten die Funktion "DAQmxWriteAnalogF64()". Mehr Informationen zum Schreiben anderer Datenformen finden Sie in der "NI-DAQmx C Reference Help". Nachfolgend sehen Sie einen Codeausschnitt für das Schreiben von 1000 Samples analoger Daten.

int written = 0;

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

Beispiele zur Illustration:

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

Task.WaitUntilDone Method [.NET]

Die Funktion "NI-DAQmx - Warten bis beendet" wartet, bis der Datenerfassungsvorgang abgeschlossen ist, bevor die Funktion beendet wird. Die Funktion dient dazu, sicherzustellen, dass die angegebene Erfassung oder Erzeugung abgeschlossen ist, bevor der Task beendet wird. Meistens wird die Funktion "NI-DAQmx - Warten bis beendet" bei endlichen Operationen verwendet. Wenn die Funktion die Ausführung beendet hat, ist die endliche Erfassung oder Erzeugung abgeschlossen und der Task kann gestoppt werden, ohne die Operation zu stören. Zusätzlich ermöglicht der Eingang Timeout das Festlegen einer maximalen Wartezeit. Wenn die Erfassung oder Erzeugung nicht innerhalb dieses Zeitrahmens abgeschlossen ist, wird die Funktion abgebrochen und ein entsprechender Fehler ausgegeben.

"DAQmx - Warten bis beendet" in LabVIEW

Das VI "DAQmx - Warten bis beendet" wird im folgenden LabVIEW-Blockdiagramm verwendet um zu verifizieren, dass die endliche digitale Ausgabeoperation vor dem Löschen des Tasks beendet ist.

"Warten bis beendet" in .NET

Mehr Informationen zur Verwendung dieser Funktion in .NET finden Sie im Beispiel "GenMultVoltUpdates_IntClk".

"Warten bis beendet" in C/C++

Die Funktion DAQmxWaitUntilTaskDone() wird verwendet, um zu warten, bis alle Samples im Puffer erzeugt worden sind. Rufen Sie die Funktion nach einer "Schreiben"- oder "Start"-Funktion auf.

Beispiele zur Illustration:

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

Task.Dispose Method [.NET]

Für kontinuierliche Operationen sollte die Funktion "NI-DAQmx - Task löschen" verwendet werden, um die Erfassung oder Erzeugung zu stoppen.

Zurücksetzen eines Tasks in LabVIEW

Im folgenden LabVIEW-Blockdiagram wird mit einem Zähler eine kontinuierliche Impulsfolge erzeugt. Die Impulsfolge wird fortlaufend ausgegeben, bis die While-Schleife beendet wird und das VI "DAQmx - Task löschen" ausgeführt wird.

Zurücksetzen eines Tasks in .NET

Nachdem ein Task den Lese- oder Schreibvorgang beendet hat, können Sie einfach die "Task.Dispose"-Methode aufrufen.

Zurücksetzen eines Tasks in C/C++

Wenn ein Task den Lese- oder Schreibvorgang beendet hat, können Sie die Funktion "DAQmxClearTask()" verwenden.

Beispiele zur Illustration:

Attribut [CVI]

Eigenschaft [.NET]

NI-DAQmx-Eigenschaften bieten Zugriff auf alle Eigenschaften, die mit einer Datenerfassungsoperation assoziiert sind. Diese Eigenschaften können durch das Schreiben in die NI-DAQmx-Eigenschaften festgelegt werden, und der aktuelle Wert der Eigenschaften kann aus den NI-DAQmx-Eigenschaften ausgelesen werden.

Viele Eigenschaften können unter Verwendung der zuvor erwähnten NI-DAQmx-Funktionen festgelegt werden. Die Eigenschaften Sample-Takt:Quelle und Sample-Takt:Aktive Flanke können beispielsweise mit Hilfe der Funktion "NI-DAQmx - Timing" festgelegt werden. Auf einige der weniger häufig verwendeten Eigenschaften kann jedoch nur über NI-DAQmx-Eigenschaften zugegriffen werden.

Verwenden von Eigenschaften in LabVIEW (Eigenschaftsknoten)

Ein NI-DAQmx-Eigenschaftsknoten in LabVIEW kann für das Lesen aus und/oder Schreiben in mehrere(n) Eigenschaften verwendet werden. Beispielsweise wird mit dem folgenden LabVIEW-Eigenschaftsknoten "DAQmx - Timing" die Quelle des Sample-Takts festgelegt. Danach wird die Quelle des Sample-Takts ausgelesen. Zuletzt wird die aktive Flanke des Sample-Takts festgelegt.

Im folgenden LabVIEW-Blockdiagramm wird mit dem Eigenschaftsknoten "DAQmx - Kanal" ein Hardware-Tiefpassfilter aktiviert und dann die Filter-Grenzfrequenz für eine Messung mit Dehnungsmesser festgelegt.

Verwenden von Eigenschaften in .NET

Wie schon oben im Abschnitt zum Timing erwähnt, werden viele Eigenschaften von Unterklassen aus und basierend auf Task-Objekt-Sammlungen festgelegt. Eine häufige Verwendung einer Eigenschaft in NI-DAQmx ist im folgenden Ausschnitt zu sehen:

//Erzeugt neuen NI-DAQmx-Task
Task t = new Task();

//Greift auf Eigenschaften des Unterobjekts der Task-Klasse zu
t.Timing.SamplesPerChannel = 1000;

Verwenden von Eigenschaften in C/C++

Die Eigenschaften für einen Task können für jede Eigenschaften mit individuellen Funktionen abgerufen und festgelegt werden. Weitere Informationen finden Sie in der Liste zu Eigenschaften und deren Funktionen in der Hilfe, "NI-DAQmx C Reference Help", unter "NI-DAQmx C Properties".

Beispiele zur Illustration:

Mit NI-DAQmx wird Zeit bei der Entwicklung eingespart und die Leistung von Anwendungen zur Datenerfassung verbessert. Eine der vielen Arten, auf die NI-DAQmx Entwicklungszeit spart, ist über eine API, mit der mit nur einer kleinen Anzahl an Funktionen ein Großteil der Funktionalität bereitgestellt wird. Tatsächlich können mit den 10 in diesem Dokument vorgestellten Funktionen 80 % aller Anforderungen an Datenerfassungsanwendungen abgedeckt werden.

• Erste Schritte mit NI-DAQmx