diff --git a/build.zig b/build.zig index a504c02..61bbd8a 100644 --- a/build.zig +++ b/build.zig @@ -17,11 +17,21 @@ pub fn build(b: *std.Build) void { .optimize = optimize, }); - const ljacklm_dep = b.dependency( - "ljacklm", - .{ .target = target, .optimize = optimize, .use_udev = use_udev }, - ); - exe.linkLibrary(ljacklm_dep.artifact("ljacklm")); + if (target.result.os.tag == .windows) { + if (target.result.cpu.arch == .x86) + exe.addObjectFile(b.path("deps/labjack/windows/ljackuw32.lib")) + else if (target.result.cpu.arch == .x86_64) + exe.addObjectFile(b.path("deps/labjack/windows/ljackuw64.lib")) + else + @panic("Unsupported CPU arch for Windows build (must be x86 or x86_64)."); + } else { + const ljacklm_dep = b.dependency( + "ljacklm", + .{ .target = target, .optimize = optimize, .use_udev = use_udev }, + ); + exe.linkLibrary(ljacklm_dep.artifact("ljacklm")); + } + exe.root_module.addImport( "udev_rules", b.addModule("udev_rules", .{ diff --git a/deps/labjack/windows/ljackuw.h b/deps/labjack/windows/ljackuw.h new file mode 100644 index 0000000..9ceb679 --- /dev/null +++ b/deps/labjack/windows/ljackuw.h @@ -0,0 +1,1667 @@ +//---------------------------------------------------------------------- +// +// ljackuw.h +// +// Header file for ljackuw DLL. +// +// support@labjack.com +// 10/2004 +// +// Version 1.03: Added "enableSTB" to Counter function. +// Added counter read option to stream functions. +// +// Version 1.05: Changed errorcode 52 to a warning. Just means +// a search of the USB turned up an HID that +// returned an unexpected response (not a LabJack). +// Changed calling convention to stdcall (_stdcall). +// Added NoThread function for TestPoint and VC debug. +// Fixed problem where timeout during feature stream or +// or burst caused a fatal fault in Win98SE. +// +// Version 1.051: Fixed a problem on Win 2000/XP where the LabJack did +// not work if there were certain other HID devices on +// on the bus. +// +// Version 1.06: Renamed function Reset to ResetLJ to avoid +// the reserved word. Changed DLL to allow +// multiple processes to attach at the same time. +// +// Version 1.061: Added back Reset (in addition to ResetLJ). +// +// Version 1.07: Added E (easy) functions. +// +// Version 1.073: Fixed problem where AIStreamStart returned error if +// demo was selected. Fixed problem where one particular +// in-house USB device (in UK) interfered with LabJack U12. +// +// Version 1.074: Fixed problem where 2-channel burst/stream data was not +// always scanned in the proper channel order, resulting +// in occasional time-sequence flip-flops. +// +// Version 1.09: Added pulse output functions. +// +// Version 1.096: Fixed timeout for PulseOut. +// +// Version 1.097: Added asynchronous comm functions. +// +// Version 1.098: Fixed AsynchConfig bug concerning DIO configuration. +// +// Version 1.100: Added synchronous and sht1x functions. +// +// Version 1.11: Changed digital I/O tris and state globals to arrays, +// so that information is stored for each LabJack in +// multiple LabJack applications. Each LabJack must have +// a unique LocalID for this to work. Also fixed a related +// issue in AOUpdate which could have caused the direction +// of all D lines to be toggled. +// +// Version 1.12: Added globals to attempt to keep track of AO states. If +// a value <0 is passed for an analog output, the global +// value is used instead. This allows 1 AO to be updated +// without changing the other, but is not foolproof as +// the globals are initialized to 0.0 volts when the DLL is +// first loaded, and if the LabJack is reset the AO are set +// to 0.0 but the DLL might not know the LabJack has reset. +// +// Version 1.13: Added most functions (i.e. WriteRead) to export list to +// make it easier for users to call functions at a lower +// lever (i.e. open, writeread, ... , writeread, close). +// +// Version 1.14: Added logic to AIBurst that forces normal transfer mode +// if timeout is set to 4 seconds or longer. It seems +// that Windows has it's own timeout on turbo mode at +// 5 seconds. +// +// Version 1.15: Firmware only allows IO0 or IO1 for AIBurst trigger. +// +// Version 1.16: Changed AIBurst transfer mode logic so that auto mode +// selects turbo unless timeout>=4 or numScans/scanRate>=4. +// +// Version 1.17: Changed timeouts from 1s to 2s. +// +// Version 1.18: Modified Static Array TempBuff in the StreamRead Function +// This fixes a Stack overflow error in TestPoints Windows 98 SE +// distribution. +// +// Version 1.19: Added LJHash function +// +// Version 1.20: Fixed issue generating too many internal windows Handles +// +// Version 1.22: Misc. bug fixes. +// +//---------------------------------------------------------------------- +// + + +//Exported Functions: +// AISample +// AIBurst +// AIStreamStart +// AIStreamRead +// AIStreamClear +// AOUpdate +// AsynchConfig +// Asynch +// BitsToVolts +// VoltsToBits +// Counter +// DigitalIO +// EAnalogIn +// EAnalogOut +// ECount +// EDigitalIn +// EDigitalOut +// GetDriverVersion +// GetErrorString +// GetFirmwareVersion +// GetWinVersion +// ListAll +// LocalID +// NoThread +// PulseOut +// PulseOutStart +// PulseOutFinish +// PulseOutCalc +// ReEnum +// Reset +// ResetLJ +// SHT1X +// SHTCRC +// SHTComm +// Synch +// Watchdog +// ReadMem +// WriteMem +// +//Low Level Exported Functions: +// OpenLabJack +// WriteRead +// WriteLabJack +// ReadLabJack +// CloseAll +// BuildAICommand +// ParseAIResponse +// BuildAOCommand +// ParseAOResponse +// RoundFL +// SHTWriteRead + + + +#if defined(__cplusplus) +extern "C" +{ +#endif + + +//====================================================================== +// EAnalogIn: Easy function reads the voltage from 1 analog input. Calling +// this function turns/leaves the status LED on. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does +// little but simulate execution time. +// channel -Channel command is 0-7 for SE or 8-11 for Diff. +// gain -Gain command is 0=1,1=2,...,7=20. Gain only +// available for differential channels. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *overVoltage -If >0, an overvoltage has been detected +// on the analog input (I32). +// *voltage -Returns the voltage reading (SGL). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall EAnalogIn(long *idnum, + long demo, + long channel, + long gain, + long *overVoltage, + float *voltage); + + +//====================================================================== +// EAnalogOut: Easy function sets the voltages of both analog outputs. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does little +// but simulate execution time. +// analogOut0 -Voltage from 0 to 5 for AO0 (SGL). +// analogOut1 -Voltage from 0 to 5 for AO1 (SGL). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall EAnalogOut(long *idnum, + long demo, + float analogOut0, + float analogOut1); + + +//====================================================================== +// ECount: Easy function to read & reset the counter. Calling this +// function disables STB (which is the default anyway). +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// resetCounter -If >0, the counter is reset to zero after +// being read (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *count -Current count, before reset. +// *ms -Value of Windows millisecond timer at the +// time of the counter read (within a few ms). +// Note that the millisecond timer rolls over +// about every 50 days. In general, the +// millisecond timer starts counting from zero +// whenever the computer reboots. +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall ECount (long *idnum, + long demo, + long resetCounter, + double *count, + double *ms); + + +//====================================================================== +// EDigitalIn: Easy function reads 1 digital input. Also configures +// the requested pin to input and leaves it that way. +// +// Note that this is a simplified version of the lower +// level function DigitalIO, which operates on all 20 +// digital lines. The DLL keeps track of the current +// direction and output state of all lines, so that this +// easy function can operate on a single line without +// changing the others. When the DLL is first loaded, +// though, it does not know the direction and state of +// the lines and assumes all directions are input and +// output states are low. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// channel -Line to read. 0-3 for IO or 0-15 for D. +// readD -If >0, a D line is read instead of an IO line. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *state -TRUE/Set if >0. FALSE/Clear if 0. +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall EDigitalIn(long *idnum, + long demo, + long channel, + long readD, + long *state); + + +//====================================================================== +// EDigitalOut: Easy function writes 1 digital output. Also configures +// the requested pin to output and leaves it that way. +// +// Note that this is a simplified version of the lower +// level function DigitalIO, which operates on all 20 +// digital lines. The DLL keeps track of the current +// direction and output state of all lines, so that this +// easy function can operate on a single line without +// changing the others. When the DLL is first loaded, +// though, it does not know the direction and state of +// the lines and assumes all directions are input and +// output states are low. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// channel -Line to write. 0-3 for IO or 0-15 for D. +// writeD -If >0, a D line is written instead of an IO line. +// state -TRUE/Set if >0. FALSE/Clear if 0. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall EDigitalOut(long *idnum, + long demo, + long channel, + long writeD, + long state); + + +//====================================================================== +// AsynchConfig: Requires firmware V1.08 or higher. +// +// This function writes to the asynch registers and sets the +// direction of the D lines (input/output) as needed. +// +// The actual 1-bit time is about 1.833 plus a "full" delay (us). +// The actual 1/2-bit time is about 1.0 plus a "half" delay (us). +// +// full/half delay = 0.833 + 0.833C + 0.667BC + 0.5ABC +// +// Common baud rates (full A,B,C; half A,B,C): +// 1 55,153,232 ; 114,255,34 +// 10 63,111,28 ; 34,123,23 +// 100 51,191,2 ; 33,97,3 +// 300 71,23,4 ; 84,39,1 +// 600 183,3,6 ; 236,7,1 +// 1000 33,29,2 ; 123,8,1 +// 1200 23,17,4 ; 14,54,1 +// 2400 21,37,1 ; 44,3,3 +// 4800 10,18,2 ; 1,87,1 +// 7200 134,2,1 ; 6,9,2 +// 9600 200,1,1 ; 48,2,1 +// 10000 63,3,1 ; 46,2,1 +// 19200 96,1,1 ; 22,2,1 +// 38400 3,5,2 ; 9,2,1 +// 57600 3,3,2 ; 11,1,1 +// 100000 3,3,1 ; 1,2,1 +// 115200 9,1,1 ; 2,1,1 or 1,1,1 +// +// +// When using data rates over 38.4 kbps, the following conditions +// need to be considered: +// -When reading the first byte, the start bit is first tested +// about 11.5 us after the start of the tx stop bit. +// -When reading bytes after the first, the start bit is first +// tested about "full" + 11 us after the previous bit 8 read, +// which occurs near the middle of bit 8. +// +// When enabled, STB does the following to aid in debugging +// asynchronous reads: +// -STB is set about 6 us after the start of the last tx stop bit, or +// about "full" + 6 us after the previous bit 8 read. +// -STB is cleared about 0-2 us after the rx start bit is detected. +// -STB is set after about "half". +// -STB is cleared after about "full". +// -Bit 0 is read about 1 us later. +// -STB is set about 1 us after the bit 0 read. +// -STB is cleared after about "full". +// -Bit 1 is read about 1 us later. +// -STB is set about 1 us after the bit 1 read. +// -STB is cleared after about "full". +// -This continues for all 8 data bits and the stop bit, after +// which STB remains low. +// +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// timeoutMult -If enabled, read timeout is about 100 +// milliseconds times this value (I32, 0-255). +// configA -If >0, D8 is set to output-high and D9 is set to +// input (I32). +// configB -If >0, D10 is set to output-high and D11 is set to +// input (I32). +// configTE -If >0, D12 is set to output-low (I32). +// fullA -A time value for a full bit (I32, 1-255). +// fullB -B time value for a full bit (I32, 1-255). +// fullC -C time value for a full bit (I32, 1-255). +// halfA -A time value for a half bit (I32, 1-255). +// halfB -B time value for a half bit (I32, 1-255). +// halfC -C time value for a half bit (I32, 1-255). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 60 ms +//---------------------------------------------------------------------- +long _stdcall AsynchConfig( long *idnum, + long demo, + long timeoutMult, + long configA, + long configB, + long configTE, + long fullA, + long fullB, + long fullC, + long halfA, + long halfB, + long halfC); + + +//====================================================================== +// Asynch: Requires firmware V1.05 or higher. +// +// This function writes and then reads half-duplex asynchronous +// data on 1 of two pairs of D lines (8,n,1). Call AsynchConfig +// to set the baud rate. Similar to RS232, except that logic is +// normal CMOS/TTL (0=low=GND, 1=high=+5V, idle state of +// transmit line is high). Connection to a normal RS232 device +// will probably require a converter chip such as the MAX233. +// +// PortA => TX is D8 and RX is D9 +// PortB => TX is D10 and RX is D11 +// Transmit Enable is D12 +// +// Up to 18 bytes can be written and read. If more than 4 bytes +// are written or read, this function uses calls to +// WriteMem/ReadMem to load/read the LabJack's data buffer. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// portB -If >0, asynch PortB is used instead of PortA. +// enableTE -If >0, D12 (Transmit Enable) is set high during +// transmit and low during receive (I32). +// enableTO -If >0, timeout is enabled for the receive phase (per byte). +// enableDel -If >0, a 1 bit delay is inserted between each +// transmit byte. +// baudrate -This is the bps as set by AsynchConfig. Asynch needs this +// so it has an idea how long the transfer should take. +// numWrite -Number of bytes to write (I32, 0-18). +// numRead -Number of bytes to read (I32, 0-18). +// *data -Serial data buffer. Send an 18 element +// array. Fill unused locations with zeros (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *data -Serial data buffer. Returns any serial read +// data. Unused locations are filled +// with 9999s. (I32). +// +// Time: 20 ms to read & write up to 4 bytes, plus 40 ms for each +// additional 4 bytes to read or write. Possibly extra +// time for slow baud rates. +//---------------------------------------------------------------------- +long _stdcall Asynch( long *idnum, + long demo, + long portB, + long enableTE, + long enableTO, + long enableDel, + long baudrate, + long numWrite, + long numRead, + long *data); + + +//====================================================================== +// AISample: Reads the voltages from 1,2, or 4 analog inputs. Also +// controls/reads the 4 IO ports. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does +// little but simulate execution time. +// *stateIO -Output states for IO0-IO3 (I32). +// updateIO -If >0, state values will be written. Otherwise, +// just a read is performed (I32). +// ledOn -If >0, the LabJack LED is turned on (I32). +// numChannels -Number of channels. 1, 2, or 4 (I32). +// *channels -Pointer to an array of channel commands with +// at least numChannels elements (I32). Each +// channel command is 0-7 for SE or 8-11 for Diff. +// *gains -Pointer to an array of gain commands with at +// least numChannels elements (I32). Gain commands +// are 0=1,1=2,...,7=20. Gain only available for +// differential channels. +// disableCal -If >0, voltages returned will be raw readings +// that are not corrected using calibration +// constants (I32). +// *voltages -Voltage readings buffer. Send a 4 element +// array of zeros (SGL). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *stateIO -Returns input states for IO0-IO3 (I32). +// *overVoltage -If >0, an overvoltage has been detected +// on one of the analog inputs (I32). +// *voltages -Returns numChannels voltage readings (SGL). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall AISample(long *idnum, + long demo, + long *stateIO, + long updateIO, + long ledOn, + long numChannels, + long *channels, + long *gains, + long disableCal, + long *overVoltage, + float *voltages); + + +//====================================================================== +// AIBurst: Reads a certain number of scans at a certain scan rate +// from 1,2, or 4 analog inputs. First, data is acquired and +// stored in the LabJacks 4096 sample RAM buffer. Then, the +// data is transferred to the PC application. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does little +// but simulate execution time. +// stateIOin -Output states for IO0-IO3 (I32). +// updateIO -If >0, state values will be written. Otherwise, +// just reads are performed (I32). +// ledOn -If >0, the LabJack LED is turned on (I32). +// numChannels -Number of channels. 1, 2, or 4 (I32). +// *channels -Pointer to an array of channel commands with at +// least numChannels elements (I32). Each channel +// command is 0-7 for SE or 8-11 for Diff. +// *gains -Pointer to an array of gain commands with at +// least numChannels elements (I32). Gain +// commands are 0=1,1=2,...,7=20. Gain only +// available for differential channels. +// *scanRate -Scans acquired per second (SGL). A scan is a +// reading from every channel (1,2, or 4). The +// sample rate (scanRate*numChannels) must +// be 400-8192. +// disableCal -If >0, voltages returned will be raw readings +// that are not corrected using calibration +// constants (I32). +// triggerIO -Set the IO port to trigger on. 0=none, +// 1=IO0, or 2=IO1 (I32). +// triggerState -If >0, the acquisition will be triggered +// when the selected IO port reads high (I32). +// numScans -Number of scans which will be collected (I32). +// Minimum is 1. Maximum numSamples is 4096 where +// numSamples is numScans * numChannels. +// timeout -Function timeout value in seconds (I32). Note +// that if timeout is >= 4, the transferMode +// is automatically set to normal. +// *voltages -Voltage readings buffer. Send a 4096 by 4 +// element array of zeros (SGL). +// *stateIOout -IO state readings buffer. Send a 4096 element +// array of zeros (I32). +// transferMode -0=auto,1=normal,2=turbo (I32). If auto, +// turbo mode is used unless timeout is >= 4, +// or numScans/scanRate >=4. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *scanRate -Returns the actual scan rate, which due to +// clock resolution is not always exactly the +// same as the desired scan rate (SGL). +// *voltages -Voltage readings are returned in this 4096 by +// 4 array (SGL). Unused locations are filled +// with 9999s. +// *stateIOout -The states of all 4 IO are returned in this +// array (I32). Unused locations are filled +// with 9999s. +// *overVoltage -If >0, an overvoltage has been detected on +// at least one sample of at least one of the +// analog inputs (I32). +// +// Time: The execution time of this function, in milliseconds, can be +// estimated with the below formulas. The actual number of samples +// collected and transferred by the LabJack is the smallest power +// of 2 from 64 to 4096 which is at least as big as numScans*numChannels. +// This is represented below as numSamplesActual. +// Normal => 30+(1000*numSamplesActual/sampleRate)+(2.5*numSamplesActual) +// Turbo => 30+(1000*numSamplesActual/sampleRate)+(0.4*numSamplesActual) +//---------------------------------------------------------------------- +long _stdcall AIBurst(long *idnum, + long demo, + long stateIOin, + long updateIO, + long ledOn, + long numChannels, + long *channels, + long *gains, + float *scanRate, + long disableCal, + long triggerIO, + long triggerState, + long numScans, + long timeout, + float (*voltages)[4], + long *stateIOout, + long *overVoltage, + long transferMode); + + +//====================================================================== +// AIStreamStart: Starts a hardware timed continuous acquisition where data +// is sampled and stored in the LabJack RAM buffer, and +// simultaneously transferred out of the RAM buffer to the +// PC application. A call to this function should be +// followed by periodic calls to AIStreamRead, and eventually +// a call to AIStreamClear. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does little +// but simulate execution time. +// stateIOin -Output states for IO0-IO3 (I32). +// updateIO -If >0, state values will be written. Otherwise, +// just reads are performed (I32). +// ledOn -If >0, the LabJack LED is turned on (I32). +// numChannels -Number of channels. 1, 2, or 4 (I32). If +// readCount is >0, numChannels should be 4. +// *channels -Pointer to an array of channel commands with at +// least numChannels elements (I32). Each channel +// command is 0-7 for SE or 8-11 for Diff. +// *gains -Pointer to an array of gain commands with at +// least numChannels elements (I32). Gain commands +// are 0=1,1=2,...,7=20. Gain only available for +// differential channels. +// *scanRate -Scans acquired per second (SGL). A scan is a +// reading from every channel (1,2, or 4). The +// sample rate (scanRate*numChannels) must +// be 200-1200. +// disableCal -If >0, voltages returned will be raw readings +// that are not corrected using calibration +// constants (I32). +// reserved1 -Reserved for future use. Send 0 (I32). +// readCount -If >0, the counter read is returned instead of +// the 2nd, 3rd, and 4th channel (I32). 2nd +// channel is bits 0-11, 3rd channel is bits +// 12-23, and 4th channel is bits 24-31. +// Only works with firmware V1.03 or higher. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *scanRate -Returns the actual scan rate, which due to clock +// resolution is not always exactly the same as the +// desired scan rate (SGL). +//---------------------------------------------------------------------- +long _stdcall AIStreamStart(long *idnum, + long demo, + long stateIOin, + long updateIO, + long ledOn, + long numChannels, + long *channels, + long *gains, + float *scanRate, + long disableCal, + long reserved1, + long readCount); + + +//====================================================================== +// AIStreamRead: Waits for a specified number of scans to be available and +// reads them. AIStreamStart should be called before this +// function and AIStreamClear should be called when finished. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: localID -Send the local ID from AIStreamStart (I32). +// numScans -Function will wait until this number of scans is +// available (I32). Minimum is 1. Maximum +// numSamples is 4096 where numSamples is +// equal to numScans * numChannels. Internally, +// this function gets data from the LabJack in +// blocks of 64 samples, so it is recommended that +// numSamples be at least 64. +// timeout -Function timeout value in seconds (I32). +// *voltages -Voltage readings buffer. Send a 4096 by 4 +// element array of zeros (SGL). +// *stateIOout -IO state readings buffer. Send a 4096 element +// array of zeros (I32). +// Outputs: *voltages -Voltage readings are returned in this 4096 by 4 +// array (SGL). Unused locations are filled +// with 9999s. +// *stateIOout -The states of all 4 IO are returned in this +// array (I32). Unused locations are filled +// with 9999s. +// *reserved -Reserved for future use (I32). +// *ljScanBacklog -Returns the scan backlog of the LabJack RAM +// buffer (I32). +// *overVoltage -If >0, an overvoltage has been detected on +// at least one sample of at least one of the +// analog inputs (I32). +//---------------------------------------------------------------------- +long _stdcall AIStreamRead(long localID, + long numScans, + long timeout, + float (*voltages)[4], + long *stateIOout, + long *reserved, + long *ljScanBacklog, + long *overVoltage); + + +//====================================================================== +// AIStreamClear: This function stops the continuous acquisition. It +// should be called after AIStreamStart and after any +// calls to AIStreamRead. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: localID -Send the local ID from AIStreamStart/Read (I32). +// Outputs: none +//---------------------------------------------------------------------- +long _stdcall AIStreamClear(long localID); + + +//====================================================================== +// AOUpdate: Sets the voltages of the analog outputs. Also +// controls/reads the digital IO and counter. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function +// to be called without a LabJack, and does little +// but simulate execution time. +// trisD -Directions for D0-D16. 0=Input, 1=Output (I32). +// trisIO -Directions for IO0-IO3. 0=Input, 1=Output (I32). +// *stateD -Output states for D0-D16 (I32). +// *stateIO -Output states for IO0-IO3 (I32). +// updateDigital -If >0, tris and state values will be written. +// Otherwise, just a read is performed (I32). +// resetCounter -If >0, the counter is reset to zero after +// being read (I32). +// analogOut0 -Voltage from 0 to 5 for AO0 (SGL). +// analogOut1 -Voltage from 0 to 5 for AO1 (SGL). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *stateD -States of D0-D15 (I32). +// *stateIO -States of IO0-IO3 (I32). +// *count -Current count, before reset (U32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall AOUpdate(long *idnum, + long demo, + long trisD, + long trisIO, + long *stateD, + long *stateIO, + long updateDigital, + long resetCounter, + unsigned long *count, + float analogOut0, + float analogOut1); + + +//====================================================================== +// BitsToVolts: Converts a 12-bit (0-4095) binary value into a LabJack +// voltage. Volts=((2*Bits*Vmax/4096)-Vmax)/Gain where +// Vmax=10 for SE, 20 for Diff. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: chnum -Channel index. 0-7=SE, 8-11=Diff (I32). +// chgain -Gain index. 0=1,1=2,...,7=20 (I32). +// bits -Binary value from 0-4095 (I32). +// Outputs: *volts -Voltage. SE=+/-10, Diff=+/-20 (SGL). +//---------------------------------------------------------------------- +long _stdcall BitsToVolts (long chnum, + long chgain, + long bits, + float *volts); + + +//====================================================================== +//VoltsToBits: Converts a voltage to it's 12-bit (0-4095) binary +// representation. Bits=(4096*((Volts*Gain)+Vmax))/(2*Vmax) +// where Vmax=10 for SE, 20 for Diff. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: chnum -Channel index. 0-7=SE, 8-11=Diff (I32). +// chgain -Gain index. 0=1,1=2,...,7=20 (I32). +// volts -Voltage. SE=+/-10, Diff=+/-20 (SGL). +// Outputs: *bits -Binary value from 0-4095 (I32). +//---------------------------------------------------------------------- +long _stdcall VoltsToBits (long chnum, + long chgain, + float volts, + long *bits); + + +//====================================================================== +// Counter: Controls and reads the counter. The counter is disabled if +// the watchdog timer is enabled. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// resetCounter -If >0, the counter is reset to zero after +// being read (I32). +// enableSTB -If >0, STB is enabled (I32). Only works with +// firmware V1.02 or later. +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *stateD -States of D0-D15 (I32). +// *stateIO -States of IO0-IO3 (I32). +// *count -Current count, before reset (U32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall Counter(long *idnum, + long demo, + long *stateD, + long *stateIO, + long resetCounter, + long enableSTB, + unsigned long *count); + + +//====================================================================== +// DigitalIO: Reads and writes to the digital I/O. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// *trisD -Directions for D0-D15. 0=Input, 1=Output (I32). +// trisIO -Directions for IO0-IO3. 0=Input, 1=Output (I32). +// *stateD -Output states for D0-D15 (I32). +// *stateIO -Output states for IO0-IO3 (I32). +// updateDigital -If >0, tris and state values will be written. +// Otherwise, just a read is performed (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *trisD -Returns a read of the direction registers +// for D0-D15 (I32). +// *stateD -States of D0-D15 (I32). +// *stateIO -States of IO0-IO3 (I32). +// *outputD -Returns a read of the output registers +// for D0-D15 (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall DigitalIO(long *idnum, + long demo, + long *trisD, + long trisIO, + long *stateD, + long *stateIO, + long updateDigital, + long *outputD); + + +//====================================================================== +//GetDriverVersion +// +// Returns: Version number of this DLL (SGL). +// Inputs: none +// Outputs: none +//---------------------------------------------------------------------- +float _stdcall GetDriverVersion(void); + + +//====================================================================== +//GetErrorString +// +// Returns: nothing +// Inputs: errorcode -LabJack errorcode (I32) +// *errorString -Must point to an array of at least 50 +// chars (I8). +// Outputs: *errorString -A sequence a characters describing the error +// will be copied into the char (I8) array. +//---------------------------------------------------------------------- +void _stdcall GetErrorString (long errorcode, + char *errorString); + + +//====================================================================== +//GetFirmwareVersion: Used to retrieve the firmware version from +// the LabJack's processor. +// +// Returns: Version number of the LabJack firmware or 0 for error (SGL). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). If error, returns 512 plus +// a normal LabJack errorcode. +// +// Time: 20 ms +//---------------------------------------------------------------------- +float _stdcall GetFirmwareVersion (long *idnum); + + +//====================================================================== +//GetWinVersion: Uses a Windows API function to get the OS version. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: none +// +// Outputs: (U32) +// Platform Major Minor Build +// Windows 3.1 0 - - - +// Windows 95 1 4 0 950 +// Windows 95 OSR2 1 4 0 1111 +// Windows 98 1 4 10 1998 +// Windows 98SE 1 4 10 2222 +// Windows Me 1 4 90 3000 +// Windows NT 3.51 2 3 51 - +// Windows NT 4.0 2 4 0 1381 +// Windows 2000 2 5 0 2195 +// Windows XP 2 5 1 - +//---------------------------------------------------------------------- +long _stdcall GetWinVersion(unsigned long *majorVersion, + unsigned long *minorVersion, + unsigned long *buildNumber, + unsigned long *platformID, + unsigned long *servicePackMajor, + unsigned long *servicePackMinor); + + +//====================================================================== +// ListAll: Searches the USB for all LabJacks. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *productIDList -Send a 127 element array of zeros (I32). +// *serialnumList -Send a 127 element array of zeros (I32). +// *localIDList -Send a 127 element array of zeros (I32). +// *powerList -Send a 127 element array of zeros (I32). +// *calMatrix -Send a 127 by 20 element array of +// zeros (I32). +// Outputs: *productIDList -Returns the product ID for each LabJack on +// the USB (I32). Unused elements filled +// with 9999s. +// *serialnumList -Returns the serial number for each LabJack +// on the USB (I32). Unused elements filled +// with 9999s. +// *localIDList -Returns the local ID for each LabJack on +// the USB (I32). Unused elements filled +// with 9999s. +// *powerList -Returns the power allowance for each LabJack +// on the USB (I32). Unused elements filled +// with 9999s. +// *calMatrix -Returns the cal constants for each LabJack +// on the USB (I32). Unused elements filled +// with 9999s. +// *numberFound -Number of LabJacks found on the USB (I32). +// *fcddMaxSize -Max size of fcdd (I32). +// *hvcMaxSize -Max size of hvc (I32). +//---------------------------------------------------------------------- +long _stdcall ListAll(long *productIDList, + long *serialnumList, + long *localIDList, + long *powerList, + long (*calMatrix)[20], + long *numberFound, + long *fcddMaxSize, + long *hvcMaxSize); + + +//====================================================================== +// LocalID: Change the local ID number of a LabJack. Changes will not take +// effect until the LabJack is re-enumerated. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// localID -New local ID (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall LocalID(long *idnum, + long localID); + + +//====================================================================== +// NoThread: Use this function to disable/enable (enabled by default) +// thread creation when this DLL reads data from a particular +// LabJack. If noThread is TRUE, it also sends a dummy write +// followed by a dummy write/read to initialize that LabJack, +// since in normal operation the LabJack does not respond to +// the first command after reset/enumeration. +// +// Normally, the DLL creates a thread when it attempts to +// read data from the LabJack. This way, if something goes +// wrong, the thread can be terminated after a timeout +// period rather than the the program just getting stuck +// while it waits for a read that might never complete. +// This would happen if Windows thinks the LabJack is +// present and operating correctly, but the LabJack does +// not send data, or Windows doesn't realize the LabJack +// has sent data. We are not sure if this is possible, but +// just to be safe we normally lauch the read in a thread +// that can be terminated after a timeout period. +// +// We have found 2 situations where creating the thread +// causes a problem: +// 1. When using TestPoint on Windows 98SE (and ME?), +// the Windows API call CreateThread cannot be used +// in a DLL that is being interfaced. +// 2. In VC, creating a thread is very slow in the +// debugger. If you call a function like AISample +// while in the debugger, it might take 200 ms to +// execute instead of 20 ms. +// +// If you fall into case #1 above, or if case #2 is too +// slow for your VC debugging needs, you should call this +// function, NoThread, before calling any other LabJack +// functions. NoThread must be called first thing any +// time the LabJack enumerates. If you use NoThread, but +// are concerned about your program getting stuck, you +// can use the Watchdog function to configure the LabJack +// to reset if it does not communicate with the PC within +// a given time. When the LabJack resets, the read +// function should stop waiting for data and return +// an error. +// +// If the read thread is disabled, the "timeout" +// specified in AIBurst and AIStreamRead is also disabled. +// +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// noThread -If >0, the thread will not be used (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 80 ms +//---------------------------------------------------------------------- +long _stdcall NoThread(long *idnum, long noThread); + + + +//====================================================================== +//ThreadTest: Simply creates a thread which exits right after doing nothing. +//---------------------------------------------------------------------- +long _stdcall ThreadTest(long timeoutms); + + + +//====================================================================== +// PulseOut: Requires firmware V1.05 or higher. +// +// The timeout of this function, in milliseconds, is set to: +// 5000+numPulses*((B1*C1*0.02)+(B2*C2*0.02)) +// +// This command creates pulses on any/all of D0-D7. The +// desired D lines must be set to output using another +// function (DigitalIO or AOUpdate). All selected lines +// are pulsed at the same time, at the same rate, for the +// same number of pulses. +// +// This function commands the time for the first half cycle +// of each pulse, and the second half cycle of each pulse. +// Each time is commanded by sending a value B & C, where +// the time is, +// +// 1st half-cycle microseconds = ~17 + 0.83*C + 20.17*B*C +// 2nd half-cycle microseconds = ~12 + 0.83*C + 20.17*B*C +// +// which can be approximated as, +// +// microseconds = 20*B*C +// +// For best accuracy when using the approximation, minimize C. +// B and C must be between 1 and 255, so each half cycle can +// vary from about 38/33 microseconds to just over 1.3 seconds. +// +// If you have enabled the LabJack Watchdog function, make sure +// it's timeout is longer than the time it takes to output all +// pulses. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// lowFirst -If >0, each line is set low then high, otherwise +// the lines are set high then low (I32). +// bitSelect -Set bits 0 to 7 to enable pulsing on each of +// D0-D7 (I32, 0-255). +// numPulses -Number of pulses for all lines (I32, 1-32767). +// timeB1 -B value for first half cycle (I32, 1-255). +// timeC1 -C value for first half cycle (I32, 1-255). +// timeB2 -B value for second half cycle (I32, 1-255). +// timeC2 -C value for second half cycle (I32, 1-255). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms plus pulse time (make sure watchdog is longer if active) +//---------------------------------------------------------------------- +long _stdcall PulseOut(long *idnum, + long demo, + long lowFirst, + long bitSelect, + long numPulses, + long timeB1, + long timeC1, + long timeB2, + long timeC2); + + +//====================================================================== +// PulseOutStart: Requires firmware V1.07 or higher. +// +// PulseOutStart and PulseOutFinish are used as an +// alternative to PulseOut. PulseOutStart starts the +// pulse output and returns without waiting for the +// finish. PulseOutFinish waits for the LabJack's +// response which signifies the end of the pulse +// output. If anything besides PulseOutFinish is +// called after PulseOutStart, the pulse output +// will be terminated and the LabJack will execute +// the new command. +// +// Note that due to boot-up tests on the LabJack +// U12, if PulseOutStart is the first command sent +// to the LabJack after reset or power-up, there +// would be no response for PulseOutFinish. In +// practice, even if no precautions were taken, this +// would probably never happen, since before calling +// PulseOutStart a call is needed to set the desired +// D lines to output. +// +// Also note that PulseOutFinish must be called before +// the LabJack completes the pulse output to read the +// response. If PulseOutFinish is not called until +// after the LabJack sends it's response, the function +// will never receive the response and will timeout. +// +// This command creates pulses on any/all of D0-D7. The +// desired D lines must be set to output using another +// function (DigitalIO or AOUpdate). All selected lines +// are pulsed at the same time, at the same rate, for the +// same number of pulses. +// +// This function commands the time for the first half cycle +// of each pulse, and the second half cycle of each pulse. +// Each time is commanded by sending a value B & C, where +// the time is, +// +// 1st half-cycle microseconds = ~17 + 0.83*C + 20.17*B*C +// 2nd half-cycle microseconds = ~12 + 0.83*C + 20.17*B*C +// +// which can be approximated as, +// +// microseconds = 20*B*C +// +// For best accuracy when using the approximation, minimize C. +// B and C must be between 1 and 255, so each half cycle can +// vary from about 38/33 microseconds to just over 1.3 seconds. +// +// If you have enabled the LabJack Watchdog function, make sure +// it's timeout is longer than the time it takes to output all +// pulses. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// lowFirst -If >0, each line is set low then high, otherwise +// the lines are set high then low (I32). +// bitSelect -Set bits 0 to 7 to enable pulsing on each of +// D0-D7 (I32, 0-255). +// numPulses -Number of pulses for all lines (I32, 1-32767). +// timeB1 -B value for first half cycle (I32, 1-255). +// timeC1 -C value for first half cycle (I32, 1-255). +// timeB2 -B value for second half cycle (I32, 1-255). +// timeC2 -C value for second half cycle (I32, 1-255). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +//---------------------------------------------------------------------- +long _stdcall PulseOutStart (long *idnum, + long demo, + long lowFirst, + long bitSelect, + long numPulses, + long timeB1, + long timeC1, + long timeB2, + long timeC2); + + +//====================================================================== +// PulseOutFinish: Requires firmware V1.07 or higher. +// +// PulseOutStart and PulseOutFinish are used as an +// alternative to PulseOut. PulseOutStart starts the +// pulse output and returns without waiting for the +// finish. PulseOutFinish waits for the LabJack's +// response which signifies the end of the pulse +// output. If anything besides PulseOutFinish is +// called after PulseOutStart, the pulse output +// will be terminated and the LabJack will execute +// the new command. +// +// Note that due to boot-up tests on the LabJack +// U12, if PulseOutStart is the first command sent +// to the LabJack after reset or power-up, there +// would be no response for PulseOutFinish. In +// practice, even if no precautions were taken, this +// would probably never happen, since before calling +// PulseOutStart a call is needed to set the desired +// D lines to output. +// +// Also note that PulseOutFinish must be called before +// the LabJack completes the pulse output to read the +// response. If PulseOutFinish is not called until +// after the LabJack sends it's response, the function +// will never receive the response and will timeout. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// timeoutMS -Amount of time, in milliseconds, that this +// function will wait for the Pulseout response (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +//---------------------------------------------------------------------- +long _stdcall PulseOutFinish (long *idnum, + long demo, + long timeoutMS); + + +//====================================================================== +// PulseOutCalc: +// +// This function can be used to calculate the cycle times +// for PulseOut or PulseOutStart. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *frequency -Desired frequency in Hz (SGL). +// Outputs: *frequency -Actual best frequency found in Hz (SGL). +// *timeB -B value for first and second half cycle (I32). +// *timeC -C value for first and second half cycle (I32). +// +// Time: +//---------------------------------------------------------------------- +long _stdcall PulseOutCalc( float *frequency, + long *timeB, + long *timeC); + + +//====================================================================== +// ReEnum: Causes the LabJack to detach and re-attach from the bus +// so it will re-enumerate. Configuration constants (local ID, +// power allowance, calibration data) are updated. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 10 ms +//---------------------------------------------------------------------- +long _stdcall ReEnum(long *idnum); + + +//====================================================================== +// Reset: Causes the LabJack to reset after about 2 seconds. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 10 ms +//---------------------------------------------------------------------- +long _stdcall Reset(long *idnum); + + +//====================================================================== +// ResetLJ: Same as "Reset". +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 10 ms +//---------------------------------------------------------------------- +long _stdcall ResetLJ(long *idnum); + + +//====================================================================== +// SHT1X: This function retrieves temperature and/or humidity +// readings from a SHT1X sensor. Data rate is about 2 kbps +// with firmware V1.09 or higher (hardware communication). +// If firmware is less than V1.09, or TRUE is passed for +// softComm, data rate is about 20 bps. +// +// DATA = IO0 +// SCK = IO1 +// +// The EI-1050 has an extra enable line that allows multiple +// probes to be connected at the same time using only the one +// line for DATA and one line for SCK. This function does not +// control the enable line. +// +// This function automatically configures IO0 has an input +// and IO1 as an output. +// +// Note that internally this function operates on the state and +// direction of IO0 and IO1, and to operate on any of the IO +// lines the LabJack must operate on all 4. The DLL keeps track +// of the current direction and output state of all lines, so that +// this function can operate on IO0 and IO1 without changing +// IO2 and IO3. When the DLL is first loaded, +// though, it does not know the direction and state of +// the lines and assumes all directions are input and +// output states are low. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// softComm -If >0, forces software based communication. Otherwise +// software communication is only used if the LabJack U12 +// firmware version is less than V1.09. +// mode -0=temp and RH,1=temp only,2=RH only. If mode is 2, +// the current temperature must be passed in for the +// RH corrections using *tempC. +// statusReg -Current value of the SHT1X status register. The +// value of the status register is 0 unless you +// have used advanced functions to write to the +// status register (enabled heater, low resolution, or +// no reload from OTP). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *tempC -Returns temperature in degrees C. If mode is 2, +// the current temperature must be passed in for the +// RH corrections. +// *tempF -Returns temperature in degrees F. +// *rh -Returns RH in percent. +// +// Time: About 20 ms plus SHT1X measurement time for hardware comm. +// Default measurement time is 210 ms for temp and 55 ms for RH. +// About 2 s per measurement for software comm. +//---------------------------------------------------------------------- +long _stdcall SHT1X( long *idnum, + long demo, + long softComm, + long mode, + long statusReg, + float *tempC, + float *tempF, + float *rh); + + +//====================================================================== +// SHTComm: Low-level public function to send and receive up to 4 bytes +// to from an SHT1X sensor. Data rate is about 2 kbps +// with firmware V1.09 or higher (hardware communication). +// If firmware is less than V1.09, or TRUE is passed for +// softComm, data rate is about 20 bps. +// +// DATA = IO0 +// SCK = IO1 +// +// The EI-1050 has an extra enable line that allows multiple +// probes to be connected at the same time using only the one +// line for DATA and one line for SCK. This function does not +// control the enable line. +// +// This function automatically configures IO0 has an input +// and IO1 as an output. +// +// Note that internally this function operates on the state and +// direction of IO0 and IO1, and to operate on any of the IO +// lines the LabJack must operate on all 4. The DLL keeps track +// of the current direction and output state of all lines, so that +// this function can operate on IO0 and IO1 without changing +// IO2 and IO3. When the DLL is first loaded, +// though, it does not know the direction and state of +// the lines and assumes all directions are input and +// output states are low. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// softComm -If >0, forces software based communication. Otherwise +// software communication is only used if the LabJack U12 +// firmware version is less than V1.09. +// waitMeas -If >0, this is a T or RH measurement request. +// serialReset -If >0, a serial reset is issued before sending and +// receiving bytes. +// dataRate -0=no extra delay (default),1=medium delay,2=max delay. +// numWrite -Number of bytes to write (0-4,I32). +// numRead -Number of bytes to read (0-4,I32). +// *datatx -Array of 0-4 bytes to send. Make sure you pass at least +// numWrite number of bytes (U8). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *datarx -Returns 0-4 read bytes as determined by numRead (U8). +// +// Time: About 20 ms plus SHT1X measurement time for hardware comm. +// Default measurement time is 210 ms for temp and 55 ms for RH. +// About 2 s per measurement for software comm. +//---------------------------------------------------------------------- +long _stdcall SHTComm( long *idnum, + long softComm, + long waitMeas, + long serialReset, + long dataRate, + long numWrite, + long numRead, + unsigned char *datatx, + unsigned char *datarx); + + +//====================================================================== +// SHTCRC: Checks the CRC on a SHT1X communication. Last byte of +// datarx is the CRC. Returns 0 if CRC is good, or +// SHT1X_CRC_ERROR_LJ if CRC is bad. +//---------------------------------------------------------------------- +long _stdcall SHTCRC( long statusReg, + long numWrite, // 0-4 + long numRead, // 0-4 + unsigned char *datatx, //4 byte write array + unsigned char *datarx); //4 byte read array + + +//====================================================================== +// Synch: Requires firmware V1.09 or higher. +// +// This function performs SPI communication. Data rate is +// about 160 kbps with no extra delay, although delays of +// 100 us or 1 ms per bit can be enabled. +// +// Control of CS (chip select) can be enabled in this +// function for D0-D7 or handled externally via any digital +// output. +// +// MOSI is D13 +// MISO is D14 +// SCK is D15 +// +// If using the CB25, the protection resistors might need to be +// shorted on all SPI connections (MOSI,MISO,SCK,CS). +// +// The initial state of SCK is set properly (CPOL), by +// this function, before !CS is brought low (final state is also +// set properly before !CS is brought high again). If chip-select +// is being handled manually, outside of this function, care +// must be taken to make sure SCK is initially set to CPOL. +// +// All modes supported (A, B, C, and D). +// +// Mode A: CPHA=1, CPOL=1 +// Mode B: CPHA=1, CPOL=0 +// Mode C: CPHA=0, CPOL=1 +// Mode D: CPHA=0, CPOL=0 +// +// If Clock Phase (CPHA) is 1, data is valid on the edge +// going to CPOL. If CPHA is 0, data is valid on the edge +// going away from CPOL. +// Clock Polarity (CPOL) determines the idle state of SCK. +// +// Up to 18 bytes can be written/read. Communication is full +// duplex so 1 byte is read at the same time each byte is written. +// If more than 4 bytes are written or read, this function uses +// calls to WriteMem/ReadMem to load/read the LabJack's data buffer. +// +// This function has the option (configD) to automatically configure +// default state and direction for MOSI (D13 Output), MISO (D14 Input), +// SCK (D15 Output CPOL), and CS (D0-D7 Output High for !CS). This +// function uses a call to DigitalIO to do this. Similar to +// EDigitalIn and EDigitalOut, the DLL keeps track of the current +// direction and output state of all lines, so that these 4 D lines +// can be configured without affecting other digital lines. When the +// DLL is first loaded, though, it does not know the direction and +// state of the lines and assumes all directions are input and +// output states are low. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// mode -Specify SPI mode as: 0=A,1=B,2=C,3=D (I32, 0-3). +// msDelay -If >0, a 1 ms delay is added between each bit. +// husDelay -If >0, a hundred us delay is added between each bit. +// controlCS -If >0, D0-D7 is automatically controlled as CS. The +// state and direction of CS is only tested if control +// is enabled. +// csLine -D line to use as CS if enabled (I32, 0-7). +// csState -Active state for CS line. This would be 0 for the +// normal !CS, or >0 for the less common CS. +// configD -If >0, state and tris are configured for D13, D14, +// D15, and !CS. +// numWriteRead -Number of bytes to write and read (I32, 1-18). +// *data -Serial data buffer. Send an 18 element +// array of bytes. Fill unused locations with zeros (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *data -Serial data buffer. Returns any serial read +// data. Unused locations are filled +// with 9999s. (I32). +// +// Time: 20 ms to read & write up to 4 bytes, plus 40 ms for each +// additional 4 bytes to read or write. Extra 20 ms if configIO +// is true. Extra time if delays are enabled. +//---------------------------------------------------------------------- +long _stdcall Synch( long *idnum, + long demo, + long mode, + long msDelay, + long husDelay, + long controlCS, + long csLine, + long csState, + long configD, + long numWriteRead, + long *data); + + +//====================================================================== +// Watchdog: Controls the LabJack watchdog function. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// demo -Send 0 for normal operation, >0 for demo +// mode (I32). Demo mode allows this function to +// be called without a LabJack, and does little but +// simulate execution time. +// active -Enables the LabJack watchdog function. If +// enabled, the 32-bit counter is disabled. +// timeout -Timer reset value in seconds (I32). +// reset -If >0, the LabJack will reset on timeout (I32). +// activeDn -If >0, Dn will be set to stateDn upon +// timeout (I32). +// stateDn -Timeout state of Dn, 0=low, >0=high (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall Watchdog(long *idnum, + long demo, + long active, + long timeout, + long reset, + long activeD0, + long activeD1, + long activeD8, + long stateD0, + long stateD1, + long stateD8); + + +//====================================================================== +// ReadMem: Reads 4 bytes from a specified address in the LabJack's +// nonvolatile memory. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// address -Starting address of data to read +// from 0-8188 (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// *data3 -Byte at address (I32). +// *data2 -Byte at address+1 (I32). +// *data1 -Byte at address+2 (I32). +// *data0 -Byte at address+3 (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall ReadMem(long *idnum, + long address, + long *data3, + long *data2, + long *data1, + long *data0); + + +//====================================================================== +// WriteMem: Writes 4 bytes to the LabJack's nonvolatile memory at a +// specified address. The data is read back and verified +// after the write. Memory 0-511 is used for configuration +// and calibration data. Memory from 512-1023 is unused by the +// the LabJack and available for the user (this corresponds to +// starting addresses from 512-1020). Memory 1024-8191 is +// used as a data buffer in hardware timed AI modes. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *idnum -Local ID, Serial Number, or -1 for first +// found (I32). +// unlocked -If >0, addresses 0-511 are unlocked for +// writing (I32). +// address -Starting address for writing 0-8188 (I32). +// data3 -Byte for address (I32). +// data2 -Byte for address+1 (I32). +// data1 -Byte for address+2 (I32). +// data0 -Byte for address+3 (I32). +// Outputs: *idnum -Returns the Local ID or -1 if no LabJack is +// found (I32). +// +// Time: 20 ms +//---------------------------------------------------------------------- +long _stdcall WriteMem(long *idnum, + long unlocked, + long address, + long data3, + long data2, + long data1, + long data0); + + +//====================================================================== +// LJHash: Hashing function used internally. +// +// Returns: LabJack errorcodes or 0 for no error (I32). +// Inputs: *inBuffer -Input buffer (U8). +// size -Size of input buffer (I32). +// mode -Reserved for future use (I32). +// Outputs: *outBuffer -16 byte array used to hold output (U8). +// +// Time: 10 ms +//---------------------------------------------------------------------- +long _stdcall LJHash(unsigned char *inBuffer, + long size, + unsigned char *outBuffer, + long mode); + +#if defined(__cplusplus) +} +#endif + diff --git a/deps/labjack/windows/ljackuw32.lib b/deps/labjack/windows/ljackuw32.lib new file mode 100644 index 0000000..6a83c98 Binary files /dev/null and b/deps/labjack/windows/ljackuw32.lib differ diff --git a/deps/labjack/windows/ljackuw64.lib b/deps/labjack/windows/ljackuw64.lib new file mode 100644 index 0000000..60563af Binary files /dev/null and b/deps/labjack/windows/ljackuw64.lib differ diff --git a/src/labjack.zig b/src/labjack.zig index eb5240b..fe4c4bf 100644 --- a/src/labjack.zig +++ b/src/labjack.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); pub fn getDriverVersion() f32 { return c_api.GetDriverVersion(); @@ -289,6 +290,11 @@ pub const PackedOutput = packed struct(u4) { } }; +const Call: std.builtin.CallingConvention = if (builtin.os.tag == .windows and builtin.cpu.arch == .x86) + .Stdcall +else + .C; + pub const c_api = struct { pub const vendor_id: u16 = 0x0CD5; pub const u12_product_id: u16 = 0x0001; @@ -300,9 +306,9 @@ pub const c_api = struct { idnum: *c_long, serialnum: *c_long, caldata: *[20]c_long, - ) c_long; + ) callconv(Call) c_long; - pub extern fn CloseAll(local_id: c_long) c_long; + pub extern fn CloseAll(local_id: c_long) callconv(Call) c_long; pub extern fn GetU12Information( handle: *anyopaque, @@ -312,7 +318,7 @@ pub const c_api = struct { cal_data: *[20]c_long, fcdd_max_size: *c_long, hvc_max_size: *c_long, - ) c_long; + ) callconv(Call) c_long; pub extern fn EAnalogIn( idnum: *c_long, @@ -321,14 +327,14 @@ pub const c_api = struct { gain: c_long, overVoltage: *c_long, voltage: *f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn EAnalogOut( idnum: *c_long, demo: c_long, analogOut0: f32, analogOut1: f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn ECount( idnum: *c_long, @@ -336,7 +342,7 @@ pub const c_api = struct { resetCounter: c_long, count: *f64, ms: *f64, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn EDigitalIn( idnum: *c_long, @@ -344,7 +350,7 @@ pub const c_api = struct { channel: c_long, readD: c_long, state: *c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn EDigitalOut( idnum: *c_long, @@ -352,7 +358,7 @@ pub const c_api = struct { channel: c_long, writeD: c_long, state: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AsynchConfig( idnum: *c_long, @@ -367,7 +373,7 @@ pub const c_api = struct { halfA: c_long, halfB: c_long, halfC: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn Asynch( idnum: *c_long, @@ -380,7 +386,7 @@ pub const c_api = struct { numWrite: c_long, numRead: c_long, data: [*]c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AISample( idnum: *c_long, @@ -394,7 +400,7 @@ pub const c_api = struct { disableCal: c_long, overVoltage: *c_long, voltages: *[4]f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AIBurst( idnum: *c_long, @@ -415,7 +421,7 @@ pub const c_api = struct { stateIOout: *[4096]c_long, overVoltage: *c_long, transferMode: c_long, // 0=auto,1=normal,2=turbo - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AIStreamStart( idnum: *c_long, @@ -430,7 +436,7 @@ pub const c_api = struct { disableCal: c_long, reserved1: c_long, // always 0 readCount: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AIStreamRead( localID: c_long, @@ -441,11 +447,11 @@ pub const c_api = struct { reserved: ?*c_long, // unused ljScanBacklog: *c_long, overVoltage: *c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AIStreamClear( localID: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn AOUpdate( idnum: *c_long, @@ -459,21 +465,21 @@ pub const c_api = struct { count: [*c]c_ulong, analogOut0: f32, analogOut1: f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn BitsToVolts( chnum: c_long, chgain: c_long, bits: c_long, volts: [*c]f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn VoltsToBits( chnum: c_long, chgain: c_long, volts: f32, bits: [*c]c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn Counter( idnum: *c_long, @@ -483,7 +489,7 @@ pub const c_api = struct { resetCounter: c_long, enableSTB: c_long, count: [*c]c_ulong, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn DigitalIO( idnum: *c_long, @@ -494,12 +500,12 @@ pub const c_api = struct { stateIO: *c_long, // 4 bits updateDigital: c_long, outputD: *c_long, // 16 bits - ) LabjackCError; + ) callconv(Call) LabjackCError; - pub extern fn GetDriverVersion() f32; - pub extern fn StaticErrorString(errorcode: c_long) [*:0]const u8; - pub extern fn GetErrorString(errorcode: c_long, errorString: *[50]u8) void; - pub extern fn GetFirmwareVersion(idnum: *c_long) f32; + pub extern fn GetDriverVersion() callconv(Call) f32; + pub extern fn StaticErrorString(errorcode: c_long) callconv(Call) [*:0]const u8; + pub extern fn GetErrorString(errorcode: c_long, errorString: *[50]u8) callconv(Call) void; + pub extern fn GetFirmwareVersion(idnum: *c_long) callconv(Call) f32; pub extern fn ListAll( productIDList: *[127]c_long, @@ -510,12 +516,12 @@ pub const c_api = struct { numberFound: *c_long, fcddMaxSize: *c_long, hvcMaxSize: *c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn LocalID( idnum: *c_long, localID: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn PulseOut( idnum: *c_long, @@ -527,7 +533,7 @@ pub const c_api = struct { timeC1: c_long, timeB2: c_long, timeC2: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn PulseOutStart( idnum: *c_long, @@ -539,24 +545,24 @@ pub const c_api = struct { timeC1: c_long, timeB2: c_long, timeC2: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn PulseOutFinish( idnum: *c_long, demo: c_long, timeoutMS: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn PulseOutCalc( frequency: *f32, timeB: *c_long, timeC: *c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; - pub extern fn ReEnum(idnum: *c_long) LabjackCError; - pub extern fn Reset(idnum: *c_long) LabjackCError; - pub extern fn ResetLJ(idnum: *c_long) LabjackCError; - pub extern fn CloseLabJack(localID: c_long) LabjackCError; + pub extern fn ReEnum(idnum: *c_long) callconv(Call) LabjackCError; + pub extern fn Reset(idnum: *c_long) callconv(Call) LabjackCError; + pub extern fn ResetLJ(idnum: *c_long) callconv(Call) LabjackCError; + pub extern fn CloseLabJack(localID: c_long) callconv(Call) LabjackCError; pub extern fn SHT1X( idnum: *c_long, @@ -567,7 +573,7 @@ pub const c_api = struct { tempC: *f32, tempF: *f32, rh: *f32, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn SHTComm( idnum: *c_long, @@ -579,7 +585,7 @@ pub const c_api = struct { numRead: c_long, datatx: [*]u8, // numWrite length datarx: [*]u8, // numRead length - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn SHTCRC( statusReg: c_long, @@ -587,7 +593,7 @@ pub const c_api = struct { numRead: c_long, datatx: *[4]u8, datarx: *[4]u8, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn Synch( idnum: *c_long, @@ -601,7 +607,7 @@ pub const c_api = struct { configD: c_long, numWriteRead: c_long, data: *[18]c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn Watchdog( idnum: *c_long, @@ -615,7 +621,7 @@ pub const c_api = struct { stateD0: c_long, stateD1: c_long, stateD8: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn ReadMem( idnum: *c_long, @@ -624,7 +630,7 @@ pub const c_api = struct { data2: *c_long, data1: *c_long, data0: *c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub extern fn WriteMem( idnum: *c_long, @@ -634,7 +640,7 @@ pub const c_api = struct { data2: c_long, data1: c_long, data0: c_long, - ) LabjackCError; + ) callconv(Call) LabjackCError; pub const LabjackCError = packed struct(c_ulong) { code: LabjackErrorCode,