CBD_XCT/Application_XCT/applications/test.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-05-30     RuoFeng       the first version
 */
/*********************↓           define           ↓************************/

#define DBG_ENABLE
#define DBG_COLOR
#define DBG_TAG "test"
#define DBG_LEVEL DBG_LOG
#include <rtdbg.h>

#define LOG_INR 10     // 默认的log打印间隔（作用域在本文件）
#define TestTimeMAX 15 // mins
#define return_modleA "{\"cmd\": \"data\", \"ext\": \"%s%s\"}"

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

#include "control.h"
#include "test.h"
#include <easyflash.h>
#include "dtu_uart2.h"
#include "cJSON.h"
#include "stdlib.h"
#include "rs485.h"
#include "Work_XCT.h"
#include <easyflash.h>

/*********************↑           include           ↑************************/
/**
 *
 *
 *
 *
 * */
/*********************↓           extern           ↓************************/

extern uint8_t CheckLogTime(int16_t *log_en_cnt, int16_t log_en_inr);
extern Res_def Mtor_Control_ZP(Motor_Ctl_type mct); // 电机控制的主逻辑
extern void HMI_WRITE(char *fmt, ...);
extern void Get_now_time(struct tm *now_stamp);
extern void Beep_Tip(uint16_t volnum);
void beep_set(uint32_t freq, uint32_t volume);

extern Device_Status_typedef device_status;
extern uint8_t ef_cfged;
extern RTC_HandleTypeDef RTC_Handler;
extern Sensor sensor[MAX_SENSOR_NUM];
extern Limit limit;
extern uint8_t ReFlash_RTC(void);
extern SYSCFG syscfg;



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

void Reflash_Screen(rs_def mode, JD_Test_Type type);
char *generate_testreturn_json(JD_Test_Type type, uint8_t val, char *info);

/********************↑           declaration          ↑***********************/
/**
 *
 *
 *
 *
 * */
/*********************↓        global variables      ↓************************/

volatile JD_Test_Sta jts = {0};      // 测试模式的工作状态
volatile Reflash_test_sta rts = {0}; // 传输屏幕向控制功能的切换请求
// Record e_code[MAX_e_code_NUM] = {0}; // 错误码保存
// static uint16_t e_pointer = 0; // 错误码计数

RTC_DateTypeDef GetDate = {0};
RTC_TimeTypeDef GetTime = {0};
struct tm tm_time;

volatile uint8_t holdon_stareflash = 0; // 停止工作状态刷新

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

/**
 * @brief 工作流程打断 还需要加上超时判断
 *
 * @return Res_def
 */
void Check_TestFree(void)
{
    uint16_t cntdown = 0;               // 测试模式设时
    uint16_t cntmax = TestTimeMAX * 60; // 测试模式最大时间
    while (JD_Check_Test_Sta(tt_auto) == res_OK)
    {
        LOG_I("wait for tt_auto %d sec\n", cntdown);
        rt_thread_mdelay(3000);
        cntdown += 3;
        HMI_WRITE("workSta.workinfo.txt=\"等待一键测试完成 %ds\"", cntdown);
        holdon_stareflash = 1;
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }

    while (JD_Check_Test_Sta(tt_collect) == res_OK)
    {
        LOG_I("wait for tt_collect %d sec\n", cntdown);
        rt_thread_mdelay(3000);
        cntdown += 3;
        HMI_WRITE("workSta.workinfo.txt=\"等待收集风机测试完成 %ds\"", cntdown);
        holdon_stareflash = 1;
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }
    while (JD_Check_Test_Sta(tt_takephoto) == res_OK)
    {
        LOG_I("wait for tt_takephoto %d sec\n", cntdown);
        rt_thread_mdelay(3000);
        holdon_stareflash = 1;
        cntdown += 3;
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }
    while (JD_Check_Test_Sta(tt_fb_test) == res_OK)
    {
        LOG_I("wait for tt_fb_test %d sec\n", cntdown);
        rt_thread_mdelay(3000);
        cntdown += 3;
        HMI_WRITE("workSta.workinfo.txt=\"等待翻板测试完成 %ds\"", cntdown);
        holdon_stareflash = 1;
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }
    while (JD_Check_Test_Sta(tt_Traplamp) == res_OK)
    {
        LOG_I("wait for tt_Traplamp %d sec\n", cntdown);
        rt_thread_mdelay(3000);
        cntdown += 3;
        HMI_WRITE("workSta.workinfo.txt=\"等待诱虫灯测试完成 %ds\"", cntdown);
        holdon_stareflash = 1;
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }
    while (JD_Check_Test_Sta(tt_switchled) == res_OK)
    {
        LOG_I("wait for tt_switchled %d sec\n", cntdown);
        holdon_stareflash = 1;
        rt_thread_mdelay(3000);
        cntdown += 3;
        HMI_WRITE("workSta.workinfo.txt=\"等待补光灯测试完成 %ds\"", cntdown);
        if (cntdown % 30 == 0 && cntdown > 0)
        {
            Beep_Tip(500);
        }
        if (cntdown > cntmax)
        {
            Beep_Tip(1500);
            cntdown = 0;
            break;
        }
    }

    holdon_stareflash = 0;
}

/**
 * @brief 确认测试模式是否能够进行
 *
 * @param type 测试类型
 * @return Res_def 结果 res_Verifi-否 res_OK-是
 */
Res_def JD_Check_Test_Sta(JD_Test_Type type)
{
    Res_def result = res_Verifi;

    switch (type)
    {
    case tt_auto:
    {
        if (jts.autotest == ON)
        {
            result = res_OK;
        }
    }
    break;

    case tt_fb_test:
    {
        if (jts.autotest != ON && jts.FBtest == ON && jts.takephoto_test != ON)
        {
            result = res_OK;
        }
    }
    break;

        break;
    case tt_collect:
    {
        if (jts.autotest != ON && jts.collect_test == ON)
        {
            result = res_OK;
        }
    }
    break;
    case tt_Traplamp:
    {
        if (jts.autotest != ON && jts.traplamp_test == ON)
        {
            result = res_OK;
        }
    }
    break;

    case tt_takephoto:
    {
        if (jts.autotest != ON && jts.takephoto_test == ON)
        {
            result = res_OK;
        }
    }
    break;
    case tt_switchled:
    {
        if (jts.autotest != ON && jts.switchled_test == ON && jts.takephoto_test != ON)
        {
            result = res_OK;
        }
    }
    break;
    default:
        break;
    }
    return result;
}

// jt_auto = 0,
// jt_aftake,
// jt_takenow

/**
 * @brief 步进电机运动
 *
 * @param type 类型
 */
void CamMove(cm_def type)
{
    if (type >= cm_typemax)
    {
        LOG_W("CamMove Fail. illegl type\n");
        return;
    }
    switch (type)
    {
    case cm_upstart:
        LOG_I("开始步进上行!");
        ctr_lamp(ON, 1);
        ctr_Motor_Driver(1, 0, 1000000, (MAX_StepTime * 1000) / 50);
        LOG_I("步进上行完成!");
        ctr_lamp(OFF, 0);
        break;
    case cm_upstop:
        LOG_I("停止步进上行!");
        ctr_lamp(OFF, 0);
        ctr_Motor_Driver(0, 0, 0, 0);
        break;
    case cm_downstart:
        LOG_I("开始步进下行!");
        ctr_lamp(ON, 1);
        ctr_Motor_Driver(1, 1, 1000000, (MAX_StepTime * 1000) / 50);
        LOG_I("步进下行完成!");
        ctr_lamp(OFF, 0);
        break;
    case cm_downstop:
        ctr_lamp(OFF, 0);
        ctr_Motor_Driver(0, 0, 0, 0);
        rt_kprintf("停止步进下行!\n");
        break;
    default:
        break;
    }
}
/**
 * @brief 一键测试主逻辑
 *
 */
