devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

protocol buffer协议的两种常用框架protobuf和nanopb

作者：小桥流水78 | 2024-06-27 19:00:49

赞

踩

nanopb

目录

目录

什么是protocol buffer

1.protobuf

1.1安装

 1.2使用

2.nanopb（支持c语言）

2.1解压压缩包

2.2使用nanopb

3.3python解析nanopb生成的二进制数据

什么是protocol buffer

百度百科解释如下
  protocolbuffer(以下简称PB)是google 的一种数据交换的格式，它独立于语言，独立于平台。google 提供了多种语言的实现：java、c#、c++、go 和 python，每一种实现都包含了相应语言的编译器以及库文件。
由于它是一种二进制的格式，比使用 xml 进行数据交换快许多。可以把它用于分布式应用之间的数据通信或者异构环境下的数据交换。
作为一种效率和兼容性都很优秀的二进制数据传输格式，可以用于诸如网络传输、配置文件、数据存储等诸多领域。

PB和json，xml比较：
一条消息数据，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一，总体看来PB的优势还是很明显的。
简单说来PB的主要优点就是：简单，快。缺点：可读性差

PB协议处理常用的两种框架protobuf和nanopb进行介绍

1.protobuf

protobuf是PB协议使用较广的一个框架，支持C++，JAVA，Python，Ruby，Go，PHP等多种语言，具体如下：

1.1安装

（1）protobuf源码git地址
https://gitcode.net/mirrors/google/protobuf?utm_source=csdn_github_accelerator
（2）protobuf各发行版本地址
https://github.com/protocolbuffers/protobuf/tags
例如下载protobuf-all-3.6.1.tar.gz


tar -zxvf protobuf-all-3.6.1.tar.gz
cd protobuf-3.6.1 
检测安装环境和生成Makefile
./configure --prefix=/home/tiger/protobuf-3.6.1/protobuf 

编译和安装
make && make install


安装完成后在目录/home/tiger/protobuf-3.6.1/protobuf下可以看到三个文件夹：


bin:存放protoc可执行程序
include:调用protobuf所需头文件
lib:调用protobuf所需库文件
查看protoc版本：
cd bin
./protoc --version

 

 1.2使用

参考文章：

java中使用protobuf总结

python中读写Protobuf总结

python中protobuf和json互相转换应用

2.nanopb（支持c语言）

protobuf支持多种语言，但是却不支持纯C语言，而且protobuf的使用笨重，在一些内存紧张的嵌入式设备上不能使用，nanopb是谷歌协议缓冲数据格式的一个纯C实现。它的目标是32位微控制器，但也适用于其他嵌入式系统的严格(< 10kB ROM，< 1kB RAM)内存限制。
源码下载地址如下：
https://jpa.kapsi.fi/nanopb/download/

2.1解压压缩包

此处以版本0.3.9.4为例子进行说明
tar -zxvf nanopb-0.3.9.4-linux-x86.tar.gz 

2.2使用nanopb

cd nanopb-0.3.9.4-linux-x86
如下7个文件是nanopb用来处理protocol buffer协议的核心文件

  1. pb_common.c
  2. pb_common.h
  3. pb_decode.c
  4. pb_decode.h
  5. pb_encode.c
  6. pb_encode.h
  7. pb.h

定义协议：

metric.proto

syntax = "proto3";

package com.union.fun;

option optimize_for = LITE_RUNTIME;

enum MetricStatus {

UNKNOWN = 0;

IDLE = 1;

BUSY = 2;

}

message Metric {

string name = 1;// [nanopb.max_length = 40];

string type = 2;

float value = 3;

repeated string tags = 4;// [(nanopb).max_length = 40, (nanopb).max_count = 5];

int32 id = 5;

repeated string remarks = 6;

MetricStatus status = 7;

bytes version = 8;

}

metric.options

com.union.fun.Metric.name max_length:40 
com.union.fun.Metric.tags max_size:40 max_count:5

生成实现文件：
生成器根据metric.proto生成对应的实现文件和头文件metric.pb.h 和 metric.pb.c

/home/tiger/nanopb-0.3.9.4-linux-x86/generator-bin/protoc  --nanopb_out=. metric.proto

查看各个字段名称

/home/tiger/nanopb-0.3.9.4-linux-x86/generator-bin/protoc  --nanopb_out=-v:. metric.proto

C++方式如下：

/home/tiger/nanopb-0.3.9.4-linux-x86/generator-bin/protoc  --cpp_out=./ metric.proto

