SXDT-Embedded
/
IoT_SCV_CH584M
mirror of https://gitee.com/SXDT-Embedded/iot_-scv_-ch584-m.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

代码暂存 添加定时关阀和关灶关阀功能

This commit is contained in:
常正强 2025-05-24 13:53:07 +08:00
parent 8a4385b0a3
commit 58a2335486
4 changed files with 322 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
bsp/inc/bsp_bmp390.h
View File

@ -13,6 +13,13 @@
#define CHECK_EVT_START (0x0001 << 0)
#define MOTOR_STOP_EVT (0x0001 << 1)
#define AUTO_CLOSE_CHECK_EVT (0x0001 << 2)
#define AUTO_CLOSE_TIMEOUT_EVT (0x0001 << 3)
#define AUTO_CLOSE_NO_FLOW_THRESHOLD 30
#define AUTO_CLOSE_CHECK_INTERVAL_MS (5 * 60 * 1000)
#define AUTO_CLOSE_CHECK_COUNT 6
#define AUTO_CLOSE_TOTAL_TIME_MS (30 * 60 * 1000)
void PRESS_LowPower(void);
@ -117,5 +124,9 @@ void bmp3_delay_us(uint32_t period, void *intf_ptr);
*/
void bmp3_check_rslt(const char api_name[], int8_t rslt);
// 新增延时关阀功能相关函数声明
uint8_t isNoFlowDetected(void);
void startAutoCloseTimer(void);
void stopAutoCloseTimer(void);
#endif

31
bsp/inc/bsp_valve.h
View File