void BZY_JD_AutoTest(void)
{

    LOG_W("BZY_JD_AutoTest Start\n");
    Recode_e_code(e_AutoTest, 0, "一键测试开始");
    if (JD_Check_Test_Sta(tt_auto) != res_OK)
    {
        LOG_W("BZY_JD_AutoTest EXIT M0\n");
        generate_testreturn_json(tt_auto, OFF, "一键测试手动关闭 M0");
        Recode_e_code(e_AutoTest, 8, "一键测试手动结束");
        goto EXIT;
    }

    device_status.auto_test_sw = 1;

    // 转盘复位
    LOG_I("             1. 翻板复位!!!\n");
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.result.txt=\"一键测试1/6：转盘复位!\"");
    rt_thread_mdelay(2000);
    Mtor_Control_ZP(mct_Foreward);
    if (JD_Check_Test_Sta(tt_auto) != res_OK)
    {
        LOG_W("BZY_JD_AutoTest EXIT M1\n");
        HMI_WRITE_Force("");
        HMI_WRITE("sysTest.result.txt=\"一键测试已结束 M1\"");
        generate_testreturn_json(tt_auto, OFF, "一键测试手动关闭 M1");
        Recode_e_code(e_AutoTest, 1, "一键测试手动结束");
        goto EXIT;
    }
    // 采集当前电压
    double current_v = atof(device_status.voltage);
    rt_thread_delay(2000);

    LOG_I("             2. 采集，打开风机!!!\n");
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.result.txt=\"一键测试2/4：采集，打开风机!\"");
    ctr_Collect_Fan(ON , syscfg.fan_speed);
    ctr_lamp(ON, 1);
    rt_thread_mdelay(10000);
    double now_v = atof(device_status.voltage);
    rt_thread_mdelay(1000);
    now_v = atof(device_status.voltage);
    LOG_I("风机:%s", device_status.voltage);
    if (current_v - now_v < 0.25)
    {
        // 上报风机预警
        char *fan_warn = makeJson_Warn("风机报警", "fan-error");
        DTU_Write("%s", fan_warn);
        rt_free(fan_warn);
        Recode_e_code(e_fan_err, 0, "风机预警");
    }
    rt_thread_mdelay(3000);
    if (JD_Check_Test_Sta(tt_auto) != res_OK)
    {
        ctr_Collect_Fan(OFF , syscfg.fan_speed);
        LOG_W("BZY_JD_AutoTest EXIT M2\n");
        HMI_WRITE_Force("");
        HMI_WRITE("sysTest.result.txt=\"一键测试已结束 M2\"");
        generate_testreturn_json(tt_auto, OFF, "一键测试手动关闭 M2");
        Recode_e_code(e_AutoTest, 2, "一键测试手动结束");
        goto EXIT;
    }

    LOG_I("             3. 开始拍照!!!\n");
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.result.txt=\"一键测试3/4：开始拍照!\"");
    ctr_lamp(ON, 1);     // 开诱捕灯
    ctr_Collect_Fan(ON , syscfg.fan_speed); // 开风机
    ctr_led(ON);
    HMI_WRITE("sysTest.result.txt=\"立即拍照开始\"");
    DTU_Write("takephoto.mp3");
    // 延时
    rt_thread_delay(1000);
    Hk_Take_io();
    char *takephotojson = makeJson_takephoto();
    DTU_Write("%s", takephotojson);
    rt_free(takephotojson);
    rt_thread_delay(60000);
    ctr_led(OFF);
    rt_thread_mdelay(2000);
    if (JD_Check_Test_Sta(tt_auto) != res_OK)
    {
        LOG_W("BZY_JD_AutoTest EXIT M3\n");
        HMI_WRITE_Force("");
        HMI_WRITE("sysTest.result.txt=\"一键测试已结束 M3\"");
        generate_testreturn_json(tt_auto, OFF, "一键测试手动关闭 M3");
        Recode_e_code(e_AutoTest, 3, "一键测试手动结束");
        goto EXIT;
    }

    LOG_I("             4. 翻板复位!!!\n");
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.result.txt=\"一键测试4/4：转盘复位!\"");
    rt_thread_mdelay(2000);
    Mtor_Control_ZP(mct_Foreward);
    if (JD_Check_Test_Sta(tt_auto) != res_OK)
    {
        LOG_W("BZY_JD_AutoTest EXIT M1\n");
        HMI_WRITE_Force("");
        HMI_WRITE("sysTest.result.txt=\"一键测试已结束 M4\"");
        generate_testreturn_json(tt_auto, OFF, "一键测试手动关闭 M4");
        Recode_e_code(e_AutoTest, 4, "一键测试手动结束");
        goto EXIT;
    }

    jts.autotest = OFF;
    ctr_lamp(OFF, 1);
    ctr_lamp(OFF, 2);
    ctr_Collect_Fan(OFF , syscfg.fan_speed);
    ctr_led(OFF);
    Recode_e_code(e_AutoTest, 7, "一键测试手动结束");
    generate_testreturn_json(tt_auto, OFF, "一键测试关闭");
EXIT:
{
    ctr_lamp(OFF, 1);
    ctr_lamp(OFF, 2);
    ctr_Collect_Fan(OFF , syscfg.fan_speed);
    ctr_led(OFF);
    jts.autotest = OFF; // 一键测试关
}
}
/**
 * @brief 翻板测试
 *
 */
void BZY_JD_TapeTest(void)
{
    uint8_t cnt_max = 10;   //翻板测试最大数量
    uint8_t cnt = 0;

    HMI_WRITE("");
    HMI_WRITE_Force("sysTest.result.txt=\"翻板测试开始\"");
    Recode_e_code(e_TapeTest, 0, "翻板测试开始");
    while (cnt++ < cnt_max)
    {
        Mtor_Control_ZP(mct_Foreward);
        rt_thread_delay(2000);
        if (JD_Check_Test_Sta(tt_fb_test) != res_OK)
        {
            jts.FBtest = OFF;
            HMI_WRITE_Force("sysTest.JD_Test.val=0");
            LOG_W("TapeTest EXIT A\n");
            HMI_WRITE_Force("sysTest.result.txt=\"翻板测试已结束！\"");
            Recode_e_code(e_TapeTest, 1, "翻板测试已结束(手动)");
            generate_testreturn_json(tt_fb_test, OFF, "翻板测试手动关闭");
            return;
        }
        rt_kprintf("TapeTest > %d / %d\n", cnt, cnt_max);
        HMI_WRITE_Force("sysTest.result.txt=\"翻板测试进行中 %d / %d\"", cnt, cnt_max);
    }
    jts.FBtest = OFF;
    HMI_WRITE_Force("sysTest.JD_Test.val=0");
    LOG_W("TapeTest EXIT B\n");
    HMI_WRITE_Force("sysTest.result.txt=\"翻板测试已结束！\"");
    Recode_e_code(e_TapeTest, 2, "翻板测试已结束");
    generate_testreturn_json(tt_fb_test, OFF, "翻板测试已完成");
}


extern SYSCFG syscfg;
/**
 * @brief 集合所有测试任务到这里执行 与控制端分离
 *
 */
static void BZY_JD_TestWork(void)
{
    uint16_t log_en_inr = LOG_INR * 30; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;
    if (chk_log_time)
    {
        LOG_I("XCT_TestWork \n");
    }
    if (JD_Check_Test_Sta(tt_auto) == res_OK)
    {
        BZY_JD_AutoTest(); // 一键
    }
    if (JD_Check_Test_Sta(tt_fb_test) == res_OK)
    {
        BZY_JD_TapeTest(); // 翻板
    }
    if (JD_Check_Test_Sta(tt_takephoto) == res_OK)
    {
        Recode_e_code(e_TakePhoto, 0, "立即拍照测试开始");
        ctr_led(ON);
        HMI_WRITE("sysTest.result.txt=\"立即拍照开始\"");
        DTU_Write("takephoto.mp3");

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


        ctr_led(OFF);
        jts.switchled_test = OFF;
        HMI_WRITE("sysTest.result.txt=\"立即拍照结束\"");
        jts.takephoto_test = OFF;
    }
}

static void Test_thread_entry(void *param)
{

    rt_thread_mdelay(6600); // 延时启动 等待初始化工作完成

    uint8_t update_flag = 0, update_wait = 0;

    while (ef_cfged == 0)
    {
        rt_thread_mdelay(1000);
        update_flag == 1 ? HMI_WRITE("workSta.workinfo.txt=\"等待升级工作结束 %ds\"", update_wait) : HMI_WRITE("workSta.workinfo.txt=\"等待参数初始化 %ds\"", update_wait);
        if (update_wait++ > 180)
        {
            break;
        }
    }

    ef_get_env_blob("update_flag", &update_flag, sizeof(device_status.update_flag), NULL);

    while (update_flag == 1)
    {
        rt_thread_mdelay(1000);
        HMI_WRITE("sysTest.result.txt=\"等待升级工作结束 %ds\"", update_wait);
        if (update_wait++ > 180)
        {
            break;
        }
    }
    HMI_WRITE_Force("sysTest.result.txt=\"\"");

    LOG_I("Test_thread_entry\n");

    uint16_t reboot_delay_time = 66;
    static uint8_t en_recode = 1;

    while (1)
    {
        if (en_recode)
        {
            reboot_delay_time++;
            ReFlash_RTC();
            if ((GetDate.Year + GetDate.Month + GetDate.Date) != 20)
            {
                char cache[30] = {0};
                sprintf(cache, "%d 秒前设备重启", reboot_delay_time / 10);
                Recode_e_code(e_Reboot, (reboot_delay_time / 10), cache);
                en_recode = 0;
            }
            else if (reboot_delay_time > 300)
            {
                Recode_e_code(e_Reboot, 1, "30秒种前设备重启");
                en_recode = 0;
            }
            // rt_kprintf("not yet \n");
        }

        rt_thread_mdelay(100);
        BZY_JD_TestWork(); // 执行测试任务
    }
}

