一、利用protobuf通信原理

最近项目中需要用到stm32与Orange Pi（移植了linux）进行数据交互，H6端是用C++编写的串口底层驱动，与stm32的串口连接并通信。串口间的通信协议定为采用protobuf打包数据并通过串口发出的形式，即发送端编码数据并序列化成数组通过串口发出，接收端接收到一帧数据，进行解码并解析数据。

二、 移植protobuf（nanopb-0.3.8）到stm32工程
$ z/ r4 R6 Z3 m1 C" c- n, T
- ?- X* f3 [# c7 V& K" e0 ?# ~, @0 ~

protobuf是一种打包数据的工具，和JSON打包数据的作用是一样的。在C++下用protobuf传递数据，要先写一个.proto文件，然后在linux环境下编译该文件，或者直接放在CMake里面编译，便可以生成出来一个类（.cpp 和 .h），利用protobuf打包便是打包这个类。

可以理解成把这个类的所有数据加上帧头帧尾帧校验，然后通过串口，网络等通信格式将数据发送出去，这个过程称为序列化。解包就是把收到序列化的数据反序列化，然后把有效数据放入生成的类中。

一般开发stm32的环境是在Windows下，基于Keil开发，要通过.proto文件生成结构体（.c和.h）需要下载一个官方protobuf的轮子，然后在命令行下编译即可生成我们需要的结构体文件。

& i0 o# e0 u) u6 U$ m# ?

三、编写.proto文件

编写.proto文件很简单，开头先写protobuf的版本号，和包名（命名空间）

1. <font size="3" color="#000000">// A very simple protocol definition, consisting of only
   
2. // one message.
   , F3 _/ T8 D% m7 x+ H
3. // 02
   % l9 E% J, a* G4 w# t
4. 
   
5. syntax = "proto3";
   * g9 ~7 l6 p" V0 \; U& |
6. 
   
7. package STM32;</font>

复制代码

然后写message，就和写结构体（枚举）的格式很相似。

. E8 C3 Y* t4 k- ]

1. <font size="3" color="#000000">message GyroOffset                        
   
