我已经在我的另外一篇博客中写到了如何进行芯片与树莓派的通信，传送门在下面：

STM32F427IIH6芯片通过DMA+USART(UART)与树莓派进行双工通信

那么我们接收到串口的数据之后如何进行解析处理呢？今天这篇帖子主要就是解决这个问题啦~

( i+ L7 Y. l/ }3 J8 |% M
9 m3 g/ ~/ J2 F

程序处理逻辑

' v. Z; m: [% d! B$ a
流程图

9 f) i3 k# J" ~' }8 D自然语言描述
5 C& V3 ~& f6 v+ `- X自然语言描述起来的话还是比较简单的，既然要处理数据，那么最开始肯定先要把数据通过串口接收下来，这个时候就用到了HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);这个函数，当接收到了数据之后我们要判断帧头是否正确，如果正确的话我们就将数据复制到相应数组里面去，用的就是这个函数SERDEB_PushCmd(uart8Rx, uart8RxLength);,如果帧头错误就需要等待下一次串口接收数据,数据接收部分完成之后就开始对数据包开始做解析了，解析帧头后面的数据包内容用的是这两个函数DebugCmdProceed();和GetDebugCmd(uint8_t *cmd, uint16_t len)，最后根据数据包里面的信息更改芯片内的变量数值，从而实现了树莓派对于底盘运动的控制。
1 e0 @1 `  D" Y( n
  L' l4 Q8 k& ~. O
0 L; l/ ?) L* \! ^9 m; J

, G4 q* }# h, ^: S4 F7 v

程序分析

! i: P' I: C8 M9 A' m. u- r6 D
接下来我将结合代码具体分析整个流程~


数据接收
首先是数据接收部分了，详细代码在下面：
. [* q! y, u/ ]$ [8 Z3 A% D

1. <font face="微软雅黑" size="3">#define buffer_size   1024
   
2. if( huart == &huart8)
   
3. {
   7 b- [1 h7 c" l0 M7 R
4.     test3++;
   
5.     HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);  
   & v* T5 h7 c- Q5 V5 |7 \- H
6. 
   ( R) d2 B; R1 N0 c
7.     uart8RxLength = buffer_size-__HAL_DMA_GET_COUNTER(&hdma_uart8_rx);     
   
8.     if(uart8Rx[0]=='@'
   , c3 l1 p7 B" z' @, r6 _
9.     &&uart8Rx[1]=='c'
   
10.     &&uart8Rx[2]=='m'
    
11.     &&uart8Rx[3]=='d')
    
12.     {
    . j$ z; B! o  ~: h% C0 H
13.         if(!SERDEB_CmdValid())
    + l$ |: n/ S2 c  k  ?' t2 p  C- X
14.             SERDEB_PushCmd(uart8Rx, uart8RxLength);
    
15.     }
    5 v& h3 a* w* {! l) |
16.     __HAL_DMA_DISABLE(&hdma_uart8_rx);
    
17.     HAL_GPIO_TogglePin(GPIOG,GPIO_PIN_8);   
    0 K, n) t0 Z' V7 n2 X# S6 |) b& P; l
18. }</font>

复制代码

在源码中可以很清楚的看到程序是先用HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);来接收串口数据，接收到数据之后通过前几个字符的帧头来判断其与命令帧头是否相同，如果相同的话说明芯片正确接收到了树莓派的指令，即可进行相应的动作。
8 ^7 @, o: t; {1 t9 Z+ n) D2 d
7 [+ E  W: x$ A9 W  ]( \8 s8 F
我再放一下SERDEB_PushCmd(uart8Rx, uart8RxLength);的源码，这个函数实现的目标就是内存复制。

1. <font face="微软雅黑" size="3">void SERDEB_PushCmd(uint8_t *cmd, uint16_t len)
   % c& Z( C5 v  W' a$ \& U2 x
2. {
   
3.     memcpy((uint8_t *)(debugCmd.cmd), cmd, len);
   
4.     debugCmd.cmd[len] = '\0';                // end of string;
   
5.     debugCmd.valid = TRUE;
   ) K3 D$ l& V  ]/ v  _
6.     debugCmd.cmdLen = len;
   
7. }</font>

复制代码

但是不知道大家发现了一个问题没有,HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);和SERDEB_PushCmd(uart8Rx, uart8RxLength);都是进行了内存复制，那为什么要2个这样相同功能的函数呢?
9 M5 B& @2 A/ D- ]3 x9 O
: U4 Q. }3 O0 v
玄机就是这个语句：debugCmd.cmd[len] = '\0';。这个关键点就相当于是给数组添加了一个结束字节，这样可以极大程度上方便之后的数据处理。
1 K- V  X" J3 }: P) f# c

