Uploads .HEX firmware files to devices that show up with “(D15 Lo)” in Device Manager. This can be used to delayed-load the usual firmware, or to load a custom firmware. In any case, .HEX firmware files are usually only provided by tech support.

A script looks something like this:

0040=C:\Dev\DebugReport\USB_8040.hex
0140=C:\Dev\DebugReport\USB_8140.hex

For each “(D15 Lo)” device found, if its PID is in the script and a valid .HEX firmware file is at the matching path in the script, then that firmware is uploaded to that device. A later entry with the same PID overrides any earlier entries. The top bit in the script PIDs is ignored, so you can specify the regular PID instead of the “(D15 Lo)” PID if you prefer, for example 8140 instead of 0140.

pFirmScript

A pointer to a null-terminated Windows-1252(ANSI) string, which is a multiline table of “Hex PID=Firmware File Path” pairs. Lines are delimited with CR, or LF, or CRLF.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Configures Digital Input/Output “I/O Groups” for use as input or as output digital bits, and set the state of any output bits. On some products can globally enable/tristate all DIO bits.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

bTristate

TRUE causes all bits on the device to enter tristate (high-impedance) mode. FALSE removes the tristate. The tristate is changed after the remainder of the configuration has occurred. All devices with this feature power-on in the "tristate" mode at this time.

pOutMask

A pointer to array of bits; one bit per “I/O Group”. Each "1" bit in the array indicates that the corresponding “I/O Group” of the device is to be configured as output.

pData

A pointer to an array of bytes. Each byte is copied to the digital output ports on the device before the ports are taken out of tristate. Any bytes in the array associated with ports configured as input are ignored.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

In this context “I/O Group” means “a group of one or more DIO bits for which a single direction control bit determines the input vs output state for all the bits in the group.”

Most devices use 1 bit per 8 DIO pins; others use 1 bit per DIO pin. Other groupings are possible: the USB-DIO-16H family has 4 "I/O Group" bits; one for the 8-bit group A, one for the 4-bit group B, and one each for the 3-bit groups C and D.

When more than one bit is in each group, “I/O Groups” are often referred to as “Ports”. In these cases, the length of the array pointed to by pData should be the same number of bytes as the number of “I/O Group” control bits, even if a specific “I/O Group” contains fewer than 8 bits - significant bits are LSB aligned, and extra bits are ignored.

However, in the “one bit per group” case (USB-DIO-32I, for example), pData is effectively an array of bits, not bytes, as each bit is copied onto the output bits in a 1-to-1 fashion.

The sizes of the out mask and data for some specific DIO boards are as follows:

Configure Digital Input/Output “I/O Groups” for use as input or as output digital bits, and set the state of any output bits. On some products can globally enable/tristate all DIO bits.

Please refer to DIO_Configure for additional information.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

pOutMask

A pointer to array of bits; one bit per “I/O Group”. Each "1" bit in the array indicates that the corresponding “I/O Group” of the device is Output.

pData

A pointer to an array of bytes. Each byte is copied to the digital output ports on the device before the ports are taken out of tristate. Any bytes in the array associated with ports configured as input are ignored.

pTristateMask

A pointer to array of bits; one bit per “Tristate Group”. Each "1" bit in the array indicates that the corresponding “Tristate Group” of the device is to be tristated.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Performs some to all of the same operations as DIO_ConfigureEx, in a process-safe (and thread-safe) manner. It can write to a single bit or a single byte without changing anything else, it can change the tristates and output values without changing the direction, etc. This function provides the most flexible "total control" over digital bits, and is thus the most complex digital function to use.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

pOuts

A null pointer, or a pointer to an array of bits; one bit per “I/O Group”. For each bit that's "masked in" by the pOutsMask array, a "1" indicates that the corresponding “I/O Group” of the device is Output, while a "0" similarly indicates Input. A null pointer indicates Input, on all bits "masked in".

pOutsMask

A null pointer, or a pointer to an array of bits; the same size as for pOuts. For each bit in the array, "1" indicates that the corresponding bit of the pOuts array is "masked in" and controls the direction of an “I/O Group”, while a "0" similarly indicates that the corresponding bit of the pOuts array is "masked out" and ignored. If both pOuts and pOutsMask are null pointers, then all bits are "masked out". If pOutsMask is a null pointer but pOuts points to an array, then all bits are "masked in".

pData

A pointer to an array of bytes. Each bit that's "masked in" by the pDataMask array is copied to the digital output ports on the device, before the ports are taken out of tristate. Any bytes in the array associated with ports configured as input are ignored, and any output bits "masked out" by pDataMask are unchanged. A null pointer indicates "1" (logic high), on all bits "masked in".