2. {
   . \* w, Y( I& L& j4 s3 [$ v2 L7 X
3.         float gyrooffsetX = 1;
   - O' Z* [" F) e. S- x
4.         
   
5.         float gyrooffsetY = 2;
   
6.         
   8 s2 @2 F* u7 G/ [! N& S! ?
7.         float gyrooffsetZ = 3;
   
8.         
   
9. }
   
10. 
    
11. message GyroAccData
    
12. {
    ! h' g& t; C# w! \% G% m
13.         uint32         accX = 1;  //加速度计x轴加速度
    7 B5 m2 U, r3 J0 M! x
14.         
    
15.         uint32  accY = 2;  //加速度计y轴加速度
    7 X, J, G3 B4 L% [0 }
16.         
    
17.         uint32  accZ = 3;  //加速度计z轴加速度
    & y/ S1 I5 f2 z  ^
18.         
    
19.         uint32  gryoX = 4; //陀螺仪x轴原始数据
    
20.         
    , X# I7 @9 F( T0 p- q
21.         uint32  gryoY = 5; //陀螺仪y轴原始数据
    
22.         
    
23.         uint32  gryoZ = 6; //陀螺仪z轴原始数据
    
24. }
    
25. 
    
26. message IsGetGyroOffset
    , U% O/ i0 A0 ?% Y/ A% x2 C( O  ]  F
27. {
    
28.         bool IsGetStatus = 1;
    
29. }
    
30. 
    
31. message Bmi160ToData
    3 [( W  _7 p8 a5 e% X0 u
32. {
    6 c+ _5 S9 U0 Q1 @8 l, h! S7 x
33.         GyroOffset gyroOffset = 1;
    8 F2 n" T# j7 C& [# I0 `4 T
34. 
    1 i% [( B) _8 @
35.         GyroAccData gyroAccData = 2;
    6 R6 i' G, h, Q) N3 S% }: |+ f
36. 
    ! y, {6 `5 A$ l0 L/ I$ ^9 k8 j
37.         IsGetGyroOffset isGetGyroOffset = 3;
    ; @1 A, l. M. v# Z4 J/ U7 R9 k
38. }</font>

复制代码

到这里为止，我们最终只需要Bmi160ToData这个结构体中包含的数据即可。

写完以后我们把.proto文件放在桌面上，然后打开cmd命令行解释器，cd到.proto文件的目录下，然后运行protoc 这个脚本去编译.proto文件，编译完成后即可生成两个文件，一个.c，一个.h。这里有一点，就是最好把这个脚本的可执行文件路径放到系统环境变量下，这样才可以在任何路径下编译.proto文件。具体的命令如下图所示：

编译完成后，在该路径下会生成一个.c一个.h文件，其内容如下：

9 G' n8 L8 ^" Q( j

1. <font size="3" color="#000000">/* Automatically generated nanopb constant definitions */
   
2. /* Generated by nanopb-0.3.8 at Fri Sep 11 16:29:22 2020. */
   1 A8 u  w) `  _- E
3. //.c
   
4. #include "Bmi160ToData.pb.h"
   ( K4 d- ?! R! D1 T+ i
5. 
   : j. j' ^3 I2 Z3 M
6. /* @@protoc_insertion_point(includes) */
   
7. #if PB_PROTO_HEADER_VERSION != 30
   ( F8 p& @! w0 j: }5 e. n1 S
8. #error Regenerate this file with the current version of nanopb generator.
   4 A2 I* W( ^! K: L+ V# e
9. #endif
   
10. 
    * O: z4 E. T8 a3 Q2 o( V
11. 
    
12. 
    $ r. |2 F. {  l& d9 g0 `) d7 q- g
13. const pb_field_t STM32_GyroOffset_fields[4] = {
    7 Z% y6 Q+ \8 Z' W$ g/ D0 x
14.     PB_FIELD(  1, FLOAT   , SINGULAR, STATIC  , FIRST, STM32_GyroOffset, gyrooffsetX, gyrooffsetX, 0),
    7 T4 J( r/ Y* M8 p9 H
15.     PB_FIELD(  2, FLOAT   , SINGULAR, STATIC  , OTHER, STM32_GyroOffset, gyrooffsetY, gyrooffsetX, 0),
    7 R6 h& M2 I! z1 l  m- w1 b
16.     PB_FIELD(  3, FLOAT   , SINGULAR, STATIC  , OTHER, STM32_GyroOffset, gyrooffsetZ, gyrooffsetY, 0),
    3 k4 f* e/ K1 Z; a3 c
17.     PB_LAST_FIELD
    4 T0 w9 D4 M. R1 J9 P
18. };
    - d- }& U, s5 C) X& _6 W$ e
19. 
    , J9 Y5 y" J( M+ U
20. const pb_field_t STM32_GyroAccData_fields[7] = {
    , Y5 S! `/ x7 X9 t( F
21.     PB_FIELD(  1, UINT32  , SINGULAR, STATIC  , FIRST, STM32_GyroAccData, accX, accX, 0),
    
22.     PB_FIELD(  2, UINT32  , SINGULAR, STATIC  , OTHER, STM32_GyroAccData, accY, accX, 0),
    
23.     PB_FIELD(  3, UINT32  , SINGULAR, STATIC  , OTHER, STM32_GyroAccData, accZ, accY, 0),
    " r* ]; N2 z+ v( S  Z1 Z
24.     PB_FIELD(  4, UINT32  , SINGULAR, STATIC  , OTHER, STM32_GyroAccData, gryoX, accZ, 0),
    ( J9 G3 l. M0 F. o9 w3 B6 |) k. w/ ]
25.     PB_FIELD(  5, UINT32  , SINGULAR, STATIC  , OTHER, STM32_GyroAccData, gryoY, gryoX, 0),
    ' F% ]& `8 I4 i/ {8 E" c) E
26.     PB_FIELD(  6, UINT32  , SINGULAR, STATIC  , OTHER, STM32_GyroAccData, gryoZ, gryoY, 0),
    
27.     PB_LAST_FIELD
    
28. };
    
29. 
    
30. const pb_field_t STM32_IsGetGyroOffset_fields[2] = {
    
31.     PB_FIELD(  1, BOOL    , SINGULAR, STATIC  , FIRST, STM32_IsGetGyroOffset, IsGetStatus, IsGetStatus, 0),
    : @* u2 G0 t7 S1 I4 F  N$ K
32.     PB_LAST_FIELD
    
33. };
    
34. 
      _( Y5 i4 U. s9 e  k( V5 d" O
35. const pb_field_t STM32_Bmi160ToData_fields[4] = {
    
36.     PB_FIELD(  1, MESSAGE , SINGULAR, STATIC  , FIRST, STM32_Bmi160ToData, gyroOffset, gyroOffset, &STM32_GyroOffset_fields),
    
37.     PB_FIELD(  2, MESSAGE , SINGULAR, STATIC  , OTHER, STM32_Bmi160ToData, gyroAccData, gyroOffset, &STM32_GyroAccData_fields),
    
38.     PB_FIELD(  3, MESSAGE , SINGULAR, STATIC  , OTHER, STM32_Bmi160ToData, isGetGyroOffset, gyroAccData, &STM32_IsGetGyroOffset_fields),
    * \) Y3 M$ x' I* U9 r# v; Y2 C/ k( x
39.     PB_LAST_FIELD
    5 M) H5 g. }& W4 y6 M9 R- h
40. };
    & i' Q( B; J6 |
41. 
    ) U' e( x' R; c5 l
42. 
    - }" a' q2 |8 v2 T3 o
43. /* Check that field information fits in pb_field_t */
    6 U3 p5 N$ w) G; K
44. #if !defined(PB_FIELD_32BIT)
    
45. /* If you get an error here, it means that you need to define PB_FIELD_32BIT
    ) A, o+ _9 X. F3 L4 }/ R
46. * compile-time option. You can do that in pb.h or on compiler command line.
    . ?; i0 _  w+ m' O1 |' y/ W% n# j, ~
47. *
    ; {% V# U5 \+ i" r; E+ r' O
48. * The reason you need to do this is that some of your messages contain tag
    
49. * numbers or field sizes that are larger than what can fit in 8 or 16 bit
    2 Y. H( ~/ k* K' z7 a
50. * field descriptors.
    
51. */
    
52. PB_STATIC_ASSERT((pb_membersize(STM32_Bmi160ToData, gyroOffset) < 65536 && pb_membersize(STM32_Bmi160ToData, gyroAccData) < 65536 && pb_membersize(STM32_Bmi160ToData, isGetGyroOffset) < 65536), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_STM32_GyroOffset_STM32_GyroAccData_STM32_IsGetGyroOffset_STM32_Bmi160ToData)
    1 P/ z! x3 e9 W# g- l2 q( i# ^
53. #endif
    
54. 
    4 |; g$ f2 G; B7 d/ u
55. #if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
    
56. /* If you get an error here, it means that you need to define PB_FIELD_16BIT
    4 d' V* h4 x( F$ O8 {
57. * compile-time option. You can do that in pb.h or on compiler command line.
    5 G: _% E; |9 X% i) p8 E- V
58. *
    
59. * The reason you need to do this is that some of your messages contain tag
    ( n/ v+ T: q* e# f% w5 P9 D
60. * numbers or field sizes that are larger than what can fit in the default
    
61. * 8 bit descriptors.
    . ?7 `4 W0 M, e* m  O  U
62. */
    
63. PB_STATIC_ASSERT((pb_membersize(STM32_Bmi160ToData, gyroOffset) < 256 && pb_membersize(STM32_Bmi160ToData, gyroAccData) < 256 && pb_membersize(STM32_Bmi160ToData, isGetGyroOffset) < 256), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_STM32_GyroOffset_STM32_GyroAccData_STM32_IsGetGyroOffset_STM32_Bmi160ToData)
    
64. #endif
    : r4 W1 r' s. ]6 Z& }
65. 
    
66. 
    
67. /* @@protoc_insertion_point(eof) */
    8 ]& G- Y5 c9 M3 w6 w( I1 v0 h
68. </font>

复制代码

1. <font size="3" color="#000000">/* Automatically generated nanopb header */
   
2. /* Generated by nanopb-0.3.8 at Fri Sep 11 16:29:22 2020. */
   
3. //.h
   
4. #ifndef PB_STM32_BMI160TODATA_PB_H_INCLUDED
   
5. #define PB_STM32_BMI160TODATA_PB_H_INCLUDED
   
6. #include <pb.h>
   + k: Y7 v2 j. b. g& I; Z
7. 
   
8. /* @@protoc_insertion_point(includes) */
   ; L% `; z$ F' J
9. #if PB_PROTO_HEADER_VERSION != 30
   
10. #error Regenerate this file with the current version of nanopb generator.
    ( h9 u& O+ N4 Z- N
11. #endif
    5 P+ p' g' D9 F% A" s4 d
12. 
    
13. #ifdef __cplusplus
    
14. extern "C" {
    8 P3 o' c/ \$ n6 C/ j4 f! X
15. #endif
    % Q. m" c# U. B- T. Y* G) Q0 X
16. 
    
17. /* Struct definitions */
    
18. typedef struct _STM32_GyroAccData {
    . a8 Z* c) R5 L; x& ^: [
19.     uint32_t accX;
    " l. |1 ?" ], h! z0 p5 i; ?
20.     uint32_t accY;
    
21.     uint32_t accZ;
    
22.     uint32_t gryoX;
    
23.     uint32_t gryoY;
    
24.     uint32_t gryoZ;
    . e+ d; D2 Z( Q. ?7 B6 L
25. /* @@protoc_insertion_point(struct:STM32_GyroAccData) */
    # a6 Q6 z6 e% [0 N" B  L( }3 i& z
26. } STM32_GyroAccData;
    8 l5 F. s$ Y5 v( q# D
27. 
    
28. typedef struct _STM32_GyroOffset {
    : L% S, N* G6 z1 x# a
29.     float gyrooffsetX;
    ) Q8 x- o& m! G3 A8 o, t
30.     float gyrooffsetY;
    
31.     float gyrooffsetZ;
    7 w" V/ g5 _6 ?6 e  b% N
32. /* @@protoc_insertion_point(struct:STM32_GyroOffset) */
      o9 B8 P  w& Z2 `8 _4 T
33. } STM32_GyroOffset;
    
34. 
    - I. b7 G$ ?# R) h4 @8 c& O7 Y; R
35. typedef struct _STM32_IsGetGyroOffset {
    : f% m6 p) L/ ^8 }
36.     bool IsGetStatus;
    
37. /* @@protoc_insertion_point(struct:STM32_IsGetGyroOffset) */
    7 X% K9 S6 G- h7 j! l9 ]
38. } STM32_IsGetGyroOffset;
    * _  R$ g! z: D" o, W8 P* ^0 G+ O
39. 
    
40. typedef struct _STM32_Bmi160ToData {
    
41.     STM32_GyroOffset gyroOffset;
    
42.     STM32_GyroAccData gyroAccData;
    1 y3 ~; Y# [9 N5 T
43.     STM32_IsGetGyroOffset isGetGyroOffset;
    : V  D% f9 [; R$ n  b) C0 ?
44. /* @@protoc_insertion_point(struct:STM32_Bmi160ToData) */
    
45. } STM32_Bmi160ToData;
    
46. 
    0 L. s4 t' J. @* Q2 X
47. /* Default values for struct fields */
    9 E6 r) x- C2 `$ ?* Q% b/ w- E# l
48. 
    
49. /* Initializer values for message structs */
    ( e' x8 ]8 |  p1 ~+ d) B. q
50. #define STM32_GyroOffset_init_default            {0, 0, 0}
    
51. #define STM32_GyroAccData_init_default           {0, 0, 0, 0, 0, 0}
    & v# |( }* P" T) H/ o
52. #define STM32_IsGetGyroOffset_init_default       {0}
    
53. #define STM32_Bmi160ToData_init_default          {STM32_GyroOffset_init_default, STM32_GyroAccData_init_default, STM32_IsGetGyroOffset_init_default}
    
54. #define STM32_GyroOffset_init_zero               {0, 0, 0}
    
55. #define STM32_GyroAccData_init_zero              {0, 0, 0, 0, 0, 0}
    % G, ^0 ]7 M/ p$ c: _
56. #define STM32_IsGetGyroOffset_init_zero          {0}
    
57. #define STM32_Bmi160ToData_init_zero             {STM32_GyroOffset_init_zero, STM32_GyroAccData_init_zero, STM32_IsGetGyroOffset_init_zero}
    
58. 
    
59. /* Field tags (for use in manual encoding/decoding) */
    4 i) a9 h2 E6 Y' m* a
60. #define STM32_GyroAccData_accX_tag               1
    / ~$ E. b: M7 d, q
61. #define STM32_GyroAccData_accY_tag               2
    " I. d- b, i. w
62. #define STM32_GyroAccData_accZ_tag               3
    7 @4 y4 @/ `8 d. M; [4 W9 F
63. #define STM32_GyroAccData_gryoX_tag              4
    - ?$ x8 ~* R# H% v- x
64. #define STM32_GyroAccData_gryoY_tag              5
    $ P4 i8 h  _8 W$ c
65. #define STM32_GyroAccData_gryoZ_tag              6
    + G0 |2 x) U9 Z2 `0 d2 s  w8 J
66. #define STM32_GyroOffset_gyrooffsetX_tag         1
    2 \) o4 x* E: }, p" M0 u4 V
67. #define STM32_GyroOffset_gyrooffsetY_tag         2
    
68. #define STM32_GyroOffset_gyrooffsetZ_tag         3
    
69. #define STM32_IsGetGyroOffset_IsGetStatus_tag    1
    3 b4 ?6 s8 r* l" l/ Z! F3 v0 ]9 Q
70. #define STM32_Bmi160ToData_gyroOffset_tag        1
    
71. #define STM32_Bmi160ToData_gyroAccData_tag       2
    ! j+ B* c% p1 ?7 }6 g6 |7 M
72. #define STM32_Bmi160ToData_isGetGyroOffset_tag   3
    7 g+ L3 y% v# N4 M0 ?- n
73. 
    
74. /* Struct field encoding specification for nanopb */
    8 R$ z# k8 w. n2 i8 |
75. extern const pb_field_t STM32_GyroOffset_fields[4];
    2 T2 x1 T% e8 ]3 Z$ n
76. extern const pb_field_t STM32_GyroAccData_fields[7];
    
77. extern const pb_field_t STM32_IsGetGyroOffset_fields[2];
    * y" U$ d6 ~2 H4 g
78. extern const pb_field_t STM32_Bmi160ToData_fields[4];
    
79. 
    
80. /* Maximum encoded size of messages (where known) */
    
81. #define STM32_GyroOffset_size                    15
    9 k% x1 R% F+ Z8 |+ J
82. #define STM32_GyroAccData_size                   36
    $ }3 d- E$ `3 y1 s9 I* X
83. #define STM32_IsGetGyroOffset_size               2
    
84. #define STM32_Bmi160ToData_size                  59
    
85. 
    ; p2 M& l# X/ _4 \& i: D8 s. z! J
86. /* Message IDs (where set with "msgid" option) */
    
87. #ifdef PB_MSGID
    3 @# ?# `5 I/ x* {
88. 
    % B# o2 Q% ?9 q' X. c
89. #define BMI160TODATA_MESSAGES \
    4 r8 k$ z7 O: S. h
90. 
    - b# m+ _( B3 Z' M7 h
91. 
    
92. #endif
    ) e& E1 }& S6 z7 p- r
