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:
stark1898y 2025-05-22 17:59:32 +08:00
parent 7cc4b38232
commit 4d2621e2e4
4 changed files with 500 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

712
bsp/src/bsp_bmp390.c
View File

@ -9,32 +9,65 @@
#include "bsp_valve.h"
uint8_t flag;
uint8_t keydown_flag = 0;
uint8_t keydown_time = 0;
uint8_t keydown_flag = 0;
uint8_t keydown_time = 0;
uint8_t volatile fault_state = 0;
// 安全阈值参数统一定义
#define SAFETY_AUTO_OPEN_THRESHOLD 3 // 自动开阀阈值（连续检测次数）
#define SAFETY_MICRO_LEAK_THRESHOLD 5 // 微泄漏检测阈值（连续检测次数）
#define SAFETY_MICRO_LEAK_PRESS_DIFF 15 // 微泄漏压力差阈值(Pa)，对应流量约0.3L/min
#define SAFETY_OVER_TEMP_THRESHOLD 65 // 超温阈值(℃)
#define SAFETY_GAS_REQUEST_PRESS_DIFF 50 // 用气请求压力差阈值(Pa)
// 安全阈值参数统一定义
#define SAFETY_AUTO_OPEN_THRESHOLD 3 // 自动开阀阈值（连续检测次数）
#define SAFETY_MICRO_LEAK_THRESHOLD 5 // 微泄漏检测阈值（连续检测次数）
#define SAFETY_MICRO_LEAK_PRESS_DIFF 15 // 微泄漏压力差阈值(Pa)，对应流量约0.3L/min
#define SAFETY_OVER_TEMP_THRESHOLD 65 // 超温阈值(℃)
#define SAFETY_GAS_REQUEST_PRESS_DIFF 50 // 用气请求压力差阈值(Pa)
// 安全保护状态结构体
typedef struct {
// 自动开阀相关
uint8_t auto_open_count; // 自动开阀检测计数
uint8_t auto_open_flag; // 自动开阀标志
// 微泄漏相关
uint8_t micro_leak_count; // 微泄漏检测计数
uint8_t micro_leak_flag; // 微泄漏标志
// 超温相关
uint8_t over_temp_flag; // 超温标志
typedef struct
{
int in_press_raw;
int out_press_raw;
int8_t in_temp;
int8_t out_temp;
int8_t atom_temp;
int in_press; // 表压 单位Pa
int out_press;
int atom_press;
// 进气端和出气端压力差值 单位Pa
int in_out_press_diff;
} TsValveRawData;
TsValveRawData ValveRawData;
TsValveRawData ValveRawData_buffer[5];
typedef struct
{
uint16_t over_press;
uint16_t low_press;
uint8_t over_temp;
int over_flow_press_diff_1kpa;
int over_flow_press_diff_2kpa;
int over_flow_press_diff_3kpa;
} TsValveInfo;
TsValveInfo ValveInfo;
// 安全保护状态结构体
typedef struct
{
// 自动开阀相关
uint8_t auto_open_count; // 自动开阀检测计数
uint8_t auto_open_flag; // 自动开阀标志
// 微泄漏相关
uint8_t micro_leak_count; // 微泄漏检测计数
uint8_t micro_leak_flag; // 微泄漏标志
// 超温相关
uint8_t over_temp_flag; // 超温标志
} TsValveSafetyStatus;
// 安全状态全局变量
// 安全状态全局变量
TsValveSafetyStatus valve_safety = {0};
extern uint8_t motor_flag;
@ -96,8 +129,8 @@ BMP3_INTF_RET_TYPE BMP390_IN_SPI_Read(uint8_t reg_addr, uint8_t *reg_data, uint3
BMP3_INTF_RET_TYPE rslt = 0;
uint8_t reg_spi[1] = {(reg_addr & 0x7F) | 0x80};
SPI_CsStart(kPressIn); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
SPI_CsStart(kPressIn); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
rslt = Bmp_ReadData(reg_data, len);
SPI_CsStop(kPressIn);
return rslt;
@ -128,8 +161,8 @@ BMP3_INTF_RET_TYPE BMP390_OUT_SPI_Read(uint8_t reg_addr, uint8_t *reg_data, uint
BMP3_INTF_RET_TYPE rslt = 0;
uint8_t reg_spi[1] = {(reg_addr & 0x7F) | 0x80};
SPI_CsStart(kPressOut); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
SPI_CsStart(kPressOut); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
rslt = Bmp_ReadData(reg_data, len);
SPI_CsStop(kPressOut);
return rslt;
@ -157,8 +190,8 @@ BMP3_INTF_RET_TYPE BMP390_ATOM_SPI_Read(uint8_t reg_addr, uint8_t *reg_data, uin
BMP3_INTF_RET_TYPE rslt = 0;
uint8_t reg_spi[1] = {(reg_addr & 0x7F) | 0x80};
SPI_CsStart(kPressAtom); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
SPI_CsStart(kPressAtom); // 拉低片选
Bmp_WriteData(reg_spi, 1); // 写入控制字节
rslt = Bmp_ReadData(reg_data, len);
SPI_CsStop(kPressAtom);
return rslt;
@ -355,7 +388,7 @@ void PRESS_IO_SPI_Init(void)
SPI_CsStop(kPressOut);
SPI_CsStop(kPressAtom);
// spi初始化，模式0
// spi初始化，模式0
GPIOA_ModeCfg(GPIO_Pin_13 | GPIO_Pin_14, GPIO_ModeOut_PP_5mA);
GPIOA_ModeCfg(GPIO_Pin_15, GPIO_ModeIN_PU);
@ -364,7 +397,7 @@ void PRESS_IO_SPI_Init(void)
void PRESS_LowerIO_Init(void)
{
// BMP390默认供电时，其他IO都是高电平,INT引脚为低电平
// BMP390默认供电时，其他IO都是高电平,INT引脚为低电平
// SPI
GPIOA_SetBits(GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
GPIOA_ModeCfg(GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15, GPIO_ModeIN_PU);
@ -391,7 +424,7 @@ void Lower_IO_Deinit(void)
GPIOA_ModeCfg(LED_VBAT_PIN | LED_ALARM_PIN, GPIO_ModeIN_PD);
// KEY | RESET KEY | boot KEY
GPIOA_ResetBits(KEY_A_PIN );
GPIOA_ResetBits(KEY_A_PIN);
GPIOA_ModeCfg(KEY_A_PIN, GPIO_ModeIN_PU);
// GPIOB_ResetBits(GPIO_Pin_23 | GPIO_Pin_22);
// GPIOB_ModeCfg(GPIO_Pin_23 | GPIO_Pin_22, GPIO_ModeIN_PD);
@ -404,40 +437,40 @@ void Lower_IO_Deinit(void)
// BMP390
// INT1: PA2 | INT2: PA6 | INT3: PA12
GPIOA_ModeCfg(GPIO_Pin_6 | GPIO_Pin_9 | GPIO_Pin_3, GPIO_ModeIN_PD);
// spi初始化
GPIOA_ModeCfg(GPIO_Pin_13 | GPIO_Pin_14, GPIO_ModeIN_PD);
GPIOA_ModeCfg(GPIO_Pin_15, GPIO_ModeIN_PD);
// spi初始化
GPIOA_ModeCfg(GPIO_Pin_13 | GPIO_Pin_14, GPIO_ModeIN_PD);
GPIOA_ModeCfg(GPIO_Pin_15, GPIO_ModeIN_PD);
//4G
// 关闭3.8V供电
// 4G
// 关闭3.8V供电
GPIOB_ResetBits(ENABLE_3_8_V);
GPIOB_ModeCfg(ENABLE_3_8_V, GPIO_ModeIN_PD);
// 将控制引脚设为下拉，减少漏电流
// 将控制引脚设为下拉，减少漏电流
GPIOB_ModeCfg(ML307_PWR_PIN | ML307_RST_PIN, GPIO_ModeIN_PD);
// UART引脚
// UART引脚
GPIOB_ModeCfg(ML307_UART_TX_PIN, GPIO_ModeIN_PD);
GPIOB_ModeCfg(ML307_UART_RX_PIN, GPIO_ModeIN_PU);
// SIM卡检测引脚配置为下拉输入
// SIM卡检测引脚配置为下拉输入
GPIOB_ModeCfg(USIM_DECT_PIN, GPIO_ModeIN_PD);
//motor
//GPIOA_ResetBits(COIL_ADC);
//GPIOA_ModeCfg(COIL_ADC, GPIO_ModeIN_PD);
//IN1 + ; IN2 +
//GPIOB_SetBits(COIL_A);
//GPIOB_SetBits(COIL_B);
//GPIOB_ModeCfg(COIL_A | COIL_B, GPIO_ModeIN_PD);
// motor
// GPIOA_ResetBits(COIL_ADC);
// GPIOA_ModeCfg(COIL_ADC, GPIO_ModeIN_PD);
// IN1 + ; IN2 +
// GPIOB_SetBits(COIL_A);
// GPIOB_SetBits(COIL_B);
// GPIOB_ModeCfg(COIL_A | COIL_B, GPIO_ModeIN_PD);
// UART3
// GPIOB_ModeCfg(GPIO_Pin_21 | GPIO_Pin_20, GPIO_ModeIN_PD);
// // 关闭UART3时钟
// // 关闭UART3时钟
// sys_safe_access_enable();
// R8_SLP_CLK_OFF0 |= RB_SLP_CLK_UART3;
// sys_safe_access_disable();
// // 关闭shell和日志系统
// shell.write = NULL; // 禁用shell输出
// // 关闭shell和日志系统
// shell.write = NULL; // 禁用shell输出
// 关闭外部低速晶振
// 关闭外部低速晶振
// GPIOA_ModeCfg(GPIO_Pin_10 | GPIO_Pin_11, GPIO_ModeIN_PD);
}
@ -460,10 +493,31 @@ struct bmp3_data data = {0};
struct bmp3_settings settings = {0};
struct bmp3_status status = {{0}};
//T,P
// T,P
int32_t T[3] = {0};
int32_t P[3] = {0};
// 定义滑动窗口函数
void slideValveRawDataBuffer(TsValveRawData *newData)
{
// 将数组元素左移一位
for (int i = 0; i < 4; i++)
{
tmos_memcpy(&ValveRawData_buffer[i], &ValveRawData_buffer[i + 1], sizeof(TsValveRawData));
}
// 将新数据存入数组[4]
tmos_memcpy(&ValveRawData_buffer[4], &newData[0], sizeof(TsValveRawData));
// for (int i = 0; i < 5; i++)
// {
// logDebug("Buffer[%d]: in_press=%d, out_press=%d, diff=%d",
// i,
// ValveRawData_buffer[i].in_press,
// ValveRawData_buffer[i].out_press,
// ValveRawData_buffer[i].in_out_press_diff);
// }
}
__HIGH_CODE
__attribute__((noinline))
uint16_t
@ -480,7 +534,7 @@ BMP390_ProcessEvent(uint8_t task_id, uint16_t events)
return (events ^ BMP390_IN_START);
}
else if(events & BMP390_OUT_START)
else if (events & BMP390_OUT_START)
{
press_done_flag = 0;
PRESS_IO_SPI_Init();
@ -490,7 +544,7 @@ BMP390_ProcessEvent(uint8_t task_id, uint16_t events)
bmp3_check_rslt("bmp3_set_op_mode", ret);
return (events ^ BMP390_OUT_START);
}
else if(events & BMP390_ATOM_START)
else if (events & BMP390_ATOM_START)
{
press_done_flag = 0;
PRESS_IO_SPI_Init();
@ -527,12 +581,12 @@ BMP390_ProcessEvent(uint8_t task_id, uint16_t events)
ret = bmp3_get_status(&status, &DevIn);
bmp3_check_rslt("bmp3_get_status", ret);
#ifdef BMP3_FLOAT_COMPENSATION
#ifdef BMP3_FLOAT_COMPENSATION
printf("IN[%d] T: %.2f deg C, P: %.2f Pa\n", loop, (data.temperature), (data.pressure));
#else
#else
printf("IN[%d] T: %ld deg C, P: %lu Pa\n", loop, (long int)(int32_t)(data.temperature / 100),
(long unsigned int)(uint32_t)(data.pressure / 100));
#endif
#endif
}
// OUT
@ -555,118 +609,153 @@ BMP390_ProcessEvent(uint8_t task_id, uint16_t events)
ret = bmp3_get_status(&status, &DevOut);
bmp3_check_rslt("bmp3_get_status", ret);
#ifdef BMP3_FLOAT_COMPENSATION
#ifdef BMP3_FLOAT_COMPENSATION
printf("OUT[%d] T: %.2f deg C, P: %.2f Pa\n", loop, (data.temperature), (data.pressure));
#else
#else
printf("OUT[%d] T: %ld deg C, P: %lu Pa\n", loop, (long int)(int32_t)(data.temperature / 100),
(long unsigned int)(uint32_t)(data.pressure / 100));
#endif
#endif
loop = loop + 1;
}
tmos_start_task(press_task_id, WF5803_EVT_START, MS1_TO_SYSTEM_TIME(2000));
#endif
if(flag == 1)
if (flag == 1)
{
ret = bmp3_get_status(&status, &DevIn); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
ret = bmp3_get_status(&status, &DevIn); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
if (status.intr.drdy == BMP3_ENABLE)
{
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevIn);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevIn);
bmp3_check_rslt("bmp3_get_status", ret);
// printf("IN[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[0] = (int32_t)(data.temperature / 100);
P[0] = (uint32_t)(data.pressure / 100);
}
//tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(100));
tmos_start_task(press_task_id, BMP390_OUT_START, MS1_TO_SYSTEM_TIME(500)); //100
//tmos_start_task(press_task_id, BMP390_IN_START, MS1_TO_SYSTEM_TIME(1000));
}
else if(flag == 2)
if (status.intr.drdy == BMP3_ENABLE)
{
ret = bmp3_get_status(&status, &DevOut); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevIn);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
if (status.intr.drdy == BMP3_ENABLE)
{
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevOut);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevIn);
bmp3_check_rslt("bmp3_get_status", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevOut);
bmp3_check_rslt("bmp3_get_status", ret);
// printf("OUT[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[1] = (int32_t)(data.temperature / 100);
P[1] = (uint32_t)(data.pressure / 100);
}
tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(500)); //100
//tmos_start_task(press_task_id, BMP390_OUT_START, MS1_TO_SYSTEM_TIME(1000));
// printf("IN[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[0] = (int32_t)(data.temperature / 100);
P[0] = (uint32_t)(data.pressure / 100);
}
else if(flag == 3)
{
ret = bmp3_get_status(&status, &DevAtom); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
if (status.intr.drdy == BMP3_ENABLE)
{
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevAtom);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevAtom);
bmp3_check_rslt("bmp3_get_status", ret);
// printf("ATOM[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[2] = (int32_t)(data.temperature / 100);
P[2] = (uint32_t)(data.pressure / 100);
//printf("%d, %d, %d\r\n",T[0],T[1],T[2]);
printf("%d, %d, %d, %d, %d, %d \r\n",T[0],T[1],T[2],P[0],P[1],P[2]);
printf("P1: %d,P2: %d ,^P: %d \r\n",P[0]-P[2],P[1]-P[2],P[0]-P[1]);
}
tmos_start_task(press_task_id, BMP390_IN_START, MS1_TO_SYSTEM_TIME(500)); //100
//tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(1000));
}
flag = 0;
press_done_flag = 1;
loop = loop + 1;
return (events ^ BMP390_EVT_READ);
// tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(100));
tmos_start_task(press_task_id, BMP390_OUT_START, MS1_TO_SYSTEM_TIME(500)); // 100
// tmos_start_task(press_task_id, BMP390_IN_START, MS1_TO_SYSTEM_TIME(1000));
}
else if (flag == 2)
{
ret = bmp3_get_status(&status, &DevOut); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
if (status.intr.drdy == BMP3_ENABLE)
{
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevOut);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevOut);
bmp3_check_rslt("bmp3_get_status", ret);
// printf("OUT[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[1] = (int32_t)(data.temperature / 100);
P[1] = (uint32_t)(data.pressure / 100);
}
tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(500)); // 100
// tmos_start_task(press_task_id, BMP390_OUT_START, MS1_TO_SYSTEM_TIME(1000));
}
else if (flag == 3)
{
ret = bmp3_get_status(&status, &DevAtom); // 配置中断引脚为锁存模式，需要读取int_status.drdy位才能清除中断状态标志
bmp3_check_rslt("bmp3_get_status", ret);
if (status.intr.drdy == BMP3_ENABLE)
{
/*
* First parameter indicates the type of data to be read
* BMP3_PRESS_TEMP : To read pressure and temperature data
* BMP3_TEMP : To read only temperature data
* BMP3_PRESS : To read only pressure data
*/
ret = bmp3_get_sensor_data(BMP3_PRESS_TEMP, &data, &DevAtom);
bmp3_check_rslt("bmp3_get_sensor_data", ret);
/* NOTE : Read status register again to clear data ready interrupt status */
ret = bmp3_get_status(&status, &DevAtom);
bmp3_check_rslt("bmp3_get_status", ret);
// printf("ATOM[%d] T: %ld deg C, P: %lu Pa\r\n", loop, (long int)(int32_t)(data.temperature / 100),
// (long unsigned int)(uint32_t)(data.pressure / 100));
T[2] = (int32_t)(data.temperature / 100);
P[2] = (uint32_t)(data.pressure / 100);
logDebug("**********************************");
logDebug("%d, %d, %d, %d, %d, %d \r\n", T[0], T[1], T[2], P[0], P[1], P[2]);
logDebug("P1: %d,P2: %d ,^P: %d \r\n", P[0] - P[2], P[1] - P[2], P[0] - P[1]);
logDebug("**********************************");
}
tmos_start_task(press_task_id, BMP390_IN_START, MS1_TO_SYSTEM_TIME(500)); // 100
// tmos_start_task(press_task_id, BMP390_ATOM_START, MS1_TO_SYSTEM_TIME(1000));
}
flag = 0;
press_done_flag = 1;
// TODO:读完三个气压传感器数据后在做计算
ValveRawData.in_press_raw = P[0];
ValveRawData.out_press_raw = P[1];
ValveRawData.atom_press = P[2];
ValveRawData.in_temp = T[0];
ValveRawData.out_temp = T[1];
ValveRawData.atom_temp = T[2];
ValveRawData.in_press = ValveRawData.in_press_raw - ValveRawData.atom_press;
ValveRawData.out_press = ValveRawData.out_press_raw - ValveRawData.atom_press;
ValveRawData.in_out_press_diff = ValveRawData.in_press - ValveRawData.out_press;
logDebug("in_press: %d, out_press: %d, atom_press: %d\r\n", ValveRawData.in_press, ValveRawData.out_press, ValveRawData.atom_press);
logDebug("in_temp: %d, out_temp: %d, atom_temp: %d\r\n", ValveRawData.in_temp, ValveRawData.out_temp, ValveRawData.atom_temp);
logDebug("in_out_press_diff: %d\r\n", ValveRawData.in_out_press_diff);
// 刷新ValveRawData_buffer,把之前的ValveRawData按时间顺序向右滑动
// ，最新的ValveRawData 存在数组[4]
slideValveRawDataBuffer(&ValveRawData);
loop = loop + 1;
return (events ^ BMP390_EVT_READ);
}
return 0;
}
void VALVE_SetInfo()
{
ValveInfo.over_press = 6200;
ValveInfo.low_press = 800;
ValveInfo.over_temp = 65;
ValveInfo.over_flow_press_diff_1kpa = 500;
ValveInfo.over_flow_press_diff_2kpa = 500;
ValveInfo.over_flow_press_diff_3kpa = 500;
}
void BSP_PRESS_Init(void)
{
PRESS_IO_SPI_Init();
// 中断引脚的配置
// 中断引脚的配置
GPIOA_ModeCfg(GPIO_Pin_9, GPIO_ModeIN_PD);
GPIOA_ITModeCfg(GPIO_Pin_9, GPIO_ITMode_RiseEdge);
@ -693,10 +782,10 @@ void BSP_PRESS_Init(void)
settings.press_en = BMP3_ENABLE;
settings.temp_en = BMP3_ENABLE;
settings.odr_filter.press_os = BMP3_OVERSAMPLING_2X; //BMP3_OVERSAMPLING_2X
settings.odr_filter.temp_os = BMP3_OVERSAMPLING_2X; //BMP3_OVERSAMPLING_2X
settings.odr_filter.odr = BMP3_ODR_0_39_HZ; //BMP3_ODR_1_5_HZ
settings.odr_filter.iir_filter = BMP3_IIR_FILTER_COEFF_1; //BMP3_IIR_FILTER_COEFF_3
settings.odr_filter.press_os = BMP3_OVERSAMPLING_2X; // BMP3_OVERSAMPLING_2X
settings.odr_filter.temp_os = BMP3_OVERSAMPLING_2X; // BMP3_OVERSAMPLING_2X
settings.odr_filter.odr = BMP3_ODR_0_39_HZ; // BMP3_ODR_1_5_HZ
settings.odr_filter.iir_filter = BMP3_IIR_FILTER_COEFF_1; // BMP3_IIR_FILTER_COEFF_3
settings_sel = BMP3_SEL_PRESS_EN | BMP3_SEL_TEMP_EN | BMP3_SEL_PRESS_OS | BMP3_SEL_TEMP_OS | BMP3_SEL_ODR | BMP3_SEL_DRDY_EN | BMP3_SEL_IIR_FILTER | BMP3_SEL_OUTPUT_MODE | BMP3_SEL_LEVEL | BMP3_SEL_LATCH;
@ -752,8 +841,31 @@ void BSP_PRESS_Init(void)
press_task_id = TMOS_ProcessEventRegister(BMP390_ProcessEvent);
tmos_set_event(press_task_id, BMP390_IN_START);
//tmos_set_event(press_task_id, BMP390_OUT_START);
//tmos_set_event(press_task_id, BMP390_ATOM_START);
// tmos_set_event(press_task_id, BMP390_OUT_START);
// tmos_set_event(press_task_id, BMP390_ATOM_START);
VALVE_SetInfo();
}
/**
* @brief 判断参考值是否在测量值的误差范围内
*
* @param ref_value 参考值
* @param measured_value 测量值
* @param tolerance 误差范围（正负）
*
* @return uint8_t 返回 1 表示在范围内，返回 0 表示不在范围内
*/
uint8_t isWithinTolerance(int32_t ref_value, int32_t measured_value, uint8_t tolerance)
{
if ((measured_value - tolerance <= ref_value) && (ref_value <= measured_value + tolerance))
{
return 1; // 在范围内
}
else
{
return 0; // 不在范围内
}
}
uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
@ -761,163 +873,239 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
if (events & CHECK_EVT_START)
{
// logDebug("fault_state = %d \r\n",fault_state);
if(!fault_state)
if (!fault_state)
{
//超压检测
if(P[0] - P[2] >= 6500) //超过7000关阀
// TODO:状态切换不对
if (gValveData.switch_status == kOpened)
{
VALVE_CLOSE();
fault_state = 1;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logDebug("Over pressure state !");
}
//欠压检测
if((P[0] - P[2] > 100) && (P[0] - P[2] <= 800)) //小于1000关阀
{
VALVE_CLOSE();
fault_state = 2;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logDebug("Under voltage status !");
}
//过流检测
if( P[0] - P[1] >= 500) //超过540关阀
{
if(keydown_flag > 0)
// 超压检测
// 后端关阀，进气端压力超过阈值6200关阀
// 流量0.45时候，进气端压力超过阈值6200关阀
if (ValveRawData.in_press >= ValveInfo.over_press)
{
logDebug("keydown_time !%d",keydown_time);
keydown_time ++;
if(keydown_time > 25)
logError("******************************");
logError("超压关阀");
logDebug("in_press = %d; over_press = %d", ValveRawData.in_press, ValveInfo.over_press);
VALVE_CLOSE();
fault_state = 1;
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();
fault_state = 2;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logError("******************************");
logError("欠压关阀");
}
if (isWithinTolerance(ValveRawData_buffer[2].in_press, ValveRawData_buffer[4].in_press, 50)
&& ValveRawData_buffer[4].in_out_press_diff >= 900)
{
logError("******************************");
logError("点火开阀");
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);
}
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);
}
}
#if 0
// 1、过流自动关闭：
// 进气端压力2kpa时，额定流量调到0.9
// 进气端压力升到 3kpa左右时，阀门不能关，流量不超过1.4
// 3、进气端压力 1kpa左右时，出气端阀口全开，需要关闭(过流自动关闭)
// if (isWithinTolerance(1000, ValveRawData.in_press, 50)
// && ValveRawData.in_out_press_diff)
// {
// /* code */
// }
// 进气端压力2kpa时，额定流量调到1.4（切断流量）要关阀
if (ValveRawData.in_out_press_diff >= ValveInfo.over_flow_press_diff_2kpa)
{
if (keydown_flag > 0)
{
logDebug("keydown_time !%d", keydown_time);
keydown_time++;
if (keydown_time > 25)
{
keydown_time = 0;
keydown_flag = 0;
}
}
else
{
keydown_time = 0;
keydown_flag = 0;
VALVE_CLOSE();
logError("******************************");
fault_state = 3;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logDebug("Over current status !");
}
}else
}
#endif
}
else if (gValveData.switch_status == kClosed)
{
// 点火开阀
// 监测ValveRawData_buffer，当前最新的压差值大于上一秒的压差
if (isWithinTolerance(ValveRawData_buffer[2].in_press, ValveRawData_buffer[4].in_press, 50)
&& ValveRawData_buffer[4].in_out_press_diff >= 900)
{
keydown_time = 0;
VALVE_CLOSE();
fault_state = 3;
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
logDebug("Over current status !");
logError("******************************");
logError("点火开阀");
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);
}
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);
}
}
}
// 超温关阀功能：检测至少两个传感器的温度超过阈值
if(!valve_safety.over_temp_flag && gValveData.switch_status == kOpened)
// 点火开阀
// 超温关阀功能：检测至少两个传感器的温度超过阈值
if (!valve_safety.over_temp_flag && gValveData.switch_status == kOpened)
{
// 计算超过阈值的传感器数量
// 计算超过阈值的传感器数量
uint8_t over_temp_count = 0;
// 检查三个传感器的温度是否超过阈值
if(T[0] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
if(T[1] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
if(T[2] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
// 如果至少有两个传感器超过阈值，触发关阀
if(over_temp_count >= 2)
// 检查三个传感器的温度是否超过阈值
if (T[0] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
if (T[1] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
if (T[2] > SAFETY_OVER_TEMP_THRESHOLD) over_temp_count++;
// 如果至少有两个传感器超过阈值，触发关阀
if (over_temp_count >= 2)
{
logDebug("Over temperature detected! T1=%d, T2=%d, T3=%d", T[0], T[1], T[2]);
valve_safety.over_temp_flag = 1;
motor_flag = 2; // 触发关阀
motor_flag = 2; // 触发关阀
}
}
// 点火开阀功能：检测燃气灶打开但阀门关闭的情况
// 当阀门关闭时，检测用气需求
if(gValveData.switch_status == kClosed)
#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))
// 检测用气特征：出口压力比大气压低一定值，表示下游有用气需求
// 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)
// 连续多次检测到用气需求，触发开阀
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，触发开阀
motor_flag = 1;
}
}
else
{
// 重置计数器
// 重置计数器
valve_safety.auto_open_count = 0;
}
}
else
{
// 阀门开启状态，重置检测计数和标志
// 阀门开启状态，重置检测计数和标志
valve_safety.auto_open_count = 0;
valve_safety.auto_open_flag = 0;
valve_safety.auto_open_flag = 0;
}
// 微泄漏关阀功能：检测微小气流并自动关闭阀门
// 当阀门打开时，检测微泄漏情况
if(gValveData.switch_status == kOpened)
// 微泄漏关阀功能：检测微小气流并自动关闭阀门
// 当阀门打开时，检测微泄漏情况
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))
// 检测微泄漏特征：入口和出口压差非常小，但存在持续的小气流
// 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)
// 连续多次检测到微泄漏，触发关阀
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，触发关阀
motor_flag = 2;
}
}
else
{
// 不满足微泄漏条件，重置计数器
// 不满足微泄漏条件，重置计数器
valve_safety.micro_leak_count = 0;
}
}
else
{
// 阀门关闭状态，重置检测计数和标志
// 阀门关闭状态，重置检测计数和标志
valve_safety.micro_leak_count = 0;
valve_safety.micro_leak_flag = 0;
valve_safety.micro_leak_flag = 0;
}
//关灶关火 ^P很小，延时后关闭
//^p与大气压
#endif
// 关灶关火 ^P很小，延时后关闭
//^p与大气压
}
// logDebug("motor_flag_end = %d",motor_flag);
//手动关阀
if(motor_flag == 1)
// 手动关阀
if (motor_flag == 1)
{
motor_flag = 0;
LED_VALVE_OPEN;
VALVE_OPEN();
keydown_flag = 1;
keydown_flag = 1;
IotFlag_t.Valve_Open_flag = 1;
fault_state = 0;
fault_state = 0;
logDebug("motor/LED open!!!");
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
}
else if(motor_flag == 2)
else if (motor_flag == 2)
{
motor_flag = 0;
LED_VALVE_CLOSE;
VALVE_CLOSE();
fault_state = 4;
// 微泄漏关阀后重置标志
if(valve_safety.micro_leak_flag)
// fault_state = 4;
// 微泄漏关阀后重置标志
if (valve_safety.micro_leak_flag)
{
valve_safety.micro_leak_flag = 0;
logDebug("Micro leak protection activated");
}
// 超温关阀后重置标志
if(valve_safety.over_temp_flag)
// 超温关阀后重置标志
if (valve_safety.over_temp_flag)
{
valve_safety.over_temp_flag = 0;
logDebug("Over temperature protection activated");
@ -925,24 +1113,34 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
logDebug("motor/LED close!!!");
tmos_start_task(check_task_id, MOTOR_STOP_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
}
else if(motor_flag == 3)
else if (motor_flag == 3)
{
motor_flag = 0;
if(gValveData.switch_status == kOpened)
if (gValveData.switch_status == kOpened)
{
LED_VALVE_OPEN;
}else
}
else
{
LED_VALVE_CLOSE;
}
// DelayMs(500);
}
tmos_start_task(check_task_id, CHECK_EVT_START, MS1_TO_SYSTEM_TIME(200)); //100
tmos_start_task(check_task_id, CHECK_EVT_START, MS1_TO_SYSTEM_TIME(200)); // 100
return (events ^ CHECK_EVT_START);
}
if (events & MOTOR_STOP_EVT)
{
VALVE_STOP();
if (gValveData.switch_status == kClosed)
{
gValveData.switch_status = kOpened;
}
else if (gValveData.switch_status == kOpened)
{
gValveData.switch_status = kClosed;
}
logDebug("motor STOP");
// DelayMs(1500);
// if(fault_state == 4)
@ -964,45 +1162,43 @@ __INTERRUPT
__HIGH_CODE
void GPIOA_IRQHandler(void)
{
// 清除中断标志位
// 清除中断标志位
GPIOA_ClearITFlagBit(KEY_A_PIN);
// 检查是否为真实按键事件（通过确认电平是否真的接近0V）
if (GPIOA_ReadPortPin(KEY_A_PIN) == 0) {
// 再次确认是否真的为低电平（接近0V）
DelayUs(10); // 短暂延时50
if (GPIOA_ReadPortPin(KEY_A_PIN) == 0) {
// 确认是真实按键事件
// 阻止睡眠
// 检查是否为真实按键事件（通过确认电平是否真的接近0V）
if (GPIOA_ReadPortPin(KEY_A_PIN) == 0)
{
// 再次确认是否真的为低电平（接近0V）
DelayUs(10); // 短暂延时50
if (GPIOA_ReadPortPin(KEY_A_PIN) == 0)
{
// 确认是真实按键事件
// 阻止睡眠
BSP_BlockSleep();
// 关按键中断
// 关按键中断
BSP_KEY_ExitLowpower();
printf("KEY IRQHandler !!!");
key_wakeup_flag = 1;
}
}
}
if (R16_PA_INT_IF & GPIO_Pin_9)
{
R16_PA_INT_IF = GPIO_Pin_9;
flag = 1;
flag = 1;
tmos_set_event(press_task_id, BMP390_EVT_READ);
// logDebug("INT2 \r\n");
}
else if (R16_PA_INT_IF & GPIO_Pin_3)
{
R16_PA_INT_IF = GPIO_Pin_3;
flag = 2;
flag = 2;
tmos_set_event(press_task_id, BMP390_EVT_READ);
// logDebug("INT3 \r\n");
}
else if (R16_PA_INT_IF & GPIO_Pin_6)
{
R16_PA_INT_IF = GPIO_Pin_6;
flag = 3;
flag = 3;
tmos_set_event(press_task_id, BMP390_EVT_READ);
// logDebug("INT1 \r\n");
}
}

6
bsp/src/bsp_motor.c
View File

@ -29,7 +29,7 @@ void VALVE_OPEN(void)
GPIOB_SetBits(COIL_A);
GPIOB_ResetBits(COIL_B);
valve_status.motor_state = 1;
gValveData.switch_status = kOpened;
// gValveData.switch_status = kOpened;
}
void VALVE_CLOSE(void)
@ -39,7 +39,7 @@ void VALVE_CLOSE(void)
GPIOB_ResetBits(COIL_A);
GPIOB_SetBits(COIL_B);
valve_status.motor_state = 0;
gValveData.switch_status = kClosed;
// gValveData.switch_status = kClosed;
}
void VALVE_STOP(void)
@ -50,4 +50,4 @@ void VALVE_STOP(void)
GPIOB_SetBits(COIL_B);
}

