QXZ_QXZ/qxz_app/applications/protocol.c

#define LOG_TAG "protocol"
#define LOG_LVL LOG_LVL_WARNING //ELOG_LVL_WARN ////LOG_LVL_DBG// ELOG_LVL_WARN  // 该模块对应的日志输出级别。不定义时，默认：调试级别

#include <ulog.h> // 必须在 LOG_TAG 与 LOG_LVL 下面
#include "protocol.h"
#include <rtthread.h>
#include <easyflash.h>
#include "dotled.h"

extern uint32_t month;
extern uint32_t day;
extern uint32_t year;
extern uint32_t hour;
extern uint32_t min;
extern uint32_t sec;
extern int mqtt_publish_ch(cJSON *data, uint8_t ch);
extern char *version_with_time(uint8_t option);
extern rt_uint32_t READ_ADC_value(rt_uint8_t times);

static char tempbuff[50];
extern uint8_t start_get_return;
extern int SwitchToGbk(const unsigned char *pszBufIn, int nBufInLen, unsigned char *pszBufOut, int *pnBufOutLen);

/*子字符串截取，长度，开始*/
char *substring(char *dst, char *src, int start, int len);
extern void http_ota_yf(const char *uri);
extern int http_ota_zk(void);

//出入参数：str_ch_name通道名称，str_ch_name：接收并解析到的通道名称，ch：通道号
uint8_t channel_config(char *str_ch_name, char *str_temp_name, uint8_t ch);
//解析要素模型json
int cJSON_to_struct_array(char *text);
/*要素属性转json*/
cJSON *Element_Upload(char *eName);
//解析通道配置json
uint8_t ch_config_parse(char *text);

/*********       e_code相关         **********/
#include "hc_ctl.h"
extern Record_Para en_recode;
extern Record e_code[MAX_e_code_NUM];
/*********       e_code相关         **********/

/*********       plps相关         **********/

extern rt_sem_t plp_req_ch;	 // 请求同步CH
extern rt_sem_t plp_req_dp;	 // 请求同步屏幕参数
extern rt_sem_t plp_req_url; // 请求同步升级url

extern rt_sem_t plp_ch_succ;  // 同步CH 成功
extern rt_sem_t plp_dp_succ;  // 同步屏幕参数 成功
extern rt_sem_t plp_url_succ; // 同步升级url 成功

extern rt_sem_t plp_ch_fail;	 // 同步CH 失败
extern rt_sem_t plp_dp_upgrade;	 // 同步屏幕参数 失败
extern rt_sem_t plp_url_upgrade; // 同步升级url 失败

/*********       plps相关         **********/

#ifdef DOTLEDSHOW
DOTLEDID_SUB sub_para = {0};
#endif

//下发解析使用的结构体
typedef struct
{
	char type[30];
	char element_type[30];
	char App_mod[5];

	uint32_t JK;
	uint32_t eKey;
	uint32_t upper;
	uint32_t lower;
	uint32_t method;

	uint32_t StartTime;
	uint32_t Duration;

	uint32_t status;

	uint32_t interval;

	char ip[30];
	uint32_t port;

	char usr[30];
	char pwd[50];

	char topic_p[50];
	char topic_s[50];

	char content[100];
	uint32_t timeout; //下发汉字显示超时失效时间

	int32_t ch0;
	int32_t ch1;
	int32_t ch2;
	int32_t ch3;
	int32_t ch4;
	int32_t ch5;
	int32_t ch6;
	int32_t ch7;
	//
	//	uint32_t ch;//modbusio模块测试
	//传感器通道名称缓冲
	//	char  c0[23];char  c1[23];char  c2[23];char  c3[23];char  c4[23];char  c5[23];
	//	char  c6[23];char  c7[23];char  c8[23];char  c9[23];char c10[23];char c11[23];
	//	char c12[23];char c13[23];char c14[23];char c15[23];char c16[23];char c17[23];
	//	char c18[23];char c19[23];char c20[23];char c21[23];char c22[23];char c23[23];
	//	char c24[23];char c25[23];char c26[23];char c27[23];char c28[23];char c29[23];

	char ID_0[20];
	char ID_1[20];
	char ID_2[20];
	char ID_3[20];
	char ID_4[20];
	char ID_5[20];

	int plus;
	int minus;
	int times;
	int divide;

	int mode;

	char cmd_s[dtu_cmd_max_len];

	uint8_t front;		  //显示字体：0:12;1:16
	uint8_t keep_time;	  //单页停留时间 0.5s为单位
	uint16_t Start_x;	  //起始坐标x(像素点为单位)
	uint16_t Start_y;	  //起始坐标x(像素点为单位)
	uint16_t Width;		  //显示宽度
	uint16_t Height;	  //显示高度
	uint8_t Control_card; //控制卡型号

	uint8_t sensor_mode;

	uint8_t en;
	uint8_t lv;

	uint8_t FC_1;
	uint8_t FC_2;
	uint8_t FC_3;
	uint8_t FC_4;

	char TaskList[10];

} Rev_Ext_t;

/*状态消息数据结构*/
typedef struct
{
	char cmd[10];
	Rev_Ext_t ext;
} Rev_Message_t;

//命令转化成枚举类型输出
Cmd_t CMD_enum_convert(char *str)
{
	if (strcmp(str, "read") == 0)
		return read;
	if (strcmp(str, "control") == 0)
		return control;
	if (strcmp(str, "timing") == 0)
		return timing;
	if (strcmp(str, "auto") == 0)
		return Auto;
	if (strcmp(str, "config") == 0)
		return config;

	if (strcmp(str, "status") == 0)
		return status;
	if (strcmp(str, "data") == 0)
		return data;
	if (strcmp(str, "upload") == 0)
		return upload;
	if (strcmp(str, "interval") == 0)
		return interval;
	if (strcmp(str, "jkStatus") == 0)
		return jkStatus;
	if (strcmp(str, "ip") == 0)
		return ip;
	if (strcmp(str, "dotled") == 0)
		return dotled;
	if (strcmp(str, "reboot") == 0)
		return REBOOT;
	if (strcmp(str, "reset") == 0)
		return RESET_F;
	if (strcmp(str, "update") == 0)
		return update;
	if (strcmp(str, "zk_dl") == 0)
		return zk_dl;
	if (strcmp(str, "soilmoisture") == 0)
		return soilmoisture;
	if (strcmp(str, "ch_conf") == 0)
		return ch_conf;
	if (strcmp(str, "platform") == 0)
		return platform;
	if (strcmp(str, "element") == 0)
		return element;
	if (strcmp(str, "upgrade_url") == 0)
		return upgrade_url;
	// modbusIO模块测试
	if (strcmp(str, "output") == 0)
		return output;
	if (strcmp(str, "input") == 0)
		return input;
	if (strcmp(str, "ctl") == 0)
		return ctl;

	///要素修正配置
	if (strcmp(str, "elem_cfg") == 0)
		return Elem_CFG;

	///要素修正读取
	if (strcmp(str, "elem_corr") == 0)
		return elem_corr;

	/// 485dtu mode的开关
	if (strcmp(str, "ctl_485_mode") == 0)
		return ctl_485_mode;

	/// 网络自动切换的开关
	if (strcmp(str, "ctl_netsw_mode") == 0)
		return ctl_netsw_mode;

	///配置led屏幕参数
	if (strcmp(str, "dotled_para") == 0)
		return dotled_para;

	///传感器读取模式相关
	if (strcmp(str, "sensor_mode") == 0)
		return sensor_mode;

	/// ecode模式相关
	if (strcmp(str, "del_e_code") == 0)
		return del_e_code;
	if (strcmp(str, "cfg_e_code") == 0)
		return cfg_e_code;
	if (strcmp(str, "ecode") == 0)
		return ecode;

	// 485dtu 指令
	if (strcmp(str, "dtu_cmd") == 0)
	{
		return rs485_dtu_cmd;
	}

	// 参数备份
	if (strcmp(str, "bak_parameters") == 0)
	{
		return bak_parameters;
	}

	if (strcmp(str, "bak_info") == 0)
	{
		return bak_info;
	}

	if (strcmp(str, "res_parameters") == 0)
	{
		return res_parameters;
	}

	if (strcmp(str, "SDT") == 0)
	{
		return SDT;
	}

	if (strcmp(str, "FloatChange") == 0)
	{
		return FloatChange;
	}

#ifdef DOTLEDSHOW
	if (strcmp(str, "DotledsubID") == 0)
		return DotledsubID;
	if (strcmp(str, "CONFIGDotledsubID") == 0)
		return CONFIGDotledsubID;
#endif
	return 0xFF;
}

extern rt_sem_t reflash_485_mode_sem;  //刷新485 模式的标记位
extern rt_sem_t reflash_elem_corr_sem; //刷新修正要素标记位
extern rt_sem_t en_read_sem;		   //使能读取传感器
extern rt_sem_t hc_OnecWait_sem;	   // 向航插发送单次延时

extern struct rt_messagequeue rs485_mq; /* rs485 消息队列控制块 */
extern rt_uint8_t rs485_msg_pool[128];	/* rs485 消息队列中用到的放置消息的内存池 */

uint8_t dtu_cmd_s[dtu_cmd_max_len] = {0}; //存放指令-文本
uint8_t dtu_cmd_h[dtu_cmd_max_len] = {0}; //存放指令-hex
uint16_t rs_485_mq_wait = 0;			  //等待485消息队列的时间

extern uint16_t CRC16_Modbus(uint8_t *_pBuf, uint16_t _usLen);

//extern Dotled_t qxz.Param.dotled_p0;

extern uint8_t en_low_power; //读取传感器工作模式标记位

extern SDT_INFO sdt_info;

