LabVIEW
how to set parameter Size of DSNewPtr for an array of double precision
Patient to doctor: Doctor it hurts if I press on this spot!
Doctor to patient: Then don't do it!
Why do you want to do this whole DSNewPtr() thing? This is not LabVIEW programming bit simply C programming, just on an even more complicated level. And you obviously do not have C programming experience. So it's not a good idea to try to build a moon rocket if you are still trying to build model cars.
Well for one, the example you mention is NOT about 2D arrays at all. It is simply about returning a normal array from the DLL. That's a huge difference and fully supported by the Call Library Node. You just have to make sure to manage the memory correctly as you have to do it too when calling such a function from C.
The only way to find out about if a 2D array is an array of pointers or rather a single memory block with x * y elements is usually to read the documentation and consult working C code examples that use that function. The syntax of the function prototype is usually not enough as the C syntax is not meant to cover such "details".
C is designed as a programming language that sits pretty close to the bare metal of the CPU and many things in C are left open to the implementer of a particular compiler for a specific CPU. As far as datatypes go, it only defines basic elements such as pointers, integers and floating point datatypes and the two compound types array and struct but even arrays are in fact only pointers. There is a special syntax for arrays, but it is mostly just syntactic sugar coating and has no practical meaning, with the exception for fixed size arrays.
So to create your array of pointers you basically do exactly the same as you would do in C, and not knowing C means that you basically miss the fundamental basics to even comprehend how this should work.
Here is one example that I recently posted here on this forum that uses arrays of pointers and you can take a look at that. It is NOT exactly the solution you look for but shows the principle about creating an array of pointers in LabVIEW and copy out the data from them (although it's for a string here) after the Call Library Node call (and properly deallocating them afterwards). However without the proper understanding of C programming with respect to pointers, you may be able to create something that seems to work, but most likely will create a memory leak generator or a memory corruption engine or even both!
The basic rule about the Call Library Node is: If you can't write the code to call a specific function in C, you should not try to write a LabVIEW VI to call that function! This is by far not enough to make sure the resulting VI code won't corrupt memory, crash your program or eat your sandwich, but it is a fundamental prerequest.
From a quick glance at your original VI there are several obvious errors.
1) You write that a double is 8 byte and the according array pointer therefore should be 8 times the number of array elements but you only use 1 as multiplicator. Your mentioning that it only works when you use 1 as mulitplicator makes no sense because of the following point.
2) The MoveBlock function does nothing useful as it is now. It basically copies the random memory content from the newly created memory block into your double array. The returned data intepreted as double values is still garbage, just as the bytes in the allocated memory block are.
As far as your second VI is concerned it has similar problems:
1) You allocate a memory block of 8 bytes => Good
2) You copy the content from that memory block into the passed in LabVIEW array! => WTF
3) You copy the content from that memory block into the newly created array. => Fine, but the array is 4 elements long while you only use two of them both in the MoveBlock() function and later on. Because of the f*ck up in stage 2) you won't get any different data than the original random data from the memory block!
4) You dispose the pointer. => Very Good
As I already told you, there is no easy way to see what implementation a 2D array is using in C without seeing the source code of the function itself or some exemple code which call the function and is fully proven to be correct!
As you haven't shared any of these (and not even the original function prototype) the only reason I provided that link with the array of pointers was because of your claim in your initial mail that you needed that. I have no way of verifying that that is really the case as I do not have any of these things available.
Well, ok! It does indeed require an array of pointers. But your claim that it is fully tested and error free is not quite right. The example code as is will create a memory leak of 8 * 8 * xres * yres bytes. For this example it doesn't matter as it is just a main() function and the memory will be released at the termination of the process anyways, so nothing bad happening, but for example code still not that great.
Your posted VI has a few (potential) problems too:
- The number of points for each channel needs to be of course xres * yres, not an arbitrary 10000 samples.
- You create 8 channels but only read 2 after the function call. This might be valid as the other channels might not contain interesting (or useful) data, but you need to be aware of that.
- More serious though you allocate 8 memory pointers but only deallocate the first 2! Nice memory leak with every call of that function. Just remove the constant to the N terminal completely. You ALWAYS want to deallocate ALL pointers you initially created.
But there are still several open questions. One is that the VI you posted is NOT calling this DLL function. There are other parameters to this function that need to be configured right and passed in with valid data to get any meaningful result. Do you do that?
