STM32串口中断接收不定长报文并解析

功能实现背景介绍
8 H( ~5 k  f) X/ C3 `( \8 f5 y. O本项目中，需要使用STM32的USART6串口与FPGA板（下位机）通信，需要发送和接收数据，有报文应答机制。
使用的报文规则如表格所示

3 k: F1 J( ]5 Z7 |, P7 v板间报文的通信协议，校验使用的是和校验
. c4 j: h% B& [  M& z$ c

1. <font size="3">U8 TX_CheckSum(U8 *buf, U8 len) //buf为数组，len为数组长度
   
2. {
     Q8 t9 [4 Z5 ^# V, L
3.     U8 i, ret = 0;
   
4.     for(i=0; i<len; i++)
   
5.     {
   : \% M* V1 J% a
6.         ret += *(buf++);
   
7.     }
   
8.      ret = ~ret;
   # \- w; F; o7 W6 ^- ?: `# @' r
9.     return ret;
     c/ l1 @& D) R' `) O$ I
10. }
    
11. U8 RX_CheckSum(U8 *buf, U8 len) //buf为数组，len为数组长度
    / s8 M8 h, {- z7 m8 S/ e2 u
12. {
    
13.     U8 i, ret = 0;
    
14.      for(i=0; i<len; i++)
    
15.     {
    
16.         ret += *(buf++);
    
17.     }
    ; \. g  f& _% F; ]
18.     ret = ret;
    
19.     return ret+1;
    " N6 ?5 I7 A" S9 o9 D7 v
20. }</font>

复制代码

