21ic电子技术开发论坛 › 单片机与嵌入式系统 › 小华半导体 › HC32F460通过USB与matlab通讯简单例程
返回列表 发新帖我要提问

[方案相关] HC32F460通过USB与matlab通讯简单例程

[复制链接]
3562|4
 楼主| 纪国圣 发表于 2021-10-31 17:06 | 显示全部楼层 |阅读模式
matlab, hc32f460, 通讯, USB, ip, ce
这个例程只是实现了HC32F460通过USB与matlab数据回环交换，更复杂的例子比如实时采集数据可以在此基础上通过Timer定时读取Read函数实现。
1.准备好之前HC32F460的WINUSB例程与其上位机，并简单测试HC32F460能否每秒发送一次数据：
1.gif
1.PNG
HC32F460_WINUSB MS_OS_20.zip (6.66 MB, 下载次数: 17)
win_usb.zip (23.4 KB, 下载次数: 11)
2.替换文件：
将下图文件放入工程中：
3.PNG
工程目录由
2.PNG
替换为
4.PNG
其中USB.cpp和USB_Dll.cpp主要是对WINUSB开启、读写、关闭做进一步的封装，方便matlab调用。
USB_Dll.h
复制
  1. #ifndef USB_Dll_H
    

  2. #define USB_Dll_H
    


  3. 

  4. #ifdef __cplusplus
    

  5. extern"C"
    

  6. {
    

  7. #endif
    


  8. 

  9. __declspec(dllexport) unsigned char Connect();
    

  10. __declspec(dllexport) unsigned char Read(unsigned char *ptr, const int len);
    

  11. __declspec(dllexport) unsigned char Write(unsigned char *ptr, unsigned long* cbsize, const int len);
    

  12. __declspec(dllexport) void Close();
    


  13. 

  14. #ifdef __cplusplus
    

  15. }
    

  16. #endif
    


  17. 

  18. #endif
USB_Dll.cpp
复制
  1. #include "WUSB.h"
    

  2. #include "USB_Dll.h"
    


  3. 

  4. #include <cfgmgr32.h>
    


  5. 

  6. DEVICE_DATA deviceData;
    

  7. PIPE_ID PipeID;
    


  8. 

  9. unsigned char Connect()
    

  10. {
    

  11.         BOOL bResult = TRUE;
    

  12.         unsigned char result;
    


  13. 

  14.         bResult = USB_Init(&deviceData, &PipeID);
    

  15.         if (bResult == FALSE)
    

  16.         {
    

  17.                 result = 0;
    

  18.         }
    

  19.         else
    

  20.         {
    

  21.                 result = 1;
    

  22.         }
    


  23. 

  24.         return result;
    

  25. }
    


  26. 

  27. unsigned char Read(unsigned char* ptr, const int len)
    

  28. {
    

  29.         BOOL bResult = TRUE;
    

  30.         unsigned char result;
    


  31. 

  32.         bResult = ReadFromBulkEndpoint(deviceData.WinusbHandle, &PipeID.PipeInId, len, ptr);
    

  33.         if (bResult == FALSE)
    

  34.         {
    

  35.                 CloseDevice(&deviceData);
    

  36.                 result = 0;
    

  37.         }
    

  38.         else
    

  39.         {
    

  40.                 result = 1;
    

  41.         }
    


  42. 

  43.         return result;
    

  44. }
    


  45. 

  46. unsigned char Write(unsigned char* ptr, unsigned long *cbsize,const int len)
    

  47. {
    

  48.         BOOL bResult = TRUE;
    

  49.         unsigned char result;
    


  50. 

  51.         bResult = WriteToBulkEndpoint(deviceData.WinusbHandle, &PipeID.PipeOutId, cbsize, ptr, len);
    


  52. 

  53.         if (bResult == FALSE)
    

  54.         {
    

  55.                 CloseDevice(&deviceData);
    

  56.                 result = 0;
    

  57.         }
    

  58.         else
    

  59.         {
    

  60.                 result = 1;
    

  61.         }
    


  62. 

  63.         return result;
    

  64. }
    


  65. 

  66. void Close()
    

  67. {
    

  68.         CloseDevice(&deviceData);
    

  69. }
