引入mqtt 引入cjson

Board/ao-board.c

@@ -0,0 +1,22 @@
+#include "ao-board.h"
+
+
+
+
+
+// //³õʼ»¯ 4-20 ma ͨµÀ
+void MX_AOInit (O4_20mA_t o)
+{
+
+}
+
+
+
+
+
+
+
+
+
+
+

Board/ao-board.h

@@ -0,0 +1,15 @@
+#ifndef _AO_BOARD_H
+#define _AO_BOARD_H
+#include <stdint.h>
+
+
+typedef enum O4_20mA_t
+{
+	O4_20mA1,
+	O4_20mA2
+} O4_20mA_t;
+
+
+#endif
+
+

Board/data.c

@@ -0,0 +1,191 @@
+#include "data.h"
+#include <rtthread.h>
+
+
+
+const StrIndex_t cDownDataType[] = 
+{
+	{"run",DownRun} ,
+	{"stop",DownStop} ,
+	{"open",DownOpen} ,
+	{"close",DownClose} ,
+	{"reg_ans",DownRegistAns} ,
+	{"heart_ans",DownHeartAns},
+	{"update",DownUpdate}, 	
+	{"reboot",DownReboot}, 	
+	{"config",DownConfig},
+	{"read",DownRead} 	
+};
+
+
+
+const StrIndex_t cSiteType[] = 
+{
+	{"sluice",SiteSluice} ,
+	{"flow",SiteFlow} ,
+	{"press",SiteSee} ,
+	{"auto",SiteColl} ,
+	{"trans",SiteServer} ,
+	{"level",SiteLevel}
+};
+
+
+const StrIndex_t cMotorType[] = 
+{
+	{"mg1000",MT_MG_1000} ,
+	{"qh100",MT_QH_V100} ,
+	{"qh200",MT_QH_V200} ,
+	{"zs100",MT_ZS_V100} ,
+	{"dy100",MT_DY_V100} ,
+	{"kg100",MT_KG_V100} 
+};
+
+const StrIndex_t c4851Type[] = 
+{
+	{"mg1000",ST_MG_1000} ,
+	{"qh100",ST_QH_V100} ,
+	{"qh200",ST_QH_V200} ,
+	{"dy100",ST_DY_V100} ,
+	{"kg100",ST_KG_V100} ,
+};
+
+const StrIndex_t cU485Type[] = 
+{
+	{"modbus",0} 
+};
+
+const StrIndex_t c4852Type[] = 
+{
+	{"rds600",ST_RDS_600} ,
+	{"tds300",ST_TDS_300} ,
+	{"ht100",ST_HT_V100} ,
+	{"zkjszk",ST_ZK_JSZK}, 
+	{"djx100",ST_DJX_100},
+	{"rds300",ST_RDS_300}	
+};
+
+
+const ParShallInfo_t ParShallTale[] = 
+{
+	{.w = 0,.c = 0,.m = 0},
+	{.w = 0.152,	.c = 0.381,	.m = 1.58	,.minLeve = 0.03,	.maxLeve = 0.45,	.minFlow = 1.5/1000,	.maxFlow = 100/1000}, 
+	{.w = 0.25,		.c = 0.561,	.m = 1.513	,.minLeve = 0.03,	.maxLeve = 0.60,	.minFlow = 3.0/1000,	.maxFlow = 250/1000},
+	{.w = 0.30,		.c = 0.679,	.m = 1.521	,.minLeve = 0.03,	.maxLeve = 0.75,	.minFlow = 3.5/1000,	.maxFlow = 400/1000},
+	{.w = 0.45,		.c = 1.038,	.m = 1.537	,.minLeve = 0.03,	.maxLeve = 0.75,	.minFlow = 4.5/1000,	.maxFlow = 630/1000},
+	{.w = 0.60,		.c = 1.403,	.m = 1.548	,.minLeve = 0.05,	.maxLeve = 0.75,	.minFlow = 12.5/1000,	.maxFlow = 850/1000},
+	{.w = 0.75,		.c = 1.772,	.m = 1.557	,.minLeve = 0.06,	.maxLeve = 0.75,	.minFlow = 25.0/1000,	.maxFlow = 1100/1000},
+	{.w = 0.90,		.c = 2.147,	.m = 1.565	,.minLeve = 0.06,	.maxLeve = 0.75,	.minFlow = 30.0/1000,	.maxFlow = 1250/1000},
+	{.w = 1.00,		.c = 2.397,	.m = 1.569	,.minLeve = 0.06,	.maxLeve = 0.80,	.minFlow = 30.0/1000,	.maxFlow = 1500/1000},
+	{.w = 1.20,		.c = 2.904,	.m = 1.577	,.minLeve = 0.06,	.maxLeve = 0.80,	.minFlow = 35.0/1000,	.maxFlow = 2000/1000},
+	{.w = 1.50,		.c = 3.668,	.m = 1.586	,.minLeve = 0.06,	.maxLeve = 0.80,	.minFlow = 45.0/1000,	.maxFlow = 2500/1000},
+	{.w = 1.80,		.c = 4.440,	.m = 1.593	,.minLeve = 0.08,	.maxLeve = 0.80,	.minFlow = 80.0/1000,	.maxFlow = 3000/1000},
+	{.w = 2.10,		.c = 5.222,	.m = 1.599	,.minLeve = 0.08,	.maxLeve = 0.80,	.minFlow = 95.0/1000,	.maxFlow = 3600/1000},
+	{.w = 2.40,		.c = 6.004,	.m = 1.605	,.minLeve = 0.08,	.maxLeve = 0.80,	.minFlow = 100.0/1000,	.maxFlow = 4000/1000},
+														
+	{.w = 3.05,		.c = 7.463,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.07,	.minFlow = 0.16,	.maxFlow = 8.28},
+	{.w = 3.66,		.c = 8.859,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.37,	.minFlow = 0.19,	.maxFlow = 14.68},
+	{.w = 4.57,		.c = 10.96,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.67,	.minFlow = 0.23,	.maxFlow = 25.04},
+	{.w = 6.10,		.c = 14.45,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.83,	.minFlow = 0.31,	.maxFlow = 37.97},
+														
+	{.w = 7.62,		.c = 17.94,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.83,	.minFlow = 0.38,	.maxFlow = 47.16},
+	{.w = 9.14,		.c = 21.44,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.83,	.minFlow = 0.46,	.maxFlow = 56.33},
+	{.w = 12.19,	.c = 28.43,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.83,	.minFlow = 0.60,	.maxFlow = 74.70},
+	{.w = 15.24,	.c = 35.41,	.m = 1.6	,.minLeve = 0.09,	.maxLeve = 1.83,	.minFlow = 0.75,	.maxFlow = 93.04},
+
+} ;
+
+
+
+SluiceData_t  SluiceData[SLUICE_COUTN];
+WaterData_t  WaterData[WATER_COUTN];
+SysData_t SysData;
+
+uint32_t g_ifconfig = 0;
+uint32_t g_ifupdate = 0;
+
+
+int cMotorGetType (char * str)
+{
+	for (int i =0;i < sizeof(cMotorType)/sizeof(StrIndex_t);i++)
+	{
+		if (rt_memcmp(str,cMotorType[i].str,rt_strlen(str)) == 0)
+		{
+			return cMotorType[i].index;
+		}
+	}
+	return -1;
+}
+
+
+int c4851GetType(char * str)
+{
+	rt_kprintf("485 option count:%d\r\n",sizeof(c4851Type)/sizeof(StrIndex_t)) ;
+	for (int i =0;i < sizeof(c4851Type)/sizeof(StrIndex_t);i++)
+	{
+		rt_kprintf("%s,%s\r\n",str,c4851Type[i].str) ;
+		if (rt_memcmp(str,c4851Type[i].str,rt_strlen(str)) == 0)
+		{
+			return c4851Type[i].index;
+		}
+	}
+	return -1;
+}
+
+int c4852GetType(char * str)
+{
+	for (int i =0;i < sizeof(c4852Type)/sizeof(StrIndex_t);i++)
+	{
+		if (rt_memcmp(str,c4852Type[i].str,rt_strlen(str)) == 0)
+		{
+			return c4852Type[i].index;
+		}
+	}
+	return -1;
+}
+
+
+int cU485GetType(char *str)
+{
+	for (int i =0;i < sizeof(cU485Type)/sizeof(StrIndex_t);i++)
+	{
+		if (rt_memcmp(str,cU485Type[i].str,rt_strlen(str)) == 0)
+		{
+			return cU485Type[i].index;
+		}
+	}
+	return -1;
+}
+
+
+int cDownType2Index(char * str)
+{
+	for (int i =0;i < sizeof(cDownDataType)/sizeof(StrIndex_t);i++)
+	{
+		if (rt_memcmp(str,cDownDataType[i].str,rt_strlen(str)) == 0)
+		{
+			return cDownDataType[i].index;
+		}
+	}
+	return -1;
+}
+
+
+
+int cSiteType2Index(char * str)
+{
+	for (int i =0;i < sizeof(cSiteType)/sizeof(StrIndex_t);i++)
+	{
+		if (rt_memcmp(str,cSiteType[i].str,rt_strlen(str)) == 0)
+		{
+			return cSiteType[i].index;
+		}
+	}
+	return -1;
+}
+
+
+
+
+
+
+

Board/data.h