也就是说HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);函数是从串口缓冲区拿到数据，SERDEB_PushCmd(uart8Rx, uart8RxLength);是给取到的数据末尾加上停止标志位，方便之后的数据处理。
1 i' n& F  n' K' V7 M( ^+ M+ R4 P  ]

因为函数SERDEB_PushCmd(uart8Rx, uart8RxLength);需要复制内存的字节数，所以需要uart8RxLength = buffer_size-__HAL_DMA_GET_COUNTER(&hdma_uart8_rx);来计算得到串口接收到的字节数。
. q: a; B8 T2 T; ?  T' s
5 ^7 n& [' p% @- i8 K
* h% o# L' I; m  j$ T& c7 E+ r__HAL_DMA_GET_COUNTER(&hdma_uart8_rx);DMA接收中断使能时该宏将会返回当前接收内存的剩余字节数(总字节数-剩余字节数=串口接受字节数) 。

; j( j# @0 Z% W% G/ Q) p
数据处理
当数据接收完成并且添加了结束字节之后就开始数据处理啦~
; K8 m, q+ P# P

% C3 \; |7 F: Y2 G首先对数据做一个粗处理，就是先把数据数组里的数据包进行分解，分到了3个不同的数组里，分别是debArray[0],debArray[1],debArray[2]，并且将数组里面的数值分别赋值到mov_sta,move_mode,step三个变量里。

, m, n" }1 p* F, U  A
' z+ r1 h5 J. N' X/ l1 ~因为接收到的串口数据是字符型的，所以需要将其转换成数字，所以就用了这个static uint8_t atoi(uint8_t *str, uint16_t *num)函数将接收到的字符转换成数字。
- ]% z, h; k: J; k1 }% ~
% j' q  }. v0 R

1. <font face="微软雅黑" size="3">static uint8_t atoi(uint8_t *str, uint16_t *num)
   0 V2 r5 j) j+ U/ P1 |
2. {
   ' v+ N9 V+ x4 A
3. #define MAX_DIG        10
   
4. 
   ) u  J4 V5 z9 `; n+ p# ~
5.     uint8_t dig = 0, cnt;
   % B6 ^$ H2 }. k# c( Q% _# u
6.     uint8_t numTmp[MAX_DIG];
   
7. 
   % W/ B' x0 k: l
8.     memset((uint8_t *)numTmp, ' ', MAX_DIG);
   $ x0 W6 ?8 P0 ~  h# {) z
9.     *num = 0;
   * Q& O% \9 p9 z7 w) R! d' ?3 C
10. 
    
11.     if(*str=='0'&&(*(str+1)=='x'||*(str+1)=='X'))
    % Q+ N0 o' k8 o5 z' B# p
12.     {
    ) n. m* o2 X7 {3 w- M
13.         str+=2;
    4 \0 I# g# N/ i) R% I2 M- z, C2 l
14. 
    - |" {  Y# }# @
15.         do
    
16.         {
    
17.             if(*str>='0'&&*str<='9')
    
18.             {
    * u2 q5 N) E1 Y* E3 K+ W6 C" C0 @
19.                 numTmp[dig] = *str - '0';
    / o4 o0 B3 g, I# m5 E8 C- O
20.             }
    4 d  d. ^6 E, {* A7 x# t
21.             else if((*str>='a'&&*str<='f'))
    
22.             {
      n# ^* P7 Y3 P# o6 d' }0 X
23.                 numTmp[dig] = *str - 'a' + 10;
    ! r  x- l5 F, H2 T/ R3 S
24.             }
    
25.             else if((*str>='A'&&*str<='F'))
    
26.             {
    
27.                 numTmp[dig] = *str - 'A' + 10;
    
28.             }
    
29. 
    
30.             str++; dig++;
    
31. 
    
32.             if(dig>MAX_DIG-2)
    
33.             {
    * x8 ]% y& I4 h7 ]
34.                 break;
    
35.             }            
    2 {! g9 m6 c! H
36.         }
    
37.         while(
    
38.         (*str>='0'&&*str<='9')
    1 h* v, o( s. ~6 d
39.         ||(*str>='a'&&*str<='f')
    
40.         ||(*str>='A'&&*str<='F')
    
41.         );
    
42. 
    . ?. [/ E1 _. Z% Y* |+ F; @, T
43.         for(cnt=0; cnt<dig; cnt++)
    5 _: I; q+ e" q6 U: U" ?) H
44.         {
    4 _) N) h! E" e: w4 Z; a
45.             *num += (numTmp[cnt]*power(16, (dig-cnt-1)));
    1 g% r1 ?/ R; S' [. S/ R- A
46.         }
    
47. 
    
48.         dig += 2;
    ; {% o$ q3 r" ^; p9 V. T* E! s4 G+ |5 T
49.     }
    - `' l$ j; S/ J
