/* * Copyright (c) 2006-2021, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Logs: * Date Author Notes * 2024-08-16 RuoFeng the first version */ /*********************↓ define ↓************************/ #define DBG_ENABLE #define DBG_COLOR #define DBG_TAG "tn" #define DBG_LEVEL DBG_INFO #include #define LOG_INR 10 // 默认的log打印间隔(作用域在本文件) #define RTU_OFF_MAX 180 #define WAIT_NET_MAX 150 #define ENABLE_WORK (Check_Allow_Work() == res_ok) #define NEW_TIMESTAMP tm_to_timestamp() /*********************↑ define ↑************************/ /** * * * * * */ /*********************↓ include ↓************************/ #include "Work_TN.h" #include "rs485.h" #include "control.h" #include "test.h" #include #include "dtu_uart2.h" /*********************↑ include ↑************************/ /** * * * * * */ /*********************↓ extern ↓************************/ extern Temporal_list Check_Work_time_period(uint8_t coll_ch); extern works_def ws_now; extern Device_Status_typedef device_status; extern void HMI_WRITE(char *fmt, ...); extern JD_Test_Sta jts; extern Res_def Mtor_Control_ZP(Motor_Ctl_type mct); extern Sensor sensor[MAX_SENSOR_NUM]; extern Temporal_list Check_Work_time_period_0oclock(void); extern RTC_DateTypeDef GetDate; extern RTC_TimeTypeDef GetTime; extern uint8_t ReFlash_RTC(void); extern void CTL_CAM1(void); extern uint32_t tm_to_timestamp(void); /*********************↑ extern ↑************************/ /** * * * * * */ /********************↓ declaration ↓***********************/ static void rtu1(void); static void rtu0(void); static char rturead(void); void Request_ntp(void); /********************↑ declaration ↑***********************/ /** * * * * * */ /*********************↓ global variables ↓************************/ static uint16_t takephoto_cnt = 0; // 拍照触发计数 static uint16_t wait_data_cnt = 0; // 上报数据计数 static uint32_t tm_data = 0; // 计算数据时间 static uint32_t tm_photo = 0; // 计算图片时间 volatile SYSCFG syscfg = {0}; // 系统配置 volatile Limit limit = {0}; // 各种控的开关和参数 volatile wm_Def workmode = TypeMAX_wx; // 工作模式 WorkMode_Def WorkModeList[TypeMAX_wx] = // 工作模式类型 { {RunTime_wx, "时控间隔模式"}, {RunTime_Tig_wx, "时控触发模式"}}; volatile uint16_t RayTigCnt = 0; // 红外触发计数 volatile static char RayTiged = 0; // 红外已触发过 volatile static char RayOneLess = 0; // 红外触发记录 volatile char CamFree = 1; // 相机空闲状态 volatile uint32_t INR_PIC = 0; // 图片上传间隔 volatile uint32_t INR_DAT = 0; // 图片上传间隔 volatile char stop_getinfo = 0; // dtuwrite时暂停 getinfo static uint8_t rain_exit = 0; // 雨控退出进度 volatile char errcnt_getinfo = 0; // err计数 // volatile char RTUGetUp = 0; // RTU上电开机 /*********************↑ global variables ↑************************/ /** * * * * * */ /** * @brief * * @return int8_t -1(超时) >1(进度百分比) */ // int8_t Get_luxworkTime(void) //{ // // ReFlash_RTC(); // // // // uint32_t start = 0, now = 0; // // // // start = lwork.start_time.Hours * 60 + lwork.start_time.Minutes; // // now = GetTime.Hours * 60 + GetTime.Minutes; // // // // if (abs(GetTime.Hours - lwork.start_time.Hours) >= 10 && GetTime.Hours < lwork.start_time.Hours) // // { // // now += 1440; // // } // // if ((now - start) > (limit.LuxTime * 60)) // // { // // return -2; // // } // // else // // { // // LOG_I("luxtime %d%% \n", ((now - start) * 100) / (limit.LuxTime * 60)); // // return ((now - start) * 100) / (limit.LuxTime * 60); // // } // // return -1; // } /** * @brief Get the Coll Info object * * @return uint8_t persen */ uint8_t GetCollInfo(void) { // uint16_t inr = 0; // (syscfg.photim >= 5) ? (inr = syscfg.photim - 1) : (inr = TakeINR); return (math_timestampe_NEW(&tm_photo) * 100) / (INR_PIC); } /** * @brief 获取晨曦模式工作进度 不在工作范围 返回负数 * * @return int8_t val(-1 未开始工作 -2 参数校验失败) */ int8_t Get_swork_percent(void) { uint32_t start = 0, end = 0, temp1 = 0, now = 0; now = GetTime.Hours * 3600 + GetTime.Minutes * 60 + GetTime.Seconds; start = device_status.collecting_sh1 * 3600; end = device_status.collecting_eh1 * 3600; if (now < start && now > end) { return -1; } if (device_status.collecting_sh1 > device_status.collecting_eh1) { end += (24 * 3600); } temp1 = end - start; // rt_kprintf("now %d ALL %d\n" , (now - start) , temp1); if (((now - start) > temp1) || ((now - start) * 100 / temp1) > 100) { return -3; } return (now - start) * 100 / temp1; } /** * @brief 确认当前工作模式 * */ void Get_work_mode(void) { /** * @brief 开始确认 * */ static uint8_t ENPrint = 1; wm_Def bak = workmode; if (syscfg.en_tigmode == 0) { workmode = RunTime_wx; if (ENPrint || bak != workmode) { rt_kprintf("\n 时控间隔模式 %d-%d 时 > %d\n\n", device_status.collecting_sh1, device_status.collecting_eh1, ws_now); bak = workmode; ENPrint = 0; } } else { workmode = RunTime_Tig_wx; if (ENPrint || bak != workmode) { rt_kprintf("\n 时控触发模式 %d-%d 时 > %d\n\n", device_status.collecting_sh1, device_status.collecting_eh1, ws_now); bak = workmode; ENPrint = 0; } } } #define Temp_Tig_MX 20 /** * @brief 检查是否允许工作 * * @return Caw_def 校验值 */ Caw_def Check_Allow_Work(void) { uint16_t log_en_inr = LOG_INR * 3; // 打印log的速度 数值越小 打印越频繁 static int16_t log_en_cnt = -1; rt_thread_mdelay(15); Get_work_mode(); /** * @brief 雨控 * */ if (device_status.rain_update == 1) // 还需要再改 { LOG_W("CAW:雨控\n"); device_status.rain_update = 0; if (device_status.rain_status == 0) { device_status.rain_status = 1; Mtor_Control_CM(mct_Foreward); // 关仓门 { Recode_e_code(e_rain_tig, 0, "进入雨控 关仓门"); char *rain_tig = makeJson_Warn("Rain Tig In", "STA"); DTU_Write("%s", rain_tig); rt_free(rain_tig); } } rain_exit = 90; rt_thread_mdelay(1000); return res_Rain; } else if (rain_exit > 0) { rain_exit--; if (rain_exit == 0) { LOG_W(" exit rain , open the door\n"); Mtor_Control_CM(mct_Reversal); // 开仓门 { Recode_e_code(e_rain_tig, 1, "退出雨控 开仓门"); device_status.rain_status = 0; char *rain_tig = makeJson_Warn("Rain Tig Out", "STA"); DTU_Write("%s", rain_tig); rt_free(rain_tig); } } else { LOG_W("ready to exit rain > %d\n", rain_exit); } rt_thread_mdelay(500); return res_Rain; } if (device_status.ds != 1) // 250327 新增 关机状态 { if (chk_log_time) { LOG_I("CAW:ds == 0\n"); } return res_PwrOff; } switch (workmode) { /** * @brief 时控模式 * */ case RunTime_wx: if ((device_status.collecting_sh1 == device_status.collecting_eh1) || (device_status.collecting_sh1 == 0 && device_status.collecting_eh1 == 24)) // 全天候牛马 { if (chk_log_time) { LOG_I("CAW:全天候牛马\n"); } } else if (device_status.collecting_eh1 < device_status.collecting_sh1) // 跨0点牛马 { if (Check_Work_time_period_0oclock() != tl_Center) { if (chk_log_time) { LOG_I("CAW:未在工作时间 0点\n"); } return res_Time; } } else // 正常牛马 { if (Check_Work_time_period(1) != tl_Center) { if (chk_log_time) { LOG_I("CAW:未在工作时间\n"); } return res_Time; } } break; /** * @brief 触发模式 * */ case RunTime_Tig_wx: if ((device_status.collecting_sh1 == device_status.collecting_eh1) || (device_status.collecting_sh1 == 0 && device_status.collecting_eh1 == 24)) // 全天候牛马 { if (chk_log_time) { LOG_I("CAW:全天候牛马\n"); } } else if (device_status.collecting_eh1 < device_status.collecting_sh1) // 跨0点牛马 { if (Check_Work_time_period_0oclock() != tl_Center) { if (chk_log_time) { LOG_I("CAW:未在工作时间 0点\n"); } return res_Time; } } else // 正常牛马 { if (Check_Work_time_period(1) != tl_Center) { if (chk_log_time) { LOG_I("CAW:未在工作时间\n"); } return res_Time; } } break; default: break; } static uint8_t temp_up_cnt = 0; static uint8_t temp_dn_cnt = 0; /** * @brief 温湿度 * */ // rt_kprintf("sensor[s_Temp].value %d Luxlimit %d\n" , sensor[s_Temp].value , limit.temp_up); if (sensor[s_Temp].online >= 1 && (sensor[s_Temp].value) > (limit.temp_up * 10) && limit.temhumEN == ON) { if (temp_up_cnt >= Temp_Tig_MX) { LOG_I("CAW:触发温控上限 %d\n", temp_up_cnt); return res_Temp; } temp_up_cnt++; rt_thread_mdelay(1000); // if (chk_log_time || 1) // { // LOG_I("CAW:温控上限 …%d\n", temp_up_cnt); // } if (temp_up_cnt >= Temp_Tig_MX) { if (device_status.temp_status == 0) { LOG_I("CAW:触发温控上限 %d\n", temp_up_cnt); } device_status.temp_status = 1; return res_Temp; } } else if (temp_up_cnt > 0) { temp_up_cnt--; rt_thread_mdelay(1000); if (temp_up_cnt == 0) { if (device_status.temp_status > 0) LOG_I("CAW:解除温控上限\n"); device_status.temp_status = 0; } } if (sensor[s_Temp].online >= 1 && (sensor[s_Temp].value) < (limit.temp_dw * 10) && limit.temhumEN == ON) { if (temp_dn_cnt >= Temp_Tig_MX) { return res_Temp; } // rt_kprintf("(sensor[s_Temp].value) %d (limit.temp_dw * 10) %d \n" , (sensor[s_Temp].value) , (limit.temp_dw * 10)); temp_dn_cnt++; rt_thread_mdelay(1000); // if (chk_log_time || 1) // { // LOG_I("CAW:温控下限 …%d\n", temp_dn_cnt); // } if (temp_dn_cnt >= Temp_Tig_MX) { temp_dn_cnt = 0; if (device_status.temp_status == 0) { LOG_I("CAW:触发温控下限 %d\n", temp_dn_cnt); } device_status.temp_status = 2; return res_Temp; } } else if (temp_dn_cnt > 0) { temp_dn_cnt--; rt_thread_mdelay(1000); if (temp_dn_cnt == 0) { if (device_status.temp_status > 0) LOG_I("CAW:解除温控下限\n"); device_status.temp_status = 0; } } /** * @brief 温湿度 * */ Check_TestFree(); return res_ok; } extern uint8_t stopreflashTakePhoto; extern uint8_t holdon_stareflash; /** * @brief 刷新工作状态 * */ void ReflashWorkSta(void) { if (ws_now >= ws_typemax) { rt_kprintf("ReflashWorkSta illegl wstype\n"); } if (holdon_stareflash) { return; } work_day_def work_day = {0}; switch (ws_now) { case ws_standby: HMI_WRITE("workSta.workinfo.txt=\"待机中...\""); break; // res_ok = 0, // 没问题 // res_Time, // 时控 // res_Light, // 光控 // res_TempH, // 温湿度 // res_Rain // 雨控 case ws_wait0: switch (Check_Allow_Work()) { case res_ok: HMI_WRITE("workSta.workinfo.txt=\"达到工作条件\""); break; case res_Time: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 时控\""); break; case res_Light: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 光控\""); break; case res_Temp: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 温控\""); break; case res_Humi: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 湿控\""); break; case res_Temp_D: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 温控(基于定位)\""); break; case res_Humi_D: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 湿控 (基于定位)\""); break; case res_Rain: HMI_WRITE("workSta.workinfo.txt=\"未达工作条件 - 雨控\""); break; default: HMI_WRITE("workSta.workinfo.txt=\"未达到工作条件 %d\"", Check_Allow_Work()); break; } break; case ws_start_coll: HMI_WRITE("workSta.workinfo.txt=\"STEP1:收集开始\""); break; case ws_wait_coll: HMI_WRITE("workSta.workinfo.txt=\"STEP2:等待收集完成 %d%%\"", GetCollInfo()); break; case ws_takephoto: HMI_WRITE("workSta.workinfo.txt=\"STEP3:开始拍照\""); break; case ws_jumptake: HMI_WRITE("workSta.workinfo.txt=\"STEP4:采集中途退出 %d\"", Check_Allow_Work()); break; case ws_flap: HMI_WRITE("workSta.workinfo.txt=\"STEP5:翻板中\""); break; case ws_once_finsh: HMI_WRITE("workSta.workinfo.txt=\"STEP6:单次工作循环结束\""); break; case ws_finsh: ef_get_env_blob("work_day", &work_day, sizeof(work_day), NULL); HMI_WRITE("workSta.workinfo.txt=\"今日工作周期结束 %02d.%02d.%02d\"", work_day.year % 100, work_day.month, work_day.day); break; default: break; } } static void TigTakePho(void) { device_status.work_status = 3; LOG_W("STEP3 :takephoto"); ws_now = ws_takephoto; ctr_led(ON); DTU_Write("takephoto.mp3"); // 延时 rt_thread_delay(1000); Hk_Take_io(); Request_ntp(); if (jts.switchled_test != ON && RunTime_wx == workmode) { ctr_led(OFF); } else { LOG_W("STEP4 :jump takephoto"); ws_now = ws_jumptake; rt_thread_delay(3000); if (jts.switchled_test != ON && RunTime_wx == workmode) { ctr_led(OFF); } } takephoto_cnt = 0; LOG_W("STEP5 :Flap"); ws_now = ws_flap; Mtor_Control_ZP(mct_auto); Mtor_Control_ZP(mct_auto); // Mtor_Control_ZP(mct_Reversal); LOG_W("STEP6 :one cycle finsh"); ws_now = ws_once_finsh; rt_thread_mdelay(1000); } /** * @brief 记录当前时刻 * * @param time 时间戳 */ void recode_timestampe_NEW(uint32_t *tim) { ReFlash_RTC(); *tim = NEW_TIMESTAMP; if (tim == &tm_photo) { rt_kprintf("recode_timestampe (photo) > %d sec\n", *tim); ef_set_env_blob("tm_photo" ,&tm_photo ,sizeof(tm_photo)); } else if (tim == &tm_data) { rt_kprintf("recode_timestampe (data ) > %d sec\n", *tim); ef_set_env_blob("tm_data" ,&tm_data ,sizeof(tm_data)); } rt_thread_mdelay(1000); } /** * @brief 计算差值 * * @param time 时间戳 * @return uint32_t 差值 */ uint32_t math_timestampe_NEW(uint32_t *tim) { // uint16_t log_en_inr = LOG_INR * 3; // 打印log的速度 数值越小 打印越频繁 // static int16_t log_en_cnt = -1; static struct tm tm_bak; static char err_cnt = 0; char time_bak[30] = {0}; if (*tim == NEW_TIMESTAMP) { rt_thread_mdelay(1000); } ReFlash_RTC(); uint32_t now = NEW_TIMESTAMP; uint32_t val = (now - *tim); if (val > 0 && val < ((syscfg.dattim + syscfg.photim) * 60)) { // if (chk_log_time) // { // if (tim == &tm_photo) // { // rt_kprintf("math_timestampe (photo) > %d sec\n", val); // } // else // { // rt_kprintf("math_timestampe (data ) > %d sec\n", val); // } // } tm_bak.tm_year = GetDate.Year; tm_bak.tm_mon = GetDate.Month; tm_bak.tm_yday = GetDate.Date; tm_bak.tm_hour = GetTime.Hours; tm_bak.tm_min = GetTime.Minutes; tm_bak.tm_sec = GetTime.Seconds; err_cnt = 0; return val; } else { if (GetDate.Year > 200) { sprintf(time_bak, "%02d-%02d-%02d %02d:%02d:%02d", tm_bak.tm_year, tm_bak.tm_mon, tm_bak.tm_yday, tm_bak.tm_hour, tm_bak.tm_min, tm_bak.tm_sec); if (tm_bak.tm_year > 0 && tm_bak.tm_year < 200) { LOG_W("Write bak time %s!", time_bak); EXE_NTP_SETTIME(&tm_bak); } err_cnt++; if (err_cnt == 5) { Recode_e_code(e_rtc_fail, 0x9D, time_bak); } if (err_cnt > 30) { rt_hw_cpu_reset(); } } if (tim == &tm_photo) { rt_kprintf("math_timestampe fail (photo) > %d (now : %d >>> tim : %d) \n", val, now, *tim); recode_timestampe_NEW(tim); } else { rt_kprintf("math_timestampe fail (data ) > %d (now : %d >>> tim : %d) \n", val, now, *tim); recode_timestampe_NEW(tim); } } return 0; } /** * @brief 简易的数据上报,用于在等待图片上报过程中检查是否需要数据上报 * */ void Updata_INR_Simple(void) { INR_DAT = syscfg.dattim * 60 - 10; // 减去30 消除上报所耗时间 if (math_timestampe_NEW(&tm_data) > INR_DAT) { LOG_I(" >>> watting mode > STEP A start report data C\n"); recode_timestampe_NEW(&tm_data); // 此时重置时间戳 wait_data_cnt = 0; UpLoad_Data(0); } } /** * @brief Construct a new Updata_INR object * * @param type > enable power off */ static uint16_t Updata_INR(uint8_t type) { static uint16_t rtuon_cnt = 0; // 非工作模式时 rtu上电时间记录 static char Once_poweroff = 1; /** * @brief ↓↓↓ 不在工作模式的时候 间隔上线上报数据 在此处实现 ↓↓↓ * */ INR_DAT = syscfg.dattim * 60 - 10; // 减去30 消除上报所耗时间 wait_data_cnt++; if (wait_data_cnt >= INR_DAT || (math_timestampe_NEW(&tm_data) > INR_DAT)) { if (wait_data_cnt >= INR_DAT) { LOG_I(" >>> watting mode > STEP A start report data A\n"); } else { LOG_I(" >>> watting mode > STEP A start report data B\n"); } recode_timestampe_NEW(&tm_data); // 此时重置时间戳 // recode_timestampe(&tm_photo); // 记录数据上报开始时间 wait_data_cnt = 0; ctr_RTU_DTU(ON); sprintf(device_status.net, "1"); // 去掉网络状态 while (++wait_data_cnt < (WAIT_NET_MAX / 2)) { SendReadInfo('D'); if (atoi(device_status.net) == 0) { LOG_I(" >>> watting mode > STEP B1 RTU net get up\n"); rt_thread_mdelay(2000); UpLoad_Data(0); rt_thread_mdelay(30000); // 留有指令下发时间 break; } rt_thread_mdelay(1000); } if (wait_data_cnt >= (WAIT_NET_MAX / 2)) { UpLoad_Data(0); LOG_W(" >>> watting mode > STEP B2 RTU net get failed\n"); Recode_e_code(e_rtu_net_fail, 1, "间隔上报时联网失败 > B2"); rt_thread_mdelay(5000); } wait_data_cnt = 0; if (math_timestampe_NEW(&tm_photo) > (INR_PIC - 60) && (Check_Allow_Work() == res_ok)) // 接近图片上报 不再断电 { LOG_I("CLOSE UP_PIC , JUMP RTU0"); } else { ctr_RTU_DTU(OFF); } Request_ntp(); } if (math_timestampe_NEW(&tm_data) == 0) { LOG_W("math_timestampe_NEW tm_data fail ,SET NOW"); } /** * @brief ↑↑↑ 不在工作模式的时候 间隔上线上报数据 在此处实现 ↑↑↑ * */ /** * @brief ↓↓↓ 首次上电后 留有三分钟数据上报 指令下发时间 ↓↓↓ * */ if (rturead() && Once_poweroff) { rtuon_cnt++; if (rtuon_cnt >= RTU_OFF_MAX) { LOG_I("RTU ON Time out of range , now turn it off A\n\n"); ctr_RTU_DTU(OFF); rtuon_cnt = 0; Once_poweroff = 0; } } /** * @brief ↑↑↑ 首次上电后 留有三分钟数据上报 指令下发时间 ↑↑↑ * */ return wait_data_cnt; } extern char Demo_Mode_NEW; void KeyTigCheck(void) { #define manual_mode_MX 60 #define demo_mode_MX 120 uint16_t log_en_inr = LOG_INR * 5; // 打印log的速度 数值越小 打印越频繁 static int16_t log_en_cnt = -1; uint32_t cnt = 0; if (ws_now == ws_KeyTig) { Recode_e_code(e_manual_mode, 0, "进入手动触发模式"); while (cnt++ < 60 * manual_mode_MX) { rt_thread_mdelay(1000); if (ws_now != ws_KeyTig) { break; } if (chk_log_time) rt_kprintf("处于手动触发模式 %d/%d\n", cnt, manual_mode_MX * 60); if (cnt % 30 == 0) { SendReadInfo('E'); } } Recode_e_code(e_manual_mode, 1, "退出手动触发模式"); } if (Demo_Mode_NEW == 1) { Recode_e_code(e_demo_mode, 0, "进入演示模式"); cnt = 0; rt_kprintf("演示模式 暂停工作 %d / %d\n", cnt, demo_mode_MX * 60); while (cnt++ < demo_mode_MX * 60) { rt_thread_mdelay(1000); if (Demo_Mode_NEW == 0) { break; } if (cnt % 100 == 0) { rt_kprintf("演示模式 暂停工作 %d / %d\n", cnt, demo_mode_MX * 60); } ws_now = ws_demo; ctr_RTU_DTU(ON); CTL_CAM1(); } Demo_Mode_NEW = 0; Recode_e_code(e_demo_mode, 1, "退出演示模式"); } } /** * @brief 天牛工作流程 * */ void WorkTask_TN(void) { uint16_t log_en_inr = LOG_INR * 5; // 打印log的速度 数值越小 打印越频繁 static int16_t log_en_cnt = -1; LOG_I(" WorkTask_TN "); if (Check_Allow_Work() != res_ok) { if (jts.switchled_test != ON) { ctr_led(OFF); } } rt_thread_mdelay(1000); if (tm_data + tm_photo == 0 && GetDate.Year > 20) { ef_get_env_blob("tm_data" ,&tm_data ,sizeof(tm_data),NULL); ef_get_env_blob("tm_photo" ,&tm_data ,sizeof(tm_photo),NULL); if(tm_data + tm_photo == 0) { recode_timestampe_NEW(&tm_data); recode_timestampe_NEW(&tm_photo); Recode_e_code(e_tm_init ,(tm_data + tm_photo)%65536,"tm INIT A"); } else { Recode_e_code(e_tm_init ,(tm_data + tm_photo)%65536,"tm INIT B"); } LOG_I("recode_timestampe INIT"); } while (Check_Allow_Work() != res_ok) // 新增数据上报逻辑(开启rtu 上报一次数据) { log_en_inr = LOG_INR * 5; rt_thread_mdelay(1000); KeyTigCheck(); ws_now = ws_wait0; // 待机 if (chk_log_time) { LOG_I("STEP0 :wait work start"); } Updata_INR(1); } rt_thread_mdelay(1000); uint16_t tig_cnt = 0; char last_once = 0; while (Check_Allow_Work() == res_ok) { LOG_W("STEP1 :start work > %d > %d ", workmode, takephoto_cnt); rt_thread_mdelay(1000); device_status.work_status = 1; (syscfg.photim >= 5) ? (INR_PIC = (syscfg.photim * 60)) : (INR_PIC = (TakeINR * 60)); switch (workmode) { case RunTime_wx: log_en_inr = LOG_INR * 5; while ((Check_Allow_Work() == res_ok) && (workmode == RunTime_wx)) { if (chk_log_time) { LOG_W("STEP2 :wait coll finsh %d%%", GetCollInfo()); } KeyTigCheck(); ws_now = ws_wait_coll; rt_thread_mdelay(1000); if (math_timestampe_NEW(&tm_photo) >= (INR_PIC)) // 拍照部分 { if (math_timestampe_NEW(&tm_photo) >= (INR_PIC)) { LOG_I("Read to takephoto B\n"); } else { LOG_I("Read to takephoto A\n"); } last_once = 1; Recode_e_code(e_pic_tri , 0 , "工作流拍照"); recode_timestampe_NEW(&tm_photo); if (rt_pin_read(CAM_CTL) != ON || rt_pin_read(RTU_DTU) != ON) { rt_kprintf("检测到拍照前未开启RTU"); ctr_RTU_DTU(ON); CTL_CAM1(); ctr_led(ON); for (uint16_t a = 0; a < 66; a++) { rt_thread_mdelay(1000); rt_kprintf("wait for RTU start A3\n"); } } TigTakePho(); takephoto_cnt = 0; if (math_timestampe_NEW(&tm_data) > (INR_DAT - 30)) // 接近数据上报 不再断电 { LOG_I("CLOSE UPDATA , JUMP RTU0"); } else { ctr_RTU_DTU(OFF); } } else if (math_timestampe_NEW(&tm_photo) >= ((INR_PIC)-WAIT_NET_MAX)) // RTU提前上电 { // rt_kprintf("takephoto_cnt close >> %d\n",math_timestampe_NEW(&tm_photo)); ctr_RTU_DTU(ON); CTL_CAM1(); ctr_led(ON); } else // 数据部分 { Updata_INR(0); } if (math_timestampe_NEW(&tm_photo) == 0) { LOG_W("math_timestampe_NEW tm_photo fail ,SET NOW"); } } // 时控模式退出后 上报一次照片 需要间隔已经有至少一半 if ((GetCollInfo() >= 60 && last_once == 0) || (GetCollInfo() >= 80)) { recode_timestampe_NEW(&tm_photo); Recode_e_code(e_pic_last_once , 0 , "工作结束图片保护"); if (rt_pin_read(CAM_CTL) != ON || rt_pin_read(RTU_DTU) != ON) { rt_kprintf("检测到拍照前未开启RTU"); ctr_RTU_DTU(ON); CTL_CAM1(); ctr_led(ON); for (uint16_t a = 0; a < 66; a++) { rt_thread_mdelay(1000); rt_kprintf("wait for RTU start A3\n"); } } TigTakePho(); takephoto_cnt = 0; ctr_RTU_DTU(OFF); CTL_CAM0(); ctr_led(OFF); } // rt_kprintf("takephoto_cnt >> %d > %d > %d\n" ,inr , inr * 60 , ((inr * 60) - WAIT_NET_MAX)); break; case RunTime_Tig_wx: log_en_inr = LOG_INR * 15; if (ENABLE_WORK && (rturead() == 0) && RayTiged) { rtu1(); // 开相机供电 rt_thread_mdelay(30 * 1000); // 等相机开机 } rtu1(); ctr_led(ON); while ((Check_Allow_Work() == res_ok) && (workmode == RunTime_Tig_wx)) { rtu1(); ctr_led(ON); rt_thread_mdelay(100); KeyTigCheck(); ws_now = ws_waitTig; // 等待触发 if (chk_log_time) { LOG_I("STEP2 :wait work start TigMod"); } if (RayTiged && CamFree) { TigTakePho(); RayTiged = 0; } } if (tig_cnt > 0 && CamFree && (Check_Allow_Work() != res_ok)) // 工作结束时 还有计数 拍一张收尾 { TigTakePho(); } else if (RayOneLess == 0 && CamFree) { TigTakePho(); } if ((Check_Allow_Work() == res_ok) && (workmode == RunTime_wx)) { // 工作模式切换 rtu0(); ctr_led(OFF); } RTC_SET_TigVal(0); tig_cnt = 0; RayOneLess = 0; break; default: break; } } if (jts.switchled_test != ON) { ctr_led(OFF); } device_status.work_status = 0; device_status.traplampsta = 0; } static void TigRay(void) { RayTiged = 1; } MSH_CMD_EXPORT(TigRay, TigRay) /********** 红外触发驱动 ************/ /* 触发标志位(Ray开头) */ static volatile rt_bool_t RayTrigFlagA = RT_FALSE; static volatile rt_bool_t RayTrigFlagB = RT_FALSE; static rt_timer_t RayDebounceTimer; // 防抖定时器 static rt_timer_t RaySequenceTimer; // 序列检测定时器(新增) /* 防抖定时器回调 */ static void RayDebounceHandler(void *param) { // rt_kprintf("[Ray] <%d:%d> Flags cleared by debounce\n", RayTrigFlagA, RayTrigFlagB); } /* 序列检测定时器回调(新增) */ static void RaySequenceHandler(void *param) { rt_kprintf("[Ray] Sequence timeout, flags cleared [A%d | B%d]\n", RayTrigFlagA, RayTrigFlagB); RayTrigFlagA = RT_FALSE; RayTrigFlagB = RT_FALSE; rt_timer_stop(RaySequenceTimer); } /****************** 优化后的中断回调 ******************/ /* RayTigA中断回调 */ static rt_err_t RayIrqHandlerA(void *args) { if (!RayTrigFlagA) { RayTrigFlagA = RT_TRUE; rt_kprintf("RayIrqHandlerA triggered\n"); // 如果B已经触发且在50ms内 if (RayTrigFlagB) { RayTigCnt++; RTC_SET_TigVal(RayTigCnt); RayTiged = RT_TRUE; RayOneLess = RT_TRUE; rt_kprintf("[Ray] Item detected! Count: %d\n", RTC_GET_TigVal()); // 清除标志和定时器 RayTrigFlagA = RT_FALSE; RayTrigFlagB = RT_FALSE; rt_timer_stop(RayDebounceTimer); rt_timer_stop(RaySequenceTimer); } else { // 启动防抖定时器 rt_timer_start(RayDebounceTimer); } } return RT_EOK; } /* RayTigB中断回调 */ static rt_err_t RayIrqHandlerB(void *args) { if (!RayTrigFlagB) { RayTrigFlagB = RT_TRUE; rt_kprintf("RayIrqHandlerB triggered\n"); // 启动序列检测定时器(50ms) rt_timer_control(RaySequenceTimer, RT_TIMER_CTRL_SET_TIME, (void *)50); rt_timer_start(RaySequenceTimer); RayTrigFlagA = RT_FALSE; // 启动防抖定时器 rt_timer_start(RayDebounceTimer); } return RT_EOK; } /****************** 初始化函数 ******************/ int RayDualTriggerInit(void) { /* GPIO模式配置 */ rt_pin_mode(RayTigA, PIN_MODE_INPUT_PULLDOWN); rt_pin_mode(RayTigB, PIN_MODE_INPUT_PULLDOWN); /* 创建防抖定时器 */ RayDebounceTimer = rt_timer_create("RayDebounce", RayDebounceHandler, RT_NULL, 10, // 10ms防抖 RT_TIMER_FLAG_ONE_SHOT); /* 创建序列检测定时器(新增) */ RaySequenceTimer = rt_timer_create("RaySequence", RaySequenceHandler, RT_NULL, 200, // 初始50ms超时 RT_TIMER_FLAG_ONE_SHOT); /* 绑定双中断 */ rt_pin_attach_irq(RayTigA, PIN_IRQ_MODE_RISING, RayIrqHandlerA, RT_NULL); rt_pin_attach_irq(RayTigB, PIN_IRQ_MODE_RISING, RayIrqHandlerB, RT_NULL); /* 使能中断 */ rt_pin_irq_enable(RayTigA, PIN_IRQ_ENABLE); rt_pin_irq_enable(RayTigB, PIN_IRQ_ENABLE); /* 读出保存的数据 */ RayTigCnt = RTC_GET_TigVal(); rt_kprintf("[Ray] Dual trigger initialized! Current count: %d\n", RayTigCnt); return RT_EOK; } /* 命令导出(命名统一) */ // MSH_CMD_EXPORT(RayDualTriggerInit, Ray dual trigger demo); /********** 红外触发驱动 ************/ void ChangeInrMode(void) { syscfg.en_tigmode = 0; ef_set_env_blob("syscfg", (const char *)&syscfg, sizeof(syscfg)); rt_kprintf("Change Workmod Inr OK\n"); } void ChangeTigMode(void) { syscfg.en_tigmode = 1; ef_set_env_blob("syscfg", (const char *)&syscfg, sizeof(syscfg)); rt_kprintf("Change Workmod Tig OK\n"); } MSH_CMD_EXPORT(ChangeInrMode, ChangeInrMode); MSH_CMD_EXPORT(ChangeTigMode, ChangeTigMode); /********** RTU Power Ctl ************/ static void rtu1(void) { ctr_RTU_DTU(ON); } static void rtu0(void) { ctr_RTU_DTU(OFF); } static char rturead(void) { char res = rt_pin_read(RTU_DTU); // res ? rt_kprintf("RTU power supply : ON\n") : rt_kprintf("RTU power supply : OFF\n"); return res; } static char readrtu(void) { char res = rt_pin_read(RTU_DTU); res ? rt_kprintf("RTU power supply : ON\n") : rt_kprintf("RTU power supply : OFF\n"); return res; } MSH_CMD_EXPORT(rtu1, rtu1) MSH_CMD_EXPORT(rtu0, rtu0) MSH_CMD_EXPORT(readrtu, readrtu) /********** RTU Power Ctl ************/ static char temp[64] = {0}; #include "cJSON.h" extern uint8_t get_mem_per(void); void status_Pri(uint8_t type) { rt_kprintf("CAM_CTL >> %d \n", rt_pin_read(CAM_CTL)); rt_kprintf("RTU_DTU >> %d \n", rt_pin_read(RTU_DTU)); // 创建根对象 cJSON *root = cJSON_CreateObject(); if (root == NULL) { // rt_kprintf("return A\n"); return; } // 添加 cmd 字段 cJSON_AddStringToObject(root, "cmd", "data"); // 创建 ext 对象 cJSON *ext = cJSON_CreateObject(); if (ext == NULL) { cJSON_Delete(root); // rt_kprintf("return B\n"); return; } sprintf(temp, "%02d-%02d-%02d %02d:%02d:%02d", GetDate.Year, GetDate.Month, GetDate.Date, GetTime.Hours, GetTime.Minutes, GetTime.Seconds); cJSON_AddStringToObject(ext, "当前时间", temp); if (workmode != TypeMAX_wx) { cJSON_AddStringToObject(ext, "工作模式", WorkModeList[workmode].keyword); } // rt_kprintf("mark A\n"); switch (workmode) { case RunTime_wx: sprintf(temp, "%d - %d", device_status.collecting_sh1, device_status.collecting_eh1); cJSON_AddStringToObject(ext, "时控时间", temp); break; case RunTime_Tig_wx: sprintf(temp, "%d - %d", device_status.collecting_sh1, device_status.collecting_eh1); cJSON_AddStringToObject(ext, "触发时间", temp); break; default: break; } // rt_kprintf("mark B\n"); sprintf(temp, "未在工作 %d ", Check_Allow_Work()); (Check_Allow_Work() == res_ok) ? cJSON_AddStringToObject(ext, "当前状态", "工作中") : cJSON_AddStringToObject(ext, "当前状态", temp); sprintf(temp, "%d 分 (%d / %d)", syscfg.dattim, math_timestampe_NEW(&tm_data), INR_DAT); cJSON_AddStringToObject(ext, "数据间隔", temp); sprintf(temp, "%d 分 (%d / %d)", syscfg.photim, math_timestampe_NEW(&tm_photo), INR_PIC); cJSON_AddStringToObject(ext, "照片间隔", temp); sprintf(temp, "%d%%", get_mem_per()); cJSON_AddStringToObject(ext, "内存使用", temp); sprintf(temp, "%d-%d", device_status.rain_status, rain_exit); cJSON_AddStringToObject(ext, "雨控状态", temp); if (type == 2) { cJSON_AddStringToObject(ext, "测试", "翻板测试开始"); } if (type == 3) { cJSON_AddStringToObject(ext, "测试", "上仓门测试开始"); } // rt_kprintf("mark C\n"); // 将 ext 对象添加到根对象 cJSON_AddItemToObject(root, "ext", ext); // 生成 JSON 字符串 char *json_str = cJSON_Print(root); rt_kprintf("status_Pri > %s", json_str); if (json_str != NULL) free(json_str); if (type != 1) { char *json_strU = cJSON_PrintUnformatted(root); DTU_Write(json_strU); if (json_strU != NULL) free(json_strU); } // 清理 cJSON_Delete(root); } /** * @brief 250826 测试整点匹配 * */ int get_report_progress(int interval_minutes) { static uint32_t last_trigger_minute = 0xFFFFFFFF; // 上次触发上报的整点时间(总分钟数) static uint32_t current_cycle_start = 0xFFFFFFFF; // 当前周期开始的整点时间 static uint8_t has_triggered = 0; // 标记当前周期是否已经触发过上报 int current_minute_total; // 当前时间转换为总分钟数(从0点开始) int progress = 0; // 刷新RTC时间 ReFlash_RTC(); // 计算当前时间从0点开始的总分钟数 current_minute_total = GetTime.Hours * 60 + GetTime.Minutes; // 如果是第一次调用,初始化 if (last_trigger_minute == 0xFFFFFFFF) { last_trigger_minute = (current_minute_total / interval_minutes) * interval_minutes; current_cycle_start = last_trigger_minute; has_triggered = 0; } // 计算当前周期的期望上报整点时间 int expected_report_minute = current_cycle_start + interval_minutes; if (expected_report_minute >= 1440) { expected_report_minute -= 1440; } // 检查是否进入新的周期 int is_new_cycle = 0; if (current_minute_total >= expected_report_minute) { // 正常情况:当前时间已经超过期望上报时间 is_new_cycle = 1; } else if (expected_report_minute - current_minute_total > 1200) { // 跨天情况:期望上报时间在前一天,当前时间在第二天 is_new_cycle = 1; } if (is_new_cycle) { // 进入新的上报周期 if (!has_triggered) { // 新周期尚未触发过上报,返回>=100触发上报 progress = 100; has_triggered = 1; last_trigger_minute = expected_report_minute; } else { // 已经触发过上报,但可能线程处理较慢,继续返回>100确保不会漏报 // 计算超时分钟数 int overtime_minutes; if (current_minute_total >= expected_report_minute) { overtime_minutes = current_minute_total - expected_report_minute; } else { overtime_minutes = (1440 - expected_report_minute) + current_minute_total; } progress = 100 + (overtime_minutes * 100 / interval_minutes); } // 检查是否需要更新周期开始时间(当超时时间超过一个完整周期时) if (progress >= 200) { // 已经超时超过一个完整周期,需要跳到下一个周期 int overtime_cycles = (progress - 100) / 100; current_cycle_start = expected_report_minute + (overtime_cycles * interval_minutes); if (current_cycle_start >= 1440) { current_cycle_start %= 1440; } has_triggered = 0; // 重置触发标记,准备触发新的周期 } } else { // 还在当前周期内,计算正常进度 int elapsed_minutes; if (current_minute_total >= current_cycle_start) { // 正常情况 elapsed_minutes = current_minute_total - current_cycle_start; } else { // 跨天情况:current_cycle_start在前一天,current_minute_total在第二天 elapsed_minutes = (1440 - current_cycle_start) + current_minute_total; } progress = elapsed_minutes * 100 / interval_minutes; has_triggered = 0; // 重置触发标记 } return progress; } /** * @brief 250826 测试整点匹配 * */ extern works_def ws_now; static void status_(void) { rt_kprintf("ws_now > %d \n", ws_now); rt_kprintf("test_match > %d \n", get_report_progress(3)); status_Pri(1); } MSH_CMD_EXPORT(status_, status_); void Request_ntp(void) { rt_thread_mdelay(600); char readinfo[] = "{\"request\":\"ntp_time\"}"; DTU_Write("%s", readinfo); rt_kprintf("Request_ntp > %s\n", readinfo); rt_thread_mdelay(600); } void ctr_RTU_DTU(uint8_t status_rtu) { static uint32_t protect_ON = 0; static uint32_t protect_OFF = 0; static uint8_t protect_sec = 8; uint8_t now = 0; if (protect_ON == 0) { recode_timestampe_NEW(&protect_ON); } if (protect_OFF == 0) { recode_timestampe_NEW(&protect_OFF); } rt_pin_mode(RTU_DTU, PIN_MODE_OUTPUT); if (status_rtu == ON) { now = math_timestampe_NEW(&protect_OFF); while (now < protect_sec) { LOG_W("ctr_RTU_DTU ON wait for %d sec", protect_sec - now); rt_thread_mdelay(1000); now++; } rt_pin_write(RTU_DTU, ON); recode_timestampe_NEW(&protect_ON); } else if (Demo_Mode_NEW == 0 && ws_now != ws_KeyTig && (syscfg.not_poweroff == 0)) // 这两种情况下 不允许断电 { now = math_timestampe_NEW(&protect_ON); while (now < protect_sec) { LOG_W("ctr_RTU_DTU OFF wait for %d sec", protect_sec - now); rt_thread_mdelay(1000); now++; } LOG_W("RTU电源复位!!!"); rt_pin_write(RTU_DTU, OFF); CTL_CAM0(); syscfg.rtu_sta = 0; sprintf(device_status.net, "1"); // 断电的时候 网络状态置为断开 recode_timestampe_NEW(&protect_OFF); } else { LOG_W("RTU电源复位被打断 ws_now %d , Demo_mode %d\n", ws_now, Demo_Mode_NEW); } } static void tig_plus(void) { RayTigCnt++; } MSH_CMD_EXPORT(tig_plus, tig_plus);