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

代码暂存 优化4G模组上报数据逻辑

This commit is contained in:
常正强 2025-06-04 09:42:05 +08:00
parent 7603947fd1
commit bcd00dd9b4
6 changed files with 179 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
APP/peripheral.c
View File

@ -443,7 +443,7 @@ static void Peripheral_ProcessGAPMsg(gapRoleEvent_t *pEvent)
LED_ALARM_Flag++; LED_ALARM_Flag++;
if(LED_ALARM_Flag > 2) if(LED_ALARM_Flag > 2)
{ {
LED_ALARM_OPEN; LED_VALVE_OPEN;
DelayMs(5); DelayMs(5);
LED_ALARM_Flag = 0; LED_ALARM_Flag = 0;
} }

4
APP/peripheral_main.c
View File

@ -110,8 +110,8 @@ int main(void)
BSP_VBAT_Init(); BSP_VBAT_Init();
logDebug("VBAT init ok\n"); logDebug("VBAT init ok\n");
// BSP_Ml307r_Init(); BSP_Ml307r_Init();
// logDebug("BSP_M1307r ok\n"); logDebug("BSP_M1307r ok\n");
ShowRestartReason(); ShowRestartReason();
IWDG_Init(5000); IWDG_Init(5000);

3
bsp/inc/bsp_valve.h
View File

@ -15,7 +15,6 @@
extern tmosTaskID vavle_task_id; extern tmosTaskID vavle_task_id;
#define VAVLE_RX_DATA_EVT (0x0001 << 0) #define VAVLE_RX_DATA_EVT (0x0001 << 0)
#define VAVLE_TX_DATA_EVT (0x0001 << 1) #define VAVLE_TX_DATA_EVT (0x0001 << 1)
@ -131,6 +130,8 @@ typedef struct __attribute__((packed))
} TsTimerCloseState; } TsTimerCloseState;
extern TsTimerCloseState gTimerCloseState; extern TsTimerCloseState gTimerCloseState;
extern TeFrameCmd gValveCloseReason;
extern TeFrameCmd gValveOpenReason;
uint8_t CheckSum(const uint8_t *data, size_t len); uint8_t CheckSum(const uint8_t *data, size_t len);

41
bsp/src/bsp_bmp390.c
View File

@ -433,12 +433,12 @@ void Lower_IO_Deinit(void)
GPIOB_ModeCfg(USIM_DECT_PIN, GPIO_ModeIN_PD); GPIOB_ModeCfg(USIM_DECT_PIN, GPIO_ModeIN_PD);
// motor // motor
// GPIOA_ResetBits(COIL_ADC); GPIOA_ResetBits(COIL_ADC);
// GPIOA_ModeCfg(COIL_ADC, GPIO_ModeIN_PD); GPIOA_ModeCfg(COIL_ADC, GPIO_ModeIN_PD);
// IN1 + ; IN2 + // IN1 + ; IN2 +
// GPIOB_SetBits(COIL_A); GPIOB_SetBits(COIL_A);
// GPIOB_SetBits(COIL_B); GPIOB_SetBits(COIL_B);
// GPIOB_ModeCfg(COIL_A | COIL_B, GPIO_ModeIN_PD); GPIOB_ModeCfg(COIL_A | COIL_B, GPIO_ModeIN_PD);
// UART3 // UART3
// GPIOB_ModeCfg(GPIO_Pin_21 | GPIO_Pin_20, GPIO_ModeIN_PD); // GPIOB_ModeCfg(GPIO_Pin_21 | GPIO_Pin_20, GPIO_ModeIN_PD);
@ -957,16 +957,16 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
stopAutoCloseTimer(); stopAutoCloseTimer();
} }
// 欠压检测 // 欠压检测
else if (ValveRawData.in_press <= ValveInfo.low_press) // else if (ValveRawData.in_press <= ValveInfo.low_press)
{ // {
BSP_VALVE_Close(kValveCmdUnderPressure); // 使用欠压关阀原因 // BSP_VALVE_Close(kValveCmdUnderPressure); // 使用欠压关阀原因
fault_state = 2; // fault_state = 2;
// 欠压关阀时停止延时关阀功能 // // 欠压关阀时停止延时关阀功能
stopAutoCloseTimer(); // stopAutoCloseTimer();
logError("******************************"); // logError("******************************");
logError("欠压关阀"); // logError("欠压关阀");
} // }
#if 1 #if 1
// 1、过流自动关闭： // 1、过流自动关闭：
// 进气端压力2kpa时，额定流量调到0.9 // 进气端压力2kpa时，额定流量调到0.9
@ -1093,19 +1093,6 @@ uint16_t Check_ProcessEvent(uint8_t task_id, uint16_t events)
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); return (events ^ CHECK_EVT_START);
} }
if (events & MOTOR_STOP_EVT)
{
VALVE_STOP();
logDebug("motor STOP");
// DelayMs(1500);
// if(fault_state == 4)
// {
// IotFlag_t.Valve_Close_flag = 1;
// Iot_Send_Data();
// }
return (events ^ MOTOR_STOP_EVT);
}
// 延时关阀检测事件处理 // 延时关阀检测事件处理
if (events & AUTO_CLOSE_CHECK_EVT) if (events & AUTO_CLOSE_CHECK_EVT)