//数据解析，参数：json字符串，接收到的mqtt通道号
void ParseCmdJson(const char *pCmdJson, uint16_t mqtt_ch)
{
	extern void RESET_SYSTEM(void);
	char sensor_ch_key[20];
	uint8_t platform_f;
	uint32_t temp[5] = {0}; //临时变量
	char temp_ip0[4] = {0};
	char temp_ip1[4] = {0};
	char temp_ip2[4] = {0};
	char temp_ip3[4] = {0};
	char *utf8str, *gbkstr;
	int len;
	uint8_t app_mod;
	uint8_t i;

	Cmd_t Cmd;
	Cmd_t Type;

	Elem_corr_list *elem_corr_list; //为要素做修正的参数
	Elem_FC_list *elem_FC_list;		// 修正参数
	uint8_t ctl_485_type = 0;		//保存本次下发的485运行模式

	uint8_t dtu_cmd_cache[20] = {0}; //字符串组包中转
	uint8_t dtu_cmd_cnt = 0;		 //命令计数

	int8_t Control_card; //控制卡型号 0为不使能
	uint8_t front;		 //显示字体
	uint8_t keep_time;	 //单页停留时间 0.5s为单位
	uint16_t Start_x;	 //起始坐标x(像素点为单位)
	uint16_t Start_y;	 //起始坐标x(像素点为单位)
	uint16_t Width;		 //显示宽度
	uint16_t Height;	 //显示高度

	if ((pCmdJson == RT_NULL) || (mqtt_ch >= 2))
		return;

	if ((strstr(pCmdJson, "MSHCMD") != NULL) && mqtt_ch == 0)
	{
		parse_MSH_CMD(pCmdJson);
		return;
	}

	if ((strstr(pCmdJson, "ScreenData") != NULL) && sdt_en)
	{
		parse_Screen_json(pCmdJson);
		return;
	}
	// rt_kprintf("sdt_en > %d \n" , sdt_en);

	// rt_kprintf("mqtt recv >>>\n %s \n\n", pCmdJson);

	//要素模型下发解析
	if (cJSON_to_struct_array((char *)pCmdJson) == 1)
	{ //下发保存成功后反馈

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Element_Upload("element_suceess"), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Element_Upload("element_suceess"), 0);
		}
		return;
	}

	//通道配置解析
	i = ch_config_parse((char *)pCmdJson);
	if (i == 1)
	{ //下发保存成功后反馈
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(CH_Config_Json(1), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(CH_Config_Json(1), 0);
		}
		Alarm_report(12, 1, 0);
		rt_thread_delay(100);
		RESET_SYSTEM(); //系统重启
	}
	else if (i == 0)
	{
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(CH_Config_Json(0), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(CH_Config_Json(0), 0);
		}
		return;
	}

	cJSON *json = cJSON_Parse(pCmdJson); //创建cJSON对象
	if (json == RT_NULL)
		return;											  //失败返回
	s2j_create_struct_obj(struct_Message, Rev_Message_t); //创建空struct_Message结构体对象

	s2j_struct_get_basic_element(struct_Message, json, string, cmd); //反序列化Rev_Message_t结构体的cmd元素

	s2j_struct_get_struct_element(struct_Rev_Ext_t, struct_Message, json_ext, json, Rev_Ext_t, ext);

	// rt_kprintf("cmd A %d\n",Cmd );

	Cmd = CMD_enum_convert(struct_Message->cmd);

	// rt_kprintf("cmd B %d\n",Cmd );
	switch (Cmd)
	{
	case update:
		//			i = 18;

	    rt_kprintf("mqtt_ch > %d \n" , mqtt_ch);

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Element_Upload("updateing"), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Element_Upload("updateing"), 0);
		}

		//准备升级了 首先来一个单次延时
		rt_sem_release(hc_OnecWait_sem);
		rt_thread_mdelay(3000);
		//			rt_thread_control(rt_thread_self(), RT_THREAD_CTRL_CHANGE_PRIORITY, &i);//临时调高线程优先级

		//读出升级标志//重启后在进行升级
		uint8_t update_flag = 0;
		if (ef_get_env_blob("update_flag", &update_flag, sizeof(update_flag), RT_NULL))
		{
			//				update_flag ++;//升级变量+1并重新写入
		    // 加1不能放在里面 可能会造成不会升级的问题
		}
		update_flag = mqtt_ch + 1; //通道编号+1
		ef_set_env_blob("update_flag", &update_flag, sizeof(update_flag));
		rt_thread_delay(1000);

		rt_kprintf("update_flag >> %d \n" , update_flag);

		RESET_SYSTEM(); //系统重启


		break;
	case zk_dl:
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Element_Upload("zk_downloading"), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Element_Upload("zk_downloading"), 0);
		}
		rt_thread_delay(3000);
		if (http_ota_zk() == RT_EOK)
		{
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(Element_Upload("zk_downloadsucc"), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(Element_Upload("zk_downloadsucc"), 0);
			}
		}
		break;
	case RESET_F:
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Element_Upload("reseting"), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Element_Upload("reseting"), 0);
		}
		rt_thread_delay(3000);
		ef_env_set_default();
		write_bak_info(Zero, qxz_bak_part);
		rt_thread_mdelay(1000);
		LOG_I("%s\r\n", struct_Message->ext.content);
		RESET_SYSTEM(); //设置完成后系统重启
		break;
	case upgrade_url:
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, content);
		if (rt_strlen(struct_Message->ext.content) == 0)
		{
			break; //检查长度是否为空
		}

		if (rt_sem_take(plp_req_url, RT_WAITING_NO) == RT_EOK)
		{
			//rt_kprintf("%s  --  %s\n",struct_Message->ext.content , qxz.Param.upgrade_url);
			if (strstr(struct_Message->ext.content, qxz.Param.upgrade_url) != NULL)
			{
				rt_sem_release(plp_url_succ); //url校验无误
				break;
			}
			else
			{
				rt_sem_release(plp_url_upgrade); //url已更新
			}
		}

		rt_memset(qxz.Param.upgrade_url, 0, sizeof(qxz.Param.upgrade_url));
		rt_memcpy(qxz.Param.upgrade_url, struct_Message->ext.content, rt_strlen(struct_Message->ext.content));

		ef_set_env_blob("upgrade_url", &qxz.Param.upgrade_url, sizeof(qxz.Param.upgrade_url));
		Mark_up_qxz();
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Upgrade_Url(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Upgrade_Url(), 0);
		}
		LOG_I("upgrade_url:%s", qxz.Param.upgrade_url); //固件升级
		break;
	case REBOOT:

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Element_Upload("rebooting"), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Element_Upload("rebooting"), 0);
		}
		RESET_SYSTEM(); //系统重启
		//rt_hw_cpu_reset();
		break;
	case dotled: // LED点阵屏显示抬头下发

		utf8str = (char *)rt_malloc(100);
		rt_memset(utf8str, 0, 100);
		gbkstr = (char *)rt_malloc(100);
		rt_memset(gbkstr, 0, 100);

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, timeout);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, content);

		// utf8str = struct_Message->ext.content;
		// title_timeout = struct_Message->ext.timeout;
		// SwitchToGbk((const uint8_t *)utf8str, strlen(utf8str), (uint8_t *)gbkstr, &len);
		// rt_memset(dotledtitle_down, '\0', 60);
		// if (len > 60)
		// 	break; //大于30个汉字跳出
		// rt_memcpy(dotledtitle_down, gbkstr, len + 1);
		// rt_free(utf8str);
		// utf8str = RT_NULL;
		// rt_free(gbkstr);
		// gbkstr = RT_NULL;
		// LOG_I("dotledtitle_down:%s\r", (char *)dotledtitle_down);

		break;
	case config: //下发设置上报间隔
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, interval);
		LOG_I("interval:%d\r", struct_Message->ext.interval);
		if ((struct_Message->ext.interval < 1) || (struct_Message->ext.interval > 360))
			break; //取值范围1-90
		//下发设置数据保存
		qxz.Param.upload_interval = (uint8_t)struct_Message->ext.interval;
		ef_set_env_blob("upload_interval", &qxz.Param.upload_interval, sizeof(qxz.Param.upload_interval));
		Mark_up_qxz();
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(IntervalUpload(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(IntervalUpload(), 0);
		}

		break;
	case ip: //下发IP，端口，主题

		/**
 * @brief ip/域名
 * 
 * 
 */
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ip);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, port);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, usr);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, pwd);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, topic_p);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, topic_s);

		if (strstr(struct_Message->ext.ip, ".") == NULL && strlen(struct_Message->ext.ip) == 12)
		{
			//截取字符串
			substring(temp_ip0, struct_Message->ext.ip, 0, 3);
			substring(temp_ip1, struct_Message->ext.ip, 3, 3);
			substring(temp_ip2, struct_Message->ext.ip, 6, 3);
			substring(temp_ip3, struct_Message->ext.ip, 9, 3);
			//字符转整形
			temp[0] = atoi(temp_ip0);
			temp[1] = atoi(temp_ip1);
			temp[2] = atoi(temp_ip2);
			temp[3] = atoi(temp_ip3);

			if ((temp[0] > 255) || (temp[1] > 255) || (temp[2] > 255) || (temp[3] > 255))
				break;
			qxz.Param.remote_bg_ip[0] = temp[0];
			qxz.Param.remote_bg_ip[1] = temp[1];
			qxz.Param.remote_bg_ip[2] = temp[2];
			qxz.Param.remote_bg_ip[3] = temp[3];
			ef_set_env_blob("remote_bg_ip", &qxz.Param.remote_bg_ip, sizeof(qxz.Param.remote_bg_ip));

			memset(qxz.Param.remote_bg_url, 0, sizeof(qxz.Param.remote_bg_url));
			ef_set_env_blob("remote_bg_url", &qxz.Param.remote_bg_url, sizeof(qxz.Param.remote_bg_url));
		}
		else if (strstr(struct_Message->ext.ip, ".") != NULL && strlen(struct_Message->ext.ip) > 6)
		{
			strcpy(qxz.Param.remote_bg_url, struct_Message->ext.ip);
			ef_set_env_blob("remote_bg_url", &qxz.Param.remote_bg_url, sizeof(qxz.Param.remote_bg_url));
		}
		else
		{
			break;
		}

		Mark_up_qxz();
		/**
 * @brief ip/域名`
 * 
 * 
 */
		//端口的赋值保存
		temp[0] = struct_Message->ext.port;
		if (temp[0] > 65535) //如果值超过65535，则恢复默认1883
		{
			temp[0] = 1883;
		}
		else
			qxz.Param.remote_bg_port = temp[0];
		ef_set_env_blob("remote_bg_port", &qxz.Param.remote_bg_port, sizeof(qxz.Param.remote_bg_port));
		Mark_up_qxz();
		// USR_NAME,PASSWORD保存
		if (strlen(struct_Message->ext.usr) < 30)
		{
			rt_memset(qxz.Param.usr, 0, strlen(qxz.Param.usr));
			strcpy(qxz.Param.usr, struct_Message->ext.usr); //获得topic字符串赋给系统topic变量，并及时存入flash
			ef_set_env_blob("usr", qxz.Param.usr, sizeof(qxz.Param.usr));
		}

		if (strlen(struct_Message->ext.pwd) < 50)
		{
			rt_memset(qxz.Param.usr, 0, strlen(qxz.Param.pwd));
			strcpy(qxz.Param.pwd, struct_Message->ext.pwd);
			ef_set_env_blob("pwd", qxz.Param.pwd, sizeof(qxz.Param.pwd));
		}

		// topic的赋值保存
		if (strlen(struct_Message->ext.topic_p) < sizeof(struct_Message->ext.topic_p))
		{
			strcpy(qxz.Param.bg_pub, struct_Message->ext.topic_p); //获得topic字符串赋给系统topic变量，并及时存入flash
			ef_set_env_blob("bg_pub", qxz.Param.bg_pub, sizeof(qxz.Param.bg_pub));
		}

		if (strlen(struct_Message->ext.topic_s) < sizeof(struct_Message->ext.topic_s))
		{
			strcpy(qxz.Param.bg_sub, struct_Message->ext.topic_s);
			ef_set_env_blob("bg_sub", qxz.Param.bg_sub, sizeof(qxz.Param.bg_sub));
		}

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Serv_info_Upload(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Serv_info_Upload(), 0);
		}
		break;
	case read: //下发查询参数
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, type);
		LOG_I("type:%s\r", struct_Message->ext.type);
		Type = CMD_enum_convert(struct_Message->ext.type);
		switch (Type)
		{
		case status: //查询设备信息
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(Status_Upload(1), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(Status_Upload(1), 0);
			}
			LOG_I("Msg_status");
			break;
		case data: //查询数据

			rt_sem_release(en_read_sem);

			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(TerminalData(1), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(TerminalData(1), 0);
			}
			LOG_I("Msg_data");
			break;
		case ip: //查询ip,端口，topic
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(Serv_info_Upload(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(Serv_info_Upload(), 0);
			}
			LOG_I("Msg_ip");
			break;
		case upload: //查询上传使能

			LOG_I("Msg_upload");
			break;
		case jkStatus: //查询上传使能
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(ControlStatus(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(ControlStatus(), 0);
			}
			LOG_I("jkStatus");
			break;
		case interval: //请求查询设备上传时间间隔
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(IntervalUpload(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(IntervalUpload(), 0);
			}
			LOG_I("Msg_interval");
			break;
		case upgrade_url: //请求查询设备更新url
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(Upgrade_Url(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(Upgrade_Url(), 0);
			}
			LOG_I("upgrade_url");
			break;
		case soilmoisture: //请求查询设备上传时间间隔
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(soillmoisture_cal(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(soillmoisture_cal(), 0);
			}
			LOG_I("soilmoisture_pub");
			break;
		case ch_conf: //请求查询通道配置
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(CH_Config_Json(1), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(CH_Config_Json(1), 0);
			}
			LOG_I("ch_config");
			break;
		case platform: //下发查询上报平台
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(PlatformUpload(), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(PlatformUpload(), 0);
			}
			LOG_I("ch_config");
			break;

		case elem_corr:

			Alarm_report(4, 0, mqtt_ch); //上报当前要素修正配置

			break;

		case ctl_485_mode:

			Alarm_report(5, 0, mqtt_ch); //上报当前485工作配置

			break;

		case dotled_para:

			Alarm_report(7, 0, mqtt_ch); //上报当前led屏幕参数

			break;

		case sensor_mode:

			Alarm_report(8, 0, mqtt_ch); //上报当前传感器读取模式

			break;

		case ecode:

			Alarm_report(9, 0, mqtt_ch); //上报当前记录的e_code

			break;

		case bak_info:

			Alarm_report(10, 1, mqtt_ch); //上报当前备份区情况

			break;

		case ctl_netsw_mode:

			Alarm_report(13, 0, mqtt_ch); //上报网络自动切换的开关

			break;

		case SDT:

			Alarm_report(14, 0, mqtt_ch); //上报订阅列表

			break;

		case FloatChange:

			Alarm_report(15, 0, mqtt_ch); //上报浮点转换列表

			break;

		default:
			break;
		}
		break;
	case control: //下发输出控制指令
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, JK);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, status);

		extern void CONTROL_OUTPUT(uint8_t jk, uint8_t ctr);
		if (struct_Message->ext.status == 0)
		{
			CONTROL_OUTPUT(struct_Message->ext.JK, 0);
			if (struct_Message->ext.JK == 0)
			{
				led_onoff_flag = 0;
			}
		}
		else if (struct_Message->ext.status == 1)
		{
			CONTROL_OUTPUT(struct_Message->ext.JK, 1);
			if (struct_Message->ext.JK == 0)
			{
				led_onoff_flag = 1;
			}
		}
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(ControlStatus(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(ControlStatus(), 0);
		}

		LOG_I("JK:%d\r", struct_Message->ext.JK);
		LOG_I("status:%d\r", struct_Message->ext.status);

		break;
	case timing: //下发定时参数配置
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, JK);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, StartTime);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Duration);
		extern Timing_Contol S_Timing_Contol[Number_JK];
		S_Timing_Contol[struct_Message->ext.JK].StartTime = struct_Message->ext.StartTime; //写入参数结构体
		S_Timing_Contol[struct_Message->ext.JK].Duration = struct_Message->ext.Duration;
		ef_set_env_blob("timing_contol", &S_Timing_Contol, sizeof(S_Timing_Contol)); //保存参数到flash

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(TimingStatus(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(TimingStatus(), 0);
		}
		LOG_I("JK:%d\r", struct_Message->ext.JK);
		LOG_I("StartTime:%d\r", struct_Message->ext.StartTime);
		LOG_I("Duration:%d\r", struct_Message->ext.Duration);
		break;
	case Auto: //下发阈值参数配置 ，大写避免与系统关键字冲突
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, JK);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, eKey);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, upper);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, lower);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, method);
		extern Threshold_Contol S_Threshold_Contol[Number_JK];
		S_Threshold_Contol[struct_Message->ext.JK].eKey = struct_Message->ext.eKey; //写入参数结构体
		S_Threshold_Contol[struct_Message->ext.JK].upper = struct_Message->ext.upper;
		S_Threshold_Contol[struct_Message->ext.JK].lower = struct_Message->ext.lower;
		S_Threshold_Contol[struct_Message->ext.JK].method = struct_Message->ext.method;
		ef_set_env_blob("threshold_contol", &S_Threshold_Contol, sizeof(S_Threshold_Contol)); //保存参数到flash

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(ThresholdStatus(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(ThresholdStatus(), 0);
		}
		LOG_I("JK:%d\r", struct_Message->ext.JK);
		LOG_I("eKey:%d\r", struct_Message->ext.eKey);
		LOG_I("upper:%d\r", struct_Message->ext.upper);
		LOG_I("lower:%d\r", struct_Message->ext.lower);
		LOG_I("method:%d\r", struct_Message->ext.method);
		break;
	case soilmoisture: //下发墒情校准值
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch0);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch1);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch2);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch3);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch4);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch5);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch6);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch7);

		soilmoisture_calibration[0] = struct_Message->ext.ch0; //更新变量
		soilmoisture_calibration[1] = struct_Message->ext.ch1;
		soilmoisture_calibration[2] = struct_Message->ext.ch2;
		soilmoisture_calibration[3] = struct_Message->ext.ch3;
		soilmoisture_calibration[4] = struct_Message->ext.ch4;
		soilmoisture_calibration[5] = struct_Message->ext.ch5;
		soilmoisture_calibration[6] = struct_Message->ext.ch6;
		soilmoisture_calibration[7] = struct_Message->ext.ch7;

		ef_set_env_blob("soilmoisture_calibration", &soilmoisture_calibration, sizeof(soilmoisture_calibration)); //保存参数到flash
		LOG_I("墒情修正值保存成功");																			  //输出指令+通道号
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(soillmoisture_cal(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(soillmoisture_cal(), 0);
		}

		LOG_I("ch0:%d\r", struct_Message->ext.ch0);
		LOG_I("ch1:%d\r", struct_Message->ext.ch1);
		LOG_I("ch2:%d\r", struct_Message->ext.ch2);
		LOG_I("ch3:%d\r", struct_Message->ext.ch3);
		LOG_I("ch4:%d\r", struct_Message->ext.ch4);
		LOG_I("ch5:%d\r", struct_Message->ext.ch5);
		LOG_I("ch6:%d\r", struct_Message->ext.ch6);
		LOG_I("ch7:%d\r", struct_Message->ext.ch7);
		break;
	case element: //要素模型查询
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, element_type);

		if (rt_strlen(struct_Message->ext.element_type) != 0) //得到通道名不为空
		{
			if (mqtt_ch == 1)
			{
				mqtt_publish_ch(Element_Upload((char *)&struct_Message->ext.element_type), 1);
			}
			else if (mqtt_ch == 0)
			{
				mqtt_publish_ch(Element_Upload((char *)&struct_Message->ext.element_type), 0);
			}
		}
		LOG_I("element type:%s\r", (char *)struct_Message->ext.element_type);
		break;
	case platform: //上报平台选择设置

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, method);
		if (struct_Message->ext.method < 3)
		{
			platform_f = struct_Message->ext.method;						//更新应用模式
			ef_set_env_blob("platform_f", &platform_f, sizeof(platform_f)); //保存参数
			Mark_up_qxz();
			mqtt_publish_ch(PlatformUpload(), mqtt_ch);

			// Alarm_report(11, 0); //上报预警消息
			mqtt_publish_ch(Platform_Chg_Alarm(0), mqtt_ch);
			Recode_e_code(platform_change_ec, 0, levle_high);

			LOG_I("platform:%d\r", struct_Message->ext.method);
		}
		break;
		//		case ctl://下发墒情校准值
		//			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, ch);
		//			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, status)
		//
		//			LOG_I("ch:%d,status: %d\r",struct_Message->ext.ch,struct_Message->ext.status);
		//			break;
