注册优化

Drivers/Business/PumpBusiness.c

@@ -170,7 +170,7 @@ static void UDPClient_SendDataInterval()
 		// 初始化流程处于空闲， 注册流程处于空闲，注册成功时发送
 		if(INITIALIZE_GetStatus() == INITIALIZE_Status_None
 			&& REGIST_GetStatus() == REGIST_Status_None 
-			&& REGIST_GetResult() == REGIST_Result_Success)
+			&& TUORENIOT_GetCodeOfRegistResponse() == 200)
 		{
 			Log_Printf_Debug("开始发送\r\n");
 			UDPCLIENT_Start();

Drivers/Encrypt/Mbedtls_Util.c

@@ -15,7 +15,7 @@
 
 #define SHA256_DIGEST_SIZE 32
 
-#define AES_LEN_SIZE 256
+#define AES_LEN_SIZE 512
 
 #define AES_BLOCK_SIZE 16
 

Drivers/Modules/Regist.h

@@ -32,4 +32,5 @@ enum REGIST_ResultEnum REGIST_GetResult(void);
 
 
 
+
 #endif

Drivers/Modules/Tuoreniot.c

@@ -18,6 +18,10 @@
 // 注册时用的密钥
 char regist_key[17]="tuorenzhinenghua";
 
+// 注册数据
+uint8_t regist_data[512];
+uint16_t regist_data_length;
+
 #if  PROD_ENV
 // 生产环境
 char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
@@ -26,8 +30,13 @@ uint16_t REGIST_PORT = 8888; //
 
 #if TEST_ENV
 // 开发环境
-char * REGIST_SERVER = "b21759p174.iok.la" ; //注册服务器地址
-uint16_t REGIST_PORT = 43097; //端口号
+//char * REGIST_SERVER = "b21759p174.iok.la" ; //注册服务器地址
+//uint16_t REGIST_PORT = 43097; //端口号
+
+
+char * REGIST_SERVER = "frp-fun.top" ; //注册服务器地址
+uint16_t REGIST_PORT = 27827; //端口号
+
 #endif
 
 
@@ -79,22 +88,21 @@ uint8_t TUORENIOT_AnalysisRegistData(uint8_t * regist_data, uint16_t regist_data
 	}
 	else if(cJSON_GetObjectItem(json, "code")->valueint == 200)
 	{
-		regist_response.version = 1;
-		regist_response.userId = 1000;
-		strcpy(regist_response.networkProtocol, "CoAP");
-		strcpy(regist_response.platform, "aliyun");
 		regist_response.code = cJSON_GetObjectItem(json, "code")->valueint;
+		regist_response.version = cJSON_GetObjectItem(json, "version")->valueint;
+		regist_response.userId = cJSON_GetObjectItem(json, "userId")->valueint;
+		strcpy(regist_response.networkProtocol, cJSON_GetObjectItem(json, "networkProtocol")->valuestring);
+		strcpy(regist_response.platform, cJSON_GetObjectItem(json, "platform")->valuestring);
 		strcpy(regist_response.deviceSecret, cJSON_GetObjectItem(json, "deviceSecret")->valuestring);
-		strcpy(regist_response.productId, cJSON_GetObjectItem(json, "productKey")->valuestring);
-		strcpy(regist_response.deviceId, cJSON_GetObjectItem(json, "deviceName")->valuestring);
-		// remoteAddress
-//		strcpy(regist_response.remoteAddress, cJSON_GetObjectItem(json, "address")->valuestring);
-		Log_Printf_Debug("sizeof(regist_response.remoteAddress): %d\r\n", sizeof(regist_response.remoteAddress));
-		memset(regist_response.remoteAddress, 0, sizeof(regist_response.remoteAddress));
-		strcat(regist_response.remoteAddress, regist_response.productId);
-		strcat(regist_response.remoteAddress, ".coap.cn-shanghai.link.aliyuncs.com");
-		regist_response.remotePort = atoi(cJSON_GetObjectItem(json, "port")->valuestring);
+		strcpy(regist_response.productId, cJSON_GetObjectItem(json, "productId")->valuestring);
+		strcpy(regist_response.deviceId, cJSON_GetObjectItem(json, "deviceId")->valuestring);
+		strcpy(regist_response.remoteAddress, cJSON_GetObjectItem(json, "remoteAddress")->valuestring);
+		regist_response.remotePort = cJSON_GetObjectItem(json, "remotePort")->valueint;
+		
 		regist_response.wifiNumber = 3;
+		// 解析wifi
+		
+		
 		result = 1;
 		WriteRegistResponseToFlash();
 	}
@@ -313,7 +321,7 @@ uint8_t TUORENIOT_AnalysisMessage(uint8_t * coap_message, uint16_t coap_message_
 	{
 		// 解析json
 		cJSON * cjson = cJSON_Parse((char * )payload);
-//		Log_Printf_Debug("plaintext(%d): %s\r\n",payload_length, payload);
+		Log_Printf_Debug("plaintext(%d): %s\r\n",payload_length, payload);
 		if(cJSON_HasObjectItem(cjson, "random"))
 		{
 			char * random = cJSON_GetObjectItem(cjson, "random")->valuestring;
@@ -388,7 +396,7 @@ void TUORENIOT_Init(void)
 // 从flash中读取注册响应
 static void ReadRegistResponseFromFlash(void)
 {
-	Log_Printf_Debug("sizeof(regist_result): %d\r\n", sizeof(regist_response));
+	Log_Printf_Debug("sizeof(regist_response): %d\r\n", sizeof(regist_response));
 	//读取flash
 	Log_Printf_Debug("读取前code：%d\r\n", regist_response.code);
 	Log_Printf_Debug("sizeof(regist_result): %d\r\n", sizeof(regist_response));

Drivers/Modules/Tuoreniot.h

@@ -9,6 +9,10 @@ extern char * REGIST_SERVER;
 extern uint16_t REGIST_PORT;
 extern struct TUORENIOT_RegistResponseStruct regist_response;
 
+// ×¢²áÊý¾Ý
+extern uint8_t regist_data[512];
+extern uint16_t regist_data_length;
+
 struct TUORENIOT_RegistRequestStruct
 {
 	uint8_t version;
@@ -72,4 +76,6 @@ void TUORENIOT_ReadRegistResponseFromFlash(void);
 uint8_t TUORENIOT_GetCodeOfRegistResponse(void);
 
 
+
+
 #endif

Drivers/Modules/bc260y/BC260Y_UDP_Client5.c

@@ -72,7 +72,6 @@ static void goto_finish(void); //
 
 // 流程
 enum Step{
-	STEP_NONE, // 空闲状态，无操作
 	STEP_START, // 开始
 	STEP_EXIT_SLEEP, // 退出睡眠
 	STEP_ENTER_SLEEP, // 进入睡眠
@@ -269,8 +268,6 @@ static void UDPCLIENT_Process(void)
 	// 流程
 	switch(pctrl.current_step)
 	{
-		case STEP_NONE: // 空闲
-			break;
 		case STEP_START: // 开始
 			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
 			break;
@@ -414,9 +411,6 @@ static void UDPCLIENT_Process(void)
 			{
 				if(cgreg_stat == 1)
 				{
-					// 参数赋值
-					pump_params.lac = cgreg_lac;
-					pump_params.ci = cgreg_ci;
 						// 下一步
 					if(UDPCLIENT_TestModeFlag == 0)
 					{
@@ -528,7 +522,6 @@ static void UDPCLIENT_Process(void)
 //			Log_Printf_Debug("\r\n");
 			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据报文");
 			break;
- 
 		case STEP_SEND: // 发送send
 			result = bc260y.send_rai(connectID, coap_message, coap_message_length, 2);
 			if(result == Result_Success)

Drivers/Modules/bc260y/Bc260y_Initialize.c

@@ -7,11 +7,12 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "bc260y.h"
 #include "PumpBusiness.h"
 #include "Log_Module.h"
 #include "Initialize.h"
 
+#include "bc260y.h"
+
 // º¯ÊýÉùÃ÷
 static void INITIALIZE_Process(void); // Á÷³Ì
 static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status); // ÉèÖÃ״̬

Drivers/Modules/bc260y/Bc260y_Regist.c

@@ -1,25 +1,8 @@
 #include "CONFIG.h"
 #if  BC260Y
-/**
-  ******************************************************************************
-  * 版   本       ：V1.0.0
-  * 作   者       ：liuyanbin
-  * 版权所有，盗版必究。
-  * Copyright(C) All rights reserved
-  ******************************************************************************
-  *                             历史记录
-  *     序号      版本        变更内容          作者              日期
-  *      1        V0.0.1      实现4G注册      刘艳斌          2023/12/20
-  *      2        V0.0.2      实现NB注册      刘艳斌          2023/12/20
-  *      3        V0.0.3      整合4g和nb      刘艳斌          2024/1/24
-  *
-  ******************************************************************************
-  */
-
 
 #include "stm32f10x.h"
 #include "Regist.h"
-#include "bc260y.h"
 #include "FlashSetup.h"
 #include <stdio.h>
 #include <stdarg.h>
@@ -32,6 +15,8 @@
 #include "Common_Util.h"
 #include "Tuoreniot.h"
 
+#include "bc260y.h"
+
 // 泵号
 extern uint8_t mcu_id[8];
 // socket ID
@@ -46,9 +31,6 @@ static struct TUORENIOT_RegistRequestStruct regist_request = {
 	.userId = 4562
 };
 
-static uint8_t regist_data[512];
-static uint16_t regist_data_length;
-
 // dns
 static char pridnsaddr[20];
 
@@ -59,6 +41,10 @@ static char pridnsaddr[20];
 */
 void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams)
 {
+	
+	Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
+	byteToHexStr(mcu_id, registParams->deviceId, sizeof(mcu_id));
+
 	sprintf((char *)(pack_data + 2), "{\"platform\":\"%s\",\"connectionType\":\"%s\",\"deviceId\":\"%s\"}", 
 	registParams->platform, registParams->networkProtocol, registParams->deviceId); // 拼接AT指令
 	Log_Printf_Debug("%s\r\n", (char *)(pack_data + 2));
@@ -194,13 +180,6 @@ static void REGIST_SetResult(enum REGIST_ResultEnum result)
 // 获取注册结果
 enum REGIST_ResultEnum REGIST_GetResult(void)
 {
-  if(TUORENIOT_GetCodeOfRegistResponse() == 200){
-    regist_result = REGIST_Result_Success;
-  }
-  else
-  {
-    regist_result = REGIST_Result_None;
-  }
 	return regist_result;
 }
 // 重置注册
@@ -398,7 +377,7 @@ static void REGIST_Process()
 			{
 				if(REGIST_GetResult() != REGIST_Result_None)
 				{
-					goto_finish();
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
 				}
 				else
 				{
@@ -415,10 +394,7 @@ static void REGIST_Process()
 			if(result == Result_Success)
 			{
 				PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据");
-				
-				memset(regist_request.deviceId, 0, sizeof(regist_request.deviceId));
-				Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
-				byteToHexStr(mcu_id, regist_request.deviceId, sizeof(mcu_id));
+				// 打包注册请求
 				memset(regist_data, 0, sizeof(regist_data));
 				TUORENIOT_PackRegistRequest(regist_data, &regist_data_length, &regist_request);
 				TUORENIOT_PrintfRegistRequestStruct(&regist_request);

Drivers/Modules/ec800m/EC800M_UDP_Client5.c

@@ -7,7 +7,6 @@
 #include <string.h>
 #include <stdlib.h>
 
-
 #include "UDP_Client.h"
 #include "Timer_Module.h"
 #include "Log_Module.h"
@@ -15,12 +14,63 @@
 #include "mbedtls_util.h"
 
 #include "cJSON.h"
-#include "ec800m.h"
 #include "Pump_Dicts_Util.h"
 #include "Regist.h"
 #include "PumpBusiness.h"
-#include "aliyuniot.h"
 #include "Initialize.h"
+#include "Tuoreniot.h"
+
+
+#include "ec800m.h"
+
+
+// 测试模式
+uint8_t UDPCLIENT_TestModeFlag = 0;
+
+// socket ID
+static uint8_t connectID = 5;
+
+// coap报文
+static uint8_t coap_message[512]; 
+static uint16_t coap_message_length = 0;
+
+// 待发送数据的地址和长度
+static uint8_t data[128];
+static uint16_t data_length;
+
+
+// 信号值
+static struct Signal
+{
+	int RSRP;
+	int RSRQ; 
+	int RSSI; 
+	int SINR;
+} signal = {
+	.RSRP = 99,
+	.RSRQ = 99,
+	.RSSI = 99,
+	.SINR = 99,
+};
+// 查询信号质量
+void UDPCLIENT_QuerySignal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
+{
+	*RSRP = signal.RSRP;
+	*RSRQ = signal.RSRQ;
+	*RSSI = signal.RSSI;
+	*SINR = signal.SINR;
+}
+
+
+// 函数声明
+static void UDPCLIENT_Process(void); // 流程
+static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status); // 设置状态
+static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result); // 设置结果
+
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
 
 // 流程
 enum Step{
@@ -62,165 +112,140 @@ enum Step{
 	STEP_VERIFY_REGIST, // 验证注册
 	STEP_VERIFY_INITIALIZE, // 验证初始化
 };
-// 当前
-static enum Step step = STEP_NONE;
-// 下一步
-static enum Step next_step = STEP_NONE;
-
-// 客户端5
-struct UDP_Client_Struct client = {
-	.status = Client_Status_None,
-};
-
 
-// socket ID
-static uint8_t connectID = 5;
 
 
-
-static uint8_t coap_message[512]; 
-static uint16_t coap_message_length = 0;
-
-// 泵参数
-extern struct Pump_Params pump_params;
-// 待发送数据的地址和长度
-static uint8_t databuff[128];
-static uint16_t data_length;
-
-static uint8_t test_flag=0;
-
-
-// 计时相关的变量
-static struct TIMER_Struct timer;
-uint32_t wait_time = 10;
-
-// 信号值
-static struct Signal
+// 步骤跳转时的监听
+static uint8_t STEP_JOIN_AUTH_MESSAGE_times = 0; // 认证的次数
+static uint8_t STEP_QUERY_CGREG_times = 0; // 查询网络状态的次数
+static void initialize()
 {
-	int RSRP;
-	int RSRQ; 
-	int RSSI; 
-	int SINR;
-} signal = {
-	.RSRP = 99,
-	.RSRQ = 99,
-	.RSSI = 99,
-	.SINR = 99,
-};
-
-void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
+	STEP_JOIN_AUTH_MESSAGE_times = 0;
+	STEP_QUERY_CGREG_times = 0;
+}	
+static uint16_t goto_step_event(uint16_t ns)
 {
-	*RSRP = signal.RSRP;
-	*RSRQ = signal.RSRQ;
-	*RSSI = signal.RSSI;
-	*SINR = signal.SINR;
+	// 重置ec800m状态
+	ec800m.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_JOIN_AUTH_MESSAGE && STEP_JOIN_AUTH_MESSAGE_times++ >= 1)
+	{
+		goto_failure("认证次数过多");
+		step = STEP_FAILURE;
+	}
+	else if(ns == STEP_QUERY_CGREG && STEP_QUERY_CGREG_times++ >= 20)
+	{
+		goto_failure("查询网络状态的次数过多，联网失败");
+		step = STEP_FAILURE;
+	}
+	return step;
 }
 
-// 初始化
-void UDP_Client_Init(void)
-{
-	//aliyuniot_set_device_params(flashdata.productKey,flashdata.deviceName,flashdata.deviceSecret);
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
 
-	aliyuniot_set_device_params(regist_get_aliyun_productKey(),regist_get_aliyun_deviceName(),regist_get_aliyun_deviceSecret());
-}
-// 声明函数。步骤跳转
-void goto_step(enum Step ns);
-// 发送流程
-void UDP_Client_Handle(void);
-// 发送数据
-void UDP_Client_Send(uint8_t test_switch)
+
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
 {
-	test_flag=test_switch;
-	if(step == STEP_NONE)
-	{
-		// 初始化
-		UDP_Client_Init();
-		// 正在发送
-		client.status = Client_Status_Sending;
-		// 流程开始
-		goto_step(STEP_START);
-	}
+	initialize();
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
 }
-// 获取状态
-enum Client_Status UDP_Client_Status(void)
+// 成功
+static void goto_success(void)
 {
-	if(client.status == Client_Status_None)
-	{
-		return client.status;
-	}
-	else if(step == STEP_FINISH)
-	{
-		return client.status;
-	}
-	else
-	{
-		return Client_Status_Sending;
-	}
+	UDPCLIENT_SetResult(UDPCLIENT_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
 }
-
-// 获取备注
-char * UDP_Client_Get_Info(void)
+// 失败
+static void goto_failure(char * _info)
 {
-	return client.info;
+	UDPCLIENT_SetResult(UDPCLIENT_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
 }
-// 清除
-void UDP_Client_Clear(void)
+// 结束
+static void goto_finish(void)
 {
-	// 流程置空
-	goto_step(STEP_NONE);
-	// 空闲
-	client.status = Client_Status_None;
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
 }
 
-// 直接跳转到下一步
-static void goto_step(enum Step ns)
+
+
+// 状态
+static enum UDPCLIENT_StatusEnum udpclient_status = UDPCLIENT_Status_None;
+// 结果
+static enum UDPCLIENT_ResultEnum udpclient_result = UDPCLIENT_Result_None;
+// 设置状态
+static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status)
 {
-	// 重置ec800m状态
-	ec800m.reset();
-	step = ns; 
+	udpclient_status = status;
 }
-
-// 先等待再跳转到下一步
-static void goto_step_wait(enum Step ns, uint32_t t)
+// 获取状态
+enum UDPCLIENT_StatusEnum UDPCLIENT_GetStatus(void)
 {
-	goto_step(STEP_WAIT); // 等待
-	wait_time = t;
-	next_step = ns; // 等待之后跳转
+	return udpclient_status;
 }
-
-// 只等待，等待之后返回原来的步骤
-static void goto_wait(uint32_t t)
+// 设置结果
+static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result)
 {
-	goto_step_wait(step, t);
+	udpclient_result = result;
 }
-
-// 失败
-static void goto_failure(char * info)
+// 获取结果
+enum UDPCLIENT_ResultEnum UDPCLIENT_GetResult(void)
 {
-	Log_Printf_Debug("STEP: 数据发送失败,%s\r\n", info);
-	client.status = Client_Status_Failure;
-	strcpy(client.info, info);
-	goto_step(STEP_FAILURE);
+	return udpclient_result;
 }
-
-// 成功
-static void goto_success(char * info)
+// 重置
+enum EXECUTE_ResultEnum UDPCLIENT_Reset(void)
 {
-	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
-	client.status = Client_Status_Success;
-	strcpy(client.info, info);
-	goto_step(STEP_SUCCESS);
+	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
+	{
+		Log_Printf_Debug("发送流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_None);
+	UDPCLIENT_SetResult(UDPCLIENT_Result_None);
+	return EXECUTE_Result_Success;
 }
-
-// 等待
-static void wait(void)
+// 开始
+enum EXECUTE_ResultEnum UDPCLIENT_Start(void)
 {
-	if(time_get_delay(&timer) > wait_time)
+	UDPCLIENT_Reset();
+	if(UDPCLIENT_GetStatus() != UDPCLIENT_Status_None)
 	{
-		goto_step(next_step); // 进入下一步
-		time_clear(&timer);
+		Log_Printf_Debug("发送流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
 	}
+	goto_start();
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_Being);
+	return EXECUTE_Result_Success;
 }
+// 流程处理，放到大循环里
+void UDPCLIENT_ProcessHandle(void)
+{
+	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
+	{
+		UDPCLIENT_Process();
+	}
+}
+
+
+
+
+
 
 // 发送数据的逻辑
 static enum Result result = Result_None;
@@ -228,40 +253,37 @@ static uint8_t cgreg_n;
 static uint8_t cgreg_stat; 
 static uint16_t cgreg_lac; 
 static uint32_t cgreg_ci;
-static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
-static uint8_t auth_times = 0; // 认证次数
 static uint16_t socket_err = 0;
-static uint8_t auth_or_data = 0;
-static enum Initialize_Result InitializeResult;
-static enum Regist_Result regist_result;
-void UDP_Client_Handle(void)
+static void UDPCLIENT_Process(void)
 {
-	// 如果模块正在初始化，直接返回发送失败
-	InitializeResult = get_initialize_status();
-	if(InitializeResult==Initialize_Result_Busy)
-	{
-		goto_failure("模块正在初始化");
-		goto_step(STEP_FINISH);
-	}
 	// 流程
-	switch(step)
+	switch(pctrl.current_step)
 	{
 		case STEP_NONE: // 空闲
 			break;
 		case STEP_START: // 开始
-			query_cgreg_times = 0; // 查询网络状态的次数
-			auth_times = 0; // 认证次数
-			goto_step(STEP_EXIT_SLEEP);
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			ec800m.exit_sleep();
-			goto_step_wait(STEP_SET_CFUN_1, 3);
+			PCTRL_GotoStepWait(&pctrl, STEP_SET_SLEEP, 3, "设置休眠模式");
+			break;
+		case STEP_SET_SLEEP: // 设置休眠模式
+			result = ec800m.set_sleep(1);
+			if(result != Result_None)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置休眠模式失败");
+			}
 			break;
 		case STEP_SET_CFUN_1: // 设置全功能模式
 			result = ec800m.set_cfun(1);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_CGREG_2);
+				PCTRL_GotoStep(&pctrl, STEP_SET_CGREG_2, "设置ps域");
 			}
 			else if(result == Result_Failed)
 			{
@@ -272,7 +294,7 @@ void UDP_Client_Handle(void)
 			result = ec800m.set_cgreg(2);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_QUERY_CGREG);
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CGREG, "查询ps域");
 			}
 			else if(result == Result_Failed)
 			{
@@ -286,23 +308,18 @@ void UDP_Client_Handle(void)
 				if(cgreg_stat == 1)
 				{
 					// 下一步
-					if(test_flag == 0)
+					if(UDPCLIENT_TestModeFlag == 0)
 					{
-						goto_step(STEP_CLOSE);
+						PCTRL_GotoStep(&pctrl, STEP_CLOSE, "关闭连接");
 					}
 					else
 					{
-						goto_step(STEP_QUERY_QENG_SERVINGCELL);
+						PCTRL_GotoStep(&pctrl, STEP_QUERY_QENG_SERVINGCELL, "查询信号质量");
 					}
 				}
-				else if(query_cgreg_times > 20) // 最多查询20次
-				{
-					goto_failure("查询ps域次数过多");
-				}
 				else
 				{
-					goto_wait(400);
-					query_cgreg_times++;
+					PCTRL_GotoWait(&pctrl, 500);
 				}
 			}
 			else if(result == Result_Failed)
@@ -314,7 +331,7 @@ void UDP_Client_Handle(void)
 			result = ec800m.qeng_servingcell(&signal.RSRP, &signal.RSRQ, &signal.RSSI, &signal.SINR);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_CLOSE);
+				PCTRL_GotoStep(&pctrl, STEP_CLOSE, "关闭连接");
 			}
 			else if(result == Result_Failed)
 			{
@@ -325,20 +342,31 @@ void UDP_Client_Handle(void)
 			result = ec800m.close_socket(connectID);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_OPEN);
+				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_0, "关闭发送回显");
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("关闭连接失败");
 			}
 			break;
+		case STEP_SET_QISDE_0: // 关闭发送回显
+			result = ec800m.set_qisde(0);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_OPEN, "打开客户端");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("关闭发送回显失败");
+			}
+			break;
 		case STEP_OPEN: // 打开客户端
-			result = ec800m.open_socket(connectID, "UDP",aliyuniot_get_host(), aliyuniot_get_port(), 1, &socket_err);
+			result = ec800m.open_socket(connectID, "UDP", regist_response.remoteAddress, regist_response.remotePort, 1, &socket_err);
 			if(result == Result_Success)
 			{
 				if(socket_err == 0)
 				{
-					goto_step(STEP_JUDGE_AUTH_OR_DATA);
+					PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证还是发送");
 				}
 				else
 				{
@@ -351,57 +379,42 @@ void UDP_Client_Handle(void)
 			}
 			break;
 		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
-			auth_or_data = aliyuniot_is_authentication();
-			if(auth_or_data == 1) // 已认证
+			if(TUORENIOT_IsAuthentication() == 1) // 已认证
 			{
-				goto_step(STEP_JOIN_DATA_MESSAGE);
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
 			}
 			else
 			{
-				goto_step(STEP_JOIN_AUTH_MESSAGE);
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_AUTH_MESSAGE, "拼接认证报文");
 			}
 			break;
 		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
-			if(auth_times > 0) // 最多重新认证一次
-			{
-				goto_failure("认证次数过多");
-			}
-			else 
-			{
-				memset(coap_message, 0, sizeof(coap_message));
-				aliyuniot_get_auth_message(coap_message, &coap_message_length);
-				goto_step(STEP_SET_QISDE_0);
-				auth_times++;
-			}
+			memset(coap_message, 0, sizeof(coap_message));
+			TUORENIOT_PackAuthMessage(coap_message, &coap_message_length);
+//				Log_Printf_Debug("认证报文：%d\r\n", coap_message_length);
+//				Log_SendHex(coap_message, coap_message_length);
+//				Log_Printf_Debug("\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送认证报文");
 			break;
 		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
 			pump_params.lac = cgreg_lac;
 			pump_params.ci = cgreg_ci;
-			Pump_Params_Refresh();
+			PUMPBUSINESS_ParamsRefresh();
 					// 编码
-			memset(databuff, 0, sizeof(databuff));
-			business_protocol_encode(pump_params, databuff, &data_length);
+			memset(data, 0, sizeof(data));
+			PUMPDICTS_ProtocolEncode(&pump_params, data, &data_length);
 			memset(coap_message, 0, sizeof(coap_message));
-			aliyuniot_get_data_message(databuff, data_length, coap_message, &coap_message_length);
-		
-			goto_step(STEP_SET_QISDE_0);
-			break;
-		case STEP_SET_QISDE_0: // 关闭发送回显
-			result = ec800m.set_qisde(0);
-			if(result == Result_Success)
-			{
-				goto_step(STEP_SEND);
-			}
-			else if(result == Result_Failed)
-			{
-				goto_failure("关闭发送回显失败");
-			}
+			TUORENIOT_PackDataMessage(data, data_length, coap_message, &coap_message_length);
+//			Log_Printf_Debug("数据报文：%d\r\n", coap_message_length);
+//			Log_SendHex(coap_message, coap_message_length);
+//			Log_Printf_Debug("\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据报文");
 			break;
 		case STEP_SEND: // 发送send
 			result = ec800m.send(connectID, coap_message, coap_message_length);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_RECV);
+				PCTRL_GotoStep(&pctrl, STEP_RECV, "等待接收数据");
 			}
 			else if(result == Result_Failed)
 			{
@@ -412,18 +425,18 @@ void UDP_Client_Handle(void)
 			result = ec800m.recv_with_time(connectID, coap_message, &coap_message_length, 10000);
 			if(result == Result_Success)
 			{
-				uint8_t res = aliyuniot_recv_data_handle(coap_message, coap_message_length);
+				uint8_t res = TUORENIOT_AnalysisMessage(coap_message, coap_message_length);
 				if(res == 0) // 发送失败
 				{
-					goto_step(STEP_JUDGE_AUTH_OR_DATA); // 重新认证
+					PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "重新认证"); // 重新认证
 				}
 				else if(res == 1) // 认证成功
 				{
-					goto_step(STEP_JOIN_DATA_MESSAGE);
+					PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
 				}
 				else if(res == 2) // 发送成功
 				{
-					goto_success("发送成功");
+					goto_success();
 				}
 			}
 			else if(result == Result_Failed)
@@ -431,36 +444,30 @@ void UDP_Client_Handle(void)
 				goto_failure("等待结果失败");
 			}
 			break;