pDataMask

A null pointer, or a pointer to an array of bytes; the same size as for pData. pDataMask controls pData the same way pOutsMask controls pOuts. If both pData and pDataMask are null pointers, then all bits are "masked out". If pDataMask is a null pointer but pData points to an array, then all bits are "masked in".

pTristates

A null pointer, or a pointer to array of bits; one bit per “Tristate Group”. For each bit that's "masked in" by the pTristatesMask array, a "1" indicates that the corresponding “Tristate Group” of the device is to be tristated, while a "0" similarly indicates enabled(un-tristated). A null pointer indicates enabled, on all bits "masked in".

pTristatesMask

A null pointer, or a pointer to an array of bits; the same size as for pTristates. pTristatesMask controls pTristates the same way pOutsMask controls pOuts, except that a null pointer always indicates all bits are "masked in".

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Please refer to DIO_Configure for additional information.

DIO_ConfigureMasked is the most complex and most powerful of the DIO_Configure… functions, and can also work like DIO_Write… but more powerful. In general, decide what you want to control and put "1"s in the mask array for that, and leave everything else "0" or a null pointer. It may be easiest to understand from some examples:

• With all null pointers, DIO_ConfigureMasked enables(untristates) everything, without making any other changes. In the usual case the tristate feature is only used during boot, and DIO_ConfigureMasked is optimized for this case.
• In order to write to all digital outputs(and enable them), pass null pointers for every parameter except pData, and pass the new output state in the pData array. If you don't want to enable(un-tristate) the digital bits in the process, then also pass an array of all "0" for pTristatesMask.
• In order to write to a single bit of digital output(and enable), pass null pointers for every parameter except pData and pDataMask; for pDataMask, pass an array with all "0" except for a "1" in the single bit to write; for pData, put the bit state to write in the corresponding bit position.
• In order to control a single “I/O Group” while leaving the rest to be controlled by other programs, keep around arrays for pOutsMask, pDataMask, and pTristatesMask that have "1" for the desired portion of the digital bits, then adjust the arrays for pOuts, pData, and pTristates as desired.

Write to all digital outputs on a device. Bits written to ports configured as “input” will be ignored.

This is the most efficient method of writing to digital outputs, because it consumes one USB transaction, regardless of the number of bits on the device.

DeviceIndex

The Index of the device to control; generally either diOnly or a specific device's device index.

pData

A pointer to the first element of an array of bytes. Each byte is copied to the corresponding output byte. Bytes written to ports configured as inputs are ignored. The number of bytes in the pData array needs to be the same as described for “pData” under DIO_Configure.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Write to a single byte-worth of digital outputs on a device.

Bytes written to ports configured as “input” are ignored.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

ByteIndex

Number of the byte you wish to change.

Data

One byte. The byte will be copied to the port outputs. Each set bit will cause the equivalent port bit to be set to "1".

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function is usually implemented in the DLL: the DLL remembers the most recently written DIO data for all ports, and merges the byte sent to DIO_Write8(), then sends the actual hardware a DIO_WriteAll() command. Therefore:

• Do not use this function simultaneously to control digital bits on a single device from multiple processes, use DIO_ConfigureMasked instead.
• This function will give unexpected results unless you call DIO_WriteAll or DIO_Configure… first.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BitIndex

Number of the bit you wish to change.

bData

TRUE will set the bit to "1", FALSE will clear the bit to "0".

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Bits written to ports configured as “input” are ignored.

On the USB-IIRO-xx and USB-IDIO-xx families, the outputs are bits 0-15; the inputs are bits 16-31. This is true even for 8-bit models, and models with only inputs. E.g. the USB-II-8's first input bit is located at BitIndex 16.

This function is usually implemented in the DLL: the DLL remembers the most recently written DIO data for all ports, and merges the bit sent to DIO_Write1(), then sends the actual hardware a DIO_WriteAll() command. Therefore, do not use this function simultaneously to control digital bits on a single device from multiple processes.

Also, on boards that do not need a DIO_Configure() call before outputs are operational, make sure to call DIO_WriteAll() at least once, to initialize the DLL's memory. You can call DIO_Configure() instead of DIO_WriteAll(), and doing so helps future-proof your code for compatibility with other devices.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pData

A pointer to the first element of an array of bytes. Each port will be read, and the reading stored in the corresponding byte in the array.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

The number of bytes in the pBuffer array needs to be the same as described for “pData” under DIO_Configure. This operation consumes one USB transaction, regardless of the number of bits on the device.