93. 
    
94. #ifdef __cplusplus
    
95. } /* extern "C" */
    $ \  b3 y4 e5 n$ b2 M3 `* Z( Y2 }
96. #endif
    
97. /* @@protoc_insertion_point(eof) */
    2 L! J- q& M8 P
98. 
    
99. #endif
    
100. f</font>

复制代码

至此，protobuf的C文件格式的代码已经生成。

' l" T8 e( O# [1 I7 w' {四、开始通信！！！
0 H3 G; x* d% I8 x" B( l6 L

把刚才生成的两个文件拉到项目里面，同时把官方的protoc所用到的三个文件和其对应的.h文件也拉到项目中来，文件格式如下图：

& k+ k) ?0 d5 Q

这三个文件回合protoc脚本一起放在文末。

我们先来看打包并发送一帧protobuf数据的代码：

9 j4 @- @' W$ }2 a  n0 _2 P

1. <font size="3" color="#000000">/*******************************************************************************
   - L% D$ r6 ?* L# x+ N0 n& |
2. * Function Name  : vProto_Encode_Send_FastPack()
   , ]( N! e5 O9 o3 O: `( V+ [9 d1 N+ B
3. * Description    : 编码protobuf数据,并将编码过后的数组通过串口1发送给上层
   / K# c& h' y! p# X4 _! D( O
4. * Input          : STM32_Stm32ToState 类型的结构体指针
   
5. * Output         : None
   * o/ e6 s/ W# @6 e+ t8 E
6. * Return         : true:编码成功   false：编码失败
   
7. *******************************************************************************/
   ) C; S5 F- ~2 Z* b4 M
8. bool vProto_Encode_Send_FastPack(void)
   7 H; S1 A) |# f  i8 L+ A
