引入mqtt 引入cjson

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