CBD_XCT/Application_XCT/applications/Work_XCT.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 "xct"
#define DBG_LEVEL DBG_INFO
#include <rtdbg.h>

#define LOG_INR 10 // 默认的log打印间隔（作用域在本文件）
#define TakeINR 10 // mins 默认的拍照间隔

#define RTU_OFF_MAX 180
#define WAIT_NET_MAX 180

#define ENABLE_WORK (Check_Allow_Work() == res_ok)

#define NEW_TIMESTAMP tm_to_timestamp()

/*********************↑           define           ↑************************/
/**
 *
 *
 *
 *
 * */
/*********************↓           include           ↓************************/

#include "Work_XCT.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);

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 RTC_DateTypeDef GetDate;
extern RTC_TimeTypeDef GetTime;

extern uint32_t tm_to_timestamp(void);

/*********************↑           extern           ↑************************/
/**
 *
 *
 *
 *
 * */
/********************↓           declaration          ↓***********************/
static char rturead(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 Luxwork lwork = {0};           // 光控相关参数
volatile Sunwork swork = {0};           // 晨曦相关参数
volatile wm_Def workmode = TypeMAX_wx;  // 工作模式
WorkMode_Def WorkModeList[TypeMAX_wx] = // 工作模式类型
    {
        {RunTime_wx, "时控模式"},
        {RunLight_wx, "光控模式"},
        {RunFRMS_wx, "晨曦模式"}};

static uint16_t INR_PIC = 0; // 图片上传间隔
static uint16_t INR_DAT = 0; // 图片上传间隔

/*********************↑        global variables      ↑************************/
/**
 *
 *
 *
 *
 * */

/**
 * @brief 执行一次清灰
 *
 * mode 0 = 日常， mode = 1 测试
 *
 */
static void FB_Clean(char mode)
{
    char recode_day = 0;

    ef_get_env_blob("FB_Clean", &recode_day, sizeof(recode_day), NULL);

    if(mode == 0)
    {
        if (recode_day != GetDate.Date && GetTime.Hours == 12 && GetTime.Minutes < 10)
        {
            rt_kprintf("ready to FB_Clean\n");
        }
        else
        {
            return;
        }
    }
    else if(mode != 1)
    {
        return;
    }
    else
    {
        rt_kprintf("FB_Clean 手动测试\n");
    }


    Recode_e_code(e_FB_Clean, GetDate.Date, "清灰开始操作");

    ctr_led(ON);

    LOG_I("STEP1 > ctr_led(ON)\n");

    ctr_Collect_Fan(ON, 100); 

    LOG_I("STEP2 >     ctr_Collect_Fan(ON)\n");
    rt_thread_mdelay(2000);

    LOG_I("STEP3 > Mtor_Control_CM > mct_Foreward\n");

    uint16_t Motor_L , Motor_R;

    Motor_L = TURN_CM_L;
    Motor_R = TURN_CM_R;


    rt_pin_mode(Motor_L, PIN_MODE_OUTPUT);
    rt_pin_mode(Motor_R, PIN_MODE_OUTPUT);


    rt_pin_write(Motor_R, OFF);
    rt_pin_write(Motor_L, ON);

    LOG_I("STEP4 > Mtor_Control_ZP > mct_Foreward\n");

    Mtor_Control_ZP(mct_Foreward);
    rt_thread_mdelay(2000);

    Mtor_Control_ZP(mct_Foreward);
    rt_thread_mdelay(2000);

    Mtor_Control_ZP(mct_Foreward);
    rt_thread_mdelay(2000);

    Mtor_Control_ZP(mct_Reversal);
    rt_thread_mdelay(2000);
    Mtor_Control_ZP(mct_Reversal);

    rt_thread_mdelay(2000);
    Mtor_Control_ZP(mct_Reversal);

    LOG_I("STEP5 > FB_Clean finsh \n");

    ctr_led(OFF);
    ctr_Collect_Fan(OFF, 0);
    rt_pin_write(Motor_R, OFF);
    rt_pin_write(Motor_L, OFF);

    ef_set_env_blob("FB_Clean", &recode_day, sizeof(recode_day));
}


static void FBClean_Test(void)
{
    FB_Clean(1);
}

MSH_CMD_EXPORT(FBClean_Test , FBClean_Test);


/**
 * @brief 记录当前时刻
 *
 * @param time 时间戳
 */
static 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);
    }
    else
    {
        rt_kprintf("recode_timestampe (data ) > %d sec\n", *tim);
    }
    rt_thread_mdelay(1000);
}

