CBD_SY/Application_SY2/applications/Work_SY2.c

/*
 * 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 "sy2"
#define DBG_LEVEL DBG_INFO
#include <rtdbg.h>

#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_SY2.h>
#include "rs485.h"
#include "control.h"
#include "test.h"
#include <easyflash.h>
#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, int8_t ctime);

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 void CTL_CAM0(void);

extern uint32_t tm_to_timestamp(void);

extern char Demo_Mode_NEW;

/*********************↑           extern           ↑************************/
/**
 *
 *
 *
 *
 * */
/********************↓           declaration          ↓***********************/

static void rtu1(void);
static void rtu0(void);
static char rturead(void);
void Request_ntp(void);

static void Photo_Base_Save(uint32_t v);      // 拍照基点持久化(ENV + RTC备份寄存器)
static uint32_t Photo_Base_Load(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, "时控间隔模式"}};

volatile uint16_t RayTigCnt = 0; // 红外触发计数

volatile static char RayTiged = 0;   // 红外已触发过
volatile static char RayOneLess = 0; // 红外触发记录
volatile char CamFree = 1;           // 相机空闲状态

volatile uint16_t INR_PIC = 0; // 图片上传间隔
volatile uint16_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);

    /* 直接按原始时间戳计算秒差, 不再调用 math_timestampe_NEW(避免其超窗时重置 tm_photo) */
    ReFlash_RTC();
    uint32_t now = NEW_TIMESTAMP;
    uint32_t last = tm_photo;
    uint32_t diff = (now > last) ? (now - last) : 0;
    if (INR_PIC == 0)
    {
        return 0;
    }
    return (diff * 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;
        }
    }
}
#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;

    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);

    int32_t temp = 0;

    if (sensor[s_Temp].online >= 1)
    {
        temp = sensor[s_Temp].value;
    }
    else
    {
        temp = atoi(device_status.tempture);
    }

    if (sensor[s_Temp].online >= 1 && temp > (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 (temp_up_cnt >= Temp_Tig_MX)
        {
            if (device_status.temp_status == 0)
            {
                LOG_I("CAW：触发温控上限 %d (%d > %d)\n", temp_up_cnt, temp, limit.temp_up * 10);
            }

            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 && temp < (limit.temp_dw * 10) && limit.temhumEN == ON)
    {
        if (temp_dn_cnt >= Temp_Tig_MX)
        {
            return res_Temp;
        }

        temp_dn_cnt++;
        rt_thread_mdelay(1000);

        if (temp_dn_cnt >= Temp_Tig_MX)
        {
            if (device_status.temp_status == 0)
            {
                LOG_I("CAW：触发温控下限 %d (%d < %d)\n", temp_dn_cnt, temp, limit.temp_dw * 10);
            }

            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(1);

    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;
}

/**
 * @brief 执行一次主要功能
 *
 */
void work_mode_pkg(void)
{
#define cleek_A 3
#define cleek_B 9

    ctr_led(ON);

    for (char a = 0; a < 24; a++)
    {
        rt_thread_mdelay(1000);
        rt_kprintf("work_mode_pkg waiting %d \n" , a);
    }
    


    Mtor_Control_CM(mct_Foreward, 1500); // 复位

    LOG_W("STEP3 :Mtor_Control_ZP A1");
    Mtor_Control_ZP(mct_Foreward, 0);
    rt_thread_mdelay(1500);
    LOG_W("STEP3 :Mtor_Control_ZP A2");
    Mtor_Control_ZP(mct_Foreward, 0);



    Mtor_Control_CM(mct_Reversal, 1500);    // 顶住

    LOG_W("STEP4 :takephoto A");
    rt_thread_mdelay(3500);
    TigTakePho();

    Mtor_Control_CM(mct_Foreward, 1500); // 复位

    LOG_W("STEP5 : Mtor_Control_ZP B1");
    Mtor_Control_ZP(mct_Foreward, 0);

    rt_thread_mdelay(1000);

    LOG_W("STEP5 : Mtor_Control_ZP B2");
    Mtor_Control_ZP(mct_Foreward, 0);

    rt_thread_mdelay(1000);

    LOG_W("STEP5 : Mtor_Control_ZP B3");
    Mtor_Control_ZP(mct_Foreward, 0);

    rt_thread_mdelay(1000);

    LOG_W("STEP5 : Mtor_Control_ZP B4");
    Mtor_Control_ZP(mct_Foreward, 0);

    rt_thread_mdelay(1000);

    LOG_W("STEP6 :takephoto B");
    TigTakePho();
    Mtor_Control_CM(mct_Foreward, 1500); // 复位
                                         //    rt_thread_mdelay(1000);
    LOG_W("STEP5 : Mtor_Control_ZP B5");
    Mtor_Control_ZP(mct_Foreward, 0);
    Mtor_Control_CM(mct_Reversal, 1500); // 顶住

    LOG_W("STEP7 :one cycle finsh");
    ws_now = ws_once_finsh;
    rt_thread_mdelay(1000);
}

/**
 * @brief 记录当前时刻
 *
 * @param time 时间戳
 */
void recode_timestampe_NEW(uint32_t *tim)
{
    ReFlash_RTC();

    // 拍照基点只能由"定时触发"推进(工作窗口内到点 / 待机定点 / 退出窗口补拍);
    // 手动与测试拍照(按键手动模式、立即拍照测试、一键测试)一律不得改动基点,
    // 否则会把下次定时拍照的时间基准带偏。
    if (tim == &tm_photo &&
        (ws_now == ws_KeyTig || jts.takephoto_test == ON || jts.autotest == ON))
    {
        LOG_W("photo base NOT advance (manual/test mode)\n");
        rt_thread_mdelay(1000);
        return;
    }

    *tim = NEW_TIMESTAMP;

    if (tim == &tm_photo)
    {
        rt_kprintf("recode_timestampe (photo) > %d sec\n", *tim);
        Photo_Base_Save(*tim); // 持久化拍照时间基点: ENV + RTC备份寄存器(重启/升级都不丢)
    }
    else if (tim == &tm_data)
    {
        rt_kprintf("recode_timestampe (data ) > %d sec\n", *tim);
    }
    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;
}

/* ==================== 拍照定时触发（间隔N天 + 指定时分） ==================== */
#define TIMESTAMP_2000 946684800UL       // 2000-01-01 00:00:00 (Unix秒), 时间戳有效性判定下限
#define TIMESTAMP_MAX_VALID 4102444800UL // 2100-01-01 00:00:00, 有效性上限(防备份区掉电读出0xFFFFFFFF)
#define PHO_NEAR_SEC   300               // 接近拍照时刻提前量(秒), 用于保持RTU上电

/* ==================== 拍照基点持久化 ==================== */
#define PHO_BASE_MAGIC 0x5048U // BKP有效性魔数('P''H'), 备份区被清/掉电后内容不可信, 靠它判定

/**
 * @brief 写入拍照基点(ENV 与 RTC备份寄存器双写)
 *
 *        ENV  : 内部Flash分区 -> 整机断电(含VBAT)也不丢; 但固件升级可能擦掉
 *        BKP  : RTC备份区 -> 升级不受影响; 但靠VBAT供电, 电池耗尽/更换会丢
 *        两处同时写同一值, 任一处失效都能从另一处恢复。F1备份寄存器为16位, 故拆高低两个。
 *        魔数最后写: 备份区被清/掉电后内容不可信, 只有魔数匹配才认那两个寄存器的值。
 */
static void Photo_Base_Save(uint32_t v)
{
    if (ef_set_env_blob("tm_photo", &v, sizeof(v)) != EF_NO_ERR)
    {
        LOG_E("tm_photo ENV save FAIL\n");
    }

    BSP_Write_RTC_Reg(PhotoBase_DR10, Reg_Low_16, 0); // 先失效, 防止读到半更新的值
    BSP_Write_RTC_Reg(PhotoBase_DR8, Reg_Low_16, v & 0xFFFFUL);
    BSP_Write_RTC_Reg(PhotoBase_DR9, Reg_Low_16, (v >> 16) & 0xFFFFUL);
    BSP_Write_RTC_Reg(PhotoBase_DR10, Reg_Low_16, PHO_BASE_MAGIC); // 再提交
}

/**
 * @brief 读取拍照基点(ENV + RTC备份寄存器双源)
 *
 *        取两者中"合法且较大"的那个: 基点是单调递增的时间戳, 取大者即最近一次成功写入。
 *        这样 ENV 被升级擦掉、或 BKP 因VBAT掉电变成垃圾值, 都能自动绕开。
 *
 * @return uint32_t 基点(Unix秒); 两处均无效时返回 0
 */
static uint32_t Photo_Base_Load(void)
{
    uint32_t env_v = 0;
    uint32_t bkp_v = 0;

    if (ef_get_env_blob("tm_photo", &env_v, sizeof(env_v), NULL) != sizeof(env_v))
    {
        env_v = 0;
    }

    if (BSP_Read_RTC_Reg(PhotoBase_DR10, Reg_Low_16) == PHO_BASE_MAGIC) // 魔数不符视为无记录
    {
        bkp_v = ((BSP_Read_RTC_Reg(PhotoBase_DR9, Reg_Low_16) & 0xFFFFUL) << 16)
              | (BSP_Read_RTC_Reg(PhotoBase_DR8, Reg_Low_16) & 0xFFFFUL);
    }

    if (env_v < TIMESTAMP_2000 || env_v > TIMESTAMP_MAX_VALID)
    {
        env_v = 0;
    }
    if (bkp_v < TIMESTAMP_2000 || bkp_v > TIMESTAMP_MAX_VALID)
    {
        bkp_v = 0;
    }

    return (env_v > bkp_v) ? env_v : bkp_v;
}

/**
 * @brief 计算本次拍照的目标触发时刻(Unix秒, 本地时间)
 *
 *        判定基准: 取上次拍照结束【当天 00:00:00】+ 间隔天数 + 目标时分。
 *        - 基于Unix秒连续运算, 跨月/跨年/闰年天然正确;
 *        - 基准取"当天0点"而非"拍照完成时刻", 拍照耗时不影响下次触发时刻, 周期稳定。
 *
 * @return uint32_t 目标时刻; RTC未同步或上次拍照时间戳无效时返回 0
 */
static uint32_t Get_Photo_Target(void)
{
    if (GetDate.Year <= 20) // RTC 未同步(年<2021), 不计算
    {
        return 0;
    }

    uint32_t last = tm_photo;         // 上次拍照结束时间戳
    if (last < TIMESTAMP_2000)        // 上次拍照时间戳无效(未初始化/异常)
    {
        return 0;
    }

    /* 参数兜底(正常流程由开机校验保证合法, 此处仅防御) */
    uint32_t day  = (syscfg.pho_inr_day >= PHO_INR_DAY_MIN && syscfg.pho_inr_day <= PHO_INR_DAY_MAX) ? syscfg.pho_inr_day : PHO_INR_DAY_DEF;
    uint32_t hour = (syscfg.pho_t_hour <= 23) ? syscfg.pho_t_hour : PHO_T_HOUR_DEF;
    uint32_t min  = (syscfg.pho_t_min  <= 59) ? syscfg.pho_t_min  : PHO_T_MIN_DEF;

    uint32_t last_day0 = last - (last % 86400UL);   // 上次拍照当天 00:00:00(本地无夏令时)
    return last_day0 + day * 86400UL
                    + hour * 3600UL + min * 60UL;
}

/**
 * @brief 时间戳(Unix秒, 本地) 格式化为 "MM-DD HH:MM:SS"
 *
 *        与 tm_to_timestamp() / Get_Photo_Target() 同一时基(本地, 无夏令时)。
 */
static void Photo_Tm_Str(uint32_t tm, char *buf, uint16_t len)
{
    if (tm < TIMESTAMP_2000)
    {
        rt_snprintf(buf, len, "--");
        return;
    }

    uint32_t days = tm / 86400UL;
    uint32_t sec = tm % 86400UL;
    uint16_t year = 1970;

    while (1)
    {
        uint16_t dy = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 366 : 365);
        if (days < dy)
        {
            break;
        }
        days -= dy;
        year++;
    }

    const uint8_t mdays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    uint8_t mon = 0;

    while (1)
    {
        uint8_t dy = mdays[mon];
        if (mon == 1 && (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)))
        {
            dy = 29;
        }
        if (days < dy)
        {
            break;
        }
        days -= dy;
        mon++;
    }

    rt_snprintf(buf, len, "%02d-%02d %02d:%02d:%02d",
                mon + 1, (uint8_t)(days + 1),
                (uint8_t)(sec / 3600UL), (uint8_t)((sec % 3600UL) / 60UL), (uint8_t)(sec % 60UL));
}

/**
 * @brief 是否到达拍照触发时刻
 *
 * @return uint8_t 1-应触发拍照 0-未到时刻
 */
uint8_t Check_Photo_Trigger(void)
{
    ReFlash_RTC();
    uint32_t target = Get_Photo_Target();
    if (target == 0)
    {
        return 0;
    }
    uint32_t now = NEW_TIMESTAMP;
    return (now >= target) ? 1 : 0;
}

/**
 * @brief 是否接近拍照触发时刻(提前 PHO_NEAR_SEC 秒)
 *
 *        用于数据上报后"接近拍照时刻不再断电", 避免拍照前重新给RTU上电。
 *
 * @return uint8_t 1-接近拍照时刻 0-远离
 */
uint8_t Check_Photo_Near(void)
{
    ReFlash_RTC();
    uint32_t target = Get_Photo_Target();
    if (target == 0)
    {
        return 0;
    }
    uint32_t now = NEW_TIMESTAMP;
    return (now + PHO_NEAR_SEC >= target) ? 1 : 0;
}

/**
 * @brief 拍照定时参数合法性校验(开机读取后调用)
 *
 *        三个参数全为0 -> 恢复默认(间隔1天 21:00);
 *        单个参数越界 -> 恢复默认值并保存。
 */
void Check_Photo_Param_Valid(void)
{
    uint8_t save = 0;

    if (syscfg.pho_inr_day == 0 && syscfg.pho_t_hour == 0 && syscfg.pho_t_min == 0)
    {
        syscfg.pho_inr_day = PHO_INR_DAY_DEF;
        syscfg.pho_t_hour  = PHO_T_HOUR_DEF;
        syscfg.pho_t_min   = PHO_T_MIN_DEF;
        save = 1;
        LOG_W("photo param all-zero, SET DEF (%d天 %02d:%02d)", syscfg.pho_inr_day, syscfg.pho_t_hour, syscfg.pho_t_min);
    }
    else
    {
        if (syscfg.pho_inr_day < PHO_INR_DAY_MIN || syscfg.pho_inr_day > PHO_INR_DAY_MAX)
        {
            syscfg.pho_inr_day = PHO_INR_DAY_DEF;
            save = 1;
            LOG_W("pho_inr_day invalid, SET DEF");
        }
        if (syscfg.pho_t_hour > 23)
        {
            syscfg.pho_t_hour = PHO_T_HOUR_DEF;
            save = 1;
            LOG_W("pho_t_hour invalid, SET DEF");
        }
        if (syscfg.pho_t_min > 59)
        {
            syscfg.pho_t_min = PHO_T_MIN_DEF;
            save = 1;
            LOG_W("pho_t_min invalid, SET DEF");
        }
    }

    if (save)
    {
        ef_set_env_blob("syscfg", &syscfg, sizeof(syscfg));
    }
}

/**
 * @brief 定点拍照的拦截条件(与时控窗口无关, 只为硬安全)
 *
 * @return char * NULL-可拍照; 否则返回被拦截的中文原因
 */
static char *Photo_Block_Reason(void)
{
    if (device_status.ds != 1)
    {
        return "设备已关机";
    }
    if (Demo_Mode_NEW == 1)
    {
        return "演示模式";
    }
    if (ws_now == ws_KeyTig)
    {
        return "手动触发模式";
    }
    if (device_status.bat_status == 1)
    {
        return "电池保护";
    }
    // 测试进行中不得掺和: 否则基点不推进(见 recode_timestampe_NEW 的护栏)会导致反复触发
    if (jts.takephoto_test == ON || jts.autotest == ON)
    {
        return "测试进行中";
    }
    return RT_NULL;
}

/**
 * @brief 时控窗口外的定点拍照(间隔N天 + 指定时分)
 *
 *        拍照不再受工作时控窗口约束: 到点即自管上电 -> 执行一次工作包 -> 下电。
 *        触发判定只用 syscfg.pho_inr_day / pho_t_hour / pho_t_min, 不看时控时间。
 *        被硬安全条件拦截时不重置基点, 条件解除后仍会补拍。
 *
 * @return uint8_t 1-本次执行了拍照 0-未到触发时刻或被拦截
 */
static uint8_t Photo_Pkg_OnStandby(void)
{
    if (Check_Photo_Trigger() == 0)
    {
        return 0;
    }

    char *block = Photo_Block_Reason();
    if (block != RT_NULL)
    {
        LOG_W("STANDBY :photo blocked by %s\n", block);
        return 0;
    }

    LOG_I("STANDBY :photo trig , out of work window\n");

    /* 拍照前把 RTU/相机/补光灯拉起(与工作窗口内同一套时序) */
    if (rt_pin_read(CAM_CTL) != ON || rt_pin_read(RTU_DTU) != ON)
    {
        ctr_RTU_DTU(ON);
        CTL_CAM1();
        ctr_led(ON);

        for (uint16_t a = 0; a < 45; a++)
        {
            rt_thread_mdelay(1000);
            rt_kprintf("wait for RTU start S1\n");
        }
    }

    /* 基点先重置: 不论成败都按本次起算, 避免失败后每秒重入 */
    recode_timestampe_NEW(&tm_photo);

    Recode_e_code(e_work_mode_pkg, 2, "时控外执行一次工作包");
    work_mode_pkg(); // 执行一次工作包

    ctr_RTU_DTU(OFF);
    CTL_CAM0();
    ctr_led(OFF);

    return 1;
}

/**
 * @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);

                rt_thread_mdelay(10000); // 留有指令下发时间

                UpLoad_Data(0);

                rt_thread_mdelay(2000);

                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 (Check_Photo_Near() && (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;
}

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_SY2(void)
{
    uint16_t log_en_inr = LOG_INR * 5; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;

    LOG_I("                 WorkTask_SY2 ");
    if (Check_Allow_Work() != res_ok)
    {
        if (jts.switchled_test != ON)
        {
            ctr_led(OFF);
        }
    }
    rt_thread_mdelay(1000);

    /* 从 ENV + RTC备份寄存器 双源恢复拍照基点(重启/升级/掉电都不丢, 不推迟下次拍照) */
    tm_photo = Photo_Base_Load();
    if (tm_photo == 0)
    {
        LOG_W("photo base invalid in ENV & BKP\n"); // 老设备/首次, 下方以当前时间起算
    }

    /* 数据上报基点: 仅存内存, 0则重置(频繁上报无需持久化) */
    if (tm_data == 0 && GetDate.Year > 20)
    {
        recode_timestampe_NEW(&tm_data);
    }
    /* 拍照基点: 双源均无有效记录时, 以当前时间起算并持久化 */
    if (tm_photo == 0 && GetDate.Year > 20)
    {
        recode_timestampe_NEW(&tm_photo);
        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");
        }

        Photo_Pkg_OnStandby(); // 定点拍照(不受时控窗口约束)

        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 (Check_Photo_Trigger()) // 拍照部分(间隔N天 + 指定时分)
                {
                    LOG_I("Read to takephoto\n");

                    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 < 45; a++)
                        {
                            rt_thread_mdelay(1000);

                            rt_kprintf("wait for RTU start A2\n");
                        }
                    }
                    Recode_e_code(e_work_mode_pkg  , 0 ,"执行一次工作包 A");
                    work_mode_pkg(); // 执行一次工作包
                    last_once = 1;

                    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);
                // } USB工业相机 开启速度极快 不需要这么麻烦了
                else // 数据部分
                {
                    Updata_INR(0);
                }
                if (GetDate.Year <= 20) // RTC 未同步, 拍照等待(RTC恢复后自动继续)
                {
                    LOG_W("RTC not ready , photo wait\n");
                }
            }

            // 时控模式退出后 本次未拍照且已到拍照时刻 则补拍一次(与主触发同一判定, 保持间隔语义)
            if (last_once == 0 && Check_Photo_Trigger())
            {
                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 < 45; a++)
                    {
                        rt_thread_mdelay(1000);
                        rt_kprintf("wait for RTU start A3\n");
                    }
                }
                Recode_e_code(e_work_mode_pkg  , 1 ,"执行一次工作包 B");
                work_mode_pkg(); // 执行一次工作包

                takephoto_cnt = 0;
                ctr_RTU_DTU(OFF);
                CTL_CAM0();
                ctr_led(OFF);
            }
            else
            {
                rt_kprintf("photo not trigger, last_once %d\n\n", last_once);
            }
            last_once = 0;
            // rt_kprintf("takephoto_cnt >> %d > %d > %d\n" ,inr , inr * 60 ,  ((inr * 60) - WAIT_NET_MAX));
            break;

        default:
            break;
        }
    }

    if (jts.switchled_test != ON)
    {
        ctr_led(OFF);
    }
    device_status.work_status = 0;
    device_status.traplampsta = 0;
}


