1. 背景

• 由于项需求，在STM32F072中需实现5个CDC设备,折腾了很久分享出来，希望能帮助别人少踩一些坑.USB2.0全速,该款单片机支持8个输出和８个输入端点
• 
  

2.1 它是什么?需要使用到什么?

• 它是USB设备类型的一种,如U盘插入电脑时，电脑会知道其是Ｕ盘，是一个存储设备，那么它就属于USB MCU存储设备。USB协议中对设备进行了分类.它在stm32上叫虚拟串口设备，当将其链接电脑后，可以把它当成串口使用，如使用windows的串口工具打开它，设置波特率等等,这是我的理解。
  

• 它需要两个接口,三个端点
  

• InterFace 0:第一个接口,其包括一个端点,和Functional_Destriptcrs，该端点为控制接口(输入型端点(IN)),Functional_Destriptcrs则是一些描述符。先不管这个
• InterFace 1:第二接口，其包括两个端点,endpoint In 和endpoint out端点，IN为stm32数据输出端点，OUT为stm32数据输入端点,随便提下,在STM32　HAL库中，USB的IN，OUT是相对于主机而言的，如：上诉的IN是指主机的输入,主机的输入(IN)，对于设备来说就是OUT，数据的输出端点,IN OUT都是相对于主机而言
  
• 由此可见,正常情况下,一个CDC需要三个端点,其中两个IN端点,一个OUT端点
  
  

3.配置过程3.1 配置流程

• 在STM32CubeIDE的帮助下，生成一个CDC的代码,这里没什么坑，点几下就成功了，注意的是可能需要将Heap设置大一点
• 修改设备描述符
• 分配端点和修改配置描述符
• 分配PMA端点缓存地址
• 修改HAL库关于CDC部分函数接口的参数,以适配多CDC设备的情况
  

3.2 使用STM32CubeIDE生成一个CDC程序的代码

• 根据下面的文件操作即可，文件会介绍USBCDC的知识，在PDF的最后会说怎么使用cubeIDE配置,很简单没什么坑(注意的是可能需要将Heap设置大一点)
  

3.3 分配端点和修改配置描述符

• 此时问题来了,CDC要求3个端点，其中2个输入1个输出,而stm32F072只支持8个输入端点，8个输出端点,2x5>8,正常情况下是不够的，这里就需要将IN端口中的控制端口省略,也就是第一幅图中的Interface 0中的endpoint IN端点，不分配有效端点给它，在本款单片机中IN端点的有效范围(0x80-0x87),OUT(0x00-0x08)
  

1. #define CDC_IN_EP                                   0x81U  /* CDC*/
   
2. #define CDC_OUT_EP                                  0x01U  
   
3. #define CDC_CMD_EP                                  0x88U  //无效端点
   
4. 
   
5. #define CDC_IN_EP1                                   0x82U   /* CDC1*/
   
6. #define CDC_OUT_EP1                                  0x02U  
   
7. #define CDC_CMD_EP1                                  0x89U  //无效端点
   
8. 
   
9. #define CDC_IN_EP2                                   0x83U   /* CDC2*/
   
10. #define CDC_OUT_EP2                                  0x03U  
    
11. #define CDC_CMD_EP2                                  0x8AU  //无效端点
    
12. 
    
13. #define CDC_IN_EP3                                   0x84U   /* CDC3*/
    
14. #define CDC_OUT_EP3                                  0x04U  
    
15. #define CDC_CMD_EP3                                  0x8CU  //无效端点
    
16. 
    
17. #define CDC_IN_EP4                                   0x85U   /* CDC4*/
    
18. #define CDC_OUT_EP4                                  0x05U
    
19. #define CDC_CMD_EP4                                  0x8BU  //无效端点

复制代码

• 修改配置描述符号,这里面的内容就很多了，里面涉及到USB方方面面的属性和参数,其中USB_CDC_CONFIG_DESC_SIZ是该结构体的大小，记得修改，或者直接改为最大255。
  
• 配置描述符的结构如下:
  
  

1. 配置描述符
   
2. {
   
3.     配置描述符总概括(相当于预览:9字节)
   
4.     IAD描述符(标识接下来的接口属于一个设备，一个设备就一个IAD描述符)CDC
   
5.     {
   
6.         接口描述符1
   
7.         {
   
8.             其他描述符(ACM等)
   
9.             端点描述符(控制端点)
   
10.         }
    
11.         接口描述符2
    
12.         {
    
13.             端点描述符(IN)
    
14.             端点描述符(OUT)
    
15.         }
    
16.     }
    
17. 
    
18.     IAD描述符(标识接下来的接口属于一个设备，一个设备就一个IAD描述符)CDC1
    
19.     {
    
20.         接口描述符1
    
21.         {
    
22.             其他描述符(ACM等)
    
23.             端点描述符(控制端点)
    
24.         }
    
25.         接口描述符2
    
26.         {
    
27.             端点描述符(IN)
    
28.             端点描述符(OUT)
    
29.         }
    
30.     }
    
31. 
    
32.     IAD描述符(标识接下来的接口属于一个设备，一个设备就一个IAD描述符)CDC2
    
33.     {
    
34.         接口描述符1
    
35.         {
    
36.             其他描述符(ACM等)
    
37.             端点描述符(控制端点)
    
38.         }
    
39.         接口描述符2
    
40.         {
    
41.             端点描述符(IN)
    
42.             端点描述符(OUT)
    
43.         }
    
44.     }
    
45. 
    
46.     IAD描述符(标识接下来的接口属于一个设备，一个设备就一个IAD描述符)CDC3
    
47.     {
    
48.         接口描述符1
    
49.         {
    
50.             其他描述符(ACM等)
    
51.             端点描述符(控制端点)
    
52.         }
    
53.         接口描述符2
    
54.         {
    
55.             端点描述符(IN)
    
56.             端点描述符(OUT)
    
57.         }
    
58.     }
    
59. 
    
60.     IAD描述符(标识接下来的接口属于一个设备，一个设备就一个IAD描述符)CDC4
    
61.     {
    
62.         接口描述符1
    
63.         {
    
64.             其他描述符(ACM等)
    
65.             端点描述符(控制端点)
    
66.         }
    
67.         接口描述符2
    
68.         {
    
69.             端点描述符(IN)
    
70.             端点描述符(OUT)
    
71.         }
    
72.     }
    
73. }