/**
 * @brief 计算差值
 *
 * @param time 时间戳
 * @return uint32_t 差值
 */
static uint32_t math_timestampe_NEW(uint32_t *tim)
{
    //    uint16_t log_en_inr = LOG_INR * 3; // 打印log的速度 数值越小 打印越频繁
    //    static int16_t log_en_cnt = -1;

    if (*tim == NEW_TIMESTAMP)
    {
        rt_thread_mdelay(1000);
    }

    ReFlash_RTC();
    uint32_t now = NEW_TIMESTAMP;
    uint32_t val = (now - *tim);
    if (val > 0 && val < ((device_status.dattim + device_status.photim) * 60))
    {
        return val;
    }
    else
    {
        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 250826 新增整点匹配逻辑
 *
 * @return uint8_t
 */

// 计算下一次整点上报时间并返回进度
// int get_report_progress(int interval_minutes, int read_type, int time_offset)
// {
//     static uint32_t last_judge_minute = 0xFFFFFFFF;  // 上次判断模式触发的时间（总分钟数）
//     static uint32_t current_cycle_base = 0xFFFFFFFF; // 当前周期的基准整点时间

//     int current_minute_total;
//     int progress = 0;

//     // 刷新RTC时间
//     ReFlash_RTC();

//     // 计算当前时间从0点开始的总分钟数
//     current_minute_total = GetTime.Hours * 60 + GetTime.Minutes;

//     // 如果是第一次调用，初始化
//     if (current_cycle_base == 0xFFFFFFFF)
//     {
//         current_cycle_base = (current_minute_total / interval_minutes) * interval_minutes;
//         last_judge_minute = 0xFFFFFFFF;
//     }

//     // 计算考虑偏移量的期望上报时间
//     int expected_minute = current_cycle_base + interval_minutes + time_offset;
//     if (expected_minute < 0)
//         expected_minute += 1440;
//     if (expected_minute >= 1440)
//         expected_minute -= 1440;

//     // 计算考虑偏移量的周期开始时间
//     int cycle_start_minute = current_cycle_base + time_offset;
//     if (cycle_start_minute < 0)
//         cycle_start_minute += 1440;
//     if (cycle_start_minute >= 1440)
//         cycle_start_minute -= 1440;

//     if (read_type == READ_TYPE_QUERY)
//     {
//         // 查询模式：简单计算进度，不管理状态
//         int elapsed_minutes;

//         if (current_minute_total >= cycle_start_minute)
//         {
//             elapsed_minutes = current_minute_total - cycle_start_minute;
//         }
//         else
//         {
//             elapsed_minutes = (1440 - cycle_start_minute) + current_minute_total;
//         }

//         progress = (elapsed_minutes * 100) / interval_minutes;

//         // 限制进度范围，防止溢出
//         if (progress < 0)
//             progress = 0;
//         if (progress > 1000)
//             progress = 1000; // 最大1000%防止异常
//     }
//     else
//     { // READ_TYPE_JUDGE
//         // 判断模式：管理状态并确保单次触发

//         // 检查是否应该触发
//         int should_trigger = 0;
//         if (current_minute_total >= expected_minute)
//         {
//             should_trigger = 1;
//         }
//         else if (expected_minute - current_minute_total > 1200)
//         { // 跨天
//             should_trigger = 1;
//         }

//         if (should_trigger)
//         {
//             // 检查是否已经在本周期触发过
//             if (last_judge_minute != current_cycle_base)
//             {
//                 // 首次触发本周期
//                 progress = 100;
//                 last_judge_minute = current_cycle_base;

//                 // 更新到下一个周期
//                 current_cycle_base += interval_minutes;
//                 if (current_cycle_base >= 1440)
//                 {
//                     current_cycle_base -= 1440;
//                 }
//             }
//             else
//             {
//                 // 已经触发过，计算超时进度（限制范围）
//                 int overtime_minutes;
//                 if (current_minute_total >= expected_minute)
//                 {
//                     overtime_minutes = current_minute_total - expected_minute;
//                 }
//                 else
//                 {
//                     overtime_minutes = (1440 - expected_minute) + current_minute_total;
//                 }

//                 progress = 100 + (overtime_minutes * 100 / interval_minutes);

//                 // 严格限制进度范围，防止11340%这样的异常
//                 if (progress > 1000)
//                 {
//                     progress = 1000;
//                     last_judge_minute = 0xFFFFFFFF; // 重置触发状态
//                 }

//                 // 如果超时太久，强制进入下一个周期
//                 if (overtime_minutes >= interval_minutes)
//                 {
//                     current_cycle_base = (current_minute_total / interval_minutes) * interval_minutes;
//                     last_judge_minute = 0xFFFFFFFF; // 重置触发状态
//                 }
//             }
//         }
//         else
//         {
//             // 还在周期内，计算正常进度
//             int elapsed_minutes;

//             if (current_minute_total >= cycle_start_minute)
//             {
//                 elapsed_minutes = current_minute_total - cycle_start_minute;
//             }
//             else
//             {
//                 elapsed_minutes = (1440 - cycle_start_minute) + current_minute_total;
//             }

//             progress = (elapsed_minutes * 100) / interval_minutes;

//             // 重置触发状态（新周期开始）
//             if (last_judge_minute != current_cycle_base || progress > 300)
//             {
//                 last_judge_minute = 0xFFFFFFFF;
//             }
//         }
//     }

//     return progress;
// }

/**
 * @brief 250826 新增整点匹配逻辑
 *
 * @return uint8_t
 */

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 -1(超时) >1(进度百分比)
 */
int8_t Get_luxworkTime(void)
{
    uint16_t log_en_inr = LOG_INR * 3; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;

    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
    {
        if (chk_log_time)
            LOG_I("luxtime %d%% \n", ((now - start) * 100) / (limit.LuxTime * 60));
        return ((now - start) * 100) / (limit.LuxTime * 60);
    }

    return -1;
}

/**
 * @brief 获取晨曦模式工作进度 不在工作范围 返回负数
 *
 * @return int8_t val(-1 未开始工作 -2 参数校验失败)
 */
int8_t Get_swork_percent(void)
{
    uint32_t start = 0, end = 0, temp1 = 0, now = 0;

    if (swork.sunup_time.Hours == 0 || swork.sundown_time.Hours == 0)
    {
        swork.sunup_time.Hours = 7;
        swork.sunup_time.Minutes = 30;
        swork.sundown_time.Hours = 17;
        swork.sundown_time.Minutes = 20;
        ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
    }
    if (swork.start_time.Hours == 0 || swork.end_time.Hours == 0)
    {
        // 计算工作开始时间
        swork.start_time.Hours = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) / 60;
        swork.start_time.Minutes = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) % 60;
        swork.start_time.Seconds = swork.sundown_time.Seconds;

        // 计算工作结束时间
        swork.end_time.Hours = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) / 60;
        swork.end_time.Minutes = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) % 60;
        swork.end_time.Seconds = swork.sunup_time.Seconds;
    }

    if ((swork.start_time.Hours + swork.end_time.Hours) == 0 || swork.start_time.Hours < swork.end_time.Hours)
    {
        return -2;
    }

    now = GetTime.Hours * 3600 + GetTime.Minutes * 60 + GetTime.Seconds;
    start = swork.start_time.Hours * 3600 + swork.start_time.Minutes * 60 + swork.start_time.Seconds;
    end = swork.end_time.Hours * 3600 + swork.end_time.Minutes * 60 + swork.end_time.Seconds;

    if (now < start && now > end)
    {
        return -1;
    }

    if (GetTime.Hours > swork.end_time.Hours)
    {
        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;
}

