Verwendung von LabWindows/CVI-DLLs in LabVIEW-Real-Time-Anwendungen

LabWindows/CVI erweitert die Funktionalität von LabVIEW Real-Time um die Möglichkeit, ANSI-C-Code auf LabVIEW-Real-Time-Zielgeräten (RT, Real-Time) einsetzen zu können. In diesem Dokument werden die Einzelheiten und Vorteile von LabWindows/CVI für die Integration von ANSI-C-Code in LabVIEW-RT-Anwendungen erläutert.

Es ist für LabVIEW-Entwickler bestimmt, die C- oder LabWindows/CVI-DLLs in ihre Projekte einbinden wollen.

Hinweis: Wenn Sie mit LabWindows/CVI entwickeln, können Sie das LabWindows/CVI Real-Time Module nutzen, um eine DLL auf ein RT-Zielgerät herunterzuladen. Mehr dazu erfahren Sie unter Programmer Reference» Creating and Downloading DLLs to Real-Time Targets in der Hilfe LabWindows/CVI Help. Dort steht Ihnen auch eine Schritt-für-Schritt-Anleitung für den Einsatz von LabWindows/CVI- und RT-Zielgeräten zur Verfügung. Wählen Sie Help» Contents, um zu LabWindows/CVI Help zu gelangen.

Vorteile der Verwendung von LabWindows/CVI-DLLs in LabVIEW Real-Time

LabWindows/CVI kann Programmcode in eine für LabVIEW Real-Time kompatible DLL kompilieren, die von der LabVIEW-Real-Time-Umgebung aufgerufen und ausgeführt werden kann. Diese Eigenschaft verringert die Entwicklungszeit für Echtzeitanwendungen folgendermaßen:

• Ein Großteil des vorhandenen ANSI-C-Codes kann wieder verwendet werden, wodurch sich die Entwicklungszeit für LabVIEW-Real-Time-Anwendungen stark verringert.
• Teile der LabVIEW-Real-Time-Anwendung können in ANSI C entwickelt werden.
• In der LabWindows/CVI-Entwicklungsumgebung können Anwender LabVIEW-Real-Time-VISA-Treiber für PXI/CompactPCI-Hardware von Drittanbietern erstellen. Daher können sie diese Hardware in LabVIEW-Real-Time-Anwendungen integrieren. Weitere Informationen zu diesem Thema sind im Abschnitt Weiterführende Links zu finden.

Architektur von LabWindows/CVI-DLLs zur Ausführung auf LabVIEW Real-Time

Werden LabWindows/CVI-DLLs auf LabVIEW Real-Time eingesetzt, muss die Architektur der LabWindows/CVI-DLL sorgfältig entwickelt werden, um Determinismus und Zuverlässigkeit sicherzustellen. Komplette Programme sollten nicht in LabWindows/CVI erstellt und die gesamte Anwendung dann einfach mittels einer DLL auf LabVIEW Real-Time übertragen werden. Stattdessen sollten DLLs modular in LabVIEW Real-Time verwendet werden. Der Einsatz einer auf C basierenden Bibliothek in LabVIEW Real-Time ist beispielsweise eine solche Aufgabe. Implementierungen von Gerätetreibern und Hardwaretreibern von Drittherstellern sind ebenfalls modulare Komponenten, die für Determinismus und Zuverlässigkeit bei LabVIEW Real-Time sorgen.

Weiterführende Links (engl.):
Übertragung eines PCI-Gerätetreibers von Windows auf LabVIEW Real-Time

LabVIEW Real-Time im Überblick

Es ist schwierig, sehr zuverlässige und deterministische (Abschluss einer Operation innerhalb einer festgelegten Zeit) Anwendungen mithilfe universeller Betriebssysteme wie Microsoft Windows und Mac OS zu implementieren. Solche Applikationen erfordern eine umfassendere Kontrolle über alle auf dem System laufenden Operationen. Ein solches Kontrollniveau können universelle Betriebssysteme gewöhnlich nicht bieten. Daher setzen Ingenieure aus den Bereichen Test und Automatisierung häufig Echtzeitbetriebssysteme ein, um Anwendungen zu implementieren, die deterministische Leistung oder hohe Zuverlässigkeit erfordern.

