• NK-RTU980 USB bulk传输

            NUC980_Non-OS_BSP_v1.03.000 SDK中没有提供USB bulk传输的例程，基于USBD_HID_Mouse例程进行修改。大体思路参考这个文章，先修改设备、配置、接口、端点等描述符，再安装驱动，最后编写下位机和上位机程序进行验证。

    USB Device Controller的框图如下：

    特性： 

    • USB Specification reversion 2.0 compliant
    • Supports 12 configurable endpoints in addition to Control Endpoint
    • Each of the endpoints can be Isochronous, Bulk or Interrupt and either IN or OUT direction
    • Three different operation modes of an in-endpoint － Auto Validation mode, Manual Validation mode, Fly mode
    • Supports DMA operation
    • 4096 Bytes Configurable RAM used as endpoint buffer
    • Supports Endpoint Maximum Packet Size up to 1024 bytes

    1.修改描述符

    关于描述符的详细说明参考博客。

    各种描述符之间的关系：

    修改descriptors.c中DeviceDescriptor：

    1. uint8_t gu8DeviceDescriptor[] __attribute__((aligned(4))) =
    2. {
    3. #endif
    4.     LEN_DEVICE,     /* bLength */
    5.     DESC_DEVICE,    /* bDescriptorType */
    6.     0x00, 0x02,     /* bcdUSB */                  //0x10,0x01->0x00,0x20
    7.     0xFF,           /* bDeviceClass */            //0x00->0xFF
    8.     0x00,           /* bDeviceSubClass */
    9.     0x00,           /* bDeviceProtocol */
    10.     CEP_MAX_PKT_SIZE,   /* bMaxPacketSize0 */
    11.     /* idVendor */
    12.     USBD_VID & 0x00FF,
    13.     ((USBD_VID & 0xFF00) >> 8),
    14.     /* idProduct */
    15.     USBD_PID & 0x00FF,
    16.     ((USBD_PID & 0xFF00) >> 8),
    17.     0x00, 0x00,     /* bcdDevice */
    18.     0x01,           /* iManufacture */
    19.     0x02,           /* iProduct */
    20.     0x00,           /* iSerialNumber - no serial */
    21.     0x01            /* bNumConfigurations */
    22. };

    修改hid_mouse.h中VID和PID的值（不是必须要修改的）：

    1. #define USBD_VID                0x303A										//0x0416->0x303A
    2. #define USBD_PID                0x3002										//0x8249->0x3001

    在hid_mouse.h中增加OUT节点的定义：

    1. /* Define EP maximum packet size */
    2. #define CEP_MAX_PKT_SIZE        64
    3. #define CEP_OTHER_MAX_PKT_SIZE  64
    4. #define EPA_MAX_PKT_SIZE        512               //修改，由64改为512
    5. #define EPA_OTHER_MAX_PKT_SIZE  64
    6. #define EPB_MAX_PKT_SIZE        512               //新增
    7. #define EPB_OTHER_MAX_PKT_SIZE  64
    8.  
    9. #define CEP_BUF_BASE    0
    10. #define CEP_BUF_LEN     CEP_MAX_PKT_SIZE
    11.  
    12. #define EPA_BUF_BASE    0x200                    //新增
    13. #define EPA_BUF_LEN     EPA_MAX_PKT_SIZE       
    14.  
    15. #define EPB_BUF_BASE    0x400                    //新增
    16. #define EPB_BUF_LEN     EPB_MAX_PKT_SIZE         //新增
    17.  
    18. /* Define the interrupt In EP number */
    19. #define INT_IN_EP_NUM   0x01
    20.  
    21. #define INT_OUT_EP_NUM   0x01                    //新增

    修改descriptors.c中ConfigDescriptor ：

    1. uint8_t gu8ConfigDescriptor[] __attribute__((aligned(4))) =
    2. {
    3. #endif
    4.     LEN_CONFIG,     /* bLength */
    5.     DESC_CONFIG,    /* bDescriptorType */
    6.     /* wTotalLength */
    7.     LEN_CONFIG_AND_SUBORDINATE & 0x00FF,
    8.     ((LEN_CONFIG_AND_SUBORDINATE & 0xFF00) >> 8),					
    9.     0x01,           /* bNumInterfaces */
    10.     0x01,           /* bConfigurationValue */
    11.     0x00,           /* iConfiguration */
    12.     0x80 | (USBD_SELF_POWERED << 6) | (USBD_REMOTE_WAKEUP << 5),/* bmAttributes */
    13.     USBD_MAX_POWER,         /* MaxPower */
    14.  
    15.     /* I/F descr: HID */
    16.     LEN_INTERFACE,  /* bLength */
    17.     DESC_INTERFACE, /* bDescriptorType */
    18.     0x00,           /* bInterfaceNumber */
    19.     0x00,           /* bAlternateSetting */
    20.     0x02,           /* bNumEndpoints */								//0x01->0x02
    21.     0xFF,           /* bInterfaceClass */							//0x03->0xFF
    22.     0x01,           /* bInterfaceSubClass */
    23.     0x00,      			/* bInterfaceProtocol */					//HID_MOUSE->0x00
    24.     0x00,           /* iInterface */
    25. 		
    26.     /* HID Descriptor */															//不使用报告描述符，将此段配置注释。
    27. //    LEN_HID,        /* Size of this descriptor in UINT8s. */
    28. //    DESC_HID,       /* HID descriptor type. */
    29. //    0x10, 0x01,     /* HID Class Spec. release number. */
    30. //    0x00,           /* H/W target country. */
    31. //    0x01,           /* Number of HID class descriptors to follow. */
    32. //    DESC_HID_RPT,   /* Descriptor type. */
    33.     /* Total length of report descriptor. */
    34. //    sizeof(HID_MouseReportDescriptor) & 0x00FF,
    35. //    ((sizeof(HID_MouseReportDescriptor) & 0xFF00) >> 8),
    37.     /* EP Descriptor: bulk in. */
    38.     LEN_ENDPOINT,   /* bLength */
    39.     DESC_ENDPOINT,  /* bDescriptorType */
    40.     (INT_IN_EP_NUM | EP_INPUT), /* bEndpointAddress */
    41.     EP_BULK,         /* bmAttributes */				//EP_INT->EP_BULK
    42.     /* wMaxPacketSize */
    43.     EPA_MAX_PKT_SIZE & 0x00FF,
    44.     ((EPA_MAX_PKT_SIZE & 0xFF00) >> 8),
    45.     0x00,					     /* bInterval */				//HID_DEFAULT_INT_IN_INTERVAL->0x00
    46. 		
    47.     /* EP Descriptor: bulk out. */									//新增一个输出端点。
    48.     LEN_ENDPOINT,   /* bLength */
    49.     DESC_ENDPOINT,  /* bDescriptorType */
    50.     (INT_OUT_EP_NUM | EP_OUTPUT), /* bEndpointAddress */
    51.     EP_BULK,         /* bmAttributes */	
    52.     /* wMaxPacketSize */
    53.     EPB_MAX_PKT_SIZE & 0x00FF,
    54.     ((EPB_MAX_PKT_SIZE & 0xFF00) >> 8),
    55.     0x00					     /* bInterval */
    56. };

    修改LEN_CONFIG_AND_SUBORDINATE的值（减去了一个REPORT，增加了一个END）：

    #define LEN_CONFIG_AND_SUBORDINATE      (LEN_CONFIG+LEN_INTERFACE+LEN_ENDPOINT+LEN_ENDPOINT)

    修改hid_mouse.c中的HID_InitForHighSpeed()、HID_InitForFullSpeed()，增加OUT端点配置：

    1. /**
    2.   * @brief  USBD Endpoint Config.
    3.   * @param  None.
    4.   * @retval None.
    5.   */
    6. void HID_InitForHighSpeed(void)
    7. {
    8.     /* EPA ==> Interrupt IN endpoint, address 1 */
    9.     USBD_SetEpBufAddr(EPA, EPA_BUF_BASE, EPA_BUF_LEN);
    10.     USBD_SET_MAX_PAYLOAD(EPA, EPA_MAX_PKT_SIZE);
    11.     USBD_ConfigEp(EPA, INT_IN_EP_NUM, USB_EP_CFG_TYPE_BULK, USB_EP_CFG_DIR_IN);
    12. 	
    13.     /* EPB ==> Interrupt OUT endpoint, address 1 */
    14.     USBD_SetEpBufAddr(EPB, EPB_BUF_BASE, EPB_BUF_LEN);
    15.     USBD_SET_MAX_PAYLOAD(EPB, EPA_MAX_PKT_SIZE);
    16.     USBD_ConfigEp(EPB, INT_OUT_EP_NUM, USB_EP_CFG_TYPE_BULK, USB_EP_CFG_DIR_OUT);	
    17. 	
    18. 		USBD_ENABLE_EP_INT(EPB, USBD_EPINTEN_RXPKIEN_Msk);
    19. }
    20.  
    21. void HID_InitForFullSpeed(void)
    22. {
    23.     /* EPA ==> Interrupt IN endpoint, address 1 */
    24.     USBD_SetEpBufAddr(EPA, EPA_BUF_BASE, EPA_BUF_LEN);
    25.     USBD_SET_MAX_PAYLOAD(EPA, EPA_OTHER_MAX_PKT_SIZE);
    26.     USBD_ConfigEp(EPA, INT_IN_EP_NUM, USB_EP_CFG_TYPE_BULK, USB_EP_CFG_DIR_IN);
    27.  
    28.     /* EPB ==> Interrupt OUT endpoint, address 1 */
    29.     USBD_SetEpBufAddr(EPB, EPB_BUF_BASE, EPB_BUF_LEN);
    30.     USBD_SET_MAX_PAYLOAD(EPB, EPB_OTHER_MAX_PKT_SIZE);
    31.     USBD_ConfigEp(EPB, INT_OUT_EP_NUM, USB_EP_CFG_TYPE_BULK, USB_EP_CFG_DIR_IN);	
    32. 	
    33. 		USBD_ENABLE_EP_INT(EPB, USBD_EPINTEN_RXPKIEN_Msk);
    34. }

    修改UsbString：

    1. uint8_t gu8ProductStringDesc[] __attribute__((aligned(4))) =
    2. {
    3. #endif
    4.     34,
    5.     DESC_STRING,
    6.     'B', 0, 'U', 0, 'L', 0, 'K', 0,' ', 0, 'T', 0, 'r', 0, 'a', 0, 'n', 0, 's', 0, 'a', 0, 'c', 0, 't', 0, 'i', 0, 'o', 0, 'n', 0
    7. };

    编译程序，重新烧录。电脑->设备管理器>其它设备 下多了一个名称为BULK Transaction的设备：

     2.生成USB 驱动

    运行inf-wizard.exe应用，点击 Next：

     选择Vendor ID为0x303A、Product ID为0x3002的设备，点击Next：

     Manufacturer Name、Device Name可修改为其它类容，点击Next：

     选择一个路径存放驱动文件。

     点击Done完成并退出。

    3.安装驱动

    右键 ->更新驱动程序->浏览我的电脑以查找驱动程序(R)，选择刚才存放驱动的文件夹：

     点击 下一页。

     一般会遇到以上问题，这是因为驱动没有包含数字签名，解决办法。

    驱动安装成功之后，设备管理器展示如下：

     4.使用工具查看设备描述符

    运行testlibusb-win.exe，设备描述符如下：

    5.编写NUC980 bulk读写函数及测试程序

    在hid_mouse.c中增加bulk读写函数：

    1. /**
    2.   * @brief  USBD Endpoint Write.
    3.   * @param  None.
    4.   * @retval None.
    5.   */
    6. void BulkWriteData( uint8_t *Datas, uint16_t Len )
    7. {
    8. 		uint16_t i;
    9. 	
    10. 		for ( i=0; i<Len; i++)
    11. 		{
    12. 				USBD->EP[EPA].ep.EPDAT_BYTE = Datas[i];
    13. 		}
    14. 		
    15. 		USBD->EP[EPA].EPRSPCTL = USB_EP_RSPCTL_SHORTTXEN;
    16. 		USBD_ENABLE_EP_INT(EPA, USBD_EPINTEN_INTKIEN_Msk);	
    17. }
    18. /**
    19.   * @brief  USBD Endpoint Read.
    20.   * @param  None.
    21.   * @retval None.
    22.   */
    23. uint16_t BulkReadData( uint8_t *Datas, uint16_t Len )
    24. {
    25. 	uint16_t i;
    26. 	uint16_t DataCnt = USBD->EP[EPB].EPDATCNT;
    27. 	if( DataCnt > 0 )
    28. 	{
    29. 		for( i = 0; i < DataCnt; i++ )
    30. 		{
    31. 			Datas[i] = USBD->EP[EPB].ep.EPDAT_BYTE;
    32. 		}
    33. 	}
    34. 	
    35. 	return DataCnt;
    36. }

    main.c中增加接收和发送数据的逻辑，main()函数如下：

    1. int32_t main (void)
    2. {
    3. 	uint8_t i, Cnt = 0;
    4. 	uint8_t DataBuf[EPB_MAX_PKT_SIZE];
    5. 	uint16_t RxLen;
    6. 	
    7.     sysDisableCache();
    8.     sysFlushCache(I_D_CACHE);
    9.     sysEnableCache(CACHE_WRITE_BACK);
    10.     UART_Init();
    11.     printf("\n");
    12.     printf("=======================\n");
    13.     printf("     USB HID Mouse     \n");
    14.     printf("=======================\n");
    15.  
    16.     sysInstallISR(IRQ_LEVEL_1, IRQ_UDC, (PVOID)USBD_IRQHandler);
    17.     /* enable CPSR I bit */
    18.     sysSetLocalInterrupt(ENABLE_IRQ);
    19.     sysEnableInterrupt(IRQ_UDC);
    20.  
    21.     USBD_Open(&gsInfo, HID_ClassRequest, NULL);
    22.  
    23.     /* Endpoint configuration */
    24.     HID_Init();
    25.  
    26.     /* Start transaction */
    27.     while(1)
    28.     {
    29.         if (USBD_IS_ATTACHED())
    30.         {
    31.             USBD_Start();
    32.             break;
    33.         }
    34.     }
    35.  
    36. 		
    37. 		
    38.     while(1)
    39.     {
    40.     	RxLen = BulkReadData(DataBuf, EPB_MAX_PKT_SIZE );
    41. 				
    42. 	    if( RxLen > 0 )
    43. 		{
    44. 			BulkWriteData( DataBuf, EPA_MAX_PKT_SIZE );
    45. 		}
    46. 				
    47.     }
    48. }

     编译之后烧写到NUC980。

    6.编写windows应用程序测试数据通信

    基于libusb.lib编写一个测试应用，进行简单的数据的发送和接收。代码如下：

    1. #include "lusb0_usb.h"
    2. #include <stdio.h>
    3. #include "stdint.h"
    4. #include <iostream>
    5. #include <sys/timeb.h>
    6. #include "windows.h"
    7.  
    8. using namespace std;
    9.  
    10. // Enables this example to work with a device running the
    11. // libusb-win32 PIC Benchmark Firmware.
    12. //#define BENCHMARK_DEVICE
    13.  
    14. //
    15. // TEST SETUP (User configurable)
    16.  
    17. // Issues a Set configuration request
    18. #define TEST_SET_CONFIGURATION
    19.  
    20. // Issues a claim interface request
    21. #define TEST_CLAIM_INTERFACE
    22.  
    23. // Use the libusb-win32 async transfer functions. see
    24. // transfer_bulk_async() below.
    25. #define TEST_ASYNC
    26.  
    27. // Attempts one bulk read.
    28. #define TEST_BULK_READ
    29.  
    30. // Attempts one bulk write.
    31.  #define TEST_BULK_WRITE
    32.  
    33. // Device vendor and product id.
    34. //#define MY_VID 0x05AC
    35. //#define MY_PID 0x12A0
    36.  
    37. #define MY_VID 0x303A
    38. #define MY_PID 0x3002
    39.  
    40. // Device configuration and interface id.
    41. #define MY_CONFIG 1    //bConfigurationValue   --lwz
    42. #define MY_INTF 0      //bInterfaceNumber     --lwz
    43.  
    44. // Device endpoint(s)
    45. #define EP_IN 0x81    //0x81
    46. #define EP_OUT 0x01
    47. // Device of bytes to transfer.
    48. #define RX_BUF_SIZE 512
    49. #define TX_BUF_SIZE 512
    50.  
    51. #define TEST_BULK_SPEED
    52.  
    53. usb_dev_handle *dev = NULL; /* the device handle */
    54.  
    55. //
    56. usb_dev_handle *open_dev(void);
    57. uint16_t usb_dev_read_sync( uint8_t *Buf, uint16_t bufsz );
    58. bool usb_dev_write_async( uint8_t *Datas, uint16_t DataLen, int timeout );
    59. int usb_dev_read_async( uint8_t *Buf, uint16_t bufsz, int timeout );
    60.  
    61. static int transfer_bulk_async(usb_dev_handle *dev,
    62.                                int ep,
    63.                                char *bytes,
    64.                                int size,
    65.                                int timeout);
    66.  
    67. usb_dev_handle *open_dev(void)
    68. {
    69.     struct usb_bus *bus;
    70.     struct usb_device *dev;
    71.  
    72.     for (bus = usb_get_busses(); bus; bus = bus->next)
    73.     {
    74.         for (dev = bus->devices; dev; dev = dev->next)
    75.         {
    76.             if (dev->descriptor.idVendor == MY_VID
    77.                     && dev->descriptor.idProduct == MY_PID)
    78.             {
    79.                 return usb_open(dev);
    80.             }
    81.         }
    82.     }
    83.     return NULL;
    84. }
    85.  
    86. //
    87. //  usb_dev_init.
    88. //
    89. void usb_dev_init( void )
    90. {
    91. 	usb_init(); /* initialize the library */
    92. }
    93. //
    94. //  usb_dev_open.
    95. //
    96. bool usb_dev_open( void )
    97. {
    98.     usb_find_busses(); /* find all busses */
    99.     usb_find_devices(); /* find all connected devices */
    100.  
    101. 	if (!(dev = open_dev()))
    102.     {
    103.         printf("error opening device: \n%s\n", usb_strerror());
    104.         return false;
    105.     }
    106.  
    107.     if (usb_set_configuration(dev, MY_CONFIG) < 0)           //MY_CONFIG是配置描述符中的bConfigurationValue
    108.     {
    109.         printf("error setting config #%d: %s\n", MY_CONFIG, usb_strerror());
    110.         usb_close(dev);
    111.         return false;
    112.     }
    113.  
    114.     if (usb_claim_interface(dev, MY_INTF) < 0)     //注册与操作系统通信的接口 --lwz
    115.     {
    116.         printf("error claiming interface #%d:\n%s\n", MY_INTF, usb_strerror());
    117.         usb_close(dev);
    118.         return false;
    119.     }
    120.  
    121. 	return true;
    122. }
    123. //
    124. //  usb_dev_close.
    125. //
    126. void usb_dev_close( void )
    127. {
    128.     if (dev)
    129.     {
    130. 		usb_release_interface(dev, MY_INTF);   //注销被usb_claim_interface函数调用后的接口，释放资源  --lwz
    131.         usb_close(dev);
    132.     }	
    133. }
    134.  
    135. bool usb_dev_isopen( void )
    136. {
    137. 	if( dev != NULL )
    138. 	{
    139. 		return true;
    140. 	}
    141.  
    142. 	return false;
    143. }
    144.  
    145. void usb_dev_reset_epin( void )
    146. {
    147. 	usb_clear_halt( dev, EP_IN );
    148. }
    149.  
    150. void usb_dev_reset_epout( void )
    151. {
    152. 	usb_clear_halt( dev, EP_OUT );
    153. }
    154.  
    155. int main(char argc,char **argv)
    156. {
    157. 	usb_dev_handle *dev = NULL; /* the device handle */
    158.     char tmp[RX_BUF_SIZE];
    159.     int ret;
    160.     void* async_read_context = NULL;
    161.     void* async_write_context = NULL;
    162.  
    163.     usb_init(); /* initialize the library */
    164.     usb_find_busses(); /* find all busses */
    165.     usb_find_devices(); /* find all connected devices */
    166.  
    167. 	if (!(dev = open_dev()))
    168.     {
    169.         printf("error opening device: \n%s\n", usb_strerror());
    170.         return 0;
    171.     }
    172.     else
    173.     {
    174.         printf("success: device %04X:%04X opened\n", MY_VID, MY_PID);
    175.     }
    176.  
    177. #ifdef TEST_SET_CONFIGURATION
    178.     if (usb_set_configuration(dev, MY_CONFIG) < 0)           //MY_CONFIG是配置描述符中的bConfigurationValue
    179.     {
    180.         printf("error setting config #%d: %s\n", MY_CONFIG, usb_strerror());
    181.         usb_close(dev);
    182.         return 0;
    183.     }
    184.     else
    185.     {
    186.         printf("success: set configuration #%d\n", MY_CONFIG);
    187.     }
    188. #endif
    189.  
    190. #ifdef TEST_CLAIM_INTERFACE
    191.     if (usb_claim_interface(dev, 0) < 0)     //注册与操作系统通信的接口 --lwz
    192.     {
    193.         printf("error claiming interface #%d:\n%s\n", MY_INTF, usb_strerror());
    194.         usb_close(dev);
    195.         return 0;
    196.     }
    197.     else
    198.     {
    199.         printf("success: claim_interface #%d\n", MY_INTF);
    200.     }
    201. #endif
    202.  
    203. #ifdef TEST_BULK_SPEED
    204.  
    205. 	char tmpOut[TX_BUF_SIZE];
    206. 	char tmpIn[RX_BUF_SIZE];
    207.  
    208. 	uint8_t Count = 0;
    209. 	uint64_t ComCnt = 0;
    210. 	uint64_t errCnt = 0;
    211.  
    212. 	struct timeb rawtime;
    213.  
    214. 	ftime(&rawtime);
    215. 	uint64_t StartTime =  rawtime.time;
    216.  
    217. 	for( ;; )
    218. 	{
    219. 		for( uint16_t i = 0; i < sizeof(tmpOut); i++ )
    220. 		{
    221. 			tmpOut[i] = Count++;
    222. 		}
    223.  
    224. 		ComCnt ++;
    225.  
    226. 		ret = transfer_bulk_async(dev, EP_OUT, tmpOut, sizeof(tmpOut), 5000);
    227. 		if (ret < 0)
    228. 		{
    229. //			printf("error writing:\n%s\n", usb_strerror());
    230. 		}
    231. 		else
    232. 		{
    233. //			printf("success: bulk write %d bytes\n", ret);
    234. 		}
    235.  
    236. 		// Running an async read test
    237. 		ret = transfer_bulk_async(dev, EP_IN, tmpIn, sizeof(tmpIn), 5000);
    238.  
    239. 		if (ret < 0)
    240. 		{
    241. 			printf("error reading:\n%s\n", usb_strerror());
    242. 		}
    243. 		else
    244. 		{
    245. 			printf("success: bulk read %d bytes\n", ret);
    246. 		}
    247.  
    248. 		
    249. 		//if( memcmp( tmpOut, tmpIn, BUF_SIZE ) != 0 )
    250. 		//{
    251. 		//	errCnt ++;
    252. 		//}
    253.  
    254. 		for( int j = 0; j < TX_BUF_SIZE; j++ )
    255. 		{
    256. 			if( tmpOut[j] != tmpIn[j] )
    257. 			{
    258. 				errCnt ++;
    259. 				break;
    260. 			}
    261. 		}
    262.  
    263. 		if( (ComCnt % 2000) == 0 )
    264. 		{
    265. 			printf("ComCnt:%d  ",ComCnt );
    266. 			printf("errCnt:%d \n",errCnt );
    267.  
    268. 			struct timeb rawtime1;
    269.  
    270. 			ftime(&rawtime1);
    271.  
    272. 			uint64_t endTime = rawtime1.time;
    273.  
    274. 			printf("transfer speed:%0.2f bps\n", ((float)(ComCnt * TX_BUF_SIZE * 2 * 8) / (endTime - StartTime)) );
    275. 		}
    276.  
    277. //		Sleep(3);
    278. 	}
    279. #endif
    280.  
    281. #ifdef TEST_BULK_WRITE
    282. 	#ifdef BENCHMARK_DEVICE      
    283. 		ret = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
    284. 							  14, /* set/get test */
    285. 							  2,  /* test type    */
    286. 							  MY_INTF,  /* interface id */
    287. 							  tmp, 1, 1000);     //从默认的管道发送和接受控制数据--lwz
    288. 	#endif
    289.  
    290. 	#ifdef TEST_ASYNC
    291. 		// Running an async write test
    292. 		for( int i = 0; i < sizeof(tmp); i++ )
    293. 		{
    294. 			tmp[i] = i;
    295. 		}
    296. 		ret = transfer_bulk_async(dev, EP_OUT, tmp, sizeof(tmp), 5000);
    297. 	#else
    298. 		// Running a sync write test
    299. 		ret = usb_bulk_write(dev, EP_OUT, tmp, sizeof(tmp), 5000);
    300. 	#endif
    301. 		if (ret < 0)
    302. 		{
    303. 			printf("error writing:\n%s\n", usb_strerror());
    304. 		}
    305. 		else
    306. 		{
    307. 			printf("success: bulk write %d bytes\n", ret);
    308. 		}
    309. #endif
    310. 		memset(tmp, 0 , TX_BUF_SIZE );
    311. #ifdef TEST_BULK_READ
    312. 	#ifdef BENCHMARK_DEVICE
    313. 		ret = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
    314. 							  14, /* set/get test */
    315. 							  1,  /* test type    */
    316. 							  MY_INTF,  /* interface id */
    317. 							  tmp, 1, 1000);
    318. 	#endif
    319.  
    320. 	#ifdef TEST_ASYNC      //有声明--lwz
    321. 		// Running an async read test
    322. 		ret = transfer_bulk_async(dev, EP_IN, tmp, sizeof(tmp), 5000);
    323. 	#else
    324. 		// Running a sync read test
    325. 		ret = usb_bulk_read(dev, EP_IN, tmp, sizeof(tmp), 5000);
    326. 	#endif
    327. 		if (ret < 0)
    328. 		{
    329. 			printf("error reading:\n%s\n", usb_strerror());
    330. 		}
    331. 		else
    332. 		{
    333. 			printf("success: bulk read %d bytes\n", ret);
    334.  
    335. 			for(int i = 0; i < ret; i++ )
    336. 			{
    337. 				printf( "%02X ", tmp[i]);
    338. 			}
    339.  
    340. 			printf("\n");
    341. 		}
    342. #endif
    343.  
    344. #ifdef TEST_BULK_READ
    345. 	#ifdef BENCHMARK_DEVICE
    346. 		ret = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
    347. 							  14, /* set/get test */
    348. 							  1,  /* test type    */
    349. 							  MY_INTF,  /* interface id */
    350. 							  tmp, 1, 1000);
    351. 	#endif
    352.  
    353. 	#ifdef TEST_ASYNC
    354. 		// Running an async read test
    355. 		ret = transfer_bulk_async(dev, EP_IN, tmp, sizeof(tmp), 5000);
    356. 	#else
    357. 		// Running a sync read test
    358. 		ret = usb_bulk_read(dev, EP_IN, tmp, sizeof(tmp), 5000);
    359. 	#endif
    360. 		if (ret < 0)
    361. 		{
    362. 			printf("error reading:\n%s\n", usb_strerror());
    363. 		}
    364. 		else
    365. 		{
    366. 			printf("success: bulk read %d bytes\n", ret);
    367. 		}
    368. #endif
    369.  
    370. #ifdef TEST_CLAIM_INTERFACE
    371.     usb_release_interface(dev, 0);   //注销被usb_claim_interface函数调用后的接口，释放资源  --lwz
    372. #endif
    373.  
    374.     if (dev)
    375.     {
    376.         usb_close(dev);
    377.     }
    378.     printf("Done.\n");
    379.  
    380.     return 0;	
    381.  
    382. }
    383.  
    384. /*
    385. * Read/Write using async transfer functions.
    386. *
    387. * NOTE: This function waits for the transfer to complete essentially making
    388. * it a sync transfer function so it only serves as an example of how one might
    389. * implement async transfers into thier own code.
    390. */
    391. static int transfer_bulk_async(usb_dev_handle *dev,
    392.                                int ep,
    393.                                char *bytes,
    394.                                int size,
    395.                                int timeout)
    396. {
    397.     // Each async transfer requires it's own context. A transfer
    398.     // context can be re-used.  When no longer needed they must be
    399.     // freed with usb_free_async().
    400.     //
    401.     void* async_context = NULL;
    402.     int ret;
    404.     // Setup the async transfer.  This only needs to be done once
    405.     // for multiple submit/reaps. (more below)
    406.     //
    407.     ret = usb_bulk_setup_async(dev, &async_context, ep);
    408.     if (ret < 0)
    409.     {
    410.         printf("error usb_bulk_setup_async:\n%s\n", usb_strerror());
    411.         goto Done;
    412.     }
    414.     // Submit this transfer.  This function returns immediately and the
    415.     // transfer is on it's way to the device.
    416.     //
    417.     ret = usb_submit_async(async_context, bytes, size);
    418.     if (ret < 0)
    419.     {
    420.         printf("error usb_submit_async:\n%s\n", usb_strerror());
    421.         usb_free_async(&async_context);
    422.         goto Done;
    423.     }
    424.  
    425.     // Wait for the transfer to complete.  If it doesn't complete in the
    426.     // specified time it is cancelled.  see also usb_reap_async_nocancel().
    427.     //
    428.     ret = usb_reap_async(async_context, timeout);
    430.     // Free the context.
    431.     usb_free_async(&async_context);
    433. Done:
    434.     return ret;
    435. }
    437. //
    438. //  usb_dev_read_async.
    439. //
    440. int usb_dev_read_async( uint8_t *Buf, uint16_t bufsz, int timeout )
    441. {
    442. 	if( dev == NULL )
    443. 	{
    444. 		return 0;
    445. 	}
    447. 	int ret;
    448. 	char tmp[RX_BUF_SIZE];
    449.     
    450. 	ret = transfer_bulk_async(dev, EP_IN, tmp, RX_BUF_SIZE, timeout );
    452. 	if( ret > 0 )
    453. 	{
    454. 		if( bufsz >= ret )
    455. 		{
    456. 			memcpy(Buf, tmp, ret );
    457. 		}
    458. 	}
    460. 	return ret;
    461. }
    462. //
    463. //  usb_dev_write_async.
    464. //
    465. bool usb_dev_write_async( uint8_t *Datas, uint16_t DataLen, int timeout )
    466. {
    467. 	if( dev == NULL )
    468. 	{
    469. 		return false;
    470. 	}
    472. 	int ret;
    474. 	ret = transfer_bulk_async(dev, EP_OUT, (char *)Datas, DataLen , timeout);
    476. 	if( ret < 0 )
    477. 	{
    478. 		return false;
    479. 	}
    481. 	return true;
    482. }
    483. //
    484. //  usb_dev_read_sync.
    485. //
    486. uint16_t usb_dev_read_sync( uint8_t *Buf, uint16_t bufsz )
    487. {
    488. 	if( dev == NULL )
    489. 	{
    490. 		return 0;
    491. 	}
    493. 	int ret;
    494. 	char tmp[RX_BUF_SIZE];
    495.   
    496. 	ret = usb_bulk_read(dev, EP_IN, tmp, RX_BUF_SIZE,5000);
    497. 	if( ret > 0 )
    498. 	{
    499. 		if( bufsz >= ret )
    500. 		{
    501. 			memcpy(Buf, tmp, ret );
    502. 		}
    503. 	}
    505. 	return ret;	
    506. }

    上位机运行日志如下：

     计算出的速率大约2.7MB/s，比全速高一点，这个速度还有待提升。

    NUC980技术交流QQ群:912184327

  • 相关阅读:
    生产力工具如何选择？印象笔记 Verse、Notion、FlowUs
    Windows CSC提权漏洞复现（CVE-2024-26229）
    Node历史版本下载及配置npm镜像
    剑指 Offer 12. 矩阵中的路径
    Matlab图像处理-三基色
    流量主如何在广告收益和用户体验中找到平衡
    微信小程序：炫酷恶趣制作神器小程序源码
    JavaWeb之MySql高级（保姆级教程）
    俯瞰·明攻山西之战（太原之战）
    计算机毕业设计之java+ssm基于android的家庭理财系统app
  • 原文地址：https://blog.csdn.net/professionalmcu/article/details/126338573