int8_t Get_percent(void)
{
    ReFlash_RTC();

    uint32_t now = GetTime.Hours * 3600 + GetTime.Minutes * 60 + GetTime.Seconds;
    uint32_t sh1 = device_status.collecting_sh1 * 3600;
    uint32_t eh1 = device_status.collecting_eh1 * 3600;

    // 情况1：不跨午夜
    if (sh1 <= eh1)
    {
        if (now < sh1 || now >= eh1)
            return -1;
        return (now - sh1) * 100 / (eh1 - sh1);
    }
    // 情况2：跨午夜
    else
    {
        // 当前时间在晚上时段（sh1～24:00）
        if (now >= sh1)
        {
            uint32_t segment_end = 24 * 3600;
            uint32_t segment_len = segment_end - sh1;
            return (now - sh1) * 100 / segment_len;
        }
        // 当前时间在早上时段（00:00～eh1）
        else if (now < eh1)
        {
            uint32_t total_len = (24 * 3600 - sh1) + eh1;
            uint32_t elapsed = (24 * 3600 - sh1) + now;
            return elapsed * 100 / total_len;
        }
        // 不在工作时段
        else
        {
            return -1;
        }
    }
}

/**
 * @brief 记录日出日落的时间
 *
 */
void Get_SunTime(void)
{
#define rec_MAX 6
    static uint8_t pointer = 0, start_get = 0;
    static uint16_t recode_lux[rec_MAX] = {0}; // 记录历史光照值
    uint16_t avg = 0, has0 = 0;

    if (!sensor[s_Lux].online || (strstr(sensor[s_Lux].eValue, "-99.99") != NULL))
    {
        return;
    }

    // 赋值
    recode_lux[pointer] = sensor[s_Lux].value;

    // rt_kprintf("set %d in pos > %d\n" ,recode_lux[pointer] ,pointer);

    // 偏移指针
    if (++pointer >= rec_MAX)
    {
        pointer = 0;
        start_get = 1;
    }

    for (uint8_t a = 0; a < rec_MAX; a++)
    {
        (a == 0) ? rt_kprintf("recode_lux > %d ", recode_lux[a]) : rt_kprintf(" > %d ", recode_lux[a]);

        avg += recode_lux[a];

        if ((a + 1) == rec_MAX)
        {
            avg /= rec_MAX;
            rt_kprintf("   avg %d\n", avg);
        }
        if (recode_lux[a] == 0)
        {
            has0 = 1;
        }
    }

    if (start_get != 1)
    {
        return;
    }

    //  if(GetTime.Hours >= 13 && GetTime.Hours < 15 && GetDate.Year > 20)     //限定判断区间 (16-20 点之间 日落)
    if (GetTime.Hours >= 16 && GetTime.Hours < 21 && GetDate.Year > 20) // 限定判断区间 (16-20 点之间 日落)
    {
        if (has0 == 0 && (avg * 100) >= (swork.slux_set * 9) && (avg * 100) <= (swork.slux_set * 11))
        {

            start_get = 0;
            pointer = 0;
            memset(recode_lux, 0, sizeof(recode_lux));
            // 记录日落时间
            swork.sundown_time.Hours = GetTime.Hours;
            swork.sundown_time.Minutes = GetTime.Minutes;
            swork.sundown_time.Seconds = GetTime.Seconds;
            // 计算工作开始时间
            swork.start_time.Hours = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) / 60;
            swork.start_time.Minutes = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) % 60;
            swork.start_time.Seconds = swork.sundown_time.Seconds;

            rt_kprintf("get sundown_time %02d:%02d:%02d \n", swork.sundown_time.Hours, swork.sundown_time.Minutes, swork.sundown_time.Seconds);
            rt_kprintf("get start_time   %02d:%02d:%02d \n\n", swork.start_time.Hours, swork.start_time.Minutes, swork.start_time.Seconds);

            ef_set_env_blob("swork", (const void *)&swork, sizeof(swork));
        }
        else
        {
            rt_kprintf("avg %d not in range %d-%d\n", (avg * 100), (swork.slux_set * 9), (swork.slux_set * 11));
        }
    }

    //    if(GetTime.Hours >= 13 && GetTime.Hours < 16 && GetDate.Year > 20)    //限定判断区间 (4-9 点之间 日出)
    if (GetTime.Hours >= 4 && GetTime.Hours < 9 && GetDate.Year > 20) // 限定判断区间 (4-9 点之间 日出)
    {
        if (has0 == 0 && (avg * 100) >= (swork.slux_set * 9) && (avg * 100) <= (swork.slux_set * 11))
        {
            start_get = 0;
            pointer = 0;
            memset(recode_lux, 0, sizeof(recode_lux));
            // 记录日出时间
            swork.sunup_time.Hours = GetTime.Hours;
            swork.sunup_time.Minutes = GetTime.Minutes;
            swork.sunup_time.Seconds = GetTime.Seconds;
            // 计算工作结束时间
            swork.end_time.Hours = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) / 60;
            swork.end_time.Minutes = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) % 60;
            swork.end_time.Seconds = swork.sunup_time.Seconds;

            rt_kprintf("get sunup time   %02d:%02d:%02d \n", swork.sunup_time.Hours, swork.sunup_time.Minutes, swork.sunup_time.Seconds);
            rt_kprintf("get end_time     %02d:%02d:%02d \n\n", swork.end_time.Hours, swork.end_time.Minutes, swork.end_time.Seconds);

            ef_set_env_blob("swork", (const void *)&swork, sizeof(swork));
        }
        else
        {
            rt_kprintf("avg %d not in range %d-%d\n", (avg * 100), (swork.slux_set * 9), (swork.slux_set * 11));
        }
    }
}
/**
 * @brief 确认当前工作模式
 *
 */
