SXDT-Embedded
/
JT-DT-YD4N02B_4G_RTT_MRS
mirror of https://gitee.com/SXDT-Embedded/JT-DT-YD4N02B_4G_RTT_MRS.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

暂存一下

This commit is contained in:
小马_666 2025-01-15 09:56:50 +08:00
parent 90617df89e
commit 958f90e78f
9 changed files with 1023 additions and 1083 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

375
applications/main.c
View File

@ -35,7 +35,7 @@ static rt_uint32_t event_flags[kMaxEventcnt] = {0};
struct rt_event alarm_event;
rt_bool_t is_event_initialized = RT_FALSE; // 是否初始化完成
rt_bool_t is_event_initialized = RT_FALSE; // 是否初始化完成
TsSysControl SysControl;
@ -43,9 +43,9 @@ struct rt_timer work_cnt_timer;
rt_timer_t led_state_timer;
void Send_Laser_Alarm_Event(AlarmEvent event_type);
void Send_Laser_Alarm_Event (AlarmEvent event_type);
static void Set_Event(AlarmEvent event_type)
static void Set_Event (AlarmEvent event_type)
{
if (event_type < kMaxEventcnt)
{
@ -53,28 +53,28 @@ static void Set_Event(AlarmEvent event_type)
}
}
void SYS_EventInit(void)
void SYS_EventInit (void)
{
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++)
{
Set_Event(event);
Set_Event (event);
}
is_event_initialized = RT_TRUE;
}
else
{
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)
{
@ -86,103 +86,105 @@ rt_uint32_t Get_Sys_Event_Flag(AlarmEvent event_type)
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 (SysControl.status == kPowerDownEvent)
{
LOG_D("掉电模式下不处理其他事件");
LOG_D ("掉电模式下不处理其他事件");
}
else
{
LOG_I("Send_Laser_Alarm_Event = %d", event_type);
rt_event_send(&alarm_event, Get_Sys_Event_Flag(event_type));
LOG_I ("Send_Laser_Alarm_Event = %d", event_type);
rt_event_send (&alarm_event, Get_Sys_Event_Flag (event_type));
}
}
else
{
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(g);
LED_STOP(y);
rt_thread_mdelay(500);
LED_CTRL(g, "500,2500", 1);
LED_START(g);
rt_thread_mdelay(1000);
LED_CTRL(y, "500,2500", 1);
LED_START(y);
rt_thread_mdelay(1000);
LED_CTRL(r, "500,2500", 1);
LED_START(r);
rt_thread_mdelay(1000);
LED_STOP(r);
LED_STOP(g);
LED_STOP(y);
LED_STOP (r);
LED_STOP (g);
LED_STOP (y);
rt_thread_mdelay (500);
LED_CTRL (g, "500,2500", 1);
LED_START (g);
rt_thread_mdelay (1000);
LED_CTRL (y, "500,2500", 1);
LED_START (y);
rt_thread_mdelay (1000);
LED_CTRL (r, "500,2500", 1);
LED_START (r);
rt_thread_mdelay (1000);
LED_STOP (r);
LED_STOP (g);
LED_STOP (y);
BEEP_SELF_CHECK;
return RT_EOK;
}
void Preheat_Sensor(rt_uint32_t timeout_counter)
void Preheat_Sensor (rt_uint32_t timeout_counter)
{
// 定义超时时间，单位为毫秒
#define TIMEOUT_MS 15000
timeout_counter += 10; // 每次递归增加10毫秒
timeout_counter += 10; // 每次递归增加10毫秒
if (H308.Data.checksum != 0)
{
BEEP_PREAT_OK;
LED_STOP(r);
LED_STOP(g);
LED_STOP(y);
LOG_D("预热完成");
LED_STOP (r);
LED_STOP (g);
LED_STOP (y);
LOG_D ("预热完成");
BEEP_PREAT_OK;
Send_Laser_Alarm_Event(kNormalDetectionEvents);
Send_Laser_Alarm_Event (kNormalDetectionEvents);
}
else if (IS_H308_EndOfLife()) // 如果寿命到期，预热完成后直接到寿命过期状态
else if (IS_H308_EndOfLife()) // 如果寿命到期，预热完成后直接到寿命过期状态
{
LED_STOP(r);
LED_STOP(g);
LED_STOP(y);
LED_STOP (r);
LED_STOP (g);
LED_STOP (y);
BEEP_PREAT_OK;
Send_Laser_Alarm_Event(kSensorFailureEvent);
Send_Laser_Alarm_Event (kSensorFailureEvent);
}
else if ((timeout_counter >= TIMEOUT_MS) && (H308.Data.checksum == 0))
{
LED_STOP(r);
LED_STOP(g);
LED_STOP(y);
LED_STOP (r);
LED_STOP (g);
LED_STOP (y);
BEEP_PREAT_OK;
LOG_D("预热完成,传感器故障");
Send_Laser_Alarm_Event(kFaultEvent); // 传感器故障
LOG_D ("预热完成,传感器故障");
Send_Laser_Alarm_Event (kFaultEvent); // 传感器故障
}
else
{
rt_thread_mdelay(10);
Preheat_Sensor(timeout_counter);
rt_thread_mdelay (10);
Preheat_Sensor (timeout_counter);
}
}
void Work_Cnt_Timer_Callback(void *parameter)
void Work_Cnt_Timer_Callback (void *parameter)
{
work_duration++;
if (IS_H308_EndOfLife()) // 每天检测一下是否过期
if (IS_H308_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);
}
}
int main(void)
int main (void)
{
#define WORK_TIMER_CNT (1000 * 60 * 60 * 24)
@ -197,244 +199,269 @@ int main(void)
SYS_EventInit();
BSP_SYS_Init();
// 读取历史记录总数
Flash_GetTotalRecord(&TotalRecords);
Flash_GetTotalRecord (&TotalRecords);
work_duration = Flash_Get_WorkDuration();
LOG_D("工作天数：%d", work_duration);
rt_timer_init(&work_cnt_timer,
"work_cnt_timer",
Work_Cnt_Timer_Callback,
RT_NULL,
WORK_TIMER_CNT,
RT_TIMER_FLAG_PERIODIC);
rt_timer_start(&work_cnt_timer);
LOG_D ("工作天数：%d", work_duration);
rt_timer_init (&work_cnt_timer,
"work_cnt_timer",
Work_Cnt_Timer_Callback,
RT_NULL,
WORK_TIMER_CNT,
RT_TIMER_FLAG_PERIODIC);
rt_timer_start (&work_cnt_timer);
TuFlashProductTimeLimitFrame LimitTime;
if (Flash_GetProductTimeLimit (&LimitTime, kExpirationTimeId) == READY)
{
// 计算出 到期时间对应的RTC秒数
H308.expiration_seconds = DateTime2Seconds (LimitTime.Struct.year,
LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.hour,
LimitTime.Struct.minute, LimitTime.Struct.second);
LOG_D ("h308_expiration_time:%04d-%02d-%02d,%02d:%02d",
LimitTime.Struct.year, LimitTime.Struct.month, LimitTime.Struct.day,
LimitTime.Struct.hour, LimitTime.Struct.minute, LimitTime.Struct.second);
}
if (Flash_GetNum_Records (kRecordSensoEndOfLife) == 1)
{
LOG_W ("寿命已到期");
H308.end_of_life = 1;
}
// 寿命到期检测
if (IS_H308_EndOfLife())
{
if (Flash_GetNum_Records (kRecordSensoEndOfLife) == 0)
{
Flash_Write_Record (kRecordSensoEndOfLife);
}
Send_Laser_Alarm_Event (kSensorFailureEvent);
}
// 检测上电/掉电复位标志
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET) // TODO:这块超级电容会造成掉电重启，并且标志是上电复位，只能通过其超级电容造成复位时事件创建失败进行判断，不治本
if (RCC_GetFlagStatus (RCC_FLAG_PORRST) != RESET) // TODO:这块超级电容会造成掉电重启，并且标志是上电复位，只能通过其超级电容造成复位时事件创建失败进行判断，不治本
{
RCC_ClearFlag();
Send_Laser_Alarm_Event(kPowerOnEvent);
Send_Laser_Alarm_Event (kPowerOnEvent);
}
else
{
Send_Laser_Alarm_Event(kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式
Send_Laser_Alarm_Event (kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式
}
}
else
{
LOG_D("欠压复位\r\n");
LOG_D ("欠压复位\r\n");
RCC_ClearFlag();
NVIC_SystemReset(); // 直接重启系统
NVIC_SystemReset(); // 直接重启系统
}
while (1)
{
if (is_event_initialized)
{
result = rt_event_recv(&alarm_event,
Get_Sys_Event_Flag(kPowerOnEvent) | // 上电
Get_Sys_Event_Flag(kPowerDownEvent) | // 掉电
Get_Sys_Event_Flag(kPreheatingEvent) | // 预热
Get_Sys_Event_Flag(kNormalDetectionEvents) | // 正常检测
Get_Sys_Event_Flag(kAlarmExceptionEvent) | // 报警异常
Get_Sys_Event_Flag(kAlarmEvent) | // 报警
Get_Sys_Event_Flag(kAlarmRcyEvent) | // 报警恢复
Get_Sys_Event_Flag(kSelfCheckEvent) | // 自检
Get_Sys_Event_Flag(kFaultEvent) | // 故障模式
Get_Sys_Event_Flag(kFaultRcyEvent) | // 故障恢复
Get_Sys_Event_Flag(KMuteEvent) | // 消音
Get_Sys_Event_Flag(kSensorFailureEvent), // 传感器寿命到期
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &received_event);
result = rt_event_recv (&alarm_event,
Get_Sys_Event_Flag (kPowerOnEvent) | // 上电
Get_Sys_Event_Flag (kPowerDownEvent) | // 掉电
Get_Sys_Event_Flag (kPreheatingEvent) | // 预热
Get_Sys_Event_Flag (kNormalDetectionEvents) | // 正常检测
Get_Sys_Event_Flag (kAlarmExceptionEvent) | // 报警异常
Get_Sys_Event_Flag (kAlarmEvent) | // 报警
Get_Sys_Event_Flag (kAlarmRcyEvent) | // 报警恢复
Get_Sys_Event_Flag (kSelfCheckEvent) | // 自检
Get_Sys_Event_Flag (kFaultEvent) | // 故障模式
Get_Sys_Event_Flag (kFaultRcyEvent) | // 故障恢复
Get_Sys_Event_Flag (KMuteEvent) | // 消音
Get_Sys_Event_Flag (kSensorFailureEvent), // 传感器寿命到期
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &received_event);
if (result == RT_EOK)
{
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("is_event_initialized :%d", is_event_initialized);
LOG_D ("上电模式");
LOG_D ("is_event_initialized :%d", is_event_initialized);
SysControl.status = kPowerOnEvent;
Flash_Write_Record(kRecordPowerOn);
Send_Laser_Alarm_Event(kPreheatingEvent);
Flash_Write_Record (kRecordPowerOn);
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.status = kPreheatingEvent;
SysControl.status = kPreheatingEvent;
LED_G_PREAT;
BEEP_PREAT_OK;
Send_Laser_Alarm_Event(kNormalDetectionEvents);
Send_Laser_Alarm_Event (kNormalDetectionEvents);
}
else if (received_event & Get_Sys_Event_Flag(kNormalDetectionEvents)) // 正常检测
else if (received_event & Get_Sys_Event_Flag (kNormalDetectionEvents)) // 正常检测
{
SysControl.last_status = SysControl.status;
SysControl.status = kNormalDetectionEvents;
SysControl.status = kNormalDetectionEvents;
if (SysControl.last_status == kSelfCheckEvent)
{
rt_thread_mdelay(5000);
LOG_I("自检电磁阀动作");
rt_thread_mdelay (5000);
LOG_I ("自检电磁阀动作");
EMV_CLOSE_VALVE;
LOG_I("自检风机动作");
LOG_I ("自检风机动作");
relay_state_flag = 1;
rt_thread_mdelay(500);
rt_thread_mdelay (500);
relay_state_flag = 0;
}
if (H308.detection_flag == kH308Alarm)
{
LED_G_NORMAL;
rt_thread_mdelay(500);
Send_Laser_Alarm_Event(kAlarmEvent);
rt_thread_mdelay (500);
Send_Laser_Alarm_Event (kAlarmEvent);
}
else if (H308.detection_flag == kH308Fault)
{
LED_G_NORMAL;
rt_thread_mdelay(500);
Send_Laser_Alarm_Event(kFaultEvent);
rt_thread_mdelay (500);
Send_Laser_Alarm_Event (kFaultEvent);
}
else
{
LOG_D("正常检测模式");
LOG_D ("正常检测模式");
}
}
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.status = kAlarmExceptionEvent;
SysControl.status = kAlarmExceptionEvent;
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.status = kAlarmEvent;
SysControl.status = kAlarmEvent;
Flash_Write_Record(kRecordAlarm); // 写入flash报警信息
Flash_Write_Record (kRecordAlarm); // 写入flash报警信息
EMV_CLOSE_VALVE;
relay_state_flag = 1;
LED_R_ALARM;
BEEP_ALARM;
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kAlarmEvent);
Nt26k_Send_Event (kNt26kAlarmEvent);
#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.status = kAlarmRcyEvent;
SysControl.status = kAlarmRcyEvent;
Flash_Write_Record(kRecordAlarmRcy);
Flash_Write_Record (kRecordAlarmRcy);
relay_state_flag = 0;
BEEP_STOP;
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kAlarmRcyEvent);
Nt26k_Send_Event (kNt26kAlarmRcyEvent);
#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 ("故障模式");
if (Flash_GetNum_Records(kRecordSensoEndOfLife) != 1) // 当设备失效时，只上报设备失效的故障，其他故障不上报
if (Flash_GetNum_Records (kRecordSensoEndOfLife) != 1) // 当设备失效时，只上报设备失效的故障，其他故障不上报
{
SysControl.last_status = SysControl.status;
SysControl.status = kFaultEvent;
SysControl.status = kFaultEvent;
Flash_Write_Record(kRecordFault);
Flash_Write_Record (kRecordFault);
LED_Y_FAULT;
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kFaultEvent);
Nt26k_Send_Event (kNt26kFaultEvent);
#endif
}
else
{
Send_Laser_Alarm_Event(kSensorFailureEvent);
Send_Laser_Alarm_Event (kSensorFailureEvent);
}
}
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.status = kFaultRcyEvent;
SysControl.status = kFaultRcyEvent;
Flash_Write_Record(kRecordFaultRcy);
Flash_Write_Record (kRecordFaultRcy);
Send_Laser_Alarm_Event(kNormalDetectionEvents);
Send_Laser_Alarm_Event (kNormalDetectionEvents);
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kFaultRcyEvent);
Nt26k_Send_Event (kNt26kFaultRcyEvent);
#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.status = KMuteEvent;
SysControl.status = KMuteEvent;
BEEP_STOP;
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kSilenceEvent);
Nt26k_Send_Event (kNt26kSilenceEvent);
#endif
}
else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电
else if (received_event & Get_Sys_Event_Flag (kPowerDownEvent)) // 掉电
{
LOG_D("掉电模式");
LOG_D ("掉电模式");
H308_PWR_OFF;
SysControl.last_status = SysControl.status;
SysControl.status = kPowerDownEvent;
SysControl.status = kPowerDownEvent;
// 写入掉电记录
Flash_Write_Record(kRecordPowerDown);
Flash_Write_Record (kRecordPowerDown);
Flash_Set_WorkDuration(work_duration); // 写入工作时长
Flash_Set_WorkDuration (work_duration); // 写入工作时长
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kPowerDownEvent);
Nt26k_Send_Event (kNt26kPowerDownEvent);
#endif
// 等待20s,要是还没断电就重启
for (uint8_t i = 0; i < 20; i++)
{
rt_thread_mdelay(1000);
LOG_D(" %d s", i);
rt_thread_mdelay (1000);
LOG_D (" %d s", i);
}
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.status = kSelfCheckEvent;
SysControl.status = kSelfCheckEvent;
_Self_Check_Mode();
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kSelfCheckEvent);
Nt26k_Send_Event (kNt26kSelfCheckEvent);
#endif
Send_Laser_Alarm_Event(kNormalDetectionEvents); // 这里先返回检测模式，然后当事件触发时进入事件模式
Send_Laser_Alarm_Event (kNormalDetectionEvents); // 这里先返回检测模式，然后当事件触发时进入事件模式
}
else if (received_event & Get_Sys_Event_Flag(kSensorFailureEvent)) // 失效
else if (received_event & Get_Sys_Event_Flag (kSensorFailureEvent)) // 失效
{
SysControl.last_status = SysControl.status;
SysControl.status = kSensorFailureEvent;
LOG_D("传感器失效模式");
SysControl.status = kSensorFailureEvent;
LOG_D ("传感器失效模式");
if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0)
if (Flash_GetNum_Records (kRecordSensoEndOfLife) == 0)
{
Flash_Write_Record(kRecordSensoEndOfLife);
Flash_Write_Record (kRecordSensoEndOfLife);
}
LED_Y_END_OF_LIFE;
}
@ -443,43 +470,45 @@ int main(void)
}
else
{
rt_thread_mdelay(1000);
rt_thread_mdelay (1000);
}
}
}
#ifdef TEST_ENABLE
static void SYS_Set_RtcProductTime(int argc, char **argv)
static void SYS_Set_RtcProductTime (int argc, char **argv)
{
if (argc == 7)
{
int year = atoi(argv[1]);
int mon = atoi(argv[2]);
int day = atoi(argv[3]);
int hour = atoi(argv[4]);
int min = atoi(argv[5]);
int second = atoi(argv[6]);
RTC_SetTime(2000 + year, mon, day, hour, min, second);
int year = atoi (argv[1]);
int mon = atoi (argv[2]);
int day = atoi (argv[3]);
int hour = atoi (argv[4]);
int min = atoi (argv[5]);
int second = atoi (argv[6]);
RTC_SetTime (2000 + year, mon, day, hour, min, second);
RTC_GetTime();
LOG_D("RTC: %4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, RtcDateTime.day,
RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.second);
LOG_D ("RTC: %4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, RtcDateTime.day,
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天
Set_ExpirationTime(MAX_EXPIRATION_DAYS);
Set_ExpirationTime (MAX_EXPIRATION_DAYS);
}
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");
static void SYS_SW_Version(void)
MSH_CMD_EXPORT (SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime");
static void SYS_SW_Version (void)
{
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

4
applications/user_sys.c
View File

@ -253,7 +253,6 @@ rt_uint32_t IMEI_Delay(void)
int BSP_SYS_Init(void)
{
BSP_Flash_Init();
BSP_RTC_Init();
BSP_Rng_Init();
BSP_WDG_Init();
@ -262,10 +261,7 @@ int BSP_SYS_Init(void)
BSP_BEEP_Init();
BSP_EMV_Init();
BSP_BUTTON_Init();
BSP_H308_Init();
BSP_HR_Init();
nt26k_device_class_register();
nt26k_device_register();
BSP_Nt26k_Thread_Init();
return 0;
}

22
bsp/inc/at_device_nt26k.h
View File

@ -1,24 +1,3 @@
/***
* @Author: mbw
* @Date: 2024-10-09 08:42:14
* @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-12-30 16:30:57
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_nt26k.h
* @Description:
* @
* @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved.
*/
/***
* @Author: mbw
* @Date: 2024-10-09 08:42:14
* @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-10-14 14:25:58
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_nt26k.h
* @Description:
* @
* @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved.
*/
#ifndef __AT_DEVICE_NT26K_H__
#define __AT_DEVICE_NT26K_H__
@ -86,7 +65,6 @@ typedef struct __attribute__((packed))
extern nt26k_sys_info nt26k;
extern rt_uint8_t nt26k_init_complate_flag;
extern struct rt_completion nt26k_init_complate;
int nt26k_device_class_register(void);
int at_send_data(struct at_device *device, const char *data, rt_size_t size);
rt_err_t Nt26k_Reset(struct at_device *device);
int Time_Calibration(struct at_device *device);

1
bsp/inc/bsp_nt26k.h
View File

@ -207,6 +207,5 @@ extern rt_sem_t nt26k_disconnect_sem;
extern rt_uint8_t nt26k_conncet_tcp_flag;
extern rt_uint8_t nt26k_disconnect_pdp_flag;
extern rt_uint8_t power_on_send_flag;
int nt26k_device_register(void);
int BSP_Nt26k_Thread_Init(void);
void Nt26k_Send_Event(Nt26kEvent event_type);

974
bsp/src/at_device_nt26k.c
View File

File diff suppressed because it is too large Load Diff

560
bsp/src/bsp_flash.c
View File

File diff suppressed because it is too large Load Diff

139
bsp/src/bsp_h308.c
View File

@ -229,51 +229,61 @@ uint8_t IS_H308_EndOfLife(void)
return H308.end_of_life;
}
void UART4_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure = {0};
USART_InitTypeDef USART_InitStructure = {0};
NVIC_InitTypeDef NVIC_InitStructure = {0};
lwrb_init(&uart4_rx_rb, uart4_rx_rb_data, sizeof(uart4_rx_rb_data));
USART_DeInit(UART4); // 寄存器恢复默认值
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOC, &GPIO_InitStructure);
USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_Init(UART4, &USART_InitStructure);
USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
USART_Cmd(UART4, ENABLE);
LOG_I("UART4 Init");
}
static void h308_thread_entry(void *param)
{
// strstr要用，静态的才能算正确偏移
rt_err_t ret;
static uint8_t str[UART4_RX_RB_LENGTH] = {0};
static uint8_t h308_rx_timout_cnt = 0;
static uint8_t h308_err_cnt = 0;
rt_err_t ret;
H308.alarm_value = Flash_Get_SysCfg(kAlarmLValueId); // 获取系统报警阈值
LOG_D("报警阈值:%d", H308.alarm_value);
LOG_D("h308_thread_entry");
H308_PWR_OFF;
rt_thread_mdelay(1000);
H308_PWR_ON;
TuFlashProductTimeLimitFrame LimitTime;
if (Flash_GetProductTimeLimit(&LimitTime, kExpirationTimeId) == READY)
{
// 计算出 到期时间对应的RTC秒数
H308.expiration_seconds = DateTime2Seconds(LimitTime.Struct.year,
LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.hour,
LimitTime.Struct.minute, LimitTime.Struct.second);
LOG_D("h308_expiration_time:%04d-%02d-%02d,%02d:%02d",
LimitTime.Struct.year, LimitTime.Struct.month, LimitTime.Struct.day,
LimitTime.Struct.hour, LimitTime.Struct.minute, LimitTime.Struct.second);
}
H308.alarm_value = Flash_Get_SysCfg(kAlarmLValueId); // 获取系统报警阈值
LOG_D("报警阈值:%d%LEL", H308.alarm_value);
if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 1)
{
LOG_W("寿命已到期");
H308.end_of_life = 1;
}
//这里应该等下iot模组更新网络，不然可能不准确，但如果从未更新时，截至日期小于1天才会有影响，所以可不等待
rt_thread_mdelay(5000);//这里等的原因是，等待4G更新网络，其二是传感器需要10s的启动时间
// 寿命到期检测
if (IS_H308_EndOfLife())
{
if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0)
{
Flash_Write_Record(kRecordSensoEndOfLife);
}
Send_Laser_Alarm_Event(kSensorFailureEvent);
}
while (1)
{
ret = rt_sem_take(uart4_rx_ok_sem, 3000);
@ -285,7 +295,7 @@ static void h308_thread_entry(void *param)
if (len >= 44)
{
ret = H308_GetFrameData(str, len, &H308.Data);
ret = H308_GetFrameData((const char *)str, len, &H308.Data);
LOG_I("str:[%s]", str);
if (ret == 0)
{
@ -335,57 +345,12 @@ static void h308_thread_entry(void *param)
}
}
void UART4_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure = {0};
USART_InitTypeDef USART_InitStructure = {0};
NVIC_InitTypeDef NVIC_InitStructure = {0};
lwrb_init(&uart4_rx_rb, uart4_rx_rb_data, sizeof(uart4_rx_rb_data));
USART_DeInit(UART4); // 寄存器恢复默认值
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOC, &GPIO_InitStructure);
USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_Init(UART4, &USART_InitStructure);
USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
USART_Cmd(UART4, ENABLE);
LOG_I("UART4 Init");
}
int BSP_H308_Init(void)
{
UART4_Init();
rt_pin_mode(H308_PWR_PIN, PIN_MODE_OUTPUT);
rt_pin_mode(H308_RST_PIN, PIN_MODE_OUTPUT);
H308_PWR_OFF;
H308_RST_OFF;
H308_PWR_ON;
uart4_rx_ok_sem = rt_sem_create("uart4_rx", 0, RT_IPC_FLAG_FIFO);
if (uart4_rx_ok_sem == RT_NULL)
@ -398,7 +363,7 @@ int BSP_H308_Init(void)
{
LOG_E("uart4_rx_timer create failed");
}
UART4_Init();
rt_err_t ret = rt_thread_init(&h308_thread,
"h308_thread",
h308_thread_entry,
@ -419,7 +384,7 @@ int BSP_H308_Init(void)
return ret;
}
// INIT_PREV_EXPORT(BSP_H308_Init);
INIT_PREV_EXPORT(BSP_H308_Init);
void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART4_IRQHandler(void)

27
bsp/src/bsp_hr.c
View File

@ -2,7 +2,7 @@
* @Author : stark1898y 1658608470@qq.com
* @Date : 2024-09-04 17:33:57
* @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2025-01-13 09:30:42
* @LastEditTime: 2025-01-15 08:53:20
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-NT26K\bsp\src\bsp_hr.c
* @Description :
*
@ -36,7 +36,6 @@ static lwrb_t uart5_tx_rb;
static rt_uint8_t uart5_tx_rb_data[UART5_TX_RB_LENGTH];
static rt_sem_t uart5_rx_ok_sem;
static rt_sem_t uart5_rx_parity_err_sem;
static rt_timer_t uart5_timer;
uint8_t hr_rx_flag = 0; // 接收缓冲区中，已经收到的数据包数量
@ -492,22 +491,16 @@ int Process_Factor_Cmd(rt_uint8_t cmd)
static void hr_thread_entry(void *param)
{
LOG_D("hr_thread_entry");
uint8_t rx_buff[64] = {0};
char rx_buff[64] = {0};
lwrb_reset(&uart5_rx_rb);
lwrb_reset(&uart5_tx_rb);
while (1)
{
rt_sem_take(uart5_rx_ok_sem, RT_WAITING_FOREVER);
if (rt_sem_trytake(uart5_rx_parity_err_sem) == 0)
{
LOG_D("uart5_rx_parity_err_sem");
lwrb_free(&uart5_rx_rb);
continue;
}
uint8_t len = lwrb_get_full(&uart5_rx_rb);
lwrb_read(&uart5_rx_rb, rx_buff, len);
LOG_HEX("hr_rx_data:", 16, &rx_buff[0], len);
if (rt_strstr(rx_buff, "[getParameter]") != RT_NULL)
{
@ -522,7 +515,7 @@ static void hr_thread_entry(void *param)
{
if (len >= HOST_FRAME_MIN_LEN)
{
TsFrameData *HostFrameData = HR_GetFrameData(rx_buff, len);
TsFrameData *HostFrameData = HR_GetFrameData((rt_uint8_t *)rx_buff, len);
if (HostFrameData != RT_NULL)
{
LOG_HEX("HostFrameData", 16, &HostFrameData->data[0], HostFrameData->len); // 数据段
@ -534,6 +527,7 @@ static void hr_thread_entry(void *param)
}
}
lwrb_reset(&uart5_rx_rb);
LOG_HEX("hr_rx_data:", 16, (rt_uint8_t *)&rx_buff[0], len);
rt_memset(rx_buff, 0, len);
}
}
@ -594,12 +588,6 @@ int BSP_HR_Init(void)
{
LOG_E("uart5_rx_ok_sem create failed");
}
uart5_rx_parity_err_sem = rt_sem_create("uart5_rx_pe", 0, RT_IPC_FLAG_PRIO);
if (uart5_rx_parity_err_sem == RT_NULL)
{
LOG_E("uart5_rx_parity_err_sem create failed");
}
uart5_timer = rt_timer_create("uart5_timeout", uart5_timeout, RT_NULL, 50, RT_TIMER_FLAG_PERIODIC);
if (uart5_timer == RT_NULL)
{
@ -634,10 +622,7 @@ void UART5_IRQHandler(void)
GET_INT_SP();
rt_interrupt_enter();
unsigned char data;
if (USART_GetITStatus(UART5, USART_IT_PE) != RESET)
{
rt_sem_release(uart5_rx_parity_err_sem);
}
if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
{
data = USART_ReceiveData(UART5);

4
bsp/src/bsp_nt26k.c
View File

@ -1574,7 +1574,7 @@ int BSP_Nt26k_Thread_Init (void)
// INIT_APP_EXPORT(BSP_Nt26k_Thread_Init);
int nt26k_device_register (void)
static int nt26k_device_register (void)
{
struct at_device_nt26k *nt26k = &_dev;
@ -1585,6 +1585,6 @@ int nt26k_device_register (void)
(void *)nt26k);
}
// INIT_COMPONENT_EXPORT(nt26k_device_register);
INIT_COMPONENT_EXPORT(nt26k_device_register);
#endif // IOT_MODULE_SWITCH