自学教程：C++ usb_interrupt_read函数代码示例

void interrupt_read_temperature(usb_dev_handle *dev, float *tempC) {     int r,i, temperature[2];    unsigned char answer[reqIntLen];    bzero(answer, reqIntLen);        r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);    // If reading failed, retry once more...    if( r != reqIntLen )    {      r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);    }   if( r != reqIntLen )    {          perror("USB interrupt read"); bad("USB read failed");     }    if(debug) {      for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i]  & 0xFF);          printf("/n");    }        temperature[0] = (answer[3] & 0xFF) + ((signed char)answer[2] << 8);    temperature[0] += calibration;    tempC[0] = temperature[0] * (125.0 / 32000.0);    temperature[1] = (answer[5] & 0xFF) + ((signed char)answer[4] << 8);    temperature[1] += calibration;    tempC[1] = temperature[1] * (125.0 / 32000.0);}

static int interrupt_read_temperatura(usb_dev_handle *dev, float *tempC) { 	int r,i, temperature;	char answer[reqIntLen];	bzero(answer, reqIntLen);    	r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);	if( r != reqIntLen )	{		if(debug){			printf("USB interrupt read");		}		return -1;	}	if(debug) {		for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i]  & 0xFF);    		printf("/n");	}    	temperature = (answer[3] & 0xFF) + (answer[2] << 8);	*tempC = temperature * (125.0 / 32000.0);	return 0;}

/* void test_control_transfer(usb_dev_handle *dev) {//   usb_set_altinterface(dev, 0);   usb_release_interface(dev, 0); }*/ void test_interrupt_transfer(usb_dev_handle *dev) {   int r,i;   char answer[reqIntLen];   char question[reqIntLen];   for (i=0;i<reqIntLen; i++) question[i]=i;   r = usb_interrupt_write(dev, endpoint_Int_out, question, reqIntLen, timeout);   if( r < 0 )   {	  perror("USB interrupt write"); bad("USB write failed");    }   r = usb_interrupt_read(dev, endpoint_Int_in, answer, reqIntLen, timeout);   if( r != reqIntLen )   {	  perror("USB interrupt read"); bad("USB read failed");    }//   for (i=0;i<reqIntLen; i++) printf("%i, %i, /n",question[i],answer[i]);	for(i = 0;i < reqIntLen; i++) {		if(i%8 == 0)			printf("/n");		printf("%02x, %02x; ",question[i],answer[i]);	}	printf("/n");//   usb_set_altinterface(dev, 0);   usb_release_interface(dev, 0); }

void RF24ComVUsb::initialize(void){    const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};    char vendor[] = {USB_CFG_VENDOR_NAME, 0}, product[] = {USB_CFG_DEVICE_NAME, 0};    int vid, pid;    int ret;    uint8_t buffer[128];    usb_init();    vid = rawVid[1] * 256 + rawVid[0];    pid = rawPid[1] * 256 + rawPid[0];    if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) != 0)        fatal(-1, "Could not find USB device /"%s/" with vid=0x%x pid=0x%x/n", product, vid, pid);    // exmptiy thei interrupt queue    DPRINT("Emptying usb interrupt queue...");    ret = usb_interrupt_read(handle, USB_ENDPOINT_IN | 1, (char *)buffer, sizeof(buffer), 100);    DPRINT("done, returned %d./n", ret);    DPRINT("Verifying protocol version/n");    buffer[0] = 4;    buffer[1] = 1;    buffer[2] = RF24_getProtocolVersion;    buffer[3] = 0;    sendRequest(buffer);    getResponse(buffer);    if (buffer[4] != RF24REMOTE_PROTOCOL_VERSION)        fatal(-1, "usb client returned wrong protocol version. Expected:%d, received:%d/n", RF24REMOTE_PROTOCOL_VERSION, buffer[4]);}