void Get_work_mode(void)
{

    /**
     * @brief 开始确认
     *
     */

    static uint8_t ENPrint = 1;
    wm_Def bak = workmode;

    if (swork.EN == ON)
    {
        workmode = RunFRMS_wx;
        if (ENPrint || bak != workmode)
        {
            rt_kprintf("        晨曦工作模式 \n\n");
            rt_kprintf("    日落 - 日出 %02d:%02d:%02d ~  %02d:%02d:%02d\n",
                       swork.sundown_time.Hours,
                       swork.sundown_time.Minutes,
                       swork.sundown_time.Seconds,
                       swork.sunup_time.Hours,
                       swork.sunup_time.Minutes,
                       swork.sunup_time.Seconds);
            rt_kprintf("    开始 - 结束 %02d:%02d:%02d ~  %02d:%02d:%02d\n",
                       swork.start_time.Hours,
                       swork.start_time.Minutes,
                       swork.start_time.Seconds,
                       swork.end_time.Hours,
                       swork.end_time.Minutes,
                       swork.end_time.Seconds);
            rt_kprintf("    偏移时间  > %d 光控阈值 > %d\n\n", swork.lseek, swork.slux_set);
            bak = workmode;
            ENPrint = 0;
        }
        return;
    }

    if (limit.LuxEN == ON)
    {
        workmode = RunLight_wx;
        if (ENPrint || bak != workmode)
        {
            rt_kprintf("\n    光控模式 %d 小时\n\n", limit.LuxTime);
            bak = workmode;
            ENPrint = 0;
        }
        return;
    }

    workmode = RunTime_wx;
    if (ENPrint || bak != workmode)
    {
        rt_kprintf("\n    时控模式 %d-%d 时\n\n", device_status.collecting_sh1, device_status.collecting_eh1);
        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; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;

    static uint8_t lux_getin_cnt = 0;
    static uint8_t lux_getout_cnt = 0;

    rt_thread_mdelay(15);

    Get_work_mode();

    switch (workmode)
    {
        /**
         * @brief 光控模式
         *
         */

    case RunLight_wx:

        // rt_kprintf("sensor[s_Lux].value  %d Luxlimit %d   online %d   on %d\n" , sensor[s_Lux].value , Luxlimit , sensor[s_Lux].online , limit.LuxEN);

        // lwork默认

        if (lwork.Read == 0)
        {
            ef_get_env_blob("lwork", (void *)&lwork, sizeof(lwork), NULL);
            if (lwork.Read == 0)
            {
                lwork.Read = 1;
                lwork.start_work = OFF;
                lwork.lux_set = Luxlimit_def;
                ef_set_env_blob("lwork", (void *)&lwork, sizeof(lwork));
            }
        }
        if (lwork.lux_set == 0)
        {
            lwork.lux_set = Luxlimit_def;
            ef_set_env_blob("lwork", (void *)&lwork, sizeof(lwork));
        }

        // lwork默认

        if (sensor[s_Lux].online >= 1 && (sensor[s_Lux].value * 10) > lwork.lux_set) // 退出
        {
            lux_getout_cnt++;
            if (chk_log_time)
            {
                LOG_I("CAW：光控\n");
            }
            if (lux_getout_cnt >= 3)
            {
                lux_getout_cnt = 0;
                device_status.lps_sta = 1;
                if (lwork.start_work == ON)
                {
                    Recode_e_code(e_exit_luxwork, (sensor[s_Lux].value * 10), "光控模式退出(光照良好)");
                    lwork.start_work = OFF;
                    ef_set_env_blob("lwork", (void *)&lwork, sizeof(lwork));
                }
            }
            return res_Light;
        }

        if (sensor[s_Lux].online >= 1 && (sensor[s_Lux].value * 10) <= lwork.lux_set) // 进入
        {
            if (workmode != RunLight_wx)
            {
                lux_getin_cnt++;
                if (lux_getin_cnt >= 3)
                {
                    lux_getin_cnt = 0;
                    lwork.Read = 1;
                    lwork.start_work = ON;
                    ReFlash_RTC();
                    lwork.start_time.Hours = GetTime.Hours;
                    lwork.start_time.Minutes = GetTime.Minutes;
                    LOG_W("进入光控工作模式 %d", ef_set_env_blob("lwork", (void *)&lwork, sizeof(lwork)));
                    Recode_e_code(e_getin_luxwork, 0, "进入光控工作模式");
                }
            }
        }
        if (Get_luxworkTime() < 0)
        {
            device_status.lps_sta = 1;
            if (lwork.start_work == ON)
            {
                Recode_e_code(e_getout_luxwork, 0, "光控工作模式结束");
                lwork.start_work = OFF;
                ef_set_env_blob("lwork", (void *)&lwork, sizeof(lwork));
            }
            return res_luxout;
        }
        device_status.lps_sta = 0;
        break;

        /**
         * @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 RunFRMS_wx:

        if ((swork.sundown_time.Minutes + swork.sunup_time.Minutes) == 0)
        {
            return res_Sunout;
        }

        // rt_kprintf("RunFRMS_wx %d\n" , Get_swork_percent());

        if (Get_swork_percent() < 0)
        {
            return res_Sunout;
        }

        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)
    {
        LOG_I("CAW：解除温控上限进行中 %d\n", temp_up_cnt);
        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 温湿度
     *
     */

    /**
     * @brief 雨控
     *
     */
    // if (sensor[s_Rain].online >= 1 && sensor[s_Rain].value > 0 && limit.RainEN == ON)
    // {
    //     if (chk_log_time)
    //     {
    //         LOG_I("CAW：雨控\n");
    //     }
    //     device_status.rain_status = 1;
    //     return res_Rain;
    // }

    // if (device_status.rain_status && limit.RainEN == ON)
    // {
    //     ctr_Collect_Fan(OFF);
    //     ctr_lamp(OFF, 1);
    //     ctr_lamp(OFF, 2);
    //     if (chk_log_time)
    //     {
    //         LOG_I("CAW：雨控\n");
    //     }
    //     return res_Rain;
    // }

    // device_status.rain_status = 0;

    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 SendReadInfo(void)
{
    char *readinfo = makeJson_ReadInfo();
    DTU_Write("%s", readinfo);
    rt_kprintf("%s\n", readinfo);
    rt_free(readinfo);
}

/**
 * @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 = device_status.dattim * 60;

    if (type == 0)
    {
        INR_DAT = device_status.dattim * 60;
    }

    wait_data_cnt++;
    if (wait_data_cnt >= INR_DAT || math_timestampe_NEW(&tm_data) > INR_DAT)
    {
        recode_timestampe_NEW(&tm_data); // 此时重置时间戳
        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");
        }

        wait_data_cnt = 0;
        LOG_I("    >>>     watting mode >  STEP A  start report data\n");
        ctr_RTU_DTU(ON);
        sprintf(device_status.net, "1"); // 去掉网络状态
        while (++wait_data_cnt < WAIT_NET_MAX)
        {
            SendReadInfo();
            if (atoi(device_status.net) == 0)
            {
                LOG_I("    >>>     watting mode >  STEP B1  RTU net get up\n");
                rt_thread_mdelay(2000);
                UpLoad_Data();
                rt_thread_mdelay(30000); // 留有指令下发时间
                break;
            }
            rt_thread_mdelay(1000);
        }
        if (wait_data_cnt >= WAIT_NET_MAX)
        {
            LOG_W("    >>>     watting mode >  STEP B2  RTU net get failed\n");
            Recode_e_code(e_rtu_net_fail, 1, "间隔上报时联网失败 > B2");
        }
        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);
        }
    }

    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

    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;
            }
            rt_kprintf("处于手动触发模式 %d/%d\n", cnt, manual_mode_MX * 60);
        }
        Recode_e_code(e_manual_mode, 1, "退出手动触发模式");
    }

    if (syscfg.Demo_mode == 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 (syscfg.Demo_mode == 0)
            {
                break;
            }
            if (cnt % 100 == 0)
            {
                rt_kprintf("演示模式 暂停工作 %d / %d\n", cnt, demo_mode_MX * 60);
            }
            ws_now = ws_demo;
            ctr_RTU_DTU(ON);
        }
        syscfg.Demo_mode = 0;
        Recode_e_code(e_demo_mode, 1, "退出演示模式");
    }
}

static void TigTakePho(void)
{

    device_status.work_status = 3;
    LOG_W("STEP3 :takephoto");
    ctr_lamp(ON, 1);          // 开诱捕灯
    ctr_Collect_Fan(ON, 100); // 开风机

    ws_now = ws_takephoto;
    ctr_led(ON);
    HMI_WRITE("sysTest.result.txt=\"立即拍照开始\"");

    uint8_t b = 0;
    for (b = 0; b < 180; b++)
    {
        if (atoi(device_status.net) == 0)
        {
            rt_kprintf("syscfg.rtu_sta check on\n");
            break;
        }
        rt_thread_mdelay(1000);
        SendReadInfo();
    }
    if (b >= 180)
    {
        rt_kprintf("syscfg.rtu_sta time out %d \n", b);
    }

    DTU_Write("takephoto.mp3");
    Hk_Take_io();
    char *takephotojson = makeJson_takephoto();
    DTU_Write("%s", takephotojson);
    rt_free(takephotojson);

    uint8_t a = 0;
    for (a = 0; a < 180; a++)
    {
        syscfg.not_poweroff = 1;
        if (syscfg.photo_finsh)
        {
            syscfg.photo_finsh = 0;
            rt_kprintf("syscfg.photo_finsh \n");
            break;
        }
        rt_thread_mdelay(1000);
        rt_kprintf("syscfg.photo >>> %d \n", a);
    }
    syscfg.not_poweroff = 0;
    if (a >= 180)
    {
        rt_kprintf("syscfg.photo time out %d \n", a);
    }

    if (jts.switchled_test != ON)
    {
        ctr_led(OFF);
    }
    else
    {
        LOG_W("STEP4 :jump takephoto");
        ws_now = ws_jumptake;
        rt_thread_delay(3000);
        ctr_lamp(OFF, 1);        // 关诱捕灯
        ctr_lamp(OFF, 2);        // 关诱捕灯下
        ctr_Collect_Fan(OFF, 0); // 关风机
        if (jts.switchled_test != ON)
        {
            ctr_led(OFF);
        }
    }
    takephoto_cnt = 0;

    LOG_W("STEP5 :Flap");
    ws_now = ws_flap;
    Mtor_Control_ZP(mct_Foreward);

    LOG_W("STEP6 :one cycle finsh");
    ws_now = ws_once_finsh;
    rt_thread_delay(5000);
}

/**
 * @brief 小虫体工作流程
 *
 */
void WorkTask_XCT(void)
{
    uint16_t log_en_inr = LOG_INR * 5; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;

    if (tm_data + tm_photo == 0 && GetDate.Year > 20)
    {
        recode_timestampe_NEW(&tm_data);
        recode_timestampe_NEW(&tm_photo);
        LOG_I("recode_timestampe  INIT");
    }

    LOG_I("                 WorkTask_XCT ");
    if (Check_Allow_Work() != res_ok)
    {
        ctr_lamp(OFF, 1);                       // 关诱捕灯
        ctr_lamp(OFF, 2);                       // 关诱捕灯下
        ctr_Collect_Fan(OFF, syscfg.fan_speed); // 关风机
        if (jts.switchled_test != ON)
        {
            ctr_led(OFF);
        }
    }
    rt_thread_mdelay(1000);
    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);

    char last_once = 0;

    while (Check_Allow_Work() == res_ok)
    {
        LOG_W("STEP1 :start coll");
        rt_thread_mdelay(2000);
        ctr_lamp(ON, 1);                       // 开诱捕灯
        ctr_Collect_Fan(ON, syscfg.fan_speed); // 开风机
        device_status.work_status = 1;
        device_status.traplampsta = 1;

        (device_status.photim >= 5) ? (INR_PIC = (device_status.photim * 60)) : (INR_PIC = (TakeINR * 60));
        rt_kprintf("takephoto_cnt %d inr %d \n", takephoto_cnt, INR_PIC);
        while ((Check_Allow_Work() == res_ok) && (takephoto_cnt++ < (INR_PIC)))
        {
            (device_status.photim >= 5) ? (INR_PIC = (device_status.photim * 60)) : (INR_PIC = (TakeINR * 60));
            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)) // 拍照部分
            {
                recode_timestampe_NEW(&tm_photo);
                LOG_I("Read to takephoto A\n");
                last_once = 1;
                ctr_RTU_DTU(ON);

                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 ((takephoto_cnt >= ((INR_PIC) - WAIT_NET_MAX))) // 等待拍照部分
            //             {
            //                 ctr_RTU_DTU(ON);
            //             }
            else // 数据部分
            {
                Updata_INR(0);
            }
            // if (Get_percent() >= 50 && Get_percent() <= 100)         260403  关闭了过半关灯逻辑
            // {
            //     if (rt_pin_read(LAMP_SW) == ON)
            //     {
            //         ctr_lamp(OFF, 1); // 进度过半 关上诱捕灯
            //         Recode_e_code(e_ctl_lamp, Get_percent(), "动态控制诱捕灯关");
            //     }
            // }
            // else if (Get_percent() < 50 && Get_percent() >= 0)
            // {
            //     if (rt_pin_read(LAMP_SW) == OFF)
            //     {
            //         ctr_lamp(ON, 1); // 进度没有 恢复上诱捕灯
            //         Recode_e_code(e_ctl_lamp, Get_percent(), "动态控制诱捕灯开");
            //     }
            // }
            if (chk_log_time)
            {
                rt_kprintf("Get_percent() >> %d \n", Get_percent());
            }
        }
        if (takephoto_cnt > (INR_PIC))
        {
            rt_kprintf("takephoto_cnt err area !\n");
            takephoto_cnt = 0;
        }
    }

    // 时控模式退出后 上报一次照片 需要间隔已经有至少一半
    if ((GetCollInfo() >= 60  && last_once == 0) || (GetCollInfo() >= 95))
    {
        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");
            }
        }

        LOG_I("Read to takephoto B\n");
        ctr_RTU_DTU(ON);

        TigTakePho();

        takephoto_cnt = 0;
        ctr_RTU_DTU(OFF);
        CTL_CAM0();
        ctr_led(OFF);
    }
    else
    {
        rt_kprintf("GetCollInfo %d last_once %d\n\n" , GetCollInfo() , last_once);
    }
    last_once = 0;

    ctr_lamp(OFF, 1);                       // 关诱捕灯
    ctr_lamp(OFF, 2);                       // 关诱捕灯下
    ctr_Collect_Fan(OFF, syscfg.fan_speed); // 关风机
    if (jts.switchled_test != ON)
    {
        ctr_led(OFF);
    }
    device_status.work_status = 0;
    device_status.traplampsta = 0;
}