@@ -0,0 +1,213 @@
+#ifndef _DATA_H
+#define _DATA_H
+#include <stdint.h>
+
+
+#define SLUICE_COUTN  1// 当前处理几口闸
+#define WATER_COUTN   6// 当前接入n个流量计
+#define SUBTOPIC_COUNT 1 // 订阅topic 数量
+#define SLUCIE_EXEC_COUNT  20// 闸门异常时间
+
+
+#define VERSION    "V2.0.1"
+
+
+
+extern uint32_t g_ifconfig;
+extern uint32_t g_ifupdate;
+
+typedef struct StrIndex_t
+{
+	char str[10];
+	int index;
+}StrIndex_t;
+
+
+// 巴歇尔槽流量计
+typedef struct ParShallInfo_t
+{
+	double w; // 喉道宽
+	double c;
+	double m;
+	double minLeve;
+	double maxLeve;
+	double minFlow;
+	double maxFlow;
+}ParShallInfo_t;
+
+
+
+typedef struct LeveInfo_t
+{
+	uint16_t Y[100];  // 水位
+	uint16_t Key[100]; // 流量
+}LeveInfo_t;
+// 水位流量关系表数据
+typedef struct WaterLeveInfo_t
+{
+	uint16_t X[100];  // 单位 mm
+	LeveInfo_t Key[100];
+}WaterLeveInfo_t;
+
+
+
+// 闸门信息
+typedef struct SluiceData_t
+{
+	int32_t gopen;  // 读取到的开度 单位 mm / %0.1
+	int32_t sopen;  // 设定开度     单位 mm / %0.1
+	int32_t lload;  // 左荷重 单位 kg
+	int32_t rload;  // 右荷重 单位 kg
+	int32_t ecode;  // 编码器原始数据
+	int32_t currt;  // 设备电流
+} SluiceData_t;
+
+
+// 系统信息
+typedef struct  SysData_t
+{
+	uint32_t Vbat;// 电池电压
+	char iccid[32] ;
+	int16_t Csq;// 信号强度
+	int netState; // 网络状态
+	int ecdState; // 编码器状态
+	int flowState;// 流量计状态
+	int ldState;  // 荷重状态
+	int scram;    // 急停被按下
+	char fileName[64]; // 文件名
+	int fileSize; // 文件大小
+} SysData_t;
+
+
+
+
+// 水量参数
+typedef struct WaterData_t
+{
+	int64_t ttWater;     // 累计流量   单位 m3
+	int32_t thisFlow;    // 瞬时流量   单位 m3
+	int32_t thisLevel;    // 水位
+	int32_t thisSpeed;   // 流速
+	int32_t thisPress;  // 压力
+	int32_t thisTemp;   // 温度
+} WaterData_t;
+
+
+
+typedef enum Ctrl_Mode_t
+{
+	CTRL_FOPEN = 0,
+	CTRL_ZOPEN = 1
+}Ctrl_Mode_t;
+
+
+typedef enum MotorType_t
+{
+	MT_MG_1000,   // 米格1000
+	MT_QH_V100,   // 强华 1.0 版本
+	MT_QH_V200,   // 强华 2.0 版本
+	MT_ZS_V100,	  // 中盛 4-20 ma 
+	MT_JZ_V200,	  // 金志 4-20 ma
+	MT_DY_V100,   // 大禹锥型阀
+	MT_KG_V100,   // 开关量模块
+	MT_KR_V100,   // 徐州正天闸位计
+} MotorType_t;
+
+typedef enum S4851Type_t
+{
+	ST_MG_1000,   // 米格1000
+	ST_QH_V100,   // 强华 1.0 版本
+	ST_QH_V200,   // 强华 2.0 版本
+	ST_AT_V100,   // 奥图编码器
+	ST_DY_V100,   // 大禹锥形阀
+	ST_KG_V100,   // 开关量模块
+	ST_KR_V100,   // 徐州正天闸位计
+} S4851Type_t;
+
+typedef enum S4852Type_t
+{
+	ST_RDS_600,   // rds600 雷达流速一体机
+	ST_TDS_300,   // tds300 超声波流量计
+	ST_HT_V100,   // 华天液位计
+	ST_ZK_JSZK,   // 精水中科多普勒 
+	ST_DJX_100,   // 丁家峡闸门 读取开度
+	ST_RDS_300,   // 雷达流量计
+} S4852Type_t;
+
+
+typedef enum SOFTFLOWType_t
+{
+	NONE,
+	WATER,
+	PARSHALL//
+}SOFTFLOWType_t;
+
+
+
+typedef enum SiteType_t
+{
+	SiteSluice,     // 闸门站
+	SiteFlow,       // 流量站
+	SiteSee,        // 渗流渗压站
+	SiteColl,       // 采集站
+	SiteServer,     // 串口服务器
+	SiteLevel    	// 水位站
+}SiteType_t;
+
+
+typedef enum DownDataType_t
+{
+	DownRun         = 0,
+	DownStop		= 1,
+	DownOpen		= 2,
+	DownClose		= 3,
+	DownRegistAns   = 4,
+	DownHeartAns	= 5, // 心跳
+	DownUpdate		= 6, // 升级
+	DownReboot		= 7,  // 重启
+	DownConfig		= 8,  // 修改参数
+	DownRead		= 9,  // 读取参数
+}DownDataType_t;
+
+
+
+extern const StrIndex_t cSiteType[];
+
+// 通过邮箱传输给驱动层
+typedef struct TypeIndexMail_t
+{
+	uint16_t  Type;
+	uint16_t index;
+}TypeIndexMail_t;
+
+
+
+
+extern SluiceData_t  SluiceData[SLUICE_COUTN];
+extern WaterData_t  WaterData[WATER_COUTN];
+extern SysData_t SysData;
+extern const WaterLeveInfo_t LeveInfo;
+extern const ParShallInfo_t ParShallTale[];
+
+
+int cMotorGetType (char * str);
+
+
+int c4851GetType(char * str);
+
+int c4852GetType(char * str);
+
+int cU485GetType(char *str);
+
+// 读取控制模式
+int cCtrlGetType(char * str);
+
+int cDownType2Index(char * str);
+
+
+int cSiteType2Index(char * str);
+
+
+
+#endif
+

Board/do-board.c

@@ -0,0 +1,9 @@
+#include "do-board.h"
+#include "tim.h"
+
+
+
+void MX_Dout_Push(int index,int pwm)
+{
+	MX_TIM_SetDuty(index,pwm);
+}

Board/do-board.h

@@ -0,0 +1,6 @@
+#ifndef _DO_BOARD_HH
+#define _DO_BOARD_HH
+
+void MX_Dout_Push(int index, int pwm);
+
+#endif 

Board/network/cat1drv.c

@@ -0,0 +1,307 @@
+#include <cat1drv.h>
+#include <rtthread.h>
+#include <os-app.h>
+#include "main.h"
+#include "usart-board.h"
+#include <string.h>
+#include <stdlib.h>
+#include <easyflash.h>
+#include "netdrv.h"
+#include "data.h"
+
+
+
+
+
+#if !defined(LOG_TAG)
+#define LOG_TAG          "CAT1"
+#endif
+#include <elog.h>
+
+
+ALIGN (RT_ALIGN_SIZE)
+static char thread_stack[4096];
+static struct rt_thread netapp_thread;
+static char tcprxbbuff[1200];
+static char tcptxbbuff[1200];
+
+
+netDrv_t g_cat1Drv =
+{
+	0,          // 信号值
+	"",         // iccid
+	Init,       // 状态
+	tcprxbbuff, // 接受缓存
+	0,          // 接受数据长度
+	tcptxbbuff, // 发送数据缓存
+	0,          // 发送数据长度
+
+};
+
+
+
+
+
+static void ec200_resp_csq_callback (char * data, uint16_t length)
+{
+	char * p;
+	p = strstr (data, "+CSQ:");
+	p = p + 6;
+	g_cat1Drv.Csq = atoi (p);
+	rt_kprintf ("CSQ:	<<< <%d>\r\n", g_cat1Drv.Csq);
+}
+
+// 校准时间程序
+static void ec200_resp_qlts_callback (char * data, uint16_t length)
+{
+	uint8_t k[6] = {NULL};
+	char *p = NULL;
+	p = strstr (data, "+QLTS:") ;
+	p = p + 10;
+	k[0] = atoi (p); // 年
+	k[0] = (k[0] + (k[0] / 10) * 6) ;   // 十进制转bcd码
+	p = p + 3;
+	k[1] = atoi (p); // 月
+	k[1] = (k[1] + (k[1] / 10) * 6) ;
+	p = p + 3;
+	k[2] = atoi (p); // 日
+	k[2] = (k[2] + (k[2] / 10) * 6) ;
+	p = p + 3; // p
+	k[3] = atoi (p); // 时
+	k[3] = (k[3] + (k[3] / 10) * 6) ;
+	p = p + 3; // p
+	k[4] = atoi (p); // 分
+	k[4] = (k[4] + (k[4] / 10) * 6) ;
+	p = p + 3; // p
+	k[5] = atoi (p); // 秒
+	k[5] = (k[5] + (k[5] / 10) * 6) ;
+	rt_kprintf ("20%02x-%02x-%02x %02x:%02x:%02x\r\n", k[0], k[1], k[2], k[3], k[4], k[5]);
+
+}
+
+
+static void ec200_resp_iccid_callback (char * data, uint16_t length)
+{
+	char *p;
+	p = strstr (data, "+QCCID:");
+	p = p + 8;
+	rt_memset (SysData.iccid, 0, 32);
+	rt_memcpy (SysData.iccid, p, 20);
+	rt_kprintf ("ICCID:	<<< <%d> [%s]\r\n", length, SysData.iccid);
+}
+
+static void ec200_resp_qird_callback (char * data, uint16_t length)
+{
+	char * p;
+	p = strstr (data, "+QIRD: ");
+	p = p + 7;
+	g_cat1Drv.rx_size = atoi (p);
+	if (g_cat1Drv.rx_size > 0) // 读取到数据
+	{
+		p = strstr (p, "\r\n");
+		p = p + 2;
+		for (int i = 0; i < g_cat1Drv.rx_size; i++)
+		{
+			g_cat1Drv.rxbuff[i] = *p;
+			p++;
+		}
+		rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_RX1) ;
+//		rt_kprintf("EVENT_TRIG_NETMODE_RX1\r\n");
+//		for(int i =0 ;i < g_cat1Drv.rx_size;i++)
+//		{
+//			rt_kprintf("%02X ",g_cat1Drv.rxbuff[i]);
+//		}
+	}
+
+}
+
+// type 0 无需打包 1 需要重新打包
+const struct
+{
+	char * cmd;
+	char * ack;
+	uint32_t delayms;
+	uint32_t waitms;
+	uint32_t retry;
+	void (*call) (char *, uint16_t);
+} cat1list[] =
+{
+	[ATE]    			= {"ATE0\r\n",								"OK",				10,		2000, 10,		NULL},
+	[ATI]    			= {"ATI\r\n",								"OK",				10,		2000, 3,		NULL},
+	[CPIN]   			= {"AT+CPIN?\r\n",							"+CPIN: READY",		10,		2000, 10,	NULL},
+//	[CREG]   			= {"AT+CREG?\r\n",							"+CREG: 0,1",		10,		2000, 30,	NULL},
+//	[CGREG]  			= {"AT+CGREG?\r\n",							"+CGREG: 0,1",		10,		2000, 30,	NULL},
+	[CGATT]  			= {"AT+CGATT?\r\n",							"+CGATT: 1",		10,		2000, 30,	NULL},
+	[CSQ] 	 			= {"AT+CSQ\r\n",							"+CSQ:",			10,		2000, 1,		ec200_resp_csq_callback},
+	[QLTS] 	 			= {"AT+QLTS=2\r\n",							"+QLTS:",			10,		2000, 1,		ec200_resp_qlts_callback},
+	[QCCID]  			= {"AT+QCCID\r\n",							"+QCCID:",			10,		2000, 1,		ec200_resp_iccid_callback},
+};
+
+
+
+static void cat1_rx_done (void)
+{
+	rt_event_send (gUartEvents, EVENT_UART_GSM_RX);
+//	for (int i = 0 ; i < g_GSMDrv.rx_size; i++)
+//	{
+//		rt_kprintf ("%c", g_GSMDrv.rx_buffer[i]);
+//	}
+
+//	MX_UART_Clear (&g_GSMDrv);
+}
+
+
+// cat1 发送数据
+//0 : 结束，下一个
+//1 : 运行中，下一个
+static CommRet_T cat1_sendcmd_and_responce (int time, char * tx, int size, char * ack, void (*call) (char *, uint16_t))
+{
+	MX_UART_Clear (&g_GSMDrv);
+	MX_UART_PutBuffer (&g_GSMDrv, tx, size);
+	//rt_kprintf ("%.*s", size, tx) ;
+	//timeout =  cat1list[i].waitms;
+	int timeout = time;
+	while (timeout--)
+	{
+		if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_GSM_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
+		{
+			//	rt_kprintf ("[%.*s]", g_GSMDrv.rx_size, g_GSMDrv.rx_buffer) ;
+			if (NULL != rt_strstr ( (char *) g_GSMDrv.rx_buffer, ack))
+			{
+				if (call != NULL)
+				{
+					call ( (char *)  g_GSMDrv.rx_buffer,  g_GSMDrv.rx_size)  ;
+				}
+				return RetSucc;   // 成功
+			}
+			MX_UART_Clear (&g_GSMDrv);
+		}
+		rt_thread_mdelay (1);
+	}
+	return RetErr; // 超时
+}
+
+
+
+
+static void thread_entry (void  * argument)
+{
+
+	char at_cmd[128] = {NULL};
+	char ipaddr[32] = {NULL};
+	int ipport;
+	char *p;
+	int retry = 0;
+
+	p = ef_get_env ("mqtt_addr");
+	rt_strncpy (ipaddr, p, rt_strlen (p));
+	p = ef_get_env ("mqtt_port");
+	ipport = atoi (p);
+	rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport);
+	g_GSMDrv.rxdone = cat1_rx_done;
+	g_GSMDrv.BaudRate = 115200;
+	// 启动4G 模块电源
+	// 拉高4G 模块复位
+	while (1)
+	{
+CAT1RST:
+		// 初始化串口,打开模块电源
+		g_cat1Drv.State = Init;
+		MX_UART_Init (&g_GSMDrv);
+		HAL_GPIO_WritePin (GSM_PW_GPIO_Port, GSM_PW_Pin, GPIO_PIN_RESET); // 关闭4G 模块电源
+		rt_thread_mdelay (3000);
+		HAL_GPIO_WritePin (GSM_PW_GPIO_Port, GSM_PW_Pin, GPIO_PIN_SET); // 开启4G
+		rt_thread_mdelay (100);
+		// 拉高模组复位
+		HAL_GPIO_WritePin (GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_RESET);
+		rt_thread_mdelay (100);
+		HAL_GPIO_WritePin (GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_SET);
+		rt_thread_mdelay (8000);
+		for (int i = 0; i < MAXSETP; i++)
+		{
+			retry =  cat1list[i].retry;
+			while (1)
+			{
+				if (cat1_sendcmd_and_responce (cat1list[i].waitms, cat1list[i].cmd, strlen (cat1list[i].cmd), cat1list[i].ack, cat1list[i].call) == RetSucc)
+				{
+					break;
+				}
+				else
+				{
+					retry--;
+					if (retry <=  0)
+					{
+						rt_kprintf ("Join Faild%d \r\n", i);
+						goto CAT1RST;
+					}
+				}
+			}
+		}
+		rt_kprintf ("Join Success \r\n");
+		rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport);
+		if (cat1_sendcmd_and_responce (15000, at_cmd, strlen (at_cmd), "+QIOPEN: 0,0", NULL) == RetSucc)
+		{
+			g_cat1Drv.State = Conn;
+			rt_kprintf ("Net is ready \r\n");
+		}
+		else
+		{
+			rt_kprintf ("Net is Error  \r\n");
+			goto CAT1RST;
+		}
+
+		while (1)
+		{
+			// 发送数据
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_TX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) // 需要发送数据
+			{
+				if (g_cat1Drv.txbuff != NULL)
+				{
+					rt_sprintf (at_cmd, "AT+QISEND=0,%d\r\n", g_cat1Drv.tx_size);
+					rt_thread_mdelay (10);
+					if (cat1_sendcmd_and_responce (1000, at_cmd, strlen (at_cmd), ">", NULL) != RetSucc)
+					{
+						rt_kprintf ("NET:+CME:ERROR QISEND\r\n");
+						goto CAT1RST;
+					}
+					if (cat1_sendcmd_and_responce (3000, g_cat1Drv.txbuff, g_cat1Drv.tx_size, "SEND OK", NULL) != RetSucc)
+					{
+						rt_kprintf ("NET:+CME:ERROR QPUSH\r\n");
+						goto CAT1RST;
+					}
+				}
+			}
+			// 读取数据
+			rt_thread_mdelay (300);
+			if (cat1_sendcmd_and_responce (1000, "AT+QIRD=0,1500\r\n", strlen ("AT+QIRD=0,1500\r\n"), "+QIRD:", ec200_resp_qird_callback) != RetSucc)
+			{
+				rt_kprintf ("NET:+CME:ERROR QIRD\r\n");
+				goto CAT1RST;
+			}
+		}
+		rt_thread_mdelay (3000);
+	}
+
+}
+
+
+void cat1_service_tx (char * buff, int size)
+{
+	rt_memcpy (g_cat1Drv.txbuff, buff, size);
+	g_cat1Drv.tx_size = size;
+	rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_TX1) ;
+}
+
+
+void CAT1ThreadStart (void)
+{
+	/* 创建线程1，名称是thread1，入口是thread1_entry */
+	rt_thread_init (&netapp_thread, "netapp_thread",
+	                thread_entry, RT_NULL,
+	                &thread_stack[0],
+	                sizeof (thread_stack),
+	                CAT1_THREAD_PRIORITY,  CAT1_THREAD_TIMESLICE);
+	rt_thread_startup (&netapp_thread);
+
+	return ;
+}