Die präemptive Architektur echtzeitfähiger Betriebssysteme stellt eine Plattform für deterministische Abarbeitung bereit. Diese Architektur sorgt dafür, dass kritische Prozesse Zeit auf dem Prozessor zugewiesen bekommen, wann immer sie sie benötigen. Überdies gewährleistet die zusätzliche Kontrolle über alle Prozesse auf dem System einen höheren Grad an Zuverlässigkeit als bei universellen Betriebssystemen. Mithilfe eines echtzeitfähigen Betriebssystems wird die Ausführung kritischer Test- oder Steuerprozesse von den Operationen der Benutzeroberfläche getrennt. So wird sichergestellt, dass ein Absturz des Host-Systems der Benutzeroberfläche die Ausführung des kritischen Echtzeitsystems nicht beeinflusst.

Das LabVIEW Real-Time Module ermöglicht den Einsatz der bedienfreundlichen grafischen Programmierumgebung LabVIEW zur Erstellung zuverlässiger, deterministischer Prüf-, Steuer- und Regelsysteme. Mit LabVIEW und dem LabVIEW Real-Time Module wird Programmcode auf einem Host-Rechner entwickelt und anschließend zur eingebetteten Ausführung auf ein echtzeitfähiges Hardwarezielgerät heruntergeladen. LabVIEW-Real-Time-Applikationen können auf Geräten wie etwa Embedded-PXI-Controller, vernetzten Compact-FieldPoint-Modulen und kompakten Bildverarbeitungssystemen ausgeführt werden. Neben einer Entwicklungsumgebung stellt der Host-Rechner auch die Benutzerschnittstelle für laufende Systeme bereit.

 Mit LabVIEW Real-Time kompatible LabWindows/CVI-Funktionen

Hardware für LabVIEW Real-Time beinhaltet ein echtzeitfähiges Embedded-Betriebssystem. Wie bereits im Abschnitt LabVIEW Real-Time im Überblick erwähnt, unterscheidet sich das echtzeitfähige Betriebssystem von herkömmlichen Betriebssystemen wie etwa Windows und bietet eine etwas andere Palette von Funktionen. Wird eine DLL in LabWindows/CVI erstellt, kann festgelegt werden, dass sie mit LabVIEW Real-Time kompatibel sein soll. Dann enthält LabWindows/CVI nur die integrierten LabWindows/CVI-Bibliotheksfunktionen, die mit dem Echtzeitbetriebssystem kompatibel sind.

Funktionen der folgenden LabWindows/CVI-Bibliotheken sind mit der LabVIEW Real-Time Support Engine kompatibel:

• Analyse- oder erweiterte Analysebibliothek
• ANSI C
• Formatierung und I/O
• TCP Support Library 
• Utility Library 

Neben den aufgeführten Bibliotheken können auch die folgenden eingebunden werden:

• VISA Library
• NI-CAN Library
• NI-DAQmx Library
• NI-DMM
• NI-Scope
• NI-FGEN
• NI-Switch
• NI-HSDIO
• Die meisten Bibliotheken in der instrsup.dll

Hinweis: Nicht alle Funktionen in den genannten Bibliotheken sind kompatibel. Eine vollständige Liste dieser exportierten Funktionen ist unter dem Pfad Programmer Reference» Creating and Downloading DLLs to Real-Time Targets» Using LabWindows/CVI Libraries in Real-Time DLLs in der Hilfe von LabWindows/CVI zu finden.

TCP Support Library

Ab LabWindows/CVI 7.0 ist eine Unterstützung für TCP-Funktion für die Anwendungsentwicklung in LabVIEW Real-Time enthalten. Deshalb können DLLs auf Echtzeitzielgeräten Daten direkt mit Knoten im Netzwerk austauschen. Der Anwender muss nicht mehr zum LabVIEW-Code zurück, um Daten an einen anderen Knoten zu übergeben. TCP-Funktionsaufrufe, wie etwa die Schreib- und Lesefunktionen, stoßen Ereignisse an, wenn sie zurückkommen. In älteren Versionen von LabWindows/CVI wurden diese Ereignisse mithilfe einer Messaging-Funktion erfasst, die bei Echtzeitbetriebssystemen nicht zur Verfügung steht. Die Funktion ProcessTCPEvents der TCP Support Library nutzt Polling zur Erfassung von TCP-Ereignissen, was bei Echtzeitbetriebssystemen unterstützt wird.

