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

6 a+ D, y3 M1 J! S但是他遇到了一个问题，他在主函数中发送循环发送内容（500ms的延时）串口一中断回调函数中如果收到了串口内容，就利用串口发送。

但是他的串口一旦接收到了信息就会导致主循环中的串口发送极快。他的主代码如下
/ D, x1 u; `5 X2 _( Y7 B" T8 ?

1. unsigned char RecieveBuffer;
   
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   , W+ I% U8 ~% ]( @/ R4 l; _
3. {
   0 V4 {4 Y; o- C9 b, F
4.   UNUSED(huart);
   
5.   HAL_UART_Transmit(&huart1,&RecieveBuffer,8 ,100); // 将接收到的数据再通过串口发送出去
   9 w2 c" t: K  [
6.   HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8); //使能接收中断,RecieveBuffer的类型是uint8_t
   
7. }

复制代码

看了他的代码，就这么短短的7行代码，让我汗流浃背。

# v3 u$ N" o9 [0 {" r他的发送和接收中有一个参数是8,这意味着当串口接收的寄存器中有8个数据时就会触发中断回调。
4 X5 C+ g& F' N! Z) [5 B2 t( k5 Z
我们需要注意的是，串口寄存器的数据会被存储到缓存区中，这里的缓存区相当于一个队列先进先出，当我们调用HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8);

会将RecieveBuffer作为缓存区，将串口接收的信息存入缓存区。
* M( I  ~, ]! Y) }) `7 i8 j9 ?3 U+ p
那么让我们来试一下这段代码。
% |8 l9 a6 c. l7 j

! p- s% e  i4 }9 q# c/ @& `$ [! d! J
可以看到，代码死住了。其实不难理解，我们发送数据的时候，由于缓存区只有一个字符的空间，我们发送八个字符的时候会导致缓存区溢出。所以我朋友的代码可以“正常运行”也是一件非常奇怪的事情。
3 l7 s9 o: T/ ?9 B
所以正确的做法应该是：设置和缓存区一样长的读取字符。
/ h3 |' [. ?# H
( O- `5 V  v; @( p. r, O; J

1. unsigned char RecieveBuffer[8];
   . E: O6 s( [  ]& s& K
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   
4.   UNUSED(huart);
   1 ~3 |; j0 m6 j
5.   HAL_UART_Transmit(&huart1,&RecieveBuffer,8 ,100); // 将接收到的数据再通过串口发送出去
   1 f! H0 c* `" S
6.   HAL_UART_Receive_IT(&huart1,&RecieveBuffer,8); //使能接收中断,RecieveBuffer的类型是uint8_t
   
7. }

复制代码

这样子就可以实现每接收8个字符就调用中断一次

; V$ A' t. @' A2 v* F

, B2 O( d4 t  m( E9 ^( Z' h1 S- V可以看到，我们正常的发送了8个字符。
: Z6 s1 b3 V% F2 ?* p- M
! f3 l% \- S1 j% P8 k$ c0 v0 J$ `但是这样子有一个非常非常致命的缺点！

5 u- Z$ w+ }; I5 `2 p由于我们的代码每8个才会接收一次，所以当我们的发送的数量小于8时，必须发送多次才能会触发一次调用。

注意，这里的每次我们都是先发送再接收，因为初始化的时候是启用了接收。



当我们发送3次“123”时才能让接收的字符>=8，我们把前八个发送了出去，此时缓存区剩下了一个字符是“3”
6 V4 S* m1 V! ?, H5 l; x* b. N
, m* |2 I8 Q7 ~- o9 d0 l8 l

5 O1 r+ ?- I5 y% X  Y第二次我们发送了三次“123123123”，再次让字符数量>=8，这时候把缓存区的八个“31231231”发送出去再接收后面的“23”，这时候缓存区的数据为:"23 "。
) `4 J  ^( }7 b* Y% G8 d. c


最后我们第三次发送“123”的时候，由于23 + 123 + 123 这时候，虽然这里按理来说正好八个，但是实际测下来，当这时候接收的时候系统就会卡死。
0 S8 s+ E, P1 a6 Z* g/ I( J
所以，实际上这种方法必须保证发送端的数据是完完整整的八个八个发送，多一个少一个都不行。
+ E" i. g6 `7 ~
' H) m: {& Z% C. J% N2 V
解法
事实上最标准的做法是单个字符单个字符处理。定义一个大的缓存区，用来存储接收到的字符并且确立一个结束符来确定数据流的结束。

1. if((USART_RX_STA&0x8000)==0)//接收未完成
   / f& D1 \# J9 {0 m# j/ K0 `
2. {
   # l2 e/ D  t1 Y9 s8 g+ Y" Z+ s& v
3.   if(USART_RX_STA&0x4000)//接收到了0x0d
   0 e  p9 d4 @0 i
4.   {
   
5.     if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
   
6.     else USART_RX_STA|=0x8000;  //接收完成了
   ; q" ]* _- o) f# x- o4 D# Y+ ]. ]
7.   }
   " X0 F1 k; [: {2 g6 a' S1 C3 P
8.   else //还没收到0X0D
   , b+ [  S, B& e
9.   {  
   , f( Y* E1 s$ [2 C5 W+ o
10.     if(Res==0x0d)USART_RX_STA|=0x4000;
    
11.     else
    ( G1 ?, q9 {) U: X% o
12.     {
    6 R" a2 h4 }5 R- O5 l
13.       USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
    
14.       USART_RX_STA++;
    ' n) z! e9 Z# \: I1 u
15.       if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收   
    ' l# s5 r2 b' ^2 T
16.     }     
    6 _5 G6 G- R+ e5 Q* C0 y
17.   }
    
18. }

复制代码

! P5 |3 p! L1 y8 @; h) U2 }

上述是正点原子的官方例程，其中USART_RX_STA是接收到的字符，即是确定一个结束符\r\n来作为一串字符的结尾并且检测长度是否超出长度。

) [1 e4 y. Q0 B  h这样子的代码容错率非常高，也确定了一个规范，并且避免了缓存区溢出的情况。
0 s$ j4 g4 Q8 i$ R4 I
) G* E* K7 m2 I3 L
转载自：电路小白
$ L5 V6 j# Z: s$ s4 a* p$ S) y如有侵权请联系删除
9 C' |+ V8 A& G