1、配置时钟
6 _5 X4 _4 T& Y$ Y  ~, C


2、开启USB

+ b& \: y/ t7 ], z& y- c, A6 I) M
) N( S* o; ?6 Y+ F; y
3、开启USB设备：虚拟串口
$ A, d. ~$ P" E% h4 l1 n
6 f% u0 Y; x$ o" M

( g* f) c6 A3 {  {4、生成工程




% M% {) e+ b8 P& @$ o6 Z
1 C) @% s" a- T( `7 X5、修改代码实现回环收发数据测试
在usbd_cdc_if.c文件中新定义一个结构体：

1. USBD_CDC_LineCodingTypeDef USBD_CDC_LineCoding =
   
2. {
   : W& b0 V& f% `* \1 I/ f  O- W
3.         115200,      // 默认波特率
   
4.         0X00,        // 1位停止位
   ' w& C+ U: d- z8 s$ e1 ^1 O
5.         0X00,        // 无奇偶校
   
6.         0X08,        // 无流控，8bit数据位
   
7. };

复制代码

找到CDC_Control_FS函数，找到CDC_SET_LINE_CODING和CDC_GET_LINE_CODING分支，添加以下代码：
! W2 f$ F1 g2 [0 ]0 @6 z$ T1 v1 k（CDC_SET_LINE_CODING：你在用串口助手选择波特率时候，STM32就会调用这个分支进行修改USB波特率）
, r1 C$ [6 d1 L) ^. |（CDC_GET_LINE_CODING：获取STM32的USB波特率）

1.     case CDC_SET_LINE_CODING:
   
2.             USBD_CDC_LineCoding.bitrate = (pbuf[3] << 24) | (pbuf[2] << 16) | (pbuf[1] << 8) | pbuf[0];
   - }- X( m, e/ R0 O
3.             USBD_CDC_LineCoding.format = pbuf[4];
   6 W, I0 U. r# N, E% V
4.             USBD_CDC_LineCoding.paritytype = pbuf[5];
   
5.             USBD_CDC_LineCoding.datatype = pbuf[6];
   
6.     break;
   
7. 
   
8.     case CDC_GET_LINE_CODING:
     ~, [6 ]+ j7 C+ \
9.             pbuf[0] = (uint8_t)(USBD_CDC_LineCoding.bitrate);
   
10.             pbuf[1] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 8);
    
11.             pbuf[2] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 16);
    
12.             pbuf[3] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 24);
    
13.             pbuf[4] = USBD_CDC_LineCoding.format;
    9 }5 C. l# a) I) }* ~! \2 c1 J4 ]
14.             pbuf[5] = USBD_CDC_LineCoding.paritytype;
    
15.             pbuf[6] = USBD_CDC_LineCoding.datatype;
    8 p" {1 u" W  R" m8 {' E, N
16.     break;

复制代码

如下图所示：

! P# v+ B& {7 ^2 O- n
& x3 o3 v; n9 @' S. B& v2 b
找到CDC_Receive_FS函数，这个函数如果USB虚拟串口数据收到就会被调用，我们在这个函数中将收到的数据在发回去，只需要添加CDC_Transmit_FS(Buf, *Len);这一句即可，如下图：

/ n0 T" a9 Q# t: P6 J

' {. i/ m1 x% L( c% U) y8 T2 D然后编译工程并下载，接上USB之后，设备管理器COM出现一个新的端口：



/ p( _3 ^& u+ [4 s, U+ R我们使用串口调试助手给它发数据：
+ B; j, Y0 g7 p. m$ I


6、实现USB转串口功能
发数据流程：串口调试助手发送数据->STM32的USB数据接收->STM32转发到串口3
3 k. t4 n) w+ y收数据流程：STM32的串口3收到数据->转发到USB->STM32的USB发送到串口调试助手

, s4 n2 f9 I/ b6 e4 x: V8 x8 x第一步先在这里加入串口3的初始化操作：


- G/ j+ M# o( V! Q+ g* ]
8 @/ P+ }) Y& z贴一下串口3的初始化代码，这里我用到了队列，因为实际测试发现串口3接收数据量比较大的话，那么转发到USB虚拟串口的时候会丢数据，所以这里采用了缓存队列，当串口接收到的数据到达一定数据量之后才做一次转发到USB的操作，并且开启了空闲中断，作用是转发最后一包数据：

关于队列的使用可以查看我的另一篇博客：C/C++语言实现的一个缓存队列
' v5 V$ {% ?* |1 R& L4 W

1. /*
   : g8 U- \. Z! t# D4 q* V
2. * myusart.c
   2 O* K: m0 [9 \) ^- I) h
3. *
   
4. *  Created on: Mar 22, 2021
   3 K- ?4 Q' B! @
5. *      Author: hello
   9 B' {" }' l* o" {% i4 h- Q9 s% }
6. */
   
7. #include "myusart.h"
   1 }# R. I8 U) C1 u7 h
8. #include "myqueue.h"
   
9. 
   
10. // 队列大小，定义为USB_CDC的发送包大小
    ! x( m/ _  K: [
11. #define QUEUE_SIZE APP_TX_DATA_SIZE
    
12. 
    
13. // 队列数据空间。请使用宏QALIGN4，目的是为了根据队列大小计算实际需要的队列存储空间大小并对齐4字节
    
14. uint8_t QueueBuffer[QALIGN4(QUEUE_SIZE)];
    ; j0 _4 o2 V0 [# g
15. 
    9 @; l( n6 v# R+ v* ~( w& p
16. // 队列句柄
    ; b# h+ X8 Q$ o6 U- p
17. Queue Uart3QueueHandle = {0};
    $ p6 S$ }2 b: B  G9 ]' q/ g
18. #define UART3_QUEUE_Handle (&Uart3QueueHandle)
    0 X( L" i4 t: v1 ~+ ]: g
19. 
    8 }$ A% C0 R& C. [
20. // 串口转发到USB的缓冲，定义为USB包的一半大小
    + c4 z; g/ K% j$ D) T% H
21. static uint8_t buffer[APP_RX_DATA_SIZE >> 1];
    
22. 
    
23. void UART3_Init(const USBD_CDC_LineCodingTypeDef *USBD_CDC_LineCoding)
      A: c' L2 t, u( Y( p: _
24. {
    
25.         __HAL_UART_DISABLE_IT(&huart3, UART_IT_RXNE);
    : k! c0 }: s' B, p
26. 
    
27.         __HAL_UART_DISABLE_IT(&huart3, UART_IT_IDLE);
    0 E& V% x, D1 B
28. 
    ! m: f5 D! o' e7 A1 X+ C
29.         HAL_UART_DeInit(&huart3);
    ; {3 [" r' q, {1 y5 B, G
30. 
    & x9 |7 m9 p9 p: h( U# n* p
31.         huart3.Instance = USART3;
    
32.         huart3.Init.BaudRate = USBD_CDC_LineCoding->bitrate;
    1 z7 Y* M$ p% S/ ]. f" e* f! R
33.         huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    , z. q5 q' ^! a/ \
34.         huart3.Init.Mode = UART_MODE_TX_RX;
    
35.         huart3.Init.OverSampling = UART_OVERSAMPLING_16;
    # z4 \- }! S1 j/ {3 Y6 O
36. 
    ! n/ o9 V  i# m/ _) h  D1 \9 [' }; P
37.         switch (USBD_CDC_LineCoding->paritytype)
    ) ]% B; J! {* _, V
38.         {
    
39.         case 0:
    0 r- z' B( Z- J* z' q8 r! L
40.                 huart3.Init.Parity = UART_PARITY_NONE;
    + \5 T6 \. u* Y7 n3 R
41.                 break;
    9 a! O0 G2 j7 k, q+ q
42.         case 1:
    # G7 X5 ^1 s( v* B) _3 z
43.                 huart3.Init.Parity = UART_PARITY_ODD;
    
44.                 break;
    
45.         case 2:
    
46.                 huart3.Init.Parity = UART_PARITY_EVEN;
    
47.                 break;
    * h" _2 w2 g6 H7 I2 z) V: `5 V
48.         default:
    
49.                 huart3.Init.Parity = UART_PARITY_NONE;
    * M2 C2 k: j. p2 M( I, b. e
50.                 break;
    : r$ {$ j( D0 s. G5 A, j5 K# H
51.         }
    
52. 
    ! A- q( R9 q* I3 b6 k
53.         switch (USBD_CDC_LineCoding->datatype)
    
54.         {
    , ?1 y* m2 S/ B9 `8 V2 a9 j4 _
55.         case 0x07:
    ) a9 \/ \9 x' [- n2 U( C' \' `2 Y. M
56.                 huart3.Init.WordLength = UART_WORDLENGTH_8B;
    
57.                 break;
    7 ]! L" j* z- O7 z* ^
58.         case 0x08:
    
59.                 if (huart3.Init.Parity == UART_PARITY_NONE)
    
60.                 {
    
61.                         huart3.Init.WordLength = UART_WORDLENGTH_8B;
    
62.                 }
    2 s0 @- v0 x) E7 `+ ~; ]
63.                 else
    
64.                 {
    ! G; E. ?/ M* ?
65.                         huart3.Init.WordLength = UART_WORDLENGTH_9B;
    
66.                 }
    4 ~" \8 u; }& F$ J2 V0 t
67.                 break;
    ! [9 E+ r! |& F5 P
68.         default:
    
69.                 huart3.Init.WordLength = UART_WORDLENGTH_8B;
    2 K! {6 Y6 ^% |) Z* t
70.                 break;
    
71.         }
    6 I. D" H! ?3 t0 Y+ }, h- @
72. 
    ( F% D: m5 B  D
73.         switch (USBD_CDC_LineCoding->format)
    
74.         {
    8 q. w2 q3 [7 G
75.         case 0:
    # r) |* J( `1 ?9 j
76.                 huart3.Init.StopBits = UART_STOPBITS_1;
    7 b, E* y9 g8 [0 \; y
77.                 break;
    8 y4 n% l" h& m  D
78.         case 2:
    7 e! [  U! _' F3 m$ V( @
79.                 huart3.Init.StopBits = UART_STOPBITS_2;
    
80.                 break;
    6 J$ @- g& d" g
81.         default:
    
82.                 huart3.Init.StopBits = UART_STOPBITS_1;
    # R6 a: B7 O. j
83.                 break;
    $ j* O$ I/ f! g4 n/ t
84.         }
    ( O* e5 N" ~$ n- d, c4 K
85. 
    
86.         HAL_UART_Init(&huart3);
    " \# d# A& s" ~6 V
87. 
    
88.         Queue_Init(UART3_QUEUE_Handle, QUEUE_SIZE, QueueBuffer);
    3 J9 L! F! L" P9 E4 s
89. 
    
90.         __HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);
    
91. 
    ' Z) l+ O& }! ]" ^9 e0 `1 ^
92.         __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
    - d/ D( y# s) H" x
93. }
    % W/ Y! l1 t) E5 `7 ?
94. 
    1 `3 M2 J; ^: s' R3 t
95. void USART3_IRQHandler(void)
    . D5 f7 {, ~3 F7 `: @( q2 g5 \
96. {
    ) U- @2 v. E; j
97.         static uint32_t nsent = 0;
    
98.         static uint8_t dat = 0;
    
99. 
    
100.         if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE) != RESET)
     / d! F+ E4 {: z6 R8 p- G* y
101.         {
     
102.                 __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE);
     / B. }, P8 h; H5 g
103.                 dat = huart3.Instance->DR & 0XFF;
     ; A9 R% {  g3 b
104.                 Queue_PutByte(UART3_QUEUE_Handle, dat);                     // 入队一个字节的数据
     - C" ^# y. ?3 _
105.                 if (Queue_GetUsed(UART3_QUEUE_Handle) >= sizeof(buffer))
     3 _3 Y' d; L9 D: [% D; a1 M
106.                 {
     
107.                         Queue_Read(UART3_QUEUE_Handle, buffer, sizeof(buffer));
     " D: [/ T. t% e: }
108.                         CDC_Transmit_FS(buffer, sizeof(buffer));                // 转发到USB
     1 M% v# h( E" i
109.                 }
     5 L* g8 E2 e) X( L6 i! R5 t* z$ |
110.         }
       b4 H7 l* I1 e. v' T+ Q1 E
111. 
     
112.         if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_IDLE) != RESET)
     9 Y! Y% K, b( C6 P% \5 D  {: ~
113.         {
     - O1 `0 h" T& v$ |4 b/ i5 R
114.                 nsent = Queue_GetUsed(UART3_QUEUE_Handle);
     . }4 r4 J  v) e8 ]  i
115.                 if (nsent != 0)
     
116.                 {
     , o9 \8 R# {& e
117.                         Queue_Read(UART3_QUEUE_Handle, buffer, nsent);
     4 U( M+ n$ O3 W3 V/ k
118.                         CDC_Transmit_FS(buffer, nsent);               // 转发到USB
     3 [" L4 b7 J) B  t1 I. }
119.                 }
     
120.                 __HAL_UART_CLEAR_IDLEFLAG(&huart3);
     * J) Z- a  `+ b/ T3 p" c. N+ j
121.         }
     
122. }
     + s% Y. E, g7 z. m
123. 
     
124. void UART3_SendData(const void *buf, uint32_t len)
     
125. {
     
126.         const uint8_t *p = (const uint8_t*) buf;
     
127.         while (len--)
     3 m9 p3 `9 H/ P5 M
128.         {
     
129.                 while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
     * Z2 b' {( X1 g3 v+ k9 G0 E: U) N
130.                 huart3.Instance->DR = (uint8_t) (*p++ & 0XFF);
     * W6 `2 G! z. I4 D7 D
131.                 while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
     
132.         }
     6 r$ m/ f3 R! h4 {
133. }
     
134. 
     
135. //#ifdef __GNUC__
     & J# o9 u7 w9 P, Z
136. //#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
     ( `; w# q' w# C
137. //#else
     
138. //#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
     7 j1 G& k# X, n5 O  u+ x1 n( @
139. //#endif
     9 I- f5 v& A& ~
140. //PUTCHAR_PROTOTYPE
     2 G/ b* W9 b; \, e! B$ _) A4 [
141. //{
     # t* f) x6 J: c4 b" `
142. //        while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
     8 r9 f: e" p& {0 O9 V
143. //        huart3.Instance->DR = (uint8_t) (ch & 0XFF);
     
144. //        while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
     
145. //        return ch;
       _8 P5 T8 U- X( H8 z
146. //}
     / B( f% @, b' p- u5 `5 I8 n

复制代码

然后在添加USB转发到串口的操作：
- p/ m  {% H8 a- q' T7 E
7 j1 o4 Y9 \! y7 n" n7 u3 G

/ R  `9 x, n4 T1 }) l这样就实现了一个类似于USB转TTL模块的功能！
9 ]# s1 Z7 ^; z
0 U7 e7 q9 D6 o