CBD_XCT/Application_XCT/applications/dtu_uart2.c

/*
 * Copyright (c) 2006-2020, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2020-05-28     Administrator       the first version
 */
#include <rtthread.h>
#include "hmi.h"
#include <board.h>
#include <rtdevice.h>
#include "stdarg.h"
#include "string.h"
#include "stdio.h"
#include "dtu_uart2.h"
#include <cJSON.h>
#include "control.h"
#include "sht30_collect.h"
#include <easyflash.h>
#include "sound.h"
#include <ymodem.h>
#include "beep.h"
#include "test.h"
#define DBG_ENABLE
#define DBG_COLOR
#define DBG_TAG "dtu"
#define DBG_LEVEL DBG_LOG
#include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options

#define DTU_THREAD_PRIORITY 6             // 线程优先级
#define DTU_THREAD_STACK_SIZE 2048 + 1024 // 线程栈空间大小
#define DTU_THREAD_TIMESLICE 5            // 时间片

Device_Status_typedef device_status;
DataTemp data_arry;
volatile sr_type screen_type = old;
JD_Test_Sta jts;

void list_mem(void);
/* 串口接收消息结构*/
struct rx_msg
{
    rt_device_t dev;
    rt_size_t size;
};
/* 消息队列句柄 */
static struct rt_messagequeue rx_mq_dtu;
rt_thread_t dtu_recv_data = RT_NULL;
rt_thread_t dtu_send_data = RT_NULL;

rt_device_t dtuserial;                                        /*串口设备句柄*/
struct serial_configure dtuconfig = RT_SERIAL_CONFIG_DEFAULT; /*初始化配置参数*/

static uint8_t makejson_sta = 0;

/**
 * @brief 初始化用于与上层dtu通信的串口 - 串口2
 *
 * @return int 成功返回RT_EOK
 */
static int DTU_uart2_init(void)
{

    dtuserial = rt_device_find(DTU_UART_NAME);
    /*修改串口配置参数*/
    dtuconfig.baud_rate = BAUD_RATE_115200; // 修改波特率9600
    dtuconfig.data_bits = DATA_BITS_8;      // 数据位8c
    dtuconfig.stop_bits = STOP_BITS_1;      // 停止位1
    dtuconfig.bufsz = 1024;                 // 缓冲区1k
    dtuconfig.parity = PARITY_NONE;         // 奇校验
    /* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
    rt_device_control(dtuserial, RT_DEVICE_CTRL_CONFIG, &dtuconfig);
    /* step4：打开串口设备。以DMA接收及轮询发送模式打开串口设备 */
    rt_device_open(dtuserial, RT_DEVICE_FLAG_DMA_RX);
    return RT_EOK;
}
/*数据发送*/
/**
 * @brief 将组包完成后的json字符串发送到dtu
 *
 * @param fmt 字符串模型
 * @param ... 可变参数
 */
void DTU_Write(char *fmt, ...)
{
    rt_pin_mode(GET_PIN(B, 14) , PIN_MODE_OUTPUT);
    rt_pin_write(GET_PIN(B, 14), 1);

    const char dtu_conf[4] = {device_status.vol, 0x00, 0x00, 0x00};
    va_list arg;
    static char dtu_str[800];
    rt_size_t str_length;
    va_start(arg, fmt);
    str_length = rt_vsnprintf(dtu_str, sizeof(dtu_str) - 1, fmt, arg);
    if (str_length > 800 - 1)
        str_length = 800 - 1;
    // rt_kprintf("DTU_Write data:%d\n%s\n", str_length, dtu_str);
    rt_device_write(dtuserial, 0, dtu_str, str_length);
    if (strstr(dtu_str, "volume") != RT_NULL)
    {
        rt_device_write(dtuserial, 0, dtu_conf, 4);
    }
    else if (strstr(dtu_str, "reset") != RT_NULL)
    {
        const char dtu_conf[4] = {7, 0x00, 0x00, 0x00};
        rt_device_write(dtuserial, 0, dtu_conf, 4);
    }
    va_end(arg);
    memset(dtu_str, '\0', sizeof(dtu_str));
    rt_pin_write(GET_PIN(B, 14), 0);
    //rt_kprintf("DTU_Write > %X > %d\n" , &dtuserial , dtuserial->device_id);
}
/* 接收数据回调函数 */
static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
{
    struct rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;
    result = rt_mq_send(&rx_mq_dtu, &msg, sizeof(struct rx_msg));
    if (result == -RT_EFULL)
    {
        /* 消息队列满 */
        rt_kprintf("message queue full！\n");
    }
    return result;
}

#include "Work_XCT.h"
extern SYSCFG syscfg;
/* 入口函数-指令接收*/
/**
 * @brief dtu数据的接收线程
 *
 * @param parameter NULL
 */
static void dtu_thread_entry_recv(void *parameter)
{
    struct rx_msg msg;
    rt_err_t result;
    rt_uint32_t rx_length;
    rt_uint32_t rx_err = 0;
    static char str_check[2] = {'{', '}'};
    static char rx_buffer[512];
    static char rx_buffer_tmp[512];
    static char rx_buffer_tmp2[512];
    while (1)
    {
        rt_memset(&msg, 0, sizeof(msg));
        // 从消息队列中获取被回调函数放入消息队列中的内容
        result = rt_mq_recv(&rx_mq_dtu, &msg, sizeof(struct rx_msg), 100);
        if (result == RT_EOK)
        {
            rx_err = 0;
            rx_length = (sizeof(rx_buffer) - 1) > msg.size ? msg.size : sizeof(rx_buffer) - 1;
            rx_length = rt_device_read(msg.dev, 0, &rx_buffer[0], rx_length);
            rx_buffer[rx_length] = '\0';
            rt_kprintf("recv data: %d %s", rx_length, rx_buffer);

            // 适配新屏幕
            if ((strstr(rx_buffer, "systest") != NULL) && (strstr(rx_buffer, "touch") != NULL))
            {
                screen_type = new;
                prase_test_cmd(rx_buffer);
            }
            // 拍照完成标记
            if (strstr(rx_buffer, "photolink") != RT_NULL && strstr(rx_buffer, "ALARM_INPUT") != RT_NULL)
            {
                syscfg.photo_finsh = 1; // 拍照完成回复
                rt_kprintf("photo_finsh \n\n\n");
            }

            if (strstr(rx_buffer, "{") == RT_NULL || strstr(rx_buffer, "}") == RT_NULL)
            {
                HMI_WRITE("sysTest.result.txt=\"%s\"", rx_buffer);
            }
            // 过滤异常数据
            char str_check_head[2];
            char str_check_end[2];
            rt_sprintf(str_check_head, "%c", rx_buffer[0]);
            rt_sprintf(str_check_end, "%c", rx_buffer[rx_length - 1]);
            if (str_check_end[0] == str_check[1] && str_check_head[0] == str_check[0])
            {
                parseDtu(rx_buffer);
                rt_memset(rx_buffer, 0, sizeof(rx_buffer));
                rt_memset(rx_buffer_tmp, 0, sizeof(rx_buffer_tmp));
                rt_memset(rx_buffer_tmp2, 0, sizeof(rx_buffer_tmp2));
            }
            else
            {
                if (rx_buffer[rx_length - 1] != '}')
                {
                    rt_sprintf(rx_buffer_tmp, "%s", rx_buffer);
                }
                else
                {
                    rt_sprintf(rx_buffer_tmp2, "%s", rx_buffer);
                    rt_sprintf(rx_buffer, "%s%s", rx_buffer_tmp, rx_buffer_tmp2);
                    // rt_kprintf("rxbuffer:%s",rx_buffer);
                    parseDtu(rx_buffer);
                    rt_memset(rx_buffer, 0, sizeof(rx_buffer));
                    rt_memset(rx_buffer_tmp, 0, sizeof(rx_buffer_tmp));
                    rt_memset(rx_buffer_tmp2, 0, sizeof(rx_buffer_tmp2));
                }
                // rt_kprintf("%s",rx_buffer);
            }
        }
        else
        {
            rx_err++;
            if (rx_err == 54000) // 90分钟未接收到数据
            {
                if (device_status.version_type == 6)
                {
                    LOG_E("RK3399 transter Error!");
                    ctr_photo(OFF);
                }
                else
                {
                    ctr_RTU_DTU(OFF);
                }
            }
            else if (rx_err == 54100 && device_status.bat_status == 0)
            {
                LOG_W("通信中断,RTU重新上电");
                rx_err = 0;
                ctr_RTU_DTU(ON);
                ctr_photo(ON);
            }
        }
        // rt_kprintf("%s\n",rx_json_buffer);
        //  将内容写回到串口1
        // rt_device_write(dtuserial, 0, &rx_json_buffer[0], rx_length);
    }
}
/*入口函数-指令发送*/
/**
 * @brief dtu数据的发送线程
 *
 * @param parameter NULL
 */
static void dtu_thread_entry_send(void *parameter)
{

    device_status.power_status = 1;
    device_status.num_updata = 0;
    rt_thread_delay(10000);
    static rt_uint16_t wait_i = 0;
    static rt_uint8_t check_i = 0;
    static rt_uint8_t power_i = 0;

    uint8_t cnt_reflash = 0;

    uint16_t log_en_inr = 30; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;
    static uint8_t onec = 0;
    while (1)
    {
        if (atoi(device_status.net) == 0)
        {

            onec = 1;
        }
        else if (onec == 0)
        {
            wait_i++;
            if (chk_log_time)
            {
                LOG_I("wait connect internet......%d", wait_i);
                rt_kprintf("net sta %s \n", device_status.net);
            }
        }

        rt_thread_mdelay(1000);

        if (++cnt_reflash >= 10)
        {
            cnt_reflash = 0;
            UpLoad_Data_refresh();
        }
    }
}