int usbReadCode_USBDIO96H(HIDInterface* hid, __u32 address, __u8 count, __u8 data[]){  struct t_readCode {    __u8 reportID;    __u8 address[3];    __u8 count;  } readCode;  struct t_readCodeI {    __u8 reportID;    __u8 data[62];  } readCodeI;  int bRead;  // bytes read  if ( count > 62 ) count = 62;    readCode.reportID = READ_CODE;  memcpy(readCode.address, &address, 3);   // 24 bit address  readCode.count = count;  PMD_SendOutputReport(hid, READ_CODE, (__u8 *) &readCode, sizeof(readCode), FS_DELAY);  do {    readCode.reportID = 0x0;    bRead = usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,			       (char *) &readCodeI, count+1, FS_DELAY);  } while (readCodeI.reportID != READ_CODE && (bRead != count+1));  memcpy(data, readCodeI.data, count);  return bRead;}

void sendBuffer(char* buffer, size_t size) {	OpenIBootCmd cmd;	cmd.command = OPENIBOOTCMD_SENDCOMMAND;	cmd.dataLen = size;	usb_interrupt_write(device, 4, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);	while(1) {		usb_interrupt_read(device, 3, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);		if(cmd.command == OPENIBOOTCMD_SENDCOMMAND_GOAHEAD)			break;	}	int toSend = 0;	while(size > 0) {		if(size <= MAX_TO_SEND)			toSend = size;		else			toSend = MAX_TO_SEND;		usb_bulk_write(device, 2, buffer, toSend, 1000);		buffer += toSend;		size -= toSend;	}}

int write_cmd(usb_dev_handle *udev, unsigned char *cmd, int read){	int ret=0, i=0;	unsigned char receive_data[1024];	unsigned char interrupt_data;	for (i=0; i<1024; i++)		receive_data[i] = 0x00;	printf("write_cmd/n");	ret = usb_bulk_write(udev, 0x02, cmd, sizeof(cmd), 10000);	if (ret != sizeof(cmd))		printf("Error!/n");	//if (read)	{		ret = usb_bulk_read(udev, 0x81, receive_data, sizeof(receive_data), 10000);		mcrw_debug(receive_data, ret);	}	//else	{		ret = usb_interrupt_read(udev, 0x83, &interrupt_data, 1, 10000);		mcrw_debug(&interrupt_data, ret);	}	return 0;}

int gotemp_update(struct usense_device *dev, void *priv){	/* From the GoIO_SDK */	const double conversion = 0.0078125;	struct gotemp *gotemp = priv;	double kelvin;	char buff[64];	int len;	assert(sizeof(gotemp->packet) == 8);	do {		len = usb_interrupt_read(gotemp->usb, 0x81, (void *)&gotemp->packet, sizeof(gotemp->packet), 1000);		if (len < 0 || len != sizeof(gotemp->packet)) {			if (len == -EAGAIN) {				continue;			}			return -EINVAL;		}	} while (0);	kelvin = C_TO_K(((double) gotemp->packet.measurement0) * conversion);	snprintf(buff, sizeof(buff), "%g", kelvin);	return usense_prop_set(dev, "reading", buff);}

void interrupt_read_temperatura(usb_dev_handle *dev, float *tempInC, float *tempOutC) {    int r,i, temperature;    unsigned char answer[reqIntLen];    bzero(answer, reqIntLen);    r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);    if( r != reqIntLen )    {          perror("USB interrupt read"); bad("USB read failed");    }    if(debug) {      for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i]  & 0xFF);      printf("/n");    }    temperature = (answer[3] & 0xFF) + ((signed char)answer[2] << 8);    temperature += calibration;    *tempInC = temperature * (125.0 / 32000.0);    temperature = (answer[5] & 0xFF) + ((signed char)answer[4] << 8);    temperature += calibration;    *tempOutC = temperature * (125.0 / 32000.0);}

int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length){    int bytes_read = -1;    bytes_read = usb_interrupt_read(dev->device_handle, 0x81, data, length, -1);    return bytes_read;}

int interrupt_read(struct usb_dev_handle *handle, int ep, char *data, int datalength){	int r;	r = usb_return(usb_interrupt_read(handle, ep, data, datalength, READ_TIMEOUT),			"usb_interrupt_read");		return r;}