#define Test_THREAD_PRIORITY 11
#define Test_THREAD_STACK_SIZE 2048
#define Test_THREAD_TIMESLICE 5

int Test_thread(void)
{
    rt_thread_t tid1 = RT_NULL;
    tid1 = rt_thread_create("Test",
                            Test_thread_entry, RT_NULL,
                            Test_THREAD_STACK_SIZE,
                            Test_THREAD_PRIORITY,
                            Test_THREAD_TIMESLICE); // 给足优先级

    if (tid1 != RT_NULL)
        rt_thread_startup(tid1);

    return 1;
}

INIT_APP_EXPORT(Test_thread);

void autostart(void)
{
    jts.autotest = ON;
}
MSH_CMD_EXPORT(autostart, autostart);
void autostop(void)
{
    jts.autotest = OFF;
}
MSH_CMD_EXPORT(autostop, autostop);

void FBstart(void)
{
    jts.FBtest = ON;
}
MSH_CMD_EXPORT(FBstart, FBstart);
void FBstop(void)
{
    jts.FBtest = OFF;
}
MSH_CMD_EXPORT(FBstop, FBstop);

/**
 * @brief 向串口屏强制发送指令
 *
 * @param fmt 字符串模板
 * @param ...  可变参数
 */
void HMI_WRITE_Force(char *fmt, ...)
{
    char send_buf[50]; // 分配足够大的缓冲区来存储格式化的字符串
    va_list args;

    // 发送初始命令
    char initial_cmd[] = "sleep=0";
    HMI_WRITE(initial_cmd);
    rt_thread_mdelay(100);

    va_start(args, fmt);
    vsnprintf(send_buf, sizeof(send_buf), fmt, args);
    va_end(args);
    HMI_WRITE(send_buf);
}

/*********************↓           24.06 加入ecode           ↓************************/

uint8_t ReFlash_RTC(void)
{
    struct tm now_stamp = {0};

    Get_now_time(&now_stamp);

    //    uint8_t result = 0;
    //    RTC_TimeTypeDef GetTime_cache = {0};
    //    RTC_DateTypeDef GetDate_cache = {0};
    //
    //    if (HAL_RTC_GetTime(&RTC_Handler, &GetTime_cache, RTC_FORMAT_BIN) == HAL_OK)
    //    {
    //
    //        GetTime.Hours = GetTime_cache.Hours;
    //        GetTime.Minutes = GetTime_cache.Minutes;
    //        GetTime.Seconds = GetTime_cache.Seconds;
    //
    //        result = 1;
    //    }
    //    if (HAL_RTC_GetDate(&RTC_Handler, &GetDate_cache, RTC_FORMAT_BIN) == HAL_OK)
    //    {
    //        GetDate.Year = GetDate_cache.Year;
    //        GetDate.Month = GetDate_cache.Month;
    //        GetDate.Date = GetDate_cache.Date;
    //    }

    GetDate.Year = now_stamp.tm_year - 100;
    GetDate.Month = now_stamp.tm_mon + 1;
    GetDate.Date = now_stamp.tm_mday;
    GetTime.Hours = now_stamp.tm_hour;
    GetTime.Minutes = now_stamp.tm_min;
    GetTime.Seconds = now_stamp.tm_sec;

    tm_time.tm_year = now_stamp.tm_year;
    tm_time.tm_mon = now_stamp.tm_mon;
    tm_time.tm_mday = GetDate.Date;
    tm_time.tm_hour = GetTime.Hours;
    tm_time.tm_min = GetTime.Minutes;
    tm_time.tm_sec = GetTime.Seconds;

    //    rt_kprintf("\n%02d/%02d/%02d\r\n", 2000 + GetDate.Year, GetDate.Month, GetDate.Date);
    //    rt_kprintf("%02d:%02d:%02d\r\n", GetTime.Hours, GetTime.Minutes, GetTime.Seconds);

    return 1;
}
/*
 *
 *            以直接存储数值的方式组成时间戳
 *
 *                 all in u32
 *
 *    1111-1111-1111-1111--1111-1111-1111-1111
 *    [---年月---][-日-][--时--][--分--][--秒-]
 *
 *        32-23 使用10位存放年月   最大存放85年
 *        22-18 使用5位存放日         最大值31天
 *        17-13 使用5位存放时         最大值24时
 *        12- 7 使用6位存放分         最大值60分
 *         6- 1 使用6位存放秒         最大值60秒
 *
 * */



/**
 * @brief 返回时间戳（自1900年起）
 *
 * @return uint32_t 戳
 */
uint32_t tm_to_timestamp(void)
{
    // 1. 修正年份和月份（tm_year=实际年份-1900, tm_mon=0-11）

    struct tm *tm = (struct tm *)&tm_time;

    int year = tm->tm_year + 1900;
    int mon = tm->tm_mon + 1; // 转为1-12

    // 2. 计算1970到目标年份的总天数
    uint32_t days = 0;
    for (int y = 1970; y < year; y++)
    {
        days += (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) ? 366 : 365;
    }

    // 3. 计算当年1月到目标月份的总天数
    const uint8_t month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    for (int m = 1; m < mon; m++)
    {
        days += month_days[m - 1];
        if (m == 2 && (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)))
        {
            days += 1; // 闰年2月加1天
        }
    }

    // 4. 加上当月天数（tm_mday从1开始）
    days += tm->tm_mday - 1;

    // 5. 计算当天秒数（tm_hour, tm_min, tm_sec）
    uint32_t seconds = tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;

    // 6. 返回总时间戳
    return days * 86400 + seconds;
}



uint32_t Get_Time_Stampe(void)
{

    /**
     * @brief 获取本地时间
     *
     */
    ReFlash_RTC();

    /**
     * @brief 获取本地时间
     *
     */

    uint32_t result = 0;
    result = GetDate.Year * 12 + GetDate.Month;
    result = (uint32_t)((result << 22) & 0xFFC00000);
    result |= (uint32_t)((GetDate.Date << 17) & 0x3E0000);
    result |= (uint32_t)((GetTime.Hours << 12) & 0x1F000);
    result |= (uint32_t)((GetTime.Minutes << 6) & 0xFC0);
    result |= (uint32_t)((GetTime.Seconds) & 0x3F);
    //  rt_kprintf("+S %d\n", result);
    return result;
}

/**
 * @brief 解析出时间戳
 *
 * @param date 日期
 * @param time 时间
 * @param tm 戳
 */
void Prase_Time_Stampe(RTC_DateTypeDef *date, RTC_TimeTypeDef *time, uint32_t tm)
{
    date->Year = (uint8_t)(((tm & 0xFFC00000) >> 22) / 12);
    date->Month = (uint8_t)(((tm & 0xFFC00000) >> 22) % 12);
    date->Date = (uint8_t)((tm & 0x3E0000) >> 17);
    time->Hours = (uint8_t)((tm & 0x1F000) >> 12);
    time->Minutes = (uint8_t)((tm & 0xFC0) >> 6);
    time->Seconds = (uint8_t)((tm & 0x3F));

    if (date->Month == 0 && date->Year != 0)
    {
        date->Month = 12;
        date->Year--;
    }
    //  rt_kprintf("%d:%d:%d %d:%d:%d", date->Year, date->Month, date->Date, time->Hours, time->Minutes, time->Seconds);
}

/**
 * @brief 记录ecode
 *
 * @param code code值
 * @param para 参数
 * @param deta 描述
 *
 *  V2.0 241030
 */
void Recode_e_code(ecode_list code, uint16_t para, char *detail)
{
    if (ef_cfged == 1 || device_status.update_flag == 1)
    {
        Record ecode = {0};

        uint32_t used = ef_log_get_used_size();
        uint32_t cnt = used / sizeof(Record);

        if (cnt > 0)
        {
            ef_log_read((cnt - 1) * sizeof(Record), (uint32_t *)&ecode, sizeof(Record));
        }
        LOG_I("e_code used %d cnt %d\n", used, cnt);

        if ((used + sizeof(Record) + 0x0C) >= LOG_AREA_SIZE)
        {
            ef_log_clean();
            ecode.Time_Stampe = Get_Time_Stampe(); // 放入时间戳
            ecode.para = code;
            ecode.code = e_clearecode;
            ecode.num++;
            snprintf(ecode.detail, sizeof(ecode.detail), "ecode存满后清空"); // 本次信息
        }
        else
        {
            ecode.Time_Stampe = Get_Time_Stampe(); // 放入时间戳
            ecode.para = para;
            ecode.code = code;
            ecode.num++;
            snprintf(ecode.detail, sizeof(ecode.detail), "%s", detail); // 本次信息
        }
        LOG_W("e_code SET %d c %d p %d", ef_log_write((uint32_t *)&ecode, sizeof(Record)), code, para);
        // rt_kprintf("%d %d %d %s\n\n" , ecode.num , ecode.code , ecode.para , ecode.detail);
    }
}

