1 前言
$ b& q/ b8 u) A4 s+ u在向客户推 STM32F4 芯片的时候，客户反馈使用 CDC 类无法发送 64 个字节，于是通过深入研究问题，发现问题之所在，到解决问题。本文将基于 STM32F4DISCOVERY 板，一步步重现问题，一方面介绍如何使用 USB 的 CDC 类进行开发，另一
6 ]& Y0 q% B6 [: X! }方面，对在开发过程中碰到发送 64 整数倍数据时会失败的问题分析及解决方案。
2 S8 n4 ~& ?$ T2 硬件介绍
4 t( d" ]5 M: U; ^在创建工程之前，我们首先即将使用的硬件进行必要的介绍。
! E+ A  h9 F7 P: }# `
& L& l9 h( e. z5 `- s: t
% A4 g7 \9 Q0 w
7 Z8 [6 _4 M& o0 \/ N* p1 d" j9 }如上图所示，USB 电路使用 PA11，PA12，全速 USB OTG，当然，这里只做 device，英雌只需要看上图的下面部分。
% ?0 a3 s- I) b2 O: X8 Y: h) a
( k, y  O7 ~+ T( A
2 j3 N$ Q- K3 \9 A/ m
如上图，本例中将使用到 1 个用户按键，PA0，按下时为 1 电平。
另外，晶振使用的是外部 HSE 8M 晶振。

3 创建 CubeMx 工程
打开 CubeMX(V4.17.0)，创建一个以 STM32F407VGTx 的工程，使用 FS-USB，并使用 PA0 外部输入 EXIT，如下图所示：
& C& r* s' D5 D# V6 i; \3 t* D% ?
* @1 Q# c  |1 h9 {) ^- e

1 G/ j4 q* |2 C' C; C7 C' \& Z2 w7 O使能外部 HSE，使用外部 8M HSE,其时钟树如下设置：



, S; f$ Y. i( m: V. k接下来是配置参数，这里只修改 USB 中断优先级为 1，而 PA0 的外部中断优先级设置为 4，如下：


  s  ?& U$ Q# s* U% Q
; a3 f$ c  X9 w3 s. L然后再中间件将 USB class 设置为 Communicaiton Device Class,如下：

" c0 @7 c0 R. V2 m

最后将工程的堆设为 0.5K，栈设为 1.5K :
! @, l0 t: X  i
# W. r8 B7 D, Z7 J


最后生成一个 F407_CDC_Test 的工程。

4 修改工程代码
我们对生成的工程不做任何修改，直接编译后烧进开发板后是可以被 PC 识别为虚拟串口的，如下图所示：
* C5 T# D5 e  G" O# V) ^

+ f* @1 L. a+ u4 U" I# v" X+ C: y

$ w; U  {4 W7 t/ d4 A4 M6 b(注意：这里所说的虚拟串口主要是指其可以被当做串口来用，但其速度跟串口所设置的波特率完全没有关系，用户不要被名字所迷惑，虽然使用起来跟串口没有区别，但其本质还是 USB，在初始化设置波特率不会对 USB 的通讯速率产生任何影响，本文档所描述的是全速 USB，因此，其最大速率就固定为 12M/S，这个是由全速 USB 外设标准 48M 输入时钟所决定的)此时是没有任何具体功能的，为了更好的看到通讯的数据，我们将使用串口通讯工具来进行测试，这里我们使用的串口工具是: sscom32.

2 ~7 v0 ^/ e3 g( a0 v6 I# r0 C4.1 验证接收功能
6 s* C6 S& @+ A3 L3 @! v+ p我们将使用 PC 串口工具 SSCOM32 通过 USB 向 MCU 发送数据，为了能在 PC 端能看到 MCU 是否能接收到数据，我们在MCU 端修改代码，让 MCU 一旦接收到来自 PC 端的数据后，立马返回一模一样的数据，因此需要在生成的源码文件usbd_cdc_if.c 文件中找到到函数：CDC_Receive_FS()，添加处理函数，如下：

1. static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len)
   / x- k( m# l! `: m  a
2. {
   
3. /* USER CODE BEGIN 6 */
   
4. HanldeReceiveData(Buf,*Len);
   
5. USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
   
6. USBD_CDC_ReceivePacket(&hUsbDeviceFS);
   
7. return (USBD_OK);
   / z+ l& m' _& |) I0 J
8. /* USER CODE END 6 */
   8 X- G4 S* l9 K0 o5 d
9. }
   - c: f( U" d% ?9 m4 ]* m( a" @
10. /* USER CODE BEGIN PRIVATE_FUNCTIONS_IMPLEMENTATION */
    1 \- a- O! c" }: _
11. static void HanldeReceiveData(uint8_t* Buf, uint32_t Len)
    
12. {
    0 k" b) F& U7 [' n9 k: c% w) N
13. CDC_Transmit_FS(Buf,Len);
    
14. }
    
15. /* USER CODE END PRIVATE_FUNCTIONS_IMPLEMENTATION */

复制代码

9 |7 P. B$ A# Q/ e2 t编译后烧进板子进行验证：

+ W) G9 C) S) l3 J; o
) Y) S) W4 X  |: @' _5 _