9. {
     \* k( Q/ M' G7 s+ I9 X3 B, G: c
10.     STM32_Stm32ToState STM32_Stm32ToState_Fast = STM32_Stm32ToState_init_default;//快包
    
11.     int message_length;
    
12.     bool status;
    9 S2 O$ A9 X* ^5 ?8 y
13.         pb_ostream_t op_stream;//创建一个编码对象，保存发送buf的数据长度，数据首地址，最大字节等信息
    
14.         
    + _% q9 S5 @* H6 h: u) J
15.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.accX   =  bmi160_protobuf.accx;
    
16.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.accY   =  bmi160_protobuf.accy;
    
17.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.accZ   =  bmi160_protobuf.accz;
    ' e8 g1 v) \5 j" K: ?4 \+ [5 Q
18.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.gryoX  =  bmi160_protobuf.gryx;
    + d8 W* ~; M2 w. B; L8 F
19.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.gryoY  =  bmi160_protobuf.gryy;
    
20.     STM32_Stm32ToState_Fast.bmi160ToData.gyroAccData.gryoZ  =  bmi160_protobuf.gryz;
    % k, w7 D: ^- s1 I1 m$ b/ M2 z, L4 Y
21.               
    ! ?$ B. u7 c; {" @
22.     //清空发送缓冲数组
    
23.     memset(ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex] , 0 , sizeof(ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex]));
    
