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!
ich hab mal wieder ein kleines Problem mit einem meiner LabVIEW-Programme:
Ich möchte eie DLL Funktion aufrufen. Das ist an sich kein Problem, hab ich schon öfters gemacht.
Aber diese DLL überfordert mich jetzt leicht. Der Funktionsaufruf sieht folgendermaßen aus:
int myfunction(mystruct** data)
hinter data soll im Endeffekt eine Strukturstehen - und Strukturen in LabVIEW Cluster ummodeln ist auch kein Problem (Als U8 Array byteweise auslesen...).
Doch hier komm ich einfach nicht an die Daten ran.
In der Call Libraray Function Node gebe ich den Parameter wie folgt an:
Damit bekomm ich verständlicherweise nicht die Daten an sich sondern nur eine Speicheradresse (4 Byte = 32 bit lang). Im "Funktionsprototyp" steht ja bei LV mit obigen Einstellungen auch nur "long _myfunction@4(unsigned char *data);" anstatt "... **data);"
Wenn ich jetzt aber bei Array-Format auf Array-Handle stelle, steht da dann zwar "... **data);" - aber dummerweise verabschiedet sich LabVIEW beim Ausführen.
Wie komme ich jetzt an die Daten ran? Kann ich aus der Speicheradresse was machen?
' schrieb:ich hab mal wieder ein kleines Problem mit einem meiner LabVIEW-Programme:
[*rofl*]
Zitat:int myfunction(mystruct** data)
Sieht schlecht aus. Schreibt die DLL Daten nach LV oder liest die DLL Daten von LV? Oder übergibt die DLL einen Pinter auf Daten an LV?
[*grübel*]
Eigenlich alles egal. Pointer auf Pinter geht so oder so mit LV nicht.
Zitat:Damit bekomm ich verständlicherweise nicht die Daten an sich sondern nur eine Speicheradresse (4 Byte = 32 bit lang). Im "Funktionsprototyp" steht ja bei LV mit obigen Einstellungen auch nur "long _myfunction@4(unsigned char *data);"
Dieses ansich sind schon die Daten.
Zitat:anstatt "... **data);"
Das wäre der Pointer. Das geht aber nicht.
Zitat:Wenn ich jetzt aber bei Array-Format auf Array-Handle
Das ist ja auch ein Handle. Was nicht zwangsläufig gleichbedeutend ist mit "Pointer auf Pointer".
Beantworte mir mal bitte meine obige Frage. Dann kann ich weiter überlegen.
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
20.03.2007, 16:28 (Dieser Beitrag wurde zuletzt bearbeitet: 20.03.2007 16:33 von astraios.)
Die DLL-Funktion schreibt Daten und ich versuche, sie aus "data" zu lesen. Wenn ich den Aufruf wie oben beschrieben (Array Datenzeiger) mache, bekomme ich einen Wert, der bei jedem Aufruf um 152 größer wird (was ungefähr der Größe der Struktur entspricht, die ich erwarte) - das deutet ja irgendwie auf eine Speicheradresse hin, oder? Aber ich will nicht die Adresse, ich will den Inhalt!
//edit: Zum Thema Pointer auf Pointer geht eh nicht in LV: Das wär schlimm. Die Struktur stellt nämlich eine verkettete Liste dar, in der jedes Element einen Zeiger auf das nachfolgende Element enthält... krieg schon langsam Kopfschmerzen...
' schrieb:Die DLL-Funktion schreibt Daten und ich versuche, sie aus "data" zu lesen.
Gut, ich glaube ich weis jetzt was du (respektive die DLL) machst: Die DLL erstellt einen Datensatz (Speicherbereich innerhalb der DLL) und gibt einen Pointer auf diesen Speicherbereich zurück. Dieser Pointer wird in data gespeichert.
Ich denke darüber nach - und werden den Fall in mein DLL-Tutorial aufnehmen.
Zitat:Wenn ich den Aufruf wie oben beschrieben (Array Datenzeiger) mache, bekomme ich einen Wert, der bei jedem Aufruf um 152 größer wird (was ungefähr der Größe der Struktur entspricht, die ich erwarte) - das deutet ja irgendwie auf eine Speicheradresse hin, oder?
Jawohl: Ein Pointer (der selbst einen Wert von größer 0x004xxxxx hat?) auf einen Datenbereich.
Zitat:Aber ich will nicht die Adresse, ich will den Inhalt!
Verstehe ich.
Zitat://edit: Zum Thema Pointer auf Pointer geht eh nicht in LV: Das wär schlimm.
Das ist schlimm.
Zitat:Die Struktur stellt nämlich eine verkettete Liste dar, in der jedes Element einen Zeiger auf das nachfolgende Element enthält
Das ist noch schlimmer, weil eben auch nicht möglich. Auch hier werde ich nochmals nachdenken.
Zitat:... krieg schon langsam Kopfschmerzen...
Schon mal was von Wrapper-DLL gehört?
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
Theoretisch könnte man hier "Array-Handle" nehmen. Aber eben nur theoretisch.
Ein Array-Handle ist - guckst du auch in der LV-Hilfe - ein Pointer auf eine Datenstruktur. Die ersten Int32 sind die Längen der Dimensionen. Je nach Anzahl der Dimensionen stehen also zuerst einige Int32. Danach kommen dann die Daten. Für ein eindimensionales I8-Array heißt das also: Zuerst vier Byte, die die Anzahl der nachfolgenden Bytes angeben, dann die nachfolgenden Daten.
Immerhin kann man sich mit "Array-Handle" von der DLL einen Pointer geben lassen auf einen Datenbereich, der in der DLL liegt. Würde dein DLL-Struct mit der Länge des Structs beginnen, so würde das wunderbarerweise funktionieren. Nur wer beginnt schon in weiser Voraussicht seinen Struct mit dessen Länge.
Was weiterhin gar nicht geht, sind Pointer in Cluster.
Pointer (auf Anwenderebene) sind ein veraltetes Hilfmittel, LV ist eine moderne Programmiersprache. Leider schließt sich das gegenseitig aus.
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
danke für Deine ausführlichen Antworten. Auch wenn diese mich wenig optimistisch stimmen
Zitat:der selbst einen Wert von größer 0x004xxxxx hat?)
Ja.
Zitat:Schon mal was von Wrapper-DLL gehört?
Nein, aber jetzt nachgeschaut... wäre ein Ausweg. Würde die Sache aber ungemein umständlicher machen als geplant war... naja, sind ja eh nur 3 oder 4 Funktionen in der API, die so dämliche Pointerpointer verwenden... die anderen könnt ich ja theoretisch direkt ansprechen.
Zitat:Würde dein DLL-Struct mit der Länge des Structs beginnen
Tut's leider nicht.
Zitat:Pointer (auf Anwenderebene) sind ein veraltetes Hilfmittel, LV ist eine moderne Programmiersprache. Leider schließt sich das gegenseitig aus.
Durch die "moderne Programmiersprache" fühle ich mich irgendwie entmündigt...
Also schonmal vielen Dank für Deine Unterstützung! Über wundersame Lösungen meines Problems würde ich mich nach wie vor sehr freuen
Viele Grüße
Robert
p.S.: Dieses LVF-Usertreffen Dingens über dem Mauszeiger nervt ungemein...
Es gibt in der LabVIEW Bibliothek eine Funktion namens "MoveBlock", der man eine Speicheradresse und Länge übergibt und die dann den Speicherbereich ausgibt.
Also ändere ich meinen DLL-Aufruf so, dass ich nur einen Zeiger auf U32 für "data" verwende. Diesen U32-Wert, der ja die Adresse der Struktur darstellt, geb ich dem MoveBlock Knoten und der gibt mir die Daten im gewünschten U8-Array aus.
Und genauso müsste das mit den Pointern in der Struktur selbst (verkettete Liste) dann auch klappen.
Also nochmal vielen Dank für die engagierte Hilfe!
' schrieb:Hast du sehr gut gemacht! Damit hast du vielen Anwendern geholfen. [*lob*]
Ja, der gut alte move() - und wie er immer heißt. Jetzt also auch in LV.
Jetzt! Lach!
Der steckt in LabVIEW seit Version 2.5 damals aber nur für CINs erreichbar. Aber seit minimal 5.0 kann man den per DLL Aufrufknoten direkt erreichen. Habe ich auf den LabVIEW Foren und Info-LabVIEW wiederholt in den letzten 6 oder 7 Jahren oder so haarfein erklärt, bevor jemand bei NI scheinbar dachte, dass man das auch mal in einem Beispiel dokumentieren könnte.
/
DLL-Aufruf mit structure**-Wert