int INDI::USBDevice::ReadInterrupt(char *buf,int c,int timeout){	int rc;	rc=usb_interrupt_read(usb_handle,InputEndpoint,buf,c,timeout);	//rc=usb_bulk_read(usb_handle,InputEndpoint,buf,c,timeout);	return rc;}

static intgusb_libusb_get(garmin_usb_packet *ibuf, size_t sz){	unsigned char *buf = &ibuf->dbuf[0];	int r = -1;	r = usb_interrupt_read(udev, gusb_intr_in_ep, (char *) buf, sz, TMOUT_I);	return r;}

/* This function assumes we have locked the receiveBuffer mutex! */unsigned int USBDevice_internalFillReceiveBuffer(LPSKYETEK_DEVICE device, unsigned int timeout){	unsigned char receiveBuffer[64];	LPUSB_DEVICE usbDevice;	int result;	unsigned char retried;#ifdef LINUX	unsigned char flushBuffer[3];#endif	if((device == NULL) || (device->user == NULL))		return 0;	usbDevice = (LPUSB_DEVICE)device->user;	/* We emptied the buffer so reset all of our pointers */	usbDevice->receiveBufferReadPtr = usbDevice->receiveBufferWritePtr = usbDevice->receiveBuffer;#ifdef LINUX	retried = 0;again:#endif	if((result = usb_interrupt_read(usbDevice->usbDevHandle, 1, receiveBuffer, 64, (timeout == 0) ? 100 : timeout)) < 0)	{		/*printf("usb_interrupt_read failed: %d/r/n", result);*/	#ifdef LINUX		if(!retried)		{			flushBuffer[0] = 0x00;			flushBuffer[1] = 0x00;			flushBuffer[2] = 0x00;					USBDevice_Write(device, flushBuffer, 3, 100);			USBDevice_Flush();			retried = 1;		}#endif		return 0;	}#ifdef LINUX	usbDevice->packetParity++;#endif	/*printf("Reading - %d /r/n", receiveBuffer[0]);	for(size_t ix = 0; ix < receiveBuffer[0]; ix++)		printf("%02x", receiveBuffer[ix]);	printf("/r/n");*/		memcpy(usbDevice->receiveBuffer, (receiveBuffer + 1), receiveBuffer[0]);	usbDevice->receiveBufferWritePtr = usbDevice->receiveBuffer + receiveBuffer[0];	return 1;}

/** * Send a command with data to usb4all controller and reads the answer. * Even if some inputs should be read a command to do this has to send before. * /param p            pointer to private data structure * /param data_out     pointer to data send to controller * /param data_in      pointer to buffer where read in data is stored * /return             number of bytes read in */intusb4all_data_io(PrivateData *p, tx_buffer * data_out, tx_buffer * data_in){	int res;	if (p->usbMode == MODE_BULK) {		res = usb_bulk_write(p->usbHandle,				     p->usbEpOut,				     (char *)data_out->buffer,				     data_out->use_count,				     TIMEOUT_WRITE);	}	else {		res = usb_interrupt_write(p->usbHandle,					  p->usbEpOut,					  (char *)data_out->buffer,					  data_out->use_count,					  TIMEOUT_WRITE);	}	if (res < 0) {		p->hd44780_functions->drv_report(RPT_WARNING,		   "usb4all_data_io: unable to send, result = %d ...", res);		return -1;	}	/* if a reset command is send the usb4all controller doesn't answer */	if (data_out->buffer[0] == USB4ALL_RESET) {		return 0;	}	if (res != data_out->use_count) {		p->hd44780_functions->drv_report(RPT_WARNING,						 "usb4all_data_io: Want to send %d bytes but currently only %d bytes was send!?",						 data_out->use_count, res);		return -1;	}	if (p->usbMode == MODE_BULK) {		res = usb_bulk_read(p->usbHandle,				    p->usbEpIn,				    (char *)data_in->buffer,				    USB4ALL_RX_MAX,				    TIMEOUT_READ);	}	else {		res = usb_interrupt_read(p->usbHandle,					 p->usbEpIn,					 (char *)data_in->buffer,					 USB4ALL_RX_MAX,					 TIMEOUT_READ);	}	return res;}

int	hidReadPoll(char *buf,int Length, int id){	int rc;	buf[0] = id;	rc = usb_interrupt_read(usb_dev, EP_IN , buf+1 , Length, 5000);//	rc = HidD_GetFeature(hHID, buf, Length);#if	DEBUG_PKTDUMP	memdump("RD", buf, Length);#endif	return rc;}

ssize_tusbReadEndpoint (  UsbDevice *device,  unsigned char endpointNumber,  void *buffer,  size_t length,  int timeout) {  UsbDeviceExtension *devx = device->extension;  const UsbEndpoint *endpoint;  if ((endpoint = usbGetInputEndpoint(device, endpointNumber))) {    const UsbEndpointDescriptor *descriptor = endpoint->descriptor;    UsbEndpointTransfer transfer = USB_ENDPOINT_TRANSFER(descriptor);    ssize_t result = -1;    switch (transfer) {      case UsbEndpointTransfer_Bulk:        result = usb_bulk_read(devx->handle, descriptor->bEndpointAddress,                               buffer, length, timeout);        break;      case UsbEndpointTransfer_Interrupt:        result = usb_interrupt_read(devx->handle, descriptor->bEndpointAddress,                                    buffer, length, timeout);        break;      default:        logMessage(LOG_ERR, "USB endpoint input transfer not supported: 0X%02X", transfer);        result = -ENOSYS;        break;    }    if (result >= 0) {      if (!usbApplyInputFilters(device, buffer, length, &result)) {        result = -EIO;      }    }    if (result >= 0) return result;    errno = -result;  }#if defined(__MINGW32__) && !defined(ETIMEDOUT)#  define ETIMEDOUT 116#endif /* __MINGW32__ && !ETIMEDOUT */#ifdef ETIMEDOUT  if (errno == ETIMEDOUT) errno = EAGAIN;#endif /* ETIMEDOUT */  if (errno != EAGAIN) logSystemError("USB endpoint read");  return -1;}

/* * Class:     ch_ntb_usb_LibusbJava * Method:    usb_interrupt_read * Signature: (JI[BII)I */JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbJava_usb_1interrupt_1read  (JNIEnv *env, jclass obj, jlong dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout)  {  	clearLibusbJavaError();  	char *bytes = (char *) malloc(size * sizeof(char)); 	int num_bytes = usb_interrupt_read((usb_dev_handle *) dev_handle, ep, bytes, size, timeout);  	if (!bytes) { return num_bytes; }  	(*env)->SetByteArrayRegion(env, jbytes, 0, size, (jbyte *) bytes);  	free(bytes); 	return num_bytes;  }

/* *	HIDデバイスから HID Report を取得する. *	受け取ったバッファは先
C++ usb_kill_anchored_urbs函数代码示例
C++ usb_init函数代码示例