@ -33,17 +33,11 @@ extern tmosTaskID vavle_task_id;
#define VAVLE_LOW_VBAT_LED_OFF_EVT (0x0001 << 10) // 低电压LED关闭事件
// 定时关阀相关事件
#define VAVLE_TIMER_CLOSE_EVT (0x0001 << 11) // 定时关阀事件
#define VAVLE_TIMER_CLOSE_START_EVT (0x0001 << 12) // 定时关阀开始事件
#define VALVE_LOW_VBAT_ALARM_PERIOD_MS (1600 * 60 * 10)
#define VALVE_DECT_PERIOD_MS (1600 * 60 * 10)
// 定时关阀默认时间（单位：分钟），可以根据需求调整
#define VALVE_TIMER_CLOSE_DEFAULT_MIN 30
// 定时关阀最大时间（单位：分钟）
#define VALVE_TIMER_CLOSE_MAX_MIN 360
#define CHARGE_TIME_MS (1500)
@ -64,7 +58,9 @@ typedef enum
kCmdCloseVavle,
kCmdOpenVavle,
kCmdData,
kCmdTimerCloseVavle, // 新增定时关阀命令
kCmdTimerClose = 0x05, // 设置定时关阀
kCmdCancelTimer = 0x06, // 取消定时关阀
kCmdQueryTimer = 0x07, // 查询定时器状态
} TeFrameCmd;
typedef struct __attribute__((packed))
@ -114,13 +110,18 @@ typedef struct __attribute__((packed))
uint8_t humi; // 1B 阀门湿度 %RH
int8_t rssi;
// 定时关阀状态变量
uint8_t timer_close_enabled; // 定时关阀是否启用
uint16_t timer_close_min; // 定时关阀时间（分钟）
uint32_t timer_close_start_time; // 定时关阀开始时间
} TsValveData;
extern TsValveData gValveData;
typedef struct __attribute__((packed))
{
uint32_t timer_minutes; // 设置的定时分钟数，0表示未激活
uint32_t start_time; // 定时器启动时的时间戳
uint8_t is_active; // 定时器是否激活 0=未激活 1=激活
} TsTimerCloseState;
extern TsTimerCloseState gTimerCloseState;
uint8_t CheckSum(const uint8_t *data, size_t len);
void BSP_VAVLE_Init(void);
@ -134,9 +135,7 @@ void BSP_VALVE_Generate_ValveResponse(TsRawFrameData *pRawData, TeFrameCmd cmd,
void BSP_VALVE_Generate_UploadData(TsRawFrameData *pRawData);
// 定时关阀相关函数
void BSP_VALVE_StartTimerClose(uint16_t close_min);
void BSP_VALVE_StopTimerClose(void);
uint16_t BSP_VALVE_GetTimerCloseRemainMin(void);
static uint8_t BSP_VALVE_SetTimerClose(uint32_t minutes);
static uint8_t BSP_VALVE_CancelTimerClose(void);
static uint32_t BSP_VALVE_GetRemainingMinutes(void);
#endif // ! __BSP_VALVE_H__

261
bsp/src/bsp_bmp390.c
View File

@ -65,6 +65,12 @@ typedef struct
// 超温相关
uint8_t over_temp_flag; // 超温标志
// 延时关阀相关
uint8_t auto_close_enabled; // 延时关阀功能是否启用
uint8_t auto_close_check_count; // 无流量检测次数计数
uint8_t auto_close_active; // 延时关阀检测是否激活
uint32_t auto_close_start_time; // 延时关阀开始时间
} TsValveSafetyStatus;
// 安全状态全局变量
@ -868,6 +874,66 @@ uint8_t isWithinTolerance(int32_t ref_value, int32_t measured_value, uint8_t tol
}
}
/**
* @brief 检测管道是否无流量状态
*
* @return uint8_t 返回1表示无流量，返回0表示有流量
*/
uint8_t isNoFlowDetected(void)
{
// 检测进出口压差是否在无流量阈值范围内 (0±2Pa)
if (ValveRawData.in_out_press_diff >= -AUTO_CLOSE_NO_FLOW_THRESHOLD &&
ValveRawData.in_out_press_diff <= AUTO_CLOSE_NO_FLOW_THRESHOLD)
{
logDebug("No flow detected: pressure diff = %d Pa", ValveRawData.in_out_press_diff);
return 1; // 无流量
}
logDebug("Flow detected: pressure diff = %d Pa", ValveRawData.in_out_press_diff);
return 0; // 有流量
}
/**
* @brief 启动延时关阀功能
*/
void startAutoCloseTimer(void)
{
if (!valve_safety.auto_close_enabled)
{
valve_safety.auto_close_enabled = 1;
valve_safety.auto_close_active = 1;
valve_safety.auto_close_check_count = 0;
valve_safety.auto_close_start_time = BSP_Get_Tick();
logDebug("Auto close timer started");
// 开始第一次检测，延时5分钟
tmos_start_task(check_task_id, AUTO_CLOSE_CHECK_EVT, MS1_TO_SYSTEM_TIME(AUTO_CLOSE_CHECK_INTERVAL_MS));
// 设置35分钟超时保护（30分钟+5分钟误差容限）
tmos_start_task(check_task_id, AUTO_CLOSE_TIMEOUT_EVT, MS1_TO_SYSTEM_TIME(35 * 60 * 1000));
}
}
/**
* @brief 停止延时关阀功能
*/
void stopAutoCloseTimer(void)
{
if (valve_safety.auto_close_enabled)
{
valve_safety.auto_close_enabled = 0;
valve_safety.auto_close_active = 0;
valve_safety.auto_close_check_count = 0;
// 停止定时器
tmos_stop_task(check_task_id, AUTO_CLOSE_CHECK_EVT);
tmos_stop_task(check_task_id, AUTO_CLOSE_TIMEOUT_EVT);
logDebug("Auto close timer stopped");
}
}
uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
{
if (events & CHECK_EVT_START)
@ -878,6 +944,17 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
// TODO:状态切换不对
if (gValveData.switch_status == kOpened)
{
// 延时关阀功能启动条件检测
// 只在未启动延时关阀时检测无流量状态，一旦启动就交给定时检测处理
if (!valve_safety.auto_close_enabled)
{
if (isNoFlowDetected())
{
startAutoCloseTimer();
logDebug("延时关阀启动：检测到无流量状态");
}
}
// 超压检测
// 后端关阀，进气端压力超过阈值6200关阀
// 流量0.45时候，进气端压力超过阈值6200关阀
@ -889,19 +966,23 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
VALVE_CLOSE();
fault_state = 1;
// 超压关阀时停止延时关阀功能
stopAutoCloseTimer();
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
}
// 欠压检测
else if (ValveRawData.in_press <= ValveInfo.low_press)
{
VALVE_CLOSE();
// else if (ValveRawData.in_press <= ValveInfo.low_press)
// {
// VALVE_CLOSE();
fault_state = 2;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logError("******************************");
logError("欠压关阀");
}
#if 0
// fault_state = 2;
// // 欠压关阀时停止延时关阀功能
// stopAutoCloseTimer();
// tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
// logError("******************************");
// logError("欠压关阀");
// }
#if 1
// 1、过流自动关闭：
// 进气端压力2kpa时，额定流量调到0.9
// 进气端压力升到 3kpa左右时，阀门不能关，流量不超过1.4
@ -940,6 +1021,12 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
}
else if (gValveData.switch_status == kClosed)
{
// 阀门关闭时停止延时关阀功能
if (valve_safety.auto_close_enabled)
{
stopAutoCloseTimer();
}
// 点火开阀
// 监测ValveRawData_buffer，当前最新的压差值大于上一秒的压差
if (isWithinTolerance(ValveRawData_buffer[2].in_press, ValveRawData_buffer[4].in_press, 50)
@ -954,15 +1041,15 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
VALVE_OPEN();
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
}
else
{
logDebug("点火开阀失败");
for (int i = 2; i < 5; i++)
{
logDebug("[%d]: in_press = %d; out_press = %d; in_out_press_diff = %d", i
, ValveRawData_buffer[i].in_press, ValveRawData_buffer[i].out_press, ValveRawData_buffer[i].in_out_press_diff);
}
}
// else
// {
// logDebug("点火开阀失败");
// for (int i = 2; i < 5; i++)
// {
// logDebug("[%d]: in_press = %d; out_press = %d; in_out_press_diff = %d", i
// , ValveRawData_buffer[i].in_press, ValveRawData_buffer[i].out_press, ValveRawData_buffer[i].in_out_press_diff);
// }
// }
}
// 超温关阀功能：检测至少两个传感器的温度超过阈值
@ -984,76 +1071,6 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
motor_flag = 2; // 触发关阀
}
}
#if 0
// 点火开阀功能：检测燃气灶打开但阀门关闭的情况
// 当阀门关闭时，检测用气需求
if (gValveData.switch_status == kClosed)
{
// 检测用气特征：出口压力比大气压低一定值，表示下游有用气需求
// P[1]为出口压力，P[2]为大气压
if (P[2] > P[1] && (P[2] - P[1] >= SAFETY_GAS_REQUEST_PRESS_DIFF))
{
valve_safety.auto_open_count++;
logDebug("Auto open detect: %d", valve_safety.auto_open_count);
// 连续多次检测到用气需求，触发开阀
if (valve_safety.auto_open_count >= SAFETY_AUTO_OPEN_THRESHOLD && !valve_safety.auto_open_flag)
{
logDebug("Auto opening valve due to gas usage detected!");
valve_safety.auto_open_flag = 1;
// 设置motor_flag为1，触发开阀
motor_flag = 1;
}
}
else
{
// 重置计数器
valve_safety.auto_open_count = 0;
}
}
else
{
// 阀门开启状态，重置检测计数和标志
valve_safety.auto_open_count = 0;
valve_safety.auto_open_flag = 0;
}
// 微泄漏关阀功能：检测微小气流并自动关闭阀门
// 当阀门打开时，检测微泄漏情况
if (gValveData.switch_status == kOpened)
{
// 检测微泄漏特征：入口和出口压差非常小，但存在持续的小气流
// P[0]为入口压力，P[1]为出口压力
// 压差范围：大于0确保有流量，但小于阈值表示流量低于0.3L/min
if (P[0] > P[1] && (P[0] - P[1] > 0) && (P[0] - P[1] < SAFETY_MICRO_LEAK_PRESS_DIFF))
{
valve_safety.micro_leak_count++;
logDebug("Micro leak detect: %d, pressure diff: %d", valve_safety.micro_leak_count, P[0] - P[1]);
// 连续多次检测到微泄漏，触发关阀
if (valve_safety.micro_leak_count >= SAFETY_MICRO_LEAK_THRESHOLD && !valve_safety.micro_leak_flag)
{
logDebug("Auto closing valve due to micro leak detected!");
valve_safety.micro_leak_flag = 1;
// 设置motor_flag为2，触发关阀
motor_flag = 2;
}
}
else
{
// 不满足微泄漏条件，重置计数器
valve_safety.micro_leak_count = 0;
}
}
else
{
// 阀门关闭状态，重置检测计数和标志
valve_safety.micro_leak_count = 0;
valve_safety.micro_leak_flag = 0;
}
#endif
// 关灶关火 ^P很小，延时后关闭
//^p与大气压
}
// logDebug("motor_flag_end = %d",motor_flag);
@ -1119,6 +1136,74 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
// }
return (events ^ MOTOR_STOP_EVT);
}
// 延时关阀检测事件处理
if (events & AUTO_CLOSE_CHECK_EVT)
{
if (valve_safety.auto_close_enabled && valve_safety.auto_close_active)
{
valve_safety.auto_close_check_count++;
logDebug("延时关阀第%d次检测 (共需6次)", valve_safety.auto_close_check_count);
// 检测当前是否仍为无流量状态
if (isNoFlowDetected())
{
logDebug("第%d次检测确认无流量 (in_out_press_diff=%d Pa)",
valve_safety.auto_close_check_count, ValveRawData.in_out_press_diff);
// 如果已经检测了6次（30分钟），执行关阀
if (valve_safety.auto_close_check_count >= AUTO_CLOSE_CHECK_COUNT)
{
logError("******************************");
logError("延时关阀:30分钟无流量,自动关闭阀门");
logError("6次检测均确认无流量,总耗时: %d ms", BSP_Get_Tick() - valve_safety.auto_close_start_time);
// 执行关阀动作
motor_flag = 2; // 触发关阀
// 停止延时关阀功能
stopAutoCloseTimer();
}
else
{
// 继续下一次检测，再等5分钟
logDebug("第%d次检测完成,5分钟后进行第%d次检测",
valve_safety.auto_close_check_count, valve_safety.auto_close_check_count + 1);
tmos_start_task(check_task_id, AUTO_CLOSE_CHECK_EVT,
MS1_TO_SYSTEM_TIME(AUTO_CLOSE_CHECK_INTERVAL_MS));
}
}
else
{
// 检测到有流量，停止延时关阀
logDebug("第%d次检测发现有流量 (in_out_press_diff=%d Pa)，停止延时关阀",
valve_safety.auto_close_check_count, ValveRawData.in_out_press_diff);
stopAutoCloseTimer();
}
}
return (events ^ AUTO_CLOSE_CHECK_EVT);
}
// 延时关阀超时事件处理（备用安全机制）
if (events & AUTO_CLOSE_TIMEOUT_EVT)
{
if (valve_safety.auto_close_enabled)
{
logError("******************************");
logError("延时关阀：超时保护，强制关闭阀门");
// 强制执行关阀动作
motor_flag = 2; // 触发关阀
// 停止延时关阀功能
stopAutoCloseTimer();
}
return (events ^ AUTO_CLOSE_TIMEOUT_EVT);
}
return 0;
}
void Function_Check(void)

