Persistence of objects in VIs called from C

Question

In my first case, I have a single VI compiled to a DLL. This VI does three different things, depending on the function call:
This is the first operation. It opens a connection to a UDP stream server. "ID" and "SA" are commands to tell the server to start send UDP data. The function call is:
callout(int Func, char *Address, char *DataOut, int Len);
Func is the operation I want to do, Address is the IP address to the server, DataOut is a container for the returned data and Len is the size of the container.
To start receiving data, I write:
callout(1, addr, data, 5000);
DataOut is ignored in this case. To retrieve UDP packets the next operation is used:
The call is:
callout(2, addr, data, 5000);
In this case, Address isn't used. 5000 bytes of data is copied to the location where data points.
And finally, this operation closes the stream:
callout(3, addr, data, 5000);
"SC" is the command to close the stream.
The above steps work just fine. The state of the VI is persistent between the function calls, and the connection saved in Connection ID is usable all the time.
What I'm trying to do now is streamline the operations by dividing this VI into three separate VIs. The first operation looks like this now:
In this case I try to save pointers to relevant objects in my C code:
TD1 *error;
LVRefNum *connectionid;
The new function call is:
callout_connect(addr, connectionid, error);
The next VI becomes:
With the function call:
callout_receive(connectionid, error, data, 5000);
And finally:
With the function call:
callout_close(addr, connectionid, error);
Needless to say, splitting up the VI into three separate entities has not worked so far. It compiles, sets up a connection, but somewhere the connection is then lost.
My suspicion is that I'm misunderstanding how the connection reference or the pointer to this reference is saved. Any suggestions?
Lars Melander
Uppsala Database Laboratory, Uppsala University
Solved!
Go to Solution.

Answer 1

What you are attempting to do is interesting.  Not ever doing this myself, I would say that the problem is that you are passing a pointer that points to nothing and telling LV to fill it in.  This would most likely cause your app to crash.
If I were doing this myself, I would not pass such things around across the boundry.  I would probably keep these simple and pass base types around.  To do this, I would for instance, pass an integer for the connection.  This would be done by using a type 1 or 2 global or a local to store the connection in an array and then index that array when the caller wants to access the connection.
Attached is a generic memory allocation vi that I made for things like this.
A
Attachments:
AllocateGetSetDeallocate.vi ‏88 KB
AllocateGetSetDeallocate_Operation.ctl ‏7 KB