Board/network/cat1drv.h

@@ -0,0 +1,26 @@
+#ifndef _CAT1_DRV_H
+#define _CAT1_DRV_H
+
+
+// 定义CAT1 状态机器
+typedef enum
+{
+	ATE,
+	ATI,
+	CPIN,
+//	CREG,
+//	CGREG,
+	CGATT,
+	CSQ,
+	QLTS,
+	QCCID,
+	MAXSETP
+} EC200_SETUP_T;
+
+
+
+
+void cat1_service_tx (char * buff, int size);
+int cat1_is_connected (void);
+
+#endif

Board/network/dtu-board.c

@@ -7,11 +7,16 @@
 #include <rtthread.h>
 #include <string.h>
 #include "usart-board.h"
+#include <MQTTPacket.h>
+#include "transport.h"
+#include "netdrv.h"
+
+
 
 
 
 #if !defined(LOG_TAG)
-    #define LOG_TAG          "dtu"
+#define LOG_TAG          "dtu"
 #endif
 #include <elog.h>
 
@@ -19,64 +24,101 @@ ALIGN (RT_ALIGN_SIZE)
 static char thread_stack[2048];
 static struct rt_thread dtu_thread;
 
-static struct
+static char tx_buffer[512];
+static char rx_buffer[512];
+
+
+
+netDrv_t g_dtuDrv =
 {
-	uint32_t isConnected; // 连接成功
-
-} g_dtuDrv ;
+	0,          // 信号值
+	"",         // iccid
+	Init,       // 状态
+	tx_buffer, // 接受缓存
+	0,          // 接受数据长度
+	rx_buffer, // 发送数据缓存
+	0,          // 发送数据长度
+};
 
 
-
-static enum
+static void net_data_rxdone (void)
 {
-	netDrvInit = 0, // 初始化网络驱动
-	netDrvJoin = 1, // 等待网络注册成功
-	netDrvSend = 2, // 发送数据
-	netDrvRecv = 3, // 读取数据
-	netDrvIdle = 4, // 读取数据
-} eDrvStatus;
-
-
-
-static void net_data_rxdone(void) 
-{
-	rt_event_send(gUartEvents,EVENT_UART_ETH1_RX);
+	rt_event_send (gUartEvents, EVENT_UART_ETH1_RX);
 	//rt_kprintf("net_data_rxdone\r\n");
 }
 
 
 static void thread_entry (void  * argument)
 {
-//	eDrvStatus = netDrvInit;
 	rt_kprintf ("%s was start!\r\n", __FILE__);
-//	gnetEvents = rt_event_create("gnetEvents", RT_IPC_FLAG_FIFO)  ;
-
-	  /*Configure GPIO pin Output Level */
-
-	HAL_GPIO_WritePin(ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
-	HAL_GPIO_WritePin(ETH_PW_GPIO_Port, ETH_PW_Pin, GPIO_PIN_SET);    
 	g_ETH1Drv.rxdone =  net_data_rxdone;
-	MX_UART_Init(&g_ETH1Drv);
-
-//	// 注册网络驱动
-	// 注册网络驱动
+//	MX_UART_Init(&g_ETH1Drv);
 	while (1)
 	{
-		//MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8);
-		if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
+MODE_RST:
+		g_dtuDrv.State = Init;
+		MX_UART_Init (&g_ETH1Drv);
+		HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_RESET);
+		rt_thread_mdelay (1000);
+		HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
+		rt_thread_mdelay (1000);
+		HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin, GPIO_PIN_SET);
+		rt_thread_mdelay (8000);
+		g_dtuDrv.State = Conn;
+		while (1) // 判断是否链接成功
 		{
-			rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx1:\r\n");
-			for(int i =0; i < g_ETH1Drv.rx_size;i++)
+			// 准备要上报数据
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_TX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) //
 			{
-				rt_kprintf("%02X ",g_ETH1Drv.rx_buffer[i]);
+				//rt_kprintf("MODE_RST\r\n");
+				MX_UART_PutBuffer (&g_ETH1Drv, g_dtuDrv.txbuff, g_dtuDrv.tx_size);
+//				rt_kprintf("tx\r\n");
+//				for(int i =0; i <g_dtuDrv.tx_size;i++ )
+//				{
+//					rt_kprintf("%02X ",g_dtuDrv.txbuff[i]);
+//				}
+//				rt_kprintf("\r\n");
 			}
-			rt_kprintf("\r\n");
-			MX_UART_Clear(&g_ETH1Drv);
+			// 接受到数据
+			if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
+			{
+//				rt_kprintf ("ETH1Rx:%d\r\n", g_ETH1Drv.rx_size);
+//				for (int i = 0; i < g_ETH1Drv.rx_size; i++)
+//				{
+//					rt_kprintf ("%02X ", g_ETH1Drv.rx_buffer[i]);
+//				}
+//				rt_kprintf ("\r\n");
+				rt_memcpy (g_dtuDrv.rxbuff, g_ETH1Drv.rx_buffer, g_ETH1Drv.rx_size);
+				g_dtuDrv.rx_size =   g_ETH1Drv.rx_size;
+				rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_RX1) ;
+				MX_UART_Clear (&g_ETH1Drv) ;
+			}
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RST, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL))
+			{
+				goto MODE_RST;
+			}
+			rt_thread_delay (100);
+			// 读取IO 状态
 		}
-		
-		
-		rt_thread_delay (100);
+
 	}
+
+
+
+}
+
+
+
+void dtu_service_tx (char * buff, int size)
+{
+	rt_memcpy (g_dtuDrv.txbuff, buff, size);
+	g_dtuDrv.tx_size = size;
+	rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_TX1) ;
+}
+
+void dtu_netreset (void)
+{
+	rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_RST) ;
 }
 
 void DTUThreadStart (void)
@@ -88,7 +130,6 @@ void DTUThreadStart (void)
 	                sizeof (thread_stack),
 	                DTU_THREAD_PRIORITY,  DTU_THREAD_TIMESLICE);
 	rt_thread_startup (&dtu_thread);
-
 	return ;
 }
 

Board/network/dtu-board.h

@@ -1,9 +1,13 @@
 #ifndef _DTU_BOARD_H
 #define _DTU_BOARD_H
 
-typedef struct  {
-	
-}
 
 
-#endif 
+
+void dtu_service_tx (char * buff, int size);
+void dtu_netreset (void);
+
+
+#endif
+
+

Board/network/dtu2-board.c