384
bsp/src/bsp_ml307r.c
View File

@ -12,6 +12,8 @@
#include "time.h" #include "time.h"
#include <stdlib.h> #include <stdlib.h>
#include "cJSON.h" #include "cJSON.h"
#include "bsp_valve.h"
#include "bsp_adc.h"
#undef LOG_ENABLE #undef LOG_ENABLE
#define LOG_ENABLE 1 #define LOG_ENABLE 1
@ -95,7 +97,7 @@ static uint8_t state = 0;
#define CPIN_RETRY_INTERVAL_TIME (20*1000UL) #define CPIN_RETRY_INTERVAL_TIME (20*1000UL)
#define CONNECT_RETRY_INTERVAL_TIME (20*1000UL) #define CONNECT_RETRY_INTERVAL_TIME (20*1000UL)
#define SEND_RETRY_INTERVAL_TIME (30*1000UL) #define SEND_RETRY_INTERVAL_TIME (30*1000UL)
#define STOP_TASK_INTERVAL_TIME (15*1000UL) #define STOP_TASK_INTERVAL_TIME (10*1000UL)
#define LOOP_INTERVAL_TIME (30*1000UL) #define LOOP_INTERVAL_TIME (30*1000UL)
#define GETINFO_INTERVAL_TIME (20*1000UL) #define GETINFO_INTERVAL_TIME (20*1000UL)
@ -135,32 +137,32 @@ void Send_CallBack(MultiTimer* timer, void* userData)
IotFlag_t.send_error_flag = 1; IotFlag_t.send_error_flag = 1;
} }
//Loop回调 // //Loop回调
void Loop_CallBack(MultiTimer* timer, void* userData) // void Loop_CallBack(MultiTimer* timer, void* userData)
{ // {
state = 0; // state = 0;
IotFlag_t.Loop_count_flag++; // IotFlag_t.Loop_count_flag++;
IotFlag_t.module_init_flag = 1; // IotFlag_t.module_init_flag = 1;
IotFlag_t.Iot_Retry_flag = 0; // IotFlag_t.Iot_Retry_flag = 0;
} // }
//StopTask超时回调 //StopTask超时回调
void StopTask_CallBack(MultiTimer* timer, void* userData) void StopTask_CallBack(MultiTimer* timer, void* userData)
{ {
logDebug("BSP_Ml307_Power_Off\r\n"); logDebug("BSP_Ml307_Power_Off\r\n");
IotFlag_t.Loop_count_flag = 0; // IotFlag_t.Loop_count_flag = 0;
if(IotFlag_t.PowerOn_error_flag == 1) // if(IotFlag_t.PowerOn_error_flag == 1)
{ // {
IotFlag_t.PowerOn_error_flag = 0; IotFlag_t.PowerOn_error_flag = 0;
tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT); // tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT);
PFIC_DisableIRQ(UART1_IRQn); // PFIC_DisableIRQ(UART1_IRQn);
BSP_RequestSleep(); // BSP_RequestSleep();
}else{ // }else{
// BSP_Ml307_Power_Off(); //关机 // BSP_Ml307_Power_Off(); //关机
tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT); tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT);
PFIC_DisableIRQ(UART1_IRQn); PFIC_DisableIRQ(UART1_IRQn);
BSP_RequestSleep(); BSP_RequestSleep();
} // }
IotFlag_t.Date_Sending_flag = 0; IotFlag_t.Date_Sending_flag = 0;
} }
@ -521,7 +523,7 @@ static int BSP_Module_Connect_CtWing_Handle(at_env_t *e)
{ {
case 0: case 0:
logDebug("create device...\r\n"); logDebug("create device...\r\n");
e->println(e, "AT+MIPOPEN=0,\"TCP\",\"112.125.89.8\",42519,,1"); // 8.135.10.183,32994 e->println(e, "AT+MIPOPEN=0,\"TCP\",\"112.125.89.8\",46696,,1"); // 8.135.10.183,32994
e->reset_timer(e); e->reset_timer(e);
e->state++; e->state++;
break; break;
@ -570,55 +572,41 @@ typedef enum {
DEVICE_STATUS_LOW_BATTERY // 低电量状态 DEVICE_STATUS_LOW_BATTERY // 低电量状态
} device_status_t; } device_status_t;
// 创建基础JSON对象 // 定义JSON缓冲区大小
static cJSON* Create_Base_Json(void) #define JSON_BUFFER_SIZE 512
{
cJSON *root = cJSON_CreateObject();
if (root == NULL) {
logDebug("创建JSON对象失败\r\n");
return NULL;
}
// 创建设备信息对象 // 定义4G上报数据结构体
cJSON *device = cJSON_CreateObject(); typedef struct {
if (device == NULL) { char json_buffer[JSON_BUFFER_SIZE]; // JSON字符串缓冲区
cJSON_Delete(root); uint16_t length; // JSON字符串长度
return NULL; } Ts4GJsonData;
}
// 添加设备基本信息
cJSON_AddStringToObject(device, "id", "SCV001");
// 获取当前时间
char time_str[20];
sprintf(time_str, "%04d-%02d-%02d %02d:%02d:%02d",
Network_Time_t.tm_year, Network_Time_t.tm_mon, Network_Time_t.tm_mday,
Network_Time_t.tm_hour, Network_Time_t.tm_min, Network_Time_t.tm_sec);
cJSON_AddStringToObject(device, "time", time_str);
// 将设备信息添加到根对象
cJSON_AddItemToObject(root, "device", device);
// 添加标准信息
cJSON *standards = cJSON_CreateObject();
if (standards) {
char iot_id[32];
sprintf(iot_id, "IoT-SCV-%s", Module_Info_t.imei);
cJSON_AddStringToObject(standards, "iotId", iot_id);
cJSON_AddItemToObject(root, "standards", standards);
}
return root;
}
// 添加网络信息到JSON对象 /**
static void Add_Network_Info(cJSON *root) * @brief 生成4G模组上报的JSON数据
*
* @param p4GData JSON数据结构体指针
* @param cmd 命令类型，与蓝牙命令类型保持一致
* @return uint8_t 0表示成功
*/
uint8_t BSP_4G_Generate_JsonData(Ts4GJsonData *p4GData, TeFrameCmd cmd)
{ {
if (root == NULL) return; // 首先清零JSON缓冲区
memset(p4GData->json_buffer, 0, JSON_BUFFER_SIZE);
cJSON *network = cJSON_CreateObject();
if (network == NULL) return;
// 获取阀门数据
TsValveData ValveData;
// 填充阀门数据，与蓝牙上报相同
ValveData.switch_status = gValveData.switch_status;
ValveData.temp = ValveRawData.atom_temp;
ValveData.in_pressure = ValveRawData.in_press_raw;
ValveData.out_pressure = ValveRawData.out_press_raw;
ValveData.atm_pressure = ValveRawData.atom_press;
ValveData.type = kZbf;
ValveData.bat = BSP_ReadVbat();
ValveData.humi = 50;
ValveData.rssi = gValveData.rssi;
// 解析信号强度，这里简单处理为0-5的整数值 // 解析信号强度，这里简单处理为0-5的整数值
int signal_strength = 0; int signal_strength = 0;
long rssi = strtol(Service_Info_t.rssi, NULL, 16); long rssi = strtol(Service_Info_t.rssi, NULL, 16);
@ -627,144 +615,73 @@ static void Add_Network_Info(cJSON *root)
else if (rssi > -110) signal_strength = 3; else if (rssi > -110) signal_strength = 3;
else if (rssi > -120) signal_strength = 2; else if (rssi > -120) signal_strength = 2;
else if (rssi > -130) signal_strength = 1; else if (rssi > -130) signal_strength = 1;
// 解析信噪比 // 生成JSON字符串
float sinr = strtol(Service_Info_t.last_sinr, NULL, 16) / 10.0f; p4GData->length = snprintf(p4GData->json_buffer, JSON_BUFFER_SIZE,
"{"
cJSON_AddNumberToObject(network, "sinr", sinr); "\"cmd\":%d,"
cJSON_AddNumberToObject(network, "signal", signal_strength); "\"data\":{"
cJSON_AddItemToObject(root, "network", network); "\"switch_status\":%d,"
"\"temp\":%d,"
"\"in_pressure\":%d,"
"\"out_pressure\":%d,"
"\"atm_pressure\":%d,"
"\"type\":%d,"
"\"bat\":%d,"
"\"humi\":%d,"
"\"rssi\":%d,"
"\"signal\":%d"
"}"
"}",
cmd,
ValveData.switch_status,
ValveData.temp,
ValveData.in_pressure,
ValveData.out_pressure,
ValveData.atm_pressure,
ValveData.type,
ValveData.bat,
ValveData.humi,
ValveData.rssi,
signal_strength
);
// 打印JSON数据信息
logDebug("4G JSON数据 (cmd=%d):\r\n%s", cmd, p4GData->json_buffer);
return 0;
} }
// 添加常规状态信息到JSON对象 /**
static void Add_Normal_Status(cJSON *root) * @brief 生成4G模组响应JSON数据
*
* @param p4GData JSON数据结构体指针
* @param responseCmd 响应的命令类型
* @param result 响应结果，0成功，非0失败
* @return uint8_t 0表示成功
*/
uint8_t BSP_4G_Generate_Response(Ts4GJsonData *p4GData, TeFrameCmd responseCmd, uint8_t result)
{ {
if (root == NULL) return; p4GData->length = snprintf(p4GData->json_buffer, JSON_BUFFER_SIZE,
"{"
"\"cmd\":%d,"
"\"data\":{"
"\"response_cmd\":%d,"
"\"result\":%d"
"}"
"}",
kCmdData, // 使用数据命令作为响应命令
responseCmd,
result
);
logDebug("4G响应JSON数据:\r\n%s", p4GData->json_buffer);
// 添加状态信息 return 0;
cJSON_AddStringToObject(root, "status", "normal");
// 添加监控信息
cJSON *monitor = cJSON_CreateObject();
if (monitor) {
// 这里添加传感器数据，如压力值等
float pressure = 0.75; // 示例值，应从传感器获取
cJSON_AddNumberToObject(monitor, "pressure", pressure);
cJSON_AddBoolToObject(monitor, "lowVoltage", false);
cJSON_AddItemToObject(root, "monitor", monitor);
}
}
// 添加关闭状态信息到JSON对象
static void Add_Closed_Status(cJSON *root)
{
if (root == NULL) return;
// 添加状态信息
cJSON_AddStringToObject(root, "status", "closed");
// 添加监控信息
cJSON *monitor = cJSON_CreateObject();
if (monitor) {
float pressure = 0.0; // 阀门关闭时压力为0
cJSON_AddNumberToObject(monitor, "pressure", pressure);
cJSON_AddBoolToObject(monitor, "lowVoltage", false);
cJSON_AddItemToObject(root, "monitor", monitor);
}
}
// 添加故障状态信息到JSON对象
static void Add_Fault_Status(cJSON *root)
{
if (root == NULL) return;
// 添加状态信息
cJSON_AddStringToObject(root, "status", "fault");
// 添加故障信息
cJSON *fault = cJSON_CreateObject();
if (fault) {
cJSON_AddBoolToObject(fault, "lowBattery", false);
cJSON_AddNumberToObject(fault, "code", 1); // 故障代码
cJSON_AddItemToObject(root, "fault", fault);
}
// 添加监控信息
cJSON *monitor = cJSON_CreateObject();
if (monitor) {
float pressure = 0.8; // 示例值
cJSON_AddNumberToObject(monitor, "pressure", pressure);
cJSON_AddBoolToObject(monitor, "lowVoltage", false);
cJSON_AddItemToObject(root, "monitor", monitor);
}
}
// 添加低电量状态信息到JSON对象
static void Add_Low_Battery_Status(cJSON *root)
{
if (root == NULL) return;
// 添加状态信息
cJSON_AddStringToObject(root, "status", "warning");
// 添加故障信息
cJSON *fault = cJSON_CreateObject();
if (fault) {
cJSON_AddBoolToObject(fault, "lowBattery", true);
cJSON_AddNumberToObject(fault, "code", 2); // 低电量代码
cJSON_AddItemToObject(root, "fault", fault);
}
// 添加监控信息
cJSON *monitor = cJSON_CreateObject();
if (monitor) {
float pressure = 0.78; // 示例值
cJSON_AddNumberToObject(monitor, "pressure", pressure);
cJSON_AddBoolToObject(monitor, "lowVoltage", true);
cJSON_AddItemToObject(root, "monitor", monitor);
}
}
// 根据设备状态构建JSON数据
static char* Build_Status_Json(device_status_t status)
{
// 创建基础JSON结构
cJSON *root = Create_Base_Json();
if (root == NULL) {
return NULL;
}
// 根据状态添加不同的信息
switch (status) {
case DEVICE_STATUS_NORMAL:
Add_Normal_Status(root);
break;
case DEVICE_STATUS_CLOSED:
Add_Closed_Status(root);
break;
case DEVICE_STATUS_FAULT:
Add_Fault_Status(root);
break;
case DEVICE_STATUS_LOW_BATTERY:
Add_Low_Battery_Status(root);
break;
default:
Add_Normal_Status(root);
break;
}
// 添加网络信息
Add_Network_Info(root);
// 将JSON转换为字符串
char *json_string = cJSON_PrintUnformatted(root);
// 释放JSON对象
cJSON_Delete(root);
return json_string;
} }
// 全局JSON数据结构体
Ts4GJsonData g4GJsonData;
char *json_data; char *json_data;
static int SendMessage(at_env_t *e) static int SendMessage(at_env_t *e)
@ -773,7 +690,7 @@ static int SendMessage(at_env_t *e)
{ {
case 0: case 0:
logDebug("SendMessage start!\r\n"); logDebug("SendMessage start!\r\n");
e->println(e, "AT+MIPSEND=0,%d,\"%s\"",strlen(json_data),json_data); e->println(e, "AT+MIPSEND=0,%d,\"%s\"", strlen(json_data), json_data);
e->reset_timer(e); e->reset_timer(e);
e->state++; e->state++;
break; break;
@ -782,6 +699,9 @@ static int SendMessage(at_env_t *e)
{ {
logDebug("SendMessage end!\r\n"); logDebug("SendMessage end!\r\n");
IotFlag_t.send_complete_flag = 1; IotFlag_t.send_complete_flag = 1;
// 发送完成后释放json_data内存
tmos_msg_deallocate((uint8_t *)json_data);
json_data = NULL;
e->finish(e, AT_RESP_OK); e->finish(e, AT_RESP_OK);
} }
if (e->is_timeout(e, 5000)) if (e->is_timeout(e, 5000))
@ -791,6 +711,9 @@ static int SendMessage(at_env_t *e)
{ {
logDebug("SendMessage error!\r\n"); logDebug("SendMessage error!\r\n");
IotFlag_t.send_complete_flag = 1; IotFlag_t.send_complete_flag = 1;
// 发送失败也需要释放json_data内存
tmos_msg_deallocate((uint8_t *)json_data);
json_data = NULL;
e->finish(e, AT_RESP_ERROR); e->finish(e, AT_RESP_ERROR);
} }
} }
@ -807,34 +730,29 @@ static void BSP_SendMessage(void)
void BSP_ML307_SendMessage(void) void BSP_ML307_SendMessage(void)
{ {
// 根据系统状态确定设备状态 // 根据系统状态确定命令类型
device_status_t device_status; TeFrameCmd cmd = kCmdData; // 默认为数据命令
// // 这里根据实际系统状态判断逻辑进行修改
// if (fault_state) {
// device_status = DEVICE_STATUS_FAULT;
// } else {
// // 检查其他状态，例如电池电量等
// // 这里可以添加更多状态检测逻辑
// device_status = DEVICE_STATUS_NORMAL;
// }
if (gValveData.switch_status == kClosed)
if(IotFlag_t.Valve_Close_flag)
{ {
IotFlag_t.Valve_Close_flag = 0; cmd = gValveCloseReason;
device_status = DEVICE_STATUS_CLOSED; }else
{
cmd = gValveOpenReason;
} }
// 生成JSON数据
BSP_4G_Generate_JsonData(&g4GJsonData, cmd);
// 分配内存并复制JSON字符串
// 构建JSON数据 json_data = (char *)tmos_msg_allocate(g4GJsonData.length + 1);
json_data = Build_Status_Json(device_status);
if (json_data != NULL) { if (json_data != NULL) {
logDebug("json_data len %d\r\n",strlen(json_data)); strcpy(json_data, g4GJsonData.json_buffer);
logDebug("json_data len %d\r\n", strlen(json_data));
BSP_SendMessage(); BSP_SendMessage();
} else { } else {
logDebug("Build_Status_Json error!\n"); logDebug("JSON数据内存分配失败!\n");
IotFlag_t.send_error_flag = 1; IotFlag_t.send_error_flag = 1;
} }
} }
@ -922,7 +840,7 @@ static int Module_Restart_Work(at_env_t *e)
e->reset_timer(e); e->reset_timer(e);
e->state++; e->state++;
} }
if (e->is_timeout(e, 5000)) if (e->is_timeout(e, 1500))
{ {
e->state--; e->state--;
if (++e->i > 3) if (++e->i > 3)
@ -986,7 +904,7 @@ static int simcom_init(at_env_t *e)
logDebug("simcom CPIN READY!\r\n"); logDebug("simcom CPIN READY!\r\n");
e->finish(e, AT_RESP_OK); e->finish(e, AT_RESP_OK);
} }
if (e->is_timeout(e, 5000)) if (e->is_timeout(e, 3000))
{ {
e->state--; e->state--;
if (++e->i > 3) if (++e->i > 3)
@ -1142,26 +1060,30 @@ static void BSP_Iot_Loop(void)
logDebug("send_complete_into_stop\r\n"); logDebug("send_complete_into_stop\r\n");
IotFlag_t.send_complete_flag = 0; IotFlag_t.send_complete_flag = 0;
state = 0; state = 0;
tmos_msg_deallocate((uint8_t *)json_data); // 检查指针是否为NULL后再释放，避免重复释放
if(json_data != NULL) {
tmos_msg_deallocate((uint8_t *)json_data);
json_data = NULL;
}
MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL); //关闭 MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL); //关闭
}else }else
{ {
if (IotFlag_t.Loop_count_flag > 2) // if (IotFlag_t.Loop_count_flag > 2)
{ // {
logDebug("Loop_count_flag_end %d\r\n",IotFlag_t.Loop_count_flag); // logDebug("Loop_count_flag_end %d\r\n",IotFlag_t.Loop_count_flag);
state = 0; state = 0;
IotFlag_t.Iot_Retry_flag = 0; IotFlag_t.Iot_Retry_flag = 0;
IotFlag_t.module_init_flag = 0; IotFlag_t.module_init_flag = 0;
MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL); MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL);
} // }
if((IotFlag_t.Iot_Retry_flag == 0)&&(IotFlag_t.Loop_count_flag < 3)) // if((IotFlag_t.Iot_Retry_flag == 0)&&(IotFlag_t.Loop_count_flag < 3))
{ // {
logDebug("error_into_loop\r\n"); // logDebug("error_into_loop\r\n");
logDebug("Loop_count_flag %d\r\n",IotFlag_t.Loop_count_flag); // logDebug("Loop_count_flag %d\r\n",IotFlag_t.Loop_count_flag);
BSP_Ml307_Power_Off(); //关机 // BSP_Ml307_Power_Off(); //关机
MultiTimerStart(&Multi_Loop_t, LOOP_INTERVAL_TIME, Loop_CallBack, NULL); // MultiTimerStart(&Multi_Loop_t, LOOP_INTERVAL_TIME, Loop_CallBack, NULL);
IotFlag_t.Iot_Retry_flag = 1; // IotFlag_t.Iot_Retry_flag = 1;
} // }
} }
break; break;
} }