The USB-IIRO-xx and USB-IDIO-xx families' inputs are bytes 2 and 3; the outputs' readback are bytes 0 and 1 in the array. This is true even for 8-bit models, and models with only inputs. E.g. the USB-II-8's input byte is located at Data[2].

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

ByteIndex

Number of the byte you wish to read.

pData

A pointer to one byte. The byte will contain the reading or readback from the port specified by ByteIndex. Each set bit indicates the equivalent port bit read as "1".

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

The USB-IIRO-xx and USB-IDIO-xx families' inputs are bytes 2 and 3; the outputs are bytes 0 and 1. This is true even for 8-bit models, and models with only inputs. E.g. the USB-II-8's first input byte is located at ByteIndex 2.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

BitIndex

Number of the bit you wish to read.

pData

Pointer to one byte; will be set to “1” or “0” to indicate the state of the bit read (or readback).

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

On the USB-IIRO-xx and USB-IDIO-xx families, the inputs are bits 16-31; the outputs are bits 0-15. This is true even for 8-bit models, and models with only inputs. E.g. the USB-II-8's first input bit is located at BitIndex 16.

Determine DIO port direction and tristate-related information about the device found at a specific device index.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pOutMask

A pointer to the first element of an array of bytes; one byte per 8 ports or fraction. Each bit in the array will be set to "1" if the corresponding port is an output, or "0" if it's an input.

pTristateMask

A pointer to the first element of an array of bytes; one byte per 8 tristate groups or fraction. Each bit in the array will be set to "1" if the corresponding tristate group is in tristate (high-impedance) mode, or a "0" if not.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function is not yet implemented on all devices. Please consult with the factory if you need to use it.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

bIsRead

Boolean. TRUE will open a stream for reading, FALSE will open a stream for writing.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Call DIO_ConfigureEx() and DIO_StreamSetClocks() as well, before sending/receiving data using DIO_StreamFrame().

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

For best results, should be called before your application closes.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

pReadClockHz

A pointer to an IEEE double-precision value indicating the desired frequency of an internal read clock.

pWriteClockHz

A pointer to an IEEE double-precision value indicating the desired frequency of an internal write clock.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Use "0" to indicate “External clock mode”.

The Read and Write clock variables will be modified to indicate the Hz rate to which the unit will actually be configured: not all frequencies you can specify with a IEEE double can be achieved by the frequency generation circuit. Our DLL calculates the closest achievable frequency. If you're interested, you can consult the LTC6904 chipspec for details, or the provided source for the DLL.

The slowest available frequency from the onboard generator is 1kHz; the fastest usable is 40MHz (the limit of the standard FIFO); the fastest useful for non-burst operation is ~8MHz (the streaming bandwidth limit of the USB→digital interface logic and code is 8MHz minimum, often as high as 12MHz if your computer is well optimized.)

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

FramePoints

Number of WORD-sized points to stream.

pFrameData

Pointer to the beginning of the block of data you wish to stream.

BytesTransferred

Pointer to a DWORD that will receive the amount of data actually transferred, in BYTEs.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function is used for either input or output operation. “Stream” can be interpreted “upload,” “write,” “read,” “download,” “send,” “receive,” or any similar term.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

Mode

A number from 0 to 5, specifying to which 8254 mode you want the specified counter to be configured.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Calling CTR_8254Mode() will halt the counter specified until it gets “loaded” by calling CTR_8254Load() or the like.

This can be used to convert a counter into an additional, albeit slow, digital output bit. The output pin will remain as configured until/unless the counter is “loaded” with a count value.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

LoadValue

A number from 0 to 65535, specifying how many counts to load in the counter specified.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

A load value of “0” will behave like a (hypothetical) load value of 65536.

Some modes do not support “1” as a load value. Other modes support neither “1” nor “2” as load values.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

Mode

A number from 0 to 5, specifying to which 8254 mode you want the specified counter to be configured.

LoadValue

A number, from 0 to 65535, specifying how many counts to load in the counter specified.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

CTR_8254ModeLoad() is similar to CTR_8254Mode() followed by CTR_8254Load(), but takes a single USB transaction, making it at least 250µsec faster than issuing the two operations independently. See CTR_8254Mode() and CTR_8254Load() for more notes.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 from which you wish to output a frequency. Most devices only contain one 8254, and therefore BlockIndex should be “0” for those units.

pHz

A pointer to a double-precision IEEE floating point number containing the desired output frequency. This value is set by the driver to the actual frequency that will be output, as limited by the device's capabilities.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function requires that the individual counters in the specified 8254 be wired up as follows: 10MHz → IN1, and OUT1 → IN2. If the 10MHz is replaced with other frequencies, the pHz calculation will scale predictably.