@@ -11,7 +11,7 @@
 
 
 #if !defined(LOG_TAG)
-    #define LOG_TAG          "dtu2"
+#define LOG_TAG          "dtu2"
 #endif
 #include <elog.h>
 
@@ -39,9 +39,9 @@ static enum
 
 
 
-static void net_data_rxdone(void) 
+static void net_data_rxdone (void)
 {
-	rt_event_send(gUartEvents,EVENT_UART_ETH2_RX);
+	rt_event_send (gUartEvents, EVENT_UART_ETH2_RX);
 	//rt_kprintf("net_data_rxdone\r\n");
 }
 
@@ -51,32 +51,32 @@ static void thread_entry (void  * argument)
 	rt_kprintf ("%s was start!\r\n", __FILE__);
 
 	g_ETH2Drv.rxdone =  net_data_rxdone;
-	MX_UART_Init(&g_ETH2Drv);
+	MX_UART_Init (&g_ETH2Drv);
 //	// 注册网络驱动
 	// 注册网络驱动
 	while (1)
 	{
 		//MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8);
-		if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
+		if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL))
 		{
-			rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx1:\r\n");
-			for(int i =0; i < g_ETH1Drv.rx_size;i++)
+			rt_kprintf ("<<<<<<<<<<<<<<<<<<<<rx1:\r\n");
+			for (int i = 0; i < g_ETH1Drv.rx_size; i++)
 			{
-				rt_kprintf("%02X ",g_ETH1Drv.rx_buffer[i]);
+				rt_kprintf ("%02X ", g_ETH1Drv.rx_buffer[i]);
 			}
-			rt_kprintf("\r\n");
-			MX_UART_Clear(&g_ETH1Drv);
+			rt_kprintf ("\r\n");
+			MX_UART_Clear (&g_ETH1Drv);
 		}
-		
-		if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH2_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
+
+		if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH2_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL))
 		{
-			rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx2:\r\n");
-			for(int i =0; i < g_ETH2Drv.rx_size;i++)
+			rt_kprintf ("<<<<<<<<<<<<<<<<<<<<rx2:\r\n");
+			for (int i = 0; i < g_ETH2Drv.rx_size; i++)
 			{
-				rt_kprintf("%02X ",g_ETH2Drv.rx_buffer[i]);
+				rt_kprintf ("%02X ", g_ETH2Drv.rx_buffer[i]);
 			}
-			rt_kprintf("\r\n");
-			MX_UART_Clear(&g_ETH2Drv);
+			rt_kprintf ("\r\n");
+			MX_UART_Clear (&g_ETH2Drv);
 		}
 		rt_thread_delay (100);
 	}

Board/network/dtu2-board.h

@@ -1,9 +1,10 @@
 #ifndef _DTU_BOARD_H
 #define _DTU_BOARD_H
 
-typedef struct  {
-	
+typedef struct
+{
+
 }
 
 
-#endif 
+#endif

Board/network/jsonpacket.c

@@ -0,0 +1,237 @@
+#include "jsonpacket.h"
+#include "cjson.h"
+#include <string.h>
+#include <rtthread.h>
+#include "data.h"
+#include <easyflash.h>
+#include <stdlib.h>
+
+#define PROTO_VER      "FF_V3.0"
+
+extern char config_list[16][32];
+extern int config_list_size;
+
+
+// 5 分钟流量站数据上报
+int Json5MinFlowDataPacket (uint8_t * buffer)
+{
+	char *result, * packMsg = (char *) buffer;
+	cJSON  *root = NULL;
+	double dbl[6] = {3.14, 3.12, 3.33, 3.20, 3.12, 3.20};
+	int length;
+	char * p;
+	root = cJSON_CreateObject();
+	cJSON_AddItemToObject (root, "func", cJSON_CreateString ("stand"));    // 功能码
+	p = ef_get_env ("site_type");
+	cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p));     	// 表示流量计
+	cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER));     // 表示流量计
+	cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid));     // 表示流量计
+	cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION));     // 表示流量计
+	cJSON_AddItemToObject (root, "vol", cJSON_CreateNumber (12.3));        // 表示电池电压
+	cJSON_AddItemToObject (root, "temp", cJSON_CreateNumber (32.5));     // 表示流量计
+	p = ef_get_env ("net_drv");
+	cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p));     // 表示流量计
+	p = ef_get_env ("iap_app_filename");
+	//uint32_t max_open = atoi (p);
+	cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p));        // 表示电池电压
+	cJSON_AddItemToObject (root, "chancnt", cJSON_CreateNumber (1));        // 表示电池电压
+	//cJSON_AddItemToObject (root, "chancnt", cJSON_CreateNumber (1));        // 表示电池电压
+	// 瞬时流速
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].thisSpeed;
+	}
+	cJSON * ArrNumSpeed = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "thisspeed", ArrNumSpeed);
+
+	// 瞬时流量
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].thisFlow;
+	}
+	cJSON * ArrNumFlow = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "thisflow", ArrNumFlow);
+
+	// 累计流量
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].ttWater;
+	}
+	cJSON * ArrNumTtflow = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "ttflow", ArrNumTtflow);
+
+	// 当前水位
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].thisLevel;
+	}
+	cJSON * ArrNumLeve = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "thisLeve", ArrNumLeve);
+	// 当前压力
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].thisPress;
+	}
+	cJSON * ArrNumPress = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "thispress", ArrNumPress);
+
+	// 当前温度
+	for (int i = 0; i < 6; i++)
+	{
+		dbl[i] = WaterData[i].ttWater;
+	}
+	cJSON * ArrNumTemp = cJSON_CreateDoubleArray (dbl, 6);
+	cJSON_AddItemToObject (root, "thistemp", ArrNumTemp);
+
+	//---------------------------------------------以下不准修改
+	result = cJSON_PrintUnformatted (root);
+	strcpy (packMsg, result);
+	cJSON_free (result);
+	cJSON_Delete (root);
+	length = rt_strlen (packMsg);
+	return length;
+}
+// 5分钟闸门站数据上报
+int JsonRegistDataPacket (uint8_t * buffer)
+{
+	char *result, * packMsg = (char *) buffer;
+	cJSON  *root = NULL;
+	char * p;
+	int length;
+	root = cJSON_CreateObject();
+	cJSON_AddItemToObject (root, "func", cJSON_CreateString ("regist"));    // 功能码
+	p = ef_get_env ("site_type");
+	cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p));     	// 表示流量计
+	cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER));     // 表示流量计
+	cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid));     // 表示流量计
+	cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION));     // 表示流量计
+	p = ef_get_env ("net_drv");
+	cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p));     // 表示流量计
+	p = ef_get_env ("iap_app_filename");
+	//uint32_t max_open = atoi (p);
+	cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p));        // 表示电池电压
+
+	//---------------------------------------------以下不准修改
+	result = cJSON_PrintUnformatted (root);
+	strcpy (packMsg, result);
+	cJSON_free (result);
+	cJSON_Delete (root);
+	length = rt_strlen (packMsg);
+	return length;
+}
+
+
+// 5分钟闸门站数据上报
+int Json5MinSluiceDataPacket (uint8_t * buffer)
+{
+	char *result, * packMsg = (char *) buffer;
+	cJSON  *root = NULL;
+	char * p;
+	int length;
+	root = cJSON_CreateObject();
+	cJSON_AddItemToObject (root, "func", cJSON_CreateString ("stand"));    // 功能码
+	p = ef_get_env ("site_type");
+	cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p));     	// 表示流量计
+	cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER));     // 表示流量计
+	cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid));     // 表示流量计
+	cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION));     // 表示流量计
+	p = ef_get_env ("net_drv");
+	cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p));     // 表示流量计
+	p = ef_get_env ("iap_app_filename");
+	//uint32_t max_open = atoi (p);
+	cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p));        // 表示电池电压
+
+	// 添加闸门相关数据
+	// 闸门当前开度
+	cJSON_AddItemToObject (root, "thisopen", cJSON_CreateNumber (SluiceData[0].gopen));        // 表示电池电压
+	// 闸门最大开度
+	p = ef_get_env ("max_open");
+	uint32_t max_open = atoi (p);
+	cJSON_AddItemToObject (root, "maxopen", cJSON_CreateNumber (max_open));
+	// 闸门A路荷重
+	cJSON_AddItemToObject (root, "aload", cJSON_CreateNumber (SluiceData[0].lload));
+	// 闸门B路荷重
+	cJSON_AddItemToObject (root, "bload", cJSON_CreateNumber (SluiceData[0].rload));
+	// 闸前水位
+	cJSON_AddItemToObject (root, "thisleve", cJSON_CreateNumber (WaterData[0].thisLevel));
+	// 闸门瞬时流速
+	cJSON_AddItemToObject (root, "thisspeed", cJSON_CreateNumber (WaterData[0].thisSpeed));
+	// 闸门累计流量
+	cJSON_AddItemToObject (root, "thisflow", cJSON_CreateNumber (WaterData[0].thisFlow));
+	// 闸门瞬时流量
+	cJSON_AddItemToObject (root, "ttflow", cJSON_CreateNumber (WaterData[0].ttWater));
+	// 闸门启动电流
+	cJSON_AddItemToObject (root, "current", cJSON_CreateNumber (SluiceData[0].currt));
+	// 闸门编码器最大值
+	p = ef_get_env ("max_ecode");
+	uint32_t max_code = atoi (p);
+
+	cJSON_AddItemToObject (root, "maxecode", cJSON_CreateNumber (max_code));
+	p = ef_get_env ("min_ecode");
+	uint32_t min_code = atoi (p);
+	// 闸门编码器最小值
+	cJSON_AddItemToObject (root, "minecode", cJSON_CreateNumber (min_code));
+	//---------------------------------------------以下不准修改
+	result = cJSON_PrintUnformatted (root);
+	strcpy (packMsg, result);
+	cJSON_free (result);
+	cJSON_Delete (root);
+	length = rt_strlen (packMsg);
+	return length;
+}
+
+// 心跳包，需要应答
+int JsonHeartDatapacket (uint8_t * buffer)
+{
+	char *result, * packMsg = (char *) buffer;
+	cJSON  *root = NULL;
+	int length;
+	char *p;
+	root = cJSON_CreateObject();
+	cJSON_AddItemToObject (root, "func", cJSON_CreateString ("heart"));    // 功能码
+	p = ef_get_env ("site_type");
+	cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p));     	// 表示流量计
+	cJSON_AddItemToObject (root, "ecdState", cJSON_CreateNumber (SysData.ecdState));     	// 编码器状态
+	cJSON_AddItemToObject (root, "flowState", cJSON_CreateNumber (SysData.flowState));     	// 流量计状态
+	cJSON_AddItemToObject (root, "ldState", cJSON_CreateNumber (SysData.ldState));     		// 荷重仪状态
+	cJSON_AddItemToObject (root, "scram", cJSON_CreateNumber (SysData.scram));     		// 荷重仪状态
+	//---------------------------------------------以下不准修改
+	result = cJSON_PrintUnformatted (root);
+	strcpy (packMsg, result);
+	cJSON_free (result);
+	cJSON_Delete (root);
+	length = rt_strlen (packMsg);
+	return length;
+}
+
+
+int JsonConfigReadDataPacket(uint8_t* buffer)
+{
+	char *result, * packMsg = (char *) buffer;
+	cJSON  *root = NULL;
+	int length;
+	char *p;
+	root = cJSON_CreateObject();
+	cJSON_AddItemToObject (root, "func", cJSON_CreateString ("read_config"));    // 功能码
+	p = ef_get_env ("site_type");
+	cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p));     	// 表示流量计
+
+	for (int i =0 ;i < config_list_size;i++)
+	{
+		p = ef_get_env (config_list[i]);
+		cJSON_AddItemToObject (root, config_list[i], cJSON_CreateString (p));     	// 表示流量计
+	}
+	//---------------------------------------------以下不准修改
+	result = cJSON_PrintUnformatted (root);
+	strcpy (packMsg, result);
+	cJSON_free (result);
+	cJSON_Delete (root);
+	length = rt_strlen (packMsg);
+	return length;
+}
+
+int JsonAckSuccPacket(char * buffer)
+{
+	rt_sprintf(buffer,"{\"state\":\"ok\"}");
+}
+