复制代码

• 配置描述符如下,下面有些字段需要修改的，都用casojie标记了，CTRL+F搜索casojie就可以方便显示;
  

1. __ALIGN_BEGIN uint8_t USBD_CDC_CfgFSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
   
2. {
   
3.   /*Configuration Descriptor*/
   
4.   0x09,   /* bLength: Configuration Descriptor size */
   
5.   USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
   
6.   USB_CDC_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
   
7.   0x00,
   
8.   0x0A,   /* bNumInterfaces: 10 interface *///总接口大小，５个CDC*2=10=0x0A casojie
   
9.   0x01,   /* bConfigurationValue: Configuration value */
   
10.   0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
    
11.   0xC0,   /* bmAttributes: self powered */
    
12.   0x32,   /* MaxPower 0 mA */
    
13. 
    
14.   /*------------------------CDC0--------------------------------------------------8+9+5+5+7+9+7+7-*/
    
15.   // // // IAD  Interface Association Descriptor　//IAD描述符需要添加 casojie
    
16.   // 0x08,  // bLength: Interface Descriptor size //标识IAD描述符的长度,基本都是8,casojie
    
17.   // 0x0B,      // bDescriptorType: IAD            //不用管
    
18.   // 0x00,  // bFirstInterface                      //第一个接口的序号
    
19.   // 0x02,  // bInterfaceCount                      //本IDA的接口数量
    
20.   // 0x02,  // bFunctionClass: CDC                  //表明该IAD是一个CDC设备
    
21.   // 0x02,  // bFunctionSubClass                    //不用管
    
22.   // 0x01,  // bFunctionProtocol                    //控制协议等其他我也不懂，默认就行
    
23.   // 0x02,  // iFunction   
    
24. 
    
25. /*Interface Descriptor */
    
26.   0x09,   /* bLength: Interface Descriptor size */
    
27.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
    
28.   /* Interface descriptor type */
    
29.   0x00,   /* bInterfaceNumber: Number of Interface */   //接口编号，从0开始 casojie
    
30.   0x00,   /* bAlternateSetting: Alternate setting */
    
31.   0x01,   /* bNumEndpoints: One endpoints used */       //接口内有多少个端点被使用 1个 casojie
    
32.   0x02,   /* bInterfaceClass: Communication Interface Class */
    
33.   0x02,   /* bInterfaceSubClass: Abstract Control Model */
    
34.   0x01,   /* bInterfaceProtocol: Common AT commands */
    
35.   0x00,   /* iInterface: */
    
36. 
    
37.   // /*Header Functional Descriptor*/
    
38.   // 0x05,   /* bLength: Endpoint Descriptor size */
    
39.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
    
40.   // 0x00,   /* bDescriptorSubtype: Header Func Desc */
    
41.   // 0x10,   /* bcdCDC: spec release number */
    
42.   // 0x01,
    
43. 
    
44.   // /*Call Management Functional Descriptor*/
    
45.   // 0x05,   /* bFunctionLength */
    
46.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
    
47.   // 0x01,   /* bDescriptorSubtype: Call Management Func Desc */
    
48.   // 0x00,   /* bmCapabilities: D0+D1 */
    
49.   // 0x01,   /* bDataInterface: 1 */
    
50. 
    
51.   /*ACM Functional Descriptor*/
    
52.   0x04,   /* bFunctionLength */
    
53.   0x24,   /* bDescriptorType: CS_INTERFACE */
    
54.   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
    
55.   0x0F,   /* bmCapabilities */
    
56. 
    
57.   /*Union Functional Descriptor*/
    
58.   0x05,   /* bFunctionLength */
    
59.   0x24,   /* bDescriptorType: CS_INTERFACE */
    
60.   0x06,   /* bDescriptorSubtype: Union func desc */
    
61.   0x00,   /* bMasterInterface: Communication class interface */ //联合描述符,与IAD功能类似，标识哪两个接口是属于一个设备的casojie
    
62.   0x01,   /* bSlaveInterface0: Data Class Interface */  //与上面一样，上面是0,这里是1,标识0号，1号接口是属于一个CDC设备的 casojie
    
63. 
    
64.   /*Endpoint 2 Descriptor*/
    
65.   0x07,                           /* bLength: Endpoint Descriptor size *///控制端点描述符，虽然端点号是无效的，但是这个描述符不可省略
    
66.   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
    
67.   CDC_CMD_EP,                     /* bEndpointAddress */
    
68.   0x03,                           /* bmAttributes: Interrupt */
    
69.   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
    
70.   HIBYTE(CDC_CMD_PACKET_SIZE),
    
71.   0x10,                           /* bInterval: */
    
72.   /*---------------------------------------------------------------------------*/
    
73. 
    
74.   /*Data class interface descriptor*/   //第二个接口描述符 casojie
    
75.   0x09,   /* bLength: Endpoint Descriptor size */
    
76.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
    
77.   0x01,   /* bInterfaceNumber: Number of Interface */   //接口的序号，上一个接口是0，那这里就是1　casojie
    
78.   0x00,   /* bAlternateSetting: Alternate setting */
    
79.   0x02,   /* bNumEndpoints: Two endpoints used */       //标识此接口有两个端点(IN)(OUT) casojie
    
80.   0x0A,   /* bInterfaceClass: CDC */
    
81.   0x00,   /* bInterfaceSubClass: */
    
82.   0x00,   /* bInterfaceProtocol: */
    
83.   0x00,   /* iInterface: */
    
84. 
    
85.   /*Endpoint OUT Descriptor*/                       //OUT端点
    
86.   0x07,   /* bLength: Endpoint Descriptor size */
    
87.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
    
88.   CDC_OUT_EP,                        /* bEndpointAddress */
    
89.   0x02,                              /* bmAttributes: Bulk */
    
90.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
    
91.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
    
92.   0x00,                              /* bInterval: ignore for Bulk transfer */
    
93. 
    
94.   /*Endpoint IN Descriptor*/                        //IN端点
    
95.   0x07,   /* bLength: Endpoint Descriptor size */
    
96.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
    
97.   CDC_IN_EP,                         /* bEndpointAddress */
    
98.   0x02,                              /* bmAttributes: Bulk */
    
99.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
    
100.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
101.   0x00,                               /* bInterval: ignore for Bulk transfer */
     
102. 
     
103.   /*---------------------------------------------------------------------------*/
     
104.   // IAD  Interface Association Descriptor       //这里就是CDC1了,重复CDC0的配置过程，注意有些字段的序号 casojie
     
105.   // 0x08,  // bLength: Interface Descriptor size
     
106.   // 0x0B,      // bDescriptorType: IAD
     
107.   // 0x02,  // bFirstInterface                  //太多了，写不下去了，意思和第一个IDA一样的
     
108.   // 0x02,  // bInterfaceCount
     
109.   // 0x02,  // bFunctionClass: CDC
     
110.   // 0x02,  // bFunctionSubClass
     
111.   // 0x01,  // bFunctionProtocol
     
112.   // 0x02,  // iFunction
     
113. 
     
114. /*Interface Descriptor */
     
115.   0x09,   /* bLength: Interface Descriptor size */
     
116.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
     
117.   /* Interface descriptor type */
     
118.   0x02,   /* bInterfaceNumber: Number of Interface */
     
119.   0x00,   /* bAlternateSetting: Alternate setting */
     
120.   0x01,   /* bNumEndpoints: One endpoints used */
     
121.   0x02,   /* bInterfaceClass: Communication Interface Class */
     
122.   0x02,   /* bInterfaceSubClass: Abstract Control Model */
     
123.   0x01,   /* bInterfaceProtocol: Common AT commands */
     
124.   0x00,   /* iInterface: */
     
125. 
     
126.   // /*Header Functional Descriptor*/
     
127.   // 0x05,   /* bLength: Endpoint Descriptor size */
     
128.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
129.   // 0x00,   /* bDescriptorSubtype: Header Func Desc */
     
130.   // 0x10,   /* bcdCDC: spec release number */
     
131.   // 0x01,
     
132. 
     
133.   // /*Call Management Functional Descriptor*/
     
134.   // 0x05,   /* bFunctionLength */
     
135.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
136.   // 0x01,   /* bDescriptorSubtype: Call Management Func Desc */
     
137.   // 0x00,   /* bmCapabilities: D0+D1 */
     
138.   // 0x01,   /* bDataInterface: 1 */
     
139. 
     
140.   /*ACM Functional Descriptor*/
     
141.   0x04,   /* bFunctionLength */
     
142.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
143.   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
     
144.   0x0F,   /* bmCapabilities */
     
145. 
     
146.   /*Union Functional Descriptor*/
     
147.   0x05,   /* bFunctionLength */
     
148.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
149.   0x06,   /* bDescriptorSubtype: Union func desc */
     
150.   0x02,   /* bMasterInterface: Communication class interface */
     
151.   0x03,   /* bSlaveInterface0: Data Class Interface */
     
152. 
     
153.   // /*Endpoint 2 Descriptor*/
     
154.   0x07,                           /* bLength: Endpoint Descriptor size */
     
155.   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
     
156.   CDC_CMD_EP1,                     /* bEndpointAddress */
     
157.   0x03,                           /* bmAttributes: Interrupt */
     
158.   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
     
159.   HIBYTE(CDC_CMD_PACKET_SIZE),
     
160.   0x10,                           /* bInterval: */
     
161.   /*---------------------------------------------------------------------------*/
     
162. 
     
163.   /*Data class interface descriptor*/
     
164.   0x09,   /* bLength: Endpoint Descriptor size */
     
165.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
     
166.   0x03,   /* bInterfaceNumber: Number of Interface */
     
167.   0x00,   /* bAlternateSetting: Alternate setting */
     
168.   0x02,   /* bNumEndpoints: Two endpoints used */
     
169.   0x0A,   /* bInterfaceClass: CDC */
     
170.   0x00,   /* bInterfaceSubClass: */
     
171.   0x00,   /* bInterfaceProtocol: */
     
172.   0x00,   /* iInterface: */
     
173. 
     
174.   /*Endpoint OUT Descriptor*/
     
175.   0x07,   /* bLength: Endpoint Descriptor size */
     
176.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
177.   CDC_OUT_EP1,                        /* bEndpointAddress */
     
178.   0x02,                              /* bmAttributes: Bulk */
     
179.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
180.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
181.   0x00,                              /* bInterval: ignore for Bulk transfer */
     
182. 
     
183.   /*Endpoint IN Descriptor*/
     
184.   0x07,   /* bLength: Endpoint Descriptor size */
     
185.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
186.   CDC_IN_EP1,                         /* bEndpointAddress */
     
187.   0x02,                              /* bmAttributes: Bulk */
     
188.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
189.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
190.   0x00,                               /* bInterval: ignore for Bulk transfer */
     
191.   /*---------------------------------------------------------------------------*/
     
192.   // IAD  Interface Association Descriptor
     
193.   // 0x08,  // bLength: Interface Descriptor size
     
194.   // 0x0B,      // bDescriptorType: IAD
     
195.   // 0x04,  // bFirstInterface
     
196.   // 0x02,  // bInterfaceCount
     
197.   // 0x02,  // bFunctionClass: CDC
     
198.   // 0x02,  // bFunctionSubClass
     
199.   // 0x01,  // bFunctionProtocol
     
200.   // 0x02,  // iFunction
     
201. 
     
202. /*Interface Descriptor */
     
203.   0x09,   /* bLength: Interface Descriptor size */
     
204.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
     
205.   /* Interface descriptor type */
     
206.   0x04,   /* bInterfaceNumber: Number of Interface */
     
207.   0x00,   /* bAlternateSetting: Alternate setting */
     
208.   0x01,   /* bNumEndpoints: One endpoints used */
     
209.   0x02,   /* bInterfaceClass: Communication Interface Class */
     
210.   0x02,   /* bInterfaceSubClass: Abstract Control Model */
     
211.   0x01,   /* bInterfaceProtocol: Common AT commands */
     
212.   0x00,   /* iInterface: */
     
213. 
     
214.   // /*Header Functional Descriptor*/
     
215.   // 0x05,   /* bLength: Endpoint Descriptor size */
     
216.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
217.   // 0x00,   /* bDescriptorSubtype: Header Func Desc */
     
218.   // 0x10,   /* bcdCDC: spec release number */
     
219.   // 0x01,
     
220. 
     
221.   // /*Call Management Functional Descriptor*/
     
222.   // 0x05,   /* bFunctionLength */
     
223.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
224.   // 0x01,   /* bDescriptorSubtype: Call Management Func Desc */
     
225.   // 0x00,   /* bmCapabilities: D0+D1 */
     
226.   // 0x01,   /* bDataInterface: 1 */
     
227. 
     
228.   /*ACM Functional Descriptor*/
     
229.   0x04,   /* bFunctionLength */
     
230.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
231.   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
     
232.   0x0F,   /* bmCapabilities */
     
233. 
     
234.   /*Union Functional Descriptor*/
     
235.   0x05,   /* bFunctionLength */
     
236.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
237.   0x06,   /* bDescriptorSubtype: Union func desc */
     
238.   0x04,   /* bMasterInterface: Communication class interface */
     
239.   0x05,   /* bSlaveInterface0: Data Class Interface */
     
240. 
     
241.   // /*Endpoint 2 Descriptor*/
     
242.   0x07,                           /* bLength: Endpoint Descriptor size */
     
243.   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
     
244.   CDC_CMD_EP2,                     /* bEndpointAddress */
     
245.   0x03,                           /* bmAttributes: Interrupt */
     
246.   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
     
247.   HIBYTE(CDC_CMD_PACKET_SIZE),
     
248.   0x10,                           /* bInterval: */
     
249.   /*---------------------------------------------------------------------------*/
     
250. 
     
251.   /*Data class interface descriptor*/
     
252.   0x09,   /* bLength: Endpoint Descriptor size */
     
253.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
     
254.   0x05,   /* bInterfaceNumber: Number of Interface */
     
255.   0x00,   /* bAlternateSetting: Alternate setting */
     
256.   0x02,   /* bNumEndpoints: Two endpoints used */
     
257.   0x0A,   /* bInterfaceClass: CDC */
     
258.   0x00,   /* bInterfaceSubClass: */
     
259.   0x00,   /* bInterfaceProtocol: */
     
260.   0x00,   /* iInterface: */
     
261. 
     
262.   /*Endpoint OUT Descriptor*/
     
263.   0x07,   /* bLength: Endpoint Descriptor size */
     
264.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
265.   CDC_OUT_EP2,                        /* bEndpointAddress */
     
266.   0x02,                              /* bmAttributes: Bulk */
     
267.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
268.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
269.   0x00,                              /* bInterval: ignore for Bulk transfer */
     
270. 
     
271.   /*Endpoint IN Descriptor*/
     
272.   0x07,   /* bLength: Endpoint Descriptor size */
     
273.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
274.   CDC_IN_EP2,                         /* bEndpointAddress */
     
275.   0x02,                              /* bmAttributes: Bulk */
     
276.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
277.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
278.   0x00,                               /* bInterval: ignore for Bulk transfer */
     
279. 
     
280.   /*---------------------------------------------------------------------------*/
     
281.   // IAD  Interface Association Descriptor
     
282.   // 0x08,  // bLength: Interface Descriptor size
     
283.   // 0x0B,      // bDescriptorType: IAD
     
284.   // 0x06,  // bFirstInterface
     
285.   // 0x02,  // bInterfaceCount
     
286.   // 0x02,  // bFunctionClass: CDC
     
287.   // 0x02,  // bFunctionSubClass
     
288.   // 0x01,  // bFunctionProtocol
     
289.   // 0x02,  // iFunction
     
290. 
     
291. /*Interface Descriptor */
     
292.   0x09,   /* bLength: Interface Descriptor size */
     
293.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
     
294.   /* Interface descriptor type */
     
295.   0x06,   /* bInterfaceNumber: Number of Interface */
     
296.   0x00,   /* bAlternateSetting: Alternate setting */
     
297.   0x01,   /* bNumEndpoints: One endpoints used */
     
298.   0x02,   /* bInterfaceClass: Communication Interface Class */
     
299.   0x02,   /* bInterfaceSubClass: Abstract Control Model */
     
300.   0x01,   /* bInterfaceProtocol: Common AT commands */
     
301.   0x00,   /* iInterface: */
     
302. 
     
303.   // /*Header Functional Descriptor*/
     
304.   // 0x05,   /* bLength: Endpoint Descriptor size */
     
305.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
306.   // 0x00,   /* bDescriptorSubtype: Header Func Desc */
     
307.   // 0x10,   /* bcdCDC: spec release number */
     
308.   // 0x01,
     
309. 
     
310.   // /*Call Management Functional Descriptor*/
     
311.   // 0x05,   /* bFunctionLength */
     
312.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
313.   // 0x01,   /* bDescriptorSubtype: Call Management Func Desc */
     
314.   // 0x00,   /* bmCapabilities: D0+D1 */
     
315.   // 0x01,   /* bDataInterface: 1 */
     
316. 
     
317.   /*ACM Functional Descriptor*/
     
318.   0x04,   /* bFunctionLength */
     
319.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
320.   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
     
321.   0x0F,   /* bmCapabilities */
     
322. 
     
323.   /*Union Functional Descriptor*/
     
324.   0x05,   /* bFunctionLength */
     
325.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
326.   0x06,   /* bDescriptorSubtype: Union func desc */
     
327.   0x06,   /* bMasterInterface: Communication class interface */
     
328.   0x07,   /* bSlaveInterface0: Data Class Interface */
     
329. 
     
330.   /*Endpoint 2 Descriptor*/
     
331.   0x07,                           /* bLength: Endpoint Descriptor size */
     
332.   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
     
333.   CDC_CMD_EP3,                     /* bEndpointAddress */
     
334.   0x03,                           /* bmAttributes: Interrupt */
     
335.   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
     
336.   HIBYTE(CDC_CMD_PACKET_SIZE),
     
337.   0x10,                           /* bInterval: */
     
338.   /*---------------------------------------------------------------------------*/
     
339. 
     
340.   /*Data class interface descriptor*/
     
341.   0x09,   /* bLength: Endpoint Descriptor size */
     
342.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
     
343.   0x07,   /* bInterfaceNumber: Number of Interface */
     
344.   0x00,   /* bAlternateSetting: Alternate setting */
     
345.   0x02,   /* bNumEndpoints: Two endpoints used */
     
346.   0x0A,   /* bInterfaceClass: CDC */
     
347.   0x00,   /* bInterfaceSubClass: */
     
348.   0x00,   /* bInterfaceProtocol: */
     
349.   0x00,   /* iInterface: */
     
350. 
     
351.   /*Endpoint OUT Descriptor*/
     
352.   0x07,   /* bLength: Endpoint Descriptor size */
     
353.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
354.   CDC_OUT_EP3,                        /* bEndpointAddress */
     
355.   0x02,                              /* bmAttributes: Bulk */
     
356.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
357.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
358.   0x00,                              /* bInterval: ignore for Bulk transfer */
     
359. 
     
360.   /*Endpoint IN Descriptor*/
     
361.   0x07,   /* bLength: Endpoint Descriptor size */
     
362.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
363.   CDC_IN_EP3,                         /* bEndpointAddress */
     
364.   0x02,                              /* bmAttributes: Bulk */
     
365.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
366.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
367.   0x00,                               /* bInterval: ignore for Bulk transfer */
     
368. 
     
369. //   /*---------------------------------------------------------------------------*/
     
370. //   // IAD  Interface Association Descriptor
     
371. //   // 0x08,   // bLength: Interface Descriptor size
     
372. //   // 0x0B,       // bDescriptorType: IAD
     
373. //   // 0x08,   // bFirstInterface
     
374. //   // 0x02,   // bInterfaceCount
     
375. //   // 0x02,   // bFunctionClass: CDC
     
376. //   // 0x02,   // bFunctionSubClass
     
377. //   // 0x01,   // bFunctionProtocol
     
378. //   // 0x02,   // iFunction
     
379. 
     
380. /*Interface Descriptor */
     
381.   0x09,   /* bLength: Interface Descriptor size */
     
382.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
     
383.   /* Interface descriptor type */
     
384.   0x08,   /* bInterfaceNumber: Number of Interface */
     
385.   0x00,   /* bAlternateSetting: Alternate setting */
     
386.   0x01,   /* bNumEndpoints: One endpoints used */
     
387.   0x02,   /* bInterfaceClass: Communication Interface Class */
     
388.   0x02,   /* bInterfaceSubClass: Abstract Control Model */
     
389.   0x01,   /* bInterfaceProtocol: Common AT commands */
     
390.   0x00,   /* iInterface: */
     
391. 
     
392.   // /*Header Functional Descriptor*/
     
393.   // 0x05,   /* bLength: Endpoint Descriptor size */
     
394.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
395.   // 0x00,   /* bDescriptorSubtype: Header Func Desc */
     
396.   // 0x10,   /* bcdCDC: spec release number */
     
397.   // 0x01,
     
398. 
     
399.   // /*Call Management Functional Descriptor*/
     
400.   // 0x05,   /* bFunctionLength */
     
401.   // 0x24,   /* bDescriptorType: CS_INTERFACE */
     
402.   // 0x01,   /* bDescriptorSubtype: Call Management Func Desc */
     
403.   // 0x00,   /* bmCapabilities: D0+D1 */
     
404.   // 0x01,   /* bDataInterface: 1 */
     
405. 
     
406.   /*ACM Functional Descriptor*/
     
407.   0x04,   /* bFunctionLength */
     
408.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
409.   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
     
410.   0x0F,   /* bmCapabilities */
     
411. 
     
412.   /*Union Functional Descriptor*/
     
413.   0x05,   /* bFunctionLength */
     
414.   0x24,   /* bDescriptorType: CS_INTERFACE */
     
415.   0x06,   /* bDescriptorSubtype: Union func desc */
     
416.   0x08,   /* bMasterInterface: Communication class interface */
     
417.   0x09,   /* bSlaveInterface0: Data Class Interface */
     
418. 
     
419.   /*Endpoint 2 Descriptor*/
     
420.   0x07,                           /* bLength: Endpoint Descriptor size */
     
421.   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
     
422.   CDC_CMD_EP4,                     /* bEndpointAddress */
     
423.   0x03,                           /* bmAttributes: Interrupt */
     
424.   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
     
425.   HIBYTE(CDC_CMD_PACKET_SIZE),
     
426.   0x10,                           /* bInterval: */
     
427.   /*---------------------------------------------------------------------------*/
     
428.   /*
     
429.   /*Data class interface descriptor*/
     
430.   0x09,   /* bLength: Endpoint Descriptor size */
     
431.   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
     
432.   0x09,   /* bInterfaceNumber: Number of Interface */
     
433.   0x00,   /* bAlternateSetting: Alternate setting */
     
434.   0x02,   /* bNumEndpoints: Two endpoints used */
     
435.   0x0A,   /* bInterfaceClass: CDC */
     
436.   0x00,   /* bInterfaceSubClass: */
     
437.   0x00,   /* bInterfaceProtocol: */
     
438.   0x00,   /* iInterface: */
     
439. 
     
440.   /*Endpoint OUT Descriptor*/
     
441.   0x07,   /* bLength: Endpoint Descriptor size */
     
442.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
443.   CDC_OUT_EP4,                        /* bEndpointAddress */
     
444.   0x02,                              /* bmAttributes: Bulk */
     
445.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
446.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
447.   0x00,                              /* bInterval: ignore for Bulk transfer */
     
448. 
     
449.   /*Endpoint IN Descriptor*/
     
450.   0x07,   /* bLength: Endpoint Descriptor size */
     
451.   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
     
452.   CDC_IN_EP4,                         /* bEndpointAddress */
     
453.   0x02,                              /* bmAttributes: Bulk */
     
454.   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
     
455.   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     
456.   0x00                               /* bInterval: ignore for Bulk transfer */
     
457. }