-		case STEP_WAIT: // 等待
-			wait();
-			break;
-		case STEP_SUCCESS: // 成功
-			goto_step(STEP_SET_SLEEP);
-			break;
-		case STEP_FAILURE: // 失败
-			goto_step(STEP_SET_SLEEP);
-			break;
-		case STEP_SET_SLEEP: // 设置休眠模式
-			result = ec800m.set_sleep(1);
-			if(result != Result_None)
-			{
-				goto_step(STEP_SET_CFUN_0);
-			}
-			break;
 		case STEP_SET_CFUN_0: // 设置最小功能模式
 			result = ec800m.set_cfun(0);
 			if(result != Result_None)
 			{
-				goto_step(STEP_ENTER_SLEEP);
+				PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
 			}
 			break;
 		case STEP_ENTER_SLEEP: // 进入睡眠
 			ec800m.enter_sleep();
-			goto_step(STEP_FINISH);
+			goto_finish();
+			break;
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;
+		case STEP_SUCCESS: // 成功
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
 			break;
 		case STEP_FINISH: // 结束流程
 			break;
 		default:
+			goto_failure("步骤不存在");
 			break;
 	}
 	

Drivers/Modules/ec800m/Ec800m_Initialize.c

@@ -7,12 +7,21 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "Initialize.h"
-#include "ec800m.h"
 #include "PumpBusiness.h"
 #include "Log_Module.h"