For most 8254s in our USB product line, this is the permanent wiring configuration. The exception is the USB-CTR-15, which has more flexibility; this wiring is provided by the USB-CTR-15's “Standard Configuration Adapter”.

The USB-CTR-15 can output as many as 15 frequencies, if you use CTR_8254ModeLoad() &emdash; but if you use CTR_StartOutputFreq(), you can only achieve 5, on CTR2 of each of the 5 blocks. (Counters 2, 5, 8, 11, and 14 under the secondary numbering convention. See note at the beginning of this section.)

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

pReadValue

A pointer to a WORD, which will be set to the value latched and read from the specified counter.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

The counts loaded cannot be read back. Only the “current count” is readable, and the current count does not initialize with the “(re-)load count value” until the first input clock occurs. Use CTR_8254ReadStatus() to distinguish between “the data read has never been loaded from the load count” (called a “null count” by the 8254 chip specification) and “the current count has been loaded, and decremented at least once”.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pData

A pointer to the first of an array of WORDs, which will be set to the values latched and read from each counter, in order. Counter 0's value is stored in pData[0], etc.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

The counts loaded cannot be read back. Only the “current count” is readable, and the current count does not initialize with the “(re-)load count value” until the first input clock occurs. Let us know if you need CTR_8254ReadStatusAll() functionality in your application.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

pReadValue

A pointer to a WORD which will be set to the count value latched and read from the specified counter.

pStatus

A pointer to a BYTE which will be set to the status latched and read from the specified counter.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

The meaning of the individual bits in the status byte is best described in the 8254 chip spec, which is readily found by searching the internet. Most often useful is “null count”, bit 6; when it's high, the count value is not particularly useful.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BlockIndex

Index of the 8254 chip you wish to control. See note at the beginning of this section.

CounterIndex

Index of the 8254 counter you wish to control. See note at the beginning of this section.

Mode

A number from 0 to 5, specifying to which 8254 mode you want the specified counter to be configured.

LoadValue

A number, from 0 to 65535, specifying how many counts to load in the counter specified.

pReadValue

A pointer to a WORD which will be set to the count value latched and read from the specified counter.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

CTR_8254ReadModeLoad() is similar to CTR_8254Read() followed by CTR_8254Mode() followed by CTR_8254Load(), but takes a single USB transaction, making it at least 500µsec faster than issuing the two operations independently. See CTR_8254Read(), CTR_8254Mode(), and CTR_8254Load() for more notes.

The reading is taken before the mode and load occur.

This simple function takes one scan of A/D data and converts it to voltage. It also averages oversamples for each channel. On “DC-Level” boards with A/D that don't support ADC_SetConfig(), it scans all channels, without oversampling.

This function converts input counts to voltages based on the range previously configured with ADC_Init or ADC_SetConfig. It will take data at the configured number of oversamples or more, average the readings from the channels, and convert the counts to voltage.

This is the easiest way to read A/D data, but can't achieve more than hundreds of Hz, or even slower depending on options. It should readily achieve 0 to 100 Hz operation, on up to 128 channels.

The speed limit is because this function performs intro & outro housekeeping USB transactions each call, to make it simple to use. For a faster but less-convenient API that moves these housekeeping functions out of the acquisition loop, please refer to the section on ADC_GetFastScanV().

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pBuf

Pointer to the first of an array of double-precision IEEE floating point numbers. Each element in the array will receive the value read from the corresponding A/D input channel. The array must be at least as large as the number of A/D input channels your product contains (16, 32, 64, 96, or 128) — but it is safe to always pass a pointer to an array of 128.

Only elements in the array corresponding to A/D channels actually acquired during the scan will be updated: start-channel through end-channel, inclusive. Other values will remain unchanged.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Acquires the voltage level on one A/D input. Use this function when your language doesn't handle implicitly-lengthed arrays of doubles as used by ADC_GetScanV(), or to acquire readings from just a few channels, slowly — during debugging or calibration, for example

This function is provided only for ease of use, implemented as a convenience wrapper for ADC_GetScanV(); it acquires all configured channels using ADC_GetScanV(), but returns only the specified channel's data. Therefore, reading two channels using ADC_GetChannelV() is at least twice as slow as using ADC_GetScanV().

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

ChannelIndex

Number of the channel to read voltage.

pBuf

A pointer to a double-precision IEEE floating point number which will receive the value read.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Like ADC_GetScanV, except it waits for an A/D trigger. Remember to configure a trigger source(timer or external) with ADC_SetConfig.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pBuf