复制代码

• 为什么上面有些描述符被注释掉了？
• 配置5个CDC如果描述符都写上了，这个结构体就超过了255个字节大小，超过了USB2.0最大配置描述符长度
• 在我的项目中，IAD和联合描述符(/Union Functional Descriptor/)功能一样,我这里注释IAD描述符,不会影响USB,但在windows平台下，它认的是IAD描述符，这个时候就可以注释联合描述符,打开IAD描述符,总之，省略一些非必要描述，减少长度
  
• 这里的坑很多很多，需要很耐心，配错一个字段，千奇百怪的问题就来了
  
  

3.4 配置PMA---USB硬件缓存

• 这里又有坑了，我把我知道的都说出
  

3.4.1 PMA是啥？

• 此部分感谢一个大佬的帖子，理解来源与它
• 这个PMA的作用就是USB设备模块用来实现MCU与主机进行数据通信的一个专门的数据缓冲区，我们称之为USB硬件缓冲区。说得具体点就是USB模块把来自主机的数据接收进来后先放到PMA，然后再被拷贝到用户数据缓存区；或者MCU要发送到主机的数据，先从用户数据缓存区拷贝**MA，再通过USB模块负责发送给主机。
  

3.4.2 5个CDC的PMA怎么配置?

• 啥也不说，先上代码
  

