AIO16 Driver

Overview

AIO16 is a function driver for the 104-AIO16-16. It works with WDM-compatible versions of Windows, including Windows 98, Windows ME, Windows NT/2000, and Windows NT/XP. Under older versions of Windows (Windows 3.1, Windows 95, and Windows NT 4.x or less), the card can be used with our ACCES32 and IRQGen drivers, at reduced speed.

Interface Documentation

All functions are exported in three forms: underscored with the cdecl calling convention (the easiest for C++), undecorated with the stdcall calling convention (easiest for Visual BASIC), and undecorated with the cdecl calling convention (easiest for most other languages). Import declarations are given for Object Pascal / Delphi, C++ Builder / Visual C++, and Visual BASIC.

Visual BASIC doesn't have true pointers, and thus pointer-using functions are declared in Visual BASIC to always have a non-null pointer.

AIO16_GetNumCards()

function AIO16_GetNumCards: LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_GetNumCards(void);

Public Declare Function AIO16_GetNumCards Lib "AIO16" Alias "VBAIO16_GetNumCards" () As Long

This function returns the number of cards installed in the system with AIO16. The cards are numbered from zero to one less than the number returned by AIO16_GetNumCards(); these card numbers are specified for the CardNum parameters of most other AIO16.dll functions. If an invalid card number is specified to another function, the function will fail.

Note that since the 104-AIO16-16 is not Plug-And-Play, the Add New Hardware wizard must be run to "attach" AIO16 to a card. Once the card appears in Device Manager and its base address and IRQ have been set there, it will get an AIO16 card number.

AIO16_Init()

function AIO16_Init(CardNum: LongWord; Base: PLongWord): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_Init(unsigned long CardNum, unsigned long *Base);

Public Declare Function AIO16_Init Lib "AIO16" Alias "VBAIO16_Init" (ByVal CardNum As Long, ByRef Base As Long) As Long

This function initializes and calibrates the card indicated by CardNum. It also retrieves the card's base address, so you can tell which physical card corresponds to which card number. If you don't care about the base address of the card(for example, you know you only have one in the system), you can pass a null pointer. AIO16_Init() returns zero if it succeeds, or a Windows error code if it fails. Several possible error codes are:

ERROR_OLD_WIN_VERSION - This indicates it's running under Windows 95, Windows NT 4.x or less, or Windows 3.1.
ERROR_INVALID_INDEX - The card number is invalid. Since card numbers are zero-based, the value returned by AIO16_GetNumCards() is not a valid card number.
ERROR_BAD_DRIVER - An unspecified error occurred in AIO16.sys.

It can also return any of the error codes CreateFile() can set as the last error.

There is one circumstance under which you may want to call AIO16_Init() more than once: if you physically change the range jumpers on the card, call AIO16_Init() to reload the jumper settings.

AIO16_GetSettings()

function AIO16_GetSettings(CardNum: LongWord; ADC16SE, ADCBip, ADC5V, DACA5V, DACB5V: PLongWord): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_GetSettings(unsigned long CardNum, unsigned long *ADC16SE, unsigned long *ADCBip, unsigned long *ADC5V, unsigned long *DACA5V, unsigned long *DACB5V);

Public Declare Function AIO16_GetSettings Lib "AIO16" Alias "VBAIO16_GetSettings" (ByVal CardNum As Long, ByRef ADC16SE As Long, ByRef ADCBip As Long, ByRef ADC5V As Long, ByRef DACA5V As Long, ByRef DACB5V As Long) As Long

This function retrieves the range jumper settings of the card indicated by CardNum. It returns zero if it succeeds, or a Windows error code if it fails. Each parameter is a pointer to a DWord to receive the corresponding setting, or a null pointer if you don't care about that setting. The settings are:

ADC16SE - nonzero if in 16-channel single-ended mode, zero if in 8-channel differential mode.
ADCBip - nonzero if in bipolar mode(±5 or ±10), zero if in unipolar mode(0-10 or "0-10(low-res)").
ADC5V - nonzero if in high-gain mode(±5 or 0-10), zero if in low-gain mode(±10 or "0-10(low-res)"). The A/D range is determined by these two modes. The "0-10(low-res)" range is theoretically 0-20V; however, the gain amplifiers on the card are limited to about 10V.
DACA5V - nonzero if DAC A is using the 0-5V range, zero if it's using the 0-10V range.
DACB5V - nonzero if DAC B is using the 0-5V range, zero if it's using the 0-10V range.

Some possible error codes are:

ERROR_NOT_READY - The card has not been initialized by AIO16_Init(). If you've called AIO16_Init(), make sure it returned success.
ERROR_INVALID_INDEX - The card number is invalid.
ERROR_BAD_DRIVER - An error occurred in AIO16.sys. GetLastError() will return the driver error code.

AIO16_ADC_Acquire()

function AIO16_ADC_Acquire(CardNum: LongWord; RateHz: PLongWord; Gain, LoChannel, HiChannel, Count, Oversample: LongWord; UserBuffer: PSingle): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_ADC_Acquire(unsigned long CardNum, unsigned long *RateHz, unsigned long Gain, unsigned long LoChannel, unsigned long HiChannel, unsigned long Count, unsigned long Oversample, short float *UserBuffer);

Public Declare Function AIO16_ADC_Acquire Lib "AIO16" Alias "VBAIO16_ADC_Acquire" (ByVal CardNum As Long, ByRef RateHz As Long, ByVal Gain As Long, ByVal LoChannel As Long, ByVal HiChannel As Long, ByVal Count As Long, ByVal Oversample As Long, ByRef UserBuffer As Single) As Long

This function starts the card indicated by CardNum taking a block of A/D data. It returns zero if it succeeds, or a Windows error code if it fails. Its parameters are:

RateHz - A pointer to a DWord value containing the rate to acquire "scans", in Hz. This value will be modified to indicate the rate actually achieved.
Gain - The gain code to acquire data at. Gain code 0 is a x1 gain multiplier, code 1 is x2, code 2 is x5, and code 3 is x10.
LoChannel and HiChannel - The first and last channels to acquire. This range of channels will be acquired back-to-back, constituting a "scan"; the value in RateHz is the rate for scans, not individual acquisitions.
Count - The number of samples to acquire. This is also the number of entries in the UserBuffer array; unlike RateHz, Count is not given in scans.
Oversample - The oversampling multiplier. Multipliers of 1, 2, 8, and 16 are accepted, and a zero can also be passed to mean x1.
UserBuffer - A pointer to the first in an array of single-precision floating-point values. There must be at least [Count] entries in the array. This is where data is placed after an AIO16_ADC_Read() or an AIO16_ADC_WaitRead().

Some possible error codes are:

ERROR_NOT_READY - The card has not been initialized by AIO16_Init(). If you've called AIO16_Init(), make sure it returned success.
ERROR_INVALID_INDEX - The card number is invalid.
ERROR_INVALID_PARAMETER - A null pointer was specified for RateHz, or RateHz was zero; Oversample was not a valid oversampling multiplier; or Gain was not a valid gain code.

It can also return any of the error codes DeviceIoControl() can set as the last error.

AIO16_ADC_Stop()

function AIO16_ADC_Stop(CardNum: LongWord): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_ADC_Stop(unsigned long CardNum);

Public Declare Function AIO16_ADC_Stop Lib "AIO16" Alias "VBAIO16_ADC_Stop" (ByVal CardNum As Long) As Long

This function stops A/D acquisition for the card indicated by CardNum. It returns zero if it succeeds, or a Windows error code if it fails; however, it can only fail if acquisition was not taking place, so the return value is not terribly useful.

AIO16_ADC_Read()

AIO16_ADC_WaitRead()

