From e0f5da6f392ab1a47d45d1dc73b761b0ad85d8b3 Mon Sep 17 00:00:00 2001
From: Wuchuyuan <1917507415@qq.com>
Date: Tue, 25 Aug 2026 10:20:14 +0800
Subject: [PATCH] =?UTF-8?q?=E6=8A=8A=E9=9D=99=E6=80=81=E5=BA=93=E6=8D=A2?=
=?UTF-8?q?=E6=88=90=E6=BA=90=E7=A0=81=E6=96=B9=E4=BE=BF=E8=B0=83=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
AC701N.cbp | 19 +-
Makefile | 18 +-
.../bt_trans_data/le_rcsp_adv_module.c | 2 +-
apps/usr_le_code/ble_proto.c | 245 ++
apps/usr_le_code/ble_proto.h | 133 +
apps/usr_le_code/bleproto.c | 529 +++
apps/usr_le_code/bleproto.h | 53 +
apps/usr_le_code/bleproto_api.h | 303 ++
apps/usr_le_code/bleproto_packer.c | 3054 +++++++++++++++++
apps/usr_le_code/bleproto_packer.h | 702 ++++
apps/usr_le_code/lib/libusr_le_code.a | Bin 257070 -> 0 bytes
apps/usr_le_code/thirdpart/mjson/mjson.c | 1066 ++++++
apps/usr_le_code/thirdpart/mjson/mjson.h | 220 ++
apps/usr_le_code/usr_le_adv.c | 340 ++
apps/usr_le_code/usr_le_api.h | 7 +-
apps/usr_le_code/usr_le_product.h | 2 +-
apps/usr_le_code/usr_le_recieve.c | 377 ++
tools/package_release.py | 27 +-
18 files changed, 7061 insertions(+), 36 deletions(-)
create mode 100644 apps/usr_le_code/ble_proto.c
create mode 100644 apps/usr_le_code/ble_proto.h
create mode 100644 apps/usr_le_code/bleproto.c
create mode 100644 apps/usr_le_code/bleproto.h
create mode 100644 apps/usr_le_code/bleproto_api.h
create mode 100644 apps/usr_le_code/bleproto_packer.c
create mode 100644 apps/usr_le_code/bleproto_packer.h
delete mode 100644 apps/usr_le_code/lib/libusr_le_code.a
create mode 100644 apps/usr_le_code/thirdpart/mjson/mjson.c
create mode 100644 apps/usr_le_code/thirdpart/mjson/mjson.h
create mode 100644 apps/usr_le_code/usr_le_adv.c
create mode 100644 apps/usr_le_code/usr_le_recieve.c
diff --git a/AC701N.cbp b/AC701N.cbp
index dcbec0d..784ddae 100644
--- a/AC701N.cbp
+++ b/AC701N.cbp
@@ -259,7 +259,6 @@
-
@@ -797,13 +796,31 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Makefile b/Makefile
index bb80165..b2bde9f 100644
--- a/Makefile
+++ b/Makefile
@@ -625,11 +625,12 @@ c_SRC_FILES := \
apps/usr_periph/bsp_hw.c \
apps/usr_app/app_led.c \
apps/usr_app/app_mode.c \
-
-
-# usr_le_code 预编译静态库（Release 不附带协议源码，禁止本地重建）
-USR_LE_LIB := apps/usr_le_code/lib/libusr_le_code.a
-
+ apps/usr_le_code/ble_proto.c \
+ apps/usr_le_code/bleproto.c \
+ apps/usr_le_code/bleproto_packer.c \
+ apps/usr_le_code/thirdpart/mjson/mjson.c \
+ apps/usr_le_code/usr_le_adv.c \
+ apps/usr_le_code/usr_le_recieve.c \
# 需要编译的 .S 文件
@@ -733,7 +734,6 @@ LFLAGS := \
cpu/br28/liba/libllns.a \
cpu/br28/liba/libkwscommon.a \
apps/common/third_party_profile/tuya_protocol/sdk/lib/libtuya_lib.a \
- apps/usr_le_code/lib/libusr_le_code.a \
cpu/br28/liba/lib_icsd_adt.a \
cpu/br28/liba/lib_diafx.a \
cpu/br28/liba/libFFT_pi32v2_OnChip.a \
@@ -798,7 +798,7 @@ LINK_AT ?= 1
# see: https://www.gnu.org/software/make/manual/html_node/Suffix-Rules.html
.SUFFIXES:
-all: pre_build $(USR_LE_LIB) $(OUT_ELF)
+all: pre_build $(OUT_ELF)
$(info +POST-BUILD)
$(QUITE) $(RUN_POST_SCRIPT) sdk
@@ -818,13 +818,13 @@ clean:
ifeq ($(LINK_AT), 1)
-$(OUT_ELF): $(OBJS) $(USR_LE_LIB)
+$(OUT_ELF): $(OBJS)
$(info +LINK $@)
$(shell $(MKDIR) $(@D))
$(file >$(OBJ_FILE), $(OBJS))
$(QUITE) $(LD) -o $(OUT_ELF) @$(OBJ_FILE) $(LFLAGS) $(LIBPATHS) $(LIBS)
else
-$(OUT_ELF): $(OBJS) $(USR_LE_LIB)
+$(OUT_ELF): $(OBJS)
$(info +LINK $@)
$(shell $(MKDIR) $(@D))
$(QUITE) $(LD) -o $(OUT_ELF) $(OBJS) $(LFLAGS) $(LIBPATHS) $(LIBS)
diff --git a/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c b/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c
index 0edd9c6..897a5b6 100644
--- a/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c
+++ b/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c
@@ -57,7 +57,7 @@
#include "chgbox_box.h"
#endif
-/* usr_le_code 库钩子：由静态库导出，供 RCSP BLE 栈回调，非应用层公开 API */
+/* usr_le_code 钩子：由 usr_le_code 导出，供 RCSP BLE 栈回调，非应用层公开 API */
extern void usr_le_data_recieve(u8* data,u16 len);
extern void usr_ble_adv_init();
#if 1
diff --git a/apps/usr_le_code/ble_proto.c b/apps/usr_le_code/ble_proto.c
new file mode 100644
index 0000000..e5b71cd
--- /dev/null
+++ b/apps/usr_le_code/ble_proto.c
@@ -0,0 +1,245 @@
+/**
+ * @file ble_proto.c
+ * @brief BLE-网关通信协议 V1.3 序列化 / 反序列化实现
+ *
+ * 结构：
+ * [Cmd:2][Reserved:4][gateway_int_cnt:1][gateway_int32[]:4*N]
+ * [device_int_len:2][device_str_len:2][device_bytes_len:2]
+ * [Payload][CRC16:2]
+ *
+ * CRC 计算范围：Cmd ~ Payload 末尾（整个包除 CRC 字段）
+ */
+
+#include "ble_proto.h"
+#include
+
+/* -----------------------------------------------------------------------
+ * 内部辅助：Big Endian 读写
+ * --------------------------------------------------------------------- */
+
+/** 写入 uint16_t（Big Endian） */
+static inline void put_be16(uint8_t *p, uint16_t v)
+{
+ p[0] = (uint8_t)(v >> 8);
+ p[1] = (uint8_t)(v & 0xFFu);
+}
+
+/** 写入 uint32_t（Big Endian） */
+static inline void put_be32(uint8_t *p, uint32_t v)
+{
+ p[0] = (uint8_t)(v >> 24);
+ p[1] = (uint8_t)((v >> 16) & 0xFFu);
+ p[2] = (uint8_t)((v >> 8) & 0xFFu);
+ p[3] = (uint8_t)( v & 0xFFu);
+}
+
+/** 读取 uint16_t（Big Endian） */
+static inline uint16_t get_be16(const uint8_t *p)
+{
+ return (uint16_t)(((uint16_t)p[0] << 8) | p[1]);
+}
+
+/** 读取 uint32_t（Big Endian） */
+static inline uint32_t get_be32(const uint8_t *p)
+{
+ return ((uint32_t)p[0] << 24)
+ | ((uint32_t)p[1] << 16)
+ | ((uint32_t)p[2] << 8)
+ | (uint32_t)p[3];
+}
+
+/* -----------------------------------------------------------------------
+ * CRC16（多项式 0x8005，初值 0xFFFF —— MODBUS 变体）
+ * --------------------------------------------------------------------- */
+uint16_t ble_proto_crc16(const uint8_t *data, size_t len)
+{
+ uint16_t crc = 0xFFFFu;
+ for (size_t i = 0; i < len; i++) {
+ crc ^= (uint16_t)data[i];
+ for (int bit = 0; bit < 8; bit++) {
+ if (crc & 0x0001u) {
+ crc = (crc >> 1) ^ 0xA001u;
+ } else {
+ crc >>= 1;
+ }
+ }
+ }
+ return crc;
+}
+
+/* -----------------------------------------------------------------------
+ * 序列化（pack）
+ * --------------------------------------------------------------------- */
+int ble_proto_pack(const ble_proto_packet_t *pkt, uint8_t *buf, size_t buf_size)
+{
+ if (!pkt || !buf) return BLE_PROTO_ERR_NULL;
+
+ /* ----- 参数合法性检查 ----- */
+ if (pkt->gateway_int_cnt > BLE_PROTO_GW_INT_MAX) return BLE_PROTO_ERR_GW_CNT;
+ if (pkt->device_int_len % 4 != 0) return BLE_PROTO_ERR_INT_ALIGN;
+
+ /* ----- 计算所需总长度 ----- */
+ size_t payload_len = (size_t)pkt->device_int_len
+ + (size_t)pkt->device_str_len
+ + (size_t)pkt->device_bytes_len;
+
+ size_t total = BLE_PROTO_HEADER_LEN /* Cmd(2) + Reserved(4) */
+ + BLE_PROTO_GW_CNT_LEN /* gateway_int_cnt (1) */
+ + (size_t)pkt->gateway_int_cnt * 4u /* gateway_int[] */
+ + BLE_PROTO_DEV_PARAM_LEN /* 3 x device_*_len */
+ + payload_len /* Payload */
+ + BLE_PROTO_CRC_LEN; /* CRC16 */
+
+ if (buf_size < total) return BLE_PROTO_ERR_BUF_SMALL;
+
+ uint8_t *p = buf;
+
+ /* ----- Protocol Header ----- */
+ put_be16(p, pkt->cmd); p += 2;
+ put_be32(p, 0); p += 4; /* Reserved 固定填 0 */
+
+ /* ----- Gateway Parameter ----- */
+ *p++ = pkt->gateway_int_cnt; /* uint8 */
+ for (uint8_t i = 0; i < pkt->gateway_int_cnt; i++) {
+ put_be32(p, (uint32_t)pkt->gateway_int[i]);
+ p += 4;
+ }
+
+ /* ----- Device Parameter ----- */
+ put_be16(p, pkt->device_int_len); p += 2;
+ put_be16(p, pkt->device_str_len); p += 2;
+ put_be16(p, pkt->device_bytes_len); p += 2;
+
+ /* ----- Payload ----- */
+ if (pkt->device_int_len > 0 && pkt->int_data) {
+ for (uint16_t i = 0; i < pkt->device_int_len / 4u; i++) {
+ put_be32(p, (uint32_t)pkt->int_data[i]);
+ p += 4;
+ }
+ }
+ if (pkt->device_str_len > 0 && pkt->str_data) {
+ memcpy(p, pkt->str_data, pkt->device_str_len);
+ p += pkt->device_str_len;
+ }
+ if (pkt->device_bytes_len > 0 && pkt->bytes_data) {
+ memcpy(p, pkt->bytes_data, pkt->device_bytes_len);
+ p += pkt->device_bytes_len;
+ }
+
+ /* ----- CRC16（从 buf[0] 开始，到 Payload 末尾） ----- */
+ uint16_t crc = ble_proto_crc16(buf, (size_t)(p - buf));
+ put_be16(p, crc);
+ p += 2;
+
+
+ return (int)(p - buf);
+}
+
+/* -----------------------------------------------------------------------
+ * 反序列化（unpack）
+ * --------------------------------------------------------------------- */
+int ble_proto_unpack(const uint8_t *buf, size_t len, ble_proto_packet_t *pkt)
+{
+ if (!buf || !pkt) return BLE_PROTO_ERR_NULL;
+
+ /* 最小包长：Header(6) + gw_cnt(1) + dev_param(6) + CRC(2) = 15 */
+ const size_t min_len = BLE_PROTO_HEADER_LEN
+ + BLE_PROTO_GW_CNT_LEN
+ + BLE_PROTO_DEV_PARAM_LEN
+ + BLE_PROTO_CRC_LEN;
+ if (len < min_len) return BLE_PROTO_ERR_LEN;
+
+ const uint8_t *p = buf;
+
+ /* ----- Protocol Header ----- */
+ pkt->cmd = get_be16(p); p += 2;
+ pkt->reserved = get_be32(p); p += 4;
+
+ /* ----- Gateway Parameter ----- */
+ pkt->gateway_int_cnt = *p++;
+ if (pkt->gateway_int_cnt > BLE_PROTO_GW_INT_MAX) return BLE_PROTO_ERR_GW_CNT;
+
+ /* 检查剩余字节是否足够容纳 gateway_int[] + dev_param + CRC */
+ size_t consumed = (size_t)(p - buf)
+ + (size_t)pkt->gateway_int_cnt * 4u
+ + BLE_PROTO_DEV_PARAM_LEN
+ + BLE_PROTO_CRC_LEN;
+ if (len < consumed) return BLE_PROTO_ERR_LEN;
+
+ for (uint8_t i = 0; i < pkt->gateway_int_cnt; i++) {
+ pkt->gateway_int[i] = (int32_t)get_be32(p);
+ p += 4;
+ }
+
+ /* ----- Device Parameter ----- */
+ pkt->device_int_len = get_be16(p); p += 2;
+ pkt->device_str_len = get_be16(p); p += 2;
+ pkt->device_bytes_len = get_be16(p); p += 2;
+
+ if (pkt->device_int_len % 4 != 0) return BLE_PROTO_ERR_INT_ALIGN;
+
+ size_t payload_len = (size_t)pkt->device_int_len
+ + (size_t)pkt->device_str_len
+ + (size_t)pkt->device_bytes_len;
+
+ /* 验证总长度（含 CRC） */
+ if ((size_t)(p - buf) + payload_len + BLE_PROTO_CRC_LEN != len) {
+ return BLE_PROTO_ERR_LEN;
+ }
+
+ /* ----- CRC16 校验（从 buf[0] 到 CRC 前一字节） ----- */
+ uint16_t crc_calc = ble_proto_crc16(buf, len - BLE_PROTO_CRC_LEN);
+ uint16_t crc_recv = get_be16(buf + len - BLE_PROTO_CRC_LEN);
+ if (crc_calc != crc_recv) return BLE_PROTO_ERR_CRC;
+
+ /* ----- Payload（零拷贝，直接指向 buf 内部） ----- */
+ if (pkt->device_int_len > 0) {
+ pkt->int_data = (const int32_t *)p;
+ } else {
+ pkt->int_data = NULL;
+ }
+ p += pkt->device_int_len;
+
+ pkt->str_data = (pkt->device_str_len > 0) ? (const char *)p : NULL;
+ p += pkt->device_str_len;
+
+ pkt->bytes_data = (pkt->device_bytes_len > 0) ? p : NULL;
+
+ // printf("cmd = %d", pkt->cmd);
+ // printf("reserved = %d", pkt->reserved);
+ // printf("gateway_int_cnt = %d", pkt->gateway_int_cnt);
+ // printf("device_int_len = %d", pkt->device_int_len);
+ // printf("device_str_len = %d", pkt->device_str_len);
+ // printf("device_bytes_len = %d", pkt->device_bytes_len);
+
+ // /* int_data 指向 buf 内部，地址未必 4 字节对齐，
+ // * 不能直接解引用 int32_t*（对齐访问会触发硬件异常）；
+ // * 必须按字节读取，用 get_be32 还原数值 */
+ // if (pkt->int_data && pkt->device_int_len >= 4) {
+ // const uint8_t *ip = (const uint8_t *)pkt->int_data;
+ // printf("int_data = ");
+ // for (uint16_t i = 0; i < pkt->device_int_len / 4u; i++) {
+ // printf("%08X ", (unsigned int)get_be32(ip + (uint32_t)i * 4u));
+ // }
+ // printf("\n");
+ // }
+ // /* str_data / bytes_data 不保证有 '\0'，用 printf_buf 打印 hex */
+ // if (pkt->str_data && pkt->device_str_len > 0) {
+ // printf("str_data = ");
+ // for (size_t i = 0; i < pkt->device_str_len; i++) {
+ // printf("%02X ", *(pkt->str_data + i));
+ // }
+ // printf("\n");
+ // }
+ // if (pkt->bytes_data && pkt->device_bytes_len > 0) {
+ // printf("bytes_data = ");
+ // for (size_t i = 0; i < pkt->device_bytes_len; i++) {
+ // printf("%02X ", *(pkt->bytes_data + i));
+ // }
+ // printf("\n");
+ // }
+ // printf("crc = %04X", crc_recv);
+ // printf("\n");
+
+ return BLE_PROTO_OK;
+}
diff --git a/apps/usr_le_code/ble_proto.h b/apps/usr_le_code/ble_proto.h
new file mode 100644
index 0000000..7ac15d7
--- /dev/null
+++ b/apps/usr_le_code/ble_proto.h
@@ -0,0 +1,133 @@
+/**
+ * @file ble_proto.h
+ * @brief BLE-网关通信协议 V1.3 序列化 / 反序列化接口
+ *
+ * 数据包结构（Big Endian）：
+ * [Cmd:2][Reserved:4]
+ * [gateway_int_cnt:1][gateway_int32[]:4*N]
+ * [device_int_len:2][device_str_len:2][device_bytes_len:2]
+ * [Payload: int_data | str_data | bytes_data]
+ * [CRC16:2]
+ *
+ * 当前协议头（固定 6 字节）：[Cmd:2][Reserved:4]
+ * （说明：本文件早期 V1.2 草案曾在 Cmd 后加入 8 字节时间戳 t，
+ * 现设备侧不再使用，已从线格式中彻底移除。）
+ *
+ * V1.1 变更（相对 V1.0）：
+ * - 删除 Magic、Version、Seq 字段
+ * - 新增 Reserved（uint32，固定填 0）
+ * - Cmd 移至偏移 0
+ * - gateway_int_cnt 由 uint16 调整为 uint8
+ * - CRC 计算范围：Cmd ~ Payload 末尾（整个包除 CRC 字段本身）
+ */
+
+#ifndef BLE_PROTO_H
+#define BLE_PROTO_H
+
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -----------------------------------------------------------------------
+ * 协议常量
+ * --------------------------------------------------------------------- */
+
+/** Header 固定长度：Cmd(2) + Reserved(4) = 6 Bytes */
+#define BLE_PROTO_HEADER_LEN 6u
+
+/** gateway_int_cnt 字段长度（uint8） */
+#define BLE_PROTO_GW_CNT_LEN 1u
+
+/** Device Parameter 固定长度：3 x uint16 = 6 Bytes */
+#define BLE_PROTO_DEV_PARAM_LEN 6u
+
+/** CRC16 字段长度 */
+#define BLE_PROTO_CRC_LEN 2u
+
+/** 最大 Gateway int32 参数个数（防御性上限，可按需修改） */
+#define BLE_PROTO_GW_INT_MAX 16u
+
+/** 最大 Payload 总长度（按实际业务调整） */
+#define BLE_PROTO_PAYLOAD_MAX 2048u
+
+/* -----------------------------------------------------------------------
+ * 报文数据包（解包后的逻辑结构）
+ * --------------------------------------------------------------------- */
+typedef struct {
+ /* ----- Protocol Header ----- */
+ uint16_t cmd; /**< 协议命令（上报、控制、应答、OTA等） */
+ uint32_t reserved; /**< 保留字段，发送端固定填 0 */
+
+ /* ----- Gateway Parameter ----- */
+ uint8_t gateway_int_cnt; /**< Gateway int32 参数个数 */
+ int32_t gateway_int[BLE_PROTO_GW_INT_MAX]; /**< Gateway int32 参数列表 */
+
+ /* ----- Device Parameter ----- */
+ uint16_t device_int_len; /**< Payload 中 int 数据字节数（必须是 4 的整数倍） */
+ uint16_t device_str_len; /**< Payload 中 string 数据字节数（不含 '\0'） */
+ uint16_t device_bytes_len; /**< Payload 中 bytes 数据字节数 */
+
+ /* ----- Payload 数据指针（指向外部 buffer，不拥有所有权） ----- */
+ const int32_t *int_data; /**< Device Int 数据（pack 输入为主机序 int32 数组，ble_proto_pack 内部逐元素 put_be32 转 BE；unpack 输出为 buf 内原始 BE 字节，调用方须用 get_be32 读取，不可直接解引用） */
+ const char *str_data; /**< Device String 数据（不含 '\0'） */
+ const uint8_t *bytes_data; /**< Device Bytes 数据 */
+} ble_proto_packet_t;
+
+/* -----------------------------------------------------------------------
+ * 错误码
+ * --------------------------------------------------------------------- */
+typedef enum {
+ BLE_PROTO_OK = 0,
+ BLE_PROTO_ERR_NULL = -1, /**< 空指针 */
+ BLE_PROTO_ERR_BUF_SMALL = -2, /**< 输出缓冲区不足 */
+ BLE_PROTO_ERR_CRC = -3, /**< CRC16 校验失败 */
+ BLE_PROTO_ERR_LEN = -4, /**< 长度字段非法 / 包长不足 */
+ BLE_PROTO_ERR_GW_CNT = -5, /**< gateway_int_cnt 超出上限 */
+ BLE_PROTO_ERR_INT_ALIGN = -6, /**< device_int_len 非 4 倍数 */
+} ble_proto_err_t;
+
+/* -----------------------------------------------------------------------
+ * 接口
+ * --------------------------------------------------------------------- */
+
+/**
+ * @brief 序列化：将逻辑数据包打包成字节流
+ *
+ * @param[in] pkt 逻辑数据包（reserved 字段被忽略，固定填 0）
+ * @param[out] buf 输出缓冲区
+ * @param[in] buf_size 缓冲区大小（字节）
+ * @return 打包后实际字节数（>0），或 ble_proto_err_t 负值
+ */
+int ble_proto_pack(const ble_proto_packet_t *pkt, uint8_t *buf, size_t buf_size);
+
+/**
+ * @brief 反序列化：将字节流解析为逻辑数据包
+ *
+ * @note pkt->int_data / str_data / bytes_data 指向 buf 内部，不复制数据。
+ * buf 的生命周期必须长于 pkt 的使用期。
+ * @note pkt->reserved 的值被读出但不做校验，接收端可直接忽略。
+ *
+ * @param[in] buf 输入字节流
+ * @param[in] len 字节流长度
+ * @param[out] pkt 解析结果
+ * @return BLE_PROTO_OK，或 ble_proto_err_t 负值
+ */
+int ble_proto_unpack(const uint8_t *buf, size_t len, ble_proto_packet_t *pkt);
+
+/**
+ * @brief 计算 CRC16（MODBUS 变体，多项式 0x8005，初值 0xFFFF）
+ *
+ * @param[in] data 数据起始地址
+ * @param[in] len 数据字节数
+ * @return CRC16 值
+ */
+uint16_t ble_proto_crc16(const uint8_t *data, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLE_PROTO_H */
diff --git a/apps/usr_le_code/bleproto.c b/apps/usr_le_code/bleproto.c
new file mode 100644
index 0000000..89992ad
--- /dev/null
+++ b/apps/usr_le_code/bleproto.c
@@ -0,0 +1,529 @@
+/****************************************************************************/
+/* bleproto.c
+ *
+ * Copyright (C) 2024 四川迈科创智科技有限公司
+ *
+ ****************************************************************************/
+
+/****************************************************************************/
+/* Included Files */
+/****************************************************************************/
+
+#include "bleproto.h"
+
+/****************************************************************************/
+/* Trace Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Pre-processor Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Types */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Function Prototypes */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Data */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Public Data */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Functions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Public Functions */
+/****************************************************************************/
+
+const char *libbleproto_version(void)
+{
+ return BLEPROTO_API_VERSION;
+}
+
+uint8_t bleproto_advdata_encode4bind(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
+{
+ bleproto_adv_t adv = {0};
+ /* adv1 */
+ {
+ adv.adv1.length = 0x02;
+ adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
+ adv.adv1.ad_data = 0x06;
+ }
+ /* adv2 */
+ // clang-format off
+ {
+ adv.adv2.length = 0x1B;
+ adv.adv2.ad_type = BLEPROTO_ADV_TYPE_SVC_DATA_UUID16;
+
+
+ adv.adv2.ad_data.service_data.uuid = BLEPROTO_ADV_SERVICE_UUID_TOBIND;
+ /* spec_data */
+ bleproto_adv_specdata_t *spec_data =
+ &adv.adv2.ad_data.service_data.spec_data;
+
+ spec_data->version = BLEPORTO_ADV_SERVICE_SPEC_DATA_VER;
+ spec_data->business = BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND;
+ spec_data->rfu[0] = 0;
+ spec_data->rfu[1] = 0;
+ spec_data->txpower = txpower;
+
+ spec_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
+ spec_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+ memcpy(spec_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
+
+ spec_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
+ spec_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+ memcpy(spec_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
+
+ spec_data->separator = 0xFF;
+
+ memcpy(spec_data->selfdata, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
+ // spec_data->selfdata[0] = 0X30;
+ // spec_data->selfdata[1] = 0X30;
+ // spec_data->selfdata[2] = 0X30;
+ // spec_data->selfdata[3] = 0X30;
+ // spec_data->selfdata[4] = 0X30;
+ // spec_data->selfdata[5] = 0X30;
+ }
+ // clang-format on
+
+ return bleproto_advdata_serialize(&adv, data, 31);
+}
+
+void bleproto_advdata_encode4heartbeat(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t gwmac[6],
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
+{
+ bleproto_adv_t adv = {0};
+ /* adv1 */
+ {
+ adv.adv1.length = 0x02;
+ adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
+ adv.adv1.ad_data = 0x06;
+ }
+ /* adv2 */
+ // clang-format off
+ {
+ adv.adv2.length = 0x1B;
+ adv.adv2.ad_type = BLEPROTO_ADV_TYPE_MFG_DATA;
+ /* mfg_data */
+ bleproto_advdata_mfg_t *mfg_data = &adv.adv2.ad_data.mfg_data;
+
+ memcpy(mfg_data->siot, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
+ #if 0
+ mfg_data->siot[0] = 'S';
+ mfg_data->siot[1] = 'I';
+ mfg_data->siot[2] = 'O';
+ mfg_data->siot[3] = 'T';
+ mfg_data->siot[4] = '-';
+ mfg_data->siot[5] = '1';
+ #endif
+
+ /* HEARTBEAT */
+ mfg_data->flag = BLEPROTO_ADV_FLAG_HEARTBEAT;
+
+ mfg_data->txpower = txpower;
+ memcpy(mfg_data->gwmac, gwmac, 6);
+
+ mfg_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
+ mfg_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+ memcpy(mfg_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
+
+ mfg_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
+ mfg_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+ memcpy(mfg_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
+ }
+ // clang-format on
+
+ (void)bleproto_advdata_serialize(&adv, data, 31);
+}
+
+uint8_t bleproto_advdata_encode4reconn(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t gwmac[6],
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
+{
+ bleproto_adv_t adv = {0};
+ /* adv1 */
+ {
+ adv.adv1.length = 0x02;
+ adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
+ adv.adv1.ad_data = 0x06;
+ }
+ /* adv2 */
+ // clang-format off
+ {
+ adv.adv2.length = 0x1B;
+ adv.adv2.ad_type = BLEPROTO_ADV_TYPE_MFG_DATA;
+ /* mfg_data */
+ bleproto_advdata_mfg_t *mfg_data = &adv.adv2.ad_data.mfg_data;
+
+ memcpy(mfg_data->siot, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
+ #if 0
+ mfg_data->siot[0] = 'S';
+ mfg_data->siot[1] = 'I';
+ mfg_data->siot[2] = 'O';
+ mfg_data->siot[3] = 'T';
+ mfg_data->siot[4] = '-';
+ mfg_data->siot[5] = '1';
+ #endif
+
+ /* RECONNECT */
+ mfg_data->flag = BLEPROTO_ADV_FLAG_RECONNECT;
+
+ mfg_data->txpower = txpower;
+ memcpy(mfg_data->gwmac, gwmac, 6);
+
+ mfg_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
+ mfg_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+ memcpy(mfg_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
+
+ mfg_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
+ mfg_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+ memcpy(mfg_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
+ }
+ // clang-format on
+
+ return bleproto_advdata_serialize(&adv, data, 31);
+}
+
+int bleproto_advdata_decode(const uint8_t *data,
+ uint8_t len,
+ bleproto_adv_t *adv)
+{
+ return bleproto_advdata_deserialize(data, len, adv);
+}
+
+int bleproto_appdata_encode(uint8_t *txbuf,
+ uint16_t size,
+ uint8_t packetlen,
+ bleproto_appdata_desc_t *desc)
+{
+ int rc;
+ uint16_t txbuf_size = size;
+
+ /*
+ * appdata.data[] 在 SMALL 模式下约 2.3KB，供 JSON/OTA 编码中间缓冲。
+ * JB 55AA 透传可走 bleproto_appdata_wrap_raw，不必经本函数。
+ * 此处用 static，避免在调用方任务栈上临时分配。
+ */
+ static bleproto_appdata_t s_enc_appdata;
+ bleproto_appdata_t *appdata = &s_enc_appdata;
+
+ /* header */
+ {
+ appdata->header = desc->header;
+ }
+ /* data */
+ if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ)
+ {
+ switch (appdata->header.serviceid)
+ {
+ case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
+ rc = bleproto_encjson_deviceinfo_req(&desc->datast.deviceinfo_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
+ rc = bleproto_encjson_authsetup_req(&desc->datast.authsetup_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
+ rc = bleproto_encjson_authdelete_req(&desc->datast.authdelete_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD:
+ rc = bleproto_encjson_runcmd_req(&desc->datast.runcmd_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD:
+ rc = bleproto_encjson_reportcmd_req(&desc->datast.reportcmd_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_DOACTION:
+ rc = bleproto_encjson_doaction_req(&desc->datast.doaction_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
+ rc = bleproto_encjson_otanotify_req(&desc->datast.otanotify_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA:
+ rc = bleproto_encjson_otadata_req(&desc->datast.otadata_req,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
+ rc = ble_proto_pack(&desc->datast.runcmd_v2_req, appdata->data, sizeof(appdata->data));
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
+ rc = ble_proto_pack(&desc->datast.reportcmd_v2_req, appdata->data, sizeof(appdata->data));
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
+ rc = ble_proto_pack(&desc->datast.otadata_v2_req, appdata->data, sizeof(appdata->data));
+ break;
+ default:
+ /* unkown serviceid */
+ return (-1);
+ }
+ }
+ else if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP)
+ {
+ switch (appdata->header.serviceid)
+ {
+ case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
+ rc = bleproto_encjson_deviceinfo_rsp(&desc->datast.deviceinfo_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
+ rc = bleproto_encjson_authsetup_rsp(&desc->datast.authsetup_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
+ rc = bleproto_encjson_authdelete_rsp(&desc->datast.authdelete_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD:
+ rc = bleproto_encjson_runcmd_rsp(&desc->datast.runcmd_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD:
+ rc = bleproto_encjson_reportcmd_rsp(&desc->datast.reportcmd_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_DOACTION:
+ rc = bleproto_encjson_doaction_rsp(&desc->datast.doaction_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
+ rc = bleproto_encjson_otanotify_rsp(&desc->datast.otanotify_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA:
+ rc = bleproto_encbin_otadata_rsp(&desc->datast.otadata_rsp,
+ appdata->data);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
+ rc = ble_proto_pack(&desc->datast.runcmd_v2_rsp, appdata->data, sizeof(appdata->data));
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
+ rc = ble_proto_pack(&desc->datast.reportcmd_v2_rsp, appdata->data, sizeof(appdata->data));
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
+ rc = ble_proto_pack(&desc->datast.otadata_v2_rsp, appdata->data, sizeof(appdata->data));
+ break;
+ default:
+ /* unkown serviceid */
+ return (-1);
+ }
+ }
+ else
+ {
+ /* unkown msgtype */
+ return (-1);
+ }
+ /* failed to encjson struct */
+ if (rc <= 0)
+ {
+ return (-1);
+ }
+
+ /* datalen */
+ appdata->header.datalen = (uint16_t)rc;
+
+ /* appdata_serialize */
+ return bleproto_appdata_serialize(appdata, packetlen, txbuf, txbuf_size);
+}
+
+int bleproto_appdata_decode(uint8_t *rxbuf,
+ uint16_t len,
+ bleproto_appdata_desc_t *desc)
+{
+ int rc, rlen;
+
+ /*
+ * V2(ble_proto_unpack) 零拷贝：bytes_data 等指向 appdata.data。
+ * 若用栈局部变量，函数返回后指针悬空，usr_run_cmd_code_v2 会踩坏数据。
+ * 使用 static，保证 desc 内指针在下次 decode 前有效。
+ */
+ static bleproto_appdata_t s_appdata;
+ bleproto_appdata_t *appdata = &s_appdata;
+
+ /* appdata_deserialize */
+ rlen = bleproto_appdata_deserialize(rxbuf, len, appdata);
+ if (rlen <= 0)
+ {
+ return (rlen);
+ }
+
+ /* header */
+ {
+ desc->header = appdata->header;
+ }
+ /* data */
+ if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ)
+ {
+ switch (appdata->header.serviceid)
+ {
+ case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
+ rc = bleproto_decjson_deviceinfo_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.deviceinfo_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
+ rc = bleproto_decjson_authsetup_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.authsetup_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
+ rc = bleproto_decjson_authdelete_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.authdelete_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD:
+ rc = bleproto_decjson_runcmd_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.runcmd_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD:
+ rc = bleproto_decjson_reportcmd_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.reportcmd_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_DOACTION:
+ rc = bleproto_decjson_doaction_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.doaction_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
+ rc = bleproto_decjson_otanotify_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.otanotify_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA:
+ rc = bleproto_decjson_otadata_req(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.otadata_req);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
+ printf("runcmd_v2_req \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.runcmd_v2_req);
+ printf("runcmd_v2_req rc = %d \n", rc);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
+ printf("reportcmd_v2_req \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.reportcmd_v2_req);
+ printf("reportcmd_v2_req rc = %d \n", rc);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
+ printf("otadata_v2_req \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.otadata_v2_req);
+ printf("otadata_v2_req rc = %d \n", rc);
+ break;
+ default:
+ /* unkown serviceid */
+ return (-1);
+ }
+ }
+ else if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP)
+ {
+ switch (appdata->header.serviceid)
+ {
+ case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
+ rc =
+ bleproto_decjson_deviceinfo_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.deviceinfo_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
+ rc = bleproto_decjson_authsetup_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.authsetup_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
+ rc =
+ bleproto_decjson_authdelete_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.authdelete_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD:
+ rc = bleproto_decjson_runcmd_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.runcmd_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD:
+ rc = bleproto_decjson_reportcmd_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.reportcmd_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_DOACTION:
+ rc = bleproto_decjson_doaction_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.doaction_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
+ rc = bleproto_decjson_otanotify_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.otanotify_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA:
+ rc = bleproto_debin_otadata_rsp(appdata->data,
+ appdata->header.datalen,
+ &desc->datast.otadata_rsp);
+ break;
+ case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
+ printf("runcmd_v2_rsp \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.runcmd_v2_rsp);
+ printf("runcmd_v2_rsp rc = %d \n", rc);
+ break;
+ case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
+ printf("reportcmd_v2_rsp \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.reportcmd_v2_rsp);
+ printf("reportcmd_v2_rsp rc = %d \n", rc);
+ break;
+ case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
+ printf("otadata_v2_rsp \n");
+ rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.otadata_v2_rsp);
+ printf("otadata_v2_rsp rc = %d \n", rc);
+ break;
+ default:
+ /* unkown serviceid */
+ return (-1);
+ }
+ }
+ else
+ {
+ /* unkown msgtype */
+ return (-1);
+ }
+ /* failed to decjson struct */
+ if (rc < 0)
+ {
+ return (-1);
+ }
+
+ return (rlen);
+}
+/****************************************************************************/
+/* */
+/* End of file. */
+/* */
+/****************************************************************************/
diff --git a/apps/usr_le_code/bleproto.h b/apps/usr_le_code/bleproto.h
new file mode 100644
index 0000000..b917a12
--- /dev/null
+++ b/apps/usr_le_code/bleproto.h
@@ -0,0 +1,53 @@
+/****************************************************************************/
+/* bleproto.h
+ *
+ * Copyright (C) 2021 四川迈科创智科技有限公司
+ *
+ ****************************************************************************/
+#ifndef BLEPROTO_H_INCLUDE
+#define BLEPROTO_H_INCLUDE
+/****************************************************************************/
+/* Included Files */
+/****************************************************************************/
+
+/* api */
+#include "bleproto_api.h"
+
+/* thirdpart api */
+#include "mjson.h"
+
+/****************************************************************************/
+/* Configure Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Pre-processor Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Public Types */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Public Data */
+/****************************************************************************/
+
+/****************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+/****************************************************************************/
+/* Public Function Prototypes */
+/****************************************************************************/
+
+/****************************************************************************/
+#ifdef __cplusplus
+}
+#endif
+/****************************************************************************/
+#endif /* BLEPROTO_H_INCLUDE */
+/****************************************************************************/
+/* */
+/* End of file. */
+/* */
+/****************************************************************************/
diff --git a/apps/usr_le_code/bleproto_api.h b/apps/usr_le_code/bleproto_api.h
new file mode 100644
index 0000000..f36f92d
--- /dev/null
+++ b/apps/usr_le_code/bleproto_api.h
@@ -0,0 +1,303 @@
+/****************************************************************************/
+/* bleproto_api.h
+ *
+ * Copyright (C) 2021 四川迈科创智科技有限公司
+ *
+ ****************************************************************************/
+/**
+ * @page bleproto_api_guides API Guides
+ *
+ * @ingroup bleproto_api_guides
+ * @addtogroup bleproto_api bleproto
+ *
+ * wiki
+ * ====
+ * - https://gogos.mkcziot.com:13000/iot-device/cziot-sdk/src/master/doc/wiki/ble/mk蓝牙设备开发指南.md
+ *
+ * @{
+ */
+
+#ifndef BLEPROTO_API_H_INCLUDE
+#define BLEPROTO_API_H_INCLUDE
+/****************************************************************************/
+/* Included Files */
+/****************************************************************************/
+
+/* system */
+//#include
+/*#include
+#include
+#include
+#include */
+
+/* group */
+#include "bleproto_packer.h"
+#include "ble_proto.h"
+/****************************************************************************/
+/* Configure Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Pre-processor Definitions */
+/****************************************************************************/
+
+/* api version */
+#define BLEPROTO_API_VERSION "1.1.4"
+
+/****************************************************************************/
+/* Public Types */
+/****************************************************************************/
+
+/**
+ * @brief 应用数据描述
+ */
+typedef struct bleproto_appdata_desc {
+ /** 包头 */
+ bleproto_appdata_header_t header;
+ /**
+ * 根据
+ * - header.msgtype:请求(0=req)、响应(1=rsp)
+ * - header.serviceid @ref bleproto_service_id_e
+ * datast取对应的member
+ *
+ * 比如 header.msgtype = 0(请求req), header.serviceid = E_BLEPROTO_SERVICE_ID_DEVICEINFO
+ * datast 对应 deviceinfo_req
+ */
+ union {
+ bleproto_deviceinfo_req_t deviceinfo_req;
+ bleproto_deviceinfo_rsp_t deviceinfo_rsp;
+ bleproto_authsetup_req_t authsetup_req;
+ bleproto_authsetup_rsp_t authsetup_rsp;
+ bleproto_authdelete_req_t authdelete_req;
+ bleproto_authdelete_rsp_t authdelete_rsp;
+ bleproto_runcmd_req_t runcmd_req;
+ bleproto_runcmd_rsp_t runcmd_rsp;
+ bleproto_reportcmd_req_t reportcmd_req;
+ bleproto_reportcmd_rsp_t reportcmd_rsp;
+ bleproto_doaction_req_t doaction_req;
+ bleproto_doaction_rsp_t doaction_rsp;
+ bleproto_otanotify_req_t otanotify_req;
+ bleproto_otanotify_rsp_t otanotify_rsp;
+ bleproto_otadata_req_t otadata_req;
+ bleproto_otadata_rsp_t otadata_rsp;
+
+ ble_proto_packet_t runcmd_v2_req;
+ ble_proto_packet_t runcmd_v2_rsp;
+ ble_proto_packet_t reportcmd_v2_req;
+ ble_proto_packet_t reportcmd_v2_rsp;
+ ble_proto_packet_t otadata_v2_req;
+ ble_proto_packet_t otadata_v2_rsp;
+
+ } datast;
+} bleproto_appdata_desc_t;
+
+/****************************************************************************/
+/* Public Data */
+/****************************************************************************/
+
+/****************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/****************************************************************************/
+/* Public Function Prototypes */
+/****************************************************************************/
+
+/**
+ * @brief Get library version
+ *
+ * @return The string of library version
+ */
+const char *libbleproto_version(void);
+
+/**
+ * @brief 序列化请求注册绑定广播数据(广播数据长度为31)
+ *
+ * @param[out] data - 序列化数据缓冲区, 固定为31个字节.
+ * @param[in] txpower - 蓝牙发射功率[-127,128]dBm
+ * @param[in] manucode - 厂商编码, 现在固定填0
+ * @param[in] pcode - 平台pcode, 比如pcode为AAABBB
+ * pcode[0] = 'A' = 0x41
+ * pcode[1] = 'A' = 0x41
+ * pcode[2] = 'A' = 0x41
+ * pcode[3] = 'B' = 0x42
+ * pcode[4] = 'B' = 0x42
+ * pcode[5] = 'B' = 0x42
+ * @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
+ * prodcode[0] = 'C' = 0x43
+ * prodcode[1] = 'B' = 0x42
+ * prodcode[2] = 'F' = 0x46
+ * prodcode[3] = 'D' = 0x44
+ */
+uint8_t bleproto_advdata_encode4bind(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
+
+/**
+ * @brief 序列化心跳广播数据(广播数据长度为31)
+ *
+ * @param[out] data - 序列化数据缓冲区, 固定为31个字节.
+ * @param[in] txpower - 蓝牙发射功率[-127,128]dBm
+ * @param[in] gwmac - 主控设备mac地址(子设备绑定到主控设备，authStep会下发主控设备的mac地址)，
+ * 例如mac地址 "11:22:33:44:55:66"
+ * gwmac[0] = 0x11
+ * gwmac[1] = 0x22
+ * gwmac[2] = 0x33
+ * gwmac[3] = 0x44
+ * gwmac[4] = 0x55
+ * gwmac[5] = 0x66
+ * @param[in] manucode - 厂商编码, 现在固定填0
+ * @param[in] pcode - 平台pcode, 比如pcode为AAABBB
+ * pcode[0] = 'A' = 0x41
+ * pcode[1] = 'A' = 0x41
+ * pcode[2] = 'A' = 0x41
+ * pcode[3] = 'B' = 0x42
+ * pcode[4] = 'B' = 0x42
+ * pcode[5] = 'B' = 0x42
+ * @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
+ * prodcode[0] = 'C' = 0x43
+ * prodcode[1] = 'B' = 0x42
+ * prodcode[2] = 'F' = 0x46
+ * prodcode[3] = 'D' = 0x44
+ */
+void bleproto_advdata_encode4heartbeat(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t gwmac[6],
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
+
+/**
+ * @brief 序列化回连广播数据(广播数据长度为31)
+ *
+ * @param[out] data - 序列化数据缓冲区, 固定为31个字节.
+ * @param[in] txpower - 蓝牙发射功率[-127,128]dBm
+ * @param[in] gwmac - 主控设备mac地址(子设备绑定到主控设备，authStep会下发主控设备的mac地址)，
+ * 例如mac地址 "11:22:33:44:55:66"
+ * gwmac[0] = 0x11
+ * gwmac[1] = 0x22
+ * gwmac[2] = 0x33
+ * gwmac[3] = 0x44
+ * gwmac[4] = 0x55
+ * gwmac[5] = 0x66
+ * @param[in] manucode - 厂商编码, 现在固定填0
+ * @param[in] pcode - 平台pcode, 比如pcode为AAABBB
+ * pcode[0] = 'A' = 0x41
+ * pcode[1] = 'A' = 0x41
+ * pcode[2] = 'A' = 0x41
+ * pcode[3] = 'B' = 0x42
+ * pcode[4] = 'B' = 0x42
+ * pcode[5] = 'B' = 0x42
+ * @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
+ * prodcode[0] = 'C' = 0x43
+ * prodcode[1] = 'B' = 0x42
+ * prodcode[2] = 'F' = 0x46
+ * prodcode[3] = 'D' = 0x44
+ *
+ * @return 小于0表示失败，大于0表示序列化后的长度(31)
+ */
+uint8_t bleproto_advdata_encode4reconn(
+ uint8_t data[31],
+ int8_t txpower,
+ uint8_t gwmac[6],
+ uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
+ uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
+ uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
+
+/**
+ * @brief 反序列化广播数据(广播数据长度为31)
+ *
+ * @param[in] data - 反序列化数据指针
+ * @param[in] len - 反序列化数据长度
+ * @param[out] adv - 广播数据结构体
+ *
+ * @return 小于0表示失败，大于0表示反序列化使用data的长度.
+ */
+int bleproto_advdata_decode(const uint8_t * data,
+ uint8_t len,
+ bleproto_adv_t *adv);
+
+/**
+ * @brief 序列化应用数据结构体到txbuf
+ *
+ * @note packetlen说明
+ *
+ * ```c
+ * ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
+ * ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ```
+ *
+ * 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
+ * +----------------+
+ * | 1 | 第一包按照packetlen填满
+ * +----------------+
+ * | |
+ * | ... | 中间包按照packetlen填满
+ * | |
+ * +----------------+
+ * | N | 最后一包长度 = totallen - (packetlen * (N -1))
+ * +----------------+
+ *
+ * 需要按照每包的顺序发给对端
+ *
+ * @param[out] txbuf - 发送数据缓冲区指针
+ * @param[in] size - 发送数据缓冲器长度
+ * @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
+ * @param[in] desc - 应用数据结构体描述
+ *
+ * @return 小于0表示失败，大于0表示序列化后的长度
+ */
+int bleproto_appdata_encode(uint8_t * txbuf,
+ uint16_t size,
+ uint8_t packetlen,
+ bleproto_appdata_desc_t *desc);
+
+/**
+ * @brief 反序列化rxbuf到应用数据结构体
+ *
+ *
+ * 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
+ * +----------------+
+ * | 1 | 第一包按照packetlen填满
+ * +----------------+
+ * | |
+ * | ... | 中间包按照packetlen填满
+ * | |
+ * +----------------+
+ * | N | 最后一包长度 = totallen - (packetlen * (N -1))
+ * +----------------+
+ *
+ * 因此接收到数据
+ * 1. 函数返回等于0，以为还有分包数据还没有接收完成，
+ * 接收到下包数据 append 在buf尾部，再调用函数的解析数据包
+ * 2. 函数返回大于0，表示收到数据解析了多少字节，需要将头上对应长度数据移除掉
+ * 3. 函数返回小于0，表示收到非法的数据包，无法解析
+ *
+ * @param[in] rxbuf - 接收缓冲区指针
+ * @param[in] len - 接收缓冲区数据长度.
+ * @param[out] desc - 应用数据结构体.
+ *
+ * @return 大于0表示解析成功, 返回当前解析了多少个字节,
+ * 等于0表示解析未完成, 只接受到分包的部分数据, 需要继续接收数据
+ * 小于0表示解析失败
+ */
+int bleproto_appdata_decode(uint8_t* rxbuf,
+ uint16_t len,
+ bleproto_appdata_desc_t *desc);
+/****************************************************************************/
+#ifdef __cplusplus
+}
+#endif
+/****************************************************************************/
+#endif /* BLEPROTO_API_H_INCLUDE */
+/****************************************************************************/
+/* */
+/* End of file. */
+/* */
+/****************************************************************************/
diff --git a/apps/usr_le_code/bleproto_packer.c b/apps/usr_le_code/bleproto_packer.c
new file mode 100644
index 0000000..b1c6159
--- /dev/null
+++ b/apps/usr_le_code/bleproto_packer.c
@@ -0,0 +1,3054 @@
+/****************************************************************************/
+/* bleproto_packer.c
+ *
+ * Copyright (C) 2024 四川迈科创智科技有限公司
+ *
+ ****************************************************************************/
+
+/****************************************************************************/
+/* Included Files */
+/****************************************************************************/
+
+#include "bleproto.h"
+#include "system/includes.h"
+#include "inttypes.h"
+/****************************************************************************/
+/* Trace Definitions */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Pre-processor Definitions */
+/****************************************************************************/
+/**
+ * @def UTILS_BITFIELD_GET
+ * @brief get bitfield value.
+ *
+ * @note MUSTBE `s`<=`e`.
+ *
+ * @param[in] v - The value to get.
+ * @param[in] e - The end-bit number.
+ * @param[in] s - The start-bit number.
+ *
+ * @code
+ * uint8_t ctrl;
+ * - bit7-2: type
+ * - bit1-0: id
+ * type = UTILS_BITFIELD_GET(ctrl, 7, 2);
+ * id = UTILS_BITFIELD_GET(ctrl, 1, 0);
+ * @endcode
+ */
+/**
+ * @def UTILS_BITFIELD_SET
+ * @brief set bitfield value.
+ *
+ * @note MUSTBE `s`<=`e`.
+ *
+ * @param[in] v - The value to set.
+ * @param[in] e - The end-bit number.
+ * @param[in] s - The start-bit number.
+ *
+ * @code
+ * uint8_t ctrl;
+ * - bit7-2: type
+ * - bit1-0: id
+ * ctrl = UTILS_BITFIELD_SET(type, 7, 2) | UTILS_BITFIELD_SET(id, 1, 0);
+ * @endcode
+ */
+/* Helper bitfield encode/decode macros */
+#define UTILS_STATIC_ASSERT_OR_ZERO(cond) (sizeof(char[1 - 2 * !(cond)]) - 1)
+#define UTILS_BITFILED_CHECK(e, s) UTILS_STATIC_ASSERT_OR_ZERO((e) >= (s))
+#define UTILS_BITFIELD_MASK(e, s) \
+ (UTILS_BITFILED_CHECK(e, s) + (((1UL << ((e) - (s) + 1)) - 1UL) << (s)))
+#define UTILS_BITFIELD_GET(v, e, s) \
+ (UTILS_BITFILED_CHECK(e, s) + \
+ (((v) >> (s)) & UTILS_BITFIELD_MASK(((e) - (s)), 0)))
+#define UTILS_BITFIELD_SET(v, e, s) \
+ (UTILS_BITFILED_CHECK(e, s) + \
+ (((v)&UTILS_BITFIELD_MASK(((e) - (s)), 0)) << (s)))
+#define UTILS_BITFIELD_CLR(v, e, s) \
+ (UTILS_BITFILED_CHECK(e, s) + ((v) & (~(UTILS_BITFIELD_MASK(e, s)))))
+#define UTILS_BITFIELD_UPD(oldv, e, s, newv) \
+ (UTILS_BITFILED_CHECK(e, s) + \
+ (UTILS_BITFIELD_CLR(oldv, e, s) | UTILS_BITFIELD_SET(newv, e, s)))
+
+/**
+ * @def UTILS_MIN
+ * @brief Calculates the minimum of x and y.
+ */
+#define UTILS_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+/****************************************************************************/
+/* Private Types */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Function Prototypes */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Data */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Public Data */
+/****************************************************************************/
+
+/****************************************************************************/
+/* Private Functions */
+/****************************************************************************/
+
+static uint8_t hex_char_to_int(char c)
+{
+ // 将十六进制字符转换为对应的数值
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ } else if (c >= 'A' && c <= 'F') {
+ return c - 'A' + 10;
+ } else if (c >= 'a' && c <= 'f') {
+ return c - 'a' + 10;
+ }
+ // 非十六进制字符，返回无效值
+ return 0xFF;
+}
+
+/* utils */
+static void proto_bytes_put_le16(uint8_t dst[2], uint16_t val)
+{
+ dst[0] = val;
+ dst[1] = val >> 8;
+}
+
+static uint16_t proto_bytes_get_le16(const uint8_t src[2])
+{
+ return ((uint16_t)src[1] << 8) | src[0];
+}
+
+static int proto_strhex_to_byte(const char *str, uint8_t *bytes, size_t size)
+{
+ // string转bytes
+ if (str == NULL || bytes == NULL) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ size_t str_len = strlen(str);
+ if (str_len % 2 != 0 || str_len / 2 > size) {
+ BLEPROTO_T_E("Invalid string length or buffer size");
+ return -1;
+ }
+
+ for (size_t i = 0; i < str_len; i += 2) {
+ uint8_t high = hex_char_to_int(str[i]);
+ uint8_t low = hex_char_to_int(str[i + 1]);
+ if (high == 0xFF || low == 0xFF) {
+ BLEPROTO_T_E("Invalid hex character");
+ return -1;
+ }
+ bytes[i / 2] = (high << 4) | low;
+ }
+
+ return (int)(str_len / 2);
+}
+
+/****************************************************************************/
+/* Public Functions */
+/****************************************************************************/
+
+int bleproto_advdata_serialize(bleproto_adv_t *adv,
+ uint8_t * data,
+ uint8_t size)
+{
+ uint8_t offset = 0;
+
+ /* check params */
+ if (!adv || !data || size < BLEPROTO_ADV_MAX_SZ) {
+ BLEPROTO_T_E("Invalid parameters");
+ return (-1);
+ }
+
+ /* check adv2 type */
+ if (adv->adv2.ad_type != BLEPROTO_ADV_TYPE_SVC_DATA_UUID16 &&
+ adv->adv2.ad_type != BLEPROTO_ADV_TYPE_MFG_DATA) {
+ BLEPROTO_T_E("Invalid adv2.adv_type");
+ return (-1);
+ }
+
+ /* clear */
+ memset(data, 0, size);
+
+ /* adv1 */
+ {
+ /* rewrite member */
+ adv->adv1.length = 0x02;
+ adv->adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
+ adv->adv1.ad_data = 0x06;
+
+ data[offset++] = adv->adv1.length;
+ data[offset++] = adv->adv1.ad_type;
+ data[offset++] = adv->adv1.ad_data;
+ }
+
+ /* adv2 */
+ adv->adv2.length = BLEPROTO_ADV_MAX_SZ - 3 - 1;
+ {
+ /* adv2 length */
+ data[offset++] = adv->adv2.length;
+ /* adv2 type */
+ data[offset++] = adv->adv2.ad_type;
+ }
+ if (adv->adv2.ad_type == BLEPROTO_ADV_TYPE_SVC_DATA_UUID16) {
+ /* uuid, little endian */
+ proto_bytes_put_le16(&data[offset],
+ adv->adv2.ad_data.service_data.uuid);
+ offset += 2;
+ /////////////////////////////////////////
+ // spec_data
+ /////////////////////////////////////////
+ bleproto_adv_specdata_t *spec_data =
+ &adv->adv2.ad_data.service_data.spec_data;
+ /* version */
+ data[offset++] = spec_data->version;
+ /* business */
+ data[offset++] = spec_data->business;
+ /* rfu */
+ data[offset++] = 0;
+ data[offset++] = 0;
+ /* txpower */
+ data[offset++] = (uint8_t)spec_data->txpower;
+ /* manucode */
+ {
+ spec_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
+ spec_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+
+ data[offset++] = spec_data->manucode.type;
+ data[offset++] = spec_data->manucode.length;
+ memcpy(&data[offset],
+ spec_data->manucode.value,
+ BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
+ offset += BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+ }
+ /* prodcode */
+ {
+ spec_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
+ spec_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+
+ data[offset++] = spec_data->prodcode.type;
+ data[offset++] = spec_data->prodcode.length;
+ memcpy(&data[offset],
+ spec_data->prodcode.value,
+ BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
+ offset += BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+ }
+ /* separator */
+ {
+ spec_data->separator = 0xFF;
+
+ data[offset++] = spec_data->separator;
+ }
+ /* selfdata */
+ {
+ memcpy(&data[offset],
+ spec_data->selfdata,
+ sizeof(spec_data->selfdata));
+ offset += (uint8_t)sizeof(spec_data->selfdata);
+ }
+ } else if (adv->adv2.ad_type == BLEPROTO_ADV_TYPE_MFG_DATA) {
+ bleproto_advdata_mfg_t *mfg_data = &adv->adv2.ad_data.mfg_data;
+ /* siot */
+ data[offset++] = mfg_data->siot[0];
+ data[offset++] = mfg_data->siot[1];
+ data[offset++] = mfg_data->siot[2];
+ data[offset++] = mfg_data->siot[3];
+ data[offset++] = mfg_data->siot[4];
+ data[offset++] = mfg_data->siot[5];
+ /* flag */
+ data[offset++] = mfg_data->flag;
+ /* txpower */
+ data[offset++] = (uint8_t)mfg_data->txpower;
+ /* gwmac */
+ data[offset++] = mfg_data->gwmac[0];
+ data[offset++] = mfg_data->gwmac[1];
+ data[offset++] = mfg_data->gwmac[2];
+ data[offset++] = mfg_data->gwmac[3];
+ data[offset++] = mfg_data->gwmac[4];
+ data[offset++] = mfg_data->gwmac[5];
+ /* manucode */
+ {
+ mfg_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
+ mfg_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+
+ data[offset++] = mfg_data->manucode.type;
+ data[offset++] = mfg_data->manucode.length;
+ memcpy(&data[offset],
+ mfg_data->manucode.value,
+ BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
+ offset += BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
+ }
+ /* prodcode */
+ {
+ mfg_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
+ mfg_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+
+ data[offset++] = mfg_data->prodcode.type;
+ data[offset++] = mfg_data->prodcode.length;
+ memcpy(&data[offset],
+ mfg_data->prodcode.value,
+ BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
+ offset += BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
+ }
+ }
+
+ return (offset);
+}
+
+int bleproto_advdata_deserialize(const uint8_t * data,
+ uint8_t len,
+ bleproto_adv_t *adv)
+{
+ int rc;
+ uint8_t offset = 0;
+
+ /* check parameters */
+ if (!data || !adv) {
+ BLEPROTO_T_E("Invalid parameters");
+ return (-1);
+ }
+
+ /* check len */
+ if (len != BLEPROTO_ADV_MAX_SZ) {
+ BLEPROTO_T_E("Invalid len");
+ return (-1);
+ }
+
+ do {
+ /* clear */
+ memset(adv, 0, sizeof(*adv));
+
+ /* adv1 */
+ adv->adv1.length = data[offset++];
+ adv->adv1.ad_type = data[offset++];
+ adv->adv1.ad_data = data[offset++];
+ if (adv->adv1.length != 0x02 ||
+ adv->adv1.ad_type != BLEPROTO_ADV_TYPE_FLAGS ||
+ adv->adv1.ad_data != 0x06) {
+ BLEPROTO_T_E("Invalid adv1 data");
+ rc = -1;
+ break;
+ }
+
+ adv->adv2.length = data[offset++];
+ adv->adv2.ad_type = data[offset++];
+ if (adv->adv2.length != BLEPROTO_ADV_MAX_SZ - 3 - 1) {
+ BLEPROTO_T_E("Invalid adv2 len");
+ rc = -1;
+ break;
+ }
+
+ /* adv2 */
+ if (adv->adv2.ad_type == BLEPROTO_ADV_TYPE_SVC_DATA_UUID16) {
+ /* uuid, little endian */
+ adv->adv2.ad_data.service_data.uuid =
+ proto_bytes_get_le16(&data[offset]);
+ offset += 2;
+ /////////////////////////////////////////
+ // spec_data
+ /////////////////////////////////////////
+ bleproto_adv_specdata_t *spec_data =
+ &adv->adv2.ad_data.service_data.spec_data;
+ /* version */
+ spec_data->version = data[offset++];
+ /* business */
+ spec_data->business = data[offset++];
+ /* rfu */
+ spec_data->rfu[0] = data[offset++];
+ spec_data->rfu[1] = data[offset++];
+ /* txpower */
+ spec_data->txpower = (int8_t)data[offset++];
+ /* manucode */
+ {
+ spec_data->manucode.type = data[offset++];
+ if (spec_data->manucode.type !=
+ BLEPROTO_ADV_TLV_TYPE_MANUCODE) {
+ BLEPROTO_T_E("Invalid adv2 service_data.manucode.type");
+ rc = -1;
+ break;
+ }
+ spec_data->manucode.length = data[offset++];
+ if (spec_data->manucode.length !=
+ BLEPROTO_ADV_TLV_LENGTH_MANUCODE) {
+ BLEPROTO_T_E("Invalid adv2 service_data.manucode.length");
+ rc = -1;
+ break;
+ }
+ memcpy(spec_data->manucode.value,
+ &data[offset],
+ spec_data->manucode.length);
+ offset += spec_data->manucode.length;
+ }
+ /* prodcode */
+ {
+ spec_data->prodcode.type = data[offset++];
+ if (spec_data->prodcode.type !=
+ BLEPROTO_ADV_TLV_TYPE_PRODCODE) {
+ BLEPROTO_T_E("Invalid adv2 service_data.prodcode.type");
+ rc = -1;
+ break;
+ }
+ spec_data->prodcode.length = data[offset++];
+ if (spec_data->prodcode.length !=
+ BLEPROTO_ADV_TLV_LENGTH_PRODCODE) {
+ BLEPROTO_T_E("Invalid adv2 service_data.prodcode.length");
+ rc = -1;
+ break;
+ }
+ memcpy(spec_data->prodcode.value,
+ &data[offset],
+ spec_data->prodcode.length);
+ offset += spec_data->prodcode.length;
+ }
+ /* separator */
+ {
+ spec_data->separator = data[offset++];
+ if (spec_data->separator != 0xff) {
+ BLEPROTO_T_E("Invalid adv2 service_data.separator");
+ rc = -1;
+ break;
+ }
+ }
+ /* selfdata */
+ {
+ memcpy(spec_data->selfdata,
+ &data[offset],
+ sizeof(spec_data->selfdata));
+ offset += (uint8_t)sizeof(spec_data->selfdata);
+ }
+ } else if (adv->adv2.ad_type == BLEPROTO_ADV_TYPE_MFG_DATA) {
+ bleproto_advdata_mfg_t *mfg_data = &adv->adv2.ad_data.mfg_data;
+ /* fix "SIOT-1" */
+ memcpy(mfg_data->siot, &data[offset], 6);
+ // if (mfg_data->siot[0] != 'S' || mfg_data->siot[1] != 'I' ||
+ // mfg_data->siot[2] != 'O' || mfg_data->siot[3] != 'T' ||
+ // mfg_data->siot[4] != '-') {
+ // BLEPROTO_T_E("Invalid adv2 mfg_data.siot");
+ // rc = -1;
+ // break;
+ // }
+ offset += 6;
+
+ /* flag */
+ mfg_data->flag = data[offset++];
+ /* txpower */
+ mfg_data->txpower = (int8_t)data[offset++];
+ /* gwmac */
+ memcpy(mfg_data->gwmac, &data[offset], 6);
+ offset += 6;
+ /* manucode */
+ {
+ mfg_data->manucode.type = data[offset++];
+ if (mfg_data->manucode.type !=
+ BLEPROTO_ADV_TLV_TYPE_MANUCODE) {
+ BLEPROTO_T_E("Invalid adv2 mfg_data.manucode.type");
+ rc = -1;
+ break;
+ }
+ mfg_data->manucode.length = data[offset++];
+ if (mfg_data->manucode.length !=
+ BLEPROTO_ADV_TLV_LENGTH_MANUCODE) {
+ BLEPROTO_T_E("Invalid adv2 mfg_data.manucode.length");
+ rc = -1;
+ break;
+ }
+ memcpy(mfg_data->manucode.value,
+ &data[offset],
+ mfg_data->manucode.length);
+ offset += mfg_data->manucode.length;
+ }
+ /* prodcode */
+ {
+ mfg_data->prodcode.type = data[offset++];
+ if (mfg_data->prodcode.type !=
+ BLEPROTO_ADV_TLV_TYPE_PRODCODE) {
+ BLEPROTO_T_E("Invalid adv2 mfg_data.prodcode.type");
+ rc = -1;
+ break;
+ }
+ mfg_data->prodcode.length = data[offset++];
+ if (mfg_data->prodcode.length !=
+ BLEPROTO_ADV_TLV_LENGTH_PRODCODE) {
+ BLEPROTO_T_E("Invalid adv2 mfg_data.prodcode.length");
+ rc = -1;
+ break;
+ }
+ memcpy(mfg_data->prodcode.value,
+ &data[offset],
+ mfg_data->prodcode.length);
+ offset += mfg_data->prodcode.length;
+ }
+ } else {
+ BLEPROTO_T_E("Invalid adv2 adv_type");
+ rc = -1;
+ break;
+ }
+
+ /* check offset */
+ if (offset != 31) {
+ BLEPROTO_T_E("Invalid offset");
+ rc = -1;
+ break;
+ }
+ rc = offset;
+ } while (0);
+
+ return (rc);
+}
+
+int bleproto_appdata_serialize_len(bleproto_appdata_t *appdata,
+ uint8_t packetlen,
+ uint16_t * outlen)
+{
+ /* check param */
+ if (!appdata || packetlen <= BLEPROTO_APPDATA_HEADR_LEN) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* data total len */
+ uint16_t datalen = appdata->header.datalen;
+
+ /* each frame max payload length */
+ uint8_t frame_max_payload = packetlen - BLEPROTO_APPDATA_HEADR_LEN;
+
+ /* calculate total frames needed */
+ uint16_t totalframe;
+ if (datalen == 0) {
+ /* even with no data, we need at least one frame for the header */
+ totalframe = 1;
+ } else {
+ /* calculate frames needed for the data */
+ totalframe = (datalen + frame_max_payload - 1) / frame_max_payload;
+ }
+ if (totalframe > 255) {
+ BLEPROTO_T_E("Invalid appdata.datalen too long >(%u)",
+ (uint16_t)frame_max_payload * 255);
+ return -1;
+ }
+
+ /* calculate total buffer size needed */
+ if (totalframe <= 1) {
+ /* at least one frame is needed */
+ if (outlen) {
+ *outlen = datalen + BLEPROTO_APPDATA_HEADR_LEN;
+ }
+ } else {
+ /* calculate size of full frames */
+ uint16_t full_frames_size = (uint16_t)(totalframe - 1) * packetlen;
+
+ // clang-format off
+ /* calculate size of last frame */
+ uint16_t last_frame_size =
+ /* header */ BLEPROTO_APPDATA_HEADR_LEN +
+ /* payload */ datalen - (uint16_t)((totalframe - 1) * frame_max_payload);
+ // clang-format on
+
+ /* total size is sum of full frames and last frame */
+ if (outlen) {
+ *outlen = full_frames_size + last_frame_size;
+ }
+ }
+
+ return 0;
+}
+
+int bleproto_appdata_serialize(bleproto_appdata_t *appdata,
+ uint8_t packetlen,
+ uint8_t * buf,
+ uint16_t size)
+
+{
+ int rc, offset = 0;
+ uint16_t data_offset = 0;
+
+ /* check param */
+ if (!appdata || packetlen <= BLEPROTO_APPDATA_HEADR_LEN) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* totoal len */
+ uint16_t total_len;
+ rc = bleproto_appdata_serialize_len(appdata, packetlen, &total_len);
+ if (rc < 0) {
+ return -1;
+ }
+ if (size < total_len) {
+ BLEPROTO_T_E("Invalid datalen:%u, buf too short(%u<%u)",
+ appdata->header.datalen,
+ size,
+ total_len);
+ return -1;
+ }
+
+ /* data total len */
+ uint16_t datalen = appdata->header.datalen;
+
+ /* each frame max payload length */
+ uint8_t frame_max_payload = packetlen - BLEPROTO_APPDATA_HEADR_LEN;
+
+ /* calculate total frames needed */
+ uint16_t totalframe;
+ if (datalen == 0) {
+ /* even with no data, we need at least one frame for the header */
+ totalframe = 1;
+ } else {
+ /* calculate frames needed for the data */
+ totalframe = (datalen + frame_max_payload - 1) / frame_max_payload;
+ }
+ if (totalframe > 255) {
+ BLEPROTO_T_E("Invalid appdata.datalen too long");
+ return -1;
+ }
+
+ for (uint8_t i = 0; i < (uint8_t)totalframe; i++) {
+ /* pthis_frame_len */
+ uint8_t pthis_frame_len = 0;
+ if (totalframe == 1) {
+ /* only one frame */
+ pthis_frame_len = (uint8_t)datalen;
+ } else if (i + 1 < totalframe) {
+ /* full size frames */
+ pthis_frame_len = frame_max_payload;
+ } else {
+ /* last frame */
+ pthis_frame_len = (uint8_t)(datalen - data_offset);
+ }
+
+ /* header */
+ bleproto_appdata_header_t hdr = appdata->header;
+ {
+ hdr.totalframe = totalframe;
+ if (totalframe == 1) {
+ hdr.frameseq = 0;
+ } else {
+ hdr.frameseq = i + 1;
+ }
+ }
+ /* serialize_header */
+ {
+ /* buf[0]: version[2:0] | datafmt[3:3] | msgtype[7:4] */
+ buf[offset + 0] = UTILS_BITFIELD_SET(hdr.version, 2, 0) |
+ UTILS_BITFIELD_SET(hdr.datafmt, 3, 3) |
+ UTILS_BITFIELD_SET(hdr.msgtype, 7, 4);
+ /* buf[1]: msgid[3:0] | encrypt[4:4] | reserve[7:5] */
+ buf[offset + 1] = UTILS_BITFIELD_SET(hdr.msgid, 3, 0) |
+ UTILS_BITFIELD_SET(hdr.encrypt, 4, 4) |
+ UTILS_BITFIELD_SET(hdr.reserve, 7, 5);
+
+ buf[offset + 2] = hdr.totalframe;
+ buf[offset + 3] = hdr.frameseq;
+ buf[offset + 4] = pthis_frame_len;
+ buf[offset + 5] = hdr.serviceid;
+
+ /* datalen in little endian */
+ proto_bytes_put_le16(&buf[offset + 6], hdr.datalen);
+ }
+ offset += BLEPROTO_APPDATA_HEADR_LEN;
+
+ /* payload */
+ if (pthis_frame_len != 0) {
+ memcpy(
+ &buf[offset], &appdata->data[data_offset], pthis_frame_len);
+ /* offset */
+ offset += pthis_frame_len;
+ /* data_offset */
+ data_offset += pthis_frame_len;
+ }
+ }
+ if (offset != total_len) {
+ BLEPROTO_T_E("Error calc appdata total_len");
+ return -1;
+ }
+
+ return (offset);
+}
+
+int bleproto_appdata_wrap_raw(uint8_t *txbuf,
+ uint16_t txbuf_size,
+ const bleproto_appdata_header_t *header,
+ const uint8_t *payload,
+ uint16_t payload_len)
+{
+ uint16_t total;
+
+ if (!txbuf || !header) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+ if (payload_len > 0 && !payload) {
+ BLEPROTO_T_E("Invalid payload");
+ return -1;
+ }
+ /* 单帧 this_frame_len 为 uint8，超过 255 需走分包 serialize */
+ if (payload_len > 255u) {
+ BLEPROTO_T_E("payload too long for single frame");
+ return -1;
+ }
+
+ total = (uint16_t)(BLEPROTO_APPDATA_HEADR_LEN + payload_len);
+ if (txbuf_size < total) {
+ BLEPROTO_T_E("txbuf too short");
+ return -1;
+ }
+
+ /* buf[0]: version[2:0] | datafmt[3:3] | msgtype[7:4] */
+ txbuf[0] = UTILS_BITFIELD_SET(header->version, 2, 0) |
+ UTILS_BITFIELD_SET(header->datafmt, 3, 3) |
+ UTILS_BITFIELD_SET(header->msgtype, 7, 4);
+ /* buf[1]: msgid[3:0] | encrypt[4:4] | reserve[7:5] */
+ txbuf[1] = UTILS_BITFIELD_SET(header->msgid, 3, 0) |
+ UTILS_BITFIELD_SET(header->encrypt, 4, 4) |
+ UTILS_BITFIELD_SET(header->reserve, 7, 5);
+ txbuf[2] = 1; /* totalframe */
+ txbuf[3] = 0; /* frameseq：单帧为 0 */
+ txbuf[4] = (uint8_t)payload_len; /* this frame payload len */
+ txbuf[5] = header->serviceid;
+ proto_bytes_put_le16(&txbuf[6], payload_len);
+
+ if (payload_len > 0) {
+ memcpy(&txbuf[BLEPROTO_APPDATA_HEADR_LEN], payload, payload_len);
+ }
+
+ return (int)total;
+}
+
+int bleproto_appdata_deserialize(uint8_t * buf,
+ uint16_t len,
+ bleproto_appdata_t *appdata)
+{
+ /* check parameters */
+ if (!buf || !appdata) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* 检查是否至少有一个完整的包头 */
+ if (len < BLEPROTO_APPDATA_HEADR_LEN) {
+ // 数据不够,需要更多数据
+ return 0;
+ }
+
+ int offset = 0;
+ uint8_t msgid;
+ uint8_t totalframe;
+ uint8_t frameseq;
+ uint16_t datalen;
+ uint8_t frame_payload_len;
+ uint8_t max_payload = 0;
+ uint8_t recv_frames = 0;
+
+ /* 第一轮: 扫描所有数据,验证分包的完整性和一致性 */
+ {
+ int scan_offset = 0;
+ bool first_frame = true;
+
+ while (scan_offset < len) {
+ /* 解析header中的关键字段 */
+ msgid = UTILS_BITFIELD_GET(buf[scan_offset + 1], 3, 0);
+ totalframe = buf[scan_offset + 2];
+ frameseq = buf[scan_offset + 3];
+ frame_payload_len = buf[scan_offset + 4];
+ datalen = proto_bytes_get_le16(&buf[scan_offset + 6]);
+ BLEPROTO_T_S("[%u/%u]=0x%02X(%u),msgid:%u,datalen:0x%02X(%u)",
+ frameseq,
+ totalframe,
+ frame_payload_len,
+ frame_payload_len,
+ msgid,
+ datalen,
+ datalen);
+
+ /* 基本参数检查 */
+ if (totalframe == 0) {
+ BLEPROTO_T_E("Invalid totalframe");
+ return -1;
+ }
+ if (frameseq > totalframe) {
+ BLEPROTO_T_E("Invalid frameseq");
+ return -1;
+ }
+ if (datalen > BLEPROTO_APPDATA_DATA_MAX_SZ) {
+ BLEPROTO_T_E("Invalid datalen");
+ return -1;
+ }
+
+ /* 分包一致性检查 */
+ if (first_frame) {
+ first_frame = false;
+ // 使用第一帧的payload长度作为最大payload
+ max_payload = frame_payload_len;
+ } else {
+ /* 检查msgid一致性 */
+ if (msgid != UTILS_BITFIELD_GET(buf[1], 3, 0)) {
+ BLEPROTO_T_E("Inconsistent msgid");
+ return -1;
+ }
+ /* 检查totalframe一致性 */
+ if (totalframe != buf[2]) {
+ BLEPROTO_T_E("Inconsistent totalframe");
+ return -1;
+ }
+ /* 检查frameseq连续性 */
+ uint8_t last_frameseq =
+ buf[scan_offset -
+ (BLEPROTO_APPDATA_HEADR_LEN + max_payload) + 3];
+ if (frameseq != (last_frameseq + 1)) {
+ BLEPROTO_T_E("Non-sequential frameseq:%u!=%u",
+ frameseq,
+ (last_frameseq + 1));
+ return -1;
+ }
+ /* 检查非最后一帧的payload长度是否与第一帧相同 */
+ if (frameseq < (totalframe - 1) &&
+ frame_payload_len != max_payload) {
+ BLEPROTO_T_E("Inconsistent frame payload length");
+ return -1;
+ }
+ }
+
+ /* 检查payload长度 */
+ if ((len - scan_offset) <
+ (BLEPROTO_APPDATA_HEADR_LEN + frame_payload_len)) {
+ return 0; // 需要更多数据
+ }
+
+ /* 验证frame_payload_len */
+ if (totalframe == 1) {
+ if (frame_payload_len != datalen) {
+ BLEPROTO_T_E(
+ "Invalid frame_payload_len for single frame");
+ return -1;
+ }
+ } else {
+ if (frameseq < totalframe) {
+ /* 非最后一帧必须是满包 */
+ if (frame_payload_len != max_payload) {
+ BLEPROTO_T_E(
+ "Invalid frame_payload_len for non-last frame");
+ return -1;
+ }
+ } else {
+ /* 最后一帧的长度计算 */
+ uint16_t last_frame_payload = datalen % max_payload;
+ if (last_frame_payload == 0) {
+ last_frame_payload = max_payload;
+ }
+ if (frame_payload_len != last_frame_payload) {
+ BLEPROTO_T_E(
+ "Invalid frame_payload_len for last frame(%u!=%u)",
+ frame_payload_len,
+ last_frame_payload);
+ return -1;
+ }
+ }
+ }
+
+ /* recv_frames */
+ recv_frames++;
+
+ scan_offset += BLEPROTO_APPDATA_HEADR_LEN + frame_payload_len;
+ }
+
+ /* 检查是否收到了完整的包 */
+ if (recv_frames != totalframe) {
+ // 还没收到所有分包
+ return 0;
+ }
+ }
+
+ /* 第二轮: 解析数据并填充到appdata结构中 */
+ {
+ /* 解析第一帧header */
+ bleproto_appdata_header_t *hdr = &appdata->header;
+
+ /* buf[0]: version[2:0] | datafmt[3:3] | msgtype[7:4] */
+ hdr->version = UTILS_BITFIELD_GET(buf[0], 2, 0);
+ hdr->datafmt = UTILS_BITFIELD_GET(buf[0], 3, 3);
+ hdr->msgtype = UTILS_BITFIELD_GET(buf[0], 7, 4);
+
+ /* buf[1]: msgid[3:0] | encrypt[4:4] | reserve[7:5] */
+ hdr->msgid = UTILS_BITFIELD_GET(buf[1], 3, 0);
+ hdr->encrypt = UTILS_BITFIELD_GET(buf[1], 4, 4);
+ hdr->reserve = UTILS_BITFIELD_GET(buf[1], 7, 5);
+
+ hdr->totalframe = buf[2];
+ hdr->frameseq = buf[3];
+ hdr->framelen = buf[4];
+ hdr->serviceid = buf[5];
+ hdr->datalen = proto_bytes_get_le16(&buf[6]);
+
+ /* 复制所有payload数据 */
+ uint16_t data_offset = 0;
+ uint8_t frames_processed = 0;
+
+ /* clear offset */
+ offset = 0;
+ while (frames_processed < hdr->totalframe) {
+ /* this frame payload length */
+ frame_payload_len = buf[offset + 4];
+
+ if (frame_payload_len > 0) {
+ uint8_t curr_frameseq = buf[offset + 3];
+ if (curr_frameseq == 0) {
+ data_offset = 0;
+ } else {
+ data_offset = (curr_frameseq - 1) * max_payload;
+ }
+
+ /* copy payload data */
+ memcpy(&appdata->data[data_offset],
+ &buf[offset + BLEPROTO_APPDATA_HEADR_LEN],
+ frame_payload_len);
+ }
+
+ offset += BLEPROTO_APPDATA_HEADR_LEN + frame_payload_len;
+ frames_processed++;
+ }
+ }
+
+ /* 返回处理的字节数 */
+ return offset;
+}
+
+int bleproto_encjson_ycmd(const bleproto_ycmd_t *ycmd,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+ uint16_t i;
+
+ /* check param */
+ if (!ycmd || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+ if (ycmd->arg_int32_count > YCMD_INT32_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_int32_count");
+ return -1;
+ }
+ if (ycmd->arg_string_count > YCMD_STRING_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_string_count");
+ return -1;
+ }
+ for (i = 0; i < ycmd->arg_string_count; i++) {
+ if (strlen(ycmd->arg_string[i]) == 0) {
+ BLEPROTO_T_E("Invalid ycmd.arg_string[%u]", i);
+ return -1;
+ }
+ }
+
+ if (ycmd->arg_bytes_count > YCMD_BYTES_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_bytes_count");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // cmd_id
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%" PRId32 ",",
+ "cmd_id",
+ (int)ycmd->cmd_id);
+ }
+
+ // arg_int32
+ if (ycmd->arg_int32_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_int32");
+ for (i = 0; i < ycmd->arg_int32_count; i++) {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "%" PRId32 "",
+ ycmd->arg_int32[i]);
+ if (i != ycmd->arg_int32_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_string
+ if (ycmd->arg_string_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_string");
+ for (i = 0; i < ycmd->arg_string_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\"", ycmd->arg_string[i]);
+ if (i != ycmd->arg_string_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_bytes
+ if (ycmd->arg_bytes_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":\"", "arg_bytes");
+ for (i = 0; i < ycmd->arg_bytes_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "%02X", ycmd->arg_bytes[i]);
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "\",");
+ }
+
+ // t
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%" PRIu64 "\"",
+ "t",
+ ycmd->t);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("ycmd:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_decjson_ycmd(const uint8_t * data,
+ uint16_t len,
+ bleproto_ycmd_t *ycmd)
+{
+ int rc, i;
+
+ /* check param */
+ if (!data || len == 0 || !ycmd) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("ycmd:%.*s", (int)len, str);
+
+ /* clear */
+ memset(ycmd, 0, sizeof(*ycmd));
+
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // cmd_id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.cmd_id",
+ /* v */ &v);
+ if (rc > 0) {
+ ycmd->cmd_id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse cmd_id");
+ return -1;
+ }
+
+ // arg_int32
+ for (i = 0; i < YCMD_INT32_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_int32[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_int32[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_NUMBER) {
+ char vstr[32] = { 0 };
+ memcpy(vstr, ptr, UTILS_MIN(n, 31));
+ ycmd->arg_int32[ycmd->arg_int32_count] =
+ (int32_t)strtol(vstr, NULL, 10);
+ ycmd->arg_int32_count++;
+ }
+ }
+
+ // arg_string
+ for (i = 0; i < YCMD_STRING_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_string[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_string[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_STRING) {
+ if (n >= 2 && ptr[0] == '"' && ptr[n - 1] == '"') {
+ ptr++; // 跳过首引号
+ n -= 2; // 去掉首尾引号的长度
+ } else {
+ BLEPROTO_T_E("Error parse arg_string");
+ return -1;
+ }
+ memcpy(ycmd->arg_string[ycmd->arg_string_count],
+ ptr,
+ UTILS_MIN(n, YCMD_STRING_MAX_SIZE));
+ ycmd->arg_string_count++;
+ }
+ }
+
+ // arg_bytes
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.arg_bytes",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ // strhex to byte
+ rc = proto_strhex_to_byte(
+ value_str, ycmd->arg_bytes, sizeof(ycmd->arg_bytes));
+ if (rc >= 0) {
+ ycmd->arg_bytes_count = (uint16_t)rc;
+ }
+ }
+
+ // t
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.t",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ ycmd->t = (uint64_t)strtoull(value_str, NULL, 10);
+ } else {
+ BLEPROTO_T_E("Error parse t");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_encjson_deviceinfo_req(const bleproto_deviceinfo_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ //{"t":"xxxxxxxx",gmtoff:%d}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // t
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"t\":\"%" PRIu64 "\",", p->t);
+ }
+
+ // gmtoff
+ {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"gmtoff\":%d", p->gmtoff);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_deviceinfo_rsp(const bleproto_deviceinfo_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* check params */
+ if (strlen(p->hwv) == 0) {
+ BLEPROTO_T_E("Invalid deviceinfo.rsp.hwv");
+ return -1;
+ }
+ if (strlen(p->swv) == 0) {
+ BLEPROTO_T_E("Invalid deviceinfo.rsp.swv");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"hwv":"%s","swv":"%s","prototype":%u,"hbcycle":%u,"longcon":%u}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // hwv
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":\"%s\",", "hwv", p->hwv);
+ }
+ // swv
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":\"%s\",", "swv", p->swv);
+ }
+ // prototype
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%u,",
+ "prototype",
+ p->prototype);
+ }
+ // hbcycle
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":%u,", "hbcycle", p->hbcycle);
+ }
+ // longcon
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":%u", "longcon", p->longcon);
+ }
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_authsetup_req(const bleproto_authsetup_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* check params */
+ if (strlen(p->devid) == 0) {
+ BLEPROTO_T_E("Invalid authsetup.req.devid");
+ return -1;
+ }
+ if (strlen(p->authcode) == 0) {
+ BLEPROTO_T_E("Invalid authsetup.req.authcode");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"gwmac":"xxxx","devid":"xxxx","authcode":"xxxx"}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // gwmac
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%02X%02X%02X%02X%02X%02X\",",
+ "gwmac",
+ p->gwmac[0],
+ p->gwmac[1],
+ p->gwmac[2],
+ p->gwmac[3],
+ p->gwmac[4],
+ p->gwmac[5]);
+ }
+
+ // devid
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":\"%s\",", "devid", p->devid);
+ }
+
+ // authcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%s\"",
+ "authcode",
+ p->authcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_authsetup_rsp(const bleproto_authsetup_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"errcode":xxx}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // errcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "errcode",
+ (int)p->errcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_authdelete_req(const bleproto_authdelete_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* check params */
+ if (strlen(p->authcode) == 0) {
+ BLEPROTO_T_E("Invalid authdelete.req.authcode");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // { "authcode": "xxxx"}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // authcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%s\"",
+ "authcode",
+ p->authcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_authdelete_rsp(const bleproto_authdelete_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"gwmac": "xxxx","errcode":xxx}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // gwmac
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%02X%02X%02X%02X%02X%02X\",",
+ "gwmac",
+ p->gwmac[0],
+ p->gwmac[1],
+ p->gwmac[2],
+ p->gwmac[3],
+ p->gwmac[4],
+ p->gwmac[5]);
+ }
+
+ // errcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "errcode",
+ (int)p->errcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_runcmd_req(const bleproto_runcmd_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+ uint16_t i;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+ if (p->ycmd.arg_int32_count > YCMD_INT32_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_int32_count");
+ return -1;
+ }
+ if (p->ycmd.arg_string_count > YCMD_STRING_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_string_count");
+ return -1;
+ }
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ if (strlen(p->ycmd.arg_string[i]) == 0) {
+ BLEPROTO_T_E("Invalid runcmd.req.arg_string[%u]", i);
+ return -1;
+ }
+ }
+
+ if (p->ycmd.arg_bytes_count > YCMD_BYTES_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_bytes_count");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // cmd_id
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%" PRId32 ",",
+ "cmd_id",
+ (int)p->ycmd.cmd_id);
+ }
+
+ // arg_int32
+ if (p->ycmd.arg_int32_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_int32");
+ for (i = 0; i < p->ycmd.arg_int32_count; i++) {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "%" PRId32 "",
+ p->ycmd.arg_int32[i]);
+ if (i != p->ycmd.arg_int32_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_string
+ if (p->ycmd.arg_string_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_string");
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\"", p->ycmd.arg_string[i]);
+ if (i != p->ycmd.arg_string_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_bytes
+ if (p->ycmd.arg_bytes_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":\"", "arg_bytes");
+ for (i = 0; i < p->ycmd.arg_bytes_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "%02X", p->ycmd.arg_bytes[i]);
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "\",");
+ }
+
+ // t
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%" PRIu64 "\"",
+ "t",
+ p->ycmd.t);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_runcmd_rsp(const bleproto_runcmd_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+ uint16_t i;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+ if (p->ycmd.arg_int32_count > YCMD_INT32_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_int32_count");
+ return -1;
+ }
+ if (p->ycmd.arg_string_count > YCMD_STRING_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_string_count");
+ return -1;
+ }
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ if (strlen(p->ycmd.arg_string[i]) == 0) {
+ BLEPROTO_T_E("Invalid runcmd.rsp.arg_string[%u]", i);
+ return -1;
+ }
+ }
+ if (p->ycmd.arg_bytes_count > YCMD_BYTES_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_bytes_count");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // cmd_id
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%" PRId32 ",",
+ "cmd_id",
+ (int)p->ycmd.cmd_id);
+ }
+
+ // arg_int32
+ if (p->ycmd.arg_int32_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_int32");
+ for (i = 0; i < p->ycmd.arg_int32_count; i++) {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "%" PRId32 "",
+ p->ycmd.arg_int32[i]);
+ if (i != p->ycmd.arg_int32_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_string
+ if (p->ycmd.arg_string_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_string");
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\"", p->ycmd.arg_string[i]);
+ if (i != p->ycmd.arg_string_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_bytes
+ if (p->ycmd.arg_bytes_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":\"", "arg_bytes");
+ for (i = 0; i < p->ycmd.arg_bytes_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "%02X", p->ycmd.arg_bytes[i]);
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "\",");
+ }
+
+ // t
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%" PRIu64 "\"",
+ "t",
+ p->ycmd.t);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_reportcmd_req(const bleproto_reportcmd_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+ uint16_t i;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+ if (p->ycmd.arg_int32_count > YCMD_INT32_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_int32_count");
+ return -1;
+ }
+ if (p->ycmd.arg_string_count > YCMD_STRING_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_string_count");
+ return -1;
+ }
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ if (strlen(p->ycmd.arg_string[i]) == 0) {
+ BLEPROTO_T_E("Invalid reportcmd.req.arg_string[%u]", i);
+ return -1;
+ }
+ }
+ if (p->ycmd.arg_bytes_count > YCMD_BYTES_MAX_COUNT) {
+ BLEPROTO_T_E("Invalid ycmd.arg_bytes_count");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx"}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // cmd_id
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%" PRId32 ",",
+ "cmd_id",
+ (int)p->ycmd.cmd_id);
+ }
+
+ // arg_int32
+ if (p->ycmd.arg_int32_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_int32");
+ for (i = 0; i < p->ycmd.arg_int32_count; i++) {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "%" PRId32 "",
+ p->ycmd.arg_int32[i]);
+ if (i != p->ycmd.arg_int32_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_string
+ if (p->ycmd.arg_string_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":[", "arg_string");
+ for (i = 0; i < p->ycmd.arg_string_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\"", p->ycmd.arg_string[i]);
+ if (i != p->ycmd.arg_string_count - 1) {
+ offset += snprintf(&str[offset], size - offset, "%s", ",");
+ }
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "],");
+ }
+
+ // arg_bytes
+ if (p->ycmd.arg_bytes_count > 0) {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":\"", "arg_bytes");
+ for (i = 0; i < p->ycmd.arg_bytes_count; i++) {
+ offset += snprintf(
+ &str[offset], size - offset, "%02X", p->ycmd.arg_bytes[i]);
+ }
+ offset += snprintf(&str[offset], size - offset, "%s", "\",");
+ }
+
+ // t
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":\"%" PRIu64 "\"",
+ "t",
+ p->ycmd.t);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_reportcmd_rsp(const bleproto_reportcmd_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"errcode":xxx}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // errcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "errcode",
+ (int)p->errcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_doaction_req(const bleproto_doaction_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"action":%d}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // action
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":%d", "action", p->action);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_doaction_rsp(const bleproto_doaction_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"errcode":xxx}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // errcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "errcode",
+ (int)p->errcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_otanotify_req(const bleproto_otanotify_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"id": %d, "ver":"xxxx", "size":%d, "md5":"xxxxxxx"}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // id
+ {
+ offset +=
+ snprintf(&str[offset], size - offset, "\"%s\":%d,", "id", p->id);
+ }
+ // ver
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":\"%s\",", "ver", p->version);
+ }
+ // size
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":%u,", "size", p->size);
+ }
+ // md5
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":\"%s\",", "md5", p->md5);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_otanotify_rsp(const bleproto_otanotify_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"errcode":xxx}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // errcode
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "errcode",
+ (int)p->errcode);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encjson_otadata_req(const bleproto_otadata_req_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ char *str = (char *)data;
+ // {"id": %d, "offset":%d, "maxsize":%d}
+
+ // {
+ offset = snprintf(str, size, "%s", "{");
+
+ // id
+ {
+ offset += snprintf(
+ &str[offset], size - offset, "\"%s\":%d, ", "id", (int)p->id);
+ }
+ // offset
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d, ",
+ "offset",
+ (int)p->offset);
+ }
+ // maxsize
+ {
+ offset += snprintf(&str[offset],
+ size - offset,
+ "\"%s\":%d",
+ "maxsize",
+ (int)p->maxsize);
+ }
+
+ // }
+ offset += snprintf((&str[offset]), size - offset, "%s", "}");
+
+ /* dump output data */
+ BLEPROTO_T_D("data:%.*s", (int)offset, str);
+
+ return (offset);
+}
+
+int bleproto_encbin_otadata_rsp(const bleproto_otadata_rsp_t *p,
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ])
+{
+ int offset = 0, size = BLEPROTO_APPDATA_DATA_MAX_SZ;
+
+ /* check param */
+ if (!p || !data) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* check buffer size */
+ if ((size_t)size < (sizeof(p->errcode) + sizeof(p->id) +
+ sizeof(p->offset) + sizeof(p->len) + p->len)) {
+ BLEPROTO_T_E("Buffer too small");
+ return -1;
+ }
+
+ /* serialize errcode (little-endian) */
+ data[offset++] = (uint8_t)(p->errcode & 0xFF);
+ data[offset++] = (uint8_t)((p->errcode >> 8) & 0xFF);
+ data[offset++] = (uint8_t)((p->errcode >> 16) & 0xFF);
+ data[offset++] = (uint8_t)((p->errcode >> 24) & 0xFF);
+
+ /* serialize id (little-endian) */
+ data[offset++] = (uint8_t)(p->id & 0xFF);
+ data[offset++] = (uint8_t)((p->id >> 8) & 0xFF);
+ data[offset++] = (uint8_t)((p->id >> 16) & 0xFF);
+ data[offset++] = (uint8_t)((p->id >> 24) & 0xFF);
+
+ /* serialize offset (little-endian) */
+ data[offset++] = (uint8_t)(p->offset & 0xFF);
+ data[offset++] = (uint8_t)((p->offset >> 8) & 0xFF);
+ data[offset++] = (uint8_t)((p->offset >> 16) & 0xFF);
+ data[offset++] = (uint8_t)((p->offset >> 24) & 0xFF);
+
+ /* serialize len (little-endian) */
+ data[offset++] = (uint8_t)(p->len & 0xFF);
+ data[offset++] = (uint8_t)((p->len >> 8) & 0xFF);
+ data[offset++] = (uint8_t)((p->len >> 16) & 0xFF);
+ data[offset++] = (uint8_t)((p->len >> 24) & 0xFF);
+
+ /* serialize data（data 为外部指针，不再内嵌数组） */
+ if (p->len > 0 && p->len <= BLEPROTO_APPDATA_OTADATA_SZ) {
+ if (!p->data) {
+ BLEPROTO_T_E("otadata_rsp.data is NULL");
+ return -1;
+ }
+ memcpy(&data[offset], p->data, p->len);
+ offset += p->len;
+ }
+
+ return offset;
+}
+
+int bleproto_decjson_deviceinfo_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_deviceinfo_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ //{"t":"xxxxxxxx",gmtoff:%d}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // t
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.t",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ p->t = (uint64_t)strtoull(value_str, NULL, 10);
+ } else {
+ BLEPROTO_T_E("Error parse t");
+ return -1;
+ }
+
+ // gmtoff
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.gmtoff",
+ /* result */ &v);
+ if (rc > 0) {
+ p->gmtoff = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse gmtoff");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_deviceinfo_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_deviceinfo_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"hwv":"%s","swv":"%s","prototype":%u, "hbcycle":%u,"longcon":%u}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // hwv
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.hwv",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->hwv, sizeof(p->hwv), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse hwv");
+ return -1;
+ }
+
+ // swv
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.swv",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->swv, sizeof(p->swv), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse swv");
+ return -1;
+ }
+
+ // prototype
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.prototype",
+ /* result */ &v);
+ if (rc > 0) {
+ p->prototype = (uint8_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse prototype");
+ return -1;
+ }
+
+ // hbcycle
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.hbcycle",
+ /* result */ &v);
+ if (rc > 0) {
+ p->hbcycle = (uint32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse hbcycle");
+ return -1;
+ }
+
+ // longcon
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.longcon",
+ /* result */ &v);
+ if (rc > 0) {
+ p->longcon = (uint8_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse longcon");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_authsetup_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_authsetup_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"gwmac":"xxxx","devid":"xxxx","authcode":"xxxx"}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+
+ // gwmac
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.gwmac",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ int nr = proto_strhex_to_byte(value_str, p->gwmac, sizeof(p->gwmac));
+ if (nr != (int)sizeof(p->gwmac)) {
+ BLEPROTO_T_E("Error parse gwmac");
+ return -1;
+ }
+ } else {
+ BLEPROTO_T_E("Error parse gwmac");
+ return -1;
+ }
+
+ // devid
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.devid",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->devid, sizeof(p->devid), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse devid");
+ return -1;
+ }
+
+ // authcode
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.authcode",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->authcode, sizeof(p->authcode), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse authcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_authsetup_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_authsetup_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"errcode":xxx}
+ double v;
+
+ // errcode
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.errcode",
+ /* result */ &v);
+ if (rc > 0) {
+ p->errcode = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_authdelete_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_authdelete_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"authcode": "xxxx"}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+
+ // authcode
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.authcode",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->authcode, sizeof(p->authcode), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse authcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_authdelete_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_authdelete_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"gwmac":"xxxx","errcode":xxx}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // gwmac
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.gwmac",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ int nr = proto_strhex_to_byte(value_str, p->gwmac, sizeof(p->gwmac));
+ if (nr != (int)sizeof(p->gwmac)) {
+ BLEPROTO_T_E("Error parse gwmac");
+ return -1;
+ }
+ } else {
+ BLEPROTO_T_E("Error parse gwmac");
+ return -1;
+ }
+
+ // errcode
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.errcode",
+ /* result */ &v);
+ if (rc > 0) {
+ p->errcode = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_runcmd_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_runcmd_req_t *p)
+{
+ int rc, i;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // cmd_id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.cmd_id",
+ /* v */ &v);
+ if (rc > 0) {
+ p->ycmd.cmd_id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse cmd_id");
+ return -1;
+ }
+
+ // arg_int32
+ for (i = 0; i < YCMD_INT32_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_int32[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_int32[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_NUMBER) {
+ char vstr[32] = { 0 };
+ memcpy(vstr, ptr, UTILS_MIN(n, 31));
+ p->ycmd.arg_int32[p->ycmd.arg_int32_count] =
+ (int32_t)strtol(vstr, NULL, 10);
+ p->ycmd.arg_int32_count++;
+ }
+ }
+
+ // arg_string
+ for (i = 0; i < YCMD_STRING_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_string[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_string[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_STRING) {
+ if (n >= 2 && ptr[0] == '"' && ptr[n - 1] == '"') {
+ ptr++; // 跳过首引号
+ n -= 2; // 去掉首尾引号的长度
+ } else {
+ BLEPROTO_T_E("Error parse arg_string");
+ return -1;
+ }
+ memcpy(p->ycmd.arg_string[p->ycmd.arg_string_count],
+ ptr,
+ UTILS_MIN(n, YCMD_STRING_MAX_SIZE));
+ p->ycmd.arg_string_count++;
+ }
+ }
+
+ // arg_bytes
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.arg_bytes",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ // strhex to byte
+ rc = proto_strhex_to_byte(
+ value_str, p->ycmd.arg_bytes, sizeof(p->ycmd.arg_bytes));
+ if (rc >= 0) {
+ p->ycmd.arg_bytes_count = (uint16_t)rc;
+ }
+ }
+
+ // t
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.t",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ p->ycmd.t = (uint64_t)strtoull(value_str, NULL, 10);
+ } else {
+ BLEPROTO_T_E("Error parse t");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_runcmd_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_runcmd_rsp_t *p)
+{
+ int rc, i;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // cmd_id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.cmd_id",
+ /* v */ &v);
+ if (rc > 0) {
+ p->ycmd.cmd_id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse cmd_id");
+ return -1;
+ }
+
+ // arg_int32
+ for (i = 0; i < YCMD_INT32_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_int32[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_int32[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_NUMBER) {
+ char vstr[32] = { 0 };
+ memcpy(vstr, ptr, UTILS_MIN(n, 31));
+ p->ycmd.arg_int32[p->ycmd.arg_int32_count] =
+ (int32_t)strtol(vstr, NULL, 10);
+ p->ycmd.arg_int32_count++;
+ }
+ }
+
+ // arg_string
+ for (i = 0; i < YCMD_STRING_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_string[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_string[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_STRING) {
+ if (n >= 2 && ptr[0] == '"' && ptr[n - 1] == '"') {
+ ptr++; // 跳过首引号
+ n -= 2; // 去掉首尾引号的长度
+ } else {
+ BLEPROTO_T_E("Error parse arg_string");
+ return -1;
+ }
+ memcpy(p->ycmd.arg_string[p->ycmd.arg_string_count],
+ ptr,
+ UTILS_MIN(n, YCMD_STRING_MAX_SIZE));
+ p->ycmd.arg_string_count++;
+ }
+ }
+
+ // arg_bytes
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.arg_bytes",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ // strhex to byte
+ rc = proto_strhex_to_byte(
+ value_str, p->ycmd.arg_bytes, sizeof(p->ycmd.arg_bytes));
+ if (rc >= 0) {
+ p->ycmd.arg_bytes_count = (uint16_t)rc;
+ }
+ }
+
+ // t
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.t",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ p->ycmd.t = (uint64_t)strtoull(value_str, NULL, 10);
+ } else {
+ BLEPROTO_T_E("Error parse t");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_reportcmd_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_reportcmd_req_t *p)
+{
+ int rc, i;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"cmd_id":xxxx,"arg_int32":[],"arg_string":[],"arg_bytes":"xxxx","t":"xxxxxxxx" }
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // cmd_id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.cmd_id",
+ /* v */ &v);
+ if (rc > 0) {
+ p->ycmd.cmd_id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse cmd_id");
+ return -1;
+ }
+
+ // arg_int32
+ for (i = 0; i < YCMD_INT32_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_int32[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_int32[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_NUMBER) {
+ char vstr[32] = { 0 };
+ memcpy(vstr, ptr, UTILS_MIN(n, 31));
+ p->ycmd.arg_int32[p->ycmd.arg_int32_count] =
+ (int32_t)strtol(vstr, NULL, 10);
+ p->ycmd.arg_int32_count++;
+ }
+ }
+
+ // arg_string
+ for (i = 0; i < YCMD_STRING_MAX_COUNT; i++) {
+ const char *ptr = NULL;
+ int n;
+ char key[sizeof("$.arg_string[65535]") + 1] = { 0 };
+ snprintf(key, sizeof(key), "$.arg_string[%d]", i);
+ if (mjson_find(str, (int)len, key, &ptr, &n) == MJSON_TOK_STRING) {
+ if (n >= 2 && ptr[0] == '"' && ptr[n - 1] == '"') {
+ ptr++; // 跳过首引号
+ n -= 2; // 去掉首尾引号的长度
+ } else {
+ BLEPROTO_T_E("Error parse arg_string");
+ return -1;
+ }
+ memcpy(p->ycmd.arg_string[p->ycmd.arg_string_count],
+ ptr,
+ UTILS_MIN(n, YCMD_STRING_MAX_SIZE));
+ p->ycmd.arg_string_count++;
+ }
+ }
+
+ // arg_bytes
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.arg_bytes",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ // strhex to byte
+ rc = proto_strhex_to_byte(
+ value_str, p->ycmd.arg_bytes, sizeof(p->ycmd.arg_bytes));
+ if (rc >= 0) {
+ p->ycmd.arg_bytes_count = (uint16_t)rc;
+ }
+ }
+
+ // t
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.t",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ p->ycmd.t = (uint64_t)strtoull(value_str, NULL, 10);
+ } else {
+ BLEPROTO_T_E("Error parse t");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_reportcmd_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_reportcmd_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"errcode":xxx}
+ double v;
+
+ // errcode
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.errcode",
+ /* result */ &v);
+ if (rc > 0) {
+ p->errcode = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_doaction_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_doaction_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"action":%d}
+ double v;
+
+ // action
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.action",
+ /* v */ &v);
+ if (rc > 0) {
+ p->action = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse action");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_doaction_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_doaction_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"errcode":xxx}
+ double v;
+
+ // errcode
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.errcode",
+ /* result */ &v);
+ if (rc > 0) {
+ p->errcode = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_otanotify_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_otanotify_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"id": %d, "ver":"xxxx", "size":%d, "md5":"xxxxxxx"}
+ char value_str[BLEPROTO_APPDATA_DATA_MAX_SZ] = { 0 };
+ double v;
+
+ // id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.id",
+ /* result */ &v);
+ if (rc > 0) {
+ p->id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ // ver
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.ver",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->version, sizeof(p->version), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse version");
+ return -1;
+ }
+
+ // size
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.size",
+ /* result */ &v);
+ if (rc > 0) {
+ p->size = (uint32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ // md5
+ rc = mjson_get_string(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.md5",
+ /* to */ value_str,
+ /* n */ (int)sizeof(value_str));
+ if (rc > 0) {
+ snprintf(p->md5, sizeof(p->md5), "%s", value_str);
+ } else {
+ BLEPROTO_T_E("Error parse md5");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_otanotify_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_otanotify_rsp_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"errcode":xxx}
+ double v;
+
+ // errcode
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.errcode",
+ /* result */ &v);
+ if (rc > 0) {
+ p->errcode = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_decjson_otadata_req(const uint8_t * data,
+ uint16_t len,
+ bleproto_otadata_req_t *p)
+{
+ int rc;
+
+ /* check param */
+ if (!data || len == 0 || !p) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ const char *str = (const char *)data;
+ /* dump input data */
+ BLEPROTO_T_D("data:%.*s", (int)len, str);
+
+ /* clear */
+ memset(p, 0, sizeof(*p));
+
+ // {"id": %d, "offset":%d, "maxsize":%d}
+ double v;
+
+ // id
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.id",
+ /* result */ &v);
+ if (rc > 0) {
+ p->id = (int)v;
+ } else {
+ BLEPROTO_T_E("Error parse errcode");
+ return -1;
+ }
+
+ // offset
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.offset",
+ /* result */ &v);
+ if (rc > 0) {
+ p->offset = (int32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse offset");
+ return -1;
+ }
+
+ // maxsize
+ rc = mjson_get_number(
+ /* s */ str,
+ /* len */ (int)len,
+ /* path */ "$.maxsize",
+ /* result */ &v);
+ if (rc > 0) {
+ p->maxsize = (uint32_t)v;
+ } else {
+ BLEPROTO_T_E("Error parse maxsize");
+ return -1;
+ }
+
+ return (0);
+}
+
+int bleproto_debin_otadata_rsp(const uint8_t * data,
+ uint16_t len,
+ bleproto_otadata_rsp_t *rsp)
+{
+ int offset = 0;
+
+ /* check param */
+ if (!data || len == 0 || !rsp) {
+ BLEPROTO_T_E("Invalid parameters");
+ return -1;
+ }
+
+ /* check minimum buffer size (errcode + id + offset + len = 16 bytes) */
+ if (len < 16) {
+ BLEPROTO_T_E("Buffer too small");
+ return -1;
+ }
+
+ /* deserialize errcode (little-endian) */
+ rsp->errcode =
+ ((int32_t)data[offset]) | ((int32_t)data[offset + 1] << 8) |
+ ((int32_t)data[offset + 2] << 16) | ((int32_t)data[offset + 3] << 24);
+ offset += 4;
+
+ /* deserialize id (little-endian) */
+ rsp->id = ((uint32_t)data[offset]) | ((uint32_t)data[offset + 1] << 8) |
+ ((uint32_t)data[offset + 2] << 16) |
+ ((uint32_t)data[offset + 3] << 24);
+ offset += 4;
+
+ /* deserialize offset (little-endian) */
+ rsp->offset = ((uint32_t)data[offset]) |
+ ((uint32_t)data[offset + 1] << 8) |
+ ((uint32_t)data[offset + 2] << 16) |
+ ((uint32_t)data[offset + 3] << 24);
+ offset += 4;
+
+ /* deserialize len (little-endian) */
+ rsp->len = ((uint32_t)data[offset]) | ((uint32_t)data[offset + 1] << 8) |
+ ((uint32_t)data[offset + 2] << 16) |
+ ((uint32_t)data[offset + 3] << 24);
+ offset += 4;
+
+ /* check data length validity */
+ if (rsp->len > BLEPROTO_APPDATA_OTADATA_SZ) {
+ BLEPROTO_T_E("Data length too large: %u", rsp->len);
+ return -1;
+ }
+
+ /* check remaining buffer size */
+ if (len < (offset + rsp->len)) {
+ BLEPROTO_T_E("Insufficient data for payload");
+ return -1;
+ }
+
+ /* 零拷贝：指向输入缓冲，调用方须在下次 decode 前用完 */
+ if (rsp->len > 0) {
+ rsp->data = &data[offset];
+ offset += rsp->len;
+ } else {
+ rsp->data = NULL;
+ }
+
+ return offset;
+}
+/****************************************************************************/
+/* */
+/* End of file. */
+/* */
+/****************************************************************************/
diff --git a/apps/usr_le_code/bleproto_packer.h b/apps/usr_le_code/bleproto_packer.h
new file mode 100644
index 0000000..8ec82c1
--- /dev/null
+++ b/apps/usr_le_code/bleproto_packer.h
@@ -0,0 +1,702 @@
+/****************************************************************************/
+/* bleproto_packer.h
+ *
+ * Copyright (C) 2020 wanshijie wanshijie@126.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ ****************************************************************************/
+/**
+ * @addtogroup bleproto_packer packer
+ * @ingroup bleproto_api
+ * @brief ble proto packer
+ *
+ * @{
+ */
+#ifndef BLEPROTO_PACKER_H_INCLUDE
+#define BLEPROTO_PACKER_H_INCLUDE
+/****************************************************************************/
+/* Included Files */
+/****************************************************************************/
+
+#include "system/includes.h"
+
+
+#if !defined(BLEPROTO_API_H_INCLUDE)
+#error "Only 'bleproto/bleproto_api.h' can be included directly."
+#endif /* BLEPROTO_API_H_INCLUDE */
+
+/****************************************************************************/
+/* Configure Definitions */
+/****************************************************************************/
+
+#define BLEPOROTO_RAM_LARGE 0 ///< 大內存模式
+#define BLEPOROTO_RAM_MID 1 ///< 中等內存模式
+#define BLEPOROTO_RAM_SMALL 2 ///< 小內存模式
+
+/* default 內存模式 */
+#ifndef BLEPOROTO_RAM_MODE
+//#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_LARGE
+//#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_MID
+#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_SMALL
+#endif /* BLEPOROTO_RAM_MODE */
+
+/****************************************************************************/
+/* Pre-processor Definitions */
+/****************************************************************************/
+
+///////////////////////////////////////////////////////////
+// trace log define
+///////////////////////////////////////////////////////////
+#ifndef BLEPROTO_TRACE_ENABLE
+#define BLEPROTO_TRACE_ENABLE 0//Jim
+#endif /* BLEPROTO_TRACE_ENABLE */
+
+/* trace default printf */
+#ifndef BLEPROTO_TRACE_PRINTF
+#define BLEPROTO_TRACE_PRINTF printf
+#endif /* BLEPROTO_TRACE_PRINTF */
+
+/* trace strfunc */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 19901L
+#define BLEPROTO_TRACE_STRFUNC ((const char *)(__func__))
+#else
+#define BLEPROTO_TRACE_STRFUNC ((const char *)(__FUNCTION__))
+#endif /* __STDC_VERSION__ */
+/* trace file line */
+#define BLEPROTO_TRACE_INTLINE ((int)(__LINE__))
+
+#if BLEPROTO_TRACE_ENABLE
+#define BLEPROTO_TRACE(lvl, ...) \
+ do { \
+ BLEPROTO_TRACE_PRINTF("[%s][%s:%d]", \
+ lvl, \
+ BLEPROTO_TRACE_STRFUNC, \
+ BLEPROTO_TRACE_INTLINE); \
+ BLEPROTO_TRACE_PRINTF(__VA_ARGS__); \
+ BLEPROTO_TRACE_PRINTF("\r\n"); \
+ } while (0)
+#else
+#define BLEPROTO_TRACE(lvl, ...) \
+ do { \
+ } while (0)
+#endif /* FLOG_TRACE_ENABLE */
+
+/* trace log error */
+#ifndef BLEPROTO_T_E
+#define BLEPROTO_T_E(...) BLEPROTO_TRACE("E", __VA_ARGS__)
+#endif /* BLEPROTO_T_E */
+
+/* trace log debug */
+#ifndef BLEPROTO_T_D
+#define BLEPROTO_T_D(...) BLEPROTO_TRACE("D", __VA_ARGS__)
+#endif /* BLEPROTO_T_D */
+
+/* printf log slient */
+#ifndef BLEPROTO_T_S
+#define BLEPROTO_T_S(...)
+#endif /* BLEPROTO_T_S */
+
+// clang-format off
+///////////////////////////////////////////////////////////
+// ADV
+///////////////////////////////////////////////////////////
+/** ADV Data Max Size. */
+#define BLEPROTO_ADV_MAX_SZ 31
+
+/** ADV Type: Flags. */
+#define BLEPROTO_ADV_TYPE_FLAGS 0x01
+/** ADV Type: Service Data - 16-bit UUID. */
+#define BLEPROTO_ADV_TYPE_SVC_DATA_UUID16 0x16
+/** ADV Type: Manufacturer Specific Data. */
+#define BLEPROTO_ADV_TYPE_MFG_DATA 0xff
+
+/** ADV service uuid */
+#define BLEPROTO_ADV_SERVICE_UUID_TOBIND 0xFDEE
+/** ADV service spec data version */
+#define BLEPORTO_ADV_SERVICE_SPEC_DATA_VER 0x01
+/** ADV service spec data business */
+#define BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND 0x01
+
+/* ADV TLV Type */
+#define BLEPROTO_ADV_TLV_TYPE_MANUCODE 0x10
+#define BLEPROTO_ADV_TLV_TYPE_PRODCODE 0x11
+/* ADV TLV Len */
+#define BLEPROTO_ADV_TLV_LENGTH_MANUCODE 4
+#define BLEPROTO_ADV_TLV_LENGTH_PRODCODE 4
+
+/* ADV PCDE */
+#define BLE_PROTO_ADV_LENGTH_PCODE 6
+
+/** ADV flag value */
+#define BLEPROTO_ADV_FLAG_HEARTBEAT 0x00
+#define BLEPROTO_ADV_FLAG_RECONNECT 0x01
+
+///////////////////////////////////////////////////////////
+// APPDATA
+///////////////////////////////////////////////////////////
+/** APPDATA header len 8bytes */
+#define BLEPROTO_APPDATA_HEADR_LEN 8
+/** APPDATA version */
+#define BLEPROTO_APPDATA_VERSION 0
+/** APPDATA data fmt */
+#define BLEPROTO_APPDATA_DATAFMT_JSON 0
+#define BLEPROTO_APPDATA_DATAFMT_RAW 1
+/** APPDATA msg type */
+#define BLEPROTO_APPDATA_MSGTYPE_REQ 0
+#define BLEPROTO_APPDATA_MSGTYPE_RSP 1
+
+#if (BLEPOROTO_RAM_MODE == BLEPOROTO_RAM_LARGE)
+/** APPDATA OTA data max size */
+#define BLEPROTO_APPDATA_OTADATA_SZ (1024*16)
+/** APPDATA data max size */
+#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
+/** APP tx buf max size */
+#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
+#elif (BLEPOROTO_RAM_MODE == BLEPOROTO_RAM_MID)
+/** APPDATA OTA data max size */
+#define BLEPROTO_APPDATA_OTADATA_SZ (1024*4)
+/** APPDATA data max size */
+#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
+/** APP tx buf max size */
+#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
+#else
+/** APPDATA OTA data max size */
+#define BLEPROTO_APPDATA_OTADATA_SZ (1024+1024+256)
+/** APPDATA data max size */
+#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
+/** APP tx buf max size */
+//#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
+#endif /* BLEPOROTO_RAM_MODE */
+
+// clang-format on
+
+/****************************************************************************/
+/* Public Types */
+/****************************************************************************/
+
+/**
+ * @brief 厂商编码-manucode(manufacturer code) TLV desc.
+ */
+typedef struct bleproto_adv_manucode {
+ // clang-format off
+ uint8_t type; ///< 厂商编码T, @ref BLEPROTO_ADV_TLV_TYPE_MANUCODE
+ uint8_t length; ///< 厂商编码L, @ref BLEPROTO_ADV_TLV_LEN_MANUCODE
+ uint8_t value[BLEPROTO_ADV_TLV_LENGTH_MANUCODE]; ///< 厂商信息V, 现在固定填写0x00000000
+ // clang-format off
+} bleproto_adv_manucode_t;
+
+/**
+ * @brief 产品型号-prodcode(product code) TLV desc.
+ */
+typedef struct bleproto_adv_prodcode {
+ // clang-format off
+ uint8_t type; ///< 产品型号T, @ref BLEPROTO_ADV_TLV_TYPE_PRODCODE
+ uint8_t length; ///< 产品型号L, @ref BLEPROTO_ADV_TLV_LENGTH_PRODCODE
+ uint8_t value[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]; ///< 产品型号V, 平台定义,需要转换成ASCII码值
+ // clang-format on
+} bleproto_adv_prodcode_t;
+
+/**
+ * @brief 请求配对广播的Spec Data结构.
+ */
+typedef struct bleproto_adv_specdata {
+ // clang-format off
+ uint8_t version; ///< 蓝牙广播协议版本, 当前1 @ref BLEPORTO_ADV_SERVICE_SPEC_DATA_VER
+ uint8_t business; ///< 设备发现模式, 固定填写0x01,表示靠近发现 @ref BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND
+ uint8_t rfu[2]; ///< 保留
+ int8_t txpower; ///< 蓝牙发射功率[-127,128]dBm
+ bleproto_adv_manucode_t manucode; ///< 厂商编码
+ bleproto_adv_prodcode_t prodcode; ///< 产品型号
+ uint8_t separator; ///< 分隔符, 固定填写0xFF
+ uint8_t selfdata[6]; ///< 自定义数据
+ // clang-format on
+} bleproto_adv_specdata_t;
+
+/**
+ * @brief 请求注册广播数据.
+ */
+typedef struct bleproto_advdata_service {
+ // clang-format off
+ uint16_t uuid; ///< 服务uuid16 @ref BLEPROTO_ADV_SERVICE_UUID_TOBIND
+ bleproto_adv_specdata_t spec_data;///< 协议数据(24bytes)
+ // clang-format on
+} bleproto_advdata_service_t;
+
+/**
+ * @brief 心跳广播, 回连广播数据.
+ */
+typedef struct bleproto_advdata_mfg {
+ // clang-format off
+ uint8_t siot[6]; ///< 固定填写SIOT-1
+ uint8_t flag; ///< 0表示心跳，1表示请求回连 @ref BLEPROTO_ADV_FLAG_HEARTBEAT or @ref BLEPROTO_ADV_FLAG_RECONNECT
+ int8_t txpower; ///< 蓝牙发射功率[-127,128]dBm
+ uint8_t gwmac[6]; ///< gwmac "11:22:33:44:55:66", gwmac[6] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }
+ bleproto_adv_manucode_t manucode; ///< 厂商编码
+ bleproto_adv_prodcode_t prodcode; ///< 产品型号
+ // clang-format on
+} bleproto_advdata_mfg_t;
+
+/**
+ * @brief AD Structure1结构.
+ */
+typedef struct bleproto_adv1 {
+ // clang-format off
+ /**
+ * 表示AD Type与AD Data的总长度,
+ * 此处取值固定为0x02
+ */
+ uint8_t length;
+
+ /**
+ * 表示该广播数据代表的含义
+ * 此处取值固定为0x01 @ref BLEPROTO_ADV_TYPE_FLAGS
+ */
+ uint8_t ad_type;
+
+ /**
+ * 固定为0x06，表示LE通用可发现模式，且不支持BR/EDR
+ * 表示蓝牙设备的物理连接能力,
+ * bit0：LE受限可发现模式。
+ * bit1：LE通用可发现模式。
+ * bit2：不支持BR/EDR。
+ * bit3：对Same Device Capable（控制器）同时支持BLE和BR/EDR。
+ * bit4：对Same Device Capable（主机）同时支持BLE和BR/EDR。
+ * bit5~7：预留
+ */
+ uint8_t ad_data;
+ // clang-format on
+} bleproto_adv1_t;
+
+/**
+ * @brief AD Structure2结构.
+ */
+typedef struct bleproto_adv2 {
+ // clang-format off
+ /**
+ * 表示AD Type与AD Data的总长度,
+ * 此处取值固定为0x1B = 27
+ */
+ uint8_t length;
+
+ /** 广播数据代表的含义
+ * BLEPROTO_ADV_TYPE_SVC_DATA_UUID16 - 0x16表示蓝牙服务数据(bleproto_advdata_service_t),
+ * BLEPROTO_ADV_TYPE_MFG_DATA - 0xFF表示厂商数据(bleproto_advdata_mfg_t)
+ */
+ uint8_t ad_type;
+
+ /** adv data */
+ union {
+ bleproto_advdata_service_t service_data; ///< 蓝牙服务数据(请求注册广播时携带)
+ bleproto_advdata_mfg_t mfg_data; ///< 厂商数据(心跳广播，回连广播时携带)
+ } ad_data;
+ // clang-format on
+} bleproto_adv2_t;
+
+/**
+ * @brief 广播数据总结构
+ */
+typedef struct bleproto_adv {
+ bleproto_adv1_t adv1; ///< ADV Structure1
+ bleproto_adv2_t adv2; ///< ADV Structure2
+} bleproto_adv_t;
+
+/**
+ * @brief 应用协议报文头(8字节)
+ */
+typedef struct bleproto_appdata_header {
+ // clang-format off
+ uint8_t version : 3; ///< byte0[2:0]:蓝牙BLE应用层协议的版本号，当前为0,根据业务演进递增 @ref BLEPROTO_APPDATA_VERSION
+ uint8_t datafmt : 1; ///< byte0[3:3]:数据格式, 当前只支持JSON字符串格式，取值固定为0, @ref BLEPROTO_APPDATA_DATAFMT_JSON
+ uint8_t msgtype : 4; ///< byte0[7:4]:消息类型, 包括：请求(0=req)、响应(1=rsp), @ref BLEPROTO_APPDATA_MSGTYPE_REQ
+ uint8_t msgid : 4; ///< byte1[3:0]:消息序号, 单调递增
+ uint8_t encrypt : 1; ///< byte1[4:4]:数据加密方式, 当前固定填写0，表示不加密
+ uint8_t reserve : 3; ///< byte1[7:5]:保留
+ uint8_t totalframe; ///< byte2 :总包数, 范围 1~255, 0x01：不分包时，取值为1, 0x02~0xFF：分包时，取值为≥2
+ uint8_t frameseq; ///< byte3 :分包包序号, 0x00：不分包时取值为0, 0x01~0xFF: 分包时, 取值为从1开始依次递增
+ uint8_t framelen; ///< byte4 :该包数据长度
+ uint8_t serviceid; ///< byte5 :应用数据服务id @ref bleproto_service_id_e
+ uint16_t datalen; ///< byte6-7 :应用数据总长度
+ // clang-format on
+} bleproto_appdata_header_t;
+
+/**
+ * @brief 应用数据
+ */
+typedef struct bleproto_appdata {
+ bleproto_appdata_header_t header;
+ uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ];
+} bleproto_appdata_t;
+
+/**
+ * @brief service id定义
+ */
+typedef uint8_t bleproto_service_id_e;
+enum {
+ E_BLEPROTO_SERVICE_ID_UNSPECIFIED = 0, ///< 保留
+ E_BLEPROTO_SERVICE_ID_DEVICEINFO = 1, ///< deviceInfo
+ E_BLEPROTO_SERVICE_ID_AUTHSETUP = 2, ///< authSetup
+ E_BLEPROTO_SERVICE_ID_AUTHDELETE = 3, ///< authDelete
+ E_BLEPROTO_SERVICE_ID_RUNCMD = 4, ///< runCmd
+ E_BLEPROTO_SERVICE_ID_REPORTCMD = 5, ///< reportCmd
+ E_BLEPROTO_SERVICE_ID_DOACTION = 6, ///< doAction
+ E_BLEPROTO_SERVICE_ID_OTANOTIFY = 7, ///< otaNotify
+ E_BLEPROTO_SERVICE_ID_OTADATA = 8, ///< otaData
+ E_BLEPROTO_SERVICE_ID_RUNCMD_V2 = 20, ///< runCmdV2
+ E_BLEPROTO_SERVICE_ID_REPORTCMD_V2 = 21, ///< reportCmdV2
+ E_BLEPROTO_SERVICE_ID_OTADATA_V2 = 22, ///< otaDataV2
+};
+
+/**
+ * @brief ycmd 定义
+ */
+#define YCMD_INT32_MAX_COUNT 32
+#define YCMD_STRING_MAX_COUNT 16
+#define YCMD_STRING_MAX_SIZE 32
+#define YCMD_BYTES_MAX_COUNT 8
+typedef struct bleproto_ycmd {
+ int32_t cmd_id;
+ uint16_t arg_int32_count;
+ int32_t arg_int32[YCMD_INT32_MAX_COUNT];
+ uint16_t arg_string_count;
+ char arg_string[YCMD_STRING_MAX_COUNT][YCMD_STRING_MAX_SIZE];
+ uint16_t arg_bytes_count;
+ uint8_t arg_bytes[YCMD_BYTES_MAX_COUNT];
+ uint64_t t;
+} bleproto_ycmd_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_DEVICEINFO
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_deviceinfo_req {
+ uint64_t t; ///< utcms时间戳
+ int gmtoff; ///< 时区偏移，单位秒，例如东八区(8x60x60=28800秒)
+} bleproto_deviceinfo_req_t;
+
+typedef struct bleproto_deviceinfo_rsp {
+ // clang-format off
+ char hwv[16]; ///< 硬件版本号
+ char swv[16]; ///< 软件版本号
+ uint8_t prototype; ///< 协议类型,固定填写为4,表示Ble设备
+ uint32_t hbcycle; ///< 设备心跳广播心跳周期,ms
+ uint8_t longcon; ///< 是否长链接, 1=长链接,0=短链接
+ // clang-format on
+} bleproto_deviceinfo_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_AUTHSETUP
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_authsetup_req {
+ // clang-format off
+ uint8_t gwmac[6]; ///< 主控mac地址, 设备需要保存
+ char devid[36 + 1]; ///< 主控分配的子设备id, 设备需要保存
+ char authcode[32 + 1]; ///< 主控分配的子设备认证码, 设备需要保存
+ uint8_t paired_flag;
+ // clang-format on
+} bleproto_authsetup_req_t;
+
+typedef struct bleproto_authsetup_rsp {
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+} bleproto_authsetup_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_AUTHDELETE
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_authdelete_req {
+ char authcode[32 + 1]; ///< 子设备认证码
+} bleproto_authdelete_req_t;
+
+typedef struct bleproto_authdelete_rsp {
+ uint8_t gwmac[6]; ///< 绑定主控设备的mac地址
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+} bleproto_authdelete_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_RUNCMD
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_runcmd_req {
+ bleproto_ycmd_t ycmd; ///< Request Ycmd
+} bleproto_runcmd_req_t;
+
+typedef struct bleproto_runcmd_rsp {
+ bleproto_ycmd_t ycmd; ///< Response Ycmd
+} bleproto_runcmd_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_REPORTCMD
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_reportcmd_req {
+ bleproto_ycmd_t ycmd; ///< Ycmd
+} bleproto_reportcmd_req_t;
+
+typedef struct bleproto_reportcmd_rsp {
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+} bleproto_reportcmd_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_DOACTION
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_doaction_req {
+ int action; ///< 0:重启, 1:指示,收到命令设备指示灯闪烁或者音频发音
+} bleproto_doaction_req_t;
+
+typedef struct bleproto_doaction_rsp {
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+} bleproto_doaction_rsp_t;
+
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_OTANOTIFY
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_otanotify_req {
+ int id; ///< file_id
+ char version[16]; ///< 版本号
+ uint32_t size; ///< 固件大小
+ char md5[32 + 1]; ///< 固件的md5值
+} bleproto_otanotify_req_t;
+
+typedef struct bleproto_otanotify_rsp {
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+} bleproto_otanotify_rsp_t;
+//////////////////////////////////////////////////////////////////////
+// E_BLEPROTO_SERVICE_ID_OTADATA
+//////////////////////////////////////////////////////////////////////
+typedef struct bleproto_otadata_req {
+ int id; ///< file_id
+ int32_t offset; ///< 要读取数据的偏移
+ uint32_t maxsize; ///< 每次最大读取的大小
+} bleproto_otadata_req_t;
+
+typedef struct bleproto_otadata_rsp {
+ int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
+ int id; ///< file_id
+ int32_t offset; ///< 当前读取到的数据偏移
+ uint32_t len; ///< 当次读取数据的大小
+ /**
+ * 固件数据指针（不内嵌大数组，避免 bleproto_appdata_desc_t 膨胀到 2KB+）
+ * - decode：指向 appdata 内部缓冲（零拷贝），下次 decode 前有效
+ * - encode：由调用方提供可读缓冲
+ */
+ const uint8_t *data;
+} bleproto_otadata_rsp_t;
+/****************************************************************************/
+/* Public Data */
+/****************************************************************************/
+
+/****************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+/****************************************************************************/
+/* Public Function Prototypes */
+/****************************************************************************/
+
+/**
+ * @brief 序列化广播数据(广播数据长度为31)
+ *
+ * @param[in] adv - 广播数据结构体.
+ * @param[out] data - 序列化数据缓冲区, 固定为31个字节.
+ * @param[in] size - 序列化数据缓冲区长度
+ *
+ * @return 小于0表示失败，大于0表示序列化后的长度(31)
+ */
+int bleproto_advdata_serialize(bleproto_adv_t *adv,
+ uint8_t * data,
+ uint8_t size);
+
+/**
+ * @brief 反序列化广播数据(广播数据长度为31)
+ *
+ * @param[in] data - 反序列化数据指针
+ * @param[in] len - 反序列化数据长度
+ * @param[out] adv - 广播数据结构体
+ *
+ * @return 小于0表示失败，大于0表示反序列化使用data的长度(31)
+ */
+int bleproto_advdata_deserialize(const uint8_t * data,
+ uint8_t len,
+ bleproto_adv_t *adv);
+
+/**
+ * @brief 计算序列化应用数据长度
+ *
+ * @note packetlen说明
+ *
+ * ```c
+ * ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
+ * ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ```
+ *
+ * @param[in] appdata - 应用数据结构体
+ * @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
+ * @param[out] outlen - 计算返回总长度，每个包都含有包头
+ *
+ * @return 成功返回0，其他值表示失败
+ */
+int bleproto_appdata_serialize_len(bleproto_appdata_t *appdata,
+ uint8_t packetlen,
+ uint16_t * outlen);
+
+/**
+ * @brief 序列化应用数据
+ *
+ * @note packetlen说明
+ *
+ * ```c
+ * ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
+ * ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
+ * ```
+ *
+ * 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
+ * +----------------+
+ * | 1 | 第一包按照packetlen填满
+ * +----------------+
+ * | |
+ * | ... | 中间包按照packetlen填满
+ * | |
+ * +----------------+
+ * | N | 最后一包长度 = totallen - (packetlen * (N -1))
+ * +----------------+
+ *
+ * 需要按照每包的顺序发给对端
+ *
+ * @param[in] appdata - 应用数据结构体
+ * @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
+ * @param[out] buf - 数据缓冲区指针
+ * @param[in] size - 数据缓冲区大小
+ *
+ * @return 小于0表示失败，大于0表示序列化后的长度
+ */
+int bleproto_appdata_serialize(bleproto_appdata_t *appdata,
+ uint8_t packetlen,
+ uint8_t * buf,
+ uint16_t size);
+
+/**
+ * @brief 将已打包好的 payload 包装成单帧 appdata（不分包）
+ * @param txbuf 输出缓冲
+ * @param txbuf_size 输出缓冲大小
+ * @param header 应用层头（datalen/totalframe/frameseq 由本函数填写）
+ * @param payload 已序列化的 service 数据；可为 NULL（payload_len==0）
+ * @param payload_len payload 长度，须 <=255（单帧 pthis_frame_len 为 u8）
+ * @return >0 总字节数；<0 失败
+ * @note 小包场景（JB 55AA 透传等）用此接口，避免 bleproto_appdata_t 大缓冲
+ */
+int bleproto_appdata_wrap_raw(uint8_t *txbuf,
+ uint16_t txbuf_size,
+ const bleproto_appdata_header_t *header,
+ const uint8_t *payload,
+ uint16_t payload_len);
+
+/**
+ * @brief 反序列化应用数据
+ *
+ *
+ * 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
+ * +----------------+
+ * | 1 | 第一包按照packetlen填满
+ * +----------------+
+ * | |
+ * | ... | 中间包按照packetlen填满
+ * | |
+ * +----------------+
+ * | N | 最后一包长度 = totallen - (packetlen * (N -1))
+ * +----------------+
+ *
+ * 因此接收到数据
+ * 1. 函数返回等于0，以为还有分包数据还没有接收完成，
+ * 接收到下包数据 append 在buf尾部，再调用函数的解析数据包
+ * 2. 函数返回大于0，表示收到数据解析了多少字节，需要将头上对应长度数据移除掉
+ * 3. 函数返回小于0，表示收到非法的数据包，无法解析
+ *
+ * @param[in] buf - 数据缓冲区指针.
+ * @param[in] len - 数据缓冲区长度.
+ * @param[out] app_data - 应用数据结构体.
+ *
+ * @return 大于0表示解析成功, 返回当前解析了多少个字节,
+ * 等于0表示解析未完成, 只接受到分包的部分数据, 需要继续接收数据
+ * 小于0表示解析失败
+ */
+int bleproto_appdata_deserialize(uint8_t * buf,
+ uint16_t len,
+ bleproto_appdata_t *appdata);
+
+////////////////////////////////////////////////////////////////////////
+// encjson 序列化, 成功返回json序列化的长度，失败返回小于0
+// decjson 反序列化, 成功返回0, 其他值表示失败
+////////////////////////////////////////////////////////////////////////
+// clang-format off
+int bleproto_encjson_ycmd(const bleproto_ycmd_t *ycmd, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_decjson_ycmd(const uint8_t *data, uint16_t len, bleproto_ycmd_t *ycmd);
+// clang-format on
+
+////////////////////////////////////////////////////////////////////////
+// encjson 序列化, 成功返回json序列化的长度，失败返回小于0
+// decjson 反序列化, 成功返回0, 其他值表示失败
+////////////////////////////////////////////////////////////////////////
+// clang-format off
+int bleproto_encjson_deviceinfo_req(const bleproto_deviceinfo_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_deviceinfo_rsp(const bleproto_deviceinfo_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_authsetup_req(const bleproto_authsetup_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_authsetup_rsp(const bleproto_authsetup_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_authdelete_req(const bleproto_authdelete_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_authdelete_rsp(const bleproto_authdelete_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_runcmd_req(const bleproto_runcmd_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_runcmd_rsp(const bleproto_runcmd_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_reportcmd_req(const bleproto_reportcmd_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_reportcmd_rsp(const bleproto_reportcmd_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_doaction_req(const bleproto_doaction_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_doaction_rsp(const bleproto_doaction_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_otanotify_req(const bleproto_otanotify_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encjson_otanotify_rsp(const bleproto_otanotify_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+// otadata 序列化请求走json，回复走二进制
+int bleproto_encjson_otadata_req(const bleproto_otadata_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+int bleproto_encbin_otadata_rsp(const bleproto_otadata_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
+
+int bleproto_decjson_deviceinfo_req(const uint8_t *data, uint16_t len, bleproto_deviceinfo_req_t *req);
+int bleproto_decjson_deviceinfo_rsp(const uint8_t *data, uint16_t len, bleproto_deviceinfo_rsp_t *rsp);
+int bleproto_decjson_authsetup_req(const uint8_t *data, uint16_t len, bleproto_authsetup_req_t *req);
+int bleproto_decjson_authsetup_rsp(const uint8_t *data, uint16_t len, bleproto_authsetup_rsp_t *rsp);
+int bleproto_decjson_authdelete_req(const uint8_t *data, uint16_t len, bleproto_authdelete_req_t *req);
+int bleproto_decjson_authdelete_rsp(const uint8_t *data, uint16_t len, bleproto_authdelete_rsp_t *rsp);
+int bleproto_decjson_runcmd_req(const uint8_t *data, uint16_t len, bleproto_runcmd_req_t *req);
+int bleproto_decjson_runcmd_rsp(const uint8_t *data, uint16_t len, bleproto_runcmd_rsp_t *rsp);
+int bleproto_decjson_reportcmd_req(const uint8_t *data, uint16_t len, bleproto_reportcmd_req_t *req);
+int bleproto_decjson_reportcmd_rsp(const uint8_t *data, uint16_t len, bleproto_reportcmd_rsp_t *rsp);
+int bleproto_decjson_doaction_req(const uint8_t *data, uint16_t len, bleproto_doaction_req_t *req);
+int bleproto_decjson_doaction_rsp(const uint8_t *data, uint16_t len, bleproto_doaction_rsp_t *rsp);
+int bleproto_decjson_otanotify_req(const uint8_t *data, uint16_t len, bleproto_otanotify_req_t *req);
+int bleproto_decjson_otanotify_rsp(const uint8_t *data, uint16_t len, bleproto_otanotify_rsp_t *rsp);
+//otadata 反序列化请求走json，回复走二进制
+int bleproto_decjson_otadata_req(const uint8_t *data, uint16_t len, bleproto_otadata_req_t *req);
+int bleproto_debin_otadata_rsp(const uint8_t *data, uint16_t len, bleproto_otadata_rsp_t *rsp);
+// clang-format on
+
+/****************************************************************************/
+#ifdef __cplusplus
+}
+#endif
+/****************************************************************************/
+#endif /* BLEPROTO_PACKER_H_INCLUDE */
+/****************************************************************************/
+/**
+ * @} (end addtogroup bleproto_packer)
+ */
+/****************************************************************************/
+/* */
+/* End of file. */
+/* */
+/****************************************************************************/
diff --git a/apps/usr_le_code/lib/libusr_le_code.a b/apps/usr_le_code/lib/libusr_le_code.a
deleted file mode 100644
index f33797959f0a70c829a8ef4f73d50dff839087f6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 257070
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