Pointer to the first of an array of double-precision IEEE floating point numbers, just like ADC_GetScanV.

TimeoutMS

The number of milliseconds to wait for a trigger, minimum 1. If this expires with no trigger, take an immediate scan and return ERROR_TIMEOUT.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Like ADC_GetScanV, except it doesn't convert to volts. It still averages oversamples for each channel.

All counts are offset-binary coded, and left-justified. For example, 12-bit boards read count values 0x0000 through 0xFFF0, with 0x0000 being “minimum input voltage” and 0xFFF0 being “maximum input voltage”.

The use of counts exposes the “digital” nature of the conversion. This function is also slow; see ADC_GetScanV() for details, see ADC_GetFastScanV() for a faster option that returns volts.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pBuf

Pointer to the first of an array of WORDs. Each element in the array will receive the value read from the corresponding A/D input channel. The array must be at least as large as the number of A/D input channels your product contains (16, 32, 64, 96, or 128) — but it is safe to always pass a pointer to an array of 128.

Only elements in the array corresponding to A/D channels actually acquired during the scan will be updated: start-channel through end-channel, inclusive. Other values will remain unchanged.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Like ADC_GetScan, except it waits for an A/D trigger. Remember to configure a trigger source(timer or external) with ADC_SetConfig.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pBuf

Pointer to the first of an array of WORDs, just like ADC_GetScan.

TimeoutMS

The number of milliseconds to wait for a trigger, minimum 1. If this expires with no trigger, take an immediate scan and return ERROR_TIMEOUT.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Provides an easier mechanism to modify the Scan Start Channel and Scan End Channel configuration.

Normally the Scan Start Channel are broken into two four-bit components each, and configured by masking the least-significant nybbles into the ADC_SetConfig() array elements [0x12] and [0x14]. This function performs this bit manipulation for you, and writes the resulting configuration to the card using ADC_SetConfig().

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

StartChannel

The first channel to be acquired during each scan. Channels are Zero-based, and scans proceed from the StartChannel through the EndChannel, inclusive. The most common StartChannel value is "0", so scans begin with the first channel on the device.

EndChannel

The last channel to be acquired during each scan. This is usually the last channel number; for 16-channel boards, "15"; for 128 channel boards, "127", etc.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Acquires a block of analog input data from the specified board into the provided buffer.

Call ADC_BulkPoll() to determine how much data has been collected, and thus if collection has completed.

DeviceIndex

The index of the device on which to start ADC Bulk Acquisition; generally either diOnly or a specific device's device index.

BufSize

The size, in bytes, of the buffer to receive the data

pBuf

A pointer to the buffer where data should be stored

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Halt any ADC operations that are underway. This will terminate background ADC operations and cause ADC callbacks and blocking functions to execute with a user-abort status.

DeviceIndex

The index of the device to halt Bulk ADC acquisition; generally either diOnly or a specific device's device index.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Not implemented, returns ERROR_NOT_SUPPORTED.

Not implemented, returns ERROR_NOT_SUPPORTED.

Acquires Analog Input data using a callback interface, as configured with ADC_SetConfig().

Internally, the continuous process generates a pool of buffers, which function as a FIFO. In general, at any particular time, one buffer is being filled, and another buffer is being given to the callback.

DeviceIndex

The index of the device to start Callback-based ADC Acquisition; generally either diOnly or a specific device's device index.

BufSize

The size of each buffer in the pool, in bytes. This must be a multiple of 512, and of course zero is invalid. In general, you'll want this to also be a multiple of the size of each scan; for example, when acquiring three channels, it's convenient for BufSize to be a multiple of 1,536. When going at high speed, larger buffers are needed; usually, a buffer size close to the data generated in 1/10 of a second is appropriate.

BaseBufCount

The number of buffers in the pool. This must be at least 2. 64 is large enough for the max rate of the USB-AI16-16A on any computer that can reasonably run Windows. During development, you can set BaseBufCount to 2, note the number of times Flags bit 2 is received by the callback, and increase this final buffer count by 50% to accomodate weaker computers.

Context

A number to be passed on to the callback; the meaning is between the callback and the caller of this function, but it may be an index into an array. Unless the callback pays attention to it, this value is ignored.

pCallback

A pointer to an ADContCallback() function(see below) to receive buffers of data.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Deprecated: use ADC_BulkContinuousCallbackStart instead. This function was created to avoid a race condition that has since been resolved.

DeviceIndex

The index of the device to start Callback-based ADC Acquisition; generally either diOnly or a specific device's device index.