/* 创建线程 */
/**
 * @brief 用于创建dtu通信相关的线程
 *
 * 该线程在主线程中-读取完保存的设备参数之后调用
 *
 * @return int 完成后返回RT_EOK
 */
int dtu_data_play(void)
{
    rt_err_t rm_dtu_result;
    DTU_uart2_init();
    // 初始化消息队列
    rm_dtu_result = rt_mq_init(&rx_mq_dtu, "dtu", &data_arry.msg_pool[0], 128 - sizeof(void *), sizeof(data_arry.msg_pool), RT_IPC_FLAG_FIFO);
    if (rm_dtu_result == RT_EOK)
    {
        rt_kprintf("消息队列创建成功!!");
    }
    else
    {
        rt_kprintf("消息队列创建失败!!");
    }
    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(dtuserial, dtu_input);
    /*创建线程-指令发送*/
    dtu_send_data = rt_thread_create("DTU_Uart_thread_send",
                                     dtu_thread_entry_send, RT_NULL,
                                     DTU_THREAD_STACK_SIZE,
                                     3, // 优先级高是为了保证数据上传的频率的精确度
                                     20 // 时间片
    );
    /* 创建线程-指令接收解析*/
    dtu_recv_data = rt_thread_create("DTU_Uart_thread_recv",
                                     dtu_thread_entry_recv, RT_NULL,
                                     DTU_THREAD_STACK_SIZE+1024,
                                     DTU_THREAD_PRIORITY,
                                     DTU_THREAD_TIMESLICE);
    /* 如果获得线程控制块，启动这个线程 */
    if (dtu_send_data != RT_NULL)
        rt_thread_startup(dtu_send_data);
    /* 如果获得线程控制块，启动这个线程 */
    if (dtu_recv_data != RT_NULL)
        rt_thread_startup(dtu_recv_data);
    return RT_EOK;
}

/**
 * @brief 组包读取设备信息的json
 *
 * @return char* 组包完成后的字符串指针
 */
char *makeJson_ReadInfo()
{
    cJSON *rJsonRoot = NULL;
    rJsonRoot = cJSON_CreateObject();
    if (NULL == rJsonRoot)
    {
        return NULL;
    }
    cJSON_AddStringToObject(rJsonRoot, "uart", "getinfo");
    char *r = cJSON_PrintUnformatted(rJsonRoot);
    if (NULL == r)
    {
        cJSON_Delete(rJsonRoot);
        return NULL;
    }
    cJSON_Delete(rJsonRoot);
    return r;
}
//{"cmd": "platform", "ext": {"type": "120.27.222.26"}}
/**
 * @brief 组包平台参数的json
 *
 * @param plt 平台参数的内容
 * @return char* 组包完成后的字符串指针
 */
char *makeJson_platform(char *plt)
{
    cJSON *platform = NULL;
    platform = cJSON_CreateObject();
    if (NULL == platform)
    {
        return NULL;
    }
    cJSON_AddStringToObject(platform, "cmd", "platform");
    cJSON *extstr = NULL;
    extstr = cJSON_CreateObject();
    if (NULL == extstr)
    {
        return NULL;
    }
    cJSON_AddItemToObject(platform, "ext", extstr);
    cJSON_AddStringToObject(extstr, "type", plt);
    char *p_str = cJSON_PrintUnformatted(platform);
    if (NULL == p_str)
    {
        cJSON_Delete(platform);
        return NULL;
    }
    cJSON_Delete(platform);
    return p_str;
}

/**
 * @brief 组包拍照指令的json
 *
 * @return char* 完成后的指针
 */
char *makeJson_takephoto()
{
    cJSON *takephoto = NULL;
    takephoto = cJSON_CreateObject();
    if (NULL == takephoto)
    {
        return NULL;
    }
    cJSON_AddStringToObject(takephoto, "cmd", "takephoto");
    char *takephoto_str = cJSON_PrintUnformatted(takephoto);
    if (NULL == takephoto_str)
    {
        cJSON_Delete(takephoto);
        return NULL;
    }
    cJSON_Delete(takephoto);
    return takephoto_str;
}

/**
 * @brief 组包RTU拍照的json
 *
 * @return char* 完成后的指针
 */
char *makeJson_Rtutakephoto()
{
    cJSON *tJsonRoot = NULL;
    tJsonRoot = cJSON_CreateObject();
    if (NULL == tJsonRoot)
    {
        return NULL;
    }
    cJSON_AddStringToObject(tJsonRoot, "cmd", "ctrl");

    cJSON *tpubstring = NULL;
    tpubstring = cJSON_CreateObject();
    if (NULL == tpubstring)
    {
        LOG_E("cJSON tpubstring NULL!!!\n");
        return NULL;
    }
    cJSON_AddItemToObject(tJsonRoot, "ext", tpubstring);
    cJSON_AddStringToObject(tpubstring, "takephoto", "2");
    char *t = cJSON_PrintUnformatted(tJsonRoot);
    if (NULL == t)
    {
        cJSON_Delete(tJsonRoot);
        return NULL;
    }
    cJSON_Delete(tJsonRoot);
    return t;
}
// 预警消息
/**
 * @brief 组包预警信息的json
 *
 * @param s status
 * @param t type
 * @return char* 完成后的指针
 */
char *makeJson_Warn(char *s, char *t)
{
    cJSON *wJsonRoot = NULL;
    wJsonRoot = cJSON_CreateObject();
    if (NULL == wJsonRoot)
    {
        return NULL;
    }
    cJSON_AddStringToObject(wJsonRoot, "cmd", "warn");
    cJSON *pubstring = NULL;
    pubstring = cJSON_CreateObject();
    if (NULL == pubstring)
    {
        rt_kprintf("cJSON pubstring NULL!!!\n");
        return NULL;
    }
    cJSON_AddItemToObject(wJsonRoot, "ext", pubstring);
    cJSON_AddStringToObject(pubstring, "status", s); //
    cJSON_AddStringToObject(pubstring, "type", t);
    char *w = cJSON_PrintUnformatted(wJsonRoot);
    if (NULL == w)
    {
        cJSON_Delete(wJsonRoot);
        rt_kprintf("wJsonRoot cJSON_Delete NULL!!!\n");
        return NULL;
    }
    cJSON_Delete(wJsonRoot);
    return w;
}
#include "Work_XCT.h"
extern Limit limit;
extern SYSCFG syscfg;
extern wm_Def workmode;

#include "rs485.h"
extern Sensor sensor[MAX_SENSOR_NUM];