/**********            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 void inr_dis(void)
{

    rt_kprintf("DATA INR >>> %d / %d \n\n", wait_data_cnt, device_status.dattim * 60);

    rt_kprintf("PHO  INR >>> %d / %d \n\n", takephoto_cnt, device_status.photim * 60 - WAIT_NET_MAX);
}

MSH_CMD_EXPORT(inr_dis, inr_dis)

extern RTC_DateTypeDef GetDate;
extern RTC_TimeTypeDef GetTime;

extern uint8_t ReFlash_RTC(void);
static char temp[64] = {0};

#include "cJSON.h"
void status_Pri(uint8_t type)
{

    // 创建根对象
    cJSON *root = cJSON_CreateObject();
    if (root == NULL)
    {
        return NULL;
    }

    // 添加 cmd 字段
    cJSON_AddStringToObject(root, "cmd", "data");

    // 创建 ext 对象
    cJSON *ext = cJSON_CreateObject();
    if (ext == NULL)
    {
        cJSON_Delete(root);
        return NULL;
    }

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

    switch (workmode)
    {

    case RunTime_wx:

        sprintf(temp, "%d - %d", device_status.collecting_sh1, device_status.collecting_eh1);
        cJSON_AddStringToObject(ext, "时控时间", temp);

        break;

    case RunLight_wx:
        sprintf(temp, "%d", limit.LuxTime);

        cJSON_AddStringToObject(ext, "光控时间", temp);

        break;

    default:
        break;
    }

    sprintf(temp, "未在工作 %d ", Check_Allow_Work());

    (Check_Allow_Work() == res_ok) ? cJSON_AddStringToObject(ext, "当前状态", "工作中") : cJSON_AddStringToObject(ext, "当前状态", temp);

    sprintf(temp, "%d 分  (%d / %d)",
            device_status.dattim,
            math_timestampe_NEW(&tm_data), INR_DAT);
    cJSON_AddStringToObject(ext, "数据间隔", temp);

    sprintf(temp, "%d 分  (%d / %d)",
            //syscfg.photim,
            device_status.photim,
            math_timestampe_NEW(&tm_photo), INR_PIC);
    cJSON_AddStringToObject(ext, "照片间隔", temp);

    // 将 ext 对象添加到根对象
    cJSON_AddItemToObject(root, "ext", ext);

    // 生成 JSON 字符串
    char *json_str = cJSON_Print(root);

    rt_kprintf("%s", json_str);

    if (json_str != NULL)
        free(json_str);

    if (type == 0)
    {
        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);
    rt_kprintf("lamp_up  > %d \n", rt_pin_read(LAMP_SW));
    rt_kprintf("lamp_dw  > %d \n", rt_pin_read(LAMP_SW_DOWN));
    status_Pri(1);
}
MSH_CMD_EXPORT(status_, status_);