#ifdef DOTLEDSHOW
	case DotledsubID: //查询订阅ID
		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Data_dotled_subid(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Data_dotled_subid(), 0);
		}
		LOG_I("DotledsubID");
		break;
	case CONFIGDotledsubID: //下发设置订阅ID
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_0);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_1);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_2);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_3);

		if (rt_strlen(struct_Message->ext.ID_0) >= 15)
		{
			strcpy(sub_para.ID_list[0], struct_Message->ext.ID_0);
		}

		if (rt_strlen(struct_Message->ext.ID_1) >= 15)
		{
			strcpy(sub_para.ID_list[1], struct_Message->ext.ID_1);
		}

		if (rt_strlen(struct_Message->ext.ID_2) >= 15)
		{
			strcpy(sub_para.ID_list[2], struct_Message->ext.ID_2);
		}

		if (rt_strlen(struct_Message->ext.ID_3) >= 15)
		{
			strcpy(sub_para.ID_list[3], struct_Message->ext.ID_3);
		}

		ef_set_env_blob("dotledsubid", sub_para.ID_list[0], sizeof(sub_para.ID_list));

		if (mqtt_ch == 1)
		{
			mqtt_publish_ch(Data_dotled_subid(), 1);
		}
		else if (mqtt_ch == 0)
		{
			mqtt_publish_ch(Data_dotled_subid(), 0);
		}
		LOG_I("dotledsubid_download");
		break;
#endif

	case Elem_CFG:

		elem_corr_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_corr));
		rt_memset(elem_corr_list, 0, qxz.Param.Num_sensors * sizeof(Elem_corr));
		if (elem_corr_list != NULL)
		{
			ef_get_env_blob("elem_corr_list", elem_corr_list, qxz.Param.Num_sensors * sizeof(Elem_corr), RT_NULL);

			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, element_type);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, plus);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, minus);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, times);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, divide);

			for (i = 0; i < qxz.Param.Num_sensors; i++)
			{

				if (strcmp(struct_Message->ext.element_type, sensor[i].eName) == 0)
				{
					rt_kprintf("match cfg elem[%d] %s\n", i, sensor[i].eName);
					elem_corr_list->elem_corr[i].en = 1;
					elem_corr_list->elem_corr[i].plus = struct_Message->ext.plus;
					elem_corr_list->elem_corr[i].minus = struct_Message->ext.minus;
					elem_corr_list->elem_corr[i].times = struct_Message->ext.times;
					elem_corr_list->elem_corr[i].divide = struct_Message->ext.divide;
					strcpy(elem_corr_list->elem_corr[i].ename, struct_Message->ext.element_type);

					ef_set_env_blob("elem_corr_list", elem_corr_list, qxz.Param.Num_sensors * sizeof(Elem_corr));

					Alarm_report(3, i, mqtt_ch); //上报成功

					rt_sem_release(reflash_elem_corr_sem);

					break;
				}
				else if (i == qxz.Param.Num_sensors - 1)
				{
					Alarm_report(2, 2, mqtt_ch); //无匹配项
				}
			}
		}
		else
		{
			Alarm_report(2, 1, mqtt_ch); //空间分配失败
		}
		rt_free(elem_corr_list);
		break;

	case ctl_485_mode:

		// rt_kprintf(" case ctl_485_mode: %s \n", pCmdJson);

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, mode);

		ctl_485_type = struct_Message->ext.mode;

		if (ctl_485_type >= 0 && ctl_485_type <= 2)
		{
			ctl_485_type += 100;
			ef_set_env_blob("ctl_485_mode", &ctl_485_type, sizeof(ctl_485_type));

			Alarm_report(5, 1, mqtt_ch); //返回成功信息

			rt_sem_release(reflash_485_mode_sem);
		}
		else
		{
			Alarm_report(5, 2, mqtt_ch); //参数校验失败
		}

		break;

	case ctl_netsw_mode:

		// rt_kprintf(" case ctl_485_mode: %s \n", pCmdJson);

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, mode);

		ctl_485_type = struct_Message->ext.mode;

		if (ctl_485_type >= 0 && ctl_485_type <= 2)
		{
			ctl_485_type += 100;
			ef_set_env_blob("ctl_netsw_mode", &ctl_485_type, sizeof(ctl_485_type));
			//rt_kprintf("write %d \n" ,ctl_485_type );

			Alarm_report(13, 1, mqtt_ch); //返回成功信息
		}
		else
		{
			Alarm_report(13, 2, mqtt_ch); //参数校验失败
		}

		break;

	case rs485_dtu_cmd:

		ef_get_env_blob("ctl_485_mode", &dtu_cmd_cnt, sizeof(ctl_485_mode), RT_NULL);

		if (dtu_cmd_cnt != 101)
		{
			Alarm_report(6, 0, mqtt_ch); //未处于dtu_mode
			break;
		}
		dtu_cmd_cnt = 0;
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, cmd_s);
		strcpy((char *)dtu_cmd_s, (const char *)struct_Message->ext.cmd_s);

		dtu_cmd_cnt = str2hex(dtu_cmd_s, dtu_cmd_h);

		if (dtu_cmd_cnt == 0)
		{
			Alarm_report(6, 1, mqtt_ch); //指令没解析到
			break;
		}
		dtu_cmd_h[dtu_cmd_cnt] = (CRC16_Modbus(dtu_cmd_h, dtu_cmd_cnt) >> 8);
		dtu_cmd_h[dtu_cmd_cnt + 1] = (uint8_t)(CRC16_Modbus(dtu_cmd_h, dtu_cmd_cnt) & 0x00FF);

		rt_memset(dtu_cmd_s, 0, dtu_cmd_max_len);
		for (uint8_t a = 0; a < dtu_cmd_cnt + 2; a++)
		{
			sprintf((char *)dtu_cmd_cache, "%02X ", dtu_cmd_h[a]);
			strcat((char *)dtu_cmd_s, (const char *)dtu_cmd_cache);
		}

		Alarm_report(6, 2, mqtt_ch); //回传带crc的读取指令

		dtu_cmd_h[(dtu_cmd_max_len / 2) - 1] = dtu_cmd_cnt + 2;

		if (rt_mq_send(&rs485_mq, dtu_cmd_h, dtu_cmd_max_len / 2) != RT_EOK)
		{
			rt_kprintf("rt_mq_send ERR\n");
		}
		rs_485_mq_wait = 0;
		while (rs_485_mq_wait < 270)
		{
			rs_485_mq_wait++;
			rt_thread_mdelay(15); //为读取线程留出时间 避免获取了自己发送的内容
			if (start_get_return == 1)
			{
				start_get_return = 0;
				break;
			}
		}
		while (rs_485_mq_wait < 270)
		{
			rs_485_mq_wait++;
			rt_thread_mdelay(10);
			if (rt_mq_recv(&rs485_mq, dtu_cmd_h, dtu_cmd_max_len / 2, RT_WAITING_NO) == RT_EOK)
			{
				// rt_kprintf("get return %d\n\n", dtu_cmd_h[(dtu_cmd_max_len / 2) - 1]);
				break;
			}
		}
		if (rs_485_mq_wait < 270)
		{
			Alarm_report(6, 3, mqtt_ch); //回传读到的内容
		}
		else
		{
			Alarm_report(6, 4, mqtt_ch); //命令没有响应
		}

		break;

	case dotled_para:

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Control_card);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, front);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, keep_time);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Start_x);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Start_y);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Width);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, Height);

		Control_card = struct_Message->ext.Control_card;
		front = struct_Message->ext.front;
		keep_time = struct_Message->ext.keep_time;
		Start_x = struct_Message->ext.Start_x;
		Start_y = struct_Message->ext.Start_y;
		Width = struct_Message->ext.Width;
		Height = struct_Message->ext.Height;

		// if (Control_card > 0
		// 	Control_card != 0 &&
		// 	Control_card != 1 &&
		// 	Control_card != 2 &&
		// 	Control_card != 3 &&
		// 	Control_card != 5 && //Y1A 单区域（1Bit）
		// 	Control_card != 6 && //Y1A 单区域（8Bit）
		// 	Control_card != 7 && //Y1A 双区域（1Bit）
		// 	Control_card != 8)	 //Y1A 双区域（8Bit）
		if (Control_card < -6 || Control_card > 8)
		{
			Alarm_report(7, 1, mqtt_ch);
			break;
		}

		if (front != 12 &&
			front != 16 && Control_card < 4)
		{
			Alarm_report(7, 2, mqtt_ch);
			break;
		}

		if (keep_time > 32 || keep_time <= 0)
		{
			Alarm_report(7, 3, mqtt_ch);
			break;
		}

		if (Start_x > Width || Start_x < 0)
		{
			Alarm_report(7, 4, mqtt_ch);
			break;
		}

		if (Start_y > Height || Start_y < 0)
		{
			Alarm_report(7, 5, mqtt_ch);
			break;
		}

		if (Width > 1024 || Width < 0)
		{
			Alarm_report(7, 6, mqtt_ch);
			break;
		}

		if (Height > 1024 || Height < 0)
		{
			Alarm_report(7, 7, mqtt_ch);
			break;
		}

		if (rt_sem_take(plp_req_dp, RT_WAITING_NO) == RT_EOK)
		{

			if (qxz.Param.Dotled_Option == Control_card &&
				qxz.Param.dotled_p0.keep_time == keep_time &&
				qxz.Param.dotled_p0.Start_x == Start_x &&
				qxz.Param.dotled_p0.Start_y == Start_y &&
				qxz.Param.dotled_p0.Width == Width &&
				qxz.Param.dotled_p0.Height == Height)
			{
				rt_sem_release(plp_dp_succ); //dp校验无误
				break;
			}
			else
			{
				rt_sem_release(plp_dp_upgrade); //dp已更新
			}
		}

		qxz.Param.Dotled_Option = Control_card;
		qxz.Param.dotled_p0.front = front;
		qxz.Param.dotled_p0.keep_time = keep_time;
		qxz.Param.dotled_p0.Start_x = Start_x;
		qxz.Param.dotled_p0.Start_y = Start_y;
		qxz.Param.dotled_p0.Width = Width;
		qxz.Param.dotled_p0.Height = Height;

		ef_set_env_blob("Dotled_Option", &qxz.Param.Dotled_Option, sizeof(qxz.Param.Dotled_Option));

		ef_set_env_blob("dotled_p0", &qxz.Param.dotled_p0, sizeof(qxz.Param.dotled_p0));

		Mark_up_qxz();

		Alarm_report(7, 0, mqtt_ch); //回传成功消息

		break;

	case sensor_mode:

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, sensor_mode);

		if (struct_Message->ext.sensor_mode == 0 || struct_Message->ext.sensor_mode == 1)
		{
			en_low_power = (struct_Message->ext.sensor_mode + 100);
			Alarm_report(8, 1, mqtt_ch); //回传成功消息
		}
		else
		{
			Alarm_report(8, 2, mqtt_ch); //参数错误
		}

		break;

	case cfg_e_code:

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, en);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, lv);

		if (struct_Message->ext.lv >= 1 && struct_Message->ext.lv <= 3 &&
			(struct_Message->ext.en == 0 || struct_Message->ext.en == 1))
		{
			en_recode.en = struct_Message->ext.en;

			en_recode.level = struct_Message->ext.lv;

			ef_set_env_blob("en_recode", &en_recode, sizeof(en_recode));

			Alarm_report(9, 1, mqtt_ch); //回传成功消息
		}
		else
		{
			Alarm_report(9, 2, mqtt_ch); //参数错误
		}

		break;

	case del_e_code:

		Alarm_report(9, 3, mqtt_ch);

		break;

	case bak_parameters:

		Mark_up_qxz();
		Mark_up_elem();
		bak_para(One, ch_bak_part);

		Alarm_report(10, 3, mqtt_ch);

		break;

	case res_parameters:

		Alarm_report(10, 2, mqtt_ch);

		break;

	case SDT:

		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, en);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, TaskList);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_0);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_1);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_2);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_3);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_4);
		s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, ID_5);

		// rt_kprintf("en %d \n", struct_Message->ext.en);
		// rt_kprintf("TaskList %s \n", struct_Message->ext.TaskList);
		// rt_kprintf("ID_0 %s \n", struct_Message->ext.ID_0);
		// rt_kprintf("ID_1 %s \n", struct_Message->ext.ID_1);
		// rt_kprintf("ID_2 %s \n", struct_Message->ext.ID_2);
		// rt_kprintf("ID_3 %s \n", struct_Message->ext.ID_3);
		// rt_kprintf("ID_4 %s \n", struct_Message->ext.ID_4);
		// rt_kprintf("ID_5 %s \n", struct_Message->ext.ID_5);

		if (struct_Message->ext.en == 1 && strstr(struct_Message->ext.ID_0, "86") != NULL)
		{
			sdt_info.en = 1;
			strcpy(sdt_info.TaskList, struct_Message->ext.TaskList);
			strcpy(sdt_info.ID_0, struct_Message->ext.ID_0);
			strcpy(sdt_info.ID_1, struct_Message->ext.ID_1);
			strcpy(sdt_info.ID_2, struct_Message->ext.ID_2);
			strcpy(sdt_info.ID_3, struct_Message->ext.ID_3);
			strcpy(sdt_info.ID_4, struct_Message->ext.ID_4);
			strcpy(sdt_info.ID_5, struct_Message->ext.ID_5);
			ef_set_env_blob("SDT", &sdt_info, sizeof(sdt_info));
		}
		else if (struct_Message->ext.en == 0)
		{
			sdt_info.en = 0;
			ef_set_env_blob("SDT", &sdt_info, sizeof(sdt_info));
		}

		Alarm_report(14, 2, mqtt_ch);

		break;

	case FloatChange:

		elem_FC_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_FC));
		rt_memset(elem_FC_list, 0, qxz.Param.Num_sensors * sizeof(Elem_FC));
		if (elem_FC_list != NULL)
		{
			ef_get_env_blob("elem_FC_list", elem_FC_list, qxz.Param.Num_sensors * sizeof(Elem_FC), RT_NULL);

			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, string, element_type);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, FC_1);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, FC_2);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, FC_3);
			s2j_struct_get_basic_element(struct_Rev_Ext_t, json_ext, int, FC_4);

			if ((struct_Message->ext.FC_1 >= 0x0A) && (struct_Message->ext.FC_1 <= 0x0D) &&
				(struct_Message->ext.FC_2 >= 0x0A) && (struct_Message->ext.FC_2 <= 0x0D) &&
				(struct_Message->ext.FC_3 >= 0x0A) && (struct_Message->ext.FC_3 <= 0x0D) &&
				(struct_Message->ext.FC_4 >= 0x0A) && (struct_Message->ext.FC_4 <= 0x0D) &&
				(struct_Message->ext.FC_1 + struct_Message->ext.FC_2 + struct_Message->ext.FC_3 + struct_Message->ext.FC_4) == 46)
			{
				for (i = 0; i < qxz.Param.Num_sensors; i++)
				{
					if (strcmp(struct_Message->ext.element_type, sensor[i].eName) == 0)
					{
						rt_kprintf("match FC cfg elem[%d] %s\n", i, sensor[i].eName);
						elem_FC_list->elem_fC[i].en = 1;
						elem_FC_list->elem_fC[i].FC_1 = struct_Message->ext.FC_1;
						elem_FC_list->elem_fC[i].FC_2 = struct_Message->ext.FC_2;
						elem_FC_list->elem_fC[i].FC_3 = struct_Message->ext.FC_3;
						elem_FC_list->elem_fC[i].FC_4 = struct_Message->ext.FC_4;
						strcpy(elem_FC_list->elem_fC[i].ename, struct_Message->ext.element_type);

						ef_set_env_blob("elem_FC_list", elem_FC_list, qxz.Param.Num_sensors * sizeof(Elem_FC));

						Alarm_report(17, i, mqtt_ch); //上报成功

						rt_sem_release(reflash_elem_corr_sem);

						break;
					}
					else if (i == qxz.Param.Num_sensors - 1)
					{
						Alarm_report(16, 2, mqtt_ch); //无匹配项
					}
				}
			}
			else
			{
				Alarm_report(16, 3, mqtt_ch); // 超范围
			}
		}
		else
		{
			Alarm_report(16, 1, mqtt_ch); //空间分配失败
		}
		rt_free(elem_FC_list);
		break;

	default:
		break;
	}

	s2j_delete_json_obj(json);
	s2j_delete_struct_obj(struct_Message);
}

