LabVIEW
read void pointer from dll
Solved!
I never had any luck bringing in structures or typedefs like that. My suggestion would be to revise the DLL so it can put out three arrays (x,y,z). If you use the DLL with some other software, add a function (such as DataGetLatest_Flat) to the DLL.
Sorry I can't be more encouraging.
You don't.
You can however use the array of U8 type to retrieve this kind of data and cast it to a cluster.
See picture.
The upper screenshot shows the configuration of the DLL parameter.
The middle one shows the complete example.
The bottom one shows an example that can be used to find the correct size and byte ordering.
Data is stored in memory as bytes. The pointer points to the first byte. By retrieving enough bytes from the pointer position onwards you get all bytes related to your structure. After that you will have to map the bytes to the individual structure elements.
It is not entirely clear how the void* data pointer should be interpreted. If it is really just a pointer to the structure as your post seems to indicate it is very trivial.
You just create a cluster with the three single precision values and configure the parameter to Adapt to Type and wire that cluster to that parameter.
If it is however an array of clusters instead then things would get a little more complicated.
Rolf Kalbermatter
GuruDoo wrote:I'll try the methods discussed above to solve my issue.
2). The cluster is actually a cluster array of that is puElements long.
Then you should create an array of float32 (single precision float, the C datatype double would be a LabVIEW double precision float) elements with 3 * puElements elements in it. Pass this as an array data pointer to your DLL function.
On return you will have in index 0 the array[0].x element, index 1 the array[0].y element, and index 2 the array[0].z element, and then the three elements for the second cluster record and so on.
Rolf Kalbermatter
GuruDoo wrote:I've come across another complication. I have gotten my program to work as long as the items in the structure are of uniform type (all floats, unit8, etc) like so:
Any hints or tricks when the items in the structure are not uniform (floats and chars etc) or embedded structures like so:
typedef struct SensorDataStruct
{
unsigned char ucPeak;
unsigned char ucDRC;
unsigned char ucCode;
unsigned char ucPeakNibble;
}SensorData
typedef struct FullRawDataStruct
{
float fCentroid [NUM_SENSORS]
SensorData SensorData[NUM_SENSORS]
}FullRawData
I'm having trouble getting cases like this to work. Thanks for the help again.
Then you are in a bit more trouble. Basically you still can do a correctly sized flat array with the least denominator of all elements. Here you could choose two possibilities:
1) an array of 2 * elements float32's and then index the odd elements, typecast them to int32, pass through Swap Bytes and Swap Words and typecast to an array of (u)Int8 which will give you 4 single byte integers.
2) an array of 8 * elements (u)int8's then extract the 4 elements from 8 * n and typecast them to an int32, pass through Swap Bytes and Swap Words and typecast to a single precision number, and also extract the four elements from 8 * n + 4 and use them as your 4 char elements.
In LabVIEW > 8 you have another option to pass in an array of 8 * elements uInt32', pass it through a Byte Array To String function and then through a Unflatten from String with the correct Endianess for your platform selected and the "data includes array or string size? (T)" input set to false.
Don't pass directly a string of appropriate size to the function as a C string pointer if you want to get binary data back from the function. LabVIEW on return from the function will scan the string and terminate it at the very first NULL byte it encounters and only return that part since this is the standard C way for string buffer termination.
All this is quite some work and for other more complicated cluster arrays it may be even more work and fiddling so I would most times suggest to write a small wrapper DLL in C instead to do this more easily.
Above example could be as easy as:
typedef struct SensorDataStruct
{
unsigned char ucPeak;
unsigned char ucDRC;
unsigned char ucCode;
unsigned char ucPeakNibble;
}SensorData
typedef struct FullRawDataStruct
{
float fCentroid [NUM_SENSORS]
SensorData SensorData[NUM_SENSORS]
}FullRawData;
typedef struct LVFullRawDataStruct {
int32 size;
FullRawData data[1];
} LVFullRawData, **LVFullRawDataHandle;
int32 MyFunction(.... , FullRawData pData[], int32 numElm, ....);
int32 LVFunction(.... , LVFullRawDataHandle pData, ....)
{
return MyFunction(.... , (*pData)->data, (*pData)->size, ....);
}
Since there is no alignment issue in this C structure, you can simply construct the cluster one to one from the C structure and pass it as an array of those elements to the LVFunction which will take apart the LabVIEW array handle and pass its elements as individual C datatypes to the actual C function.
C alignment issues can be handled by adding according dummy bytes (uInt8 elements) into the LabVIEW cluster since LabVIEW does always full byte packing.
Rolf Kalbermatter
