libusb-win32，我装完后，插上Ukey，可以读出VID，PID。我用VC写的程序，总是遇到write和read超时的错误，新手，第一次写USB程序，希望高人帮忙指点一下，谢谢了！
下面是我写的代码：
#define MY_VID 0x1234
#define MY_PID 0x5678

// Device configuration and interface id.
#define MY_CONFIG 1
#define MY_INTF 0

// Device endpoint(s)
#define EP_IN 0x81
#define EP_OUT 0x01

// Device of bytes to transfer.
#define BUF_SIZE 64

static int transfer_bulk_async(usb_dev_handle *dev,
                               int ep,
                               char *bytes,
                               int size,
                               int timeout);

usb_dev_handle *open_dev(void)
{
    struct usb_bus *bus;
    struct usb_device *dev;

    for (bus = usb_get_busses(); bus; bus = bus->next)
    {
        for (dev = bus->devices; dev; dev = dev->next)
        {
            if (dev->descriptor.idVendor == MY_VID && dev->descriptor.idProduct == MY_PID)
            {
                return usb_open(dev);
            }
        }
    }
    return NULL;
}







 typedef struct tagusb_cbw_package{
UINT32 dCBWSignature; //byte3-0
UINT32 dCBWTag; //byte 7-4
UINT32 dCBWDataTransferLength;//byte 11-8
BYTE bmCBWFlags; //byte 12
BYTE bCBWLUN; //byte 13
BYTE bCBWCBLength; //byte 14
BYTE CBWCB[16];//byte 31-15
}usb_cbw_package;

 typedef struct tagusb_csw_package{
UINT32 dCSWSignature;//byte 3-0
UINT32 dCSWTag;//byte 7-4
UINT32 dCSWDataResidue;//byte 11-8
BYTE bCSWStatus;//byte 12
}usb_csw_package;

 usb_cbw_package CBW;
usb_csw_package CSW;

int main()
{

//////////////////////////////////////////////////////////////////////////////



    usb_dev_handle *dev = NULL; /* the device handle */
    char tmp[BUF_SIZE];
char readdata[40];
memset(readdata,0,40);
    int ret;
    void* async_read_context = NULL;
    void* async_write_context = NULL;

    usb_init(); /* initialize the library */
    usb_find_busses(); /* find all busses */
    usb_find_devices(); /* find all connected devices */


    if (!( dev = open_dev()))
    {
       printf("error opening device: \n%s\n", usb_strerror());
        //return 0;
    }
    else
    {
        printf("success: device %04X:%04X opened\n", MY_VID, MY_PID);
    }
CBW.CBWCB[0]=0xFE;
CBW.CBWCB[1]=0x01;
CBW.dCBWDataTransferLength=0x10000;
CBW.dCBWSignature=0x43425355;
CBW.dCBWTag=0x01000000;
CBW.bmCBWFlags=0x00;
CBW.bCBWLUN=0x00;

//#ifdef TEST_SET_CONFIGURATION
    if (usb_set_configuration(dev, MY_CONFIG) < 0)
    {
        printf("error setting config #%d: %s\n", MY_CONFIG, usb_strerror());
        usb_close(dev);
        return 0;
    }
    else
    {
        printf("success: set configuration #%d\n", MY_CONFIG);
    }
//#endif

//#ifdef TEST_CLAIM_INTERFACE
    if (usb_claim_interface(dev, 0) < 0)
    {
        printf("error claiming interface #%d:\n%s\n", MY_INTF, usb_strerror());
        usb_close(dev);
        return 0;
    }
    else
    {
        printf("success: claim_interface #%d\n", MY_INTF);
    }
//#endif

//#ifdef TEST_BULK_WRITE


//#ifdef BENCHMARK_DEVICE
   ret = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
                          14, /* set/get test */
                          2,  /* test type    */
                          MY_INTF,  /* interface id */
  (char *)CBW.CBWCB, 512, 1000);
  ret = transfer_bulk_async(dev, EP_OUT, (char *)CBW.CBWCB, sizeof(CBW.CBWCB), 1000);

  
    ret = usb_bulk_write(dev, EP_OUT, (char *)(CBW.CBWCB), sizeof(CBW.CBWCB), 1000);

    if (ret < 0)
    {
        printf("error writing:\n%s\n", usb_strerror());
    }
    else
    {
        printf("success: bulk write %d bytes\n", ret);
    }

 //ret = usb_get_string_simple(hdev, dev->descriptor.iProduct, string, sizeof(string));




    /*CBW.CBWCB[0]=0xFE;
CBW.CBWCB[1]=0x01;
CBW.dCBWDataTransferLength=0x10000;
CBW.dCBWSignature=0x43425355;
CBW.dCBWTag=0x01000000;
CBW.bmCBWFlags=0x01;
CBW.bCBWLUN=0x00;*/

ret = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
                          14, /* set/get test */
                          1,  /* test type    */
                          MY_INTF,  /* interface id */
                          readdata, 512, 1000);

    ret = transfer_bulk_async(dev, EP_IN, readdata, sizeof(readdata), 1000);


   ret = usb_bulk_read(dev, EP_IN, readdata, sizeof(readdata), 1000);

    if (ret < 0)
    {
        printf("error reading:\n%s\n", usb_strerror());
    }
    else
    {
        printf("success: bulk read %d bytes\n", ret);
    }
for (int i=0;i<ret;i++)
printf("the miwen is %2x \n",readdata[i]);

usb_release_interface(dev, 0);
system("pause");
if (dev)
    {
        usb_close(dev);
    }
    printf("Done.\n");

    return 0;
system("pause");
}
static int transfer_bulk_async(usb_dev_handle *dev,
                               int ep,
                               char *bytes,
                               int size,
                               int timeout)
{
    // Each async transfer requires it's own context. A transfer
    // context can be re-used.  When no longer needed they must be
    // freed with usb_free_async().
    //
    void* async_context = NULL;
    int ret;

    // Setup the async transfer.  This only needs to be done once
    // for multiple submit/reaps. (more below)
    //
    ret = usb_bulk_setup_async(dev, &async_context, ep);
    if (ret < 0)
    {
        printf("error usb_bulk_setup_async:\n%s\n", usb_strerror());
        goto Done;
    }

    // Submit this transfer.  This function returns immediately and the
    // transfer is on it's way to the device.
    //
    ret = usb_submit_async(async_context, bytes, size);
    if (ret < 0)
    {
        printf("error usb_submit_async:\n%s\n", usb_strerror());
        usb_free_async(&async_context);
        goto Done;
    }

    // Wait for the transfer to complete.  If it doesn't complete in the
    // specified time it is cancelled.  see also usb_reap_async_nocancel().
    //
    ret = usb_reap_async(async_context, timeout);

    // Free the context.
    usb_free_async(&async_context);

Done:
    return ret;
}