C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
Wenn dein Problem oder deine Frage geklärt worden ist, markiere den Beitrag als "Lösung",
indem du auf den "Lösung" Button rechts unter dem entsprechenden Beitrag klickst. Vielen Dank!
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
Hallo zusammen,
ich habe eine *.dll (DSP-SW) die Radiosondensignale über die Soundkarte erfasst und die Messwerte ausgibt. Ich habe die dll vom Sondenhersteller erhalten und möchte sie verwenden, um in LabVIEW eine für unsere Bedürfnisse angepasste Datenerfassungssoftware zu schreiben. Dabei habe ich größte Schwierigkeiten, die *.dll richtig anzusprechen um an die Messwerte zu gelangen. Die DSP-SW steht als C++ Laufzeit Bibliothek(DLL) zur Verfügung.
Nun meine Fragen:
Ich habe ein vi mit einem "Library Function Node" erstellt, dem ich alle Variablen und Arrays entsprechend dem "DSPSwFrameType" (s.u.) eingebe. Dabei würde ich nun erwarten, dass dann am entsprechenden Ausgang die Messwerte ausgegeben werden. Das ist wohl aber zu einfach gedacht, denn ich bekomme lediglich Systemabstürze und im besten Falle Fehlermeldungen von LabVIEW (error 1097 oder seltener 1517), was auf einen Speicherkonflikt hinweist.
Ich habe generell 2 Versionen probiert:
1)(dspsw_get_frame_LV85_1.vi)
Eingangsparameter alle in ein Cluster gepackt, das wiederum aus Clustern, Arrays und Variablen besteht. Der Typ des Ausgangs ist dann als "An Typen
anpassen" konfiguriert. In dieser Konfiguration stürzt LabVIEW kommentarlos ab, wenn ich das VI im Gesamtprojekt laufen lasse.
2)(dspsw_get_frame_LV85_2.vi)
Eingangsparameter einzeln mit dem node verdrahtet. Die Ausgangstypen sind dann entsprechend der unten aufgeführten Anweisungen konfiguriert. In dieser
Konfiguration stürzt LabVIEW nicht ab, meldet jedoch "error 1097", wenn ich das VI im Gesamtprojekt laufen lasse.
Nach allem was ich durch stöbern auf diversen NatInst Seiten und Foren gelernt habe, ist es wohl ein Problem, die Speicherbereiche für die arrays richtig zu reservieren. Wie wird ausserdem die Anweisung "MarshalAs...." richtig in LabVIEW umgesetzt? Ich füge zur Verdeutlichung die beiden Versionen des vi bei, mit dem ich versuche, die Daten auszulesen. Ausserdem sind unten alle mir verfügbaren Informationen zu den Datentypen dieser dll-Funktion zusammengestellt.
Ich würde mich freuen wenn sich jemand finden würde, der mir bei diesem Problem helfen kann.
Vielen Dank schonmal und Grüße,
Dieter
------------------------------------------------------------------------------------------
Die DLL Einsprungfunktion in C++ zum Auslesen des Datenframes sieht fogendermassen aus:
------------------------------------------------------------------------------------------
Public Declare Function dspsw_get_frame Lib "./dspsw.dll"
(
<MarshalAs(UnmanagedType.Struct)> ByRef dt_gps_frame As DSPSwFrameType
)
As Integer
-------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
Dazu wurden mir zusätzlich noch folgende VB .NET 2005/2008 Datentypen angegeben:
-----------------------------------------------------------------------------------
Public Structure DSPSwPhysValType
Dim Value As Double
Dim Status As Short
Dim StatusArgc As Short
Dim Reserved0 As Short
Dim Reserved1 As Short
End Structure
Public DSPSwPhysVal As DSPSwPhysValType
Public Structure DSPSwFrameType
Dim IFrameCounter As Integer
Dim FrameCounter As Integer ' Laufende Nr. des TD_GPS_Frame
Dim IFrameTime As Double ' Zeit in s seit dsp_init
Dim frameTime As Double
Dim SyncQuality As Double ' Qualität des Synchronworts
Dim RecLevel As Double ' Pegel des Empfangssig. in dB
Dim BitDrift As Double ' Abweichung Sender/Empfänger in bits
Dim ClockDrift As Double ' Abweichung Signal/Empfänger in ppm
Dim t_phase As Short
Dim frame_sync_stat As Short
Dim framesync_cnt As Short
Dim frame_sync_diff As Short
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=40)> Dim RawData()As Byte ' Telemetrie - Frame, original
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=40)> Dim DeInterleaved() As Byte ' Telemetrie - Daten, deInterleaved
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=40)> Dim Correct() As Byte ' Telemetrie - Daten, korrigiert
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=40)> Dim DecodeError() As Byte ' Anzahl Fehlerbits
Dim BitError0 As Short ' Anzahl Bytes ohne Bitfehler
Dim BitError1 As Short ' Anzahl Bytes mit 1 Bitfehler
Dim BitError2 As Short ' Anzahl Bytes mit 2 Bitfehler
Dim BitError2Value As Short ' Anzahl Bytes mit 2 Bitfehler im Meßwert
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Dim DFMID() As Byte
Dim Reserved1 As Integer
Dim Sensor As Short
Dim Status As Short
Dim SensorId As Short
Dim SkMode As Short
Dim MeasData As Double
Dim MeasValue As DSPSwPhysValType
' Benutzte Werte für Strahlungsfehlerkorrektur
Dim Pressure As DSPSwPhysValType
Dim Altitude As DSPSwPhysValType
Dim SunElevation As DSPSwPhysValType
Dim RayCorrection As DSPSwPhysValType
Dim ReservedPv1 As DSPSwPhysValType
Dim ReservedPv2 As DSPSwPhysValType
Dim ReservedPv3 As DSPSwPhysValType
Dim ReservedPv4 As DSPSwPhysValType
Dim ReservedPv5 As DSPSwPhysValType
Dim ReservedPv6 As DSPSwPhysValType
' GPS-Daten bis Ende des Frames
Dim GPSValid As Short ' S J - 1, wenn GPS gültig (Jupiter) - 3, wenn GPS gültig (Sirf)
Dim tx_rfu1 As Short ' S - do not use.
Dim nav_type As Short ' S - bitmask
Dim tx_rfu2 As Short ' S - do not use.
Dim tx_rfu3 As Byte ' S - do not use.
Dim LLAValid As Short ' J - 1, wenn GPS-Lat/Lon/Alt gültig
Dim GPSFrameCounter As Integer ' S J - Nummer des empfangenen GPSFrame
Dim ValidItem As Integer ' S J - Bitmap 0...31
Dim SatMap As Integer ' S J - Bitmap, Bit(i) --> PRN(i+1)
Dim Latit As Double ' S J - +- 90°
Dim Longit As Double ' S J - +- 180°
Dim Altit As Double ' J - Meter, von ECEF
Dim Altit_Eli As Double ' S - Meter, über Ellipsoid
Dim Altit_MSL As Double ' S - Meter, über MSL
' ECEF: +- 0 ... 9.000.000m, resolution: e-2
Dim PosX As Integer ' J
Dim PosY As Integer ' J
Dim PosZ As Integer ' J
' ECEF: +- 0 ... 320m/s, resolution: e-2
Dim VelX As Integer ' J
Dim VelY As Integer ' J
Dim VelZ As Integer ' J
' 0 ... 1.000m, resolution: e-2
Dim EHPE As Integer ' J
Dim EVPE As Integer ' J
' 0 ... 300m, resolution: e-2
Dim EHVE As Integer ' J
Dim ErrorID As Short ' J - vom GPS-Empfänger
Dim UTCSec As Short ' J - Sekunden
Dim UTCTSec As Short ' J - 1/1000 Sekunden
Dim MaskAngle As Short ' J - +- 0 ... pi/2, Resolution: e-3
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Dim CNo() As Short ' J - 0 ... 60dBHz (MaxSatsVisible = 12)
Dim rfu As Integer ' J - do not use.
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Dim prn() As Byte ' S - PRN visible: 0 = unused, 1..32 = SV ID
<MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Dim cn0() As Byte ' S - C/N0: 0 ... 60dBHz
Dim sog As Double ' S - speed over ground, m/s
Dim cog As Double ' S - course over ground, deg. true north
Dim climb_rate As Double ' S - climb rate, m/s
Dim s_ehpe As Double ' S - m
Dim s_evpe As Double ' S - m
Dim rfu52 As Short ' S - do not use.
Dim rfu53 As Short ' S - do not use.
Dim utc_year As Short ' S - UTC
Dim utc_month As Short ' S - UTC
Dim utc_day As Short ' S - UTC
Dim utc_hour As Short ' S - UTC
Dim utc_minute As Short ' S - UTC
Dim utc_ms As Short ' S - UTC
Dim utc_time As Double ' S - 00:00:00.000 ... 23:59:59.999
Public Sub Initialize()
'ReDim reserved(3)
ReDim RawData(39)
ReDim DeInterleaved(39)
ReDim Correct(39)
ReDim DecodeError(39)
ReDim DFMID(3)
'ReDim ReservedPv(4)
ReDim CNo(31)
ReDim prn(31)
ReDim cn0(31)
End Sub
End Structure
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
' schrieb:Dabei habe ich größte Schwierigkeiten, die *.dll richtig anzusprechen um an die Messwerte zu gelangen.
Das sehe ich auch so.
Zitat:Ich habe ein vi mit einem "Library Function Node" erstellt, dem ich alle Variablen und Arrays entsprechend dem "DSPSwFrameType" (s.u.) eingebe. Dabei würde ich nun erwarten, dass dann am entsprechenden Ausgang die Messwerte ausgegeben werden. Das ist wohl aber zu einfach gedacht,
Nein, gedacht ist das genau richtig.
Ich gehe davon aus, dass es so geht - so gehen soll.
Zitat:Ich habe generell 2 Versionen probiert:
Nur eine kann richtig sein.
Ich gehe davon aus, deine erste Methode ist richtig. Was richtig ist, muss in der Beschreibung der DLL-Funktionen stehen. Wenn da eine Funktion mit nur einem Parameter steht, kann nur deine erste Version richtig sein. Und die Methode mit den 50 Eingängen - sowas macht keiner.
Zitat:In dieser Konfiguration stürzt LabVIEW kommentarlos ab, wenn ich das VI im Gesamtprojekt laufen lasse.
Das kommt von folgendem:
Verlangt wird ein Pointer auf einen Speicherbereich, der alle Daten enthält. So ein Bereich heißt normalerweise Cluster. Zuerst einmal musst du sicherstellen, dass die Reihenfolge der Daten im Cluster die selbe ist, wie in der Beschreibung des Parameters der Funktion.
Hast du jetzt ein Array (oder String) im Cluster - fängt das Problem an. Die DLL erwartet hier ein statisches Array (davon gehe ich aus). D.h. die Daten des Arrays werden direkt im Cluster erwartet. LV schreibt aber nicht die Daten des Arrays in den Cluster, sondern einen Pointer auf die Arraydaten. Letztendlich führt das zum Absturz.
So einen großen Cluster mit so vielen Parametern hab ich auch noch nicht gesehen. Drei Möglichkeiten fallen mir ein, die du mal prüfen müsstest. Ich hätte ja die erste bevorzugt.
Erstens:
Cluster erstellen. Dann ein Array of U8 erstellen, das die Länge des erwarteten Speicherbereiches hat. Danach die Daten aus dem Cluster der Reihe nach manuell hart typcasten in das Array of U8. DLL aufrufen und das ganze rückwärts. Für kleine, komplexe Cluster kann man das so machen.
Zweitens:
Du kannst mal "Daten serialisieren" probieren. Dabei gibst du den Cluster auf das Serialisier-Element - heraus kommt ein Datenstream in Form eines Strings. Den String gibt du an die DLL als PChar. Rückwärts musst du das selbe probieren: den String aus dem DLL-Knoten auf ein Deserialisierungs-Element. Das Element bekommt den Cluster als Typeingang und liefert am Ausgang einen Datencluster. Ob das geht weiß ich nicht. Ich war noch nie in der Situation, einen derartigen Cluster an eine DLL zu übergeben.
Drittens:
Eine Wrapper-DLL. Mach dir eine C++-DLL, die auf der einen Seite die User-DLL bedienen kann. Das sollte einfach sein. Und auf der anderen Seite machst du eine oder mehrere Funktionen, die LV bedienen kann. Das ist auch einfach.
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
06.02.2009, 07:10 (Dieser Beitrag wurde zuletzt bearbeitet: 06.02.2009 07:12 von rolfk.)
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
' schrieb:Das sehe ich auch so.
Nein, gedacht ist das genau richtig.
Ich gehe davon aus, dass es so geht - so gehen soll.
Nur eine kann richtig sein.
Ich gehe davon aus, deine erste Methode ist richtig. Was richtig ist, muss in der Beschreibung der DLL-Funktionen stehen. Wenn da eine Funktion mit nur einem Parameter steht, kann nur deine erste Version richtig sein. Und die Methode mit den 50 Eingängen - sowas macht keiner.
Also der Prototyp (leider Visual Basic BHÄÄÄÄÄ) sagt deutlich dass die struct (der C Begriff eines Clusters) ByRef übergeben wird. Das heisst es muss ein Pointer übergeben werden. Wenn es ByVal wäre wäre der Zweite Approach richtig (mein lieber Himmel!!!).
Zitat:So einen großen Cluster mit so vielen Parametern hab ich auch noch nicht gesehen. Drei Möglichkeiten fallen mir ein, die du mal prüfen müsstest. Ich hätte ja die erste bevorzugt.
Erstens:
Cluster erstellen. Dann ein Array of U8 erstellen, das die Länge des erwarteten Speicherbereiches hat. Danach die Daten aus dem Cluster der Reihe nach manuell hart typcasten in das Array of U8. DLL aufrufen und das ganze rückwärts. Für kleine, komplexe Cluster kann man das so machen.
Zweitens:
Du kannst mal "Daten serialisieren" probieren. Dabei gibst du den Cluster auf das Serialisier-Element - heraus kommt ein Datenstream in Form eines Strings. Den String gibt du an die DLL als PChar. Rückwärts musst du das selbe probieren: den String aus dem DLL-Knoten auf ein Deserialisierungs-Element. Das Element bekommt den Cluster als Typeingang und liefert am Ausgang einen Datencluster. Ob das geht weiß ich nicht. Ich war noch nie in der Situation, einen derartigen Cluster an eine DLL zu übergeben.
Drittens:
Eine Wrapper-DLL. Mach dir eine C++-DLL, die auf der einen Seite die User-DLL bedienen kann. Das sollte einfach sein. Und auf der anderen Seite machst du eine oder mehrere Funktionen, die LV bedienen kann. Das ist auch einfach.
1) ist möglich aber immens viel Arbeit. Ich habe nicht im Detail die Definition betrachtet aber ich konnte so auf die Schnelle keine Array und String Pointer sehen. Dann geht es nämlich eigentlich nicht. LabVIEW Arrays und Strings sind nicht direkt kompatibel mit C Strings und Arrays. Direkt als Parameter kann man die durch die Call Library Node übersetzen lassen nach C Pointern aber innerhalb eines Clusters geht das nicht.
Was ich sah waren fixed size Arrays (die haben alle eine Nummer zwischen eckigen Klammern hinter dem Variablennamen). Diese kann man durch einen eingebetteten Cluster mit der entsprechenden Anzahl Elemente vom Typ den die Variable hat simulieren.
2) Vergiss es. Das Serialisier Format packt alle Daten im Cluster zusammen und fügt bei Arrays und Strings noch eine i32 Zahl hinzu die die jeweilige Anzahl der Elemente angibt die nun folgt.
3) Mein absoluter Verzug. Diese Funktion alleine macht diesen Wrapper eigentlich schon fast eine Pflicht. Wenn da noch andere Funktionen hinzukommen mit auch nur halb so komplexen Parametern dann hat sich der Wrapper im Endeffekt ganz sicher bezahlt gemacht.
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
' schrieb:Was ich sah waren fixed size Arrays (die haben alle eine Nummer zwischen eckigen Klammern hinter dem Variablennamen). Diese kann man durch einen eingebetteten Cluster mit der entsprechenden Anzahl Elemente vom Typ den die Variable hat simulieren.
Also, Dieter, probiers mal damit: Anstelle eines Arrays im Cluster einen Cluster in den Cluster und dann den Haupt-Cluster auf den DLL-Knoten. Aber immer dran denken, dass die Reihenfolge im Cluster mit der im Struct übereinstimmen muss.
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
' schrieb:
Also, Dieter, probiers mal damit: Anstelle eines Arrays im Cluster einen Cluster in den Cluster und dann den Haupt-Cluster auf den DLL-Knoten. Aber immer dran denken, dass die Reihenfolge im Cluster mit der im Struct übereinstimmen muss.
Vielen Dank an alle für die schnellen Antworten. Ich sehe jetzt tatsächlich Messwerte, nachdem ich die arrays durch cluster gleicher Größe ersetzt habe. Ein schönes Wochenende an alle!
Gruss,
Dieter
/
C++ DLL mit komplexer Datenstruktur inLabVIEW verwenden
