hulk/ldc1612_cmake_vscode
1
0
Fork 0
generated from hulk/gd32e23x_template_cmake_vscode
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

release dev branch

Browse Source
This commit is contained in:
yelvlab
2025-08-17 02:58:32 +08:00
parent f82ab23898
commit 5cdd7ca58c
34 changed files with 5220 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

846
Src/command.c Normal file
View File

@@ -0,0 +1,846 @@
/**
* @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 <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#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<value>: 设置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), &param_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));
}