+#include "Initialize.h"
 
+#include "ec800m.h"
+
+// 函数声明
+static void INITIALIZE_Process(void); // 流程
+static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status); // 设置状态
+static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result); // 设置结果
 
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
 
 // 流程
 enum PowerStep{
@@ -30,170 +39,190 @@ enum PowerStep{
 	STEP_FAILURE, // 失败
 	STEP_FINISH,
 };
-// 当前
-static enum PowerStep powerstep = STEP_START;
-// 下一步
-static enum PowerStep next_step = STEP_START;
-
-static enum Initialize_Result InitializeResult;
-
-
-static struct TIMER_Struct timer;
-static struct TIMER_Struct timer2;
-
-// 计时相关的变量
-
-static uint8_t Restart_flag = 0;//4分钟内重启次数计数
-
 
+// 步骤跳转时的监听
+static uint8_t STEP_QUERY_CGREG_times = 0; // 查询网络状态的次数
+static void initialize()
+{
+	STEP_QUERY_CGREG_times = 0;
+}	
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置ec800m状态
+	ec800m.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_QUERY_CGREG && STEP_QUERY_CGREG_times++ >= 20)
+	{
+		goto_failure("查询网络状态的次数过多，联网失败");
+		step = STEP_FAILURE;
+	}
+	return step;
+}
 
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
 