5
bsp/src/bsp_uart.c
View File

@ -148,9 +148,8 @@ void BSP_UART3_Init(void)
GPIOB_ModeCfg(UART3_RX_PIN, GPIO_ModeIN_PU); // RXD-配置上拉输入
GPIOB_ModeCfg(UART3_TX_PIN, GPIO_ModeOut_PP_5mA); // TXD-配置推挽输出，注意先让IO口输出高电平
UART3_DefInit();
UART3_BaudRateCfg(460800); //115200
UART3_BaudRateCfg(4000000); //115200
UART3_ByteTrigCfg(UART_1BYTE_TRIG);
// 中断方式接收数据
UART3_INTCfg(ENABLE, RB_IER_LINE_STAT | RB_IER_RECV_RDY | RB_IER_THR_EMPTY);
PFIC_EnableIRQ(UART3_IRQn);
@ -174,7 +173,7 @@ static uint16_t BSP_Shell_TimeoutTask(uint8_t task_id, uint16_t events)
BSP_RequestSleep();
return (events ^ SHELL_TIMEOUT_EVT);
}
return 0;
}

80
bsp/src/bsp_valve.c
View File

@ -2,8 +2,8 @@
* @Author : stark1898y 1658608470@qq.com
* @Date : 2024-12-15 15:01:15
* @LastEditors : stark1898y 1658608470@qq.com
* @LastEditTime : 2025-02-24 17:58:40
* @FilePath : \BLE_TYQ_CH584M\BSP\src\bsp_valve.c
* @LastEditTime : 2025-05-22 17:01:27
* @FilePath : \iot_-scv_-ch584-m(1)\bsp\src\bsp_valve.c
* @Description :
*
* Copyright (c) 2024 by yzy, All Rights Reserved.
@ -18,7 +18,7 @@
#include "SLEEP.h"
#include "bsp_adc.h"
#include "bsp_led.h"
#include "bsp_bmp390.h"
#include "bsp_bmp390.h"
#undef LOG_ENABLE
#define LOG_ENABLE 1
@ -293,52 +293,52 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
logDebug("VAVLE_CLOSE_END_EVT");
return (events ^ VAVLE_CLOSE_END_EVT);
}
if (events & VAVLE_OPEN_START_EVT) // 阀门打开开始事件
{
logDebug("VAVLE_OPEN_START_EVT");
BSP_BlockSleep();
LED_VALVE_OPEN;
// DelayUs(200);
VALVE_STOP();
logDebug("MOTOR_INIT");
tmos_start_task(vavle_task_id, VAVLE_OPEN_ACTION_EVT, MS1_TO_SYSTEM_TIME(200));
return (events ^ VAVLE_OPEN_START_EVT);
}
if (events & VAVLE_OPEN_ACTION_EVT) // 阀门打开动作事件
{
BSP_BlockSleep();
logDebug("VAVLE_OPEN_ACTION_EVT");
VALVE_OPEN();
keydown_flag = 1;
logDebug("VALVE_OPEN");
tmos_start_task(vavle_task_id, VAVLE_OPEN_END_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
return (events ^ VAVLE_OPEN_ACTION_EVT);
}
if (events & VAVLE_OPEN_END_EVT) // 阀门打开结束事件
{
VALVE_STOP();
LED_ALL_CLOSE;
tmos_memset(&RelyData, 0, sizeof(RelyData));
BSP_VALVE_Generate_ValveResponse(&RelyData, kCmdOpenVavle, 1);
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
BSP_RequestSleep();
logDebug("VAVLE_OPEN_END_EVT");
return (events ^ VAVLE_OPEN_END_EVT);
}
if (events & VAVLE_LOOP_DECT_EVT) // 循环检测事件
{
logDebug("VAVLE_LOOP_DECT_EVT");
@ -366,7 +366,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
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)
{
// 时间到，触发关阀事件
@ -379,7 +379,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
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);
@ -392,9 +392,9 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
{
return (events ^ VAVLE_LOW_VBAT_ALARM_EVT);
}
logDebug("VAVLE_LOW_VBAT_ALARM_EVT");
logDebug("VAVLE_LOW_VBAT_ALARM_EVT");
BSP_BlockSleep();
BSP_BlockSleep();
LED_VBAT_OPEN;
tmos_start_task(vavle_task_id, VAVLE_LOW_VBAT_LED_OFF_EVT, MS1_TO_SYSTEM_TIME(500));
@ -405,12 +405,12 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
// tmos_start_task(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT, MS1_TO_SYSTEM_TIME(VALVE_LOW_VBAT_ALARM_PERIOD_MS)); // 启动低电压报警事件，延时一段时间
return (events ^ VAVLE_LOW_VBAT_ALARM_EVT);
return (events ^ VAVLE_LOW_VBAT_ALARM_EVT);
}
if (events & VAVLE_LOW_VBAT_LED_OFF_EVT) // 低电压LED关闭事件
{
LED_VBAT_CLOSE;
BSP_RequestSleep();
BSP_RequestSleep();
return (events ^ VAVLE_LOW_VBAT_LED_OFF_EVT);
}
@ -418,17 +418,17 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
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);
}
@ -436,13 +436,13 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
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);
@ -454,7 +454,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
{
LED_VALVE_CLOSE;
}
return (events ^ VAVLE_TIMER_CLOSE_START_EVT);
}
@ -473,7 +473,7 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
gValveData.type = kTyq; // 设置阀门类型
gValveData.bat = BSP_ReadVbat(); // 读取电池电压
// 初始化定时关阀状态变量
gValveData.timer_close_enabled = 0;
gValveData.timer_close_min = 0;
@ -484,6 +484,8 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(1000)); //VALVE_DECT_PERIOD_MS
logInfo("BSP_Valve_Init");
gValveData.switch_status = kClosed; // 初始化阀门状态为关闭
}
void BSP_VALVE_StartTimerClose(uint16_t close_min)
@ -494,19 +496,19 @@ void BSP_VALVE_StartTimerClose(uint16_t close_min)
BSP_VALVE_StopTimerClose();
return;
}
// 限制最大定时时间
if (close_min > VALVE_TIMER_CLOSE_MAX_MIN)
{
close_min = VALVE_TIMER_CLOSE_MAX_MIN;
}
// 设置定时参数
gValveData.timer_close_min = close_min;
// 触发定时开始事件
tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_START_EVT);
logDebug("BSP_VALVE_StartTimerClose: %d minutes", close_min);
}
@ -514,7 +516,7 @@ void BSP_VALVE_StopTimerClose(void)
{
gValveData.timer_close_enabled = 0;
gValveData.timer_close_min = 0;
logDebug("BSP_VALVE_StopTimerClose");
}
@ -524,15 +526,15 @@ uint16_t BSP_VALVE_GetTimerCloseRemainMin(void)
{
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);
}