/**
 * @brief printf_ecode
 *
 */
void printf_ecode(void)
{
    RTC_DateTypeDef r_date = {0};
    RTC_TimeTypeDef r_time = {0};

    uint32_t used = ef_log_get_used_size();
    uint32_t cnt = used / sizeof(Record);

    LOG_I("e_code used %d cnt %d\n", used, cnt);

    Record ecode = {0};

    for (uint32_t a = 0; a < cnt; a++)
    {
        if (ef_log_read(a * sizeof(Record), (uint32_t *)&ecode, sizeof(Record)) == EF_NO_ERR)
        {
            Prase_Time_Stampe(&r_date, &r_time, ecode.Time_Stampe);
            LOG_I("%d - %02d/%02d/%02d %02d:%02d:%02d:(%d-%d) %s",
                  ecode.num,
                  r_date.Year, r_date.Month, r_date.Date,
                  r_time.Hours, r_time.Minutes, r_time.Seconds,
                  ecode.code, ecode.para, ecode.detail);
            memset(&ecode, 0, sizeof(ecode));
        }
        else
        {
            LOG_I("ef_log_read %d fail\n", a);
        }
    }
}

/**
 * @brief 刷新ecode信息
 *
 */
void getEcodeData(uint8_t type)
{
    RTC_DateTypeDef r_date = {0};
    RTC_TimeTypeDef r_time = {0};

    uint32_t used = ef_log_get_used_size();
    uint32_t cnt = used / sizeof(Record);

    Record ecode = {0};

    LOG_I("e_code used %d cnt %d\n", used, cnt);

    if (cnt > 0)
    {
        if (type == 0)
        {
            HMI_WRITE("ecode_read.slt0.txt=\"\"");
            HMI_WRITE("ecode_read.t3.txt=\"\"");
        }
    }
    else
    {
        if (type == 0)
        {
            HMI_WRITE("ecode_read.t3.txt=\"当前无异常事件记录\"");
        }
        return;
    }

    if (type == 0)
    {
        char sbuf[150] = {0};

        for (uint32_t a = 0; a < cnt; a++)
        {
            if (ef_log_read(a * sizeof(Record), (uint32_t *)&ecode, sizeof(Record)) == EF_NO_ERR)
            {
                Prase_Time_Stampe(&r_date, &r_time, ecode.Time_Stampe);
                sprintf(sbuf, "ecode_read.slt0.txt+=\"%d - %02d/%02d/%02d %02d:%02d:%02d : (%d-%d) %s\\r\"",
                        (int)ecode.num,
                        r_date.Year, r_date.Month, r_date.Date,
                        r_time.Hours, r_time.Minutes, r_time.Seconds,
                        ecode.code, ecode.para, ecode.detail);
                HMI_WRITE(sbuf);
            }
            else
            {
                HMI_WRITE("ecode_read.slt0.txt+=\"本次读取log失败\\r\"");
            }
            memset(&ecode, 0, sizeof(ecode));
        }
        return;
    }

    char mqtt_buf[1024] = {0};
    char buf[128] = {0};
    for (uint32_t a = 0; a < cnt; a++)
    {
        if (a == 0)
        {
            sprintf(mqtt_buf, "{\"cmd\": \"data\", \"ext\":{");
        }
        if (ef_log_read(a * sizeof(Record), (uint32_t *)&ecode, sizeof(Record)) == EF_NO_ERR)
        {
            Prase_Time_Stampe(&r_date, &r_time, ecode.Time_Stampe);
            sprintf(buf, "\"%d/%d\" :\" %02d/%02d/%02d %02d:%02d:%02d : (%d-%d) %s\",",
                    (int)a+1,(int)cnt,
                    r_date.Year, r_date.Month, r_date.Date,
                    r_time.Hours, r_time.Minutes, r_time.Seconds,
                    ecode.code, ecode.para, ecode.detail);
            strcat(mqtt_buf, buf);
            if ((a > 0 && (a + 1) % 10 == 0) || (a == (cnt - 1)))
            {
                mqtt_buf[strlen(mqtt_buf) - 1] = '\0';
                strcat(mqtt_buf, "}}");
                if (strlen(mqtt_buf) <= sizeof(mqtt_buf))
                {
                    DTU_Write(mqtt_buf);
                }
                rt_kprintf("strlen : %d\n", strlen(mqtt_buf));
                rt_kprintf("sizeof %d \n", sizeof(mqtt_buf));
                memset(mqtt_buf, 0, sizeof(mqtt_buf));
                sprintf(mqtt_buf, "{\"cmd\": \"data\", \"ext\":{");
                rt_thread_mdelay(1500);
            }
        }
        memset(&ecode, 0, sizeof(ecode));
    }
}

void recode_test(void)
{
    Recode_e_code(3, 6, "3-6是一条msh测试数据123456789");
}
MSH_CMD_EXPORT(recode_test, recode_test);

void pre(void)
{
    printf_ecode();
}
MSH_CMD_EXPORT(pre, pre);

void delecode(void)
{
    ef_log_clean();
}
MSH_CMD_EXPORT(delecode, delecode);

/*********************↑           24.06 加入ecode           ↑************************/

/*********************↓           北大荒定制           ↓************************/

/*设置北大荒设备编码到RTU*/
// char *makeJson_Config_BDH(char *deviceId)
// {
//     cJSON *tJsonRoot = NULL;
//     tJsonRoot = cJSON_CreateObject();
//     if (NULL == tJsonRoot)
//     {
//         cJSON_Delete(tJsonRoot);
//         return NULL;
//     }
//     cJSON_AddStringToObject(tJsonRoot, "cmd", "bzy");
//     cJSON_AddStringToObject(tJsonRoot, "deviceId", deviceId);
//     char *t = cJSON_PrintUnformatted(tJsonRoot);
//     if (NULL == t)
//     {
//         cJSON_Delete(tJsonRoot);
//         return NULL;
//     }
//     cJSON_Delete(tJsonRoot);
//     return t;
// }

// 给定一个 ':' 位置 获取json数组中 该':'后 ','之前的数据并返回该数值
int Get_cfg_value(uint16_t start_addr, char *CMD_Find_Buf)
{

    /*
     * :3,
     * :-10,
     * */
    int value = 0xFFFF; // 获取到的数值
    uint8_t width = 0;  // 数据位长度
    uint8_t minus = 0;  // 负数标记位

    if (CMD_Find_Buf[start_addr] == ':')
    {
        for (uint8_t i = 1; i <= 6; i++)
        {
            if (CMD_Find_Buf[start_addr + i] == '-' && i == 1)
            {
                minus = 1;
                continue;
            }
            if (CMD_Find_Buf[start_addr + i] >= 0x30 && CMD_Find_Buf[start_addr + i] <= 0x39)
            {
                width++;
            }
            if (CMD_Find_Buf[start_addr + i + 1] == ',')
            {
                break;
            }
        }
    }

    if (width != 0)
    {
        char cache[6] = {0};
        memcpy(cache, (char *)(CMD_Find_Buf + start_addr + minus + 1), width);
        cache[width] = '\0';
        value = atoi(cache);
        if (minus == 1)
        {
            value = value * -1;
        }
    }

    return value;
}

/**
 * @brief 设置温控参数
 *
 * @param cmd
 */
void prase_paraset(char *cmd)
{
    rt_kprintf("%s\n", cmd);
    // 开始时间
    if (strstr(cmd, "S:") != NULL)
    {
        device_status.collecting_sh1 = Get_cfg_value(((strstr(cmd, "S:") + 1) - cmd), cmd);
        rt_kprintf("start :%d\n", device_status.collecting_sh1);
    }
    else
    {
        return;
    }
    // 结束时间
    if (strstr(cmd, "E:") != NULL)
    {
        device_status.collecting_eh1 = Get_cfg_value(((strstr(cmd, "E:") + 1) - cmd), cmd);
        rt_kprintf("end :%d\n", device_status.collecting_eh1);
    }
    else
    {
        return;
    }
    // 温度上限
    if (strstr(cmd, "Tup:") != NULL)
    {
        limit.temp_up = Get_cfg_value(((strstr(cmd, "Tup:") + 3) - cmd), cmd);
        rt_kprintf("Tup: :%d\n", limit.temp_up);
    }
    else
    {
        return;
    }
    // 温度下限
    if (strstr(cmd, "Tdn:") != NULL)
    {
        limit.temp_dw = Get_cfg_value(((strstr(cmd, "Tdn:") + 3) - cmd), cmd);
        rt_kprintf("Tdn :%d\n", limit.temp_dw);
    }
    else
    {
        return;
    }
    // 光控时长
    if (strstr(cmd, "gkTime:") != NULL)
    {
        limit.LuxTime = Get_cfg_value(((strstr(cmd, "gkTime:") + 6) - cmd), cmd);
        rt_kprintf("gkTime :%d\n", limit.LuxTime);
    }
    else
    {
        return;
    }
    ef_set_env_blob("collecting_sh1", &device_status.collecting_sh1, sizeof(device_status.collecting_sh1));
    ef_set_env_blob("collecting_eh1", &device_status.collecting_eh1, sizeof(device_status.collecting_eh1));
    LOG_W("limit SET %d", ef_set_env_blob("limit", &limit, sizeof(Limit)));
    HMI_WRITE("clockSet.res.txt=\"保存成功\"");
    rt_thread_mdelay(1500);
    HMI_WRITE("page menu");
}