char *makeJson_with_para(uint8_t type)
{

    char utos[5];
    if (device_status.gps == NULL)
        rt_sprintf(device_status.gps, "0");
    // 如果设备工作并且电流小于500，并且不是上电启动灯管异常
    if (atoi(device_status.power) < 400 && atoi(device_status.power) != 0 && device_status.work_status == 1 && makejson_sta != 0)
    {
#if LAMP_EN == 0
        LOG_I("Current is:%d", atoi(device_status.power));
        if (atoi(device_status.power) > 10) // 过滤电流检测芯片损坏导致电流直为0 的异常
            device_status.lamp_status = 1;
#endif
    }
    else
    {
        device_status.lamp_status = 0;
    }
    if (atoi(device_status.power) > 5000)
        rt_sprintf(device_status.power, "0.01");

    makejson_sta = 1;
    time_t stamp = time(RT_NULL);
    static struct tm tm;
    gmtime_r(&stamp, &tm);
    rt_sprintf(device_status.stamp, "%04d%02d%02d%02d%02d%02d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

    cJSON *pJsonRoot = NULL;
    pJsonRoot = cJSON_CreateObject();
    if (NULL == pJsonRoot)
    {
        rt_kprintf("cJSON pJsonRoot NULL!!!\n");
        return NULL;
    }
    if (type == 0x0A)
    {
        cJSON_AddStringToObject(pJsonRoot, "cmd", "data");
    }
    else
    {
        cJSON_AddStringToObject(pJsonRoot, "cmd", "refresh");
    }

    cJSON *pSubJson = NULL;
    pSubJson = cJSON_CreateObject();
    if (NULL == pSubJson)
    {
        rt_kprintf("cJSON pSubJson NULL!!!\n");
        return NULL;
    }
    memset(device_status.driver, 0, sizeof(device_status.driver));

    rt_sprintf(device_status.driver, "%s-%s", VERSION_XCT, device_status.driver_4g);

    if (device_status.sensor_485_sta != 0)
    {
        if (strstr(device_status.driver, "485") == RT_NULL)
            strcat(device_status.driver, ".485");
    }
    cJSON_AddItemToObject(pJsonRoot, "ext", pSubJson);
    cJSON_AddStringToObject(pSubJson, "dver", device_status.driver);  // 版本号,字符型
    cJSON_AddStringToObject(pSubJson, "proj", device_status.project); // 项目类型
    // 设备类型
    rt_sprintf(utos, "%d", device_status.dtype);
    cJSON_AddStringToObject(pSubJson, "dtype", utos);

    // 光控定时时长
    rt_sprintf(utos, "%d", limit.LuxTime);
    cJSON_AddStringToObject(pSubJson, "tt", utos);

    // 时控定时开始
    rt_sprintf(utos, "%d", device_status.collecting_sh1);
    cJSON_AddStringToObject(pSubJson, "collstart", utos);

    // 时控定时结束
    rt_sprintf(utos, "%d", device_status.collecting_eh1);
    cJSON_AddStringToObject(pSubJson, "collend", utos);

    // 定时模式
    // rt_sprintf(utos, "%d", workmode);
    rt_sprintf(utos, "%d", limit.LuxEN);
    cJSON_AddStringToObject(pSubJson, "ts", utos);

    // 温控开关
    rt_sprintf(utos, "%d", limit.temhumEN);
    cJSON_AddStringToObject(pSubJson, "tps", utos);

    // 高温保护
    rt_sprintf(utos, "%d", limit.temp_up);
    cJSON_AddStringToObject(pSubJson, "tph", utos);

    // 低温保护
    rt_sprintf(utos, "%d", limit.temp_dw);
    cJSON_AddStringToObject(pSubJson, "tpl", utos);

    // 雨控开关
    rt_sprintf(utos, "%d", limit.RainEN);
    cJSON_AddStringToObject(pSubJson, "rps", utos);

    // 当前光控状态
    rt_sprintf(utos, "%d", device_status.lps_sta);
    cJSON_AddStringToObject(pSubJson, "lps", utos);

    // 当前雨控状态
    rt_sprintf(utos, "%d", device_status.rain_status);
    cJSON_AddStringToObject(pSubJson, "nrps", utos);

    // 当前温控状态
    rt_sprintf(utos, "%d", device_status.temp_status);
    cJSON_AddStringToObject(pSubJson, "ntps", utos);

    // 电池状态
    rt_sprintf(utos, "%d", device_status.bat_status);
    cJSON_AddStringToObject(pSubJson, "batStatus", utos);

    // 上灯管状态
    rt_sprintf(utos, "%d", rt_pin_read(LAMP_SW));
    cJSON_AddStringToObject(pSubJson, "lamp", utos);

    // 下灯管状态
    rt_sprintf(utos, "%d", rt_pin_read(LAMP_SW_DOWN));
    cJSON_AddStringToObject(pSubJson, "lamp_down", utos);

    // 补光灯
    rt_sprintf(utos, "%d", rt_pin_read(LED_SW));
    cJSON_AddStringToObject(pSubJson, "led", utos);

    // 定位状态
    cJSON_AddStringToObject(pSubJson, "gps", device_status.gps);
    // 开关状态
    rt_sprintf(utos, "%d", device_status.ds);
    cJSON_AddStringToObject(pSubJson, "ds", utos);

    char *temp_c = NULL;
    char *humi_c = NULL;

    if (sensor[s_Temp].online)
        temp_c = sensor[s_Temp].eValue;
    else
        temp_c = device_status.tempture;
    if (sensor[s_Humi].online)
        humi_c = sensor[s_Humi].eValue;
    else
        humi_c = device_status.humidity;
    // rt_kprintf("temp %s humi %s\n",temp_c , humi_c);
    //  温度
    cJSON_AddStringToObject(pSubJson, "at", temp_c);
    // 湿度
    cJSON_AddStringToObject(pSubJson, "ah", humi_c);

    cJSON_AddStringToObject(pSubJson, "imei", device_status.imei);   // IMEI
    cJSON_AddStringToObject(pSubJson, "iccid", device_status.iccid); // ICCID
    cJSON_AddStringToObject(pSubJson, "stamp", device_status.stamp); // 时间
    // 经度
    cJSON_AddStringToObject(pSubJson, "lng", device_status.lng);
    // 纬度
    cJSON_AddStringToObject(pSubJson, "lat", device_status.lat);
    // 是否为上电开机
    cJSON_AddNumberToObject(pSubJson, "rcnt", device_status.rebootcnt);
    // 电流(当前)
    cJSON_AddStringToObject(pSubJson, "current", device_status.power);
    // 电压
    cJSON_AddStringToObject(pSubJson, "vbat", device_status.voltage);
    // 数据上传间隔
    rt_sprintf(utos, "%d", device_status.dattim);
    cJSON_AddStringToObject(pSubJson, "dat_f", utos);

    // 照片上传间隔
    rt_sprintf(utos, "%d", device_status.photim);
    cJSON_AddStringToObject(pSubJson, "pho_f", utos);

    // 风机调速
    rt_sprintf(utos, "%d", syscfg.fan_speed);
    cJSON_AddStringToObject(pSubJson, "fan_speed", utos);

    // 演示模式
    rt_sprintf(utos, "%d", syscfg.Demo_mode);
    cJSON_AddStringToObject(pSubJson, "Demo_mode", utos);

    if (type != 0x0A)
    {
        // 风机状态
        rt_sprintf(utos, "%d", rt_pin_read(Collect_Fan));
        cJSON_AddStringToObject(pSubJson, "fan_sta", utos);

        // LED状态
        rt_sprintf(utos, "%d", rt_pin_read(LED_SW));
        cJSON_AddStringToObject(pSubJson, "led_sta", utos);
    }
    else
    {
        rt_kprintf("type %X\n", type);
    }

    // 信号强度
    cJSON_AddStringToObject(pSubJson, "csq", device_status.csq);
    char *p = cJSON_PrintUnformatted(pJsonRoot);
    if (NULL == p)
    {
        cJSON_Delete(pJsonRoot);
        rt_kprintf("cJSON_Delete NULL!!!\n");
        return NULL;
    }

    cJSON_Delete(pJsonRoot);
    return p;
}

/*生成JSON数据*/
/**
 * @brief 组包设备状态信息的json
 *
 * @return char* 完成后的指针
 */
char *makeJson()
{
    return makeJson_with_para(0x0A);
}

// 适用于给安卓屏刷新状态
char *makeJson_refresh()
{
    return makeJson_with_para(0x0B);
}

/**
 * @brief 组包返回信息的json
 *
 * @return char* 组包完成后的字符串指针
 */
char *makeJson_Return(char *cmd, char *data)
{
    // 创建一个JSON对象
    cJSON *root = cJSON_CreateObject();
    if (root == NULL)
    {
        fprintf(stderr, "Error creating JSON object\n");
        return NULL;
    }

    // 在JSON对象中添加键值对
    cJSON_AddStringToObject(root, cmd, data);

    // 将JSON对象转换为字符串
    char *json_str = cJSON_Print(root);
    if (json_str == NULL)
    {
        fprintf(stderr, "Error printing JSON string\n");
        // 释放JSON对象的内存
        cJSON_Delete(root);
        return NULL;
    }

    // 释放JSON对象的内存
    cJSON_Delete(root);

    return json_str;
}

/*****************          241217 新增控制指令框架         *******************/

#include "Work_XCT.h"
#include "rs485.h"
#define return_modle "{\"cmd\": \"data\", \"ext\": %s}"
extern void getEcodeData(uint8_t type);
extern wm_Def workmode;
extern WorkMode_Def WorkModeList[TypeMAX_wx];
extern Caw_def Check_Allow_Work(void);
extern Sunwork swork;
extern Luxwork lwork;
extern Sensor sensor[MAX_SENSOR_NUM];
extern void CollFanSetPWM(uint8_t percent);

static char RC_Res[512] = {0};
static char temp[64] = {0};

static RC_Def rcdList[TypeMAX_rcd] =
    {
        {read_limit_rcd, "read_limit"},
        {TEMP_ON_rcd, "TEMP_ON"},
        {TEMP_OFF_rcd, "TEMP_OFF"},
        {RAIN_ON_rcd, "RAIN_ON"},
        {RAIN_OFF_rcd, "RAIN_OFF"},

        {RunFRMS_rcd, "RunFRMS"},
        {RunLight_rcd, "RunLight"},
        {RunTime_rcd, "RunTime"},

        {Read_ecode_rcd, "Read_ecode"},
        {Read_status_rcd, "Read_status"},
        {Clear_log_rcd, "clear_log"},

        {RebootRTU_rcd, "RebootRTU"},
        {Demo_ON_rcd, "Demo_ON"},
        {Force_Reset_rcd, "Force_Reset"}

};

static RCD Get_RCType(char *cmd)
{
    RCD res = TypeMAX_rcd;

    for (uint8_t a = 0; a < TypeMAX_rcd; a++)
    {
        if (strstr(cmd, rcdList[a].keyword) != NULL)
        {
            return rcdList[a].rcd;
        }
    }
    return res;
}

/**
 * @brief 把收到的请求指令解析出来
 *
 * @param cmd 指令
 */
void prase_Rcmd(char *cmd)
{
    if (strstr(cmd, "RC") == NULL || Get_RCType(cmd) == TypeMAX_rcd)
    {
        rt_kprintf("prase_Rcmd no keyword find \n\n");
        return;
    }

    RCD type = Get_RCType(cmd);

    // rt_kprintf("type %d \n", type);

    switch (type)
    {
    case read_limit_rcd:

        sprintf(RC_Res, "\"温湿控- %s | 光控-%s | 雨控-%s\"",
                limit.temhumEN ? "开" : "关",
                limit.LuxEN ? "开" : "关",
                limit.RainEN ? "开" : "关");

        break;

    case TEMP_ON_rcd:

        limit.temhumEN = ON;
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;

    case TEMP_OFF_rcd:

        limit.temhumEN = OFF;
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;

    case RAIN_ON_rcd:

        limit.RainEN = ON;
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;

    case RAIN_OFF_rcd:

        limit.RainEN = OFF;
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;
    case RunFRMS_rcd:
        ef_get_env_blob("swork", &swork, sizeof(swork), NULL);
        swork.Read = 1;
        swork.EN = ON;
        ef_set_env_blob("swork", &swork, sizeof(swork));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;
    case RunLight_rcd:

        swork.Read = 1;
        swork.EN = OFF;
        ef_set_env_blob("swork", &swork, sizeof(swork));

        limit.LuxEN = ON;
        if (limit.LuxTime == 0)
        {
            limit.LuxTime = gktime_def;
        }
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;
    case RunTime_rcd:

        swork.Read = 1;
        swork.EN = OFF;
        ef_set_env_blob("swork", &swork, sizeof(swork));

        limit.LuxEN = OFF;
        ef_set_env_blob("limit", &limit, sizeof(Limit));
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
        break;

    case Read_ecode_rcd:
        getEcodeData(1);
        break;

    case Clear_log_rcd:
        ef_log_clean();
        char static_array[] = "{\"cmd\":\"data\",\"ext\":{\"RC\":\"Ecode 已清空\"}}";
        DTU_Write(static_array);
        break;


    case RebootRTU_rcd:
        rt_pin_write(RTU_DTU, OFF);
        CTL_CAM0();
        rt_thread_mdelay(3000);
        Recode_e_code(e_rtu_reboot , 0 , "RTU断电重启");
        rt_hw_cpu_reset();
        break;

    case Force_Reset_rcd:
        ef_env_set_default();
        device_status.stop_in_bootloader = 0;
        ef_set_env_blob("stop_in_bootloader", &device_status.stop_in_bootloader, sizeof(device_status.stop_in_bootloader));
        Recode_e_code(e_para_setdef , 0 ,"强制恢复默认参数");
        sprintf(RC_Res, "\"%s\"", rcdList[type].keyword);
    break;
    

    default:

        break;
    }
    if ((type != Read_ecode_rcd) && (type != Clear_log_rcd))
    {
        //        rt_kprintf("\n");
        //        rt_kprintf(return_modle, RC_Res);
        //        rt_kprintf("\n");
        DTU_Write(return_modle, RC_Res);
    }
    if(type == Force_Reset_rcd)
    {
        rt_hw_cpu_reset();
    }
}


/*****************          241217 新增控制指令框架         *******************/

/**
 * @brief 获取Cjson数值
 *
 * @return int
 */

int cjson_getval(cJSON *json)
{
    if (json->type == cJSON_Number)
    {
        return json->valueint;
    }
    else if (json->type == cJSON_String)
    {
        return atoi(json->valuestring);
    }
    else
    {
        return -99;
    }
}

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

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

    cJSON_AddStringToObject(root, "type", "info");

    // 创建嵌套的"ext"对象
    cJSON *ext = cJSON_CreateObject();
    if (!ext)
    {
        fprintf(stderr, "Failed to create ext JSON object.\n");
        cJSON_Delete(root);
        return;
    }
    // Recode_e_code(code, para, detail)
    uint32_t used = ef_log_get_used_size();
    uint32_t cnt = used / sizeof(Record);

    uint16_t pages = cnt / EcodeOnePageNum;

    if (pages * EcodeOnePageNum < cnt)
    {
        pages++;
    }

    cJSON_AddNumberToObject(ext, "count", cnt);
    cJSON_AddNumberToObject(ext, "pages", pages);

    // 将"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;
    }

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

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