USB.c
复制
  1. #include <stdio.h>
    

  2. #include "WUSB.h"
    


  3. 

  4. BOOL GetUSBDeviceSpeed(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pDeviceSpeed)
    

  5. {
    

  6.     if (!pDeviceSpeed || hDeviceHandle == INVALID_HANDLE_VALUE)
    

  7.     {
    

  8.         return FALSE;
    

  9.     }
    


  10. 

  11.     BOOL bResult = TRUE;
    


  12. 

  13.     ULONG length = sizeof(UCHAR);
    


  14. 

  15.     bResult = WinUsb_QueryDeviceInformation(hDeviceHandle, DEVICE_SPEED, &length, pDeviceSpeed);
    

  16.     if (!bResult)
    

  17.     {
    

  18.         printf("Error getting device speed: %d.\n", GetLastError());
    

  19.         goto done;
    

  20.     }
    


  21. 

  22.     if (*pDeviceSpeed == LowSpeed)
    

  23.     {
    

  24.         printf("Device speed: %d (Low speed).\n", *pDeviceSpeed);
    

  25.         goto done;
    

  26.     }
    

  27.     if (*pDeviceSpeed == FullSpeed)
    

  28.     {
    

  29.         printf("Device speed: %d (Full speed).\n", *pDeviceSpeed);
    

  30.         goto done;
    

  31.     }
    

  32.     if (*pDeviceSpeed == HighSpeed)
    

  33.     {
    

  34.         printf("Device speed: %d (High speed).\n", *pDeviceSpeed);
    

  35.         goto done;
    

  36.     }
    


  37. 

  38. done:
    

  39.     return bResult;
    

  40. }
    


  41. 

  42. BOOL QueryDeviceEndpoints(WINUSB_INTERFACE_HANDLE hDeviceHandle, PIPE_ID* pipeid)
    

  43. {
    

  44.     if (hDeviceHandle == INVALID_HANDLE_VALUE)
    

  45.     {
    

  46.         return FALSE;
    

  47.     }
    


  48. 

  49.     BOOL bResult = TRUE;
    


  50. 

  51.     USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
    

  52.     ZeroMemory(&InterfaceDescriptor, sizeof(USB_INTERFACE_DESCRIPTOR));
    


  53. 

  54.     WINUSB_PIPE_INFORMATION  Pipe;
    

  55.     ZeroMemory(&Pipe, sizeof(WINUSB_PIPE_INFORMATION));
    


  56. 


  57. 

  58.     bResult = WinUsb_QueryInterfaceSettings(hDeviceHandle, 0, &InterfaceDescriptor);
    


  59. 

  60.     if (bResult)
    

  61.     {
    

  62.         for (UCHAR index = 0; index < InterfaceDescriptor.bNumEndpoints; index++)
    

  63.         {
    

  64.             bResult = WinUsb_QueryPipe(hDeviceHandle, 0, index, &Pipe);
    


  65. 

  66.             if (bResult)
    

  67.             {
    

  68.                 if (Pipe.PipeType == UsbdPipeTypeControl)
    

  69.                 {
    

  70.                     printf("Endpoint index: %d Pipe type: %d Control Pipe ID: %d.\n", index, Pipe.PipeType, Pipe.PipeId);
    

  71.                 }
    

  72.                 if (Pipe.PipeType == UsbdPipeTypeIsochronous)
    

  73.                 {
    

  74.                     printf("Endpoint index: %d Pipe type: %d Isochronous Pipe ID: %d.\n", index, Pipe.PipeType, Pipe.PipeId);
    

  75.                 }
    

  76.                 if (Pipe.PipeType == UsbdPipeTypeBulk)
    

  77.                 {
    

  78.                     if (USB_ENDPOINT_DIRECTION_IN(Pipe.PipeId))
    

  79.                     {
    

  80.                         printf("Endpoint index: %d Pipe type: %d Bulk Pipe ID: %d.\n", index, UsbdPipeTypeBulk, Pipe.PipeId);
    

  81.                         pipeid->PipeInId = Pipe.PipeId;
    

  82.                     }
    

  83.                     if (USB_ENDPOINT_DIRECTION_OUT(Pipe.PipeId))
    

  84.                     {
    

  85.                         printf("Endpoint index: %d Pipe type: %d Bulk Pipe ID: %d.\n", index, Pipe.PipeType, Pipe.PipeId);
    

  86.                         pipeid->PipeOutId = Pipe.PipeId;
    

  87.                     }
    


  88. 

  89.                 }
    

  90.                 if (Pipe.PipeType == UsbdPipeTypeInterrupt)
    

  91.                 {
    

  92.                     printf("Endpoint index: %d Pipe type: %d Interrupt Pipe ID: %d.\n", index, Pipe.PipeType, Pipe.PipeId);
    

  93.                 }
    

  94.             }
    

  95.             else
    

  96.             {
    

  97.                 continue;
    

  98.             }
    

  99.         }
    

  100.     }
    


  101. 

  102. //done:
    

  103.     return bResult;
    

  104. }
    


  105. 

  106. BOOL SendDatatoDefaultEndpoint(WINUSB_INTERFACE_HANDLE hDeviceHandle)
    

  107. {
    

  108.     if (hDeviceHandle == INVALID_HANDLE_VALUE)
    

  109.     {
    

  110.         return FALSE;
    

  111.     }
    


  112. 

  113.     BOOL bResult = TRUE;
    


  114. 


  115. 

  116.     UCHAR bars = 0;
    


  117. 

  118.     WINUSB_SETUP_PACKET SetupPacket;
    

  119.     ZeroMemory(&SetupPacket, sizeof(WINUSB_SETUP_PACKET));
    

  120.     ULONG cbSent = 0;
    


  121. 

  122.     //Set bits to light alternate bars
    

  123.     for (short i = 0; i < 7; i += 2)
    

  124.     {
    

  125.         bars += 1 << i;
    

  126.     }
    


  127. 

  128.     //Create the setup packet
    

  129.     SetupPacket.RequestType = 0;
    

  130.     SetupPacket.Request = 0xD8;
    

  131.     SetupPacket.Value = 0;
    

  132.     SetupPacket.Index = 0;
    

  133.     SetupPacket.Length = sizeof(UCHAR);
    


  134. 

  135.     bResult = WinUsb_ControlTransfer(hDeviceHandle, SetupPacket, &bars, sizeof(UCHAR), &cbSent, 0);
    

  136.     if (!bResult)
    

  137.     {
    

  138.         goto done;
    

  139.     }
    


  140. 

  141.     printf("Data sent: %d \nActual data transferred: %d.\n", bars, cbSent);
    


  142. 


  143. 

  144. done:
    

  145.     return bResult;
    


  146. 

  147. }
    


  148. 

  149. BOOL WriteToBulkEndpoint(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG* pcbWritten, UCHAR* szBuffer, ULONG cbSize)
    

  150. {
    

  151.     if (hDeviceHandle == INVALID_HANDLE_VALUE || !pID || !pcbWritten)
    

  152.     {
    

  153.         return FALSE;
    

  154.     }
    


  155. 

  156.     BOOL bResult = TRUE;
    


  157. 

  158.     ULONG cbSent = 0;
    


  159. 

  160.     bResult = WinUsb_WritePipe(hDeviceHandle, *pID, szBuffer, cbSize, &cbSent, 0);
    

  161.     if (!bResult)
    

  162.     {
    

  163.         goto done;
    

  164.     }
    


  165. 

  166.     printf("Wrote to pipe %d: %s \nActual data transferred: %d.\n", *pID, szBuffer, cbSent);
    

  167.     *pcbWritten = cbSent;
    


  168. 


  169. 

  170. done:
    

  171.     return bResult;
    


  172. 

  173. }
    


  174. 

  175. BOOL ReadFromBulkEndpoint(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG cbSize, UCHAR* szBuffer)
    

  176. {
    

  177.     if (hDeviceHandle==INVALID_HANDLE_VALUE)
    

  178.     {
    

  179.         return FALSE;
    

  180.     }
    


  181. 

  182.     BOOL bResult = TRUE;
    

  183.     
    

  184.     ULONG cbRead = 0;
    


  185. 

  186.     bResult = WinUsb_ReadPipe(hDeviceHandle, *pID, szBuffer, cbSize, &cbRead, 0);
    

  187.     if(!bResult)
    

  188.     {
    

  189.         goto done;
    

  190.     }
    


  191. 

  192.     printf("Read from pipe %d: %s \nActual data read: %d.\n", *pID, szBuffer, cbRead);
    


  193. 


  194. 

  195. done:
    

  196.     LocalFree(szBuffer);
    

  197.     return bResult;
    


  198. 

  199. }
    


  200. 

  201. BOOL USB_Init(DEVICE_DATA *deviceData, PIPE_ID *PipeID)
    

  202. {
    

  203.     HRESULT hr;
    

  204.     BOOL noDevice;
    

  205.     BOOL bResult;
    

  206.     USB_DEVICE_DESCRIPTOR deviceDesc;
    

  207.     UCHAR DeviceSpeed;
    

  208.     ULONG lengthReceived;
    


  209. 

  210.     //
    

  211.     // Find a device connected to the system that has WinUSB installed using our
    

  212.     // INF
    

  213.     //
    

  214.     hr = OpenDevice(deviceData, &noDevice);
    


  215. 

  216.     if (FAILED(hr)) {
    


  217. 

  218.         if (noDevice) {
    


  219. 

  220.             wprintf(L"Device not connected or driver not installed\n");
    


  221. 

  222.         }
    

  223.         else {
    


  224. 

  225.             wprintf(L"Failed looking for device, HRESULT 0x%x\n", hr);
    

  226.         }
    


  227. 

  228.         return FALSE;
    

  229.     }
    


  230. 

  231.     //
    

  232.     // Get device descriptor
    

  233.     //
    

  234.     bResult = WinUsb_GetDescriptor(deviceData->WinusbHandle,
    

  235.         USB_DEVICE_DESCRIPTOR_TYPE,
    

  236.         0,
    

  237.         0,
    

  238.         (PBYTE)&deviceDesc,
    

  239.         sizeof(deviceDesc),
    

  240.         &lengthReceived);
    


  241. 

  242.     if (FALSE == bResult || lengthReceived != sizeof(deviceDesc)) {
    


  243. 

  244.         wprintf(L"Error among LastError %d or lengthReceived %d\n",
    

  245.             FALSE == bResult ? GetLastError() : 0,
    

  246.             lengthReceived);
    

  247.         CloseDevice(deviceData);
    

  248.         return FALSE;
    

  249.     }
    


  250. 

  251.     //
    

  252.     // Print a few parts of the device descriptor
    

  253.     //
    

  254.     wprintf(L"Device found: VID_%04X&PID_%04X; bcdUsb %04X\n",
    

  255.         deviceDesc.idVendor,
    

  256.         deviceDesc.idProduct,
    

  257.         deviceDesc.bcdUSB);
    


  258. 


  259. 

  260.     bResult = GetUSBDeviceSpeed(deviceData->WinusbHandle, &DeviceSpeed);
    

  261.     if (!bResult)
    

  262.     {
    

  263.         CloseDevice(deviceData);
    


  264. 

  265.         return FALSE;
    

  266.     }
    


  267. 

  268.     bResult = QueryDeviceEndpoints(deviceData->WinusbHandle, PipeID);
    

  269.     if (!bResult)
    

  270.     {
    

  271.         CloseDevice(deviceData);
    


  272. 

  273.         return FALSE;
    

  274.     }
    


  275. 

  276.     return TRUE;
    

  277. }