Board/network/jsonpacket.h

@@ -0,0 +1,18 @@
+#ifndef _JSON_PACKET_H
+#define _JSON_PACKET_H
+#include <stdint.h>
+
+
+// 5 分钟数据上报
+int Json5MinFlowDataPacket (uint8_t * buffer);
+
+// 注册包数据  需要应答
+int JsonRegistDataPacket (uint8_t * buffer);
+// 心跳包，需要应答
+int JsonHeartDatapacket (uint8_t * buffer);
+
+int Json5MinSluiceDataPacket (uint8_t * buffer);
+
+int JsonConfigReadDataPacket(uint8_t* buffer);
+int JsonAckSuccPacket(char * buffer);
+#endif

Board/network/jsonunpack.c

@@ -0,0 +1,106 @@
+#include "jsonunpack.h"
+#include "cjson.h"
+#include <string.h>
+#include <rtthread.h>
+#include "data.h"
+#include <easyflash.h>
+#include <stdlib.h>
+#include "data.h"
+#include "os-app.h"
+
+char config_list[16][32] = {NULL};
+int config_list_size  = 0;
+
+
+
+void JsonUnPacket (int index, char *buff)
+{
+	// 读取Json 数据类型
+	char * packMsg = (char *) buff;
+	cJSON  *root = NULL, *list = NULL;
+	root = cJSON_Parse (packMsg);
+	DownDataType_t type = (DownDataType_t) 0;
+	char * p, *key, *value;
+	int list_size;
+	TypeIndexMail_t mail;
+	p = cJSON_GetStringValue (cJSON_GetObjectItem (root, "type"));
+	type = (DownDataType_t) cDownType2Index (p);
+	rt_kprintf("down :%s<%d>\r\n",p,type);
+	switch (type)
+	{
+	case  DownRun		:  // 开度提闸
+
+//				rt_kprintf ("open:%u mm/10\r\n", datak);
+
+//				//SluiceData[gMqttDrv.rx_index].opt = 1; // 执行操作闸门
+//				SluiceData[gMqttDrv.rx_index - 1].sopen = datak / 10;
+//				mail.Type = MAIL_SLUICE_OPT;
+//				mail.index = gMqttDrv.rx_index - 1;
+//				rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail));
+
+//				// 回复应答
+//				mail.Type = MAIL_COMM_SLACK;
+//				mail.index = gMqttDrv.rx_index;
+//				rt_mb_send (gTCommMail, * ( (uint32_t*) &mail));
+		break;
+	case  DownStop		:
+		break;
+	case  DownOpen		:
+		break;
+	case  DownClose		:
+		break;
+	case  DownRegistAns	:
+		break;
+	case  DownHeartAns	:
+		break;
+	case  DownUpdate	:
+		rt_memset (SysData.fileName, 0, 32);
+		p = cJSON_GetStringValue (cJSON_GetObjectItem (root, "file"));
+		rt_sprintf (SysData.fileName, "%s", p) ;
+		// 启动升级线程
+		// 回复应答
+		mail.Type = MAIL_COMM_UPACK;
+		mail.index = index + 1; // 0通道用来升级的通道
+		rt_mb_send (gTCommMail, * ( (uint32_t*) &mail));
+		rt_thread_mdelay (2000);  // 等待2s 进入升级线程
+		UpgradeThreadStart();
+		break;
+	case  DownReboot	:
+		break;
+	case DownConfig: // 设置参数
+		// 读取参数列表
+		list = cJSON_GetObjectItem (root, "list");
+		list_size = cJSON_GetArraySize (list);
+		for (int i = 0; i < list_size; i++)
+		{
+			key = cJSON_GetStringValue (cJSON_GetArrayItem (list, i));
+			value = cJSON_GetStringValue (cJSON_GetObjectItem (root, key));
+			if ( (ef_get_env (key) != NULL) && (value != NULL))
+			{
+				ef_set_env (key, value);
+			}
+		}
+		break;
+	case DownRead:    // 读取参数
+		list = cJSON_GetObjectItem (root, "list");
+		config_list_size = cJSON_GetArraySize (list);
+		for (int i = 0; i < config_list_size; i++)
+		{
+			key = cJSON_GetStringValue (cJSON_GetArrayItem (list, i));
+			rt_sprintf(config_list[i],"%s",key);
+		}
+		mail.Type = MAIL_COMM_READPARA;
+		mail.index = index + 1; // 0通道用来升级的通道
+		rt_mb_send (gTCommMail, * ( (uint32_t*) &mail));
+		// 读取参数列表
+		break;
+	default:
+		break;
+	}
+	cJSON_Delete (root);
+}
+
+
+
+
+

Board/network/jsonunpack.h

@@ -0,0 +1,9 @@
+#ifndef _JSON_UNPACKET_H
+#define _JSON_UNPACKET_H
+#include <stdint.h>
+
+
+
+
+void JsonUnPacket (int index, char *buff);
+#endif

Board/network/mje1s2fdrv.c

@@ -0,0 +1,114 @@
+#include <cat1drv.h>
+#include <rtthread.h>
+#include <os-app.h>
+#include "main.h"
+#include "usart-board.h"
+#include <string.h>
+#include <stdlib.h>
+#include <easyflash.h>
+#include "netdrv.h"
+
+
+
+
+
+
+#if !defined(LOG_TAG)
+#define LOG_TAG          "MJE1S2"
+#endif
+#include <elog.h>
+
+
+ALIGN (RT_ALIGN_SIZE)
+static char thread_stack[4096];
+static struct rt_thread thread;
+static char tcprxbbuff[1200];
+static char tcptxbbuff[1200];
+
+
+
+netDrv_t g_MJEth1Drv =
+{
+	0,          // 信号值
+	"",         // iccid
+	Init,       // 状态
+	tcprxbbuff, // 接受缓存
+	0,          // 接受数据长度
+	tcptxbbuff, // 发送数据缓存
+	0,          // 发送数据长度
+};
+
+
+static void mje1s2f_rx_done (void)
+{
+	rt_event_send (gUartEvents, EVENT_UART_ETH1_RX);
+
+}
+
+
+
+
+
+static void thread_entry (void  * argument)
+{
+
+
+
+	uint8_t low_leve = 0; // 高电平时间
+	g_ETH1Drv.rxdone = mje1s2f_rx_done;
+	g_ETH1Drv.BaudRate = 115200;
+	// 启动4G 模块电源
+	// 拉高4G 模块复位
+	MX_UART_Init (&g_ETH1Drv);
+	HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
+	rt_thread_mdelay (1000);
+	HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET);
+	rt_thread_mdelay (3000);
+	while (1)
+	{
+MODE_RST:
+		MX_UART_Init (&g_ETH1Drv);
+		HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
+		rt_thread_mdelay (1000);
+		HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET);
+		rt_thread_mdelay (3000);
+		while (1) // 判断是否链接成功
+		{
+
+		}
+
+////	rt_kprintf("zs0010+++++++++++++++++++\r\n");
+//		MX_UART_PutBuffer(&g_ETH1Drv,(char *)readip,13) ;
+//
+		// 发送数据
+		if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 2000, RT_NULL)) // 需要发送数据
+		{
+			for (int i = 0 ; i < g_ETH1Drv.rx_size; i++)
+			{
+				rt_kprintf ("%02X", g_ETH1Drv.rx_buffer[i]);
+			}
+			rt_kprintf ("\r\n");
+			MX_UART_Clear (&g_ETH1Drv) ;
+		}
+
+		rt_thread_mdelay (10);
+	}
+
+}
+
+
+
+
+
+void MJEth1ThreadStart (void)
+{
+	/* 创建线程1，名称是thread1，入口是thread1_entry */
+	rt_thread_init (&thread, "mjeth1_thread",
+	                thread_entry, RT_NULL,
+	                &thread_stack[0],
+	                sizeof (thread_stack),
+	                MJETH1_THREAD_PRIORITY,  MJETH1_THREAD_TIMESLICE);
+	rt_thread_startup (&thread);
+
+	return ;
+}

Board/network/mje1s2fdrv.h

@@ -0,0 +1,12 @@
+#ifndef _MJETH1_DRV_H
+#define _MJETH1_DRV_H
+
+
+
+
+
+
+
+
+
+#endif

Board/network/mqtt-board.c