/**
 * @brief 设置温湿度参数
 *
 * @param cmd
 */
void ex_set_sensor(char *cmd)
{
    // rt_kprintf("ex_set_sensor >> %s \n",cmd);

    Sensor_Read_Type type = get_sensor_num(cmd);

    if (type == s_ALL)
    {
        LOG_W("ex_set_sensor not find");
    }

    if (strstr(cmd, "A:") != NULL)
    {
        sensor[type].sensor_addr = Get_cfg_value(((strstr(cmd, "A:") + 1) - cmd), cmd);
    }
    else
    {
        return;
    }
    if (strstr(cmd, "S:") != NULL)
    {
        sensor[type].start_reg = Get_cfg_value(((strstr(cmd, "S:") + 1) - cmd), cmd);
    }
    else
    {
        return;
    }

    sensor[type].count = 1;
    sensor[type].d_pos = 0;
    sensor[type].d_length = 1;
    sensor[type].cfged = 1;

    LOG_I("sensor SET %d", ef_set_env_blob("sensor", &sensor, sizeof(sensor)));

    rt_kprintf("ex_set_sensor >> a:%d s:%d \n", sensor[type].sensor_addr, sensor[type].start_reg);
    HMI_WRITE("result.txt=\"%s参数已保存(%d,%d)\"", sensor[type].eName, sensor[type].sensor_addr, sensor[type].start_reg);
}

/**
 * @brief 手动测试
 *
 * @param cmd
 */
void ex_read_sensor(char *cmd)
{
    // rt_kprintf("ex_read_sensor >> %s \n", cmd);

    Sensor_Read_Type type = get_sensor_num(cmd);

    if (type == s_ALL)
    {
        LOG_W("ex_read_sensor not find");
    }

    if (ef_cfged == 0)
    {
        HMI_WRITE("result.txt=\"无测试条件 ef\"");
        return;
    }

    ef_get_env_blob("sensor", &sensor, sizeof(sensor), NULL);

    if (sensor[type].cfged == 0)
    {
        HMI_WRITE("result.txt=\"无测试条件 cfg\"");
        return;
    }

    HMI_WRITE("ReadSenor.Addr.val=%d", sensor[type].sensor_addr);
    HMI_WRITE("ReadSenor.Sreg.val=%d", sensor[type].start_reg);

    if (READ_MODBUS_DATA_1(type) != -1)
    {
        device_status.sensor_485_sta = 100;
        switch (type)
        {
        case s_Temp:
            HMI_WRITE("ReadSenor.t1.txt=\"读取温度：\"");
            break;
        case s_Humi:
            HMI_WRITE("ReadSenor.t1.txt=\"读取湿度：\"");
            break;
        case s_Airpre:
            HMI_WRITE("ReadSenor.t1.txt=\"读取气压：\"");
            break;
        case s_Lux:
            HMI_WRITE("ReadSenor.t1.txt=\"读取光照：\"");
            break;
        case s_Rain:
            HMI_WRITE("ReadSenor.t1.txt=\"读取雨量：\"");
            break;
        default:
            HMI_WRITE("ReadSenor.t1.txt=\"未获取要素名\"");
            break;
        }
    }

    if (sensor[type].online == 1)
    {
        HMI_WRITE("ReadSenor.temp.txt=\"%s\"", sensor[type].eValue);
        HMI_WRITE("result.txt=\"%s读取测试成功\"", sensor[type].eName);
    }
    else
    {
        HMI_WRITE("result.txt=\"%s读取测试失败\"", sensor[type].eName);
    }
}

/**
 * @brief 限位预警消息
 *fan-error
 */
void Report_Limit_Error(le_def type)
{
    if (type >= le_typemax)
    {
        rt_kprintf("Report_Limit_Error > illegl type\n");
        return;
    }
    char *turn_warn;
    switch (type)
    {
    case le_limit_tape:
        turn_warn = makeJson_Warn("未检测到限位", "tape-error");
        Recode_e_code(e_limit_tape_err, 0, "未检测到胶带限位");
        break;
    case le_limit_up:
        turn_warn = makeJson_Warn("未检测到限位", "limitup-error");
        Recode_e_code(e_limit_up_err, 0, "未检测到上限位");
        break;
    case le_limlt_dowm:
        turn_warn = makeJson_Warn("未检测到限位", "limitdown-error");
        Recode_e_code(e_limit_down_err, 0, "未检测到下限位");
        break;
    default:

        break;
    }
    DTU_Write("%s", turn_warn);
    rt_free(turn_warn);
    rt_kprintf("Report_Limit_Error %d\n", type);
}

/*********************↑           北大荒定制           ↑************************/

/*********************↓           24.07.11 对测试界面进行整体重绘           ↓************************/

/**
 * @brief 把收到的请求指令解析出来
 *
 * @param cmd 指令
 */
void prase_test_cmd(char *cmd)
{
    rt_kprintf("prase_test_cmd >> %s \n", cmd);
    if (strstr(cmd, "touch") == NULL)
    {
        return;
    }
    if (strstr(cmd, "autotest") != NULL)
    {
        rts.autotest_t = tig_ON;
    }
    if (strstr(cmd, "collect") != NULL)
    {
        rts.collect_t = tig_ON;
    }
    if (strstr(cmd, "takephoto_Now") != NULL)
    {
        rts.takephoto_t = tig_ON;
    }
    if (strstr(cmd, "Traplamp") != NULL)
    {
        rts.traplamp_t = tig_ON;
    }
    if (strstr(cmd, "Trap_Down") != NULL)
    {
        rts.trapdown_t = tig_ON;
    }
    if (strstr(cmd, "fb_test") != NULL)
    {
        rts.fb_test_t = tig_ON;
    }
    if (strstr(cmd, "switchled") != NULL)
    {
        rts.switchled_t = tig_ON;
    }
}

void lamptest(void)
{
    rts.traplamp_t = tig_ON;
}

void collecttest(void)
{
    rts.collect_t = tig_ON;
}

void ledtest(void)
{
    rts.switchled_t = tig_ON;
}

MSH_CMD_EXPORT(lamptest, lamptest);
MSH_CMD_EXPORT(collecttest, collecttest);
MSH_CMD_EXPORT(ledtest, ledtest);

/**
 * @brief 刷新屏幕上的状态显示
 *
 * @param mode 刷新类型
 * @param type 刷新对象
 */
void Reflash_Screen(rs_def mode, JD_Test_Type type)
{
    static uint8_t time_cnt = 0;
    uint8_t jumpout = 1;
    time_cnt++;
    if (time_cnt < 50 && mode == rs_normal)
    {
        return;
    }
    time_cnt = 0;
    if (mode == rs_force && type < tt_typemax)
    {
        switch (type)
        {
        case tt_auto:
            (jts.autotest == ON) ? HMI_WRITE_Force("sysTest.autotest.pic=92") : HMI_WRITE_Force("sysTest.autotest.pic=95");
            break;
        case tt_collect:
            (jts.collect_test == ON) ? HMI_WRITE_Force("sysTest.collect.pic=92") : HMI_WRITE_Force("sysTest.collect.pic=95");
            break;
        case tt_takephoto:
            (jts.takephoto_test == ON) ? HMI_WRITE_Force("sysTest.takephoto.pic=92") : HMI_WRITE_Force("sysTest.takephoto.pic=95");
            break;
        case tt_Traplamp:
            (jts.traplamp_test == ON) ? HMI_WRITE_Force("sysTest.Traplamp_test.pic=92") : HMI_WRITE_Force("sysTest.Traplamp_test.pic=95");
            break;
        case tt_switchled:
            (jts.switchled_test == ON) ? HMI_WRITE_Force("sysTest.switchled.pic=92") : HMI_WRITE_Force("sysTest.switchled.pic=95");
            break;
        case tt_fb_test:
            (jts.FBtest == ON) ? HMI_WRITE_Force("sysTest.fb_test.pic=92") : HMI_WRITE_Force("sysTest.fb_test.pic=95");
            break;
        default:
            jumpout = 0;
            break;
        }
        if (jumpout)
        {
            return;
        }
    }
    if (jts.autotest == ON) // 一键测试
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.autotest.pic=92") : HMI_WRITE_Force("sysTest.autotest.pic=92");
    }
    else if (jts.autotest == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.autotest.pic=95") : HMI_WRITE_Force("sysTest.autotest.pic=95");
    }
    if (jts.collect_test == ON) // 采集风机
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.collect.pic=92") : HMI_WRITE_Force("sysTest.collect.pic=92");
    }
    else if (jts.collect_test == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.collect.pic=95") : HMI_WRITE_Force("sysTest.collect.pic=95");
    }
    if (jts.takephoto_test == ON) // 立即拍照
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.takephoto.pic=92") : HMI_WRITE_Force("sysTest.takephoto.pic=92");
    }
    else if (jts.takephoto_test == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.takephoto.pic=95") : HMI_WRITE_Force("sysTest.takephoto.pic=95");
    }
    if (jts.traplamp_test == ON) // 诱捕灯
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.Traplamp_test.pic=92") : HMI_WRITE_Force("sysTest.Traplamp_test.pic=92");
    }
    else if (jts.traplamp_test == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.Traplamp_test.pic=95") : HMI_WRITE_Force("sysTest.Traplamp_test.pic=95");
    }
    if (jts.switchled_test == ON) // 补光灯
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.switchled.pic=92") : HMI_WRITE_Force("sysTest.switchled.pic=92");
    }
    else if (jts.switchled_test == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.switchled.pic=95") : HMI_WRITE_Force("sysTest.switchled.pic=95");
    }
    if (jts.FBtest == ON) // 翻板
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.fb_test.pic=92") : HMI_WRITE_Force("sysTest.fb_test.pic=92");
    }
    else if (jts.FBtest == OFF)
    {
        (mode == rs_normal) ? HMI_WRITE("sysTest.fb_test.pic=95") : HMI_WRITE_Force("sysTest.fb_test.pic=95");
    }
}

