/**
 * @file command.c
 * @brief 串口命令解析与处理模块实现（FilmForge：数据口走 RS485）。
 * @details 实现基于状态机的协议解析器，支持 D5 BOARD_TYPE LEN [cmd] CRC 格式的
 *          命令处理，包含命令帧解析、响应生成功能。
 *          自 GD32E23x 工程移植：数据源改为 RS485 接收环形缓冲区，
 *          响应经 rs485_send() 发出（DE 收发自动切换）。
 * @author Hulk
 * @date 2026-10-09
 * @version 1.1.0（FilmForge 移植版）
 * @ingroup Command
 */

#include "command.h"
#include "rs485.h"
#include "uart.h"
#include "systick.h"
#include "ntc.h"
#include "heat.h"
#include "board_config.h"
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

/* ============================================================================
 * 协议常量定义
 * ============================================================================ */

/** @name 协议帧标识符
 * @{ */
#define PROTOCOL_PACKAGE_HEADER   0xD5  /**< 命令帧包头标识 */
/** @} */

/** @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    32    /**< 最大完整帧长度 */
/** @} */

/** @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  /**< 长度错误 >**/
#define RESP_TYPE_PARAM_ERR       0xFD  /**< 参数错误 >**/
#define RESP_TYPE_CMD_ERR         0xFE  /**< 命令错误 >**/
#define RESP_TYPE_ERR             0xFF  /**< 通用错误 >**/
/** @} */

/* ============================================================================
 * 模块内部变量
 * ============================================================================ */

/** @name 预设响应数据
 * @{ */
static const uint8_t s_report_status_ok[] = { 'o', 'k' };   /**< 成功响应数据 */
static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应数据 */
/** @} */

/** @name M2 连续温度上报状态
 * @{ */
static bool s_temp_report_enabled = false;     /**< 连续上报使能（M2S<ms> 设置） */
static uint16_t s_temp_report_period_ms = 500; /**< 上报间隔（ms），100~60000 */
static uint16_t s_temp_report_counter = 0;     /**< 主循环 10ms 圈计数 */
/** @} */

/** @name M3/M4 加热控制（heat 模块：PB12 慢 PWM + PID 闭环）
 * @{ */
/** @} */

void system_software_reset(void)
{
    // 确保所有待处理的内存访问完成
    __DSB();

    // 执行系统复位
    NVIC_SystemReset();

    // 以下代码不会执行
    while(1);
}

/* Debug output control */
#if COM_DEBUG == CFG_ENABLE
    #define COMMAND_DEBUG(fmt, ...) printf("[COMMAND] " fmt "\r\n", ##__VA_ARGS__)
#else
    #define COMMAND_DEBUG(fmt, ...)
#endif

/* ============================================================================
 * 公共接口函数
 * ============================================================================ */

/**
 * @brief 计算协议包的 8 位累加校验值（Checksum）。
 * @details 对输入缓冲区逐字节累加并取低 8 位，累加范围为 data[1] 至 data[len-2]，
 *          即不包含包头 HEADER（索引 0）与尾部 CRC 字节（索引 len-1）。
 *          当 len 小于最小协议帧长度（PROTOCOL_MIN_FRAME_LEN）时返回 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 发送协议响应帧（经 RS485 数据口，DE 收发自动切换）。
 * @details 构造并发送格式为 B5 TYPE LEN [payload] CRC 的响应帧，
 *          自动计算CRC校验值并通过 RS485 发出。
 * @param type 响应类型码（如 RESP_TYPE_OK, RESP_TYPE_CRC_ERR 等）。
 * @param payload 指向响应数据的缓冲区，当len为0时可为NULL。
 * @param len 响应数据长度（字节），为0时不复制payload数据。
 * @note 内部使用固定大小缓冲区，超长响应将被丢弃。
 * @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);

    // 经 RS485 发出（rs485_send 内部处理 DE 切换与发送完成等待）
    rs485_send(buf, buf_len);
}

/**
 * @brief 发送协议响应帧（调试用，发送到 DEBUG_UART）。
 * @details 构造并发送格式为 B5 TYPE LEN [payload] CRC 的响应帧，
 *          自动计算CRC校验值并通过 DEBUG_UART 输出（Hex 视图观察协议交互用）。
 * @param type 响应类型码（如 RESP_TYPE_OK, RESP_TYPE_CRC_ERR 等）。
 * @param payload 指向响应数据的缓冲区，当len为0时可为NULL。
 * @param len 响应数据长度（字节）。
 * @note 内部使用固定大小缓冲区，超长响应将被丢弃。
 * @ingroup Command
 */