Diese Funktion eignet sich für Anwendungen, die Daten so zur Verfügung stellen müssen, wie sie eingingen. Es ist beispielsweise eine DLL vorhanden, die eine Funktion mit mehreren Schleifen zur Datenerfassung enthält. Der Anwender möchte die Daten veröffentlichen, während er sie erfasst. Da DLLs Daten nur an die aufrufende Anwendung schicken, wenn die Funktion deren Ausführung beendet hat, müsste es möglich sein, die Daten aus der DLL zu verschicken. Ohne die TCP-Abfragefunktionen könnten die Daten, so wie sie empfangen wurden, nur über das Netzwerk verschickt werden, wenn eine Schleife in LabVIEW implementiert und eine Funktion in der LabWindows/CVI-DLL aufgerufen würde, die Daten nur einmal erfasst. Mit dieser Methode würde die Funktion bei jedem Erfassen von Daten zurückkehren und die Daten würden wieder an die LabVIEW-Real-Time-Anwendung übergeben. Wenn die Daten dann wieder in LabVIEW angekommen sind, könnten die TCP-Funktionen in LabVIEW zu ihrer Veröffentlichung eingesetzt werden. Dazu wäre es erforderlich, die DLL immer dann aufzurufen, zu laden und zu entfernen, wenn die LabVIEW-Schleife ausgeführt wird. Das würde sich stark auf die Leistung auswirken. Mithilfe der zusätzlichen Funktionalität der Funktionsaufrufe der TCP Support Library in LabWindows/CVI können die Daten aus der DLL in jeder Schleife verschickt werden. Die DLL muss nur einmal aufgerufen werden, wodurch Zeit und Speicher gespart werden.

Fehlerbehebung von LabWindows/CVI-DLLs auf LabVIEW-Real-Time-Zielgeräten

Mit LabWindows/CVI 7.1 wurde die dezentrale Fehlerbehebung eingeführt, womit DLLs auf Fehler untersucht werden können, während sie auf Echtzeitzielgeräten ausgeführt werden. Das Fehlersuchprogramm, das sich auf dem lokalen Rechner befindet, und das zu untersuchende Programm auf dem Zielrechner kommunizieren über eine TCP/IP-Verbindung.

Ohne diese Möglichkeit müsste die Fehlerbehandlung von DLLs, die für den Einsatz auf LabVIEW-Real-Time-Zielgeräten vorgesehen sind, auf dem Host-Rechner erfolgen. Zwar können auf diese Weise viele Fehler erkannt und behoben werden, doch gibt es keine Garantie, dass die DLL funktionieren wird, wenn sie auf Echtzeitzielgeräte übertragen wird. Grund dafür sind die bestehenden Unterschiede zwischen den Windows- und den Echtzeitbetriebssystemen. Bei der dezentralen Fehlerbehebung kann der Anwender alle dafür vorgesehenen Werkzeuge auf dem Host-Rechner verwenden, wie beispielsweise die Möglichkeit, reguläre und bedingte Haltepunkte zu setzen, die nächste auszuführende Anweisung festzulegen und den Wert von Variablen anzusehen und zu ändern, um die korrekte Funktionsweise der DLL auf LabVIEW-Real-Time-Zielgeräten sicherzustellen.

LabWindows/CVI-Host-Anwendungen für LabVIEW-Real-Time-Zielgeräte

Mithilfe von LabWindows/CVI können Host-Applikationen für LabVIEW-Real-Time-Zielgeräte erstellt werden. Dabei können LabWindows/CVI-Anwendungen eingesetzt werden, um mit diesen Zielgeräten zu kommunizieren und sie zu steuern. Ein Beispiel aus der Praxis ist ein Echtzeitzielgerät, das Daten erfasst und sie an eine Host-LabWindows/CVI-Applikation schickt, die dann diese Daten anzeigt. Am häufigsten wird mittels TCP und UDP zwischen Host-Anwendung und dem Echtzeitzielgerät kommuniziert.