如上如所示，串口工具能够收到来自 MCU 的返回数据，与发送数据完全一样，这说明，MCU 已经接收到了 PC 端发送的数据，另外，PC 端也能接收到 MCU 端发送的数据。

4.2 验证发送功能
8 n4 u; O$ ]# v2 P7 B* v" |接下来我们来通过按键响应来主动向 PC 端发送数据，我们在按键回调函数内添加代码如下：

1. /* USER CODE BEGIN 0 */
   
2. static uint8_t SendData[256] ={0};
   , H: i# b; ]+ _+ i2 ?
3. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
4. {
   
5. uint16_t i;
   
6. for(i =0; i<sizeof(SendData); i++)
   1 `! G# f+ {$ M, z
7. {
   : V5 Z, K8 H4 d
8. SendData[i] =i;
   
9. }
   0 m2 m9 l3 i, y% V7 q
10. CDC_Transmit_FS(SendData,63);
    8 S* F; ~$ [" d# @
11. }
    - i. Z" C) A5 @  s/ r
12. /* USER CODE END 0 */

复制代码

/ J3 y4 h9 k6 g5 Y& j7 j! \
4 Y, n( q3 g& d7 A$ Z, M! R即用户按下按键，MCU 则向 PC 端发送一次数据，这里发送的是 63 个字节，内容为 0~62，测试后 PC 端的串口工具完全能收到 MCU 端发送的 63 个字节，如下图所示：




但是当我们将代码修改为发送 64 个字节后 :
$ Z  P& q6 ~! }0 y1 h1 Z; L

1. /* USER CODE BEGIN 0 */
   4 l$ r# F5 r" ?* ^) q/ {7 @
2. static uint8_t SendData[256] ={0};
   
3. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
4. {
   1 h  l/ d6 `) R6 f! P
5. uint16_t i;
   1 i3 \' [4 F/ Q' I8 y) y
6. for(i =0; i<sizeof(SendData); i++)
   
7. {
   
8. SendData[i] =i;
   
9. }
   ) @+ x& x4 J, i+ f
10. CDC_Transmit_FS(SendData,64);
    
