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

325
applications/main.c
View File

@ -43,9 +43,9 @@ struct rt_timer work_cnt_timer;
rt_timer_t led_state_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) 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 (!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)
{ {
@ -86,51 +86,51 @@ 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);
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
BEEP_SELF_CHECK; BEEP_SELF_CHECK;
return RT_EOK; return RT_EOK;
} }
void Preheat_Sensor(rt_uint32_t timeout_counter) void Preheat_Sensor (rt_uint32_t timeout_counter)
{ {
// 定义超时时间，单位为毫秒 // 定义超时时间，单位为毫秒
#define TIMEOUT_MS 15000 #define TIMEOUT_MS 15000
@ -140,49 +140,51 @@ void Preheat_Sensor(rt_uint32_t timeout_counter)
if (H308.Data.checksum != 0) if (H308.Data.checksum != 0)
{ {
BEEP_PREAT_OK; BEEP_PREAT_OK;
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
LOG_D("预热完成"); LOG_D ("预热完成");
BEEP_PREAT_OK; 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 (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
BEEP_PREAT_OK; BEEP_PREAT_OK;
Send_Laser_Alarm_Event(kSensorFailureEvent); Send_Laser_Alarm_Event (kSensorFailureEvent);
} }
else if ((timeout_counter >= TIMEOUT_MS) && (H308.Data.checksum == 0)) else if ((timeout_counter >= TIMEOUT_MS) && (H308.Data.checksum == 0))
{ {
LED_STOP(r); LED_STOP (r);
LED_STOP(g); LED_STOP (g);
LED_STOP(y); LED_STOP (y);
BEEP_PREAT_OK; BEEP_PREAT_OK;
LOG_D("预热完成,传感器故障"); LOG_D ("预热完成,传感器故障");
Send_Laser_Alarm_Event(kFaultEvent); // 传感器故障 Send_Laser_Alarm_Event (kFaultEvent); // 传感器故障
} }
else else
{ {
rt_thread_mdelay(10); rt_thread_mdelay (10);
Preheat_Sensor(timeout_counter); Preheat_Sensor (timeout_counter);
} }
} }
void Work_Cnt_Timer_Callback(void *parameter)
void Work_Cnt_Timer_Callback (void *parameter)
{ {
work_duration++; 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) #define WORK_TIMER_CNT (1000 * 60 * 60 * 24)
@ -197,32 +199,57 @@ int main(void)
SYS_EventInit(); SYS_EventInit();
BSP_SYS_Init(); BSP_SYS_Init();
// 读取历史记录总数 // 读取历史记录总数
Flash_GetTotalRecord(&TotalRecords); Flash_GetTotalRecord (&TotalRecords);
work_duration = Flash_Get_WorkDuration(); work_duration = Flash_Get_WorkDuration();
LOG_D("工作天数：%d", work_duration); LOG_D ("工作天数：%d", work_duration);
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);
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(); RCC_ClearFlag();
Send_Laser_Alarm_Event(kPowerOnEvent); Send_Laser_Alarm_Event (kPowerOnEvent);
} }
else else
{ {
Send_Laser_Alarm_Event(kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式 Send_Laser_Alarm_Event (kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式
} }
} }
else else
{ {
LOG_D("欠压复位\r\n"); LOG_D ("欠压复位\r\n");
RCC_ClearFlag(); RCC_ClearFlag();
NVIC_SystemReset(); // 直接重启系统 NVIC_SystemReset(); // 直接重启系统
} }
@ -230,191 +257,191 @@ int main(void)
{ {
if (is_event_initialized) if (is_event_initialized)
{ {
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(kAlarmExceptionEvent) | // 报警异常 Get_Sys_Event_Flag (kAlarmExceptionEvent) | // 报警异常
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(kSensorFailureEvent), // 传感器寿命到期 Get_Sys_Event_Flag (kSensorFailureEvent), // 传感器寿命到期
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;
LED_G_PREAT; LED_G_PREAT;
BEEP_PREAT_OK; 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.last_status = SysControl.status;
SysControl.status = kNormalDetectionEvents; SysControl.status = kNormalDetectionEvents;
if (SysControl.last_status == kSelfCheckEvent) if (SysControl.last_status == kSelfCheckEvent)
{ {
rt_thread_mdelay(5000); rt_thread_mdelay (5000);
LOG_I("自检电磁阀动作"); LOG_I ("自检电磁阀动作");
EMV_CLOSE_VALVE; EMV_CLOSE_VALVE;
LOG_I("自检风机动作"); LOG_I ("自检风机动作");
relay_state_flag = 1; relay_state_flag = 1;
rt_thread_mdelay(500); rt_thread_mdelay (500);
relay_state_flag = 0; relay_state_flag = 0;
} }
if (H308.detection_flag == kH308Alarm) if (H308.detection_flag == kH308Alarm)
{ {
LED_G_NORMAL; LED_G_NORMAL;
rt_thread_mdelay(500); rt_thread_mdelay (500);
Send_Laser_Alarm_Event(kAlarmEvent); Send_Laser_Alarm_Event (kAlarmEvent);
} }
else if (H308.detection_flag == kH308Fault) else if (H308.detection_flag == kH308Fault)
{ {
LED_G_NORMAL; LED_G_NORMAL;
rt_thread_mdelay(500); rt_thread_mdelay (500);
Send_Laser_Alarm_Event(kFaultEvent); Send_Laser_Alarm_Event (kFaultEvent);
} }
else 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.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;
Flash_Write_Record(kRecordAlarm); // 写入flash报警信息 Flash_Write_Record (kRecordAlarm); // 写入flash报警信息
EMV_CLOSE_VALVE; EMV_CLOSE_VALVE;
relay_state_flag = 1; relay_state_flag = 1;
LED_R_ALARM; LED_R_ALARM;
BEEP_ALARM; BEEP_ALARM;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kAlarmEvent); Nt26k_Send_Event (kNt26kAlarmEvent);
#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);
relay_state_flag = 0; relay_state_flag = 0;
BEEP_STOP; BEEP_STOP;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kAlarmRcyEvent); Nt26k_Send_Event (kNt26kAlarmRcyEvent);
#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 ("故障模式");
if (Flash_GetNum_Records(kRecordSensoEndOfLife) != 1) // 当设备失效时，只上报设备失效的故障，其他故障不上报 if (Flash_GetNum_Records (kRecordSensoEndOfLife) != 1) // 当设备失效时，只上报设备失效的故障，其他故障不上报
{ {
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)
Nt26k_Send_Event(kNt26kFaultEvent); Nt26k_Send_Event (kNt26kFaultEvent);
#endif #endif
} }
else 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.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) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kFaultRcyEvent); Nt26k_Send_Event (kNt26kFaultRcyEvent);
#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;
BEEP_STOP; BEEP_STOP;
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kSilenceEvent); Nt26k_Send_Event (kNt26kSilenceEvent);
#endif #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; H308_PWR_OFF;
SysControl.last_status = SysControl.status; 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) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kPowerDownEvent); Nt26k_Send_Event (kNt26kPowerDownEvent);
#endif #endif
// 等待20s,要是还没断电就重启 // 等待20s,要是还没断电就重启
for (uint8_t i = 0; i < 20; i++) for (uint8_t i = 0; i < 20; i++)
{ {
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
LOG_D(" %d s", i); 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.last_status = SysControl.status;
SysControl.status = kSelfCheckEvent; SysControl.status = kSelfCheckEvent;
@ -422,19 +449,19 @@ int main(void)
_Self_Check_Mode(); _Self_Check_Mode();
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kSelfCheckEvent); Nt26k_Send_Event (kNt26kSelfCheckEvent);
#endif #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.last_status = SysControl.status;
SysControl.status = kSensorFailureEvent; SysControl.status = kSensorFailureEvent;
LOG_D("传感器失效模式"); 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; LED_Y_END_OF_LIFE;
} }
@ -443,43 +470,45 @@ int main(void)
} }
else else
{ {
rt_thread_mdelay(1000); rt_thread_mdelay (1000);
} }
} }
} }
#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");
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 #endif

4
applications/user_sys.c
View File