void send_autostart(void)
{
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.work_sta.txt=\"一键测试已开启,关闭其余测试功能\"");
}
void send_denial(void)
{
    HMI_WRITE_Force("");
    HMI_WRITE("sysTest.work_sta.txt=\"操作驳回,一键测试进行中...\"");
}

// 测试指令函数定义
char *generate_testreturn_json(JD_Test_Type type, uint8_t val, char *info)
{

    if (type >= tt_typemax)
    {
        return NULL;
    }

    // 创建根JSON对象
    cJSON *root = cJSON_CreateObject();
    if (!root)
    {
        fprintf(stderr, "Failed to create root JSON object.\n");
        return NULL;
    }

    cJSON_AddStringToObject(root, "cmd", "test");

    // 创建嵌套的"ext"对象
    cJSON *ext = cJSON_CreateObject();
    if (!ext)
    {
        fprintf(stderr, "Failed to create ext JSON object.\n");
        cJSON_Delete(root);
        return NULL;
    }

    switch (type)
    {
    case tt_auto:
        cJSON_AddStringToObject(ext, "type", "autotest");
        break;
    case tt_takephoto:
        cJSON_AddStringToObject(ext, "type", "takephoto_Now");
        break;
    case tt_collect:
        cJSON_AddStringToObject(ext, "type", "collect");
        break;
    case tt_Traplamp:
        cJSON_AddStringToObject(ext, "type", "Traplamp");
        break;
    case tt_Trapdown:
        cJSON_AddStringToObject(ext, "type", "Trapdown");
        break;
    case tt_fb_test:
        cJSON_AddStringToObject(ext, "type", "fb_test");
        break;
    case tt_switchled:
        cJSON_AddStringToObject(ext, "type", "switchled");
        break;
    default:
        break;
    }

    switch (val)
    {
    case 0:
        cJSON_AddStringToObject(ext, "status", "Turn OFF");
        break;
    case 1:
        cJSON_AddStringToObject(ext, "status", "Turn ON");
        break;
    case 2:
        cJSON_AddStringToObject(ext, "status", "fail");
        break;
    default:
        break;
    }

    if (info != NULL && strlen(info) <= 45)
    {
        cJSON_AddStringToObject(ext, "info", info);
    }

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

    // 将cJSON对象转换为字符串
    char *json_string = cJSON_Print(root);
    if (!json_string)
    {
        fprintf(stderr, "Failed to print JSON object.\n");
        cJSON_Delete(root);
        return NULL;
    }

    // 释放cJSON对象（字符串已经复制出来，不需要再保留这个对象）
    cJSON_Delete(root);

    DTU_Write("%s", json_string);
    free(json_string);

    UpLoad_Data_refresh();

    return json_string;
}

/**
 * @brief 刷新状态
 *
 */
void Reflash_Sta(void)
{
    if (rts.autotest_t == tig_ON) // 一键测试
    {
        rts.autotest_t = tig_OFF;
        if (jts.autotest == ON)
        {
            jts.autotest = OFF;
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            generate_testreturn_json(tt_auto, OFF, "一键测试关闭");
        }
        else
        {
            jts.autotest = ON;

//            tt_auto = 0,
//             tt_takephoto,
//             tt_collect,
//             tt_Traplamp,
//             tt_Trapdown,
//             tt_fb_test,
//             tt_switchled,
            if(jts.collect_test == ON)
            {
                jts.collect_test = OFF;
                generate_testreturn_json(tt_collect, OFF, "一键测试：中止收集测试");
                rt_thread_mdelay(1500);
            }

            if(jts.takephoto_test == ON)
            {
                jts.takephoto_test = OFF;
                generate_testreturn_json(tt_collect, OFF, "一键测试：中止拍照测试");
                rt_thread_mdelay(1500);
            }

            if(jts.traplamp_test == ON || jts.trapdown_test == ON)
            {
                jts.traplamp_test = OFF;
                jts.trapdown_test = OFF;
                generate_testreturn_json(tt_Traplamp, OFF, "一键测试：中止诱捕灯测试");
                rt_thread_mdelay(1500);
                generate_testreturn_json(tt_Trapdown, OFF, "一键测试：中止诱捕灯测试");
                rt_thread_mdelay(1500);
            }

            if(jts.switchled_test == ON)
            {
                jts.switchled_test = OFF;
                generate_testreturn_json(tt_switchled, OFF, "一键测试：中止补光灯测试");
                rt_thread_mdelay(1500);
            }

            if(jts.FBtest == ON)
            {
                jts.FBtest = OFF;
                generate_testreturn_json(tt_fb_test, OFF, "一键测试：中止翻板测试");
                rt_thread_mdelay(1500);
            }


            send_autostart();
            generate_testreturn_json(tt_auto, ON, "一键测试开启");
        }
        Reflash_Screen(rs_force, tt_auto);
    }

    if (rts.collect_t == tig_ON) // 采集风机
    {
        rts.collect_t = tig_OFF;
        if (jts.autotest == ON)
        {
            generate_testreturn_json(tt_collect, 2, "操作驳回 一键测试进行中");
            send_denial();
        }
        else if (jts.takephoto_test == ON) // 校验是否立即拍照
        {
            generate_testreturn_json(tt_collect, 2, "操作驳回 立即拍照进行中");
            HMI_WRITE("sysTest.work_sta.txt=\"操作驳回 立即拍照进行中\"");
        }
        else if (jts.collect_test == ON)
        {
            Recode_e_code(e_Collect, 1, "手动测试：风机已关闭");
            jts.collect_test = OFF;
            ctr_Collect_Fan(OFF , syscfg.fan_speed);
            HMI_WRITE("sysTest.result.txt=\"风机已关闭\"");
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_collect);
            generate_testreturn_json(tt_collect, OFF, "手动测试：风机已关闭");
        }
        else
        {
            Recode_e_code(e_Collect, 0, "手动测试：风机已打开");
            jts.collect_test = ON;
            ctr_Collect_Fan(ON , syscfg.fan_speed);
            HMI_WRITE("sysTest.result.txt=\"风机已打开\"");
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_collect);
            generate_testreturn_json(tt_collect, ON, "手动测试：风机已打开");
        }
    }
    if (rts.takephoto_t == tig_ON) // 立即拍照
    {
        rts.takephoto_t = tig_OFF;
        if (jts.autotest == ON)
        {
            send_denial();
            generate_testreturn_json(tt_takephoto, 2, "操作驳回 一键测试进行中");
        }
        else if (jts.takephoto_test == ON)
        {
            jts.takephoto_test = OFF;
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_takephoto);
            generate_testreturn_json(tt_takephoto, OFF, "立即拍照关闭");
        }
        else
        {
            jts.takephoto_test = ON;
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_takephoto);
            generate_testreturn_json(tt_takephoto, ON, "立即拍照开启");
        }
    }
    if (rts.traplamp_t == tig_ON)
    {
        rts.traplamp_t = tig_OFF;
        if (jts.autotest == ON)
        {
            send_denial();
            generate_testreturn_json(tt_Traplamp, 2, "操作驳回 一键测试进行中");
        }
        else if (jts.traplamp_test == ON)
        {
            jts.traplamp_test = OFF;
            ctr_lamp(OFF, 1);
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"诱捕灯已关闭\"");
            Reflash_Screen(rs_force, tt_Traplamp);
            device_status.traplampsta = 0;
            generate_testreturn_json(tt_Traplamp, OFF, "手动测试：诱捕灯已关闭");
        }
        else
        {
            jts.traplamp_test = ON;
            rt_pin_mode(LAMP_SW, PIN_MODE_OUTPUT);
            rt_pin_write(LAMP_SW, ON);
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"诱捕灯已打开\"");
            Reflash_Screen(rs_force, tt_Traplamp);
            device_status.traplampsta = 1;
            generate_testreturn_json(tt_Traplamp, ON, "手动测试：诱捕灯已打开");
        }
    }

    if (rts.trapdown_t == tig_ON)
    {
        rts.trapdown_t = tig_OFF;
        if (jts.autotest == ON)
        {
            send_denial();
            generate_testreturn_json(tt_Trapdown, 2, "操作驳回 一键测试进行中");
        }
        else if (jts.trapdown_test == ON)
        {
            jts.trapdown_test = OFF;
            ctr_lamp(OFF, 2);
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"诱捕灯已关闭\"");
            Reflash_Screen(rs_force, tt_Trapdown);

            generate_testreturn_json(tt_Trapdown, OFF, "手动测试：下诱捕灯已关闭");
        }
        else
        {
            jts.trapdown_test = ON;
            ctr_lamp(ON, 2);
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"诱捕灯已打开\"");
            Reflash_Screen(rs_force, tt_Trapdown);

            generate_testreturn_json(tt_Trapdown, ON, "手动测试：下诱捕灯已打开");
        }
    }

    if (rts.switchled_t == tig_ON)
    {
        rts.switchled_t = tig_OFF;
        if (jts.autotest == ON)
        {
            send_denial();
            generate_testreturn_json(tt_switchled, 2, "操作驳回 一键测试进行中");
        }
        else if (jts.takephoto_test == ON) // 校验是否立即拍照
        {
            HMI_WRITE("sysTest.work_sta.txt=\"操作驳回 立即拍照进行中\"");
        }
        else if (jts.switchled_test == ON)
        {
            Recode_e_code(e_TestLed, 1, "手动测试：补光已关闭");
            jts.switchled_test = OFF;
            ctr_led(OFF);
            HMI_WRITE("sysTest.result.txt=\"补光已关闭\"");
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_switchled);
            generate_testreturn_json(tt_switchled, OFF, "手动测试：补光已关闭");
        }
        else
        {
            Recode_e_code(e_TestLed, 0, "手动测试：补光已打开");
            jts.switchled_test = ON;
            ctr_led(ON);
            HMI_WRITE("sysTest.result.txt=\"补光已打开\"");
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            Reflash_Screen(rs_force, tt_switchled);
            generate_testreturn_json(tt_switchled, ON, "手动测试：补光已开启");
        }
    }
    if (rts.fb_test_t == tig_ON)
    {
        rts.fb_test_t = tig_OFF;
        if (jts.autotest == ON)
        {
            send_denial();
            generate_testreturn_json(tt_switchled, 2, "操作驳回 一键测试进行中");
        }
        else if (jts.takephoto_test == ON) // 校验是否立即拍照
        {
            HMI_WRITE("sysTest.work_sta.txt=\"操作驳回 立即拍照进行中\"");
        }
        else if (jts.FBtest == ON)
        {
            jts.FBtest = OFF;
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"翻板测试退出\"");
            Reflash_Screen(rs_force, tt_fb_test);
            generate_testreturn_json(tt_fb_test, OFF, "翻板测试关闭");
        }

        else
        {
            jts.FBtest = ON;
            HMI_WRITE("sysTest.work_sta.txt=\"\"");
            HMI_WRITE("sysTest.result.txt=\"翻板测试开始\"");
            Reflash_Screen(rs_force, tt_fb_test);
            generate_testreturn_json(tt_fb_test, ON, "翻板测试开启");
        }
    }
}

