z: T! U! j8 X/ D* c/ d
+ P8 ~; T8 R2 N: U$ [+ p7 ?8 }; H% f4 U) Q看到大家经常写一些关于串口的问题，我也尝试开一个使用串口的工程。
简单的要求是，USART1和USART2之间互相转发。
- \& K8 J1 X9 `+ R. C5 p  N& ~发现使用CubeMX平台，建立测试工程没有难度，情况如下：
1 H6 e, ~) H, n! R
; v- T0 |: [7 S8 z6 g1. 配置管脚，使用BluePill最小板，PC13接有LED：
( R# y+ P* I% d7 Q# g* v+ yMCU是STM32F103C8T6，这个不重要. 不要忘记配置SWD调试接口。

& [$ ~4 F' ?  Y* X( i2 A* [% c
4 K. ^( q7 w  H2 {! C$ _2. 配置时钟，重点已经标出：

5 j% G. s- }$ w- h, H' s, A
3. 配置中断选项，由于不使用DMA，可以不理DMA的选项：
" d8 K3 J9 {' y; I* V8 \9 _8 x: Q（USART2也要同样配置）
- m- |0 r! [9 o& |; F
3 n+ ~& M3 |7 `. ~2 V! |
（然后，生成工程代码）

$ L7 ~: E6 U3 v& b# m4. 添加代码
4.1 在main的初始化部分，添加接收中断使能：
# e) v7 L4 l- T

1. __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); //enable Rx INT
   5 d/ {+ ^7 {7 e  b- _# x9 p# \
2. __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); //enable Rx INT

复制代码

- O* ^; R1 r; N, I5 V
' I6 o8 H; J# H5 B

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

1. /* USER CODE BEGIN 0 */
   ; d  ~7 F* i/ p- S- @
2. #define UART_BUFFER_SIZE    64 //here must be 2^n
   
3. struct bufer_st {
   
4.   unsigned int in;                // Next In Index
   
5.   unsigned int out;               // Next Out Index
   # ?( K  K0 C6 h$ n! e: n
6.   char buffer [UART_BUFFER_SIZE]; // Buffer
   
7. };
   
8. static struct bufer_st uart1buffer = { 0, 0, };
   + R; v. N) o# O5 c, \, s
9. static struct bufer_st uart2buffer = { 0, 0, };
   6 j2 G4 |7 R! f. I' Q8 O: Z$ v
10. /* USER CODE END 0 */

复制代码

9 c. q- Y" o; A- E) X

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

1. /**
   ! }5 u" X) A, L! t' L& B& o5 s
2. * @brief This function handles USART1 global interrupt.
   ; [+ K4 c  z: X" O
3. */
   ' a2 M: _, e) z# p" d# W  K
4. void USART1_IRQHandler(void)
   / \8 e. ^& I$ @2 Z, l
5. {
   
6.   /* USER CODE BEGIN USART1_IRQn 0 */
   3 {; t! r4 I5 w
7.   struct bufer_st *p;
   
8.   /* USER CODE END USART1_IRQn 0 */
   9 O% R  ~% t  ]  d) ?1 F& G' A4 E! Y, x1 }
9.   HAL_UART_IRQHandler(&huart1);
   * B$ ~5 X, e' c7 ?: _! b) g, M
10.   /* USER CODE BEGIN USART1_IRQn 1 */
    
11.   p = &uart1buffer; //use UART1 buffer
    0 o' W( W4 V3 [* i2 H4 S: \# A
12.   
    5 |/ j: T8 k) |3 b
13.   //raed UART1
    
14.   if (USART1->SR & UART_IT_RXNE) // read interrupt
    
15.   {                  
    
16.     USART1->SR &= ~UART_IT_RXNE; // clear interrupt
      _! C6 @, F6 X+ m* u
17. 
    
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
      E. d. F7 w8 I" ]. o+ [
20.       p->in++;
    - b: v3 _$ L, T2 r/ X
21.     }
    ' p, l; O: j7 e$ Q
22.   }
    2 ~# J2 P4 I% R5 l) V
23.   //send to UART2
    - a5 j7 U- c$ b- U