1. u_int16_t ep_addR=0x70; //起始分配地址: 这里是大坑 casojie
   
2. u_int8_t ep_addr_size=64;
   
3. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x00 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;   //此端点是用于USB枚举和基本的通信使用，默认就有，且不可省去
   
4. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x80 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;
   
5. /* USER CODE END EndPoint_Configuration */
   
6. //CDC0　每个端点都分配了64B
   
7. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;
   
8. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;
   
9. 
   
10. //CDC1                                                                                                //+5
    
11. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP1, PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;  //192 258
    
12. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP1 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;    //272 2A8
    
13. 
    
14. //CDC2
    
15. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP2 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size; //0x270
    
16. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP2 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;//0x2C0
    
17. 
    
18. //CDC3
    
19. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP3, PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;  //192 258 0x1E0
    
20. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP3 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;
    
21. 
    
22. //CDC4
    
23. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP4, PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;  
    
24. HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP4 , PCD_SNG_BUF, ep_addR);ep_addR+=ep_addr_size;

复制代码

• PMA图(我理解的)
  

• 在PMA的开头部分，是用于记录信息的，这些信息就是：端点缓存区的起始地址：说这简单点，里面写了端点0的缓存区的起始地址是X，端点1的缓冲区起始地址是Y等等
• 由此可见，当使用的端点数量比较多时，信息记录区索要的空间就比较大，反之，就小，需要动态调整
• 由大佬的帖子可知，记录一个端点的起始地址信息需要8字节,那么我们五个CDC，则5x2(IN,OUT)=10,再加上0x80 ,0x00端点，一共12个.则12*8=76字节
• 因此,端点(0x00)分配的地址需要往后偏移,默认的不行,如这次需要76字节的大小,换成16进制,0x4C,我设置了0x70>0x4C,默认的太小了,会导致部分信息记录区被端点0的数据覆盖，而导致部分端点无法使用.
  