BufSize

The same as for ADC_BulkContinuousCallbackStart.

BaseBufCount

The same as for ADC_BulkContinuousCallbackStart.

Context

The same as for ADC_BulkContinuousCallbackStart.

pCallback

The same as for ADC_BulkContinuousCallbackStart.

Hz

As used by CTR_StartOutputFreq, this will be the "start ADC rate".

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function provides diagnostic information, generally for factory-use only. This debug information describes the buffer pool for an ongoing ADC bulk continuous mode acquisition.

Contact us if you'd like more information about this diagnostic function.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

Blanks

Receives the number of blank buffers in the pool.

Accessings

Receives the number of buffers held for read or write.

GotDatas

Receives the number of buffers waiting with data.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This function serves to gracefully cease background acquisition of ADC readings. Calling ADC_BulkContinuousEnd() is how a well-behaved application should close ADC operations started using ADC_BulkContinuousCallbackStart(), ADC_BulkContinuousCallbackStartClocked(), or ADC_BulkContinuousRingStart(),

DeviceIndex

The index of the device to stop background ADC Continuous Acquisition; generally either diOnly or a specific device's device index.

pIOStatus

Passed as the status to any related callbacks.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Starts acquiring ADC readings using a background/async process optimized for use from environments that cannot support callbacks. This function simplifies data collection from applications like Excel or LabVIEW.

Call ADC_ReadData() to grab Analog Input data that has been acquired asynchronously by this acquisition mode.

DeviceIndex

The index of the device to begin background ADC Ring-mode acquisition; generally either diOnly or a specific device's device index.

RingBufferSize

PacketsPerBlock

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Explicitly set the I/O mode of ADC bulk functions. This function is no longer supported; bulk mode is now set implicitly and automatically.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

BulkMode

The ADC bulk mode to set.

ERROR_NOT_SUPPORTED (50).

After background/async analog input data acquisition has been started by a call to ADC_BulkAcquire(), call ADC_BulkPoll() to check how much ADC data remains to be taken, and thus how much in the buffer is available for use.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

BytesLeft

A pointer to a variable that receives the number of bytes left in the bulk block acquisition. Bytes that are no longer "left" have been acquired and are available; for example, if you call ADC_BulkAcquire with a 2MB buffer, and ADC_BulkPoll shows 1½MB left, then ½MB has been acquired and can be read out of the buffer.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Provides a single function to configure and start acquiring ADC readings using a background/async process.

DeviceIndex

The index of the device to control ; generally either diOnly or a specific device's device index.

pConfigBuf

a pointer to the first of an array of bytes for configuration data. Refer to ADC_SetConfig() for more information.

ConfigBufSize

a pointer to a variable holding the number of configuration bytes to write (21 bytes, typically).

CalFileName

either the file name of a calibration file, or one of several reserved command strings. Refer to ADC_SetCal() for more information.

pCounterHz

A pointer to a double-precision IEEE floating point number containing the desired output frequency. This value is set by the driver to the actual frequency that will be output, as limited by the device's capabilities. Refer to CTR_StartOutputFreq() for more information.

RingBufferSize

The size, in bytes, of the entire ring buffer. The absolute minimum is equal to 512×PacketsPerBlock, and in general you'll want about a dozen times that.

PacketsPerBlock

The number of 512-byte packets in each transfer block. This is analogous to the "streaming block size", or to the BufSize parameter to ADC_BulkContinuousCallbackStart.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Read the current calibration reference value specified; useful for determining how much the device calibration has changed over time.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

CalRefIndex

Pass 0 to read the "ground" reference value. Pass "1" to read the "+" reference value. The unipolar references will be used if channel 0 is set(see ADC_SetConfig) to unipolar, or likewise the bipolar references if channel 0 is set to bipolar.

pRef

a pointer to a variable where the reading will be stored, in volts.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Reads the ADC configuration last configured with ADC_SetConfig() and functions that call it.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pConfigBuf

A pointer to a buffer to receive the ADC configuration.

ConfigBufSize

A pointer to a variable that holds the size of the buffer pointed to by pConfigBuf. The variable will be changed to the full size of the buffer on this device. Thus, it's safe to call ADC_GetConfig with ConfigBufSize pointing to a zero, to get the size of the actual buffer, then allocate that much and call ADC_GetConfig again.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Performs a "software start" ADC trigger. This trigger obeys the ADC configuration normally, notably for purposes of which channels are acquired, and returns the ADC data normally, for example via ADC_BulkContinuousCallback.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

Channel