248
bsp/src/bsp_valve.c
View File

@ -19,6 +19,7 @@
#include "bsp_adc.h"
#include "bsp_led.h"
#include "bsp_bmp390.h"
#include "bsp_tim.h"
#undef LOG_ENABLE
#define LOG_ENABLE 1
@ -28,6 +29,7 @@
TsValveData gValveData = {0};
TsRawFrameData RelyData;
TsTimerCloseState gTimerCloseState = {0};
tmosTaskID vavle_task_id = INVALID_TASK_ID;
@ -196,17 +198,41 @@ static void VAVLE_Task_ProcessTmosMsg(uint8_t *p_rev_msg) // 处理TMOS消息函
logDebug("kCmdOpenVavle");
tmos_set_event(vavle_task_id, VAVLE_OPEN_START_EVT);
break;
// case kCmdTimerCloseVavle: // 定时关阀命令
// logDebug("kCmdTimerCloseVavle");
// if (HostFrameData->len >= 2) {
// // 定时参数在data中，前2字节表示定时时间（分钟）
// uint16_t close_min = (HostFrameData->data[0] << 8) | HostFrameData->data[1];
// BSP_VALVE_StartTimerClose(close_min);
// } else {
// // 使用默认时间
// BSP_VALVE_StartTimerClose(VALVE_TIMER_CLOSE_DEFAULT_MIN);
// }
// break;
case kCmdTimerClose: // 设置定时关阀命令
{
uint8_t result = 0;
if (HostFrameData->len >= 4) {
uint32_t minutes = 0;
tmos_memcpy(&minutes, HostFrameData->data, 4); // 安全的内存拷贝
result = BSP_VALVE_SetTimerClose(minutes);
logDebug("kCmdTimerClose: %d minutes, result: %d", minutes, result);
}
// 生成响应: 状态(1字节) + 设置的分钟数(4字节)
uint8_t response[5] = {result};
tmos_memcpy(&response[1], &gTimerCloseState.timer_minutes, 4); // 安全的内存拷贝
GenerateRawFrame(&RelyData, kCmdTimerClose, response, 5);
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
break;
}
case kCmdCancelTimer: // 取消定时关阀命令
{
uint8_t result = BSP_VALVE_CancelTimerClose();
logDebug("kCmdCancelTimer: result: %d", result);
BSP_VALVE_Generate_ValveResponse(&RelyData, kCmdCancelTimer, result);
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
break;
}
case kCmdQueryTimer: // 查询定时器状态命令
{
uint32_t remaining = BSP_VALVE_GetRemainingMinutes();
uint8_t response[5];
response[0] = gTimerCloseState.is_active;
tmos_memcpy(&response[1], &remaining, 4); // 安全的内存拷贝
logDebug("kCmdQueryTimer: active: %d, remaining: %d", gTimerCloseState.is_active, remaining);
GenerateRawFrame(&RelyData, kCmdQueryTimer, response, 5);
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
break;
}
default:
logError("Invalid command");
break;
@ -360,26 +386,6 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
tmos_set_event(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT);
}
// // 检查定时关阀是否到时间
// if (gValveData.timer_close_enabled && gValveData.switch_status == kOpened)
// {
// uint32_t current_time = BSP_Get_Tick();
// uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time;
// uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000;
// if (elapsed_ms >= timer_ms)
// {
// // 时间到，触发关阀事件
// tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_EVT);
// }
// else
// {
// // 剩余时间（分钟）
// uint16_t remain_min = (timer_ms - elapsed_ms) / (60 * 1000);
// logDebug("Timer close remaining: %d minutes", remain_min);
// }
// }
tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(VALVE_DECT_PERIOD_MS));
return (events ^ VAVLE_LOOP_DECT_EVT);
@ -414,49 +420,24 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
return (events ^ VAVLE_LOW_VBAT_LED_OFF_EVT);
}
// // 定时关阀事件处理
// if (events & VAVLE_TIMER_CLOSE_EVT)
// {
// logDebug("VAVLE_TIMER_CLOSE_EVT");
// // 关闭定时器
// BSP_VALVE_StopTimerClose();
// // 如果阀门当前是打开状态，则触发关闭
// if (gValveData.switch_status == kOpened)
// {
// // 触发关阀事件
// tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
// }
// return (events ^ VAVLE_TIMER_CLOSE_EVT);
// }
// // 定时关阀开始事件处理
// if (events & VAVLE_TIMER_CLOSE_START_EVT)
// {
// logDebug("VAVLE_TIMER_CLOSE_START_EVT");
// // 记录开始时间
// gValveData.timer_close_start_time = BSP_Get_Tick();
// gValveData.timer_close_enabled = 1;
// logDebug("Timer close started: %d minutes", gValveData.timer_close_min);
// // 闪烁LED提示用户定时已设置（可选）
// LED_VALVE_CLOSE;
// DelayMs(200);
// if (gValveData.switch_status == kOpened)
// {
// LED_VALVE_OPEN;
// }
// else
// {
// LED_VALVE_CLOSE;
// }
// return (events ^ VAVLE_TIMER_CLOSE_START_EVT);
// }
if (events & VAVLE_TIMER_CLOSE_EVT) // 定时关阀事件
{
logInfo("Timer close triggered - auto closing valve");
// 清除定时器状态
gTimerCloseState.is_active = 0;
gTimerCloseState.timer_minutes = 0;
// 触发关阀动作
tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
// 发送定时关阀完成通知
uint8_t notification = 1; // 定时关阀完成
GenerateRawFrame(&RelyData, kCmdTimerClose, &notification, 1);
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
return (events ^ VAVLE_TIMER_CLOSE_EVT);
}
return 0;
}
@ -465,6 +446,9 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
{
vavle_task_id = TMOS_ProcessEventRegister(VAVLE_Task_ProcessEvent);
tmos_memset(&gValveData, 0, sizeof(gValveData));
// 初始化定时器状态
tmos_memset(&gTimerCloseState, 0, sizeof(gTimerCloseState));
gValveData.temp = -100;
gValveData.in_pressure = 0;
@ -474,11 +458,6 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
gValveData.type = kTyq; // 设置阀门类型
gValveData.bat = BSP_ReadVbat(); // 读取电池电压
// 初始化定时关阀状态变量
gValveData.timer_close_enabled = 0;
gValveData.timer_close_min = 0;
gValveData.timer_close_start_time = 0;
BSP_MOTOR_Init(); // 初始化电机
tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(1000)); //VALVE_DECT_PERIOD_MS
@ -488,53 +467,72 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
gValveData.switch_status = kClosed; // 初始化阀门状态为关闭
}
// void BSP_VALVE_StartTimerClose(uint16_t close_min)
// {
// if (close_min == 0)
// {
// // 关闭定时器
// BSP_VALVE_StopTimerClose();
// return;
// }
static uint8_t BSP_VALVE_SetTimerClose(uint32_t minutes)
{
// 参数验证
if (minutes == 0 || minutes > 1440) { // 1分钟到24小时
logError("Invalid timer minutes: %d", minutes);
return 0; // 设置失败
}
// 检查当前阀门状态，如果已经关闭则不需要定时关阀
if (gValveData.switch_status == kClosed) {
logDebug("Valve already closed, timer not needed");
return 2; // 阀门已关闭
}
// 停止现有定时器（如果有）
if (gTimerCloseState.is_active) {
tmos_stop_task(vavle_task_id, VAVLE_TIMER_CLOSE_EVT);
logDebug("Stopped existing timer");
}
// 设置新的定时器
gTimerCloseState.timer_minutes = minutes;
gTimerCloseState.start_time = BSP_Get_Tick();
gTimerCloseState.is_active = 1;
// 启动TMOS定时器
uint32_t delay_ms = minutes * 60 * 1000;
tmos_start_task(vavle_task_id, VAVLE_TIMER_CLOSE_EVT, MS1_TO_SYSTEM_TIME(delay_ms));
logInfo("Timer close set: %d minutes", minutes);
return 1; // 设置成功
}
// // 限制最大定时时间
// if (close_min > VALVE_TIMER_CLOSE_MAX_MIN)
// {
// close_min = VALVE_TIMER_CLOSE_MAX_MIN;
// }
static uint8_t BSP_VALVE_CancelTimerClose(void)
{
if (!gTimerCloseState.is_active) {
logDebug("No active timer to cancel");
return 0; // 没有激活的定时器
}
// 停止定时器
tmos_stop_task(vavle_task_id, VAVLE_TIMER_CLOSE_EVT);
// 清除状态
gTimerCloseState.is_active = 0;
gTimerCloseState.timer_minutes = 0;
logInfo("Timer close cancelled");
return 1; // 取消成功
}
// // 设置定时参数
// gValveData.timer_close_min = close_min;
static uint32_t BSP_VALVE_GetRemainingMinutes(void)
{
if (!gTimerCloseState.is_active) {
return 0; // 没有激活的定时器
}
uint32_t elapsed_ms = BSP_Get_Tick() - gTimerCloseState.start_time;
uint32_t total_ms = gTimerCloseState.timer_minutes * 60 * 1000;
if (elapsed_ms >= total_ms) {
return 0; // 时间已到
}
uint32_t remaining_ms = total_ms - elapsed_ms;
return (remaining_ms / 60000) + 1; // 向上取整到分钟
}
// // 触发定时开始事件
// tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_START_EVT);
// logDebug("BSP_VALVE_StartTimerClose: %d minutes", close_min);
// }
// void BSP_VALVE_StopTimerClose(void)
// {
// gValveData.timer_close_enabled = 0;
// gValveData.timer_close_min = 0;
// logDebug("BSP_VALVE_StopTimerClose");
// }
// uint16_t BSP_VALVE_GetTimerCloseRemainMin(void)
// {
// if (!gValveData.timer_close_enabled)
// {
// return 0;
// }
// uint32_t current_time = BSP_Get_Tick();
// uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time;
// uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000;
// if (elapsed_ms >= timer_ms)
// {
// return 0;
// }
// return (timer_ms - elapsed_ms) / (60 * 1000);
// }