24.     //初始化这个编码对象，并填充发送数组首地址，发送数据长度
    ! I& T$ R# V  t3 u+ n) l
25.     op_stream = pb_ostream_from_buffer(ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex] , sizeof(ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex]));
    & A! t' a2 \" f' w# M
26.     //调用编码API，将形参结构体的值赋给编码对象（数组首地址和长度）
    
27.     status = pb_encode(&op_stream,STM32_Stm32ToState_fields, &STM32_Stm32ToState_Fast);
    , m: ~) D5 r6 b0 I" X8 `
28.     if(!status) return status;
    + O/ f/ Q6 S0 U7 D4 A" |6 ~4 F/ u
29.     //打包以后数据的长度
    ) M2 x/ K. M8 b
30.     message_length = op_stream.bytes_written;
    % r. @  {; r: Z
31.     DEBUG("零飘结构体编码后的大小为：%d" , message_length);
    % T+ W; H- n0 m, {& H) a0 J
32. 
    3 l3 _' {9 [, A% w! F. `
33.         ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex][0] = ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex][0];
    
34.         //发送该帧数据
    , P7 j2 J, @& A/ \9 C" ^  F5 I
35.         memcpy(ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex],(uint8_t *)&ucUSART1TrainsmitBuffer[ucWtiteDataToUSART1TransmitGrooveIndex],message_length);
    ! v2 y' N. J9 `- u
