SXDT-Embedded
/
BLE_TYQ_BJQ_CH32V303
mirror of https://gitee.com/SXDT-Embedded/ble_-tyq_-bjq_-ch32-v303.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

暂存

This commit is contained in:
小马_666 2025-05-29 08:55:08 +08:00
parent 1b566c8281
commit 2b9a2d0c32
2 changed files with 369 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

413
applications/main.c
View File

@ -45,12 +45,12 @@ struct rt_timer preheat_timer; // 传统模式需要进行预热，
uint8_t preheat_flag = 0; // 预热时间是否结束标志 uint8_t preheat_flag = 0; // 预热时间是否结束标志
uint8_t Calibration_flag = 0;//查看是否在标定检测状态 uint8_t Calibration_flag = 0; // 查看是否在标定检测状态
void Send_Laser_Alarm_Event(AlarmEvent event_type); void Send_Laser_Alarm_Event (AlarmEvent event_type);
TeCalibrationStatus g_Calibration_status = kNotCalibrated; TeCalibrationStatus g_Calibration_status = kNotCalibrated;
static void Set_Event(AlarmEvent event_type) static void Set_Event (AlarmEvent event_type)
{ {
if (event_type < kMaxEventcnt) if (event_type < kMaxEventcnt)
{ {
@ -58,28 +58,28 @@ static void Set_Event(AlarmEvent event_type)
} }
} }
void SYS_EventInit(void) void SYS_EventInit (void)
{ {
if (!is_event_initialized) if (!is_event_initialized)
{ {
if (rt_event_init(&alarm_event, "alarm_event", RT_IPC_FLAG_PRIO) == RT_EOK) if (rt_event_init (&alarm_event, "alarm_event", RT_IPC_FLAG_PRIO) == RT_EOK)
{ {
for (AlarmEvent event = kPowerOnEvent; event < kMaxEventcnt; event++) for (AlarmEvent event = kPowerOnEvent; event < kMaxEventcnt; event++)
{ {
Set_Event(event); Set_Event (event);
} }
is_event_initialized = RT_TRUE; is_event_initialized = RT_TRUE;
} }
else else
{ {
is_event_initialized = RT_FALSE; is_event_initialized = RT_FALSE;
LOG_E("Alarm event init failed!"); LOG_E ("Alarm event init failed!");
} }
} }
} }
rt_uint32_t Get_Sys_Event_Flag(AlarmEvent event_type) rt_uint32_t Get_Sys_Event_Flag (AlarmEvent event_type)
{ {
if (is_event_initialized == RT_TRUE) if (is_event_initialized == RT_TRUE)
{ {
@ -91,78 +91,78 @@ rt_uint32_t Get_Sys_Event_Flag(AlarmEvent event_type)
return kMaxEventcnt; return kMaxEventcnt;
} }
void Send_Laser_Alarm_Event(AlarmEvent event_type) void Send_Laser_Alarm_Event (AlarmEvent event_type)
{ {
if (is_event_initialized == RT_TRUE) if (is_event_initialized == RT_TRUE)
{ {
if (SysControl.status == kPowerDownEvent) if (SysControl.status == kPowerDownEvent)
{ {
LOG_D("掉电模式下不处理其他事件"); LOG_D ("掉电模式下不处理其他事件");
} }
else else
{ {
LOG_I("Send_Laser_Alarm_Event = %d", event_type); LOG_I ("Send_Laser_Alarm_Event = %d", event_type);
rt_event_send(&alarm_event, Get_Sys_Event_Flag(event_type)); rt_event_send (&alarm_event, Get_Sys_Event_Flag (event_type));
} }
} }
else else
{ {
is_event_initialized = RT_FALSE; is_event_initialized = RT_FALSE;
LOG_E("Alarm event no init !"); LOG_E ("Alarm event no init !");
} }
} }
int _Self_Check_Mode(void) int _Self_Check_Mode (void)
{ {
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
rt_thread_mdelay(500); rt_thread_mdelay (500);
LED_CTRL(g, "500,2500", -1); LED_CTRL (g, "500,2500", -1);
LED_START(g); LED_START (g);
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
LED_CTRL(y, "500,2500", -1); LED_CTRL (y, "500,2500", -1);
LED_START(y); LED_START (y);
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
LED_CTRL(r, "500,2500", -1); LED_CTRL (r, "500,2500", -1);
LED_START(r); LED_START (r);
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
BEEP_SELF_CHECK; BEEP_SELF_CHECK;
return RT_EOK; return RT_EOK;
} }
void Work_Cnt_Timer_Callback(void *parameter) void Work_Cnt_Timer_Callback (void *parameter)
{ {
work_duration++; work_duration++;
if (IS_EndOfLife()) // 每小时检测一下是否过期 if (IS_EndOfLife()) // 每小时检测一下是否过期
{ {
if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0) if (Flash_GetNum_Records (kRecordSensoEndOfLife) == 0)
{ {
Flash_Write_Record(kRecordSensoEndOfLife); Flash_Write_Record (kRecordSensoEndOfLife);
} }
Send_Laser_Alarm_Event(kSensorFailureEvent); Send_Laser_Alarm_Event (kSensorFailureEvent);
} }
} }
void Preheat_Timer_Callback(void *parameter) void Preheat_Timer_Callback (void *parameter)
{ {
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
LOG_D("预热完成"); LOG_D ("预热完成");
preheat_flag = 1; preheat_flag = 1;
if (g_Calibration_status == kSysGasCalibStatus) if (g_Calibration_status == kSysGasCalibStatus)
{ {
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
} }
else else
{ {
Send_Laser_Alarm_Event(kCalibrationEvent); Send_Laser_Alarm_Event (kCalibrationEvent);
} }
} }
int APP_Calibration_Handle(void) int APP_Calibration_Handle (void)
{ {
uint8_t i = 0; uint8_t i = 0;
uint16_t gas_buf[10] = {0}; uint16_t gas_buf[10] = {0};
@ -178,18 +178,18 @@ int APP_Calibration_Handle(void)
// } // }
if (Get_Gas_VoltageAdcInt1000x() > (MQ_VOLTAGE_ALARM_DEFAULT - 1500) && Get_Gas_VoltageAdcInt1000x() < (MQ_VOLTAGE_ALARM_DEFAULT + 1000)) if (Get_Gas_VoltageAdcInt1000x() > (MQ_VOLTAGE_ALARM_DEFAULT - 1500) && Get_Gas_VoltageAdcInt1000x() < (MQ_VOLTAGE_ALARM_DEFAULT + 1000))
{ {
LOG_D("标定开始"); LOG_D ("标定开始");
LED_OFF(g); LED_OFF (g);
LED_OFF(y); LED_OFF (y);
LED_OFF(r); LED_OFF (r);
LED_CTRL(y, "200,200", -1); LED_CTRL (y, "200,200", -1);
LED_START(y); LED_START (y);
} }
else else
{ {
g_Calibration_status = kNotCalibrated; g_Calibration_status = kNotCalibrated;
LOG_D("没有气体,请重新上电标定"); LOG_D ("没有气体,请重新上电标定");
Send_Laser_Alarm_Event(kNotCalibratedEvent); Send_Laser_Alarm_Event (kNotCalibratedEvent);
return 0; return 0;
} }
Calibration_flag = 1; Calibration_flag = 1;
@ -203,7 +203,7 @@ int APP_Calibration_Handle(void)
return 0; return 0;
} }
gas_calibration_voltage |= gas_buf[i]; gas_calibration_voltage |= gas_buf[i];
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
} }
if (i == 10) if (i == 10)
{ {
@ -211,25 +211,25 @@ int APP_Calibration_Handle(void)
uint8_t calibration_buf[2] = {0}; uint8_t calibration_buf[2] = {0};
calibration_buf[0] = gas_calibration_voltage & 0xFF; // 低字节 calibration_buf[0] = gas_calibration_voltage & 0xFF; // 低字节
calibration_buf[1] = (gas_calibration_voltage >> 8) & 0xFF; // 高字节 calibration_buf[1] = (gas_calibration_voltage >> 8) & 0xFF; // 高字节
LOG_D("calibration_buf[0] = %X calibration_buf[1] = %X", calibration_buf[0], calibration_buf[1]); LOG_D ("calibration_buf[0] = %X calibration_buf[1] = %X", calibration_buf[0], calibration_buf[1]);
Flash_Sys_Cfg(kAlarmLValueId, calibration_buf, 2); Flash_Sys_Cfg (kAlarmLValueId, calibration_buf, 2);
LOG_D("标定完成"); LOG_D ("标定完成");
Calibration_flag = 0; Calibration_flag = 0;
Flash_Set_Calibration_State(kSysGasCalibStatus); Flash_Set_Calibration_State (kSysGasCalibStatus);
g_Calibration_status = kSysGasCalibStatus; g_Calibration_status = kSysGasCalibStatus;
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
return 0; return 0;
} }
else else
{ {
LOG_E("标定错误"); LOG_E ("标定错误");
return -1; return -1;
} }
} }
} }
int main(void) int main (void)
{ {
// 定义超时时间，单位为毫秒 // 定义超时时间，单位为毫秒
#define TIMEOUT_MS (3 * 60 * 1000) #define TIMEOUT_MS (3 * 60 * 1000)
@ -240,14 +240,14 @@ int main(void)
SYS_EventInit(); SYS_EventInit();
BSP_SYS_Init(); BSP_SYS_Init();
work_duration = Flash_Get_WorkDuration(); work_duration = Flash_Get_WorkDuration();
LOG_D("工作时长：%d", work_duration); LOG_D ("工作时长：%d", work_duration);
// 读取历史记录总数 // 读取历史记录总数
g_Calibration_status = Flash_Get_Calibration_State(); g_Calibration_status = Flash_Get_Calibration_State();
rt_thread_mdelay(10); rt_thread_mdelay (10);
} }
else else
{ {
LOG_D("欠压复位\r\n"); LOG_D ("欠压复位\r\n");
RCC_ClearFlag(); RCC_ClearFlag();
NVIC_SystemReset(); // 直接重启系统 NVIC_SystemReset(); // 直接重启系统
} }
@ -258,74 +258,74 @@ int main(void)
rt_uint32_t received_event; rt_uint32_t received_event;
TuFlashProductTimeLimitFrame LimitTime; TuFlashProductTimeLimitFrame LimitTime;
if (Flash_GetProductTimeLimit(&LimitTime, kExpirationTimeId) == READY) if (Flash_GetProductTimeLimit (&LimitTime, kExpirationTimeId) == READY)
{ {
// 计算出 到期时间对应的RTC秒数 // 计算出 到期时间对应的RTC秒数
Sensor_device.expiration_seconds = DateTime2Seconds(LimitTime.Struct.year, Sensor_device.expiration_seconds = DateTime2Seconds (LimitTime.Struct.year,
LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.hour, LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.hour,
LimitTime.Struct.minute, LimitTime.Struct.second); LimitTime.Struct.minute, LimitTime.Struct.second);
LOG_D("h308_expiration_time:%04d-%02d-%02d,%02d:%02d", LOG_D ("h308_expiration_time:%04d-%02d-%02d,%02d:%02d",
LimitTime.Struct.year, LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.year, LimitTime.Struct.month, LimitTime.Struct.day,
LimitTime.Struct.hour, LimitTime.Struct.minute, LimitTime.Struct.second); LimitTime.Struct.hour, LimitTime.Struct.minute, LimitTime.Struct.second);
} }
rt_timer_init(&work_cnt_timer, rt_timer_init (&work_cnt_timer,
"work_cnt_timer", "work_cnt_timer",
Work_Cnt_Timer_Callback, Work_Cnt_Timer_Callback,
RT_NULL, RT_NULL,
WORK_TIMER_CNT, WORK_TIMER_CNT,
RT_TIMER_FLAG_PERIODIC); RT_TIMER_FLAG_PERIODIC);
rt_timer_start(&work_cnt_timer); rt_timer_start (&work_cnt_timer);
rt_timer_init(&preheat_timer, rt_timer_init (&preheat_timer,
"preheat_timer", "preheat_timer",
Preheat_Timer_Callback, Preheat_Timer_Callback,
RT_NULL, RT_NULL,
TIMEOUT_MS, TIMEOUT_MS,
RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT); RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
// 检测上电/掉电复位标志 // 检测上电/掉电复位标志
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET) // TODO:这块超级电容会造成掉电重启，并且标志是上电复位，只能通过其超级电容造成复位时事件创建失败进行判断，不治本 if (RCC_GetFlagStatus (RCC_FLAG_PORRST) != RESET) // TODO:这块超级电容会造成掉电重启，并且标志是上电复位，只能通过其超级电容造成复位时事件创建失败进行判断，不治本
{ {
Send_Laser_Alarm_Event(kPowerOnEvent); Send_Laser_Alarm_Event (kPowerOnEvent);
} }
else else
{ {
Send_Laser_Alarm_Event(kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式 Send_Laser_Alarm_Event (kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式
} }
RCC_ClearFlag(); RCC_ClearFlag();
while (1) while (1)
{ {
result = rt_event_recv(&alarm_event, result = rt_event_recv (&alarm_event,
Get_Sys_Event_Flag(kPowerOnEvent) | // 上电 Get_Sys_Event_Flag (kPowerOnEvent) | // 上电
Get_Sys_Event_Flag(kPowerDownEvent) | // 掉电 Get_Sys_Event_Flag (kPowerDownEvent) | // 掉电
Get_Sys_Event_Flag(kPreheatingEvent) | // 预热 Get_Sys_Event_Flag (kPreheatingEvent) | // 预热
Get_Sys_Event_Flag(kNormalDetectionEvents) | // 正常检测 Get_Sys_Event_Flag (kNormalDetectionEvents) | // 正常检测
Get_Sys_Event_Flag(kSensorFailureEvent) | // 寿命到期 Get_Sys_Event_Flag (kSensorFailureEvent) | // 寿命到期
Get_Sys_Event_Flag(kAlarmEvent) | // 报警 Get_Sys_Event_Flag (kAlarmEvent) | // 报警
Get_Sys_Event_Flag(kAlarmRcyEvent) | // 报警恢复 Get_Sys_Event_Flag (kAlarmRcyEvent) | // 报警恢复
Get_Sys_Event_Flag(kSelfCheckEvent) | // 自检 Get_Sys_Event_Flag (kSelfCheckEvent) | // 自检
Get_Sys_Event_Flag(kFaultEvent) | // 故障模式 Get_Sys_Event_Flag (kFaultEvent) | // 故障模式
Get_Sys_Event_Flag(kFaultRcyEvent) | // 故障恢复 Get_Sys_Event_Flag (kFaultRcyEvent) | // 故障恢复
Get_Sys_Event_Flag(KMuteEvent) | // 消音 Get_Sys_Event_Flag (KMuteEvent) | // 消音
Get_Sys_Event_Flag(kCalibrationEvent) | // 标定 Get_Sys_Event_Flag (kCalibrationEvent) | // 标定
Get_Sys_Event_Flag(kNotCalibratedEvent), // 标定 Get_Sys_Event_Flag (kNotCalibratedEvent), // 标定
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &received_event); RT_WAITING_FOREVER, &received_event);
if (result == RT_EOK) if (result == RT_EOK)
{ {
if (is_event_initialized == RT_TRUE) if (is_event_initialized == RT_TRUE)
{ {
if (received_event & Get_Sys_Event_Flag(kPowerOnEvent)) // 上电 if (received_event & Get_Sys_Event_Flag (kPowerOnEvent)) // 上电
{ {
LOG_D("上电模式"); LOG_D ("上电模式");
LOG_D("is_event_initialized :%d", is_event_initialized); LOG_D ("is_event_initialized :%d", is_event_initialized);
SysControl.status = kPowerOnEvent; SysControl.status = kPowerOnEvent;
Flash_Write_Record(kRecordPowerOn); Flash_Write_Record (kRecordPowerOn);
Send_Laser_Alarm_Event(kPreheatingEvent); Send_Laser_Alarm_Event (kPreheatingEvent);
} }
else if (received_event & Get_Sys_Event_Flag(kPreheatingEvent)) // 预热 else if (received_event & Get_Sys_Event_Flag (kPreheatingEvent)) // 预热
{ {
LOG_D("预热模式"); LOG_D ("预热模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kPreheatingEvent; SysControl.status = kPreheatingEvent;
@ -333,36 +333,36 @@ int main(void)
if (SysControl.last_status != kSelfCheckEvent) if (SysControl.last_status != kSelfCheckEvent)
{ {
LED_G_PREAT; LED_G_PREAT;
rt_timer_start(&preheat_timer); rt_timer_start (&preheat_timer);
} }
else else
{ {
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
LED_CTRL(g, "100,100", -1); LED_CTRL (g, "100,100", -1);
LED_START(g); LED_START (g);
} }
} }
else if (received_event & Get_Sys_Event_Flag(kCalibrationEvent)) // 标定状态 else if (received_event & Get_Sys_Event_Flag (kCalibrationEvent)) // 标定状态
{ {
LOG_D("标定检测"); LOG_D ("标定检测");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kCalibrationEvent; SysControl.status = kCalibrationEvent;
APP_Calibration_Handle(); APP_Calibration_Handle();
} }
else if (received_event & Get_Sys_Event_Flag(kNotCalibratedEvent)) // 未标定状态 else if (received_event & Get_Sys_Event_Flag (kNotCalibratedEvent)) // 未标定状态
{ {
LOG_D("未标定模式"); LOG_D ("未标定模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kNotCalibratedEvent; SysControl.status = kNotCalibratedEvent;
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
LED_ON(r); LED_ON (r);
} }
else if (received_event & Get_Sys_Event_Flag(kNormalDetectionEvents)) // 正常检测 else if (received_event & Get_Sys_Event_Flag (kNormalDetectionEvents)) // 正常检测
{ {
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kNormalDetectionEvents; SysControl.status = kNormalDetectionEvents;
@ -371,194 +371,197 @@ int main(void)
{ {
if ((voltage > Sensor_device.alarm_value) && (voltage < MQ_VOLTAGE_HIGH_LIMIT)) if ((voltage > Sensor_device.alarm_value) && (voltage < MQ_VOLTAGE_HIGH_LIMIT))
{ {
Send_Laser_Alarm_Event(kAlarmEvent); Send_Laser_Alarm_Event (kAlarmEvent);
} }
} }
else if (Sensor_device.detection_flag == kSensorFault) else if (Sensor_device.detection_flag == kSensorFault)
{ {
if ((voltage < MQ_VOLTAGE_LOW_LIMIT) || (voltage > MQ_VOLTAGE_HIGH_LIMIT)) if ((voltage < MQ_VOLTAGE_LOW_LIMIT) || (voltage > MQ_VOLTAGE_HIGH_LIMIT))
{ {
Send_Laser_Alarm_Event(kFaultEvent); Send_Laser_Alarm_Event (kFaultEvent);
} }
} }
} }
else if (received_event & Get_Sys_Event_Flag(kAlarmExceptionEvent)) // 浓度异常 else if (received_event & Get_Sys_Event_Flag (kAlarmExceptionEvent)) // 浓度异常
{ {
LOG_D("浓度异常模式"); LOG_D ("浓度异常模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kAlarmExceptionEvent; SysControl.status = kAlarmExceptionEvent;
LED_R_ALARM; LED_R_ALARM;
LOG_D("LED_R_ALARM"); LOG_D ("LED_R_ALARM");
} }
else if (received_event & Get_Sys_Event_Flag(kAlarmEvent)) // 报警 else if (received_event & Get_Sys_Event_Flag (kAlarmEvent)) // 报警
{ {
LOG_D("报警模式"); LOG_D ("报警模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kAlarmEvent; SysControl.status = kAlarmEvent;
LED_R_ALARM; LED_R_ALARM;
BEEP_ALARM; BEEP_ALARM;
LOG_I("报警机械手动作"); LOG_I ("报警机械手动作");
EMV_FORWARD_ON(50); EMV_FORWARD_ON (50);
rt_thread_mdelay(10); rt_thread_mdelay (10);
EMV_BACKWARD_ON(50); EMV_BACKWARD_ON (50);
Flash_Write_Record(kRecordAlarm); // 写入flash报警信息 Flash_Write_Record (kRecordAlarm); // 写入flash报警信息
if (Flash_Get_Valve_Num()) if (Flash_Get_Valve_Num())
{ {
rt_uint8_t mac_addr[6]; rt_uint8_t mac_addr[6];
Flash_Get_Mac_Addr(mac_addr, 1); Flash_Get_Mac_Addr (mac_addr, 1);
Bt_Valve_Handler(kValveCmdCtr, 1, mac_addr); Bt_Valve_Handler (kValveCmdCtr, 1, mac_addr);
if (rt_sem_take(&bt_ctr_sem, 10000) == RT_EOK) if (rt_sem_take (&bt_ctr_sem, 10000) == RT_EOK)
{ {
LOG_D("电磁阀动作完成"); LOG_D ("电磁阀动作完成");
} }
else else
{ {
LOG_E("电磁阀动作失败"); LOG_E ("电磁阀动作失败");
} }
} }
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307AlarmEvent); Ml307_Send_Event (kMl307AlarmEvent);
#endif #endif
} }
else if (received_event & Get_Sys_Event_Flag(kAlarmRcyEvent)) // 报警恢复 else if (received_event & Get_Sys_Event_Flag (kAlarmRcyEvent)) // 报警恢复
{ {
LOG_D("报警恢复模式"); LOG_D ("报警恢复模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kAlarmRcyEvent; SysControl.status = kAlarmRcyEvent;
Flash_Write_Record(kRecordAlarmRcy); Flash_Write_Record (kRecordAlarmRcy);
BEEP_STOP; BEEP_STOP;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307AlarmRcyEvent); Ml307_Send_Event (kMl307AlarmRcyEvent);
#endif #endif
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
} }
else if (received_event & Get_Sys_Event_Flag(kFaultEvent)) // 故障 else if (received_event & Get_Sys_Event_Flag (kFaultEvent)) // 故障
{ {
LOG_D("故障模式"); LOG_D ("故障模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kFaultEvent; SysControl.status = kFaultEvent;
Flash_Write_Record(kRecordFault); Flash_Write_Record (kRecordFault);
LED_Y_FAULT; LED_Y_FAULT;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307FaultEvent); Ml307_Send_Event (kMl307FaultEvent);
#endif #endif
} }
else if (received_event & Get_Sys_Event_Flag(kFaultRcyEvent)) // 故障恢复 else if (received_event & Get_Sys_Event_Flag (kFaultRcyEvent)) // 故障恢复
{ {
LOG_D("故障恢复模式"); LOG_D ("故障恢复模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kFaultRcyEvent; SysControl.status = kFaultRcyEvent;
Flash_Write_Record(kRecordFaultRcy); Flash_Write_Record (kRecordFaultRcy);
BEEP_STOP; BEEP_STOP;
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307FaultRcyEvent); Ml307_Send_Event (kMl307FaultRcyEvent);
#endif #endif
} }
else if (received_event & Get_Sys_Event_Flag(KMuteEvent)) // 消音 else if (received_event & Get_Sys_Event_Flag (KMuteEvent)) // 消音
{ {
LOG_D("消音模式"); LOG_D ("消音模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = KMuteEvent; SysControl.status = KMuteEvent;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307SilenceEvent); Ml307_Send_Event (kMl307SilenceEvent);
#endif #endif
BEEP_STOP; BEEP_STOP;
} }
else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电 else if (received_event & Get_Sys_Event_Flag (kPowerDownEvent)) // 掉电
{ {
LOG_D("掉电模式"); LOG_D ("掉电模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kPowerDownEvent; SysControl.status = kPowerDownEvent;
GAS_POWER_CLOSE; GAS_POWER_CLOSE;
// 写入掉电记录 // 写入掉电记录
Flash_Write_Record(kRecordPowerDown); Flash_Write_Record (kRecordPowerDown);
Flash_Set_WorkDuration(work_duration); // 写入工作时长 Flash_Set_WorkDuration (work_duration); // 写入工作时长
if (Flash_Get_Valve_Num()) if (Flash_Get_Valve_Num())
{ {
rt_uint8_t mac_addr[6]; rt_uint8_t mac_addr[6];
Flash_Get_Mac_Addr(mac_addr, 1); Flash_Get_Mac_Addr (mac_addr, 1);
Bt_Valve_Handler(kValveCmdCtr, 1, mac_addr); Bt_Valve_Handler (kValveCmdCtr, 1, mac_addr);
if (rt_sem_take(&bt_ctr_sem, 5000) == RT_EOK) }
#if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event (kMl307PowerDownEvent);
#endif
if (Flash_Get_Valve_Num())
{ {
LOG_D("电磁阀动作完成"); if (rt_sem_take (&bt_ctr_sem, 5000) == RT_EOK)
{
LOG_D ("电磁阀动作完成");
} }
else else
{ {
LOG_E("电磁阀动作失败"); LOG_E ("电磁阀动作失败");
} }
} }
#if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307PowerDownEvent);
#endif
rt_uint8_t cnt = 0; rt_uint8_t cnt = 0;
while ((ml307_power_down_flag == 0) && (cnt < 60)) // 等待接收到物联网模组关机完成 while ((ml307_power_down_flag == 0) && (cnt < 30)) // 等待接收到物联网模组关机完成
{ {
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
LOG_D("cnt = %d", cnt); LOG_D ("cnt = %d", cnt);
cnt++; cnt++;
} }
__disable_irq(); // 关闭中断 __disable_irq(); // 关闭中断
NVIC_SystemReset(); // 直接重启系统 NVIC_SystemReset(); // 直接重启系统
} }
else if (received_event & Get_Sys_Event_Flag(kSelfCheckEvent)) // 自检 else if (received_event & Get_Sys_Event_Flag (kSelfCheckEvent)) // 自检
{ {
LOG_D("自检模式"); LOG_D ("自检模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
LOG_D("Self Check Mode SysControl.last_status:%d", SysControl.last_status); LOG_D ("Self Check Mode SysControl.last_status:%d", SysControl.last_status);
SysControl.status = kSelfCheckEvent; SysControl.status = kSelfCheckEvent;
_Self_Check_Mode(); _Self_Check_Mode();
rt_thread_mdelay(5000); rt_thread_mdelay (5000);
// 第5s关闭电磁阀 // 第5s关闭电磁阀
LOG_I("自检机械手动作"); LOG_I ("自检机械手动作");
EMV_FORWARD_ON(50); EMV_FORWARD_ON (50);
rt_thread_mdelay(10); rt_thread_mdelay (10);
EMV_BACKWARD_ON(50); EMV_BACKWARD_ON (50);
if (Flash_Get_Valve_Num()) if (Flash_Get_Valve_Num())
{ {
rt_uint8_t mac_addr[6] = {0}; rt_uint8_t mac_addr[6] = {0};
Flash_Get_Mac_Addr(mac_addr, 1); Flash_Get_Mac_Addr (mac_addr, 1);
Bt_Valve_Handler(kValveCmdCtr, 1, mac_addr); Bt_Valve_Handler (kValveCmdCtr, 1, mac_addr);
if (rt_sem_take(&bt_ctr_sem, 10000) == RT_EOK) if (rt_sem_take (&bt_ctr_sem, 10000) == RT_EOK)
{ {
LOG_D("电磁阀动作完成"); LOG_D ("电磁阀动作完成");
} }
else else
{ {
LOG_E("电磁阀动作失败"); LOG_E ("电磁阀动作失败");
} }
} }
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Ml307_Send_Event(kMl307SelfCheckEvent); Ml307_Send_Event (kMl307SelfCheckEvent);
#endif #endif
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
if (g_Calibration_status == kSysGasCalibStatus) if (g_Calibration_status == kSysGasCalibStatus)
{ {
@ -566,43 +569,43 @@ int main(void)
{ {
if (preheat_flag) if (preheat_flag)
{ {
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
} }
else else
{ {
Send_Laser_Alarm_Event(kPreheatingEvent); Send_Laser_Alarm_Event (kPreheatingEvent);
} }
} }
else else
{ {
Send_Laser_Alarm_Event(kNormalDetectionEvents); Send_Laser_Alarm_Event (kNormalDetectionEvents);
} }
} }
else else
{ {
if (preheat_flag) if (preheat_flag)
{ {
Send_Laser_Alarm_Event(kNotCalibratedEvent); Send_Laser_Alarm_Event (kNotCalibratedEvent);
} }
else else
{ {
Send_Laser_Alarm_Event(kPreheatingEvent); Send_Laser_Alarm_Event (kPreheatingEvent);
} }
} }
} }
else if (received_event & Get_Sys_Event_Flag(kSensorFailureEvent)) // 失效 else if (received_event & Get_Sys_Event_Flag (kSensorFailureEvent)) // 失效
{ {
LOG_D("传感器失效模式"); LOG_D ("传感器失效模式");
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kSensorFailureEvent; SysControl.status = kSensorFailureEvent;
if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0) if (Flash_GetNum_Records (kRecordSensoEndOfLife) == 0)
{ {
Flash_Write_Record(kRecordSensoEndOfLife); Flash_Write_Record (kRecordSensoEndOfLife);
} }
Ml307_Send_Event(kMl307DeviceFailureEvent); // 发送一个失效事件 Ml307_Send_Event (kMl307DeviceFailureEvent); // 发送一个失效事件
Send_Laser_Alarm_Event(kNormalDetectionEvents); /// 再返回正常模式继续检测 Send_Laser_Alarm_Event (kNormalDetectionEvents); /// 再返回正常模式继续检测
// LED_Y_END_OF_LIFE; // LED_Y_END_OF_LIFE;
} }
} }
@ -611,63 +614,63 @@ int main(void)
} }
#ifdef TEST_ENABLE #ifdef TEST_ENABLE
static void SYS_Set_RtcProductTime(int argc, char **argv) static void SYS_Set_RtcProductTime (int argc, char **argv)
{ {
if (argc == 7) if (argc == 7)
{ {
int year = atoi(argv[1]); int year = atoi (argv[1]);
int mon = atoi(argv[2]); int mon = atoi (argv[2]);
int day = atoi(argv[3]); int day = atoi (argv[3]);
int hour = atoi(argv[4]); int hour = atoi (argv[4]);
int min = atoi(argv[5]); int min = atoi (argv[5]);
int second = atoi(argv[6]); int second = atoi (argv[6]);
RTC_SetTime(2000 + year, mon, day, hour, min, second); RTC_SetTime (2000 + year, mon, day, hour, min, second);
RTC_GetTime(); RTC_GetTime();
LOG_D("RTC: %4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, RtcDateTime.day, LOG_D ("RTC: %4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, RtcDateTime.day,
RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.second); RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.second);
// 设置出厂时间 // 设置出厂时间
Flash_SetProductTimeLimit(2000 + year, mon, day, hour, min, second, kFactoryTimeId); Flash_SetProductTimeLimit (2000 + year, mon, day, hour, min, second, kFactoryTimeId);
// 到期时间自动 + 5年30天 // 到期时间自动 + 5年30天
Set_ExpirationTime(MAX_EXPIRATION_DAYS); Set_ExpirationTime (MAX_EXPIRATION_DAYS);
} }
else else
{ {
LOG_E("SYS_Set_RtcProductTime --use _cmd_ [2000 + y] [m] [d] [h] [m] [s]"); LOG_E ("SYS_Set_RtcProductTime --use _cmd_ [2000 + y] [m] [d] [h] [m] [s]");
} }
} }
MSH_CMD_EXPORT(SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime"); MSH_CMD_EXPORT (SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime");
// 测试系统标定值修改 // 测试系统标定值修改
static void TEST_SYS_Calibartion(int argc, char **argv) static void TEST_SYS_Calibartion (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int calibartion_valve = atoi(argv[1]); int calibartion_valve = atoi (argv[1]);
uint8_t calibration_buf[2] = {0}; uint8_t calibration_buf[2] = {0};
calibration_buf[0] = calibartion_valve & 0xFF; // 低字节 calibration_buf[0] = calibartion_valve & 0xFF; // 低字节
calibration_buf[1] = (calibartion_valve >> 8) & 0xFF; // 高字节 calibration_buf[1] = (calibartion_valve >> 8) & 0xFF; // 高字节
Flash_Sys_Cfg(kAlarmLValueId, calibration_buf, 2); Flash_Sys_Cfg (kAlarmLValueId, calibration_buf, 2);
Flash_Set_Calibration_State(kSysGasCalibStatus); Flash_Set_Calibration_State (kSysGasCalibStatus);
LOG_D("标定值修改为 = %d", Flash_Get_SysCfg(kAlarmLValueId)); LOG_D ("标定值修改为 = %d", Flash_Get_SysCfg (kAlarmLValueId));
g_Calibration_status = kSysGasCalibStatus; g_Calibration_status = kSysGasCalibStatus;
Send_Laser_Alarm_Event(kNormalDetectionEvents); /// 再返回正常模式继续检测 Send_Laser_Alarm_Event (kNormalDetectionEvents); /// 再返回正常模式继续检测
} }
else else
{ {
LOG_E("TEST_SYS_Calibartion 0~4095"); LOG_E ("TEST_SYS_Calibartion 0~4095");
} }
} }
MSH_CMD_EXPORT(TEST_SYS_Calibartion, "修改系统标定值"); MSH_CMD_EXPORT (TEST_SYS_Calibartion, "修改系统标定值");
static void SYS_SW_Version(void) static void SYS_SW_Version (void)
{ {
COMPILE_TIME; COMPILE_TIME;
rt_kprintf("JT-DT-YD4N02A Software version: V%02X\r\n", (uint8_t)Flash_Get_SysCfg(kSwVerId)); rt_kprintf ("JT-DT-YD4N02A Software version: V%02X\r\n", (uint8_t)Flash_Get_SysCfg (kSwVerId));
} }
MSH_CMD_EXPORT(SYS_SW_Version, "软件版本和编译时间"); MSH_CMD_EXPORT (SYS_SW_Version, "软件版本和编译时间");
#endif #endif

123
bsp/src/bsp_ml307.c
View File

@ -479,12 +479,20 @@ int Ml307_Send_Time_Calibration (struct at_device *device, void *param)
*/ */
int Ml307_Send_Alarm (struct at_device *device, void *param) int Ml307_Send_Alarm (struct at_device *device, void *param)
{ {
rt_err_t ret = RT_EOK;
struct Ml307_Ops *ml307_ops = (struct Ml307_Ops *)param; struct Ml307_Ops *ml307_ops = (struct Ml307_Ops *)param;
if ((device == RT_NULL) || (ml307_ops == RT_NULL)) if ((device == RT_NULL) || (ml307_ops == RT_NULL))
{ {
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_ALARM)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_ALARM))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_ALARM); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_ALARM);
@ -507,7 +515,13 @@ int Ml307_Send_Alarm_Recover (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_ALARM_RECOVER)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_ALARM_RECOVER))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_ALARM_RECOVER); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_ALARM_RECOVER);
@ -530,7 +544,13 @@ int Ml307_Send_Fault (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_FAULT)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_FAULT))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_FAULT); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_FAULT);
@ -553,7 +573,13 @@ int Ml307_Send_Fault_Recover (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_FAULT_RECOVER)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_FAULT_RECOVER))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_FAULT_RECOVER); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_FAULT_RECOVER);
@ -576,7 +602,13 @@ int Ml307_Send_Self_Check (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_SELF_CHECK)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_SELF_CHECK))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_SELF_CHECK); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_SELF_CHECK);
@ -599,7 +631,13 @@ int Ml307_Send_Silence (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_SILENCE)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_SILENCE))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_SILENCE); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_SILENCE);
@ -622,7 +660,13 @@ int Ml307_Send_Exception (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_EXCEPTION)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_EXCEPTION))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_EXCEPTION); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_EXCEPTION);
@ -714,7 +758,13 @@ int Ml307_Send_Power_On (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_POWER_ON)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_POWER_ON))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_POWER_ON); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_POWER_ON);
@ -737,6 +787,13 @@ int Ml307_Send_Power_Off (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
rt_memset (&valve[0].valve_connct_status, 0, (sizeof (struct valve_t) - 7)); // 当掉电事件时，直接清空阀门结构体，这样连接状态就为断开 rt_memset (&valve[0].valve_connct_status, 0, (sizeof (struct valve_t) - 7)); // 当掉电事件时，直接清空阀门结构体，这样连接状态就为断开
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_POWER_OFF)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_POWER_OFF))
{ {
@ -760,7 +817,13 @@ int Ml307_Send_Valve_Connect (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_VALVE_CONNECT)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_VALVE_CONNECT))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_VALVE_CONNECT); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_VALVE_CONNECT);
@ -783,7 +846,13 @@ int Ml307_Send_Valve_Disconnect (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_VALVE_DISCONNECT)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_VALVE_DISCONNECT))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_VALVE_DISCONNECT); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_VALVE_DISCONNECT);
@ -806,7 +875,13 @@ int Ml307_Send_Device_Failure (struct at_device *device, void *param)
LOG_E ("ml307 param error\n"); LOG_E ("ml307 param error\n");
return RT_ERROR; return RT_ERROR;
} }
rt_err_t ret = RT_EOK;
ret = device->class->device_ops->control (device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL);
if (ret != RT_EOK)
{
LOG_E ("ml307 get signal failed\n");
return -RT_ERROR;
}
if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_DEVICE_FAILURE)) if (ml307_ops->send (ml307_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_ML307, EVENT_TYPE_DEVICE_FAILURE))
{ {
LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_DEVICE_FAILURE); LOG_E ("ml307 send cmd[%X] failed\n", EVENT_TYPE_DEVICE_FAILURE);
@ -944,10 +1019,20 @@ int Ml307_Process_Events (Ml307Event ml307_recv_event, struct at_device *device,
{ {
if (ret != RT_EOK) if (ret != RT_EOK)
{ {
ml307_connect_sever_flag = 0; ml307_connect_sever_flag = 0;
if (!ml307_disconnect_retry_flag)
{
LOG_D("与服务器断开,重连网络中");
rt_sem_release (ml307_disconnect_sem); rt_sem_release (ml307_disconnect_sem);
}
else
{
LOG_D ("与服务区断开连接,等待连接中......\n"); LOG_D ("与服务区断开连接,等待连接中......\n");
} }
}
} }
return ret; return ret;
@ -1353,11 +1438,25 @@ rt_err_t Handle_Valve_Add (struct Ml307_Ops *ops)
} }
LOG_D ("新增阀门设备成功\n"); LOG_D ("新增阀门设备成功\n");
Flash_Set_Valve_Num (cnt + 1); Flash_Set_Valve_Num (cnt + 1);
ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_ML307, INSTRUCTION_DOWN_VALVE_ADD, temp, RESPONSE_CODE_SUCCESS); if (ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_ML307, INSTRUCTION_DOWN_VALVE_ADD, temp, RESPONSE_CODE_SUCCESS) != RT_EOK)
{
LOG_D ("发送失败,清空本地mac地址");
rt_uint8_t mac_addr[6] = {0};
// 清空本地阀门信息
if (Flash_Set_Mac_Addr (mac_addr, 1) != RESET)
{
LOG_E ("本地阀门信息清空完成");
Flash_Set_Valve_Num (0);
}
Bt_Valve_Handler (kValveCmdRemAll, RT_NULL, RT_NULL);
if (rt_sem_take (&bt_rem_sem, 10000) == RT_EOK) // 如果没刷掉数据，则黄灯会亮一秒，如果刷成功了，则红灯闪一下黄灯不会亮
{
return RT_EOK; return RT_EOK;
} }
} }
}
return RT_EOK; return RT_EOK;
}
} }
/*更换阀门设备*/ /*更换阀门设备*/
@ -1890,7 +1989,7 @@ static void Ml307_Life_Thread_Entry (void *parameter)
goto __exit; goto __exit;
} }
/*设置心跳包*/ /*设置心跳包*/
if (at_obj_exec_cmd (device->client, resp, "AT+MIPTKA=0,1,120,60,1") != RT_EOK) if (at_obj_exec_cmd (device->client, resp, "AT+MIPTKA=0,1,120,60,3") != RT_EOK)
{ {
result = -RT_ERROR; result = -RT_ERROR;
goto __exit; goto __exit;