static void send_response_debug(uint8_t type, const uint8_t *payload, uint8_t len) __attribute__((unused));
static void send_response_debug(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;

    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);

    // 经 debug 串口逐字节输出
    for (uint8_t i = 0; i < buf_len; i++) {
        debug_uart_write(buf[i]);
    }
    // 等待发送完成
    while (RESET == usart_flag_get(DEBUG_UART, USART_FLAG_TC)) {}
}

/**
 * @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 将一个无符号整数转换为字符串并追加到缓冲区。
 * @param value 要转换的数字。
 * @param buffer 指向目标缓冲区的指针，转换后的字符串将写入此处。
 * @return uint8_t 写入的字符数。
 * @ingroup Command
 */
static uint8_t uint_to_str(uint32_t value, char *buffer) {
    char temp[10]; // 32位无符号整数最多10位
    int i = 0;

    if (value == 0) {
        buffer[0] = '0';
        return 1;
    }

    // 将数字逆序转换为字符存入临时数组
    while (value > 0) {
        temp[i++] = (char)((value % 10) + '0');
        value /= 10;
    }

    // 将逆序的字符串反转并存入目标缓冲区
    uint8_t len = (uint8_t)i;
    for (int j = 0; j < len; j++) {
        buffer[j] = temp[--i];
    }

    return len;
}

/**
 * @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 通用T参数解析函数
 * @details 解析命令中的T参数（定时参数），格式为T<数字>
 * @param cmd 指向命令缓冲区
 * @param cmd_index 当前解析位置的指针（会被更新）
 * @param cmd_len 命令总长度
 * @param timer_value 输出参数，存储解析到的定时值
 * @return bool 解析结果
 * @retval true 成功解析到T参数
 * @retval false 没有T参数或解析失败
 * @note 如果解析成功，cmd_index会被更新到T参数后的位置
 * @ingroup Command
 */
static bool __attribute__((unused)) parse_timer_parameter(const uint8_t *cmd, uint8_t *cmd_index, uint8_t cmd_len, uint32_t *timer_value)
{
    if (*cmd_index >= cmd_len || cmd[*cmd_index] != 'T') {
        return false; // 没有T参数
    }

    uint8_t temp_index = *cmd_index + 1; // T后的位置
    const uint8_t used_timer_cmd = parse_uint_dec(&cmd[temp_index], (uint8_t)(cmd_len - temp_index), timer_value);

    if (used_timer_cmd == 0) {
        return false; // T后面没有有效数字
    }

    *cmd_index = (uint8_t)(temp_index + used_timer_cmd); // 更新索引
    return true;
}

/**
 * @brief 检查命令是否完全解析完毕
 * @details 验证命令中是否还有未解析的字符，用于格式验证
 * @param cmd_index 当前解析位置
 * @param cmd_len 命令总长度
 * @return bool 检查结果
 * @retval true 命令完全解析完毕
 * @retval false 还有未解析的字符
 * @ingroup Command
 */
static bool __attribute__((unused)) is_command_fully_parsed(uint8_t cmd_index, uint8_t cmd_len)
{
    return (cmd_index == cmd_len);
}

/**
 * @brief 在命令字符串中查找指定参数的值
 * @param cmd 指向命令起始位置（Mxxx 之后）
 * @param cmd_len 命令剩余长度
 * @param key 要查找的参数字符（如 'P', 'S'）
 * @param value 输出参数，存储解析到的值
 * @return bool 是否找到该参数
 * @ingroup Command
 */
static bool __attribute__((unused)) find_parameter_value(const uint8_t *cmd, uint8_t cmd_len, char key, uint32_t *value)
{
    for (uint8_t i = 0; i < cmd_len; i++) {
        if (cmd[i] == (uint8_t)key) {
            uint8_t param_idx = i + 1;
            if (param_idx >= cmd_len) return false;
            if (parse_uint_dec(&cmd[param_idx], cmd_len - param_idx, value) > 0) {
                return true;
            }
            return false;
        }
    }
    return false;
}

/* ============================================================================
 * 命令处理函数
 * ============================================================================ */