36.     ucUSART1TrainsmitLength[ucWtiteDataToUSART1TransmitGrooveIndex] = message_length;
    , C( f1 i& z) A8 c, e
37.    
    
38.         WriteDataToUSART1TraismitBufferDone( );//发送下标移位
    " a. m% ?; K: p
39.         
    ( v, q5 [9 ^9 f0 k
40.         return status;
    
41. }</font>

复制代码

3 ?, }8 L* m, s8 O8 `7 V' G' F1 f; B

其实就是先把我们需要发送的结构体填充对应的值，然后通过protoc的API将这个结构体序列化以后的值放在一个buf数组里面，最后把这个数组通过串口DMA发送出去。这时linux端会从串口接收到该帧数据并存放在一个数组里面，然后通过API去将这个数组反序列化成.proto生成的类，这时类里的值，就是stm32发送上去的值。

同理可得，stm32接收到linux端发送的一帧数据，可以通过串口IDLE+DMA接收到一个数组里面，然后调用API去反序列化这个数组，并将结果填充到接收结构体里面，即可完成一次数据的收发，接收代码如下：

1. <font size="3" color="#000000">/*******************************************************************************
   7 }& {! j' ]9 ^- T6 Z  e( |" l7 Z, s
2. * Function Name  : vProto_Decode_Receive_Lslam()
   0 r" n  k7 J/ i8 b
3. * Description    : 解码protobuf数据,并分析数据和改变坐标全局变量
   0 g: D0 V5 @" s* {: H) [0 ^
4. * Input          : buf：接收一帧数组，buf_length：接收一帧数组的数组长度，
   2 G, E$ Z# \8 K1 S% A- M1 L
5.                    STM32_Stm32ToStete 类型的结构体指针
   
6. * Output         : None
   
7. * Return         : true:解码成功 false：解码失败
   
8. *******************************************************************************/
   2 E' B& u. n: b% S* N5 q( m
9. bool vProto_Decode_Receive(u8* buf , u16 buf_length)
   
10. {
    
11.     bool status;
    
12.    
    
13.     STM32_Stm32ToState STM32_Stm32ToState_t = STM32_Stm32ToState_init_default;
    
14.    
    
15.         pb_istream_t ip_stream;//创建一个解码对象，用于保存接收到的数组地址和数组长度
    
16.         
    , i# O0 x; v6 `! N: ~3 o