Hinweis: Wenn TCP genutzt wird, muss beachtet werden, dass LabVIEW die Big-Endian-Notation verwendet. Wenn das Programm, an das die Daten geschickt werden, die Little-Endian-Notation verwendet, müssen die Daten vor der Darstellung konvertiert werden. Die Daten können in LabVIEW mithilfe der Funktionen „Swap Bytes“ und „Swap Words“ konvertiert werden.

Anwendungsbeispiel: Erstellung von LabVIEW-Real-Time-DLLs in LabWindows/CVI

Ziel: Umwandlung eines vorhandenen LabWindows/CVI-Programms in eine DLL, die von LabVIEW-Real-Time-Zielgeräten verwendet werden kann

Softwarevoraussetzungen

• LabWindows/CVI 7.0 oder höher
• Calc.zip-Datei (Diese Datei steht im Beispiel „LabWindows/CVI Standard I/O Calculator“ auf der NI Developer Zone zur Verfügung. Ein Link zu diesem Beispielprogramm steht am Ende dieses Abschnitts.)

Anleitung

1. Öffnen Sie simpCalc.prj.
2. Öffnen Sie simpCalc.c. Drücken Sie die Taste <F2>, um zum ersten Tag zu gelangen. Die vier Funktionen, die in die DLL zu exportieren sind, sind hier als Prototyp vorhanden. Drücken Sie <F2> erneut, um zu dem Codeabschnitt zu gelangen, in dem jede Funktion definiert wird.
3. Kompilieren und starten Sie das Projekt. Das Programm übernimmt zwei numerische Eingaben, führt die vom Anwender festgelegte Operation aus und gibt das Ergebnis aus.
4. Konfigurieren Sie das Projekt, um eine DLL zu erzeugen, indem Sie sie als Zieltyp für das Projekt festlegen. Wählen Sie Build» Target Type» Dynamic Link Library (siehe Abbildung 1).

[+] Bild vergrößern

Abb. 1: Festlegung des Zieltyps

5. Um das Erstellen der Release-Version der DLL festzulegen, wählen Sie Build» Configuration» Release.
6. LabWindows/CVI erstellt eine DLL, die nur die vom Anwender festgelegten Funktionen exportiert. Um eine Funktion in die DLL exportieren zu können, müssen Sie den entsprechenden Prototypen in eine Header-Datei einfügen. Wählen Sie zur Erstellung einer Header-Datei File» New» Include (*.h).
7. Erstellen Sie in der neuen Header-Datei Prototypen der vier Funktionen, die dann von der DLL exportiert werden. Sie können die Prototypen aus simpCalc.c einfügen.
8. Speichern Sie die Header-Datei als simpCalc.h und fügen Sie die Datei dem Projekt hinzu. Der Code in der Header-Datei sollte dem Code in Abbildung 2 entsprechen.

[+] Bild vergrößern

Abb. 2: simpCalc-Header-Datei

9. Als nächstes konfigurieren Sie die Zieleinstellungen für die zu erstellende DLL. Öffnen Sie über den Pfad Build» Target Settings das Dialogfeld „Target Settings“.
10. Legen Sie die Bezeichnung und den Speicherort der DLL mit der Option DLL file in diesem Dialogfeld fest. Standardmäßig legt LabWindows/CVI die Bezeichnung der DLL entsprechend des aktuellen Projekts fest, in diesem Beispiel simpCalc.dll.
11. Wählen Sie bei der Option Run-time support die MöglichkeitReal-time only aus. Wenn Sie Real-time only wählen, verknüpft LabWindows/CVI mit einem kleineren Satz von in LabWindows/CVI integrierten Bibliotheksfunktionen, die in Echtzeitanwendungen unterstützt werden.
12. Klicken Sie zum Öffnen des Dialogfelds „DLL Export Options“ auf die Schaltfläche Change. Wählen Sie die Header-Datei simpCalc.h aus, um sicherzustellen, dass nur die in der Header-Datei prototypisierten Funktionen aus der DLL exportiert werden. Das Dialogfeld „Target Settings“ sollte dann wie folgt aussehen:

[+] Bild vergrößernAbb. 3: Dialogfeld „Target Settings“

9. Bestätigen Sie das Dialogfeld mit OK.
10. Wählen Sie zur Erstellung der DLL den Pfad Build» Create Release Dynamic Link Library aus.
11. LabWindows/CVI erstellt die DLL-Dateien und zeigt eine Nachricht an, welche die erstellten Dateien aufführt. Jetzt kann die LabWindows/CVI-DLL aus einer LabVIEW-Real-Time-Anwendung aufgerufen werden.

Weiterführende Links:

Standard I/O Calculator in LabWindows/CVI

Anwendungsbeispiel: Aufruf einer LabWindows/CVI-DLL aus einer LabVIEW-Anwendung

Ziel: Aufruf einer in LabWindows/CVI erstellten DLL aus einer LabVIEW-Anwendung

Softwarevoraussetzungen

• LabVIEW
• simpCalc.dll-Datei (aus der vorhergehenden Übung)

Anleitung

1. Öffnen Sie LabVIEW.
2. In der LabVIEW-Hilfe finden Sie Hinweise zur Erstellung eines Echtzeitprojekts.
3. Wählen Sie File» New VI aus, um ein neues VI (virtuelles Instrument) zu erstellen.
4. Platzieren Sie zwei numerische Bedienelemente und ein numerisches Anzeigeelement auf das Frontpanel. Beschriften Sie die Bedienelemente mit X und Y und das Anzeigeelement mit Result.
5. Rufen Sie die in der vorherigen Übung erstellten LabWindows/CVI-DLL auf. Platzieren Sie den Knoten „Call Library Function“ auf dem Blockdiagramm. Der Knotenpunkt „Call Library Function“ befindet sich in der Unterpalette Connectivity» Libraries & Executables.
6. Führen Sie einen Doppelklick auf den Knoten „Call Library Function“ aus. Klicken Sie im Dialogfeld „Call Library Function“ auf die Schaltfläche Browse, um eine DLL festzulegen. Wählen Sie die Datei simpCalc.dll, die Sie in der vorherigen Übung erstellt haben.
7. Wählen Sie eine der vier Funktionen aus dem simpCalc-Projekt im Bedienelement Function Name.
   
   Hinweis: Es stehen nur die Funktionen zur Verfügung, die in der Header-Datei prototypisiert wurden.
8. Bestimmen Sie die Argumenttypen für den Rückgabewert und die Parameter. Das simpCalc-Programm übernimmt zwei Doubles als Parameter und gibt ein Double zurück. Die entsprechende Variable in LabVIEW ist der numerische 8-byte-Fließkommatyp. Legen Sie für den ersten Parameter, return type, Numeric als Type und 8-byte Double als Data Type fest.
9. Um die Argumenttypen für die Parameter zu bestimmen, die an die Funktion übergeben werden, klicken Sie auf Add a Parameter After. Bestimmen Sie arg1 als einen numerischen 8-byte-Fließkommatyp. Wiederholen Sie diesen Vorgang für arg2.
10. Um die Funktionen in LabVIEW Real-Time hinlänglich zu nutzen, können Sie festlegen, dass die Funktion ablaufinvariant sein soll. Wenn eine Funktion ablaufinvariant ist, können mehrere Threads diese in der DLL gleichzeitig aufrufen. Wählen Sie im Drop-down-Feld Run in UI Thread die Möglichkeit Reentrant aus. Der Knoten „Call Library Function“ auf dem Frontpanel wechselt die Farbe und wird gelb, um anzuzeigen, dass die Funktion ablaufinvariant ist.
11. Das Dialogfeld „Call Library Function“ sollte dann wie folgt aussehen:

[+] Bild vergrößern

Abb. 4: Dialogfeld „Call Library Function“