/**
 * @brief 解析并处理完整的命令帧。
 * @details 处理经过协议校验的完整命令帧，支持以下命令格式：
 *          - 无参数命令：M<数字>（如 M999、M888）
 *          - 带参数命令：M<数字>S<参数>（如 M100S123，参数为十进制）
 *
 *          支持的命令（FilmForge）：
 *          - M1:     单次查询温度值（payload 为 ASCII 摄氏度，如 "23.8"；OPEN/SHRT=故障）
 *          - M2:     查询连续上报状态（payload: "ON <ms>" 或 "OFF"）
 *          - M2S<ms>: 设置连续上报间隔（100~60000）并开启；M2S0 停止
 *          - M3:     查询加热使能（payload: "ON" / "OFF"）
 *          - M3S1/M3S0: 开启/关闭加热（PB12 慢 PWM，PID 按目标温度闭环）
 *          - M4:     查询目标温度（payload: ASCII 摄氏度）
 *          - M4S<temp>: 设定目标温度（整数摄氏度，0~200）
 *          - M888:   软件复位
 *          - M999:   输出固件版本号（v<板卡码>.<主>.<次>.<修订>）
 *          - M9999:  进入 OTA 模式（复位进 Bootloader）
 *          权威帧示例见工程根 protocols.md（脚本生成，勿手算 CRC）。
 *
 *          具体业务命令（加热/测温/控温等）待定，在 switch 中按需扩展。
 *
 * @param frame 指向完整命令帧的缓冲区（从包头0xD5开始）。
 * @param len 命令帧总长度（字节）。
 * @note 函数内部进行帧格式校验，格式错误时自动发送错误响应。
 * @warning 假设输入帧已通过基本协议校验（包头、类型、CRC等）。
 * @ingroup Command
 */