4.修改USB初始化代码，新增对新端点的初始化

1. static uint8_t  USBD_CDC_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   
2. {
   
3.   uint8_t ret = 0U;
   
4.   USBD_CDC_HandleTypeDef   *hcdc;
   
5. 
   
6.   if (pdev->dev_speed == USBD_SPEED_HIGH)
   
7.   {
   
8.     /* Open EP IN */
   
9.     USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK,
   
10.                    CDC_DATA_HS_IN_PACKET_SIZE);
    
11. 
    
12.     pdev->ep_in[CDC_IN_EP & 0xFU].is_used = 1U;
    
13. 
    
14.     /* Open EP OUT */
    
15.     USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK,
    
16.                    CDC_DATA_HS_OUT_PACKET_SIZE);
    
17. 
    
18.     pdev->ep_out[CDC_OUT_EP & 0xFU].is_used = 1U;
    
19. 
    
20.   }
    
21.   else
    
22.   {
    
23.     /* Open EP IN */
    
24.      USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK,
    
25.                    CDC_DATA_FS_IN_PACKET_SIZE);
    
26. 
    
27.      pdev->ep_in[CDC_IN_EP & 0xFU].is_used = 1U;
    
28. 
    
29.     /* Open EP OUT */
    
30.      USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK,
    