11. }
    & B! _( G0 |! s$ S! @, Y
12. /* USER CODE END 0 */

复制代码

# q* I. z3 ]5 T4 ^  Y2 j
3 b. h/ e# d; O" F' y$ @! N修改后进行验证，发现 PC 端串口工具不能接收到数据，，这里代码基本完全没有变化，只是发送长度之前为 63，这里为 64，结果却不相同，很明显，USB CDC 协议栈哪里出了问题。

* A* y* ^6 f7 c4 L7 j, A
我们先使用 USB 分析仪对发送 64 个字节时进行 USB 总线监控：
: I  I3 N. n. E: N
4 R  r* u  R2 [

如上图，我们发现，当发送 64 个字节时，由于正好是最大包长(64)，按 USB 标准来看，应该多发一次空的 transaction,但是这里，仅仅只发了一次 transaction，这也就是为什么串口没有接收到数据的原因(MCU 端的 USB 实际上是已经发送了 64 个字节，但由于缺少一个 transaction，因此 PC 端的驱动会认为数据格式不完整，而放弃所有已经接收到的数据，从而使上层看起来没有接收到任何内容)。


/ F9 ?! c1 y+ i0 K7 Y" \* D
因此，接下来的工作就是找到 USB 协议栈中的相应处理环节，然后将缺少的那个空的 transaction 补上即可。
  X( d( A) q1 i; Z  A


4.3 USB CDC 协议栈修改
8 M, |3 T5 I5 |2 l  L# _! [4.3.1 USB 数据发送流程分析
" X  |5 E0 C, h9 @在对 USB CDC 协议栈进行修改之前，我们先来梳理下 USB 发送的流程。
( F; y: `- E9 k( ?" |& S# e发送 USB 数据大概过程如下：
1> 填写 DIEPTSIZ 寄存器的发送包数(pakage count)和传输大小(transfer size)。
2> 使能发送断点的发送空中断(DIEPEMPMSK,利用发送空中断 TXFE 来将发送数据填充到 DFIFO)。
3> 使能断点。
$ \/ c4 J# p2 a: ~6 e4> 后续就是中断的事了。
- b# X3 ^! t& M1 A* z6 R9 n" o6 K后续将会有 3 次中断：
5 Z5 ^' P3 p0 u  Z1> USB_OTG_DIEPINT_TXFE 中断:在此中断处理中，程序将发送缓冲的数据分包填充到 DFIFO（不能超过最大包长，只
4 ^3 J$ h/ H. R" V有最后一包数据才有可能小于最大包长）。
6 f! i' c' X# p. [2> USB_OTG_DIEPINT_TXFE 中断: 还是 TXFE 中断，上次 TXFE 填充的发送数据全部发送完了后，最终还是会继续触发
TXFE 中断，也就是这次中断，在这次 FXFE 中断中禁止 FXFE。也就是说，后续不会再有 TXFE 中断，除非再次使能。
3> USB_OTG_DIEPINT_XFRC 中断：传输完成中断，表示到这次中断为止，传输完成。在这个中断中将回调HAL_PCD_DataInStageCallback()函数，就相当于发送中断一样。
6 T2 r2 s/ K9 h, G+ n这就是 USB 数据发送的流程，这里需要注意地是，对于端点 0 和非端点 0 来说，在具体流程实现上还是稍微有所差异的。究其原因，主要是端点 0 和非端点 0 的 DIEPTSIZ 寄存器的包大小和传输大小位宽是不一样的。如下图：


3 J; `4 J5 J1 v" C$ A  g$ n
3 g7 o/ B; t3 d! u+ S! q5 D
- ]# F5 W$ t- ~# y
+ D  h  G+ @6 U4 v
对比上图，端点 0 的 DIEPTSIZ 寄存器的 XFRSIZ 位宽为 7，最大值为 127，也就是说最多一次只能传输 127 个字节，按最大包长 64 字节来算，就是是最多两包数据。如果需要发送超过 127 个字节时，又该如何做呢？查看 USB 协议栈内核代码，发现每次端点 0 发送数据时，在发送代码中固定每次最多可以传输 64 字节，然后在传输完成中断处理时，再将剩下的数据接着传输(usb core)，当然，每次传输最多也是 64 个字节，就这样，直到发送完所有数据为止。为什么每次传输最大设置为 64？
' d4 O6 a6 C# P! ]& M不是 XFRSIZ 位宽为 7,理论上可以为 127 吗？我的理解是，这样也是可以的，只要包长控制在 64 个字节内就可以了，至于每次传输多少字节，只要 XFRSIZ 位宽够用，你可以设置 127 个字节范围内任何数据均可。代码中设置为 64，主要为了图方便。
* u6 n+ G: y! O' Q2 q. \4 y2 [" f但是，对于非端点 0，XFRSIZ 位宽为 19 位，524288 个字节，足够传输所有实际数据了，因此，在发送代码中，并没有限定传输数据的长度，在 TXFE 中断中也能将所有待发送的字节填入 DFIFO。但是，当发送的数据刚好是 64 的整数倍时，按USB 标准，应该继续发送一次空字节，以表示数据全部发送完毕。如下：


4.3.2 代码修改
对比端点 0 的处理，发现端点 0 在传输完成中断(XFRC)中，有对这种情况的判断，一旦检测到这种情况，则会发送一次空传输。如下：
usb_core.c 文件中的 USBD_LL_DataInStage()函数 :
; w( B9 B9 O  p) {* Q

1. USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev ,uint8_t epnum, uint8_t
   
2. *pdata)
   ) Y" ~% b" h( T: Z! O& }/ l+ }' ?0 o
3. {
   
4. USBD_EndpointTypeDef *pep;
   4 P6 E4 y/ [+ B" d! j$ l2 K2 r
5. 
   7 h/ v0 Q1 U, b; t( }5 I/ O
6. if(epnum == 0)
   6 k/ X- p0 |! I# v  Q6 \
7. {
   
8. pep = &pdev->ep_in[0];
   
9. 
   2 I0 ]0 H8 C" }4 v. t! d3 X$ b
10. if ( pdev->ep0_state == USBD_EP0_DATA_IN)
    
11. {
    : I, k/ d% G1 H% N- H/ }2 ]3 [' }
12. if(pep->rem_length > pep->maxpacket)
    8 A- u! I3 M# r( x5 [- F
13. {
    + n5 S! [7 u/ _+ A8 E: ^
14. pep->rem_length -= pep->maxpacket;
    
15. //继续发送剩余数据
    / o+ i  ]5 @- E; t. o$ g& e9 r
16. USBD_CtlContinueSendData (pdev,
    : g- z" s4 N0 {  n: {( L6 Q
17. pdata,
    
18. pep->rem_length);
    ! q" {0 }7 M( E: }' g3 u7 m! P: \
19. 
    9 N/ s$ ?' y; U/ W+ b' L
20. /* Prepare endpoint for premature end of transfer */
    & Z+ |( w  T1 K  _" \
21. USBD_LL_PrepareReceive (pdev,
    ' L; a5 \5 K3 l: e) D. h' V
22. 0,
    # s+ s( I, I& R4 B
23. NULL,
    % O, U6 v$ \' u. j9 F) g$ R
24. 0);
    
25. }
    
26. else
    
27. { /* last packet is MPS multiple, so send ZLP packet */
    : F* t0 E- N% e1 A# A# `+ K  u
28. if((pep->total_length % pep->maxpacket == 0) &&
    ! o2 K- {- c* y7 k! F3 |
29. (pep->total_length >= pep->maxpacket) &&
    
30. (pep->total_length ep0_data_len ))
    
31. {
    
32. //再多发送一次空数据
    
33. USBD_CtlContinueSendData(pdev , NULL, 0);
    . g4 j8 `0 n5 P4 G, K
34. pdev->ep0_data_len = 0;
    
35. 
    # [: Q( Q' ^# N) H
36. /* Prepare endpoint for premature end of transfer */
    
37. USBD_LL_PrepareReceive (pdev,
    + d" M6 _1 D+ ?8 P+ t& y5 H
38. 0,
    
39. NULL,
    
40. 0);
    3 ~) y( B8 Q6 u" J% M# ~1 W' Y
41. }
    
42. else
    
43. {
    
44. if((pdev->pClass->EP0_TxSent != NULL)&&
    - ]8 E; P7 \8 p: E3 Z
45. (pdev->dev_state == USBD_STATE_CONFIGURED))
    
46. {
    % V/ F" `; w7 Q! g' k$ H/ _! T0 m9 e
47. pdev->pClass->EP0_TxSent(pdev);
    
48. }
    
49. USBD_CtlReceiveStatus(pdev);
    
50. }
    + }, f8 E2 p- ~- K$ J: j! r
51. }
    - ]! m+ ?+ @5 I: e' Z& s
52. }
    
