int main(int argc, char *argv[] )
{
unsigned long productId, nameSize, numDIOBytes, numCounters;
const int MAX_NAME_SIZE = 20;
char name[ MAX_NAME_SIZE + 2 ];
int stopval;
unsigned long deviceIndex = 0;
AIOUSB_BOOL deviceFound = AIOUSB_FALSE;
printf(
" AIOUSB library version %s, %s\n"
" This program demonstrates controlling a USB-IIRO or USB-IDIO device on\n"
" the USB bus. For simplicity, it uses the first such device found\n"
" on the bus.\n"
, AIOUSB_GetVersion(), AIOUSB_GetVersionDate()
);
/*
* Must call AIOUSB_Init() before any meaningful AIOUSB functions;
* AIOUSB_GetVersion() above is an exception
*/
unsigned long result = AIOUSB_Init();
/*
* call GetDevices() to obtain "list" of devices found on the bus
*/
unsigned long deviceMask = GetDevices();
if( deviceMask != 0 ) {
/*
* at least one ACCES device detected, but we want one of a specific type
*/
AIOUSB_ListDevices(); /* print list of all devices found on the bus */
while( deviceMask != 0 ) {
if( ( deviceMask & 1 ) != 0 ) {
// found a device, but is it the correct type?
nameSize = MAX_NAME_SIZE;
result = QueryDeviceInfo( deviceIndex, &productId, &nameSize, name, &numDIOBytes, &numCounters );
if( result == AIOUSB_SUCCESS ) {
if( (productId >= USB_IIRO_16 && productId <= USB_IIRO_4 ) ||
(productId >= USB_IDIO_16 && productId <= USB_IDIO_4 )) {
// found a USB-AI16-16A family device
deviceFound = AIOUSB_TRUE;
break; // from while()
}
} else
printf( "Error '%s' querying device at index %lu\n"
, AIOUSB_GetResultCodeAsString( result ), deviceIndex );
}
deviceIndex++;
deviceMask >>= 1;
}
}
int main( int argc, char **argv ) {
const int DEVICES_REQUIRED = 1;
const int MAX_DIO_BYTES = 4;
const int MASK_BYTES = ( MAX_DIO_BYTES + BITS_PER_BYTE - 1 ) / BITS_PER_BYTE;
const int MAX_NAME_SIZE = 20;
int devicesFound = 0;
int index = 0;
typedef enum {
SUCCESS = 0,
USB_ERROR = -1,
NO_DEVICE_FOUND = -2
} EXIT_CODE;
EXIT_CODE exit_code = SUCCESS;
struct DeviceInfo {
unsigned char outputMask[ MASK_BYTES ];
unsigned char readBuffer[ MAX_DIO_BYTES ]; // image of data read from board
unsigned char writeBuffer[ MAX_DIO_BYTES ]; // image of data written to board
char name[ MAX_NAME_SIZE + 2 ];
unsigned long productID;
unsigned long nameSize;
unsigned long numDIOBytes;
unsigned long numCounters;
uint64_t serialNumber;
int index;
} deviceTable[ DEVICES_REQUIRED ];
struct DeviceInfo *device;
printf(
"USB-DIO-32 sample program version 1.17, 26 November 2009\n"
" AIOUSB library version %s, %s\n"
" This program demonstrates communicating with %d USB-DIO-32 devices on\n"
" the same USB bus. For simplicity, it uses the first %d such devices\n"
" found on the bus.\n",
AIOUSB_GetVersion(),
AIOUSB_GetVersionDate(),
DEVICES_REQUIRED,
DEVICES_REQUIRED
);
unsigned long result = AIOUSB_Init(); /* Call AIOUSB_Init() before any meaningful AIOUSB functions; */
if( result != AIOUSB_SUCCESS ) {
printf("Can't initialize AIOUSB USB device\n");
exit_code = USB_ERROR;
}
unsigned long deviceMask = GetDevices(); /**< @ref GetDevices */
if( deviceMask == 0 ) {
printf( "No ACCES devices found on USB bus\n" );
exit_code = USB_ERROR;
goto exit_sample;
}
AIOUSB_ListDevices();
/*
* search for required number of USB-DIO-32 devices
*/
while( deviceMask != 0 && devicesFound < DEVICES_REQUIRED ) {
if( ( deviceMask & 1 ) != 0 ) {
// found a device, but is it the correct type?
device = &deviceTable[ devicesFound ];
device->nameSize = MAX_NAME_SIZE;
result = QueryDeviceInfo( index, &device->productID,
&device->nameSize,
device->name,
&device->numDIOBytes,
&device->numCounters
);
if( result == AIOUSB_SUCCESS ) {
if( device->productID == USB_DIO_32 ) { // found a USB-DIO-32
device->index = index;
devicesFound++;
}
} else
printf( "Error '%s' querying device at index %d\n",
AIOUSB_GetResultCodeAsString( result ),
index
);
}
index++;
deviceMask >>= 1;
}
if( devicesFound < DEVICES_REQUIRED ) {
printf( "Error: You need at least %d devices connected to run this sample\n", DEVICES_REQUIRED );
goto exit_sample;
}
unsigned port, pattern;
AIOUSB_BOOL correct;
for( index = 0; index < devicesFound; index++ ) {
device = &deviceTable[ index ];
result = GetDeviceSerialNumber( device->index, &device->serialNumber );
if( result == AIOUSB_SUCCESS )
printf( "Serial number of device at index %d: %llx\n", device->index, ( long long ) device->serialNumber );
else
printf( "Error '%s' getting serial number of device at index %d\n", AIOUSB_GetResultCodeAsString( result ), device->index );
}
/*
* DIO configuration
*/
device = &deviceTable[ 0 ]; /* select first device */
AIOUSB_SetCommTimeout( device->index, 1000 ); /* set timeout for all USB operations */
/*
* set all ports to output mode (we could just write "device->outputMask[ 0 ] = 0x0f"
* here since there are only 4 ports)
*/
memset( device->outputMask, 0xff, MASK_BYTES );
for( port = 0; port < device->numDIOBytes; port++ )
device->writeBuffer[ port ] = 0x11 * ( port + 1 );
/* for ( port =0 ; port < 0xff ; port ++ ) { */
device->outputMask[0] = (unsigned char )0xff;
for( port = 0; port <= 0xff; port ++ ) {
device->writeBuffer[0] = port;
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
usleep(10000);
}
for( port = 0; port <= 0xff; port ++ ) {
device->writeBuffer[1] = port;
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
usleep(10000);
}
for( port = 0; port <= 0xff; port ++ ) {
device->writeBuffer[2] = port;
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
usleep(10000);
}
for( port = 0; port <= 0xff; port ++ ) {
device->writeBuffer[3] = port;
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
usleep(10000);
}
for ( port = 0; port < 4 ; port ++ ) {
device->writeBuffer[port] = 0xff;
}
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
for ( int i =0 ; i <= 0xf ; i ++ ) {
device->outputMask[0] = (unsigned char )i;
result = DIO_ConfigureRaw( device->index, AIOUSB_FALSE, device->outputMask, device->writeBuffer );
if ( result != AIOUSB_SUCCESS )
break;
usleep(100000);
}
if( result == AIOUSB_SUCCESS )
printf( "Device at index %d successfully configured\n", device->index );
else
printf( "Error '%s' configuring device at index %d\n", AIOUSB_GetResultCodeAsString( result ), device->index );
exit_sample:
AIOUSB_Exit();
return ( int ) 0;
}
int
main(int argc, char *argv[] )
{
struct opts options = AIO_OPTIONS;
AIOContinuousBuf *buf = 0;
struct timespec foo , bar;
AIORET_TYPE retval = AIOUSB_SUCCESS;
int *indices;
int num_devices;
process_aio_cmd_line( &options, argc, argv );
int tobufsize = (options.num_scans+1)*options.num_channels*20;
uint16_t *tobuf = (uint16_t *)malloc(sizeof(uint16_t)*tobufsize);
unsigned short *tmp = (unsigned short *)malloc(sizeof(unsigned short)*(options.num_scans+1)*options.num_channels);
if( !tmp ) {
fprintf(stderr,"Can't allocate memory for temporary buffer \n");
exit(1);
}
AIOUSB_Init();
AIOUSB_ListDevices();
AIOUSB_FindDevices( &indices, &num_devices, find_ai_board );
aio_list_devices( &options, indices, num_devices ); /* will exit if no devices found */
buf = (AIOContinuousBuf *)NewAIOContinuousBufForCounts( options.index, options.num_scans, options.num_channels );
if( !buf ) {
fprintf(stderr,"Can't allocate memory for temporary buffer \n");
exit(1);
}
AIOContinuousBufSetDeviceIndex( buf, options.index ); /* Assign the first matching device for this sample */
if( options.reset ) {
fprintf(stderr,"Resetting device at index %d\n",buf->DeviceIndex );
AIOContinuousBufResetDevice( buf );
exit(0);
}
FILE *fp = fopen(options.outfile,"w");
if( !fp ) {
fprintf(stderr,"Unable to open '%s' for writing\n", options.outfile );
exit(1);
}
/**
* 2. Setup the Config object for Acquisition, either the more complicated
* part in comments (BELOW) or using a simple interface.
*/
/* New simpler interface */
AIOContinuousBufInitConfiguration( buf );
if ( options.slow_acquire ) {
unsigned char bufData[64];
unsigned long bytesWritten = 0;
GenericVendorWrite( 0, 0xDF, 0x0000, 0x001E, bufData, &bytesWritten );
}
AIOContinuousBufSetOversample( buf, 0 );
AIOContinuousBufSetStartAndEndChannel( buf, options.start_channel, options.end_channel );
if( !options.number_ranges ) {
AIOContinuousBufSetAllGainCodeAndDiffMode( buf , options.gain_code , AIOUSB_FALSE );
} else {
for ( int i = 0; i < options.number_ranges ; i ++ ) {
AIOContinuousBufSetChannelRange( buf,
options.ranges[i]->start_channel,
options.ranges[i]->end_channel,
options.ranges[i]->gaincode
);
}
}
AIOContinuousBufSaveConfig(buf);
if ( retval < AIOUSB_SUCCESS ) {
printf("Error setting up configuration\n");
exit(1);
}
options.block_size = ( options.block_size < 0 ? 1024*64 : options.block_size );
if ( options.clock_rate < 1000 ) {
AIOContinuousBufSetStreamingBlockSize( buf, 512 );
} else {
AIOContinuousBufSetStreamingBlockSize( buf, options.block_size );
}
/**
* 3. Setup the sampling clock rate, in this case
* 10_000_000 / 1000
*/
AIOContinuousBufSetClock( buf, options.clock_rate );
/**
* 4. Start the Callback that fills up the
* AIOContinuousBuf. This fires up an thread that
* performs the acquistion, while you go about
* doing other things.
*/
AIOContinuousBufInitiateCallbackAcquisition(buf);
/**
* in this example we read bytes in blocks of our core num_channels parameter.
* the channel order
*/
if ( options.with_timing )
clock_gettime( CLOCK_MONOTONIC_RAW, &bar );
int scans_remaining;
int read_count = 0;
int scans_read = 0;
while ( AIOContinuousBufGetRunStatus(buf) == RUNNING || read_count < options.num_scans ) {
if ( (scans_remaining = AIOContinuousBufCountScansAvailable(buf) ) > 0 ) {
if ( scans_remaining ) {
if ( options.with_timing )
clock_gettime( CLOCK_MONOTONIC_RAW, &foo );
scans_read = AIOContinuousBufReadIntegerScanCounts( buf, tobuf, tobufsize, AIOContinuousBufNumberChannels(buf)*AIOContinuousBufCountScansAvailable(buf) );
if ( options.with_timing )
clock_gettime( CLOCK_MONOTONIC_RAW, &bar );
read_count += scans_read;
if ( options.verbose )
fprintf(stdout,"Waiting : total=%u, readpos=%d, writepos=%d, scans_read=%d\n", read_count,
(int)AIOContinuousBufGetReadPosition(buf), (int)AIOContinuousBufGetWritePosition(buf), scans_read);
for( int scan_count = 0; scan_count < scans_read ; scan_count ++ ) {
if( options.with_timing )
fprintf(fp ,"%d,%d,", (int)bar.tv_sec, (int)(( bar.tv_sec - foo.tv_sec )*1e9 + (bar.tv_nsec - foo.tv_nsec )));
for( int ch = 0 ; ch < AIOContinuousBufNumberChannels(buf); ch ++ ) {
fprintf(fp,"%u,",tobuf[scan_count*AIOContinuousBufNumberChannels(buf)+ch] );
if( (ch+1) % AIOContinuousBufNumberChannels(buf) == 0 ) {
fprintf(fp,"\n");
}
}
}
}
} else {
usleep(100);
}
}
fclose(fp);
fprintf(stdout,"Test completed...exiting\n");
AIOUSB_Exit();
return 0;
}
int main( int argc, char **argv )
{
struct opts options = AIO_OPTIONS;
AIORET_TYPE result = AIOUSB_SUCCESS;
int *indices;
int num_devices;
ADCConfigBlock *config;
AIOUSBDevice *dev;
USBDevice *usb;
double *volts;
process_aio_cmd_line( &options, argc, argv );
result = AIOUSB_Init();
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error calling AIOUSB_Init(): %d\n", (int)result );
exit(result );
}
AIOUSB_ListDevices();
process_aio_cmd_line( &options, argc, argv );
AIOUSB_FindDevices( &indices, &num_devices, find_ai_board );
if( (result = aio_list_devices( &options, indices, num_devices ) != AIOUSB_SUCCESS ))
exit(result);
if ( (config = NewADCConfigBlockFromJSON( options.adcconfig_json )) == NULL )
exit(AIOUSB_ERROR_INVALID_ADCCONFIG);
if ( (result = aio_override_adcconfig_settings( config, &options )) != AIOUSB_SUCCESS )
exit(result);
/* Save the config for the device index in question */
dev = AIODeviceTableGetDeviceAtIndex( options.index , (AIORESULT*)&result );
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error getting device at index %d\n", options.index );
exit(result);
}
usb = AIOUSBDeviceGetUSBHandle( dev );
/* Copy the modified config settings back to the
* device ave config to the device
*/
result = ADCConfigBlockCopy( AIOUSBDeviceGetADCConfigBlock( dev ), config );
result = USBDevicePutADCConfigBlock( usb, config );
/* or do this
* ADC_SetConfig( options.index, config->registers, &config->size ); */
volts = (double*)malloc((ADCConfigBlockGetEndChannel( config )-ADCConfigBlockGetStartChannel( config )+1)*sizeof(double));
for ( int i = 0, channel = 0; i < options.num_scans; i ++ , channel = 0) {
if ( options.counts ) { /* --counts will write out the raw values */
ADC_GetScan( options.index, (unsigned short*)volts );
unsigned short *counts = (unsigned short *)volts;
for ( int j = ADCConfigBlockGetStartChannel( config ); j < ADCConfigBlockGetEndChannel( config ) ; j ++ , channel ++) {
printf("%u,", counts[channel] );
}
printf("%u\n", counts[channel] );
} else {
ADC_GetScanV( options.index, volts );
for ( int j = ADCConfigBlockGetStartChannel( config ); j < ADCConfigBlockGetEndChannel( config ) ; j ++ , channel ++) {
printf("%.3f,", volts[channel] );
}
printf("%f\n", volts[channel] );
}
}
return 0;
}
int main( int argc, char **argv )
{
struct opts options = AIO_OPTIONS;
AIORET_TYPE result = AIOUSB_SUCCESS;
int *indices;
int num_devices;
ADCConfigBlock *config;
AIOUSBDevice *dev;
process_aio_cmd_line( &options, argc, argv );
result = AIOUSB_Init();
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error calling AIOUSB_Init(): %d\n", (int)result );
exit(result );
}
AIOUSB_ListDevices();
process_aio_cmd_line( &options, argc, argv );
AIOUSB_FindDevices( &indices, &num_devices, find_ai_board );
if( (result = aio_list_devices( &options, indices, num_devices ) != AIOUSB_SUCCESS ))
exit(result);
if ( (config = NewADCConfigBlockFromJSON( options.adcconfig_json )) == NULL )
exit(AIOUSB_ERROR_INVALID_ADCCONFIG);
if ( (result = aio_override_adcconfig_settings( config, &options )) != AIOUSB_SUCCESS )
exit(result);
/* Save the config for the device index in question */
dev = AIODeviceTableGetDeviceAtIndex( options.index , (AIORESULT*)&result );
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error getting device at index %d\n", options.index );
exit(result);
}
unsigned short tmp = 0;
unsigned short mask = 0xffff;
/**
* @brief Make all ports outputs and 0 value as the initial tristate
*/
printf("Configuring all ports for output\n" );
result = DIO_Configure( options.index, AIOUSB_FALSE, &mask, &tmp );
result = DIO_ReadAll( options.index, &tmp ); /* Verify that all the values are initially 0 */
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error performing DIO_ReadAll(): %d\n", result );
exit(1);
}
if ( tmp != 0 ) {
fprintf(stderr, "Error, by default all ports should have value 0, and not %u\n", tmp );
} else {
printf("DIO_ReadAll() gave value %u == %u(expected)\n", tmp, 0 );
}
for ( int i = 0 ; i < dev->DIOBytes*8 ; i ++ ) {
result = DIO_Write1(options.index,i, (i % 2 == 0 ? AIOUSB_FALSE : AIOUSB_TRUE ));
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error running on index %d , retval=%d\n", i, result );
exit(1);
}
}
printf("Successfully performed DIO_Write1()\n");
tmp = 0;
result = DIO_ReadAll( options.index, &tmp );
if ( result != AIOUSB_SUCCESS ) {
fprintf(stderr,"Error performing DIO_ReadAll(): %d\n", result );
} else if ( tmp != 0xaaaa ) {
fprintf(stderr,"Values expected from DIO_ReadAll() %#x != %#x\n", 0xaaaa, tmp );
} else {
printf("DIO_ReadAll() gave value %#x == %#x(expected)\n", tmp, 0xaaaa );
}
return result;
}