31.                    CDC_DATA_FS_OUT_PACKET_SIZE);
    
32. 
    
33.      pdev->ep_out[CDC_OUT_EP & 0xFU].is_used = 1U;
    
34. 
    
35. 
    
36.         /* Open EP IN */
    
37.      USBD_LL_OpenEP(pdev, CDC_IN_EP1, USBD_EP_TYPE_BULK,
    
38.                    CDC_DATA_FS_IN_PACKET_SIZE);
    
39. 
    
40.      pdev->ep_in[CDC_IN_EP1 & 0xFU].is_used = 1U;
    
41. 
    
42.     /* Open EP OUT */
    
43.      USBD_LL_OpenEP(pdev, CDC_OUT_EP1, USBD_EP_TYPE_BULK,
    
44.                    CDC_DATA_FS_OUT_PACKET_SIZE);
    
45. 
    
46.      pdev->ep_out[CDC_OUT_EP1 & 0xFU].is_used = 1U;
    
47. 
    
48. 
    
49. 
    
50. //--------------------------------------------------------------------
    
51.        /* Open EP IN */
    
52.      USBD_LL_OpenEP(pdev, CDC_IN_EP2, USBD_EP_TYPE_BULK,
    
53.                    CDC_DATA_FS_IN_PACKET_SIZE);
    