12. Bestätigen Sie das Dialogfeld mit OK und kehren Sie zum Blockdiagrammfenster zurück.
13. „Call Library Function“ gibt jetzt die Parameter wieder, die Sie festgelegt haben. Der Knotenpunkt „Call Library Function“ hat zwei Eingangs- und drei Ausgangsanschlüsse. Der obere rechte Anschluss gibt das Ergebnis aus. Die beiden anderen Ausgänge sind die zwei übergebenen Eingänge. Verdrahten Sie X mit dem oberen und Y mit dem unteren Eingang. Verdrahten Sie den oberen Ausgangsanschluss mit dem Anzeigeelement Result.
14. Speichern Sie das Programm als DllCaller.vi. Anschließend sollte das Blockdiagramm wie folgt aussehen:

Abb. 5: Blockdiagramm DllCaller.vi

15. Jetzt können Sie das Programm testen. Wechseln Sie zum Frontpanel und geben Sie Werte für die X- und Y-Eingänge ein. Klicken Sie nun auf die Schaltfläche Run. Das numerische Anzeigeelement zeigt das entsprechende Ergebnis.

Anwendungsbeispiel: Erstellung einer Debug-Version einer LabVIEW-Real-Time-DLL in LabWindows/CVI

Ziel: Umwandlung eines vorhandenen LabWindows/CVI-Programms in die Debug-Version einer DLL, die auf einem LabVIEW-Real-Time-Zielgerät aufgerufen und auf Fehler behandelt werden kann

Softwarevoraussetzungen

• LabWindows/CVI 7.1 oder höher
• Calc.zip-Datei (Diese Datei steht im Beispiel „LabWindows/CVI Standard I/O Calculator“ auf der NI Developer Zone zur Verfügung. Ein Link zu diesem Beispielprogramm steht am Ende dieses Abschnitts.)

Anleitung

1. Öffnen Sie DebCalc.prj.
2. Konfigurieren Sie das Projekt, um eine DLL zu erzeugen, indem Sie sie als Zieltyp für das Projekt festlegen. Wählen Sie den Pfad Build» Target Type» Dynamic Link Library aus.
3. Um zu bestimmen, dass die DLL auf Fehler untersucht werden kann, wählen Sie Build» Configuration» Debug.
4. LabWindows/CVI erstellt eine DLL, die nur die vom Anwender festgelegten Funktionen exportiert. Um eine Funktion in die DLL exportieren zu können, müssen Sie den entsprechenden Prototypen in eine Header-Datei einfügen. Wählen Sie zur Erstellung einer Header-Datei File» New» Include (*.h).
5. Erstellen Sie in der neuen Header-Datei Prototypen der vier Funktionen, die dann von der DLL exportiert werden. Sie können die Prototypen aus DebCalc.c einfügen.
6. Speichern Sie die Header-Datei als DebCalc.h und fügen Sie die Datei dem Projekt hinzu. Der Code in der Header-Datei sollte dem Code in Abbildung 6 entsprechen.

Abb. 6: DebCalc-Header-Datei

7. Konfigurieren Sie die Zieleinstellungen für die zu erstellende DLL. Öffnen Sie über den Pfad Build» Target Settings das Dialogfeld „Target Settings“.
8. Legen Sie die Bezeichnung und den Speicherort der DLL mit der Option DLL file in diesem Dialogfeld fest. Für dieses Beispiel wird die erzeugte DLL DebCalc.dll genannt. 
9. Wählen Sie bei der Option Run-time support die MöglichkeitReal-time only aus. Wenn Sie Real-time only wählen, verweist LabWindows/CVI auf eine kleineren Satz von in LabWindows/CVI integrierten Bibliotheksfunktionen, die in Echtzeitanwendungen unterstützt werden.
10. Klicken Sie zum Öffnen des Dialogfelds „DLL Export Options“ auf die Schaltfläche Change. Wählen Sie die Header-Datei simpCalc.h aus, um sicherzustellen, dass nur die in der Header-Datei prototypisierten Funktionen aus der DLL exportiert werden. Das Dialogfeld „Target Settings“ sollte dann wie folgt aussehen:

[+] Bild vergrößern
Abb. 7: Dialogfeld „Target Settings“