@@ -0,0 +1,323 @@
+
+#include "main.h"
+
+#include "os-app.h"
+
+#include <stdio.h>
+#include <rtthread.h>
+#include <string.h>
+#include "usart-board.h"
+#include <MQTTPacket.h>
+#include "transport.h"
+#include <easyflash.h>
+#include "mqtt-board.h"
+#include "netdrv.h"
+#include "stdlib.h"
+#include "data.h"
+
+
+
+
+#if !defined(LOG_TAG)
+#define LOG_TAG          "mqtt"
+#endif
+#include <elog.h>
+
+ALIGN (RT_ALIGN_SIZE)
+static char thread_stack[2048];
+static struct rt_thread mqtt_thread;
+
+
+
+
+
+
+static rt_timer_t timer;
+
+static char  mqtt_tx_buff[500];
+static char  mqtt_rx_buff[500];
+
+
+
+static enum {CONN = 1, DISC = 0} State = DISC;
+MqttDrv_t  gMqttDrv =
+{
+	.State = DISC,
+	.txbuff = mqtt_tx_buff,
+	.tx_size = 0,
+	.tx_index = 0,
+	.rxbuff = mqtt_rx_buff,
+	.rx_size = 0,
+	.rx_index = 0
+};
+
+
+
+// 定义mqtt 的数据存储buffer
+#define MQTT_BUFF_LENGTH   1500
+static uint8_t mqtt_buffer[MQTT_BUFF_LENGTH];
+
+//static uint8_t mqtt_payload[1200];
+//// 定义mqtt消息的 数据长度
+//static int mqtt_payload_size = 0;
+// 定义mqtt消息的 数据长度
+static int mqtt_buflen = 0;
+// 定义qos
+static int qos[SUBTOPIC_COUNT + 1] = {0};
+// 定义message id
+static int message_id = 0;
+
+// 定义mqtt 链接参数
+MQTTPacket_connectData connectData  = MQTTPacket_connectData_initializer;
+MQTTString subtopic[SUBTOPIC_COUNT + 1]    = {MQTTString_initializer};
+MQTTString pubtopic[SUBTOPIC_COUNT + 1]    = {MQTTString_initializer};
+char sub_topic_str[SUBTOPIC_COUNT + 1][64] = {NULL};
+char pub_topic_str[SUBTOPIC_COUNT + 1][64] = {NULL};
+char client_id_str[64] = {NULL};
+
+
+static char device_id[32] = {NULL}; 	// 设备编码
+static char user_topic[32] = {NULL};	// topic
+
+static void net_data_rxdone (void)
+{
+	rt_event_send (gUartEvents, EVENT_UART_ETH1_RX);
+}
+
+static int timerout_timer = 0;
+static void timerouter (void * parameter)
+{
+	timerout_timer ++;
+	if (timerout_timer > 90)   // 超过90s 没有收到数据，重启网络
+	{
+		rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_RST);
+		timerout_timer = 0;
+	}
+}
+
+
+static void thread_entry (void  * argument)
+{
+
+	int count = 0;
+	// 初始化串口驱动
+	rt_kprintf ("%s was start!\r\n", __FILE__);
+	timer = rt_timer_create ("timer", timerouter, RT_NULL, 1000, RT_TIMER_FLAG_PERIODIC); // 异常检测定时器
+	// 读取配置文件
+	char * p = ef_get_env ("device_id");
+	rt_sprintf (device_id, "%s", p);
+	p = ef_get_env ("mqtt_topic");
+	rt_memcpy (user_topic, p, strlen (p));
+
+	int id =  rand() % 1000;
+	rt_sprintf (client_id_str, "GID_SLUICE_V2_220000%s", device_id) ;
+	rt_kprintf ("clinet:%s\r\n", client_id_str);
+	connectData.clientID.cstring = client_id_str;
+	connectData.keepAliveInterval = 120;
+	connectData.cleansession = 1;
+	connectData.username.cstring = "admin";
+	connectData.password.cstring = "admin";
+	rt_sprintf (sub_topic_str[0], "device/%s/tx/220000%s", "update", device_id);
+	rt_sprintf (pub_topic_str[0], "device/%s/rx/220000%s", "update", device_id);
+	// 读取设备编码
+	rt_sprintf (sub_topic_str[1], "device/%s/tx/220000%s", user_topic, device_id);
+	rt_sprintf (pub_topic_str[1], "device/%s/rx/220000%s", user_topic, device_id);
+#if (SUBTOPIC_COUNT > 1)
+	rt_sprintf (sub_topic_str[2], "device/%s/tx/2200002308170002", user_topic);
+	rt_sprintf (pub_topic_str[2], "device/%s/rx/2200002308170002", user_topic);
+#endif
+
+	for (int i = 0; i < SUBTOPIC_COUNT + 1; i++)
+	{
+		subtopic[i].cstring = sub_topic_str[i];
+		pubtopic[i].cstring = pub_topic_str[i];
+	}
+
+	rt_timer_start (timer);
+	while (1)
+	{
+MQTTINIT:
+		if (g_netDrv->State != Conn)
+		{
+			//rt_kprintf ("mqtt tcp-connected fail\r\n");
+			rt_thread_delay (1000); // 延迟3s 等待模块连接TCP 服务成功
+			goto MQTTINIT;
+		}
+		// 链接MQTT 服务器
+		rt_kprintf ("mqtt connected\r\n");
+		mqtt_buflen = MQTTSerialize_connect (mqtt_buffer, MQTT_BUFF_LENGTH, &connectData);
+		netdrv_service_tx (mqtt_buffer, mqtt_buflen);
+		if (RT_EOK != rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 10000, RT_NULL))
+		{
+			goto MQTTINIT;
+		}
+		rt_thread_mdelay (10);
+		if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == CONNACK)
+		{
+			unsigned char sessionPresent, connack_rc;
+			if (MQTTDeserialize_connack (&sessionPresent, &connack_rc, mqtt_buffer, MQTT_BUFF_LENGTH) != 1 || connack_rc != 0)
+			{
+				rt_kprintf ("Unable to connect, return code %d\n", connack_rc);
+				rt_thread_delay (3000);
+				netdrv_clear();
+				goto MQTTINIT;
+			}
+		}
+		else
+		{
+			rt_kprintf ("mqtt error");
+			netdrv_clear();
+			goto MQTTINIT;
+		}
+		netdrv_clear();
+		rt_kprintf ("connect to mqtt successful\n");
+		// 订阅topic
+		mqtt_buflen = MQTTSerialize_subscribe (mqtt_buffer, MQTT_BUFF_LENGTH, 0, message_id++, SUBTOPIC_COUNT + 1, subtopic, qos);
+		netdrv_service_tx (mqtt_buffer, mqtt_buflen);
+		if (RT_EOK != rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 10000, RT_NULL))
+		{
+			netdrv_clear();
+			goto MQTTINIT;
+		}
+		if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == SUBACK) /* wait for suback */
+		{
+			unsigned short submsgid;
+			int subcount;
+			int granted_qos;
+			MQTTDeserialize_suback (&submsgid, 1, &subcount, &granted_qos, mqtt_buffer, MQTT_BUFF_LENGTH);
+			if (granted_qos != 0)
+			{
+				rt_kprintf ("granted qos != 0, %d\n", granted_qos);
+				netdrv_clear();
+				goto MQTTINIT;
+			}
+		}
+		else
+		{
+			rt_kprintf ("sub topic faild\r\n");
+			rt_thread_delay (1000);
+			netdrv_clear();
+			goto MQTTINIT;
+		}
+		netdrv_clear();
+
+		rt_kprintf ("subtopic topic %s\r\n", subtopic[0].cstring);
+		rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_SUB);
+		netdrv_clear();
+		rt_thread_delay (500);
+		State = CONN;
+		while (1)
+		{
+			// 接受到数据
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
+			{
+				if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == PUBLISH)
+				{
+
+					unsigned char dup;
+					int qos;
+					unsigned char retained;
+					unsigned short msgid;
+					int payloadlen_in;
+					unsigned char* payload_in;
+					int rc;
+					MQTTString receivedTopic;
+					rc = MQTTDeserialize_publish (&dup, &qos, &retained, &msgid, &receivedTopic,
+					                              &payload_in, &payloadlen_in, mqtt_buffer, MQTT_BUFF_LENGTH);
+					rt_memcpy (gMqttDrv.rxbuff, payload_in, payloadlen_in) ;
+					gMqttDrv.rx_size = payloadlen_in;
+					//rt_memcpy(gMqttDrv.topic,receivedTopic.lenstring.data,receivedTopic.lenstring.len);
+
+
+					for (int var = 0; var < SUBTOPIC_COUNT + 1; ++var)
+					{
+						if (rt_memcmp (subtopic[var].cstring, receivedTopic.lenstring.data, receivedTopic.lenstring.len) == 0)
+						{
+							gMqttDrv.rx_index = var;
+							rt_kprintf ("recv from :%d,%*.s\r\n", gMqttDrv.rx_index, receivedTopic.lenstring.len, receivedTopic.lenstring.data);
+							break;
+						}
+					}
+					if (gMqttDrv.rx_index == 0) // 0 通道为升级通道
+					{
+						rt_event_send (gTrigEvents, EVENT_TRIG_UPGRADE_RX);
+					}
+					else
+					{
+						rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RX);
+					}
+					timerout_timer = 0;
+				}
+				netdrv_clear();
+			}
+			// 发送数据
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_MQTT_TX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
+			{
+				mqtt_buflen = MQTTSerialize_publish (mqtt_buffer, MQTT_BUFF_LENGTH, 0, 0, 0, 0, pubtopic[gMqttDrv.tx_index], (uint8_t *) gMqttDrv.txbuff, gMqttDrv.tx_size);
+				netdrv_service_tx (mqtt_buffer, mqtt_buflen);
+			}
+			if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_MQTT_RST, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
+			{
+				rt_kprintf ("mqtt conn lost\r\n");
+				netdrv_reset();
+				State = DISC;
+				rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RST);
+				goto MQTTINIT;
+			}
+			// 网络链接丢失
+			if (g_netDrv->State != Conn)
+			{
+				rt_kprintf ("mqtt conn lost\r\n");
+				netdrv_reset();
+				State = DISC;
+				rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RST);
+				goto MQTTINIT;
+			}
+			rt_thread_delay (100);
+		}
+	}
+
+}
+
+
+
+void MQTT_SendData (void)
+{
+
+//	topic_index = index;
+////	rt_memcpy(mqtt_payload,data,size);
+////	mqtt_payload_size = size ;
+	rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_TX);
+}
+int MQTT_Subscribed (void)
+{
+	return State;
+}
+
+
+void MQTTThreadStart (void)
+{
+	/* 创建线程1，名称是thread1，入口是thread1_entry*/
+	rt_thread_init (&mqtt_thread, "mqtt_thread",
+	                thread_entry, RT_NULL,
+	                &thread_stack[0],
+	                sizeof (thread_stack),
+	                MQTT_THREAD_PRIORITY,  MQTT_THREAD_TIMESLICE);
+	rt_thread_startup (&mqtt_thread);
+
+	return ;
+}
+
+
+
+
+void shell_mqtt_time (void)
+{
+	rt_kprintf ("lost_timer:%u\r\n", timerout_timer) ;
+}
+
+
+
+
+
+

Board/network/mqtt-board.h

@@ -0,0 +1,22 @@
+#ifndef _MQTT__BOARD_H
+#define _MQTT__BOARD_H
+
+
+
+void MQTTThreadStart (void);
+void MQTT_SendData (void);
+int MQTT_Subscribed (void);
+
+
+typedef struct MqttDrv_t
+{
+	int State; // 订阅成功
+	char * txbuff;
+	int tx_size;
+	uint8_t tx_index;
+	char * rxbuff;
+	int rx_size;
+	uint8_t rx_index;// 接受数据的订阅
+} MqttDrv_t;
+
+#endif

Board/network/netdrv.c