54. 
    
55.     pdev->ep_in[CDC_IN_EP2 & 0xFU].is_used = 1U;
    
56. 
    
57.     /* Open EP OUT */
    
58.     USBD_LL_OpenEP(pdev, CDC_OUT_EP2, USBD_EP_TYPE_BULK,
    
59.                    CDC_DATA_FS_OUT_PACKET_SIZE);
    
60. 
    
61.     pdev->ep_out[CDC_OUT_EP2 & 0xFU].is_used = 1U;
    
62. 
    
63. 
    
64.    //-------------------------5---------------------
    
65.            /* Open EP IN */
    
66.     USBD_LL_OpenEP(pdev, CDC_IN_EP3, USBD_EP_TYPE_BULK,
    
67.                    CDC_DATA_FS_IN_PACKET_SIZE);
    
68. 
    
69.     pdev->ep_in[CDC_IN_EP3 & 0xFU].is_used = 1U;
    
70. 
    
71.     /* Open EP OUT */
    
72.     USBD_LL_OpenEP(pdev, CDC_OUT_EP3, USBD_EP_TYPE_BULK,
    
73.                    CDC_DATA_FS_OUT_PACKET_SIZE);
    
74. 
    
75.     pdev->ep_out[CDC_OUT_EP3 & 0xFU].is_used = 1U;
    
76. 
    
77.     //-------------------------5---------------------
    
78. 
    
79.            /* Open EP IN */
    
80.     USBD_LL_OpenEP(pdev, CDC_IN_EP4, USBD_EP_TYPE_BULK,
    
81.                    CDC_DATA_FS_IN_PACKET_SIZE);
    
82. 
    
83.     pdev->ep_in[CDC_IN_EP4 & 0xFU].is_used = 1U;
    
84. 
    
85.     /* Open EP OUT */
    
86.     USBD_LL_OpenEP(pdev, CDC_OUT_EP4, USBD_EP_TYPE_BULK,
    
87.                    CDC_DATA_FS_OUT_PACKET_SIZE);
    
88. 
    
89.     pdev->ep_out[CDC_OUT_EP4 & 0xFU].is_used = 1U;
    
90. 
    
91.   }
    
92.   /* Open Command IN EP *///控制端口无效，不要取消注释
    
93. //  USBD_LL_OpenEP(pdev, CDC_CMD_EP, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE);
    
94. //  pdev->ep_in[CDC_CMD_EP & 0xFU].is_used = 1U;
    
95. 
    
96. 
    
97. //   USBD_LL_OpenEP(pdev, CDC_CMD_EP1, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE);
    
98. //   pdev->ep_in[CDC_CMD_EP1 & 0xFU].is_used = 1U;
    
99. 
    
100. 
     
101. //     USBD_LL_OpenEP(pdev, CDC_CMD_EP2, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE);
     
102. //   pdev->ep_in[CDC_CMD_EP2 & 0xFU].is_used = 1U;
     
103. 
     
104. 
     
105.   //   USBD_LL_OpenEP(pdev, CDC_CMD_EP3, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE);
     
106.   // pdev->ep_in[CDC_CMD_EP3 & 0xFU].is_used = 1U;
     
107. 
     
108.   pdev->pClassData = USBD_malloc(sizeof(USBD_CDC_HandleTypeDef));
     
109. 
     
110.   if (pdev->pClassData == NULL)
     
111.   {
     
112.     ret = 1U;
     
113.   }
     
114.   else
     
115.   {
     
116.     hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
     
117. 
     
118.     /* Init  physical Interface components */
     
119.     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init();
     
120. 
     
121.     /* Init Xfer states */
     
122.     hcdc->TxState = 0U;
     
123.     hcdc->RxState = 0U;
     
124. 
     
125.     if (pdev->dev_speed == USBD_SPEED_HIGH)
     
126.     {
     
127.       /* Prepare Out endpoint to receive next packet */
     
128.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer,
     
129.                              CDC_DATA_HS_OUT_PACKET_SIZE);
     
130.     }
     
131.     else
     
132.     {
     
133.       /* Prepare Out endpoint to receive next packet */
     
134.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer,
     
135.                              CDC_DATA_FS_OUT_PACKET_SIZE);
     
136. 
     
137.                                    /* Prepare Out endpoint to receive next packet */
     
138.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP1, hcdc->RxBuffer,
     
139.                              CDC_DATA_FS_OUT_PACKET_SIZE);
     
140. 
     
141.                                    /* Prepare Out endpoint to receive next packet */
     
142.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP2, hcdc->RxBuffer,
     
143.                              CDC_DATA_FS_OUT_PACKET_SIZE);
     
144. 
     
145.                                    /* Prepare Out endpoint to receive next packet */
     
146.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP3, hcdc->RxBuffer,
     
147.                              CDC_DATA_FS_OUT_PACKET_SIZE);
     
148. 
     
149.                                                              /* Prepare Out endpoint to receive next packet */
     
150.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP4, hcdc->RxBuffer,
     
151.                              CDC_DATA_FS_OUT_PACKET_SIZE);
     
152. 
     
153.       USBD_LL_PrepareReceive(pdev, CDC_OUT_EP5, hcdc->RxBuffer,
     
154.                             CDC_DATA_FS_OUT_PACKET_SIZE);
     
