% o" F/ W% [3 Q/ @+ U$ a! E
: R* p7 k2 e. m3 N8 F; Q0 B- r0 j5 c看到大家经常写一些关于串口的问题，我也尝试开一个使用串口的工程。
% H+ S( t1 |% I) ]3 V4 d简单的要求是，USART1和USART2之间互相转发。
- ~8 E5 S6 `$ }$ E4 P发现使用CubeMX平台，建立测试工程没有难度，情况如下：
* @: k9 }/ f% ~$ `$ I7 [! M
1. 配置管脚，使用BluePill最小板，PC13接有LED：
4 s- c- M& d: P& D/ ], s# QMCU是STM32F103C8T6，这个不重要. 不要忘记配置SWD调试接口。
' {3 a' Z1 {0 O

2. 配置时钟，重点已经标出：


9 w5 Z4 y5 t. K' w3. 配置中断选项，由于不使用DMA，可以不理DMA的选项：
（USART2也要同样配置）
4 P: I+ [) R% i" _, A. g
1 Q: V6 n  p. x4 C* e
9 m! s4 A) I5 J（然后，生成工程代码）

4. 添加代码
1 M1 n0 r+ p- j: Y- w. @% K4.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

复制代码

, X! M3 k5 ~. a: q# f8 N
) t3 z+ u# ^3 H8 {8 \0 n; i( Q3 Q& L

4.2 打开stm32f1xx_it.c，在前面添加接收缓存结构体：

1. /* USER CODE BEGIN 0 */
   
2. #define UART_BUFFER_SIZE    64 //here must be 2^n
   
3. struct bufer_st {
   
4.   unsigned int in;                // Next In Index
   ' ]+ F$ W. \) k7 O3 o6 j3 W
5.   unsigned int out;               // Next Out Index
   ' j( e' `$ u) ]) d
6.   char buffer [UART_BUFFER_SIZE]; // Buffer
   3 s3 D/ ]3 U% j+ |( P+ ?: _/ z
7. };
   : |4 q2 I7 P; ?+ I3 Y
8. static struct bufer_st uart1buffer = { 0, 0, };
   
9. static struct bufer_st uart2buffer = { 0, 0, };
   
10. /* USER CODE END 0 */

复制代码

* n( ^- C0 a& D+ Q
: @1 L: J* |; S5 k  k/ h1 g" j4 z

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

1. /**
   
2. * @brief This function handles USART1 global interrupt.
   
3. */
   
4. void USART1_IRQHandler(void)
   + v: s$ X2 x) I8 ^( E" Y* ?
5. {
   9 |1 i% x& _% w+ ]( B
6.   /* USER CODE BEGIN USART1_IRQn 0 */
     T, z( f9 D* f1 i2 D
7.   struct bufer_st *p;
   ; }! Y, R8 y/ a
8.   /* USER CODE END USART1_IRQn 0 */
   
9.   HAL_UART_IRQHandler(&huart1);
   
10.   /* USER CODE BEGIN USART1_IRQn 1 */
    ! p( d8 e1 y9 k& M
11.   p = &uart1buffer; //use UART1 buffer
      u5 k! c0 x1 j2 ^$ i) k) V
12.   
    . y/ O6 g9 d1 ~8 d  D% P: `! ~$ G
13.   //raed UART1
    
14.   if (USART1->SR & UART_IT_RXNE) // read interrupt
    % g5 t8 W+ D' B* Q$ U
15.   {                  
    ( a& n6 y1 \/ N* t+ ]+ y! ^
16.     USART1->SR &= ~UART_IT_RXNE; // clear interrupt
    1 Y2 M; Z2 u5 q) w3 |
17. 
    : S! H# B' F* \5 ^8 @0 u
18.     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0) {
    % t; t+ {) p* z  o
19.       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART1->DR & 0xFF); //read DATA
    ! K8 Y/ P7 o3 h
20.       p->in++;
    4 a& F6 J! t2 l8 C
21.     }
    / f; b% x0 \2 J, L% n
22.   }
    
23.   //send to UART2
    ; n0 f2 x# |2 b1 S2 {" q% g
24.   if (p->in != p->out)
    ( f0 R! V$ y4 \: e6 h
25.   {
    
26.     USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out
    
27.     p->out++;
    , y! N; n$ s& N
28.   }
    + \: _9 o' l0 p  |/ T% r! I
29.   /* USER CODE END USART1_IRQn 1 */
    " I" a7 u, l2 o/ z
30. }
    
31. 
    
32. /**
    . Z0 X  B4 P$ w( a( x
33. * @brief This function handles USART2 global interrupt.
    
34. */
    