9
bsp/src/bsp_valve.c
View File

@ -20,6 +20,7 @@
#include "bsp_led.h" #include "bsp_led.h"
#include "bsp_bmp390.h" #include "bsp_bmp390.h"
#include "bsp_tim.h" #include "bsp_tim.h"
#include "bsp_ml307r.h"
#undef LOG_ENABLE #undef LOG_ENABLE
#define LOG_ENABLE 1 #define LOG_ENABLE 1
@ -30,8 +31,8 @@
TsValveData gValveData = {0}; TsValveData gValveData = {0};
TsRawFrameData RelyData; TsRawFrameData RelyData;
TsTimerCloseState gTimerCloseState = {0}; TsTimerCloseState gTimerCloseState = {0};
static TeFrameCmd gValveCloseReason = kCmdCloseVavle; // 默认为普通关阀命令 TeFrameCmd gValveCloseReason = kCmdCloseVavle; // 默认为普通关阀命令
static TeFrameCmd gValveOpenReason = kCmdOpenVavle; // 默认为普通开阀命令 TeFrameCmd gValveOpenReason = kCmdOpenVavle; // 默认为普通开阀命令
tmosTaskID vavle_task_id = INVALID_TASK_ID; tmosTaskID vavle_task_id = INVALID_TASK_ID;
@ -325,6 +326,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
logDebug("VAVLE_CLOSE_START_EVT"); logDebug("VAVLE_CLOSE_START_EVT");
BSP_BlockSleep(); BSP_BlockSleep();
BSP_MOTOR_Init();
LED_VALVE_CLOSE; LED_VALVE_CLOSE;
// DelayUs(200); // DelayUs(200);
@ -365,6 +367,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
BSP_RequestSleep(); BSP_RequestSleep();
logDebug("VAVLE_CLOSE_END_EVT"); logDebug("VAVLE_CLOSE_END_EVT");
Iot_Send_Data();
return (events ^ VAVLE_CLOSE_END_EVT); return (events ^ VAVLE_CLOSE_END_EVT);
} }
@ -373,6 +376,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
logDebug("VAVLE_OPEN_START_EVT"); logDebug("VAVLE_OPEN_START_EVT");
BSP_BlockSleep(); BSP_BlockSleep();
BSP_MOTOR_Init();
LED_VALVE_OPEN; LED_VALVE_OPEN;
// DelayUs(200); // DelayUs(200);
@ -416,6 +420,7 @@ static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events) // 阀
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT); tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
BSP_RequestSleep(); BSP_RequestSleep();
Iot_Send_Data();
// 启动微泄漏检测 // 启动微泄漏检测
startMicroLeakDetection(); startMicroLeakDetection();