reformat libk8055.c

1 files changed, 145 insertions, 145 deletions

diff --git a/libk8055/libk8055.c b/libk8055/libk8055.c
index 3fae4e5..ff288aa 100644
--- a/libk8055/libk8055.c
+++ b/libk8055/libk8055.c
@@ -122,103 +122,103 @@ int debug = 0;
 struct k8055_dev {
     unsigned char data_in[PACKET_LEN+1];
     unsigned char data_out[PACKET_LEN+1];
-    struct usb_dev_handle *device_handle;
+    struct usb_dev_handle* device_handle;
     int dev_no;
 };
 
 static struct k8055_dev k8055d[K8055_MAX_DEV];
-static struct k8055_dev *curr_dev;
+static struct k8055_dev* curr_dev;
 
 /* Actual read of data from the device endpoint, retry READ_RETRY times if not responding ok */
 static int k8055_read( struct k8055_dev* dev ) {
-    if(dev->dev_no==0) return K8055_ERROR;
-    for(int i=0; i<READ_RETRY; i++) {
-        int read_status = usb_interrupt_read(dev->device_handle, USB_INP_EP, (char*)dev->data_in, PACKET_LEN, USB_TIMEOUT);
-        if( (read_status==PACKET_LEN) && (dev->data_in[1]==dev->dev_no) ) {
-            if(debug) fprintf(stderr,"read dev %d data : %X\n",dev->data_in[1],dev->data_in);
+    if( dev->dev_no==0 ) return K8055_ERROR;
+    for( int i=0; i<READ_RETRY; i++ ) {
+        int read_status = usb_interrupt_read( dev->device_handle, USB_INP_EP, ( char* )dev->data_in, PACKET_LEN, USB_TIMEOUT );
+        if( ( read_status==PACKET_LEN ) && ( dev->data_in[1]==dev->dev_no ) ) {
+            if( debug ) fprintf( stderr,"read dev %d data : %X\n",dev->data_in[1],dev->data_in );
             return 0;
         }
-        if(debug) fprintf(stderr, "k8055 read retry\n");
+        if( debug ) fprintf( stderr, "k8055 read retry\n" );
     }
     return K8055_ERROR;
 }
 
 /* Actual write of data to the device endpont, retry WRITE_RETRY times if not reponding correctly */
 static int k8055_write( struct k8055_dev* dev ) {
-    if(dev->dev_no == 0) return K8055_ERROR;
-    for(int i=0; i<WRITE_RETRY; i++) {
-        int write_status = usb_interrupt_write(dev->device_handle, USB_OUT_EP, (char*)dev->data_out, PACKET_LEN, USB_TIMEOUT);
-        if(write_status==PACKET_LEN) return 0;
-        if(debug) fprintf(stderr, "k8055 write retry\n");
+    if( dev->dev_no == 0 ) return K8055_ERROR;
+    for( int i=0; i<WRITE_RETRY; i++ ) {
+        int write_status = usb_interrupt_write( dev->device_handle, USB_OUT_EP, ( char* )dev->data_out, PACKET_LEN, USB_TIMEOUT );
+        if( write_status==PACKET_LEN ) return 0;
+        if( debug ) fprintf( stderr, "k8055 write retry\n" );
     }
     return K8055_ERROR;
 }
 
 /* If device is owned by some kernel driver, try to disconnect it and claim the device*/
-static int takeover_device(usb_dev_handle * udev, int interface) {
+static int takeover_device( usb_dev_handle* udev, int interface ) {
     char driver_name[STR_BUFF];
-    memset(driver_name, 0, STR_BUFF);
+    memset( driver_name, 0, STR_BUFF );
     int ret = K8055_ERROR;
-    assert(udev != NULL);
-    if(usb_get_driver_np(udev, interface, driver_name, sizeof(driver_name))==0) {
-        if(debug) fprintf(stderr, "usb_get_driver_np success: %s\n", driver_name);
-        if(usb_detach_kernel_driver_np(udev, interface)==0) {
-            if(debug) fprintf(stderr, "usb_detach_kernel_driver_np success");
+    assert( udev != NULL );
+    if( usb_get_driver_np( udev, interface, driver_name, sizeof( driver_name ) )==0 ) {
+        if( debug ) fprintf( stderr, "usb_get_driver_np success: %s\n", driver_name );
+        if( usb_detach_kernel_driver_np( udev, interface )==0 ) {
+            if( debug ) fprintf( stderr, "usb_detach_kernel_driver_np success" );
         } else {
-            if(debug) fprintf(stderr, "usb_detach_kernel_driver_np failure : %s\n", usb_strerror());
+            if( debug ) fprintf( stderr, "usb_detach_kernel_driver_np failure : %s\n", usb_strerror() );
         }
     } else {
-        if(debug) fprintf(stderr, "usb_get_driver_np failure : %s\n", usb_strerror());
+        if( debug ) fprintf( stderr, "usb_get_driver_np failure : %s\n", usb_strerror() );
     }
-    if (usb_claim_interface(udev, interface)==0) {
-        usb_set_altinterface(udev, interface);
+    if ( usb_claim_interface( udev, interface )==0 ) {
+        usb_set_altinterface( udev, interface );
     } else {
-        if(debug) fprintf(stderr, "usb_claim_interface failure: %s\n", usb_strerror());
+        if( debug ) fprintf( stderr, "usb_claim_interface failure: %s\n", usb_strerror() );
         return K8055_ERROR;
     }
-    usb_set_configuration(udev, 1);
-    if (debug) fprintf(stderr, "Found interface %d, took over the device\n", interface);
+    usb_set_configuration( udev, 1 );
+    if ( debug ) fprintf( stderr, "Found interface %d, took over the device\n", 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;
+    if( k8055d[board_address].dev_no!=0 ) return board_address;
     usb_init();
     usb_find_busses();
     usb_find_devices();
-    int ipid = K8055_IPID + (int)board_address;
+    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];
+            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) {
-                    if(debug) fprintf(stderr,"usb_open failure : %s\n", usb_strerror());
+                kdev->device_handle = usb_open( dev );
+                if( kdev->device_handle==0 ) {
+                    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, "Can not take over the device from the OS driver\n");
-                    usb_close(kdev->device_handle);
+                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, "Can not take over the device from the OS driver\n" );
+                    usb_close( kdev->device_handle );
                     kdev->device_handle = NULL;
                     return K8055_ERROR;
                 } else {
-                    memset(kdev->data_out,0,PACKET_LEN);
+                    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) {
-                        if(debug) fprintf(stderr, "Device %d ready\n",board_address);
+                    k8055_write( kdev );
+                    if ( k8055_read( kdev )==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);
+                        if( debug ) fprintf( stderr, "Device %d not ready\n",board_address );
                         kdev->dev_no = 0;
-                        usb_close(kdev->device_handle);
+                        usb_close( kdev->device_handle );
                         kdev->device_handle = NULL;
                         return K8055_ERROR;
                     }
@@ -226,23 +226,23 @@ int OpenDevice( long board_address ) {
             }
         }
     }
-    if(debug) fprintf(stderr, "Could not find Velleman k8055 with address %d\n",(int)board_address);
+    if( debug ) fprintf( stderr, "Could not find Velleman k8055 with address %d\n",( int )board_address );
     return K8055_ERROR;
 }
 
 /* Close the Current device */
 int CloseDevice() {
-    if (curr_dev->dev_no == 0) {
-        if (debug) fprintf(stderr, "Current device is not open\n" );
+    if ( curr_dev->dev_no == 0 ) {
+        if ( debug ) fprintf( stderr, "Current device is not open\n" );
         return 0;
     }
-    if(curr_dev->device_handle==NULL) {
-        if (debug) fprintf(stderr, "Current device is marked as open, but device hanlde is NULL\n" );
+    if( curr_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;
         return 0;
     }
-    int rc = usb_close(curr_dev->device_handle);
-    if (rc >= 0) {
+    int rc = usb_close( curr_dev->device_handle );
+    if ( rc >= 0 ) {
         curr_dev->dev_no = 0;
         curr_dev->device_handle = NULL;
     }
@@ -250,39 +250,39 @@ int CloseDevice() {
 }
 
 /* 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;
+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) {
+long SearchDevices( void ) {
     int retval = 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_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;
+            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;
                 /* 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",retval );
+    return retval;
 }
 
-long ReadAnalogChannel(long channel) {
-    if (!(channel==1 || channel==2)) return K8055_ERROR;
-    if ( k8055_read(curr_dev)==0) {
-        if (channel==1) {
+long ReadAnalogChannel( long channel ) {
+    if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
+    if ( k8055_read( curr_dev )==0 ) {
+        if ( channel==1 ) {
             return curr_dev->data_in[ANALOG_1_OFFSET];
         } else {
             return curr_dev->data_in[ANALOG_2_OFFSET];
@@ -291,144 +291,144 @@ long ReadAnalogChannel(long channel) {
     return K8055_ERROR;
 }
 
-int ReadAllAnalog(long *data1, long *data2) {
-    if ( k8055_read(curr_dev)!=0 ) 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];
     return 0;
 }
 
-int OutputAnalogChannel(long channel, long data) {
-    if (!(channel==1 || channel==2)) return K8055_ERROR;
+int OutputAnalogChannel( long channel, long data ) {
+    if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
     curr_dev->data_out[0] = CMD_SET_ANALOG_DIGITAL;
-    if (channel==1) {
-        curr_dev->data_out[ANALOG_1_OFFSET] = (unsigned char)data;
+    if ( channel==1 ) {
+        curr_dev->data_out[ANALOG_1_OFFSET] = ( unsigned char )data;
     } else {
-        curr_dev->data_out[ANALOG_2_OFFSET] = (unsigned char)data;
+        curr_dev->data_out[ANALOG_2_OFFSET] = ( unsigned char )data;
     }
-    return k8055_write(curr_dev);
+    return k8055_write( curr_dev );
 }
 
-int OutputAllAnalog(long data1, long data2) {
+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);
+    curr_dev->data_out[2] = ( unsigned char )data1;
+    curr_dev->data_out[3] = ( unsigned char )data2;
+    return k8055_write( curr_dev );
 }
 
 int ClearAllAnalog() {
-    return OutputAllAnalog(0, 0);
+    return OutputAllAnalog( 0, 0 );
 }
 
-int ClearAnalogChannel(long channel) {
-    if (!(channel==1 || channel==2)) return K8055_ERROR;
-    if (channel==1) {
-        return OutputAnalogChannel(1, 0);
+int ClearAnalogChannel( long channel ) {
+    if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
+    if ( channel==1 ) {
+        return OutputAnalogChannel( 1, 0 );
     } else {
-        return OutputAnalogChannel(2, 0);
+        return OutputAnalogChannel( 2, 0 );
     }
 }
 
-int SetAnalogChannel(long channel) {
-    if (!(channel==1 || channel==2)) return K8055_ERROR;
-    if (channel == 2) {
-        return OutputAnalogChannel(2, 0xff);
+int SetAnalogChannel( long channel ) {
+    if ( !( channel==1 || channel==2 ) ) return K8055_ERROR;
+    if ( channel == 2 ) {
+        return OutputAnalogChannel( 2, 0xff );
     } else {
-        return OutputAnalogChannel(1, 0xff);
+        return OutputAnalogChannel( 1, 0xff );
     }
 }
 
 int SetAllAnalog() {
-    return OutputAllAnalog(0xff, 0xff);
+    return OutputAllAnalog( 0xff, 0xff );
 }
 
-int WriteAllDigital(long data) {
+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);
+    curr_dev->data_out[1] = ( unsigned char )data;
+    return k8055_write( curr_dev );
 }
 
-int ClearDigitalChannel(long channel) {
+int ClearDigitalChannel( 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);
+    if ( channel<1 || channel>8 ) return K8055_ERROR;
+    data = curr_dev->data_out[1] & ~( 1 << ( channel-1 ) );
+    return WriteAllDigital( data );
 }
 
 int ClearAllDigital() {
-    return WriteAllDigital(0x00);
+    return WriteAllDigital( 0x00 );
 }
 
-int SetDigitalChannel(long channel) {
+int SetDigitalChannel( 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);
+    if ( channel<1 || channel>8 ) return K8055_ERROR;
+    data = curr_dev->data_out[1] | ( 1 << ( channel-1 ) );
+    return WriteAllDigital( data );
 }
 
 int SetAllDigital() {
-    return WriteAllDigital(0xff);
+    return WriteAllDigital( 0xff );
 }
 
-int ReadDigitalChannel(long channel) {
+int ReadDigitalChannel( long channel ) {
     int rval;
-    if (channel<1 || channel>8) return K8055_ERROR;
-    if ((rval = ReadAllDigital()) == K8055_ERROR) return K8055_ERROR;
-    return ((rval & (1 << (channel-1))) > 0);
+    if ( channel<1 || channel>8 ) return K8055_ERROR;
+    if ( ( rval = ReadAllDigital() ) == K8055_ERROR ) return K8055_ERROR;
+    return ( ( rval & ( 1 << ( channel-1 ) ) ) > 0 );
 }
 
 long ReadAllDigital() {
     int return_data = 0;
-    if ( k8055_read(curr_dev)!=0) return K8055_ERROR;
+    if ( k8055_read( curr_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 */
+                      ( ( 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 */
     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 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;
     *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 */
+                 ( ( 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]));
+    *data4 = *( ( short int* )( &curr_dev->data_in[COUNTER_1_OFFSET] ) );
+    *data5 = *( ( short int* )( &curr_dev->data_in[COUNTER_2_OFFSET] ) );
     return 0;
 }
 
-int SetAllValues(int DigitalData, int AdData1, int AdData2) {
+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);
+    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 ResetCounter(long counter) {
-    if (!(counter==1 || counter==2)) return K8055_ERROR;
-    curr_dev->data_out[0] = 0x02 + (unsigned char)counter;
+int ResetCounter( 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);
+    return k8055_write( curr_dev );
 }
 
-long ReadCounter(long counter) {
-    if (!(counter==1 || counter==2)) return K8055_ERROR;
-    if (k8055_read(curr_dev)!=0) return K8055_ERROR;
-    if (counter==1) {
-        return *((short int *)(&curr_dev->data_in[COUNTER_1_OFFSET]));
+long ReadCounter( long counter ) {
+    if ( !( counter==1 || counter==2 ) ) return K8055_ERROR;
+    if ( k8055_read( curr_dev )!=0 ) return K8055_ERROR;
+    if ( counter==1 ) {
+        return *( ( short int* )( &curr_dev->data_in[COUNTER_1_OFFSET] ) );
     } else {
-        return *((short int *)(&curr_dev->data_in[COUNTER_2_OFFSET]));
+        return *( ( short int* )( &curr_dev->data_in[COUNTER_2_OFFSET] ) );
     }
 }
 
-int SetCounterDebounceTime(long counter, long debounce_time) {
+int SetCounterDebounceTime( long counter, long debounce_time ) {
     float value;
-    if (!(counter==1 || counter==2)) return K8055_ERROR;
-    curr_dev->data_out[0] = (unsigned char)counter;
+    if ( !( counter==1 || counter==2 ) ) return K8055_ERROR;
+    curr_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
@@ -439,15 +439,15 @@ int SetCounterDebounceTime(long counter, long debounce_time) {
      * high values. But the time set with this formula is within +-4%
      *  -- Sven Lindberg
      */
-    if (debounce_time > 7450) debounce_time = 7450;
-    value = sqrtf(debounce_time / 0.115);
+    if ( debounce_time > 7450 ) debounce_time = 7450;
+    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);
+    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 );
 }
 
-char * Version(void) {
-    return(VERSION);
+char* Version( void ) {
+    return( VERSION );
 }