void handle_command(const uint8_t *frame, uint8_t len) {
    // 帧格式：D5 BOARD_TYPE LEN [cmd] CRC; cmd 支持变长，如 "M999"、"M100S123"
    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); // 更新索引到命令后

    switch (base_cmd) {
        /* ==========================================
         * M1 单次查询温度值
         * ========================================== */
        case 1u: // M1: 查询最新 NTC 温度（后台 100ms 采样值），payload 为 ASCII 摄氏度（如 "23.8"）
        {
            float temp = ntc_get_temperature();
            char temp_str[8];
            uint8_t n;

            if (temp <= -274.0f) {
                n = (uint8_t)sprintf(temp_str, "SHRT"); // PC5 被拉到 GND（短路）
            } else if (temp <= -273.0f) {
                n = (uint8_t)sprintf(temp_str, "OPEN"); // PC5 被拉到 VREF（NTC 未连通）
            } else {
                n = (uint8_t)sprintf(temp_str, "%.1f", temp);
            }
            send_response(RESP_TYPE_OK, (const uint8_t *)temp_str, n);
            COMMAND_DEBUG("M1 temp query: %s", temp_str);
        }
        return;

        /* ==========================================
         * M2 连续温度上报控制（画曲线用，全部幂等可重发）
         * M2       : 查询上报状态（payload: "ON <ms>" 或 "OFF"）
         * M2S<ms>  : 100~60000 设置上报间隔（10ms 步进）并开启
         * M2S0     : 停止上报
         * 上报帧格式与 M1 响应相同：B5 F0 LEN [ASCII 摄氏度] CRC
         * 注意：勿用"翻转"语义——链路 ack 丢失重发时翻转类命令会状态错乱，
         *       本命令族全部为幂等的显式设置。
         * ========================================== */
        case 2u:
        {
            uint32_t period = 0;

            if (find_parameter_value(&cmd[cmd_index], (uint8_t)(cmd_len - cmd_index), 'S', &period)) {
                if (period == 0U) {
                    /* M2S0: 停止上报 */
                    s_temp_report_enabled = false;
                    s_temp_report_counter = 0;
                    send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                } else if (period >= 100U && period <= 60000U) {
                    /* M2S<ms>: 设置间隔并开启 */
                    s_temp_report_period_ms = (uint16_t)period;
                    s_temp_report_enabled = true;
                    s_temp_report_counter = 0;
                    send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                } else {
                    send_response(RESP_TYPE_PARAM_ERR, s_report_status_err, sizeof(s_report_status_err));
                }
            } else {
                /* M2: 查询上报状态 */
                char state_str[12];
                uint8_t n;
                if (s_temp_report_enabled) {
                    n = (uint8_t)sprintf(state_str, "ON %u", s_temp_report_period_ms);
                } else {
                    n = (uint8_t)sprintf(state_str, "OFF");
                }
                send_response(RESP_TYPE_OK, (const uint8_t *)state_str, n);
            }
            COMMAND_DEBUG("M2 report %s, period=%ums",
                          s_temp_report_enabled ? "ON" : "OFF", s_temp_report_period_ms);
        }
        return;

        /* ==========================================
         * M3 加热开关（PB12 慢 PWM 驱动 + PID 闭环）
         * M3       : 查询加热使能（payload: "ON" / "OFF"）
         * M3S1     : 开启加热（使能后由 PID 按目标温度闭环输出）
         * M3S0     : 关闭加热（立即断输出并复位 PID）
         * 安全：上电默认关闭；NTC 故障/过温时强制关断。
         * ========================================== */
        case 3u:
        {
            uint32_t onoff = 0;

            if (find_parameter_value(&cmd[cmd_index], (uint8_t)(cmd_len - cmd_index), 'S', &onoff)) {
                if (onoff == 0U || onoff == 1U) {
                    heat_set_enable(onoff == 1U);
                    send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                } else {
                    send_response(RESP_TYPE_PARAM_ERR, s_report_status_err, sizeof(s_report_status_err));
                }
            } else {
                send_response(RESP_TYPE_OK,
                              heat_get_enable() ? (const uint8_t *)"ON" : (const uint8_t *)"OFF",
                              heat_get_enable() ? 2U : 3U);
            }
            COMMAND_DEBUG("M3 heater %s", heat_get_enable() ? "ON" : "OFF");
        }
        return;

        /* ==========================================
         * M4 温度设定（PID 目标值）
         * M4        : 查询目标温度（payload: ASCII 摄氏度，如 "120.0"）
         * M4S<temp> : 设定目标温度（整数摄氏度，HEATER_TEMP_MIN~MAX）
         * ========================================== */
        case 4u:
        {
            uint32_t target = 0;

            if (find_parameter_value(&cmd[cmd_index], (uint8_t)(cmd_len - cmd_index), 'S', &target)) {
                if (target >= HEATER_TEMP_MIN && target <= HEATER_TEMP_MAX) {
                    heat_set_target((float)target);
                    send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                } else {
                    send_response(RESP_TYPE_PARAM_ERR, s_report_status_err, sizeof(s_report_status_err));
                }
            } else {
                char target_str[8];
                uint8_t n = (uint8_t)sprintf(target_str, "%.1f", heat_get_target());
                send_response(RESP_TYPE_OK, (const uint8_t *)target_str, n);
            }
            COMMAND_DEBUG("M4 target: %.1f", heat_get_target());
        }
        return;

        /* ==========================================
         * M888 软件重启命令
         * ========================================== */
        case 888u:
            // 先发送确认响应
            send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));

            // 短暂延时确保响应发送完成
            delay_ms(100);

            // 执行软件重启
            system_software_reset();
            return;

        /* ==========================================
         * M999 输出固件版本号命令
         * ========================================== */
        case 999u: //M999: 输出固件版本号
            {
                char version_str[16];
                char *p = version_str;

                *p++ = 'v';
                p += uint_to_str(BOARD_TYPE_CODE, p);
                *p++ = '.';
                p += uint_to_str(FW_VERSION_MAJOR, p);
                *p++ = '.';
                p += uint_to_str(FW_VERSION_MINOR, p);
                *p++ = '.';
                p += uint_to_str(FW_VERSION_PATCH, p);
                *p = '\0'; // null-terminate for printf safety

                uint8_t n = (uint8_t)(p - version_str);
                send_response(RESP_TYPE_OK, (const uint8_t *)version_str, n);
                COMMAND_DEBUG("Firmware Version: %s", version_str);
            }
            return;

        /* ==========================================
         * M9999 进入OTA模式
         * ========================================== */
        case 9999u: //M9999: 进入OTA模式
            __disable_irq(); // 关中断，防止竞态条件
            NVIC_SystemReset(); // 触发系统复位，进入Bootloader
            return;

        /* ==========================================
         * 具体业务命令（加热驱动/控温等）
         * TODO: 待定义后在下方按 base_cmd 扩展，格式参考：
         *   case 100u: // M100S<value>
         *       if (!is_command_fully_parsed(cmd_index, cmd_len)) { ... 参数解析 }
         *       find_parameter_value(...);  // 按键取参
         *       send_response(RESP_TYPE_OK, s_report_status_ok, ...);
         *       return;
         * ========================================== */
        default:
            send_response(RESP_TYPE_CMD_ERR, s_report_status_err, sizeof(s_report_status_err));
            break;
    }
}