-static uint32_t Power_wait_time = 10;
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
+{
+	initialize();
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
+}
+// 成功
+static void goto_success(void)
+{
+	INITIALIZE_SetResult(INITIALIZE_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
+}
+// 失败
+static void goto_failure(char * _info)
+{
+	INITIALIZE_SetResult(INITIALIZE_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
+}
+// 结束
+static void goto_finish(void)
+{
+	INITIALIZE_SetStatus(INITIALIZE_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
+}
 
-static uint8_t set_mincfun_flag=1;//0代表正在初始化，1代表空闲
 
 
-static uint8_t cgreg_n; 
-static uint8_t cgreg_stat; 
-static uint16_t cgreg_lac; 
-static uint32_t cgreg_ci;
-static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
-//// 声明函数。步骤跳转
-void pownext_step(enum PowerStep ns);
 
 
-// 等待
-static void powerwait(void)
+// 状态
+static enum INITIALIZE_StatusEnum udpclient_status = INITIALIZE_Status_None;
+// 结果
+static enum INITIALIZE_ResultEnum udpclient_result = INITIALIZE_Result_None;
+// 设置状态
+static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status)
 {
-   if(time_get_delay(&timer) > Power_wait_time)
-	{
-	 pownext_step(next_step); // 进入下一步
-	 time_clear(&timer);
-	}
+	udpclient_status = status;
 }
-// 失败
-static void power_failure(char * info)
+// 获取状态
+enum INITIALIZE_StatusEnum INITIALIZE_GetStatus(void)
 {
-	Log_Printf_Debug("STEP: 初始化失败,%s\r\n", info);
-	networkTest_Flag=1;
-	pownext_step(STEP_SET_CFUN_0);
+	return udpclient_status;
 }
-
-// 成功
-static void power_success(char * info)
+// 设置结果
+static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result)
 {
-	Log_Printf_Debug("STEP: 初始化成功,%s\r\n", info);
-
-	networkTest_Flag=2;
-	pownext_step(STEP_SET_CFUN_0);
+	udpclient_result = result;
 }
-
- //直接跳转到下一步
-static void pownext_step(enum PowerStep ns)
+// 获取结果
+enum INITIALIZE_ResultEnum INITIALIZE_GetResult(void)
 {
-	// 重置ec800m状态
-	ec800m.reset();
-	powerstep = ns; 
+	return udpclient_result;
 }
-
-// 先等待再跳转到下一步
-static void pownext_wait_step(enum PowerStep ns, uint32_t t)
+// 重置
+enum EXECUTE_ResultEnum INITIALIZE_Reset(void)
 {
-	pownext_step(STEP_WAIT); // 等待
-	Power_wait_time = t;
-	next_step = ns; // 等待之后跳转
-}
-
-// 发送数据的逻辑
-static enum Result result = Result_None;
-//获取初始化状态
-enum Initialize_Result get_initialize_status(void){
-	
-	if(set_mincfun_flag==0)
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
 	{
-	  InitializeResult=Initialize_Result_Busy;
+		Log_Printf_Debug("初始化流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
 	}
-	else
-	{
-	InitializeResult=Initialize_Result_free;
-	}
- return InitializeResult;
-
+	INITIALIZE_SetStatus(INITIALIZE_Status_None);
+	INITIALIZE_SetResult(INITIALIZE_Result_None);
+	return EXECUTE_Result_Success;
 }
-void Initialize_Handle(void)
+// 开始
+enum EXECUTE_ResultEnum INITIALIZE_Start(void)
 {
-	result =ec800m.ready();
-	if(result==Result_Success)
-	{
-		set_mincfun_flag=0;
-		pownext_step(STEP_START);
-		Restart_flag++;
-		Log_Printf_Debug("完成准备%d\r\n",Restart_flag);
-	}
-	
-	if(time_get_delay(&timer2) >= 240000)
+	INITIALIZE_Reset();
+	if(INITIALIZE_GetStatus() != INITIALIZE_Status_None)
 	{
-		Restart_flag=0;
-		time_clear(&timer2);
+		Log_Printf_Debug("初始化流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
 	}
-	else if(Restart_flag >= 4 && module_switch == 0)//4分钟内重启4次
+	goto_start();
+	INITIALIZE_SetStatus(INITIALIZE_Status_Being);
+	return EXECUTE_Result_Success;
+}
+// 流程处理，放到循环里
+void INITIALIZE_ProcessHandle(void)
+{
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
 	{
-		module_switch=1;
-		pownext_step(STEP_SET_CFUN_0);//模块不断重启，直接进入最小功能模式
-		Log_Printf_Debug("模块关闭中...%d\r\n",module_switch);
+		INITIALIZE_Process();
 	}
-	if(module_switch==1)networkTest_Flag=1;
-	if(set_mincfun_flag == 1)
+}
+
+// 初始化诱因处理
+void INITIALIZE_TriggerHandle(void)
+{
+	enum Result result =ec800m.ready();
+	if(result==Result_Success)
 	{
-		return ;
+		INITIALIZE_Start();
 	}
+}
+
+
+
+
+static enum Result result = Result_None;
+static uint8_t cgreg_n; 
+static uint8_t cgreg_stat; 
+static uint16_t cgreg_lac; 
+static uint32_t cgreg_ci;
+
+static void INITIALIZE_Process(void)
+{
 	// 流程
-	switch(powerstep)
+	switch(pctrl.current_step)
 	{
 		case STEP_START: // 开始
-			pownext_step(STEP_EXIT_SLEEP);
-		   query_cgreg_times = 0; // 查询网络状态的次数
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			ec800m.exit_sleep();
-			pownext_wait_step(STEP_SET_SLEEP, 10);
+			PCTRL_GotoStepWait(&pctrl, STEP_SET_SLEEP, 3, "设置休眠模式");
 			break;
-		
 		case STEP_SET_SLEEP: // 设置休眠模式
 			result = ec800m.set_sleep(1);
-
-			if(result == Result_Success)
+			if(result != Result_None)
 			{
-				Log_Printf_Debug("设置休眠模式成功\r\n");
-					pownext_wait_step(STEP_SET_CFUN_1,3);
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
 			}
 			else if(result == Result_Failed)
 			{
-				Log_Printf_Debug("设置休眠模式失败\r\n");
-				pownext_step(STEP_FAILURE);
+				goto_failure("设置休眠模式失败");
 			}
 			break;
-		case STEP_SET_CFUN_1:
-					result = ec800m.set_cfun(1);
-		    		    
+		case STEP_SET_CFUN_1: // 设置全功能模式
+			result = ec800m.set_cfun(1);
 			if(result == Result_Success)
 			{
-				pownext_step(STEP_SET_CGREG_2);
+				PCTRL_GotoStep(&pctrl, STEP_SET_CGREG_2, "设置ps域");
 			}
 			else if(result == Result_Failed)
 			{
-				power_failure("设置全功能模式失败");
+				goto_failure("设置全功能模式失败");
 			}
 			break;
 		case STEP_SET_CGREG_2: // 设置ps域
 			result = ec800m.set_cgreg(2);
 			if(result == Result_Success)
 			{
-				pownext_step(STEP_QUERY_CGREG);
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CGREG, "查询ps域");
 			}
 			else if(result == Result_Failed)
 			{
-				power_failure("设置ps域失败");
+				goto_failure("设置ps域失败");
 			}
 			break;
 		case STEP_QUERY_CGREG: // 查询ps域
@@ -202,60 +231,46 @@ void Initialize_Handle(void)
 			{
 				if(cgreg_stat == 1)
 				{
-					// 下一步
-			    power_success("查询PS域成功");
-				}
-				else if(query_cgreg_times > 20) // 最多查询20次
-				{
-					power_failure("查询ps域次数过多");
+					goto_success();
 				}
 				else
 				{
-					pownext_wait_step(STEP_QUERY_CGREG,400);
-					query_cgreg_times++;
+					PCTRL_GotoWait(&pctrl, 500);
 				}
 			}
 			else if(result == Result_Failed)
 			{
-				power_failure("查询ps域失败");
+				goto_failure("查询ps域失败");
 			}
 			break;
-		case STEP_WAIT: // 等待
-			powerwait();
-			break;
-		case STEP_SUCCESS: // 成功
-			pownext_step(STEP_SET_CFUN_0);
-			Log_Printf_Debug("初始化成功\r\n");
-			break;
-		case STEP_FAILURE: // 失败
-			pownext_step(STEP_SET_CFUN_0);
-			Log_Printf_Debug("初始化失败\r\n");
-			break;
 		case STEP_SET_CFUN_0: // 设置最小功能模式
 			result = ec800m.set_cfun(0);
-			if(result == Result_Success)
+			if(result != Result_None)
 			{
-				Log_Printf_Debug("设置最小功能模式成功\r\n");
-				pownext_step(STEP_ENTER_SLEEP);
-			}
-			else if(result == Result_Failed)
-			{
-				Log_Printf_Debug("设置最小功能模式失败\r\n");
-				pownext_step(STEP_ENTER_SLEEP);
+				PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
 			}
 			break;
 		case STEP_ENTER_SLEEP: // 进入睡眠
 			ec800m.enter_sleep();
-			pownext_step(STEP_FINISH);
+			goto_finish();
+			break;
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;
+		case STEP_SUCCESS: // 成功
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
 			break;
 		case STEP_FINISH: // 结束流程
-		  set_mincfun_flag=1;
 			break;
 		default:
+			goto_failure("步骤不存在");
 			break;
 	}
-	
 }
+
 #endif
 
 

Drivers/Modules/ec800m/Ec800m_Regist.c

@@ -1,25 +1,9 @@
 #include "CONFIG.h"
 #if  EC800M
 
-/**
-  ******************************************************************************
-  * 版   本       ：V1.0.0
-  * 作   者       ：liuyanbin
-  * 版权所有，盗版必究。
-  * Copyright(C) All rights reserved
-  ******************************************************************************
-  *                             历史记录
-  *     序号      版本        变更内容          作者              日期
-  *      1        V0.0.1      实现4G注册      刘艳斌          2023/12/20
-  *      2        V0.0.2      实现NB注册      刘艳斌          2023/12/20
-  *      3        V0.0.3      整合4g和nb      刘艳斌          2024/1/24
-  *
-  ******************************************************************************
-  */
 #include "stm32f10x.h"
 #include "Regist.h"
-#include "ec800m.h"
-#include "INflash.h"
+#include "FlashSetup.h"
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
@@ -30,206 +14,397 @@
 #include "At_Module.h"
 #include "Common_Util.h"
 #include "Tuoreniot.h"
-extern uint8_t mcu_id[8];
-
-static Coefficient_Data flashdata;
 
-static uint8_t tcpconnectID = 2;
-#if  PROD_ENV
-// 生产环境
-static char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
-static uint16_t REGIST_PORT = 8888; //端口号
-#endif
+#include "ec800m.h"
 
-#if TEST_ENV
-// 开发环境
-static char * REGIST_SERVER = "b21759p174.iok.la" ; //注册服务器地址
-static uint16_t REGIST_PORT = 43097; //端口号
-#endif
+// 泵号
+extern uint8_t mcu_id[8];
+// socket ID
+static uint8_t connectID = 2;
 
 // 注册参数
-static struct Regist_Params_Struct regist_params_struct = {
+static struct TUORENIOT_RegistRequestStruct regist_request = {
+	.version = 1,
 	.platform = "aliyun",
-	.connType = "CoAP",
+	.networkProtocol = "CoAP",
 	.deviceId = "3431228A1936013C",
 	.userId = 4562
 };
-static uint8_t regist_data[512];
-static uint16_t regist_data_length;
-
-//清空flash
-void clearflash(void){
-	flashdata.read_flag=0;
-	memset(flashdata.deviceSecret, 0, sizeof(flashdata.deviceSecret));
-	memset(flashdata.productKey, 0, sizeof(flashdata.productKey));
-	memset(flashdata.deviceName, 0, sizeof(flashdata.deviceName));
-	my_delay_ms(10);
-	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
-}
 
-void storedata(void)
+
+/**
+* 
+*注册参数信息打包
+*/
+void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams)
 {
-	flashdata.read_flag=1;
-	strcpy(flashdata.deviceSecret, regist_params_struct.deviceSecret);
-	strcpy(flashdata.productKey, regist_params_struct.productKey);
-	strcpy(flashdata.deviceName, regist_params_struct.deviceName);
 	
-	my_delay_ms(10);
-	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
-	flashdata.read_flag=0;
-	my_delay_ms(10);
-	Log_Printf_Debug("写入数据完成\r\n");
-	STMFLASH_Read(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
-	Log_Printf_Debug("读取完成read_flag:%d,deviceSecret:%s,productKey:%s,deviceName:%s\r\n",flashdata.read_flag,flashdata.deviceSecret,flashdata.productKey,flashdata.deviceName);
+	Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
+	// 设置deviceId
+	bytesToHex(registParams->deviceId, mcu_id, sizeof(mcu_id));
+	
+	sprintf((char *)(pack_data + 2), "{\"platform\":\"%s\",\"connectionType\":\"%s\",\"deviceId\":\"%s\"}", 
+	registParams->platform, registParams->networkProtocol, registParams->deviceId); // 拼接AT指令
+	Log_Printf_Debug("%s\r\n", (char *)(pack_data + 2));
+	
+	uint16_t datalen = utils_aes128_ECB_base64_enc_with_length(regist_key, (pack_data + 2));
+	
+	pack_data[0] = datalen>>8;//头2个字节赋值数据长度
+	pack_data[1] = datalen;
 
+	* pack_data_length = datalen + 2;
 }
 
-//4G模块注册流程
-uint8_t regist_Handle()
-{
-	uint8_t mode,stat,regist_flag = 0;
-	uint16_t lac,err = 0;
-	uint32_t ci = 0;
-	enum Result result = Result_None;
-	ec800m.exit_sleep();//退出休眠
-	my_delay_ms(10);
-	result=ec800m.set_sleep_sync(1);//设置休眠模式
-	if(result==Result_Success)
-	{
-		result=ec800m.set_cfun_sync(1);//设置全功能模式
-	}
-	
-	if(result==Result_Success)
-	{
-		result=ec800m.set_cgreg_sync(2);//设置网络状态
-	}
-	
-	if(result==Result_Success)
-	{
-		for(int i=0;i<20;i++){
-			my_delay_ms(400);
-			result=ec800m.query_cgreg_sync(&mode,&stat,&lac,&ci);//循环查询网络状态最多20次
-			if(stat==1)
-			{
-				i=20;
-			}
-		}
-	}
 
-	if(result==Result_Success&&stat==1)
-	{
-		//tcp连接流程
-		result=ec800m.open_socket_sync(tcpconnectID,"TCP",REGIST_SERVER,REGIST_PORT,1,&err);//连接tcp
-	}
+// 函数声明
+static void REGIST_Process(void); // 注册流程
+static void REGIST_SetStatus(enum REGIST_StatusEnum status); // 设置注册状态
+static void REGIST_SetResult(enum REGIST_ResultEnum result); // 设置注册结果
 
-	if(result==Result_Success)
-	{
-		result = ec800m.set_qisde_sync(0);//关闭回显
-	}
-	
-	if(result==Result_Success)
-	{
-		memset(regist_params_struct.deviceId, 0, sizeof(regist_params_struct.deviceId));
-		byteToHexStr(mcu_id, regist_params_struct.deviceId, sizeof(mcu_id));
-		memset(regist_data, 0, sizeof(regist_data));
-		packRegistParams(regist_data, &regist_data_length, regist_params_struct);
-		printf_regist_param_struct(regist_params_struct);
-		result =ec800m.send_sync(tcpconnectID, regist_data, regist_data_length);//数据发送
-		Log_Printf_Debug("regist_data:\r\n");
-		Log_SendHex(regist_data, regist_data_length);
-		Log_Printf_Debug("\r\n");
-	}
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
 
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("数据发送成功\r\n");
-		memset(regist_data, 0, sizeof(regist_data));
-		result =ec800m.recv_with_time_sync(tcpconnectID,regist_data,&regist_data_length,10000);
-		
-	}
+// 流程
+enum Step{
+	STEP_START, // 开始
+	STEP_EXIT_SLEEP, // 退出睡眠
+	STEP_ENTER_SLEEP, // 进入睡眠
+	STEP_WAIT, // 等待
 	
-	if(result==Result_Success)
-	{
-		// 解析注册数据
-		regist_flag = analysisRegistData(regist_data, regist_data_length, &regist_params_struct);
-		printf_regist_param_struct(regist_params_struct);
-		
-		result=ec800m.close_socket_sync(tcpconnectID);//断开tcp连接
-	}
+	STEP_STATE, // 查询状态
+	STEP_OPEN, // 打开
+	STEP_OPEN_WAIT_RESULT, // 等待打开结果
+	STEP_JUDGE_AUTH_OR_DATA, // 判断认证还是发送
+	STEP_JOIN_AUTH_MESSAGE, // 拼接认证报文
+	STEP_JOIN_DATA_MESSAGE, // 拼接数据报文
+	STEP_QUERY_SLEEP, // 查询休眠
+	STEP_SET_SLEEP, // 开启休眠
+	STEP_QUERY_QENG_SERVINGCELL, // 查询信号质量
+	
+	STEP_SET_QISDE_0, // 关闭发送回显
+	STEP_SEND, // 发送
+	STEP_RECV, // 等待发送结果
+	
+	STEP_SET_CFUN_0, // 设置最小功能模式
+	STEP_WAIT_SET_CFUN_0, // 等待设置最小功能模式
+	STEP_SET_CFUN_1, // 设置全功能模式
+	STEP_WAIT_SET_CFUN_1, // 等待设置全功能模式结果
+	
+	STEP_SET_CGREG_2, // 设置ps域允许上报网络注册和位置信息
+	STEP_QUERY_CGREG, // 查询网络注册状态
+	
+	STEP_CLOSE, // 关闭
+	
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_FINISH, // 流程结束
+	
+	
+	STEP_VERIFY_REGIST, // 验证注册
+	STEP_VERIFY_INITIALIZE, // 验证初始化
+};
 
-	if(result==Result_Success)
+// 步骤跳转时的监听
+static uint8_t STEP_QUERY_CGREG_times = 0; // 查询网络状态的次数
+static void initialize()
+{
+	STEP_QUERY_CGREG_times = 0;
+}	
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置ec800m状态
+	ec800m.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_QUERY_CGREG && STEP_QUERY_CGREG_times++ >= 20)
 	{
-		Log_Printf_Debug("断开tcp连接成功\r\n");
+		goto_failure("查询网络状态的次数过多，联网失败");
+		step = STEP_FAILURE;
 	}
-	
-	ec800m.set_cfun_sync(0);//设置最小功能模式
-	ec800m.enter_sleep();//进入休眠状态
-	
-	return regist_flag;
+	return step;
 }
 
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
 
 
-static uint8_t register_status = 0;//注册成功，向flash存储标志
-uint8_t regist_device_sync(void)
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
 {
-	//未注册开始注册流程
-	register_status=regist_Handle();//注册流程
-	if (register_status==0)//注册流程失败不储存flash
-	{
-		clearflash();
-		Log_Printf_Debug("注册失败！\r\n");
-	}
-	else
-	{
-		storedata();//存储到flash
-		Log_Printf_Debug("注册成功！\r\n");
-	}
-	return register_status;
+	initialize();
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
+}
+
+// 成功
+static void goto_success(void)
+{
+	REGIST_SetResult(REGIST_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
+}
+// 失败
+static void goto_failure(char * _info)
+{
+	REGIST_SetResult(REGIST_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
+}
+// 结束
+static void goto_finish(void)
+{
+	REGIST_SetStatus(REGIST_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
 }
 
 
-static uint8_t read_flash_flag = 0; // 读取flash的标志
-enum Regist_Result regist_get_result(void)
+// 注册状态
+static enum REGIST_StatusEnum regist_status = REGIST_Status_None;
+// 注册结果
+static enum REGIST_ResultEnum regist_result = REGIST_Result_None;
+// 设置注册状态
+static void REGIST_SetStatus(enum REGIST_StatusEnum status)
+{
+	regist_status = status;
+}
+// 获取注册状态
+enum REGIST_StatusEnum REGIST_GetStatus(void)
+{
+	return regist_status;
+}
+// 设置注册结果
+static void REGIST_SetResult(enum REGIST_ResultEnum result)
+{
+	regist_result = result;
+}
+// 获取注册结果
+enum REGIST_ResultEnum REGIST_GetResult(void)
 {
-	if(read_flash_flag == 0)
+	return regist_result;
+}
+// 重置注册
+enum EXECUTE_ResultEnum REGIST_Reset(void)
+{
+	if(REGIST_GetStatus() == REGIST_Status_Being)
 	{
-		flashdata.read_flag=0;
-		//读取flash
-		Log_Printf_Debug("读取前read_flag:%d\r\n",flashdata.read_flag);
-		STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)&flashdata,sizeof(flashdata));//读取flash
-		my_delay_ms(10);
-		//已经注册。读取flash成功
-		if(flashdata.read_flag == 1)
-		{
-			register_status=1;
-			Log_Printf_Debug("读取flash成功read_flag:%d,\ndeviceSecret:%s,\n productKey:%s,\ndeviceName:%s\r\n",flashdata.read_flag,flashdata.deviceSecret,flashdata.productKey,flashdata.deviceName); 
-		}
-		read_flash_flag = 1;
+		Log_Printf_Debug("注册流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
 	}
-	
-  if(flashdata.read_flag == 1){
-    return Regist_Result_Success;
-  }
-  else
-  {
-    return Regist_Result_None;
-  }
+	REGIST_SetStatus(REGIST_Status_None);
+	REGIST_SetResult(REGIST_Result_None);
+	return EXECUTE_Result_Success;
 }
-
-char * regist_get_aliyun_productKey(void)
+// 开始注册
+enum EXECUTE_ResultEnum REGIST_Start(void)
 {
-	return flashdata.productKey;
+	REGIST_Reset();
+	if(REGIST_GetStatus() != REGIST_Status_None)
+	{
+		Log_Printf_Debug("注册流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	goto_start();
+	REGIST_SetStatus(REGIST_Status_Being);
+	return EXECUTE_Result_Success;
 }
-char * regist_get_aliyun_deviceName(void)
+// 注册流程处理，放到大循环里
+void REGIST_ProcessHandle(void)
 {
-  return flashdata.deviceName;
+	if(REGIST_GetStatus() == REGIST_Status_Being)
+	{
+		REGIST_Process();
+	}
 }
-char * regist_get_aliyun_deviceSecret(void)
+
+
+
+// 发送数据的逻辑
+static enum Result result = Result_None;
+static uint8_t cgreg_n; 
+static uint8_t cgreg_stat; 
+static uint16_t cgreg_lac; 
+static uint32_t cgreg_ci;
+static uint16_t socket_err = 0;
+static void REGIST_Process(void)
 {
-	return flashdata.deviceSecret;
+	// 流程
+	switch(pctrl.current_step)
+	{
+		case STEP_START: // 开始
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
+			break;
+		case STEP_EXIT_SLEEP: // 退出休眠
+			ec800m.exit_sleep();
+			PCTRL_GotoStepWait(&pctrl, STEP_SET_SLEEP, 3, "设置休眠模式");
+			break;
+		case STEP_SET_SLEEP: // 设置休眠模式
+			result = ec800m.set_sleep(1);
+			if(result != Result_None)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置休眠模式失败");
+			}
+			break;
+		case STEP_SET_CFUN_1: // 设置全功能模式
+			result = ec800m.set_cfun(1);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_CGREG_2, "设置ps域");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置全功能模式失败");
+			}
+			break;
+		case STEP_SET_CGREG_2: // 设置ps域
+			result = ec800m.set_cgreg(2);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CGREG, "查询ps域");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置ps域失败");
+			}
+			break;
+		case STEP_QUERY_CGREG: // 查询ps域
+			result = ec800m.query_cgreg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
+			if(result == Result_Success)
+			{
+				if(cgreg_stat == 1)
+				{
+					PCTRL_GotoStep(&pctrl, STEP_CLOSE, "断开tcp连接");
+				}
+				else
+				{
+					PCTRL_GotoWait(&pctrl, 500);
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询ps域失败");
+			}
+			break;
+		case STEP_CLOSE: // 关闭连接
+			result = ec800m.close_socket(connectID);
+			if(result == Result_Success)
+			{
+				if(REGIST_GetResult() != REGIST_Result_None)
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_0, "关闭发送回显");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("断开tcp连接失败");
+			}
+			break;
+		case STEP_SET_QISDE_0: // 关闭发送回显
+			result = ec800m.set_qisde(0);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_OPEN, "连接tcp");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("关闭发送回显失败");
+			}
+			break;
+		case STEP_OPEN: // 打开客户端
+			result=ec800m.open_socket(connectID, "TCP", REGIST_SERVER, REGIST_PORT, 1, &socket_err);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据");
+				// 打包注册请求
+				memset(regist_data, 0, sizeof(regist_data));
+				TUORENIOT_PackRegistRequest(regist_data, &regist_data_length, &regist_request);
+				Log_Printf_Debug("regist_data: \r\n");
+				Log_SendHex(regist_data, regist_data_length);
+				Log_Printf_Debug("\r\n");
+				TUORENIOT_PrintfRegistRequestStruct(&regist_request);
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("连接tcp失败");
+			}
+			break;
+		case STEP_SEND: // 发送send
+			result = ec800m.send(connectID, regist_data, regist_data_length);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_RECV, "等待结果");
+				memset(regist_data, 0, sizeof(regist_data));
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("发送数据失败");
+			}
+			break;
+		case STEP_RECV: // 等待结果
+			result = ec800m.recv_with_time(connectID, regist_data, &regist_data_length, 10000);
+			if(result == Result_Success)
+			{
+				uint8_t res = TUORENIOT_AnalysisRegistData(regist_data, regist_data_length);
+				if(res == 1) // 成功
+				{
+					goto_success();
+				}
+				else // 失败
+				{
+					goto_failure("解析失败");
+				}
+				PCTRL_GotoStep(&pctrl, STEP_CLOSE, "断开tcp连接");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("等待结果失败");
+			}
+			break;
+		case STEP_SET_CFUN_0: // 设置最小功能模式
+			result = ec800m.set_cfun(0);
+			if(result != Result_None)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
+			}
+			break;
+		case STEP_ENTER_SLEEP: // 进入睡眠
+			ec800m.enter_sleep();
+			goto_finish();
+			break;
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;
+		case STEP_SUCCESS: // 成功
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+			break;
+		case STEP_FINISH: // 结束流程
+			break;
+		default:
+			goto_failure("步骤不存在");
+			break;
+	}
+	
 }
 