//字符串转hex
uint8_t str2hex(uint8_t *str, uint8_t *bin)
{
	uint8_t count = 0;
	uint8_t one_byte = 0;

	for (uint8_t a = 0; a < strlen((const char *)str); a++)
	{
		one_byte = 0;
		if (str[a] != 0x20 && str[a + 1] != 0x20)
		{
			if (str[a] >= 0x30 && str[a] <= 0x39)
			{
				one_byte += (str[a] - 0x30) << 4;
			}
			else if (str[a] >= 0x41 && str[a] <= 0x46)
			{
				one_byte += (str[a] - 55) << 4;
			}
			else
			{
				return 0;
			}
			if (str[a + 1] >= 0x30 && str[a + 1] <= 0x39)
			{
				one_byte += (str[a + 1] - 0x30);
			}
			else if (str[a + 1] >= 0x41 && str[a + 1] <= 0x46)
			{
				one_byte += (str[a + 1] - 55);
			}
			else
			{
				return 0;
			}
			bin[count++] = one_byte;
			// rt_kprintf("%d byte : %d\n",count - 1 , one_byte);
			a++;
		}
	}
	return count;
}

//出入参数：str_ch_name通道名称，str_ch_name：接收并解析到的通道名称，ch：通道号
uint8_t channel_config(char *str_ch_name, char *str_temp_name, uint8_t ch)
{

	if (ch > Number_sensors)
		return 0; //超过最大通道数量直接返回

	if (strcmp(str_temp_name, "\0") != 0) //存在通道名
	{
		strcpy(str_ch_name, str_temp_name);
		//		LOG_I("ch%d_name:%s\r", ch, str_ch_name);
		//		ch ++ ;
		return 1;
	}
	else
		return 0;
}

/* 开机上传设备IMEI,ICCID,CSQ,经纬度坐标等信息。*/

TerminalStatus terminalstatus = {

	.VOLT = 0,
	.RSSI = 0,
	.IMEI = sys_info.imei,
	.ICCID = sys_info.iccid,
	.longitude = sys_info.lng,
	.latitude = sys_info.lat,
	.altitude = sys_info.altitude,
	.Dotled = 0,
	.Version = 0};

Status_Ext Status_ext = {

	.StationID = qxz.Param.device_sn,
	.MonitorTime = tempbuff,
	.terminalStatus = &terminalstatus,
};

Status_Message Status_message = {
	.cmd = "Status",
	.ext = &Status_ext,
};

/*imei,iccid,rssi，经纬度等信息，开机上传或者查询上传,选项1：可选全部上传，0：只上传电压 ，rssi*/
cJSON *Status_Upload(uint8_t option) //(void* struct_obj,uint32_t option)
{
	char rssi_s[5];
	char volt_s[5];
	char dotled_s[3];

	//LOG_I("Status_Upload\n");

	rt_sprintf(rssi_s, "%d", sys_info.rssi);								  //计算rssi为字符串
	rt_sprintf(volt_s, "%d.%d", sys_info.VCC / 100, sys_info.VCC % 100 / 10); //计算电压为字符串
	rt_sprintf(dotled_s, "%d", qxz.Param.Dotled_Option);					  //点阵屏使能标志位为字符串

	terminalstatus.RSSI = rssi_s;
	terminalstatus.VOLT = volt_s;
	terminalstatus.Dotled = dotled_s;
	terminalstatus.Version = version_with_time(1);

	rt_memset(tempbuff, '\0', 50);
	rt_sprintf(tempbuff, "%0.4d-%0.2d-%0.2d %0.2d:%0.2d:%0.2d", year, month,
			   day, hour, min, sec); //当前时间
									 //	Status_ext.MonitorTime = timer_str;

	Status_Message *struct_Status_message_obj = (Status_Message *)&Status_message;
	// 创建Status_Upload对象
	s2j_create_json_obj(json_Status_Upload);
	// 序列化json_Status_Upload对象
	s2j_json_set_basic_element(json_Status_Upload, struct_Status_message_obj, string, cmd);

	// 序列化json_ext对象
	s2j_json_set_struct_element(json_ext, json_Status_Upload, *struct_Status_Ext, struct_Status_message_obj, Status_Ext, ext);
	s2j_json_set_basic_element(json_ext, *struct_Status_Ext, string, StationID);
	s2j_json_set_basic_element(json_ext, *struct_Status_Ext, string, MonitorTime);

	// 序列化json_terminalstatus对象
	s2j_json_set_struct_element(json_terminalstatus, json_ext, *struct_TerminalStatus, *struct_Status_Ext, TerminalStatus, terminalStatus);
	s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, VOLT);
	s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, RSSI);
	if (option == 1)
	{ //全部上传

		/*******************			按需自动恢复备份经纬度信息			*********************/

		// rt_kprintf("sys_info.lng %s\n", sys_info.lng);
		// rt_kprintf("sys_info.lat %s\n", sys_info.lat);

		if (rt_strstr(sys_info.lng, "0.0") != RT_NULL && rt_strstr(sys_info.lat, "0.0") != RT_NULL)
		{
			// rt_sprintf(sys_info.lng , "113.53530");
			// rt_sprintf(sys_info.lat , "34.77435");

			// ef_set_env_blob("sys_info.lng",&sys_info.lng,sizeof(sys_info.lng));
			// ef_set_env_blob("sys_info.lat",&sys_info.lat,sizeof(sys_info.lat));

			// rt_kprintf("write lng %s\n",sys_info.lng);
			// rt_kprintf("write lat %s\n",sys_info.lat);

			// memset(sys_info.lng , 0 , sizeof(sys_info.lng));
			// memset(sys_info.lat , 0 , sizeof(sys_info.lat));

			if ((ef_get_env_blob("sys_info.lng", &sys_info.lng, sizeof(sys_info.lng), NULL) > 0) &&
				(ef_get_env_blob("sys_info.lat", &sys_info.lat, sizeof(sys_info.lat), NULL) > 0))
			{
				rt_kprintf("res sys_info.lng %s\n", sys_info.lng);
				rt_kprintf("res sys_info.lat %s\n", sys_info.lat);
			}
		}
		/*******************			按需自动恢复备份经纬度信息			*********************/

		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, IMEI);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, ICCID);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, longitude);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, latitude);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, altitude);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, Dotled);
		s2j_json_set_basic_element(json_terminalstatus, *struct_TerminalStatus, string, Version);
	}

	return json_Status_Upload;
}

// 上报通道0服务器IP，端口，topic等服务器信息
cJSON *Serv_info_Upload(void)
{
	uint8_t i = 0;
	char ip[36] = {0};

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *ip_address = RT_NULL;
	cJSON *port = RT_NULL;
	cJSON *topic = RT_NULL;

	if (strstr(qxz.Param.remote_bg_url, ".") != NULL && strlen(qxz.Param.remote_bg_url) > 6)
	{
		sprintf(ip, "%s", qxz.Param.remote_bg_url);
	}
	else
	{
		rt_sprintf(ip, "%03d%03d%03d%03d", qxz.Param.remote_bg_ip[0], qxz.Param.remote_bg_ip[1], qxz.Param.remote_bg_ip[2], qxz.Param.remote_bg_ip[3]);
	}

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddStringToObject(ext, "ip", ip);
	cJSON_AddNumberToObject(ext, "port", qxz.Param.remote_bg_port);

	cJSON_AddStringToObject(ext, "usr", qxz.Param.usr);
	cJSON_AddStringToObject(ext, "pwd", qxz.Param.pwd);

	cJSON_AddStringToObject(ext, "topic_p", qxz.Param.bg_pub);
	cJSON_AddStringToObject(ext, "topic_s", qxz.Param.bg_sub);

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("ip"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

/*上传时间间隔报告
{
	"cmd": "config",
	"ext": {
		"interval": 5
	}
}
*/

//上传间隔时间json
cJSON *IntervalUpload(void)
{
	uint8_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddNumberToObject(ext, "interval", qxz.Param.upload_interval); //"interval":

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("config")); //"cmd": "terminalData",
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

//上传平台选择json
cJSON *PlatformUpload(void)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	ef_get_env_blob("platform_f", &platform_f, sizeof(platform_f), RT_NULL);
	cJSON_AddNumberToObject(ext, "platform", platform_f); //"platform":

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("read")); //
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

//平台切换预警json
cJSON *Platform_Chg_Alarm(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	//rt_kprintf("Platform_Chg_Alarm exe ");

	if (type == 0)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("platform_change CMD"));
		//	rt_kprintf("0\n");
	}
	else
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("platform_change manual"));
		//	rt_kprintf("1\n");
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("alarm"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *Sensor_Read_Error(void)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddItemToObject(ext, "type", cJSON_CreateString("Sensor_Read_Error"));
	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("alarm"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *Configch_CHG(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	if (type == 0)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("configCH changed manual"));
	}
	else if (type == 1)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("ConfigCH changed CMD"));
	}
	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("alarm"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

// Type 1 分配空间失败 Type2 无匹配项
cJSON *Elem_cfg_fail(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	if (type == 1)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("create elem_corr_list fail"));
	}
	else if (type == 2)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("no match in sensor_ch"));
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("elem_cfg_fail"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *Elem_cfg_succ(uint8_t e_pos)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[30];
	Elem_corr_list *elem_corr_list; //修正参数

	elem_corr_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_corr));
	rt_memset(elem_corr_list, 0, qxz.Param.Num_sensors * sizeof(Elem_corr));
	ef_get_env_blob("elem_corr_list", elem_corr_list, qxz.Param.Num_sensors * sizeof(Elem_corr), RT_NULL);

	rt_sprintf(cache, "para : %d,%d,%d,%d",
			   elem_corr_list->elem_corr[e_pos].plus,
			   elem_corr_list->elem_corr[e_pos].minus,
			   elem_corr_list->elem_corr[e_pos].times,
			   elem_corr_list->elem_corr[e_pos].divide);

	cJSON_AddItemToObject(ext, elem_corr_list->elem_corr[e_pos].ename, cJSON_CreateString(cache));

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("elem_cfg_succ"));
	cJSON_AddItemToObject(root, "ext", ext);

	rt_free(elem_corr_list);

	return root;
}