void ecode_concent_json(uint16_t page_num)
{

    uint32_t used = ef_log_get_used_size();
    uint32_t cnt = used / sizeof(Record);
    uint16_t pages = cnt / EcodeOnePageNum;
    if (pages * EcodeOnePageNum < cnt)
    {
        pages++;
    }

    if (page_num >= pages)
    {
        rt_kprintf("ecode_concent_json > illagl para \n");
        return;
    }

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

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

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

    //    cJSON_AddNumberToObject(ext, "count", cnt);
    //    cJSON_AddNumberToObject(ext, "pages", pages);

    cJSON_AddStringToObject(root, "type", "data");

    Record ecode = {0};
    RTC_DateTypeDef r_date = {0};
    RTC_TimeTypeDef r_time = {0};
    char cache[96] = {0};
    char c_num[8] = {0};

    uint16_t start = 0, end = 0;

    start = (EcodeOnePageNum * page_num);

    if (page_num + 1 == pages)
    {
        end = cnt;
    }
    else
    {
        end = (EcodeOnePageNum * page_num + EcodeOnePageNum);
    }

    for (uint16_t a = start; a < end; 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);

            sprintf(c_num, "%d", ecode.num);
            sprintf(cache, "%02d/%02d/%02d %02d:%02d:%02d (%02d-%02d) : %s",
                    r_date.Year, r_date.Month, r_date.Date,
                    r_time.Hours, r_time.Minutes, r_time.Seconds,
                    ecode.code, ecode.para, ecode.detail);

            cJSON_AddStringToObject(ext, c_num, cache);

            memset(&ecode, 0, sizeof(ecode));
        }
        else
        {
            LOG_I("ef_log_read %d fail\n", a);
        }
    }

    // 将"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;
    }

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

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

extern RTC_DateTypeDef GetDate;
extern RTC_TimeTypeDef GetTime;
/**
 * @brief 检查将要对时的时间是否合法
 *
 * @param cmd 字符串的时间
 * @return char 0-非法 1-合法
 */
static char CHECK_DATE(char *cmd)
{
    if (cmd == NULL)
    {
        return -1;
    }
    ReFlash_RTC();
    char datetime[12] = {0};
    strncpy(datetime, cmd, 10);
    uint32_t ntc_time = atoi(datetime);

    uint32_t yyyy = 2000 + GetDate.Year;
    uint32_t mm = GetDate.Month;
    uint32_t dd = GetDate.Date;
    uint32_t hh = GetTime.Hours;

    uint32_t now_time = (yyyy * 1000000) + (mm * 10000) + (dd * 100) + hh;

    if (ntc_time >= now_time)
    {
        return 1;
    }

    LOG_E("NTP Time val illagl %s \n", cmd);

    return 0;
}
extern void prase_test_cmd(char *cmd);
extern Reflash_test_sta rts;
// JSON数据解析
/**
 * @brief 解析dtu发来的指令
 *
 * @param json_string 收到的json字符串
 * @return int 0 完成
 */
