wangyan/CCU621M
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: CCU621_M firmware project with BLE debug link support.

Browse Source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jiankalka
2026-07-08 17:28:36 +08:00
commit 9ceb218f80
1597 changed files with 724159 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/sub_comm/sub_comm_task.c
+777
View File
@@ -0,0 +1,777 @@
#include "sub_comm/sub_comm_task.h"
#include "app_init/app_init.h"
#include "app_init/task_lock.h"
#include "mylog/mylog.h"
#include "wdt_task/wdt_task.h"
#include "publicdata/publicdata.h"
#include "collect_ctrl/collect_task.h"
#include "collect_ctrl/led_ctrl.h"
#include "flowctrl/flow_interface.h"
#include "fault_cheak/fault_interface.h"
#include "app_rtc/app_rtc.h"
#include <string.h>
#include <stdio.h>
#include "usart.h"
#define SUBCOMM_TASK_ID (TASK_ID_SubComm)
#define SUBCOMM_SLEEP_TIME_MS() (MY_GET_SLEEP_TIME(SUBCOMM_TASK_ID))
#define SUBCOMM_LOCK_INIT() (u8_task_lock_ctrl(SUBCOMM_TASK_ID, TASK_LOCK_OP_INIT))
#define SUBCOMM_LOCK_TAKE() (u8_task_lock_ctrl(SUBCOMM_TASK_ID, TASK_LOCK_OP_TAKE))
#define SUBCOMM_LOCK_GIVE() (u8_task_lock_ctrl(SUBCOMM_TASK_ID, TASK_LOCK_OP_GIVE))
#define SUBCOMM_FEED_DOG() (v_wdt_setFlag(SUBCOMM_TASK_ID))
#define SUBCOMM_LOG(fmt, ...) MYLOG_MSG(SUBCOMM_TASK_ID, (fmt), ##__VA_ARGS__)
/* ======================== 接收缓存（处理粘包/残包） ======================== */
/* 说明：
* - USART0 中断已把数据写入 FIFO，本模块周期从 FIFO 读出并追加到该缓存；
* - 缓存中可能存在：
* 1) 粘包：一次收到多帧 -> 解析循环连续处理
* 2) 残包：一次只到半帧 -> 保留到下次继续拼
* 3) 杂散字节：找不到帧头/校验失败 -> 丢弃直到重新同步 */
#define SUBCOMM_RX_BUF_MAX (128U)
/* ======================== SubComm 模块上下文（模块私有） ======================== */
typedef struct
{
/* 副板遥控/遥信缓存 */
U_SUB_YK_DATA sub_yk;
U_SUB_YX_DATA sub_yx;
/* 接收缓存（处理粘包/残包） */
U8_T rx_buf[SUBCOMM_RX_BUF_MAX];
U16_T rx_len;
/* 最近一次收到有效 DI 状态帧(0x01)的时间戳（ms）。用于离线超时判断。 */
uint64_t last_di_ms;
} S_SUBCOMM_CTX;
static S_SUBCOMM_CTX g_subcomm_ctx; /* SubComm 模块运行时上下文（缓存+状态） */
/* ======================== 副板串口协议（USART0） ======================== */
/* 帧格式：
* [0] 0x5A 帧头
* [1] cmd 命令码
* [2] len 数据长度 N（0~64）
* [3] data[0..N-1] 数据域（可选）
* [3+N] sum 校验：从帧头到数据域的累加和（8-bit 截断）
* [4+N] 0xA5 帧尾 */
#define SUBCOMM_UART_ID (E_USART_0)
#define SUBCOMM_FRAME_HEAD (0x5AU)
#define SUBCOMM_FRAME_TAIL (0xA5U)
#define SUBCOMM_DATA_MAX (64U)
/* 命令码定义 */
#define SUBCOMM_CMD_DI_STATUS (0x01U) /* 辅板DI状态：辅板 -> 主板 */
#define SUBCOMM_CMD_DO_CTRL (0x02U) /* 控制继电器：主板 -> 辅板 */
#define SUBCOMM_CMD_SYS_INFO (0x03U) /* 系统信息：主板 -> 辅板 */
#define SUBCOMM_CMD_GUN_INFO (0x04U) /* 枪信息：主板 -> 辅板 */
/* DI 超时：超过该时间未收到 0x01，则认为副板离线（清零采集缓存）。 */
#define SUBCOMM_DI_TIMEOUT_MS (5000U)
/* 接收缓存已纳入 g_subcomm_ctx 统一管理。 */
#if 1 // 初始化/数据清理
/**
* @brief SubComm 模块数据初始化。
*
* - 清空 YK/YX 缓存（默认全 0）；
* - 重置接收状态机到“等待帧头”。
*/
static void v_sub_comm_data_init(void)
{
(void)memset(&g_subcomm_ctx.sub_yk, 0, sizeof(g_subcomm_ctx.sub_yk));
(void)memset(&g_subcomm_ctx.sub_yx, 0, sizeof(g_subcomm_ctx.sub_yx));
(void)memset(g_subcomm_ctx.rx_buf, 0, sizeof(g_subcomm_ctx.rx_buf));
g_subcomm_ctx.rx_len = 0U;
/* 置 0 表示“尚未收到任何 DI 帧”。 */
g_subcomm_ctx.last_di_ms = 0U;
}
#endif
#if 1 // bit 操作辅助
/* ======================== bit 操作辅助 ======================== */
/**
* @brief 按 bit 写入 16bit 点位缓存。
*
* @param bits 目标 bit-map 指针
* @param bit_idx bit 下标（0~15）
* @param val01 0 或 1
*
* @note 本模块约定：点位枚举值 == bit 下标（与 sub_comm_task.h 的枚举顺序一致）。
*/
static void v_sub_comm_bit_set_u16(uint16_t *bits, U8_T bit_idx, U8_T val01)
{
uint16_t mask; /* 当前点位掩码 */
if ((bits == NULL) || (bit_idx >= 16U))
{
return;
}
mask = (uint16_t)(1U << bit_idx);
if (val01 == 0U)
{
*bits = (uint16_t)(*bits & (uint16_t)(~mask));
}
else
{
*bits = (uint16_t)(*bits | mask);
}
}
/**
* @brief 读取 16bit 点位缓存的某一 bit。
* @return 0/1
*/
static U8_T u8_sub_comm_bit_get_u16(uint16_t bits, U8_T bit_idx)
{
if (bit_idx >= 16U)
{
return 0U;
}
return (U8_T)((bits >> bit_idx) & 0x01U);
}
/**
* @brief 读取 32bit 点位缓存的某一 bit。
* @return 0/1
*/
static U8_T u8_sub_comm_bit_get_u32(uint32_t bits, U8_T bit_idx)
{
if (bit_idx >= 32U)
{
return 0U;
}
return (U8_T)((bits >> bit_idx) & 0x01U);
}
#endif
#if 1 // DI 数据域解析/命令分发
/**
* @brief 将副板 DI 状态数据域解码进 g_subcomm_ctx.sub_yx。
*
* 数据域编码（本工程默认 bit-map 方案，便于紧凑传输）：
* - len >= 2 时使用 data[0..1] 的 16 个 bit：
* bit0 -> YX13
* bit1 -> YX14
* ...
* bit9 -> YX22
* bit10 -> DIP1
* ...
* bit15 -> DIP6
*
* 说明：
* - 若现场协议改为“每点 1 字节”或“更多字节”，只需在此函数内替换映射。
*/
static void v_sub_comm_apply_di_payload(const U8_T *data, U8_T len)
{
if ((data == NULL) || (len < 2U))
{
return;
}
/* 当前 0x01 数据域仅承载低 16bit（YX13~YX22 + DIP1~DIP6），预留 8bit 默认 0。 */
g_subcomm_ctx.sub_yx.u32_bits = (uint32_t)data[0] | ((uint32_t)data[1] << 8);
}
/**
* @brief 解析一帧完整有效的副板协议帧，并更新内部缓存。
* @param cmd 命令码
* @param data 数据域
* @param len 数据长度
*/
static void v_sub_comm_handle_frame(U8_T cmd, const U8_T *data, U8_T len)
{
switch (cmd)
{
case SUBCOMM_CMD_DI_STATUS:
v_sub_comm_apply_di_payload(data, len);
g_subcomm_ctx.last_di_ms = u64_get_current_millis();
break;
default:
/* 其它命令暂不处理 */
break;
}
}
#endif
#if 1 // RX 缓存解帧（处理粘包/残包）
/**
* @brief 从接收缓存中尝试解析一帧完整协议帧。
*
* @return U8_T 1=成功解析并消费掉该帧；0=缓存中暂时没有完整有效帧（可能是残包/需继续收数）
*/
static U8_T u8_sub_comm_try_parse_one_frame(void)
{
U16_T i; /* 遍历下标 */
U16_T frame_start = 0U; /* 帧头位置 */
U16_T total_len; /* 当前帧总长度 */
U8_T cmd; /* 命令码 */
U8_T len; /* 数据域长度 */
U8_T checksum; /* 计算得到的校验值 */
/* 最小帧长度：head+cmd+len+sum+tail = 5 */
if (g_subcomm_ctx.rx_len < 5U)
{
return 0U;
}
/* 1) 查找帧头 */
frame_start = 0xFFFFU;
for (i = 0U; i < g_subcomm_ctx.rx_len; i++)
{
if (g_subcomm_ctx.rx_buf[i] == SUBCOMM_FRAME_HEAD)
{
frame_start = i;
break;
}
}
if (frame_start == 0xFFFFU)
{
/* 缓存里没有帧头，直接清空 */
g_subcomm_ctx.rx_len = 0U;
return 0U;
}
/* 丢弃帧头之前的杂散数据 */
if (frame_start > 0U)
{
g_subcomm_ctx.rx_len = (U16_T)(g_subcomm_ctx.rx_len - frame_start);
(void)memmove(g_subcomm_ctx.rx_buf, &g_subcomm_ctx.rx_buf[frame_start], g_subcomm_ctx.rx_len);
}
/* 2) 至少要有 head/cmd/len */
if (g_subcomm_ctx.rx_len < 3U)
{
return 0U;
}
cmd = g_subcomm_ctx.rx_buf[1];
len = g_subcomm_ctx.rx_buf[2];
if (len > (U8_T)SUBCOMM_DATA_MAX)
{
/* 长度非法，丢弃 1 字节重新同步 */
g_subcomm_ctx.rx_len--;
(void)memmove(g_subcomm_ctx.rx_buf, &g_subcomm_ctx.rx_buf[1], g_subcomm_ctx.rx_len);
return 1U; /* 已消费 1 字节，让外层继续循环 */
}
total_len = (U16_T)(5U + (U16_T)len);
if (g_subcomm_ctx.rx_len < total_len)
{
/* 残包：等待后续数据 */
return 0U;
}
/* 3) 校验帧尾 */
if (g_subcomm_ctx.rx_buf[total_len - 1U] != SUBCOMM_FRAME_TAIL)
{
/* 帧尾不匹配，丢弃 1 字节重新同步 */
g_subcomm_ctx.rx_len--;
(void)memmove(g_subcomm_ctx.rx_buf, &g_subcomm_ctx.rx_buf[1], g_subcomm_ctx.rx_len);
return 1U;
}
/* 4) 校验累加和：从 head 到 data（3+len 字节），对比 sum 字节 */
checksum = (U8_T)u16_crc_checksum(&g_subcomm_ctx.rx_buf[0], (U16_T)(3U + (U16_T)len));
if (checksum != g_subcomm_ctx.rx_buf[3U + (U16_T)len])
{
/* 校验失败，丢弃 1 字节重新同步 */
g_subcomm_ctx.rx_len--;
(void)memmove(g_subcomm_ctx.rx_buf, &g_subcomm_ctx.rx_buf[1], g_subcomm_ctx.rx_len);
return 1U;
}
/* 5) 处理帧 */
v_sub_comm_handle_frame(cmd, &g_subcomm_ctx.rx_buf[3], len);
/* 6) 移除已处理数据（支持粘包：后面可能还有帧） */
g_subcomm_ctx.rx_len = (U16_T)(g_subcomm_ctx.rx_len - total_len);
if (g_subcomm_ctx.rx_len > 0U)
{
(void)memmove(g_subcomm_ctx.rx_buf, &g_subcomm_ctx.rx_buf[total_len], g_subcomm_ctx.rx_len);
}
return 1U;
}
#endif
#if 1 // 系统接口
/* ======================== 系统接口（03/04数据来源与编码） ======================== */
#define SUBCOMM_SYS_TIME_LEN (12U)
#define SUBCOMM_SYS_RSVD_LEN (6U)
#define SUBCOMM_SYS_INFO_LEN (22U)
#define SUBCOMM_GUN_INFO_LEN (14U)
#define SUBCOMM_GUN_RSVD_LEN (8U)
/**
* @brief 获取系统枪数量（并限制到工程上限）。
* @return U8_T 枪数量，范围 0~GUN_MAX_CNT
*/
static U8_T u8_sub_comm_get_gun_cnt_if(void)
{
U8_T gun_cnt = g_t_share_data.t_sys_fix_cfg.u8_gunCnt; /* 配置中的枪数量 */
if (gun_cnt > (U8_T)GUN_MAX_CNT) {
gun_cnt = (U8_T)GUN_MAX_CNT;
}
return gun_cnt;
}
/**
* @brief 获取灯板类型（透传系统固定配置）。
* @return U8_T 灯板类型编码
*/
static U8_T u8_sub_comm_get_led_board_type_if(void)
{
return (U8_T)g_t_share_data.t_sys_fix_cfg.e_ledType;
}
/**
* @brief 获取液冷使能标志（0/1）。
* @return U8_T 0/1（取最低位）
*/
static U8_T u8_sub_comm_get_liquid_cooling_enable_if(void)
{
return (U8_T)(g_t_share_data.t_sys_fix_cfg.u_enable.bit_enable.bit_YeLenEn & 0x01U);
}
/**
* @brief 获取液冷类型。
* @return U8_T 当前未对接任何系统接口，固定为 0。
*/
static U8_T u8_sub_comm_get_liquid_cooling_type_if(void)
{
return 0U;
}
/**
* @brief 获取指定枪连接状态。
* @param gun_no 枪号（0-based）
* @return U8_T 0=未连接，1=已连接
*/
static U8_T u8_sub_comm_get_gun_link_if(U8_T gun_no)
{
return (U8_T)((u8_get_gun_yx_data(YX_GUN_LINK, gun_no) == 0U) ? 0U : 1U);
}
/**
* @brief 获取指定枪对外充电状态（flow 实时状态）。
* @param gun_no 枪号（0-based）
* @return U8_T 充电状态枚举值低8位
*/
static U8_T u8_sub_comm_get_charge_state_if(U8_T gun_no)
{
U16_T flow_state = u16_flow_put_data(gun_no, E_FLOW_PUT_DATA_GUN_REAL_STATE, 0U); /* 流程状态原值 */
return (U8_T)(flow_state & 0xFFU);
}
/**
* @brief 获取指定枪故障/告警标志。
* @param gun_no 枪号（0-based）
* @return U8_T 0=无，1=故障，2=告警
*/
static U8_T u8_sub_comm_get_fault_alarm_flag_if(U8_T gun_no)
{
U8_T pile_fault = u8_get_fault_sum(0U, 0U); /* 整桩故障数量 */
U8_T gun_fault = u8_get_fault_sum((U8_T)(gun_no + 1U), 0U); /* 该枪故障数量 */
U8_T pile_alarm = u8_get_fault_sum(0U, 1U); /* 整桩告警数量 */
U8_T gun_alarm = u8_get_fault_sum((U8_T)(gun_no + 1U), 1U); /* 该枪告警数量 */
if ((pile_fault != 0U) || (gun_fault != 0U)) {
return 1U;
}
if ((pile_alarm != 0U) || (gun_alarm != 0U)) {
return 2U;
}
return 0U;
}
/**
* @brief 获取指定枪 SOC（0~100）。
* @param gun_no 枪号（0-based）
* @return U8_T SOC 百分比
*/
static U8_T u8_sub_comm_get_soc_if(U8_T gun_no)
{
U16_T soc = u16_flow_get_sys_data(gun_no, E_FLOW_GET_DATA_BMS_SOC, 0U); /* BMS 上报 SOC */
if (soc > 100U) {
soc = 100U;
}
return (U8_T)soc;
}
/**
* @brief 计算指定枪对应的指示灯状态编码。
* @param gun_no 枪号（0-based）
* @return U8_T 指示灯状态（与 yk_ctrl 约定一致）
*/
static U8_T u8_sub_comm_get_led_state_if(U8_T gun_no)
{
/* 统一由 led_ctrl 模块计算并缓存两把枪状态，sub_comm 直接读取缓存。 */
return u8_led_state_get(gun_no);
}
/**
* @brief 生成 12 字节时间 ASCII（YYMMDDhhmmss）。
* @param out 输出缓存，长度至少 12 字节
*/
static void v_sub_comm_fill_time_ascii12(U8_T *out)
{
Comm_Time now; /* RTC 当前时间结构体 */
char time_buf[13]; /* 临时字符串，包含结尾 '\0' */
if (out == NULL) {
return;
}
GetCurrentTime(&now);
(void)snprintf(time_buf, sizeof(time_buf), "%02u%02u%02u%02u%02u%02u",
(unsigned int)(now.iYear % 100),
(unsigned int)now.ucMonth,
(unsigned int)now.ucDay,
(unsigned int)now.ucHour,
(unsigned int)now.ucMin,
(unsigned int)now.ucSec);
(void)memcpy(out, time_buf, SUBCOMM_SYS_TIME_LEN);
}
#endif
#if 1 //发送函数
/**
* @brief 组帧并通过 USART0 发送一条副板协议命令。
*
* @param cmd 命令码
* @param data 数据域指针（允许 NULL）
* @param len 数据长度（0~64）
*
* @return U8_T 1=发送成功（至少发出一帧）；0=参数不合法或发送失败
*/
static U8_T u8_sub_comm_send_cmd(U8_T cmd, const U8_T *data, U8_T len)
{
U8_T buf[4U + SUBCOMM_DATA_MAX + 1U]; /* 最大发送帧缓存：head+cmd+len+data+sum+tail */
U8_T sum; /* 8位累加和 */
uint16_t total_len; /* 实际总帧长 */
if (len > (U8_T)SUBCOMM_DATA_MAX)
{
return 0U;
}
buf[0] = SUBCOMM_FRAME_HEAD;
buf[1] = cmd;
buf[2] = len;
if ((len > 0U) && (data != NULL))
{
(void)memcpy(&buf[3], data, len);
}
/* 累加和：从帧头到数据域的累加和（取低 8 位） */
sum = (U8_T)u16_crc_checksum(&buf[0], (U16_T)(3U + len));
buf[3U + len] = sum;
buf[4U + len] = SUBCOMM_FRAME_TAIL;
total_len = (uint16_t)(5U + len);
if (u16_usart_send(SUBCOMM_UART_ID, buf, total_len) != total_len)
{
return 0U;
}
return 1U;
}
/**
* @brief 将副板继电器控制（DO11~DO16）编码为数据域并发送 0x02。
*
* 数据域编码（本工程默认 bit-map 方案）：
* - 2 字节（低字节在前）：
* - bit0~bit5：K1~K6（即 DO11~DO16）
* - bit6~bit11：预留遥控点位（RSVD1~RSVD6）
* - bit12~bit15：保留（对齐）
* bit0 -> DO11(K1)
* bit1 -> DO12(K2)
* ...
* bit5 -> DO16(K6)
*/
static void v_sub_comm_send_do_ctrl(void)
{
/* 下发 2 字节，包含 DO11~DO16 + 预留位 */
U8_T payload[2]; /* 0x02 数据域 */
payload[0] = g_subcomm_ctx.sub_yk.u8_bytes[0];
payload[1] = g_subcomm_ctx.sub_yk.u8_bytes[1];
(void)u8_sub_comm_send_cmd(SUBCOMM_CMD_DO_CTRL, payload, 2U);
}
/**
* @brief 发送 0x03 系统信息帧。
*
* 数据域格式：
* - [0..11] 时间字符串 YYMMDDhhmmss
* - [12] 枪数量
* - [13] 灯板类型
* - [14] 液冷使能（0/1）
* - [15] 液冷类型（默认0）
* - [16..21] 预留
*/
static void v_sub_comm_send_sys_info(void)
{
U8_T payload[SUBCOMM_SYS_INFO_LEN] = {0}; /* 0x03 数据域 */
v_sub_comm_fill_time_ascii12(&payload[0]);
payload[12] = u8_sub_comm_get_gun_cnt_if();
payload[13] = u8_sub_comm_get_led_board_type_if();
payload[14] = u8_sub_comm_get_liquid_cooling_enable_if(); /* liquid_cooling_enable */
payload[15] = u8_sub_comm_get_liquid_cooling_type_if(); /* liquid_cooling_type */
/* payload[16..21] 为预留，默认0 */
(void)u8_sub_comm_send_cmd(SUBCOMM_CMD_SYS_INFO, payload, (U8_T)sizeof(payload));
}
/**
* @brief 发送 0x04 充电枪信息帧。
* @param gun_no 枪号（0-based）
*
* 数据域格式：
* - [0] 枪号(1-based) [1]连接状态 [2]充电状态 [3]灯状态
* - [4]故障告警标志 [5]SOC [6..13]预留
*/
static void v_sub_comm_send_gun_info(U8_T gun_no)
{
U8_T payload[SUBCOMM_GUN_INFO_LEN] = {0}; /* 0x04 数据域 */
payload[0] = (U8_T)(gun_no + 1U); /* 枪号：1/2 */
payload[1] = u8_sub_comm_get_gun_link_if(gun_no); /* 枪连接状态 */
payload[2] = u8_sub_comm_get_charge_state_if(gun_no); /* 充电状态 */
payload[3] = u8_sub_comm_get_led_state_if(gun_no); /* 指示灯状态 */
payload[4] = u8_sub_comm_get_fault_alarm_flag_if(gun_no);/* 故障告警标志 */
payload[5] = u8_sub_comm_get_soc_if(gun_no); /* 充电SOC */
/* payload[6..13] 为预留，默认0 */
(void)u8_sub_comm_send_cmd(SUBCOMM_CMD_GUN_INFO, payload, (U8_T)sizeof(payload));
}
/**
* @brief 发送处理：按调用计数轮询发送 0x02/0x03/0x04。
* @param period_ms 本次调用周期（ms，当前方案未使用）
*
* 轮询策略：
* - 偶数轮：固定发送 0x02（保证与上次 0x02 至少间隔一个执行周期）；
* - 奇数轮：按状态发送信息帧（0=0x03，1=1枪0x04，2=2枪0x04）。
*/
static void v_sub_comm_tx_process(uint16_t period_ms)
{
static U8_T s_send_turn = 0U; /* 发送轮次计数：偶数发0x02，奇数发信息帧 */
static U8_T s_info_slot = 0U; /* 信息帧状态：0=0x03，1=1枪0x04，2=2枪0x04 */
U8_T gun_cnt; /* 当前枪数量 */
(void)period_ms;
if ((s_send_turn & 0x01U) == 0U)
{
v_sub_comm_send_do_ctrl();
s_send_turn++;
return;
}
gun_cnt = u8_sub_comm_get_gun_cnt_if();
switch (s_info_slot)
{
case 0U:
v_sub_comm_send_sys_info();
s_info_slot = 1U;
break;
case 1U:
if (gun_cnt >= 1U)
{
v_sub_comm_send_gun_info(0U); /* 发送1枪数据 */
}
/* 在状态1判断是否双枪：双枪进状态2，否则回状态0。 */
s_info_slot = (gun_cnt >= 2U) ? 2U : 0U;
break;
case 2U:
if (gun_cnt >= 2U)
{
v_sub_comm_send_gun_info(1U); /* 发送2枪数据 */
}
s_info_slot = 0U;
break;
default:
s_info_slot = 0U;
break;
}
s_send_turn++;
}
#endif
#if 1 // 接收函数（USART FIFO -> RX缓存 -> 解帧）
/**
* @brief 接收处理：从 USART0 FIFO 读取并解析所有已到达数据。
*/
static void v_sub_comm_rx_process(void)
{
/* 接收：尽可能把 FIFO 中的数据取出并追加到接收缓存 */
uint8_t rx_buf[64]; /* USART 临时读缓存 */
uint16_t left; /* 本轮读到的字节数 */
uint16_t free_space;/* 全局接收缓存剩余空间 */
uint16_t copy_len; /* 本次可复制字节数 */
left = u16_usart_recv(SUBCOMM_UART_ID, rx_buf, (uint16_t)sizeof(rx_buf));
while (left > 0U)
{
/* 追加到缓存，满了则丢弃最老的数据（保留末尾 1/2，类似 meter 的处理） */
free_space = (g_subcomm_ctx.rx_len < (U16_T)SUBCOMM_RX_BUF_MAX) ? (U16_T)(SUBCOMM_RX_BUF_MAX - g_subcomm_ctx.rx_len) : 0U;
copy_len = (left > free_space) ? free_space : left;
if (copy_len > 0U)
{
(void)memcpy(&g_subcomm_ctx.rx_buf[g_subcomm_ctx.rx_len], rx_buf, copy_len);
g_subcomm_ctx.rx_len = (U16_T)(g_subcomm_ctx.rx_len + copy_len);
}
else
{
/* 缓冲区无空间：保留最后 1/2 数据 */
if (g_subcomm_ctx.rx_len > (U16_T)(SUBCOMM_RX_BUF_MAX / 2U))
{
(void)memmove(g_subcomm_ctx.rx_buf,
&g_subcomm_ctx.rx_buf[g_subcomm_ctx.rx_len - (U16_T)(SUBCOMM_RX_BUF_MAX / 2U)],
(U16_T)(SUBCOMM_RX_BUF_MAX / 2U));
g_subcomm_ctx.rx_len = (U16_T)(SUBCOMM_RX_BUF_MAX / 2U);
}
}
/* 若一次读取的数据超出剩余空间，剩余部分丢弃（避免阻塞/反复搬运）。 */
left = u16_usart_recv(SUBCOMM_UART_ID, rx_buf, (uint16_t)sizeof(rx_buf));
}
/* 解析：循环消费缓存中的完整帧（处理粘包） */
while (u8_sub_comm_try_parse_one_frame() != 0U) {}
}
#endif
#if 1 // 超时处理函数
/**
* @brief 超时处理：若 DI 状态帧(0x01)长时间未更新，则清空 YX/DIP 缓存。
*
* 策略：
* - 若从未收到过 DI 帧（last_di_ms==0），不处理；
* - 若超过 SUBCOMM_DI_TIMEOUT_MS 未更新，清空 g_subcomm_ctx.sub_yx（全部置 0）。
*/
static void v_sub_comm_timeout_process(void)
{
uint64_t now_ms; /* 当前时间戳(ms)，用于调试保留 */
uint64_t delta_ms; /* 距离上次 DI 更新时间 */
if (g_subcomm_ctx.last_di_ms == 0U)
{
return;
}
now_ms = u64_get_current_millis();
delta_ms = u64_safe_millis_since(g_subcomm_ctx.last_di_ms);
if (delta_ms >= (uint64_t)SUBCOMM_DI_TIMEOUT_MS)
{
(void)memset(&g_subcomm_ctx.sub_yx, 0, sizeof(g_subcomm_ctx.sub_yx));
/* 避免每个周期都重复清零：重置 last_di_ms，等待下次有效帧重新置位。 */
g_subcomm_ctx.last_di_ms = 0U;
}
(void)now_ms;
}
#endif
#if 1 // 对外接口函数（缓存读写）
/**
* @brief 写入副板遥控(YK)命令缓存。
*
* @param e_type 点位（DO11~DO16 或预留位）
* @param e_cmd CMD_OFF/CMD_ON
*
* @note 仅更新缓存；串口下发由 v_sub_comm_poll() 周期执行。
*/
void v_sub_comm_yk_set(E_SUB_YK_TYPE e_type, E_CMD e_cmd)
{
if ((U8_T)e_type >= (U8_T)E_SUB_YK_NUM)
{
return;
}
v_sub_comm_bit_set_u16(&g_subcomm_ctx.sub_yk.u16_bits, (U8_T)e_type, (U8_T)((e_cmd == CMD_OFF) ? 0U : 1U));
}
/**
* @brief 读取副板遥控(YK)命令缓存。
* @return CMD_OFF/CMD_ON
*/
E_CMD e_sub_comm_yk_get(E_SUB_YK_TYPE e_type)
{
if ((U8_T)e_type >= (U8_T)E_SUB_YK_NUM)
{
return CMD_OFF;
}
return (u8_sub_comm_bit_get_u16(g_subcomm_ctx.sub_yk.u16_bits, (U8_T)e_type) == 0U) ? CMD_OFF : CMD_ON;
}
/**
* @brief 读取副板遥信(YX)/拨码(DIP)/预留位采集缓存。
* @return 0/1
*/
U8_T u8_sub_comm_yx_get(E_SUB_YX_TYPE e_type)
{
if ((U8_T)e_type >= (U8_T)E_SUB_YX_NUM)
{
return 0U;
}
return u8_sub_comm_bit_get_u32(g_subcomm_ctx.sub_yx.u32_bits, (U8_T)e_type);
}
#endif
#if 1 // SubComm 任务入口
/**
* @brief 副板通信任务（USART0）。
*
* 职责：
* - 解析副板上报帧（0x01），刷新副板 DI/DIP 状态；
* - 周期下发副板继电器控制（0x02），数据来源为 g_subcomm_ctx.sub_yk 缓存；
* - 任务喂狗与运行状态打印。
*/
void v_sub_comm_task(void *arg)
{
uint16_t sleep_time_ms; /* 任务轮询周期(ms) */
uint32_t last_send_time;/* 上次运行日志打印时间(s) */
uint32_t current_time; /* 当前秒计时 */
(void)arg;
(void)SUBCOMM_LOCK_INIT();
sleep_time_ms = SUBCOMM_SLEEP_TIME_MS();
last_send_time = get_current_seconds();
v_sub_comm_data_init();
for (;;) {
SUBCOMM_FEED_DOG();
current_time = get_current_seconds();
if ((TASK_RUN_PRINT_TIME != 0U) && (u32_safe_seconds_since(last_send_time) >= TASK_RUN_PRINT_TIME)) {
if (SUBCOMM_LOCK_TAKE() == 1U) {
SUBCOMM_LOG("sub comm task is runing, sleep time is %ums", sleep_time_ms);
(void)SUBCOMM_LOCK_GIVE();
}
last_send_time = current_time;
}
/* 副板通信：接收 / 发送 / 超时 三部分独立执行 */
v_sub_comm_rx_process();
v_sub_comm_tx_process(sleep_time_ms);
v_sub_comm_timeout_process();
mSleep(sleep_time_ms);
}
}
#endif