53 changed files with 6114 additions and 0 deletions
@ -0,0 +1,917 @@ |
|||
/* Common parts of the nanopb library. Most of these are quite low-level
|
|||
* stuff. For the high-level interface, see pb_encode.h and pb_decode.h. |
|||
*/ |
|||
|
|||
#ifndef PB_H_INCLUDED |
|||
#define PB_H_INCLUDED |
|||
|
|||
/*****************************************************************
|
|||
* Nanopb compilation time options. You can change these here by * |
|||
* uncommenting the lines, or on the compiler command line. * |
|||
*****************************************************************/ |
|||
|
|||
/* Enable support for dynamically allocated fields */ |
|||
/* #define PB_ENABLE_MALLOC 1 */ |
|||
|
|||
/* Define this if your CPU / compiler combination does not support
|
|||
* unaligned memory access to packed structures. Note that packed |
|||
* structures are only used when requested in .proto options. */ |
|||
/* #define PB_NO_PACKED_STRUCTS 1 */ |
|||
|
|||
/* Increase the number of required fields that are tracked.
|
|||
* A compiler warning will tell if you need this. */ |
|||
/* #define PB_MAX_REQUIRED_FIELDS 256 */ |
|||
|
|||
/* Add support for tag numbers > 65536 and fields larger than 65536 bytes. */ |
|||
/* #define PB_FIELD_32BIT 1 */ |
|||
|
|||
/* Disable support for error messages in order to save some code space. */ |
|||
/* #define PB_NO_ERRMSG 1 */ |
|||
|
|||
/* Disable support for custom streams (support only memory buffers). */ |
|||
/* #define PB_BUFFER_ONLY 1 */ |
|||
|
|||
/* Disable support for 64-bit datatypes, for compilers without int64_t
|
|||
or to save some code space. */ |
|||
/* #define PB_WITHOUT_64BIT 1 */ |
|||
|
|||
/* Don't encode scalar arrays as packed. This is only to be used when
|
|||
* the decoder on the receiving side cannot process packed scalar arrays. |
|||
* Such example is older protobuf.js. */ |
|||
/* #define PB_ENCODE_ARRAYS_UNPACKED 1 */ |
|||
|
|||
/* Enable conversion of doubles to floats for platforms that do not
|
|||
* support 64-bit doubles. Most commonly AVR. */ |
|||
/* #define PB_CONVERT_DOUBLE_FLOAT 1 */ |
|||
|
|||
/* Check whether incoming strings are valid UTF-8 sequences. Slows down
|
|||
* the string processing slightly and slightly increases code size. */ |
|||
/* #define PB_VALIDATE_UTF8 1 */ |
|||
|
|||
/* This can be defined if the platform is little-endian and has 8-bit bytes.
|
|||
* Normally it is automatically detected based on __BYTE_ORDER__ macro. */ |
|||
/* #define PB_LITTLE_ENDIAN_8BIT 1 */ |
|||
|
|||
/* Configure static assert mechanism. Instead of changing these, set your
|
|||
* compiler to C11 standard mode if possible. */ |
|||
/* #define PB_C99_STATIC_ASSERT 1 */ |
|||
/* #define PB_NO_STATIC_ASSERT 1 */ |
|||
|
|||
/******************************************************************
|
|||
* You usually don't need to change anything below this line. * |
|||
* Feel free to look around and use the defined macros, though. * |
|||
******************************************************************/ |
|||
|
|||
|
|||
/* Version of the nanopb library. Just in case you want to check it in
|
|||
* your own program. */ |
|||
#define NANOPB_VERSION "nanopb-0.4.8-dev" |
|||
|
|||
/* Include all the system headers needed by nanopb. You will need the
|
|||
* definitions of the following: |
|||
* - strlen, memcpy, memset functions |
|||
* - [u]int_least8_t, uint_fast8_t, [u]int_least16_t, [u]int32_t, [u]int64_t |
|||
* - size_t |
|||
* - bool |
|||
* |
|||
* If you don't have the standard header files, you can instead provide |
|||
* a custom header that defines or includes all this. In that case, |
|||
* define PB_SYSTEM_HEADER to the path of this file. |
|||
*/ |
|||
#ifdef PB_SYSTEM_HEADER |
|||
#include PB_SYSTEM_HEADER |
|||
#else |
|||
#include <stdint.h> |
|||
#include <stddef.h> |
|||
#include <stdbool.h> |
|||
#include <string.h> |
|||
#include <limits.h> |
|||
|
|||
#ifdef PB_ENABLE_MALLOC |
|||
#include <stdlib.h> |
|||
#endif |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Macro for defining packed structures (compiler dependent).
|
|||
* This just reduces memory requirements, but is not required. |
|||
*/ |
|||
#if defined(PB_NO_PACKED_STRUCTS) |
|||
/* Disable struct packing */ |
|||
# define PB_PACKED_STRUCT_START |
|||
# define PB_PACKED_STRUCT_END |
|||
# define pb_packed |
|||
#elif defined(__GNUC__) || defined(__clang__) |
|||
/* For GCC and clang */ |
|||
# define PB_PACKED_STRUCT_START |
|||
# define PB_PACKED_STRUCT_END |
|||
# define pb_packed __attribute__((packed)) |
|||
#elif defined(__ICCARM__) || defined(__CC_ARM) |
|||
/* For IAR ARM and Keil MDK-ARM compilers */ |
|||
# define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)") |
|||
# define PB_PACKED_STRUCT_END _Pragma("pack(pop)") |
|||
# define pb_packed |
|||
#elif defined(_MSC_VER) && (_MSC_VER >= 1500) |
|||
/* For Microsoft Visual C++ */ |
|||
# define PB_PACKED_STRUCT_START __pragma(pack(push, 1)) |
|||
# define PB_PACKED_STRUCT_END __pragma(pack(pop)) |
|||
# define pb_packed |
|||
#else |
|||
/* Unknown compiler */ |
|||
# define PB_PACKED_STRUCT_START |
|||
# define PB_PACKED_STRUCT_END |
|||
# define pb_packed |
|||
#endif |
|||
|
|||
/* Detect endianness */ |
|||
#ifndef PB_LITTLE_ENDIAN_8BIT |
|||
#if ((defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \ |
|||
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \ |
|||
defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || \ |
|||
defined(__THUMBEL__) || defined(__AARCH64EL__) || defined(_MIPSEL) || \ |
|||
defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM)) \ |
|||
&& CHAR_BIT == 8 |
|||
#define PB_LITTLE_ENDIAN_8BIT 1 |
|||
#endif |
|||
#endif |
|||
|
|||
/* Handly macro for suppressing unreferenced-parameter compiler warnings. */ |
|||
#ifndef PB_UNUSED |
|||
#define PB_UNUSED(x) (void)(x) |
|||
#endif |
|||
|
|||
/* Harvard-architecture processors may need special attributes for storing
|
|||
* field information in program memory. */ |
|||
#ifndef PB_PROGMEM |
|||
#ifdef __AVR__ |
|||
#include <avr/pgmspace.h> |
|||
#define PB_PROGMEM PROGMEM |
|||
#define PB_PROGMEM_READU32(x) pgm_read_dword(&x) |
|||
#else |
|||
#define PB_PROGMEM |
|||
#define PB_PROGMEM_READU32(x) (x) |
|||
#endif |
|||
#endif |
|||
|
|||
/* Compile-time assertion, used for checking compatible compilation options.
|
|||
* If this does not work properly on your compiler, use |
|||
* #define PB_NO_STATIC_ASSERT to disable it. |
|||
* |
|||
* But before doing that, check carefully the error message / place where it |
|||
* comes from to see if the error has a real cause. Unfortunately the error |
|||
* message is not always very clear to read, but you can see the reason better |
|||
* in the place where the PB_STATIC_ASSERT macro was called. |
|||
*/ |
|||
#ifndef PB_NO_STATIC_ASSERT |
|||
# ifndef PB_STATIC_ASSERT |
|||
# if defined(__ICCARM__) |
|||
/* IAR has static_assert keyword but no _Static_assert */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG); |
|||
# elif defined(_MSC_VER) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112) |
|||
/* MSVC in C89 mode supports static_assert() keyword anyway */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG); |
|||
# elif defined(PB_C99_STATIC_ASSERT) |
|||
/* Classic negative-size-array static assert mechanism */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1]; |
|||
# define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) |
|||
# define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##_##LINE##_##COUNTER |
|||
# elif defined(__cplusplus) |
|||
/* C++11 standard static_assert mechanism */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG); |
|||
# else |
|||
/* C11 standard _Static_assert mechanism */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) _Static_assert(COND,#MSG); |
|||
# endif |
|||
# endif |
|||
#else |
|||
/* Static asserts disabled by PB_NO_STATIC_ASSERT */ |
|||
# define PB_STATIC_ASSERT(COND,MSG) |
|||
#endif |
|||
|
|||
/* Test that PB_STATIC_ASSERT works
|
|||
* If you get errors here, you may need to do one of these: |
|||
* - Enable C11 standard support in your compiler |
|||
* - Define PB_C99_STATIC_ASSERT to enable C99 standard support |
|||
* - Define PB_NO_STATIC_ASSERT to disable static asserts altogether |
|||
*/ |
|||
PB_STATIC_ASSERT(1, STATIC_ASSERT_IS_NOT_WORKING) |
|||
|
|||
/* Number of required fields to keep track of. */ |
|||
#ifndef PB_MAX_REQUIRED_FIELDS |
|||
#define PB_MAX_REQUIRED_FIELDS 64 |
|||
#endif |
|||
|
|||
#if PB_MAX_REQUIRED_FIELDS < 64 |
|||
#error You should not lower PB_MAX_REQUIRED_FIELDS from the default value (64). |
|||
#endif |
|||
|
|||
#ifdef PB_WITHOUT_64BIT |
|||
#ifdef PB_CONVERT_DOUBLE_FLOAT |
|||
/* Cannot use doubles without 64-bit types */ |
|||
#undef PB_CONVERT_DOUBLE_FLOAT |
|||
#endif |
|||
#endif |
|||
|
|||
/* List of possible field types. These are used in the autogenerated code.
|
|||
* Least-significant 4 bits tell the scalar type |
|||
* Most-significant 4 bits specify repeated/required/packed etc. |
|||
*/ |
|||
|
|||
typedef uint_least8_t pb_type_t; |
|||
|
|||
/**** Field data types ****/ |
|||
|
|||
/* Numeric types */ |
|||
#define PB_LTYPE_BOOL 0x00U /* bool */ |
|||
#define PB_LTYPE_VARINT 0x01U /* int32, int64, enum, bool */ |
|||
#define PB_LTYPE_UVARINT 0x02U /* uint32, uint64 */ |
|||
#define PB_LTYPE_SVARINT 0x03U /* sint32, sint64 */ |
|||
#define PB_LTYPE_FIXED32 0x04U /* fixed32, sfixed32, float */ |
|||
#define PB_LTYPE_FIXED64 0x05U /* fixed64, sfixed64, double */ |
|||
|
|||
/* Marker for last packable field type. */ |
|||
#define PB_LTYPE_LAST_PACKABLE 0x05U |
|||
|
|||
/* Byte array with pre-allocated buffer.
|
|||
* data_size is the length of the allocated PB_BYTES_ARRAY structure. */ |
|||
#define PB_LTYPE_BYTES 0x06U |
|||
|
|||
/* String with pre-allocated buffer.
|
|||
* data_size is the maximum length. */ |
|||
#define PB_LTYPE_STRING 0x07U |
|||
|
|||
/* Submessage
|
|||
* submsg_fields is pointer to field descriptions */ |
|||
#define PB_LTYPE_SUBMESSAGE 0x08U |
|||
|
|||
/* Submessage with pre-decoding callback
|
|||
* The pre-decoding callback is stored as pb_callback_t right before pSize. |
|||
* submsg_fields is pointer to field descriptions */ |
|||
#define PB_LTYPE_SUBMSG_W_CB 0x09U |
|||
|
|||
/* Extension pseudo-field
|
|||
* The field contains a pointer to pb_extension_t */ |
|||
#define PB_LTYPE_EXTENSION 0x0AU |
|||
|
|||
/* Byte array with inline, pre-allocated byffer.
|
|||
* data_size is the length of the inline, allocated buffer. |
|||
* This differs from PB_LTYPE_BYTES by defining the element as |
|||
* pb_byte_t[data_size] rather than pb_bytes_array_t. */ |
|||
#define PB_LTYPE_FIXED_LENGTH_BYTES 0x0BU |
|||
|
|||
/* Number of declared LTYPES */ |
|||
#define PB_LTYPES_COUNT 0x0CU |
|||
#define PB_LTYPE_MASK 0x0FU |
|||
|
|||
/**** Field repetition rules ****/ |
|||
|
|||
#define PB_HTYPE_REQUIRED 0x00U |
|||
#define PB_HTYPE_OPTIONAL 0x10U |
|||
#define PB_HTYPE_SINGULAR 0x10U |
|||
#define PB_HTYPE_REPEATED 0x20U |
|||
#define PB_HTYPE_FIXARRAY 0x20U |
|||
#define PB_HTYPE_ONEOF 0x30U |
|||
#define PB_HTYPE_MASK 0x30U |
|||
|
|||
/**** Field allocation types ****/ |
|||
|
|||
#define PB_ATYPE_STATIC 0x00U |
|||
#define PB_ATYPE_POINTER 0x80U |
|||
#define PB_ATYPE_CALLBACK 0x40U |
|||
#define PB_ATYPE_MASK 0xC0U |
|||
|
|||
#define PB_ATYPE(x) ((x) & PB_ATYPE_MASK) |
|||
#define PB_HTYPE(x) ((x) & PB_HTYPE_MASK) |
|||
#define PB_LTYPE(x) ((x) & PB_LTYPE_MASK) |
|||
#define PB_LTYPE_IS_SUBMSG(x) (PB_LTYPE(x) == PB_LTYPE_SUBMESSAGE || \ |
|||
PB_LTYPE(x) == PB_LTYPE_SUBMSG_W_CB) |
|||
|
|||
/* Data type used for storing sizes of struct fields
|
|||
* and array counts. |
|||
*/ |
|||
#if defined(PB_FIELD_32BIT) |
|||
typedef uint32_t pb_size_t; |
|||
typedef int32_t pb_ssize_t; |
|||
#else |
|||
typedef uint_least16_t pb_size_t; |
|||
typedef int_least16_t pb_ssize_t; |
|||
#endif |
|||
#define PB_SIZE_MAX ((pb_size_t)-1) |
|||
|
|||
/* Data type for storing encoded data and other byte streams.
|
|||
* This typedef exists to support platforms where uint8_t does not exist. |
|||
* You can regard it as equivalent on uint8_t on other platforms. |
|||
*/ |
|||
typedef uint_least8_t pb_byte_t; |
|||
|
|||
/* Forward declaration of struct types */ |
|||
typedef struct pb_istream_s pb_istream_t; |
|||
typedef struct pb_ostream_s pb_ostream_t; |
|||
typedef struct pb_field_iter_s pb_field_iter_t; |
|||
|
|||
/* This structure is used in auto-generated constants
|
|||
* to specify struct fields. |
|||
*/ |
|||
typedef struct pb_msgdesc_s pb_msgdesc_t; |
|||
struct pb_msgdesc_s { |
|||
const uint32_t *field_info; |
|||
const pb_msgdesc_t * const * submsg_info; |
|||
const pb_byte_t *default_value; |
|||
|
|||
bool (*field_callback)(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field); |
|||
|
|||
pb_size_t field_count; |
|||
pb_size_t required_field_count; |
|||
pb_size_t largest_tag; |
|||
}; |
|||
|
|||
/* Iterator for message descriptor */ |
|||
struct pb_field_iter_s { |
|||
const pb_msgdesc_t *descriptor; /* Pointer to message descriptor constant */ |
|||
void *message; /* Pointer to start of the structure */ |
|||
|
|||
pb_size_t index; /* Index of the field */ |
|||
pb_size_t field_info_index; /* Index to descriptor->field_info array */ |
|||
pb_size_t required_field_index; /* Index that counts only the required fields */ |
|||
pb_size_t submessage_index; /* Index that counts only submessages */ |
|||
|
|||
pb_size_t tag; /* Tag of current field */ |
|||
pb_size_t data_size; /* sizeof() of a single item */ |
|||
pb_size_t array_size; /* Number of array entries */ |
|||
pb_type_t type; /* Type of current field */ |
|||
|
|||
void *pField; /* Pointer to current field in struct */ |
|||
void *pData; /* Pointer to current data contents. Different than pField for arrays and pointers. */ |
|||
void *pSize; /* Pointer to count/has field */ |
|||
|
|||
const pb_msgdesc_t *submsg_desc; /* For submessage fields, pointer to field descriptor for the submessage. */ |
|||
}; |
|||
|
|||
/* For compatibility with legacy code */ |
|||
typedef pb_field_iter_t pb_field_t; |
|||
|
|||
/* Make sure that the standard integer types are of the expected sizes.
|
|||
* Otherwise fixed32/fixed64 fields can break. |
|||
* |
|||
* If you get errors here, it probably means that your stdint.h is not |
|||
* correct for your platform. |
|||
*/ |
|||
#ifndef PB_WITHOUT_64BIT |
|||
PB_STATIC_ASSERT(sizeof(int64_t) == 2 * sizeof(int32_t), INT64_T_WRONG_SIZE) |
|||
PB_STATIC_ASSERT(sizeof(uint64_t) == 2 * sizeof(uint32_t), UINT64_T_WRONG_SIZE) |
|||
#endif |
|||
|
|||
/* This structure is used for 'bytes' arrays.
|
|||
* It has the number of bytes in the beginning, and after that an array. |
|||
* Note that actual structs used will have a different length of bytes array. |
|||
*/ |
|||
#define PB_BYTES_ARRAY_T(n) struct { pb_size_t size; pb_byte_t bytes[n]; } |
|||
#define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes)) |
|||
|
|||
struct pb_bytes_array_s { |
|||
pb_size_t size; |
|||
pb_byte_t bytes[1]; |
|||
}; |
|||
typedef struct pb_bytes_array_s pb_bytes_array_t; |
|||
|
|||
/* This structure is used for giving the callback function.
|
|||
* It is stored in the message structure and filled in by the method that |
|||
* calls pb_decode. |
|||
* |
|||
* The decoding callback will be given a limited-length stream |
|||
* If the wire type was string, the length is the length of the string. |
|||
* If the wire type was a varint/fixed32/fixed64, the length is the length |
|||
* of the actual value. |
|||
* The function may be called multiple times (especially for repeated types, |
|||
* but also otherwise if the message happens to contain the field multiple |
|||
* times.) |
|||
* |
|||
* The encoding callback will receive the actual output stream. |
|||
* It should write all the data in one call, including the field tag and |
|||
* wire type. It can write multiple fields. |
|||
* |
|||
* The callback can be null if you want to skip a field. |
|||
*/ |
|||
typedef struct pb_callback_s pb_callback_t; |
|||
struct pb_callback_s { |
|||
/* Callback functions receive a pointer to the arg field.
|
|||
* You can access the value of the field as *arg, and modify it if needed. |
|||
*/ |
|||
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; |
|||
|
|||
/* Free arg for use by callback */ |
|||
void *arg; |
|||
}; |
|||
|
|||
extern bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field); |
|||
|
|||
/* Wire types. Library user needs these only in encoder callbacks. */ |
|||
typedef enum { |
|||
PB_WT_VARINT = 0, |
|||
PB_WT_64BIT = 1, |
|||
PB_WT_STRING = 2, |
|||
PB_WT_32BIT = 5, |
|||
PB_WT_PACKED = 255 /* PB_WT_PACKED is internal marker for packed arrays. */ |
|||
} pb_wire_type_t; |
|||
|
|||
/* Structure for defining the handling of unknown/extension fields.
|
|||
* Usually the pb_extension_type_t structure is automatically generated, |
|||
* while the pb_extension_t structure is created by the user. However, |
|||
* if you want to catch all unknown fields, you can also create a custom |
|||
* pb_extension_type_t with your own callback. |
|||
*/ |
|||
typedef struct pb_extension_type_s pb_extension_type_t; |
|||
typedef struct pb_extension_s pb_extension_t; |
|||
struct pb_extension_type_s { |
|||
/* Called for each unknown field in the message.
|
|||
* If you handle the field, read off all of its data and return true. |
|||
* If you do not handle the field, do not read anything and return true. |
|||
* If you run into an error, return false. |
|||
* Set to NULL for default handler. |
|||
*/ |
|||
bool (*decode)(pb_istream_t *stream, pb_extension_t *extension, |
|||
uint32_t tag, pb_wire_type_t wire_type); |
|||
|
|||
/* Called once after all regular fields have been encoded.
|
|||
* If you have something to write, do so and return true. |
|||
* If you do not have anything to write, just return true. |
|||
* If you run into an error, return false. |
|||
* Set to NULL for default handler. |
|||
*/ |
|||
bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension); |
|||
|
|||
/* Free field for use by the callback. */ |
|||
const void *arg; |
|||
}; |
|||
|
|||
struct pb_extension_s { |
|||
/* Type describing the extension field. Usually you'll initialize
|
|||
* this to a pointer to the automatically generated structure. */ |
|||
const pb_extension_type_t *type; |
|||
|
|||
/* Destination for the decoded data. This must match the datatype
|
|||
* of the extension field. */ |
|||
void *dest; |
|||
|
|||
/* Pointer to the next extension handler, or NULL.
|
|||
* If this extension does not match a field, the next handler is |
|||
* automatically called. */ |
|||
pb_extension_t *next; |
|||
|
|||
/* The decoder sets this to true if the extension was found.
|
|||
* Ignored for encoding. */ |
|||
bool found; |
|||
}; |
|||
|
|||
#define pb_extension_init_zero {NULL,NULL,NULL,false} |
|||
|
|||
/* Memory allocation functions to use. You can define pb_realloc and
|
|||
* pb_free to custom functions if you want. */ |
|||
#ifdef PB_ENABLE_MALLOC |
|||
# ifndef pb_realloc |
|||
# define pb_realloc(ptr, size) realloc(ptr, size) |
|||
# endif |
|||
# ifndef pb_free |
|||
# define pb_free(ptr) free(ptr) |
|||
# endif |
|||
#endif |
|||
|
|||
/* This is used to inform about need to regenerate .pb.h/.pb.c files. */ |
|||
#define PB_PROTO_HEADER_VERSION 40 |
|||
|
|||
/* These macros are used to declare pb_field_t's in the constant array. */ |
|||
/* Size of a structure member, in bytes. */ |
|||
#define pb_membersize(st, m) (sizeof ((st*)0)->m) |
|||
/* Number of entries in an array. */ |
|||
#define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0])) |
|||
/* Delta from start of one member to the start of another member. */ |
|||
#define pb_delta(st, m1, m2) ((int)offsetof(st, m1) - (int)offsetof(st, m2)) |
|||
|
|||
/* Force expansion of macro value */ |
|||
#define PB_EXPAND(x) x |
|||
|
|||
/* Binding of a message field set into a specific structure */ |
|||
#define PB_BIND(msgname, structname, width) \ |
|||
const uint32_t structname ## _field_info[] PB_PROGMEM = \ |
|||
{ \ |
|||
msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ ## width, structname) \ |
|||
0 \ |
|||
}; \ |
|||
const pb_msgdesc_t* const structname ## _submsg_info[] = \ |
|||
{ \ |
|||
msgname ## _FIELDLIST(PB_GEN_SUBMSG_INFO, structname) \ |
|||
NULL \ |
|||
}; \ |
|||
const pb_msgdesc_t structname ## _msg = \ |
|||
{ \ |
|||
structname ## _field_info, \ |
|||
structname ## _submsg_info, \ |
|||
msgname ## _DEFAULT, \ |
|||
msgname ## _CALLBACK, \ |
|||
0 msgname ## _FIELDLIST(PB_GEN_FIELD_COUNT, structname), \ |
|||
0 msgname ## _FIELDLIST(PB_GEN_REQ_FIELD_COUNT, structname), \ |
|||
0 msgname ## _FIELDLIST(PB_GEN_LARGEST_TAG, structname), \ |
|||
}; \ |
|||
msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ASSERT_ ## width, structname) |
|||
|
|||
#define PB_GEN_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) +1 |
|||
#define PB_GEN_REQ_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) \ |
|||
+ (PB_HTYPE_ ## htype == PB_HTYPE_REQUIRED) |
|||
#define PB_GEN_LARGEST_TAG(structname, atype, htype, ltype, fieldname, tag) \ |
|||
* 0 + tag |
|||
|
|||
/* X-macro for generating the entries in struct_field_info[] array. */ |
|||
#define PB_GEN_FIELD_INFO_1(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_2(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_4(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_8(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_AUTO(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \ |
|||
tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_FIELDINFO_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) |
|||
|
|||
#define PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_FIELDINFO_ ## width(tag, type, data_offset, data_size, size_offset, array_size) |
|||
|
|||
/* X-macro for generating asserts that entries fit in struct_field_info[] array.
|
|||
* The structure of macros here must match the structure above in PB_GEN_FIELD_INFO_x(), |
|||
* but it is not easily reused because of how macro substitutions work. */ |
|||
#define PB_GEN_FIELD_INFO_ASSERT_1(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_ASSERT_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_ASSERT_2(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_ASSERT_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_ASSERT_4(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_ASSERT_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_ASSERT_8(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_ASSERT_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_GEN_FIELD_INFO_ASSERT_AUTO(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_FIELDINFO_ASSERT_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \ |
|||
tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \ |
|||
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \ |
|||
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname)) |
|||
|
|||
#define PB_FIELDINFO_ASSERT_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) |
|||
|
|||
#define PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_FIELDINFO_ASSERT_ ## width(tag, type, data_offset, data_size, size_offset, array_size) |
|||
|
|||
#define PB_DATA_OFFSET_STATIC(htype, structname, fieldname) PB_DO ## htype(structname, fieldname) |
|||
#define PB_DATA_OFFSET_POINTER(htype, structname, fieldname) PB_DO ## htype(structname, fieldname) |
|||
#define PB_DATA_OFFSET_CALLBACK(htype, structname, fieldname) PB_DO ## htype(structname, fieldname) |
|||
#define PB_DO_PB_HTYPE_REQUIRED(structname, fieldname) offsetof(structname, fieldname) |
|||
#define PB_DO_PB_HTYPE_SINGULAR(structname, fieldname) offsetof(structname, fieldname) |
|||
#define PB_DO_PB_HTYPE_ONEOF(structname, fieldname) offsetof(structname, PB_ONEOF_NAME(FULL, fieldname)) |
|||
#define PB_DO_PB_HTYPE_OPTIONAL(structname, fieldname) offsetof(structname, fieldname) |
|||
#define PB_DO_PB_HTYPE_REPEATED(structname, fieldname) offsetof(structname, fieldname) |
|||
#define PB_DO_PB_HTYPE_FIXARRAY(structname, fieldname) offsetof(structname, fieldname) |
|||
|
|||
#define PB_SIZE_OFFSET_STATIC(htype, structname, fieldname) PB_SO ## htype(structname, fieldname) |
|||
#define PB_SIZE_OFFSET_POINTER(htype, structname, fieldname) PB_SO_PTR ## htype(structname, fieldname) |
|||
#define PB_SIZE_OFFSET_CALLBACK(htype, structname, fieldname) PB_SO_CB ## htype(structname, fieldname) |
|||
#define PB_SO_PB_HTYPE_REQUIRED(structname, fieldname) 0 |
|||
#define PB_SO_PB_HTYPE_SINGULAR(structname, fieldname) 0 |
|||
#define PB_SO_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF2(structname, PB_ONEOF_NAME(FULL, fieldname), PB_ONEOF_NAME(UNION, fieldname)) |
|||
#define PB_SO_PB_HTYPE_ONEOF2(structname, fullname, unionname) PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname) |
|||
#define PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname) pb_delta(structname, fullname, which_ ## unionname) |
|||
#define PB_SO_PB_HTYPE_OPTIONAL(structname, fieldname) pb_delta(structname, fieldname, has_ ## fieldname) |
|||
#define PB_SO_PB_HTYPE_REPEATED(structname, fieldname) pb_delta(structname, fieldname, fieldname ## _count) |
|||
#define PB_SO_PB_HTYPE_FIXARRAY(structname, fieldname) 0 |
|||
#define PB_SO_PTR_PB_HTYPE_REQUIRED(structname, fieldname) 0 |
|||
#define PB_SO_PTR_PB_HTYPE_SINGULAR(structname, fieldname) 0 |
|||
#define PB_SO_PTR_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF(structname, fieldname) |
|||
#define PB_SO_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) 0 |
|||
#define PB_SO_PTR_PB_HTYPE_REPEATED(structname, fieldname) PB_SO_PB_HTYPE_REPEATED(structname, fieldname) |
|||
#define PB_SO_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) 0 |
|||
#define PB_SO_CB_PB_HTYPE_REQUIRED(structname, fieldname) 0 |
|||
#define PB_SO_CB_PB_HTYPE_SINGULAR(structname, fieldname) 0 |
|||
#define PB_SO_CB_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF(structname, fieldname) |
|||
#define PB_SO_CB_PB_HTYPE_OPTIONAL(structname, fieldname) 0 |
|||
#define PB_SO_CB_PB_HTYPE_REPEATED(structname, fieldname) 0 |
|||
#define PB_SO_CB_PB_HTYPE_FIXARRAY(structname, fieldname) 0 |
|||
|
|||
#define PB_ARRAY_SIZE_STATIC(htype, structname, fieldname) PB_AS ## htype(structname, fieldname) |
|||
#define PB_ARRAY_SIZE_POINTER(htype, structname, fieldname) PB_AS_PTR ## htype(structname, fieldname) |
|||
#define PB_ARRAY_SIZE_CALLBACK(htype, structname, fieldname) 1 |
|||
#define PB_AS_PB_HTYPE_REQUIRED(structname, fieldname) 1 |
|||
#define PB_AS_PB_HTYPE_SINGULAR(structname, fieldname) 1 |
|||
#define PB_AS_PB_HTYPE_OPTIONAL(structname, fieldname) 1 |
|||
#define PB_AS_PB_HTYPE_ONEOF(structname, fieldname) 1 |
|||
#define PB_AS_PB_HTYPE_REPEATED(structname, fieldname) pb_arraysize(structname, fieldname) |
|||
#define PB_AS_PB_HTYPE_FIXARRAY(structname, fieldname) pb_arraysize(structname, fieldname) |
|||
#define PB_AS_PTR_PB_HTYPE_REQUIRED(structname, fieldname) 1 |
|||
#define PB_AS_PTR_PB_HTYPE_SINGULAR(structname, fieldname) 1 |
|||
#define PB_AS_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) 1 |
|||
#define PB_AS_PTR_PB_HTYPE_ONEOF(structname, fieldname) 1 |
|||
#define PB_AS_PTR_PB_HTYPE_REPEATED(structname, fieldname) 1 |
|||
#define PB_AS_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) pb_arraysize(structname, fieldname[0]) |
|||
|
|||
#define PB_DATA_SIZE_STATIC(htype, structname, fieldname) PB_DS ## htype(structname, fieldname) |
|||
#define PB_DATA_SIZE_POINTER(htype, structname, fieldname) PB_DS_PTR ## htype(structname, fieldname) |
|||
#define PB_DATA_SIZE_CALLBACK(htype, structname, fieldname) PB_DS_CB ## htype(structname, fieldname) |
|||
#define PB_DS_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname)) |
|||
#define PB_DS_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname)[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname[0]) |
|||
#define PB_DS_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname[0][0]) |
|||
#define PB_DS_CB_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_CB_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_CB_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_CB_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname)) |
|||
#define PB_DS_CB_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname) |
|||
#define PB_DS_CB_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname) |
|||
|
|||
#define PB_ONEOF_NAME(type, tuple) PB_EXPAND(PB_ONEOF_NAME_ ## type tuple) |
|||
#define PB_ONEOF_NAME_UNION(unionname,membername,fullname) unionname |
|||
#define PB_ONEOF_NAME_MEMBER(unionname,membername,fullname) membername |
|||
#define PB_ONEOF_NAME_FULL(unionname,membername,fullname) fullname |
|||
|
|||
#define PB_GEN_SUBMSG_INFO(structname, atype, htype, ltype, fieldname, tag) \ |
|||
PB_SUBMSG_INFO_ ## htype(_PB_LTYPE_ ## ltype, structname, fieldname) |
|||
|
|||
#define PB_SUBMSG_INFO_REQUIRED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE) |
|||
#define PB_SUBMSG_INFO_SINGULAR(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE) |
|||
#define PB_SUBMSG_INFO_OPTIONAL(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE) |
|||
#define PB_SUBMSG_INFO_ONEOF(ltype, structname, fieldname) PB_SUBMSG_INFO_ONEOF2(ltype, structname, PB_ONEOF_NAME(UNION, fieldname), PB_ONEOF_NAME(MEMBER, fieldname)) |
|||
#define PB_SUBMSG_INFO_ONEOF2(ltype, structname, unionname, membername) PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername) |
|||
#define PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername) PB_SI ## ltype(structname ## _ ## unionname ## _ ## membername ## _MSGTYPE) |
|||
#define PB_SUBMSG_INFO_REPEATED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE) |
|||
#define PB_SUBMSG_INFO_FIXARRAY(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE) |
|||
#define PB_SI_PB_LTYPE_BOOL(t) |
|||
#define PB_SI_PB_LTYPE_BYTES(t) |
|||
#define PB_SI_PB_LTYPE_DOUBLE(t) |
|||
#define PB_SI_PB_LTYPE_ENUM(t) |
|||
#define PB_SI_PB_LTYPE_UENUM(t) |
|||
#define PB_SI_PB_LTYPE_FIXED32(t) |
|||
#define PB_SI_PB_LTYPE_FIXED64(t) |
|||
#define PB_SI_PB_LTYPE_FLOAT(t) |
|||
#define PB_SI_PB_LTYPE_INT32(t) |
|||
#define PB_SI_PB_LTYPE_INT64(t) |
|||
#define PB_SI_PB_LTYPE_MESSAGE(t) PB_SUBMSG_DESCRIPTOR(t) |
|||
#define PB_SI_PB_LTYPE_MSG_W_CB(t) PB_SUBMSG_DESCRIPTOR(t) |
|||
#define PB_SI_PB_LTYPE_SFIXED32(t) |
|||
#define PB_SI_PB_LTYPE_SFIXED64(t) |
|||
#define PB_SI_PB_LTYPE_SINT32(t) |
|||
#define PB_SI_PB_LTYPE_SINT64(t) |
|||
#define PB_SI_PB_LTYPE_STRING(t) |
|||
#define PB_SI_PB_LTYPE_UINT32(t) |
|||
#define PB_SI_PB_LTYPE_UINT64(t) |
|||
#define PB_SI_PB_LTYPE_EXTENSION(t) |
|||
#define PB_SI_PB_LTYPE_FIXED_LENGTH_BYTES(t) |
|||
#define PB_SUBMSG_DESCRIPTOR(t) &(t ## _msg), |
|||
|
|||
/* The field descriptors use a variable width format, with width of either
|
|||
* 1, 2, 4 or 8 of 32-bit words. The two lowest bytes of the first byte always |
|||
* encode the descriptor size, 6 lowest bits of field tag number, and 8 bits |
|||
* of the field type. |
|||
* |
|||
* Descriptor size is encoded as 0 = 1 word, 1 = 2 words, 2 = 4 words, 3 = 8 words. |
|||
* |
|||
* Formats, listed starting with the least significant bit of the first word. |
|||
* 1 word: [2-bit len] [6-bit tag] [8-bit type] [8-bit data_offset] [4-bit size_offset] [4-bit data_size] |
|||
* |
|||
* 2 words: [2-bit len] [6-bit tag] [8-bit type] [12-bit array_size] [4-bit size_offset] |
|||
* [16-bit data_offset] [12-bit data_size] [4-bit tag>>6] |
|||
* |
|||
* 4 words: [2-bit len] [6-bit tag] [8-bit type] [16-bit array_size] |
|||
* [8-bit size_offset] [24-bit tag>>6] |
|||
* [32-bit data_offset] |
|||
* [32-bit data_size] |
|||
* |
|||
* 8 words: [2-bit len] [6-bit tag] [8-bit type] [16-bit reserved] |
|||
* [8-bit size_offset] [24-bit tag>>6] |
|||
* [32-bit data_offset] |
|||
* [32-bit data_size] |
|||
* [32-bit array_size] |
|||
* [32-bit reserved] |
|||
* [32-bit reserved] |
|||
* [32-bit reserved] |
|||
*/ |
|||
|
|||
#define PB_FIELDINFO_1(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
(0 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(data_offset) & 0xFF) << 16) | \ |
|||
(((uint32_t)(size_offset) & 0x0F) << 24) | (((uint32_t)(data_size) & 0x0F) << 28)), |
|||
|
|||
#define PB_FIELDINFO_2(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
(1 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFF) << 16) | (((uint32_t)(size_offset) & 0x0F) << 28)), \ |
|||
(((uint32_t)(data_offset) & 0xFFFF) | (((uint32_t)(data_size) & 0xFFF) << 16) | (((uint32_t)(tag) & 0x3c0) << 22)), |
|||
|
|||
#define PB_FIELDINFO_4(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
(2 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFFF) << 16)), \ |
|||
((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \ |
|||
(data_offset), (data_size), |
|||
|
|||
#define PB_FIELDINFO_8(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
(3 | (((tag) << 2) & 0xFF) | ((type) << 8)), \ |
|||
((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \ |
|||
(data_offset), (data_size), (array_size), 0, 0, 0, |
|||
|
|||
/* These assertions verify that the field information fits in the allocated space.
|
|||
* The generator tries to automatically determine the correct width that can fit all |
|||
* data associated with a message. These asserts will fail only if there has been a |
|||
* problem in the automatic logic - this may be worth reporting as a bug. As a workaround, |
|||
* you can increase the descriptor width by defining PB_FIELDINFO_WIDTH or by setting |
|||
* descriptorsize option in .options file. |
|||
*/ |
|||
#define PB_FITS(value,bits) ((uint32_t)(value) < ((uint32_t)1<<bits)) |
|||
#define PB_FIELDINFO_ASSERT_1(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,6) && PB_FITS(data_offset,8) && PB_FITS(size_offset,4) && PB_FITS(data_size,4) && PB_FITS(array_size,1), FIELDINFO_DOES_NOT_FIT_width1_field ## tag) |
|||
|
|||
#define PB_FIELDINFO_ASSERT_2(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,10) && PB_FITS(data_offset,16) && PB_FITS(size_offset,4) && PB_FITS(data_size,12) && PB_FITS(array_size,12), FIELDINFO_DOES_NOT_FIT_width2_field ## tag) |
|||
|
|||
#ifndef PB_FIELD_32BIT |
|||
/* Maximum field sizes are still 16-bit if pb_size_t is 16-bit */ |
|||
#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag) |
|||
|
|||
#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width8_field ## tag) |
|||
#else |
|||
/* Up to 32-bit fields supported.
|
|||
* Note that the checks are against 31 bits to avoid compiler warnings about shift wider than type in the test. |
|||
* I expect that there is no reasonable use for >2GB messages with nanopb anyway. |
|||
*/ |
|||
#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag) |
|||
|
|||
#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \ |
|||
PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,31), FIELDINFO_DOES_NOT_FIT_width8_field ## tag) |
|||
#endif |
|||
|
|||
|
|||
/* Automatic picking of FIELDINFO width:
|
|||
* Uses width 1 when possible, otherwise resorts to width 2. |
|||
* This is used when PB_BIND() is called with "AUTO" as the argument. |
|||
* The generator will give explicit size argument when it knows that a message |
|||
* structure grows beyond 1-word format limits. |
|||
*/ |
|||
#define PB_FIELDINFO_WIDTH_AUTO(atype, htype, ltype) PB_FI_WIDTH ## atype(htype, ltype) |
|||
#define PB_FI_WIDTH_PB_ATYPE_STATIC(htype, ltype) PB_FI_WIDTH ## htype(ltype) |
|||
#define PB_FI_WIDTH_PB_ATYPE_POINTER(htype, ltype) PB_FI_WIDTH ## htype(ltype) |
|||
#define PB_FI_WIDTH_PB_ATYPE_CALLBACK(htype, ltype) 2 |
|||
#define PB_FI_WIDTH_PB_HTYPE_REQUIRED(ltype) PB_FI_WIDTH ## ltype |
|||
#define PB_FI_WIDTH_PB_HTYPE_SINGULAR(ltype) PB_FI_WIDTH ## ltype |
|||
#define PB_FI_WIDTH_PB_HTYPE_OPTIONAL(ltype) PB_FI_WIDTH ## ltype |
|||
#define PB_FI_WIDTH_PB_HTYPE_ONEOF(ltype) PB_FI_WIDTH ## ltype |
|||
#define PB_FI_WIDTH_PB_HTYPE_REPEATED(ltype) 2 |
|||
#define PB_FI_WIDTH_PB_HTYPE_FIXARRAY(ltype) 2 |
|||
#define PB_FI_WIDTH_PB_LTYPE_BOOL 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_BYTES 2 |
|||
#define PB_FI_WIDTH_PB_LTYPE_DOUBLE 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_ENUM 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_UENUM 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_FIXED32 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_FIXED64 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_FLOAT 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_INT32 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_INT64 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_MESSAGE 2 |
|||
#define PB_FI_WIDTH_PB_LTYPE_MSG_W_CB 2 |
|||
#define PB_FI_WIDTH_PB_LTYPE_SFIXED32 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_SFIXED64 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_SINT32 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_SINT64 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_STRING 2 |
|||
#define PB_FI_WIDTH_PB_LTYPE_UINT32 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_UINT64 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_EXTENSION 1 |
|||
#define PB_FI_WIDTH_PB_LTYPE_FIXED_LENGTH_BYTES 2 |
|||
|
|||
/* The mapping from protobuf types to LTYPEs is done using these macros. */ |
|||
#define PB_LTYPE_MAP_BOOL PB_LTYPE_BOOL |
|||
#define PB_LTYPE_MAP_BYTES PB_LTYPE_BYTES |
|||
#define PB_LTYPE_MAP_DOUBLE PB_LTYPE_FIXED64 |
|||
#define PB_LTYPE_MAP_ENUM PB_LTYPE_VARINT |
|||
#define PB_LTYPE_MAP_UENUM PB_LTYPE_UVARINT |
|||
#define PB_LTYPE_MAP_FIXED32 PB_LTYPE_FIXED32 |
|||
#define PB_LTYPE_MAP_FIXED64 PB_LTYPE_FIXED64 |
|||
#define PB_LTYPE_MAP_FLOAT PB_LTYPE_FIXED32 |
|||
#define PB_LTYPE_MAP_INT32 PB_LTYPE_VARINT |
|||
#define PB_LTYPE_MAP_INT64 PB_LTYPE_VARINT |
|||
#define PB_LTYPE_MAP_MESSAGE PB_LTYPE_SUBMESSAGE |
|||
#define PB_LTYPE_MAP_MSG_W_CB PB_LTYPE_SUBMSG_W_CB |
|||
#define PB_LTYPE_MAP_SFIXED32 PB_LTYPE_FIXED32 |
|||
#define PB_LTYPE_MAP_SFIXED64 PB_LTYPE_FIXED64 |
|||
#define PB_LTYPE_MAP_SINT32 PB_LTYPE_SVARINT |
|||
#define PB_LTYPE_MAP_SINT64 PB_LTYPE_SVARINT |
|||
#define PB_LTYPE_MAP_STRING PB_LTYPE_STRING |
|||
#define PB_LTYPE_MAP_UINT32 PB_LTYPE_UVARINT |
|||
#define PB_LTYPE_MAP_UINT64 PB_LTYPE_UVARINT |
|||
#define PB_LTYPE_MAP_EXTENSION PB_LTYPE_EXTENSION |
|||
#define PB_LTYPE_MAP_FIXED_LENGTH_BYTES PB_LTYPE_FIXED_LENGTH_BYTES |
|||
|
|||
/* These macros are used for giving out error messages.
|
|||
* They are mostly a debugging aid; the main error information |
|||
* is the true/false return value from functions. |
|||
* Some code space can be saved by disabling the error |
|||
* messages if not used. |
|||
* |
|||
* PB_SET_ERROR() sets the error message if none has been set yet. |
|||
* msg must be a constant string literal. |
|||
* PB_GET_ERROR() always returns a pointer to a string. |
|||
* PB_RETURN_ERROR() sets the error and returns false from current |
|||
* function. |
|||
*/ |
|||
#ifdef PB_NO_ERRMSG |
|||
#define PB_SET_ERROR(stream, msg) PB_UNUSED(stream) |
|||
#define PB_GET_ERROR(stream) "(errmsg disabled)" |
|||
#else |
|||
#define PB_SET_ERROR(stream, msg) (stream->errmsg = (stream)->errmsg ? (stream)->errmsg : (msg)) |
|||
#define PB_GET_ERROR(stream) ((stream)->errmsg ? (stream)->errmsg : "(none)") |
|||
#endif |
|||
|
|||
#define PB_RETURN_ERROR(stream, msg) return PB_SET_ERROR(stream, msg), false |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
#if __cplusplus >= 201103L |
|||
#define PB_CONSTEXPR constexpr |
|||
#else // __cplusplus >= 201103L
|
|||
#define PB_CONSTEXPR |
|||
#endif // __cplusplus >= 201103L
|
|||
|
|||
#if __cplusplus >= 201703L |
|||
#define PB_INLINE_CONSTEXPR inline constexpr |
|||
#else // __cplusplus >= 201703L
|
|||
#define PB_INLINE_CONSTEXPR PB_CONSTEXPR |
|||
#endif // __cplusplus >= 201703L
|
|||
|
|||
extern "C++" |
|||
{ |
|||
namespace nanopb { |
|||
// Each type will be partially specialized by the generator.
|
|||
template <typename GenMessageT> struct MessageDescriptor; |
|||
} // namespace nanopb
|
|||
} |
|||
#endif /* __cplusplus */ |
|||
|
|||
#endif |
|||
@ -0,0 +1,49 @@ |
|||
/* pb_common.h: Common support functions for pb_encode.c and pb_decode.c.
|
|||
* These functions are rarely needed by applications directly. |
|||
*/ |
|||
|
|||
#ifndef PB_COMMON_H_INCLUDED |
|||
#define PB_COMMON_H_INCLUDED |
|||
|
|||
#include "pb.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initialize the field iterator structure to beginning.
|
|||
* Returns false if the message type is empty. */ |
|||
bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_msgdesc_t *desc, void *message); |
|||
|
|||
/* Get a field iterator for extension field. */ |
|||
bool pb_field_iter_begin_extension(pb_field_iter_t *iter, pb_extension_t *extension); |
|||
|
|||
/* Same as pb_field_iter_begin(), but for const message pointer.
|
|||
* Note that the pointers in pb_field_iter_t will be non-const but shouldn't |
|||
* be written to when using these functions. */ |
|||
bool pb_field_iter_begin_const(pb_field_iter_t *iter, const pb_msgdesc_t *desc, const void *message); |
|||
bool pb_field_iter_begin_extension_const(pb_field_iter_t *iter, const pb_extension_t *extension); |
|||
|
|||
/* Advance the iterator to the next field.
|
|||
* Returns false when the iterator wraps back to the first field. */ |
|||
bool pb_field_iter_next(pb_field_iter_t *iter); |
|||
|
|||
/* Advance the iterator until it points at a field with the given tag.
|
|||
* Returns false if no such field exists. */ |
|||
bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag); |
|||
|
|||
/* Find a field with type PB_LTYPE_EXTENSION, or return false if not found.
|
|||
* There can be only one extension range field per message. */ |
|||
bool pb_field_iter_find_extension(pb_field_iter_t *iter); |
|||
|
|||
#ifdef PB_VALIDATE_UTF8 |
|||
/* Validate UTF-8 text string */ |
|||
bool pb_validate_utf8(const char *s); |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
|
|||
@ -0,0 +1,193 @@ |
|||
/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
|
|||
* The main function is pb_decode. You also need an input stream, and the |
|||
* field descriptions created by nanopb_generator.py. |
|||
*/ |
|||
|
|||
#ifndef PB_DECODE_H_INCLUDED |
|||
#define PB_DECODE_H_INCLUDED |
|||
|
|||
#include "pb.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Structure for defining custom input streams. You will need to provide
|
|||
* a callback function to read the bytes from your storage, which can be |
|||
* for example a file or a network socket. |
|||
* |
|||
* The callback must conform to these rules: |
|||
* |
|||
* 1) Return false on IO errors. This will cause decoding to abort. |
|||
* 2) You can use state to store your own data (e.g. buffer pointer), |
|||
* and rely on pb_read to verify that no-body reads past bytes_left. |
|||
* 3) Your callback may be used with substreams, in which case bytes_left |
|||
* is different than from the main stream. Don't use bytes_left to compute |
|||
* any pointers. |
|||
*/ |
|||
struct pb_istream_s |
|||
{ |
|||
#ifdef PB_BUFFER_ONLY |
|||
/* Callback pointer is not used in buffer-only configuration.
|
|||
* Having an int pointer here allows binary compatibility but |
|||
* gives an error if someone tries to assign callback function. |
|||
*/ |
|||
int *callback; |
|||
#else |
|||
bool (*callback)(pb_istream_t *stream, pb_byte_t *buf, size_t count); |
|||
#endif |
|||
|
|||
void *state; /* Free field for use by callback implementation */ |
|||
size_t bytes_left; |
|||
|
|||
#ifndef PB_NO_ERRMSG |
|||
const char *errmsg; |
|||
#endif |
|||
}; |
|||
|
|||
#ifndef PB_NO_ERRMSG |
|||
#define PB_ISTREAM_EMPTY {0,0,0,0} |
|||
#else |
|||
#define PB_ISTREAM_EMPTY {0,0,0} |
|||
#endif |
|||
|
|||
/***************************
|
|||
* Main decoding functions * |
|||
***************************/ |
|||
|
|||
/* Decode a single protocol buffers message from input stream into a C structure.
|
|||
* Returns true on success, false on any failure. |
|||
* The actual struct pointed to by dest must match the description in fields. |
|||
* Callback fields of the destination structure must be initialized by caller. |
|||
* All other fields will be initialized by this function. |
|||
* |
|||
* Example usage: |
|||
* MyMessage msg = {}; |
|||
* uint8_t buffer[64]; |
|||
* pb_istream_t stream; |
|||
* |
|||
* // ... read some data into buffer ...
|
|||
* |
|||
* stream = pb_istream_from_buffer(buffer, count); |
|||
* pb_decode(&stream, MyMessage_fields, &msg); |
|||
*/ |
|||
bool pb_decode(pb_istream_t *stream, const pb_msgdesc_t *fields, void *dest_struct); |
|||
|
|||
/* Extended version of pb_decode, with several options to control
|
|||
* the decoding process: |
|||
* |
|||
* PB_DECODE_NOINIT: Do not initialize the fields to default values. |
|||
* This is slightly faster if you do not need the default |
|||
* values and instead initialize the structure to 0 using |
|||
* e.g. memset(). This can also be used for merging two |
|||
* messages, i.e. combine already existing data with new |
|||
* values. |
|||
* |
|||
* PB_DECODE_DELIMITED: Input message starts with the message size as varint. |
|||
* Corresponds to parseDelimitedFrom() in Google's |
|||
* protobuf API. |
|||
* |
|||
* PB_DECODE_NULLTERMINATED: Stop reading when field tag is read as 0. This allows |
|||
* reading null terminated messages. |
|||
* NOTE: Until nanopb-0.4.0, pb_decode() also allows |
|||
* null-termination. This behaviour is not supported in |
|||
* most other protobuf implementations, so PB_DECODE_DELIMITED |
|||
* is a better option for compatibility. |
|||
* |
|||
* Multiple flags can be combined with bitwise or (| operator) |
|||
*/ |
|||
#define PB_DECODE_NOINIT 0x01U |
|||
#define PB_DECODE_DELIMITED 0x02U |
|||
#define PB_DECODE_NULLTERMINATED 0x04U |
|||
bool pb_decode_ex(pb_istream_t *stream, const pb_msgdesc_t *fields, void *dest_struct, unsigned int flags); |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define pb_decode_noinit(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_NOINIT) |
|||
#define pb_decode_delimited(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_DELIMITED) |
|||
#define pb_decode_delimited_noinit(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_DELIMITED | PB_DECODE_NOINIT) |
|||
#define pb_decode_nullterminated(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_NULLTERMINATED) |
|||
|
|||
/* Release any allocated pointer fields. If you use dynamic allocation, you should
|
|||
* call this for any successfully decoded message when you are done with it. If |
|||
* pb_decode() returns with an error, the message is already released. |
|||
*/ |
|||
void pb_release(const pb_msgdesc_t *fields, void *dest_struct); |
|||
|
|||
/**************************************
|
|||
* Functions for manipulating streams * |
|||
**************************************/ |
|||
|
|||
/* Create an input stream for reading from a memory buffer.
|
|||
* |
|||
* msglen should be the actual length of the message, not the full size of |
|||
* allocated buffer. |
|||
* |
|||
* Alternatively, you can use a custom stream that reads directly from e.g. |
|||
* a file or a network socket. |
|||
*/ |
|||
pb_istream_t pb_istream_from_buffer(const pb_byte_t *buf, size_t msglen); |
|||
|
|||
/* Function to read from a pb_istream_t. You can use this if you need to
|
|||
* read some custom header data, or to read data in field callbacks. |
|||
*/ |
|||
bool pb_read(pb_istream_t *stream, pb_byte_t *buf, size_t count); |
|||
|
|||
|
|||
/************************************************
|
|||
* Helper functions for writing field callbacks * |
|||
************************************************/ |
|||
|
|||
/* Decode the tag for the next field in the stream. Gives the wire type and
|
|||
* field tag. At end of the message, returns false and sets eof to true. */ |
|||
bool pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof); |
|||
|
|||
/* Skip the field payload data, given the wire type. */ |
|||
bool pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type); |
|||
|
|||
/* Decode an integer in the varint format. This works for enum, int32,
|
|||
* int64, uint32 and uint64 field types. */ |
|||
#ifndef PB_WITHOUT_64BIT |
|||
bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest); |
|||
#else |
|||
#define pb_decode_varint pb_decode_varint32 |
|||
#endif |
|||
|
|||
/* Decode an integer in the varint format. This works for enum, int32,
|
|||
* and uint32 field types. */ |
|||
bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest); |
|||
|
|||
/* Decode a bool value in varint format. */ |
|||
bool pb_decode_bool(pb_istream_t *stream, bool *dest); |
|||
|
|||
/* Decode an integer in the zig-zagged svarint format. This works for sint32
|
|||
* and sint64. */ |
|||
#ifndef PB_WITHOUT_64BIT |
|||
bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest); |
|||
#else |
|||
bool pb_decode_svarint(pb_istream_t *stream, int32_t *dest); |
|||
#endif |
|||
|
|||
/* Decode a fixed32, sfixed32 or float value. You need to pass a pointer to
|
|||
* a 4-byte wide C variable. */ |
|||
bool pb_decode_fixed32(pb_istream_t *stream, void *dest); |
|||
|
|||
#ifndef PB_WITHOUT_64BIT |
|||
/* Decode a fixed64, sfixed64 or double value. You need to pass a pointer to
|
|||
* a 8-byte wide C variable. */ |
|||
bool pb_decode_fixed64(pb_istream_t *stream, void *dest); |
|||
#endif |
|||
|
|||
#ifdef PB_CONVERT_DOUBLE_FLOAT |
|||
/* Decode a double value into float variable. */ |
|||
bool pb_decode_double_as_float(pb_istream_t *stream, float *dest); |
|||
#endif |
|||
|
|||
/* Make a limited-length substream for reading a PB_WT_STRING field. */ |
|||
bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream); |
|||
bool pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream); |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,185 @@ |
|||
/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
|
|||
* The main function is pb_encode. You also need an output stream, and the |
|||
* field descriptions created by nanopb_generator.py. |
|||
*/ |
|||
|
|||
#ifndef PB_ENCODE_H_INCLUDED |
|||
#define PB_ENCODE_H_INCLUDED |
|||
|
|||
#include "pb.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Structure for defining custom output streams. You will need to provide
|
|||
* a callback function to write the bytes to your storage, which can be |
|||
* for example a file or a network socket. |
|||
* |
|||
* The callback must conform to these rules: |
|||
* |
|||
* 1) Return false on IO errors. This will cause encoding to abort. |
|||
* 2) You can use state to store your own data (e.g. buffer pointer). |
|||
* 3) pb_write will update bytes_written after your callback runs. |
|||
* 4) Substreams will modify max_size and bytes_written. Don't use them |
|||
* to calculate any pointers. |
|||
*/ |
|||
struct pb_ostream_s |
|||
{ |
|||
#ifdef PB_BUFFER_ONLY |
|||
/* Callback pointer is not used in buffer-only configuration.
|
|||
* Having an int pointer here allows binary compatibility but |
|||
* gives an error if someone tries to assign callback function. |
|||
* Also, NULL pointer marks a 'sizing stream' that does not |
|||
* write anything. |
|||
*/ |
|||
const int *callback; |
|||
#else |
|||
bool (*callback)(pb_ostream_t *stream, const pb_byte_t *buf, size_t count); |
|||
#endif |
|||
void *state; /* Free field for use by callback implementation. */ |
|||
size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */ |
|||
size_t bytes_written; /* Number of bytes written so far. */ |
|||
|
|||
#ifndef PB_NO_ERRMSG |
|||
const char *errmsg; |
|||
#endif |
|||
}; |
|||
|
|||
/***************************
|
|||
* Main encoding functions * |
|||
***************************/ |
|||
|
|||
/* Encode a single protocol buffers message from C structure into a stream.
|
|||
* Returns true on success, false on any failure. |
|||
* The actual struct pointed to by src_struct must match the description in fields. |
|||
* All required fields in the struct are assumed to have been filled in. |
|||
* |
|||
* Example usage: |
|||
* MyMessage msg = {}; |
|||
* uint8_t buffer[64]; |
|||
* pb_ostream_t stream; |
|||
* |
|||
* msg.field1 = 42; |
|||
* stream = pb_ostream_from_buffer(buffer, sizeof(buffer)); |
|||
* pb_encode(&stream, MyMessage_fields, &msg); |
|||
*/ |
|||
bool pb_encode(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct); |
|||
|
|||
/* Extended version of pb_encode, with several options to control the
|
|||
* encoding process: |
|||
* |
|||
* PB_ENCODE_DELIMITED: Prepend the length of message as a varint. |
|||
* Corresponds to writeDelimitedTo() in Google's |
|||
* protobuf API. |
|||
* |
|||
* PB_ENCODE_NULLTERMINATED: Append a null byte to the message for termination. |
|||
* NOTE: This behaviour is not supported in most other |
|||
* protobuf implementations, so PB_ENCODE_DELIMITED |
|||
* is a better option for compatibility. |
|||
*/ |
|||
#define PB_ENCODE_DELIMITED 0x02U |
|||
#define PB_ENCODE_NULLTERMINATED 0x04U |
|||
bool pb_encode_ex(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct, unsigned int flags); |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define pb_encode_delimited(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_DELIMITED) |
|||
#define pb_encode_nullterminated(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_NULLTERMINATED) |
|||
|
|||
/* Encode the message to get the size of the encoded data, but do not store
|
|||
* the data. */ |
|||
bool pb_get_encoded_size(size_t *size, const pb_msgdesc_t *fields, const void *src_struct); |
|||
|
|||
/**************************************
|
|||
* Functions for manipulating streams * |
|||
**************************************/ |
|||
|
|||
/* Create an output stream for writing into a memory buffer.
|
|||
* The number of bytes written can be found in stream.bytes_written after |
|||
* encoding the message. |
|||
* |
|||
* Alternatively, you can use a custom stream that writes directly to e.g. |
|||
* a file or a network socket. |
|||
*/ |
|||
pb_ostream_t pb_ostream_from_buffer(pb_byte_t *buf, size_t bufsize); |
|||
|
|||
/* Pseudo-stream for measuring the size of a message without actually storing
|
|||
* the encoded data. |
|||
* |
|||
* Example usage: |
|||
* MyMessage msg = {}; |
|||
* pb_ostream_t stream = PB_OSTREAM_SIZING; |
|||
* pb_encode(&stream, MyMessage_fields, &msg); |
|||
* printf("Message size is %d\n", stream.bytes_written); |
|||
*/ |
|||
#ifndef PB_NO_ERRMSG |
|||
#define PB_OSTREAM_SIZING {0,0,0,0,0} |
|||
#else |
|||
#define PB_OSTREAM_SIZING {0,0,0,0} |
|||
#endif |
|||
|
|||
/* Function to write into a pb_ostream_t stream. You can use this if you need
|
|||
* to append or prepend some custom headers to the message. |
|||
*/ |
|||
bool pb_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count); |
|||
|
|||
|
|||
/************************************************
|
|||
* Helper functions for writing field callbacks * |
|||
************************************************/ |
|||
|
|||
/* Encode field header based on type and field number defined in the field
|
|||
* structure. Call this from the callback before writing out field contents. */ |
|||
bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_iter_t *field); |
|||
|
|||
/* Encode field header by manually specifying wire type. You need to use this
|
|||
* if you want to write out packed arrays from a callback field. */ |
|||
bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number); |
|||
|
|||
/* Encode an integer in the varint format.
|
|||
* This works for bool, enum, int32, int64, uint32 and uint64 field types. */ |
|||
#ifndef PB_WITHOUT_64BIT |
|||
bool pb_encode_varint(pb_ostream_t *stream, uint64_t value); |
|||
#else |
|||
bool pb_encode_varint(pb_ostream_t *stream, uint32_t value); |
|||
#endif |
|||
|
|||
/* Encode an integer in the zig-zagged svarint format.
|
|||
* This works for sint32 and sint64. */ |
|||
#ifndef PB_WITHOUT_64BIT |
|||
bool pb_encode_svarint(pb_ostream_t *stream, int64_t value); |
|||
#else |
|||
bool pb_encode_svarint(pb_ostream_t *stream, int32_t value); |
|||
#endif |
|||
|
|||
/* Encode a string or bytes type field. For strings, pass strlen(s) as size. */ |
|||
bool pb_encode_string(pb_ostream_t *stream, const pb_byte_t *buffer, size_t size); |
|||
|
|||
/* Encode a fixed32, sfixed32 or float value.
|
|||
* You need to pass a pointer to a 4-byte wide C variable. */ |
|||
bool pb_encode_fixed32(pb_ostream_t *stream, const void *value); |
|||
|
|||
#ifndef PB_WITHOUT_64BIT |
|||
/* Encode a fixed64, sfixed64 or double value.
|
|||
* You need to pass a pointer to a 8-byte wide C variable. */ |
|||
bool pb_encode_fixed64(pb_ostream_t *stream, const void *value); |
|||
#endif |
|||
|
|||
#ifdef PB_CONVERT_DOUBLE_FLOAT |
|||
/* Encode a float value so that it appears like a double in the encoded
|
|||
* message. */ |
|||
bool pb_encode_float_as_double(pb_ostream_t *stream, float value); |
|||
#endif |
|||
|
|||
/* Encode a submessage field.
|
|||
* You need to pass the pb_field_t array and pointer to struct, just like |
|||
* with pb_encode(). This internally encodes the submessage twice, first to |
|||
* calculate message size and then to actually write it out. |
|||
*/ |
|||
bool pb_encode_submessage(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct); |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,388 @@ |
|||
/* pb_common.c: Common support functions for pb_encode.c and pb_decode.c.
|
|||
* |
|||
* 2014 Petteri Aimonen <jpa@kapsi.fi> |
|||
*/ |
|||
|
|||
#include "pb_common.h" |
|||
|
|||
static bool load_descriptor_values(pb_field_iter_t *iter) |
|||
{ |
|||
uint32_t word0; |
|||
uint32_t data_offset; |
|||
int_least8_t size_offset; |
|||
|
|||
if (iter->index >= iter->descriptor->field_count) |
|||
return false; |
|||
|
|||
word0 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]); |
|||
iter->type = (pb_type_t)((word0 >> 8) & 0xFF); |
|||
|
|||
switch(word0 & 3) |
|||
{ |
|||
case 0: { |
|||
/* 1-word format */ |
|||
iter->array_size = 1; |
|||
iter->tag = (pb_size_t)((word0 >> 2) & 0x3F); |
|||
size_offset = (int_least8_t)((word0 >> 24) & 0x0F); |
|||
data_offset = (word0 >> 16) & 0xFF; |
|||
iter->data_size = (pb_size_t)((word0 >> 28) & 0x0F); |
|||
break; |
|||
} |
|||
|
|||
case 1: { |
|||
/* 2-word format */ |
|||
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]); |
|||
|
|||
iter->array_size = (pb_size_t)((word0 >> 16) & 0x0FFF); |
|||
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 28) << 6)); |
|||
size_offset = (int_least8_t)((word0 >> 28) & 0x0F); |
|||
data_offset = word1 & 0xFFFF; |
|||
iter->data_size = (pb_size_t)((word1 >> 16) & 0x0FFF); |
|||
break; |
|||
} |
|||
|
|||
case 2: { |
|||
/* 4-word format */ |
|||
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]); |
|||
uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]); |
|||
uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]); |
|||
|
|||
iter->array_size = (pb_size_t)(word0 >> 16); |
|||
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6)); |
|||
size_offset = (int_least8_t)(word1 & 0xFF); |
|||
data_offset = word2; |
|||
iter->data_size = (pb_size_t)word3; |
|||
break; |
|||
} |
|||
|
|||
default: { |
|||
/* 8-word format */ |
|||
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]); |
|||
uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]); |
|||
uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]); |
|||
uint32_t word4 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 4]); |
|||
|
|||
iter->array_size = (pb_size_t)word4; |
|||
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6)); |
|||
size_offset = (int_least8_t)(word1 & 0xFF); |
|||
data_offset = word2; |
|||
iter->data_size = (pb_size_t)word3; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (!iter->message) |
|||
{ |
|||
/* Avoid doing arithmetic on null pointers, it is undefined */ |
|||
iter->pField = NULL; |
|||
iter->pSize = NULL; |
|||
} |
|||
else |
|||
{ |
|||
iter->pField = (char*)iter->message + data_offset; |
|||
|
|||
if (size_offset) |
|||
{ |
|||
iter->pSize = (char*)iter->pField - size_offset; |
|||
} |
|||
else if (PB_HTYPE(iter->type) == PB_HTYPE_REPEATED && |
|||
(PB_ATYPE(iter->type) == PB_ATYPE_STATIC || |
|||
PB_ATYPE(iter->type) == PB_ATYPE_POINTER)) |
|||
{ |
|||
/* Fixed count array */ |
|||
iter->pSize = &iter->array_size; |
|||
} |
|||
else |
|||
{ |
|||
iter->pSize = NULL; |
|||
} |
|||
|
|||
if (PB_ATYPE(iter->type) == PB_ATYPE_POINTER && iter->pField != NULL) |
|||
{ |
|||
iter->pData = *(void**)iter->pField; |
|||
} |
|||
else |
|||
{ |
|||
iter->pData = iter->pField; |
|||
} |
|||
} |
|||
|
|||
if (PB_LTYPE_IS_SUBMSG(iter->type)) |
|||
{ |
|||
iter->submsg_desc = iter->descriptor->submsg_info[iter->submessage_index]; |
|||
} |
|||
else |
|||
{ |
|||
iter->submsg_desc = NULL; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
static void advance_iterator(pb_field_iter_t *iter) |
|||
{ |
|||
iter->index++; |
|||
|
|||
if (iter->index >= iter->descriptor->field_count) |
|||
{ |
|||
/* Restart */ |
|||
iter->index = 0; |
|||
iter->field_info_index = 0; |
|||
iter->submessage_index = 0; |
|||
iter->required_field_index = 0; |
|||
} |
|||
else |
|||
{ |
|||
/* Increment indexes based on previous field type.
|
|||
* All field info formats have the following fields: |
|||
* - lowest 2 bits tell the amount of words in the descriptor (2^n words) |
|||
* - bits 2..7 give the lowest bits of tag number. |
|||
* - bits 8..15 give the field type. |
|||
*/ |
|||
uint32_t prev_descriptor = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]); |
|||
pb_type_t prev_type = (prev_descriptor >> 8) & 0xFF; |
|||
pb_size_t descriptor_len = (pb_size_t)(1 << (prev_descriptor & 3)); |
|||
|
|||
/* Add to fields.
|
|||
* The cast to pb_size_t is needed to avoid -Wconversion warning. |
|||
* Because the data is is constants from generator, there is no danger of overflow. |
|||
*/ |
|||
iter->field_info_index = (pb_size_t)(iter->field_info_index + descriptor_len); |
|||
iter->required_field_index = (pb_size_t)(iter->required_field_index + (PB_HTYPE(prev_type) == PB_HTYPE_REQUIRED)); |
|||
iter->submessage_index = (pb_size_t)(iter->submessage_index + PB_LTYPE_IS_SUBMSG(prev_type)); |
|||
} |
|||
} |
|||
|
|||
bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_msgdesc_t *desc, void *message) |
|||
{ |
|||
memset(iter, 0, sizeof(*iter)); |
|||
|
|||
iter->descriptor = desc; |
|||
iter->message = message; |
|||
|
|||
return load_descriptor_values(iter); |
|||
} |
|||
|
|||
bool pb_field_iter_begin_extension(pb_field_iter_t *iter, pb_extension_t *extension) |
|||
{ |
|||
const pb_msgdesc_t *msg = (const pb_msgdesc_t*)extension->type->arg; |
|||
bool status; |
|||
|
|||
uint32_t word0 = PB_PROGMEM_READU32(msg->field_info[0]); |
|||
if (PB_ATYPE(word0 >> 8) == PB_ATYPE_POINTER) |
|||
{ |
|||
/* For pointer extensions, the pointer is stored directly
|
|||
* in the extension structure. This avoids having an extra |
|||
* indirection. */ |
|||
status = pb_field_iter_begin(iter, msg, &extension->dest); |
|||
} |
|||
else |
|||
{ |
|||
status = pb_field_iter_begin(iter, msg, extension->dest); |
|||
} |
|||
|
|||
iter->pSize = &extension->found; |
|||
return status; |
|||
} |
|||
|
|||
bool pb_field_iter_next(pb_field_iter_t *iter) |
|||
{ |
|||
advance_iterator(iter); |
|||
(void)load_descriptor_values(iter); |
|||
return iter->index != 0; |
|||
} |
|||
|
|||
bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag) |
|||
{ |
|||
if (iter->tag == tag) |
|||
{ |
|||
return true; /* Nothing to do, correct field already. */ |
|||
} |
|||
else if (tag > iter->descriptor->largest_tag) |
|||
{ |
|||
return false; |
|||
} |
|||
else |
|||
{ |
|||
pb_size_t start = iter->index; |
|||
uint32_t fieldinfo; |
|||
|
|||
if (tag < iter->tag) |
|||
{ |
|||
/* Fields are in tag number order, so we know that tag is between
|
|||
* 0 and our start position. Setting index to end forces |
|||
* advance_iterator() call below to restart from beginning. */ |
|||
iter->index = iter->descriptor->field_count; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
/* Advance iterator but don't load values yet */ |
|||
advance_iterator(iter); |
|||
|
|||
/* Do fast check for tag number match */ |
|||
fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]); |
|||
|
|||
if (((fieldinfo >> 2) & 0x3F) == (tag & 0x3F)) |
|||
{ |
|||
/* Good candidate, check further */ |
|||
(void)load_descriptor_values(iter); |
|||
|
|||
if (iter->tag == tag && |
|||
PB_LTYPE(iter->type) != PB_LTYPE_EXTENSION) |
|||
{ |
|||
/* Found it */ |
|||
return true; |
|||
} |
|||
} |
|||
} while (iter->index != start); |
|||
|
|||
/* Searched all the way back to start, and found nothing. */ |
|||
(void)load_descriptor_values(iter); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
bool pb_field_iter_find_extension(pb_field_iter_t *iter) |
|||
{ |
|||
if (PB_LTYPE(iter->type) == PB_LTYPE_EXTENSION) |
|||
{ |
|||
return true; |
|||
} |
|||
else |
|||
{ |
|||
pb_size_t start = iter->index; |
|||
uint32_t fieldinfo; |
|||
|
|||
do |
|||
{ |
|||
/* Advance iterator but don't load values yet */ |
|||
advance_iterator(iter); |
|||
|
|||
/* Do fast check for field type */ |
|||
fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]); |
|||
|
|||
if (PB_LTYPE((fieldinfo >> 8) & 0xFF) == PB_LTYPE_EXTENSION) |
|||
{ |
|||
return load_descriptor_values(iter); |
|||
} |
|||
} while (iter->index != start); |
|||
|
|||
/* Searched all the way back to start, and found nothing. */ |
|||
(void)load_descriptor_values(iter); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
static void *pb_const_cast(const void *p) |
|||
{ |
|||
/* Note: this casts away const, in order to use the common field iterator
|
|||
* logic for both encoding and decoding. The cast is done using union |
|||
* to avoid spurious compiler warnings. */ |
|||
union { |
|||
void *p1; |
|||
const void *p2; |
|||
} t; |
|||
t.p2 = p; |
|||
return t.p1; |
|||
} |
|||
|
|||
bool pb_field_iter_begin_const(pb_field_iter_t *iter, const pb_msgdesc_t *desc, const void *message) |
|||
{ |
|||
return pb_field_iter_begin(iter, desc, pb_const_cast(message)); |
|||
} |
|||
|
|||
bool pb_field_iter_begin_extension_const(pb_field_iter_t *iter, const pb_extension_t *extension) |
|||
{ |
|||
return pb_field_iter_begin_extension(iter, (pb_extension_t*)pb_const_cast(extension)); |
|||
} |
|||
|
|||
bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field) |
|||
{ |
|||
if (field->data_size == sizeof(pb_callback_t)) |
|||
{ |
|||
pb_callback_t *pCallback = (pb_callback_t*)field->pData; |
|||
|
|||
if (pCallback != NULL) |
|||
{ |
|||
if (istream != NULL && pCallback->funcs.decode != NULL) |
|||
{ |
|||
return pCallback->funcs.decode(istream, field, &pCallback->arg); |
|||
} |
|||
|
|||
if (ostream != NULL && pCallback->funcs.encode != NULL) |
|||
{ |
|||
return pCallback->funcs.encode(ostream, field, &pCallback->arg); |
|||
} |
|||
} |
|||
} |
|||
|
|||
return true; /* Success, but didn't do anything */ |
|||
|
|||
} |
|||
|
|||
#ifdef PB_VALIDATE_UTF8 |
|||
|
|||
/* This function checks whether a string is valid UTF-8 text.
|
|||
* |
|||
* Algorithm is adapted from https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c
|
|||
* Original copyright: Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> 2005-03-30
|
|||
* Licensed under "Short code license", which allows use under MIT license or |
|||
* any compatible with it. |
|||
*/ |
|||
|
|||
bool pb_validate_utf8(const char *str) |
|||
{ |
|||
const pb_byte_t *s = (const pb_byte_t*)str; |
|||
while (*s) |
|||
{ |
|||
if (*s < 0x80) |
|||
{ |
|||
/* 0xxxxxxx */ |
|||
s++; |
|||
} |
|||
else if ((s[0] & 0xe0) == 0xc0) |
|||
{ |
|||
/* 110XXXXx 10xxxxxx */ |
|||
if ((s[1] & 0xc0) != 0x80 || |
|||
(s[0] & 0xfe) == 0xc0) /* overlong? */ |
|||
return false; |
|||
else |
|||
s += 2; |
|||
} |
|||
else if ((s[0] & 0xf0) == 0xe0) |
|||
{ |
|||
/* 1110XXXX 10Xxxxxx 10xxxxxx */ |
|||
if ((s[1] & 0xc0) != 0x80 || |
|||
(s[2] & 0xc0) != 0x80 || |
|||
(s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) || /* overlong? */ |
|||
(s[0] == 0xed && (s[1] & 0xe0) == 0xa0) || /* surrogate? */ |
|||
(s[0] == 0xef && s[1] == 0xbf && |
|||
(s[2] & 0xfe) == 0xbe)) /* U+FFFE or U+FFFF? */ |
|||
return false; |
|||
else |
|||
s += 3; |
|||
} |
|||
else if ((s[0] & 0xf8) == 0xf0) |
|||
{ |
|||
/* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */ |
|||
if ((s[1] & 0xc0) != 0x80 || |
|||
(s[2] & 0xc0) != 0x80 || |
|||
(s[3] & 0xc0) != 0x80 || |
|||
(s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) || /* overlong? */ |
|||
(s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) /* > U+10FFFF? */ |
|||
return false; |
|||
else |
|||
s += 4; |
|||
} |
|||
else |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
#endif |
|||
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,20 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_CV.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(CV_struct_define, CV_struct_define, AUTO) |
|||
|
|||
|
|||
|
|||
#ifndef PB_CONVERT_DOUBLE_FLOAT |
|||
/* On some platforms (such as AVR), double is really float.
|
|||
* To be able to encode/decode double on these platforms, you need. |
|||
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line. |
|||
*/ |
|||
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES) |
|||
#endif |
|||
|
|||
@ -0,0 +1,125 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_CV_PB_H_INCLUDED |
|||
#define PB_BSP_CV_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
#include "bsp_PV.pb.h" |
|||
#include "bsp_PID.pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _CV_struct_define { |
|||
int32_t Speed_m_per_min; /* MPMin = 1m/min 1米每分钟 m/min */ |
|||
int32_t LeftTurnSpeed; |
|||
int32_t RightTurnSpeed; |
|||
int32_t RobotLeftAngleValue; /* 水平左方向 单位0.01° */ |
|||
int32_t RobotRightAngleValue; /* 水平右方向角度值 单位0.01° */ |
|||
int32_t RobotUpAngleValue; /* 竖直方向角度值 单位0.01° */ |
|||
int32_t RobotDownAngleValue; /* 竖直向下角度值 单位0.01° */ |
|||
int32_t Robot_Permitted_Angler_Error_Value_E_2D; /* 作业时需用的最大角度偏差值 0.01°，超出将停止作业 */ |
|||
int32_t Robot_Angle_Start_BaseE_2D; /* 角度值 0.01° */ |
|||
int32_t Lane_Change_Speed_m_per_min; |
|||
int32_t Is_Automation_Authorized; |
|||
int32_t Is_Function_Authorized; |
|||
int32_t Joy_Sticker_Angle_Allowance; /* 例如在90度的±30° */ |
|||
int32_t Joy_Sticker_Value_Allowance; /* 例如 joysticker的值超过600 */ |
|||
int32_t Allowable_Error_For_Angle_Tracking; /* 纠偏角度跟踪的允许误差1 度 */ |
|||
int32_t Paint_Gun_Shutdown_Distance; /* 喷枪关闭距离，喷枪关闭后多上厘米停止运行 */ |
|||
int32_t Horizontal_ChangeLane_Compensation; /* 水平换道补偿距离 */ |
|||
int32_t Vertical_ChangeLane_Compensation; /* 竖直换道补偿距离 */ |
|||
int32_t pulse_Per_Circle; /* 每转多少脉冲 */ |
|||
int32_t wheel_Reduction_Ratio; /* 减速比 */ |
|||
double wheel_Diameter_m; /* 车轮直径 m */ |
|||
bool has_PID_high; |
|||
PID_Parameters PID_high; |
|||
bool has_PID_mid; |
|||
PID_Parameters PID_mid; |
|||
bool has_PID_low; |
|||
PID_Parameters PID_low; |
|||
} CV_struct_define; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define CV_struct_define_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, PID_Parameters_init_default, false, PID_Parameters_init_default, false, PID_Parameters_init_default} |
|||
#define CV_struct_define_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, PID_Parameters_init_zero, false, PID_Parameters_init_zero, false, PID_Parameters_init_zero} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define CV_struct_define_Speed_m_per_min_tag 1 |
|||
#define CV_struct_define_LeftTurnSpeed_tag 2 |
|||
#define CV_struct_define_RightTurnSpeed_tag 3 |
|||
#define CV_struct_define_RobotLeftAngleValue_tag 4 |
|||
#define CV_struct_define_RobotRightAngleValue_tag 5 |
|||
#define CV_struct_define_RobotUpAngleValue_tag 6 |
|||
#define CV_struct_define_RobotDownAngleValue_tag 7 |
|||
#define CV_struct_define_Robot_Permitted_Angler_Error_Value_E_2D_tag 8 |
|||
#define CV_struct_define_Robot_Angle_Start_BaseE_2D_tag 9 |
|||
#define CV_struct_define_Lane_Change_Speed_m_per_min_tag 10 |
|||
#define CV_struct_define_Is_Automation_Authorized_tag 11 |
|||
#define CV_struct_define_Is_Function_Authorized_tag 12 |
|||
#define CV_struct_define_Joy_Sticker_Angle_Allowance_tag 13 |
|||
#define CV_struct_define_Joy_Sticker_Value_Allowance_tag 14 |
|||
#define CV_struct_define_Allowable_Error_For_Angle_Tracking_tag 15 |
|||
#define CV_struct_define_Paint_Gun_Shutdown_Distance_tag 16 |
|||
#define CV_struct_define_Horizontal_ChangeLane_Compensation_tag 17 |
|||
#define CV_struct_define_Vertical_ChangeLane_Compensation_tag 18 |
|||
#define CV_struct_define_pulse_Per_Circle_tag 19 |
|||
#define CV_struct_define_wheel_Reduction_Ratio_tag 20 |
|||
#define CV_struct_define_wheel_Diameter_m_tag 21 |
|||
#define CV_struct_define_PID_high_tag 22 |
|||
#define CV_struct_define_PID_mid_tag 23 |
|||
#define CV_struct_define_PID_low_tag 24 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define CV_struct_define_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, Speed_m_per_min, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, LeftTurnSpeed, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, RightTurnSpeed, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotLeftAngleValue, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotRightAngleValue, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotUpAngleValue, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotDownAngleValue, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, Robot_Permitted_Angler_Error_Value_E_2D, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, Robot_Angle_Start_BaseE_2D, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, Lane_Change_Speed_m_per_min, 10) \ |
|||
X(a, STATIC, SINGULAR, INT32, Is_Automation_Authorized, 11) \ |
|||
X(a, STATIC, SINGULAR, INT32, Is_Function_Authorized, 12) \ |
|||
X(a, STATIC, SINGULAR, INT32, Joy_Sticker_Angle_Allowance, 13) \ |
|||
X(a, STATIC, SINGULAR, INT32, Joy_Sticker_Value_Allowance, 14) \ |
|||
X(a, STATIC, SINGULAR, INT32, Allowable_Error_For_Angle_Tracking, 15) \ |
|||
X(a, STATIC, SINGULAR, INT32, Paint_Gun_Shutdown_Distance, 16) \ |
|||
X(a, STATIC, SINGULAR, INT32, Horizontal_ChangeLane_Compensation, 17) \ |
|||
X(a, STATIC, SINGULAR, INT32, Vertical_ChangeLane_Compensation, 18) \ |
|||
X(a, STATIC, SINGULAR, INT32, pulse_Per_Circle, 19) \ |
|||
X(a, STATIC, SINGULAR, INT32, wheel_Reduction_Ratio, 20) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, wheel_Diameter_m, 21) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, PID_high, 22) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, PID_mid, 23) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, PID_low, 24) |
|||
#define CV_struct_define_CALLBACK NULL |
|||
#define CV_struct_define_DEFAULT NULL |
|||
#define CV_struct_define_PID_high_MSGTYPE PID_Parameters |
|||
#define CV_struct_define_PID_mid_MSGTYPE PID_Parameters |
|||
#define CV_struct_define_PID_low_MSGTYPE PID_Parameters |
|||
|
|||
extern const pb_msgdesc_t CV_struct_define_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define CV_struct_define_fields &CV_struct_define_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_CV_PB_H_MAX_SIZE CV_struct_define_size |
|||
#define CV_struct_define_size 358 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_Cmd.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(Cmd, Cmd, 2) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,80 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_CMD_PB_H_INCLUDED |
|||
#define PB_BSP_CMD_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
/* this message is used for the computer to send command */ |
|||
typedef struct _Cmd { |
|||
int32_t CommadNum; |
|||
/* 定义 1 上位机获取默认CV值
|
|||
定义 2 下位机返回CV值 |
|||
定义 3 上位机设定CV值 |
|||
定义 4 上位机设定Trace等级值，无返回 |
|||
定义 5 下位机上传位置点数据 |
|||
定义 6 上位机设定编码器角度值为0 |
|||
定义 7 上位机获取拟合点 |
|||
定义 8 上位机获取位置点 |
|||
定义 9 上位机向下位机下发程序 此时，Parameter0 下发的程序起始位，Parameter0 是校验位 |
|||
Buff_Data_Length 是下发的字节数， */ |
|||
int32_t Parameter0; |
|||
int32_t Parameter1; |
|||
int32_t Parameter2; |
|||
int32_t Parameter3; |
|||
int32_t Parameter4; |
|||
int32_t Buff_Data_Length; |
|||
pb_byte_t Buff_Data[512]; |
|||
} Cmd; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define Cmd_init_default {0, 0, 0, 0, 0, 0, 0, {0}} |
|||
#define Cmd_init_zero {0, 0, 0, 0, 0, 0, 0, {0}} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define Cmd_CommadNum_tag 1 |
|||
#define Cmd_Parameter0_tag 2 |
|||
#define Cmd_Parameter1_tag 3 |
|||
#define Cmd_Parameter2_tag 4 |
|||
#define Cmd_Parameter3_tag 5 |
|||
#define Cmd_Parameter4_tag 6 |
|||
#define Cmd_Buff_Data_Length_tag 7 |
|||
#define Cmd_Buff_Data_tag 8 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define Cmd_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, CommadNum, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter0, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter1, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter2, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter3, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter4, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, Buff_Data_Length, 7) \ |
|||
X(a, STATIC, SINGULAR, FIXED_LENGTH_BYTES, Buff_Data, 8) |
|||
#define Cmd_CALLBACK NULL |
|||
#define Cmd_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t Cmd_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define Cmd_fields &Cmd_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_CMD_PB_H_MAX_SIZE Cmd_size |
|||
#define Cmd_size 592 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,13 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_Error.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(ErrorData, ErrorData, AUTO) |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,72 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_ERROR_PB_H_INCLUDED |
|||
#define PB_BSP_ERROR_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Enum definitions */ |
|||
typedef enum _ComError { |
|||
ComError_MK32_SBus = 0, |
|||
ComError_TL720D = 1, |
|||
ComError_LS_LeftMotor = 2, |
|||
ComError_LS_RightMotor = 3, |
|||
ComError_Remote_Button_Reset_State = 4, |
|||
ComError_MK32_Serial = 5, |
|||
ComError_MK32_UDP = 6 |
|||
} ComError; |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _ErrorData { |
|||
int32_t Com_Error_Code; |
|||
int32_t Left_Motor_Error_Code; |
|||
int32_t Right_Motor_Error_Code; |
|||
} ErrorData; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Helper constants for enums */ |
|||
#define _ComError_MIN ComError_MK32_SBus |
|||
#define _ComError_MAX ComError_MK32_UDP |
|||
#define _ComError_ARRAYSIZE ((ComError)(ComError_MK32_UDP+1)) |
|||
|
|||
|
|||
|
|||
/* Initializer values for message structs */ |
|||
#define ErrorData_init_default {0, 0, 0} |
|||
#define ErrorData_init_zero {0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define ErrorData_Com_Error_Code_tag 1 |
|||
#define ErrorData_Left_Motor_Error_Code_tag 2 |
|||
#define ErrorData_Right_Motor_Error_Code_tag 3 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define ErrorData_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, Com_Error_Code, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, Left_Motor_Error_Code, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Right_Motor_Error_Code, 3) |
|||
#define ErrorData_CALLBACK NULL |
|||
#define ErrorData_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t ErrorData_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define ErrorData_fields &ErrorData_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_ERROR_PB_H_MAX_SIZE ErrorData_size |
|||
#define ErrorData_size 33 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_GV.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(GV_struct_define, GV_struct_define, 2) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,108 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_GV_PB_H_INCLUDED |
|||
#define PB_BSP_GV_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
#include "msp_MK32.pb.h" |
|||
#include "msp_Motor.pb.h" |
|||
#include "msp_LS_MotorParameters.pb.h" |
|||
#include "msp_TL720D.pb.h" |
|||
#include "bsp_Error.pb.h" |
|||
#include "bsp_PV.pb.h" |
|||
#include "bsp_IO.pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _GV_struct_define { |
|||
int32_t TempatureE_2C; /* E_2C=0.01 Celsius 0.01摄氏度 */ |
|||
int32_t Left_Compensation; /* E_2D =0.01 Degree 0.01度 */ |
|||
int32_t Right_Compensation; /* 0.01度 */ |
|||
int32_t Robot_Angle; /* 机器人角度 //0.01度 */ |
|||
int32_t Robot_Move_Speed; /* 0.1rpm */ |
|||
int32_t ForceValue; |
|||
int32_t LaneChangeDistance; |
|||
bool has_P_MK32; |
|||
SP_MSP_MK32_Button P_MK32; |
|||
bool has_LeftMotor; |
|||
LS_MotorParameters LeftMotor; /* 左电机 ID2 */ |
|||
bool has_RightMotor; |
|||
LS_MotorParameters RightMotor; /* 右电机 ID3 */ |
|||
bool has_TL720DParameters; |
|||
MSP_TL720DParameters TL720DParameters; |
|||
bool has_IO; |
|||
IO_Data IO; |
|||
bool has_SystemErrorData; |
|||
ErrorData SystemErrorData; |
|||
bool has_PV; |
|||
PV_struct_define PV; /* 用户配置数据 */ |
|||
} GV_struct_define; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define GV_struct_define_init_default {0, 0, 0, 0, 0, 0, 0, false, SP_MSP_MK32_Button_init_default, false, LS_MotorParameters_init_default, false, LS_MotorParameters_init_default, false, MSP_TL720DParameters_init_default, false, IO_Data_init_default, false, ErrorData_init_default, false, PV_struct_define_init_default} |
|||
#define GV_struct_define_init_zero {0, 0, 0, 0, 0, 0, 0, false, SP_MSP_MK32_Button_init_zero, false, LS_MotorParameters_init_zero, false, LS_MotorParameters_init_zero, false, MSP_TL720DParameters_init_zero, false, IO_Data_init_zero, false, ErrorData_init_zero, false, PV_struct_define_init_zero} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define GV_struct_define_TempatureE_2C_tag 1 |
|||
#define GV_struct_define_Left_Compensation_tag 2 |
|||
#define GV_struct_define_Right_Compensation_tag 3 |
|||
#define GV_struct_define_Robot_Angle_tag 4 |
|||
#define GV_struct_define_Robot_Move_Speed_tag 5 |
|||
#define GV_struct_define_ForceValue_tag 6 |
|||
#define GV_struct_define_LaneChangeDistance_tag 7 |
|||
#define GV_struct_define_P_MK32_tag 9 |
|||
#define GV_struct_define_LeftMotor_tag 10 |
|||
#define GV_struct_define_RightMotor_tag 11 |
|||
#define GV_struct_define_TL720DParameters_tag 12 |
|||
#define GV_struct_define_IO_tag 13 |
|||
#define GV_struct_define_SystemErrorData_tag 14 |
|||
#define GV_struct_define_PV_tag 15 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define GV_struct_define_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, TempatureE_2C, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, Left_Compensation, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Right_Compensation, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, Robot_Angle, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Robot_Move_Speed, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, ForceValue, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, LaneChangeDistance, 7) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, P_MK32, 9) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, LeftMotor, 10) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, RightMotor, 11) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, TL720DParameters, 12) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, IO, 13) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, SystemErrorData, 14) \ |
|||
X(a, STATIC, OPTIONAL, MESSAGE, PV, 15) |
|||
#define GV_struct_define_CALLBACK NULL |
|||
#define GV_struct_define_DEFAULT NULL |
|||
#define GV_struct_define_P_MK32_MSGTYPE SP_MSP_MK32_Button |
|||
#define GV_struct_define_LeftMotor_MSGTYPE LS_MotorParameters |
|||
#define GV_struct_define_RightMotor_MSGTYPE LS_MotorParameters |
|||
#define GV_struct_define_TL720DParameters_MSGTYPE MSP_TL720DParameters |
|||
#define GV_struct_define_IO_MSGTYPE IO_Data |
|||
#define GV_struct_define_SystemErrorData_MSGTYPE ErrorData |
|||
#define GV_struct_define_PV_MSGTYPE PV_struct_define |
|||
|
|||
extern const pb_msgdesc_t GV_struct_define_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define GV_struct_define_fields &GV_struct_define_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_GV_PB_H_MAX_SIZE GV_struct_define_size |
|||
#define GV_struct_define_size 906 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_IAP.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(IAP_struct_define, IAP_struct_define, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,58 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_IAP_PB_H_INCLUDED |
|||
#define PB_BSP_IAP_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
/* IAP，即In Application Programming，IAP是用户自己的程序在运行过程中对User Flash的部分区域进行烧写。 */ |
|||
typedef struct _IAP_struct_define { |
|||
int32_t Total_Bytes; /* all the received data; */ |
|||
int32_t NextCodeVrsion; /* the New upgrade Version of the Project */ |
|||
int32_t UtcTime; /* Udgrade Time */ |
|||
int32_t UpgradeSucceeded; /* */ |
|||
} IAP_struct_define; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define IAP_struct_define_init_default {0, 0, 0, 0} |
|||
#define IAP_struct_define_init_zero {0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define IAP_struct_define_Total_Bytes_tag 1 |
|||
#define IAP_struct_define_NextCodeVrsion_tag 2 |
|||
#define IAP_struct_define_UtcTime_tag 3 |
|||
#define IAP_struct_define_UpgradeSucceeded_tag 4 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define IAP_struct_define_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, Total_Bytes, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, NextCodeVrsion, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, UtcTime, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, UpgradeSucceeded, 4) |
|||
#define IAP_struct_define_CALLBACK NULL |
|||
#define IAP_struct_define_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t IAP_struct_define_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define IAP_struct_define_fields &IAP_struct_define_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_IAP_PB_H_MAX_SIZE IAP_struct_define_size |
|||
#define IAP_struct_define_size 44 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_IO.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(IO_Data, IO_Data, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,81 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_IO_PB_H_INCLUDED |
|||
#define PB_BSP_IO_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _IO_Data { |
|||
int32_t DO0; |
|||
int32_t DO1; |
|||
int32_t DO2; |
|||
int32_t DO3; |
|||
int32_t DO4; |
|||
int32_t DO5; |
|||
int32_t DI0; |
|||
int32_t DI1; |
|||
int32_t DI2; |
|||
int32_t DI3; |
|||
int32_t DI4; |
|||
int32_t DI5; |
|||
} IO_Data; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define IO_Data_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define IO_Data_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define IO_Data_DO0_tag 1 |
|||
#define IO_Data_DO1_tag 2 |
|||
#define IO_Data_DO2_tag 3 |
|||
#define IO_Data_DO3_tag 4 |
|||
#define IO_Data_DO4_tag 5 |
|||
#define IO_Data_DO5_tag 6 |
|||
#define IO_Data_DI0_tag 7 |
|||
#define IO_Data_DI1_tag 8 |
|||
#define IO_Data_DI2_tag 9 |
|||
#define IO_Data_DI3_tag 10 |
|||
#define IO_Data_DI4_tag 11 |
|||
#define IO_Data_DI5_tag 12 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define IO_Data_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO0, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO1, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO2, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO3, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO4, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, DO5, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI0, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI1, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI2, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI3, 10) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI4, 11) \ |
|||
X(a, STATIC, SINGULAR, INT32, DI5, 12) |
|||
#define IO_Data_CALLBACK NULL |
|||
#define IO_Data_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t IO_Data_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define IO_Data_fields &IO_Data_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_IO_PB_H_MAX_SIZE IO_Data_size |
|||
#define IO_Data_size 132 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_IV.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(IV_struct_define, IV_struct_define, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,75 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_IV_PB_H_INCLUDED |
|||
#define PB_BSP_IV_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _IV_struct_define { |
|||
int32_t CurrentAngle; /* 单位0.01° */ |
|||
int32_t RobotMoveSpeed; /* 单位m/min 目标速度 */ |
|||
int32_t SBUS_State; /* 0断开 1连接 */ |
|||
int32_t SystemError; /* 硬件通讯错误及按键未初始化错误 */ |
|||
int32_t Left_Motor_Err; /* 左轮电机报警 */ |
|||
int32_t Right_Motor_Err; /* 右轮电机报警 */ |
|||
int32_t IsWorking; /* 机器人正在执行运动指令 */ |
|||
int32_t CurrentSpeed; /* 当前速度 */ |
|||
int64_t TimeStamp; /* 当前时间戳 */ |
|||
int32_t IsRestart; /* 是否重启 */ |
|||
} IV_struct_define; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define IV_struct_define_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define IV_struct_define_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define IV_struct_define_CurrentAngle_tag 1 |
|||
#define IV_struct_define_RobotMoveSpeed_tag 2 |
|||
#define IV_struct_define_SBUS_State_tag 3 |
|||
#define IV_struct_define_SystemError_tag 4 |
|||
#define IV_struct_define_Left_Motor_Err_tag 5 |
|||
#define IV_struct_define_Right_Motor_Err_tag 6 |
|||
#define IV_struct_define_IsWorking_tag 7 |
|||
#define IV_struct_define_CurrentSpeed_tag 8 |
|||
#define IV_struct_define_TimeStamp_tag 9 |
|||
#define IV_struct_define_IsRestart_tag 10 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define IV_struct_define_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, CurrentAngle, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotMoveSpeed, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, SBUS_State, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, SystemError, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Left_Motor_Err, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, Right_Motor_Err, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, IsWorking, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, CurrentSpeed, 8) \ |
|||
X(a, STATIC, SINGULAR, INT64, TimeStamp, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, IsRestart, 10) |
|||
#define IV_struct_define_CALLBACK NULL |
|||
#define IV_struct_define_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t IV_struct_define_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define IV_struct_define_fields &IV_struct_define_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_IV_PB_H_MAX_SIZE IV_struct_define_size |
|||
#define IV_struct_define_size 110 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,20 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_PID.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(PID_Parameters, PID_Parameters, AUTO) |
|||
|
|||
|
|||
|
|||
#ifndef PB_CONVERT_DOUBLE_FLOAT |
|||
/* On some platforms (such as AVR), double is really float.
|
|||
* To be able to encode/decode double on these platforms, you need. |
|||
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line. |
|||
*/ |
|||
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES) |
|||
#endif |
|||
|
|||
@ -0,0 +1,57 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_PID_PB_H_INCLUDED |
|||
#define PB_BSP_PID_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _PID_Parameters { |
|||
int32_t PID_Angle; /* 调整 单位0.01° 配置时需要*100 */ |
|||
double Kp; /* PID参数 */ |
|||
double Ki; |
|||
double Kd; |
|||
} PID_Parameters; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define PID_Parameters_init_default {0, 0, 0, 0} |
|||
#define PID_Parameters_init_zero {0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define PID_Parameters_PID_Angle_tag 1 |
|||
#define PID_Parameters_Kp_tag 2 |
|||
#define PID_Parameters_Ki_tag 3 |
|||
#define PID_Parameters_Kd_tag 4 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define PID_Parameters_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, PID_Angle, 1) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, Kp, 2) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, Ki, 3) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, Kd, 4) |
|||
#define PID_Parameters_CALLBACK NULL |
|||
#define PID_Parameters_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t PID_Parameters_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define PID_Parameters_fields &PID_Parameters_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_PID_PB_H_MAX_SIZE PID_Parameters_size |
|||
#define PID_Parameters_size 38 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,20 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_PV.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(PV_struct_define, PV_struct_define, AUTO) |
|||
|
|||
|
|||
|
|||
#ifndef PB_CONVERT_DOUBLE_FLOAT |
|||
/* On some platforms (such as AVR), double is really float.
|
|||
* To be able to encode/decode double on these platforms, you need. |
|||
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line. |
|||
*/ |
|||
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES) |
|||
#endif |
|||
|
|||
@ -0,0 +1,64 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_PV_PB_H_INCLUDED |
|||
#define PB_BSP_PV_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _PV_struct_define { |
|||
/* 喷漆项目 */ |
|||
int32_t RunMode; /* 1 手动无校准作业 2 手动竖直向左作业 3 手动竖直向右作业 */ |
|||
int32_t RobotSpeed; /* 0-30m/min */ |
|||
int32_t LaneChangeDistance; /* 1-100cm */ |
|||
double Vertical_Calibration; /* 1° */ |
|||
int32_t IV_IsRestart_Notified; /* 是否接收到IV restart flag */ |
|||
int64_t TimeStamp; /* */ |
|||
} PV_struct_define; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define PV_struct_define_init_default {0, 0, 0, 0, 0, 0} |
|||
#define PV_struct_define_init_zero {0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define PV_struct_define_RunMode_tag 1 |
|||
#define PV_struct_define_RobotSpeed_tag 2 |
|||
#define PV_struct_define_LaneChangeDistance_tag 3 |
|||
#define PV_struct_define_Vertical_Calibration_tag 4 |
|||
#define PV_struct_define_IV_IsRestart_Notified_tag 5 |
|||
#define PV_struct_define_TimeStamp_tag 6 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define PV_struct_define_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, RunMode, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, RobotSpeed, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, LaneChangeDistance, 3) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, Vertical_Calibration, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, IV_IsRestart_Notified, 5) \ |
|||
X(a, STATIC, SINGULAR, INT64, TimeStamp, 6) |
|||
#define PV_struct_define_CALLBACK NULL |
|||
#define PV_struct_define_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t PV_struct_define_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define PV_struct_define_fields &PV_struct_define_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_PV_PB_H_MAX_SIZE PV_struct_define_size |
|||
#define PV_struct_define_size 64 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "bsp_ReCmd.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(ReCmd, ReCmd, 2) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,80 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_BSP_RECMD_PB_H_INCLUDED |
|||
#define PB_BSP_RECMD_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
/* this message is used for the reply the command */ |
|||
typedef struct _ReCmd { |
|||
int32_t CommadNum; |
|||
/* 定义 1 上位机获取默认CV值
|
|||
定义 2 下位机返回CV值 |
|||
定义 3 上位机设定CV值 |
|||
定义 4 上位机设定Trace等级值，无返回 |
|||
定义 5 下位机上传位置点数据 |
|||
定义 6 上位机设定编码器角度值为0 |
|||
定义 7 上位机获取拟合点 |
|||
定义 8 上位机获取位置点 |
|||
定义 9 上位机向下位机下发程序 此时，Parameter0 下发的程序起始位，Parameter0 是校验位 |
|||
Buff_Data_Length 是下发的字节数， */ |
|||
int32_t Parameter0; |
|||
int32_t Parameter1; |
|||
int32_t Parameter2; |
|||
int32_t Parameter3; |
|||
int32_t Parameter4; |
|||
int32_t Buff_Data_Length; |
|||
pb_byte_t Buff_Data[512]; |
|||
} ReCmd; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define ReCmd_init_default {0, 0, 0, 0, 0, 0, 0, {0}} |
|||
#define ReCmd_init_zero {0, 0, 0, 0, 0, 0, 0, {0}} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define ReCmd_CommadNum_tag 1 |
|||
#define ReCmd_Parameter0_tag 2 |
|||
#define ReCmd_Parameter1_tag 3 |
|||
#define ReCmd_Parameter2_tag 4 |
|||
#define ReCmd_Parameter3_tag 5 |
|||
#define ReCmd_Parameter4_tag 6 |
|||
#define ReCmd_Buff_Data_Length_tag 7 |
|||
#define ReCmd_Buff_Data_tag 8 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define ReCmd_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, CommadNum, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter0, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter1, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter2, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter3, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, Parameter4, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, Buff_Data_Length, 7) \ |
|||
X(a, STATIC, SINGULAR, FIXED_LENGTH_BYTES, Buff_Data, 8) |
|||
#define ReCmd_CALLBACK NULL |
|||
#define ReCmd_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t ReCmd_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define ReCmd_fields &ReCmd_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define BSP_RECMD_PB_H_MAX_SIZE ReCmd_size |
|||
#define ReCmd_size 592 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,20 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "msp_LS_MotorParameters.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(LS_MotorParameters, LS_MotorParameters, AUTO) |
|||
|
|||
|
|||
|
|||
#ifndef PB_CONVERT_DOUBLE_FLOAT |
|||
/* On some platforms (such as AVR), double is really float.
|
|||
* To be able to encode/decode double on these platforms, you need. |
|||
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line. |
|||
*/ |
|||
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES) |
|||
#endif |
|||
|
|||
@ -0,0 +1,84 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_MSP_LS_MOTORPARAMETERS_PB_H_INCLUDED |
|||
#define PB_MSP_LS_MOTORPARAMETERS_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _LS_MotorParameters { |
|||
int32_t MotorID; |
|||
int32_t Real_Current; |
|||
int32_t Target_Current; /* 0.1rpm */ |
|||
int32_t Real_Velcity; /* 0.1rpm */ |
|||
int32_t Target_Velcity; /* 0.1rpm */ |
|||
int32_t Target_Position; /* 0.1rpm */ |
|||
int32_t Real_Position; |
|||
int32_t Motor_Fault; |
|||
int32_t Number_Of_Rounds; |
|||
int32_t Start_Measuring_Position; |
|||
int32_t Last_Real_Position; |
|||
double Real_Disatnce; |
|||
int32_t Start_Measuring; /* 开始测距 */ |
|||
} LS_MotorParameters; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define LS_MotorParameters_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define LS_MotorParameters_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define LS_MotorParameters_MotorID_tag 1 |
|||
#define LS_MotorParameters_Real_Current_tag 2 |
|||
#define LS_MotorParameters_Target_Current_tag 3 |
|||
#define LS_MotorParameters_Real_Velcity_tag 4 |
|||
#define LS_MotorParameters_Target_Velcity_tag 5 |
|||
#define LS_MotorParameters_Target_Position_tag 6 |
|||
#define LS_MotorParameters_Real_Position_tag 7 |
|||
#define LS_MotorParameters_Motor_Fault_tag 8 |
|||
#define LS_MotorParameters_Number_Of_Rounds_tag 9 |
|||
#define LS_MotorParameters_Start_Measuring_Position_tag 10 |
|||
#define LS_MotorParameters_Last_Real_Position_tag 11 |
|||
#define LS_MotorParameters_Real_Disatnce_tag 12 |
|||
#define LS_MotorParameters_Start_Measuring_tag 13 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define LS_MotorParameters_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, MotorID, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, Real_Current, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Current, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, Real_Velcity, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Velcity, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Position, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, Real_Position, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, Motor_Fault, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, Number_Of_Rounds, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, Start_Measuring_Position, 10) \ |
|||
X(a, STATIC, SINGULAR, INT32, Last_Real_Position, 11) \ |
|||
X(a, STATIC, SINGULAR, DOUBLE, Real_Disatnce, 12) \ |
|||
X(a, STATIC, SINGULAR, INT32, Start_Measuring, 13) |
|||
#define LS_MotorParameters_CALLBACK NULL |
|||
#define LS_MotorParameters_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t LS_MotorParameters_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define LS_MotorParameters_fields &LS_MotorParameters_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define LS_MotorParameters_size 141 |
|||
#define MSP_LS_MOTORPARAMETERS_PB_H_MAX_SIZE LS_MotorParameters_size |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "msp_MK32.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(SP_MSP_MK32_Button, SP_MSP_MK32_Button, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,99 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_MSP_MK32_PB_H_INCLUDED |
|||
#define PB_MSP_MK32_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _SP_MSP_MK32_Button { |
|||
int32_t RxIndex; |
|||
int32_t CH0_RY_H; /* 上1000，下-1000 */ |
|||
int32_t CH1_RY_V; /* 上1000，下-1000 */ |
|||
int32_t CH2_LY_V; /* 上1000，下-1000 */ |
|||
int32_t CH3_LY_H; /* 上1000，下-1000 */ |
|||
int32_t CH4_SA; /* 上-1000，下1000 */ |
|||
int32_t CH5_SB; /* 上-1000，下1000 */ |
|||
int32_t CH6_SC; /* 上-1000，下1000 */ |
|||
int32_t CH7_SD; /* 上-1000，下1000 */ |
|||
int32_t CH8_SE; /* 上-1000，下1000 */ |
|||
int32_t CH9_SF; /* 上-1000，下1000 */ |
|||
int32_t CH10_LD1; |
|||
int32_t CH11_RD1; |
|||
int32_t CH12_S1; |
|||
int32_t CH13_S2; |
|||
int32_t CH14_LT; |
|||
int32_t CH15_RT; |
|||
int32_t IsOnline; |
|||
} SP_MSP_MK32_Button; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define SP_MSP_MK32_Button_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define SP_MSP_MK32_Button_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define SP_MSP_MK32_Button_RxIndex_tag 1 |
|||
#define SP_MSP_MK32_Button_CH0_RY_H_tag 2 |
|||
#define SP_MSP_MK32_Button_CH1_RY_V_tag 3 |
|||
#define SP_MSP_MK32_Button_CH2_LY_V_tag 4 |
|||
#define SP_MSP_MK32_Button_CH3_LY_H_tag 5 |
|||
#define SP_MSP_MK32_Button_CH4_SA_tag 6 |
|||
#define SP_MSP_MK32_Button_CH5_SB_tag 7 |
|||
#define SP_MSP_MK32_Button_CH6_SC_tag 8 |
|||
#define SP_MSP_MK32_Button_CH7_SD_tag 9 |
|||
#define SP_MSP_MK32_Button_CH8_SE_tag 10 |
|||
#define SP_MSP_MK32_Button_CH9_SF_tag 11 |
|||
#define SP_MSP_MK32_Button_CH10_LD1_tag 12 |
|||
#define SP_MSP_MK32_Button_CH11_RD1_tag 13 |
|||
#define SP_MSP_MK32_Button_CH12_S1_tag 14 |
|||
#define SP_MSP_MK32_Button_CH13_S2_tag 15 |
|||
#define SP_MSP_MK32_Button_CH14_LT_tag 16 |
|||
#define SP_MSP_MK32_Button_CH15_RT_tag 17 |
|||
#define SP_MSP_MK32_Button_IsOnline_tag 18 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define SP_MSP_MK32_Button_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, RxIndex, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH0_RY_H, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH1_RY_V, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH2_LY_V, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH3_LY_H, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH4_SA, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH5_SB, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH6_SC, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH7_SD, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH8_SE, 10) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH9_SF, 11) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH10_LD1, 12) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH11_RD1, 13) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH12_S1, 14) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH13_S2, 15) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH14_LT, 16) \ |
|||
X(a, STATIC, SINGULAR, INT32, CH15_RT, 17) \ |
|||
X(a, STATIC, SINGULAR, INT32, IsOnline, 18) |
|||
#define SP_MSP_MK32_Button_CALLBACK NULL |
|||
#define SP_MSP_MK32_Button_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t SP_MSP_MK32_Button_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define SP_MSP_MK32_Button_fields &SP_MSP_MK32_Button_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define MSP_MK32_PB_H_MAX_SIZE SP_MSP_MK32_Button_size |
|||
#define SP_MSP_MK32_Button_size 201 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "msp_Motor.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(MotorParameters, MotorParameters, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,91 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_MSP_MOTOR_PB_H_INCLUDED |
|||
#define PB_MSP_MOTOR_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _MotorParameters { |
|||
int32_t MotorID; |
|||
int32_t RxIndex; |
|||
int32_t Run_Mode; |
|||
int32_t Current; |
|||
int32_t Target_Current; |
|||
int32_t Velcity; |
|||
int32_t Target_Velcity; |
|||
int32_t Position; |
|||
int32_t Target_Position; |
|||
int32_t ERROR_Flag; |
|||
int32_t Temperature_Motor; |
|||
int32_t Temperature_PCB; |
|||
int32_t AccTime; |
|||
int32_t DecTime; |
|||
int32_t EncoderOffset; /* 53 83 设置位置偏移 int32_t "设置偏移值和目标位置
|
|||
（目标位置=编码器位置 - 偏移值）" */ |
|||
} MotorParameters; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define MotorParameters_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define MotorParameters_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define MotorParameters_MotorID_tag 1 |
|||
#define MotorParameters_RxIndex_tag 2 |
|||
#define MotorParameters_Run_Mode_tag 3 |
|||
#define MotorParameters_Current_tag 4 |
|||
#define MotorParameters_Target_Current_tag 5 |
|||
#define MotorParameters_Velcity_tag 6 |
|||
#define MotorParameters_Target_Velcity_tag 7 |
|||
#define MotorParameters_Position_tag 8 |
|||
#define MotorParameters_Target_Position_tag 9 |
|||
#define MotorParameters_ERROR_Flag_tag 10 |
|||
#define MotorParameters_Temperature_Motor_tag 11 |
|||
#define MotorParameters_Temperature_PCB_tag 12 |
|||
#define MotorParameters_AccTime_tag 13 |
|||
#define MotorParameters_DecTime_tag 14 |
|||
#define MotorParameters_EncoderOffset_tag 15 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define MotorParameters_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, MotorID, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, RxIndex, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, Run_Mode, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, Current, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Current, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, Velcity, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Velcity, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, Position, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, Target_Position, 9) \ |
|||
X(a, STATIC, SINGULAR, INT32, ERROR_Flag, 10) \ |
|||
X(a, STATIC, SINGULAR, INT32, Temperature_Motor, 11) \ |
|||
X(a, STATIC, SINGULAR, INT32, Temperature_PCB, 12) \ |
|||
X(a, STATIC, SINGULAR, INT32, AccTime, 13) \ |
|||
X(a, STATIC, SINGULAR, INT32, DecTime, 14) \ |
|||
X(a, STATIC, SINGULAR, INT32, EncoderOffset, 15) |
|||
#define MotorParameters_CALLBACK NULL |
|||
#define MotorParameters_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t MotorParameters_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define MotorParameters_fields &MotorParameters_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define MSP_MOTOR_PB_H_MAX_SIZE MotorParameters_size |
|||
#define MotorParameters_size 165 |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/* Automatically generated nanopb constant definitions */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#include "msp_TL720D.pb.h" |
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
PB_BIND(MSP_TL720DParameters, MSP_TL720DParameters, AUTO) |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,72 @@ |
|||
/* Automatically generated nanopb header */ |
|||
/* Generated by nanopb-0.4.8 */ |
|||
|
|||
#ifndef PB_MSP_TL720D_PB_H_INCLUDED |
|||
#define PB_MSP_TL720D_PB_H_INCLUDED |
|||
#include "pb.h" |
|||
|
|||
#if PB_PROTO_HEADER_VERSION != 40 |
|||
#error Regenerate this file with the current version of nanopb generator. |
|||
#endif |
|||
|
|||
/* Struct definitions */ |
|||
typedef struct _MSP_TL720DParameters { |
|||
int32_t RF_Angle_Roll; /* 横滚角 */ |
|||
int32_t RF_Angle_Pitch; /* 俯仰角 */ |
|||
int32_t RF_Angle_Yaw; /* 航向角 */ |
|||
int32_t RF_Acc_X; /* X轴加速度 */ |
|||
int32_t RF_Acc_Y; /* Y轴加速度 */ |
|||
int32_t RF_Acc_Z; /* Z轴加速度 */ |
|||
int32_t RF_Gro_X; /* X轴陀螺 */ |
|||
int32_t RF_Gro_Y; /* Y轴陀螺 */ |
|||
int32_t RF_Gro_Z; /* Z轴陀螺 */ |
|||
} MSP_TL720DParameters; |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Initializer values for message structs */ |
|||
#define MSP_TL720DParameters_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
#define MSP_TL720DParameters_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0} |
|||
|
|||
/* Field tags (for use in manual encoding/decoding) */ |
|||
#define MSP_TL720DParameters_RF_Angle_Roll_tag 1 |
|||
#define MSP_TL720DParameters_RF_Angle_Pitch_tag 2 |
|||
#define MSP_TL720DParameters_RF_Angle_Yaw_tag 3 |
|||
#define MSP_TL720DParameters_RF_Acc_X_tag 4 |
|||
#define MSP_TL720DParameters_RF_Acc_Y_tag 5 |
|||
#define MSP_TL720DParameters_RF_Acc_Z_tag 6 |
|||
#define MSP_TL720DParameters_RF_Gro_X_tag 7 |
|||
#define MSP_TL720DParameters_RF_Gro_Y_tag 8 |
|||
#define MSP_TL720DParameters_RF_Gro_Z_tag 9 |
|||
|
|||
/* Struct field encoding specification for nanopb */ |
|||
#define MSP_TL720DParameters_FIELDLIST(X, a) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Angle_Roll, 1) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Angle_Pitch, 2) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Angle_Yaw, 3) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Acc_X, 4) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Acc_Y, 5) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Acc_Z, 6) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Gro_X, 7) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Gro_Y, 8) \ |
|||
X(a, STATIC, SINGULAR, INT32, RF_Gro_Z, 9) |
|||
#define MSP_TL720DParameters_CALLBACK NULL |
|||
#define MSP_TL720DParameters_DEFAULT NULL |
|||
|
|||
extern const pb_msgdesc_t MSP_TL720DParameters_msg; |
|||
|
|||
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */ |
|||
#define MSP_TL720DParameters_fields &MSP_TL720DParameters_msg |
|||
|
|||
/* Maximum encoded size of messages (where known) */ |
|||
#define MSP_TL720DParameters_size 99 |
|||
#define MSP_TL720D_PB_H_MAX_SIZE MSP_TL720DParameters_size |
|||
|
|||
#ifdef __cplusplus |
|||
} /* extern "C" */ |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,42 @@ |
|||
syntax = "proto3"; |
|||
//import "nanopb.proto"; |
|||
|
|||
import "bsp_PV.proto"; |
|||
import "bsp_PID.proto"; |
|||
message CV_struct_define{ |
|||
|
|||
//喷漆项目 |
|||
|
|||
int32 Speed_m_per_min = 1; // MPMin = 1m/min 1米每分钟 m/min |
|||
|
|||
int32 LeftTurnSpeed = 2; |
|||
int32 RightTurnSpeed = 3; |
|||
|
|||
|
|||
|
|||
int32 RobotLeftAngleValue=4;// 水平左方向 单位0.01° |
|||
int32 RobotRightAngleValue=5;// 水平右方向角度值 单位0.01° |
|||
int32 RobotUpAngleValue=6;// 竖直方向角度值 单位0.01° |
|||
int32 RobotDownAngleValue=7;// 竖直向下角度值 单位0.01° |
|||
|
|||
int32 Robot_Permitted_Angler_Error_Value_E_2D = 8;// 作业时需用的最大角度偏差值 0.01°，超出将停止作业 |
|||
int32 Robot_Angle_Start_BaseE_2D = 9;//角度值 0.01° |
|||
int32 Lane_Change_Speed_m_per_min = 10; |
|||
int32 Is_Automation_Authorized = 11; |
|||
int32 Is_Function_Authorized = 12; |
|||
int32 Joy_Sticker_Angle_Allowance = 13;// 例如在90度的±30° |
|||
int32 Joy_Sticker_Value_Allowance = 14;//例如 joysticker的值超过600 |
|||
int32 Allowable_Error_For_Angle_Tracking = 15;//纠偏角度跟踪的允许误差1 度 |
|||
int32 Paint_Gun_Shutdown_Distance = 16;//喷枪关闭距离，喷枪关闭后多上厘米停止运行 |
|||
int32 Horizontal_ChangeLane_Compensation=17; //水平换道补偿距离 |
|||
int32 Vertical_ChangeLane_Compensation=18; //竖直换道补偿距离 |
|||
int32 pulse_Per_Circle=19; //每转多少脉冲 |
|||
int32 wheel_Reduction_Ratio=20; //减速比 |
|||
double wheel_Diameter_m=21; //车轮直径 m |
|||
PID_Parameters PID_high=22; |
|||
PID_Parameters PID_mid=23; |
|||
PID_Parameters PID_low=24; |
|||
|
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,2 @@ |
|||
# lock.options |
|||
Cmd.Buff_Data max_size:512 fixed_length:true |
|||
@ -0,0 +1,24 @@ |
|||
syntax = "proto3"; |
|||
//this message is used for the computer to send command |
|||
message Cmd{ |
|||
int32 CommadNum = 1; |
|||
//定义 1 上位机获取默认CV值 |
|||
//定义 2 下位机返回CV值 |
|||
//定义 3 上位机设定CV值 |
|||
//定义 4 上位机设定Trace等级值，无返回 |
|||
//定义 5 下位机上传位置点数据 |
|||
//定义 6 上位机设定编码器角度值为0 |
|||
//定义 7 上位机获取拟合点 |
|||
//定义 8 上位机获取位置点 |
|||
//定义 9 上位机向下位机下发程序 此时，Parameter0 下发的程序起始位，Parameter0 是校验位 |
|||
//Buff_Data_Length 是下发的字节数， |
|||
int32 Parameter0 = 2; |
|||
int32 Parameter1 = 3; |
|||
int32 Parameter2 = 4; |
|||
int32 Parameter3 = 5; |
|||
int32 Parameter4 = 6; |
|||
int32 Buff_Data_Length = 7; |
|||
bytes Buff_Data=8; |
|||
|
|||
}; |
|||
|
|||
@ -0,0 +1,25 @@ |
|||
syntax = "proto3"; |
|||
|
|||
option java_multiple_files = false; |
|||
option java_package = "com.example.paintapp.models"; |
|||
|
|||
message ErrorData |
|||
{ |
|||
int32 Com_Error_Code=1; |
|||
int32 Left_Motor_Error_Code=2; |
|||
int32 Right_Motor_Error_Code=3; |
|||
|
|||
} |
|||
|
|||
enum ComError //枚举消息类型 Error Bit Define |
|||
{ |
|||
MK32_SBus = 0; |
|||
TL720D = 1; |
|||
LS_LeftMotor = 2; |
|||
LS_RightMotor = 3; |
|||
Remote_Button_Reset_State = 4; |
|||
MK32_Serial=5; |
|||
MK32_UDP=6; |
|||
} |
|||
|
|||
//protoc --nanopb_out=. *.proto |
|||
@ -0,0 +1,2 @@ |
|||
# lock.options |
|||
GV_struct_define.Motor_P max_size:50 fixed_length:true |
|||
@ -0,0 +1,29 @@ |
|||
syntax = "proto3"; |
|||
import "msp_MK32.proto"; |
|||
import "msp_Motor.proto"; |
|||
import "msp_LS_MotorParameters.proto"; |
|||
import "msp_TL720D.proto"; |
|||
import "bsp_Error.proto"; |
|||
import "bsp_PV.proto"; |
|||
import "bsp_IO.proto"; |
|||
|
|||
message GV_struct_define |
|||
{ |
|||
int32 TempatureE_2C= 1; // E_2C=0.01 Celsius 0.01摄氏度 |
|||
int32 Left_Compensation= 2; // E_2D =0.01 Degree 0.01度 |
|||
int32 Right_Compensation= 3; //0.01度 |
|||
int32 Robot_Angle=4; //机器人角度 //0.01度 |
|||
int32 Robot_Move_Speed= 5; // 0.1rpm |
|||
int32 ForceValue= 6; |
|||
int32 LaneChangeDistance= 7; |
|||
SP_MSP_MK32_Button P_MK32=9; |
|||
LS_MotorParameters LeftMotor=10;//左电机 ID2 |
|||
LS_MotorParameters RightMotor=11;// 右电机 ID3 |
|||
MSP_TL720DParameters TL720DParameters= 12; |
|||
IO_Data IO=13; |
|||
ErrorData SystemErrorData=14; |
|||
PV_struct_define PV =15;//用户配置数据 |
|||
|
|||
}; |
|||
|
|||
//protoc --nanopb_out=. *.proto |
|||
@ -0,0 +1,2 @@ |
|||
# lock.options |
|||
# IAP_struct_define.Buff_Data max_size:64 fixed_length:true |
|||
@ -0,0 +1,11 @@ |
|||
syntax = "proto3"; |
|||
//IAP，即In Application Programming，IAP是用户自己的程序在运行过程中对User Flash的部分区域进行烧写。 |
|||
message IAP_struct_define |
|||
{ |
|||
int32 Total_Bytes = 1;// all the received data; |
|||
int32 NextCodeVrsion = 2;//the New upgrade Version of the Project |
|||
int32 UtcTime=3;//Udgrade Time |
|||
int32 UpgradeSucceeded=4;// |
|||
|
|||
}; |
|||
|
|||
@ -0,0 +1,19 @@ |
|||
syntax = "proto3"; |
|||
|
|||
message IO_Data |
|||
{ |
|||
int32 DO0=1; |
|||
int32 DO1=2; |
|||
int32 DO2=3; |
|||
int32 DO3=4; |
|||
int32 DO4=5; |
|||
int32 DO5=6; |
|||
int32 DI0=7; |
|||
int32 DI1=8; |
|||
int32 DI2=9; |
|||
int32 DI3=10; |
|||
int32 DI4=11; |
|||
int32 DI5=12; |
|||
}; |
|||
|
|||
//protoc --nanopb_out=. *.proto |
|||
@ -0,0 +1,18 @@ |
|||
syntax = "proto3"; |
|||
|
|||
option java_multiple_files = false; |
|||
option java_package = "com.example.paintapp.models"; |
|||
|
|||
message IV_struct_define |
|||
{ |
|||
int32 CurrentAngle= 1; //单位0.01° |
|||
int32 RobotMoveSpeed= 2; //单位m/min 目标速度 |
|||
int32 SBUS_State=3; //0断开 1连接 |
|||
int32 SystemError=4; //硬件通讯错误及按键未初始化错误 |
|||
int32 Left_Motor_Err=5;//左轮电机报警 |
|||
int32 Right_Motor_Err=6;//右轮电机报警 |
|||
int32 IsWorking=7;//机器人正在执行运动指令 |
|||
int32 CurrentSpeed=8;//当前速度 |
|||
int64 TimeStamp=9;//当前时间戳 |
|||
int32 IsRestart=10;//是否重启 |
|||
}; |
|||
@ -0,0 +1,9 @@ |
|||
syntax = "proto3"; |
|||
|
|||
message PID_Parameters { |
|||
int32 PID_Angle=1; //调整 单位0.01° 配置时需要*100 |
|||
double Kp=2; //PID参数 |
|||
double Ki=3; |
|||
double Kd=4; |
|||
|
|||
} |
|||
@ -0,0 +1,15 @@ |
|||
syntax = "proto3"; |
|||
option java_multiple_files = false; |
|||
option java_package = "com.example.paintapp.models"; |
|||
message PV_struct_define{ |
|||
|
|||
// 喷漆项目 |
|||
int32 RunMode = 1; //1 手动无校准作业 2 手动竖直向左作业 3 手动竖直向右作业 |
|||
int32 RobotSpeed=2;//0-30m/min |
|||
int32 LaneChangeDistance= 3;//1-100cm |
|||
double Vertical_Calibration=4;// 1° |
|||
int32 IV_IsRestart_Notified=5;// 是否接收到IV restart flag |
|||
int64 TimeStamp=6;// |
|||
|
|||
|
|||
}; |
|||
@ -0,0 +1,2 @@ |
|||
# lock.options |
|||
ReCmd.Buff_Data max_size:512 fixed_length:true |
|||
@ -0,0 +1,24 @@ |
|||
syntax = "proto3"; |
|||
//this message is used for the reply the command |
|||
message ReCmd{ |
|||
int32 CommadNum = 1; |
|||
//定义 1 上位机获取默认CV值 |
|||
//定义 2 下位机返回CV值 |
|||
//定义 3 上位机设定CV值 |
|||
//定义 4 上位机设定Trace等级值，无返回 |
|||
//定义 5 下位机上传位置点数据 |
|||
//定义 6 上位机设定编码器角度值为0 |
|||
//定义 7 上位机获取拟合点 |
|||
//定义 8 上位机获取位置点 |
|||
//定义 9 上位机向下位机下发程序 此时，Parameter0 下发的程序起始位，Parameter0 是校验位 |
|||
//Buff_Data_Length 是下发的字节数， |
|||
int32 Parameter0 = 2; |
|||
int32 Parameter1 = 3; |
|||
int32 Parameter2 = 4; |
|||
int32 Parameter3 = 5; |
|||
int32 Parameter4 = 6; |
|||
int32 Buff_Data_Length = 7; |
|||
bytes Buff_Data=8; |
|||
|
|||
}; |
|||
|
|||
@ -0,0 +1,19 @@ |
|||
syntax = "proto3"; |
|||
|
|||
message LS_MotorParameters { |
|||
int32 MotorID=1; |
|||
int32 Real_Current=2; |
|||
int32 Target_Current=3; // 0.1rpm |
|||
int32 Real_Velcity=4; // 0.1rpm |
|||
int32 Target_Velcity=5; // 0.1rpm |
|||
int32 Target_Position=6; // 0.1rpm |
|||
int32 Real_Position=7; |
|||
int32 Motor_Fault=8; |
|||
int32 Number_Of_Rounds=9; |
|||
int32 Start_Measuring_Position=10; |
|||
int32 Last_Real_Position=11; |
|||
double Real_Disatnce=12; |
|||
int32 Start_Measuring=13;//开始测距 |
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,22 @@ |
|||
syntax = "proto3"; |
|||
|
|||
message SP_MSP_MK32_Button { |
|||
int32 RxIndex= 1; |
|||
int32 CH0_RY_H= 2;//上1000，下-1000 |
|||
int32 CH1_RY_V= 3; //上1000，下-1000 |
|||
int32 CH2_LY_V= 4;//上1000，下-1000 |
|||
int32 CH3_LY_H= 5;//上1000，下-1000 |
|||
int32 CH4_SA= 6;//上-1000，下1000 |
|||
int32 CH5_SB= 7;//上-1000，下1000 |
|||
int32 CH6_SC= 8;//上-1000，下1000 |
|||
int32 CH7_SD= 9;//上-1000，下1000 |
|||
int32 CH8_SE= 10;//上-1000，下1000 |
|||
int32 CH9_SF= 11;//上-1000，下1000 |
|||
int32 CH10_LD1= 12; |
|||
int32 CH11_RD1= 13; |
|||
int32 CH12_S1= 14; |
|||
int32 CH13_S2= 15; |
|||
int32 CH14_LT= 16; |
|||
int32 CH15_RT= 17; |
|||
int32 IsOnline= 18; |
|||
} |
|||
@ -0,0 +1,23 @@ |
|||
syntax = "proto3"; |
|||
|
|||
message MotorParameters{ |
|||
int32 MotorID=1; |
|||
int32 RxIndex=2; |
|||
int32 Run_Mode=3; |
|||
int32 Current=4; |
|||
int32 Target_Current=5; |
|||
int32 Velcity=6; |
|||
int32 Target_Velcity=7; |
|||
int32 Position=8; |
|||
int32 Target_Position=9; |
|||
int32 ERROR_Flag=10; |
|||
int32 Temperature_Motor=11; |
|||
int32 Temperature_PCB=12; |
|||
int32 AccTime=13; |
|||
int32 DecTime=14; |
|||
int32 EncoderOffset=15; |
|||
//53 83 设置位置偏移 int32_t "设置偏移值和目标位置 |
|||
//（目标位置=编码器位置 - 偏移值）" |
|||
|
|||
}; |
|||
|
|||
@ -0,0 +1,20 @@ |
|||
syntax = "proto3"; |
|||
//import "nanopb.proto"; |
|||
|
|||
message MSP_TL720DParameters{ |
|||
|
|||
int32 RF_Angle_Roll=1; /*横滚角*/ |
|||
int32 RF_Angle_Pitch=2; /*俯仰角*/ |
|||
int32 RF_Angle_Yaw=3; /*航向角*/ |
|||
|
|||
int32 RF_Acc_X=4; /*X轴加速度*/ |
|||
int32 RF_Acc_Y=5; /*Y轴加速度*/ |
|||
int32 RF_Acc_Z=6; /*Z轴加速度*/ |
|||
|
|||
int32 RF_Gro_X=7; /*X轴陀螺*/ |
|||
int32 RF_Gro_Y=8; /*Y轴陀螺*/ |
|||
int32 RF_Gro_Z=9; /*Z轴陀螺*/ |
|||
|
|||
|
|||
}; |
|||
|
|||
Loading…
Reference in new issue