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 habe eine DLL mit dem LabVIEW DLL-Importwizard eingebunden. Nun kann ich auf die DLL-Funktionen zugreifen. Eine Funktion davon ist das kopieren eines Speicherbereichs (von CPU) und einen anderen (Grafikkartenspeicher). Hierzu greife ich mit Hilfe eines Knotens auf die DLL-Funktion "Memcopy" zu. Diese ist wie folgt definiert:
Ich habe ein Array mit Werten initialisiert. Nun möchte ich das Array an die Funktion übergeben, jedoch weiß ich nicht was ich beim Knoten einstellen muss. Was muss ich beim Knoten einstellen, damit dies funktioniert?
Developer Suite Core -> LabVIEW 2015 Prof.
2006
EN
71083
Deutschland
Hilfe bei Knotenzugriff
Gruß Markus
-------------------------------------------------------------------------- Bitte stellt mir keine Fragen über PM, dafür ist das Forum da - andere haben vielleicht auch Interesse an der Antwort !!
--------------------------------------------------------------------------
Das Array wird direkt als Eingang auf den DLL-Knoten gegeben. Die Parameter (Doppelklick auf Knoten ...) für diesen Eingang heißen dann: Numerisches Array, Basistyp U32, Zeiger auf Datenbereich. Voraussetzung Win32 (kein .Net, kein X64)
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
Den Pointer für die Grafikkarte bekomme ich über folgende Funktion:
Errot_t Malloc( void** devicePTr, size_t size)
Was mir ein wenig zu denken gibt ist der Datentype des Zeigers. Dieser wird mit void angegeben. Dies kann ich in LabVIEW nicht, sondern ich muss einen Datentype angeben.
' schrieb:Den Pointer für die Grafikkarte bekomme ich über folgende Funktion:
Errot_t Malloc( void** devicePTr, size_t size)
Nun gut, ich will mal glauben, dass das alles so geht, solange ich das nicht nachvollzogen habe.
Zitat:Was mir ein wenig zu denken gibt ist der Datentype des Zeigers. Dieser wird mit void angegeben. Dies kann ich in LabVIEW nicht, sondern ich muss einen Datentype angeben.
Void bedeutet "untypisiert". Es wird also ein Wert übertragen, von dem nur bekannt ist, dass es ein Pointer ist. Worauf der zeigt - nämlich auf einen Speicher, der einen Typ hat - ist irrelevanrt. Die DLL wird schon alles richtig machen.
In so einem Falle nimmst du U32.
Wobei ich bei void ** (wegen der zwei Sterne) eher skeptisch bin, was LV respektive Datenflussteuerung betrifft. Oder diplomatisch ausgedruckt: Hier musst du besondere Sorgfalt walten lassen z.B. beim Testen.
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
Ich hatte es schon mal zum laufen gebracht, so das ich Daten vom PC in die Grafikkarte kopieren konnte, dort eine FFT ausgefüht hatte und diese wieder in den PC-Speicher kopiert hatte. Die FFT, die ich mit LabVIEW gemacht hatte habe ich dann mit der, die auf der Grafikkarte ausgeführt wurde verglichen. Nun wollte ich das ganze vereinfachen, indem ich ein Array nicht erst mit einer DLL auf dem PC allocieren, sondern indem ich ein Array mit LabVIEW initialisiere und dann die Adresse des Arrays übergebe.
LabVIEW zeigt mir jetzt auch keine Fehler mehr an, jedoch ist das Ergebnisarray 0. Also muss noch ein Fehler vorliegen.
' schrieb:Nun wollte ich das ganze vereinfachen, indem ich ein Array nicht erst mit einer DLL auf dem PC allocieren, sondern indem ich ein Array mit LabVIEW initialisiere und dann die Adresse des Arrays übergebe.
Das wäre ja ein Pointer mit der Vorgabe "Zeiger auf Daten".
Das klingt nach C-DLL. Mit C hast du aber die Möglichkeit, mit Pointern zu hantieren, wie du willst. Das geht in LV - glücklicherweise - nicht. Daher sind manche Sachen in LV eben nicht möglich oder nur sehr schwierig.
Ein Problem sind Doppelsterne. Das heißt nämlich: Der Pointer auf das Array wird in einem U32-Speicher abgelegt. Der Pointer auf diesen Speicher wird an die DLL/Graphikkarte übergeben. (Also ein doppelter Pointer). Nur zur Info.
Noch eins: Wenn die DLL in ein LV-Array schreiben soll (also das ohne const), dann musst du am Eingang des DLL-Knotens ein entsprechend großes Array anlegen und am Ausgang die Daten abgreifen!
Jeder, der zur wahren Erkenntnis hindurchdringen will, muss den Berg Schwierigkeit alleine erklimmen (Helen Keller).
' schrieb:Nun gut, ich will mal glauben, dass das alles so geht, solange ich das nicht nachvollzogen habe.
Void bedeutet "untypisiert". Es wird also ein Wert übertragen, von dem nur bekannt ist, dass es ein Pointer ist. Worauf der zeigt - nämlich auf einen Speicher, der einen Typ hat - ist irrelevanrt. Die DLL wird schon alles richtig machen.
In so einem Falle nimmst du U32.
Wobei ich bei void ** (wegen der zwei Sterne) eher skeptisch bin, was LV respektive Datenflussteuerung betrifft. Oder diplomatisch ausgedruckt: Hier musst du besondere Sorgfalt walten lassen z.B. beim Testen.
void ** ist ein Pointer auf einen untypisierten Pointer. Der untypisierte Pointer kann in 32 Bit Systemen wie von Dir schon angegeben als 32 Bit (unsigned) Integer behandelt werden. Falls man LabVIEW 8.6 verwendet und RÜckwärtskompatibilität nicht nötig ist kann man auch den neuen LabVIEw 8.6 Parameter Typ "Pointer sized (unsigned/signed) Integer" verwenden. Da es ein Rückgabeparameter ist, (die Funktion gibt diesen Pointer zurück, deshalb der zweite Stern) muss man diesen Parameter noch als "passed by Referenz" definieren was in LabVIEW als "Pass: Pointer to Value" konfiguriert wird.
Man bekommt hier also einen UINT32 zürück und konfiguriert alle anderen Funktionen die diesen Pointer als void * übergeben bekommen ebenfalls in der selben Weise aber dann wegen dem fehlenden zweiten Stern als "Pass: Value".