24.   if (p->in != p->out)
    / l, `: r2 G; a& ]8 E! @5 o
25.   {
    0 u' N/ Q3 a4 K2 i/ I" l; d
26.     USART2->DR = (p->buffer[p->out & (UART_BUFFER_SIZE-1)] & 0xFF); //send out
    0 `+ `3 U- P6 o
27.     p->out++;
    
28.   }
    ! A. w  ?/ a. r; `( G
29.   /* USER CODE END USART1_IRQn 1 */
    
30. }
    
31. 
    
32. /**
    
33. * @brief This function handles USART2 global interrupt.
    
34. */
    0 ^/ C; H+ F1 p+ i
35. void USART2_IRQHandler(void)
    " G4 G7 I" E( {
36. {
    
37.   /* USER CODE BEGIN USART2_IRQn 0 */
    + o" D5 n9 ^$ @# ~5 o; k4 `
38.   struct bufer_st *p;
    
39.   /* USER CODE END USART2_IRQn 0 */
    
40.   HAL_UART_IRQHandler(&huart2);
      E/ w: h$ q, |! f( s" v
41.   /* USER CODE BEGIN USART2_IRQn 1 */
    5 q1 E' W8 W, l* `4 B8 S
42.   p = &uart2buffer; //use UART2 buffer
    
43.   
    
44.   //raed UART2
    
45.   if (USART2->SR & UART_IT_RXNE) // read interrupt
    
46.   {                  
    . @5 \! C; m% d; ^% d4 L3 `# v( E4 ]
47.     USART2->SR &= ~UART_IT_RXNE; // clear interrupt
    * f: v2 {# P3 ?! O( {' b4 H
48. 
    
49.     if (((p->in - p->out) & ~(UART_BUFFER_SIZE-1)) == 0)
    
50.     {
    : V4 n( W4 a, y( ~
51.       p->buffer[p->in & (UART_BUFFER_SIZE-1)] = (USART2->DR & 0xFF); //read DATA
    
52.       p->in++;
    ; Q" {) N. h0 Q: N8 J" s- D
53.     }
    
54.   }
    
55.   //send to UART1
    7 ?9 u, e5 \3 u. x1 N0 E$ d
56.   if (p->in != p->out)
    
57.   {
    # s% G1 T6 l: L
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 */
    
62. }

复制代码

5 L  _4 U" ~' k- t! L2 _- j, L7 x3 M（看得出，中断里面是收到一个字符发送一个字符。 发送是直接发送，不处理发送中断。）

' K6 E/ G, y0 w2 h* k

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

5 x# l; A0 _9 \( e. X* _

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

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

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

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

7 I9 G3 P, q2 T4 b; v

% z$ R/ `' i5 u4 A3 I( s% P
谢谢楼主，解决了我的HAL库不能单字节中断收发的问题！
: d6 k: t; a8 \- {* r/ a

• 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 */
• }
• 
  

  m7 G( C( G7 j4 K( e8 s

wwwheihei 发表于 2018-8-14 08:30
/ ?7 ]) P  r  @9 g( l1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
2.写入dr寄存 ...

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

0 F$ {) t9 @5 a6 K% ~

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

1.那你搞的那个数组有啥用啊，看似环形数组，那还不如直接收到一个数据然后直接给dr寄存器，
0 Y2 V! A$ U" t! w+ P5 _3 ?2.写入dr寄存器很快，但是发送完成又是另外一会事情

学习了

谢谢分享！

不错

看标题以为采用DMA

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

' [& d$ X# F* Z% b' O当你把数据送到dr寄存器后，你没判断发送完成寄存器啊？会不会覆盖数据呢？

wwwheihei 发表于 2018-8-13 17:22
/ d( S( `0 `$ o8 U/ a+ {( W* I; Y3 pUSART2->DR = (p->buffer & 0xFF); //send out，此处我将USART2修改成USART1，就能实现每个字节接收中断收 ...

8 r, n& i. O: K: v+ N4 j- x不会，因为收到1个字节之后发送一个字节，写入DR是瞬间完成，收发速度相同，不会有重叠的。
( b* U& a4 y/ E; G  E7 ]

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

我用国产的，gd32试过 丢失数据严重，不是每个芯片都能这么搞

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

收藏

学习了

学习一下，谢谢