1、配置时钟
! l, E# d5 m% O  J$ Z


2、开启USB
6 k' d8 x3 Q8 e/ ^6 k  m& N

0 c% t7 M1 V1 e' T( q
3、开启USB设备：虚拟串口
" u/ k' t, b# g6 l7 b9 K5 |


# Q3 G. K4 \/ Y) i" \  Q' ]4、生成工程


3 l) k/ X0 @0 Q0 q5 N
# }; f) D9 Z% Y& B5 B& O; q
2 y. J7 `2 H. F0 M8 S5 ]- x
) h& `+ q4 i+ x5、修改代码实现回环收发数据测试
. Z/ x* \' L5 i2 J: R0 G, c; y# w2 n0 b在usbd_cdc_if.c文件中新定义一个结构体：

6 ?/ \8 V% e' r3 ^2 ]( u

1. USBD_CDC_LineCodingTypeDef USBD_CDC_LineCoding =
   
2. {
   
3.         115200,      // 默认波特率
   1 ~. ~" a+ }$ L
4.         0X00,        // 1位停止位
   
5.         0X00,        // 无奇偶校
   ( J/ j$ |$ Q# Z% a9 F# y& l* Y4 a
6.         0X08,        // 无流控，8bit数据位
   - s! J0 L1 V1 }7 @0 W& M$ R% q
7. };

复制代码

( G  C0 R! l/ m* l, v" m* Y9 i找到CDC_Control_FS函数，找到CDC_SET_LINE_CODING和CDC_GET_LINE_CODING分支，添加以下代码：
) y, E6 y8 y0 J' H0 r（CDC_SET_LINE_CODING：你在用串口助手选择波特率时候，STM32就会调用这个分支进行修改USB波特率）
$ |. X0 \7 m, k, t/ Z& c（CDC_GET_LINE_CODING：获取STM32的USB波特率）
4 q$ ?: t8 `& W% J5 i2 _5 Y
: ?" \% S" g. v5 E9 z# u5 ^" m, Y

1.     case CDC_SET_LINE_CODING:
   
2.             USBD_CDC_LineCoding.bitrate = (pbuf[3] << 24) | (pbuf[2] << 16) | (pbuf[1] << 8) | pbuf[0];
   
3.             USBD_CDC_LineCoding.format = pbuf[4];
   " ]- @( `' g2 ]) C' P. @- O( O4 p
4.             USBD_CDC_LineCoding.paritytype = pbuf[5];
   * }# t* `. J+ L2 V, j7 {' w
5.             USBD_CDC_LineCoding.datatype = pbuf[6];
   * j  |! Y7 v0 o( ~8 \1 U
6.     break;
   ; e6 S+ d* t) Q' M. J& Z  A
7. 
   
8.     case CDC_GET_LINE_CODING:
   
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;
    3 K# ]/ N3 n8 l( p  |; ?
14.             pbuf[5] = USBD_CDC_LineCoding.paritytype;
    8 I0 r0 J% J! p: z
15.             pbuf[6] = USBD_CDC_LineCoding.datatype;
    ( P; Q( A; x1 p& }
16.     break;

复制代码

9 F; ?9 E. |+ p* j6 Z) C; v2 R9 l, H
: O, f  t& t0 M. J8 z如下图所示：
5 E5 A9 Y4 t6 ~& r