/**
 * @brief 负责传递状态的刷新
 *
 */
static void BZY_JD_TestReflashWork(void)
{
    static uint8_t rtc_cnt = 0;
    Reflash_Sta();
    Reflash_Screen(rs_normal, tt_typemax);
    if (rtc_cnt++ > 33)
    {
        rtc_cnt = 0;
        ReFlash_RTC();
    }
}

static void test_sta_reflash_thread_entry(void *param)
{
    rt_thread_mdelay(6000); // 延时启动 等待初始化工作完成

    uint8_t update_flag = 0, update_wait = 0;

    while (ef_cfged == 0)
    {
        rt_thread_mdelay(1000);
        if (update_wait++ > 180)
        {
            break;
        }
    }

    ef_get_env_blob("update_flag", &update_flag, sizeof(device_status.update_flag), NULL);

    while (update_flag == 1)
    {
        rt_thread_mdelay(1000);
        if (update_wait++ > 180)
        {
            break;
        }
    }

    LOG_I("test_sta_reflash_thread_entry\n");

    while (1)
    {
        rt_thread_mdelay(30);
        BZY_JD_TestReflashWork();
    }
}

#define test_sta_reflash_thread_PRIORITY 10
#define test_sta_reflash_thread_STACK_SIZE 1024 * 2
#define test_sta_reflash_thread_TIMESLICE 5

int test_sta_reflash_thread(void)
{
    rt_thread_t tid1 = RT_NULL;
    tid1 = rt_thread_create("test_sta_reflash",
                            test_sta_reflash_thread_entry, RT_NULL,
                            test_sta_reflash_thread_STACK_SIZE,
                            test_sta_reflash_thread_PRIORITY,
                            test_sta_reflash_thread_TIMESLICE); // 给足优先级

    if (tid1 != RT_NULL)
        rt_thread_startup(tid1);

    return 1;
}

INIT_APP_EXPORT(test_sta_reflash_thread);

/*********************↑           24.07.11 对测试界面进行整体重绘           ↑************************/

void efwrite(void)
{
    static uint8_t a = 0;

    char wbuf[32] = {0};

    a++;

    sprintf(wbuf, "%d %s", a, "这是一条写入数据测试");

    EfErrCode result = ef_log_write((uint32_t *)wbuf, sizeof(wbuf));

    if (result == EF_NO_ERR)
    {
        rt_kprintf("%d 写入成功\n", a);
    }
    else
    {
        rt_kprintf("%d 写入失败\n", a);
    }
}

void efread(void)
{

    char rbuf[32] = {0};
    uint32_t used = ef_log_get_used_size();
    uint32_t cnt = used / 32;

    rt_kprintf("used %d cnt %d\n", used, cnt);

    EfErrCode result;
    for (uint16_t a = 0; a < cnt; a++)
    {
        result = ef_log_read(a * sizeof(rbuf), (uint32_t *)rbuf, sizeof(rbuf));
        if (result == EF_NO_ERR)
        {
            rt_kprintf("%d 读取成功 ： %s\n", a, rbuf);
        }
        else
        {
            rt_kprintf("%d 读取失败\n", a);
        }
    }
}

void efclear(void)
{
    ef_log_clean();
}

MSH_CMD_EXPORT(efwrite, efwrite);
MSH_CMD_EXPORT(efread, efread);
MSH_CMD_EXPORT(efclear, efclear);

/*********************                  250313 BSP_RTC                     ********************/

/**
 * @brief 读RTC备份寄存器
 *
 * @param reg_num 寄存器号
 * @param type 读取数据的位置及宽度（可选择8位 16位 或32位）
 * @return uint32_t 若为0x7FFF则读取失败反之成功
 */
uint32_t BSP_Read_RTC_Reg(BKP_Reg_Num reg_num, BKP_Reg_Pos type)
{
    uint32_t result = Reg_Read_Fail; // 读取失败返回失效值 0x7FFF

    if (reg_num > RTC_BKP_DR10) // 若需移植 给此处修改为最大支持的寄存器即可
    {
        return result;
    }

    if (type <= Reg_Very_High) // 当按8位读取时
    {
        result = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & (0xFF << (type * 8))) >> (type * 8));
    }

    switch (type)
    {
    case Reg_Low_16:
    {
        result = (HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & 0xFFFF);
    }
    break;
        //    case Reg_High_16:
        //    {
        //        //result = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & (0xFFFF << 16)) >> 16);
        //    }
        //    break;
        //    case Reg_All:
        //    {
        //        //result = HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num);
        //    }
        //    break;
    default:
        break;
    }

    return result;
}
/**
 * @brief 向RTC备份寄存器写入数据
 *
 * @param reg_num 寄存器号
 * @param w_data 要写入的数据
 */