@@ -0,0 +1,161 @@
+#include <cat1drv.h>
+#include <rtthread.h>
+#include <os-app.h>
+#include "main.h"
+#include "usart-board.h"
+#include <string.h>
+#include <stdlib.h>
+#include <easyflash.h>
+#include "netdrv.h"
+#include "dtu-board.h"
+
+extern netDrv_t g_cat1Drv;
+extern netDrv_t g_MJEth1Drv;
+extern netDrv_t g_dtuDrv;
+
+
+netDrv_t * g_netDrv;
+
+
+static int mysock = 0;
+static int offset = 0;
+
+
+
+void netdrv_init (void)
+{
+	char * drv =  ef_get_env ("net_drv"); // 读取网络类型
+	if (rt_memcmp ("dtu", drv, 3) == 0) // 驱动程序位DTU模式，就是不通过本地配置，直接透传
+	{
+		g_netDrv = &g_dtuDrv;
+		DTUThreadStart();
+	}
+	else if (rt_memcmp ("ec200", drv, 4) == 0)
+	{
+		g_netDrv = &g_cat1Drv;
+
+		CAT1ThreadStart();
+	}
+//	else if (rt_memcmp ("eth", drv, 3) == 0)
+//	{
+//		g_netDrv = &g_MJEth1Drv;
+//		MJEth1ThreadStart();
+//	}
+	else
+	{
+
+	}
+}
+
+
+void netdrv_service_tx (uint8_t * data, int length)
+{
+	char * drv =  ef_get_env ("net_drv"); // 读取网络类型
+	if (rt_memcmp ("dtu", drv, 3) == 0) // 驱动程序位DTU模式，就是不通过本地配置，直接透传
+	{
+		dtu_service_tx ( (char *) data, length);
+	}
+	else if (rt_memcmp ("ec200", drv, 4) == 0)
+	{
+		cat1_service_tx ( (char *) data, length);
+	}
+	else if (rt_memcmp ("eth", drv, 3) == 0)
+	{
+
+	}
+	else
+	{
+
+	}
+}
+
+void netdrv_reset (void)
+{
+	char * drv =  ef_get_env ("net_drv"); // 读取网络类型
+	if (rt_memcmp ("dtu", drv, 3) == 0) // 驱动程序位DTU模式，就是不通过本地配置，直接透传
+	{
+		dtu_netreset();
+	}
+	else if (rt_memcmp ("ec200", drv, 4) == 0)
+	{
+		//cat1_service_tx ( (char *) data, length);
+	}
+	else if (rt_memcmp ("eth", drv, 3) == 0)
+	{
+
+	}
+	else
+	{
+
+	}
+}
+
+
+int netdrv_getdata (unsigned char* buf, int count)
+{
+	int tsize = 0;
+	char * drv =  ef_get_env ("net_drv"); // 读取网络类型
+	if (rt_memcmp ("dtu", drv, 3) == 0) // 驱动程序位DTU模式，就是不通过本地配置，直接透传
+	{
+		if (offset + count > g_netDrv->rx_size)
+		{
+			tsize = g_netDrv->rx_size - offset;
+			rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize);
+		}
+		else
+		{
+			tsize = count;
+			rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize);
+		}
+
+	}
+	else if (rt_memcmp ("ec200", drv, 4) == 0)
+	{
+		if (offset + count > g_netDrv->rx_size)
+		{
+			tsize = g_netDrv->rx_size - offset;
+			rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize);
+		}
+		else
+		{
+			tsize = count;
+			rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize);
+		}
+	}
+	else if (rt_memcmp ("eth", drv, 3) == 0)
+	{
+
+	}
+	else
+	{
+
+	}
+	offset += count;
+	return tsize;
+}
+
+
+int netdrv_clear (void)
+{
+
+	char * drv =  ef_get_env ("net_drv"); // 读取网络类型
+	if (rt_memcmp ("dtu", drv, 3) == 0) // 驱动程序位DTU模式，就是不通过本地配置，直接透传
+	{
+		MX_UART_Clear (&g_ETH1Drv);
+
+	}
+	else if (rt_memcmp ("ec200", drv, 4) == 0)
+	{
+		//rt_memcpy(buf, &g_cat1Drv.rxbuff[offset], count);
+	}
+	else if (rt_memcmp ("eth", drv, 3) == 0)
+	{
+
+	}
+	else
+	{
+
+	}
+	offset = 0;
+	return 0;
+}

Board/network/netdrv.h

@@ -0,0 +1,41 @@
+#ifndef _NET_DRV_H
+#define _NET_DRV_H
+
+
+typedef enum netDrvState_t
+{
+	Init, // 初始化状态
+	Join, // 入网
+	Conn, // 入网成功
+	Idle  // 空闲
+} netDrvState_t;
+
+typedef struct netDrv_t
+{
+	int Csq;
+	char Iccid[20];
+	netDrvState_t State;
+	char * rxbuff;
+	int rx_size;    // 接受到的tcp 数据缓存
+	char * txbuff;  // 发送的TCP 数据缓存
+	int tx_size;
+} netDrv_t;
+
+
+typedef enum CommRet_T
+{
+	RetSucc,
+	RetErr
+} CommRet_T;
+
+extern netDrv_t * g_netDrv;;
+
+
+void netdrv_service_tx (uint8_t * data, int length);
+int  netdrv_getdata (uint8_t* buf, int count);
+int  netdrv_clear (void);
+void netdrv_init (void);
+void netdrv_reset (void);      // 网络链接失败，通知驱动重新启动网络模块
+
+
+#endif

Board/network/network.c

@@ -0,0 +1,43 @@
+
+#include "main.h"
+
+#include "os-app.h"
+
+#include <stdio.h>
+#include <rtthread.h>
+#include <string.h>
+#include "usart-board.h"
+
+
+void networkInit (void)
+{
+
+}
+
+
+// 网络线程  mqtt 线程和 驱动都从这里走
+void networkthread_entry (void  * argument)
+{
+	while (1)
+	{
+
+	}
+}
+
+
+
+
+
+
+
+#if !defined(LOG_TAG)
+#define LOG_TAG          "network"
+#endif
+#include <elog.h>
+
+
+
+
+
+
+

Board/network/network.h

@@ -0,0 +1,10 @@
+#ifndef _NET_WORK_H
+#define _NET_WORK_H
+
+
+
+#endif
+
+
+
+

Board/network/proto.c

@@ -0,0 +1,238 @@
+#include "proto.h"
+#include "util.h"
+#include "main.h"
+#include "data.h"
+#include "crc.h"
+#include <ef_api.h>
+#include <rtthread.h>
+#include "data.h"
+
+
+
+
+static int g_syn_number  = 0;
+
+
+// 打包数据帧
+int PacketHeader (uint8_t func, char * data, int length, char * txbuff)
+{
+	char * p;
+	char id [5];
+	p = ef_get_env ("device_id");
+	hexstr_to_hexbyte (p, id, 10);
+	int tx_size = 0;
+	uint16_t crc = 0;
+	txbuff[tx_size++] = 0x7E;
+	txbuff[tx_size++] = 0x7E;
+	txbuff[tx_size++] = 0x01;
+	txbuff[tx_size++] = 0xFF;
+	txbuff[tx_size++] = 0xFF;
+	for (int i = 0; i < 5; i++)
+	{
+		txbuff[tx_size++] = id[i];
+	}
+	txbuff[tx_size++] = func;
+	txbuff[tx_size++] = 0x00;
+	txbuff[tx_size++] = length;// 长度
+	txbuff[tx_size++] = _651_STX;
+	//dbg_printf ("sizeof (_651_U_Header_t):%d\r\n", tx_size);
+
+	for (int i = 0; i < length; i++)
+	{
+		txbuff[tx_size++] = data[i];
+	}
+	txbuff[tx_size++] = 0x03;
+
+	crc = MX_CRC_CALC ( (uint8_t *) txbuff, tx_size); //MX_;
+
+	txbuff[tx_size++] = (crc >> 8)  & 0x00FF;
+	txbuff[tx_size++] = crc & 0x00FF;
+	return tx_size;
+	//
+	// 计算校验
+}
+
+// 均匀时段报
+int PakcetTimerUp (int k, char * tx_data)
+{
+
+	char * p;
+	char id [5];
+	p = ef_get_env ("device_id");
+	hexstr_to_hexbyte (p, id, 10);
+	int tx_size = 0;
+	g_syn_number ++;
+	Int intk;
+	tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF;
+	tx_data[tx_size++] =  g_syn_number & 0xFF;
+	for (int i = 0; i < 6; i++)
+	{
+		tx_data[tx_size++] = 0;
+	}
+	for (int i = 0; i < 5; i++)
+	{
+		tx_data[tx_size++] = id[i];
+	}
+	tx_data[tx_size++] = 0x5A; //闸坝
+	for (int i = 0; i < 6; i++)
+	{
+		tx_data[tx_size++] = 0;
+	}
+	tx_data[tx_size++] = 0x30;   // 编码要素
+	tx_data[tx_size++] = 0xFF;   // 要素1 瞬时流速
+	tx_data[tx_size++] = 0x31;   // 要素1 瞬时流速
+	tx_data[tx_size++] = 0xFF;   // 要素1 瞬时流量
+	tx_data[tx_size++] = 0x32;   // 要素1 瞬时流量
+	tx_data[tx_size++] = 0xFF;   // 要素1 累计流量
+	tx_data[tx_size++] = 0x33;   // 要素1 累计流量
+	tx_data[tx_size++] = 0xFF;   // 要素1 闸门开度
+	tx_data[tx_size++] = 0x34;   // 要素1 闸门开度
+	tx_data[tx_size++] = 0xFF;   // 要素1 闸门荷重
+	tx_data[tx_size++] = 0x35;   // 要素1 闸门荷重
+
+	tx_data[tx_size++] = 0xFF;   // 要素1 累计流量
+	tx_data[tx_size++] = 0x36;   // 要素1 累计流量
+	tx_data[tx_size++] = 0xFF;   // 要素1 闸门开度
+	tx_data[tx_size++] = 0x37;   // 要素1 闸门开度
+	tx_data[tx_size++] = 0xFF;   // 要素1 闸门荷重
+	tx_data[tx_size++] = 0x38;   // 要素1 闸门荷重
+
+	tx_data[tx_size++] = 0xFF;   // 要素1 闸前水位
+	tx_data[tx_size++] = 0x39;   // 要素1 闸前水位
+
+	intk.data = WaterData[0].thisSpeed * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	intk.data = WaterData[0].thisFlow * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	intk.data = WaterData[0].ttWater * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+	intk.data = SluiceData[k].gopen * 10;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	intk.data = (SluiceData[k].lload + SluiceData[k].rload) * 10;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	// 要素6 最大开度
+	intk.data = ef_get_integer ("max_open") * 10; // 单位mm *10
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	// 要素7 电池电压
+	intk.data = 0 * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	// 要素8 机箱温度
+	intk.data = 0 * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	// 要素9 闸前水位
+	intk.data = WaterData[0].thisLevel;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+	return tx_size;
+
+}
+
+// 闸门状态自报  闸门开度发生变化时上报
+int PacketSluiceUp (int k, char * tx_data)
+{
+	int tx_size = 0;
+	g_syn_number ++;
+	Int intk;
+	tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF;
+	tx_data[tx_size++] =  g_syn_number & 0xFF;
+	tx_data[tx_size++] = 0x01;
+	tx_data[tx_size++] = 0x01;
+//	// 闸门开度
+	intk.data = SluiceData[k].gopen * 10;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+
+	intk.data = (SluiceData[k].lload + SluiceData[k].rload) * 10;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+	// 闸前水位
+	intk.data =  WaterData[0].thisLevel;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+	// 瞬时流量
+	intk.data = 0 * 100;
+	tx_data[tx_size++] = intk.byte[3];
+	tx_data[tx_size++] = intk.byte[2];
+	tx_data[tx_size++] = intk.byte[1];
+	tx_data[tx_size++] = intk.byte[0];
+	return tx_size;
+
+}
+
+// 接受到提闸数据时，应答的ACK
+int PacketSluiceAck (char* tx_data)
+{
+	int tx_size = 0;
+	g_syn_number ++;
+	tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF;
+	tx_data[tx_size++] =  g_syn_number & 0xFF;
+	for (int i = 0; i < 6; i++)
+	{
+		tx_data[tx_size++] = 0;
+	}
+
+	for (int i = 0; i < 5; i++)
+	{
+		tx_data[tx_size++] = 0xEE;
+	}
+	return tx_size;
+}
+
+
+int PacketAnsAck (char * tx_data)
+{
+	int size = 0;
+	size = rt_sprintf (tx_data, "{\"result\":\"ok\"}");
+	return size;
+}
+
+
+int PacketUpRegist (char * tx_data)
+{
+
+	int tx_size = rt_sprintf (tx_data, "{\"iccid\":\"%s\",\"version\":\"%s\"}", SysData.iccid, VERSION);
+	return tx_size ;
+}
+
+
+
+

