summaryrefslogtreecommitdiffstats
path: root/libk8055
diff options
context:
space:
mode:
Diffstat (limited to 'libk8055')
-rw-r--r--libk8055/k8055.h85
-rw-r--r--libk8055/libk8055.c333
2 files changed, 257 insertions, 161 deletions
diff --git a/libk8055/k8055.h b/libk8055/k8055.h
index 4d5ae81..044349e 100644
--- a/libk8055/k8055.h
+++ b/libk8055/k8055.h
@@ -23,32 +23,65 @@
extern "C" {
#endif
-/* prototypes */
-int OpenDevice(long board_address);
-int CloseDevice();
-long ReadAnalogChannel(long Channelno);
-int ReadAllAnalog(long* data1, long* data2);
-int OutputAnalogChannel(long channel, long data);
-int OutputAllAnalog(long data1,long data2);
-int ClearAllAnalog();
-int ClearAnalogChannel(long channel);
-int SetAnalogChannel(long channel);
-int SetAllAnalog();
-int WriteAllDigital(long data);
-int ClearDigitalChannel(long channel);
-int ClearAllDigital();
-int SetDigitalChannel(long channel);
-int SetAllDigital();
-int ReadDigitalChannel(long channel);
-long ReadAllDigital();
-int ResetCounter(long counternr);
-long ReadCounter(long counterno);
-int SetCounterDebounceTime(long counterno, long debouncetime);
-int ReadAllValues (long int *data1, long int *data2, long int *data3, long int *data4, long int *data5);
-int SetAllValues(int digitaldata, int addata1, int addata2);
-long SetCurrentDevice(long deviceno);
-long SearchDevices(void);
-char *Version(void);
+#define PACKET_LEN 8
+
+ struct k8055_dev {
+ int dev_no;
+ struct usb_dev_handle* device_handle;
+ unsigned char data_in[PACKET_LEN+1];
+ unsigned char data_out[PACKET_LEN+1];
+ };
+
+ long search_devices( void );
+ int open_device( struct k8055_dev* dev, long board_address );
+ int close_device( struct k8055_dev* dev );
+ long read_analog_channel( struct k8055_dev* dev, long channel );
+ int read_all_analog( struct k8055_dev* dev, long* data1, long* data2 );
+ int output_analog_channel( struct k8055_dev* dev ,long channel, long data );
+ int output_all_analog( struct k8055_dev* dev, long data1, long data2 );
+ int clear_all_analog( struct k8055_dev* dev );
+ int clear_analog_channel( struct k8055_dev* dev, long channel );
+ int set_analog_channel( struct k8055_dev* dev, long channel );
+ int set_all_analog( struct k8055_dev* dev );
+ int write_all_digital( struct k8055_dev* dev, long data );
+ int clear_digital_channel( struct k8055_dev* dev, long channel );
+ int clear_all_digital( struct k8055_dev* dev );
+ int set_digital_channel( struct k8055_dev* dev, long channel );
+ int set_all_digital( struct k8055_dev* dev );
+ int read_digital_channel( struct k8055_dev* dev, long channel );
+ long read_all_digital( struct k8055_dev* dev );
+ int read_all_values( struct k8055_dev* dev, long int* data1, long int* data2, long int* data3, long int* data4, long int* data5 );
+ int set_all_values( struct k8055_dev* dev, int digital_data, int ad_data1, int ad_data2 );
+ int reset_counter( struct k8055_dev* dev, long counter );
+ long read_counter( struct k8055_dev* dev, long counter );
+ int set_counter_debounce_time( struct k8055_dev* dev, long counter, long debounce_time );
+
+ /* Velleman API */
+ char* Version( void );
+ long SearchDevices( void );
+ int OpenDevice( long board_address );
+ int CloseDevice();
+ long SetCurrentDevice( long deviceno );
+ long ReadAnalogChannel( long Channelno );
+ int ReadAllAnalog( long* data1, long* data2 );
+ int OutputAnalogChannel( long channel, long data );
+ int OutputAllAnalog( long data1,long data2 );
+ int ClearAllAnalog();
+ int ClearAnalogChannel( long channel );
+ int SetAnalogChannel( long channel );
+ int SetAllAnalog();
+ int WriteAllDigital( long data );
+ int ClearDigitalChannel( long channel );
+ int ClearAllDigital();
+ int SetDigitalChannel( long channel );
+ int SetAllDigital();
+ int ReadDigitalChannel( long channel );
+ long ReadAllDigital();
+ int ReadAllValues ( long int* data1, long int* data2, long int* data3, long int* data4, long int* data5 );
+ int SetAllValues( int digitaldata, int addata1, int addata2 );
+ int ResetCounter( long counternr );
+ long ReadCounter( long counterno );
+ int SetCounterDebounceTime( long counterno, long debouncetime );
#ifdef __cplusplus
}
#endif
diff --git a/libk8055/libk8055.c b/libk8055/libk8055.c
index ff288aa..2df72bd 100644
--- a/libk8055/libk8055.c
+++ b/libk8055/libk8055.c
@@ -87,7 +87,6 @@
#include "k8055.h"
#define STR_BUFF 256
-#define PACKET_LEN 8
#define READ_RETRY 3
#define WRITE_RETRY 3
@@ -118,14 +117,6 @@
/* set debug to 0 to not print excess info */
int debug = 0;
-/* globals for datatransfer */
-struct k8055_dev {
- unsigned char data_in[PACKET_LEN+1];
- unsigned char data_out[PACKET_LEN+1];
- struct usb_dev_handle* device_handle;
- int dev_no;
-};
-
static struct k8055_dev k8055d[K8055_MAX_DEV];
static struct k8055_dev* curr_dev;
@@ -181,45 +172,40 @@ static int takeover_device( usb_dev_handle* udev, int interface ) {
return 0;
}
-/* Open device - scan through usb busses looking for the right device, claim it and then open the device */
-int OpenDevice( long board_address ) {
- if( board_address<0 || board_address>=K8055_MAX_DEV ) return K8055_ERROR;
- if( k8055d[board_address].dev_no!=0 ) return board_address;
+int open_device( struct k8055_dev* dev, long board_address ) {
usb_init();
usb_find_busses();
usb_find_devices();
int ipid = K8055_IPID + ( int )board_address;
struct usb_bus* busses = usb_get_busses();
for( struct usb_bus* bus=busses; bus; bus=bus->next ) {
- for( struct usb_device* dev=bus->devices; dev; dev=dev->next ) {
- if( ( dev->descriptor.idVendor==VELLEMAN_VENDOR_ID ) && ( dev->descriptor.idProduct==ipid ) ) {
- struct k8055_dev* kdev = &k8055d[board_address];
- kdev->dev_no = 0;
- kdev->device_handle = usb_open( dev );
- if( kdev->device_handle==0 ) {
+ for( struct usb_device* usb_dev=bus->devices; usb_dev; usb_dev=usb_dev->next ) {
+ if( ( usb_dev->descriptor.idVendor==VELLEMAN_VENDOR_ID ) && ( usb_dev->descriptor.idProduct==ipid ) ) {
+ dev->dev_no = 0;
+ dev->device_handle = usb_open( usb_dev );
+ if( dev->device_handle==NULL ) {
if( debug ) fprintf( stderr,"usb_open failure : %s\n", usb_strerror() );
return K8055_ERROR;
}
- if( debug ) fprintf( stderr, "Velleman Device Found @ Address %s Vendor 0x0%x Product ID 0x0%x\n", dev->filename, dev->descriptor.idVendor, dev->descriptor.idProduct );
- if( takeover_device( kdev->device_handle, 0 )<0 ) {
+ if( debug ) fprintf( stderr, "Velleman Device Found @ Address %s Vendor 0x0%x Product ID 0x0%x\n", usb_dev->filename, usb_dev->descriptor.idVendor, usb_dev->descriptor.idProduct );
+ if( takeover_device( dev->device_handle, 0 )<0 ) {
if( debug ) fprintf( stderr, "Can not take over the device from the OS driver\n" );
- usb_close( kdev->device_handle );
- kdev->device_handle = NULL;
+ usb_close( dev->device_handle );
+ dev->device_handle = NULL;
return K8055_ERROR;
} else {
- memset( kdev->data_out,0,PACKET_LEN );
- kdev->dev_no = board_address + 1;
- kdev->data_out[0] = CMD_RESET;
- k8055_write( kdev );
- if ( k8055_read( kdev )==0 ) {
+ memset( dev->data_out,0,PACKET_LEN );
+ dev->dev_no = board_address + 1;
+ dev->data_out[0] = CMD_RESET;
+ k8055_write( dev );
+ if ( k8055_read( dev )==0 ) {
if( debug ) fprintf( stderr, "Device %d ready\n",board_address );
- curr_dev = kdev;
return board_address;
} else {
if( debug ) fprintf( stderr, "Device %d not ready\n",board_address );
- kdev->dev_no = 0;
- usb_close( kdev->device_handle );
- kdev->device_handle = NULL;
+ dev->dev_no = 0;
+ usb_close( dev->device_handle );
+ dev->device_handle = NULL;
return K8055_ERROR;
}
}
@@ -230,205 +216,195 @@ int OpenDevice( long board_address ) {
return K8055_ERROR;
}
-/* Close the Current device */
-int CloseDevice() {
- if ( curr_dev->dev_no == 0 ) {
+int close_device( struct k8055_dev* dev ) {
+ if ( dev->dev_no == 0 ) {
if ( debug ) fprintf( stderr, "Current device is not open\n" );
return 0;
}
- if( curr_dev->device_handle==NULL ) {
+ if( dev->device_handle==NULL ) {
if ( debug ) fprintf( stderr, "Current device is marked as open, but device hanlde is NULL\n" );
- curr_dev->dev_no = 0;
+ dev->dev_no = 0;
return 0;
}
- int rc = usb_close( curr_dev->device_handle );
+ int rc = usb_close( dev->device_handle );
if ( rc >= 0 ) {
- curr_dev->dev_no = 0;
- curr_dev->device_handle = NULL;
+ dev->dev_no = 0;
+ dev->device_handle = NULL;
}
return rc;
}
-/* New function in version 2 of Velleman DLL, should return deviceno if OK */
-long SetCurrentDevice( long deviceno ) {
- if ( deviceno < 0 || deviceno >= K8055_MAX_DEV ) return K8055_ERROR;
- if ( k8055d[deviceno].dev_no == 0 ) return K8055_ERROR;
- curr_dev = &k8055d[deviceno];
- return deviceno;
-}
-
-/* New function in version 2 of Velleman DLL, should return devices-found bitmask or 0*/
-long SearchDevices( void ) {
- int retval = 0;
+long search_devices( void ) {
+ int ret = 0;
usb_init();
usb_find_busses();
usb_find_devices();
struct usb_bus* busses = usb_get_busses();
for ( struct usb_bus* bus = busses; bus; bus = bus->next ) {
- for( struct usb_device* dev=bus->devices; dev; dev=dev->next ) {
- if ( dev->descriptor.idVendor == VELLEMAN_VENDOR_ID ) {
- if( dev->descriptor.idProduct == K8055_IPID + 0 ) retval |= 0x01;
- if( dev->descriptor.idProduct == K8055_IPID + 1 ) retval |= 0x02;
- if( dev->descriptor.idProduct == K8055_IPID + 2 ) retval |= 0x04;
- if( dev->descriptor.idProduct == K8055_IPID + 3 ) retval |= 0x08;
+ for( struct usb_device* usb_dev=bus->devices; usb_dev; usb_dev=usb_dev->next ) {
+ if ( usb_dev->descriptor.idVendor == VELLEMAN_VENDOR_ID ) {
+ if( usb_dev->descriptor.idProduct == K8055_IPID + 0 ) ret |= 0x01;
+ if( usb_dev->descriptor.idProduct == K8055_IPID + 1 ) ret |= 0x02;
+ if( usb_dev->descriptor.idProduct == K8055_IPID + 2 ) ret |= 0x04;
+ if( usb_dev->descriptor.idProduct == K8055_IPID + 3 ) ret |= 0x08;
/* else some other kind of Velleman board */
}
}
}
- if( debug ) fprintf( stderr,"found devices : %X\n",retval );
- return retval;
+ if( debug ) fprintf( stderr,"found devices : %X\n",ret );
+ return ret;
}
-long ReadAnalogChannel( long channel ) {
+long read_analog_channel( struct k8055_dev* dev, long channel ) {
if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
- if ( k8055_read( curr_dev )==0 ) {
+ if ( k8055_read( dev )==0 ) {
if ( channel==1 ) {
- return curr_dev->data_in[ANALOG_1_OFFSET];
+ return dev->data_in[ANALOG_1_OFFSET];
} else {
- return curr_dev->data_in[ANALOG_2_OFFSET];
+ return dev->data_in[ANALOG_2_OFFSET];
}
}
return K8055_ERROR;
}
-int ReadAllAnalog( long* data1, long* data2 ) {
- if ( k8055_read( curr_dev )!=0 ) return K8055_ERROR;
- *data1 = curr_dev->data_in[ANALOG_1_OFFSET];
- *data2 = curr_dev->data_in[ANALOG_2_OFFSET];
+int read_all_analog( struct k8055_dev* dev, long* data1, long* data2 ) {
+ if ( k8055_read( dev )!=0 ) return K8055_ERROR;
+ *data1 = dev->data_in[ANALOG_1_OFFSET];
+ *data2 = dev->data_in[ANALOG_2_OFFSET];
return 0;
}
-int OutputAnalogChannel( long channel, long data ) {
+int output_analog_channel( struct k8055_dev* dev ,long channel, long data ) {
if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
- curr_dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
+ dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
if ( channel==1 ) {
- curr_dev->data_out[ANALOG_1_OFFSET] = ( unsigned char )data;
+ dev->data_out[ANALOG_1_OFFSET] = ( unsigned char )data;
} else {
- curr_dev->data_out[ANALOG_2_OFFSET] = ( unsigned char )data;
+ dev->data_out[ANALOG_2_OFFSET] = ( unsigned char )data;
}
- return k8055_write( curr_dev );
+ return k8055_write( dev );
}
-int OutputAllAnalog( long data1, long data2 ) {
- curr_dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
- curr_dev->data_out[2] = ( unsigned char )data1;
- curr_dev->data_out[3] = ( unsigned char )data2;
- return k8055_write( curr_dev );
+int output_all_analog( struct k8055_dev* dev, long data1, long data2 ) {
+ dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
+ dev->data_out[2] = ( unsigned char )data1;
+ dev->data_out[3] = ( unsigned char )data2;
+ return k8055_write( dev );
}
-int ClearAllAnalog() {
- return OutputAllAnalog( 0, 0 );
+int clear_all_analog( struct k8055_dev* dev ) {
+ return output_all_analog( dev, 0, 0 );
}
-int ClearAnalogChannel( long channel ) {
+int clear_analog_channel( struct k8055_dev* dev, long channel ) {
if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
if ( channel==1 ) {
- return OutputAnalogChannel( 1, 0 );
+ return output_analog_channel( dev, 1, 0 );
} else {
- return OutputAnalogChannel( 2, 0 );
+ return output_analog_channel( dev, 2, 0 );
}
}
-int SetAnalogChannel( long channel ) {
+int set_analog_channel( struct k8055_dev* dev, long channel ) {
if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
if ( channel == 2 ) {
- return OutputAnalogChannel( 2, 0xff );
+ return output_analog_channel( dev, 2, 0xff );
} else {
- return OutputAnalogChannel( 1, 0xff );
+ return output_analog_channel( dev, 1, 0xff );
}
}
-int SetAllAnalog() {
- return OutputAllAnalog( 0xff, 0xff );
+int set_all_analog( struct k8055_dev* dev ) {
+ return output_all_analog( dev, 0xff, 0xff );
}
-int WriteAllDigital( long data ) {
- curr_dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
- curr_dev->data_out[1] = ( unsigned char )data;
- return k8055_write( curr_dev );
+int write_all_digital( struct k8055_dev* dev, long data ) {
+ dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
+ dev->data_out[1] = ( unsigned char )data;
+ return k8055_write( dev );
}
-int ClearDigitalChannel( long channel ) {
+int clear_digital_channel( struct k8055_dev* dev, long channel ) {
unsigned char data;
if ( channel<1 || channel>8 ) return K8055_ERROR;
- data = curr_dev->data_out[1] & ~( 1 << ( channel-1 ) );
+ data = dev->data_out[1] & ~( 1 << ( channel-1 ) );
return WriteAllDigital( data );
}
-int ClearAllDigital() {
- return WriteAllDigital( 0x00 );
+int clear_all_digital( struct k8055_dev* dev ) {
+ return write_all_digital( dev, 0x00 );
}
-int SetDigitalChannel( long channel ) {
+int set_digital_channel( struct k8055_dev* dev, long channel ) {
unsigned char data;
if ( channel<1 || channel>8 ) return K8055_ERROR;
- data = curr_dev->data_out[1] | ( 1 << ( channel-1 ) );
- return WriteAllDigital( data );
+ data = dev->data_out[1] | ( 1 << ( channel-1 ) );
+ return write_all_digital( dev, data );
}
-int SetAllDigital() {
- return WriteAllDigital( 0xff );
+int set_all_digital( struct k8055_dev* dev ) {
+ return write_all_digital( dev, 0xff );
}
-int ReadDigitalChannel( long channel ) {
+int read_digital_channel( struct k8055_dev* dev, long channel ) {
int rval;
if ( channel<1 || channel>8 ) return K8055_ERROR;
- if ( ( rval = ReadAllDigital() ) == K8055_ERROR ) return K8055_ERROR;
+ if ( ( rval = read_all_digital( dev ) ) == K8055_ERROR ) return K8055_ERROR;
return ( ( rval & ( 1 << ( channel-1 ) ) ) > 0 );
}
-long ReadAllDigital() {
+long read_all_digital( struct k8055_dev* dev ) {
int return_data = 0;
- if ( k8055_read( curr_dev )!=0 ) return K8055_ERROR;
+ if ( k8055_read( dev )!=0 ) return K8055_ERROR;
return_data = (
- ( ( curr_dev->data_in[0] >> 4 ) & 0x03 ) | /* Input 1 and 2 */
- ( ( curr_dev->data_in[0] << 2 ) & 0x04 ) | /* Input 3 */
- ( ( curr_dev->data_in[0] >> 3 ) & 0x18 ) ); /* Input 4 and 5 */
+ ( ( dev->data_in[0] >> 4 ) & 0x03 ) | /* Input 1 and 2 */
+ ( ( dev->data_in[0] << 2 ) & 0x04 ) | /* Input 3 */
+ ( ( dev->data_in[0] >> 3 ) & 0x18 ) ); /* Input 4 and 5 */
return return_data;
}
-int ReadAllValues( long int* data1, long int* data2, long int* data3, long int* data4, long int* data5 ) {
- if ( k8055_read( curr_dev )!=0 ) return K8055_ERROR;
+int read_all_values( struct k8055_dev* dev, long int* data1, long int* data2, long int* data3, long int* data4, long int* data5 ) {
+ if ( k8055_read( dev )!=0 ) return K8055_ERROR;
*data1 = (
- ( ( curr_dev->data_in[0] >> 4 ) & 0x03 ) | /* Input 1 and 2 */
- ( ( curr_dev->data_in[0] << 2 ) & 0x04 ) | /* Input 3 */
- ( ( curr_dev->data_in[0] >> 3 ) & 0x18 ) ); /* Input 4 and 5 */
- *data2 = curr_dev->data_in[ANALOG_1_OFFSET];
- *data3 = curr_dev->data_in[ANALOG_2_OFFSET];
- *data4 = *( ( short int* )( &curr_dev->data_in[COUNTER_1_OFFSET] ) );
- *data5 = *( ( short int* )( &curr_dev->data_in[COUNTER_2_OFFSET] ) );
+ ( ( dev->data_in[0] >> 4 ) & 0x03 ) | /* Input 1 and 2 */
+ ( ( dev->data_in[0] << 2 ) & 0x04 ) | /* Input 3 */
+ ( ( dev->data_in[0] >> 3 ) & 0x18 ) ); /* Input 4 and 5 */
+ *data2 = dev->data_in[ANALOG_1_OFFSET];
+ *data3 = dev->data_in[ANALOG_2_OFFSET];
+ *data4 = *( ( short int* )( &dev->data_in[COUNTER_1_OFFSET] ) );
+ *data5 = *( ( short int* )( &dev->data_in[COUNTER_2_OFFSET] ) );
return 0;
}
-int SetAllValues( int DigitalData, int AdData1, int AdData2 ) {
- curr_dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
- curr_dev->data_out[1] = ( unsigned char )DigitalData;
- curr_dev->data_out[2] = ( unsigned char )AdData1;
- curr_dev->data_out[3] = ( unsigned char )AdData2;
- return k8055_write( curr_dev );
+int set_all_values( struct k8055_dev* dev, int digital_data, int ad_data1, int ad_data2 ) {
+ dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
+ dev->data_out[1] = ( unsigned char )digital_data;
+ dev->data_out[2] = ( unsigned char )ad_data1;
+ dev->data_out[3] = ( unsigned char )ad_data2;
+ return k8055_write( dev );
}
-int ResetCounter( long counter ) {
+int reset_counter( struct k8055_dev* dev, long counter ) {
if ( !( counter==1 || counter==2 ) ) return K8055_ERROR;
- curr_dev->data_out[0] = 0x02 + ( unsigned char )counter;
- curr_dev->data_out[3+counter] = 0x00;
- return k8055_write( curr_dev );
+ dev->data_out[0] = 0x02 + ( unsigned char )counter;
+ dev->data_out[3+counter] = 0x00;
+ return k8055_write( dev );
}
-long ReadCounter( long counter ) {
+long read_counter( struct k8055_dev* dev, long counter ) {
if ( !( counter==1 || counter==2 ) ) return K8055_ERROR;
- if ( k8055_read( curr_dev )!=0 ) return K8055_ERROR;
+ if ( k8055_read( dev )!=0 ) return K8055_ERROR;
if ( counter==1 ) {
- return *( ( short int* )( &curr_dev->data_in[COUNTER_1_OFFSET] ) );
+ return *( ( short int* )( &dev->data_in[COUNTER_1_OFFSET] ) );
} else {
- return *( ( short int* )( &curr_dev->data_in[COUNTER_2_OFFSET] ) );
+ return *( ( short int* )( &dev->data_in[COUNTER_2_OFFSET] ) );
}
}
-int SetCounterDebounceTime( long counter, long debounce_time ) {
+int set_counter_debounce_time( struct k8055_dev* dev, long counter, long debounce_time ) {
float value;
if ( !( counter==1 || counter==2 ) ) return K8055_ERROR;
- curr_dev->data_out[0] = ( unsigned char )counter;
+ dev->data_out[0] = ( unsigned char )counter;
/*
* the velleman k8055 use a exponetial formula to split up the
* debounce_time 0-7450 over value 1-255. I've tested every value and
@@ -443,11 +419,98 @@ int SetCounterDebounceTime( long counter, long debounce_time ) {
value = sqrtf( debounce_time / 0.115 );
/* simple round() function) */
if ( value > ( ( int )value + 0.49999999 ) ) value+=1;
- curr_dev->data_out[5+counter] = ( unsigned char )value;
- if ( debug ) fprintf( stderr, "Debouncetime%d value for k8055:%d\n",( int )counter, curr_dev->data_out[5+counter] );
- return k8055_write( curr_dev );
+ dev->data_out[5+counter] = ( unsigned char )value;
+ if ( debug ) fprintf( stderr, "Debouncetime%d value for k8055:%d\n",( int )counter, dev->data_out[5+counter] );
+ return k8055_write( dev );
}
+/** Velleman API ***************************************************************************************************************************/
char* Version( void ) {
return( VERSION );
}
+/* New function in version 2 of Velleman DLL, should return devices-found bitmask or 0*/
+long SearchDevices( void ) {
+ return search_devices();
+}
+/* Open device - scan through usb busses looking for the right device, claim it and then open the device */
+int OpenDevice( long board_address ) {
+ if( board_address<0 || board_address>=K8055_MAX_DEV ) return K8055_ERROR;
+ if( k8055d[board_address].dev_no!=0 ) return board_address;
+ int ret = open_device( &k8055d[board_address], board_address );
+ if ( ret != K8055_ERROR ) {
+ curr_dev = &k8055d[board_address];
+ return ret;
+ }
+ return K8055_ERROR;
+}
+/* Close the Current device */
+int CloseDevice() {
+ return close_device( curr_dev );
+}
+/* New function in version 2 of Velleman DLL, should return deviceno if OK */
+long SetCurrentDevice( long deviceno ) {
+ if ( deviceno < 0 || deviceno >= K8055_MAX_DEV ) return K8055_ERROR;
+ if ( k8055d[deviceno].dev_no == 0 ) return K8055_ERROR;
+ curr_dev = &k8055d[deviceno];
+ return deviceno;
+}
+long ReadAnalogChannel( long channel ) {
+ return read_analog_channel( curr_dev, channel );
+}
+int ReadAllAnalog( long* data1, long* data2 ) {
+ return read_all_analog( curr_dev, data1, data2 );
+}
+int OutputAnalogChannel( long channel, long data ) {
+ return output_analog_channel( curr_dev, channel, data );
+}
+int OutputAllAnalog( long data1, long data2 ) {
+ return output_all_analog( curr_dev, data1, data2 );
+}
+int ClearAllAnalog() {
+ return clear_all_analog( curr_dev );
+}
+int ClearAnalogChannel( long channel ) {
+ return clear_analog_channel( curr_dev, channel );
+}
+int SetAnalogChannel( long channel ) {
+ return set_analog_channel( curr_dev, channel );
+}
+int SetAllAnalog() {
+ return set_all_analog( curr_dev );
+}
+int WriteAllDigital( long data ) {
+ return write_all_digital( curr_dev, data );
+}
+int ClearDigitalChannel( long channel ) {
+ return clear_digital_channel( curr_dev, channel );
+}
+int ClearAllDigital() {
+ return clear_all_digital( curr_dev );
+}
+int SetDigitalChannel( long channel ) {
+ return set_digital_channel( curr_dev, channel );
+}
+int SetAllDigital() {
+ return set_all_digital( curr_dev );
+}
+int ReadDigitalChannel( long channel ) {
+ return read_digital_channel( curr_dev, channel );
+}
+long ReadAllDigital() {
+ return read_all_digital( curr_dev );
+}
+int ReadAllValues( long int* data1, long int* data2, long int* data3, long int* data4, long int* data5 ) {
+ return read_all_values( curr_dev, data1, data2, data3, data4, data5 );
+}
+int SetAllValues( int DigitalData, int AdData1, int AdData2 ) {
+ return set_all_values( curr_dev, DigitalData, AdData1, AdData2 );
+}
+int ResetCounter( long counter ) {
+ return reset_counter( curr_dev, counter );
+}
+long ReadCounter( long counter ) {
+ return read_counter( curr_dev, counter );
+}
+int SetCounterDebounceTime( long counter, long debounce_time ) {
+ return set_counter_debounce_time( curr_dev, counter, debounce_time );
+}
generated by cgit v1.1-2-g2b99 at 2024-11-22 11:14:12 +0100