LabVIEW coding using wnaspi32.dll

Question

Hi to all, here I need you guys help in LV coding with wnaspi32.dll for I have no experience in doing that at all!
I will appreciate if any of you can tell me what the equivalent in lv code for
1)
typedef struct
BYTE SRB_Cmd; // ASPI command code = SC_EXEC_SCSI_CMD
BYTE SRB_Status; // ASPI command status byte
BYTE SRB_HaId; // ASPI host adapter number
BYTE SRB_Flags; // ASPI request flags
DWORD SRB_Hdr_Rsvd; // Reserved
BYTE SRB_Target; // Target's SCSI ID
BYTE SRB_Lun; // Target's LUN number
WORD SRB_Rsvd1; // Reserved for Alignment
DWORD SRB_BufLen; // Data Allocation Length
BYTE *SRB_BufPointer; // Data Buffer Point
BYTE SRB_SenseLen; // Sense Allocation Length
BYTE SRB_CDBLen; // CDB Length
BYTE SRB_HaStat; // Host Adapter Status
BYTE SRB_TargStat; // Target Status
void (*SRB_PostProc)(); // Post routine
void *SRB_Rsvd2; // Reserved
BYTE SRB_Rsvd3[16]; // Reserved for expansion
BYTE CDBByte[16]; // SCSI CDB
BYTE SenseArea[SENSE_LEN+2]; // Request Sense buffer
2.) In the following example, how do I do the (a) and (b) correctly?
This example sends a SCSI Inquiry command to host adapter #0, target #0, LUN
#0.
SRB_ExecSCSICmd MySRB;
DWORD ASPIStatus;
(a) char InquiryBuffer[32];
MySRB.SRB_Header = SC_EXEC_SCSI_CMD;
MySRB.SRB_HaId = 0;
MySRB.SRB_Flags = SRB_DIR_IN | SRB_POSTING;
MySRB.SRB_Hdr_Rsvd = 0;
MySRB.SRB_Target = 0;
MySRB.SRB_Lun = 0;
MySRB.SRB_BufLen = 32;
MySRB.SRB_SenseLen = SENSE_LEN;
(b) MySRB.SRB_BufPointer = InquiryBuffer;
MySRB.SRB_CDBLen = 6;
MySRB.RB_PostProc = PostProcedure;
MySRB.CDBByte[0] = SCSI_INQUIRY;
MySRB.CDBByte[1] = 0;
MySRB.CDBByte[2] = 0;
MySRB.CDBByte[3] = 0;
MySRB.CDBByte[4] = 32;
MySRB.CDBByte[5] = 0;
I am really struggling in getting it right for the *SRB_BufPointer (data buffer pointer) to work so as the aspi32.dll function will returns data to the pointer's buffer. But
q: How do get this buffer pointer correctly and how to read the buffer data after?
Hope that I am giving enough information on my problem. And, I will really aprreciate if anyone of you out there can help me on this. really.
Hear from ya.
Cheers and warmest regards
ian
[email protected]
Ian F
Since LabVIEW 5.1... 7.1.1... 2009, 2010
依恩与LabVIEW
LVVILIB.blogspot.com

Answer 1

Well, I don't think NI should spend much time on this. The configuration screen necessary to configure all those options really would be a mess to deal with and you would still need to know all the detail knowledge about C data types, how they are passed between functions, particular byte boundary alignement etc.
Without this knowledge present you still couldn't use these options and once you have the knowledge, writing a simple wrapper DLL which goes between LabVIEW and your complicated data structure and possibly callback API is actually much simpler than trying to configure and possible wire your API interface in LabVIEW.
Of course knowing the layout of the LabVIEW data structures you can basically use a trick to get the pointer to a LabVIEW string into a data structure to be passed to a DLL but it is still far from simple. The callback pointer however can't be tricked from a LabVIEW diagram (at least not without so much magic that writing a DLL is actually hundred times faster than trying to get this to work in LabVIEW).
You need to know that LabVIEW byte arrays are basically a pointer to a pointer to a buffer with an additional i32 at the beginning indicating the size. So by allocating a LabVIEW array you can then place a Call Library Node on the diagram with following configuration:
library: LabVIEW
function name: MoveBlock
return value: void
first parameter: LabVIEW array handle of uInt8
second parameter: uInt32 pointer to value
third parameter: int32 value
Then wire the array to the first parameter, a 0 constant to the second and a 4 constant to the third. The resulting value from the second parameter is the pointer to the effective LabVIEW array buffer and adding 4 to this value will be the pointer to the begin of the actual array.
Make sure the array wire stays valid until the Call Library Node returns (by wiring it to a structure boundary which depends on some output of the Call Library Node and not branching the wire to anyplace else until that point) and resize the array after the Call Library Node returns, by the actual size returned somewhere from the Call Library Node. Make sure the intial array is as large as required by the API function or as you have indicated in one of the parameters to the API function as otherwise the function will crash.
Remains filling in the structure which will be a bit of a pain also, but I told you that writing a wrapper DLL is almost always faster than trying to do such things in LabVIEW.
Rolf Kalbermatter
Rolf Kalbermatter
CIT Engineering Netherlands
a division of Test & Measurement Solutions