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-23 11:04:04 +08:00
parent a6f40e4c90
commit 8a4385b0a3
6 changed files with 132 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.mrs/launch.json
View File

@ -5,12 +5,12 @@
"type": "mrs-debugger", "type": "mrs-debugger",
"request": "launch", "request": "launch",
"name": "IoT_SCV_CH584M1", "name": "IoT_SCV_CH584M1",
"cwd": "c:\\Users\\16586\\Desktop\\iot_-scv_-ch584-m(1)", "cwd": "c:\\Users\\123\\Desktop\\自闭阀项目\\V1.1\\iot_-scv_-ch584-m",
"openOCDCfg": { "openOCDCfg": {
"useLocalOpenOCD": true, "useLocalOpenOCD": true,
"executable": "c:/MounRiver/MounRiver_Studio2/resources/app/resources/win32/components/WCH/OpenOCD/OpenOCD/bin/openocd.exe", "executable": "d:/MounRiverV2/MounRiver_Studio2/resources/app/resources/win32/components/WCH/OpenOCD/OpenOCD/bin/openocd.exe",
"configOptions": [ "configOptions": [
"-f \"c:/MounRiver/MounRiver_Studio2/resources/app/resources/win32/components/WCH/OpenOCD/OpenOCD/bin/wch-riscv.cfg\" -c \"chip_id CH32L10x\"" "-f \"d:/MounRiverV2/MounRiver_Studio2/resources/app/resources/win32/components/WCH/OpenOCD/OpenOCD/bin/wch-riscv.cfg\" -c \"chip_id CH32L10x\""
], ],
"gdbport": 3333, "gdbport": 3333,
"telnetport": 4444, "telnetport": 4444,
@ -22,7 +22,7 @@
"enableNoZeroWaitingAreaFlash": false "enableNoZeroWaitingAreaFlash": false
}, },
"gdbCfg": { "gdbCfg": {
"executable": "c:/MounRiver/MounRiver_Studio2/resources/app/resources/win32/components/WCH/Toolchain/RISC-V Embedded GCC12/bin/riscv-wch-elf-gdb.exe", "executable": "d:/MounRiverV2/MounRiver_Studio2/resources/app/resources/win32/components/WCH/Toolchain/RISC-V Embedded GCC12/bin/riscv-wch-elf-gdb.exe",
"commands": [ "commands": [
"set mem inaccessible-by-default off", "set mem inaccessible-by-default off",
"set architecture riscv:rv32", "set architecture riscv:rv32",
@ -39,8 +39,8 @@
"additionalCommands": [] "additionalCommands": []
}, },
"loadedFiles": { "loadedFiles": {
"executableFile": "c:\\Users\\16586\\Desktop\\iot_-scv_-ch584-m(1)\\obj\\IoT_SCV_CH584M1.elf", "executableFile": "c:\\Users\\123\\Desktop\\自闭阀项目\\V1.1\\iot_-scv_-ch584-m\\obj\\IoT_SCV_CH584M1.elf",
"symbolFile": "c:\\Users\\16586\\Desktop\\iot_-scv_-ch584-m(1)\\obj\\IoT_SCV_CH584M1.elf", "symbolFile": "c:\\Users\\123\\Desktop\\自闭阀项目\\V1.1\\iot_-scv_-ch584-m\\obj\\IoT_SCV_CH584M1.elf",
"executableFileOffset": 0, "executableFileOffset": 0,
"symbolFileOffset": 0 "symbolFileOffset": 0
}, },

26
APP/peripheral.c
View File

@ -870,22 +870,22 @@ void BLE_ConnectEventCB(uint32_t timeUs)
*********************************************************************/ *********************************************************************/
// 假设在此处有handleTimerCloseReq函数，添加定时关阀的处理函数 // 假设在此处有handleTimerCloseReq函数，添加定时关阀的处理函数
static void handleTimerCloseReq(uint16_t time_min) // static void handleTimerCloseReq(uint16_t time_min)
{ // {
// 设置定时关阀 // // 设置定时关阀
BSP_VALVE_StartTimerClose(time_min); // BSP_VALVE_StartTimerClose(time_min);
// 回复设置成功 // // 回复设置成功
uint8_t buf[3]; // uint8_t buf[3];
buf[0] = 0x01; // 命令成功标志 // buf[0] = 0x01; // 命令成功标志
buf[1] = (time_min >> 8) & 0xFF; // 高字节 // buf[1] = (time_min >> 8) & 0xFF; // 高字节
buf[2] = time_min & 0xFF; // 低字节 // buf[2] = time_min & 0xFF; // 低字节
// 假设以下函数用于向蓝牙客户端发送回复 // // 假设以下函数用于向蓝牙客户端发送回复
// sendTimerCloseRsp(buf, sizeof(buf)); // // sendTimerCloseRsp(buf, sizeof(buf));
logInfo("Set timer close: %d minutes", time_min); // logInfo("Set timer close: %d minutes", time_min);
} // }
// 在处理BLE命令的地方添加处理定时关阀命令的代码 // 在处理BLE命令的地方添加处理定时关阀命令的代码
// 假设有类似以下处理命令的函数，在其中添加对定时关阀命令的处理 // 假设有类似以下处理命令的函数，在其中添加对定时关阀命令的处理

35
bsp/src/bsp_bmp390.c
View File

@ -424,8 +424,8 @@ void Lower_IO_Deinit(void)
GPIOA_ModeCfg(LED_VBAT_PIN | LED_ALARM_PIN, GPIO_ModeIN_PD); GPIOA_ModeCfg(LED_VBAT_PIN | LED_ALARM_PIN, GPIO_ModeIN_PD);
// KEY | RESET KEY | boot KEY // KEY | RESET KEY | boot KEY
GPIOA_ResetBits(KEY_BPIN); GPIOB_ResetBits(KEY_BPIN);
GPIOA_ModeCfg(KEY_BPIN, GPIO_ModeIN_PU); GPIOB_ModeCfg(KEY_BPIN, GPIO_ModeIN_PU);
// GPIOB_ResetBits(GPIO_Pin_23 | GPIO_Pin_22); // GPIOB_ResetBits(GPIO_Pin_23 | GPIO_Pin_22);
// GPIOB_ModeCfg(GPIO_Pin_23 | GPIO_Pin_22, GPIO_ModeIN_PD); // GPIOB_ModeCfg(GPIO_Pin_23 | GPIO_Pin_22, GPIO_ModeIN_PD);
@ -901,27 +901,6 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
logError("******************************"); logError("******************************");
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 #if 0
// 1、过流自动关闭： // 1、过流自动关闭：
// 进气端压力2kpa时，额定流量调到0.9 // 进气端压力2kpa时，额定流量调到0.9
@ -986,8 +965,6 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
} }
} }
// 点火开阀
// 超温关阀功能：检测至少两个传感器的温度超过阈值 // 超温关阀功能：检测至少两个传感器的温度超过阈值
if (!valve_safety.over_temp_flag && gValveData.switch_status == kOpened) if (!valve_safety.over_temp_flag && gValveData.switch_status == kOpened)
{ {
@ -1132,14 +1109,6 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
if (events & MOTOR_STOP_EVT) if (events & MOTOR_STOP_EVT)
{ {
VALVE_STOP(); VALVE_STOP();
if (gValveData.switch_status == kClosed)
{
gValveData.switch_status = kOpened;
}
else if (gValveData.switch_status == kOpened)
{
gValveData.switch_status = kClosed;
}
logDebug("motor STOP"); logDebug("motor STOP");
// DelayMs(1500); // DelayMs(1500);

10
bsp/src/bsp_key.c
View File

@ -301,16 +301,16 @@ void BSP_KEY_Init(app_task_evt_handler_t handler)
GPIOB_ModeCfg(KEY_BPIN, GPIO_ModeIN_PU); GPIOB_ModeCfg(KEY_BPIN, GPIO_ModeIN_PU);
// 下降沿触发 // 下降沿触发
// GPIOB_ITModeCfg(KEY_BPIN, GPIO_ITMode_FallEdge); GPIOB_ITModeCfg(KEY_BPIN, GPIO_ITMode_FallEdge);
// 开启GPIO的睡眠唤醒,如果需要的话 // 开启GPIO的睡眠唤醒,如果需要的话
// PWR_PeriphWakeUpCfg(ENABLE, RB_SLP_GPIO_WAKE, Long_Delay); // PWR_PeriphWakeUpCfg(ENABLE, RB_SLP_GPIO_WAKE, Long_Delay);
// PWR_PeriphWakeUpCfg(ENABLE, RB_GPIO_WAKE_MODE | RB_SLP_GPIO_WAKE, Long_Delay); PWR_PeriphWakeUpCfg(ENABLE, RB_GPIO_WAKE_MODE | RB_SLP_GPIO_WAKE, Long_Delay);
// 开启GPIOB中断 // 开启GPIOB中断
// PFIC_EnableIRQ(GPIO_B_IRQn); PFIC_EnableIRQ(GPIO_B_IRQn);
// tmos_start_task(key_task_id, KEY_SCAN_EVT, MS1_TO_SYSTEM_TIME(KEY_SACN_MS)); tmos_start_task(key_task_id, KEY_SCAN_EVT, MS1_TO_SYSTEM_TIME(KEY_SACN_MS));
// tmos_start_task(key_task_id, KEY_SCAN_EVT, MS1_TO_SYSTEM_TIME(5)); // tmos_start_task(key_task_id, KEY_SCAN_EVT, MS1_TO_SYSTEM_TIME(5));
@ -374,7 +374,7 @@ void GPIOB_IRQHandler(void)
GPIOB_ClearITFlagBit(KEY_BPIN); GPIOB_ClearITFlagBit(KEY_BPIN);
// 检查是否为真实按键事件（通过确认电平是否真的接近0V） // 检查是否为真实按键事件（通过确认电平是否真的接近0V）
if (IS_KEY_Vaild() == 0) if (IS_KEY_Vaild() == 1)
{ {
// 确认是真实按键事件 // 确认是真实按键事件
// 阻止睡眠 // 阻止睡眠

4
bsp/src/bsp_motor.c
View File

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

208
bsp/src/bsp_valve.c
View File

@ -196,17 +196,17 @@ static void VAVLE_Task_ProcessTmosMsg(uint8_t *p_rev_msg) // 处理TMOS消息函
logDebug("kCmdOpenVavle"); logDebug("kCmdOpenVavle");
tmos_set_event(vavle_task_id, VAVLE_OPEN_START_EVT); tmos_set_event(vavle_task_id, VAVLE_OPEN_START_EVT);
break; break;
case kCmdTimerCloseVavle: // 定时关阀命令 // case kCmdTimerCloseVavle: // 定时关阀命令
logDebug("kCmdTimerCloseVavle"); // logDebug("kCmdTimerCloseVavle");
if (HostFrameData->len >= 2) { // if (HostFrameData->len >= 2) {
// 定时参数在data中，前2字节表示定时时间（分钟） // // 定时参数在data中，前2字节表示定时时间（分钟）
uint16_t close_min = (HostFrameData->data[0] << 8) | HostFrameData->data[1]; // uint16_t close_min = (HostFrameData->data[0] << 8) | HostFrameData->data[1];
BSP_VALVE_StartTimerClose(close_min); // BSP_VALVE_StartTimerClose(close_min);
} else { // } else {
// 使用默认时间 // // 使用默认时间
BSP_VALVE_StartTimerClose(VALVE_TIMER_CLOSE_DEFAULT_MIN); // BSP_VALVE_StartTimerClose(VALVE_TIMER_CLOSE_DEFAULT_MIN);
} // }
break; // break;
default: default:
logError("Invalid command"); logError("Invalid command");
break; break;
@ -360,25 +360,25 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
tmos_set_event(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT); tmos_set_event(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT);
} }
// 检查定时关阀是否到时间 // // 检查定时关阀是否到时间
if (gValveData.timer_close_enabled && gValveData.switch_status == kOpened) // if (gValveData.timer_close_enabled && gValveData.switch_status == kOpened)
{ // {
uint32_t current_time = BSP_Get_Tick(); // uint32_t current_time = BSP_Get_Tick();
uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time; // uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time;
uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000; // uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000;
if (elapsed_ms >= timer_ms) // if (elapsed_ms >= timer_ms)
{ // {
// 时间到，触发关阀事件 // // 时间到，触发关阀事件
tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_EVT); // tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_EVT);
} // }
else // else
{ // {
// 剩余时间（分钟） // // 剩余时间（分钟）
uint16_t remain_min = (timer_ms - elapsed_ms) / (60 * 1000); // uint16_t remain_min = (timer_ms - elapsed_ms) / (60 * 1000);
logDebug("Timer close remaining: %d minutes", remain_min); // 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)); tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(VALVE_DECT_PERIOD_MS));
@ -414,49 +414,49 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
return (events ^ VAVLE_LOW_VBAT_LED_OFF_EVT); return (events ^ VAVLE_LOW_VBAT_LED_OFF_EVT);
} }
// 定时关阀事件处理 // // 定时关阀事件处理
if (events & VAVLE_TIMER_CLOSE_EVT) // if (events & VAVLE_TIMER_CLOSE_EVT)
{ // {
logDebug("VAVLE_TIMER_CLOSE_EVT"); // logDebug("VAVLE_TIMER_CLOSE_EVT");
// 关闭定时器 // // 关闭定时器
BSP_VALVE_StopTimerClose(); // BSP_VALVE_StopTimerClose();
// 如果阀门当前是打开状态，则触发关闭 // // 如果阀门当前是打开状态，则触发关闭
if (gValveData.switch_status == kOpened) // if (gValveData.switch_status == kOpened)
{ // {
// 触发关阀事件 // // 触发关阀事件
tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT); // tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
} // }
return (events ^ VAVLE_TIMER_CLOSE_EVT); // return (events ^ VAVLE_TIMER_CLOSE_EVT);
} // }
// 定时关阀开始事件处理 // // 定时关阀开始事件处理
if (events & VAVLE_TIMER_CLOSE_START_EVT) // if (events & VAVLE_TIMER_CLOSE_START_EVT)
{ // {
logDebug("VAVLE_TIMER_CLOSE_START_EVT"); // logDebug("VAVLE_TIMER_CLOSE_START_EVT");
// 记录开始时间 // // 记录开始时间
gValveData.timer_close_start_time = BSP_Get_Tick(); // gValveData.timer_close_start_time = BSP_Get_Tick();
gValveData.timer_close_enabled = 1; // gValveData.timer_close_enabled = 1;
logDebug("Timer close started: %d minutes", gValveData.timer_close_min); // logDebug("Timer close started: %d minutes", gValveData.timer_close_min);
// 闪烁LED提示用户定时已设置（可选） // // 闪烁LED提示用户定时已设置（可选）
LED_VALVE_CLOSE; // LED_VALVE_CLOSE;
DelayMs(200); // DelayMs(200);
if (gValveData.switch_status == kOpened) // if (gValveData.switch_status == kOpened)
{ // {
LED_VALVE_OPEN; // LED_VALVE_OPEN;
} // }
else // else
{ // {
LED_VALVE_CLOSE; // LED_VALVE_CLOSE;
} // }
return (events ^ VAVLE_TIMER_CLOSE_START_EVT); // return (events ^ VAVLE_TIMER_CLOSE_START_EVT);
} // }
return 0; return 0;
} }
@ -488,53 +488,53 @@ void BSP_VAVLE_Init(void) // 阀门初始化函数
gValveData.switch_status = kClosed; // 初始化阀门状态为关闭 gValveData.switch_status = kClosed; // 初始化阀门状态为关闭
} }
void BSP_VALVE_StartTimerClose(uint16_t close_min) // void BSP_VALVE_StartTimerClose(uint16_t close_min)
{ // {
if (close_min == 0) // if (close_min == 0)
{ // {
// 关闭定时器 // // 关闭定时器
BSP_VALVE_StopTimerClose(); // BSP_VALVE_StopTimerClose();
return; // return;
} // }
// 限制最大定时时间 // // 限制最大定时时间
if (close_min > VALVE_TIMER_CLOSE_MAX_MIN) // if (close_min > VALVE_TIMER_CLOSE_MAX_MIN)
{ // {
close_min = VALVE_TIMER_CLOSE_MAX_MIN; // close_min = VALVE_TIMER_CLOSE_MAX_MIN;
} // }
// 设置定时参数 // // 设置定时参数
gValveData.timer_close_min = close_min; // gValveData.timer_close_min = close_min;
// 触发定时开始事件 // // 触发定时开始事件
tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_START_EVT); // tmos_set_event(vavle_task_id, VAVLE_TIMER_CLOSE_START_EVT);
logDebug("BSP_VALVE_StartTimerClose: %d minutes", close_min); // logDebug("BSP_VALVE_StartTimerClose: %d minutes", close_min);
} // }
void BSP_VALVE_StopTimerClose(void) // void BSP_VALVE_StopTimerClose(void)
{ // {
gValveData.timer_close_enabled = 0; // gValveData.timer_close_enabled = 0;
gValveData.timer_close_min = 0; // gValveData.timer_close_min = 0;
logDebug("BSP_VALVE_StopTimerClose"); // logDebug("BSP_VALVE_StopTimerClose");
} // }
uint16_t BSP_VALVE_GetTimerCloseRemainMin(void) // uint16_t BSP_VALVE_GetTimerCloseRemainMin(void)
{ // {
if (!gValveData.timer_close_enabled) // if (!gValveData.timer_close_enabled)
{ // {
return 0; // return 0;
} // }
uint32_t current_time = BSP_Get_Tick(); // uint32_t current_time = BSP_Get_Tick();
uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time; // uint32_t elapsed_ms = current_time - gValveData.timer_close_start_time;
uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000; // uint32_t timer_ms = (uint32_t)gValveData.timer_close_min * 60 * 1000;
if (elapsed_ms >= timer_ms) // if (elapsed_ms >= timer_ms)
{ // {
return 0; // return 0;
} // }
return (timer_ms - elapsed_ms) / (60 * 1000); // return (timer_ms - elapsed_ms) / (60 * 1000);
} // }