53. if (pdev->dev_test_mode == 1)
    + J" F" y* d  [
54. {
    . j/ b8 |# p6 |9 C# B  W5 O0 P
55. USBD_RunTestMode(pdev);
    4 e- `2 l! i' B* N6 W+ j5 r
56. pdev->dev_test_mode = 0;
    2 A0 u+ m9 E8 }5 O+ b) c1 @  |% l! S2 P9 V, }
57. }
    
58. }
    1 }' Q  z' \6 s! ]
59. else if((pdev->pClass->DataIn != NULL)&&
    
60. (pdev->dev_state == USBD_STATE_CONFIGURED))
    
61. {
    
62. pdev->pClass->DataIn(pdev, epnum); //非 0 端点回调 CDC 类的 DataIn()函数处理
    
63. }
    
64. return USBD_OK;
    
65. }

复制代码

从上述代码，我们明显可以可以看出，USB 协议栈在对于端点 0 的数据明确做了一系列处理，以使其可以续发数据以及发送空数据传输，向主机端表示所有数据发送完毕。而对于非端点 0 的数据，则直接向上回调相应 USB 类的 DataIn 处理函数，
$ f% m/ e. t$ r把责任完全撇给 USB 类去处理。
接下来查看 CDC 类的 DataIn()函数 :
) _: y$ ^" Q! I' C1 L

1. static uint8_t USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
   
2. {
   
3. USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
   0 B0 U/ L8 \1 T# p
4. 
   . b  _3 `( x. `8 ^) c- ]
5. if(pdev->pClassData != NULL)
   - d& N( N, U( C/ P
6. {
   
7. 
   
8. hcdc->TxState = 0;
   
9. return USBD_OK;
   * h" _& R( b' D
10. }
    
11. else
    9 b5 G- Q) z" T3 v
12. {
    
13. return USBD_FAIL;
    
14. }
    # r4 d- x% C( T& X4 h3 @2 a
15. }

复制代码

虽然 USB 类的 DataIn()回调函数是不需要处理做续发数据处理（19 位的 XFRSIZ 位宽已足够表示数据长度），但是对于最大包长的整数倍长度数据的最后一个空包并没有做相应处理，因此，我们需要对其进行改造：

1. static uint8_t USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
   # j+ h* q; [4 d: N! c
2. {
   
3. USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
   7 k  H" |: A: |1 F( D8 a( q
4. PCD_HandleTypeDef *hpcd =pdev->pData;
   
5. USB_OTG_EPTypeDef *ep;
   
6. ep = &hpcd->IN_ep[epnum];
   
7. if(ep->xfer_len >0 &&ep->xfer_len%ep->maxpacket ==0)
   
8. {
   
9. USBD_LL_Transmit (pdev,epnum,NULL,0);
   
10. return USBD_OK;
    
11. }
    
12. else
    5 y" X6 y$ K* M! v; u$ s- h
13. {
    
14. if(pdev->pClassData != NULL)
    
15. {
    $ y, j. W- c# j/ T0 k$ v
16. hcdc->TxState = 0;
    % q! C6 `7 E1 y: e- W1 O/ J
17. return USBD_OK;
    
18. }
    
19. else
    
20. {
    
21. return USBD_FAIL;
    
22. }
    2 q! T4 r0 v8 f( C8 f* q
23. }
    
24. }

复制代码

将修改后的代码进行测试，测试发送 64,256 长度字节内容均可以成功发送 :
( M: v7 N. r4 u" T% S( I% x
8 k& k7 {  P2 ^; B2 d1 N! s7 f

) Q, g+ d) r0 y9 O2 f) t+ F
" ?8 F- |" O+ v! m% D
从上图可以明显看到最后那次空事务(transaction),同时，使用串口工具也能正常接收到 64 个字节数据 :