Reserved. This is conceptually the index of an ADC channel, but it no longer functions as such.

pBuf

Reserved. Still must point to a 16-bit word variable. This is conceptually to receive the ADC data, but it no longer functions as such.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

A convenient function to use during initial configuration at the start of your application, ADC_Initialize() calls ADC_SetConfig() and ADC_SetCal() for you.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

pConfigBuf

a pointer to the first of an array of bytes for configuration data. Refer to ADC_SetConfig() for more information.

ConfigBufSize

a pointer to a variable holding the number of configuration bytes to write (21 bytes, typically).

CalFileName

either the file name of a calibration file, or one of several reserved command strings. Refer to ADC_SetCal() for more information.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Returns ERROR_SUCCESS if the specified DeviceIndex supports ADC_GetCalRefV(), and therefore ADC_SetCal(":AUTO:") and related functions.

You can skip calling ADC_QueryCal() by calling ADC_SetCal() regardless and simply ignoring any returned errors.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Configure the Range Code for all ADC channels.

Normally configuring Range Codes requires bit manipulation to combine the Unipolar/Bipolar bit, the Differential/Single-Ended bit, and the Gain Bits into a single byte value per Range Group. This function performs this operation for you and updates the new configuration to the device using ADC_SetConfig()

This function is currently implemented as a convenience-wrapper via a read-modify-write algorithm: It calls ADC_GetConfig(), modifies the returned config array as requested, then writes the new config via ADC_SetConfig(). Although USB serializes operations across the cable this function performs several sequential transactions and is therefore not process-safe.

DeviceIndex

The index of the device to configure; generally either diOnly or a specific device's device index.

pGainCodes

a pointer to the first of an array of one Range Code per Range Group (generally 8 or 16 bytes (Differential or Singled-Ended, respectively))

bDifferential

pass zero to indicate Single-Ended mode, pass non-zero to indicate Differential mode.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Configure the Range Code for a single “Range Group” of channels, which is a single channel on 16-channel boards.

