//http://www.dreamincode.net/forums/topic/148707-introduction-to-using-libusb-10/
int list_all_usb_devices() {
libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
libusb_context *ctx = NULL; //a libusb session
int r; //for return values
ssize_t cnt; //holding number of devices in list
r = libusb_init(&ctx); //initialize a library session
if(r < 0) {
std::cout<<"Init Error "<<r<<std::endl; //there was an error
return 1;
}
libusb_set_debug(ctx, 3); //set verbosity level to 3, as suggested in the documentation
cnt = libusb_get_device_list(ctx, &devs); //get the list of devices
if(cnt < 0)
std::cout<<"Get Device Error"<<std::endl; //there was an error
std::cout<<cnt<<" Devices in list."<<std::endl; //print total number of usb devices
ssize_t i; //for iterating through the list
for(i = 0; i < cnt; i++)
printdev(devs[i]); //print specs of this device
libusb_free_device_list(devs, 1); //free the list, unref the devices in it
libusb_exit(ctx); //close the session
return 0;
}
int main(int argc, char **argv) {
printf("Arguments: %i\n",argc);
int arg;
for (arg = 0 ; arg < argc ; arg++)
printf(" %i: %s;\n", arg,argv[arg]);
if ((argc > 1) && argv[1][0] == '1') {
test = 1;
printf("Set test\n");
}
libusb_device **list;
//libusb_device *accel;
libusb_context *ctx = NULL;
libusb_init(&ctx);
libusb_set_debug(ctx,3);
names_init("./usb.ids");
ssize_t cnt = libusb_get_device_list(ctx,&list);
ssize_t i = 0;
int err = 0;
if (cnt < 0) {
printf("Error getting usb device list\n");
exit(1);
}
for (i = 0 ; i < cnt ; i++) {
libusb_device *device = list[i];
struct libusb_device_descriptor desc;
err = libusb_get_device_descriptor(device,&desc);
if (err < 0)
printf("Error getting device descriptor: %i\n",err);
else {
if (desc.idVendor == VENDOR_ID && desc.idProduct == PRODUCT_ID) {
printf("Device Found: idVendor = %xh, idProduct = %xh\n",desc.idVendor, desc.idProduct);
printdev(device);
int reattach = 0;
libusb_device_handle *handle;
int r = libusb_open(device,&handle);
if (r < 0){
printf("Error opening device: %i\n",r);
exit(1);
}
if (libusb_kernel_driver_active(handle,0)) {
printf("Device already has a kernel driver\n");
r = libusb_detach_kernel_driver(handle,0);
if (r < 0) {
printf("Unable to detach kernel driver: %i\n",r);
goto CLOSE;
}
reattach = 1;
}
if (libusb_claim_interface(handle,0) == 0) {
printf("Claimed Device\n");
dump_hid(device,handle);
if (test) {
printf("Beginning report testing\n");
test_report(handle);
}
}
CLOSE:
libusb_release_interface(handle, 0);
if (reattach) {
r = libusb_attach_kernel_driver(handle,0);
if (r < 0) {
printf("Failed to reattach kernel driver: %i\n",r);
switch (-1) {
case LIBUSB_ERROR_IO:
printf("I/O error\n");
break;
case LIBUSB_ERROR_ACCESS:
printf("Access Denied\n");
break;
case LIBUSB_ERROR_NOT_FOUND:
printf("Kernel driver wasn't active\n");
break;
case LIBUSB_ERROR_INVALID_PARAM:
printf("Interface doesn't exist\n");
break;
case LIBUSB_ERROR_NO_DEVICE:
printf("Device was disconnected\n");
break;
case LIBUSB_ERROR_BUSY:
printf("Interface is still claimed\n");
break;
case LIBUSB_ERROR_TIMEOUT:
printf("Operation timed out\n");
break;
case LIBUSB_ERROR_OVERFLOW:
printf("Overflow\n");
break;
case LIBUSB_ERROR_PIPE:
printf("Pipe Error\n");
break;
case LIBUSB_ERROR_INTERRUPTED:
printf("System call interrupted\n");
break;
case LIBUSB_ERROR_NO_MEM:
printf("Insufficient Memory\n");
break;
case LIBUSB_ERROR_NOT_SUPPORTED:
printf("Operation not supported\n");
break;
default:
printf("Some other error occured\n");
break;
}
}
}
libusb_close(handle);
}
}
}
libusb_free_device_list(list,1);
libusb_exit(ctx);
exit(err);
}
void
printlong(const DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20];
#ifdef COLORLS
int color_printed = 0;
#endif
if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
(f_longform || f_size)) {
xo_emit("{L:total} {:total-blocks/%lu}\n",
howmany(dp->btotal, blocksize));
}
xo_open_list("entry");
for (p = dp->list; p; p = p->fts_link) {
char *name, *type;
if (IS_NOPRINT(p))
continue;
xo_open_instance("entry");
sp = p->fts_statp;
name = getname(p->fts_name);
if (name)
xo_emit("{ke:name/%hs}", name);
if (f_inode)
xo_emit("{t:inode/%*ju} ",
dp->s_inode, (uintmax_t)sp->st_ino);
if (f_size)
xo_emit("{t:blocks/%*jd} ",
dp->s_block, howmany(sp->st_blocks, blocksize));
strmode(sp->st_mode, buf);
aclmode(buf, p);
np = p->fts_pointer;
xo_attr("value", "%03o", (int) sp->st_mode & ALLPERMS);
if (f_numericonly) {
xo_emit("{t:mode/%s}{e:mode_octal/%03o} {t:links/%*u} {td:user/%-*s}{e:user/%ju} {td:group/%-*s}{e:group/%ju} ",
buf, (int) sp->st_mode & ALLPERMS, dp->s_nlink, sp->st_nlink,
dp->s_user, np->user, sp->st_uid, dp->s_group, np->group, sp->st_gid);
} else {
xo_emit("{t:mode/%s}{e:mode_octal/%03o} {t:links/%*u} {t:user/%-*s} {t:group/%-*s} ",
buf, (int) sp->st_mode & ALLPERMS, dp->s_nlink, sp->st_nlink,
dp->s_user, np->user, dp->s_group, np->group);
}
if (S_ISBLK(sp->st_mode))
asprintf(&type, "block");
if (S_ISCHR(sp->st_mode))
asprintf(&type, "character");
if (S_ISDIR(sp->st_mode))
asprintf(&type, "directory");
if (S_ISFIFO(sp->st_mode))
asprintf(&type, "fifo");
if (S_ISLNK(sp->st_mode))
asprintf(&type, "symlink");
if (S_ISREG(sp->st_mode))
asprintf(&type, "regular");
if (S_ISSOCK(sp->st_mode))
asprintf(&type, "socket");
if (S_ISWHT(sp->st_mode))
asprintf(&type, "whiteout");
xo_emit("{e:type/%s}", type);
free(type);
if (f_flags)
xo_emit("{:flags/%-*s} ", dp->s_flags, np->flags);
if (f_label)
xo_emit("{t:label/%-*s} ", dp->s_label, np->label);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
printdev(dp->s_size, sp->st_rdev);
else
printsize("size", dp->s_size, sp->st_size);
if (f_accesstime)
printtime("access-time", sp->st_atime);
else if (f_birthtime)
printtime("birth-time", sp->st_birthtime);
else if (f_statustime)
printtime("change-time", sp->st_ctime);
else
printtime("modify-time", sp->st_mtime);
#ifdef COLORLS
if (f_color)
color_printed = colortype(sp->st_mode);
#endif
if (name) {
xo_emit("{dk:name/%hs}", name);
free(name);
}
#ifdef COLORLS
if (f_color && color_printed)
endcolor(0);
#endif
if (f_type)
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
xo_close_instance("entry");
xo_emit("\n");
}
xo_close_list("entry");
}
void
printlong(const DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20];
#ifdef COLORLS
int color_printed = 0;
#endif
if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
(f_longform || f_size)) {
(void)printf("total %lu\n", howmany(dp->btotal, blocksize));
}
for (p = dp->list; p; p = p->fts_link) {
if (IS_NOPRINT(p))
continue;
sp = p->fts_statp;
if (f_inode)
(void)printf("%*lu ", dp->s_inode, (u_long)sp->st_ino);
if (f_size)
(void)printf("%*jd ",
dp->s_block, howmany(sp->st_blocks, blocksize));
strmode(sp->st_mode, buf);
aclmode(buf, p);
np = p->fts_pointer;
(void)printf("%s %*u %-*s %-*s ", buf, dp->s_nlink,
sp->st_nlink, dp->s_user, np->user, dp->s_group,
np->group);
if (f_flags)
(void)printf("%-*s ", dp->s_flags, np->flags);
if (f_label)
(void)printf("%-*s ", dp->s_label, np->label);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
printdev(dp->s_size, sp->st_rdev);
else
printsize(dp->s_size, sp->st_size);
if (f_accesstime)
printtime(sp->st_atime);
else if (f_birthtime)
printtime(sp->st_birthtime);
else if (f_statustime)
printtime(sp->st_ctime);
else
printtime(sp->st_mtime);
#ifdef COLORLS
if (f_color)
color_printed = colortype(sp->st_mode);
#endif
(void)printname(p->fts_name);
#ifdef COLORLS
if (f_color && color_printed)
endcolor(0);
#endif
if (f_type)
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
(void)putchar('\n');
}
}
int setup_usb(void){
int status; //Holds status value for functions
ssize_t dev_cnt; //Holds number of devices found
//////////////////-Create libusb session
status = libusb_init(&ctx); //Create a libusb session
if(status < 0){
cout<<"Cannot create libusb session. Error: "<<status<<endl;
exit(-2);
}
libusb_set_debug(ctx,3); //Set verbosity to lvl 3
//////////////////
//////////////////-Available USB devices
dev_cnt = libusb_get_device_list(ctx, &dev); //Get list of USB devices
#ifdef USB_DEBUG
if(dev_cnt < 0 ){
cout<<"No USB devices found"<<endl;
}
ssize_t i; //Search through device list
for(i = 0; i < dev_cnt; i++){
status = libusb_get_device_descriptor(dev[i], &desc);
if(status < 0){
cout<<"Failed to get device descriptor"<<endl;
exit(-2);
}
if(desc.idVendor == SCROD_USB_VID && desc.idProduct == SCROD_USB_PID){
cout<<"Found SCROD USB Device"<<endl;
printdev(dev[i]);
list_endpoints(dev[i]);
break;
}
}
if(i == dev_cnt){
cout<<"Could not find SCROD USB Device"<<endl;
exit(-2);
}
#endif
//////////////////
//////////////////-Open USB device
dev_handle = libusb_open_device_with_vid_pid(ctx,SCROD_USB_VID,SCROD_USB_PID); //Open SCROD USB Device
if(dev_handle == NULL){
cout<<"Could not open SCROD USB Device"<<endl;
exit(-2);
}
else{
cout<<"SCROD USB Device Opened"<<endl;
}
libusb_free_device_list(dev,1); //Unreferencing devices in device list as suggested in documentation
//////////////////
//////////////////-Check kernel status
status = libusb_kernel_driver_active(dev_handle,0);
if(status == 1){
cout<<"Kernel driver active"<<endl;
cout<<"Trying to detach driver..."<<endl;
status = libusb_detach_kernel_driver(dev_handle,0);
if(status == 0){
cout<<"Kernel driver detached"<<endl;
}
else{
cout<<"Kernel driver cannot be detached"<<endl;
exit(-3);
}
}
//////////////////
//////////////////-Claim an interface
status = libusb_claim_interface(dev_handle,0);
if(status < 0){
cout<<"Could not claim an interface"<<endl;
exit(-3);
}
else{
cout<<"Interface claimed"<<endl;
}
//////////////////
}
int main(int argc, char **argv) {
libusb_context* m_context;
int init_result= libusb_init(&m_context);
if(init_result){
std::cerr << "USB init failed: "<< init_result << std::endl;
exit(EXIT_FAILURE);
}
libusb_set_debug(m_context,3);
// libusb_device** m_device_list;
// libusb_device** actual_device_ptr;
//
// ssize_t num_devices=libusb_get_device_list(m_context, &m_device_list);
//
// actual_device_ptr=m_device_list;
//
// // iterate device list
// while(*actual_device_ptr!=0){
// libusb_device_descriptor desc;
//
// if(int error=libusb_get_device_descriptor(*m_device_list,&desc)){
//
// std::cerr << "Get device error: " << libusb_error_name(error) <<std::endl;
// }
//
// std::cout << std::hex
// << "VendorID: " << desc.idVendor << std::endl
// << "ProductID: " << desc.idProduct << std::endl
// << "USB Release: "<< desc.bcdUSB << std::endl
// << "Serial number: " <<(int) desc.iSerialNumber << std::endl
//
// << std::dec;
//
//
//
// std::cout << "******************************************"<< std::endl;
//
// actual_device_ptr++;
// }
//
// std::cout << "Devices found: "<< num_devices << std::endl;
//
// libusb_free_device_list(m_device_list,0);
//
#define VENDORID 0x19a2
#define PRODUCTID 0x5001
libusb_device_handle* m_usb_device_handle = libusb_open_device_with_vid_pid(m_context, VENDORID, PRODUCTID);
// libusb_device_handle* m_device_handle = libusb_open_device_with_vid_pid(m_context, 0x05e3,0x1205);
if( !m_usb_device_handle){
std::cerr << "Error open device:" << std::endl;
}else{
libusb_device* m_device =libusb_get_device(m_usb_device_handle);
printdev(m_device);
std::cout << " Device Class 0: All Interfaces operate independently" << std::endl;
std::cout << " Interface Number: 0" << std::endl;
std::cout << " Two descriptors of type Endpoint" << std::endl;
std::cout << " Endpoint Adresses 129 and 2, does thes mean we have Adress 2 with different directions? " << std::endl;
// Our only available interface number
int the_usb_interface_number=0;
if(libusb_kernel_driver_active(m_usb_device_handle,the_usb_interface_number)){
std::cout << "Error: Kernel driver found" << std::endl;
if (int error=libusb_detach_kernel_driver(m_usb_device_handle,the_usb_interface_number)){
std::cout << "Detaching Kernel Driver failed " << error << std::endl;
exit(EXIT_FAILURE);
}
}else{
std::cout << " No Kernel driver for attached Device found, "
"that's good, libusb handels the device" << std::endl;
}
// Now we claim the device
int error = libusb_claim_interface(m_usb_device_handle,the_usb_interface_number);
if(error){
std::cout << "Claiming interface failed " << error << std::endl;
exit(EXIT_FAILURE);
}
static const uint8_t DATA_STX=2; //Start of text
static const uint8_t DATA_ETX=3; // End of Text
uint8_t start_one_scan[]={DATA_STX,'s','R','N',' ','L','M','D','s','c','a','n','d','a','t','a',DATA_ETX};
uint8_t start_continuous_scan[]={DATA_STX,'s','E','N',' ','L','M','D','s','c','a','n','d','a','t','a',' ','1',DATA_ETX};
uint8_t stop_continuous_scan[]={DATA_STX,'s','E','N',' ','L','M','D','s','c','a','n','d','a','t','a',' ','0',DATA_ETX};
uint8_t read_endpoint=129;
uint8_t write_endpoint=2;
unsigned int timeout_millis=10000;
// std::cout << sizeof(start_one_scan) << std::endl;
int transferred_data_size=0;
uint8_t receive_buf[2049];
error =libusb_bulk_transfer(
m_usb_device_handle,
write_endpoint,
// start_one_scan,
// sizeof(start_one_scan),
start_continuous_scan,
sizeof(start_continuous_scan),
&transferred_data_size,
timeout_millis);
if(error){
std::cout << "Write Bulk Transfer failed " << error << std::endl;
exit(EXIT_FAILURE);
}
std::cout<< "Transfered Data written: " << transferred_data_size<< std::endl;
// Receive acknoledge
error =libusb_bulk_transfer(
m_usb_device_handle,
read_endpoint,
receive_buf ,
sizeof(receive_buf)-1, // leave one for termination
&transferred_data_size,
timeout_millis);
if(error){
std::cout << "Read Bulk Transfer failed " << error << std::endl;
exit(EXIT_FAILURE);
}
// String terminierung
receive_buf[transferred_data_size]=0;
std::cout<< "Acknoledge: " << receive_buf<< std::endl;
TiM3xx_Data_Parser mdp;
for (int i = 0; i < 10; ++i) {
error =libusb_bulk_transfer(
m_usb_device_handle,
read_endpoint,
receive_buf ,
sizeof(receive_buf)-1, // leave one for termination
&transferred_data_size,
timeout_millis);
if(error){
std::cout << "Read Bulk Transfer failed " << error << std::endl;
exit(EXIT_FAILURE);
}
//std::cout<< "Transfered Data read: " << transferred_data_size<< std::endl;
// String terminierung
receive_buf[transferred_data_size]=0;
if(receive_buf[0]!=DATA_STX){ // read from device buff until it is empty, and next data set starts with STX-Code
std::cout << ".";
}else{
// std::cout << receive_buf << std::endl;
mdp.set_pointer_to_data_buf(receive_buf,transferred_data_size);
mdp.parse_data();
mdp.print_data();
}
} // end of for loop
// Stop Measurment
error =libusb_bulk_transfer(
m_usb_device_handle,
write_endpoint,
stop_continuous_scan,
sizeof(stop_continuous_scan),
&transferred_data_size,
timeout_millis);
if(error){
std::cout << "Write Bulk Transfer failed " << error << std::endl;
exit(EXIT_FAILURE);
}
std::cout<< "Transfered Data written: " << transferred_data_size<< std::endl;
error =libusb_bulk_transfer(
m_usb_device_handle,
read_endpoint,
receive_buf ,
sizeof(receive_buf)-1, // leave one for termination
&transferred_data_size,
timeout_millis);
if(error){
std::cout << "Read Bulk Transfer failed " << error << std::endl;
exit(EXIT_FAILURE);
}
std::cout<< "Transfered Data read: " << transferred_data_size<< std::endl;
// String terminierung
receive_buf[transferred_data_size]=0;
std::cout << receive_buf << std::endl;
error= libusb_release_interface(m_usb_device_handle,the_usb_interface_number);
if(error){
std::cout << "Releasing interface failed " << error << std::endl;
exit(EXIT_FAILURE);
}
// libusb_device_descriptor desc;
//
// libusb_get_device_descriptor(m_device,&desc);
// uint8_t buff[2048];
//
// for(int desc_index=1; desc_index<256;desc_index++){
//
// int num_bytes_read=libusb_get_string_descriptor_ascii(m_device_handle,desc_index,buff,2048);
//
//
// if(num_bytes_read>0){
// std::cout<< desc_index << ": " << num_bytes_read << ": " << buff << std::endl;
//
// if(libusb_kernel_driver_active(m_device_handle,0)){
//
// std::cout << "Kernel driver found" << std::endl;
// }
//
//
// }else{
// std::cerr<< desc_index << ": " << libusb_error_name(num_bytes_read) << std::endl;
// }
// }
// std::cout << "**********************************************" << std::endl;
}
if( m_usb_device_handle){
libusb_close(m_usb_device_handle);
}
libusb_exit(m_context);
}