$ h$ f7 C! O( {  r. z$ }- E, I8 Y
由此证明此修改是生效的。


5 结束语
1 此问题是在使用 CubeMx V4.17.0 发现的问题，不排除后续 CubeMx 更新版本中会解决此问题。
  b' [  \- c: u  G$ g  v, c3 d2 此问题同样适用于其他 USB 类，本着不轻易修改 USB 协议栈原则，因此没有将修改转移到 USB 协议栈的内核中。因此，在其他 USB 类中的非 0 端点出现类似问题时，可以参考本文的 DataIn()函数修改。
, `* ^7 i, G( ~; {8 ]

19 位的 XFRSIZ 位宽表示的长度只有0.5Mbyte，但是我需要一包发送1.5Mbyte大小的数据，该如何在USBD_CDC_DataIn（）续包发送数据。因为上位机没有源码，所以无法通过上位机修改包的大小。

报:当前使用MX6.12.0版本生成的USB代码已修复该问题

static uint8_t USBD_CDC_DataIn(USBD_HandleTypeDef pdev, uint8_t epnum) { USBD_CDC_HandleTypeDef hcdc = (USBD_CDC_HandleTypeDef )pdev->pClassData; PCD_HandleTypeDef hpcd = pdev->pData;

if (pdev->pClassData != NULL) { if ((pdev->ep_in[epnum].total_length > 0U) && ((pdev->ep_in[epnum].total_length % hpcd->IN_ep[epnum].maxpacket) == 0U)) { / Update the packet total length / pdev->ep_in[epnum].total_length = 0U;

/ Send ZLP / USBD_LL_Transmit(pdev, epnum, NULL, 0U); } else { hcdc->TxState = 0U; } return USBD_OK; } else { return USBD_FAIL; } }