4 \  F, U! U- {$ ?7 s- @
& l( @, S. a2 `. q6 j+ S' V; ~2 F找到CDC_Receive_FS函数，这个函数如果USB虚拟串口数据收到就会被调用，我们在这个函数中将收到的数据在发回去，只需要添加CDC_Transmit_FS(Buf, *Len);这一句即可，如下图：

2 u+ g. I* x$ o- S* R

4 U! v. S& k; U3 ~: r: P& A然后编译工程并下载，接上USB之后，设备管理器COM出现一个新的端口：
1 E7 @5 u6 x$ h& ^! ^' s6 }

! y7 T; H# |' y8 G  Z% a" t7 c
我们使用串口调试助手给它发数据：

: O. H, f- Z0 z% h; e/ M  f1 ?
8 D$ u9 `6 ~; G' ?& @
6、实现USB转串口功能
: \  A! t5 B3 {% ^# H( d: I发数据流程：串口调试助手发送数据->STM32的USB数据接收->STM32转发到串口3
8 V2 Y! Q+ w0 p# @收数据流程：STM32的串口3收到数据->转发到USB->STM32的USB发送到串口调试助手
; o9 o$ A% m% m5 B- m/ _
第一步先在这里加入串口3的初始化操作：
+ w/ E. D+ b  a2 {: T, x
: N' A/ C" s4 a- j3 h8 g

$ R* r8 D- ^! e贴一下串口3的初始化代码，这里我用到了队列，因为实际测试发现串口3接收数据量比较大的话，那么转发到USB虚拟串口的时候会丢数据，所以这里采用了缓存队列，当串口接收到的数据到达一定数据量之后才做一次转发到USB的操作，并且开启了空闲中断，作用是转发最后一包数据：

关于队列的使用可以查看我的另一篇博客：C/C++语言实现的一个缓存队列
3 a! T. ]  w$ Q$ e: R

1. /*
   
2. * myusart.c
   " \) B+ R" X6 h3 p
3. *
   
4. *  Created on: Mar 22, 2021
   ' ]8 Y0 Z, n% q: h' X! l) W) J
5. *      Author: hello
   
6. */
   
7. #include "myusart.h"
   
8. #include "myqueue.h"
   
9. 
   
10. // 队列大小，定义为USB_CDC的发送包大小
    
11. #define QUEUE_SIZE APP_TX_DATA_SIZE
    8 v' A2 Q) L% f2 }6 S" ^+ l, o
12. 
    
13. // 队列数据空间。请使用宏QALIGN4，目的是为了根据队列大小计算实际需要的队列存储空间大小并对齐4字节
    
14. uint8_t QueueBuffer[QALIGN4(QUEUE_SIZE)];
    
15. 
    
16. // 队列句柄
    ) u2 }2 ^' D* b: `# a, `
17. Queue Uart3QueueHandle = {0};
    
18. #define UART3_QUEUE_Handle (&Uart3QueueHandle)
    . d" Y% f* B/ ^" Q: S
19. 
    ( D* C' j0 {. W* H8 ]2 n+ S+ K
20. // 串口转发到USB的缓冲，定义为USB包的一半大小
    
21. static uint8_t buffer[APP_RX_DATA_SIZE >> 1];
    + c4 S0 z; Q; M5 E  \' x% g
22. 
    
23. void UART3_Init(const USBD_CDC_LineCodingTypeDef *USBD_CDC_LineCoding)
    
24. {
    
25.         __HAL_UART_DISABLE_IT(&huart3, UART_IT_RXNE);
    $ L8 l7 r) z% J# D
26. 
    . Z, F6 m. W! v* B; ^
27.         __HAL_UART_DISABLE_IT(&huart3, UART_IT_IDLE);
    . s0 B8 u3 K  |/ B. m* `( j
28. 
    
29.         HAL_UART_DeInit(&huart3);
    
30. 
    
31.         huart3.Instance = USART3;
    
32.         huart3.Init.BaudRate = USBD_CDC_LineCoding->bitrate;
    5 G$ I; ^, v/ n: J; Z/ K1 g
33.         huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    % ~( H, }. I7 F/ e8 m% r
34.         huart3.Init.Mode = UART_MODE_TX_RX;
    
35.         huart3.Init.OverSampling = UART_OVERSAMPLING_16;
    * n9 P1 {; G- T+ g( z
36. 
    
37.         switch (USBD_CDC_LineCoding->paritytype)
    ( I6 I1 L0 [: W, _
38.         {
    + s4 N8 [9 n3 T$ _+ p0 s: o
39.         case 0:
    ; I2 G' g% {/ I$ `
40.                 huart3.Init.Parity = UART_PARITY_NONE;
    
41.                 break;
    
42.         case 1:
    % E4 ]" S% K: j0 r3 V
43.                 huart3.Init.Parity = UART_PARITY_ODD;
    
44.                 break;
    
45.         case 2:
    ( X6 N; T  U% M- G' j0 y
46.                 huart3.Init.Parity = UART_PARITY_EVEN;
    9 m4 @( p9 Q6 |9 r
47.                 break;
    1 e; y+ W5 h: y: y2 T7 t4 l
48.         default:
    
49.                 huart3.Init.Parity = UART_PARITY_NONE;
    % M. P( |% y3 b# c
50.                 break;
    
51.         }
    
52. 
    + L9 z+ G5 [: G0 |
53.         switch (USBD_CDC_LineCoding->datatype)
    
54.         {
    . m  \) j- n: T/ S7 L
55.         case 0x07:
    
56.                 huart3.Init.WordLength = UART_WORDLENGTH_8B;
    
57.                 break;
    
58.         case 0x08:
    
59.                 if (huart3.Init.Parity == UART_PARITY_NONE)
    
60.                 {
    4 H' y! w9 x' ^
61.                         huart3.Init.WordLength = UART_WORDLENGTH_8B;
    
62.                 }
    8 A" K6 Q, F& [5 p
63.                 else
    % {4 n* b2 D" v$ [/ ^4 }
64.                 {
    
65.                         huart3.Init.WordLength = UART_WORDLENGTH_9B;
    
66.                 }
    
67.                 break;
    
68.         default:
    ( T- M2 m( _' h/ x
69.                 huart3.Init.WordLength = UART_WORDLENGTH_8B;
    8 M. @( @4 d0 Q! x- H; l
70.                 break;
    3 h1 X6 \6 t7 R0 Q3 a( h0 p% a
71.         }
    
72. 
    # ^( `$ \3 T# \- ?) m0 S" x# \
73.         switch (USBD_CDC_LineCoding->format)
    
74.         {
    - S& b8 d/ [7 r# D/ d/ b6 k; O
75.         case 0:
    : O0 e0 f' I& ?. l. w+ w
76.                 huart3.Init.StopBits = UART_STOPBITS_1;
    
77.                 break;
    ' F* s: }% A: s1 R5 [# Y
78.         case 2:
    / o: g4 J5 O4 m& D! p2 a' F( |
79.                 huart3.Init.StopBits = UART_STOPBITS_2;
    ' _1 I8 |+ T+ x0 s' s
80.                 break;
    1 w) K% [: \8 ?, N/ p9 |4 k7 c
81.         default:
    ( Y# V, k$ v: X4 s1 v8 Y
82.                 huart3.Init.StopBits = UART_STOPBITS_1;
    / \- v' {& D2 E
83.                 break;
    ( d' J( r! [$ H! }# {* G3 i, m) L
84.         }
    
85. 
    
86.         HAL_UART_Init(&huart3);
    8 r( D9 ?. R" @  D2 n/ @) ]
87. 
    ; ]4 m# Z2 Q  G
88.         Queue_Init(UART3_QUEUE_Handle, QUEUE_SIZE, QueueBuffer);
    " [; @: Z8 L$ x4 t  m
89. 
    0 `% v8 r# h& N+ S2 u& H5 r& h
90.         __HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);
    
91. 
    
92.         __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
    
93. }
    6 z* n+ l+ L/ b6 |( H0 o9 U
94. 
    * r/ ^. J/ n8 Z) |* h' e' B) Z
95. void USART3_IRQHandler(void)
    
96. {
    7 S1 }7 J, K) z; {
97.         static uint32_t nsent = 0;
    " ?0 @2 K  V0 n% E
98.         static uint8_t dat = 0;
    
99. 
    / z0 L! B/ W  v8 N
100.         if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE) != RESET)
     $ @9 R4 S2 J' w* g+ t$ [# I
101.         {
     % V: s0 f& B& k3 A7 \) |3 v
102.                 __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE);
     3 ^. Z7 U" Y7 d9 R0 `/ |6 p, ~5 X
103.                 dat = huart3.Instance->DR & 0XFF;
     
104.                 Queue_PutByte(UART3_QUEUE_Handle, dat);                     // 入队一个字节的数据
     & Z. y; }+ ]3 r. J- s" M3 ?/ h& l" l# h
105.                 if (Queue_GetUsed(UART3_QUEUE_Handle) >= sizeof(buffer))
     - Z" y% [- L+ N0 p3 J' O/ ]# _7 ^
106.                 {
     7 y1 e' ]4 t3 E
107.                         Queue_Read(UART3_QUEUE_Handle, buffer, sizeof(buffer));
     1 i, a  f- b6 a2 J" v  V2 A
108.                         CDC_Transmit_FS(buffer, sizeof(buffer));                // 转发到USB
     
109.                 }
     
110.         }
     ' Y8 D) V) V. J2 @: K& D8 `4 ]
111. 
     
112.         if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_IDLE) != RESET)
     + B! c9 a4 r6 M9 |! s! G
113.         {
     
114.                 nsent = Queue_GetUsed(UART3_QUEUE_Handle);
     
115.                 if (nsent != 0)
     
116.                 {
     
117.                         Queue_Read(UART3_QUEUE_Handle, buffer, nsent);
     % {2 e( @5 F" m  W- g6 Q
118.                         CDC_Transmit_FS(buffer, nsent);               // 转发到USB
     ' ~6 P( {5 G' |1 x+ G
119.                 }
     8 Z7 Q1 _# u8 T$ [% M
120.                 __HAL_UART_CLEAR_IDLEFLAG(&huart3);
     
121.         }
     
122. }
     / I; @7 d4 n7 m
123. 
     
124. void UART3_SendData(const void *buf, uint32_t len)
     / T* \! c3 ?! t
125. {
     % Z4 b9 A/ v  W. t) W
126.         const uint8_t *p = (const uint8_t*) buf;
     
127.         while (len--)
     
128.         {
     / P% V  ?- X8 X& q3 x& D& g0 O
129.                 while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
     
130.                 huart3.Instance->DR = (uint8_t) (*p++ & 0XFF);
     ! o2 u# g' q/ e: \" T- V+ A
131.                 while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
     
132.         }
     6 Z, t% S; R1 n  q- d! ]: D
133. }
     
134. 
     
135. //#ifdef __GNUC__
     
136. //#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
     - N# x4 f& a! \1 h$ U: `: H0 W
137. //#else
     9 i. s# c+ i8 |
138. //#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
     
139. //#endif
     
140. //PUTCHAR_PROTOTYPE
     ; P, h, F+ P/ ~1 t! h- R) E4 \) |
141. //{
     ) [4 _4 ^" E1 f4 f& s
142. //        while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
     
143. //        huart3.Instance->DR = (uint8_t) (ch & 0XFF);
     / e+ F% d( n' J  b4 D
144. //        while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
     
145. //        return ch;
     
146. //}
     

复制代码

7 \/ V) K1 e, g然后在添加USB转发到串口的操作：



0 T: [; z0 Y: I; u/ w& Q, F这样就实现了一个类似于USB转TTL模块的功能！
/ a# l1 }8 s2 b# E4 {
9 O; a$ A' r0 K: x. a' o: C* }5 b