-
 #endif
 

Drivers/Modules/ec800m/ec800m.c

@@ -314,21 +314,48 @@ static uint8_t verifyActiveID(uint8_t activeID)
 static enum Result overtime(void)
 {
 	setStatus(Status_Overtime); // 超时
+	
+	// 发送日志
+	Log_Printf_Debug("接收超时: %d\r\n", AT_result_length());
+	Log_SendArray_Debug(AT_result(), AT_result_length());
+	
 	return Result_Failed; // 结果
 }
 // 返回成功结果
-static enum Result success(void)
+static enum Result success_no_log(void)
 {
 	// 成功
 	setStatus(Status_Success);
 	// 结果
 	return Result_Success;
 }
+// 返回成功结果
+static enum Result success(void)
+{
+	// 发送日志
+	Log_Printf_Debug("接收成功: %d\r\n", AT_result_length());
+	Log_SendArray_Debug(AT_result(), AT_result_length());
+	return success_no_log();
+}
 // 返回失败结果
-static enum Result failed(void)
+static enum Result failed(int type)
 {
 	// 失败
 	setStatus(Status_Failed);
+	if(type == 1)
+	{
+		Log_Printf_Debug("activeID: %d, error: 接收结果过期，请重置状态\r\n", ec800m.activeID); // 打印日志
+	}
+	else if(type == 2)
+	{
+		// 发送日志
+		Log_Printf_Debug("activeID: %d, AT接收失败: %d\r\n", ec800m.activeID, AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+	}
+	else
+	{
+		Log_Printf_Debug("activeID: %d, error: 未知错误类型\r\n", ec800m.activeID); // 打印日志
+	}
 	// 失败结果
 	return Result_Failed;
 }
@@ -344,23 +371,14 @@ void ec800m_reset(void)
 	AT_Clear(); // 清除AT指令
 }
 