155.     }
     
156.   }
     
157.   return ret;
     
158. }

复制代码

5.修改HAL默认USB CDC相关接口函数

• 现在是多CDC的状况了,但默认的HAL库的函数均只是针对一个CDC的情况，我们需要将端口的参数引出来
• USBD_CDC_DataOut:USB接收函数回调，修改提供端口参数
• CDC_Receive_FS(uint8_t *Buf, uint32_t *Len):USB CDC接收函数
• CDC_Transmit_FS(uint8_t* Buf, uint16_t Len):USB CDC发送函数
• USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev)
• USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)
  

---

• 先说说这几个函数的关系:CDC_Transmit_FS---调用--->USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev)
• USBD_CDC_DataOut(数据接收回调)---调用--->CDC_Receive_FS
  

---

CDC_Receive_FS(uint8_t *Buf, uint32_t *Len)修改为CDC_Receive_FS(uint8_t* Buf, uint32_t *Len,uint8_t epnum):　此后所有OUT端点来的数据都将进入此函数,可通过参数epnum区分

1. static uint8_t  USBD_CDC_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
   
2. {
   
3.   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   
4. 
   
5.   /* Get the received data length */
   
6.   hcdc->RxLength = USBD_LL_GetRxDataSize(pdev, epnum);
   
7.   /* USB data will be immediately processed, this allow next USB traffic being
   
8.   NAKed till the end of the application Xfer */
   
9.   // printf("USBD_CDC_DataOut.1294:Len:%d :EP:%02X\n",hcdc->RxLength,epnum);
   
10.   if (pdev->pClassData != NULL)
    
11.   {
    
12.     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength,epnum);//此处修改，加入端点，相关的函数声明也跟这这样改
    
13.     return USBD_OK;
    
14.   }
    
15. 
    
16.   else
    
17.   {
    
18.     return USBD_FAIL;
    
19.   }
    
20. }

复制代码

---

• CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)该为CDC_Transmit_FS(uint8_t* Buf, uint16_t Len,uint8_t epnum):只是增加一个参数，函数体不用动
  

1. uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len,uint8_t epnum)
   
2. {
   
3.   uint8_t result = USBD_OK;
   
4.   /* USER CODE BEGIN 7 */
   
5.   USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*)hUsbDeviceFS_CDC.pClassData;
   
6.   if (hcdc->TxState != 0){
   
7.     return USBD_BUSY;
   
8.   }
   
9.   USBD_CDC_SetTxBuffer(&hUsbDeviceFS_CDC, Buf, Len);
   
10.   result = USBD_CDC_TransmitPacket(&hUsbDeviceFS_CDC,epnum);    //将epnum的端点传到这个函数，这个函数也需要改
    
11.   /* USER CODE END 7 */
    
12.   return result;
    
13. }

复制代码

• USBD_CDC_TransmitPacket的修改
  

1. uint8_t  USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev,uint8_t epnum)
   
2. {
   
3.   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   
4. 
   
5.   if (pdev->pClassData != NULL)
   
6.   {
   
7.     if (hcdc->TxState == 0U)
   
8.     {
   
9.       /* Tx Transfer in progress */
   
10.       hcdc->TxState = 1U;
    
11. 
    
12.       /* Update the packet total length */
    
13.       pdev->ep_in[epnum & 0xFU].total_length = hcdc->TxLength;//将原本的CDC_IN_EP更改为我们传入的端点
    
14.       /* Transmit next packet */
    
15.       USBD_LL_Transmit(pdev, epnum, hcdc->TxBuffer,
    
16.                        (uint16_t)hcdc->TxLength);//此处也是
    
17. 
    
18.       return USBD_OK;
    
19.     }
    
20.     else
    
21.     {
    
22.       return USBD_BUSY;
    
23.     }
    
24.   }
    
25.   else
    
26.   {
    
27.     return USBD_FAIL;
    
28.   }
    
29. }

复制代码

---

该函数的作用:当端口接收一包数据后，需要执行此函数来接收下一包数据，简单的说:告诉主机我可以接收下一包数据了

1. uint8_t  USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev,uint8_t epnum)
   
2. {
   
3.   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   
4. 
   
5.   /* Suspend or Resume USB Out process */
   
6.   if (pdev->pClassData != NULL)
   
7.   {
   
8.     if (pdev->dev_speed == USBD_SPEED_HIGH)
   
9.     {
   
10.       /* Prepare Out endpoint to receive next packet */
    
11.       USBD_LL_PrepareReceive(pdev,
    
12.                              CDC_OUT_EP,
    
13.                              hcdc->RxBuffer,
    
14.                              CDC_DATA_HS_OUT_PACKET_SIZE);
    
15.     }
    
16.     else
    
17.     {
    
18.       /* Prepare Out endpoint to receive next packet */
    
19.       USBD_LL_PrepareReceive(pdev,
    
20.                              epnum,
    
21.                              hcdc->RxBuffer,
    
22.                              CDC_DATA_FS_OUT_PACKET_SIZE);
    
23.     }
    
24.     return USBD_OK;
    
25.   }
    
26.   else
    
27.   {
    
28.     return USBD_FAIL;
    
29.   }
    
30. }

复制代码

对以后而言，我们就使用CDC_Receive_FS(uint8_t* Buf, uint32_t *Len,uint8_t epnum)和CDC_Transmit_FS(uint8_t* Buf, uint16_t Len,uint8_t epnum) 向CDCx发送数据，就填写CDCx的IN端口 * 接收CDCx数据时，CDC_Receive_FS函数会传入该数据来源(OUT)端口,就可知道哪个CDCx了

6.后续

• 此时就完成了，不过不排除有些深层的问题。
• 如:当五个CDC同时在Read时,其中一个close,有可能会导致其他四个都无法再Read出数据，需要重新Open,但在电脑的深度depin系统上并没有这个问题,在项目中的板子上就有，希望大佬们提供下线索。感激不尽
  

转载自：casojie