/**
 * @brief 处理 RS485 接收环形缓冲区中的命令数据，解析完整的协议帧。
 * @details 本函数实现一个基于状态机的协议解析器，用于处理格式为
 *          D5 BOARD_TYPE LEN [cmd] CRC 的命令帧（数据源：RS485 数据口）：
 *          - 状态1：等待包头字节 PROTOCOL_PACKAGE_HEADER (0xD5)
 *          - 状态2：接收板卡类型字节 PROTOCOL_BOARD_TYPE
 *          - 状态3：接收长度字段并计算期望的完整帧长度
 *          - 状态4：继续接收剩余数据直到完整帧
 *          - 状态5：对完整帧进行校验（包头、板卡类型、CRC）并处理
 *
 *          函数采用非阻塞方式处理，每次调用处理缓冲区中所有可用数据。
 *          遇到格式错误、长度异常或校验失败时自动重置状态机。
 *
 * @note 本函数使用静态变量维护解析状态，因此不可重入。在中断环境中使用需注意并发安全。
 *       协议帧最大长度受 PROTOCOL_MAX_FRAME_LEN 限制，超出范围的帧将被丢弃。
 *
 * @warning 函数依赖 rs485_rx_available() 和 rs485_rx_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 (rs485_rx_available() > 0) {
        int byte = rs485_rx_get();
        if (byte < 0) break;

#if COM_DEBUG == CFG_ENABLE
        /* 调试：打印 RS485 收到的每个原始字节 */
        printf("[RX] %02X\r\n", (uint8_t)byte);
#endif

        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;
            continue;
        }

        // 缓存后续字节
        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;

            #if DEBUG_VERBOSE == CFG_ENABLE
            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);
            } else {
                // 验证失败时清空缓冲区，避免后续帧受影响
                rs485_rx_clear();
            }

            // 复位，等待下一帧
            cmd_len = 0;
            expected_cmd_len = 0;
        }
    }
}

/**
 * @brief M2 连续温度上报任务（在主循环中周期调用，主循环周期 10ms）。
 * @details 使能时按 s_temp_report_period_ms 间隔向 RS485 发送温度帧，
 *          帧格式与 M1 响应相同（B5 F0 LEN [ASCII 摄氏度] CRC）。
 */
void command_report_task(void) {
    if (!s_temp_report_enabled) return;

    s_temp_report_counter++;
    if (s_temp_report_counter >= (uint16_t)(s_temp_report_period_ms / 10U)) {
        s_temp_report_counter = 0;

        float temp = ntc_get_temperature();
        char temp_str[8];
        uint8_t n;

        if (temp <= -274.0f) {
            n = (uint8_t)sprintf(temp_str, "SHRT");
        } else if (temp <= -273.0f) {
            n = (uint8_t)sprintf(temp_str, "OPEN");
        } else {
            n = (uint8_t)sprintf(temp_str, "%.1f", temp);
        }
        send_response(RESP_TYPE_OK, (const uint8_t *)temp_str, n);
    }
}

/**
 * @brief 执行命令（简化版）
 * @details 根据命令字符串直接构造协议帧并执行，无需手动构造协议帧
 * @param cmd_str 命令字符串（如"M999"、"M888"）
 * @note 简化的测试函数，自动处理协议帧构造、CRC计算和命令执行。
 *       与 E23x 版不同：构造后直接调用 handle_command()（不经接收缓冲）。
 * @ingroup Command
 */
void command_execute(const char *cmd_str)
{
    if (cmd_str == NULL) return;

    uint8_t cmd_len = (uint8_t)strlen(cmd_str);
    uint8_t frame_len = 3 + cmd_len + 1; // header + type + len + cmd + crc
    uint8_t frame_buf[32]; // 简单固定缓冲区

    if (frame_len > sizeof(frame_buf)) return;

    // 构造命令帧
    frame_buf[0] = PROTOCOL_PACKAGE_HEADER;    // 0xD5
    frame_buf[1] = PROTOCOL_BOARD_TYPE;        // Board Type
    frame_buf[2] = cmd_len;                    // 命令长度

    // 复制命令数据
    for (uint8_t i = 0; i < cmd_len; i++) {
        frame_buf[3 + i] = (uint8_t)cmd_str[i];
    }

    // 计算CRC
    uint16_t crc = 0;
    for (uint8_t i = 1; i < (frame_len - 1); i++) {
        crc += frame_buf[i];
    }
    frame_buf[frame_len - 1] = (uint8_t)(crc & 0xFF);

    // 直接交命令处理（本地执行，不经 RS485 接收缓冲）
    handle_command(frame_buf, frame_len);
}