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;
}