cJSON *Elem_cfg_read(void)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[30];
	Elem_corr_list *elem_corr_list; //修正参数

	elem_corr_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_corr));
	rt_memset(elem_corr_list, 0, qxz.Param.Num_sensors * sizeof(Elem_corr));
	ef_get_env_blob("elem_corr_list", elem_corr_list, qxz.Param.Num_sensors * sizeof(Elem_corr), RT_NULL);

	for (uint8_t a = 0; a < qxz.Param.Num_sensors; a++)
	{
		if (elem_corr_list->elem_corr[a].en == 1)
		{
			rt_memset(cache, 0, 30);
			rt_sprintf(cache, "ch%d : %d , %d , %d , %d", a,
					   elem_corr_list->elem_corr[a].plus,
					   elem_corr_list->elem_corr[a].minus,
					   elem_corr_list->elem_corr[a].times,
					   elem_corr_list->elem_corr[a].divide);
			cJSON_AddItemToObject(ext, elem_corr_list->elem_corr[a].ename, cJSON_CreateString(cache));
		}
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("elem_corr_read"));
	cJSON_AddItemToObject(root, "ext", ext);

	rt_free(elem_corr_list);

	return root;
}

cJSON *FC_cfg_read(void)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[30];
	Elem_FC_list *elem_FC_list; // 修正参数

	elem_FC_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_FC));
	rt_memset(elem_FC_list, 0, qxz.Param.Num_sensors * sizeof(Elem_FC));
	ef_get_env_blob("elem_FC_list", elem_FC_list, qxz.Param.Num_sensors * sizeof(Elem_FC), RT_NULL);

	for (uint8_t a = 0; a < qxz.Param.Num_sensors; a++)
	{
		if (elem_FC_list->elem_fC[a].en == 1)
		{
			rt_memset(cache, 0, 30);
			rt_sprintf(cache, "ch%d : %d , %d , %d , %d", a,
					   elem_FC_list->elem_fC[a].FC_1,
					   elem_FC_list->elem_fC[a].FC_2,
					   elem_FC_list->elem_fC[a].FC_3,
					   elem_FC_list->elem_fC[a].FC_4);
			cJSON_AddItemToObject(ext, elem_FC_list->elem_fC[a].ename, cJSON_CreateString(cache));
		}
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("elem_FC_read"));
	cJSON_AddItemToObject(root, "ext", ext);

	rt_free(elem_FC_list);

	return root;
}

cJSON *FC_cfg_fail(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	if (type == 1)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("create elem_FC_list fail"));
	}
	else if (type == 2)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("no match in sensor_ch"));
	}
	else if (type == 3)
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("val out of range"));
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("FC_cfg_fail"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *FC_cfg_succ(uint8_t e_pos)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[30];
	Elem_FC_list *elem_FC_list; // 修正参数

	elem_FC_list = rt_malloc(qxz.Param.Num_sensors * sizeof(Elem_FC));
	rt_memset(elem_FC_list, 0, qxz.Param.Num_sensors * sizeof(Elem_FC));
	ef_get_env_blob("elem_FC_list", elem_FC_list, qxz.Param.Num_sensors * sizeof(Elem_FC), RT_NULL);

	rt_sprintf(cache, "para : %d,%d,%d,%d",
			   elem_FC_list->elem_fC[e_pos].FC_1,
			   elem_FC_list->elem_fC[e_pos].FC_2,
			   elem_FC_list->elem_fC[e_pos].FC_3,
			   elem_FC_list->elem_fC[e_pos].FC_4);
	cJSON_AddItemToObject(ext, elem_FC_list->elem_fC[e_pos].ename, cJSON_CreateString(cache));

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("FC_cfg_succ"));
	cJSON_AddItemToObject(root, "ext", ext);

	rt_free(elem_FC_list);

	return root;
}

cJSON *Ctl_485_report(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	uint8_t ctl_485_mode = 0;
	ef_get_env_blob("ctl_485_mode", &ctl_485_mode, sizeof(ctl_485_mode), RT_NULL);
	char cache[30] = {0};

	if (type == 0)
	{
		if (ctl_485_mode == 100)
		{
			rt_sprintf(cache, "%s", "read sensor mode");
		}
		else if (ctl_485_mode == 101)
		{
			rt_sprintf(cache, "%s", "Transparent mode");
		}
		else if (ctl_485_mode == 102)
		{
			rt_sprintf(cache, "%s", "monitor mode");
		}
		else
		{
			rt_sprintf(cache, "ctl_485_mode %d", ctl_485_mode);
		}
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("485 mode read"));
	}
	if (type == 1)
	{
		rt_sprintf(cache, "%s%d", "mode ", ctl_485_mode - 100);
		cJSON_AddItemToObject(ext, "succ", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("ctl_485_mode"));
	}
	if (type == 2)
	{
		rt_sprintf(cache, "%s", "illegal para");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("ctl_485_mode"));
	}

	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *Ctl_netsw_report(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	uint8_t ctl_netsw_mode = 0;
	ef_get_env_blob("ctl_netsw_mode", &ctl_netsw_mode, sizeof(ctl_netsw_mode), RT_NULL);
	char cache[30] = {0};

	if (type == 0)
	{
		if (ctl_netsw_mode == 100)
		{
			rt_sprintf(cache, "%s", "OFF");
		}
		else if (ctl_netsw_mode == 101)
		{
			rt_sprintf(cache, "%s", "ON");
		}
		else
		{
			rt_sprintf(cache, "%s%d", "read err ", ctl_netsw_mode);
		}

		cJSON_AddItemToObject(ext, "type", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("netsw mode read"));
	}
	if (type == 1)
	{
		rt_sprintf(cache, "%s%d", "mode ", ctl_netsw_mode - 100);
		cJSON_AddItemToObject(ext, "succ", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("ctl_netsw_mode"));
	}
	if (type == 2)
	{
		rt_sprintf(cache, "%s", "illegal para");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("ctl_netsw_mode"));
	}

	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *SDT_report(uint8_t type)
{
	uint8_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[30] = {0};

	if (sdt_info.en == 1 && strstr(sdt_info.ID_0, "86") != NULL)
	{
		rt_sprintf(cache, "%s", "ON");
	}
	else
	{
		rt_sprintf(cache, "%s", "OFF");
	}

	cJSON_AddItemToObject(ext, "type", cJSON_CreateString(cache));

	cJSON_AddItemToObject(ext, "TaskList", cJSON_CreateString(sdt_info.TaskList));
	cJSON_AddItemToObject(ext, "ID_0", cJSON_CreateString(sdt_info.ID_0));
	cJSON_AddItemToObject(ext, "ID_1", cJSON_CreateString(sdt_info.ID_1));
	cJSON_AddItemToObject(ext, "ID_2", cJSON_CreateString(sdt_info.ID_2));
	cJSON_AddItemToObject(ext, "ID_3", cJSON_CreateString(sdt_info.ID_3));
	cJSON_AddItemToObject(ext, "ID_4", cJSON_CreateString(sdt_info.ID_4));
	cJSON_AddItemToObject(ext, "ID_5", cJSON_CreateString(sdt_info.ID_5));

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("SDT_INFO"));

	cJSON_AddItemToObject(root, "ext", ext);

	//rt_kprintf("%s\n\n"  , cJSON_PrintUnformatted(root));

	return root;
}