-// 退出休眠
-void ec800m_exit_sleep(void)
-{
-	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉低io口，唤醒模组
-}
 
-// 进入休眠
-void ec800m_enter_sleep(void)
-{
-	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉高io口，进入睡眠
-}
 // 发送指令并改变状态
-enum Result send_at(char * cmd, uint8_t activeID)
+enum Result send_at_nolog(char * cmd, uint8_t activeID)
 {
-	Log_Printf_Debug(cmd); // 打印AT指令
 	if(send_at_string(cmd)) // 发送AT指令
 	{
+		Log_Printf_Debug("发送成功: %d\r\n", strlen(cmd)); // 打印日志
+		
 		setActiveID(activeID); // 活动ID
 		setStatus(Status_Sending); // 设置已发送
 		clearTimer(); // 重置计时
@@ -368,12 +386,35 @@ enum Result send_at(char * cmd, uint8_t activeID)
 	}
 	else
 	{
-		Log_Printf_Debug("AT指令发送失败\r\n"); // 打印日志
+		Log_Printf_Debug("activeID: %d, error: AT指令发送失败\r\n", ec800m.activeID); // 打印日志
+		
 		return Result_Failed; // 失败结果
 	}
 }
 
+enum Result send_at(char * cmd, uint8_t activeID)
+{
+	enum Result result = send_at_nolog(cmd, activeID);
+	if(result == Result_None) // 发送成功
+	{
+		Log_Printf_Debug(cmd); // 打印AT指令
+	}
+	return result;
+}
+
+
+
+// 退出休眠
+void ec800m_exit_sleep(void)
+{
+	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉低io口，唤醒模组
+}
 