35. void USART2_IRQHandler(void)
    2 j4 G! p0 U' C0 ?  F4 `" P, j; `2 {
36. {
    - q$ \8 u, ~/ H) I3 i( V
37.   /* USER CODE BEGIN USART2_IRQn 0 */
    
38.   struct bufer_st *p;
    % f! u; Q. J5 S9 e
39.   /* USER CODE END USART2_IRQn 0 */
    
40.   HAL_UART_IRQHandler(&huart2);
    / S) h# S% ?  l' n$ o! |8 [9 y5 r) o
41.   /* USER CODE BEGIN USART2_IRQn 1 */
    " P, H$ c! c* C, |
42.   p = &uart2buffer; //use UART2 buffer
    
43.   
    ' L% A7 p% U4 p1 h: _2 C; C
44.   //raed UART2
      R  z# Y  f8 L: d8 g
45.   if (USART2->SR & UART_IT_RXNE) // read interrupt
    
46.   {                  
    ! \( a* Y* ?4 J
47.     USART2->SR &= ~UART_IT_RXNE; // clear interrupt
    
48. 
    
49.     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0)
    " V3 P* A# x8 o( x% s/ S4 h
50.     {
    
51.       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART2->DR & 0xFF); //read DATA
      U" {+ w0 H, Y% Z5 e) c6 z
52.       p->in++;
    % ^9 X. Y/ q- Z" e8 ]
53.     }
    ! O( l8 a8 _  e0 b# d4 b
54.   }
    0 S8 n. H( N; I  V% v5 {+ f
55.   //send to UART1
    
56.   if (p->in != p->out)
    
57.   {
    . L! ?/ a( F. ?% P& |
58.     USART1->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out
    
59.     p->out++;
    
60.   }
    
61.   /* USER CODE END USART2_IRQn 1 */
    # x' o6 v7 K. ?( C: Y+ n
62. }

复制代码

（看得出，中断里面是收到一个字符发送一个字符。 发送是直接发送，不处理发送中断。）

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

: L9 E, W0 ~3 n! A8 n* j  Z

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

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

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

7 W1 b6 J  u" ]' t

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

. D1 R' ~6 _, J

) |+ M0 ]1 i$ Y6 z& N; E
谢谢楼主，解决了我的HAL库不能单字节中断收发的问题！

• 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 */
• }
• 
    G, k; ?" [5 F" T; S+ U) t

: X6 ^: u( C) Q) r

wwwheihei 发表于 2018-8-14 08:30
, I4 v2 E% v) [6 ]1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
% x( O8 y; J1 y/ G6 X2 k2.写入dr寄存 ...

6 s; D8 A7 j  f/ S# a( u0 n! Y1. 同意您的说法，数组并不重要。反正是收到一个字节发送一个字节。
3 @$ m! K* q  f1 V2. 串口的速度，相对于MCU的运行速度是慢太多，由于收发的速度相同，近似于“同步状态”，接收和发送是受硬件控制同时进行的，收到一个字节，触发中断进行处理，处理中断这个时候，上一个字节刚好发送完成。所以不会重叠的。

6 ^% Q: m4 H4 v: j

radio2radio 发表于 2018-8-13 19:42
. R) l4 Z% \* \3 J  @不会，因为收到1个字节之后发送一个字节，写入DR是瞬间完成，收发速度相同，不会有重叠的。
  w9 [' }8 X( Z. t. X- S ...

) a% Y- W! W5 [% ^1 t0 n5 h1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
2.写入dr寄存器很快，但是发送完成又是另外一会事情

学习了

谢谢分享！

不错

看标题以为采用DMA

USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收发

当你把数据送到dr寄存器后，你没判断发送完成寄存器啊？会不会覆盖数据呢？
  N9 u( p7 C# y: P* d# u: |

wwwheihei 发表于 2018-8-13 17:22
+ P$ c6 j+ |, ~USART2->DR = (p->buffer & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收 ...

不会，因为收到1个字节之后发送一个字节，写入DR是瞬间完成，收发速度相同，不会有重叠的。
  D9 p  H7 a# T# }2 f, l7 G

radio2radio 发表于 2018-8-14 10:23
9 E& a6 n/ |/ a& ?& C4 ]# e1. 同意您的说法，数组并不重要。反正是收到一个字节发送一个字节。
2. 串口的速度，相对于MCU的运行速度 ...

4 t  E2 m+ W- _8 Y$ Z$ W我用国产的，gd32试过 丢失数据严重，不是每个芯片都能这么搞

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

收藏

学习了

学习一下，谢谢