一个关于STM32串口的问题。他想实现接收无限制字符数量的串口信息。

但是他遇到了一个问题，他在主函数中发送循环发送内容（500ms的延时）串口一中断回调函数中如果收到了串口内容，就利用串口发送。
1 i: O; y9 k7 y; l. {# R8 l. A" K
  Q5 ~& c' _) n- E5 L; O但是他的串口一旦接收到了信息就会导致主循环中的串口发送极快。他的主代码如下
3 b6 B4 `1 M, Q& y, @, F; i

1. unsigned char RecieveBuffer;
   $ A2 o, T3 q. n* ?3 _
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   
4.   UNUSED(huart);
   ! m- \, ^! g. }
5.   HAL_UART_Transmit(&huart1,&RecieveBuffer,8 ,100); // 将接收到的数据再通过串口发送出去
   
6.   HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8); //使能接收中断,RecieveBuffer的类型是uint8_t
   0 q! q" \+ X' B  p8 V3 T. Q
7. }

复制代码

( g* Y% z% D( y7 b4 {看了他的代码，就这么短短的7行代码，让我汗流浃背。
5 q9 j7 L5 _5 L- ]1 _2 Z/ N
他的发送和接收中有一个参数是8,这意味着当串口接收的寄存器中有8个数据时就会触发中断回调。
. H1 b4 p( p0 l) ~
4 d( V  |4 v0 O+ U7 V我们需要注意的是，串口寄存器的数据会被存储到缓存区中，这里的缓存区相当于一个队列先进先出，当我们调用HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8);
% M1 A5 U4 r0 o- o6 `4 T/ L$ N
会将RecieveBuffer作为缓存区，将串口接收的信息存入缓存区。

那么让我们来试一下这段代码。
$ d0 _, z# B! I2 o7 H

. P4 g% [0 u( ~' F
8 v% W6 S: ~9 h+ }- x: b可以看到，代码死住了。其实不难理解，我们发送数据的时候，由于缓存区只有一个字符的空间，我们发送八个字符的时候会导致缓存区溢出。所以我朋友的代码可以“正常运行”也是一件非常奇怪的事情。
" k- R  t. r+ \9 z, ?/ t9 S* b8 H
所以正确的做法应该是：设置和缓存区一样长的读取字符。
( ]5 \# a" Y5 r0 h

1. unsigned char RecieveBuffer[8];
   
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   $ W8 G9 ~6 h3 W4 I$ n. B4 y( v
3. {
   
4.   UNUSED(huart);
   5 F* s% {1 U5 p7 s, J/ c6 _: }
5.   HAL_UART_Transmit(&huart1,&RecieveBuffer,8 ,100); // 将接收到的数据再通过串口发送出去
   " S2 X0 l" U- k, a5 {5 J* W- |% G/ J
6.   HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8); //使能接收中断,RecieveBuffer的类型是uint8_t
   ' a. U: I& I$ R! r* Q
7. }

复制代码

/ E0 u5 Y7 J, ?( `) W. n8 @/ C# }这样子就可以实现每接收8个字符就调用中断一次



可以看到，我们正常的发送了8个字符。
1 J+ N0 k6 v/ z% x
; e  w- d6 _$ {3 i: h但是这样子有一个非常非常致命的缺点！

由于我们的代码每8个才会接收一次，所以当我们的发送的数量小于8时，必须发送多次才能会触发一次调用。
/ ?1 ~5 ]. G! K
注意，这里的每次我们都是先发送再接收，因为初始化的时候是启用了接收。
- y; M/ _$ t0 j4 p! d


当我们发送3次“123”时才能让接收的字符>=8，我们把前八个发送了出去，此时缓存区剩下了一个字符是“3”


0 A# e$ X% C5 `3 \( r( ?
8 S' i! y% k2 C/ {& e8 r第二次我们发送了三次“123123123”，再次让字符数量>=8，这时候把缓存区的八个“31231231”发送出去再接收后面的“23”，这时候缓存区的数据为:"23 "。



最后我们第三次发送“123”的时候，由于23 + 123 + 123 这时候，虽然这里按理来说正好八个，但是实际测下来，当这时候接收的时候系统就会卡死。
. V+ S4 R) U" B8 l$ R
# y* u" N& E, n" f+ Q' Z7 b所以，实际上这种方法必须保证发送端的数据是完完整整的八个八个发送，多一个少一个都不行。
$ _5 J5 l9 |6 E  C- {
* C0 D$ h4 S: O
解法
事实上最标准的做法是单个字符单个字符处理。定义一个大的缓存区，用来存储接收到的字符并且确立一个结束符来确定数据流的结束。

1. if((USART_RX_STA&0x8000)==0)//接收未完成
   7 N& x. K( e; c9 r
2. {
   7 A; a) E$ V* j' c$ `1 o: q# G
3.   if(USART_RX_STA&0x4000)//接收到了0x0d
   , E7 v) G/ c7 J. [4 [& g$ L4 ^2 n
4.   {
   ) v1 P% A- I( O  t! G0 K. @1 i$ o
5.     if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
   
6.     else USART_RX_STA|=0x8000;  //接收完成了
   
7.   }
   
8.   else //还没收到0X0D
   , C& n& a( E$ f1 t( D
9.   {  
   
10.     if(Res==0x0d)USART_RX_STA|=0x4000;
    7 G7 b2 S0 S$ {, p
11.     else
    1 U: @& a9 \  y& ]) p
12.     {
    
13.       USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
    
14.       USART_RX_STA++;
    
15.       if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收   
    " t  @* P+ N, I/ R
16.     }     
    0 Q3 E# }* a" d3 x
17.   }
    % p. S/ S1 S+ J$ ]% |/ n
18. }

复制代码

, T) i( A' u9 d3 V, x
: P3 a, z  \6 n% W! p" g6 T
" k1 t( D$ @) B上述是正点原子的官方例程，其中USART_RX_STA是接收到的字符，即是确定一个结束符\r\n来作为一串字符的结尾并且检测长度是否超出长度。

这样子的代码容错率非常高，也确定了一个规范，并且避免了缓存区溢出的情况。


转载自：电路小白
: i& k' b4 p, s, M) G+ i8 ]* @$ u如有侵权请联系删除