17.         ip_stream = pb_istream_from_buffer(buf,buf_length);//把接收到的一帧数据和帧长度给到解码对象
    
18.         
    
19.         if(pb_decode(&ip_stream , STM32_Stm32ToState_fields ,&STM32_Stm32ToState_t))
    
20.     {
    
21.                 g_tRouteCoord.Self_Coox              = LSLAM_PlanMsgToState_t.curpos.x;
    ' Z- T9 q) L( {8 x$ b9 W
22.             g_tRouteCoord.Self_Cooy              = LSLAM_PlanMsgToState_t.curpos.y;
    3 v3 a% f2 g% k: m. L& x
23.             g_tRouteCoord.Self_Angle             = LSLAM_PlanMsgToState_t.curpos.theta;
    + h; N# z- r! E0 G) ^
24.             g_tRouteCoord.CurrentCoo.cooY = LSLAM_PlanMsgToState_t.point1.y;
    , z: d" m& a2 |: W' Y/ v1 x
25.             g_tRouteCoord.Coo1.cooX       = LSLAM_PlanMsgToState_t.point2.x;
    
26.             g_tRouteCoord.Coo1.cooY       = LSLAM_PlanMsgToState_t.point2.y;
    
27.             g_tRouteCoord.Coo2.cooX       = LSLAM_PlanMsgToState_t.point3.x;
    
28.             g_tRouteCoord.Coo2.cooY       = LSLAM_PlanMsgToState_t.point3.y;
    ! A5 l. D: a1 }) C