cJSON *dtu_cmd(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[dtu_cmd_max_len] = {0};
	char cache1[dtu_cmd_max_len / 2 * 3] = {0};
	if (type == 0)
	{

		rt_sprintf(cache, "%s", "not in dtu mode");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dtu_cmd"));
	}
	if (type == 1)
	{
		rt_sprintf(cache, "%s", "cmd parsing failed");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dtu_cmd"));
	}
	if (type == 2)
	{
		rt_sprintf(cache, "%s", dtu_cmd_s);
		cJSON_AddItemToObject(ext, "reading", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dtu_cmd"));
	}
	if (type == 3)
	{
		for (uint8_t a = 0; a < dtu_cmd_h[(dtu_cmd_max_len / 2) - 1]; a++)
		{
			memset(cache, 0, sizeof(cache));
			rt_sprintf(cache, "%02X ", dtu_cmd_h[a]);
			strcat(cache1, cache);
		}

		memset(cache, 0, sizeof(cache));

		rt_sprintf(cache, " (%dms)", rs_485_mq_wait * 10 + 110);

		strcat(cache1, cache);

		rs_485_mq_wait = 0;

		cJSON_AddItemToObject(ext, "return", cJSON_CreateString(cache1));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dtu_cmd"));
	}
	if (type == 4)
	{
		rt_sprintf(cache, "%s", "response timed out");
		cJSON_AddItemToObject(ext, "return", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dtu_cmd"));
	}

	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *dotled_return(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	//	ef_get_env_blob("Dotled_Option", &qxz.Param.Dotled_Option, sizeof(qxz.Param.Dotled_Option), RT_NULL);
	//	ef_get_env_blob("dotled_p0", &dotled_p0, sizeof(dotled_p0), RT_NULL);

	char cache[30] = {0};

	if (type == 0)
	{

		/**
		 *LED点阵屏使能标志
		 * 0：不使用LED点阵屏
		 * 1：控制卡型号5K1
		 * 2：控制卡型号5K2
		 * 3：控制卡型号5K3
		 */

		rt_memset(cache, 0, sizeof(cache));
		if (qxz.Param.Dotled_Option < 0)
		{
			rt_sprintf(cache, "Slave %d", abs(qxz.Param.Dotled_Option));
		}
		else
		{
			switch (qxz.Param.Dotled_Option)
			{
			case 0:
				rt_sprintf(cache, "Disabled");
				break;

			case 1:
				rt_sprintf(cache, "5K1/6K1");
				break;

			case 2:
				rt_sprintf(cache, "5K2/6K2");
				break;

			case 3:
				rt_sprintf(cache, "5K3/6K3");
				break;

			case 5:
				rt_sprintf(cache, "Y1A-1DP-1Bit");
				break;

			case 6:
				rt_sprintf(cache, "Y1A-1DP-8Bit");
				break;

			case 7:
				rt_sprintf(cache, "Y1A-2DP-1Bit");
				break;

			case 8:
				rt_sprintf(cache, "Y1A-2DP-8Bit");
				break;

			default:
				break;
			}
		}

		if (qxz.Param.Dotled_Option >= -5 && qxz.Param.Dotled_Option <= 8)
		{
			cJSON_AddItemToObject(ext, "Control_card", cJSON_CreateString(cache));
		}

		// //点阵屏参数
		// typedef struct  {

		// 	uint8_t front;//显示字体：0:12;1:16

		// 	uint8_t keep_time;//单页停留时间 0.5s为单位

		// 	uint16_t Start_x;//起始坐标x(像素点为单位)

		// 	uint16_t Start_y;//起始坐标x(像素点为单位)

		// 	uint16_t Width;//显示宽度

		// 	uint16_t Height;//显示高度

		// }Dotled_t;

		//		if (dotled_p0.front == 0)
		//		{
		//			memset(cache, 0, sizeof(cache));
		//			rt_sprintf(cache, "12");
		//			cJSON_AddItemToObject(ext, "front", cJSON_CreateString(cache));
		//		}
		//		else if (dotled_p0.front == 1)
		//		{
		//			memset(cache, 0, sizeof(cache));
		//			rt_sprintf(cache, "16");
		//			cJSON_AddItemToObject(ext, "front", cJSON_CreateString(cache));
		//		}
		//		else
		//		{
		//			rt_kprintf("front %d \n",dotled_p0.front);
		//		}

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.front);
		cJSON_AddItemToObject(ext, "front", cJSON_CreateString(cache));

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.keep_time);
		cJSON_AddItemToObject(ext, "keep_time", cJSON_CreateString(cache));

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.Start_x);
		cJSON_AddItemToObject(ext, "Start_x", cJSON_CreateString(cache));

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.Start_y);
		cJSON_AddItemToObject(ext, "Start_y", cJSON_CreateString(cache));

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.Width);
		cJSON_AddItemToObject(ext, "Width", cJSON_CreateString(cache));

		rt_memset(cache, 0, sizeof(cache));
		rt_sprintf(cache, "%d", qxz.Param.dotled_p0.Height);
		cJSON_AddItemToObject(ext, "Height", cJSON_CreateString(cache));

		cJSON_AddItemToObject(root, "read", cJSON_CreateString("dotled_para"));
	}

	if (type == 1)
	{
		rt_sprintf(cache, "%s", "Control_card");
	}
	if (type == 2)
	{
		rt_sprintf(cache, "%s", "front");
	}
	if (type == 3)
	{
		rt_sprintf(cache, "%s", "keep_time");
	}
	if (type == 4)
	{
		rt_sprintf(cache, "%s", "Start_x");
	}
	if (type == 5)
	{
		rt_sprintf(cache, "%s", "Start_y");
	}
	if (type == 6)
	{
		rt_sprintf(cache, "%s", "Width");
	}
	if (type == 7)
	{
		rt_sprintf(cache, "%s", "Height");
	}
	if (type == 1 || type == 2 || type == 3 || type == 4 || type == 5 || type == 6 || type == 7)
	{
		cJSON_AddItemToObject(ext, "illegal para", cJSON_CreateString(cache));
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("dotled_para"));
	}

	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *sensor_mode_read(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[20] = {0};

	if (type == 0)
	{
		rt_sprintf(cache, "mode %d", en_low_power);
		cJSON_AddItemToObject(ext, "read", cJSON_CreateString(cache));
	}

	if (type == 1)
	{
		if (en_low_power >= 100)
		{
			rt_sprintf(cache, "mode %d", en_low_power - 100);
		}
		else
		{
			rt_sprintf(cache, "mode %d", en_low_power);
		}
		cJSON_AddItemToObject(ext, "set succ", cJSON_CreateString(cache));
	}

	if (type == 2)
	{
		rt_sprintf(cache, "illegal para");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("sensor_mode"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}
extern uint16_t e_pointer;
cJSON *ecode_cmd(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[60] = {0};
	char cache1[60] = {0};
	char head[30] = {0};

	RTC_DateTypeDef date = {0};
	RTC_TimeTypeDef time = {0};

	uint8_t for_time = 0;

	uint16_t read_cnt = 0;

	if (type == 0)
	{
	    read_cnt = ef_get_env_blob("e_code", &e_code, sizeof(Record) * (MAX_e_code_NUM), NULL);

	//    rt_kprintf("read_cnt >>> %d \n" , read_cnt);

		if (e_pointer <= MAX_e_code_NUM)
		{
			for_time = e_pointer;
		}
		else
		{
			for_time = MAX_e_code_NUM;
		}

//		rt_kprintf("for_time >>> %d \n" , for_time);


		for (uint8_t a = 0; a < for_time; a++)
		{
			Prase_Time_Stampe(&date, &time, e_code[a].Time_Stampe);

			rt_sprintf(cache, "C %d  P %d  Time %02d-%02d-%02d %02d:%02d:%02d", e_code[a].code, e_code[a].para,
					   date.Year, date.Month, date.Date, time.Hours, time.Minutes, time.Seconds);

			rt_sprintf(cache1, "%d/%d", a+1, for_time);

			//rt_kprintf("cache >>> \n %s %s \n\n " ,cache1, cache);

			cJSON_AddItemToObject(ext, cache1, cJSON_CreateString(cache));
		}
	}

	if (type == 1)
	{
		rt_sprintf(cache, "en %d lv %d", en_recode.en, en_recode.level);
		cJSON_AddItemToObject(ext, "set succ", cJSON_CreateString(cache));
	}

	if (type == 2)
	{
		rt_sprintf(cache, "illegal para");
		cJSON_AddItemToObject(ext, "fail", cJSON_CreateString(cache));
	}

	if (type == 3)
	{
		ef_del_env("e_code");
		rt_sprintf(cache, "del e_code finsh");
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString(cache));
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("e_code"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

cJSON *bak_parameters_respon(uint8_t type)
{
	uint8_t i = 0;
	uint8_t platform_f;
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	char cache[60] = {0};

	if (type == 1) //查询bak信息
	{
		rt_sprintf(cache, " %d ", read_bak_info());
		cJSON_AddItemToObject(ext, "bak_flag", cJSON_CreateString(cache));

		uint32_t elemcnt = 0;
		ef_port_read(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
		elemcnt = elemcnt / sizeof(Sensor);
		rt_sprintf(cache, " %d ", elemcnt);
		cJSON_AddItemToObject(ext, "elemcnt", cJSON_CreateString(cache));

		uint32_t chcnt = 0;
		ef_port_read(Bak_ch_size_Addr, (uint32_t *)&chcnt, sizeof(uint32_t));
		chcnt = chcnt / sizeof(Sensor_CH);
		rt_sprintf(cache, " %d ", chcnt);
		cJSON_AddItemToObject(ext, "chcnt", cJSON_CreateString(cache));

		uint8_t res_event = Zero;
		ef_get_env_blob("res_event", &res_event, sizeof(res_event), NULL);

		if (res_event == One)
		{
			cJSON_AddItemToObject(ext, "bakfun", cJSON_CreateString("off"));
		}
		else
		{
			cJSON_AddItemToObject(ext, "bakfun", cJSON_CreateString("on"));
		}

		uint8_t bl_ver = 0;
		ef_get_env_blob("bl_ver", &bl_ver, sizeof(bl_ver), NULL); //读出版本号的值
		if (bl_ver > 0)
		{
			rt_sprintf(cache, " V%d.%02d ", bl_ver / 100, bl_ver % 100);
			cJSON_AddItemToObject(ext, "bl_ver", cJSON_CreateString(cache));
		}
		else
		{
			cJSON_AddItemToObject(ext, "bl_ver", cJSON_CreateString("old"));
		}
	}
	if (type == 2) //还原所有参数
	{
		Restor_para(qxz_bak_part);
		Restor_para(ch_bak_part);
		Restor_para(elem_bak_part);
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("All parameters restored"));
	}
	if (type == 3) //备份所有参数
	{
		cJSON_AddItemToObject(ext, "type", cJSON_CreateString("All parameters are backed up"));
	}

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("bak_parameters"));
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

void Alarm_report(uint8_t type, uint8_t para, uint8_t mqtt_ch)
{

	switch (type)
	{
	case 1:
		mqtt_publish_ch(Sensor_Read_Error(), 0); //传感器读取失败预警
		mqtt_publish_ch(Sensor_Read_Error(), 1); //传感器读取失败预警
		break;
	case 2:
		mqtt_publish_ch(Elem_cfg_fail(para), mqtt_ch); //要素修正配置失败
		break;
	case 3:
		mqtt_publish_ch(Elem_cfg_succ(para), mqtt_ch); //要素修正配置成功
		break;
	case 4:
		mqtt_publish_ch(Elem_cfg_read(), mqtt_ch); //要素修正配置读取
		break;
	case 5:
		mqtt_publish_ch(Ctl_485_report(para), mqtt_ch); // 485 透传模式相关
		break;
	case 6:
		mqtt_publish_ch(dtu_cmd(para), mqtt_ch); // dtu cmd 相关
		break;
	case 7:
		mqtt_publish_ch(dotled_return(para), mqtt_ch); // led屏幕参数相关
		break;
	case 8:
		mqtt_publish_ch(sensor_mode_read(para), mqtt_ch); //传感器读取模式相关
		break;
	case 9:
		mqtt_publish_ch(ecode_cmd(para), mqtt_ch); //传感器读取模式相关
		break;

	case 10:
		mqtt_publish_ch(bak_parameters_respon(para), mqtt_ch); //写入备份区参数
		break;

	case 11:
		mqtt_publish_ch(Platform_Chg_Alarm(para), mqtt_ch); //平台切换预警
		break;
	case 12:
		mqtt_publish_ch(Configch_CHG(para), 0); //通道更新预警
		mqtt_publish_ch(Configch_CHG(para), 1); //通道更新预警
		break;

	case 13:
		mqtt_publish_ch(Ctl_netsw_report(para), mqtt_ch);
		break;

	case 14:
		mqtt_publish_ch(SDT_report(para), mqtt_ch);
		break;

	case 15:
		mqtt_publish_ch(FC_cfg_read(), mqtt_ch);
		break;
	case 16:
		mqtt_publish_ch(FC_cfg_fail(para), mqtt_ch);
		break;
	case 17:
		mqtt_publish_ch(FC_cfg_succ(para), mqtt_ch);
		break;

	default:
		break;
	}
}

//升级urljson
cJSON *Upgrade_Url(void)
{
	uint8_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddStringToObject(ext, "content", qxz.Param.upgrade_url); //"interval":

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("upgrade_url")); //"cmd": "terminalData",
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

//墒情校准值json
cJSON *soillmoisture_cal(void)
{
	uint8_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *interval = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddNumberToObject(ext, "ch0", soilmoisture_calibration[0]); //"ch0":
	cJSON_AddNumberToObject(ext, "ch1", soilmoisture_calibration[1]); //"ch1":
	cJSON_AddNumberToObject(ext, "ch2", soilmoisture_calibration[2]); //"ch2":
	cJSON_AddNumberToObject(ext, "ch3", soilmoisture_calibration[3]); //"ch3":
	cJSON_AddNumberToObject(ext, "ch4", soilmoisture_calibration[4]); //"ch4":
	cJSON_AddNumberToObject(ext, "ch5", soilmoisture_calibration[5]); //"ch5":
	cJSON_AddNumberToObject(ext, "ch6", soilmoisture_calibration[6]); //"ch6":

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("soilmoisture")); //"cmd": "terminalData",
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

//
// extern Filter_Para AT_Para; //用于抑制NA

extern RTC_DateTypeDef data_supp_date;
extern RTC_TimeTypeDef data_supp_time;
extern Bak_Elem_Info e_info;

extern uint8_t FR_flg[3];

extern uint8_t data_supp_flag;

//数据上传json
cJSON *TerminalData(uint8_t option)
{
	uint8_t i = 0;

	//rt_kprintf("TerminalData execute\n\n");
	//LOG_I("TerminalData Upload\n");

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *data = RT_NULL;
	cJSON *data0 = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	data = cJSON_CreateArray();

	memset(FR_flg, 1, sizeof(FR_flg)); //告诉modbus可以记录数据了

	uint8_t cache[10] = {0}; //组包evalue
	int NA_fill_val = 0;	 //替代NA的数据

	for (i = 0; i < qxz.Param.Num_sensors; i++)
	{
		if (rt_strcmp(sensor[i].eName, "\0") != 0) //传感器eName不能为空
		{
			cJSON_AddItemToArray(data, data0 = cJSON_CreateObject());

			if (sensor[i].online_flag == 1)
			{
				cJSON_AddStringToObject(data0, "eValue", sensor[i].eValue);
			}
			else
			{
				cJSON_AddStringToObject(data0, "eValue", "-99.99");
			}

			cJSON_AddStringToObject(data0, "eKey", sensor[i].eKey);
			if (option == 1) //选项值为1上报eName
				cJSON_AddStringToObject(data0, "eName", sensor[i].eName);
			cJSON_AddStringToObject(data0, "eNum", sensor[i].eNum);
		}
	}
	rt_memset(tempbuff, '\0', 50);

	if (data_supp_flag == 100)
	{
		rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", data_supp_date.Year + 2000, data_supp_date.Month, data_supp_date.Date, data_supp_time.Hours, data_supp_time.Minutes, data_supp_time.Seconds);
		//rt_kprintf("time + ");
	}
	else
	{
		rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);
		data_supp_flag = 0;
	}

	//rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);

	cJSON_AddItemToObject(ext, "StationID", cJSON_CreateString(qxz.Param.device_sn)); //"StationID": "18054382",
	cJSON_AddItemToObject(ext, "MonitorTime", cJSON_CreateString(tempbuff));		  //"MonitorTime": "2019-08-22 14:39:34",
	cJSON_AddItemToObject(ext, "data", data);										  //"data": [{

	if (data_supp_flag == 100)
	{
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("terminalhistoryData"));
		//rt_kprintf("title \n");
	}
	else
	{
		cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("terminalData")); //"cmd": "terminalData",
	}
	// cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("terminalData"));

	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

extern void READ_OUTPUT_STATUS(void);
extern JK_Status S_JK_Status[Number_JK];
extern Timing_Contol S_Timing_Contol[Number_JK];
extern Threshold_Contol S_Threshold_Contol[Number_JK];
//控制通道状态json
cJSON *ControlStatus(void)
{
	uint32_t i = 0;
	//	uint32_t jk[Number_JK];

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *Runstatus = RT_NULL;
	cJSON *data0 = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	Runstatus = cJSON_CreateArray();

	READ_OUTPUT_STATUS(); //更新IO状态

	for (i = 0; i < Number_JK; i++)
	{
		cJSON_AddItemToArray(Runstatus, data0 = cJSON_CreateObject());
		cJSON_AddNumberToObject(data0, "status", S_JK_Status[i].status);
		cJSON_AddNumberToObject(data0, "JK", S_JK_Status[i].JK);
	}
	rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);

	cJSON_AddItemToObject(ext, "StationID", cJSON_CreateString(qxz.Param.device_sn)); //"StationID": "18054382",
	cJSON_AddItemToObject(ext, "MonitorTime", cJSON_CreateString(tempbuff));		  //"MonitorTime": "2019-08-22 14:39:34",
	cJSON_AddItemToObject(ext, "runStatus", Runstatus);								  //"runStatus": [{

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("control")); //"cmd": "control",
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

//阈值状态信息json
cJSON *ThresholdStatus(void)
{
	uint32_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *Runstatus = RT_NULL;
	cJSON *data0 = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	Runstatus = cJSON_CreateArray();

	for (i = 0; i < Number_JK; i++)
	{
		cJSON_AddItemToArray(Runstatus, data0 = cJSON_CreateObject());
		cJSON_AddNumberToObject(data0, "JK", S_Threshold_Contol[i].JK);
		cJSON_AddNumberToObject(data0, "eKey", S_Threshold_Contol[i].eKey);
		cJSON_AddNumberToObject(data0, "upper", S_Threshold_Contol[i].upper);
		cJSON_AddNumberToObject(data0, "lower", S_Threshold_Contol[i].lower);
		cJSON_AddNumberToObject(data0, "method", S_Threshold_Contol[i].method);
	}

	rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);

	cJSON_AddItemToObject(ext, "StationID", cJSON_CreateString(qxz.Param.device_sn)); //"StationID": "18054382",
	cJSON_AddItemToObject(ext, "MonitorTime", cJSON_CreateString(tempbuff));		  //"MonitorTime": "2019-08-22 14:39:34",
	cJSON_AddItemToObject(ext, "runStatus", Runstatus);								  //"runStatus": [{

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("auto")); //"cmd": "control",
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

//定时控制状态信息json
cJSON *TimingStatus(void)
{
	uint32_t i = 0;
	uint32_t jk[Number_JK];

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *setTime = RT_NULL;
	cJSON *data0 = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	setTime = cJSON_CreateArray();

	for (i = 0; i < Number_JK; i++)
	{
		cJSON_AddItemToArray(setTime, data0 = cJSON_CreateObject());
		cJSON_AddNumberToObject(data0, "JK", S_Timing_Contol[i].JK);
		cJSON_AddNumberToObject(data0, "StartTime", S_Timing_Contol[i].StartTime);
		cJSON_AddNumberToObject(data0, "Duration", S_Timing_Contol[i].Duration);
	}
	rt_sprintf(tempbuff, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);

	cJSON_AddItemToObject(ext, "setTime", setTime); //"runStatus": [{

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("timing")); //"cmd": "control",
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

//震动报警上报
cJSON *Alarm_Upload(void)
{
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("alarm"));	  //"cmd": "alarm",
	cJSON_AddItemToObject(ext, "type", cJSON_CreateString("shakealarm")); //"StationID": "shakealarm",
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

