778 lines
24 KiB
C
778 lines
24 KiB
C
#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
|