29.             g_tRouteCoord.Coo3.cooX       = LSLAM_PlanMsgToState_t.point4.x;
    
30.             g_tRouteCoord.Coo3.cooY       = LSLAM_PlanMsgToState_t.point4.y;
    
31.             g_tRouteCoord.Coo4.cooX       = LSLAM_PlanMsgToState_t.point5.x;
    
32.             g_tRouteCoord.Coo4.cooY       = LSLAM_PlanMsgToState_t.point5.y;
    
33.         
    
34.             IsGetRoute = true;
    
35.     }
    / u0 @  E! ~; Q8 r" ~2 M: P5 I
36.             g_tRouteCoord.CurrentCoo.cooX = LSLAM_PlanMsgToState_t.point1.x;
    : P& R( e1 A. K. C  U
37.    
      r5 m" b# B) G" c3 R* |
38.     if(pb_decode(&ip_stream , IsGetGyroOffset_fields ,&IsGetGyroOffset_t))
    
39.     {
    , q+ r( E' c2 c% _( U* S# S9 H& w) _  g! \
40.         H6IsGetGyroOffset = IsGetGyroOffset_t.IsGetStatus;
    6 p( v. Q6 V) V
41.     }
    . }" b1 J$ c* D7 q5 q) }/ A
42.    
    ( A+ P( i4 ?$ J! X1 T
43.     return status;
    
44. }</font>

复制代码

通过这个解码对象生成的值，可以判断数据对应的哪个结构体，从而填充不同的结构体出来。

五、protobuf的缺点和不足

" ~7 b- N# A6 x6 N

protobuf终究是面向上层开发出来的数据打包协议，但是正如.proto文件限制的那样，它打包数据的最小单位是32位，也就是说我们想通过protobuf传输一个bool量的数据也要用一个32位的结构体成员去承载它。

尽管protobuf拥有优化打包数据内存的功能，也就是说当一个数据很小的时候（小于255），protobuf会将其打包成uint8_t类型的数据序列化到数组里，但是这样的特性也意味着数据打包长短的不确定性，这在一个稳定的通信系统里面是很致命的一点。我们需要定义一个最大长度的数组去承载protobuf序列化前后的数据。

protobuf打包数据其实和我们自己定义协议一样，我们可以把序列化以后的数据通过串口打印出来，就可以发现所谓的序列化也只不过是对一帧数据加上帧头帧尾帧校验然后发送出去。利用protobuf协议只是方便和linux端的通信，这样项目里的每个程序块都可以用同一个.proto文件进行数据的通信，这在一个大型项目里是很有好处的。

至此，基于protobuf完成stm32和Linux的数据通信为大家介绍完毕。

- O' k7 X* \/ A# F% q( Q2 D

5 ~; P  s0 Z* c7 O5 s1 c; c