看到大家经常写一些关于串口的问题，我也尝试开一个使用串口的工程。
+ g9 S9 E, L! J. I+ X1 P0 g简单的要求是，USART1和USART2之间互相转发。
发现使用CubeMX平台，建立测试工程没有难度，情况如下：
( d- w; U' y% I  N
1. 配置管脚，使用BluePill最小板，PC13接有LED：
6 w3 C, s7 p7 R  P$ n1 fMCU是STM32F103C8T6，这个不重要. 不要忘记配置SWD调试接口。

9 F: J$ q' N0 F  P
3 M' T  c* O- s4 l$ A  ]6 q6 K2. 配置时钟，重点已经标出：

. a* }4 V/ G  I) s/ i5 G- g
3. 配置中断选项，由于不使用DMA，可以不理DMA的选项：
（USART2也要同样配置）
' m2 y: u( I  A  i

- b& R4 O4 k+ G（然后，生成工程代码）
1 d4 o5 Z! b+ |( F* r6 b/ L5 U4 q
6 ]& H9 P5 f* I; U9 h4 J4. 添加代码
4.1 在main的初始化部分，添加接收中断使能：

1. __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); //enable Rx INT
   
2. __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); //enable Rx INT

复制代码

4.2 打开stm32f1xx_it.c，在前面添加接收缓存结构体：
3 S% H3 N# E2 ?0 T8 e

1. /* USER CODE BEGIN 0 */
   8 E) m* _- a' y5 A& N. q- J" W
2. #define UART_BUFFER_SIZE    64 //here must be 2^n
   ( U- }! M2 m/ p9 P4 i9 }
3. struct bufer_st {
   + B; I, Q% N5 d( b. z6 S) N1 R
4.   unsigned int in;                // Next In Index
   " |- }0 [0 v  i% h1 I# R: `
5.   unsigned int out;               // Next Out Index
   6 \( r* d4 u4 M7 Z: B9 G
6.   char buffer [UART_BUFFER_SIZE]; // Buffer
   : Y+ ]7 n3 P2 x0 f+ i$ c
7. };
   
8. static struct bufer_st uart1buffer = { 0, 0, };
   . e3 r( q! J5 u
9. static struct bufer_st uart2buffer = { 0, 0, };
   
10. /* USER CODE END 0 */

复制代码

' W/ k3 y7 X. k* {$ g

4.3 在stm32f1xx_it.c的底下，修改USART1和USART2的中断服务程序如下：

1. /**
   
2. * @brief This function handles USART1 global interrupt.
   $ j! S3 ]5 B4 G
3. */
   
4. void USART1_IRQHandler(void)
   
5. {
   
6.   /* USER CODE BEGIN USART1_IRQn 0 */
   4 s" s5 ^% S0 u& R
7.   struct bufer_st *p;
   
8.   /* USER CODE END USART1_IRQn 0 */
   
9.   HAL_UART_IRQHandler(&huart1);
   % X; i* S3 I5 X% {5 v
10.   /* USER CODE BEGIN USART1_IRQn 1 */
    
11.   p = &uart1buffer; //use UART1 buffer
    4 ?2 m% G$ h1 o1 H# H  @( s! j
12.   
    2 ^# d  q" Z) v& F, p6 I, N/ L% W
13.   //raed UART1
    $ M9 B8 J) F( Q/ z8 z7 I' o
14.   if (USART1->SR & UART_IT_RXNE) // read interrupt
    
15.   {                  
    
16.     USART1->SR &= ~UART_IT_RXNE; // clear interrupt
    
17. 
    / c1 B' \3 m4 B- I  t( c
18.     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0) {
    
19.       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART1->DR & 0xFF); //read DATA
    ( j, Y, S' B4 X0 Y) B
20.       p->in++;
    5 T3 ]1 h7 j) T. h6 o/ f
21.     }
    
22.   }
    9 [" `$ c/ F' B/ `% y' }
23.   //send to UART2
    ( K- h# H+ M# c" C; d1 q' s
24.   if (p->in != p->out)
      A! ]& }( R/ F
25.   {
    ) w$ z! t# }; L) X
26.     USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out
    
27.     p->out++;
      r+ x& d) B# t
28.   }
    
29.   /* USER CODE END USART1_IRQn 1 */
    
30. }
    4 E7 t4 L4 R- s
31. 
    
32. /**
    ( g' H$ n9 V* T9 f# i$ D+ X: O
33. * @brief This function handles USART2 global interrupt.
    
34. */
    