function AIO16_ADC_Read(CardNum: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_ADC_WaitRead(CardNum: LongWord; MinResults: LongWord): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_ADC_Read(unsigned long CardNum); __declspec(dllimport) unsigned long AIO16_ADC_WaitRead(unsigned long CardNum, unsigned long MinResults);

Public Declare Function AIO16_ADC_Read Lib "AIO16" Alias "VBAIO16_ADC_Read" (ByVal CardNum As Long) As Long Public Declare Function AIO16_ADC_WaitRead Lib "AIO16" Alias "VBAIO16_ADC_WaitRead" (ByVal CardNum As Long, ByVal MinResults As Long) As Long

These functions validate A/D data acquired by the card indicated by CardNum. They both return the number of samples validated; the total number of samples acquired and valid can be determined by accumulating this result. The data is in the buffer passed for UserBuffer to AIO16_ADC_Acquire(). They differ in that AIO16_ADC_WaitRead() does not return until at least [MinResults] samples have been validated. AIO16_ADC_WaitRead() can return more than [MinResults] valid samples, but will only return less if an error occurs. If an error occurs in either function, it will return zero, and GetLastError() can retrieve the error code.

An example of use: AIO16_ADC_Acquire is used to acquire 200,000 samples. A call to AIO16_ADC_WaitRead() with MinResults=800 returns 1024 valid samples; UserBuffer[0] through UserBuffer[1023] are now valid. The next call to AIO16_ADC_WaitRead() returns another 1024 valid samples; UserBuffer[1024] through UserBuffer[2047] are now valid as well.

AIO16_DAC_Write()

function AIO16_DAC_Write(CardNum, DACNum: LongWord; Volts: Double): Double; cdecl; external 'AIO16.dll'; __declspec(dllimport) signed double AIO16_DAC_Write(unsigned long CardNum, unsigned long DACNum, signed double Volts);

Public Declare Function AIO16_DAC_Write Lib "AIO16" Alias "VBAIO16_DAC_Write" (ByVal CardNum As Long, ByVal DACNum As Long, ByVal Volts As Double) As Double

This function outputs a voltage to one of the the D/A channels on the card indicated by CardNum. It returns the voltage actually output, or 22222.0 if an error occurs(in which case GetLastError() can retrieve the error code). DACNum should be 0 for DAC A, or 1 for DAC B. Note that the maximum-scale voltage cannot be exactly achieved; for example, the 0-5V range is actually 0-4.9987V, and if you specify 5V, it will wrap to 0V. Calculate the exact maximum-scale voltage by multiplying the listed maximum by 4095/4096.

Control Functions

function AIO16_EEPROM_Enable(CardNum: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_EEPROM_Disable(CardNum: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_EEPROM_Read(CardNum, Addr: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_EEPROM_Write(CardNum, Addr, Data: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_ADC_Cal(CardNum, M, B: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_DAC_Cal(CardNum, DACNum, M: LongWord): LongWord; cdecl; external 'AIO16.dll'; function AIO16_LoadCal(CardNum: LongWord): LongWord; cdecl; external 'AIO16.dll'; __declspec(dllimport) unsigned long AIO16_EEPROM_Enable(unsigned long CardNum); __declspec(dllimport) unsigned long AIO16_EEPROM_Disable(unsigned long CardNum); __declspec(dllimport) unsigned long AIO16_EEPROM_Read(unsigned long CardNum, unsigned long Addr); __declspec(dllimport) unsigned long AIO16_EEPROM_Write(unsigned long CardNum, unsigned long Addr, unsigned long Data); __declspec(dllimport) unsigned long AIO16_ADC_Cal(unsigned long CardNum, unsigned long M, unsigned long B); __declspec(dllimport) unsigned long AIO16_DAC_Cal(unsigned long CardNum, unsigned long DACNum, unsigned long M); __declspec(dllimport) unsigned long AIO16_LoadCal(unsigned long CardNum);

Public Declare Function AIO16_EEPROM_Enable Lib "AIO16" Alias "VBAIO16_EEPROM_Enable" (ByVal CardNum As Long) As Long Public Declare Function AIO16_EEPROM_Disable Lib "AIO16" Alias "VBAIO16_EEPROM_Disable" (ByVal CardNum As Long) As Long Public Declare Function AIO16_EEPROM_Read Lib "AIO16" Alias "VBAIO16_EEPROM_Read" (ByVal CardNum As Long, ByVal Addr As Long) As Long Public Declare Function AIO16_EEPROM_Write Lib "AIO16" Alias "VBAIO16_EEPROM_Write" (ByVal CardNum As Long, ByVal Addr As Long, ByVal Data As Long) As Long Public Declare Function AIO16_ADC_Cal Lib "AIO16" Alias "VBAIO16_ADC_Cal" (ByVal CardNum As Long, ByVal M As Long, ByVal B As Long) As Long Public Declare Function AIO16_DAC_Cal Lib "AIO16" Alias "VBAIO16_DAC_Cal" (ByVal CardNum As Long, ByVal DACNum As Long, ByVal M As Long) As Long Public Declare Function AIO16_LoadCal Lib "AIO16" Alias "VBAIO16_LoadCal" (ByVal CardNum As Long) As Long

These functions are not generally useful to the customer, but are exported for use by our calibration program. Briefly:

AIO16_EEPROM_Enable() - Enables the ability to write to the EEPROM.
AIO16_EEPROM_Disable() - Disables the ability to write to the EEPROM.
AIO16_EEPROM_Read() - Reads a value from the EEPROM.
AIO16_EEPROM_Write() - Writes a value to the EEPROM.
AIO16_ADC_Cal() - Loads the A/D's calpots with the given M and B values(using y = Mx + B).
AIO16_DAC_Cal() - Loads the specified D/A's calpot with the given M value.
AIO16_LoadCal() - Loads the calibration constants from the EEPROM into the calpots.