Board/network/proto.h

@@ -0,0 +1,64 @@
+#ifndef _PROTO_H
+#define _PROTO_H
+#include <stdint.h>
+
+
+// 上行统一使用M1模式，无确认
+// 下行统一使用M2模式一次确认
+
+#define _651_STX  2
+#define _651_ETX  3
+#define _651_ETB  23
+
+
+
+#pragma pack (1)
+typedef struct _651_U_Header_t
+{
+	uint16_t Head;
+	uint8_t CentAddr;
+	uint8_t DeviAddr[5];
+	uint16_t Pass;
+	uint8_t FuncCode;
+	uint16_t TypeLength;
+	uint8_t  Stx;
+} _651_U_Header_t;
+
+typedef struct _651_D_Header_t
+{
+	uint16_t Head;
+	uint8_t DeviAddr[5];
+	uint8_t CentAddr;
+	uint16_t Pass;
+	uint8_t FuncCode;
+	uint16_t Type: 4;
+	uint16_t Length: 12;
+	uint8_t  Stx;
+} _651_D_Header_t;
+#pragma pack ()
+
+
+
+
+// 打包数据帧
+int PacketHeader (uint8_t func, char * data, int length, char * txbuff);
+
+// 均匀时段报
+int PakcetTimerUp (int k, char * tx_data);
+
+// 闸门状态自报  闸门开度发生变化时上报
+int PacketSluiceUp (int k, char * tx_data);
+
+// 接受到提闸数据时，应答的ACK
+int PacketSluiceAck (char* tx_data);
+
+
+int PacketAnsAck (char * tx_data);
+int PacketUpRegist (char * tx_data);
+
+
+
+
+
+
+#endif

Board/network/zs001drv.c

@@ -0,0 +1,132 @@
+#include <cat1drv.h>
+#include <rtthread.h>
+#include <os-app.h>
+#include "main.h"
+#include "usart-board.h"
+#include <string.h>
+#include <stdlib.h>
+#include <easyflash.h>
+#include "netdrv.h"
+
+
+
+
+
+
+#if !defined(LOG_TAG)
+#define LOG_TAG          "CAT1"
+#endif
+#include <elog.h>
+
+
+ALIGN (RT_ALIGN_SIZE)
+static char thread_stack[4096];
+static struct rt_thread thread;
+static char tcprxbbuff[1200];
+static char tcptxbbuff[1200];
+
+
+static const uint8_t header[] = {0xed, 0xf2, 0xa3, 0x56, 0xca, 0xdb, 0x91, 0x84, 0xb0, 0xd7};
+static const uint8_t readip[] = {0xed, 0xf2, 0xa3, 0x56, 0xca, 0xdb, 0x91, 0x84, 0xb0, 0xd7, 0x00, 0x00, 0x04};
+
+
+netDrv_t g_ZS001Drv =
+{
+	0,          // 信号值
+	"",         // iccid
+	Init,       // 状态
+	tcprxbbuff, // 接受缓存
+	0,          // 接受数据长度
+	tcptxbbuff, // 发送数据缓存
+	0,          // 发送数据长度
+};
+
+
+static void zs001_rx_done (void)
+{
+	rt_event_send (gUartEvents, EVENT_UART_ETH1_RX);
+
+}
+
+
+
+static int zs001_packet_commad (int type, int loc, int size, char * data)
+{
+	int index = 0;
+	for (int i = 0; i < 10; i++)
+	{
+		data[index++] =  header[i];
+	}
+	data[index++] = type;
+	data[index++] = loc;
+	data[index++] = size;
+	return index;
+}
+
+
+static void thread_entry (void  * argument)
+{
+
+//	char at_cmd[128] = {NULL};
+//	char ipaddr[32] = {NULL};
+//	int ipport;
+//	char *p;
+//	int retry = 0;
+
+
+
+//	char send_data[32];
+//	int size = 0;
+//	size = zs001_packet_commad(0,)
+//	p = ef_get_env ("mqtt_addr");
+//	rt_strncpy (ipaddr, p, rt_strlen (p));
+//	p = ef_get_env ("mqtt_port");
+//	ipport = atoi (p);
+	//rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport);
+	g_ETH1Drv.rxdone = zs001_rx_done;
+	g_ETH1Drv.BaudRate = 115200;
+	// 启动4G 模块电源
+	// 拉高4G 模块复位
+	MX_UART_Init (&g_ETH1Drv);
+	HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
+	rt_thread_mdelay (1000);
+	HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET);
+	rt_thread_mdelay (3000);
+	while (1)
+	{
+
+//		rt_kprintf("zs0010+++++++++++++++++++\r\n");
+		MX_UART_PutBuffer (&g_ETH1Drv, (char *) readip, 13) ;
+
+		// 发送数据
+		if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 2000, RT_NULL)) // 需要发送数据
+		{
+			for (int i = 0 ; i < g_ETH1Drv.rx_size; i++)
+			{
+				rt_kprintf ("%02X", g_ETH1Drv.rx_buffer[i]);
+			}
+			rt_kprintf ("\r\n");
+			MX_UART_Clear (&g_ETH1Drv) ;
+		}
+
+		rt_thread_mdelay (3000);
+	}
+
+}
+
+
+
+
+
+void ZS001ThreadStart (void)
+{
+	/* 创建线程1，名称是thread1，入口是thread1_entry */
+	rt_thread_init (&thread, "zs001_thread",
+	                thread_entry, RT_NULL,
+	                &thread_stack[0],
+	                sizeof (thread_stack),
+	                ZS001_THREAD_PRIORITY,  ZS001_THREAD_TIMESLICE);
+	rt_thread_startup (&thread);
+
+	return ;
+}

Board/network/zs001drv.h

@@ -0,0 +1,16 @@
+#ifndef _ZS001_DRV_H
+#define _ZS001_DRV_H
+
+
+
+#define ZS001_READ_CMD   0x00
+#define ZS001_WRITE_CMD  0x01
+
+//#define ZS001_CMD_READSTATE
+
+
+
+
+
+
+#endif

Board/usart-board.c

@@ -57,8 +57,8 @@ void MX_UART_TickHandle (void)
 		g_DebugDrv.rx_timer--;
 
 	// 4851
-	
-	
+
+
 	if (g_U4851Drv.rx_timer == 2)  // 通过事件通知到业务app
 	{
 		if (g_U4851Drv.rxdone != NULL)
@@ -238,6 +238,7 @@ void MX_UART_Init (UartDrv_t *drv)
 		{
 			Error_Handler();
 		}
+		__HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_RXNE);
 		break;
 	case G0_UART1 : // 4853
 		huart1.Instance = USART1;
@@ -328,6 +329,7 @@ void MX_UART_Init (UartDrv_t *drv)
 		{
 			Error_Handler();
 		}
+		__HAL_UART_ENABLE_IT (&huart3, UART_IT_RXNE);
 		break;
 	case G0_UART4:  // ETH1
 		huart4.Instance = USART4;
@@ -383,6 +385,7 @@ void MX_UART_Init (UartDrv_t *drv)
 		{
 			Error_Handler();
 		}
+		__HAL_UART_ENABLE_IT (&huart6, UART_IT_RXNE);
 		break;
 	default:
 		break;
@@ -394,10 +397,21 @@ void MX_UART_Init (UartDrv_t *drv)
 void MX_UART_IRQHandle (void)
 {
 	uint8_t ret;
+	if (USART3->ISR & (1 << 5)) // 串口2
+	{
+		ret = USART3->RDR;
+		if (g_U4852Drv.rx_buffer != NULL)
+		{
+			g_U4852Drv.rx_buffer[g_U4852Drv.rx_size++] = ret;
+			g_U4852Drv.rx_timer = 30;  // 30ms
+			if (g_U4852Drv.rx_size > UART_UART3_BUFF_SIZE)
+				g_U4852Drv.rx_size = 0;
+		}
+	}
 	if (USART2->ISR & (1 << 5)) // 串口2
 	{
 		ret = USART2->RDR;
-		if( g_DebugDrv.rx_buffer != NULL)
+		if (g_DebugDrv.rx_buffer != NULL)
 		{
 			g_DebugDrv.rx_buffer[g_DebugDrv.rx_size++] = ret;
 			g_DebugDrv.rx_timer = 30;  // 30ms
@@ -408,7 +422,7 @@ void MX_UART_IRQHandle (void)
 	if (USART4->ISR & (1 << 5))
 	{
 		ret = USART4->RDR;
-		if( g_ETH1Drv.rx_buffer != NULL)
+		if (g_ETH1Drv.rx_buffer != NULL)
 		{
 			g_ETH1Drv.rx_buffer[g_ETH1Drv.rx_size++] = ret;
 			g_ETH1Drv.rx_timer = 30;  // 30ms
@@ -419,7 +433,7 @@ void MX_UART_IRQHandle (void)
 	if (USART5->ISR & (1 << 5))
 	{
 		ret = USART5->RDR;
-		if( g_U4851Drv.rx_buffer != NULL)
+		if (g_U4851Drv.rx_buffer != NULL)
 		{
 			g_U4851Drv.rx_buffer[g_U4851Drv.rx_size++] = ret;
 			g_U4851Drv.rx_timer = 30;  // 30ms
@@ -427,11 +441,22 @@ void MX_UART_IRQHandle (void)
 				g_U4851Drv.rx_size = 0;
 		}
 	}
-	
+	if (USART6->ISR & (1 << 5))
+	{
+		ret = USART6->RDR;
+		if (g_ViewDrv.rx_buffer != NULL)
+		{
+			g_ViewDrv.rx_buffer[g_ViewDrv.rx_size++] = ret;
+			g_ViewDrv.rx_timer = 30;  // 30ms
+			if (g_ViewDrv.rx_size > UART_UART6_BUFF_SIZE)
+				g_ViewDrv.rx_size = 0;
+		}
+	}
+
 	if (LPUART1->ISR & (1 << 5))
 	{
 		ret = LPUART1->RDR;
-		if( g_ETH2Drv.rx_buffer != NULL)
+		if (g_ETH2Drv.rx_buffer != NULL)
 		{
 			g_ETH2Drv.rx_buffer[g_ETH2Drv.rx_size++] = ret;
 			g_ETH2Drv.rx_timer = 30;  // 30ms
@@ -439,6 +464,18 @@ void MX_UART_IRQHandle (void)
 				g_ETH2Drv.rx_size = 0;
 		}
 	}
+
+	if (LPUART2->ISR & (1 << 5))
+	{
+		ret = LPUART2->RDR;
+		if (g_GSMDrv.rx_buffer != NULL)
+		{
+			g_GSMDrv.rx_buffer[g_GSMDrv.rx_size++] = ret;
+			g_GSMDrv.rx_timer = 30;  // 30ms
+			if (g_GSMDrv.rx_size > UART_LPUART2_BUFF_SIZE)
+				g_GSMDrv.rx_size = 0;
+		}
+	}
 }
 
 

Board/usart-board.h

@@ -56,7 +56,7 @@ extern UartDrv_t g_LoRaDrv  ;
 
 
 
-// function 
+// function
 
 
 extern void MX_UART_TickHandle (void);