//电源报警上报
cJSON *Powerdown_Upload(void)
{
	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();
	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("alarm"));	 //"cmd": "alarm",
	cJSON_AddItemToObject(ext, "type", cJSON_CreateString("powerdown")); //"StationID": "powerdown",
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

/*
{
"cmd": "offline",
"ext": {
		"imei": "868575028xxxxxx"
		}
}
*/

//遗嘱
cJSON *Will_upload(void)
{
	uint8_t i = 0;

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *imei = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	cJSON_AddItemToObject(ext, "imei", cJSON_CreateString(qxz.Param.device_sn)); //"imei":

	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("online")); //"cmd": "offline",
	cJSON_AddItemToObject(root, "ext", ext);

	return root;
}

// modbus模块状态上报
//  cJSON *modbus_dev(char *iotype)
//{
//	uint8_t i = 0;
//
//	cJSON *root = RT_NULL;
//	cJSON *ext = RT_NULL;
//	cJSON *interval = RT_NULL;
//	uint8_t io_status[16];
//	char *cmd_str = RT_NULL;
//
//	if(iotype ==  RT_NULL)return 0;
//	else  cmd_str = iotype;
//
//	if(strcmp(iotype,"input" ) == 0)
//	{
//		for(i = 0; i < 16;  i++ )
//		{
//			io_status[i] = IN_STATUS(i);
//
//		}
//	}
//	else if(strcmp(iotype,"input" ) == 0)
//	{
//		for(i = 0; i < 16;  i++ )
//		{
//
//			io_status[i] = OUT_STATUS(i);
//		}
//	}
//	else return 0;

//	root =cJSON_CreateObject();
//	ext  =cJSON_CreateObject();
//
//	cJSON_AddNumberToObject(ext, "ch0", io_status[0]);//"ch0":
//	cJSON_AddNumberToObject(ext, "ch1", io_status[1]);//"ch1":
//	cJSON_AddNumberToObject(ext, "ch2", io_status[2]);//"ch2":
//	cJSON_AddNumberToObject(ext, "ch3", io_status[3]);//"ch3":
//	cJSON_AddNumberToObject(ext, "ch4", io_status[4]);//"ch4":
//	cJSON_AddNumberToObject(ext, "ch5", io_status[5]);//"ch5":
//	cJSON_AddNumberToObject(ext, "ch6", io_status[6]);//"ch6":
//	cJSON_AddNumberToObject(ext, "ch7", io_status[7]);//"ch7":
//	cJSON_AddNumberToObject(ext, "ch8", io_status[8]);//"ch8":
//	cJSON_AddNumberToObject(ext, "ch9", io_status[9]);//"ch9":
//	cJSON_AddNumberToObject(ext, "ch10", io_status[10]);//"ch10":
//	cJSON_AddNumberToObject(ext, "ch11", io_status[11]);//"ch11":
//	cJSON_AddNumberToObject(ext, "ch12", io_status[12]);//"ch12":
//	cJSON_AddNumberToObject(ext, "ch13", io_status[13]);//"ch13":
//	cJSON_AddNumberToObject(ext, "ch14", io_status[14]);//"ch14":
//	cJSON_AddNumberToObject(ext, "ch15", io_status[15]);//"ch15":

//
//	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString(cmd_str));//"cmd": "terminalData",
//	cJSON_AddItemToObject(root, "ext", ext);
//
//	return root;
//}

/* 设备属性结构体赋值*/
Sensor sensor_config = {

	.num = 0,
	.sensor_addr = 0,
	.start_reg = 0,
	.count = 0,
	.d_pos = 0,
	.factor = 0,
	.d_length = 0,
	.err_cnt = 0,
	.online_flag = 0,
	.value = 0,
	.cName = 0,
	.units = 0,
	.eName = 0,
	.eValue = 0,
	.eKey = 0,
	.eNum = 0,
	.dotled_s = 0,
	.pwr_level = 0,
};

Element_Message element_message = {
	.cmd = tempbuff,
	.ext = &sensor_config,
};

Sensor *sensor_config_buff;
extern int sensor_config_find(Sensor *sensor_config_buff, const char *sensor_eName);

/*单个要素模型生成json*/
cJSON *Element_Upload(char *eName)
{

	if (eName == RT_NULL)
		return RT_NULL;

	sensor_config_buff = (Sensor *)rt_malloc(sizeof(Sensor));

	//根据通道名称字符串获取通道的参数
	//从flash中获取要素信息
	if (0 != ef_get_env_blob(eName, sensor_config_buff, sizeof(Sensor), RT_NULL))
	{
		rt_memcpy(&sensor_config, sensor_config_buff, sizeof(Sensor));
		strcpy(tempbuff, sensor_config.eName); //赋值给相应结构体
		LOG_I("eName:%s\r\n", sensor_config.eName);
	} //兼容下发要素属性成功反馈
	else if (rt_strcmp(eName, "rebooting") == 0)
		strcpy(tempbuff, "rebooting");
	else if (rt_strcmp(eName, "reseting") == 0)
		strcpy(tempbuff, "reseting");
	else if (rt_strcmp(eName, "element_suceess") == 0)
		strcpy(tempbuff, "element_success");
	else if (rt_strcmp(eName, "updateing") == 0)
		strcpy(tempbuff, "updateing");
	else if (rt_strcmp(eName, "zk_downloading") == 0)
		strcpy(tempbuff, "zk_downloading");
	else if (rt_strcmp(eName, "zk_downloadsucc") == 0)
		strcpy(tempbuff, "zk_downloadsucc");
	else
		strcpy(tempbuff, "element_RT_NULL"); //没有查询到返回

	//从内置结构体数组中获取要素信息
	//	if(sensor_config_find(sensor_config_buff, eName) == RT_TRUE)
	//	{
	//		rt_memcpy(&sensor_config, sensor_config_buff, sizeof(Sensor));
	//		strcpy(tempbuff, sensor_config.eName);//赋值给相应结构体
	//		LOG_I("eName:%s", sensor_config.eName);
	//	}
	//	else strcpy(tempbuff, "element_RT_NULL");//没有查询到返回

	Element_Message *struct_Element_message_obj = (Element_Message *)&element_message;
	// 创建Status_Upload对象
	s2j_create_json_obj(json_Element_Upload);
	// 序列化json_Status_Upload对象
	s2j_json_set_basic_element(json_Element_Upload, struct_Element_message_obj, string, cmd);

	if (rt_strcmp(tempbuff, "element_RT_NULL") == 0)
		goto _exit; //没有获取到直接返回
	else if (rt_strcmp(tempbuff, "element_success") == 0)
		goto _exit; //上报下发要素属性成功返回消息
	else if (rt_strcmp(tempbuff, "updateing") == 0)
		goto _exit; //更新固件返回消息
	else if (rt_strcmp(tempbuff, "zk_downloading") == 0)
		goto _exit; //下载字库支持文件返回消息
	else if (rt_strcmp(tempbuff, "zk_downloadsucc") == 0)
		goto _exit; //下载字库支持文件成功返回消息
	else if (rt_strcmp(tempbuff, "rebooting") == 0)
		goto _exit; //重启命令反馈
	else if (rt_strcmp(tempbuff, "reseting") == 0)
		goto _exit; //复位命令反馈
					// 序列化json_ext对象
	s2j_json_set_struct_element(json_ext, json_Element_Upload, *struct_Element_Ext, struct_Element_message_obj, Sensor, ext);

	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, num);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, sensor_addr);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, start_reg);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, count);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, d_pos);

	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, factor);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, d_length);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, err_cnt);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, online_flag);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, value);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, cName);

	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, units);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, eName);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, eValue);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, eKey);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, eNum);
	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, string, dotled_s);

	s2j_json_set_basic_element(json_ext, *struct_Element_Ext, int, pwr_level);

_exit:
	if (sensor_config_buff)
	{
		rt_free(sensor_config_buff);
		sensor_config_buff = RT_NULL;
	}
	return json_Element_Upload;
}
//要素模型配置json解析
#define gbk_utf_len 100
int cJSON_to_struct_array(char *text)
{
	cJSON *json, *arrayItem, *item, *object;
	int i;
	int ret = 0;
	int size = 0;
	int len = 0;
	char *gbk_buff = RT_NULL;
	Sensor *sensor_config = RT_NULL;

	json = cJSON_Parse(text);
	if (!json)
	{
		LOG_W("Error before: [%s]\n", cJSON_GetErrorPtr());
		ret = 0;
		return ret;
	}
	else
	{
		//创建汉字接收转码缓存
		gbk_buff = (char *)rt_malloc(gbk_utf_len);
		//创建配置解析用结构体缓存
		sensor_config = (Sensor *)rt_malloc(sizeof(Sensor));

		arrayItem = cJSON_GetObjectItem(json, "element");
		if (arrayItem != RT_NULL)
		{
			size = cJSON_GetArraySize(arrayItem);
			LOG_I("cJSON_GetArraySize: size=%d\n", size);

			for (i = 0; i < size; i++)
			{
				LOG_I("i=%d\n", i);
				object = cJSON_GetArrayItem(arrayItem, i);
				rt_memset(sensor_config, 0, sizeof(Sensor));
				/**** 1  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "num");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->num = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get num failed\n");
				}

				/**** 2  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "sensor_addr");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->sensor_addr = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get sensor_addr failed\n");
				}

				/**** 3  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "start_reg");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->start_reg = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get start_reg failed\n");
				}

				/**** 4  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "count");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->count = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get count failed\n");
				}

				/**** 5  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "d_pos");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->d_pos = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get d_pos failed\n");
				}

				/**** 6  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "factor");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->factor = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get factor failed\n");
				}

				/**** 7  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "d_length");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->d_length = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get d_length failed\n");
				}
				/**** 8  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "err_cnt");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->err_cnt = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get err_cnt failed\n");
				}
				/**** 9  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "online_flag");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->online_flag = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get online_flag failed\n");
				}
				/**** 10  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "value");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s, valueint=%d\n", item->type, item->string, item->valueint);
					sensor_config->value = item->valueint;
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get value failed\n");
				}
				/**** 11  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "cName");
				if (item != RT_NULL)
				{
					rt_memset(gbk_buff, 0, gbk_utf_len);
					SwitchToGbk((const uint8_t *)item->valuestring, strlen(item->valuestring), (uint8_t *)gbk_buff, &len);
					rt_memset(gbk_buff + len, '\0', 1);
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, gbk_buff);
					rt_memcpy(sensor_config->cName, gbk_buff, strlen(gbk_buff));
				}
				/**** 12  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "units");
				if (item != RT_NULL)
				{
					rt_memset(gbk_buff, 0, gbk_utf_len);
					SwitchToGbk((const uint8_t *)item->valuestring, strlen(item->valuestring), (uint8_t *)gbk_buff, &len);
					rt_memset(gbk_buff + len, '\0', 1);
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, gbk_buff);
					rt_memcpy(sensor_config->units, gbk_buff, strlen(gbk_buff));
				}
				/**** 13  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "eName");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, item->valuestring);
					rt_memcpy(sensor_config->eName, item->valuestring, strlen(item->valuestring));
				}
				/**** 14  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "eValue");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, item->valuestring);
					rt_memcpy(sensor_config->eValue, item->valuestring, strlen(item->valuestring));
				}
				/**** 15  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "eKey");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, item->valuestring);
					rt_memcpy(sensor_config->eKey, item->valuestring, strlen(item->valuestring));
				}
				/**** 16  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "eNum");
				if (item != RT_NULL)
				{

					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, item->valuestring);
					rt_memcpy(sensor_config->eNum, item->valuestring, strlen(item->valuestring));
				}
				/**** 17  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "dotled_s");
				if (item != RT_NULL)
				{
					rt_memset(gbk_buff, 0, gbk_utf_len);
					SwitchToGbk((const uint8_t *)item->valuestring, strlen(item->valuestring), (uint8_t *)gbk_buff, &len);
					rt_memset(gbk_buff + len, '\0', 1);
					LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, gbk_buff);
					rt_memcpy(sensor_config->dotled_s, gbk_buff, strlen(gbk_buff));
				}
				/**** 18  ***********************************************************************************/
				item = cJSON_GetObjectItem(object, "pwr_level");
				if (item != RT_NULL)
				{
					if (item->valueint >= 0 && item->valueint <= 2) // pwr_level  3种模式为 0 1 2
						sensor_config->pwr_level = item->valueint;
				}

				// rt_kprintf("item->valueint %d \n",item->valueint);

				LOG_I("sensor_config->eName: %s\n", sensor_config->eName);
				//保存到ENV
				ef_set_env_blob(sensor_config->eName, sensor_config, sizeof(Sensor));
			}
			ret = 1; //解析完成
		}
		else
		{
			ret = 0;
		}
	}

	if (gbk_buff)
	{
		rt_free(gbk_buff);
		gbk_buff = RT_NULL;
	}
	if (sensor_config)
	{
		rt_free(sensor_config);
		sensor_config = RT_NULL;
	}
	cJSON_Delete(json);
	return ret;
}

