diff --git a/AC701N.cbp b/AC701N.cbp index f2b466b..f570e7a 100644 --- a/AC701N.cbp +++ b/AC701N.cbp @@ -258,7 +258,6 @@ - @@ -790,6 +789,24 @@ + + + + + + + + + + + + diff --git a/JBao_JL7016_SOC_SDK_README.md b/JBao_JL7016_SOC_SDK_README.md index f7d5594..de49de3 100644 --- a/JBao_JL7016_SOC_SDK_README.md +++ b/JBao_JL7016_SOC_SDK_README.md @@ -16,7 +16,7 @@ JBao_JL7016_SOC_SDK_V1.0.1/ │ ├── earphone/ # 耳机应用 │ ├── usr_jb_proto/ # 应用协议层 │ ├── usr_periph/ # 板级外设（RTC 等，源码开放） -│ └── usr_le_code/ # BLE 协议库（库文件 + 公开头文件） +│ └── usr_le_code/ # BLE 协议层（源码直编：协议编解码 + 广播/收发 + mjson） ├── cpu/ # 芯片相关代码与工具 ├── include_lib/ # SDK 头文件 ├── tools/ # 工程工具 @@ -29,7 +29,10 @@ JBao_JL7016_SOC_SDK_V1.0.1/ **apps/usr_le_code** -- 静态库：`apps/usr_le_code/lib/` +- 源码直编（已弃用预编译静态库 `libusr_le_code.a`），源文件随主工程一起编译： + - `apps/usr_le_code/ble_proto.c` / `bleproto.c` / `bleproto_packer.c` + - `apps/usr_le_code/usr_le_adv.c` / `usr_le_recieve.c` + - `apps/usr_le_code/thirdpart/mjson/mjson.c` - 公开头文件： - `apps/usr_le_code/usr_le_api.h` - `apps/usr_le_code/usr_le_product.h` diff --git a/Makefile b/Makefile index c4761fe..f1fecac 100644 --- a/Makefile +++ b/Makefile @@ -621,10 +621,12 @@ c_SRC_FILES := \ apps/usr_jb_proto/Utils/jb_ringbuffer.c \ apps/usr_jb_proto/usr_jb_main.c \ apps/usr_periph/usr_rtc.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 \ @@ -729,7 +731,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 \ @@ -794,7 +795,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 @@ -814,13 +815,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/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 f337979..0000000 Binary files a/apps/usr_le_code/lib/libusr_le_code.a and /dev/null differ diff --git a/apps/usr_le_code/thirdpart/mjson/mjson.c b/apps/usr_le_code/thirdpart/mjson/mjson.c new file mode 100644 index 0000000..75548d4 --- /dev/null +++ b/apps/usr_le_code/thirdpart/mjson/mjson.c @@ -0,0 +1,1066 @@ +// Copyright (c) 2018-2020 Cesanta Software Limited +// All rights reserved +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#include +#include + +#include "mjson.h" + +#if defined(_MSC_VER) +#define alloca(x) _alloca(x) +#endif + +#if defined(_MSC_VER) && _MSC_VER < 1700 +#define va_copy(x, y) (x) = (y) +#define isinf(x) !_finite(x) +#define isnan(x) _isnan(x) +#endif + +static double mystrtod(const char *str, const char **end); + +static int mjson_esc(int c, int esc) { + const char *p, *esc1 = "\b\f\n\r\t\\\"", *esc2 = "bfnrt\\\""; + for (p = esc ? esc1 : esc2; *p != '\0'; p++) { + if (*p == c) return esc ? esc2[p - esc1] : esc1[p - esc2]; + } + return 0; +} + +static int mjson_escape(int c) { + return mjson_esc(c, 1); +} + +static int mjson_pass_string(const char *s, int len) { + int i; + for (i = 0; i < len; i++) { + if (s[i] == '\\' && i + 1 < len && mjson_escape(s[i + 1])) { + i++; + } else if (s[i] == '\0') { + return MJSON_ERROR_INVALID_INPUT; + } else if (s[i] == '"') { + return i; + } + } + return MJSON_ERROR_INVALID_INPUT; +} + +int mjson(const char *s, int len, mjson_cb_t cb, void *ud) { + enum { S_VALUE, S_KEY, S_COLON, S_COMMA_OR_EOO } expecting = S_VALUE; + unsigned char nesting[MJSON_MAX_DEPTH]; + int i, depth = 0; +#define MJSONCALL(ev) \ + if (cb != NULL && cb(ev, s, start, i - start + 1, ud)) return i + 1; + +// In the ascii table, the distance between `[` and `]` is 2. +// Ditto for `{` and `}`. Hence +2 in the code below. +#define MJSONEOO() \ + do { \ + if (c != nesting[depth - 1] + 2) return MJSON_ERROR_INVALID_INPUT; \ + depth--; \ + if (depth == 0) { \ + MJSONCALL(tok); \ + return i + 1; \ + } \ + } while (0) + + for (i = 0; i < len; i++) { + int start = i; + unsigned char c = ((const unsigned char *) s)[i]; + int tok = c; + if (c == ' ' || c == '\t' || c == '\n' || c == '\r') continue; + // printf("- %c [%.*s] %d %d\n", c, i, s, depth, expecting); + switch (expecting) { + case S_VALUE: + if (c == '{') { + if (depth >= (int) sizeof(nesting)) return MJSON_ERROR_TOO_DEEP; + nesting[depth++] = c; + expecting = S_KEY; + break; + } else if (c == '[') { + if (depth >= (int) sizeof(nesting)) return MJSON_ERROR_TOO_DEEP; + nesting[depth++] = c; + break; + } else if (c == ']' && depth > 0) { // Empty array + MJSONEOO(); + } else if (c == 't' && i + 3 < len && memcmp(&s[i], "true", 4) == 0) { + i += 3; + tok = MJSON_TOK_TRUE; + } else if (c == 'n' && i + 3 < len && memcmp(&s[i], "null", 4) == 0) { + i += 3; + tok = MJSON_TOK_NULL; + } else if (c == 'f' && i + 4 < len && memcmp(&s[i], "false", 5) == 0) { + i += 4; + tok = MJSON_TOK_FALSE; + } else if (c == '-' || ((c >= '0' && c <= '9'))) { + const char *end = NULL; + mystrtod(&s[i], &end); + if (end != NULL) i += (int) (end - &s[i] - 1); + tok = MJSON_TOK_NUMBER; + } else if (c == '"') { + int n = mjson_pass_string(&s[i + 1], len - i - 1); + if (n < 0) return n; + i += n + 1; + tok = MJSON_TOK_STRING; + } else { + return MJSON_ERROR_INVALID_INPUT; + } + if (depth == 0) { + MJSONCALL(tok); + return i + 1; + } + expecting = S_COMMA_OR_EOO; + break; + + case S_KEY: + if (c == '"') { + int n = mjson_pass_string(&s[i + 1], len - i - 1); + if (n < 0) return n; + i += n + 1; + tok = MJSON_TOK_KEY; + expecting = S_COLON; + } else if (c == '}') { // Empty object + MJSONEOO(); + expecting = S_COMMA_OR_EOO; + } else { + return MJSON_ERROR_INVALID_INPUT; + } + break; + + case S_COLON: + if (c == ':') { + expecting = S_VALUE; + } else { + return MJSON_ERROR_INVALID_INPUT; + } + break; + + case S_COMMA_OR_EOO: + if (depth <= 0) return MJSON_ERROR_INVALID_INPUT; + if (c == ',') { + expecting = (nesting[depth - 1] == '{') ? S_KEY : S_VALUE; + } else if (c == ']' || c == '}') { + MJSONEOO(); + } else { + return MJSON_ERROR_INVALID_INPUT; + } + break; + } + MJSONCALL(tok); + } + return MJSON_ERROR_INVALID_INPUT; +} + +struct msjon_get_data { + const char *path; // Lookup json path + int pos; // Current path position + int d1; // Current depth of traversal + int d2; // Expected depth of traversal + int i1; // Index in an array + int i2; // Expected index in an array + int obj; // If the value is array/object, offset where it starts + const char **tokptr; // Destination + int *toklen; // Destination length + int tok; // Returned token +}; + +//#include + +static int plen1(const char *s) { + int i = 0, n = 0; + while (s[i] != '\0' && s[i] != '.' && s[i] != '[') + n++, i += s[i] == '\\' ? 2 : 1; + // printf("PLEN: s: [%s], [%.*s] => %d\n", s, i, s, n); + return n; +} + +static int plen2(const char *s) { + int i = 0, n = 0; + while (s[i] != '\0' && s[i] != '.' && s[i] != '[') + n++, i += s[i] == '\\' ? 2 : 1; + // printf("PLEN: s: [%s], [%.*s] => %d\n", s, i, s, n); + return i; +} + +static int kcmp(const char *a, const char *b, int n) { + int i = 0, j = 0, r = 0; + for (i = 0, j = 0; j < n; i++, j++) { + if (b[i] == '\\') i++; + if ((r = a[j] - b[i]) != 0) return r; + } + // printf("KCMP: a: [%.*s], b:[%.*s] ==> %d\n", n, a, i, b, r); + return r; +} + +static int mjson_get_cb(int tok, const char *s, int off, int len, void *ud) { + struct msjon_get_data *d = (struct msjon_get_data *) ud; +#if 0 + printf("--> %2x %2d %2d %2d %2d\t %2d %2d\t'%s' '%s' '%s' '%s'\n", tok, d->d1, + d->d2, d->i1, d->i2, (int) off, (int) d->pos, s, d->path, s + off, + d->path + d->pos); +#endif + if (d->tok != MJSON_TOK_INVALID) return 1; // Found + if (tok == '{' || tok == '[') { + if (d->d1 < d->d2) d->obj = -1; + if (d->d1 == d->d2) d->obj = off; + if (d->d1 == d->d2 && tok == '[' && d->path[d->pos] == '[') { + d->i1 = 0; + d->i2 = (int) mystrtod(&d->path[d->pos + 1], NULL); + if (d->i1 == d->i2) { + while (d->path[d->pos] && d->path[d->pos] != ']') d->pos++; + if (d->path[d->pos] == ']') d->pos++; + d->d2++; + } + } + d->d1++; + } else if (tok == '}' || tok == ']') { + if (tok == ']' && d->d1 == d->d2) d->i1 = 0; + d->d1--; + // printf("X %s %d %d %d %d %d\n", d->path + d->pos, d->d1, d->d2, d->i1, + // d->i2, d->obj); + if (!d->path[d->pos] && d->d1 == d->d2 && d->obj != -1) { + d->tok = tok - 2; + if (d->tokptr) *d->tokptr = s + d->obj; + if (d->toklen) *d->toklen = off - d->obj + 1; + return 1; + } + } else if (tok == ',' && d->d1 == d->d2 && d->pos && + d->path[d->pos - 1] == ']') { + return 1; // Not found in the current elem array + } else if (tok == ',' && d->d1 == d->d2 + 1 && d->path[d->pos] == '[') { + // printf("GG '%s' '%s'\n", d->path, &d->path[d->pos]); + d->i1++; + if (d->i1 == d->i2) { + while (d->path[d->pos] && d->path[d->pos] != ']') d->pos++; + if (d->path[d->pos] == ']') d->pos++; + d->d2++; + } + } else if (tok == MJSON_TOK_KEY && d->d1 == d->d2 + 1 && + d->path[d->pos] == '.' && s[off] == '"' && + s[off + len - 1] == '"' && + plen1(&d->path[d->pos + 1]) == len - 2 && + kcmp(s + off + 1, &d->path[d->pos + 1], len - 2) == 0) { + d->d2++; + d->pos += plen2(&d->path[d->pos + 1]) + 1; + } else if (tok == MJSON_TOK_KEY && d->d1 == d->d2) { + return 1; // Exhausted path, not found + } else if (MJSON_TOK_IS_VALUE(tok)) { + // printf("T %d %d %d %d %d\n", tok, d->d1, d->d2, d->i1, d->i2); + if (d->d1 == d->d2 && d->i1 == d->i2 && !d->path[d->pos]) { + d->tok = tok; + if (d->tokptr) *d->tokptr = s + off; + if (d->toklen) *d->toklen = len; + return 1; + } + } + return 0; +} + +int mjson_find(const char *s, int n, const char *jp, const char **tp, int *tl) { + struct msjon_get_data data = {jp, 1, 0, 0, 0, + 0, -1, tp, tl, MJSON_TOK_INVALID}; + if (jp[0] != '$') return MJSON_TOK_INVALID; + if (mjson(s, n, mjson_get_cb, &data) < 0) return MJSON_TOK_INVALID; + return data.tok; +} + +int mjson_get_number(const char *s, int len, const char *path, double *v) { + const char *p; + int tok, n; + if ((tok = mjson_find(s, len, path, &p, &n)) == MJSON_TOK_NUMBER) { + if (v != NULL) *v = mystrtod(p, NULL); + } + return tok == MJSON_TOK_NUMBER ? 1 : 0; +} + +int mjson_get_bool(const char *s, int len, const char *path, int *v) { + int tok = mjson_find(s, len, path, NULL, NULL); + if (tok == MJSON_TOK_TRUE && v != NULL) *v = 1; + if (tok == MJSON_TOK_FALSE && v != NULL) *v = 0; + return tok == MJSON_TOK_TRUE || tok == MJSON_TOK_FALSE ? 1 : 0; +} + +static unsigned char unhex(unsigned char c) { + return (c >= '0' && c <= '9') ? (unsigned char) (c - '0') + : (c >= 'A' && c <= 'F') ? (unsigned char) (c - '7') + : (unsigned char) (c - 'W'); +} + +static unsigned char mjson_unhex_nimble(const char *s) { + const unsigned char *u = (const unsigned char *) s; + return (unsigned char) (((unsigned char) (unhex(u[0]) << 4)) | unhex(u[1])); +} + +static int mjson_unescape(const char *s, int len, char *to, int n) { + int i, j; + for (i = 0, j = 0; i < len && j < n; i++, j++) { + if (s[i] == '\\' && i + 5 < len && s[i + 1] == 'u') { + // \uXXXX escape. We could process a simple one-byte chars + // \u00xx from the ASCII range. More complex chars would require + // dragging in a UTF8 library, which is too much for us + if (s[i + 2] != '0' || s[i + 3] != '0') return -1; // Too much, give up + ((unsigned char *) to)[j] = mjson_unhex_nimble(s + i + 4); + i += 5; + } else if (s[i] == '\\' && i + 1 < len) { + int c = mjson_esc(s[i + 1], 0); + if (c == 0) return -1; + to[j] = (char) (unsigned char) c; + i++; + } else { + to[j] = s[i]; + } + } + if (j >= n) return -1; + if (n > 0) to[j] = '\0'; + return j; +} + +int mjson_get_string(const char *s, int len, const char *path, char *to, + int n) { + const char *p; + int sz; + if (mjson_find(s, len, path, &p, &sz) != MJSON_TOK_STRING) return -1; + return mjson_unescape(p + 1, sz - 2, to, n); +} + +int mjson_get_hex(const char *s, int len, const char *x, char *to, int n) { + const char *p; + int i, j, sz; + if (mjson_find(s, len, x, &p, &sz) != MJSON_TOK_STRING) return -1; + for (i = j = 0; i < sz - 3 && j < n; i += 2, j++) { + ((unsigned char *) to)[j] = mjson_unhex_nimble(p + i + 1); + } + if (j < n) to[j] = '\0'; + return j; +} + +#if MJSON_ENABLE_BASE64 +static unsigned char mjson_base64rev(int c) { + if (c >= 'A' && c <= 'Z') { + return (unsigned char) (c - 'A'); + } else if (c >= 'a' && c <= 'z') { + return (unsigned char) (c + 26 - 'a'); + } else if (c >= '0' && c <= '9') { + return (unsigned char) (c + 52 - '0'); + } else if (c == '+') { + return 62; + } else if (c == '/') { + return 63; + } else { + return 64; + } +} + +int mjson_base64_dec(const char *src, int n, char *dst, int dlen) { + const char *end = src + n; + int len = 0; + while (src + 3 < end && len < dlen) { + unsigned char a = mjson_base64rev(src[0]), b = mjson_base64rev(src[1]), + c = mjson_base64rev(src[2]), d = mjson_base64rev(src[3]); + dst[len++] = (char) (unsigned char) ((a << 2) | (b >> 4)); + if (src[2] != '=' && len < dlen) { + dst[len++] = (char) (unsigned char) ((b << 4) | (c >> 2)); + if (src[3] != '=' && len < dlen) { + dst[len++] = (char) (unsigned char) ((c << 6) | d); + } + } + src += 4; + } + if (len < dlen) dst[len] = '\0'; + return len; +} + +int mjson_get_base64(const char *s, int len, const char *path, char *to, + int n) { + const char *p; + int sz; + if (mjson_find(s, len, path, &p, &sz) != MJSON_TOK_STRING) return 0; + return mjson_base64_dec(p + 1, sz - 2, to, n); +} +#endif // MJSON_ENABLE_BASE64 + +#if MJSON_ENABLE_NEXT +struct nextdata { + int off, len, depth, t, vo, arrayindex; + int *koff, *klen, *voff, *vlen, *vtype; +}; + +static int next_cb(int tok, const char *s, int off, int len, void *ud) { + struct nextdata *d = (struct nextdata *) ud; + // int i; + switch (tok) { + case '{': + case '[': + if (d->depth == 0 && tok == '[') d->arrayindex = 0; + if (d->depth == 1 && off > d->off) { + d->vo = off; + d->t = tok == '{' ? MJSON_TOK_OBJECT : MJSON_TOK_ARRAY; + if (d->voff) *d->voff = off; + if (d->vtype) *d->vtype = d->t; + } + d->depth++; + break; + case '}': + case ']': + d->depth--; + if (d->depth == 1 && d->vo) { + d->len = off + len; + if (d->vlen) *d->vlen = d->len - d->vo; + if (d->arrayindex >= 0) { + if (d->koff) *d->koff = d->arrayindex; // koff holds array index + if (d->klen) *d->klen = 0; // klen holds 0 + } + return 1; + } + if (d->depth == 1 && d->arrayindex >= 0) d->arrayindex++; + break; + case ',': + case ':': + break; + case MJSON_TOK_KEY: + if (d->depth == 1 && d->off < off) { + if (d->koff) *d->koff = off; // And report back to the user + if (d->klen) *d->klen = len; // If we have to + } + break; + default: + if (d->depth != 1) break; + // If we're iterating over the array + if (off > d->off) { + d->len = off + len; + if (d->vlen) *d->vlen = len; // value length + if (d->voff) *d->voff = off; // value offset + if (d->vtype) *d->vtype = tok; // value type + if (d->arrayindex >= 0) { + if (d->koff) *d->koff = d->arrayindex; // koff holds array index + if (d->klen) *d->klen = 0; // klen holds 0 + } + return 1; + } + if (d->arrayindex >= 0) d->arrayindex++; + break; + } + (void) s; + return 0; +} + +int mjson_next(const char *s, int n, int off, int *koff, int *klen, int *voff, + int *vlen, int *vtype) { + struct nextdata d = {off, 0, 0, 0, 0, -1, koff, klen, voff, vlen, vtype}; + mjson(s, n, next_cb, &d); + return d.len; +} +#endif + +#if MJSON_ENABLE_PRINT +int mjson_print_fixed_buf(const char *ptr, int len, void *fn_data) { + struct mjson_fixedbuf *fb = (struct mjson_fixedbuf *) fn_data; + int i, left = fb->size - 1 - fb->len; + if (left < len) len = left; + for (i = 0; i < len; i++) fb->ptr[fb->len + i] = ptr[i]; + fb->len += len; + fb->ptr[fb->len] = '\0'; + return len; +} + +// This function allocates memory in chunks of size MJSON_DYNBUF_CHUNK +// to decrease memory fragmentation, when many calls are executed to +// print e.g. a base64 string or a hex string. +int mjson_print_dynamic_buf(const char *ptr, int len, void *fn_data) { + char *s, *buf = *(char **) fn_data; + size_t curlen = buf == NULL ? 0 : strlen(buf); + size_t new_size = curlen + (size_t) len + 1 + MJSON_DYNBUF_CHUNK; + new_size -= new_size % MJSON_DYNBUF_CHUNK; + + if ((s = (char *) MJSON_REALLOC(buf, new_size)) == NULL) { + return 0; + } else { + memcpy(s + curlen, ptr, (size_t) len); + s[curlen + (size_t) len] = '\0'; + *(char **) fn_data = s; + return len; + } +} + +int mjson_snprintf(char *buf, size_t len, const char *fmt, ...) { + va_list ap; + struct mjson_fixedbuf fb = {buf, (int) len, 0}; + va_start(ap, fmt); + mjson_vprintf(mjson_print_fixed_buf, &fb, fmt, &ap); + va_end(ap); + return fb.len; +} + +char *mjson_aprintf(const char *fmt, ...) { + va_list ap; + char *result = NULL; + va_start(ap, fmt); + mjson_vprintf(mjson_print_dynamic_buf, &result, fmt, &ap); + va_end(ap); + return result; +} + +int mjson_print_null(const char *ptr, int len, void *userdata) { + (void) ptr; + (void) userdata; + return len; +} + +int mjson_print_buf(mjson_print_fn_t fn, void *fnd, const char *buf, int len) { + return fn(buf, len, fnd); +} + +int mjson_print_long(mjson_print_fn_t fn, void *fnd, long val, int is_signed) { + unsigned long v = (unsigned long) val, s = 0, n, i; + char buf[20], t; + if (is_signed && val < 0) buf[s++] = '-', v = (unsigned long) (-val); + // This loop prints a number in reverse order. I guess this is because we + // write numbers from right to left: least significant digit comes last. + // Maybe because we use Arabic numbers, and Arabs write RTL? + for (n = 0; v > 0; v /= 10) buf[s + n++] = "0123456789"[v % 10]; + // Reverse a string + for (i = 0; i < n / 2; i++) + t = buf[s + i], buf[s + i] = buf[s + n - i - 1], buf[s + n - i - 1] = t; + if (val == 0) buf[n++] = '0'; // Handle special case + return fn(buf, (int) (s + n), fnd); +} + +int mjson_print_int(mjson_print_fn_t fn, void *fnd, int v, int s) { + return mjson_print_long(fn, fnd, s ? (long) v : (long) (unsigned) v, s); +} + +static int addexp(char *buf, int e, int sign) { + int n = 0; + buf[n++] = 'e'; + buf[n++] = (char) sign; + if (e > 400) return 0; + if (e < 10) buf[n++] = '0'; + if (e >= 100) buf[n++] = (char) (e / 100 + '0'), e -= 100 * (e / 100); + if (e >= 10) buf[n++] = (char) (e / 10 + '0'), e -= 10 * (e / 10); + buf[n++] = (char) (e + '0'); + return n; +} + +int mjson_print_dbl(mjson_print_fn_t fn, void *fnd, double d, int width) { + char buf[40]; + int i, s = 0, n = 0, e = 0; + double t, mul, saved; + if (d == 0.0) return fn("0", 1, fnd); + if (isinf(d)) return fn(d > 0 ? "inf" : "-inf", d > 0 ? 3 : 4, fnd); + if (isnan(d)) return fn("nan", 3, fnd); + if (d < 0.0) d = -d, buf[s++] = '-'; + + // Round + saved = d; + mul = 1.0; + while (d >= 10.0 && d / mul >= 10.0) mul *= 10.0; + while (d <= 1.0 && d / mul <= 1.0) mul /= 10.0; + for (i = 0, t = mul * 5; i < width; i++) t /= 10.0; + d += t; + // Calculate exponent, and 'mul' for scientific representation + mul = 1.0; + while (d >= 10.0 && d / mul >= 10.0) mul *= 10.0, e++; + while (d < 1.0 && d / mul < 1.0) mul /= 10.0, e--; + // printf(" --> %g %d %g %g\n", saved, e, t, mul); + + if (e >= width) { + struct mjson_fixedbuf fb = {buf + s, (int) sizeof(buf) - s, 0}; + n = mjson_print_dbl(mjson_print_fixed_buf, &fb, saved / mul, width); + // printf(" --> %.*g %d [%.*s]\n", 10, d / t, e, fb.len, fb.ptr); + n += addexp(buf + s + n, e, '+'); + return fn(buf, s + n, fnd); + } else if (e <= -width) { + struct mjson_fixedbuf fb = {buf + s, (int) sizeof(buf) - s, 0}; + n = mjson_print_dbl(mjson_print_fixed_buf, &fb, saved / mul, width); + // printf(" --> %.*g %d [%.*s]\n", 10, d / mul, e, fb.len, fb.ptr); + n += addexp(buf + s + n, -e, '-'); + return fn(buf, s + n, fnd); + } else { + for (i = 0, t = mul; t >= 1.0 && s + n < (int) sizeof(buf); i++) { + int ch = (int) (d / t); + if (n > 0 || ch > 0) buf[s + n++] = (char) (ch + '0'); + d -= ch * t; + t /= 10.0; + } + // printf(" --> [%g] -> %g %g (%d) [%.*s]\n", saved, d, t, n, s + n, buf); + if (n == 0) buf[s++] = '0'; + while (t >= 1.0 && n + s < (int) sizeof(buf)) buf[n++] = '0', t /= 10.0; + if (s + n < (int) sizeof(buf)) buf[n + s++] = '.'; + // printf(" 1--> [%g] -> [%.*s]\n", saved, s + n, buf); + for (i = 0, t = 0.1; s + n < (int) sizeof(buf) && n < width; i++) { + int ch = (int) (d / t); + buf[s + n++] = (char) (ch + '0'); + d -= ch * t; + t /= 10.0; + } + } + while (n > 0 && buf[s + n - 1] == '0') n--; // Trim trailing zeros + if (n > 0 && buf[s + n - 1] == '.') n--; // Trim trailing dot + buf[s + n] = '\0'; + return fn(buf, s + n, fnd); +} + +int mjson_print_str(mjson_print_fn_t fn, void *fnd, const char *s, int len) { + int i, n = fn("\"", 1, fnd); + for (i = 0; i < len; i++) { + char c = (char) (unsigned char) mjson_escape(s[i]); + if (c) { + n += fn("\\", 1, fnd); + n += fn(&c, 1, fnd); + } else { + n += fn(&s[i], 1, fnd); + } + } + return n + fn("\"", 1, fnd); +} + +#if MJSON_ENABLE_BASE64 +int mjson_print_b64(mjson_print_fn_t fn, void *fnd, const unsigned char *s, + int n) { + const char *t = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + int i, len = fn("\"", 1, fnd); + for (i = 0; i < n; i += 3) { + int a = s[i], b = i + 1 < n ? s[i + 1] : 0, c = i + 2 < n ? s[i + 2] : 0; + char buf[4] = {t[a >> 2], t[(a & 3) << 4 | (b >> 4)], '=', '='}; + if (i + 1 < n) buf[2] = t[(b & 15) << 2 | (c >> 6)]; + if (i + 2 < n) buf[3] = t[c & 63]; + len += fn(buf, sizeof(buf), fnd); + } + return len + fn("\"", 1, fnd); +} +#endif /* MJSON_ENABLE_BASE64 */ + +int mjson_vprintf(mjson_print_fn_t fn, void *fnd, const char *fmt, + va_list *ap) { + int i = 0, n = 0; + while (fmt[i] != '\0') { + if (fmt[i] == '%') { + char fc = fmt[++i]; + int is_long = 0; + if (fc == 'l') { + is_long = 1; + fc = fmt[i + 1]; + } + if (fc == 'Q') { + char *buf = va_arg(*ap, char *); + n += mjson_print_str(fn, fnd, buf ? buf : "", + buf ? (int) strlen(buf) : 0); + } else if (strncmp(&fmt[i], ".*Q", 3) == 0) { + int len = va_arg(*ap, int); + char *buf = va_arg(*ap, char *); + n += mjson_print_str(fn, fnd, buf, len); + i += 2; + } else if (fc == 'd' || fc == 'u') { + int is_signed = (fc == 'd'); + if (is_long) { + long val = va_arg(*ap, long); + n += mjson_print_long(fn, fnd, val, is_signed); + i++; + } else { + int val = va_arg(*ap, int); + n += mjson_print_int(fn, fnd, val, is_signed); + } + } else if (fc == 'B') { + const char *s = va_arg(*ap, int) ? "true" : "false"; + n += mjson_print_buf(fn, fnd, s, (int) strlen(s)); + } else if (fc == 's') { + char *buf = va_arg(*ap, char *); + n += mjson_print_buf(fn, fnd, buf, (int) strlen(buf)); + } else if (strncmp(&fmt[i], ".*s", 3) == 0) { + int len = va_arg(*ap, int); + char *buf = va_arg(*ap, char *); + n += mjson_print_buf(fn, fnd, buf, len); + i += 2; + } else if (fc == 'g') { + n += mjson_print_dbl(fn, fnd, va_arg(*ap, double), 6); + } else if (strncmp(&fmt[i], ".*g", 3) == 0) { + int width = va_arg(*ap, int); + n += mjson_print_dbl(fn, fnd, va_arg(*ap, double), width); + i += 2; +#if MJSON_ENABLE_BASE64 + } else if (fc == 'V') { + int len = va_arg(*ap, int); + const char *buf = va_arg(*ap, const char *); + n += mjson_print_b64(fn, fnd, (const unsigned char *) buf, len); +#endif + } else if (fc == 'H') { + const char *hex = "0123456789abcdef"; + int j, len = va_arg(*ap, int); + const unsigned char *p = va_arg(*ap, const unsigned char *); + n += fn("\"", 1, fnd); + for (j = 0; j < len; j++) { + n += fn(&hex[(p[j] >> 4) & 15], 1, fnd); + n += fn(&hex[p[j] & 15], 1, fnd); + } + n += fn("\"", 1, fnd); + } else if (fc == 'M') { + mjson_vprint_fn_t vfn = va_arg(*ap, mjson_vprint_fn_t); + n += vfn(fn, fnd, ap); + } + i++; + } else { + n += mjson_print_buf(fn, fnd, &fmt[i++], 1); + } + } + return n; +} + +int mjson_printf(mjson_print_fn_t fn, void *fnd, const char *fmt, ...) { + va_list ap; + int len; + va_start(ap, fmt); + len = mjson_vprintf(fn, fnd, fmt, &ap); + va_end(ap); + return len; +} +#endif /* MJSON_ENABLE_PRINT */ + +static int is_digit(int c) { + return c >= '0' && c <= '9'; +} + +/* NOTE: strtod() implementation by Yasuhiro Matsumoto. */ +static double mystrtod(const char *str, const char **end) { + double d = 0.0; + int sign = 1, n = 0; + const char *p = str, *a = str; + + /* decimal part */ + if (*p == '-') { + sign = -1; + ++p; + } else if (*p == '+') { + ++p; + } + if (is_digit(*p)) { + d = (double) (*p++ - '0'); + while (*p && is_digit(*p)) { + d = d * 10.0 + (double) (*p - '0'); + ++p; + ++n; + } + a = p; + } else if (*p != '.') { + goto done; + } + d *= sign; + + /* fraction part */ + if (*p == '.') { + double f = 0.0; + double base = 0.1; + ++p; + + if (is_digit(*p)) { + while (*p && is_digit(*p)) { + f += base * (*p - '0'); + base /= 10.0; + ++p; + ++n; + } + } + d += f * sign; + a = p; + } + + /* exponential part */ + if ((*p == 'E') || (*p == 'e')) { + int i, e = 0, neg = 0; + p++; + if (*p == '-') p++, neg++; + if (*p == '+') p++; + while (is_digit(*p)) e = e * 10 + *p++ - '0'; + if (neg) e = -e; +#if 0 + if (d == 2.2250738585072011 && e == -308) { + d = 0.0; + a = p; + goto done; + } + if (d == 2.2250738585072012 && e <= -308) { + d *= 1.0e-308; + a = p; + goto done; + } +#endif + for (i = 0; i < e; i++) d *= 10; + for (i = 0; i < -e; i++) d /= 10; + a = p; + } else if (p > str && !is_digit(*(p - 1))) { + a = str; + goto done; + } + +done: + if (end) *end = a; + return d; +} + +#if MJSON_ENABLE_MERGE +int mjson_merge(const char *s, int n, const char *s2, int n2, + mjson_print_fn_t fn, void *userdata) { + int koff, klen, voff, vlen, t, t2, k, off = 0, len = 0, comma = 0; + if (n < 2) return len; + len += fn("{", 1, userdata); + while ((off = mjson_next(s, n, off, &koff, &klen, &voff, &vlen, &t)) != 0) { + char *path = (char *) alloca((size_t) klen + 1); + const char *val; + memcpy(path, "$.", 2); + memcpy(path + 2, s + koff + 1, (size_t) (klen - 2)); + path[klen] = '\0'; + if ((t2 = mjson_find(s2, n2, path, &val, &k)) != MJSON_TOK_INVALID) { + if (t2 == MJSON_TOK_NULL) continue; // null deletes the key + } else { + val = s + voff; // Key is not found in the update. Copy the old value. + } + if (comma) len += fn(",", 1, userdata); + len += fn(s + koff, klen, userdata); + len += fn(":", 1, userdata); + if (t == MJSON_TOK_OBJECT && t2 == MJSON_TOK_OBJECT) { + len += mjson_merge(s + voff, vlen, val, k, fn, userdata); + } else { + if (t2 != MJSON_TOK_INVALID) vlen = k; + len += fn(val, vlen, userdata); + } + comma = 1; + } + // Add missing keys + off = 0; + while ((off = mjson_next(s2, n2, off, &koff, &klen, &voff, &vlen, &t)) != 0) { + char *path = (char *) alloca((size_t) klen + 1); + const char *val; + if (t == MJSON_TOK_NULL) continue; + memcpy(path, "$.", 2); + memcpy(path + 2, s2 + koff + 1, (size_t) (klen - 2)); + path[klen] = '\0'; + if (mjson_find(s, n, path, &val, &vlen) != MJSON_TOK_INVALID) continue; + if (comma) len += fn(",", 1, userdata); + len += fn(s2 + koff, klen, userdata); + len += fn(":", 1, userdata); + len += fn(s2 + voff, vlen, userdata); + comma = 1; + } + len += fn("}", 1, userdata); + return len; +} +#endif // MJSON_ENABLE_MERGE + +#if MJSON_ENABLE_PRETTY +struct prettydata { + int level; + int len; + int prev; + const char *pad; + int padlen; + mjson_print_fn_t fn; + void *userdata; +}; + +static int pretty_cb(int ev, const char *s, int off, int len, void *ud) { + struct prettydata *d = (struct prettydata *) ud; + int i; + switch (ev) { + case '{': + case '[': + d->level++; + d->len += d->fn(s + off, len, d->userdata); + break; + case '}': + case ']': + d->level--; + if (d->prev != '[' && d->prev != '{' && d->padlen > 0) { + d->len += d->fn("\n", 1, d->userdata); + for (i = 0; i < d->level; i++) + d->len += d->fn(d->pad, d->padlen, d->userdata); + } + d->len += d->fn(s + off, len, d->userdata); + break; + case ',': + d->len += d->fn(s + off, len, d->userdata); + if (d->padlen > 0) { + d->len += d->fn("\n", 1, d->userdata); + for (i = 0; i < d->level; i++) + d->len += d->fn(d->pad, d->padlen, d->userdata); + } + break; + case ':': + d->len += d->fn(s + off, len, d->userdata); + if (d->padlen > 0) d->len += d->fn(" ", 1, d->userdata); + break; + case MJSON_TOK_KEY: + if (d->prev == '{' && d->padlen > 0) { + d->len += d->fn("\n", 1, d->userdata); + for (i = 0; i < d->level; i++) + d->len += d->fn(d->pad, d->padlen, d->userdata); + } + d->len += d->fn(s + off, len, d->userdata); + break; + default: + if (d->prev == '[' && d->padlen > 0) { + d->len += d->fn("\n", 1, d->userdata); + for (i = 0; i < d->level; i++) + d->len += d->fn(d->pad, d->padlen, d->userdata); + } + d->len += d->fn(s + off, len, d->userdata); + break; + } + d->prev = ev; + return 0; +} + +int mjson_pretty(const char *s, int n, const char *pad, mjson_print_fn_t fn, + void *userdata) { + struct prettydata d = {0, 0, 0, pad, (int) strlen(pad), fn, userdata}; + if (mjson(s, n, pretty_cb, &d) < 0) return -1; + return d.len; +} +#endif // MJSON_ENABLE_PRETTY + +#if MJSON_ENABLE_RPC +struct jsonrpc_ctx jsonrpc_default_context; + +int mjson_globmatch(const char *s1, int n1, const char *s2, int n2) { + int i = 0, j = 0, ni = 0, nj = 0; + while (i < n1 || j < n2) { + if (i < n1 && j < n2 && (s1[i] == '?' || s2[j] == s1[i])) { + i++, j++; + } else if (i < n1 && (s1[i] == '*' || s1[i] == '#')) { + ni = i, nj = j + 1, i++; + } else if (nj > 0 && nj <= n2 && (s1[i - 1] == '#' || s2[j] != '/')) { + i = ni, j = nj; + } else { + return 0; + } + } + return 1; +} + +void jsonrpc_return_errorv(struct jsonrpc_request *r, int code, + const char *message, const char *data_fmt, + va_list *ap) { + if (r->id_len == 0) return; + mjson_printf(r->fn, r->fn_data, + "{\"id\":%.*s,\"error\":{\"code\":%d,\"message\":%Q", r->id_len, + r->id, code, message == NULL ? "" : message); + if (data_fmt != NULL) { + mjson_printf(r->fn, r->fn_data, ",\"data\":"); + mjson_vprintf(r->fn, r->fn_data, data_fmt, ap); + } + mjson_printf(r->fn, r->fn_data, "}}\n"); +} + +void jsonrpc_return_error(struct jsonrpc_request *r, int code, + const char *message, const char *data_fmt, ...) { + va_list ap; + va_start(ap, data_fmt); + jsonrpc_return_errorv(r, code, message, data_fmt, &ap); + va_end(ap); +} + +void jsonrpc_return_successv(struct jsonrpc_request *r, const char *result_fmt, + va_list *ap) { + if (r->id_len == 0) return; + mjson_printf(r->fn, r->fn_data, "{\"id\":%.*s,\"result\":", r->id_len, r->id); + if (result_fmt != NULL) { + mjson_vprintf(r->fn, r->fn_data, result_fmt, ap); + } else { + mjson_printf(r->fn, r->fn_data, "%s", "null"); + } + mjson_printf(r->fn, r->fn_data, "}\n"); +} + +void jsonrpc_return_success(struct jsonrpc_request *r, const char *result_fmt, + ...) { + va_list ap; + va_start(ap, result_fmt); + jsonrpc_return_successv(r, result_fmt, &ap); + va_end(ap); +} + +void jsonrpc_ctx_process(struct jsonrpc_ctx *ctx, const char *buf, int len, + mjson_print_fn_t fn, void *fn_data, void *ud) { + const char *result = NULL, *error = NULL; + int result_sz = 0, error_sz = 0; + struct jsonrpc_method *m = NULL; + struct jsonrpc_request r = {ctx, buf, len, 0, 0, 0, 0, 0, 0, fn, fn_data, ud}; + + // Is is a response frame? + mjson_find(buf, len, "$.result", &result, &result_sz); + if (result == NULL) mjson_find(buf, len, "$.error", &error, &error_sz); + if (result_sz > 0 || error_sz > 0) { + if (ctx->response_cb) ctx->response_cb(buf, len, ctx->response_cb_data); + return; + } + + // Method must exist and must be a string + if (mjson_find(buf, len, "$.method", &r.method, &r.method_len) != + MJSON_TOK_STRING) { + mjson_printf(fn, fn_data, + "{\"error\":{\"code\":-32700,\"message\":%.*Q}}\n", len, buf); + return; + } + + // id and params are optional + mjson_find(buf, len, "$.id", &r.id, &r.id_len); + mjson_find(buf, len, "$.params", &r.params, &r.params_len); + + for (m = ctx->methods; m != NULL; m = m->next) { + if (mjson_globmatch(m->method, m->method_sz, r.method + 1, + r.method_len - 2) > 0) { + if (r.params == NULL) r.params = ""; + m->cb(&r); + break; + } + } + if (m == NULL) { + jsonrpc_return_error(&r, JSONRPC_ERROR_NOT_FOUND, "method not found", NULL); + } +} + +static int jsonrpc_print_methods(mjson_print_fn_t fn, void *fn_data, + va_list *ap) { + struct jsonrpc_ctx *ctx = va_arg(*ap, struct jsonrpc_ctx *); + struct jsonrpc_method *m; + int len = 0; + for (m = ctx->methods; m != NULL; m = m->next) { + if (m != ctx->methods) len += mjson_print_buf(fn, fn_data, ",", 1); + len += mjson_print_str(fn, fn_data, m->method, (int) strlen(m->method)); + } + return len; +} + +void jsonrpc_list(struct jsonrpc_request *r) { + jsonrpc_return_success(r, "[%M]", jsonrpc_print_methods, r->ctx); +} + +void jsonrpc_ctx_init(struct jsonrpc_ctx *ctx, mjson_print_fn_t response_cb, + void *response_cb_data) { + ctx->methods = NULL; + ctx->response_cb = response_cb; + ctx->response_cb_data = response_cb_data; +} + +void jsonrpc_init(mjson_print_fn_t response_cb, void *userdata) { + struct jsonrpc_ctx *ctx = &jsonrpc_default_context; + jsonrpc_ctx_init(ctx, response_cb, userdata); + jsonrpc_ctx_export(ctx, MJSON_RPC_LIST_NAME, jsonrpc_list); +} +#endif // MJSON_ENABLE_RPC diff --git a/apps/usr_le_code/thirdpart/mjson/mjson.h b/apps/usr_le_code/thirdpart/mjson/mjson.h new file mode 100644 index 0000000..d8156e0 --- /dev/null +++ b/apps/usr_le_code/thirdpart/mjson/mjson.h @@ -0,0 +1,220 @@ +// Copyright (c) 2018-2020 Cesanta Software Limited +// All rights reserved +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#ifndef MJSON_H +#define MJSON_H + +#include +#include +#include + +#ifndef MJSON_ENABLE_PRINT +#define MJSON_ENABLE_PRINT 1 +#endif + +#ifndef MJSON_ENABLE_RPC +#define MJSON_ENABLE_RPC 1 +#endif + +#ifndef MJSON_ENABLE_BASE64 +#define MJSON_ENABLE_BASE64 1 +#endif + +#ifndef MJSON_ENABLE_MERGE +#define MJSON_ENABLE_MERGE 1 +#endif + +#ifndef MJSON_ENABLE_PRETTY +#define MJSON_ENABLE_PRETTY 1 +#endif + +#ifndef MJSON_ENABLE_NEXT +#define MJSON_ENABLE_NEXT 1 +#endif + +#ifndef MJSON_RPC_LIST_NAME +#define MJSON_RPC_LIST_NAME "rpc.list" +#endif + +#ifndef MJSON_DYNBUF_CHUNK +#define MJSON_DYNBUF_CHUNK 256 // Allocation granularity for print_dynamic_buf +#endif + +#ifndef MJSON_REALLOC +#define MJSON_REALLOC realloc +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define MJSON_ERROR_INVALID_INPUT (-1) +#define MJSON_ERROR_TOO_DEEP (-2) +#define MJSON_TOK_INVALID 0 +#define MJSON_TOK_KEY 1 +#define MJSON_TOK_STRING 11 +#define MJSON_TOK_NUMBER 12 +#define MJSON_TOK_TRUE 13 +#define MJSON_TOK_FALSE 14 +#define MJSON_TOK_NULL 15 +#define MJSON_TOK_ARRAY 91 +#define MJSON_TOK_OBJECT 123 +#define MJSON_TOK_IS_VALUE(t) ((t) > 10 && (t) < 20) + +typedef int (*mjson_cb_t)(int event, const char *buf, int offset, int len, + void *fn_data); + +#ifndef MJSON_MAX_DEPTH +#define MJSON_MAX_DEPTH 20 +#endif + +int mjson(const char *buf, int len, mjson_cb_t cb, void *ud); +int mjson_find(const char *buf, int len, const char *jp, const char **tp, + int *tl); +int mjson_get_number(const char *buf, int len, const char *path, double *v); +int mjson_get_bool(const char *buf, int len, const char *path, int *v); +int mjson_get_string(const char *buf, int len, const char *path, char *to, + int n); +int mjson_get_hex(const char *buf, int len, const char *path, char *to, int n); + +#if MJSON_ENABLE_NEXT +int mjson_next(const char *buf, int len, int offset, int *key_offset, + int *key_len, int *val_offset, int *val_len, int *vale_type); +#endif + +#if MJSON_ENABLE_BASE64 +int mjson_get_base64(const char *buf, int len, const char *path, char *dst, + int dst_len); +int mjson_base64_dec(const char *src, int src_len, char *dst, int dst_len); +#endif + +#if MJSON_ENABLE_PRINT +typedef int (*mjson_print_fn_t)(const char *buf, int len, void *fn_data); +typedef int (*mjson_vprint_fn_t)(mjson_print_fn_t fn, void *, va_list *); + +struct mjson_fixedbuf { + char *ptr; + int size, len; +}; + +int mjson_printf(mjson_print_fn_t fn, void *fn_data, const char *fmt, ...); +int mjson_vprintf(mjson_print_fn_t fn, void *fn_data, const char *fmt, + va_list *ap); +int mjson_print_str(mjson_print_fn_t fn, void *fn_data, const char *buf, + int len); +int mjson_print_int(mjson_print_fn_t fn, void *fn_data, int value, + int is_signed); +int mjson_print_long(mjson_print_fn_t fn, void *fn_data, long value, + int is_signed); +int mjson_print_buf(mjson_print_fn_t fn, void *fn_data, const char *buf, + int len); +int mjson_print_dbl(mjson_print_fn_t fn, void *fn_data, double d, int width); + +int mjson_print_null(const char *ptr, int len, void *fn_data); +int mjson_print_fixed_buf(const char *ptr, int len, void *fn_data); +int mjson_print_dynamic_buf(const char *ptr, int len, void *fn_data); + +int mjson_snprintf(char *buf, size_t len, const char *fmt, ...); +char *mjson_aprintf(const char *fmt, ...); + +#if MJSON_ENABLE_PRETTY +int mjson_pretty(const char *s, int n, const char *pad, mjson_print_fn_t fn, + void *fn_data); +#endif + +#if MJSON_ENABLE_MERGE +int mjson_merge(const char *s, int n, const char *s2, int n2, + mjson_print_fn_t fn, void *fn_data); +#endif + +#endif // MJSON_ENABLE_PRINT + +#if MJSON_ENABLE_RPC + +void jsonrpc_init(mjson_print_fn_t response_cb, void *fn_data); +int mjson_globmatch(const char *s1, int n1, const char *s2, int n2); + +struct jsonrpc_request { + struct jsonrpc_ctx *ctx; + const char *frame; // Points to the whole frame + int frame_len; // Frame length + const char *params; // Points to the "params" in the request frame + int params_len; // Length of the "params" + const char *id; // Points to the "id" in the request frame + int id_len; // Length of the "id" + const char *method; // Points to the "method" in the request frame + int method_len; // Length of the "method" + mjson_print_fn_t fn; // Printer function + void *fn_data; // Printer function data + void *userdata; // Callback's user data as specified at export time +}; + +struct jsonrpc_method { + const char *method; + int method_sz; + void (*cb)(struct jsonrpc_request *); + struct jsonrpc_method *next; +}; + +// Main RPC context, stores current request information and a list of +// exported RPC methods. +struct jsonrpc_ctx { + struct jsonrpc_method *methods; + mjson_print_fn_t response_cb; + void *response_cb_data; +}; + +// Registers function fn under the given name within the given RPC context +#define jsonrpc_ctx_export(ctx, name, fn) \ + do { \ + static struct jsonrpc_method m = {(name), sizeof(name) - 1, (fn), 0}; \ + m.next = (ctx)->methods; \ + (ctx)->methods = &m; \ + } while (0) + +void jsonrpc_ctx_init(struct jsonrpc_ctx *ctx, mjson_print_fn_t response_cb, + void *response_cb_data); +void jsonrpc_return_error(struct jsonrpc_request *r, int code, + const char *message, const char *data_fmt, ...); +void jsonrpc_return_success(struct jsonrpc_request *r, const char *result_fmt, + ...); +void jsonrpc_ctx_process(struct jsonrpc_ctx *ctx, const char *req, int req_sz, + mjson_print_fn_t fn, void *fn_data, void *userdata); + +extern struct jsonrpc_ctx jsonrpc_default_context; +extern void jsonrpc_list(struct jsonrpc_request *r); + +#define jsonrpc_export(name, fn) \ + jsonrpc_ctx_export(&jsonrpc_default_context, (name), (fn)) + +#define jsonrpc_process(buf, len, fn, fnd, ud) \ + jsonrpc_ctx_process(&jsonrpc_default_context, (buf), (len), (fn), (fnd), (ud)) + +#define JSONRPC_ERROR_INVALID -32700 /* Invalid JSON was received */ +#define JSONRPC_ERROR_NOT_FOUND -32601 /* The method does not exist */ +#define JSONRPC_ERROR_BAD_PARAMS -32602 /* Invalid params passed */ +#define JSONRPC_ERROR_INTERNAL -32603 /* Internal JSON-RPC error */ + +#endif // MJSON_ENABLE_RPC +#ifdef __cplusplus +} +#endif +#endif // MJSON_H diff --git a/apps/usr_le_code/usr_le_adv.c b/apps/usr_le_code/usr_le_adv.c new file mode 100644 index 0000000..9faa88c --- /dev/null +++ b/apps/usr_le_code/usr_le_adv.c @@ -0,0 +1,340 @@ +/****************************************************************************** + * @file usr_le_adv.c + * @brief BLE 广播 / 配对 / OTA 广播切换 + * @author cyWu <1917507415@qq.com> + * @date 2026.08.19 + * @version V1.1.0 + * @history + * - V1.0.0, 2026.08.03, cyWu, 首次发布 + * - V1.1.0, 2026.08.19, cyWu, 对齐模组注释与助手；保留 SOC 上电绑广播策略 + ******************************************************************************/ + +#include "system/includes.h" +#include "app_config.h" +#include "app_main.h" +#include "vm.h" +#include "bleproto.h" +#include "bleproto_api.h" +#include "usr_le_product.h" + +#define LOG_TAG_CONST APP +#define LOG_TAG "[LE_ADV]" +#define LOG_ERROR_ENABLE +#define LOG_DEBUG_ENABLE +#define LOG_INFO_ENABLE +#include "debug.h" + +/****************************************************************************** + * 广播相关三个标志（务必区分）： + * + * 1) usr_auth_data.paired_flag —— 配网结果（存 VM，掉电保持） + * - 0：未配网 + * - 1：已配网（三元组已保存） + * + * 2) usr_var.usr_goto_pair —— 是否主动进入配网流程（RAM，掉电丢失） + * - 0：非配网流程 + * - 1：app_main 上电 / usr_goto_pair_mode() 触发，发【绑定广播】 + * + * 3) usr_var.usr_adv_flag —— 广播内容是否需要刷新到协议栈（一次性） + * - 1：usr_ble_adv_updata() 会重新 set adv data 并 enable + * - 0：本周期不刷新 + * + * SOC 决策表（与模组不同：未配网也发绑定广播，便于上电配网）： + * usr_goto_pair==1 → 绑定广播 + * paired_flag==0 → 绑定广播 + * paired_flag==1 → 回连广播 + ******************************************************************************/ + +extern u8 muti_adv_data[31]; +extern u8 muti_adv_data_len; + +/* 定义在 usr_le_recieve.c，库内共用，不对外导出 */ +extern bleproto_authsetup_req_t usr_auth_data; + +extern u16 usr_get_conn_service(void); +extern int muti_make_set_adv_data(u8 *data, u8 data_len); +extern int muti_make_set_adv_data_updata(void); +extern void usr_set_adv_interval(u16 val); +extern u16 usr_get_adv_interval(void); +extern void ble_multi_trans_disconnect(void); +extern void ble_trans_module_enable(u8 flag); +extern void usr_timer_loop(void); +extern u8 usr_get_ota_status(void); +extern void usr_ota_exit(void); + +void usr_ble_adv_init(void); +void usr_ble_adv_updata(void); + +static int le_timer_handle = 0; + +/** + * @brief BLE 是否已连接 + * @return 1=已连接，0=未连接 + */ +uint8_t usr_ble_is_connected(void) +{ + return (usr_get_conn_service() != 0) ? 1u : 0u; +} + +/** + * @brief 从 VM 读取配对信息到 usr_auth_data + * @note 失败则清零，并将 paired_flag 置 0 写回 + */ +void usr_get_pair_info(void) +{ + int ret; + + ret = syscfg_read(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data)); + if (ret <= 0) + { + memset(&usr_auth_data, 0x00, sizeof(usr_auth_data)); + usr_auth_data.paired_flag = 0; + syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data)); + } +} + +/** + * @brief 标记已配网并保存三元组到 VM + * @note AUTHSETUP 成功后调用，paired_flag = 1 + */ +void usr_write_pair_info(void) +{ + usr_auth_data.paired_flag = 1; + syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data)); +} + +/** + * @brief 清除配对信息并延时复位 + */ +void usr_clear_pair_info(void) +{ + printf("usr_clear_pair_info_reset\n"); + memset(&usr_auth_data, 0x00, sizeof(usr_auth_data)); + usr_auth_data.paired_flag = 0; + syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data)); + sys_timeout_add(NULL, cpu_reset, 600); +} + +/** + * @brief 清除配对信息但不复位（用于重新配网） + */ +void usr_clear_pair_info_noreset(void) +{ + printf("usr_clear_pair_info_noreset\n"); + memset(&usr_auth_data, 0x00, sizeof(usr_auth_data)); + usr_auth_data.paired_flag = 0; + syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data)); +} + +/** + * @brief 进入配网模式：清配对 + 置 usr_goto_pair + 发绑定广播 + */ +void usr_goto_pair_mode(void) +{ + ble_multi_trans_disconnect(); + usr_clear_pair_info_noreset(); + usr_var.usr_goto_pair = 1; + os_time_dly(5); + usr_ble_adv_init(); +} + +/** + * @brief 断开 BLE 并停止广播（复位/重启前） + */ +void usr_ble_disconnect_and_stop_adv(void) +{ + printf("usr_ble_disconnect_and_stop_adv\n"); + ble_multi_trans_disconnect(); + usr_var.usr_goto_pair = 0; + usr_var.usr_adv_flag = 0; + ble_trans_module_enable(0); +} + +/** + * @brief 按当前标志刷新广播策略并启动周期更新 + * @note 见文件头「三个标志」；SOC 未配网也发绑定广播 + */ +void usr_ble_adv_init(void) +{ + int8_t txpower = 0; + uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE] = {0}; + uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]; + uint8_t gmac[6] = {0}; + uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE]; + + /* 产品身份由应用层 g_usr_le_* 提供（见 usr_jb_main.c） */ + memcpy(prodcode, g_usr_le_prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE); + memcpy(pcode, g_usr_le_pcode, BLE_PROTO_ADV_LENGTH_PCODE); + + usr_set_adv_interval(80); + if (usr_var.usr_ota_succ_flag) + { + return; + } + + if (usr_var.usr_goto_pair) + { + /* app_main 上电已置 usr_goto_pair=1 并清配对信息，此处发绑定广播供网关配网 */ + usr_clear_pair_info_noreset(); + printf("goto pair bind adv, paired_flag=%d\n", usr_auth_data.paired_flag); + muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower, + manucode, pcode, prodcode); + usr_var.usr_adv_flag = 1; + } + else + { + usr_get_pair_info(); + if (usr_auth_data.paired_flag == 0) + { + /* SOC：未配网也发绑定广播（模组此处为不广播） */ + muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower, + manucode, pcode, prodcode); + usr_var.usr_adv_flag = 0; + } + else + { + memcpy(gmac, usr_auth_data.gwmac, 6); + muti_adv_data_len = bleproto_advdata_encode4reconn(muti_adv_data, txpower, gmac, + manucode, pcode, prodcode); + usr_var.usr_adv_flag = 1; + } + } + + usr_ble_adv_updata(); + if (le_timer_handle == 0) + { + le_timer_handle = sys_timer_add(NULL, usr_ble_adv_updata, 500); + } +} + +/** + * @brief 获取是否已配网 + * @return 1=已配网，0=未配网 + */ +u8 usr_get_pair_flag(void) +{ + return usr_auth_data.paired_flag; +} + +/** + * @brief 周期处理广播刷新（由 500ms 定时器调用） + * @note 仅当 usr_adv_flag==1 时：停广播 → 写入 muti_adv_data → 再开广播 + */ +void usr_ble_adv_updata(void) +{ + static u16 usr_goto_slow_adv = 0; + + if (usr_var.usr_adv_flag) + { + ble_trans_module_enable(0); + usr_var.usr_adv_flag = 0; + muti_make_set_adv_data(muti_adv_data, muti_adv_data_len); + printf("###muti_adv_data = "); + printf_buf(muti_adv_data, muti_adv_data_len); + ble_trans_module_enable(1); + } + + if (!usr_ble_is_connected()) + { + /* 未连接：回连快广播（80）持续约 60s（500ms×120）后切慢广播 */ + if (usr_get_adv_interval() == 80) + { + if ((usr_var.usr_goto_pair == 0) && usr_auth_data.paired_flag) + { + if (usr_var.usr_ota_succ_flag == 0) + { + usr_goto_slow_adv++; + printf("usr_goto_slow_adv = %d\n", usr_goto_slow_adv); + } + if (usr_goto_slow_adv >= 120) + { + usr_goto_slow_adv = 0; + usr_set_adv_interval(80 * 10); + usr_var.usr_adv_flag = 1; + } + } + } + else + { + usr_goto_slow_adv = 0; + } + } + else + { + usr_goto_slow_adv = 0; + } + + if (usr_get_ota_status() == 0) + { + if (!usr_ble_is_connected()) + { + if (usr_var.usr_ota_succ_flag == 0) + { + usr_ota_exit(); + } + } + } + + /* 协议层周期处理（上报/应答） */ + usr_timer_loop(); +} + +void usr_soft_off(void) +{ + sys_enter_soft_poweroff(NULL); +} + +void usr_ble_adv_updata_OTA(void) +{ + ble_trans_module_enable(0); + usr_var.usr_adv_flag = 0; + + extern u8 usr_mac_addr[6]; + extern int le_controller_set_mac(void *addr); + usr_mac_addr[0] = usr_mac_addr[0] + 1; + le_controller_set_mac(usr_mac_addr); + muti_make_set_adv_data_updata(); + printf("###muti_adv_data = "); + printf_buf(muti_adv_data, muti_adv_data_len); + ble_trans_module_enable(1); +} + +void usr_ota_process(void) +{ + static u8 cnt = 0; + + if (cnt == 0) + { + ble_multi_trans_disconnect(); + } + + if (!usr_ble_is_connected()) + { + cnt++; + if (cnt == 2) + { + usr_ble_adv_updata_OTA(); + } + if (cnt >= 60) + { + cnt = 0; + cpu_reset(); + } + } + else + { + cnt = 1; + } +} + +/** + * @brief 旧版 RCSP/JSON OTA 入口；产品 JB 0x30/0x32 路径不要调用 + */ +void usr_app_ota_init(void) +{ + usr_var.usr_goto_updata = 1; + if (usr_var.ota_timer == 0) + { + usr_var.ota_timer = sys_timer_add(NULL, usr_ota_process, 1000); + } +} diff --git a/apps/usr_le_code/usr_le_recieve.c b/apps/usr_le_code/usr_le_recieve.c new file mode 100644 index 0000000..4e0ddfe --- /dev/null +++ b/apps/usr_le_code/usr_le_recieve.c @@ -0,0 +1,377 @@ +/****************************************************************************** + * @file usr_le_recieve.c + * @brief BLE 收包入口：bleproto 解析后分发配网 / 对时 / JB 协议 / 组应答 + * @author cyWu <1917507415@qq.com> + * @date 2026.08.19 + * @version V1.1.0 + * @history + * - V1.0.0, 2026.08.03, cyWu, 首次发布 + * - V1.1.0, 2026.08.19, cyWu, 对齐模组结构；废弃 JSON OTA；修 AUTHDELETE serviceid + ******************************************************************************/ + +#include "system/includes.h" +#include "app_config.h" +#include "app_main.h" +#include "vm.h" +#include "bleproto.h" +#include "bleproto_api.h" +#include "ble_proto.h" +#include "usr_rtc.h" +#include "usr_le_api.h" +#include "jb_protocol.h" + +#define LOG_TAG_CONST APP +#define LOG_TAG "[USR_LE]" +#define LOG_ERROR_ENABLE +#define LOG_DEBUG_ENABLE +#define LOG_INFO_ENABLE +#include "debug.h" + +/* 拼 GATT 分包：业务包 ≈ bleproto头 + V2 开销 + JB 帧(<=128)，1024 足够 */ +#define USR_LE_RX_BUF_LEN 1024 +#define USR_LE_V2_WRAP_OVERHEAD 32u /* V2 头开销，JB 帧最大 128 → 约 160 */ +#define USR_LE_V2_CMD_REPORT 100u /* REPORTCMD_V2 内层 cmd */ +#define USR_LE_V2_CMD_RUN 110u /* RUNCMD_V2 内层 cmd */ +#define USR_LE_JB_CMD_OFF 4u /* 55 AA | LEN_H LEN_L | CMD */ + +static int encode_len = 0; +static u8 txbuf[384] = {0}; +static u8 rxbuf[USR_LE_RX_BUF_LEN] = {0}; +static u8 s_last_runcmd_msgid = 0; /* RUNCMD_V2 应答须回填最近 msgid */ + +bleproto_authsetup_req_t usr_auth_data; + +extern void usr_ble_send_data(u8 *data, u16 len); +extern u8 usr_ble_is_notify_ready(void); +extern void usr_write_pair_info(void); +extern void usr_clear_pair_info(void); +extern void usr_jb_le_recieve_data(u8 *data, u16 len); +extern int8_t jbReportAckCheck(u16 cmd, u8 gateway_int_cnt, int32_t gateway_int0); + +static void usr_data_ana(bleproto_appdata_desc_t *desc); +static void usr_run_cmd_code_v2(ble_proto_packet_t *runcmd_par, u8 usr_msg_id); + +/** + * @brief 填 bleproto 应答头 + * @param out 输出 desc + * @param in 请求 desc（取 msgid） + * @param serviceid 服务号 + */ +static void usr_le_fill_rsp_header(bleproto_appdata_desc_t *out, + const bleproto_appdata_desc_t *in, + uint8_t serviceid) +{ + out->header.version = 0; + out->header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON; + out->header.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP; + out->header.msgid = in->header.msgid; + out->header.encrypt = 0; + out->header.serviceid = serviceid; +} + +/** + * @brief 编码并经 BLE 发出 + * @param desc 已填好的应答 + */ +static void usr_le_encode_and_send(bleproto_appdata_desc_t *desc) +{ + encode_len = bleproto_appdata_encode(txbuf, sizeof(txbuf), sizeof(txbuf), desc); + if (encode_len > 0) + { + printf("encode_len = %d\n", encode_len); + usr_ble_send_data(txbuf, encode_len); + } + else + { + printf("encode_len fail %d\n", encode_len); + } +} + +/** + * @brief 是否走网关主动上报（REPORTCMD_V2） + * @param jb_cmd 55AA 命令字 + * @return 1=主动上报，0=RUNCMD 应答 + */ +static uint8_t usr_le_is_gateway_report_cmd(uint8_t jb_cmd) +{ + return (jb_cmd == CMD_REPORT || + jb_cmd == CMD_OTA_COMPLETE || + jb_cmd == CMD_OTA_STOP_MCU) + ? 1u + : 0u; +} + +/** + * @brief BLE 收包入口 + * @param data 收包数据 + * @param len 数据长度 + */ +void usr_le_data_recieve(u8 *data, u16 len) +{ + static u16 usr_len = 0; + /* desc 含 ycmd 等 union，放 static，避免每次收包在栈上开大块 */ + static bleproto_appdata_desc_t s_rx_desc; + int rc_result = 0; + + if (!data || len == 0) + { + return; + } + if ((u32)usr_len + len > sizeof(rxbuf)) + { + printf("### rxbuf overflow, usr_len=%u len=%u, reset\n", usr_len, len); + usr_len = 0; + return; + } + + memcpy(&rxbuf[usr_len], data, len); + usr_len += len; + rc_result = bleproto_appdata_decode(rxbuf, usr_len, &s_rx_desc); + if (rc_result < 0) + { + printf("### invild pack\n"); + usr_len = 0; + } + else if (rc_result == 0) + { + printf("### keep recieving\n"); + } + else + { + printf("### pack recieved ok\n"); + usr_len = 0; + usr_data_ana(&s_rx_desc); + } +} + +/** + * @brief 解析 bleproto 服务并分发 + * @param desc 已 decode 的包 + */ +static void usr_data_ana(bleproto_appdata_desc_t *desc) +{ + static bleproto_appdata_desc_t s_encode_desc; + + memset(&s_encode_desc, 0, sizeof(s_encode_desc)); + printf("desc serviceid=%d msgtype=%d\n", + desc->header.serviceid, desc->header.msgtype); + + if (desc->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ) + { + switch (desc->header.serviceid) + { + case E_BLEPROTO_SERVICE_ID_DEVICEINFO: { + bleproto_deviceinfo_req_t *req = &desc->datast.deviceinfo_req; + bleproto_deviceinfo_rsp_t *rsp = &s_encode_desc.datast.deviceinfo_rsp; + + /* 网关从子设备连上开始计时，每 12 小时经 DEVICEINFO 同步一次 */ + usr_rtc_set_from_unix(req->t, (int32_t)req->gmtoff); + + usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_DEVICEINFO); + rsp->hbcycle = 1000; + strcpy(rsp->swv, "V1.0.0.00"); + strcpy(rsp->hwv, "V1.0.0.00"); + rsp->longcon = 1; + rsp->prototype = 4; + usr_le_encode_and_send(&s_encode_desc); + break; + } + case E_BLEPROTO_SERVICE_ID_AUTHSETUP: { + bleproto_authsetup_rsp_t *au_rsp = &s_encode_desc.datast.authsetup_rsp; + + printf("E_BLEPROTO_SERVICE_ID_AUTHSETUP\n"); + usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_AUTHSETUP); + au_rsp->errcode = 0; + memcpy(&usr_auth_data, &desc->datast.authsetup_req, sizeof(usr_auth_data)); + if (usr_auth_data.paired_flag == 0) + { + usr_write_pair_info(); + usr_var.usr_goto_pair = 0; // 新增：退出强制配网 + printf("usr_auth_data %s %s ", usr_auth_data.authcode, usr_auth_data.devid); + printf_buf(usr_auth_data.gwmac, 6); + } + usr_le_encode_and_send(&s_encode_desc); + break; + } + case E_BLEPROTO_SERVICE_ID_AUTHDELETE: { + bleproto_authdelete_rsp_t *aude_rsp = &s_encode_desc.datast.authdelete_rsp; + + printf("E_BLEPROTO_SERVICE_ID_AUTHDELETE\n"); + usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_AUTHDELETE); + memcpy(aude_rsp->gwmac, usr_auth_data.gwmac, 6); + if (!memcmp(usr_auth_data.authcode, desc->datast.authdelete_req.authcode, 32)) + { + aude_rsp->errcode = 0; + usr_clear_pair_info(); + } + else + { + aude_rsp->errcode = 501; + } + usr_le_encode_and_send(&s_encode_desc); + break; + } + case E_BLEPROTO_SERVICE_ID_RUNCMD: + printf("E_BLEPROTO_SERVICE_ID_RUNCMD\n"); + break; + case E_BLEPROTO_SERVICE_ID_RUNCMD_V2: + printf("E_BLEPROTO_SERVICE_ID_RUNCMD_V2\n"); + usr_run_cmd_code_v2(&desc->datast.runcmd_v2_req, desc->header.msgid); + break; + case E_BLEPROTO_SERVICE_ID_OTANOTIFY: + case E_BLEPROTO_SERVICE_ID_OTADATA: + case E_BLEPROTO_SERVICE_ID_OTADATA_V2: + /* JSON OTA 已废弃，SOC 走 JB 0x30/0x32 */ + printf("JSON OTA deprecated, use JB 0x30/0x32\n"); + break; + default: + printf("err !!! default event desc->header.serviceid =%d\n", + desc->header.serviceid); + break; + } + return; + } + + if (desc->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP) + { + switch (desc->header.serviceid) + { + case E_BLEPROTO_SERVICE_ID_REPORTCMD: + printf("E_BLEPROTO_SERVICE_ID_REPORTCMD errcode=%d\n", + desc->datast.reportcmd_rsp.errcode); + break; + case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2: { + ble_proto_packet_t *rpt_ack = &desc->datast.reportcmd_v2_rsp; + + printf("REPORTCMD_V2 cmd=%u cnt=%u int0=%ld\n", + (unsigned)rpt_ack->cmd, + (unsigned)rpt_ack->gateway_int_cnt, + (long)((rpt_ack->gateway_int_cnt > 0) ? rpt_ack->gateway_int[0] : 0)); + jbReportAckCheck(rpt_ack->cmd, + rpt_ack->gateway_int_cnt, + (rpt_ack->gateway_int_cnt > 0) ? rpt_ack->gateway_int[0] : -1); + break; + } + case E_BLEPROTO_SERVICE_ID_OTADATA: + printf("JSON OTA deprecated, use JB 0x32\n"); + break; + default: + printf("unhandled RSP serviceid=%d\n", desc->header.serviceid); + break; + } + } +} + +/** + * @brief APP RUNCMD_V2：55AA 字节流转交 JB 协议层 + * @param runcmd_par 内层包 + * @param usr_msg_id bleproto msgid + */ +static void usr_run_cmd_code_v2(ble_proto_packet_t *runcmd_par, u8 usr_msg_id) +{ + u8 jb_frame[MAX_PACKAGE_LEN]; + u16 copy_len; + + if (!runcmd_par || !runcmd_par->bytes_data || runcmd_par->device_bytes_len == 0) + { + printf("usr_run_cmd_code_v2 invalid bytes, len=%u\n", + runcmd_par ? runcmd_par->device_bytes_len : 0); + return; + } + + printf("runcmd_par id = %d, bytes_len = %u\n", + runcmd_par->cmd, runcmd_par->device_bytes_len); + + copy_len = runcmd_par->device_bytes_len; + if (copy_len > sizeof(jb_frame)) + { + printf("usr_run_cmd_code_v2 bytes too long %u\n", copy_len); + return; + } + memcpy(jb_frame, runcmd_par->bytes_data, copy_len); + + s_last_runcmd_msgid = usr_msg_id; + usr_jb_le_recieve_data(jb_frame, copy_len); +} + +/** + * @brief 将 JB 协议帧封装为 bleproto V2 后通过 BLE 发送 + * @param data JB 协议原始帧（55 AA | LEN | CMD | ...） + * @param len 帧长度 + * @note 主动上报(0x07/0x34/0x38) → REPORTCMD_V2；其余 → RUNCMD_V2 应答 + * 对外符号名保持 ble_send_data，供 jb_protocol 调用 + */ +void ble_send_data(u8 *data, u16 len) +{ + ble_proto_packet_t pkt; + bleproto_appdata_header_t hdr; + u8 v2_buf[MAX_PACKAGE_LEN + USR_LE_V2_WRAP_OVERHEAD]; + u8 jb_cmd; + u8 is_active_send; + int plen; + int elen; + + if (!data || len < 5) + { + printf("ble_send_data invalid param, len=%d\n", len); + return; + } + // if (len > MAX_PACKAGE_LEN) + // { + // printf("ble_send_data frame too long %u\n", len); + // return; + // } + if (!usr_ble_is_notify_ready()) + { + printf("ble_send_data wait CCC cmd=0x%02X\n", data[USR_LE_JB_CMD_OFF]); + return; + } + + jb_cmd = data[USR_LE_JB_CMD_OFF]; + is_active_send = usr_le_is_gateway_report_cmd(jb_cmd); + + memset(&pkt, 0, sizeof(pkt)); + memset(&hdr, 0, sizeof(hdr)); + hdr.version = 0; + hdr.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON; + hdr.encrypt = 0; + + if (is_active_send) + { + hdr.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ; + hdr.msgid = 0; + hdr.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD_V2; + pkt.cmd = USR_LE_V2_CMD_REPORT; + pkt.gateway_int_cnt = 0; + } + else + { + hdr.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP; + hdr.msgid = s_last_runcmd_msgid; + hdr.serviceid = E_BLEPROTO_SERVICE_ID_RUNCMD_V2; + pkt.cmd = USR_LE_V2_CMD_RUN; + pkt.gateway_int_cnt = 2; + pkt.gateway_int[0] = 0; + pkt.gateway_int[1] = 0; + } + + pkt.device_bytes_len = len; + pkt.bytes_data = data; + + plen = ble_proto_pack(&pkt, v2_buf, sizeof(v2_buf)); + if (plen <= 0) + { + printf("ble_send_data pack fail %d\n", plen); + return; + } + + elen = bleproto_appdata_wrap_raw(txbuf, sizeof(txbuf), &hdr, v2_buf, (uint16_t)plen); + printf("ble_send_data jb_cmd=0x%02X active=%d encode_len=%d msgid=%d\n", + jb_cmd, is_active_send, elen, hdr.msgid); + if (elen <= 0) + { + return; + } + usr_ble_send_data(txbuf, elen); + printf_buf(txbuf, elen); +}