int parseDtu(char *json_string)
{
    extern int rt_hw_rtc_init(void);
    char *json_s = NULL;
    cJSON *item_cmd = NULL;       // 嵌套ext
    cJSON *item_ext = NULL;       // 嵌套ext
    cJSON *item_checkself = NULL; //

    /**
     * 有用的小虫体指令
     *
     */

    cJSON *collstart = NULL; // 时控开始（整型 / 时）
    cJSON *collend = NULL;   // 时控结束（整型 / 时）

    cJSON *tt = NULL; // 光控定时时长（整型 / 时）
    cJSON *ts = NULL; // 工作模式（整型 / 0-时控 1-光控）

    cJSON *tpl = NULL; // 低温保护阈值
    cJSON *tph = NULL; // 高温保护阈值

    cJSON *inr_data = NULL;  // 数据上传间隔（整型 / min）
    cJSON *inr_photo = NULL; // 拍照间隔（整型 / min）

    cJSON *limit_temp = NULL; // 设置温控开关（bool / 0-关闭 1-开启）
    cJSON *limit_rain = NULL; // 设置雨控开关（bool / 0-关闭 1-开启）

    // 晨曦模式新增参数

    cJSON *RunFRMS = NULL;   // 晨曦模式开关
    cJSON *FRMSlseek = NULL; // 晨曦模式便宜量
    cJSON *setLux = NULL;    // 晨曦模式光控阈值

    // 晨曦模式新增参数

    cJSON *tps = NULL; // 温控开关

    cJSON *Demo_mode = NULL;

    cJSON *no_reply = NULL;

    /**
     * 有用的小虫体指令
     *
     */

    cJSON *gps = NULL; // 定位状态
    cJSON *datetime = NULL;
    cJSON *lat = NULL;
    cJSON *lng = NULL;
    cJSON *csq = NULL;
    cJSON *net = NULL;
    cJSON *iccid = NULL;
    cJSON *imei = NULL;
    cJSON *sim = NULL;
    cJSON *volume = NULL;
    cJSON *driver_4g = NULL; // 版本号
    cJSON *project = NULL;   // Project
    cJSON *ds = NULL;        // 设备状态
    // cJSON *vt = NULL;        // 版本类型
    //     cJSON* account_status = NULL;   //卡状态
    //     cJSON* data_plan = NULL;        //套餐
    //     cJSON* data_usage = NULL;       //已使用
    //     cJSON* expiry_date = NULL;      //到期时间
    cJSON *mqttcfg1 = NULL;
    cJSON *mqttcfg2 = NULL;
    cJSON *type = NULL;
    cJSON *hum = NULL;
    cJSON *tmp = NULL;
    cJSON *sunrise = NULL;
    cJSON *sunset = NULL;
    cJSON *link_sta = NULL;
    cJSON *value_commn = NULL;
    cJSON *fan_speed = NULL;
    cJSON *pages = NULL;
    // rt_kprintf("parseDtu ： %s\n", json_string);
    cJSON *root = cJSON_Parse(json_string);
    if (!root)
    {
        cJSON_Delete(root);
        rt_kprintf("parse json err:%s", json_string);
        return -1;
    }
    // 适配远程控制指令
    else if (strstr(json_string, "RC") != NULL)
    {
        prase_Rcmd(json_string);
    }

    else
    {
        item_cmd = cJSON_GetObjectItem(root, "cmd");
        item_ext = cJSON_GetObjectItem(root, "ext");
        item_checkself = cJSON_GetObjectItem(root, "selfcheck");
        // item_data = cJSON_GetObjectItem(root,"data");
        if (item_checkself != NULL)
        { // 自检签名
            LOG_I("自检签名:%s", item_checkself->valuestring);
            // 执行一键测试任务
            jts.autotest = ON;
            device_status.test_flag = 10;
        }
        if (item_cmd != RT_NULL)
        {
            if (strstr(item_cmd->valuestring, "ReadEcodeInfo") != RT_NULL)
            {
                ecodeinfo_json();
            }
            else if (strstr(item_cmd->valuestring, "takephoto") != RT_NULL)
            {
                // HK_TakePhoto();
                device_status.photo_ws = 1;
                char *photo = makeJson_Warn("takephoto", "control");
                DTU_Write("%s", photo);
                rt_free(photo);
                rt_thread_delay(2000);
            }
            else if (strstr(item_cmd->valuestring, "json_w_clock") != RT_NULL)
            {
                rt_kprintf("查询时间配置!\n");
                json_s = makeJson_Warn(device_status.json_w_clock, "主动查询");
                DTU_Write("%s", json_s);
                rt_free(json_s);
                rt_thread_delay(1000);
            }
            else if (strstr(item_cmd->valuestring, "json_w_reset") != RT_NULL)
            {
                rt_kprintf("查询重置配置!\n");
                json_s = makeJson_Warn(device_status.json_w_reset, "主动查询");
                DTU_Write("%s", json_s);
                rt_free(json_s);
                rt_thread_delay(1000);
            }
            else if (strstr(item_cmd->valuestring, "json_w_platform") != RT_NULL)
            {
                rt_kprintf("查询平台配置!\n");
                json_s = makeJson_Warn(device_status.json_w_platform, "主动查询");
                DTU_Write("%s", json_s);
                rt_free(json_s);
                rt_thread_delay(1000);
            }
            else if (strstr(item_cmd->valuestring, "shake") != RT_NULL)
            {
                ctr_shake(ON, 30);
                char *shake = makeJson_Warn("shake", "control");
                DTU_Write("%s", shake);
                rt_free(shake);
                rt_thread_delay(2000);
            }
            // 远程给rtu重新上电
            else if (strstr(item_cmd->valuestring, "ctrl") != RT_NULL)
            {
                type = cJSON_GetObjectItem(item_ext, "type");
                if (strstr(type->valuestring, "rtu_off_on") != RT_NULL)
                {
                    LOG_W("DTU 12V Power down");
                    ctr_RTU_DTU(OFF);
                    rt_thread_delay(5000);
                    ctr_RTU_DTU(ON);
                }
                // 对焦拍照
                else if (strstr(type->valuestring, "auto_takephoto") != RT_NULL)
                {
                    device_status.autotakepic = 1;
                    rt_thread_delay(2000);
                    char *auto_takephoto = makeJson_Warn("send cmd success:auto_takephoto", "control");
                    DTU_Write("%s", auto_takephoto);
                    rt_free(auto_takephoto);
                }
                else if (strstr(type->valuestring, "takephoto") != RT_NULL)
                {
                    // HK_TakePhoto();

                    rts.takephoto_t = tig_ON;
                    char *takephotojson = makeJson_takephoto();
                    DTU_Write("%s", takephotojson);
                    rt_free(takephotojson);

                    rt_kprintf("cmd triger takepho\n");

                    rt_thread_delay(2000);
                }
                //{"ext": {"type": "turn"}, "cmd": "ctrl"}   转仓
                else if (strstr(type->valuestring, "turn") != RT_NULL)
                {
#if Color_EN == 0
                    char *turn_zp = makeJson_Warn("send cmd success:turn_zp", "control");
                    DTU_Write("%s", turn_zp);
                    rt_free(turn_zp);
                    ctr_turn(90, 0);
#else
                    DTU_Write("黄板复位:%d", ctr_Color_board(RESET, 800));
#endif
                }
            }
            // 切换平台
            else if (strstr(item_cmd->valuestring, "platform") != RT_NULL)
            {
                type = cJSON_GetObjectItem(item_ext, "type");
                if (strstr(type->valuestring, "8.136.98.49") != RT_NULL)
                {
                    rt_sprintf(device_status.mqttcfg1, "8.136.98.49");
                    ef_set_env_blob("platform", &device_status.mqttcfg1, sizeof(device_status.mqttcfg1));
                    // 给RTU发送切换指令
                    DTU_Write("%s", makeJson_platform("8.136.98.49"));
                    rt_free(makeJson_platform("8.136.98.49"));
                    rt_thread_delay(1000);
                    rt_sprintf(device_status.json_w_platform, "平台操作:切换平台>大数据,操作时间:%s", device_status.stamp);
                    json_s = makeJson_Warn(device_status.json_w_platform, "切换平台");
                    ef_set_env_blob("json_w_platform", &device_status.json_w_platform, sizeof(device_status.json_w_platform)); // 将修改屏幕参数操作记录保存到Flash中
                    if (atoi(device_status.net) == 0)
                        DTU_Write("%s", json_s);
                    rt_free(json_s);
                    rt_thread_delay(1000);
                    MA_save();
                }
                else if (strstr(type->valuestring, "120.27.222.26") != RT_NULL)
                {
                    rt_sprintf(device_status.mqttcfg1, "120.27.222.26");
                    ef_set_env_blob("platform", &device_status.mqttcfg1, sizeof(device_status.mqttcfg1));
                    // 给RTU发送切换指令
                    DTU_Write("%s", makeJson_platform("120.27.222.26"));
                    rt_free(makeJson_platform("120.27.222.26"));
                    rt_thread_delay(1000);
                    rt_sprintf(device_status.json_w_platform, "平台操作:切换平台>四情,操作时间:%s", device_status.stamp);
                    json_s = makeJson_Warn(device_status.json_w_platform, "切换平台");
                    ef_set_env_blob("json_w_platform", &device_status.json_w_platform, sizeof(device_status.json_w_platform)); // 将修改屏幕参数操作记录保存到Flash中
                    if (atoi(device_status.net) == 0)
                        DTU_Write("%s", json_s);
                    rt_free(json_s);
                    rt_thread_delay(1000);
                    MA_save();
                }
            }
            // 水稻2000万像素的串口拍照指令
            else if (strstr(item_cmd->valuestring, "mvs_photo") != RT_NULL)
            {
                HK_TakePhoto();
                char *photo = makeJson_Warn("mvs_takephoto", "control");
                DTU_Write("%s", photo);
                rt_free(photo);
                rt_thread_delay(2000);
            }
            else if (strstr(item_cmd->valuestring, "dtu_reboot") != RT_NULL)
            {
                char *restart = makeJson_Warn("sysrem will restart [RTU]", "control");
                rt_kprintf("%s\n", restart);
                DTU_Write("%s", restart);
                rt_thread_delay(2000);
                rt_pin_write(RTU_DTU, OFF);
                CTL_CAM0();
                rt_thread_mdelay(3000);
                Recode_e_code(e_rtu_reboot , 1 , "RTU断电重启");
                rt_hw_cpu_reset();
            }
            else if (strstr(item_cmd->valuestring, "reboot") != RT_NULL)
            {
                char *restart = makeJson_Warn("sysrem will restart", "control");
                rt_kprintf("%s\n", restart);
                rt_thread_delay(2000);
                DTU_Write("%s", restart);
                rt_hw_cpu_reset();
            }
            else if (strstr(item_cmd->valuestring, "reset") != RT_NULL)
            {
                ResetParamDefault();
                char *restart = makeJson_Warn("sysrem will reset", "control");
                DTU_Write("%s", restart);
                rt_free(restart);
                rt_thread_delay(2000);
            }
            else if (strstr(item_cmd->valuestring, "update") != RT_NULL)
            {
                rt_kprintf("准备升级!!!");
                device_status.update_flag = 1;
                ef_set_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag));
                rt_kprintf("%s\n", makeJson_Warn("system will update", "control"));
                rt_thread_delay(2000);
                DTU_Write("%s", makeJson_Warn("system will update", "control"));
                rt_thread_delay(20);
                rt_hw_cpu_reset(); // 现在升级不能先重启再下载
            }
            else if (strstr(item_cmd->valuestring, "read") != RT_NULL)
            {

                char *readinfo = makeJson_ReadInfo();
                DTU_Write("%s", readinfo);
                rt_kprintf("%s\n", readinfo);
                rt_free(readinfo);
                device_status.hmi_fresh = 2;
                device_status.refresh_num = 15;
            }
            else if (strstr(item_cmd->valuestring, "poweron") != RT_NULL)
            {
                device_status.ds = 1;
                ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds)); //
                UpLoad_Data();
                rt_kprintf("UpLoad_Data Mark B \n\n");
            }
            else if (strstr(item_cmd->valuestring, "poweroff") != RT_NULL)
            {
                device_status.ds = 0;
                ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds)); //
                UpLoad_Data();
                rt_kprintf("UpLoad_Data Mark C \n\n");
            }
            //              else if (strstr(item_cmd->valuestring,"log")!=RT_NULL) {
            //                  rt_thread_mdelay(2000);
            //                  //read_all_flash_log();
            //            }
            // 设置温湿度
            else if (strstr(item_cmd->valuestring, "sensor") != RT_NULL)
            {
                // 2022-04-12add：485传感器正常,不再解析服务器下发的温湿度数据
                // if(device_status.sensor_485_sta!=0) return 0;
                hum = cJSON_GetObjectItem(item_ext, "new_hum");
                tmp = cJSON_GetObjectItem(item_ext, "new_tem");
                if (hum != NULL && tmp != NULL)
                {
                    // 先判断是否是空字符再判断数值是否合理
                    if (strcmp(hum->valuestring, "") != 0 && atoi(hum->valuestring) >= 0 && atoi(hum->valuestring) <= 100 && atoi(hum->valuestring) != 30 && device_status.sensor_485_sta == 0)
                    {
                        if (atoi(hum->valuestring) != atoi(device_status.humidity))
                        {
                            rt_sprintf(device_status.humidity, "%s", hum->valuestring);
                            ef_set_env_blob("env_h", &device_status.humidity, sizeof(device_status.humidity)); // 湿度
                            rt_kprintf("保存湿度成功:%d\n", atoi(device_status.humidity));
                        }
                        LOG_I("设置湿度成功:%d\n", atoi(device_status.humidity));
                    }
                    else
                    {
                        rt_kprintf("设置湿度失败:%s!!!\n", hum->valuestring);
                    }
                    // 先判断是否是空字符再判断数值是否合理
                    if (strcmp(tmp->valuestring, "") != 0 && atoi(tmp->valuestring) > -50 && atoi(tmp->valuestring) <= 100 && device_status.sensor_485_sta == 0)
                    {
                        if (atoi(tmp->valuestring) != atoi(device_status.tempture))
                        {
                            rt_sprintf(device_status.tempture, "%s", tmp->valuestring);
                            ef_set_env_blob("env_t", &device_status.tempture, sizeof(device_status.tempture)); // 湿度
                            rt_kprintf("保存温度成功:%d\n", atoi(device_status.tempture));
                        }
                        LOG_I("设置温度成功:%d\n", atoi(device_status.tempture));
                    }
                    else
                    {
                        rt_kprintf("设置温度失败:%s!!!\n", tmp->valuestring);
                    }
                }
                sunrise = cJSON_GetObjectItem(item_ext, "sunrise");
                sunset = cJSON_GetObjectItem(item_ext, "sunset");
                if (sunrise != NULL && sunset != NULL)
                {
                    char cache[3] = {0};
                    char cach1[3] = {0};
                    char en_saveswork = 0;
                    // rt_kprintf("sunset size %d %s\n", sizeof(sunrise->valuestring) , sunrise->valuestring);
                    if (sunrise->valuestring[2] == ':')
                    {
                        cache[0] = sunrise->valuestring[0];
                        cache[1] = sunrise->valuestring[1];
                        cache[2] = '\0';
                        // rt_kprintf("cache %d\n" , atoi(cache));
                        cach1[0] = sunrise->valuestring[3];
                        cach1[1] = sunrise->valuestring[4];
                        cach1[2] = '\0';
                        // rt_kprintf("cach1 %d\n" , atoi(cach1));
                        if (atoi(cache) >= 4 && atoi(cache) < 9)
                        {
                            swork.sunrise_time.Hours = atoi(cache);
                            swork.sunrise_time.Minutes = atoi(cach1);
                            en_saveswork = 1;
                        }
                    }
                    if (sunset->valuestring[2] == ':')
                    {
                        cache[0] = sunset->valuestring[0];
                        cache[1] = sunset->valuestring[1];
                        cache[2] = '\0';
                        // rt_kprintf("cache %d\n" , atoi(cache));
                        cach1[0] = sunset->valuestring[3];
                        cach1[1] = sunset->valuestring[4];
                        cach1[2] = '\0';
                        // rt_kprintf("cach1 %d\n" , atoi(cach1));
                        if (atoi(cache) >= 16 && atoi(cache) < 21)
                        {
                            swork.sunset_time.Hours = atoi(cache);
                            swork.sunset_time.Minutes = atoi(cach1);
                            en_saveswork = 1;
                        }
                    }
                    if (en_saveswork)
                    {
                        LOG_I("rise %d.%d set %d.%d\n", swork.sunrise_time.Hours, swork.sunrise_time.Minutes, swork.sunset_time.Hours, swork.sunset_time.Minutes);
                        ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
                        en_saveswork = 0;
                    }
                }
                rt_kprintf("do not report data now\n");
                return;
            }
            else if (strstr(item_cmd->valuestring, "color") != RT_NULL)
            {
                if (item_ext != RT_NULL && strstr(item_ext->valuestring, "turn") != RT_NULL)
                {
                    device_status.run_sta = 5;
                }
                else
                {
                    LOG_W("Unknow cmd value!");
                }
            }
            else if (strstr(item_cmd->valuestring, "synchronization") != RT_NULL)
            {
// #if Color_EN == 0
//                 if (device_status.dtype == 7)
//                 {
//                     DTU_Write("%s", "SwversionVXCT");
//                 }
//                 else if (device_status.dtype == 3)
//                 {
//                     DTU_Write("%s", "SwversionVXCT");
//                 }
// #endif
                device_status.refresh_timeout = 0;
                // driver_4g =  cJSON_GetObjectItem(item_ext,"version");
                driver_4g = cJSON_GetObjectItem(item_ext, "dver");
                // project = cJSON_GetObjectItem(item_ext,"project");
                project = cJSON_GetObjectItem(item_ext, "proj");
                datetime = cJSON_GetObjectItem(item_ext, "datetime");
                lat = cJSON_GetObjectItem(item_ext, "lat");
                lng = cJSON_GetObjectItem(item_ext, "lng");
                csq = cJSON_GetObjectItem(item_ext, "csq");
                net = cJSON_GetObjectItem(item_ext, "net");
                sim = cJSON_GetObjectItem(item_ext, "sim");
                iccid = cJSON_GetObjectItem(item_ext, "iccid");
                imei = cJSON_GetObjectItem(item_ext, "imei");
                gps = cJSON_GetObjectItem(item_ext, "gps");
                volume = cJSON_GetObjectItem(item_ext, "volume");
                mqttcfg1 = cJSON_GetObjectItem(item_ext, "mqttcfg1");
                mqttcfg2 = cJSON_GetObjectItem(item_ext, "mqttcfg2");
                link_sta = cJSON_GetObjectItem(item_ext, "link_sta");
                cJSON *gps_inuse = cJSON_GetObjectItem(item_ext, "gps_inuse");
                cJSON *gps_view = cJSON_GetObjectItem(item_ext, "gps_view");
                // 如果DTU的IMEI和FLash中的不一样,保存到FLASH
                value_commn = cJSON_GetObjectItem(item_ext, "photo_sta");
                if (value_commn != RT_NULL)
                {
                    device_status.camsta = value_commn->valueint;
                    if (device_status.camsta == 0)
                    {
                        rt_kprintf("相机已连接 \n");
                        HMI_WRITE("menu.va_cam.val=1");
                    }
                    else
                    {
                        rt_kprintf("相机未连接 \n");
                        HMI_WRITE("menu.va_cam.val=0");
                    }
                }
                value_commn = cJSON_GetObjectItem(item_ext, "cpu_tmp");
                if (value_commn != RT_NULL)
                {
                    HMI_WRITE("menu.cpu_temp.txt=\"%d.%d℃\"", atoi(value_commn->valuestring) / 1000, atoi(value_commn->valuestring) % 1000);
                }
                if (strstr(device_status.imei, imei->valuestring) == RT_NULL)
                {
                    rt_kprintf("Change IMEI:new:%s-old:%s", imei->valuestring, device_status.imei);
                    rt_sprintf(device_status.imei, "%s", imei->valuestring);
                    ef_set_env_blob("imei", &device_status.imei, sizeof(device_status.imei)); // IMEI
                }
                else
                {
                    rt_sprintf(device_status.imei, "%s", imei->valuestring);
                    rt_kprintf("IMEI not change:%s-%s", imei->valuestring, device_status.imei);
                }
                // 如果DTU的ICCID和FLash中的不一样,保存到FLASH
                if (strstr(device_status.iccid, iccid->valuestring) == RT_NULL)
                {
                    rt_kprintf("Change ICCID:new:%s-old:%s", iccid->valuestring, device_status.iccid);
                    rt_sprintf(device_status.iccid, "%s", iccid->valuestring);
                    ef_set_env_blob("iccid", &device_status.iccid, sizeof(device_status.iccid)); // Iccid
                }
                else
                {
                    rt_sprintf(device_status.iccid, "%s", iccid->valuestring);
                    rt_kprintf("ICCID not change:%s-%s", iccid->valuestring, device_status.iccid);
                }
                LOG_I("DTU时间:%s", datetime->valuestring);
                static char year_s[5], month_s[3], day_s[3], hour_s[3], min_s[3], sec_s[3];
                strncpy(year_s, datetime->valuestring, 4);
                strncpy(month_s, datetime->valuestring + 4, 2);
                strncpy(day_s, datetime->valuestring + 6, 2);
                strncpy(hour_s, datetime->valuestring + 8, 2);
                strncpy(min_s, datetime->valuestring + 10, 2);
                strncpy(sec_s, datetime->valuestring + 12, 2);
                if (atoi(year_s) >= 2022 && atoi(year_s) < 3000 && atoi(month_s) > 0 && atoi(month_s) < 13 && atoi(day_s) > 0 && atoi(day_s) < 32 && CHECK_DATE(datetime->valuestring))
                {

                    // if (atoi(net->valuestring) == 0 && atoi(year_s) >= 2022)
                    if (atoi(year_s) >= 2022)
                    {
                        if (set_date(atoi(year_s), atoi(month_s), atoi(day_s)) == RT_EOK)
                        {
                            LOG_I("设置日期:%d年%d月%d日", atoi(year_s), atoi(month_s), atoi(day_s));

                            if (atoi(hour_s) > 0 && atoi(hour_s) <= 24 && atoi(min_s) >= 0 && atoi(min_s) <= 60 && atoi(sec_s) >= 0 && atoi(sec_s) <= 60)
                            {
                                LOG_I("设置时间:%d时%d分%d秒", atoi(hour_s), atoi(min_s), atoi(sec_s));
                                set_time(atoi(hour_s), atoi(min_s), atoi(sec_s));
                            }
                        }
                        else
                        {
                            LOG_E("set_date failed!");
                            rt_hw_rtc_init();
                        }
                    }
                    else
                    {
                        LOG_E("网络连接失败,同步时间失败!");
                    }
                }
                LOG_I("参数同步:lat:%s lng:%s", lat->valuestring, lng->valuestring);
                // CSQ
                if (csq != NULL && atoi(csq->valuestring) >= 0 && atoi(csq->valuestring) <= 31)
                {
                    rt_sprintf(device_status.csq, "%s", csq->valuestring);
                }
                else
                {
                    rt_sprintf(device_status.csq, "0");
                }
                // 更新网线接入状态
                if (link_sta != NULL && atoi(link_sta->valuestring) >= 0 && atoi(link_sta->valuestring) <= 1)
                {
                    device_status.link_sta = atoi(link_sta->valuestring);
                    LOG_I(">>>>>>>>>>>>>有线接入状态>>>>>>>>>>>>>>:%d", device_status.link_sta);
                }
                // Volume
                if (volume != NULL && atoi(volume->valuestring) >= 0 && atoi(volume->valuestring) <= 31)
                {
                    device_status.vol = atoi(volume->valuestring);
                    LOG_I("设置音量:%d", device_status.vol);
                }
                else
                {
                    device_status.vol = 7;
                }
                // NET
                if (net != NULL && atoi(net->valuestring) >= 0 && atoi(net->valuestring) <= 1)
                {
                    LOG_I("网络状态:%s", net->valuestring);
                    rt_sprintf(device_status.net, "%s", net->valuestring);
                }
                else
                {
                    rt_sprintf(device_status.net, "1");
                }
                // SIM
                if (sim != NULL && atoi(sim->valuestring) >= 0 && atoi(sim->valuestring) <= 1)
                {
                    rt_sprintf(device_status.sim, "%s", sim->valuestring);
                }
                else
                {
                    rt_sprintf(device_status.sim, "1");
                }
                // GPS
                if (gps != NULL && atoi(gps->valuestring) >= 0 && atoi(gps->valuestring) <= 3)
                {
                    rt_sprintf(device_status.gps, "%s", gps->valuestring);
                    if (atoi(gps->valuestring) != 0)
                    {
#if BOOT_ERR == 1
                        if (atoi(gps->valuestring) == 1)
                            rt_sprintf(device_status.gps_state, "%s", "GPS+BD");

                        if (gps_inuse != NULL)
                        {
                            device_status.gps_inuse = atoi(gps_inuse->valuestring);
                        }
                        if (gps_view != NULL)
                        {
                            device_status.gps_view = atoi(gps_view->valuestring);
                        }
#endif
                        if (strstr(device_status.lat, lat->valuestring) == NULL)
                        {
                            memset(device_status.lat, 0, sizeof(device_status.lat));
                            memset(device_status.lng, 0, sizeof(device_status.lng));
                            rt_sprintf(device_status.lat, "%s", lat->valuestring);
                            rt_sprintf(device_status.lng, "%s", lng->valuestring);
                            ef_set_env_blob("lat", &device_status.lat, sizeof(device_status.lat)); // Iccid
                            ef_set_env_blob("lng", &device_status.lng, sizeof(device_status.lng)); // Iccid
                        }
                        else
                        {
                            LOG_I("经纬度信息同步：lat-%s,lng-%s", lat->valuestring, lng->valuestring);
                        }
                    }
                    else if (atoi(gps->valuestring) == 0)
                    {
                        memset(device_status.lat, 0, sizeof(device_status.lat));
                        memset(device_status.lng, 0, sizeof(device_status.lng));
                        rt_sprintf(device_status.lat, "%s", lat->valuestring);
                        rt_sprintf(device_status.lng, "%s", lng->valuestring);
                    }
                }
                else
                {
                    rt_sprintf(device_status.gps, "0");
                    memset(device_status.lat, 0, sizeof(device_status.lat));
                    memset(device_status.lng, 0, sizeof(device_status.lng));
                    if (sizeof(device_status.lat) < 3)
                    {
                        sprintf(device_status.lat, "%s", "0");
                        sprintf(device_status.lng, "%s", "0");
                    }
                    else
                    {
                        sprintf(device_status.lat, "%s", lat->valuestring);
                        sprintf(device_status.lng, "%s", lng->valuestring);
                    }
                }
                if (driver_4g != RT_NULL)
                    sprintf(device_status.driver_4g, "%s", driver_4g->valuestring);
                if (project != RT_NULL)
                    sprintf(device_status.project, "%s", project->valuestring);
                if (mqttcfg1 != NULL)
                {
                    if (strstr("8.136.98.49", mqttcfg1->valuestring) != RT_NULL)
                    {
                        rt_sprintf(device_status.mqttcfg1, "8.136.98.49");
                    }
                    else if (strstr("120.27.222.26", mqttcfg1->valuestring) != RT_NULL)
                    {
                        rt_sprintf(device_status.mqttcfg1, "120.27.222.26");
                    }
                    else
                    {
                        rt_sprintf(device_status.mqttcfg1, "8.136.98.49");
                    }
                    LOG_I("当前平台1:%s", mqttcfg1->valuestring);
                }
                if (mqttcfg2 != NULL)
                {
                    sprintf(device_status.mqttcfg2, "%s", mqttcfg2->valuestring);
                    LOG_I("当前平台2:%s", mqttcfg2->valuestring);
                }
                if (device_status.num_updata == 0)
                {
                    Beep_Tip(100);
                }
                else if (device_status.num_updata != 0 && device_status.hmi_fresh == 2)
                {
                    if (strstr(device_status.project, "A7_DTU_V3") != RT_NULL)
                    {
                        UpLoad_Data();
                        rt_kprintf("UpLoad_Data Mark D \n\n");
                    }
                    else
                    {
                        rt_thread_delay(2000);
                        UpLoad_Data();
                        rt_kprintf("UpLoad_Data Mark E \n\n");
                    }
                }
                device_status.hmi_fresh = 0;
            }
            /**
             * @brief 平台端下放控制指令
             *
             */
            if (item_ext != RT_NULL && strstr(item_cmd->valuestring, "paramconf") != RT_NULL)
            {

                char change_coll_time = 0;
                /**
                 * @brief 内容获取
                 *
                 */

                tt = cJSON_GetObjectItem(item_ext, "tt");
                ts = cJSON_GetObjectItem(item_ext, "ts");

                tpl = cJSON_GetObjectItem(item_ext, "tpl");
                tph = cJSON_GetObjectItem(item_ext, "tph");

                ds = cJSON_GetObjectItem(item_ext, "ds");

                inr_data = cJSON_GetObjectItem(item_ext, "dat_f");
                inr_photo = cJSON_GetObjectItem(item_ext, "pho_f");

                limit_temp = cJSON_GetObjectItem(item_ext, "limit_temp");
                limit_rain = cJSON_GetObjectItem(item_ext, "limit_rain");

                collstart = cJSON_GetObjectItem(item_ext, "collstart");
                collend = cJSON_GetObjectItem(item_ext, "collend");

                RunFRMS = cJSON_GetObjectItem(item_ext, "RunFRMS");
                FRMSlseek = cJSON_GetObjectItem(item_ext, "FRMSlseek");
                setLux = cJSON_GetObjectItem(item_ext, "setLux");

                fan_speed = cJSON_GetObjectItem(item_ext, "fan_speed");

                pages = cJSON_GetObjectItem(item_ext, "ecode_pagenum");

                tps = cJSON_GetObjectItem(item_ext, "tps");

                Demo_mode = cJSON_GetObjectItem(item_ext, "Demo_mode");

                no_reply = cJSON_GetObjectItem(item_ext, "no_reply");

                /**
                 * @brief 参数设置
                 *
                 */

                int temp = 0;

                /**
                 * @brief 光控定时
                 *
                 */
                if (tt != NULL)
                {
                    temp = cjson_getval(tt);

                    if (temp >= 1 && temp <= 10)
                    {

                        limit.LuxTime = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        rt_kprintf("光控定时tt:%d\n", temp);
                    }
                    else
                    {
                        rt_kprintf("光控定时tt设置失败参数错误!!!\n");
                        return 0;
                    }
                }
                /**
                 * @brief 工作模式
                 *
                 */
                if (ts != NULL)
                {
                    temp = cjson_getval(ts);
                    if (temp == 0 || temp == 1)
                    {
                        workmode = RunLight_wx;
                        limit.LuxEN = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        LOG_I("定时模式ts:%d", temp);
                    }
                    else
                    {
                        LOG_E("定时模式ts设置失败参数错误!!!");
                        return 0;
                    }
                }
                /**
                 * @brief 低温保护
                 *
                 */
                if (tpl != NULL)
                {
                    temp = cjson_getval(tpl);

                    if (temp >= -10 && temp <= 29)
                    {
                        limit.temp_dw = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        rt_kprintf("低温保护tpl:%d\n", temp);
                    }
                    else
                    {
                        rt_kprintf("低温保护tpl设置失败参数错误!!!  %d \n", temp);
                        return 0;
                    }
                }
                /**
                 * @brief 高温保护
                 *
                 */
                if (tph != NULL)
                {
                    temp = cjson_getval(tph);

                    if (temp >= 30 && temp <= 80)
                    {
                        limit.temp_up = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        rt_kprintf("高温保护tph:%d\n", temp);
                    }
                    else
                    {
                        rt_kprintf("高温保护tph设置失败参数错误!!!\n");
                        return 0;
                    }
                }

                /**
                 * @brief 开关机状态
                 *
                 */

                if (ds != NULL)
                {
                    temp = cjson_getval(ds);

                    if (temp >= 0 && temp <= 1)
                    {
                        device_status.ds = temp;
                        ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds));
                        LOG_I("开关机状态:%d", temp);
                    }
                    else
                    {
                        LOG_E("开关机状态设置失败参数错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 数据间隔
                 *
                 */

                if (inr_data != NULL)
                {
                    temp = cjson_getval(inr_data);

                    if (temp >= 5 && temp <= 120)
                    {
                        device_status.dattim = temp;
                        ef_set_env_blob("dattim", &device_status.dattim, sizeof(device_status.dattim));
                        LOG_I("数据上传间隔:%d", temp);
                    }
                    else
                    {
                        LOG_E("数据上传间隔设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 照片间隔
                 *
                 */

                if (inr_photo != NULL)
                {
                    temp = cjson_getval(inr_photo);

                    if (temp >= 5 && temp <= 120)
                    {
                        device_status.photim = temp;
                        ef_set_env_blob("photim", &device_status.photim, sizeof(device_status.photim));
                        LOG_I("照片上传间隔:%d", temp);
                    }
                    else
                    {
                        LOG_E("照片上传间隔设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 温控开关
                 *
                 */

                if (limit_temp != NULL)
                {
                    temp = cjson_getval(limit_temp);

                    if (temp >= 0 && temp <= 1)
                    {
                        limit.temhumEN = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        LOG_I("温控开关:%d", temp);
                    }
                    else
                    {
                        LOG_E("温控开关设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 雨控开关
                 *
                 */

                if (limit_rain != NULL)
                {
                    temp = cjson_getval(limit_rain);

                    if (temp >= 0 && temp <= 1)
                    {
                        limit.RainEN = temp;
                        ef_set_env_blob("limit", &limit, sizeof(Limit));
                        LOG_I("温控开关:%d", temp);
                    }
                    else
                    {
                        LOG_E("温控开关设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 时控开始
                 *
                 */

                if (collstart != NULL)
                {
                    temp = cjson_getval(collstart);

                    if (temp >= 0 && temp <= 24)
                    {
                        if(temp != device_status.collecting_sh1)
                        {
                            change_coll_time = 1;
                        }
                        device_status.collecting_sh1 = temp;
                        ef_set_env_blob("collecting_sh1", &device_status.collecting_sh1, sizeof(device_status.collecting_sh1));
                        LOG_I("时控开始:%d", temp);
                    }
                    else
                    {
                        LOG_E("时控开始设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 时控结束
                 *
                 */

                if (collend != NULL)
                {
                    temp = cjson_getval(collend);

                    if (temp >= 0 && temp <= 24)
                    {
                        if(temp != device_status.collecting_eh1)
                        {
                            change_coll_time = 1;
                        }
                        device_status.collecting_eh1 = temp;
                        ef_set_env_blob("collecting_eh1", &device_status.collecting_eh1, sizeof(device_status.collecting_eh1));
                        LOG_I("时控结束:%d", temp);
                    }
                    else
                    {
                        LOG_E("时控结束设置错误!!!");
                        return 0;
                    }
                }

                // if(change_coll_time)     250624 决定先不重启生效
                // {
                //     char readinfo[64] = "{\"TimeChange(%d-%d)\":\"NowReboot\"}";
                //     char buff[64] = {0};
                //     sprintf(buff,readinfo , device_status.collecting_sh1,device_status.collecting_eh1);
                //     DTU_Write("%s", buff);
                //     rt_hw_cpu_reset();
                // }


                /**
                 * @brief FRMS 开启开关
                 *
                 */

                if (RunFRMS != NULL)
                {
                    temp = cjson_getval(RunFRMS);

                    if (temp >= 0 && temp <= 1)
                    {
                        swork.EN = temp;
                        ef_set_env_blob("swork", &swork, sizeof(swork));
                        LOG_I("FRMS 开启开关:%d", temp);
                    }
                    else
                    {
                        LOG_E("FRMS 开启开关设置错误!!!");
                        return 0;
                    }
                }
                /**
                 * @brief 晨曦偏移
                 *
                 */

                if (FRMSlseek != NULL)
                {
                    temp = cjson_getval(FRMSlseek);

                    if (temp >= 10 && temp <= 60)
                    {
                        swork.lseek = temp;
                        ef_set_env_blob("swork", &swork, sizeof(swork));
                        LOG_I("晨曦偏移:%d", temp);
                    }
                    else
                    {
                        LOG_E("晨曦偏移设置错误!!!");
                        return 0;
                    }
                }
                /**
                 * @brief 晨曦光照阈值
                 *
                 */

                if (setLux != NULL)
                {
                    temp = cjson_getval(setLux);

                    if (temp >= 50 && temp <= 1000)
                    {
                        swork.slux_set = temp;
                        ef_set_env_blob("swork", &swork, sizeof(swork));
                        lwork.lux_set = temp;
                        ef_set_env_blob("lwork", &lwork, sizeof(lwork));
                        LOG_I("光照阈值:%d", temp);
                    }
                    else
                    {
                        LOG_E("光照阈值设置错误!!!");
                        return 0;
                    }
                }
                /**
                 * @brief 风机调速
                 *
                 */

                if (fan_speed != NULL)
                {
                    temp = cjson_getval(fan_speed);

                    if (temp >= 10 && temp <= 100)
                    {
                        syscfg.fan_speed = temp;
                        ef_set_env_blob("syscfg", &syscfg, sizeof(syscfg));
                        LOG_I("风机调速 set:%d", temp);
                        CollFanSetPWM(syscfg.fan_speed);
                    }
                    else
                    {
                        LOG_E("风机调速设置错误!!!");
                        return 0;
                    }
                }

                if (pages != NULL)
                {
                    temp = cjson_getval(pages);
                    ecode_concent_json(temp);
                    return 0;
                }

                /**
                 * @brief 温控开关
                 *
                 */
                if (tps != NULL)
                {
                    temp = cjson_getval(tps);

                    if (temp >= 0 && temp <= 1)
                    {
                        limit.temhumEN = temp;
                        ef_set_env_blob("limit", &limit, sizeof(limit));
                        if (limit.temhumEN == 1)
                            LOG_I("温控开关 打开  %d ~ %d℃\n", limit.temp_dw, limit.temp_up);
                        else
                            LOG_I("温控开关 关闭");
                        CollFanSetPWM(syscfg.fan_speed);
                    }
                    else
                    {
                        LOG_E("温控开关设置错误!!!");
                        return 0;
                    }
                }

                /**
                 * @brief 演示模式
                 *
                 */
                if (Demo_mode != NULL)
                {
                    temp = cjson_getval(Demo_mode);

                    if (temp == 0 || temp == 1)
                    {
                        syscfg.Demo_mode = temp;

                        if (temp)
                            LOG_I("演示模式 > 打开");
                        else
                            LOG_I("演示模式 > 关闭");
                    }
                    else
                    {
                        LOG_E("演示模式设置参数错误!!!");
                        return 0;
                    }
                }

                UpLoad_Data_refresh();

                if (no_reply == NULL)
                {
                    rt_thread_mdelay(200);
                    LOG_I("执行一次平台端回复");
                    UpLoad_Data();
                }

                rt_thread_delay(2000);
                // 2022/06/23,add:
                if (device_status.dtype == 3)
                {
                    rt_sprintf(device_status.json_w_clock, "平台操作:修改工作时间：开始-%d,结束-%d,模式-%d(0-光控,1-时控)-%s", device_status.startBar, device_status.stopBar, device_status.timeSwitch, device_status.stamp);
                    json_s = makeJson_Warn(device_status.json_w_clock, "修改时间");
                    ef_set_env_blob("json_w_clock", &device_status.json_w_clock, sizeof(device_status.json_w_clock)); // 将修改屏幕参数操作记录保存到Flash中
                    if (atoi(device_status.net) == 0)
                        DTU_Write("%s", json_s);
                    rt_free(json_s);
                }

                rt_thread_delay(1000);
                MA_save();
                rt_thread_delay(1000);
            }
        }
        cJSON_Delete(root);
    }
    return 0;
}

/**
 * @brief 执行上报状态信息json的动作
 *
 */
void UpLoad_Data_refresh(void)
{
    char *updata = makeJson_refresh();
    // rt_kprintf("upload data:%d%s", rt_strlen(updata), updata);
    rt_free(updata);
    DTU_Write("%s", updata);
    //   list_mem();
    // 播放数据上传中语音
}

/**
 * @brief 执行上报状态信息json的动作
 *
 */
void UpLoad_Data(void)
{
    char *updata = makeJson();
    rt_kprintf("upload data:%d%s", rt_strlen(updata), updata);
    rt_free(updata);
    DTU_Write("%s", updata);
    // list_mem();
    // 播放数据上传中语音
}

void updata(void)
{
    UpLoad_Data();
}

MSH_CMD_EXPORT(updata, updata);




static void RESET_ENV_TEST(void)
{
    ef_env_set_default();
    Recode_e_code(e_para_setdef , 1 ,"强制恢复默认参数");
}
MSH_CMD_EXPORT(RESET_ENV_TEST , RESET_ENV_TEST);