//通道配置生成json
cJSON *CH_Config_Json(uint8_t stat) // 1:保存成功，0：保存失败
{
	uint8_t i = 0;
	char ch_num[10] = {0};
	char app_mode[10] = {0};

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	rt_sprintf(app_mode, "%d", qxz.Param.application_model);

	cJSON_AddItemToObject(ext, "App_mod", cJSON_CreateString(app_mode));

	if (stat == 1)
	{
		for (i = 0; i < Number_sensors; i++)
		{
			if (rt_strcmp(SENSOR_CH[i].eName, "\0") != 0) //存在通道名
			{
				rt_sprintf(ch_num, "c%d", i);
				cJSON_AddItemToObject(ext, ch_num, cJSON_CreateString(SENSOR_CH[i].eName));
			}
		}
		Mark_up_elem();
	}
	else if (stat == 0) //保存失败
	{
		rt_sprintf(ch_num, "stat");
		cJSON_AddItemToObject(ext, ch_num, cJSON_CreateString("FAIL"));
	}
	cJSON_AddItemToObject(root, "config", cJSON_CreateString("ch_conf"));
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

//通道配置json解析
//返回0：解析失败，返回1：解析成功.返回-1 ：不是本次解析数据跳出
uint8_t ch_config_parse(char *text)
{
	cJSON *json = RT_NULL;
	cJSON *item = RT_NULL;
	cJSON *ext = RT_NULL;
	int i = 0, n = 0;
	int ret = 0;
	uint8_t app_mod = 0;
	char ch_temp[5] = {0};
	char sensor_ch_key[20];
	//	rt_kprintf("ch_config_parse 1\r\n");list_mem();
	json = cJSON_Parse(text);
	if (!json)
	{
		LOG_W("Error before: [%s]\n", cJSON_GetErrorPtr());
		ret = 0;
		goto __exit; //没有创建成功
	}
	else
	{
		item = cJSON_GetObjectItem(json, "config");
		if (item != RT_NULL) //检测到"cmd":"ch_conf"
		{
			LOG_I("cJSON_GetObjectItem is %s\n", item->valuestring);
			if (rt_strcmp(item->valuestring, "ch_conf") != 0)
			{
				ret = 0;
				goto __exit;
			}
		}
		else
		{
			ret = -1;
			goto __exit;
		} //不是本次解析数据，跳出

		ext = cJSON_GetObjectItem(json, "ext");

		if (ext == RT_NULL)
		{
			LOG_W("Error before: [%s]\n", cJSON_GetErrorPtr());
			ret = 0;
			goto __exit;
		}

		if (rt_sem_take(plp_req_ch, RT_WAITING_NO) == RT_EOK) //当从平台同步数据
		{
			uint8_t compare = 1;

			for (uint8_t a = 0; a < Number_sensors; a++)
			{
				rt_sprintf(ch_temp, "c%d", a);
				item = cJSON_GetObjectItem(ext, ch_temp);
				//rt_kprintf("%d : %s %s \n", a, SENSOR_CH[a].eName, item->valuestring);
				if (item != RT_NULL)
				{
					if (strlen(item->valuestring) > sizeof(SENSOR_CH[a].eName))
					{
						continue; //写入的长度超过通道存储长度，跳出
					}
					if (strstr(SENSOR_CH[a].eName, item->valuestring) == NULL)
					{
						compare = 0;
						//rt_kprintf("-A-");
						break;
					}
				}
				else if (a == qxz.Param.Num_sensors) //刚刚好 校验全通过 pass
				{
					compare = 1;
					//rt_kprintf("-B-");
					break;
				}
				else // 通道查完了
				{
					compare = 0;
					//rt_kprintf("-C-");
					break;
				}
			}
			//rt_kprintf("compare %d \n", compare);
			if (compare == 1) //不用更新
			{
				rt_sem_release(plp_ch_succ); //ch校验无误
				ret = 2;
				goto __exit;
			}
			else
			{
				rt_sem_release(plp_ch_fail); //ch校验有差异
				ret = 3;
				goto __exit;
			}
		}

		item = cJSON_GetObjectItem(ext, "App_mod");
		if (item != RT_NULL)
		{
			app_mod = atoi(item->valuestring);
			if (app_mod < 4) //检测下发是否在合理范围
				qxz.Param.application_model = app_mod;
			else
				qxz.Param.application_model = 0;
			LOG_I("app_mod:%d", app_mod);
			//保存运行模式参数
			ef_set_env_blob("application_model", &qxz.Param.application_model, sizeof(qxz.Param.application_model)); //保存参数
			Mark_up_qxz();
		}
		else
		{
			ret = 0;
			goto __exit;
		}

		for (i = 0; i < Number_sensors; i++) //配置生效之前先清空原有
		{
			rt_memset(SENSOR_CH[i].eName, '\0', sizeof(SENSOR_CH[i].eName));
		}
		for (n = 0, i = 0; i < Number_sensors; i++)
		{
			rt_sprintf(ch_temp, "c%d", i);
			item = cJSON_GetObjectItem(ext, ch_temp);
			if (item != RT_NULL)
			{
				if (strlen(item->valuestring) > sizeof(SENSOR_CH[n].eName))
					continue; //写入的长度超过通道存储长度，跳出
				rt_memcpy(SENSOR_CH[n].eName, item->valuestring, strlen(item->valuestring));
				LOG_I("cJSON_GetObjectItem: type=%d, string is %s\n", item->type, item->valuestring);
			}
			else
			{
				rt_memset(SENSOR_CH[n].eName, '\0', sizeof(SENSOR_CH[n].eName));
				LOG_E("CH:%s:item = RT_NULL n =%d", ch_temp, n);
			}
			n++;
		}

		if (qxz.Param.application_model == 0)
			strcpy(sensor_ch_key, "SENSOR_CH_M0"); //根据不同应用模式写入相应的key
		else if (qxz.Param.application_model == 1)
			strcpy(sensor_ch_key, "SENSOR_CH_M1");
		else if (qxz.Param.application_model == 2)
			strcpy(sensor_ch_key, "SENSOR_CH_M2");
		else if (qxz.Param.application_model == 3)
			strcpy(sensor_ch_key, "SENSOR_CH_M3");

		//		if(EF_ENV_FULL == ef_set_env_blob(sensor_ch_key, SENSOR_CH, sizeof(SENSOR_CH)))
		i = ef_set_env_blob(sensor_ch_key, SENSOR_CH, Number_sensors * sizeof(Sensor_CH)); //如果保存返回EF_ENV_FULL，则再操作1次
		LOG_I("ef_set_env_blob:%d", i);
		if (i == EF_NO_ERR) //保存成功消息
		{
			bak_para(One, ch_bak_part);

			ret = 1;
			LOG_I("ret:%d", ret);
		}
		else //保存失败消息
		{
			ret = 0;
			LOG_I("ret:%d", ret);
		}
		rt_sem_release(plp_ch_fail); //ch更新完成
	}
__exit:
	cJSON_Delete(json); // rt_kprintf("ch_config_parse 2\r\n");list_mem();
	return ret;
}

#ifdef DOTLEDSHOW
/*查询订阅ID列表

{"cmd": "DotledsubID"}

*/
/*下发设置订阅ID

{
	"cmd": "CONFIGDotledsubID",
	"ext": {
		"ID_0": "866193059758496",
		"ID_1": "866193059770186",
		"ID_2": "866193059757480",
		"ID_3": "866193059746079"
	}
}

*/
//订阅ID列表的反馈上报
cJSON *Data_dotled_subid(void)
{
	uint8_t i = 0;
	char ID[10] = {0};

	cJSON *root = RT_NULL;
	cJSON *ext = RT_NULL;

	root = cJSON_CreateObject();
	ext = cJSON_CreateObject();

	for (i = 0; i < sub_dev_n; i++)
	{
		rt_sprintf(ID, "ID_%d", i);
		cJSON_AddItemToObject(ext, ID, cJSON_CreateString(sub_para.ID_list[i]));
	}
	cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("DotledsubID"));
	cJSON_AddItemToObject(root, "ext", ext);
	return root;
}

int eNum_find(Sensor *buff, const char *eName)
{
	int i;

	if (eName == RT_NULL)
		return -1;
	if (buff == RT_NULL)
		return -1;

	for (i = 0; i < qxz.Param.Num_sensors; i++)
	{
		if (rt_strcmp(sensor[i].eName, eName) == 0) //此处必须为判断等于0，取反判断为0不可取
		{
			return i;
		}
	}
	return -1;
}

//订阅到其他设备数据解析
int DOETLED_Json_Value(char *text)
{
	cJSON *json = RT_NULL;
	cJSON *item = RT_NULL;
	cJSON *ext = RT_NULL;
	cJSON *arrayItem = RT_NULL;
	cJSON *object = RT_NULL;
	int i, sensor_num = 0;
	int ret = 0;
	int size = 0;
	int len = 0;

	json = cJSON_Parse(text);
	if (!json)
	{
		LOG_W("Error before: [%s]\n", cJSON_GetErrorPtr());
		ret = 0;
		return ret;
	}
	else
	{
		item = cJSON_GetObjectItem(json, "cmd");
		if (item != RT_NULL) //检测到"cmd":"terminalData"
		{
			LOG_I("cJSON_GetObjectItem is %s\n", item->valuestring);
			if (rt_strcmp(item->valuestring, "terminalData") != 0)
			{
				ret = 0;
				goto __exit;
			}
		}
		else
		{
			ret = -1;
			goto __exit;
		} //不是本次解析数据，跳出

		ext = cJSON_GetObjectItem(json, "ext");

		if (ext == RT_NULL)
		{
			LOG_W("Error before: [%s]\n", cJSON_GetErrorPtr());
			ret = 0;
			goto __exit;
		}

		item = cJSON_GetObjectItem(ext, "StationID");
		if (item != RT_NULL) //检测到"cmd":"terminalData"
		{
			LOG_I("cJSON_GetObjectItem is %s\n", item->valuestring);
			for (i = 0; i < sub_dev_n; i++)
			{ //检查收到的id是否在订阅的列表中
				if (rt_strcmp(item->valuestring, sub_para.ID_list[i]) == 0)
					break;
				else if (i == sub_dev_n) //检查后列表中没有对应的id
				{
					ret = -1;
					goto __exit;
				} //不是本次解析数据，跳出
				else
					continue;
			}
		}
		else
		{
			ret = -1;
			goto __exit;
		} //不是本次解析数据，跳出

		arrayItem = cJSON_GetObjectItem(ext, "data");
		if (arrayItem != RT_NULL)
		{

			size = cJSON_GetArraySize(arrayItem);
			LOG_I("cJSON_GetArraySize: size=%d\n", size);

			for (i = 0; i < size; i++)
			{
				object = cJSON_GetArrayItem(arrayItem, i);

				/**** 1  ***********获取通道名称并查找模型数据结构中的位置**************************************/
				item = cJSON_GetObjectItem(object, "eName");
				if (item != RT_NULL)
				{
					LOG_I("cJSON_GetObjectItem: string is %s, valuestring:%s\n", item->string, item->valuestring);
					sensor_num = eNum_find(sensor, item->valuestring);
					LOG_I("SENSOR_NUM:%d", sensor_num);
				}
				else
				{
					LOG_W("cJSON_GetObjectItem: get eName failed\n");
					continue;
				}

				/**** 2  ************通过获取到的模型数据结构中的位置将数据保存到对应的位置**********************************/
				if (sensor_num >= 0)
				{
					item = cJSON_GetObjectItem(object, "eValue");
					if (item != RT_NULL)
					{
						LOG_I("cJSON_GetObjectItem: string is %s, valuestring:%s\n", item->string, item->valuestring);

						rt_memset(&sensor[sensor_num].eValue, 0, sizeof(sensor[sensor_num].eValue));
						strcpy(sensor[sensor_num].eValue, item->valuestring);
						if (rt_strcmp(sensor[sensor_num].eValue, "-99.99") != 0) //获取到无效数据将在线标志置零
							sensor[sensor_num].online_flag = 1;
						else
							sensor[sensor_num].online_flag = 0;
						sub_para.timeout[sensor_num] = qxz.Param.upload_interval * 2;
					}
					else
					{
						LOG_W("cJSON_GetObjectItem: get eValue failed\n");
					}
				}

				/*处理风向数据，为了LED显示实际风向，必须转为整型数据*/
				if (rt_strcmp(sensor[sensor_num].eName, "WindDirection") == 0)
				{
					sensor[sensor_num].value = atoi(sensor[sensor_num].eValue);
					LOG_I("WindDirection:%d\r\n", sensor[sensor_num].value);
				}
			}
			ret = 1; //解析完成
		}
		else
		{
			ret = 0;
		}
	}

__exit:

	cJSON_Delete(json); // rt_kprintf("ch_config_parse 2\r\n");list_mem();
	return ret;
}

//数据解析，参数：json字符串，接收到的mqtt通道号
void DOTLEDParseJson(const char *pCmdJson, uint16_t mqtt_ch)
{
	if ((pCmdJson == RT_NULL) || (mqtt_ch >= 2))
		return;
	//要素模型下发解析
	if (DOETLED_Json_Value((char *)pCmdJson) == 1)
	{ //下发保存成功后反馈
		LOG_D("cjson_succee");
		return;
	}
}
//设备的数据接收超时函数
rt_timer_t dotled_data_timeout;

static void dotled_data_timeout_callback(void *parameter)
{
	uint8_t i;

	for (i = 0; i < qxz.Param.Num_sensors; i++)
	{
		if (sub_para.timeout)
			sub_para.timeout[i]--;

		if (sub_para.timeout[i] == 0)
		{
			strcpy(sensor[i].eValue, "-99.99");
			log_w("%s read fail\r\n", sensor[i].eName);
			sensor[i].online_flag = 0;
		}
	}
}

static int dotledshow_init(void)
{
	rt_thread_t tid;
	rt_err_t result;

	uint8_t i;

	if (ef_get_env_blob("dotledsubid", &sub_para.ID_list[0], sizeof(sub_para.ID_list), RT_NULL))
	{
		rt_kprintf("sub_para.ID_list[0] :%s\r\n", sub_para.ID_list[0]);
		rt_kprintf("sub_para.ID_list[1] :%s\r\n", sub_para.ID_list[1]);
		rt_kprintf("sub_para.ID_list[2] :%s\r\n", sub_para.ID_list[2]);
		rt_kprintf("sub_para.ID_list[3] :%s\r\n", sub_para.ID_list[3]);
	}
	sub_para.timeout = (uint16_t *)rt_malloc(sizeof(uint16_t) * qxz.Param.Num_sensors);
	if (sub_para.timeout == RT_NULL)
		result = RT_ERROR;
	rt_memset(sub_para.timeout, 0, sizeof(uint16_t) * qxz.Param.Num_sensors);
	//赋值初始变量
	for (i = 0; i < qxz.Param.Num_sensors; i++)
	{
		strcpy(sensor[i].eValue, "-99.99");
		sensor[i].online_flag = 0;
	}

	/* 创建定时器 1  周期定时器 */
	dotled_data_timeout = rt_timer_create("dotled_data_timeout", dotled_data_timeout_callback,
										  RT_NULL, 60000,
										  RT_TIMER_FLAG_PERIODIC);

	/* 启动定时器 1 */
	if (dotled_data_timeout != RT_NULL)
		rt_timer_start(dotled_data_timeout);
	return result;
}

INIT_APP_EXPORT(dotledshow_init);
#endif