1）string类型使用注意
在nanopb中,string类型在生成c语言文件的时候,会有两种结构,一种是指定了最大长度的,一种是没有指定最大长度.指定了最大长度的string,会生成char[] 数组类型,
没有指定最大长度的,会生成pb_callback_t类型.具体的可以参照nanopb文档（https://jpa.kapsi.fi/nanopb/docs/concepts.html#compiling-proto-files-for-nanopb）


2）.proto中optimize_for的参数
option optimize_for = LITE_RUNTIME;
optimize_for是文件级别的选项，Protocol Buffer定义三种优化级别SPEED/CODE_SIZE/LITE_RUNTIME。缺省情况下是SPEED。
SPEED: 表示生成的代码运行效率高，但是由此生成的代码编译后会占用更多的空间。
CODE_SIZE: 和SPEED恰恰相反，代码运行效率较低，但是由此生成的代码编译后会占用更少的空间，通常用于资源有限的平台，如Mobile。
LITE_RUNTIME: 生成的代码执行效率高，同时生成代码编译后的所占用的空间也是非常少。这是以牺牲Protocol Buffer提供的反射功能为代价的。因此我们在C++中链接Protocol Buffer库时仅需链接libprotobuf-lite，而非libprotobuf。
在Java中仅需包含protobuf-java-2.4.1-lite.jar，而非protobuf-java-2.4.1.jar。
注：对于LITE_MESSAGE选项而言，其生成的代码均将继承自MessageLite，而非Message。

3）pb_callback_t结构

pb_callback_t 是一个结构体,有两个成员变量,一个是回调函数指针,这个回调函数是一个union,在编码的时候,需要赋值encode函数,解码的时候赋值decode,如果不赋值,则该属性值会忽略.
另外一个变量是arg,这是一个指针,会在回调函数中作为最后一个参数传递给回调函数.
typedef struct pb_callback_s pb_callback_t;
struct pb_callback_s {
#ifdef PB_OLD_CALLBACK_STYLE
    /* Deprecated since nanopb-0.2.1 */
    union {
        bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void *arg);
        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, const void *arg);
    } funcs;
#else
    /* New function signature, which allows modifying arg contents in callback. */
    union {
        bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
    } funcs;
#endif    
    
    /* Free arg for use by callback */
    void *arg;
};

struct _pb_ostream_t
{
   bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
   void *state;
   size_t max_size;
   size_t bytes_written;
};

struct _pb_istream_t
{
   bool (*callback)(pb_istream_t *stream, uint8_t *buf, size_t count);
   void *state;
   size_t bytes_left;
};

调用举例：