@ -253,7 +253,6 @@ rt_uint32_t IMEI_Delay(void)
int BSP_SYS_Init(void) int BSP_SYS_Init(void)
{ {
BSP_Flash_Init();
BSP_RTC_Init(); BSP_RTC_Init();
BSP_Rng_Init(); BSP_Rng_Init();
BSP_WDG_Init(); BSP_WDG_Init();
@ -262,10 +261,7 @@ int BSP_SYS_Init(void)
BSP_BEEP_Init(); BSP_BEEP_Init();
BSP_EMV_Init(); BSP_EMV_Init();
BSP_BUTTON_Init(); BSP_BUTTON_Init();
BSP_H308_Init();
BSP_HR_Init(); BSP_HR_Init();
nt26k_device_class_register();
nt26k_device_register();
BSP_Nt26k_Thread_Init(); BSP_Nt26k_Thread_Init();
return 0; 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__ #ifndef __AT_DEVICE_NT26K_H__
#define __AT_DEVICE_NT26K_H__ #define __AT_DEVICE_NT26K_H__
@ -86,7 +65,6 @@ typedef struct __attribute__((packed))
extern nt26k_sys_info nt26k; extern nt26k_sys_info nt26k;
extern rt_uint8_t nt26k_init_complate_flag; extern rt_uint8_t nt26k_init_complate_flag;
extern struct rt_completion nt26k_init_complate; 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); int at_send_data(struct at_device *device, const char *data, rt_size_t size);
rt_err_t Nt26k_Reset(struct at_device *device); rt_err_t Nt26k_Reset(struct at_device *device);
int Time_Calibration(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_conncet_tcp_flag;
extern rt_uint8_t nt26k_disconnect_pdp_flag; extern rt_uint8_t nt26k_disconnect_pdp_flag;
extern rt_uint8_t power_on_send_flag; extern rt_uint8_t power_on_send_flag;
int nt26k_device_register(void);
int BSP_Nt26k_Thread_Init(void); int BSP_Nt26k_Thread_Init(void);
void Nt26k_Send_Event(Nt26kEvent event_type); void Nt26k_Send_Event(Nt26kEvent event_type);

750
bsp/src/at_device_nt26k.c
View File

File diff suppressed because it is too large Load Diff

426
bsp/src/bsp_flash.c
View File

@ -86,7 +86,7 @@ struct flash_sever_info sever_info =
.server_port = SYS_IOT_PORT, .server_port = SYS_IOT_PORT,
}; };
static void BSP_Flash_UnLock(void) static void BSP_Flash_UnLock (void)
{ {
#if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE) #if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE)
RCC->CFGR0 |= (uint32_t)RCC_HPRE_DIV2; RCC->CFGR0 |= (uint32_t)RCC_HPRE_DIV2;
@ -96,17 +96,17 @@ static void BSP_Flash_UnLock(void)
FLASH_Unlock(); FLASH_Unlock();
} }
static void BSP_Flash_Lock(void) static void BSP_Flash_Lock (void)
{ {
FLASH_Lock(); FLASH_Lock();
#if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE) #if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE)
RCC->CFGR0 &= ~(uint32_t)RCC_HPRE_DIV2; RCC->CFGR0 &= ~(uint32_t)RCC_HPRE_DIV2;
#endif #endif
rt_hw_interrupt_enable(interrupt_value); rt_hw_interrupt_enable (interrupt_value);
} }
static void BSP_Flash_FastUnLock(void) static void BSP_Flash_FastUnLock (void)
{ {
#if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE) #if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE)
RCC->CFGR0 |= (uint32_t)RCC_HPRE_DIV2; RCC->CFGR0 |= (uint32_t)RCC_HPRE_DIV2;
@ -116,17 +116,17 @@ static void BSP_Flash_FastUnLock(void)
FLASH_Unlock_Fast(); FLASH_Unlock_Fast();
} }
static void BSP_Flash_FastLock(void) static void BSP_Flash_FastLock (void)
{ {
FLASH_Lock_Fast(); FLASH_Lock_Fast();
#if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE) #if (SystemCoreClock > SYSCLK_FREQ_96MHz_HSE)
RCC->CFGR0 &= ~(uint32_t)RCC_HPRE_DIV2; RCC->CFGR0 &= ~(uint32_t)RCC_HPRE_DIV2;
#endif #endif
rt_hw_interrupt_enable(interrupt_value); rt_hw_interrupt_enable (interrupt_value);
} }
static rt_size_t Flash_Read(rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len) static rt_size_t Flash_Read (rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len)
{ {
rt_size_t read_len = 0; rt_size_t read_len = 0;
@ -138,13 +138,13 @@ static rt_size_t Flash_Read(rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len)
return read_len; return read_len;
} }
int Get_IotImei(char *buf, rt_size_t len) int Get_IotImei (char *buf, rt_size_t len)
{ {
if ((*(rt_uint8_t *)FLASH_NB_IMEI_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_IMEI_ADDR != 0x39)) if ((*(rt_uint8_t *)FLASH_NB_IMEI_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_IMEI_ADDR != 0x39))
{ {
rt_memcpy(buf, (char *)FLASH_NB_IMEI_ADDR, len); rt_memcpy (buf, (char *)FLASH_NB_IMEI_ADDR, len);
LOG_D("NB IMEI: %s", buf); LOG_D ("NB IMEI: %s", buf);
return 0; return 0;
} }
else else
@ -154,18 +154,18 @@ int Get_IotImei(char *buf, rt_size_t len)
{ {
buf[i] = '0'; buf[i] = '0';
} }
LOG_D("NB IMSI: %s", buf); LOG_D ("NB IMSI: %s", buf);
return -1; return -1;
} }
} }
int Get_IotImsi(char *buf, rt_size_t len) int Get_IotImsi (char *buf, rt_size_t len)
{ {
if ((*(rt_uint8_t *)FLASH_NB_IMSI_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_IMSI_ADDR != 0x39)) if ((*(rt_uint8_t *)FLASH_NB_IMSI_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_IMSI_ADDR != 0x39))
{ {
rt_memcpy(buf, (char *)FLASH_NB_IMSI_ADDR, len); rt_memcpy (buf, (char *)FLASH_NB_IMSI_ADDR, len);
LOG_D("NB IMSI: %s", buf); LOG_D ("NB IMSI: %s", buf);
return 0; return 0;
} }
else else
@ -175,18 +175,18 @@ int Get_IotImsi(char *buf, rt_size_t len)
{ {
buf[i] = '0'; buf[i] = '0';
} }
LOG_D("NB IMSI: %s", buf); LOG_D ("NB IMSI: %s", buf);
return -1; return -1;
} }
} }
int Get_IotIccid(char *buf, rt_size_t len) int Get_IotIccid (char *buf, rt_size_t len)
{ {
if ((*(rt_uint8_t *)FLASH_NB_ICCID_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_ICCID_ADDR != 0x39)) if ((*(rt_uint8_t *)FLASH_NB_ICCID_ADDR != 0xE3) && (*(rt_uint8_t *)FLASH_NB_ICCID_ADDR != 0x39))
{ {
rt_memcpy(buf, (char *)FLASH_NB_ICCID_ADDR, len); rt_memcpy (buf, (char *)FLASH_NB_ICCID_ADDR, len);
LOG_D("NB ICCID: %s", buf); LOG_D ("NB ICCID: %s", buf);
return 0; return 0;
} }
else else
@ -196,7 +196,7 @@ int Get_IotIccid(char *buf, rt_size_t len)
{ {
buf[i] = '0'; buf[i] = '0';
} }
LOG_D("NB ICCID: %s", buf); LOG_D ("NB ICCID: %s", buf);
return -1; return -1;
} }
} }
@ -208,28 +208,28 @@ int Get_IotIccid(char *buf, rt_size_t len)
* @param {size_t} len * @param {size_t} len
* @return {*} * @return {*}
*/ */
static rt_size_t Flash_Write(rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len) static rt_size_t Flash_Write (rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len)
{ {
rt_size_t i = 0; rt_size_t i = 0;
__attribute__((aligned(2))) rt_uint16_t write_data; __attribute__ ((aligned (2))) rt_uint16_t write_data;
if (addr % 2 != 0) if (addr % 2 != 0)
return 0; return 0;
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_WRPRTERR); FLASH_ClearFlag (FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_WRPRTERR);
BSP_Flash_UnLock(); BSP_Flash_UnLock();
for (i = 0; i < len; i += 2, buf += 2, addr += 2) for (i = 0; i < len; i += 2, buf += 2, addr += 2)
{ {
rt_memcpy(&write_data, buf, 2); rt_memcpy (&write_data, buf, 2);
FLASH_ProgramHalfWord(addr, write_data); FLASH_ProgramHalfWord (addr, write_data);
/* You can add your code under here. */ /* You can add your code under here. */
if (*(rt_uint16_t *)addr != write_data) if (*(rt_uint16_t *)addr != write_data)
{ {
BSP_Flash_Lock(); BSP_Flash_Lock();
LOG_E("Flash_Write Error"); LOG_E ("Flash_Write Error");
return 0; return 0;
} }
} }
@ -239,54 +239,54 @@ static rt_size_t Flash_Write(rt_uint32_t addr, rt_uint8_t *buf, rt_size_t len)
return i; return i;
} }
int BSP_Flash_Write_Info(rt_uint8_t *buf, rt_size_t len) int BSP_Flash_Write_Info (rt_uint8_t *buf, rt_size_t len)
{ {
rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0}; rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0};
rt_uint8_t in_page_offset = (FLASH_HW_VER_ADDR - FLASH_CONFIG_INFO_START_ADDR); rt_uint8_t in_page_offset = (FLASH_HW_VER_ADDR - FLASH_CONFIG_INFO_START_ADDR);
Flash_ErasePage_ReadConfigInfo(page_buf); Flash_ErasePage_ReadConfigInfo (page_buf);
for (rt_uint8_t i = 0; i < len; i++) for (rt_uint8_t i = 0; i < len; i++)
{ {
page_buf[in_page_offset + i] = buf[i]; page_buf[in_page_offset + i] = buf[i];
} }
return Flash_Write_ConfigInfo(page_buf); return Flash_Write_ConfigInfo (page_buf);
} }
rt_uint16_t Flash_Get_WorkDuration(void) rt_uint16_t Flash_Get_WorkDuration (void)
{ {
return *(rt_uint16_t *)(FLASH_WORK_TIME_ADDR); return *(rt_uint16_t *)(FLASH_WORK_TIME_ADDR);
} }
int Flash_Set_WorkDuration(rt_uint16_t value) int Flash_Set_WorkDuration (rt_uint16_t value)
{ {
rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0}; rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0};
rt_uint8_t in_page_offset = (FLASH_WORK_TIME_ADDR - FLASH_CONFIG_INFO_START_ADDR); rt_uint8_t in_page_offset = (FLASH_WORK_TIME_ADDR - FLASH_CONFIG_INFO_START_ADDR);
Flash_ErasePage_ReadConfigInfo(page_buf); Flash_ErasePage_ReadConfigInfo (page_buf);
rt_memcpy(page_buf + in_page_offset, &value, FLASH_WORK_TIME_LEN); rt_memcpy (page_buf + in_page_offset, &value, FLASH_WORK_TIME_LEN);
return Flash_Write_ConfigInfo(page_buf); return Flash_Write_ConfigInfo (page_buf);
} }
int Flash_Get_Sever_Data(struct flash_sever_info *sever_info) int Flash_Get_Sever_Data (struct flash_sever_info *sever_info)
{ {
rt_uint8_t data[FLASH_SERVER_LEN] = {0}; rt_uint8_t data[FLASH_SERVER_LEN] = {0};
rt_memcpy(data, (rt_uint8_t *)FLASH_SERVER_ADDR_ADDR, FLASH_SERVER_LEN); rt_memcpy (data, (rt_uint8_t *)FLASH_SERVER_ADDR_ADDR, FLASH_SERVER_LEN);
LOG_D("data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x", 0, data[0], 1, data[1], 2, data[2], 3, data[3], 4, data[4], 5, data[5]); LOG_D ("data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x", 0, data[0], 1, data[1], 2, data[2], 3, data[3], 4, data[4], 5, data[5]);
rt_snprintf(sever_info->server_url, sizeof(sever_info->server_url), "%d.%d.%d.%d", rt_snprintf (sever_info->server_url, sizeof (sever_info->server_url), "%d.%d.%d.%d",
data[3], data[2], data[1], data[0]); data[3], data[2], data[1], data[0]);
rt_uint16_t port_num = ((data[5] << 8) | data[4]); rt_uint16_t port_num = ((data[5] << 8) | data[4]);
LOG_D("port_num = %d", port_num); LOG_D ("port_num = %d", port_num);
rt_snprintf(sever_info->server_port, sizeof(sever_info->server_port), "%d", port_num); rt_snprintf (sever_info->server_port, sizeof (sever_info->server_port), "%d", port_num);
LOG_D("server_url:%s, server_port:%s", sever_info->server_url, sever_info->server_port); LOG_D ("server_url:%s, server_port:%s", sever_info->server_url, sever_info->server_port);
return 0; return 0;
} }
int Flash_Set_Sever_Data(rt_uint8_t *data) int Flash_Set_Sever_Data (rt_uint8_t *data)
{ {
rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0}; rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0};
rt_uint8_t in_page_offset = (FLASH_SERVER_ADDR_ADDR - FLASH_CONFIG_INFO_START_ADDR); rt_uint8_t in_page_offset = (FLASH_SERVER_ADDR_ADDR - FLASH_CONFIG_INFO_START_ADDR);
@ -295,14 +295,14 @@ int Flash_Set_Sever_Data(rt_uint8_t *data)
return -RT_ERROR; return -RT_ERROR;
} }
Flash_ErasePage_ReadConfigInfo(page_buf); Flash_ErasePage_ReadConfigInfo (page_buf);
//*将传入的数据写到flash地址中 //*将传入的数据写到flash地址中
for (size_t i = 0; i < FLASH_SERVER_LEN; i++) for (size_t i = 0; i < FLASH_SERVER_LEN; i++)
{ {
page_buf[in_page_offset++] = data[i]; page_buf[in_page_offset++] = data[i];
} }
return Flash_Write_ConfigInfo(page_buf); return Flash_Write_ConfigInfo (page_buf);
} }
/** /**
@ -311,7 +311,7 @@ int Flash_Set_Sever_Data(rt_uint8_t *data)
* @param {uint8_t} page * @param {uint8_t} page
* @return {*} * @return {*}
*/ */
static ErrorStatus Flash_ErasePage_Records(TeRecord record, static ErrorStatus Flash_ErasePage_Records (TeRecord record,
rt_uint8_t page_offset) rt_uint8_t page_offset)
{ {
ErrorStatus flag = READY; ErrorStatus flag = READY;
@ -328,7 +328,7 @@ static ErrorStatus Flash_ErasePage_Records(TeRecord record,
} }
BSP_Flash_FastUnLock(); BSP_Flash_FastUnLock();
FLASH_ErasePage_Fast(hr_start_addr[record] + FLASH_PAGE_SIZE * erase_page); FLASH_ErasePage_Fast (hr_start_addr[record] + FLASH_PAGE_SIZE * erase_page);
BSP_Flash_FastLock(); BSP_Flash_FastLock();
for (rt_uint8_t i = 0; i < (FLASH_PAGE_SIZE / 2); i++) for (rt_uint8_t i = 0; i < (FLASH_PAGE_SIZE / 2); i++)
@ -339,19 +339,19 @@ static ErrorStatus Flash_ErasePage_Records(TeRecord record,
} }
} }
LOG_D("/**Flash_Erase(%d)Page(%d)=%d**/", record, erase_page, flag); LOG_D ("/**Flash_Erase(%d)Page(%d)=%d**/", record, erase_page, flag);
return flag; return flag;
} }
void Flash_Erase_Records(TeRecord record) void Flash_Erase_Records (TeRecord record)
{ {
for (rt_uint8_t erase_page = 0; erase_page < hr_record_pages[record]; for (rt_uint8_t erase_page = 0; erase_page < hr_record_pages[record];
erase_page++) erase_page++)
{ {
Flash_ErasePage_Records(record, erase_page); Flash_ErasePage_Records (record, erase_page);
} }
LOG_D("Flash_Erase_Records(%d)", record); LOG_D ("Flash_Erase_Records(%d)", record);
} }
/* /*
@ -359,7 +359,7 @@ void Flash_Erase_Records(TeRecord record)
* @param {TeRecord} record * @param {TeRecord} record
* @return {*} * @return {*}
*/ */
static rt_uint16_t Flash_GetMaxIndex_Records(TeRecord record) static rt_uint16_t Flash_GetMaxIndex_Records (TeRecord record)
{ {
rt_uint16_t index_max = 0; rt_uint16_t index_max = 0;
@ -370,13 +370,13 @@ static rt_uint16_t Flash_GetMaxIndex_Records(TeRecord record)
if (*(rt_uint16_t *)(hr_start_addr[record] + FLASH_PAGE_SIZE * page + FLASH_HR_ONE_RECORD_SIZE * i) == HR_RECORD_FRAME_HEADER) if (*(rt_uint16_t *)(hr_start_addr[record] + FLASH_PAGE_SIZE * page + FLASH_HR_ONE_RECORD_SIZE * i) == HR_RECORD_FRAME_HEADER)
{ {
index_max = index_max =
LWUTIL_MAX(index_max, LWUTIL_MAX (index_max,
*(rt_uint16_t *)(hr_start_addr[record] + FLASH_PAGE_SIZE * page + FLASH_HR_ONE_RECORD_SIZE * i + 2)); *(rt_uint16_t *)(hr_start_addr[record] + FLASH_PAGE_SIZE * page + FLASH_HR_ONE_RECORD_SIZE * i + 2));
} }
} }
} }
LOG_D("Flash_Get_Records(%d)MaxNum = %d", record, index_max); LOG_D ("Flash_Get_Records(%d)MaxNum = %d", record, index_max);
return index_max; return index_max;
} }
@ -386,10 +386,10 @@ static rt_uint16_t Flash_GetMaxIndex_Records(TeRecord record)
* @param {TeRecord} record * @param {TeRecord} record
* @return {*} * @return {*}
*/ */
rt_uint8_t Flash_GetNum_Records(TeRecord record) rt_uint8_t Flash_GetNum_Records (TeRecord record)
{ {
rt_uint8_t num = 0; rt_uint8_t num = 0;
rt_uint16_t num_max = Flash_GetMaxIndex_Records(record); rt_uint16_t num_max = Flash_GetMaxIndex_Records (record);
if (num_max <= hr_record_max_num[record]) if (num_max <= hr_record_max_num[record])
{ {
@ -400,7 +400,7 @@ rt_uint8_t Flash_GetNum_Records(TeRecord record)
num = hr_record_max_num[record]; num = hr_record_max_num[record];
} }
LOG_D("Flash_GetNum_(%d)Records = %d", record, num); LOG_D ("Flash_GetNum_(%d)Records = %d", record, num);
return num; return num;
} }
@ -412,11 +412,11 @@ rt_uint8_t Flash_GetNum_Records(TeRecord record)
* @param {uint8_t} index * @param {uint8_t} index
* @return {*} * @return {*}
*/ */
void Flash_Read_Record(TuFlashHrRecordFrame *pHrRecord, TeRecord record, void Flash_Read_Record (TuFlashHrRecordFrame *pHrRecord, TeRecord record,
rt_uint8_t index) rt_uint8_t index)
{ {
LOG_D("/*********Flash_Read_(%d)Record(%d)***************/", record, index); LOG_D ("/*********Flash_Read_(%d)Record(%d)***************/", record, index);
uint16_t index_max = Flash_GetMaxIndex_Records(record); uint16_t index_max = Flash_GetMaxIndex_Records (record);
rt_uint8_t page_offset = 0; rt_uint8_t page_offset = 0;
rt_uint8_t in_page_offset = 0; rt_uint8_t in_page_offset = 0;
@ -429,7 +429,7 @@ void Flash_Read_Record(TuFlashHrRecordFrame *pHrRecord, TeRecord record,
{ {
// index_redirect = index_max - (hr_record_max_num[record] - index); // index_redirect = index_max - (hr_record_max_num[record] - index);
uint16_t index_redirect = index_max - (50 - index); uint16_t index_redirect = index_max - (50 - index);
LOG_D("index_redirect = %d", index_redirect); LOG_D ("index_redirect = %d", index_redirect);
page_offset = ((index_redirect - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; page_offset = ((index_redirect - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
in_page_offset = ((index_redirect - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE; in_page_offset = ((index_redirect - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE;
} }
@ -444,23 +444,23 @@ void Flash_Read_Record(TuFlashHrRecordFrame *pHrRecord, TeRecord record,
page_offset = ((index - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; page_offset = ((index - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
in_page_offset = ((index - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE; in_page_offset = ((index - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE;
} }
LOG_D("page_offset = %d", page_offset); LOG_D ("page_offset = %d", page_offset);
LOG_D("in_page_offset = %d", in_page_offset); LOG_D ("in_page_offset = %d", in_page_offset);
uint32_t addr = (hr_start_addr[record] + FLASH_PAGE_SIZE * page_offset + in_page_offset); uint32_t addr = (hr_start_addr[record] + FLASH_PAGE_SIZE * page_offset + in_page_offset);
LOG_D("addr = %04X", addr); LOG_D ("addr = %04X", addr);
Flash_Read(addr, pHrRecord->buf, HR_RECORD_FRAME_LEN); Flash_Read (addr, pHrRecord->buf, HR_RECORD_FRAME_LEN);
LOG_D("Flash_Read_(%d)Record(%d):%04d-%02d-%02d,%02d:%02d", record, LOG_D ("Flash_Read_(%d)Record(%d):%04d-%02d-%02d,%02d:%02d", record,
index, pHrRecord->Struct.year, pHrRecord->Struct.month, index, pHrRecord->Struct.year, pHrRecord->Struct.month,
pHrRecord->Struct.day, pHrRecord->Struct.hour, pHrRecord->Struct.day, pHrRecord->Struct.hour,
pHrRecord->Struct.minute); pHrRecord->Struct.minute);
} }
else else
{ {
rt_memset(pHrRecord->buf, 0, HR_RECORD_FRAME_LEN); rt_memset (pHrRecord->buf, 0, HR_RECORD_FRAME_LEN);
LOG_E("Flash_GetMaxNum_(%d)Records Error!: (index_max)%d < %d", record, LOG_E ("Flash_GetMaxNum_(%d)Records Error!: (index_max)%d < %d", record,
index_max, index); index_max, index);
} }
} }
@ -471,37 +471,37 @@ void Flash_Read_Record(TuFlashHrRecordFrame *pHrRecord, TeRecord record,
* @param {uint16_t} index * @param {uint16_t} index
* @return {*} * @return {*}
*/ */
void Flash_Write_RecordIndex(TuFlashHrRecordFrame *pHrRecord, TeRecord record, void Flash_Write_RecordIndex (TuFlashHrRecordFrame *pHrRecord, TeRecord record,
rt_uint16_t index) rt_uint16_t index)
{ {
LOG_D("/*********Flash_Write_RecordIndex***************/"); LOG_D ("/*********Flash_Write_RecordIndex***************/");
rt_uint8_t page_offset = ((index - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; rt_uint8_t page_offset = ((index - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
LOG_D("page_offset = %d", page_offset); LOG_D ("page_offset = %d", page_offset);
rt_uint8_t in_page_offset = ((index - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE; rt_uint8_t in_page_offset = ((index - 1) % FLASH_PAGE_HR_RECORD_NUM) * FLASH_HR_ONE_RECORD_SIZE;
LOG_D("in_page_offset = %d", in_page_offset); LOG_D ("in_page_offset = %d", in_page_offset);
rt_uint32_t addr = (hr_start_addr[record] + FLASH_PAGE_SIZE * page_offset + in_page_offset); rt_uint32_t addr = (hr_start_addr[record] + FLASH_PAGE_SIZE * page_offset + in_page_offset);
LOG_D("addr = %04X", addr); LOG_D ("addr = %04X", addr);
Flash_Write(addr, pHrRecord->buf, HR_RECORD_FRAME_LEN); Flash_Write (addr, pHrRecord->buf, HR_RECORD_FRAME_LEN);
TuFlashHrRecordFrame pReadRecord; TuFlashHrRecordFrame pReadRecord;
Flash_Read(addr, pReadRecord.buf, HR_RECORD_FRAME_LEN); Flash_Read (addr, pReadRecord.buf, HR_RECORD_FRAME_LEN);
LOG_D("(%04X)Flash_Write_(%d)RecordIndex(%d):%04d-%02d-%02d,%02d:%02d", LOG_D ("(%04X)Flash_Write_(%d)RecordIndex(%d):%04d-%02d-%02d,%02d:%02d",
pReadRecord.Struct.header, record, pReadRecord.Struct.index, pReadRecord.Struct.header, record, pReadRecord.Struct.index,
pReadRecord.Struct.year, pReadRecord.Struct.month, pReadRecord.Struct.year, pReadRecord.Struct.month,
pReadRecord.Struct.day, pReadRecord.Struct.hour, pReadRecord.Struct.day, pReadRecord.Struct.hour,
pReadRecord.Struct.minute); pReadRecord.Struct.minute);
} }
void Flash_Write_Record(TeRecord record) void Flash_Write_Record (TeRecord record)
{ {
LOG_D("/*********Flash_Write_Record***************/"); LOG_D ("/*********Flash_Write_Record***************/");
rt_uint16_t index_max = Flash_GetMaxIndex_Records(record); rt_uint16_t index_max = Flash_GetMaxIndex_Records (record);
rt_uint16_t index_new = index_max + 1; rt_uint16_t index_new = index_max + 1;
LOG_D("index_new = %d", index_new); LOG_D ("index_new = %d", index_new);
rt_uint16_t index_start; rt_uint16_t index_start;
rt_uint8_t index_start_page_offset; rt_uint8_t index_start_page_offset;
@ -514,28 +514,28 @@ void Flash_Write_Record(TeRecord record)
index_start = 0; index_start = 0;
index_start_page_offset = 0; index_start_page_offset = 0;
index_max_page_offset = ((index_max - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; index_max_page_offset = ((index_max - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
LOG_D("index_max_page_offset = %d", index_max_page_offset); LOG_D ("index_max_page_offset = %d", index_max_page_offset);
} }
else else
{ {
index_start = index_max - (hr_record_max_num[record] - 1); index_start = index_max - (hr_record_max_num[record] - 1);
LOG_D("index_start = %d", index_start); LOG_D ("index_start = %d", index_start);
index_start_page_offset = ((index_start - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; index_start_page_offset = ((index_start - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
LOG_D("index_start_page_offset = %d", index_start_page_offset); LOG_D ("index_start_page_offset = %d", index_start_page_offset);
index_max_page_offset = ((index_max - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record]; index_max_page_offset = ((index_max - 1) / FLASH_PAGE_HR_RECORD_NUM) % hr_record_pages[record];
} }
index_max_in_page_offset = (index_max - 1) % FLASH_PAGE_HR_RECORD_NUM; index_max_in_page_offset = (index_max - 1) % FLASH_PAGE_HR_RECORD_NUM;
LOG_D("index_max_in_page_offset = %d", index_max_in_page_offset); LOG_D ("index_max_in_page_offset = %d", index_max_in_page_offset);
if ((index_max_in_page_offset + 1) == (FLASH_PAGE_HR_RECORD_NUM - 1) && index_max_page_offset == (hr_record_pages[record] - 1)) if ((index_max_in_page_offset + 1) == (FLASH_PAGE_HR_RECORD_NUM - 1) && index_max_page_offset == (hr_record_pages[record] - 1))
{ {
Flash_ErasePage_Records(record, 0); Flash_ErasePage_Records (record, 0);
} }
else if ((index_max_in_page_offset + 1) == (FLASH_PAGE_HR_RECORD_NUM - 1) && index_max_page_offset == index_start_page_offset - 1) else if ((index_max_in_page_offset + 1) == (FLASH_PAGE_HR_RECORD_NUM - 1) && index_max_page_offset == index_start_page_offset - 1)
{ {
Flash_ErasePage_Records(record, index_max_page_offset + 1); Flash_ErasePage_Records (record, index_max_page_offset + 1);
} }
RTC_GetTime(); RTC_GetTime();
@ -549,30 +549,30 @@ void Flash_Write_Record(TeRecord record)
HrRecord.Struct.hour = RtcDateTime.hour; HrRecord.Struct.hour = RtcDateTime.hour;
HrRecord.Struct.minute = RtcDateTime.minute; HrRecord.Struct.minute = RtcDateTime.minute;
Flash_Write_RecordIndex(&HrRecord, record, index_new); Flash_Write_RecordIndex (&HrRecord, record, index_new);
} }
void Flash_ErasePage_ConfigInfo(void) void Flash_ErasePage_ConfigInfo (void)
{ {
BSP_Flash_FastUnLock(); BSP_Flash_FastUnLock();
FLASH_ErasePage_Fast(FLASH_CONFIG_INFO_START_ADDR); FLASH_ErasePage_Fast (FLASH_CONFIG_INFO_START_ADDR);
BSP_Flash_FastLock(); BSP_Flash_FastLock();
} }
void Flash_ErasePage_ReadConfigInfo(rt_uint8_t *page_buf) void Flash_ErasePage_ReadConfigInfo (rt_uint8_t *page_buf)
{ {
Flash_Read(FLASH_CONFIG_INFO_START_ADDR, page_buf, FLASH_PAGE_SIZE); Flash_Read (FLASH_CONFIG_INFO_START_ADDR, page_buf, FLASH_PAGE_SIZE);
rt_thread_mdelay(10); rt_thread_mdelay (10);
Flash_ErasePage_ConfigInfo(); Flash_ErasePage_ConfigInfo();
rt_thread_mdelay(10); rt_thread_mdelay (10);
} }
int Flash_Write_ConfigInfo(rt_uint8_t *page_buf) int Flash_Write_ConfigInfo (rt_uint8_t *page_buf)
{ {
return Flash_Write(FLASH_CONFIG_INFO_START_ADDR, page_buf, FLASH_PAGE_SIZE); return Flash_Write (FLASH_CONFIG_INFO_START_ADDR, page_buf, FLASH_PAGE_SIZE);
} }
ErrorStatus Flash_GetProductTimeLimit(TuFlashProductTimeLimitFrame *pLimitTime, ErrorStatus Flash_GetProductTimeLimit (TuFlashProductTimeLimitFrame *pLimitTime,
TeFlashProductTimeLimitId id) TeFlashProductTimeLimitId id)
{ {
ErrorStatus flag = NoREADY; ErrorStatus flag = NoREADY;
@ -588,33 +588,33 @@ ErrorStatus Flash_GetProductTimeLimit(TuFlashProductTimeLimitFrame *pLimitTime,
} }
if (addr != 0) if (addr != 0)
{ {
Flash_Read(addr, pLimitTime->buf, sizeof(TuFlashProductTimeLimitFrame)); Flash_Read (addr, pLimitTime->buf, sizeof (TuFlashProductTimeLimitFrame));
if (pLimitTime->Struct.header == FLASH_PRODUCT_TIME_FRAME_HEADER) if (pLimitTime->Struct.header == FLASH_PRODUCT_TIME_FRAME_HEADER)
{ {
flag = READY; flag = READY;
LOG_D("Flash_GetProductTimeLimit(%d):%04d-%02d-%02d,%02d:%02d:%02d", LOG_D ("Flash_GetProductTimeLimit(%d):%04d-%02d-%02d,%02d:%02d:%02d",
id, pLimitTime->Struct.year, pLimitTime->Struct.month, id, pLimitTime->Struct.year, pLimitTime->Struct.month,
pLimitTime->Struct.day, pLimitTime->Struct.hour, pLimitTime->Struct.day, pLimitTime->Struct.hour,
pLimitTime->Struct.minute, pLimitTime->Struct.second); pLimitTime->Struct.minute, pLimitTime->Struct.second);
} }
else else
{ {
LOG_E("Flash_GetProductTimeLimit Error!"); LOG_E ("Flash_GetProductTimeLimit Error!");
} }
} }
return flag; return flag;
} }
void Flash_SetProductTimeLimit(rt_uint16_t year, rt_uint8_t mon, rt_uint8_t day, void Flash_SetProductTimeLimit (rt_uint16_t year, rt_uint8_t mon, rt_uint8_t day,
rt_uint8_t hour, rt_uint8_t min, rt_uint8_t second, rt_uint8_t hour, rt_uint8_t min, rt_uint8_t second,
TeFlashProductTimeLimitId id) TeFlashProductTimeLimitId id)
{ {
TuFlashProductTimeLimitFrame LimitTime; TuFlashProductTimeLimitFrame LimitTime;
rt_uint8_t page_buf[FLASH_PAGE_SIZE]; rt_uint8_t page_buf[FLASH_PAGE_SIZE];
Flash_ErasePage_ReadConfigInfo(page_buf); Flash_ErasePage_ReadConfigInfo (page_buf);
LimitTime.Struct.header = FLASH_PRODUCT_TIME_FRAME_HEADER; LimitTime.Struct.header = FLASH_PRODUCT_TIME_FRAME_HEADER;
LimitTime.Struct.year = year; LimitTime.Struct.year = year;
@ -634,25 +634,22 @@ void Flash_SetProductTimeLimit(rt_uint16_t year, rt_uint8_t mon, rt_uint8_t day,
in_page_offset = (FLASH_EXPIRATION_TIME_START_ADDR - FLASH_CONFIG_INFO_START_ADDR); in_page_offset = (FLASH_EXPIRATION_TIME_START_ADDR - FLASH_CONFIG_INFO_START_ADDR);
} }
for (rt_uint8_t i = 0; i < sizeof(TuFlashProductTimeLimitFrame); i++) for (rt_uint8_t i = 0; i < sizeof (TuFlashProductTimeLimitFrame); i++)
{ {
page_buf[in_page_offset + i] = LimitTime.buf[i]; page_buf[in_page_offset + i] = LimitTime.buf[i];
} }
Flash_Write_ConfigInfo(page_buf); Flash_Write_ConfigInfo (page_buf);
TuFlashProductTimeLimitFrame ReadLimitTime;
Flash_GetProductTimeLimit(&ReadLimitTime, id);
} }
void Set_ExpirationTime(rt_uint16_t days) void Set_ExpirationTime (rt_uint16_t days)
{ {
uint32_t factory_seconds, expiration_seconds; uint32_t factory_seconds, expiration_seconds;
TuFlashProductTimeLimitFrame LimitTime; TuFlashProductTimeLimitFrame LimitTime;
if (Flash_GetProductTimeLimit(&LimitTime, kFactoryTimeId) == READY) if (Flash_GetProductTimeLimit (&LimitTime, kFactoryTimeId) == READY)
{ {
factory_seconds = DateTime2Seconds(LimitTime.Struct.year, factory_seconds = DateTime2Seconds (LimitTime.Struct.year,
LimitTime.Struct.month, LimitTime.Struct.day, LimitTime.Struct.month, LimitTime.Struct.day,
LimitTime.Struct.hour, LimitTime.Struct.minute, LimitTime.Struct.hour, LimitTime.Struct.minute,
LimitTime.Struct.second); LimitTime.Struct.second);
@ -660,32 +657,24 @@ void Set_ExpirationTime(rt_uint16_t days)
expiration_seconds = factory_seconds + days * 24 * 3600; expiration_seconds = factory_seconds + days * 24 * 3600;
TsRtcDateTime DateTime; TsRtcDateTime DateTime;
Seconds2DateTime(expiration_seconds, &DateTime); Seconds2DateTime (expiration_seconds, &DateTime);
Flash_SetProductTimeLimit(DateTime.year, DateTime.month, DateTime.day, Flash_SetProductTimeLimit (DateTime.year, DateTime.month, DateTime.day,
DateTime.hour, DateTime.minute, DateTime.second, DateTime.hour, DateTime.minute, DateTime.second,
kExpirationTimeId); kExpirationTimeId);
if (Flash_GetProductTimeLimit(&LimitTime, kExpirationTimeId) == READY)
{
LOG_D("到期时间:%04d-%02d-%02d,%02d:%02d:%02d",
LimitTime.Struct.year, LimitTime.Struct.month,
LimitTime.Struct.day, LimitTime.Struct.hour,
LimitTime.Struct.minute, LimitTime.Struct.second);
}
} }
} }
rt_uint8_t Flash_Sys_Cfg(TeFlashCfgInfoId id, rt_uint8_t *buf, rt_size_t len) rt_uint8_t Flash_Sys_Cfg (TeFlashCfgInfoId id, rt_uint8_t *buf, rt_size_t len)
{ {
rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0}; rt_uint8_t page_buf[FLASH_PAGE_SIZE] = {0};
Flash_ErasePage_ReadConfigInfo(page_buf); Flash_ErasePage_ReadConfigInfo (page_buf);
rt_uint8_t in_page_offset = (hr_sys_cfg_info_addr[id] - FLASH_CONFIG_INFO_START_ADDR); rt_uint8_t in_page_offset = (hr_sys_cfg_info_addr[id] - FLASH_CONFIG_INFO_START_ADDR);
if (len > hr_sys_cfg_info_len[id]) if (len > hr_sys_cfg_info_len[id])
{ {
LOG_E("Flash_Sys_Cfg: id value too long ->%d", id); LOG_E ("Flash_Sys_Cfg: id value too long ->%d", id);
LOG_D("buf len %d > id len[%d]", len, hr_sys_cfg_info_len[id]); LOG_D ("buf len %d > id len[%d]", len, hr_sys_cfg_info_len[id]);
return -RT_ERROR; return -RT_ERROR;
} }
@ -694,11 +683,11 @@ rt_uint8_t Flash_Sys_Cfg(TeFlashCfgInfoId id, rt_uint8_t *buf, rt_size_t len)
page_buf[in_page_offset + i] = buf[i]; page_buf[in_page_offset + i] = buf[i];
} }
return Flash_Write_ConfigInfo(page_buf); return Flash_Write_ConfigInfo (page_buf);
} }
/*这个返回一两个字节的数，方便提取*/ /*这个返回一两个字节的数，方便提取*/
size_t Flash_Get_SysCfg(TeFlashCfgInfoId id) size_t Flash_Get_SysCfg (TeFlashCfgInfoId id)
{ {
rt_uint8_t iot_upload_cycle[2] = {0}; rt_uint8_t iot_upload_cycle[2] = {0};
rt_uint16_t iot_upload; rt_uint16_t iot_upload;
@ -708,31 +697,31 @@ size_t Flash_Get_SysCfg(TeFlashCfgInfoId id)
} }
else else
{ {
rt_memcpy(&iot_upload_cycle[0], (rt_uint8_t *)hr_sys_cfg_info_addr[id], 2); rt_memcpy (&iot_upload_cycle[0], (rt_uint8_t *)hr_sys_cfg_info_addr[id], 2);
iot_upload = ((iot_upload_cycle[0] << 8) + iot_upload_cycle[1]); iot_upload = ((iot_upload_cycle[0] << 8) + iot_upload_cycle[1]);
LOG_D("iot_upload: %d", iot_upload); LOG_D ("iot_upload: %d", iot_upload);
return iot_upload; return iot_upload;
} }
} }
ErrorStatus Flash_GetTotalRecord(TsTotalRecords *pTotalRecords) ErrorStatus Flash_GetTotalRecord (TsTotalRecords *pTotalRecords)
{ {
ErrorStatus flag = NoREADY; ErrorStatus flag = NoREADY;
pTotalRecords->alarm = Flash_GetNum_Records(kRecordAlarm); pTotalRecords->alarm = Flash_GetNum_Records (kRecordAlarm);
pTotalRecords->alarm_rcy = Flash_GetNum_Records(kRecordAlarmRcy); pTotalRecords->alarm_rcy = Flash_GetNum_Records (kRecordAlarmRcy);
pTotalRecords->fault = Flash_GetNum_Records(kRecordFault); pTotalRecords->fault = Flash_GetNum_Records (kRecordFault);
pTotalRecords->fault_rcy = Flash_GetNum_Records(kRecordFaultRcy); pTotalRecords->fault_rcy = Flash_GetNum_Records (kRecordFaultRcy);
pTotalRecords->power_failure = Flash_GetNum_Records(kRecordPowerDown); pTotalRecords->power_failure = Flash_GetNum_Records (kRecordPowerDown);
pTotalRecords->power_on = Flash_GetNum_Records(kRecordPowerOn); pTotalRecords->power_on = Flash_GetNum_Records (kRecordPowerOn);
pTotalRecords->sensor_failure = Flash_GetNum_Records(kRecordSensoEndOfLife); pTotalRecords->sensor_failure = Flash_GetNum_Records (kRecordSensoEndOfLife);
flag = READY; flag = READY;
return flag; return flag;
} }
ErrorStatus Flash_GetRecord(TeFrameC2 record_type, rt_uint8_t index, ErrorStatus Flash_GetRecord (TeFrameC2 record_type, rt_uint8_t index,
TsRecordsTime *pRecordsTime) TsRecordsTime *pRecordsTime)
{ {
ErrorStatus flag = NoREADY; ErrorStatus flag = NoREADY;
@ -740,9 +729,9 @@ ErrorStatus Flash_GetRecord(TeFrameC2 record_type, rt_uint8_t index,
if (kNumOfRecords < record_type && record_type < kGetCurrentTime) if (kNumOfRecords < record_type && record_type < kGetCurrentTime)
{ {
TuFlashHrRecordFrame pHrReadRecord; TuFlashHrRecordFrame pHrReadRecord;
Flash_Read_Record(&pHrReadRecord, record_type - 1, index); Flash_Read_Record (&pHrReadRecord, record_type - 1, index);
LOG_D("(%d)Flash_GetRecord(%d):%04d-%02d-%02d,%02d:%02d", LOG_D ("(%d)Flash_GetRecord(%d):%04d-%02d-%02d,%02d:%02d",
record_type - 1, pHrReadRecord.Struct.index, record_type - 1, pHrReadRecord.Struct.index,
pHrReadRecord.Struct.year, pHrReadRecord.Struct.month, pHrReadRecord.Struct.year, pHrReadRecord.Struct.month,
pHrReadRecord.Struct.day, pHrReadRecord.Struct.hour, pHrReadRecord.Struct.day, pHrReadRecord.Struct.hour,
@ -765,24 +754,23 @@ ErrorStatus Flash_GetRecord(TeFrameC2 record_type, rt_uint8_t index,
* @description: * @description:
* @return {*} * @return {*}
*/ */
void BSP_Flash_EraseRecodrs(void) void BSP_Flash_EraseRecodrs (void)
{ {
for (rt_uint8_t record = 0; record <= kRecordSensoEndOfLife; record++) for (rt_uint8_t record = 0; record <= kRecordSensoEndOfLife; record++)
{ {
for (rt_uint8_t i = 0; i < hr_record_pages[record]; i++) for (rt_uint8_t i = 0; i < hr_record_pages[record]; i++)
{ {
Flash_ErasePage_Records(record, i); Flash_ErasePage_Records (record, i);
} }
// LOG_D("/**BSP_Flash_First_Init (%d)**/", record);
} }
Flash_ErasePage_ConfigInfo(); Flash_ErasePage_ConfigInfo();
} }
int BSP_Flash_Init(void) int BSP_Flash_Init (void)
{ {
if (*(rt_uint16_t *)FLASH_INIT_FLAG_ADDR != FLASH_FIRST_INIT_VALUE) if (*(rt_uint16_t *)FLASH_INIT_FLAG_ADDR != FLASH_FIRST_INIT_VALUE)
{ {
LOG_D("BSP_Flash_EraseRecodrs!"); LOG_D ("BSP_Flash_EraseRecodrs!");
rt_uint8_t flash_init_flag[2]; rt_uint8_t flash_init_flag[2];
sys_config_info sci; sys_config_info sci;
rt_uint8_t sever_data[6] = {0}; rt_uint8_t sever_data[6] = {0};
@ -792,11 +780,20 @@ int BSP_Flash_Init(void)
BSP_Flash_EraseRecodrs(); BSP_Flash_EraseRecodrs();
Flash_Write(FLASH_INIT_FLAG_ADDR, flash_init_flag, Flash_Write (FLASH_INIT_FLAG_ADDR, flash_init_flag,
sizeof(flash_init_flag)); sizeof (flash_init_flag));
Flash_Set_WorkDuration (work_duration);
LOG_D ("work_duration:%d", Flash_Get_WorkDuration());
Flash_SetProductTimeLimit(2025, 1, 10, 13, 50, 20, kFactoryTimeId); Convert_To_Hex (&sever_info, sever_data);
Set_ExpirationTime(MAX_EXPIRATION_DAYS);
if (Flash_Set_Sever_Data (sever_data) <= 0)
{
LOG_D ("Flash_Set_Sever_Data error!");
}
Flash_SetProductTimeLimit (2025, 1, 10, 13, 50, 20, kFactoryTimeId);
Set_ExpirationTime (MAX_EXPIRATION_DAYS);
sci.hw_ver = SYS_HW_VERSION; sci.hw_ver = SYS_HW_VERSION;
sci.sw_ver = SYS_SW_VERSION; sci.sw_ver = SYS_SW_VERSION;
@ -808,180 +805,175 @@ int BSP_Flash_Init(void)
sci.emagnetic_switch = SYS_EMV_SWITCH; sci.emagnetic_switch = SYS_EMV_SWITCH;
sci.relay_switch = SYS_RELAY_SWITCH; sci.relay_switch = SYS_RELAY_SWITCH;
Flash_Set_WorkDuration(0); Flash_Write (FLASH_HW_VER_ADDR, (rt_uint8_t *)&sci,
LOG_D("work_duration:%d", Flash_Get_WorkDuration()); (sizeof (sys_config_info) - 50));
Convert_To_Hex(&sever_info, sever_data);
for (size_t i = 0; i < sizeof(sever_data); i++)
{
LOG_D("%02x", sever_data[i]);
}
if (Flash_Set_Sever_Data(sever_data) <= 0)
{
LOG_D("Flash_Set_Sever_Data error!");
}
Flash_Write(FLASH_HW_VER_ADDR, (rt_uint8_t *)&sci,
(sizeof(sys_config_info) - 50));
} }
return 0; return 0;
} }
#ifdef RT_USING_COMPONENTS_INIT #ifdef RT_USING_COMPONENTS_INIT
// INIT_BOARD_EXPORT(BSP_Flash_Init); INIT_PREV_EXPORT (BSP_Flash_Init);
#endif #endif
#ifdef TEST_ENABLE #ifdef TEST_ENABLE
static void TEST_Flash_GetMaxIndex_Records(int argc, char **argv) static void TEST_Flash_GetMaxIndex_Records (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
rt_uint8_t record = atoi(argv[1]); rt_uint8_t record = atoi (argv[1]);
LOG_D("Flash_GetMaxIndex_Records(%d) = %d", record, LOG_D ("Flash_GetMaxIndex_Records(%d) = %d", record,
Flash_GetMaxIndex_Records(record)); Flash_GetMaxIndex_Records (record));
} }
else else
{ {
LOG_E("TEST_Flash_GetMaxIndex_Records --use _cmd_ [record](0~6)"); LOG_E ("TEST_Flash_GetMaxIndex_Records --use _cmd_ [record](0~6)");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_GetMaxIndex_Records,
MSH_CMD_EXPORT (TEST_Flash_GetMaxIndex_Records,
"TEST_Flash_GetMaxIndex_Records"); "TEST_Flash_GetMaxIndex_Records");
static void TEST_Flash_Erase_Records(int argc, char **argv) static void TEST_Flash_Erase_Records (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int record = atoi(argv[1]); int record = atoi (argv[1]);
Flash_Erase_Records(record); Flash_Erase_Records (record);
} }
else else
{ {
LOG_E("TEST_Flash_Erase_Records --use _cmd_ [record](0~6)"); LOG_E ("TEST_Flash_Erase_Records --use _cmd_ [record](0~6)");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_Erase_Records, "TEST_Flash_Erase_Records");
static void TEST_Flash_Write_Record(int argc, char **argv) MSH_CMD_EXPORT (TEST_Flash_Erase_Records, "TEST_Flash_Erase_Records");
static void TEST_Flash_Write_Record (int argc, char **argv)
{ {
if (argc == 3) if (argc == 3)
{ {
int record = atoi(argv[1]); int record = atoi (argv[1]);
int num = atoi(argv[2]); int num = atoi (argv[2]);
for (rt_uint8_t i = 0; i < num; i++) for (rt_uint8_t i = 0; i < num; i++)
{ {
Flash_Write_Record(record); Flash_Write_Record (record);
rt_thread_mdelay(2); rt_thread_mdelay (2);
// BSP_WDG_Loop(); // BSP_WDG_Loop();
} }
} }
else else
{ {
LOG_E("TEST_Flash_Write_Record --use _cmd_ [record(0~6)] [num]"); LOG_E ("TEST_Flash_Write_Record --use _cmd_ [record(0~6)] [num]");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_Write_Record, "TEST_Flash_Write_Record");
static void TEST_Flash_GetNum_Records(int argc, char **argv) MSH_CMD_EXPORT (TEST_Flash_Write_Record, "TEST_Flash_Write_Record");
static void TEST_Flash_GetNum_Records (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int record = atoi(argv[1]); int record = atoi (argv[1]);
if (0 <= record && record <= 6) if (0 <= record && record <= 6)
{ {
LOG_D("TEST_Flash_GetNum_Records(%d) = %d", record, LOG_D ("TEST_Flash_GetNum_Records(%d) = %d", record,
Flash_GetNum_Records(record)); Flash_GetNum_Records (record));
} }
else else
{ {
LOG_E("TEST_Flash_GetNum_Records --use _cmd_ [record](0~6)"); LOG_E ("TEST_Flash_GetNum_Records --use _cmd_ [record](0~6)");
} }
} }
else else
{ {
LOG_E("TEST_Flash_GetNum_Records --use _cmd_ [record](0~6)"); LOG_E ("TEST_Flash_GetNum_Records --use _cmd_ [record](0~6)");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_GetNum_Records, "TEST_Flash_GetNum_Records");
static void TEST_Flash_GetProductTimeLimit(int argc, char **argv) MSH_CMD_EXPORT (TEST_Flash_GetNum_Records, "TEST_Flash_GetNum_Records");
static void TEST_Flash_GetProductTimeLimit (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int id = atoi(argv[1]); int id = atoi (argv[1]);
TuFlashProductTimeLimitFrame LimitTime; TuFlashProductTimeLimitFrame LimitTime;
Flash_GetProductTimeLimit(&LimitTime, id); Flash_GetProductTimeLimit (&LimitTime, id);
} }
else else
{ {
LOG_E( LOG_E (
"TEST_Flash_GetProductTimeLimit --use _cmd_ [id(0:FACTORY; 1:EXPIRATION)]"); "TEST_Flash_GetProductTimeLimit --use _cmd_ [id(0:FACTORY; 1:EXPIRATION)]");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_GetProductTimeLimit,
MSH_CMD_EXPORT (TEST_Flash_GetProductTimeLimit,
"TEST_Flash_GetProductTimeLimit"); "TEST_Flash_GetProductTimeLimit");
static void TEST_Flash_SetProductTimeLimit(int argc, char **argv) static void TEST_Flash_SetProductTimeLimit (int argc, char **argv)
{ {
if (argc == 8) if (argc == 8)
{ {
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]);
int id = atoi(argv[7]); int id = atoi (argv[7]);
Flash_SetProductTimeLimit(year, mon, day, hour, min, second, id); Flash_SetProductTimeLimit (year, mon, day, hour, min, second, id);
} }
else else
{ {
LOG_E( LOG_E (
"TEST_Flash_SetProductTimeLimit --use _cmd_ [y] [m] [d] [h] [m] [s] [id(0:FACTORY; 1:EXPIRATION)]"); "TEST_Flash_SetProductTimeLimit --use _cmd_ [y] [m] [d] [h] [m] [s] [id(0:FACTORY; 1:EXPIRATION)]");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_SetProductTimeLimit,
MSH_CMD_EXPORT (TEST_Flash_SetProductTimeLimit,
"TEST_Flash_SetProductTimeLimit"); "TEST_Flash_SetProductTimeLimit");
void Set_FactoryRtcTime(void) void Set_FactoryRtcTime (void)
{ {
RTC_GetTime(); RTC_GetTime();
LOG_D("%4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, LOG_D ("%4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month,
RtcDateTime.day, RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.day, RtcDateTime.hour, RtcDateTime.minute,
RtcDateTime.second); RtcDateTime.second);
Flash_SetProductTimeLimit(RtcDateTime.year, RtcDateTime.month, Flash_SetProductTimeLimit (RtcDateTime.year, RtcDateTime.month,
RtcDateTime.day, RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.day, RtcDateTime.hour, RtcDateTime.minute,
RtcDateTime.second, kFactoryTimeId); RtcDateTime.second, kFactoryTimeId);
} }
MSH_CMD_EXPORT(Set_FactoryRtcTime, "Use RTC time Set_FactoryRtcTime");
static void TEST_Flash_Set_ExpirationTime(int argc, char **argv) MSH_CMD_EXPORT (Set_FactoryRtcTime, "Use RTC time Set_FactoryRtcTime");
static void TEST_Flash_Set_ExpirationTime (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int days = atoi(argv[1]); int days = atoi (argv[1]);
Set_ExpirationTime(days); Set_ExpirationTime (days);
} }
else else
{ {
LOG_E("TEST_Flash_Set_ExpirationTime --use _cmd_ [days]"); LOG_E ("TEST_Flash_Set_ExpirationTime --use _cmd_ [days]");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_Set_ExpirationTime, "TEST_Flash_Set_ExpirationTime");
static void TEST_Flash_Get_Sys_Info(int argc, char **argv) MSH_CMD_EXPORT (TEST_Flash_Set_ExpirationTime, "TEST_Flash_Set_ExpirationTime");
static void TEST_Flash_Get_Sys_Info (int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {
int id = atoi(argv[1]); int id = atoi (argv[1]);
Flash_Get_SysCfg(id); Flash_Get_SysCfg (id);
} }
else else
{ {
LOG_E("TEST_Flash_Get_Sys_Info "); LOG_E ("TEST_Flash_Get_Sys_Info ");
} }
} }
MSH_CMD_EXPORT(TEST_Flash_Get_Sys_Info, "TEST_Flash_Get_Sys_Info");
MSH_CMD_EXPORT (TEST_Flash_Get_Sys_Info, "TEST_Flash_Get_Sys_Info");
#endif #endif

137
bsp/src/bsp_h308.c
View File

@ -229,51 +229,61 @@ uint8_t IS_H308_EndOfLife(void)
return H308.end_of_life; 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) static void h308_thread_entry(void *param)
{ {
// strstr要用，静态的才能算正确偏移 rt_err_t ret;
static uint8_t str[UART4_RX_RB_LENGTH] = {0}; static uint8_t str[UART4_RX_RB_LENGTH] = {0};
static uint8_t h308_rx_timout_cnt = 0; static uint8_t h308_rx_timout_cnt = 0;
static uint8_t h308_err_cnt = 0; static uint8_t h308_err_cnt = 0;
rt_err_t ret;
H308.alarm_value = Flash_Get_SysCfg(kAlarmLValueId); // 获取系统报警阈值 H308.alarm_value = Flash_Get_SysCfg(kAlarmLValueId); // 获取系统报警阈值
LOG_D("报警阈值:%d", H308.alarm_value); LOG_D("报警阈值:%d%LEL", 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);
}
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) while (1)
{ {
ret = rt_sem_take(uart4_rx_ok_sem, 3000); ret = rt_sem_take(uart4_rx_ok_sem, 3000);
@ -285,7 +295,7 @@ static void h308_thread_entry(void *param)
if (len >= 44) if (len >= 44)
{ {
ret = H308_GetFrameData(str, len, &H308.Data); ret = H308_GetFrameData((const char *)str, len, &H308.Data);
LOG_I("str:[%s]", str); LOG_I("str:[%s]", str);
if (ret == 0) 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) int BSP_H308_Init(void)
{ {
UART4_Init();
rt_pin_mode(H308_PWR_PIN, PIN_MODE_OUTPUT); rt_pin_mode(H308_PWR_PIN, PIN_MODE_OUTPUT);
rt_pin_mode(H308_RST_PIN, PIN_MODE_OUTPUT); rt_pin_mode(H308_RST_PIN, PIN_MODE_OUTPUT);
H308_PWR_OFF;
H308_RST_OFF; H308_RST_OFF;
H308_PWR_ON;
uart4_rx_ok_sem = rt_sem_create("uart4_rx", 0, RT_IPC_FLAG_FIFO); uart4_rx_ok_sem = rt_sem_create("uart4_rx", 0, RT_IPC_FLAG_FIFO);
if (uart4_rx_ok_sem == RT_NULL) if (uart4_rx_ok_sem == RT_NULL)
@ -398,7 +363,7 @@ int BSP_H308_Init(void)
{ {
LOG_E("uart4_rx_timer create failed"); LOG_E("uart4_rx_timer create failed");
} }
UART4_Init();
rt_err_t ret = rt_thread_init(&h308_thread, rt_err_t ret = rt_thread_init(&h308_thread,
"h308_thread", "h308_thread",
h308_thread_entry, h308_thread_entry,
@ -419,7 +384,7 @@ int BSP_H308_Init(void)
return ret; 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) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART4_IRQHandler(void) void UART4_IRQHandler(void)

27
bsp/src/bsp_hr.c
View File

@ -2,7 +2,7 @@
* @Author : stark1898y 1658608470@qq.com * @Author : stark1898y 1658608470@qq.com
* @Date : 2024-09-04 17:33:57 * @Date : 2024-09-04 17:33:57
* @LastEditors: mbw && 1600520629@qq.com * @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 * @FilePath: \JT-DT-YD4N02A_RTT_MRS-NT26K\bsp\src\bsp_hr.c
* @Description : * @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_uint8_t uart5_tx_rb_data[UART5_TX_RB_LENGTH];
static rt_sem_t uart5_rx_ok_sem; static rt_sem_t uart5_rx_ok_sem;
static rt_sem_t uart5_rx_parity_err_sem;
static rt_timer_t uart5_timer; static rt_timer_t uart5_timer;
uint8_t hr_rx_flag = 0; // 接收缓冲区中，已经收到的数据包数量 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) static void hr_thread_entry(void *param)
{ {
LOG_D("hr_thread_entry"); LOG_D("hr_thread_entry");
uint8_t rx_buff[64] = {0}; char rx_buff[64] = {0};
lwrb_reset(&uart5_rx_rb); lwrb_reset(&uart5_rx_rb);
lwrb_reset(&uart5_tx_rb); lwrb_reset(&uart5_tx_rb);
while (1) while (1)
{ {
rt_sem_take(uart5_rx_ok_sem, RT_WAITING_FOREVER); 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); uint8_t len = lwrb_get_full(&uart5_rx_rb);
lwrb_read(&uart5_rx_rb, rx_buff, len); 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) 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) 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) if (HostFrameData != RT_NULL)
{ {
LOG_HEX("HostFrameData", 16, &HostFrameData->data[0], HostFrameData->len); // 数据段 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); lwrb_reset(&uart5_rx_rb);
LOG_HEX("hr_rx_data:", 16, (rt_uint8_t *)&rx_buff[0], len);
rt_memset(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"); 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); uart5_timer = rt_timer_create("uart5_timeout", uart5_timeout, RT_NULL, 50, RT_TIMER_FLAG_PERIODIC);
if (uart5_timer == RT_NULL) if (uart5_timer == RT_NULL)
{ {
@ -634,10 +622,7 @@ void UART5_IRQHandler(void)
GET_INT_SP(); GET_INT_SP();
rt_interrupt_enter(); rt_interrupt_enter();
unsigned char data; 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) if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
{ {
data = USART_ReceiveData(UART5); 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); // INIT_APP_EXPORT(BSP_Nt26k_Thread_Init);
int nt26k_device_register (void) static int nt26k_device_register (void)
{ {
struct at_device_nt26k *nt26k = &_dev; struct at_device_nt26k *nt26k = &_dev;
@ -1585,6 +1585,6 @@ int nt26k_device_register (void)
(void *)nt26k); (void *)nt26k);
} }
// INIT_COMPONENT_EXPORT(nt26k_device_register); INIT_COMPONENT_EXPORT(nt26k_device_register);
#endif // IOT_MODULE_SWITCH #endif // IOT_MODULE_SWITCH