void Write_RTC_BKP(uint8_t reg_num, uint32_t w_data)
{
    __HAL_RCC_PWR_CLK_ENABLE(); // 使能电源时钟PWR
    __HAL_RCC_BKP_CLK_ENABLE();
    HAL_PWR_EnableBkUpAccess();                         // 取消备份区域写保护
    HAL_RTCEx_BKUPWrite(&RTC_Handler, reg_num, w_data); // 写入数据
    HAL_PWR_DisableBkUpAccess();                        // 开启备份区域写保护
}
/**
 * @brief 向RTC备份寄存器写入数据
 *
 * @param reg_num 寄存器号
 * @param type 写入数据的位置及宽度（可选择8位 16位 或32位）
 * @param w_data 要写入的数据
 * @return uint8_t 执行结果（0 -> 失败 1 -> 成功）
 */
uint8_t BSP_Write_RTC_Reg(BKP_Reg_Num reg_num, BKP_Reg_Pos type, uint32_t w_data)
{
    uint8_t result = 0;       // 返回操作结果
    uint32_t cache = 0;       // 临时存放原始数据
    uint32_t source_mask = 0; // 用于保留不需要被覆写部分的掩码

    if (reg_num > RTC_BKP_DR10) // 若需移植 给此处修改为最大支持的寄存器即可
    {
        return result;
    }

    if (type <= Reg_Very_High) // 当写入8位数据
    {
        source_mask = (uint32_t)(~(0xFF << (type * 8)));
        cache = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num)) & source_mask) | ((uint32_t)(w_data << (type * 8)));
        Write_RTC_BKP(reg_num, cache);
        result = 1;
    }
    else // 当写入16或32位数据时
    {
        cache = HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num);
        switch (type)
        {
        case Reg_Low_16:
        {
            source_mask = (uint32_t)(~(0xFFFF));
            Write_RTC_BKP(reg_num, ((cache & source_mask) | w_data));
            result = 1;
        }
        break;
            //        case Reg_High_16:
            //        {
            //            source_mask = (uint32_t)(0xFFFF);
            //            Write_RTC_BKP(reg_num, ((cache & source_mask) | (w_data << 16)));
            //            result = 1;
            //        }
            //        break;
            //        case Reg_All:
            //        {
            //            Write_RTC_BKP(reg_num, w_data);
            //            result = 1;
            //        }
            break;
        default:
            break;
        }
    }
    return result;
}

/**
 * @brief 使用了234号寄存器进行RTC寄存器读写bsp 快速判断配置是否成功
 *  STM32F1(16B) STM32G0(32B) STM32F4(32B)
 */
void test_bsp_rtc(void)
{
    uint32_t data = 0x12345678;
    uint32_t data1 = 0xABC0DEF0;
    // uint32_t data2 = 0xA1B2C3D4;

    LOG_I("Start test");

    LOG_I("write low 8bit %X ", data & 0xFF);

    BSP_Write_RTC_Reg(RTC_BKP_DR5, Reg_Low, data & 0xFF);

    LOG_I("read low 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR5, Reg_Low));

    LOG_I("write Reg_Middle 8bit %X ", (data & 0xFF00) >> 8);

    BSP_Write_RTC_Reg(RTC_BKP_DR5, Reg_Middle, (data & 0xFF00) >> 8);

    LOG_I("read  Reg_Middle 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR5, Reg_Middle));

    //    LOG_I("write Reg_High 8bit %X ", (data & 0xFF0000) >> 16);
    //
    //    BSP_Write_RTC_Reg(RTC_BKP_DR5, Reg_High, (data & 0xFF0000) >> 16);
    //
    //    LOG_I("read  Reg_High 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR5, Reg_High));

    //    LOG_I("write Reg_Very_High 8bit %X ", (data & 0xFF000000) >> 24);
    //
    //    BSP_Write_RTC_Reg(RTC_BKP_DR5, Reg_Very_High, (data & 0xFF000000) >> 24);
    //
    //    LOG_I("read  Reg_Very_High 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR5, Reg_Very_High));

    LOG_I("write Reg_Low_16 %X ", data1 & 0xFFFF);

    BSP_Write_RTC_Reg(RTC_BKP_DR6, Reg_Low_16, data1 & 0xFFFF);

    LOG_I("read  Reg_Low_16 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR6, Reg_Low_16));

    //    LOG_I("write Reg_High_16 %X ", (data1 & 0xFFFF0000) >> 16);
    //
    //    BSP_Write_RTC_Reg(RTC_BKP_DR6, Reg_High_16, (data1 & 0xFFFF0000) >> 16);
    //
    //    LOG_I("read  Reg_High_16 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR6, Reg_High_16));

    //    LOG_I("write Reg_All %X ", data2);
    //
    //    BSP_Write_RTC_Reg(RTC_BKP_DR7, Reg_All, data2);
    //
    //    LOG_I("read  Reg_All %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR3, Reg_All));

    LOG_I("read RTC_BKP_DR5 %X ", BSP_Read_RTC_Reg(RTC_BKP_DR5, Reg_All));
    LOG_I("read RTC_BKP_DR6 %X ", BSP_Read_RTC_Reg(RTC_BKP_DR6, Reg_All));
    //    LOG_I("read RTC_BKP_DR7 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR7, Reg_All));

    LOG_I("Test Finsh");
}

MSH_CMD_EXPORT(test_bsp_rtc, test_bsp_rtc);

void RTC_SET_TigVal(uint16_t val)
{
    BSP_Write_RTC_Reg(RayTigCnt_DR2, Reg_Low_16, val);
    return;
}

uint16_t RTC_GET_TigVal(void)
{
    return BSP_Read_RTC_Reg(RayTigCnt_DR2, Reg_Low_16);
}

/*********************                  250313 BSP_RTC                     ********************/

/**
 * @brief 控制数字5V供电开
 * 
 */
void CTL_5V1(void)
{
    rt_pin_mode(CTL_5V, PIN_MODE_OUTPUT);
    rt_pin_write(CTL_5V, PIN_HIGH);
}
/**
 * @brief 控制数字5V供电关
 * 
 */
void CTL_5V0(void)
{
    rt_pin_mode(CTL_5V, PIN_MODE_OUTPUT);
    rt_pin_write(CTL_5V, PIN_HIGH);
}
/**
 * @brief 控制传感器供电开
 * 
 */
void CTL_SENSOR_12V1(void)
{
    rt_pin_mode(CTL_SENSOR_12V, PIN_MODE_OUTPUT);
    rt_pin_write(CTL_SENSOR_12V, PIN_HIGH);
}
/**
 * @brief 控制传感器供电关
 * 
 */
void CTL_SENSOR_12V0(void)
{
    rt_pin_mode(CTL_SENSOR_12V, PIN_MODE_OUTPUT);
    rt_pin_write(CTL_SENSOR_12V, PIN_LOW);
}

void CTL_RTU1(void)
{
    rt_pin_mode(RTU_DTU, PIN_MODE_OUTPUT);
    rt_pin_write(RTU_DTU, PIN_HIGH);
}

void CTL_RTU0(void)
{
    rt_pin_mode(RTU_DTU, PIN_MODE_OUTPUT);
    rt_pin_write(RTU_DTU, PIN_LOW);
}


void CTL_CAM1(void)
{
    rt_pin_mode(CAM_CTL, PIN_MODE_OUTPUT);
    rt_pin_write(CAM_CTL, PIN_HIGH);
}

void CTL_CAM0(void)
{
    rt_pin_mode(CAM_CTL, PIN_MODE_OUTPUT);
    rt_pin_write(CAM_CTL, PIN_LOW);
}
//MSH_CMD_EXPORT(CTL_5V1, CTL_5V1)
//MSH_CMD_EXPORT(CTL_5V0, CTL_5V0)
//MSH_CMD_EXPORT(CTL_SENSOR_12V1, CTL_SENSOR_12V1)
//MSH_CMD_EXPORT(CTL_SENSOR_12V0, CTL_SENSOR_12V0)
//MSH_CMD_EXPORT(CTL_RTU1, CTL_RTU1)
//MSH_CMD_EXPORT(CTL_RTU0, CTL_RTU0)
//MSH_CMD_EXPORT(CTL_CAM1, CTL_CAM1)
//MSH_CMD_EXPORT(CTL_CAM0, CTL_CAM0)
//void CTL_OUT1(void)
//{
//    rt_pin_mode( LAMP_SW, PIN_MODE_OUTPUT);
//    rt_pin_write(LAMP_SW, PIN_HIGH);
//}
//
//void CTL_OUT2(void)
//{
//    rt_pin_mode(LAMP_SW_DOWN, PIN_MODE_OUTPUT);
//    rt_pin_write(LAMP_SW_DOWN, PIN_HIGH);
//}
//
//void CTL_OUT3(void)
//{
//    rt_pin_mode(Collect_Fan, PIN_MODE_OUTPUT);
//    rt_pin_write(Collect_Fan, PIN_HIGH);
//}
//MSH_CMD_EXPORT(CTL_OUT1, CTL_OUT1)
//MSH_CMD_EXPORT(CTL_OUT2, CTL_OUT2)
//MSH_CMD_EXPORT(CTL_OUT3, CTL_OUT3)