static int lusb_get_speed(void *driver, bladerf_dev_speed *device_speed) { int speed; int status = 0; struct bladerf_lusb *lusb = (struct bladerf_lusb *) driver; speed = libusb_get_device_speed(lusb->dev); if (speed == LIBUSB_SPEED_SUPER) { *device_speed = BLADERF_DEVICE_SPEED_SUPER; } else if (speed == LIBUSB_SPEED_HIGH) { *device_speed = BLADERF_DEVICE_SPEED_HIGH; } else { *device_speed = BLADERF_DEVICE_SPEED_UNKNOWN; if (speed == LIBUSB_SPEED_FULL) { log_debug("Full speed connection is not suppored.\n"); status = BLADERF_ERR_UNSUPPORTED; } else if (speed == LIBUSB_SPEED_LOW) { log_debug("Low speed connection is not supported.\n"); status = BLADERF_ERR_UNSUPPORTED; } else { log_debug("Unknown/unexpected device speed (%d)\n", speed); status = BLADERF_ERR_UNEXPECTED; } } return status; }
int GetUSBSpeed (libusb_device_handle *handle) { libusb_device *pUSB_dev; pUSB_dev = libusb_get_device (handle); return libusb_get_device_speed (pUSB_dev); }
string UsbWrap::AboutUsbDevice() { if (!_isInitialized) { throw UsbWrapException("USB driver not initialized"); } if (!_isConnected) { throw UsbWrapException("USB device not connected"); } ostringstream os; libusb_device *device = libusb_get_device(_handleDevice); os << "Number of the bus: " << std::dec << libusb_get_bus_number(device) << endl; os << "Address of the device on the bus: " << std::dec << libusb_get_device_address(device) << endl; os << "Negotiated connection speed: " << std::dec << libusb_get_device_speed(device) << endl; return os.str(); }
int Protonect::openKinect(std::string binpath){ if( bOpened ){ closeKinect(); } cmd_seq = 0; uint16_t vid = 0x045E; uint16_t pid[2] = {0x02d8, 0x02C4}; uint16_t mi = 0x00; bool debug_mode = false; uint8_t bus; int r; const struct libusb_version* version; version = libusb_get_version(); printf("Using libusbx v%d.%d.%d.%d\n\n", version->major, version->minor, version->micro, version->nano); r = libusb_init(NULL); if (r < 0) return r; libusb_set_debug(NULL, debug_mode ? LIBUSB_LOG_LEVEL_DEBUG : LIBUSB_LOG_LEVEL_INFO); for(int i = 0; i < 2; i++){ printf("Trying to open device %04X:%04X...\n", vid, pid[i]); handle = NULL; int tryCount = 4; if (handle == NULL){ while(tryCount > 0 && handle == NULL){ handle = libusb_open_device_with_vid_pid(NULL, vid, pid[i]); tryCount--; usleep(100); if( handle ){ libusb_reset_device(handle); usleep(100); handle = libusb_open_device_with_vid_pid(NULL, vid, pid[i]); } } } if(handle != NULL){ break; } } if( handle == NULL ){ perr("Protonect::openKinect Failed. - handle is NULL\n"); return -1; } dev = libusb_get_device(handle); bus = libusb_get_bus_number(dev); /* struct libusb_device_descriptor dev_desc; printf("\nReading device descriptor:\n"); CALL_CHECK(libusb_get_device_descriptor(dev, &dev_desc)); printf(" length: %d\n", dev_desc.bLength); printf(" device class: %d\n", dev_desc.bDeviceClass); printf(" S/N: %d\n", dev_desc.iSerialNumber); printf(" VID:PID: %04X:%04X\n", dev_desc.idVendor, dev_desc.idProduct); printf(" bcdDevice: %04X\n", dev_desc.bcdDevice); printf(" iMan:iProd:iSer: %d:%d:%d\n", dev_desc.iManufacturer, dev_desc.iProduct, dev_desc.iSerialNumber); printf(" nb confs: %d\n", dev_desc.bNumConfigurations); */ r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); int active_cfg = -5; r = libusb_get_configuration(handle, &active_cfg); printf("active configuration: %d, err: %d", active_cfg, r); int configId = 1; if (active_cfg != configId) { printf("Setting config: %d\n", configId); r = libusb_set_configuration(handle, configId); if (r != LIBUSB_SUCCESS) { perr(" Can't set configuration. Error code: %d (%s)\n", r, libusb_error_name(r)); } } int iface = 0; printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); if (r != LIBUSB_SUCCESS) { perr(" Failed: %d.\n", r); } iface = 1; printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); if (r != LIBUSB_SUCCESS) { perr(" Failed: %d.\n", r); } InitKinect(handle); // install signal handler now signal(SIGINT,sigint_handler); shutdown = false; usb_loop.start(); //INITIALIZE OBJECTS // frame_listener = new libfreenect2::FrameListener(libfreenect2::Frame::Color | libfreenect2::Frame::Ir | libfreenect2::Frame::Depth); rgb_bulk_transfers = new libfreenect2::usb::BulkTransferPool(handle, 0x83); //rgb_processor = new libfreenect2::ofRGBPacketProcessor(); // rgb_packet_stream_parser = new libfreenect2::RgbPacketStreamParser(rgb_processor); // rgb_processor->setFrameListener(frame_listener); rgb_bulk_transfers->allocate(50, 0x4000); rgb_bulk_transfers->setCallback(rgb_packet_stream_parser); rgb_bulk_transfers->enableSubmission(); rgb_bulk_transfersPtr = rgb_bulk_transfers; depth_iso_transfers = new libfreenect2::usb::IsoTransferPool(handle, 0x84); depth_processor = new libfreenect2::CpuDepthPacketProcessor(); depth_processor->setFrameListener(frame_listener); depth_processor->load11To16LutFromFile((binpath + "11to16.bin").c_str()); depth_processor->loadXTableFromFile((binpath + "xTable.bin").c_str()); depth_processor->loadZTableFromFile((binpath + "zTable.bin").c_str()); depth_packet_stream_parser = new libfreenect2::DepthPacketStreamParser(depth_processor); size_t max_packet_size = libusb_get_max_iso_packet_size(dev, 0x84); std::cout << "iso max_packet_size: " << max_packet_size << std::endl; depth_iso_transfers = new libfreenect2::usb::IsoTransferPool(handle, 0x84); depth_iso_transfers->allocate(80, 8, max_packet_size); depth_iso_transfers->setCallback(depth_packet_stream_parser); depth_iso_transfers->enableSubmission(); depth_iso_transfersPtr = depth_iso_transfers; r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); RunKinect(handle, *depth_processor); rgb_bulk_transfers->submit(10); depth_iso_transfers->submit(60); r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); bOpened = true; return 0; }
static int test_device(uint16_t vid, uint16_t pid) { libusb_device_handle *handle; libusb_device *dev; uint8_t bus, port_path[8]; struct libusb_bos_descriptor *bos_desc; struct libusb_config_descriptor *conf_desc; const struct libusb_endpoint_descriptor *endpoint; int i, j, k, r; int iface, nb_ifaces, first_iface = -1; struct libusb_device_descriptor dev_desc; const char* speed_name[5] = { "Unknown", "1.5 Mbit/s (USB LowSpeed)", "12 Mbit/s (USB FullSpeed)", "480 Mbit/s (USB HighSpeed)", "5000 Mbit/s (USB SuperSpeed)"}; char string[128]; uint8_t string_index[3]; // indexes of the string descriptors uint8_t endpoint_in = 0, endpoint_out = 0; // default IN and OUT endpoints printf("Opening device %04X:%04X...\n", vid, pid); handle = libusb_open_device_with_vid_pid(NULL, vid, pid); if (handle == NULL) { perr(" Failed.\n"); return -1; } dev = libusb_get_device(handle); bus = libusb_get_bus_number(dev); if (extra_info) { r = libusb_get_port_numbers(dev, port_path, sizeof(port_path)); if (r > 0) { printf("\nDevice properties:\n"); printf(" bus number: %d\n", bus); printf(" port path: %d", port_path[0]); for (i=1; i<r; i++) { printf("->%d", port_path[i]); } printf(" (from root hub)\n"); } r = libusb_get_device_speed(dev); if ((r<0) || (r>4)) r=0; printf(" speed: %s\n", speed_name[r]); } printf("\nReading device descriptor:\n"); CALL_CHECK(libusb_get_device_descriptor(dev, &dev_desc)); printf(" length: %d\n", dev_desc.bLength); printf(" device class: %d\n", dev_desc.bDeviceClass); printf(" S/N: %d\n", dev_desc.iSerialNumber); printf(" VID:PID: %04X:%04X\n", dev_desc.idVendor, dev_desc.idProduct); printf(" bcdDevice: %04X\n", dev_desc.bcdDevice); printf(" iMan:iProd:iSer: %d:%d:%d\n", dev_desc.iManufacturer, dev_desc.iProduct, dev_desc.iSerialNumber); printf(" nb confs: %d\n", dev_desc.bNumConfigurations); // Copy the string descriptors for easier parsing string_index[0] = dev_desc.iManufacturer; string_index[1] = dev_desc.iProduct; string_index[2] = dev_desc.iSerialNumber; printf("\nReading BOS descriptor: "); if (libusb_get_bos_descriptor(handle, &bos_desc) == LIBUSB_SUCCESS) { printf("%d caps\n", bos_desc->bNumDeviceCaps); for (i = 0; i < bos_desc->bNumDeviceCaps; i++) print_device_cap(bos_desc->dev_capability[i]); libusb_free_bos_descriptor(bos_desc); } else { printf("no descriptor\n"); } printf("\nReading first configuration descriptor:\n"); CALL_CHECK(libusb_get_config_descriptor(dev, 0, &conf_desc)); nb_ifaces = conf_desc->bNumInterfaces; printf(" nb interfaces: %d\n", nb_ifaces); if (nb_ifaces > 0) first_iface = conf_desc->usb_interface[0].altsetting[0].bInterfaceNumber; for (i=0; i<nb_ifaces; i++) { printf(" interface[%d]: id = %d\n", i, conf_desc->usb_interface[i].altsetting[0].bInterfaceNumber); for (j=0; j<conf_desc->usb_interface[i].num_altsetting; j++) { printf("interface[%d].altsetting[%d]: num endpoints = %d\n", i, j, conf_desc->usb_interface[i].altsetting[j].bNumEndpoints); printf(" Class.SubClass.Protocol: %02X.%02X.%02X\n", conf_desc->usb_interface[i].altsetting[j].bInterfaceClass, conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass, conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol); if ( (conf_desc->usb_interface[i].altsetting[j].bInterfaceClass == LIBUSB_CLASS_MASS_STORAGE) && ( (conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x01) || (conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x06) ) && (conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol == 0x50) ) { // Mass storage devices that can use basic SCSI commands test_mode = USE_SCSI; } for (k=0; k<conf_desc->usb_interface[i].altsetting[j].bNumEndpoints; k++) { struct libusb_ss_endpoint_companion_descriptor *ep_comp = NULL; endpoint = &conf_desc->usb_interface[i].altsetting[j].endpoint[k]; printf(" endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress); // Use the first interrupt or bulk IN/OUT endpoints as default for testing if ((endpoint->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) & (LIBUSB_TRANSFER_TYPE_BULK | LIBUSB_TRANSFER_TYPE_INTERRUPT)) { if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) { if (!endpoint_in) endpoint_in = endpoint->bEndpointAddress; } else { if (!endpoint_out) endpoint_out = endpoint->bEndpointAddress; } } printf(" max packet size: %04X\n", endpoint->wMaxPacketSize); printf(" polling interval: %02X\n", endpoint->bInterval); libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp); if (ep_comp) { printf(" max burst: %02X (USB 3.0)\n", ep_comp->bMaxBurst); printf(" bytes per interval: %04X (USB 3.0)\n", ep_comp->wBytesPerInterval); libusb_free_ss_endpoint_companion_descriptor(ep_comp); } } } } libusb_free_config_descriptor(conf_desc); libusb_set_auto_detach_kernel_driver(handle, 1); for (iface = 0; iface < nb_ifaces; iface++) { printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); if (r != LIBUSB_SUCCESS) { perr(" Failed.\n"); } } printf("\nReading string descriptors:\n"); for (i=0; i<3; i++) { if (string_index[i] == 0) { continue; } if (libusb_get_string_descriptor_ascii(handle, string_index[i], (unsigned char*)string, 128) >= 0) { printf(" String (0x%02X): \"%s\"\n", string_index[i], string); } } // Read the OS String Descriptor if (libusb_get_string_descriptor_ascii(handle, 0xEE, (unsigned char*)string, 128) >= 0) { printf(" String (0x%02X): \"%s\"\n", 0xEE, string); // If this is a Microsoft OS String Descriptor, // attempt to read the WinUSB extended Feature Descriptors if (strncmp(string, "MSFT100", 7) == 0) read_ms_winsub_feature_descriptors(handle, string[7], first_iface); } switch(test_mode) { case USE_PS3: CALL_CHECK(display_ps3_status(handle)); break; case USE_XBOX: CALL_CHECK(display_xbox_status(handle)); CALL_CHECK(set_xbox_actuators(handle, 128, 222)); msleep(2000); CALL_CHECK(set_xbox_actuators(handle, 0, 0)); break; case USE_HID: test_hid(handle, endpoint_in); break; case USE_SCSI: CALL_CHECK(test_mass_storage(handle, endpoint_in, endpoint_out)); case USE_GENERIC: break; } printf("\n"); for (iface = 0; iface<nb_ifaces; iface++) { printf("Releasing interface %d...\n", iface); libusb_release_interface(handle, iface); } printf("Closing device...\n"); libusb_close(handle); return 0; }
void UsbConnection::print_info() { int error_config; libusb_config_descriptor *config_desc; libusb_device_descriptor desc; if (!device) { ConnectionStatus status = usb_connect (); if (status == ready){ return; } } libusb_get_device_descriptor(device, &desc); unsigned char data[255] = {}; int response = libusb_get_string_descriptor_ascii (handler, desc.iProduct, data, sizeof(data)); qDebug("Product Description: %s|\n", data); response = libusb_get_string_descriptor_ascii (handler, desc.iManufacturer, data, sizeof(data)); qDebug("Manufacturer Description: %s|\n", data); libusb_get_string_descriptor_ascii (handler, desc.iSerialNumber, data, sizeof(data)); qDebug("SerialNumber Description: %s|\n", data); qDebug("\nbegin descriptor\n"); qDebug("\tbus_num: %d\n", libusb_get_bus_number(device)); qDebug("\taddress: %d\n", libusb_get_device_address(device)); qDebug("\tspeed: %d\n", libusb_get_device_speed(device)); qDebug("\tClass: %d\n", desc.bDeviceClass); qDebug("\tSubClass: %d\n", desc.bDeviceSubClass); qDebug("\tDeviceProtocol: %d\n", desc.bDeviceProtocol); qDebug("\tidVendor: %d\n", desc.idVendor); qDebug("\tidProduct: %d\n", desc.idProduct); qDebug("\tiManufacturer: %d\n", desc.iManufacturer); qDebug("\tiProduct: %d\n", desc.iProduct); qDebug("\tiSerialNumber: %d\n", desc.iSerialNumber); qDebug("\tbMaxPacketSize0: %d\n", desc.bMaxPacketSize0); qDebug("\tbNumConfigurations: %d\n", desc.bNumConfigurations); qDebug("\tconfigDescriptor:\n"); error_config = libusb_get_active_config_descriptor(device, &config_desc); if (error_config) { if (error_config == LIBUSB_ERROR_NOT_FOUND) { qDebug("Error config not founds\n"); } else { qDebug("Error in config %s\n", libusb_error_name (error_config)); } } else { qDebug("\tiConfiguration: %d\n", config_desc->iConfiguration); qDebug("\tbNumInterface: %d\n", config_desc->bNumInterfaces); qDebug("\tbmAttributes: %d\n", config_desc->bmAttributes); for (int i_interface = 0; i_interface < config_desc->bNumInterfaces; i_interface++) { for (int i_altinterface = 0; i_altinterface < config_desc->interface[i_interface].num_altsetting; i_altinterface++) { libusb_interface_descriptor alt_settings = config_desc->interface[i_interface].altsetting[i_altinterface]; qDebug("\tbInterfaceNumber[%d][%d]: %d\n", i_interface, i_altinterface, alt_settings.bInterfaceNumber); qDebug("\tbInterfaceClass[%d][%d]: %d\n", i_interface, i_altinterface, alt_settings.bInterfaceClass); qDebug("\bInterfaceSubClass[%d][%d]: %d\n", i_interface, i_altinterface, alt_settings.bInterfaceSubClass); qDebug("\tbInterfaceProtocol[%d][%d]: %d\n", i_interface, i_altinterface, alt_settings.bInterfaceProtocol); qDebug("\textra[%d][%d]: %s\n", i_interface, i_altinterface, alt_settings.extra); for (int i_ep = 0; i_ep < alt_settings.bNumEndpoints; i_ep++) { libusb_endpoint_descriptor ep_desc = alt_settings.endpoint[i_ep]; qDebug("\t\tbEndpointAddress[%d][%d][%d]: %d (in=%d / out=%d)\n", i_interface, i_altinterface, i_ep, ep_desc.bEndpointAddress, LIBUSB_ENDPOINT_IN, LIBUSB_ENDPOINT_OUT); qDebug("\t\tbDescriptorType[%d][%d][%d]: %d\n", i_interface, i_altinterface, i_ep, ep_desc.bDescriptorType); qDebug("\t\tbmAttributes[%d][%d][%d]: %d\n", i_interface, i_altinterface, i_ep, ep_desc.bmAttributes); qDebug("\t\textra[%d][%d][%d]: %d\n", i_interface, i_altinterface, i_ep, ep_desc.extra_length); qDebug("\t\tbSynchAddress[%d][%d][%d]: %d\n", i_interface, i_altinterface, i_ep, ep_desc.bSynchAddress); } } } libusb_free_config_descriptor(config_desc); } }
enum Device::usb_speed Device::getDeviceSpeed() const { return (Device::usb_speed)libusb_get_device_speed(dev); }
int main() { libusb_context *pCTX = NULL; libusb_device **pDevList = NULL; libusb_device_handle *pDev; libusb_device_handle *hDev = NULL; struct libusb_config_descriptor *pConfig = NULL; struct libusb_device_descriptor Desc; int err; int NumDev, NumInterfaces; int i, j, k, l; err = libusb_init(&pCTX); if (err) { printf("Error: %d\n", err); pCTX = NULL; } else { printf("OK\n"); } NumDev = libusb_get_device_list(pCTX, &pDevList); printf("Num devices: %d\n", NumDev); for(i = 0; i < NumDev; i++) { if (libusb_get_device_descriptor(pDevList[i], &Desc) != 0) { printf("Get desc failed for %d\n", i); continue; } printf("Device %d:\n", i); printf(" VID:PID 0x%x:0x%x\n", Desc.idVendor, Desc.idProduct); printf(" Speed: %d\n", libusb_get_device_speed(pDevList[i])); printf(" Num Config: %d\n", Desc.bNumConfigurations); if (Desc.idVendor == 0x0416 && Desc.idProduct == 0xffff) { if (Desc.bNumConfigurations > 0) { if (libusb_get_config_descriptor(pDevList[i], 0, &pConfig) == 0) { struct libusb_interface_descriptor id; NumInterfaces = pConfig->bNumInterfaces; for(j = 0; j < NumInterfaces; j++) { printf(" %d settings\n", pConfig->interface[j].num_altsetting); for(k = 0; k < pConfig->interface[j].num_altsetting; k++) { id = pConfig->interface[j].altsetting[k]; printf(" if %d Class: %d\n", k, id.bInterfaceClass); printf(" %d endpoints\n", id.bNumEndpoints); for(l = 0; l < id.bNumEndpoints; l++) { printf(" Endpoint %d\n", l); printf(" Address: %d\n", id.endpoint[l].bEndpointAddress); printf(" Attributes 0x%x\n", id.endpoint[l].bmAttributes); printf(" MaxSize: %d\n", id.endpoint[l].wMaxPacketSize); printf(" Interval: %d\n", id.endpoint[l].bInterval); } } } } } if (libusb_open(pDevList[i], &hDev) == 0) { libusb_close(hDev); } if (pConfig) libusb_free_config_descriptor(pConfig); pConfig = NULL; if (Desc.bDeviceClass == LIBUSB_CLASS_HID) { printf(" Is HID\n"); } else { printf(" Device Class %d\n", Desc.bDeviceClass); } } } if (pDevList) libusb_free_device_list(pDevList, 1); /* pDev = libusb_open_device_with_vid_pid(pCTX, 0x416, 0xFFFF); if (pDev) { printf("Found device!\n"); libusb_close(pDev); } else { printf("Device not found.\n"); }*/ if (pCTX) { libusb_exit(pCTX); } }
int main(int argc, char *argv[]) { std::string program_path(argv[0]); size_t executable_name_idx = program_path.rfind("Protonect"); std::string binpath = "/"; if(executable_name_idx != std::string::npos) { binpath = program_path.substr(0, executable_name_idx); } uint16_t vid = 0x045E; uint16_t pid = 0x02C4; uint16_t mi = 0x00; bool debug_mode = false; libusb_device_handle *handle; libusb_device *dev; uint8_t bus; const char* speed_name[5] = { "Unknown", "1.5 Mbit/s (USB LowSpeed)", "12 Mbit/s (USB FullSpeed)", "480 Mbit/s (USB HighSpeed)", "5000 Mbit/s (USB SuperSpeed)" }; int r; const struct libusb_version* version; version = libusb_get_version(); printf("Using libusbx v%d.%d.%d.%d\n\n", version->major, version->minor, version->micro, version->nano); r = libusb_init(NULL); if (r < 0) return r; libusb_set_debug(NULL, debug_mode ? LIBUSB_LOG_LEVEL_DEBUG : LIBUSB_LOG_LEVEL_INFO); printf("Opening device %04X:%04X...\n", vid, pid); handle = libusb_open_device_with_vid_pid(NULL, vid, pid); if (handle == NULL) { perr(" Failed.\n"); //system("PAUSE"); return -1; } dev = libusb_get_device(handle); bus = libusb_get_bus_number(dev); /* struct libusb_device_descriptor dev_desc; printf("\nReading device descriptor:\n"); CALL_CHECK(libusb_get_device_descriptor(dev, &dev_desc)); printf(" length: %d\n", dev_desc.bLength); printf(" device class: %d\n", dev_desc.bDeviceClass); printf(" S/N: %d\n", dev_desc.iSerialNumber); printf(" VID:PID: %04X:%04X\n", dev_desc.idVendor, dev_desc.idProduct); printf(" bcdDevice: %04X\n", dev_desc.bcdDevice); printf(" iMan:iProd:iSer: %d:%d:%d\n", dev_desc.iManufacturer, dev_desc.iProduct, dev_desc.iSerialNumber); printf(" nb confs: %d\n", dev_desc.bNumConfigurations); */ r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); int active_cfg = -5; r = libusb_get_configuration(handle, &active_cfg); printf("active configuration: %d, err: %d", active_cfg, r); int configId = 1; if (active_cfg != configId) { printf("Setting config: %d\n", configId); r = libusb_set_configuration(handle, configId); if (r != LIBUSB_SUCCESS) { perr(" Can't set configuration. Error code: %d (%s)\n", r, libusb_error_name(r)); } } int iface = 0; printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); if (r != LIBUSB_SUCCESS) { perr(" Failed: %d.\n", r); } iface = 1; printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); if (r != LIBUSB_SUCCESS) { perr(" Failed: %d.\n", r); } InitKinect(handle); // install signal handler now signal(SIGINT,sigint_handler); shutdown = false; libfreenect2::usb::EventLoop usb_loop; usb_loop.start(); libfreenect2::FrameMap frames; libfreenect2::FrameListener frame_listener(libfreenect2::Frame::Color | libfreenect2::Frame::Ir | libfreenect2::Frame::Depth); //libfreenect2::DumpRgbPacketProcessor rgb_processor; libfreenect2::TurboJpegRgbPacketProcessor rgb_processor; rgb_processor.setFrameListener(&frame_listener); libfreenect2::RgbPacketStreamParser rgb_packet_stream_parser(&rgb_processor); libfreenect2::usb::BulkTransferPool rgb_bulk_transfers(handle, 0x83); rgb_bulk_transfers.allocate(50, 0x4000); rgb_bulk_transfers.setCallback(&rgb_packet_stream_parser); rgb_bulk_transfers.enableSubmission(); libfreenect2::CpuDepthPacketProcessor depth_processor; depth_processor.setFrameListener(&frame_listener); depth_processor.load11To16LutFromFile((binpath + "../11to16.bin").c_str()); depth_processor.loadXTableFromFile((binpath + "../xTable.bin").c_str()); depth_processor.loadZTableFromFile((binpath + "../zTable.bin").c_str()); libfreenect2::DepthPacketStreamParser depth_packet_stream_parser(&depth_processor); size_t max_packet_size = libusb_get_max_iso_packet_size(dev, 0x84); std::cout << "iso max_packet_size: " << max_packet_size << std::endl; libfreenect2::usb::IsoTransferPool depth_iso_transfers(handle, 0x84); depth_iso_transfers.allocate(80, 8, max_packet_size); depth_iso_transfers.setCallback(&depth_packet_stream_parser); depth_iso_transfers.enableSubmission(); r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); RunKinect(handle, depth_processor); rgb_bulk_transfers.submit(10); depth_iso_transfers.submit(60); r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); while(!shutdown) { frame_listener.waitForNewFrame(frames); libfreenect2::Frame *rgb = frames[libfreenect2::Frame::Color]; libfreenect2::Frame *ir = frames[libfreenect2::Frame::Ir]; libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth]; cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC3, rgb->data)); cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f); cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f); cv::waitKey(1); frame_listener.release(frames); } r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); rgb_bulk_transfers.disableSubmission(); depth_iso_transfers.disableSubmission(); CloseKinect(handle); rgb_bulk_transfers.cancel(); depth_iso_transfers.cancel(); // wait for all transfers to cancel // TODO: better implementation libfreenect2::this_thread::sleep_for(libfreenect2::chrono::seconds(2)); rgb_bulk_transfers.deallocate(); depth_iso_transfers.deallocate(); r = libusb_get_device_speed(dev); if ((r < 0) || (r > 4)) r = 0; printf(" speed: %s\n", speed_name[r]); iface = 0; printf("Releasing interface %d...\n", iface); libusb_release_interface(handle, iface); iface = 1; printf("Releasing interface %d...\n", iface); libusb_release_interface(handle, iface); printf("Closing device...\n"); libusb_close(handle); usb_loop.stop(); libusb_exit(NULL); //system("PAUSE"); return 0; }
static int test_device(uint16_t vid, uint16_t pid) { libusb_device_handle *handle; libusb_device *dev; #ifdef HAS_GETPORTPATH uint8_t bus, port_path[8]; #endif struct libusb_config_descriptor *conf_desc; const struct libusb_endpoint_descriptor *endpoint; int i, j, k, r; int iface, nb_ifaces, first_iface = -1; #if defined(__linux) // Attaching/detaching the kernel driver is only relevant for Linux int iface_detached = -1; #endif struct libusb_device_descriptor dev_desc; const char* speed_name[5] = { "Unknown", "1.5 Mbit/s (USB 1.0 LowSpeed)", "12 Mbit/s (USB 1.0 FullSpeed)", "480 Mbit/s (USB 2.0 HighSpeed)", "5000 Mbit/s (USB 3.0 SuperSpeed)"}; char string[128]; uint8_t string_index[3]; // indexes of the string descriptors uint8_t endpoint_in = 0, endpoint_out = 0; // default IN and OUT endpoints printf("Opening device...\n"); handle = libusb_open_device_with_vid_pid(NULL, vid, pid); if (handle == NULL) { perr(" Failed.\n"); return -1; } dev = libusb_get_device(handle); #ifdef HAS_GETPORTPATH bus = libusb_get_bus_number(dev); r = libusb_get_port_path(NULL, dev, port_path, sizeof(port_path)); if (r > 0) { printf("bus: %d, port path from HCD: %d", bus, port_path[0]); for (i=1; i<r; i++) { printf("->%d", port_path[i]); } printf("\n"); } #endif r = libusb_get_device_speed(dev); if ((r<0) || (r>4)) r=0; printf("speed: %s\n", speed_name[r]); printf("\nReading device descriptor:\n"); CALL_CHECK(libusb_get_device_descriptor(dev, &dev_desc)); printf(" length: %d\n", dev_desc.bLength); printf(" device class: %d\n", dev_desc.bDeviceClass); printf(" S/N: %d\n", dev_desc.iSerialNumber); printf(" VID:PID: %04X:%04X\n", dev_desc.idVendor, dev_desc.idProduct); printf(" bcdDevice: %04X\n", dev_desc.bcdDevice); printf(" iMan:iProd:iSer: %d:%d:%d\n", dev_desc.iManufacturer, dev_desc.iProduct, dev_desc.iSerialNumber); printf(" nb confs: %d\n", dev_desc.bNumConfigurations); // Copy the string descriptors for easier parsing string_index[0] = dev_desc.iManufacturer; string_index[1] = dev_desc.iProduct; string_index[2] = dev_desc.iSerialNumber; printf("\nReading configuration descriptors:\n"); CALL_CHECK(libusb_get_config_descriptor(dev, 0, &conf_desc)); nb_ifaces = conf_desc->bNumInterfaces; printf(" nb interfaces: %d\n", nb_ifaces); if (nb_ifaces > 0) first_iface = conf_desc->usb_interface[0].altsetting[0].bInterfaceNumber; for (i=0; i<nb_ifaces; i++) { printf(" interface[%d]: id = %d\n", i, conf_desc->usb_interface[i].altsetting[0].bInterfaceNumber); for (j=0; j<conf_desc->usb_interface[i].num_altsetting; j++) { printf("interface[%d].altsetting[%d]: num endpoints = %d\n", i, j, conf_desc->usb_interface[i].altsetting[j].bNumEndpoints); printf(" Class.SubClass.Protocol: %02X.%02X.%02X\n", conf_desc->usb_interface[i].altsetting[j].bInterfaceClass, conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass, conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol); if ( (conf_desc->usb_interface[i].altsetting[j].bInterfaceClass == LIBUSB_CLASS_MASS_STORAGE) && ( (conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x01) || (conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x06) ) && (conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol == 0x50) ) { // Mass storage devices that can use basic SCSI commands test_mode = USE_SCSI; } for (k=0; k<conf_desc->usb_interface[i].altsetting[j].bNumEndpoints; k++) { endpoint = &conf_desc->usb_interface[i].altsetting[j].endpoint[k]; printf(" endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress); // Use the first bulk IN/OUT endpoints found as default for testing if ((endpoint->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == LIBUSB_TRANSFER_TYPE_BULK) { if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) { if (!endpoint_in) endpoint_in = endpoint->bEndpointAddress; } else { if (!endpoint_out) endpoint_out = endpoint->bEndpointAddress; } } printf(" max packet size: %04X\n", endpoint->wMaxPacketSize); printf(" polling interval: %02X\n", endpoint->bInterval); } } } libusb_free_config_descriptor(conf_desc); for (iface = 0; iface < nb_ifaces; iface++) { printf("\nClaiming interface %d...\n", iface); r = libusb_claim_interface(handle, iface); #if defined(__linux) if ((r != LIBUSB_SUCCESS) && (iface == 0)) { // Maybe we need to detach the driver perr(" Failed. Trying to detach driver...\n"); libusb_detach_kernel_driver(handle, iface); iface_detached = iface; printf(" Claiming interface again...\n"); r = libusb_claim_interface(handle, iface); } #endif if (r != LIBUSB_SUCCESS) { perr(" Failed.\n"); } } printf("\nReading string descriptors:\n"); for (i=0; i<3; i++) { if (string_index[i] == 0) { continue; } if (libusb_get_string_descriptor_ascii(handle, string_index[i], (unsigned char*)string, 128) >= 0) { printf(" String (0x%02X): \"%s\"\n", string_index[i], string); } } // Read the OS String Descriptor if (libusb_get_string_descriptor_ascii(handle, 0xEE, (unsigned char*)string, 128) >= 0) { printf(" String (0x%02X): \"%s\"\n", 0xEE, string); // If this is a Microsoft OS String Descriptor, // attempt to read the WinUSB extended Feature Descriptors if (strncmp(string, "MSFT100", 7) == 0) read_ms_winsub_feature_descriptors(handle, string[7], first_iface); } switch(test_mode) { case USE_PS3: CALL_CHECK(display_ps3_status(handle)); break; case USE_XBOX: CALL_CHECK(display_xbox_status(handle)); CALL_CHECK(set_xbox_actuators(handle, 128, 222)); msleep(2000); CALL_CHECK(set_xbox_actuators(handle, 0, 0)); break; case USE_SCSI: CALL_CHECK(test_mass_storage(handle, endpoint_in, endpoint_out)); case USE_GENERIC: break; } printf("\n"); for (iface = 0; iface<nb_ifaces; iface++) { printf("Releasing interface %d...\n", iface); libusb_release_interface(handle, iface); } #if defined(__linux) if (iface_detached >= 0) { printf("Re-attaching kernel driver...\n"); libusb_attach_kernel_driver(handle, iface_detached); } #endif printf("Closing device...\n"); libusb_close(handle); return 0; }