1 K5 F6 ?* c( s! z1 S8 K发送和接收的报文要满足不定长
# f8 {# m* y$ V' q0 N3 lHAL库的中断接收函数
如果要直接使用HAL库的中断接收函数，也就是HAL_UART_Receive_IT()函数
7 O# ^/ M) Y& i/ {

1. HAL_UART_Receive_IT(&huart6,UART6_RxBuffer,5);              //下位机FPGA

复制代码

2 g: U. ]9 P3 J! k+ T0 R8 ?# q
在使用时，选择串口，选择接收的缓冲区，选择接收长度。
$ r: Y# g" A# h: R4 v: O5 E! o
3 M0 |( `: r' `1 R1 e
8 D0 E; {) x. _% D5 s" `- ]! Q9 `

1. /**
   " Z9 a% \5 d9 M1 R9 k' Y
2.   * @brief  Receives an amount of data in non blocking mode.
   7 j; Z5 K; w7 x$ Y7 E
3.   * @note   When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
   
4.   *         the received data is handled as a set of u16. In this case, Size must indicate the number
   
5.   *         of u16 available through pData.
   
6.   * @param  huart Pointer to a UART_HandleTypeDef structure that contains
   - N1 U5 p/ V3 v9 |. v
7.   *               the configuration information for the specified UART module.
   " c! H6 b8 E4 X. i1 }; S
8.   * @param  pData Pointer to data buffer (u8 or u16 data elements).
   
9.   * @param  Size  Amount of data elements (u8 or u16) to be received.
   " C  `4 p6 K# f: N
10.   * @retval HAL status
    
11.   */
    5 ]) N1 I( M* S
12. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
    7 Z( q1 M5 ]. J' y# B
13. {
    
14.   /* Check that a Rx process is not already ongoing */
    1 ?; b- @  Z, c/ D, W
15.   if (huart->RxState == HAL_UART_STATE_READY)
    
16.   {
    
17.     if ((pData == NULL) || (Size == 0U))
    
18.     {
    
19.       return HAL_ERROR;
    
20.     }
    ) L9 Z# B* P8 g1 L' x  ?: M% X' ?
21. 
    $ ?0 _( g+ I0 w/ x8 ~
22.     /* Process Locked */
    
23.     __HAL_LOCK(huart);
    
24. 
    
25.     huart->pRxBuffPtr = pData;
    8 E! ^2 u4 n  w0 |1 a
26.     huart->RxXferSize = Size;
    4 r4 U- P( o! [8 S* s& B3 p
27.     huart->RxXferCount = Size;
    ) L# s% b+ ]; o
28. 
    
29.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    , n. X3 R9 v* u$ g1 k- `
30.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    6 u9 N& I& |% d% K0 N
31. 
    
32.     /* Process Unlocked */
    9 e) I* U0 c( t9 a- A2 L" J
33.     __HAL_UNLOCK(huart);
    
34. 
    - m2 j; s: U# y1 \* f0 W1 o4 l
35.     /* Enable the UART Parity Error Interrupt */
    . G4 n. K: c8 f7 p4 S8 Y
36.     __HAL_UART_ENABLE_IT(huart, UART_IT_PE);
    
37. 
    ; e. c* N- A" I" F
38.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    
39.     __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
    ; l# p9 Q# @+ a% B( C
40. 
    ' _  F, z1 |" f' y1 {8 x
41.     /* Enable the UART Data Register not empty Interrupt */
    
42.     __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
    
43. 
    9 w; k+ }- B* q9 s! F) ~2 J
44.     return HAL_OK;
    0 l5 i: W6 D5 c
45.   }
    
46.   else
    ; I* K' }. U/ [# L
47.   {
    
48.     return HAL_BUSY;
    " l6 a7 y1 v& \& z! @) z& N
49.   }
    6 ^9 e& K4 I. {. e
50. }

复制代码

# e- T+ E1 T! N" ]
这个函数本质上其实不是中断接收函数，只是配置函数，配置开启中断的信息，并且接收多少定长的数据结束本数据接收，串口的中断接收还是在中断中进行。
我们本次的长度虽然也是定长，但是有两种长度数据的接收，所以还是从设计接收不定长的数据为最终效果。
" x, Z" k4 [% R; W& e2 K$ d状态机的运用
+ X$ T+ B/ w8 z对于不定长数据的接收，使用了状态机，分两次中断来接收数据

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   / e% G( H& q0 {& d1 H
3.         if(huart->Instance == USART6)                                         // 判断是由哪个串口触发的中断
   % M: f; ~' p5 ~" D/ H
4.         {
   ! S+ k" s. _5 r+ L1 i
5.                 if(StateMachine_USART6)                                      //状态机为1，都接收完毕，准备校验
   5 a+ N7 Z5 b* H7 U, F0 _  o
6.                 {       
   ( e' ]9 h/ z! G% v
7.       if(re_flag6 == 1)
   
8.                         {
   8 p$ p8 c4 {+ B* E
9.                                 UART6_RxCounter = 6;
     s- A. ?' A$ h: t2 e5 x6 d
10.                                 re_flag6 = 0;
    4 P6 H0 {! s$ n5 Y4 n
11.                         }       
    
12.       else
    5 W' o. Z- Y' b: a
13.                         {
    
14.                                 len_counter6 = 2+5+UART6_RxBuffer[2]+(UART6_RxBuffer[3]<<8);  
    
15.                           if(UART6_RxBuffer[len_counter6 - 1] == 0x55 && UART6_RxBuffer[0] == 0xAA)       
    
16.                           {
    
17.                                   UART6_RxCounter = len_counter6;
    
18.                           }       
    
19.         else
    
20.                           {
    
21.                                   memset(UART6_RxBuffer,0,0x400);
    . q+ k3 L. _0 P' p9 C. j2 a
22.                                         UART6_RxCounter = 0;
    
23.                           }               
    
24.                         }                               
    ) X& h" G! f/ E  B, |" e) \8 G! i
25.                      
    " s5 d' X7 P4 p% ], _- F/ w2 s% s& l
26.                         StateMachine_USART6 = 0;                                   //状态机为0
    
27.       len_counter6 = 0;                       
    
28.                         HAL_UART_Receive_IT(&huart6,UART6_RxBuffer,5);               
    ' {% E& a! e6 V7 ]8 s
29.                 }
    3 s' B) I$ @3 }: U3 e$ Y3 R
30.                 else                                                         //状态机为0，只接受到了前五个字节，继续接收后面的字节
    1 I( E3 I9 C9 v+ }4 a$ [" J3 U2 `' \
31.                 {                                       
    4 C  s  j. [* }
32.                         if(UART6_RxBuffer[0] == 0xAA)
    
33.                         {
    * F3 z3 f5 f; z1 B' @
34.                                 StateMachine_USART6 = 1;
    : g0 e1 z1 V4 O$ H. k# h) e4 k
35.                                 UART6_RxCounter = 5;
    
36.                                 if(UART6_RxBuffer[2] == 0 && UART6_RxBuffer[3] == 0)
    " L4 Z+ _/ \8 K/ x- L3 g
37.                           {
    
38.                                   HAL_UART_Receive_IT(&huart6,(uint8_t*)&UART6_RxBuffer[5], 1);
    
39.                                         re_flag6 = 1;
    0 r: F' ?7 Z3 s8 n7 V$ U% l
40.                           }
    
41.                           else
    . O8 r* L; Y/ M. c( a7 k
42.                             HAL_UART_Receive_IT(&huart6,(uint8_t*)&UART6_RxBuffer[5], 2 + UART6_RxBuffer[2] + (UART6_RxBuffer[3] << 8));
    , }( W& X8 r4 |. b5 U) w$ E( _
43.                         }
    
44.                         else
    1 v8 T* W. H: m/ ~% [, l
45.                         {
    
46.                                 memset(UART6_RxBuffer,0,0x400);
      k5 z6 _8 |2 I# t- |. Q
47.                                 UART6_RxCounter = 0;
    : u) x' E. m0 N+ R% o4 G
48.                                 HAL_UART_Receive_IT(&huart6,UART6_RxBuffer,5);
    " r" Y; ~. `* O, S8 {1 U
49.                         }
    
50.                        
    0 }0 `! P% x1 C" y! u9 b5 `
51.                 }
    
52.         }
    
53. }

复制代码

$ @; I3 Q7 o2 h4 B) x$ y
0 Q# o! I& p& D& ?) G7 L0 G核心思想就是先接收报文的头，根据头来判断后面的长度，把应答报文和音量数据报文区分开，不合格的报文直接舍去同时开启新的接收。
3 b6 Y$ P- Z, w7 z& q# N$ m
  y( B6 h4 b) E4 z; v" y6 Q1 q
8 B2 [3 y; a" S& D- S: Y  ^

- Z8 O4 B4 D% Q: a文章出处：Outsider Hub
8 M) M' \8 z' |