11. Bestätigen Sie das Dialogfeld mit OK.
12. Wählen Sie den Pfad Run» Switch Execution Targets aus, um sich eine Liste verfügbarer Echtzeitzielsysteme anzeigen zu lassen. Wählen Sie ein Echtzeitzielsystem aus der Liste aus. Wählen Sie Select Target with Options, um ein neues Echtzeitzielsystem zu konfigurieren.
13. Wählen Sie im Dialogfeld „Select Target with Options“ New RT Target via LabVIEW on the Network aus dem Ring-Bedienelement im oberen Bereich des Dialogfelds aus.
14. Geben Sie den Gerätenamen oder die IP-Adresse des Echtzeitzielgeräts in der Option Machine Name/IP ein. Geben Sie den Netzwerkanschluss für die Kommunikation zwischen LabWindows/CVI und dem Echtzeitzielgerät in die Option Port ein. Wählen Sie OK, um das Dialogfeld zu verlassen.
15. Wählen Sie zur Erstellung der DLL den Pfad Build» Debuggable Release Dynamic Link Library aus.
16. LabWindows/CVI erstellt die DLL-Dateien und zeigt eine Nachricht an, welche die erstellten Dateien aufführt. Jetzt kann die Debug-Version der LabWindows/CVI-DLL aus einer LabVIEW-Real-Time-Anwendung aufgerufen werden.

Weiterführende Links (engl.):
Standard I/O Calculator in LabWindows/CVI

Anwendungsbeispiel: Fehlerbehebung von LabWindows/CVI-DLLs auf LabVIEW-Real-Time-Zielgeräten

Ziel: Kennenlernen der Hilfsprogramme in LabWindows/CVI zur dezentralen Fehlerbehebung und Beseitigung von Fehlern in einer DLL, die auf einem LabVIEW-Real-Time-Zielgerät läuft

Softwarevoraussetzungen

LabWindows/CVI 7.1 oder höher

LabVIEW Real-Time

DebCalc.dll (aus der vorhergehenden Übung)

Calc.zip-Datei (Diese Datei steht im Beispiel „LabWindows/CVI Standard I/O Calculator“ auf der NI Developer Zone zur Verfügung. Ein Link zu diesem Beispielprogramm steht am Ende dieses Abschnitts.)

Anleitung

1. Öffnen Sie LabVIEW.
2. In der LabVIEW-Hilfe finden Sie Hinweise zur Erstellung eines Echtzeitprojekts.
3. Wählen Sie File» New VI aus, um ein neues VI zu erstellen.
4. Platzieren Sie zwei numerische Bedienelemente und ein numerisches Anzeigeelement auf das Frontpanel. Beschriften Sie die Bedienelemente mit X und Y und das Anzeigeelement mit Result.
5. Rufen Sie die LabWindows/CVI-DLL auf, die Sie in der vorherigen Übung erstellt haben, indem Sie einen Knoten „Call Library Function“ auf dem Blockdiagramm platzieren. Der Knotenpunkt „Call Library Function“ befindet sich in der Unterpalette Connectivity» Libraries & Executables.
6. Führen Sie einen Doppelklick auf den Knoten „Call Library Function“ aus. Klicken Sie im Dialogfeld „Call Library Function“ auf die Schaltfläche Browse, um eine DLL festzulegen. Wählen Sie die Datei DebCalc.dll, die Sie in der vorherigen Übung erstellt haben.
7. Wählen Sie eine der vier Funktionen aus dem DebCalc-Projekt im Bedienelement Function Name.
   
   Hinweis: Es stehen nur die Funktionen zur Verfügung, die in der Header-Datei prototypisiert wurden.