MSH_CMD_EXPORT(work_mode_pkg , work_mode_pkg);

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++;
            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;

    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天 %02d:%02d",
            syscfg.pho_inr_day, syscfg.pho_t_hour, syscfg.pho_t_min);
    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);

    sprintf(temp, "%d-%d", RTC_GET_TigVal() , Get_REMAIN());
    cJSON_AddStringToObject(ext, "卷带计数", temp);

    /* 拍照诊断: 基点 / 下次时刻 / 距触发剩余 / 上次结果(判断"为什么没拍/拍了失败") */
    {
        char tbuf[32] = {0};
        uint32_t tgt = Get_Photo_Target();
        uint32_t now = NEW_TIMESTAMP;

        if (GetDate.Year <= 20)
        {
            cJSON_AddStringToObject(ext, "拍照基点", "时间未同步");
            cJSON_AddStringToObject(ext, "下次拍照", "时间未同步");
            cJSON_AddStringToObject(ext, "距拍照", "--");
        }
        else if (tm_photo < TIMESTAMP_2000)
        {
            cJSON_AddStringToObject(ext, "拍照基点", "未定");
            cJSON_AddStringToObject(ext, "下次拍照", "未定");
            cJSON_AddStringToObject(ext, "距拍照", "--");
        }
        else
        {
            Photo_Tm_Str(tm_photo, tbuf, sizeof(tbuf));
            cJSON_AddStringToObject(ext, "拍照基点", tbuf);

            Photo_Tm_Str(tgt, tbuf, sizeof(tbuf));
            cJSON_AddStringToObject(ext, "下次拍照", tbuf);

            if (tgt <= now)
            {
                sprintf(temp, "已到点 %u 秒 (待触发)", (unsigned int)(now - tgt));
            }
            else
            {
                sprintf(temp, "%u 秒后", (unsigned int)(tgt - now));
            }
            cJSON_AddStringToObject(ext, "距拍照", temp);
        }

        if (photo_stat.res == 0)
        {
            cJSON_AddStringToObject(ext, "上次拍照", "无记录");
        }
        else
        {
            char *r = "未知";

            switch (photo_stat.res)
            {
            case 1:
                r = "成功";
                break;
            case 2:
                r = "失败(图像传输超时)";
                break;
            case 3:
                r = "未执行(相机忙)";
                break;
            case 4:
                r = "进行中";
                break;
            default:
                break;
            }

            Photo_Tm_Str(photo_stat.res_tm ? photo_stat.res_tm : photo_stat.tig_tm, tbuf, sizeof(tbuf));
            sprintf(temp, "%s %s", r, tbuf);
            cJSON_AddStringToObject(ext, "上次拍照", temp);
        }

        /* 到点却没拍时, 这里能看出被哪条硬安全条件拦住 */
        char *blk = Photo_Block_Reason();
        cJSON_AddStringToObject(ext, "拍照拦截", blk ? blk : "无");
    }

    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);
}

extern works_def ws_now;

static void status_(void)
{
    rt_kprintf("ws_now  > %d \n", ws_now);
    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);