3.编译生成DLL文件：

修改工程属性：
11.PNG
编译生成DLL文件：
12.PNG
13.PNG
win_usb_dll.zip (784.96 KB, 下载次数: 7)
4.将生成的DLL与.h文件拷贝至matlab工作环境，打开matlab，切换工作环境至DLL所在文件夹中：
14.PNG
在命令行中使用如下函数，加载DLL与查看：
15.PNG
可以看到DLL加载成功。
编写m文件，简单测试回环通信：
复制
  1. clc
    


  2. 

  3. loadlibrary('USB_Dll.dll','USB_Dll.h')
    


  4. 

  5. state = calllib('USB_Dll','Connect');
    


  6. 

  7. if(state == 1)
    

  8.     disp('USB Connect')
    

  9.     
    

  10. str = [1 2 3 4 5]
    

  11.     len = 0;
    

  12.     wptr = libpointer('uint8Ptr',str);
    

  13.     n_ptr = libpointer('uint32Ptr',len);
    

  14.     state = calllib('USB_Dll','Write',wptr,n_ptr,length(str));
    

  15.     if(state == 0)
    

  16.         disp('USB error')
    

  17.     else
    

  18.         rptr = libpointer('uint8Ptr',zeros(1,64));
    

  19.         state = calllib('USB_Dll','Read',rptr,63);
    

  20.         if(state == 0)
    

  21.             disp('USB error')
    

  22.         else
    

  23.             char(rptr.Value)
    

  24.             calllib('USB_Dll','Close');
    

  25.             disp('USB Disonnect')
    

  26.         end
    

  27.     end
    

  28. else
    

  29.     disp('USB do not open')  
    

  30. end
一切正常：
16.PNG
19.PNG

5.总结
总体来说matlab对usb通信的支持力度远没有串口的大，为了实现usb通信就不得不实现混合编程，难度挺大的。这个例子只是简单的实现matlab与HC32F460的通信，但其有很多需要完善的地方。写这篇帖子仅仅起到抛砖引玉的作用，欢迎大家提出建议。

回复

收藏 举报

相关帖子
caigang13 发表于 2021-11-2 07:40 来自手机 | 显示全部楼层
学习了，谢谢分享。
回复

收藏 举报

sparrow054 发表于 2021-11-2 11:56 | 显示全部楼层
这个是不是要大大的赞啊，太牛了！
回复

收藏 举报

foxsbig 发表于 2022-1-21 16:55 | 显示全部楼层
这个厉害，MATLAB还能这样玩~~
回复

收藏 举报

duo点 发表于 2022-1-21 17:11 来自手机 | 显示全部楼层
厉害，非常赞
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

纪国圣

77

主题

407

帖子

5

粉丝
快速回复 在线客服 返回列表 返回顶部