8. Bestimmen Sie die Argumenttypen für den Rückgabewert und die Parameter. Legen Sie für den ersten Parameter, return type, Numeric als Type und 8-byte Double als Data Type fest.
9. Um die Argumenttypen für die Parameter zu bestimmen, die an die Funktion übergeben werden, klicken Sie auf Add a Parameter After. Bestimmen Sie arg1 als einen Numeric 8-byte Double. Wiederholen Sie diesen Vorgang für arg2.
10. Um die Funktionen in LabVIEW Real-Time noch besser zu nutzen, können Sie festlegen, dass die Funktion ablaufinvariant sein soll. Wenn eine Funktion ablaufinvariant ist, können mehrere Threads diese in der DLL gleichzeitig aufrufen. Wählen Sie im Drop-down-Feld Run in UI Thread die Möglichkeit Reentrant aus. Der Knoten „Call Library Function“ auf dem Frontpanel wechselt die Farbe und wird gelb, um anzuzeigen, dass die Funktion ablaufinvariant ist.
11. Nach Abschluss sollte das Dialogfeld „Call Library Function“ dann in etwa wie folgt aussehen:

[+] Bild vergrößern
Abb. 8: Dialogfeld „Call Library Function“

12. Bestätigen Sie das Dialogfeld mit OK und kehren Sie zum Blockdiagrammfenster zurück.
13. Das Symbol „Call Library Function Node“ gibt jetzt die Parameter wieder, die Sie festgelegt haben. „Call Library Node“ hat zwei Eingangs- und drei Ausgangsanschlüsse. Der obere rechte Anschluss gibt das Ergebnis aus. Die beiden anderen Ausgänge sind die zwei übergebenen Eingänge. Verdrahten Sie X mit dem oberen und Y mit dem unteren Eingang. Verdrahten Sie den oberen Ausgangsanschluss mit dem Anzeigeelement Result.
14. Speichern Sie das Programm als DebugDllCaller.vi. Anschließend sollte das Blockdiagramm wie folgt aussehen:

[+] Bild vergrößern
Abb. 9: Blockdiagramm des DebugDLLCaller.vi

15. Jetzt können Sie das Programm ausführen, Funktionsaufrufe in die DebCalc.dll auf Fehler untersuchen und diese beseitigen. Wechseln Sie zum Frontpanel und geben Sie die Werte für die X- und Y-Eingänge ein.
16. Öffnen Sie in LabWindows/CVI DebCalc.prj.
17. Wählen Sie zum Starten des Fehlersuchprogramms den Pfad Run» Debug Project aus. Das Fehlersuchprogramm fungiert als TCP-Server und wartet, bis die DLL eine Verbindung herstellt. Nach Start des Fehlersuchprogramms zeigt LabWindows/CVI eine Nachricht an, die Sie auffordert, die DLL auf die LabVIEW Real-Time-Hardware herunterzuladen.
18. Gehen Sie zum bereits in LabVIEW erstellten VI zurück und wählen Sie den Pfad Operate» Run.
19. Wenn die Ausführung der DLL-Funktion beendet ist, zeigt LabWindows/CVI ein Mitteilungsfeld an. Sie werden darüber informiert, dass das Fehlersuchprogramm auf weitere Anfragen von der DLL wartet. Um mit der Fehlerbehebung der DLL fortzufahren, ignorieren Sie die Mitteilung und führen Sie die LabVIEW-Anwendung erneut an. Wenn die Fehlerbehandlung abgeschlossen ist, klicken Sie auf die Schaltfläche Stop Debugging in diesem Mitteilungsfeld.

Fazit

Wird LabWindows/CVI zur Erstellung und Fehlerbehebung von LabVIEW-Real-Time-kompatiblen DLLs eingesetzt, lässt sich die Funktionalität von LabVIEW Real-Time erweitern. Diese DLLs können genutzt werden, um ANSI-C-Code in deterministische, zuverlässige Echtzeitanwendungen zu integrieren. Die Anwendungsbeispiele in diesem Dokument haben gezeigt, wie sowohl Release- als auch Debug-Versionen von LabVIEW-Real-Time-kompatiblen DLLs erstellt werden können und wie der Anwender diese DLLs aus einer LabVIEW-Anwendung heraus aufrufen kann. Die Schritte in diesen Beispielen kann der Anwender einsetzen, um eigene mit LabVIEW Real-Time kompatible DLLs in LabWindows/CVI zu erstellen.

Weiterführende Links (engl.):
Standard I/O Calculator in LabWindows/CVI