/** * @file command.c * @brief 串口命令解析与处理模块实现 * @details 实现基于状态机的协议解析器，支持 D5 03 LEN [cmd] CRC 格式的命令处理， * 包含命令帧解析、响应生成和传感器状态管理功能。 * @author Hulk * @date 2025-08-13 * @version 1.0.0 * @ingroup Command */ #include "command.h" #include "uart_ring_buffer.h" #include "led.h" #include #include #include #include "board_config.h" #include "gd32e23x_usart.h" #include "ldc1612.h" /* ============================================================================ * 协议格式说明 * ============================================================================ */ /** * @name 协议帧格式 * @{ * @details * Host -> Device 命令帧格式： * [0] HEADER = 0xD5 // 包头标识 * [1] BOARD_TYPE = 0x03 // 板卡类型标识 * [2] LEN = 数据区字节数 // 有效载荷长度 * [3..(3+LEN-1)] 数据 // 命令数据，如 "M1", "M2S123" * [last] CRC = 校验码 // 从索引1到(last-1)的累加和低8位 * * 最小协议包长度为 6 字节 * 数据示例（两字节命令）："M1" / "M2" / "M3" * * Device -> Host 响应帧格式： * [0] 0xB5 // 响应包头 * [1] TYPE // 响应类型（0xF0=成功，0xF1..=错误类型） * [2] LEN // 响应数据长度 * [3..(3+LEN-1)] 数据 // 响应数据，如 "ok", "err" * [last] CRC // 校验码（同命令帧规则） * @} */ /* ============================================================================ * 协议常量定义 * ============================================================================ */ /** @name 协议帧标识符 * @{ */ #define PROTOCOL_PACKAGE_HEADER 0xD5 /**< 命令帧包头标识 */ #define PROTOCOL_BOARD_TYPE 0x03 /**< 板卡类型标识 */ /** @} */ /** @name 命令长度限制 * @{ */ #define COMMAND_MIN_LEN 2 /**< 最小命令长度，如"M1" */ #define PROTOCOL_MIN_FRAME_LEN (3 + COMMAND_MIN_LEN + 1) /**< 最小完整帧长度：header+type+len+payload+crc = 6 */ #define PROTOCOL_MAX_FRAME_LEN 16 /**< 最大完整帧长度 */ /** @} */ /** @name 响应帧标识符 * @{ */ #define RESP_HEADER 0xB5 /**< 响应帧包头标识 */ #define RESP_TYPE_OK 0xF0 /**< 成功响应类型 */ #define RESP_TYPE_CRC_ERR 0xF1 /**< CRC校验错误 */ #define RESP_TYPE_HEADER_ERR 0xF2 /**< 包头错误 */ #define RESP_TYPE_TYPE_ERR 0xF3 /**< 类型错误 */ #define RESP_TYPE_LEN_ERR 0xF4 /**< 长度错误 */ /** @} */ /* ============================================================================ * 模块内部变量 * ============================================================================ */ /** @brief 传感器周期上报使能标志 */ volatile bool g_sensor_report_enabled = false; /** @name 预设响应数据 * @{ */ static const uint8_t s_report_status_ok[] = { 'o', 'k' }; /**< 成功响应数据 */ static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应数据 */ /** @} */ /* ============================================================================ * 公共接口函数 * ============================================================================ */ /** * @brief 查询是否启用周期性传感器上报。 * @return true 表示启用；false 表示禁用。 * @ingroup Command */ bool get_sensor_report_enabled(void) { return g_sensor_report_enabled; } /** * @brief 设置是否启用周期性传感器上报标志。 * @details 本模块内部保存的布尔状态，供其他逻辑决定是否进行周期性数据上报； * 推荐通过本函数修改而非直接访问全局/静态变量，以便后续扩展（如加锁/回调）。 * @param status true 启用周期上报；false 禁用。 * @ingroup Command */ void set_sensor_report_status(bool status) { g_sensor_report_enabled = status; } /** * @brief 计算协议包的 8 位累加校验值（Checksum）。 * @details 对输入缓冲区逐字节累加并取低 8 位，累加范围为 data[1] 至 data[len-2]， * 即不包含包头 HEADER（索引 0）与尾部 CRC 字节（索引 len-1）。 * 当 len 小于最小协议帧长度（PACKAGE_MIN_LENGTH）时返回 0。 * @param data 指向待校验的完整协议包缓冲区。 * @param len 缓冲区总长度（字节），应满足 header + type + len + payload + crc 的最小格式。 * @return uint8_t 计算得到的 8 位校验值。 * @note 本函数实现为简单求和校验（Checksum），非多项式 CRC；与本协议“从索引 1 累加到 len-2”的规则一致。 * @ingroup Command */ static uint8_t command_sum_crc_calc(const uint8_t *data, uint8_t len) { uint16_t crc = 0; // 仅在满足协议最小帧长时计算（header + type + len + payload + crc） if (len < PROTOCOL_MIN_FRAME_LEN) return 0; // 累加从索引 1 到 len-2 的字节（不含 header 和 crc 字节） for (uint8_t i = 1; i < (len - 1); i++) { crc += data[i]; } return (uint8_t)(crc & 0xFF); } /** * @brief 发送协议响应帧（使用GD32E230标准库）。 * @details 构造并发送格式为 B5 TYPE LEN [payload] CRC 的响应帧， * 自动计算CRC校验值并通过串口输出。 * @param type 响应类型码（如 RESP_TYPE_OK, RESP_TYPE_CRC_ERR 等）。 * @param payload 指向响应数据的缓冲区，当len为0时可为NULL。 * @param len 响应数据长度（字节），为0时不复制payload数据。 * @note 内部使用固定大小缓冲区，超长响应将被丢弃。 * @warning 使用GD32E230标准库函数发送，确保串口已正确初始化。 * @ingroup Command */ static void send_response(uint8_t type, const uint8_t *payload, uint8_t len) { uint8_t buf_len = (uint8_t)(3 + len + 1); uint8_t buf[16]; // 简单场景足够，必要时可增大 if (buf_len > sizeof(buf)) return; // 防御 buf[0] = RESP_HEADER; buf[1] = type; buf[2] = len; // 简化逻辑：只有当len > 0且payload非空时才复制数据 if (len > 0 && payload != NULL) { for (uint8_t i = 0; i < len; i++) { buf[3 + i] = payload[i]; } } buf[buf_len - 1] = command_sum_crc_calc(buf, buf_len); // 使用GD32E230标准库函数逐字节发送（标准库实现） for (uint8_t i = 0; i < buf_len; i++) { // 等待发送缓冲区空 while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {} usart_data_transmit(RS485_PHY, buf[i]); } // 等待发送完成 while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {} // // 使用printf发送（通过重定向到串口） // for (uint8_t i = 0; i < buf_len; i++) { // printf("%c", buf[i]); // } // // 刷新缓冲区 // fflush(stdout); } /** * @brief 判断字符是否为十进制数字字符。 * @param c 待检查的字符（ASCII码值）。 * @return bool 判断结果。 * @retval true 字符为 '0' 到 '9' 之间的数字字符。 * @retval false 字符不是十进制数字字符。 * @ingroup Command */ static inline bool is_dec_digit(uint8_t c) { return (c >= '0' && c <= '9'); } /** * @brief 从缓冲区解析十进制无符号整数。 * @details 从指定位置开始连续读取十进制数字字符，累加构成32位无符号整数。 * 遇到非数字字符或到达长度限制时停止解析。 * @param s 指向待解析字符缓冲区的起始位置。 * @param n 允许解析的最大字符数。 * @param out 输出参数，存储解析结果，可为NULL。 * @return uint8_t 实际消耗的字符数。 * @retval 0 首字符不是数字，解析失败。 * @retval >0 成功解析的数字字符个数。 * @note 不处理符号、空白字符或进制前缀。 * @warning 不进行溢出检查，超出uint32_t范围时按无符号算术溢出处理。 * @ingroup Command */ static uint8_t parse_uint_dec(const uint8_t *s, uint8_t n, uint32_t *out) { uint8_t i = 0; uint32_t v = 0; while (i < n && is_dec_digit(s[i])) { v = v * 10u + (uint32_t)(s[i] - '0'); i++; } if (i == 0) return 0; // 未读到数字 if (out) *out = v; // return i; } /* ============================================================================ * 命令处理函数 * ============================================================================ */ /** * @brief 解析并处理完整的命令帧。 * @details 处理经过协议校验的完整命令帧，支持以下命令格式： * - 无参数命令：M<数字>（如 M1、M2、M10、M201） * - 带参数命令：M<数字>S<参数>（如 M100S123，参数为十进制） * * 支持的命令： * - M1: 开启LED，启用传感器上报 * - M2: 关闭LED，禁用传感器上报 * - M100S: 设置PWM值（示例） * * @param frame 指向完整命令帧的缓冲区（从包头0xD5开始）。 * @param len 命令帧总长度（字节）。 * @note 函数内部进行帧格式校验，格式错误时自动发送错误响应。 * @warning 假设输入帧已通过基本协议校验（包头、类型、CRC等）。 * @ingroup Command */ void handle_command(const uint8_t *frame, uint8_t len) { // 帧格式：D5 03 LEN [cmd] CRC; cmd 支持变长，如 "M1"、"M10"、"M201"、"M123S400"，有最小长度限制和命令长度校验 uint8_t cmd_len = frame[2]; if (len < PROTOCOL_MIN_FRAME_LEN || (uint8_t)(3 + cmd_len + 1) != len) return; // 长度不匹配或者小于最小限制 const uint8_t *cmd = &frame[3]; // 提取命令部分 // 命令必须以 'M' 开头 if (cmd[0] != 'M'){ send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err)); return; } // 从 'M' 后开始解析 uint8_t cmd_index = 1; // 解析M后的十进制数，即命令本体 uint32_t base_cmd = 0; uint8_t used_base_cmd = parse_uint_dec(&cmd[cmd_index], (cmd_len - cmd_index), &base_cmd); if (used_base_cmd == 0) { // 'M' 后没有数字，格式错误 send_response(RESP_TYPE_LEN_ERR, s_report_status_err, sizeof(s_report_status_err)); return; } cmd_index = (uint8_t)(cmd_index + used_base_cmd); // 更新索引到命令后 // 情况A：无附加参数的基础命令 if (cmd_index == cmd_len) { // 仅基础命令，如 M1, M2, M3 switch (base_cmd) { case 1u: // M1: enable sensor report set_sensor_report_status(true); return; case 2u: // M2: disable sensor report set_sensor_report_status(false); return; // 示例：M3、M10、M201、M100 等（按需添加） // case 3u: // M3命令 - 高电流驱动测试 // /** // * M3命令：使用更高驱动电流测试线圈响应 // * 响应格式：6字节状态信息 // * // * 响应数据解析： // * [0-1]: 传感器状态寄存器（大端序） // * bit[15-8]: 预留 // * bit[7]: DRDY_1 - 通道1数据就绪 // * bit[6]: DRDY_0 - 通道0数据就绪 // * bit[5]: UNREAD_CONV - 未读转换结果 // * bit[4]: ERR_ZC - 零计数错误 // * bit[3]: ERR_AE - 幅度错误（重点关注） // * bit[2]: ERR_WD - 看门狗超时 // * bit[1]: ERR_OR - 过量程错误 // * bit[0]: ERR_UR - 欠量程错误 // * [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪) // * [3]: 0xA0 - 高电流测试标记 // * [4]: 幅度错误专用标志 (0xAE=有幅度错误, 0x00=无) // * [5]: 0x33 - M3命令标记 // * // * 分析要点： // * - 如果[0-1]从0x0008变为其他值，说明高电流有效果 // * - 如果[2]变为0x01，说明数据开始就绪 // * - 如果[4]变为0x00，说明幅度错误消失 // */ // // 重置传感器 // ldc1612_reset_sensor(); // delay_ms(50); // // 使用更高的驱动电流重新配置 // // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xA000); // delay_ms(10); // // 重新配置其他参数 // ldc1612_config_single_channel(CHANNEL_0); // delay_ms(200); // 更长稳定时间 // // 检查结果 // uint16_t status_m3 = ldc1612_get_sensor_status(); // bool ready_m3 = ldc1612_is_data_ready(CHANNEL_0); // uint8_t m3_info[6]; // m3_info[0] = (uint8_t)(status_m3 >> 8); // m3_info[1] = (uint8_t)(status_m3 & 0xFF); // m3_info[2] = ready_m3 ? 0x01 : 0x00; // m3_info[3] = 0xA0; // 高电流标记 // m3_info[4] = (status_m3 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志 // m3_info[5] = 0x33; // M3命令标记 // send_response(RESP_TYPE_OK, m3_info, sizeof(m3_info)); // return; // case 4u: // M4命令 - 寄存器诊断 // /** // * M4命令：读取关键寄存器进行配置诊断 // * 响应格式：8字节寄存器信息 // * // * 响应数据解析： // * [0-1]: 状态寄存器 (0x18) - 当前传感器状态 // * [2-3]: 传感器配置寄存器 (0x1A) - 传感器工作模式 // * 期望值: 0x1601 (活动模式，单通道) // * [4-5]: 驱动电流寄存器 (0x1E) - 当前驱动电流设置 // * 常见值: 0x9000(默认), 0xA000(高), 0xF800(最高) // * [6]: I2C读取状态 (0x4F='O'=成功, 0xEE=失败) // * [7]: 0x44 - M4命令标记 // * // * 分析要点： // * - [2-3]应该是0x1601，如果不是说明配置异常 // * - [4-5]显示实际的驱动电流设置 // * - [6]必须是0x4F，否则I2C通信有问题 // */ // // 简化版本，只读取最关键的寄存器，避免I2C超时 // uint16_t status_reg = ldc1612_get_sensor_status(); // 0x18 // // 逐一安全读取关键寄存器 // uint8_t data_buf[2] = {0}; // uint16_t sensor_config = 0; // uint16_t drive_current = 0; // // 尝试读取传感器配置寄存器 // bool result1_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data_buf) == I2C_RESULT_SUCCESS); // if (result1_ok) { // sensor_config = (data_buf[0] << 8) | data_buf[1]; // } // // 尝试读取驱动电流寄存器 // bool result2_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data_buf) == I2C_RESULT_SUCCESS); // if (result2_ok) { // drive_current = (data_buf[0] << 8) | data_buf[1]; // } // // 构造8字节简化诊断信息 // uint8_t diag_info[8]; // diag_info[0] = (uint8_t)(status_reg >> 8); // 状态寄存器高位 // diag_info[1] = (uint8_t)(status_reg & 0xFF); // 状态寄存器低位 // diag_info[2] = (uint8_t)(sensor_config >> 8); // 传感器配置寄存器高位 // diag_info[3] = (uint8_t)(sensor_config & 0xFF); // 传感器配置寄存器低位 // diag_info[4] = (uint8_t)(drive_current >> 8); // 驱动电流寄存器高位 // diag_info[5] = (uint8_t)(drive_current & 0xFF); // 驱动电流寄存器低位 // diag_info[6] = (result1_ok && result2_ok) ? 0x4F : 0xEE; // I2C状态 // diag_info[7] = 0x44; // M4命令标记 // send_response(RESP_TYPE_OK, diag_info, sizeof(diag_info)); // return; // case 5u: // M5命令 - 最高电流启动测试 // // 命令: D5 03 02 4D 35 87 // // 响应: B5 F0 08 [状态2字节][就绪标志][电流设置2字节][幅度错误标志][M5标记][最高电流标记] CRC // // 响应格式: // // [0-1]: 传感器状态寄存器（启动后状态） // // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪) // // [3-4]: 实际驱动电流设置值（应该是0xF800） // // [5]: 幅度错误专用标志 (0xAE=仍有错误, 0x00=错误消失) // // [6]: 0x55 - M5命令标记 // // [7]: 0xF8 - 最高电流标记 // // 重置传感器 // ldc1612_reset_sensor(); // delay_ms(100); // // 使用最高驱动电流并固定配置 // // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xF800); // delay_ms(10); // // 手动配置其他必要寄存器，避免被覆盖 // // 配置频率分频器为较低频率 (更容易起振) // uint8_t freq_data[2] = {0x10, 0x00}; // 较低分频 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_data); // delay_ms(10); // // 设置较长的LC稳定时间 // uint8_t lc_data[2] = {0x04, 0x00}; // 更长稳定时间 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_data); // delay_ms(10); // // 配置MUX为单通道模式 // // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz); // delay_ms(10); // // 启动传感器 // uint8_t sensor_cfg_data[2] = {0x16, 0x01}; // 活动模式，单通道 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_cfg_data); // delay_ms(200); // 更长稳定时间 // // 读取结果 // uint16_t status_m5 = ldc1612_get_sensor_status(); // bool ready_m5 = ldc1612_is_data_ready(CHANNEL_0); // // 再次确认驱动电流设置 // uint8_t curr_data[2]; // LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, curr_data); // uint16_t actual_current = (curr_data[0] << 8) | curr_data[1]; // uint8_t m5_info[8]; // m5_info[0] = (uint8_t)(status_m5 >> 8); // m5_info[1] = (uint8_t)(status_m5 & 0xFF); // m5_info[2] = ready_m5 ? 0x01 : 0x00; // m5_info[3] = (uint8_t)(actual_current >> 8); // 实际电流设置高位 // m5_info[4] = (uint8_t)(actual_current & 0xFF); // 实际电流设置低位 // m5_info[5] = (status_m5 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志 // m5_info[6] = 0x55; // M5命令标记 // m5_info[7] = 0xF8; // 最高电流标记 // send_response(RESP_TYPE_OK, m5_info, sizeof(m5_info)); // return; // case 6u: // M6命令 - 芯片功能验证 // // 命令: D5 03 02 4D 36 88 // // 响应: B5 F0 0C [写入值2字节][读取值2字节][制造商ID2字节][设备ID2字节][状态2字节][ID读取状态][M6标记] CRC // // 响应格式: // // [0-1]: 写入测试值 (0x9000) // // [2-3]: 读取回的值 // // [4-5]: 制造商ID (应该是0x5449="TI") // // [6-7]: 设备ID (应该是0x3055) // // [8-9]: 当前状态寄存器 // // [10]: ID读取状态 (0x4F=成功, 0xEE=失败) // // [11]: 0x66 - M6命令标记 // // 测试1: 写入和读取特定值到驱动电流寄存器 // uint8_t test_current_data[2] = {0x90, 0x00}; // 写入0x9000 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, test_current_data); // delay_ms(10); // // 读取验证 // uint8_t read_current_data[2]; // LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, read_current_data); // uint16_t read_current = (read_current_data[0] << 8) | read_current_data[1]; // // 测试2: 读取制造商ID和设备ID // uint8_t manufacturer_data[2]; // uint8_t device_data[2]; // bool id_read_ok = true; // if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7E, manufacturer_data) != I2C_RESULT_SUCCESS) { // id_read_ok = false; // } // if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7F, device_data) != I2C_RESULT_SUCCESS) { // id_read_ok = false; // } // uint16_t manufacturer_id = id_read_ok ? ((manufacturer_data[0] << 8) | manufacturer_data[1]) : 0x0000; // uint16_t device_id = id_read_ok ? ((device_data[0] << 8) | device_data[1]) : 0x0000; // // 测试3: 检查当前状态 // uint16_t current_status = ldc1612_get_sensor_status(); // // 构造12字节测试结果 // uint8_t test_info[12]; // test_info[0] = 0x90; // 写入的值高位 // test_info[1] = 0x00; // 写入的值低位 // test_info[2] = (uint8_t)(read_current >> 8); // 读取的值高位 // test_info[3] = (uint8_t)(read_current & 0xFF); // 读取的值低位 // test_info[4] = (uint8_t)(manufacturer_id >> 8); // test_info[5] = (uint8_t)(manufacturer_id & 0xFF); // test_info[6] = (uint8_t)(device_id >> 8); // test_info[7] = (uint8_t)(device_id & 0xFF); // test_info[8] = (uint8_t)(current_status >> 8); // test_info[9] = (uint8_t)(current_status & 0xFF); // test_info[10] = id_read_ok ? 0x4F : 0xEE; // ID读取状态 // test_info[11] = 0x66; // M6命令标记 // send_response(RESP_TYPE_OK, test_info, sizeof(test_info)); // return; // case 7u: // M7命令 - 保守参数测试 // // 命令: D5 03 02 4D 37 89 // // 响应: B5 F0 0A [状态2字节][就绪标志][频率设置2字节][幅度错误标志][欠量程错误标志][过量程错误标志][M7标记][低频标记] CRC // // 响应格式: // // [0-1]: 状态寄存器 // // [2]: 数据就绪标志 // // [3-4]: 实际频率分频器设置 (0x2000=较低频率) // // [5]: 幅度错误标志 (0xAE=有错误, 0x00=无) // // [6]: 欠量程错误标志 (0x01=有, 0x00=无) // // [7]: 过量程错误标志 (0x02=有, 0x00=无) // // [8]: 0x77 - M7命令标记 // // [9]: 0x20 - 低频标记 // // 重置传感器 // ldc1612_reset_sensor(); // delay_ms(100); // // 使用保守的配置尝试启动线圈 // // 1. 设置最高驱动电流 // uint8_t drive_data[2] = {0xF8, 0x00}; // 最高电流 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, drive_data); // delay_ms(10); // // 2. 设置较低的频率分频器(适合更大电感值) // uint8_t freq_low_data[2] = {0x20, 0x00}; // 更低频率 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_low_data); // delay_ms(10); // // 3. 设置更长的LC稳定时间 // uint8_t lc_stable_data[2] = {0x08, 0x00}; // 更长稳定时间 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_stable_data); // delay_ms(10); // // 4. 设置更长的转换时间 // uint8_t conv_time_data[2] = {0x04, 0x00}; // 更长转换时间 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_TIME_REG_START + CHANNEL_0, conv_time_data); // delay_ms(10); // // 5. 设置转换偏移 // uint8_t conv_offset_data[2] = {0x00, 0x00}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_OFFSET_REG_START + CHANNEL_0, conv_offset_data); // delay_ms(10); // // 6. 配置错误寄存器 - 降低错误敏感度 // uint8_t error_config_data[2] = {0x00, 0x00}; // 允许所有错误 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, error_config_data); // delay_ms(10); // // 7. 配置MUX寄存器 // // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz); // delay_ms(10); // // 8. 启动传感器 // uint8_t sensor_start_data[2] = {0x16, 0x01}; // 活动模式 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_start_data); // delay_ms(500); // 给予充分时间稳定 // // 检查结果 // uint16_t status_m7 = ldc1612_get_sensor_status(); // bool ready_m7 = ldc1612_is_data_ready(CHANNEL_0); // // 读取实际配置的频率分频器确认 // uint8_t freq_readback[2]; // LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_readback); // uint16_t freq_actual = (freq_readback[0] << 8) | freq_readback[1]; // uint8_t m7_info[10]; // m7_info[0] = (uint8_t)(status_m7 >> 8); // m7_info[1] = (uint8_t)(status_m7 & 0xFF); // m7_info[2] = ready_m7 ? 0x01 : 0x00; // m7_info[3] = (uint8_t)(freq_actual >> 8); // 实际频率分频器 // m7_info[4] = (uint8_t)(freq_actual & 0xFF); // m7_info[5] = (status_m7 & 0x0008) ? 0xAE : 0x00; // 幅度错误 // m7_info[6] = (status_m7 & 0x0001) ? 0x01 : 0x00; // 欠量程错误 // m7_info[7] = (status_m7 & 0x0002) ? 0x02 : 0x00; // 过量程错误 // m7_info[8] = 0x77; // M7命令标记 // m7_info[9] = 0x20; // 低频标记 // send_response(RESP_TYPE_OK, m7_info, sizeof(m7_info)); // return; // case 8u: // M8命令 - 极端参数测试 // // 命令: D5 03 02 4D 38 8A // // 响应: B5 F0 06 [状态2字节][就绪标志][幅度错误标志][M8标记][极端测试标记] CRC // // 响应格式: // // [0-1]: 传感器状态寄存器 // // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪) // // [3]: 幅度错误标志 (0xAE=仍有错误, 0x00=错误消失) // // [4]: 0x88 - M8命令标记 // // [5]: 0xEE - 极端测试标记 // { // // 重置传感器 // ldc1612_reset_sensor(); // delay_ms(100); // // 极端配置1: 极低频率 // uint8_t extreme_freq[2] = {0x40, 0x00}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, extreme_freq); // delay_ms(10); // // 极端配置2: 最大驱动电流 // uint8_t max_drive[2] = {0xFF, 0x00}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, max_drive); // delay_ms(10); // // 极端配置3: 禁用错误检测 // uint8_t no_errors[2] = {0x00, 0x00}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, no_errors); // delay_ms(10); // // 启动传感器 // uint8_t start_data[2] = {0x16, 0x01}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_data); // delay_ms(1000); // 等待1秒 // // 读取状态 // uint16_t status_8 = ldc1612_get_sensor_status(); // bool ready_8 = ldc1612_is_data_ready(CHANNEL_0); // uint8_t m8_result[6]; // m8_result[0] = (uint8_t)(status_8 >> 8); // m8_result[1] = (uint8_t)(status_8 & 0xFF); // m8_result[2] = ready_8 ? 0x01 : 0x00; // m8_result[3] = (status_8 & 0x0008) ? 0xAE : 0x00; // 幅度错误 // m8_result[4] = 0x88; // M8标记 // m8_result[5] = 0xEE; // 极端测试标记 // send_response(RESP_TYPE_OK, m8_result, sizeof(m8_result)); // return; // } // case 9u: // M9命令 - 多频率特性测试 // // 命令: D5 03 02 4D 39 8B // // 响应: B5 F0 08 [高频状态2字节][高频就绪标志][低频状态2字节][低频就绪标志][M9标记][多频测试标记] CRC // // 响应格式: // // [0-1]: 高频测试状态 // // [2]: 高频就绪标志 (0x01=就绪, 0x00=未就绪) // // [3-4]: 低频测试状态 // // [5]: 低频就绪标志 (0x01=就绪, 0x00=未就绪) // // [6]: 0x99 - M9命令标记 // // [7]: 0xAA - 多频测试标记 // { // // 测试1: 高频配置 // ldc1612_reset_sensor(); // delay_ms(50); // uint8_t high_freq[2] = {0x04, 0x00}; // 高频 // uint8_t low_drive[2] = {0x80, 0x00}; // 低电流 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, high_freq); // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, low_drive); // delay_ms(10); // // 启动高频测试 // uint8_t start_hf[2] = {0x16, 0x01}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf); // delay_ms(200); // uint16_t hf_status = ldc1612_get_sensor_status(); // bool hf_ready = ldc1612_is_data_ready(CHANNEL_0); // // 测试2: 低频配置 // uint8_t sleep_mode[2] = {0x20, 0x01}; // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sleep_mode); // delay_ms(50); // uint8_t low_freq[2] = {0x20, 0x00}; // 低频 // uint8_t high_drive[2] = {0xC0, 0x00}; // 高电流 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, low_freq); // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, high_drive); // delay_ms(10); // // 启动低频测试 // LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf); // delay_ms(200); // uint16_t lf_status = ldc1612_get_sensor_status(); // bool lf_ready = ldc1612_is_data_ready(CHANNEL_0); // uint8_t m9_result[8]; // m9_result[0] = (uint8_t)(hf_status >> 8); // 高频状态 // m9_result[1] = (uint8_t)(hf_status & 0xFF); // m9_result[2] = hf_ready ? 0x01 : 0x00; // 高频就绪 // m9_result[3] = (uint8_t)(lf_status >> 8); // 低频状态 // m9_result[4] = (uint8_t)(lf_status & 0xFF); // m9_result[5] = lf_ready ? 0x01 : 0x00; // 低频就绪 // m9_result[6] = 0x99; // M9标记 // m9_result[7] = 0xAA; // 多频测试标记 // send_response(RESP_TYPE_OK, m9_result, sizeof(m9_result)); // return; // } // case 201u: // M201命令 // send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok)); // return; default: // 其它无参数命令在此扩展（示例：M100）处理逻辑该如何待定 // send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok)); // return; break; } // 未在处理列表的无参数基础命令，回复错误 send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err)); return; } // 情况B：有附加参数的命令 if (cmd[cmd_index] == 'S') { cmd_index++; uint32_t param_value = 0; const uint8_t used_param_cmd = parse_uint_dec(&cmd[cmd_index], (uint8_t)(cmd_len - cmd_index), ¶m_value); if (used_param_cmd == 0) { // 'S' 后没有数字，格式错误 send_response(RESP_TYPE_LEN_ERR, s_report_status_err, sizeof(s_report_status_err)); return; } switch (base_cmd) { // case 100u: // // set_pwm(param_value); // printf("Set PWM to %u\n", param_value); // return; default: break; } send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err)); } } /** * @brief 处理串口环形缓冲区中的命令数据，解析完整的协议帧。 * @details 本函数实现一个基于状态机的协议解析器，用于处理格式为 D5 03 LEN [cmd] CRC 的命令帧： * - 状态1：等待包头字节 PROTOCOL_PACKAGE_HEADER (0xD5) * - 状态2：接收板卡类型字节 PROTOCOL_BOARD_TYPE (0x03) * - 状态3：接收长度字段并计算期望的完整帧长度 * - 状态4：继续接收剩余数据直到完整帧 * - 状态5：对完整帧进行校验（包头、板卡类型、CRC）并处理 * * 函数采用非阻塞方式处理，每次调用处理缓冲区中所有可用数据。 * 遇到格式错误、长度异常或校验失败时自动重置状态机。 * * @note 本函数使用静态变量维护解析状态，因此不可重入。在中断环境中使用需注意并发安全。 * 协议帧最大长度受 PROTOCOL_MAX_FRAME_LEN 限制，超出范围的帧将被丢弃。 * * @warning 函数依赖 uart_ring_buffer_available() 和 uart_ring_buffer_get() * 正确实现，若这些函数有缺陷可能导致死循环或数据丢失。 * * @see handle_command() 用于处理校验通过的完整命令帧 * @see command_sum_crc_calc() 用于计算和校验 CRC 值 * @see send_response() 用于发送错误响应 * * @ingroup Command */ void command_process(void) { static uint8_t cmd_buf[PROTOCOL_MAX_FRAME_LEN]; static uint8_t cmd_len = 0; static uint8_t expected_cmd_len = 0; // 0 表示尚未确定总长度 while (uart_ring_buffer_available() > 0) { int byte = uart_ring_buffer_get(); if (byte < 0) break; if (cmd_len == 0) { if ((uint8_t)byte == PROTOCOL_PACKAGE_HEADER) { cmd_buf[cmd_len++] = (uint8_t)byte; expected_cmd_len = 0; // 等待进一步字段以确定长度 } else { // 丢弃非起始字节 } continue; } if (cmd_len >= PROTOCOL_MAX_FRAME_LEN) { // 防御：缓冲溢出，复位状态机 cmd_len = 0; expected_cmd_len = 0; } // 缓存后续字节 cmd_buf[cmd_len++] = (uint8_t)byte; // 当到达长度字段（索引 2）后，确定总长度：3 + LEN + 1 if (cmd_len == 3) { uint8_t payload_len = cmd_buf[2]; expected_cmd_len = (uint8_t)(3 + payload_len + 1); if (expected_cmd_len > PROTOCOL_MAX_FRAME_LEN) { // 异常：长度超界，复位状态机 cmd_len = 0; expected_cmd_len = 0; } continue; } if (expected_cmd_len > 0 && cmd_len == expected_cmd_len) { // 到帧尾，进行各项校验 bool verification_status = true; #ifdef DEBUG_VERBOSE if (cmd_buf[0] != PROTOCOL_PACKAGE_HEADER) { send_response(RESP_TYPE_HEADER_ERR, s_report_status_err, sizeof(s_report_status_err)); verification_status = false; } #endif if (verification_status && cmd_buf[1] != PROTOCOL_BOARD_TYPE) { send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err)); verification_status = false; } if (verification_status) { uint8_t crc_calc = command_sum_crc_calc(cmd_buf, expected_cmd_len); uint8_t crc_recv = cmd_buf[expected_cmd_len - 1]; if (crc_calc != crc_recv) { send_response(RESP_TYPE_CRC_ERR, s_report_status_err, sizeof(s_report_status_err)); verification_status = false; } } if (verification_status) { handle_command(cmd_buf, expected_cmd_len); } // 复位，等待下一帧 cmd_len = 0; expected_cmd_len = 0; } } } void eddy_current_report(void) { // if (!g_sensor_report_enabled) return; uint32_t raw_result = ldc1612_get_raw_channel_result(CHANNEL_0); uint8_t sensor_data[4]; sensor_data[0] = (uint8_t)(raw_result >> 24); sensor_data[1] = (uint8_t)(raw_result >> 16); sensor_data[2] = (uint8_t)(raw_result >> 8); sensor_data[3] = (uint8_t)(raw_result & 0xFF); send_response(RESP_TYPE_OK, sensor_data, sizeof(sensor_data)); }