35. void USART2_IRQHandler(void)
    : R  m, w. ?( i( A4 {( l! \1 a4 D
36. {
    
37.   /* USER CODE BEGIN USART2_IRQn 0 */
    
38.   struct bufer_st *p;
    
39.   /* USER CODE END USART2_IRQn 0 */
    
40.   HAL_UART_IRQHandler(&huart2);
    
41.   /* USER CODE BEGIN USART2_IRQn 1 */
    
42.   p = &uart2buffer; //use UART2 buffer
    
43.   
    
44.   //raed UART2
    
45.   if (USART2->SR & UART_IT_RXNE) // read interrupt
    
46.   {                  
    4 r1 F' q* m: ~; V$ k# V4 r
47.     USART2->SR &= ~UART_IT_RXNE; // clear interrupt
    
48. 
    4 e# c& {4 j: i5 V, V
49.     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0)
    % e4 \2 x( O& r8 P5 F1 l' g2 }
50.     {
    ; y  {9 |- i( H8 w, @
51.       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART2->DR & 0xFF); //read DATA
    : Z7 U- \/ H3 h1 N. j
52.       p->in++;
    9 i! q, W) {! N7 H: A) Y" D" I
53.     }
    
54.   }
    + L# d  J5 `8 U9 g6 [" D5 l
55.   //send to UART1
    
56.   if (p->in != p->out)
    
57.   {
    2 ^! p$ z' ?' j* v0 Z; y  j& Z4 o
58.     USART1->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out
    5 {1 }" j0 Z# u
59.     p->out++;
    
60.   }
    
61.   /* USER CODE END USART2_IRQn 1 */
    / G9 r9 W) k0 v  l& o/ D+ |
62. }

复制代码

. n0 O  o+ m! c9 u; [  f1 b9 X（看得出，中断里面是收到一个字符发送一个字符。 发送是直接发送，不处理发送中断。）

8 d# ]- c' y. z, M0 P& h% k

大功告成了！！ 编译后烧录。

" }. j& ]! W2 T, [! k2 f2 O

测试条件，使用两个UART转USB板子（FTDI）和sscom5上位机程序（开两个），发送区都摆放700多个字符，以10ms的间隔连续发送。

测试结果，速度115200bps和1Mbps，双向同时收发100万字符无差错。 2Mbps，单方向100万字符无差错。

（高速测试时，需要修改main.c里面的串口速度BaudRate配置。 我没有测试“自动波特率”的模式是否正常。）

* ]6 z6 V! E( |# T

最后，完整的工程见附件。

  q0 F% B4 [7 X! M' j

4 A2 Z4 C! t; H谢谢楼主，解决了我的HAL库不能单字节中断收发的问题！
1 B! ]" }( e: R, ?

• void USART1_IRQHandler(void)
• {
•   /* USER CODE BEGIN USART1_IRQn 0 */
•   struct bufer_st *p;
•   /* USER CODE END USART1_IRQn 0 */
•   HAL_UART_IRQHandler(&huart1);
•   /* USER CODE BEGIN USART1_IRQn 1 */
•   p = &uart1buffer; //use UART1 buffer
•   //raed UART1
•   if (USART1->SR & UART_IT_RXNE) // read interrupt
•   {
•     USART1->SR &= ~UART_IT_RXNE; // clear interrupt
•     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0) {
•       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART1->DR & 0xFF); //read DATA
•       p->in++;
•     }
•   }
•   //send to UART2
•   if (p->in != p->out)
•   {
•     USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收发
•     p->out++;
•   }
•   /* USER CODE END USART1_IRQn 1 */
• }
• 
  % T" w& u9 C; C

8 Z" m* B/ ]: Q. a, z3 T0 t

wwwheihei 发表于 2018-8-14 08:30
5 s. j9 n9 \1 L; t) h' _  d" \1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
2 R7 R9 {; R" g* m  c3 p  w7 E2.写入dr寄存 ...

1. 同意您的说法，数组并不重要。反正是收到一个字节发送一个字节。
  K+ v  H, {+ E9 [2. 串口的速度，相对于MCU的运行速度是慢太多，由于收发的速度相同，近似于“同步状态”，接收和发送是受硬件控制同时进行的，收到一个字节，触发中断进行处理，处理中断这个时候，上一个字节刚好发送完成。所以不会重叠的。

* `$ C0 q, f. y& b

radio2radio 发表于 2018-8-13 19:42
2 ~* y* b- _" f2 ^( L不会，因为收到1个字节之后发送一个字节，写入DR是瞬间完成，收发速度相同，不会有重叠的。
...

1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
2.写入dr寄存器很快，但是发送完成又是另外一会事情

学习了

谢谢分享！

不错

看标题以为采用DMA

USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收发
+ K" [4 H+ @, N0 |$ ]7 B4 B8 G. z
2 f# r+ O0 M3 P" v3 M当你把数据送到dr寄存器后，你没判断发送完成寄存器啊？会不会覆盖数据呢？

wwwheihei 发表于 2018-8-13 17:22
3 a2 p% Q+ {" T5 K8 m: yUSART2->DR = (p->buffer & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收 ...

* P$ u* Z7 N! b! \不会，因为收到1个字节之后发送一个字节，写入DR是瞬间完成，收发速度相同，不会有重叠的。

radio2radio 发表于 2018-8-14 10:23
1. 同意您的说法，数组并不重要。反正是收到一个字节发送一个字节。
2. 串口的速度，相对于MCU的运行速度 ...

$ f8 J- U* e+ `我用国产的，gd32试过 丢失数据严重，不是每个芯片都能这么搞

你这个方案有两个地方可以讨论下，一是转发双方如果速率不同，就需要进行流控制管理；二是如果速率过高，中断会很频繁，这将导致系统中其他程序的实时性变差，最好用DMA

收藏

学习了

学习一下，谢谢