50.     else
    : l. X5 `" P) R5 {% @( G- ^6 s
51.     {
    0 Q+ W$ L( Q% S4 Y. P- T
52.         do
    
53.         {
    5 D" P& T  ~' D% H# p/ R+ T. K1 h: @
54.             numTmp[dig] = *str - '0';
    1 K. C/ Q) e& d! {
55.             str++; dig++;        
    
56. 
    ; ~% d8 E2 s- t4 {
57.             if(dig>MAX_DIG-1)
    
58.                 break;
    
59.         }while(*str>='0'&&*str<='9');
    * F$ k; L. J8 {- Q( }$ s
60. 
    * _: P5 a8 ?  ?6 U8 A
61.         for(cnt=0; cnt<dig; cnt++)
    ) j2 E, T* H9 u- r' R# t
62.         {
    
63.             *num += (numTmp[cnt]*power(10, (dig-cnt-1)));
    
64.         }
    & y4 }6 Z$ J+ r* T
65.     }
    9 `, w* I, ^/ L9 u! n
66. 
    * z7 m$ f* ?2 T
67.     return dig;
    . x( d: |" ?0 S+ K* u
68. 
    4 `4 a) f0 r: l- k
69. #undef MAX_DIG
    6 Y; p! t( J% r+ E% B+ J
70. }
    
71. 
    8 A9 p: e& ^! D; P
72. static uint32_t power(uint8_t base, uint8_t exponent)
    
73. {
    $ q0 m; A! j; |- e
74.     uint32_t value;
    
75.     uint8_t cnt;
    
76. 
    4 C. ?- l( x4 e; D
77.     if(exponent==0)
    
78.         return 1;
    0 I: v3 h7 c" I" {7 S8 @, V
79. 
    
80.     value = 1;
    
81.     for(cnt=0; cnt<exponent; cnt++)
    
82.     {
    ; B% x3 B0 j/ t1 r4 |% |1 k1 {$ Z. |
83.         value *= base;
    % G1 T: A: ~8 u
84.     }
    
85. 
    
86.     return value;
    
87. }
    
88. #define MAX_DEBBUF            (1024)
    ' z- b: W5 {( C* l6 V$ L3 y
89. #define mov_sta    debArray[0]
    
90. #define move_mode  debArray[1]
    9 Y8 l4 p8 ^' L  m
91. #define step             debArray[2]     
    
92. static uint8_t GetDebugCmd(uint8_t *cmd, uint16_t len)
    ; D, `- [6 |+ z
93. {
    
94.     uint8_t *pCmd;
    
95.     uint8_t index;
    
96.     uint8_t u8Temp = 0;
    
97. 
    6 M2 {8 k* L; X* h; z1 a* K, f0 g
98.     pCmd = cmd;
    
99. 
    
100.     if(cmd[0]!='@'
     9 t6 A8 ^$ L: o6 R4 T
101.         &&cmd[1] != 'c'
     
102.         &&cmd[2] != 'm'
     
103.         &&cmd[3] != 'd'
       E/ s1 m, L7 K/ V" g9 u
104.         &&cmd[4] != ' ')
     ' [6 M$ x8 t: `! g
105.     {
     
106.         printf("GetDebugCmd: error cmd format. It must be @cmd n1 n2 n3... \r\n");
     
107.         return FALSE;
     
108.     }
     ) S- w# o8 m  \: ?% @. g
109. 
     ' t3 z& `2 Y2 k- A2 u( f2 n
110.     pCmd += 5;            // the first num   
     
111.     index = 0;            // index of debArray, ==0 the first num ==1 the second num ==2... ...
     
112. 
     
113.     while(1)
     - x! U2 {+ F# O0 v  b+ D' v  ]
114.     {
     5 A" y: z3 w! z' S5 X. M
115.         if(*pCmd=='\r'
       M2 Q; V7 r2 N7 W6 N% ]/ R
116.             ||*pCmd=='\n'
     
117.             ||*pCmd=='\0'
     
118.             ||len==0)
     * b. G$ B8 Q: [4 Z
119.         {
     
120.             break;
     
121.         }
     4 Y, @8 i& H; n1 g7 A. [
122. 
     
123.         u8Temp = atoi(pCmd, (uint16_t *)(debArray+index));
     
124.         pCmd+=u8Temp; len-=u8Temp;
     
125. 
     , s$ \6 H/ c0 I% d8 [; X8 H
126.         pCmd+=1; len-=1;
     
127.         index++;        
     
128.     }
     ( D+ B: |5 G: D+ B2 K9 U+ e3 e4 W# u
129. 
     
130.     return TRUE;
     ; h& S1 D4 \0 l0 c: Q
131. }</font>

复制代码

当我把数据放到这三个变量mov_sta,move_mode,step里面之后就可以进行最终的细数据处理啦~
4 K: X  R; Z7 Y, X* M/ x" G. p0 ]

1. <font face="微软雅黑" size="3">static void DebugCmdProceed(void)
   ) B/ y" ?  q! y' \1 t5 y& H7 j
2. {
   
3.     switch(mov_sta){
   
4.         case STOP:
   
5.         //    printf("I'm stop\n");
   
6.             MOV_STA = STOP;
   
7.             speed=0;
   * W5 v) e' o- x! ]& j
8.             break;
   
9. 
   
10.         case RUN:
    : A* B: \# o: O4 t) T
11.             //printf("start running\n");
    
12.           MOV_STA = RUN;   
    
13.             cross_sta=mid_cnt;
    
14.             speed=0;
    
15.             break;
    2 `1 T2 u9 _$ q% B6 T5 G8 z6 D
16. 
    
17.         case LEFT:
    
18.         //    printf("start turning left\n");
    
19.             MOV_STA = LEFT ;
    
20.             cross_sta=mid_cnt;
    
21.             speed =0;
    ! ?! x/ C% g2 U8 W
22.             break;
    
23. 
    
24.         case RIGHT:
    
25.         //    printf("start turning right\n");
    
26.             MOV_STA = RIGHT ;
    
27.             cross_sta=mid_cnt;
    
28.             speed =0;
    
29.             break;
    & q) e4 B% D3 w4 n, K
30. 
    
31.         case BACK:
    
32.         //    printf("start going back\n");
    
33.             MOV_STA = BACK ;
    
34.             cross_sta=mid_cnt;
    + m+ {  O0 o% h$ ]  a/ g
35.             speed =0;
    6 Q8 \. i/ L4 M. Q& Z
36.             break;
    % [6 x3 l5 J& i$ f+ }
37. 
    8 U6 r/ I  |2 e# T
38.         case GET_WALL:
    
39.             //printf("start running to wall\n");
    
40.             MOV_STA = GET_WALL ;
    0 H2 D/ Y( l5 o8 z& {, W/ w, ^# p
41.             cross_sta=mid_cnt;
    8 v2 X; Q% R: [2 ?) ?) Q" ^2 e
42.             speed =0;
    
43.             break;
    3 |3 \2 F: @$ N" X
44.     }
    
45. 
    8 H- c; f  |' f' U% W& T# {8 O" L, {
46. 
    
47.     switch(move_mode){
    ) f0 s& ^+ H& @% n4 O6 m) K- s
48.         case MODE_A:
    
49.             MOV_MODE = MODE_A;
    3 m: O4 D1 M( U+ m4 Q
50.             //printf(",MODE : A");
    6 {9 R$ J- U* h3 m" n* V. q% I
51.             break;
    5 }$ Z7 P- k, ]. r. a3 [
52.         case MODE_B:
    
53.             MOV_MODE = MODE_B;
    
54.             //printf(",MODE : B");
    
55.             break;
    : Z; e( I* D# u) a( E5 X  p* h* u3 a
56.     }
    / ^' k' Z, k+ H7 J0 m3 T, w
57. 
    
58.     printf("cross_sta is %d\n",cross_sta);
    
59.     switch(step){
    - |; K9 O9 n8 w' u8 {
60.         case 0:
    1 {8 h3 Y' B5 D) O
61.             STEP = 0;
    0 L6 [# E$ ~8 G; |# Y
62.             //printf(" STEP: half ");
    8 @( q" v7 x4 @1 H
63.             break;
    
64.         case 1:
    
65.             STEP = 1;
    
66.         //    printf(" STEP:1 ");
    , @0 [  p: \. n4 y, z
67.             break;
    5 m9 ^. l; r, u( ]! N! `
68.         case 2:
    
69.             STEP = 2;
    
70.         //    printf(" STEP:2 ");
    5 P, s# \+ |4 X3 l" ]
71.             break;
    
72.         case 3:
    
73.             STEP = 3;
    9 c/ o+ U  H+ S7 |( A9 r
74.             //printf(" STEP:3");
    , |% X2 ~( q# b0 d9 u! g4 L  e
75.             break;
    
76.         case 4:
    $ o( L0 S% p. T9 J! c9 L
77.             STEP = 4;
    
78.         //    printf(" STEP:4 ");
    
79.             break;
    ; p$ P# o: T9 P! a
80.         case 5:
    # B% Q. O5 I4 K
81.             STEP = 5;
    
82.             //printf(" STEP:5 ");
    * w- d! V% Y. f8 i
83.             break;
    $ [8 D: Z  C2 ^. u
84.     }
    
85. }</font>

复制代码

) P( x/ d6 y: L# L+ t
( P; Q0 G" M( U
  k6 U! E$ h% E6 g. d