Normally the Range Code for each Range Group is configured using the ADC_SetConfig() array byte at [Range Group #]. This function updates the config array for you, and writes the resulting configuration to the card using ADC_SetConfig().

This function is currently implemented as a convenience-wrapper via a read-modify-write algorithm: it calls ADC_QueryConfig(), modifies the returned config array as requested, then writes the new config via ADC_SetConfig(). Although USB serializes operations across the cable this function performs several sequential transactions and is therefore not process-safe.

DeviceIndex

The index of the device to configure; generally either diOnly or a specific device's device index.

ADChannel

The Range Group # you wish to configure.

GainCode

The gain code to set for this Range Group.

bDifferential

pass zero to indicate Single-Ended mode, pass non-zero to indicate Differential mode.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Retrieves analog input data acquired into a ring buffer via ADC_BulkContinuousRingStart or ADC_FullStartRing. Oversamples, if any, are averaged, and the data is converted to volts.

DeviceIndex

The index of the device to request data from; generally either diOnly or a specific device's device index.

pConfigBuf

A pointer to the ADC configuration used to acquire the data. ADC_ReadData uses this to determine the layout of the data, and to convert to volts.

ScansToRead

A pointer to a variable holding the number of "scans" to read. If the board is not in scan mode, then "scan" still refers to acquiring all selected channels in turn. On return, this will be changed to the number of "scans" read.

pData

A pointer to the first of a buffer of double precision IEEE floating point numbers, to receive the ADC data.

Timeout

A double precision IEEE floating point number indicating the timeout and timeout behavior. Note that, regardless of Timeout, if ADC_ReadData can immediately return all the requested data, then it will do so and return immediately.

Timeout Value	Resulting Behavior
0	Data already acquired is returned. ADC_ReadData doesn't wait for more, regardless of the amount.
Infinity	The specified number of scans(or an error) is returned. So long as the ADC operation is functioning, ADC_ReadData will continue to wait until this request is fulfilled.
Positive	ADC_ReadData will wait up to Timeout milliseconds in order to return all the requested data. At that time, if a lesser amount of data is available, then ADC_ReadData will return what's available.
Negative	"All or nothing". ADC_ReadData will wait up to abs(Timeout) milliseconds in order to return all the requested data. If there still isn't that much data available at that time, then ADC_ReadData will time out.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Configure the analog input calibration of a USB-AIx board.

Some revisions of the driver will return errors under all conditions if you attempt to ADC_SetCal() unsupported hardware; other driver revisions will return ERROR_SUCCESS if you explicitly request “:NONE:” (or “:1TO1:”) on a board that does not support calibration, as the request, although skipped, was technically successful - the calibration table of unsupported hardware is always :NONE:

Call ADC_SetCalAndSave() to also receive the calibration table data for use by your application.

DeviceIndex

The index of the device to configure; generally either diOnly or a specific device's device index.

CalFileName

A file name can include the full path, or be relative to the current directory. The calibration file format consists of two 64k arrays of unsigned 16-bit count values. The first array is the Unipolar calibration table; the second, bipolar.
A command string of either ":NONE:" or ":1TO1:" turns off calibration.
":NORM:" applies only factory Vref calibration.
":AUTO:" commands AIOUSB to perform a self-calibration sequence, measuring the onboard + and - references using ADC_GetCalRefV(), generating an in-memory calibration file, and writing the calibration to the device.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Configures the calibration for the specified Analog Input device, and returns the calibration table for use by your application.

This is mostly useful if you're curious what ADC_SetCal() did when you asked it to ":AUTO:" calibrate, as this function will return the generated calibration table.

DeviceIndex

The index of the device to calibrate; generally either diOnly or a specific device's device index.

CalFileName

A file name can include the full path, or be relative to the current directory. The calibration file format consists of two 64k arrays of unsigned 16-bit count values. The first array is the Unipolar calibration table; the second, bipolar.
A command string of either ":NONE:" or ":1TO1:" turns off calibration.
":NORM:" applies only factory Vref calibration.
":AUTO:" commands AIOUSB to perform a self-calibration sequence, measuring the onboard + and - references using ADC_GetCalRefV(), generating an in-memory calibration file, and writing the calibration to the device.

SaveCalFileName

Path and filename to which the calibration table should be saved.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

This utility function provides read-modify-write access to the “Oversample” configuration byte in the ADC_SetConfig array.

DeviceIndex

The index of the device to configure Oversamples; generally either diOnly or a specific device's device index.

Oversample

Any compatible ADC acquisition operation will acquire one reading from any given Analog Input Channel followed immediately by one additional reading per Oversample configured. These "Oversamples" are designed to be used in your digital filtering to improve the number of effective bits from the ADC acquisition

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Perform extensive configuration of analog inputs, typically useful only for the "USB-AIx" and "DPK-" product Families.

Read-Modify-Write convenience wrappers are available to simplify modifying individual components of the ADC Configuration structure. See ADC_RangeAll(), ADC_Range1(), ADC_SetOversamples(), and ADC_SetScanLimits() for more information on these convenient setters.

DeviceIndex

The index of the device to configure; generally either diOnly or a specific device's device index.

pConfigBuf

a pointer to the first byte of an array of bytes for configuration data. The array of bytes can also be interpreted as a structure, described below.

ConfigBufSize

a pointer to a variable holding the number of configuration bytes to write (21 bytes, typically).

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

struct ADCConfig
{
	byte RangeCodePerRangeGroup[16]; // configures Diff/S.E. Uni/Bip and Gain
	byte CalCode;                    // selects Reference or Input ADC data
	byte TriggerMode;                // selects Timer or External ADC Starts
	byte ScanLimitsLSN;              // least-significant nybbles of start and end channel
	byte OversampleCount;            // configures how many extra conversions per reading
	byte ScanLimitsMSN;              // most-significant nybbles of start and end channel
}

Takes a scan, similar to ADC_GetScanV, but without the intro and outro code. It's thus faster, but it requires the caller to call the intro and (optionally) outro.

Call ADC_InitFastScanV first. You can then call this function repeatedly. Optionally, call ADC_ResetFastScanV when you're done using this function.

DeviceIndex

The index of the device to query; generally either diOnly or a specific device's device index.

pBuf

Pointer to the first of an array of double-precision IEEE floating point numbers. Each element in the array will receive the value read from the corresponding A/D input channel. The array must be at least as large as the number of A/D input channels your product contains (16, 32, 64, 96, or 128) — but it is safe to always pass a pointer to an array of 128.

Only elements in the array corresponding to A/D channels actually acquired during the scan will be updated: start-channel through end-channel, inclusive. Other values will remain unchanged.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Puts the ADC configuration back after ADC_GetFastScanV calls. This function is optional, because the configuration for ADC_GetFastScanV is still valid.

If you do call this function, then you'll need to call ADC_InitFastScanV again before you can resume calling ADC_GetFastScanV.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.

Prepares the ADC configuration for repeated ADC_GetFastScanV calls.

DeviceIndex

The index of the device to control; generally either diOnly or a specific device's device index.

Windows standard “Win32” error codes. ERROR_SUCCESS (0) means “Success”.