项目结构：

 main.c

  1. #include "metric.pb.h"
  2. #include "nanopb_tools.h"
  3.  
  4. #define DATA_BUFFER_SIZE 1024
  5.  
  6. bool write_string_list(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  7. {
  8.     char *str = *arg;
  9.     if (!pb_encode_tag_for_field(stream, field))
  10.         return false;
  11.     printf("write_string_list %s\n", str);
  12.     return pb_encode_string(stream, (uint8_t*)str, strlen(str));
  13. }
  14.  
  15. //打包
  16. static int pack_data(uint8_t *buffer)
  17. {
  18.     com_union_fun_Metric metric = com_union_fun_Metric_init_zero;
  19.  
  20.     memset(buffer, 0, DATA_BUFFER_SIZE);
  21.  
  22.     char name[41];
  23.     pb_callback_t type;
  24.     float value;
  25.     pb_size_t tags_count;
  26.     char tags[5][40];
  27.     int32_t id;
  28.     pb_callback_t remarks;
  29.     com_union_fun_MetricStatus status;
  30.     pb_callback_t version;
  31.  
  32.     strcpy(metric.name, "liudehua");
  33.  
  34.     metric.type.funcs.encode = write_string;
  35.     metric.type.arg = &"welcome to using nanopb";
  36.  
  37.     metric.value = 99.01; 
  38.     
  39.     metric.tags_count = 5;
  40.     for (int i = 0; i < 5; i++) {
  41.         sprintf(metric.tags[i], "%d ok", i);
  42.     }
  43.  
  44.     metric.id = 110;
  45.  
  46.     //metric.remarks.funcs.encode = &write_string_list;
  47.     //metric.remarks.arg = &"hello hello hello hello hello";
  48.  
  49.     metric.status = com_union_fun_MetricStatus_BUSY;
  50.  
  51.     metric.version.funcs.encode = &nanopb_encode_map_bytes;
  52.     char strVersion[128] = {0};
  53.     strcpy(strVersion, "V1.0.0.1");
  54.     struct pb_bytes_array byteData;
  55.     byteData.size = strlen(strVersion);
  56.     byteData.bytes = (uint8_t*)strVersion;
  57.     metric.version.arg = &byteData;
  58.  
  59.     pb_ostream_t enc_stream;
  60. 	enc_stream = pb_ostream_from_buffer(buffer, DATA_BUFFER_SIZE);
  61. 	if (!pb_encode(&enc_stream, com_union_fun_Metric_fields, &metric))
  62. 	{
  63. 		printf("pb_encode error in %s [%s]\n", __func__, PB_GET_ERROR(&enc_stream));
  64. 		return -1;
  65. 	}
  66.  
  67.     return enc_stream.bytes_written;
  68. }
  69.  
  70. //解包
  71. static int unpack_data(const uint8_t *buffer, size_t len)
  72. {
  73.     com_union_fun_Metric metric;
  74.  
  75.     metric.type.funcs.decode = read_ints;
  76.     char tmp[128] = {0};
  77.     metric.type.arg = &tmp;
  78.  
  79.     metric.version.funcs.decode = nanopb_decode_map_bytes;
  80.     metric.version.arg = NULL;
  81.  
  82. 	pb_istream_t dec_stream;
  83. 	dec_stream = pb_istream_from_buffer(buffer, len);
  84. 	if (!pb_decode(&dec_stream, com_union_fun_Metric_fields, &metric))
  85. 	{
  86. 		printf("pb_decodeerror in  %s [%s]\n", __func__, PB_GET_ERROR(&dec_stream));
  87. 		return -1;
  88. 	}
  89.  
  90.     for (int i = 0; i < 5; i++) {
  91.         printf("unpack_data: %d %s %s %f %s %d %s\n", 
  92.             metric.id, metric.name, tmp, metric.value, metric.tags[i], metric.status, (char*)metric.version.arg);
  93.     }
  94.     
  95.     nanopb_release_map_bytes(&metric.version);
  96.  
  97.     return 0;
  98. }
  99.  
  100. int main(int argc,char *argv[])
  101. {
  102.     uint8_t buffer[DATA_BUFFER_SIZE];
  103.  
  104.     int lenght = pack_data(buffer);
  105.     if(lenght < 0) {
  106.         printf("pack_data fail \n");
  107.         return -1;
  108.     }
  109.     printf("pack_data len: %d\n", lenght);
  110.     unpack_data(buffer, lenght);
  111.  
  112.     return 0;
  113. }

metric.pb.h

  1. /* Automatically generated nanopb header */
  2. /* Generated by nanopb-0.3.9.4 at Mon Mar 13 20:12:37 2023. */
  3.  
  4. #ifndef PB_COM_UNION_FUN_METRIC_PB_H_INCLUDED
  5. #define PB_COM_UNION_FUN_METRIC_PB_H_INCLUDED
  6. #include <pb.h>
  7.  
  8. /* @@protoc_insertion_point(includes) */
  9. #if PB_PROTO_HEADER_VERSION != 30
  10. #error Regenerate this file with the current version of nanopb generator.
  11. #endif
  12.  
  13. #ifdef __cplusplus
  14. extern "C" {
  15. #endif
  16.  
  17. /* Enum definitions */
  18. typedef enum _com_union_fun_MetricStatus {
  19.     com_union_fun_MetricStatus_UNKNOWN = 0,
  20.     com_union_fun_MetricStatus_IDLE = 1,
  21.     com_union_fun_MetricStatus_BUSY = 2
  22. } com_union_fun_MetricStatus;
  23. #define _com_union_fun_MetricStatus_MIN com_union_fun_MetricStatus_UNKNOWN
  24. #define _com_union_fun_MetricStatus_MAX com_union_fun_MetricStatus_BUSY
  25. #define _com_union_fun_MetricStatus_ARRAYSIZE ((com_union_fun_MetricStatus)(com_union_fun_MetricStatus_BUSY+1))
  26.  
  27. /* Struct definitions */
  28. typedef struct _com_union_fun_Metric {
  29.     char name[41];
  30.     pb_callback_t type;
  31.     float value;
  32.     pb_size_t tags_count;
  33.     char tags[5][40];
  34.     int32_t id;
  35.     pb_callback_t remarks;
  36.     com_union_fun_MetricStatus status;
  37.     pb_callback_t version;
  38. /* @@protoc_insertion_point(struct:com_union_fun_Metric) */
  39. } com_union_fun_Metric;
  40.  
  41. /* Default values for struct fields */
  42.  
  43. /* Initializer values for message structs */
  44. #define com_union_fun_Metric_init_default        {"", {{NULL}, NULL}, 0, 0, {"", "", "", "", ""}, 0, {{NULL}, NULL}, _com_union_fun_MetricStatus_MIN, {{NULL}, NULL}}
  45. #define com_union_fun_Metric_init_zero           {"", {{NULL}, NULL}, 0, 0, {"", "", "", "", ""}, 0, {{NULL}, NULL}, _com_union_fun_MetricStatus_MIN, {{NULL}, NULL}}
  46.  
  47. /* Field tags (for use in manual encoding/decoding) */
  48. #define com_union_fun_Metric_name_tag            1
  49. #define com_union_fun_Metric_type_tag            2
  50. #define com_union_fun_Metric_value_tag           3
  51. #define com_union_fun_Metric_tags_tag            4
  52. #define com_union_fun_Metric_id_tag              5
  53. #define com_union_fun_Metric_remarks_tag         6
  54. #define com_union_fun_Metric_status_tag          7
  55. #define com_union_fun_Metric_version_tag         8
  56.  
  57. /* Struct field encoding specification for nanopb */
  58. extern const pb_field_t com_union_fun_Metric_fields[9];
  59.  
  60. /* Maximum encoded size of messages (where known) */
  61. /* com_union_fun_Metric_size depends on runtime parameters */
  62.  
  63. /* Message IDs (where set with "msgid" option) */
  64. #ifdef PB_MSGID
  65.  
  66. #define METRIC_MESSAGES \
  68.  
  69. #endif
  70.  
  71. #ifdef __cplusplus
  72. } /* extern "C" */
  73. #endif
  74. /* @@protoc_insertion_point(eof) */
  75.  
  76. #endif

metric.pb.c

  1. /* Automatically generated nanopb constant definitions */
  2. /* Generated by nanopb-0.3.9.4 at Mon Mar 13 20:12:37 2023. */
  3.  
  4. #include "metric.pb.h"
  5.  
  6. /* @@protoc_insertion_point(includes) */
  7. #if PB_PROTO_HEADER_VERSION != 30
  8. #error Regenerate this file with the current version of nanopb generator.
  9. #endif
  10.  
  11.  
  12.  
  13. const pb_field_t com_union_fun_Metric_fields[9] = {
  14.     PB_FIELD(  1, STRING  , SINGULAR, STATIC  , FIRST, com_union_fun_Metric, name, name, 0),
  15.     PB_FIELD(  2, STRING  , SINGULAR, CALLBACK, OTHER, com_union_fun_Metric, type, name, 0),
  16.     PB_FIELD(  3, FLOAT   , SINGULAR, STATIC  , OTHER, com_union_fun_Metric, value, type, 0),
  17.     PB_FIELD(  4, STRING  , REPEATED, STATIC  , OTHER, com_union_fun_Metric, tags, value, 0),
  18.     PB_FIELD(  5, INT32   , SINGULAR, STATIC  , OTHER, com_union_fun_Metric, id, tags, 0),
  19.     PB_FIELD(  6, STRING  , REPEATED, CALLBACK, OTHER, com_union_fun_Metric, remarks, id, 0),
  20.     PB_FIELD(  7, UENUM   , SINGULAR, STATIC  , OTHER, com_union_fun_Metric, status, remarks, 0),
  21.     PB_FIELD(  8, BYTES   , SINGULAR, CALLBACK, OTHER, com_union_fun_Metric, version, status, 0),
  22.     PB_LAST_FIELD
  23. };
  24.  
  25.  
  26.  
  27. /* @@protoc_insertion_point(eof) */

nanopb_tools.h

  1. #ifndef _NANOPB_TOOL_H_
  2. #define _NANOPB_TOOL_H_
  3. #include "pb.h"
  4. #include "pb_encode.h"
  5. #include "pb_decode.h"
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. struct pb_bytes_array {
  11.     int size;
  12.     uint8_t* bytes;
  13. };
  14.  
  15. bool write_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
  16.  
  17. bool read_ints(pb_istream_t *stream, const pb_field_t *field, void **arg);
  18.  
  19. /**
  20.  *	nanopb库解析bytes类型
  21.  *
  22.  *		@param		[in] stream			nanop：b输入数据流
  23.  *		@param		[in] field			proto对象属性域数组
  24.  *		@param		[in] arg			callback回调的参数(外部传入NULL即可，内存动态申请内存)
  25.  *
  26.  *		@return		是否解析成功
  27.  *		@note：		nanopb在解析不定长对象时需要指定解析的回调函数，为了方便，解析string类型，封装该方法
  28.  *
  29.  */
  30. bool nanopb_decode_map_bytes(pb_istream_t *stream, const pb_field_t *field, void **arg);
  31.  
  32. // 
  33. bool nanopb_decode_map_string(pb_istream_t *stream, const pb_field_t *field, void **arg);
  34.  
  35. /**
  36.  *	nanopb库构造string 类型buffer
  37.  *
  38.  *		@param		[in] stream			nanop：b输入数据流
  39.  *		@param		[in] field			proto对象属性域数组
  40.  *		@param		[in] arg			callback回调的参数(外部传入)
  41.  *
  42.  *		@return		是否解析成功
  43.  *		@note：		nanopb在解析不定长对象时需要指定解析的回调函数，为了方便，解析string类型，封装该方法
  44.  *
  45.  */
  46. bool nanopb_encode_map_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
  47.  
  48. bool nanopb_encode_map_bytes(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
  49.  
  50. /**
  51.  *	nanopb库释放callback申请的heap内存
  52.  *
  53.  *		@param		[in] pCallBack			指向callback申请内存的指针
  54.  *
  55.  *		@return		N/A
  56.  *		@note：
  57.  *
  58.  */
  59. void nanopb_release_map_string(pb_callback_t* pCallBack);
  60.  
  61.  
  62. /**
  63.  *	nanopb库释放callback申请的heap内存
  64.  *
  65.  *		@param		[in] pCallBack			指向callback申请内存的指针
  66.  *
  67.  *		@return		N/A
  68.  *		@note：
  69.  *
  70.  */
  71. void nanopb_release_map_bytes(pb_callback_t* pCallBack);
  72.  
  73. /**
  74.  *	nanopb库设置string类型
  75.  *
  76.  *		@param		[in] pCallBack		string的callback
  77.  *		@param		[in] pSrcChar		源字符串
  78.  *		@return		N/A
  79.  *		@note：		nanopb的字符串类型赋值封装接口，内部会申请内存
  80.  *
  81.  */
  82. void nanopb_map_set_string(pb_callback_t* pCallBack, const char* pSrcChar);
  83.  
  84. #endif

nanopb_tools.c

  1. #include "nanopb_tools.h"
  2.  
  3. bool write_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  4. {
  5.     char *str = *arg;
  6.     if (!pb_encode_tag_for_field(stream, field))
  7.         return false;
  8.     // printf("11111111111111111\n");
  9.     return pb_encode_string(stream, (uint8_t*)str, strlen(str));
  10. }
  11.  
  12. bool read_ints(pb_istream_t *stream, const pb_field_t *field, void **arg)
  13. {
  14.     int i=0;
  15.     char* tmp = *arg;
  16.     while (stream->bytes_left)
  17.     {
  18.         uint64_t value;
  19.         if (!pb_decode_varint(stream, &value))
  20.             return false;
  21.         *(tmp+i)=value;
  22.         i++;
  23.         // printf("222222222222222222\n");
  24.     }
  25.     return true;
  26. }
  27.  
  28. /**
  29.  *	nanopb库解析bytes类型
  30.  *
  31.  *		@param		[in] stream			nanop：b输入数据流
  32.  *		@param		[in] field			proto对象属性域数组
  33.  *		@param		[in] arg			callback回调的参数(外部传入NULL即可，内存动态申请内存)
  34.  *
  35.  *		@return		是否解析成功
  36.  *		@note：		nanopb在解析不定长对象时需要指定解析的回调函数，为了方便，解析string类型，封装该方法
  37.  *
  38.  */
  39. bool nanopb_decode_map_bytes(pb_istream_t *stream, const pb_field_t *field, void **arg)
  40. {
  41. #if 1
  42.     if (*arg != NULL)
  43.     {
  44.         free(*arg);
  45.         *arg = NULL;
  46.     }
  47. #else
  48.     if (*arg != NULL)
  49.     {
  50.         pb_bytes_array* pBytes = (pb_bytes_array*)*arg;
  51.         if (pBytes->bytes)
  52.         {
  53.             free(pBytes->bytes);
  54.             pBytes->bytes = NULL;
  55.         }
  56.         pBytes->size = 0;
  57.         delete[] pBytes;
  58.         *arg = NULL;
  59.     }
  60. #endif
  61.  
  62. #if 1
  63.     size_t alloc_size = 0;
  64.     bool status = false;
  65.  
  66.     size_t size = stream->bytes_left;
  67.     /* Space for null terminator */
  68.     alloc_size = size + 1;
  69.  
  70.     if (alloc_size < size) {
  71.         PB_RETURN_ERROR(stream, "size too large");
  72.     }
  73.  
  74.     char* pData = (char*)malloc(alloc_size);
  75.  
  76.     if (!pData) {
  77.         return false;
  78.     }
  79.     memset(pData, 0, alloc_size);
  80.  
  81.     status = pb_read(stream, (uint8_t*)pData, size);
  82.     *((uint8_t*)pData + size) = 0;
  83.  
  84.     *arg = pData;
  85.  
  86. #else
  87.     pb_bytes_array* pDest = new pb_bytes_array;
  88.     if (!pDest)
  89.         return V_FALSE;
  90.  
  91.     bool status;
  92.     size_t alloc_size = stream->bytes_left;
  93.  
  94.     pDest->bytes = (uint8_t*)malloc(alloc_size);
  95.  
  96.     if (!pDest->bytes)
  97.     {
  98.         delete pDest;
  99.         return V_TRUE;
  100.     }
  101.  
  102.     pDest->size = alloc_size;
  103.     memset(pDest->bytes, 0, alloc_size);
  104.  
  105.     status = pb_read(stream, (uint8_t*)pDest->bytes, pDest->size);
  106.  
  107.     *arg = pDest;
  108. #endif
  109.  
  110.     return status;
  111. }
  112.  
  113.  
  114.  
  115. // 
  116. bool nanopb_decode_map_string(pb_istream_t *stream, const pb_field_t *field, void **arg)
  117. {
  118.     if ( *arg != NULL )
  119.     {
  120.         free(*arg);
  121.         *arg = NULL;
  122.     }
  123.  
  124.     size_t alloc_size;
  125.     bool status;
  126.     //if (!pb_decode_varint32(stream, &size))
  127.     //	return false;
  128.     size_t size = stream->bytes_left;
  129.     /* Space for null terminator */
  130.     alloc_size = size + 1;
  131.  
  132.     if (alloc_size < size)
  133.         PB_RETURN_ERROR(stream, "size too large");
  134.  
  135.     char* pData = (char*)malloc( alloc_size );
  136.  
  137.     if ( !pData )
  138.         return false;
  139.     memset(pData, 0, alloc_size);
  140.  
  141.     status = pb_read(stream, (uint8_t*)pData, size);
  142.     *((uint8_t*)pData + size) = 0;
  143.  
  144.     *arg = pData;
  145.  
  146.     return status;
  147. }
  148.  
  149. /**
  150.  *	nanopb库构造string 类型buffer
  151.  *
  152.  *		@param		[in] stream			nanop：b输入数据流
  153.  *		@param		[in] field			proto对象属性域数组
  154.  *		@param		[in] arg			callback回调的参数(外部传入)
  155.  *
  156.  *		@return		是否解析成功
  157.  *		@note：		nanopb在解析不定长对象时需要指定解析的回调函数，为了方便，解析string类型，封装该方法
  158.  *
  159.  */
  160. bool nanopb_encode_map_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  161. {
  162.     if ( !stream || !field )
  163.         return false;
  164.  
  165.     int nLen = 0;
  166.     if ( *arg )
  167.     {
  168.         nLen = strlen((const char *)*arg);
  169.     }
  170.     return pb_encode_tag_for_field(stream, field) &&
  171.         pb_encode_string(stream, (const uint8_t *)*arg, nLen);
  172. }
  173.  
  174. bool nanopb_encode_map_bytes(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  175. {
  176.     if (!stream || !field)
  177.         return false;
  178.     const struct pb_bytes_array *bytes = (const struct pb_bytes_array*)*arg;
  179.  
  180.     if (bytes == NULL)
  181.     {
  182.         printf("nanopb_encode_map_bytes 1\n");
  183.         /* Threat null pointer as an empty bytes field */
  184.         return pb_encode_string(stream, NULL, 0);
  185.     }
  186.     printf("nanopb_encode_map_bytes 2\n");
  187.     return pb_encode_tag_for_field(stream, field) &&
  188.     pb_encode_string(stream, (const uint8_t *)bytes->bytes, bytes->size);
  189. }
  190.  
  191. /**
  192.  *	nanopb库释放callback申请的heap内存
  193.  *
  194.  *		@param		[in] pCallBack			指向callback申请内存的指针
  195.  *
  196.  *		@return		N/A
  197.  *		@note：
  198.  *
  199.  */
  200. void nanopb_release_map_string(pb_callback_t* pCallBack)
  201. {
  202.     if ( !pCallBack || !pCallBack->arg )
  203.         return;
  204.  
  205.     char* pData = (char*)pCallBack->arg;
  206.     if ( pData )
  207.     {
  208.         free(pData);
  209.         pCallBack->arg = NULL;
  210.     }
  211. }
  212.  
  213.  
  214. /**
  215.  *	nanopb库释放callback申请的heap内存
  216.  *
  217.  *		@param		[in] pCallBack			指向callback申请内存的指针
  218.  *
  219.  *		@return		N/A
  220.  *		@note：
  221.  *
  222.  */
  223. void nanopb_release_map_bytes(pb_callback_t* pCallBack)
  224. {
  225.     if ( !pCallBack || !pCallBack->arg )
  226.         return;
  227.  
  228. #if 1
  229.     char* pData = (char*)pCallBack->arg;
  230.     if (pData)
  231.     {
  232.         free(pData);
  233.         pCallBack->arg = NULL;
  234.     }
  235. #else
  236.     pb_bytes_array* pBytes = (pb_bytes_array*)pCallBack->arg;
  237.     if (pBytes->bytes)
  238.     {
  239.         free(pBytes->bytes);
  240.         pBytes->bytes = V_NULL;
  241.     }
  242.  
  243.     pBytes->size = 0;
  244.     delete pBytes;
  245.     pCallBack->arg = V_NULL;
  246. #endif
  247. }
  248.  
  249. /**
  250.  *	nanopb库设置string类型
  251.  *
  252.  *		@param		[in] pCallBack		string的callback
  253.  *		@param		[in] pSrcChar		源字符串
  254.  *		@return		N/A
  255.  *		@note：		nanopb的字符串类型赋值封装接口，内部会申请内存
  256.  *
  257.  */
  258. void nanopb_map_set_string(pb_callback_t* pCallBack, const char* pSrcChar)
  259. {
  260.     if(!pCallBack || !pSrcChar)
  261.         return;
  262.  
  263.     int nLen = strlen(pSrcChar);
  264.  
  265.     pCallBack->arg = malloc(nLen+1);
  266.     memset( pCallBack->arg, 0, nLen+1 );
  267.  
  268.     if ( pCallBack->arg )
  269.     {
  270.         memcpy(pCallBack->arg, pSrcChar, nLen);
  271.     }
  272. }

编译：

gcc -I . main.c metric.pb.c pb_common.c pb_decode.c  pb_encode.c nanopb_tools.c

执行：

./a.out

运行结果：

源码下载

3.3python解析nanopb生成的二进制数据

  1. #include "metric.pb.h"
  2. #include "nanopb_tools.h"
  3.  
  4. #define DATA_BUFFER_SIZE 1024
  5.  
  6. bool write_string_list(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  7. {
  8.     char *str = *arg;
  9.     if (!pb_encode_tag_for_field(stream, field))
  10.         return false;
  11.     printf("write_string_list %s\n", str);
  12.     return pb_encode_string(stream, (uint8_t*)str, strlen(str));
  13. }
  14.  
  15. //打包
  16. static int pack_data(uint8_t *buffer)
  17. {
  18.     com_union_fun_Metric metric = com_union_fun_Metric_init_zero;
  19.  
  20.     memset(buffer, 0, DATA_BUFFER_SIZE);
  21.  
  22.     char name[41];
  23.     pb_callback_t type;
  24.     float value;
  25.     pb_size_t tags_count;
  26.     char tags[5][40];
  27.     int32_t id;
  28.     pb_callback_t remarks;
  29.     com_union_fun_MetricStatus status;
  30.     pb_callback_t version;
  31.  
  32.     strcpy(metric.name, "liudehua");
  33.  
  34.     metric.type.funcs.encode = write_string;
  35.     metric.type.arg = &"welcome to using nanopb";
  36.  
  37.     metric.value = 99.01; 
  38.     
  39.     metric.tags_count = 5;
  40.     for (int i = 0; i < 5; i++) {
  41.         sprintf(metric.tags[i], "%d ok", i);
  42.     }
  43.  
  44.     metric.id = 110;
  45.  
  46.     //metric.remarks.funcs.encode = &write_string_list;
  47.     //metric.remarks.arg = &"hello hello hello hello hello";
  48.  
  49.     metric.status = com_union_fun_MetricStatus_BUSY;
  50.  
  51.     metric.version.funcs.encode = &nanopb_encode_map_bytes;
  52.     char strVersion[128] = {0};
  53.     strcpy(strVersion, "V1.0.0.1");
  54.     struct pb_bytes_array byteData;
  55.     byteData.size = strlen(strVersion);
  56.     byteData.bytes = (uint8_t*)strVersion;
  57.     metric.version.arg = &byteData;
  58.  
  59.     pb_ostream_t enc_stream;
  60. 	enc_stream = pb_ostream_from_buffer(buffer, DATA_BUFFER_SIZE);
  61. 	if (!pb_encode(&enc_stream, com_union_fun_Metric_fields, &metric))
  62. 	{
  63. 		printf("pb_encode error in %s [%s]\n", __func__, PB_GET_ERROR(&enc_stream));
  64. 		return -1;
  65. 	}
  66.  
  67.     return enc_stream.bytes_written;
  68. }
  69.  
  70. //解包
  71. static int unpack_data(const uint8_t *buffer, size_t len)
  72. {
  73.     com_union_fun_Metric metric;
  74.  
  75.     metric.type.funcs.decode = read_ints;
  76.     char tmp[128] = {0};
  77.     metric.type.arg = &tmp;
  78.  
  79.     metric.version.funcs.decode = nanopb_decode_map_bytes;
  80.     metric.version.arg = NULL;
  81.  
  82. 	pb_istream_t dec_stream;
  83. 	dec_stream = pb_istream_from_buffer(buffer, len);
  84. 	if (!pb_decode(&dec_stream, com_union_fun_Metric_fields, &metric))
  85. 	{
  86. 		printf("pb_decodeerror in  %s [%s]\n", __func__, PB_GET_ERROR(&dec_stream));
  87. 		return -1;
  88. 	}
  89.  
  90.     for (int i = 0; i < 5; i++) {
  91.         printf("unpack_data: %d %s %s %f %s %d %s\n", 
  92.             metric.id, metric.name, tmp, metric.value, metric.tags[i], metric.status, (char*)metric.version.arg);
  93.     }
  94.     
  95.     nanopb_release_map_bytes(&metric.version);
  96.  
  97.     return 0;
  98. }
  99.  
  100. int main(int argc,char *argv[])
  101. {
  102.     uint8_t buffer[DATA_BUFFER_SIZE];
  103.  
  104.     int lenght = pack_data(buffer);
  105.     if(lenght < 0) {
  106.         printf("pack_data fail \n");
  107.         return -1;
  108.     }
  109.  
  110.     FILE* fp = fopen("metric.bin", "wb");
  111.     fwrite(buffer, sizeof(uint8_t), lenght, fp);
  112.     fwrite(buffer, sizeof(uint8_t), lenght, fp);
  113.     fwrite(buffer, sizeof(uint8_t), lenght, fp);
  114.     fclose(fp);
  115.     fp = NULL;
  116.  
  117.     printf("pack_data len: %d\n", lenght);
  118.     unpack_data(buffer, lenght);
  119.  
  120.     return 0;
  121. }

运行结果如下：

从运行结果可以看出每个对象84字节 , 将3个nanopb生成的PB对象存放在metric.bin

利用Python解析读取

/home/tiger/protobuf-3.6.1/protobuf/bin/protoc -I=/home/tiger/nanopb  --python_out=/home/tiger/nanopb  metric.proto

test_nanopb.py

  1. """
  2. This is the main module.
  3. """
  4. #coding=utf-8
  5. import sys
  6. import os
  7. import argparse
  8. import metric_pb2
  9.  
  10. '''
  11. /home/tiger/protobuf-3.6.1/protobuf/bin/protoc -I=/home/tiger/nanopb  --python_out=/home/tiger/nanopb  metric.proto
  12. python3 test_nanopb.py -f=metric.bin 
  13. '''
  14.  
  15. def main(pbfile):
  16.     print("main start ...", pbfile)
  17.     index = 0
  18.     with open(pbfile, 'rb') as f:
  19.         buf = f.read()
  20.         while index < len(buf):
  21.             data = buf[index : index+84]
  22.             index += 84
  23.             #print(data)
  24.             read_metric = metric_pb2.Metric()
  25.             read_metric.ParseFromString(data)
  26.             print(read_metric)
  27.             print("================")
  28.           
  29. if __name__ == "__main__":
  30.     #print(sys.argv)
  31.     parser = argparse.ArgumentParser()
  32.     
  33.     parser.add_argument(
  34.         '-f', '--file', dest='pbfile', type=str, default="anpVehicleData.log",
  35.         help='input pb file'
  36.     )
  37.     
  38.     parser.add_argument(
  39.         '-s', '--start', dest='startpos', default=123, required=False,
  40.         help='input start postion'
  41.     ) 
  42.     
  43.     parser.add_argument(
  44.         '-e', '--end', dest='endpos', default=456, required=False,
  45.         help='input end postion'
  46.     ) 
  47.  
  48.     args = parser.parse_args()
  49.     pbfile = args.pbfile
  50.     startpos = args.startpos
  51.     endpos = args.endpos
  52.     print("pbfile:", pbfile)
  53.     print("startpos:", startpos)
  54.     print("endpos:", endpos)
  55.     
  56.     main(pbfile)

执行Python脚本：python3 test_nanopb.py -f=metric.bin

可以看到三个PB对象被成功解析出来 

说明：另一种支持c语言的框架是protobuf-c，此处不再说明

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/763444
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号