+// 进入休眠
+void ec800m_enter_sleep(void)
+{
+	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉高io口，进入睡眠
+}
 
 /**
 * 查询休眠模式
@@ -396,20 +437,15 @@ enum Result ec800m_query_sleep(uint8_t * n)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 	
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -425,15 +461,10 @@ enum Result ec800m_query_sleep(uint8_t * n)
 		// 获取mode
 		* n = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
 		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -483,30 +514,19 @@ enum Result ec800m_set_sleep(uint8_t n)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
 		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -557,13 +577,10 @@ enum Result ec800m_set_cfun(uint8_t fun)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
@@ -571,20 +588,12 @@ enum Result ec800m_set_cfun(uint8_t fun)
 		// 防止接收不完整
 		if(AT_wait_time() > 10) // 过10ms之后再取数据，避免数据截断。
 		{
-			// 发送日志
-			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-			Log_SendArray_Debug(AT_result(), AT_result_length());
-			
 			result = success(); // 成功
 		}
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -636,30 +645,19 @@ enum Result ec800m_set_cgreg(uint8_t n)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
 		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -713,21 +711,15 @@ enum Result ec800m_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 		
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -746,16 +738,10 @@ enum Result ec800m_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 		* ci = strtoul(strtok_r(NULL, split_inner, &saveptr_inner), NULL, 16);
 		// 打印
 		Log_Printf_Debug("mode: %d, stat: %d, lac: %d, ci: %d\r\n", * n, * stat, * lac, * ci);
-		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -809,19 +795,15 @@ enum Result ec800m_query_socket_state(uint8_t connectID, uint8_t * state)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 		
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -847,16 +829,10 @@ enum Result ec800m_query_socket_state(uint8_t connectID, uint8_t * state)
 		}
 		// 打印
 		Log_Printf_Debug("result: %d\r\n", * state);
-		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -913,20 +889,15 @@ enum Result ec800m_open_socket(uint8_t connectID, char * service_type, char * IP
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "+QIOPEN: ") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 		
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -948,16 +919,10 @@ enum Result ec800m_open_socket(uint8_t connectID, char * service_type, char * IP
 			* err = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
 			Log_Printf_Debug("result: %d, %d\r\n", connID, * err);
 		}
-		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -1015,29 +980,19 @@ enum Result ec800m_close_socket(uint8_t connectID)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
 		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -1087,29 +1042,19 @@ enum Result ec800m_set_qisde(uint8_t echo)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
 		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -1163,12 +1108,10 @@ enum Result ec800m_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "> ") != NULL) // 有响应
@@ -1187,27 +1130,15 @@ enum Result ec800m_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	}
 	else if(strstr((char * )AT_result(), "SEND OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
 		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "SEND FALL\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -1326,12 +1257,10 @@ enum Result ec800m_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t *
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("等待时间超时\r\n"); // 打印日志
 		result = overtime(); // 超时
 	}
 	else
@@ -1340,7 +1269,7 @@ enum Result ec800m_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t *
 		result = ec800m.recv(connectID, data, data_length);
 		if(result == Result_Success)
 		{
-			result = success(); // 成功
+			result = success_no_log(); // 成功
 		}
 	}
 	return result;
@@ -1395,20 +1324,14 @@ enum Result ec800m_power_down(uint8_t n)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime();
 	}
 	else if(strstr((char * )AT_result(), "POWERED DOWN\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		// 成功结果
 		result = success();
 	}
 	return result;
@@ -1492,21 +1415,15 @@ enum Result ec800m_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SI
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 		
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -1539,15 +1456,10 @@ enum Result ec800m_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SI
 		// 打印
 		Log_Printf_Debug("RSRP: %d, RSRQ: %d, RSSI: %d, SINR: %d\r\n", * RSRP, * RSRQ, * RSSI, * SINR);
 		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }
@@ -1590,21 +1502,15 @@ enum Result ec800m_query_qccid(char * iccid)
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
-		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		
-		result = failed(); // 失败
+		result = failed(1); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
-		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		
 		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = success(); // 成功
 		
 		// 处理返回结果
 		char * saveptr = NULL;
@@ -1624,15 +1530,10 @@ enum Result ec800m_query_qccid(char * iccid)
 		// 打印
 		Log_Printf_Debug("ICCID: %s\r\n", iccid);
 		
-		result = success(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
 	{
-		// 发送日志
-		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
-		Log_SendArray_Debug(AT_result(), AT_result_length());
-		
-		result = failed(); // 失败
+		result = failed(2); // 失败
 	}
 	return result;
 }

Drivers/Utils/Common_Util.c

@@ -102,6 +102,16 @@ void byteToHexStr(const unsigned char* source, char* dest, int sourceLen)
     return ;  
 }
 
+void bytesToHex(char * dest, uint8_t * source, uint16_t source_length)
+{
+	int i = 0;
+	for(; i < source_length; i++)
+	{
+		sprintf(dest + 2 * i, "%02X", source[i]);
+	}
+//	*(dest + 2 * i + 1) = 0;
+}
+
 
 uint8_t memmem(uint8_t * result,uint16_t result_length, uint8_t *rdystring,uint8_t rdylen)
 {

Drivers/Utils/Common_Util.h

@@ -18,6 +18,8 @@ char* my_itoa(int num,char* str,int radix);
 //×Ö½ÚÁ÷תHEX×Ö·û´®
 void byteToHexStr(const unsigned char* source, char* dest, int sourceLen);
 
+void bytesToHex(char * dest, uint8_t * source, uint16_t source_length);
+
 uint8_t memmem(uint8_t * result,uint16_t result_length, uint8_t *rdystring,uint8_t rdylen);
 
 

User/main.c

@@ -16,6 +16,7 @@
 
 #include "CONFIG.h"
 #include "mbedtls_util.h"
+#include "Common_Util.h"
 
 #include "Timer_Module.h"
 #include "Log_Module.h"
@@ -25,16 +26,16 @@
 #include "bc260y.h"
 #include "At_Module.h"
 
+// 6365736869303036
 uint8_t mcu_id[8] = "ceshi006";
 
 // 计时器
 static struct TIMER_Struct timer;
-//static uint8_t send_flag = 1;
-//static char AT_CMD[512];
-//static char pridnsaddr[20];
 
 static uint8_t regist_flag = 0;
 
+char ch[30] = "11111111111111111111111111111";
+
 int main(void)
 {
 //	uint8_t memmem_flag = 0;
@@ -49,27 +50,11 @@ int main(void)
 	
 	Log_Printf_Debug("1234\r\n");
 	
+	bytesToHex(ch, mcu_id, sizeof(mcu_id));
+	
+	
 	// 通讯流程初始化
 	PUMPBUSINESS_Init();
-//	my_delay_ms(5000);
-	
-	//注册设备
-//	if(regist_get_result() == Regist_Result_None)
-//	{
-//		uint8_t state = regist_device_sync();
-//		if(state == 1)
-//		{
-//			// 注册成功
-//		}
-//		else
-//		{
-//			// 注册失败
-//		}
-//	}
-//	
-//	Log_Printf_Debug("注册结束\r\n");
-//	
-//	Log_Printf_Debug("code: %d", regist_get_result());
 	
 	while(1)
 	{
@@ -84,17 +69,17 @@ int main(void)
 		// 注册接口使用方法
 		if(regist_flag == 0)
 		{
-			if(REGIST_GetResult() != REGIST_Result_Success)
+			if(TUORENIOT_GetCodeOfRegistResponse() != 200)
 			{
 				Log_Printf_Debug("开始注册\r\n");
 				// 开始注册
 				REGIST_Start();
-				regist_flag = 1;
 			}
 			else
 			{
 				Log_Printf_Debug("已注册\r\n");
 			}
+			regist_flag = 1;
 		}