代码结构调整

Drivers/Business/PumpBusiness.c

@@ -95,7 +95,7 @@ void Pump_Params_Refresh(void)
 
 
 
-static uint32_t Business_wait_time = 600; // 秒
+static uint32_t Business_wait_time = 1200; // 秒
 // 业务处理
 void PumpBusines_Handle(void)
 {
@@ -116,7 +116,7 @@ void PumpBusines_Handle(void)
 	// 发送
 	if(UDP_Client_Status() == Client_Status_None)
 	{
-		if(test_switch==1&&Data_Number>=100)//测试模式只发100条数据
+		if(test_switch==1 && Data_Number>=100)//测试模式只发100条数据
 		{
 			send_data_switch=0;
 			return ;
@@ -164,6 +164,11 @@ void PumpBusines_Handle(void)
 // 循环执行
 void pump_business_loop_execution()
 {
+	// 没注册，直接返回
+	if(regist_get_result() == Regist_Result_Failure)
+	{
+		return;
+	}
 	// 初始化
 	Initialize_Handle();
 	// 业务处理

Drivers/CONFIG.h

@@ -7,8 +7,8 @@
 
 
 
-#define EC800M 1 //4G开关，不能数字开头
-//#define BC260Y 1  // NB
+//#define EC800M 1 //4G开关，不能数字开头
+#define BC260Y 1  // NB
 
 
 

Drivers/Modules/Timer_Module.c

@@ -51,3 +51,14 @@ void time_clear(struct TIMER_Struct * timer)
 	timer->time = 0;
 }
 
+
+// ÑÓʱº¯Êý
+void my_delay_ms(uint32_t ms)
+{
+	struct TIMER_Struct timer = {
+		.time = 0,
+		.flag = 0,
+	};
+	while(time_get_delay(&timer) < ms){}
+}
+

Drivers/Modules/Timer_Module.h

@@ -12,4 +12,9 @@ struct TIMER_Struct
 uint32_t time_get_delay(struct TIMER_Struct * timer);
 void time_clear(struct TIMER_Struct * timer);
 
+
+
+// ÑÓʱº¯Êý
+void my_delay_ms(uint32_t ms);
+
 #endif

Drivers/Modules/bc260y/BC260Y_UDP_Client5.c

@@ -22,19 +22,18 @@
 #include <string.h>
 #include <stdlib.h>
 
-
 #include "UDP_Client.h"
-#include "CoAP_Util.h"
 #include "Timer_Module.h"
+#include "Log_Module.h"
+
 #include "mbedtls_util.h"
-#include "Regist.h"
+
 #include "cJSON.h"
 #include "bc260y.h"
 #include "Pump_Dicts_Util.h"
-#include "INflash.h"
+#include "Regist.h"
 #include "PumpBusiness.h"
 #include "aliyuniot.h"
-#include "Log_Module.h"
 #include "Initialize.h"
 
 // 流程
@@ -56,9 +55,11 @@ enum Step{
 	STEP_QUERY_QENG_SERVINGCELL, // 查询信号质量
 	
 	STEP_SET_QISDE_0, // 关闭发送回显
+	STEP_SET_QISDE_1,
 	STEP_SEND, // 发送
 	STEP_RECV, // 等待发送结果
 	
+	STEP_QUERY_CFUN,
 	STEP_SET_CFUN_0, // 设置最小功能模式
 	STEP_WAIT_SET_CFUN_0, // 等待设置最小功能模式
 	STEP_SET_CFUN_1, // 设置全功能模式
@@ -80,7 +81,6 @@ enum Step{
 static enum Step step = STEP_NONE;
 // 下一步
 static enum Step next_step = STEP_NONE;
-static uint8_t resend_counter = 0;//nb失败重发标志
 // 客户端5
 struct UDP_Client_Struct client = {
 	.status = Client_Status_None,
@@ -133,10 +133,10 @@ void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
 // 初始化
 void UDP_Client_Init(void)
 {
+//   aliyuniot_set_device_params("he1fAihB9M9", "123456", "76ef28342ee0760d781af138095b8fe4");
    aliyuniot_set_device_params(regist_get_aliyun_productKey(),regist_get_aliyun_deviceName(),regist_get_aliyun_deviceSecret());
 //	aliyuniot_set_device_params(flashdata.productKey,flashdata.deviceName,flashdata.deviceSecret);
 	// 设置host
-  resend_counter=0;//失败重发置0
 }
 // 声明函数。步骤跳转
 void goto_step(enum Step ns);
@@ -244,16 +244,17 @@ 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 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;
+static uint8_t resend_counter = 0;//nb失败重发标志
+static uint8_t cfun_mode = 0;
 void UDP_Client_Handle(void)
 {
-	
-		// 如果模块正在初始化，直接返回发送失败
+	// 如果模块正在初始化，直接返回发送失败
 	InitializeResult = get_initialize_status();
 	if(InitializeResult==Initialize_Result_Busy)
 	{
@@ -266,68 +267,99 @@ void UDP_Client_Handle(void)
 		case STEP_NONE: // 空闲
 			break;
 		case STEP_START: // 开始
-			query_cgreg_times = 0; // 查询网络状态的次数
+			Log_Printf_Debug("开始\r\n");
 			auth_times = 0; // 认证次数
+//			goto_step(STEP_EXIT_SLEEP);
 			goto_step(STEP_EXIT_SLEEP);
 			break;
-		case STEP_VERIFY_REGIST: // 验证是否注册
-			regist_result = regist_get_result();
-			if(regist_result == Regist_Result_Success)
+		case STEP_EXIT_SLEEP: // 退出休眠
+			result = bc260y.exit_sleep();
+		  if(result == Result_Success)
 			{
-				goto_step(STEP_VERIFY_INITIALIZE);
+				Log_Printf_Debug("退出休眠成功\r\n");
+				goto_step(STEP_SET_QISDE_1);
 			}
-			else
+			else if(result == Result_Failed)
 			{
-				goto_failure("设备未注册");
+				goto_failure("退出休眠失败");
 			}
 			break;
-		case STEP_EXIT_SLEEP: // 退出休眠
-			result = bc260y.exit_sleep();
-		    if(result == Result_Success)
+		case STEP_SET_QISDE_1: // 开启回显
+			result = bc260y.set_qisde(1);
+			if(result == Result_Success)
 			{
-				goto_step_wait(STEP_SET_CFUN_1, 5);
+				goto_step(STEP_SET_SLEEP);
 			}
 			else if(result == Result_Failed)
 			{
-				goto_step_wait(STEP_SET_CFUN_1, 100);
+				goto_failure("开启回显失败");
 			}
 			break;
-
-		case STEP_SET_CFUN_1: // 设置全功能模式
-			result = bc260y.set_cfun(1);
+		case STEP_SET_SLEEP: // 设置休眠模式
+			result = bc260y.set_sleep(1);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_CGREG_2);
+				goto_step(STEP_DATAFORMAT);
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("设置全功能模式失败");
+				goto_failure("设置休眠模式失败");
 			}
 			break;
-		case STEP_SET_CGREG_2: // 设置ps域
-			result = bc260y.set_cgreg(2);
+		case STEP_DATAFORMAT:
+			result = bc260y.dataformat(0);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_QISDE_0);
+			 goto_step(STEP_QUERY_CFUN);
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("设置ps域失败");
+				goto_failure("配置发送格式失败");
+			}
+		   break;
+		case STEP_QUERY_CFUN: // 查询功能模式
+			result = bc260y.query_cfun(&cfun_mode);
+			if(result == Result_Success)
+			{
+				if(cfun_mode == 0)
+				{
+					goto_step(STEP_SET_CFUN_1);
+				}
+				else
+				{
+					goto_step(STEP_SET_CGREG_2);
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询功能模式失败");
+			}
+		   break;
+		case STEP_SET_CFUN_1: // 设置全功能模式
+			result = bc260y.set_cfun(1);
+			if(result == Result_Success)
+			{
+				Log_Printf_Debug("设置全功能模式成功\r\n");
+				goto_step(STEP_SET_CGREG_2);
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置全功能模式失败");
 			}
 			break;
-		case STEP_SET_QISDE_0: // 关闭回显
-			result = bc260y.set_qisde(0);
+		case STEP_SET_CGREG_2: // 设置ps域
+			result = bc260y.set_cereg(2);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_QUERY_CGREG);
+				goto_step_wait(STEP_QUERY_CGREG, 400);
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("关闭回显失败");
+				goto_failure("设置ps域失败");
 			}
 			break;
 		case STEP_QUERY_CGREG: // 查询ps域
-			result = bc260y.query_cgreg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
+			result = bc260y.query_cereg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
 			if(result == Result_Success)
 			{
 				if(cgreg_stat == 1)
@@ -346,14 +378,9 @@ void UDP_Client_Handle(void)
 						goto_step(STEP_QUERY_QENG_SERVINGCELL);
 					}
 				}
-				else if(query_cgreg_times > 10) // 最多查询20次
-				{
-					goto_failure("查询ps域次数过多");
-				}
 				else
 				{
-					goto_wait(400);
-					query_cgreg_times++;
+					goto_failure("网络注册失败");
 				}
 			}
 			else if(result == Result_Failed)
@@ -361,7 +388,7 @@ void UDP_Client_Handle(void)
 				goto_failure("查询ps域失败");
 			}
 			break;
-			case STEP_QUERY_QENG_SERVINGCELL: // 查询信号质量
+		case STEP_QUERY_QENG_SERVINGCELL: // 查询信号质量
 			result = bc260y.qeng_servingcell(&signal.RSRP, &signal.RSRQ, &signal.RSSI, &signal.SINR);
 			if(result == Result_Success)
 			{
@@ -376,24 +403,13 @@ void UDP_Client_Handle(void)
 			result = bc260y.close_socket(connectID);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_DATAFORMAT);
+				goto_step(STEP_OPEN);
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("关闭连接失败");
 			}
 			break;
-		case STEP_DATAFORMAT:
-			result = bc260y.dataformat(1);
-			if(result == Result_Success)
-			{
-			 goto_step(STEP_OPEN);
-			}
-			else if(result == Result_Failed)
-			{
-				goto_failure("配置发送格式失败");
-			}
-		   break;
 		case STEP_OPEN: // 打开客户端
 			result = bc260y.open_socket(connectID, "UDP",aliyuniot_get_host(), aliyuniot_get_port(), 1, &socket_err);
 			if(result == Result_Success)
@@ -424,23 +440,28 @@ void UDP_Client_Handle(void)
 			}
 			break;
 		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
+			Log_Printf_Debug("拼接认证报文\r\n");
 			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_SEND);
 				auth_times++;
 			}
 			break;
 		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
+			Log_Printf_Debug("拼接数据报文\r\n");
 			pump_params.lac = cgreg_lac;
 			pump_params.ci = cgreg_ci;
 			Pump_Params_Refresh();
 					// 编码
+			memset(databuff, 0, sizeof(databuff));
 			business_protocol_encode(pump_params, databuff, &data_length);
+			memset(coap_message, 0, sizeof(coap_message));
 			aliyuniot_get_data_message(databuff, data_length, coap_message, &coap_message_length);
 			goto_step(STEP_SEND);
 			break;
@@ -483,28 +504,33 @@ void UDP_Client_Handle(void)
 			wait();
 			break;
 		case STEP_SUCCESS: // 成功
-			goto_step(STEP_SET_SLEEP);
+			goto_step(STEP_ENTER_SLEEP);
 			break;
 		case STEP_FAILURE: // 失败
-			if(resend_counter>=2){
-			goto_step(STEP_SET_SLEEP);
-			}
-			else
-			{
-				//重发2次
 			resend_counter++;
-			goto_step(STEP_SET_CFUN_1);	
-			}
+			goto_step(STEP_SET_CFUN_0);
 			break;
-		case STEP_SET_SLEEP: // 设置休眠模式
-			result = bc260y.set_sleep(1);
-			if(result != Result_None)
+		case STEP_SET_CFUN_0: // 设置最小功能模式
+			result = bc260y.set_cfun(0);
+			if(result == Result_Success)
+			{
+				Log_Printf_Debug("设置最小模式成功\r\n");
+				if(resend_counter > 1) // 重发次数
+				{
+					goto_step(STEP_ENTER_SLEEP);
+				}
+				else
+				{
+					goto_step(STEP_START);
+				}
+			}
+			else if(result == Result_Failed)
 			{
-			   goto_step(STEP_ENTER_SLEEP);
+				goto_step(STEP_ENTER_SLEEP);
 			}
 			break;
 		case STEP_ENTER_SLEEP: // 进入睡眠
-			//bc260y.enter_sleep();
+			resend_counter=0;//失败重发置0
 			goto_step(STEP_FINISH);
 			break;
 		case STEP_FINISH: // 结束流程

Drivers/Modules/bc260y/Bc260y_Initialize.c

@@ -20,14 +20,18 @@ enum PowerStep{
 	STEP_EXIT_SLEEP, // 退出睡眠
 	STEP_ENTER_SLEEP, // 进入睡眠
 	STEP_SET_SLEEP ,// 设置休眠模式
+	STEP_QUERY_CFUN,
+	STEP_SET_CFUN_0,
 	STEP_SET_CFUN_1, // 设置全功能模式
 	STEP_WAIT_SET_CFUN_1, // 等待设置全功能模式结果
 	STEP_WAIT, // 等待
 	STEP_SET_QISDE_0,
+	STEP_SET_QISDE_1,
 	STEP_SET_CGREG_2, // 设置ps域允许上报网络注册和位置信息
 	STEP_QUERY_CGREG, // 查询网络注册状态
 	STEP_SUCCESS, // 成功
 	STEP_FAILURE, // 失败
+	STEP_FINISH,
 };
 // 当前
 static enum PowerStep powerstep = STEP_START;
@@ -42,7 +46,7 @@ static struct TIMER_Struct timer;
 // 计时相关的变量
 static uint32_t Power_wait_time = 10;
 
-static uint8_t set_mincfun_flag=0;//0代表正在初始化，1代表空闲
+static uint8_t set_mincfun_flag=1;//0代表正在初始化，1代表空闲
 
 static uint8_t cgreg_n; 
 static uint8_t cgreg_stat; 
@@ -52,7 +56,6 @@ static uint8_t query_cgreg_times = 0; //
 //// 声明函数。步骤跳转
 void pownext_step(enum PowerStep ns);
 // 发送流程
-void Power_Handle(void);
 
 // 等待
 static void powerwait(void)
@@ -66,9 +69,7 @@ static void powerwait(void)
 // 失败
 static void power_failure(char * info)
 {
-	Log_Printf_Debug("STEP: 数据发送失败,%s\r\n", info);
-//	UDP_Client5.status = Client_Status_Failure;
-//	strcpy(UDP_Client5.info, info);
+	Log_Printf_Debug("STEP: 初始化失败,%s\r\n", info);
 	networkTest_Flag=1;
 	pownext_step(STEP_FAILURE);
 }
@@ -76,9 +77,7 @@ static void power_failure(char * info)
 // 成功
 static void power_success(char * info)
 {
-	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
-//	UDP_Client5.status = Client_Status_Success;
-//	strcpy(UDP_Client5.info, info);
+	Log_Printf_Debug("STEP: 初始化成功,%s\r\n", info);
 	networkTest_Flag=2;
 	pownext_step(STEP_SUCCESS);
 }
@@ -99,8 +98,15 @@ static void pownext_wait_step(enum PowerStep ns, uint32_t t)
 	next_step = ns; // 等待之后跳转
 }
 
+// 只等待，等待之后返回原来的步骤
+static void pownext_wait(uint32_t t)
+{
+	pownext_wait_step(powerstep, t);
+}
+
 // 发送数据的逻辑
 static enum Result result = Result_None;
+static uint8_t cfun_mode = 0;
 //获取初始化状态
 enum Initialize_Result get_initialize_status(void){
 	
@@ -110,10 +116,9 @@ enum Initialize_Result get_initialize_status(void){
 	}
 	else
 	{
-	InitializeResult=Initialize_Result_free;
+		InitializeResult=Initialize_Result_free;
 	}
- return InitializeResult;
-
+	return InitializeResult;
 }
 void Initialize_Handle(void)
 {
@@ -122,9 +127,8 @@ void Initialize_Handle(void)
 	{
 		set_mincfun_flag=0;
 		pownext_wait_step(STEP_START,2000);
-		Log_Printf_Debug("完成准备%d\r\n");
 	}
-	if(set_mincfun_flag==1) 
+	if(set_mincfun_flag==1)
 	{
 		return ;
 	}
@@ -136,17 +140,36 @@ void Initialize_Handle(void)
 		
 		   query_cgreg_times = 0; // 查询网络状态的次数
 			break;
-        case STEP_EXIT_SLEEP: // 退出休眠
-			bc260y.exit_sleep();
-			pownext_wait_step(STEP_SET_SLEEP, 10);
+		case STEP_EXIT_SLEEP: // 退出休眠
+			result = bc260y.exit_sleep();
+			if(result == Result_Success)
+			{
+				Log_Printf_Debug("退出休眠成功\r\n");
+				pownext_wait_step(STEP_SET_QISDE_1, 10);
+			}
+			else if(result == Result_Failed)
+			{
+				Log_Printf_Debug("退出休眠失败\r\n");
+				power_failure("退出休眠失败");
+			}
 			break;
+		case STEP_SET_QISDE_1: // 开启回显
+			result = bc260y.set_qisde(1);
+		   if(result == Result_Success)
+			{
+				pownext_step(STEP_SET_SLEEP);
+			}
+			else if(result == Result_Failed)
+			{
+				power_failure("开启回显失败");
+			}
+		    break;
 		case STEP_SET_SLEEP: // 设置休眠模式
 			result = bc260y.set_sleep(1);
-//            power_times++;
 			if(result == Result_Success)
 			{
 				Log_Printf_Debug("设置休眠模式成功\r\n");
-					pownext_wait_step(STEP_SET_CFUN_1,3);
+				pownext_wait_step(STEP_QUERY_CFUN,3);
 			}
 			else if(result == Result_Failed)
 			{
@@ -154,9 +177,26 @@ void Initialize_Handle(void)
 				pownext_step(STEP_FAILURE);
 			}
 			break;
+		case STEP_QUERY_CFUN: // 查询功能模式
+			result = bc260y.query_cfun(&cfun_mode);
+			if(result == Result_Success)
+			{
+				if(cfun_mode == 0)
+				{
+					pownext_step(STEP_SET_CFUN_1);
+				}
+				else
+				{
+					pownext_step(STEP_SET_CGREG_2);
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				power_failure("查询功能模式失败");
+			}
+		  break;
 		case STEP_SET_CFUN_1:
-					result = bc260y.set_cfun(1);
-		    		    
+			result = bc260y.set_cfun(1);
 			if(result == Result_Success)
 			{
 				pownext_wait_step(STEP_SET_CGREG_2,3);
@@ -167,66 +207,63 @@ void Initialize_Handle(void)
 			}
 			break;
 		case STEP_SET_CGREG_2: // 设置ps域
-			result = bc260y.set_cgreg(2);
+			result = bc260y.set_cereg(2);
 			if(result == Result_Success)
 			{
-				pownext_wait_step(STEP_SET_QISDE_0,5);
+				pownext_wait_step(STEP_QUERY_CGREG,5);
 			}
 			else if(result == Result_Failed)
 			{
 				power_failure("设置ps域失败");
 			}
 			break;
-		case STEP_SET_QISDE_0:
-			result = bc260y.set_qisde(0);
-		   if(result == Result_Success)
-			{
-				pownext_step(STEP_QUERY_CGREG);
-			}
-			else if(result == Result_Failed)
-			{
-				power_failure("关闭回显失败");
-			}
-		    break;
 		case STEP_QUERY_CGREG: // 查询ps域
-			result = bc260y.query_cgreg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
+			result = bc260y.query_cereg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
 			if(result == Result_Success)
 			{
 				if(cgreg_stat == 1)
 				{
-					
 					// 下一步
-			            power_success("查询PS域成功");
-					
+			    power_success("查询PS域成功");
 				}
-				else if(query_cgreg_times > 20) // 最多查询20次
+				else if(query_cgreg_times > 10) // 最多查询10次
 				{
-					power_failure("查询ps域次数过多");
+					power_failure("网络注册失败");
 				}
 				else
 				{
-					pownext_wait_step(STEP_QUERY_CGREG,400);
 					query_cgreg_times++;
+					pownext_wait(400);
 				}
 			}
 			else if(result == Result_Failed)
 			{
-				power_failure("查询ps域失败");
+				power_failure("网络注册失败");
 			}
 			break;
 		case STEP_WAIT: // 等待
 			powerwait();
 			break;
 		case STEP_SUCCESS: // 成功
-//			bc260y.enter_sleep();
-			pownext_wait_step(STEP_START, 50);
-
-		    set_mincfun_flag=1;
-             Log_Printf_Debug("初始化成功\r\n");
+      Log_Printf_Debug("初始化成功\r\n");
+			pownext_step(STEP_FINISH);
 			break;
 		case STEP_FAILURE: // 失败
-//			bc260y.enter_sleep();
-			pownext_wait_step(STEP_START, 500);
+			pownext_step(STEP_SET_CFUN_0);
+			break;
+		case STEP_SET_CFUN_0: // 设置最小功能模式
+			result = bc260y.set_cfun(0);
+			if(result == Result_Success)
+			{
+				pownext_step(STEP_FINISH);
+			}
+			else if(result == Result_Failed)
+			{
+				pownext_step(STEP_FINISH);
+			}
+			break;
+		case STEP_FINISH: // 结束流程
+		  set_mincfun_flag=1;
 			break;
 		default:
 			break;

Drivers/Modules/bc260y/Bc260y_Regist.c

@@ -26,7 +26,6 @@
 #include <string.h>
 #include <stdlib.h>
 #include "cJSON.h"
-#include "Delay.h"
 #include "mbedtls_util.h"
 #include "Log_Module.h"
 #include "At_Module.h"
@@ -62,7 +61,7 @@ void clearflash(void){
 	memset(flashdata.deviceSecret, 0, sizeof(flashdata.deviceSecret));
 	memset(flashdata.productKey, 0, sizeof(flashdata.productKey));
 	memset(flashdata.deviceName, 0, sizeof(flashdata.deviceName));
-	delay_ms(10);
+	my_delay_ms(10);
 	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
 }
 
@@ -73,10 +72,10 @@ void storedata(void)
 	strcpy(flashdata.productKey, regist_params_struct.productKey);
 	strcpy(flashdata.deviceName, regist_params_struct.deviceName);
 	
-	delay_ms(10);
+	my_delay_ms(10);
 	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
 	flashdata.read_flag=0;
-	delay_ms(10);
+	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);
@@ -86,99 +85,111 @@ void storedata(void)
 
 uint8_t regist_Handle()
 {
-uint8_t mode,stat,regist_flag = 0;
+	uint8_t cfun_mode, mode,stat,regist_flag = 0;
 	uint16_t lac,err = 0;
 	uint32_t ci = 0;
- enum Result result = Result_None;
-GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin);
- bc260y.exit_sleep_sync();//退出休眠
- delay_ms(100);
-	bc260y.reset();
- result = bc260y.set_qisde_sync(0);//关闭回显
-   if(result==Result_Failed)
- {
-   return 0;
- }
-  result=bc260y.set_sleep_sync(1);//设置休眠模式
-  if(result==Result_Failed)
- {
-   return 0;
- }
-  result=bc260y.set_cfun_sync(1);//设置全功能模式
- 
-  if(result==Result_Failed)
- {
-   return 0;
- }
-    result=bc260y.set_cgreg_sync(2);//设置网络状态
-  if(result==Result_Failed)
- {
-   return 0;
- }
-
+	enum Result result = Result_None;
+//	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin);
+	result = bc260y.exit_sleep_sync();//退出休眠
+	if(result==Result_Success)
+	{
+		Log_Printf_Debug("退出休眠成功\r\n");
+		result = bc260y.set_qisde_sync(1);//开启回显
+	}
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("开启回显成功\r\n");
+		result=bc260y.set_sleep_sync(1);//设置休眠模式
+	}
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("设置休眠模式成功\r\n");
+		result=bc260y.query_cfun_sync(&cfun_mode);//查询功能模式
+	}
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("查询功能模式成功\r\n");
+		if(cfun_mode == 0)
+		{
+			result=bc260y.set_cfun_sync(1);//设置全功能模式
+		}
+	}
  
-for(int i=0;i<20;i++){
- delay_ms(400);
-  result=bc260y.query_cgreg_sync(&mode,&stat,&lac,&ci);//循环查询网络状态最多20次
-	if(stat==1)
-	{i=20;
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("设置全功能模式成功\r\n");
+		result=bc260y.set_cereg_sync(2);//设置网络状态
+	}
 	
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("设置网络状态成功\r\n");
+		for(uint8_t i = 0; i < 10; i++)
+		{
+			result=bc260y.query_cereg_sync(&mode,&stat,&lac,&ci);//循环查询网络状态最多10次
+			if(result == Result_Failed || stat == 1)
+			{
+				break;
+			}
+			my_delay_ms(400);
+		}
 	}
-}
-
 
-  
-if(result==Result_Success&&stat==1)
+	if(result==Result_Success)
+	{
+		Log_Printf_Debug("网络注册成功\r\n");
+		result=bc260y.close_socket_sync(tcpconnectID);//防止以前链接没断开，断开tcp链接
+	}
+	
+	if(result==Result_Success)
 	{
- result=bc260y.close_socket_sync(tcpconnectID);//防止以前链接没断开，断开tcp链接
+		Log_Printf_Debug("断开tcp链接成功\r\n");
+		result=bc260y.open_socket_sync(tcpconnectID,"TCP",REGIST_SERVER,REGIST_PORT,1,&err);//连接tcp
 	}
-   if(result==Result_Failed)
- {
-	Log_Printf_Debug(" result=%d\r\n", result);
-   return 0;
- }
-  //tcp连接流程
-  result=bc260y.open_socket_sync(tcpconnectID,"TCP",REGIST_SERVER,REGIST_PORT,1,&err);//连接tcp
-  if(result==Result_Failed)
- {
-	Log_Printf_Debug(" result=%d\r\n", result);
-   return 0;
- }
+	
 	if(result==Result_Success)
 	{
+		Log_Printf_Debug("连接tcp成功\r\n");
 		memset(regist_data, 0, sizeof(regist_data));
 		byteToHexStr(mcu_id, regist_params_struct.deviceId, sizeof(mcu_id));
 		packRegistParams(regist_data, &regist_data_length, regist_params_struct);
 		printf_regist_param_struct(regist_params_struct);
 		result =bc260y.send_sync(tcpconnectID, regist_data, regist_data_length);//数据发送
 	}
-   result = bc260y.dataformat_sync(1);//配置发送数据格式
-   if(result==Result_Failed)
- {
-   return 0;
- }
-
-
+	
 	if(result==Result_Success)
 	{
+		Log_Printf_Debug("数据发送成功\r\n");
 		memset(regist_data, 0, sizeof(regist_data));
 		result =bc260y.recv_with_time_sync(tcpconnectID,regist_data,&regist_data_length,10000);
-		if(result==Result_Failed)
-		{
-			return result;
-		}
+	}
+	
+	
+	if(result == Result_Success)
+	{
+		Log_Printf_Debug("数据返回成功\r\n");
 		// 解析注册数据
 		regist_flag = analysisRegistData(regist_data, regist_data_length, &regist_params_struct);
 		printf_regist_param_struct(regist_params_struct);
+		
+		result=bc260y.close_socket_sync(tcpconnectID);//断开tcp连接
 	}
+	
  
   if(result==Result_Success)
- {
-   result=bc260y.close_socket_sync(tcpconnectID);//断开tcp连接
- }
-
+	{
+		Log_Printf_Debug("断开tcp连接成功\r\n");
+	}
+	
+	
+	// 注册失败，进入最小功能模式，防止耗电
+  if(result == Result_Failed)
+	{
+		Log_Printf_Debug("设置最小功能模式\r\n");
+		bc260y.set_cfun_sync(0);//设置最小功能模式
+	}
+	
 
- bc260y.enter_sleep();//进入休眠状态
   return regist_flag;
 }
 
@@ -188,7 +199,7 @@ uint8_t regist_device_sync(void)
 	//读取flash
 	Log_Printf_Debug("读取前read_flag:%d\r\n",flashdata.read_flag);
 	STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)&flashdata,sizeof(flashdata));//读取flash
-	delay_ms(10);
+	my_delay_ms(10);
 	//已经注册。读取flash成功
 	if(flashdata.read_flag == 1)
 	{

Drivers/Modules/bc260y/bc260y.c

@@ -29,7 +29,6 @@
 #include "Common_Util.h"
 
 
-static char hexData[800] = {0};//数据发送的中间数据
 // 方法声明
 
 void bc260y_reset(void); // 重置状态。该文件中的方法共用状态，在使用下面的方法前需要重置一下状态。
@@ -61,6 +60,8 @@ enum Result bc260y_set_sleep_sync(uint8_t n); //
 * 输出>>
 * 
 **/
+enum Result bc260y_query_cfun(uint8_t * n); // 查询功能模式。
+enum Result bc260y_query_cfun_sync(uint8_t * n); // 查询功能模式。
 enum Result bc260y_set_cfun(uint8_t fun);
 enum Result bc260y_set_cfun_sync(uint8_t fun); // 同步
 /**
@@ -70,8 +71,8 @@ enum Result bc260y_set_cfun_sync(uint8_t fun); // 同
 * 输出>>
 * 
 **/
-enum Result bc260y_set_cgreg(uint8_t n);
-enum Result bc260y_set_cgreg_sync(uint8_t n); // 同步
+enum Result bc260y_set_cereg(uint8_t n);
+enum Result bc260y_set_cereg_sync(uint8_t n); // 同步
 /**
 * 查询ps域网络注册状态
 * 输入<<
@@ -83,8 +84,8 @@ enum Result bc260y_set_cgreg_sync(uint8_t n); // 同
 * ci 基站小区ID。用于基站定位，4个字节。
 *
 **/
-enum Result bc260y_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci);
-enum Result bc260y_query_cgreg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 同步
+enum Result bc260y_query_cereg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci);
+enum Result bc260y_query_cereg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 同步
 /** 
 * 查询socket服务状态
 * 输入<<
@@ -227,6 +228,10 @@ static char AT_CMD[256];
 // EC800M提供的一些方法
 struct BC260Y_Struct bc260y =
 {
+	.timer = {
+		.time = 0,
+		.flag = 0
+	},
 	.reset = bc260y_reset,
 	.exit_sleep = bc260y_exit_sleep,
 	.exit_sleep_sync = bc260y_exit_sleep_sync,
@@ -235,12 +240,14 @@ struct BC260Y_Struct bc260y =
 	.query_sleep_sync = bc260y_query_sleep_sync,
 	.set_sleep = bc260y_set_sleep,
 	.set_sleep_sync = bc260y_set_sleep_sync,
+	.query_cfun = bc260y_query_cfun,
+	.query_cfun_sync = bc260y_query_cfun_sync,
 	.set_cfun = bc260y_set_cfun,
 	.set_cfun_sync = bc260y_set_cfun_sync,
-	.set_cgreg = bc260y_set_cgreg,
-	.set_cgreg_sync = bc260y_set_cgreg_sync,
-	.query_cgreg = bc260y_query_cgreg,
-	.query_cgreg_sync = bc260y_query_cgreg_sync,
+	.set_cereg = bc260y_set_cereg,
+	.set_cereg_sync = bc260y_set_cereg_sync,
+	.query_cereg = bc260y_query_cereg,
+	.query_cereg_sync = bc260y_query_cereg_sync,
 	.query_socket_state = bc260y_query_socket_state,
 	.query_socket_state_sync = bc260y_query_socket_state_sync,
 	.open_socket = bc260y_open_socket,
@@ -301,13 +308,18 @@ static void setStatus(enum STATUS status)
 // 获取定时
 static uint32_t getTimerMs(void)
 {
-	return bc260y.timer_ms;
+	return time_get_delay(&bc260y.timer);
 }
-// 设置定时
-static void setTimerMs(uint32_t time)
+// 清除定时
+static void clearTimer(void)
 {
-	bc260y.timer_ms = time;
+	time_clear(&bc260y.timer);
 }
+// 设置定时
+//static void setTimerMs(uint32_t time)
+//{
+//	bc260y.timer_ms = time;
+//}
 // 获取ID
 static uint8_t getActiveID(void)
 {
@@ -358,7 +370,7 @@ void bc260y_reset(void)
 {
 	setStatus(Status_None); // 重置状态
 	setActiveID(0); // 重置ID
-	setTimerMs(0); // 重置计时
+	clearTimer(); // 重置计时
 	AT_Clear(); // 清除AT指令
 }
 // 发送指令并改变状态
@@ -369,7 +381,7 @@ enum Result send_at(char * cmd, uint8_t activeID)
 	{
 		setActiveID(activeID); // 活动ID
 		setStatus(Status_Sending); // 设置已发送
-		setTimerMs(0); // 重置计时
+		clearTimer(); // 重置计时
 		return Result_None; // 未知结果
 	}
 	else
@@ -389,7 +401,7 @@ enum Result bc260y_exit_sleep(void)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT\r\r\n"); // 拼接AT指令
+		sprintf(AT_CMD, "AT\r\n"); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -448,7 +460,7 @@ enum Result bc260y_exit_sleep_sync()
 // 进入休眠
 void bc260y_enter_sleep(void)
 {
-	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // nb拉低io口，进入睡眠
+//	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // nb拉低io口，进入睡眠
 }
 
 
@@ -470,7 +482,7 @@ enum Result bc260y_query_sleep(uint8_t * n)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QSCLK?\r\r\n"); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QSCLK?\r\n"); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -558,7 +570,7 @@ enum Result bc260y_set_sleep(uint8_t n)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QSCLK=%d\r\r\n", n); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QSCLK=%d\r\n", n); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -611,6 +623,91 @@ enum Result bc260y_set_sleep_sync(uint8_t n)
 	return result;
 }
 
+
+
+/**
+* 查询功能模式
+* 输入<<
+* 
+* 输出>>
+* n 功能模式。0 最小功能模式，默认；1 全功能模式。
+*
+**/
+enum Result bc260y_query_cfun(uint8_t * n)
+{
+	enum Result result = Result_None;
+	int activeID = 100, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CFUN?\r\n"); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
+		
+		result = failed(); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
+		result = overtime(); // 超时
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+	}
+	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());
+	
+		// 处理返回结果
+		char * saveptr = NULL;
+		char * split = "\r\n";
+		// 第一行
+		strtok_r((char * )AT_result(), split, &saveptr);
+		// 第二行
+		char * Line2 = strtok_r(NULL, split, &saveptr);
+		// 拆解第二行
+		char * saveptr_inner = NULL;
+		char * split_inner = ": ";
+		strtok_r(Line2, split_inner, &saveptr_inner);
+		// 获取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(); // 失败
+	}
+	return result;
+}
+
+
+enum Result bc260y_query_cfun_sync(uint8_t * n)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = bc260y_query_cfun(n);
+		if(result != Result_None)
+		{
+			// 重置
+			bc260y.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+
+
 /**
 * 设置功能模式
 * fun 0 最小功能模式；1 全功能模式。
@@ -621,7 +718,7 @@ enum Result bc260y_set_cfun(uint8_t fun)
 	int activeID = 4, time; // 活动ID, 超时时间
 	// 校验参数
 	if(fun == 0){ time = 3000; }
-	else if(fun == 1){ time = 8000; }
+	else if(fun == 1){ time = 7000; }
 	else
 	{
 		Log_Printf_Debug("set_cfun params error!\r\n");
@@ -632,7 +729,7 @@ enum Result bc260y_set_cfun(uint8_t fun)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+CFUN=%d\r\r\n", fun); // 拼接AT指令
+		sprintf(AT_CMD, "AT+CFUN=%d\r\n", fun); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -647,7 +744,19 @@ enum Result bc260y_set_cfun(uint8_t fun)
 		Log_SendArray_Debug(AT_result(), AT_result_length());
 		result = overtime(); // 超时
 	}
-	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
+	else if(fun == 1 && strstr((char * )AT_result(), "+IP:") != NULL) // 查询是否返回
+	{
+		// 防止接收不完整
+		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(fun == 0 && strstr((char * )AT_result(), "+CPIN: NOT READY") != NULL) // 查询是否返回
 	{
 		// 防止接收不完整
 		if(AT_wait_time() > 10) // 过10ms之后再取数据，避免数据截断。
@@ -697,7 +806,7 @@ enum Result bc260y_set_cfun_sync(uint8_t fun)
 * 设置ps域网络注册状态
 * n 0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
 **/
-enum Result bc260y_set_cgreg(uint8_t n)
+enum Result bc260y_set_cereg(uint8_t n)
 {
 	enum Result result = Result_None;
 	int activeID = 6, time = 500; // 活动ID, 超时时间
@@ -712,7 +821,7 @@ enum Result bc260y_set_cgreg(uint8_t n)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+CEREG=%d\r\r\n", n); // 拼接AT指令
+		sprintf(AT_CMD, "AT+CEREG=%d\r\n", n); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -752,12 +861,12 @@ enum Result bc260y_set_cgreg(uint8_t n)
 * 输出>>
 * 
 **/
-enum Result bc260y_set_cgreg_sync(uint8_t n)
+enum Result bc260y_set_cereg_sync(uint8_t n)
 {
 	enum Result result = Result_None;
 	while(1)
 	{
-		result = bc260y_set_cgreg(n);
+		result = bc260y_set_cereg(n);
 		if(result != Result_None)
 		{
 			// 重置
@@ -780,7 +889,7 @@ enum Result bc260y_set_cgreg_sync(uint8_t n)
 * ci 基站小区ID。用于基站定位，4个字节。
 *
 **/
-enum Result bc260y_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
+enum Result bc260y_query_cereg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
 {
 	enum Result result = Result_None;
 	int activeID = 9, time = 500; // 活动ID, 超时时间
@@ -789,7 +898,7 @@ enum Result bc260y_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+CEREG?\r\r\n"); // 拼接AT指令
+		sprintf(AT_CMD, "AT+CEREG?\r\n"); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -814,10 +923,12 @@ enum Result bc260y_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 		char * saveptr = NULL;
 		char * split = "\r\n";
 		// 第一行
-		char * Line1 = strtok_r((char * )AT_result(), split, &saveptr);
+		strtok_r((char * )AT_result(), split, &saveptr);
+		// 第二行
+		char * Line2 = strtok_r(NULL, split, &saveptr);
 		char * saveptr_inner = NULL;
 		char * split_inner = ": ,\"";
-		strtok_r(Line1, split_inner, &saveptr_inner);
+		strtok_r(Line2, split_inner, &saveptr_inner);
 		* n = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
 		* stat = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
 		
@@ -851,12 +962,12 @@ enum Result bc260y_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 * ci 基站小区ID。用于基站定位，4个字节。
 *
 **/
-enum Result bc260y_query_cgreg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
+enum Result bc260y_query_cereg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
 {
 	enum Result result = Result_None;
 	while(1)
 	{
-		result = bc260y_query_cgreg(n, stat, lac, ci);
+		result = bc260y_query_cereg(n, stat, lac, ci);
 		if(result != Result_None)
 		{
 			// 重置
@@ -884,7 +995,7 @@ enum Result bc260y_query_socket_state(uint8_t connectID, uint8_t * state)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QISTATE=1,%d\r\r\n", connectID); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QISTATE=1,%d\r\n", connectID); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -988,7 +1099,7 @@ enum Result bc260y_open_socket(uint8_t connectID, char * service_type, char * IP
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QIOPEN=0,%d,\"%s\",\"%s\",%d,%d,%d\r\r\n", connectID, service_type, IP_address, remote_port, 0, access_mode); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QIOPEN=0,%d,\"%s\",\"%s\",%d,%d,%d\r\n", connectID, service_type, IP_address, remote_port, 0, access_mode); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1093,7 +1204,7 @@ enum Result bc260y_close_socket(uint8_t connectID)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QICLOSE=%d\r\r\n", connectID); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QICLOSE=%d\r\n", connectID); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1165,7 +1276,7 @@ enum Result bc260y_set_qisde(uint8_t echo)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "ATE%d\r\r\n", echo); // 拼接AT指令
+		sprintf(AT_CMD, "ATE%d\r\n", echo); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1233,8 +1344,6 @@ enum Result bc260y_set_qisde_sync(uint8_t echo)
 enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 {
 	enum Result result = Result_None;
-//	char hexData[1024] = {0};
-	
 	int activeID = 49, time = 10000; // 活动ID, 超时时间
 	// 校验ID
 	if(!verifyActiveID(activeID)){ return Result_Failed; }
@@ -1242,11 +1351,8 @@ enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		 memset(hexData,0, sizeof(hexData));
-		byteToHexStr(data,hexData, data_length);//nb需要转16进制
-		sprintf(AT_CMD, "AT+QISEND=%d,%d,%s\r\r\n", connectID, data_length,hexData); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QISEND=%d,%d\r\n", connectID, data_length); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
-		
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
@@ -1257,7 +1363,20 @@ enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
 		result = overtime(); // 超时
+	}
+	else if(strstr((char * )AT_result(), ">") != NULL) // 有响应
+	{
+		// 发送日志
+		Log_Printf_Debug("AT6返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
 		
+//		Log_Printf_Debug("coap:\r\n");
+//		Log_SendHex(data, data_length);
+//		Log_Printf_Debug("\r\n");
+		// 发送数据
+		send_data(data, data_length);
+		// 清理一下AT返回结果缓存
+		AT_Clear_Result();
 	}
 	else if(strstr((char * )AT_result(), "SEND OK\r\n") != NULL) // 查询是否返回
 	{
@@ -1292,23 +1411,23 @@ enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 * connectID Socket ID。范围1-11。
 * send_length 发送长度。
 * data 待发送的数据。
-*rai 发送模式，0发送不释放RRC,1发送立即释放RRC,发送返回释放RRC
+*rai 发送模式，0发送不释放RRC,1发送立即释放RRC,2发送返回释放RRC
 * activeID 49
 **/
 enum Result bc260y_send_rai(uint8_t connectID, uint8_t * data, uint16_t data_length,uint8_t rai)
 {
 	enum Result result = Result_None;
 	
-	int activeID = 49, time = 10000; // 活动ID, 超时时间
+	int activeID = 50, time = 10000; // 活动ID, 超时时间
 	// 校验ID
 	if(!verifyActiveID(activeID)){ return Result_Failed; }
 	
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		 memset(hexData,0, sizeof(hexData));
-		byteToHexStr(data,hexData, data_length);//nb需要转16进制
-		sprintf(AT_CMD, "AT+QISEND=%d,%d,%s,%d\r\r\n", connectID, data_length,hexData,rai); // 拼接AT指令
+//		memset(hexData,0, sizeof(hexData));
+//		byteToHexStr(data,hexData, data_length);//nb需要转16进制
+//		sprintf(AT_CMD, "AT+QISEND=%d,%d,%s,%d\r\n", connectID, data_length,hexData,rai); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1413,7 +1532,7 @@ enum Result bc260y_recv(uint8_t connectID, uint8_t * data, uint16_t * data_lengt
 			char * split = "\r";//删除\n，这个会改变解析的值
 			char * Line1 = strtok_r((char * )AT_result(), split, &saveptr);
 			uint8_t Line1_Len = strlen(Line1);
-			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
+//			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
 			 
 			// 分割Line1，获取报文长度
 			char * saveptr_inner = NULL;
@@ -1533,7 +1652,7 @@ enum Result bc260y_power_down(uint8_t n)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QPOWD=%d\r\r\n", n); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QPOWD=%d\r\n", n); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1630,8 +1749,8 @@ enum Result bc260y_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SI
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		//sprintf(AT_CMD, "AT+QENG=\"servingcell\"\r\r\n"); // 拼接AT指令
-		sprintf(AT_CMD, "AT+QENG=0\r\r\n"); // 拼接AT指令
+		//sprintf(AT_CMD, "AT+QENG=\"servingcell\"\r\n"); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QENG=0\r\n"); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
@@ -1716,7 +1835,7 @@ enum Result bc260y_query_qccid(char * iccid)
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
 	{
-		sprintf(AT_CMD, "AT+QCCID\r\r\n"); // 拼接AT指令
+		sprintf(AT_CMD, "AT+QCCID\r\n"); // 拼接AT指令
 		result = send_at(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用

Drivers/Modules/bc260y/bc260y.h

@@ -29,7 +29,8 @@ struct BC260Y_Struct
 {
 	enum STATUS status; // 状态
 	uint16_t activeID; // 活动的编号。下面的每个活动都有一个唯一的编号
-	uint32_t timer_ms; // 计时器
+//	uint32_t timer_ms; // 计时器
+	struct TIMER_Struct timer; // 计时器
 	void (* reset) (void);
 	enum Result (* exit_sleep)(void); // 退出休眠
 	enum Result (* exit_sleep_sync)(void); // 退出休眠
@@ -38,12 +39,14 @@ struct BC260Y_Struct
 	enum Result (* query_sleep_sync)(uint8_t * n); // 查询休眠状态。同步
 	enum Result (* set_sleep)(uint8_t n); // 设置休眠模式
 	enum Result (* set_sleep_sync)(uint8_t n); // 设置休眠模式。同步
+	enum Result (* query_cfun)(uint8_t * n); // 查询功能模式
+	enum Result (* query_cfun_sync)(uint8_t * n); // 查询功能模式。同步
 	enum Result (* set_cfun)(uint8_t fun); // 设置功能模式
 	enum Result (* set_cfun_sync)(uint8_t fun); // 设置功能模式。同步
-	enum Result (* set_cgreg)(uint8_t n); // 设置ps域注册状态。
-	enum Result (* set_cgreg_sync)(uint8_t n); // 设置ps域注册状态。。同步
-	enum Result (* query_cgreg)(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 查询ps域网络注册状态
-	enum Result (* query_cgreg_sync)(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 查询ps域网络注册状态。同步
+	enum Result (* set_cereg)(uint8_t n); // 设置ps域注册状态。
+	enum Result (* set_cereg_sync)(uint8_t n); // 设置ps域注册状态。。同步
+	enum Result (* query_cereg)(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 查询ps域网络注册状态
+	enum Result (* query_cereg_sync)(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 查询ps域网络注册状态。同步
 	enum Result (* query_socket_state)(uint8_t connectID, uint8_t * state); // 查询Socket服务状态
 	enum Result (* query_socket_state_sync)(uint8_t connectID, uint8_t * state); // 查询Socket服务状态。同步
 	enum Result (* open_socket)(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err); // 打开Socket服务

Drivers/Modules/ec800m/EC800M_UDP_Client5.c

@@ -251,18 +251,7 @@ void UDP_Client_Handle(void)
 		case STEP_START: // 开始
 			query_cgreg_times = 0; // 查询网络状态的次数
 			auth_times = 0; // 认证次数
-			goto_step(STEP_VERIFY_REGIST);
-			break;
-		case STEP_VERIFY_REGIST: // 验证是否注册
-			regist_result = regist_get_result();
-			if(regist_result == Regist_Result_Success)
-			{
-				goto_step(STEP_EXIT_SLEEP);
-			}
-			else
-			{
-				goto_failure("设备未注册");
-			}
+			goto_step(STEP_EXIT_SLEEP);
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			ec800m.exit_sleep();

Drivers/Modules/ec800m/Ec800m_Initialize.c

@@ -28,6 +28,7 @@ enum PowerStep{
 	STEP_QUERY_CGREG, // 查询网络注册状态
 	STEP_SUCCESS, // 成功
 	STEP_FAILURE, // 失败
+	STEP_FINISH,
 };
 // 当前
 static enum PowerStep powerstep = STEP_START;
@@ -218,39 +219,36 @@ void Initialize_Handle(void)
 				power_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)
 			{
-				pownext_step(STEP_SUCCESS);
-				
 				Log_Printf_Debug("设置最小功能模式成功\r\n");
+				pownext_step(STEP_ENTER_SLEEP);
 			}
 			else if(result == Result_Failed)
 			{
 				Log_Printf_Debug("设置最小功能模式失败\r\n");
-				pownext_step(STEP_FAILURE);
+				pownext_step(STEP_ENTER_SLEEP);
 			}
 			break;
-		case STEP_WAIT: // 等待
-			powerwait();
-			break;
-		case STEP_SUCCESS: // 成功
+		case STEP_ENTER_SLEEP: // 进入睡眠
 			ec800m.enter_sleep();
-			pownext_wait_step(STEP_START, 50);
-			Log_Printf_Debug("初始化成功\r\n");
-			set_mincfun_flag=1;
+			pownext_step(STEP_FINISH);
 			break;
-		case STEP_FAILURE: // 失败
-			ec800m.enter_sleep();
-			if(module_switch==0)
-			{
-				pownext_wait_step(STEP_START, 50);
-			}
-			else
-			{
-				pownext_wait_step(STEP_SET_CFUN_0, 500);
-			}
+		case STEP_FINISH: // 结束流程
+		  set_mincfun_flag=1;
 			break;
 		default:
 			break;

Drivers/Modules/ec800m/Ec800m_Regist.c

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <stdlib.h>
 #include "cJSON.h"
-#include "Delay.h"
 #include "mbedtls_util.h"
 #include "Log_Module.h"
 #include "At_Module.h"
@@ -61,7 +60,7 @@ void clearflash(void){
 	memset(flashdata.deviceSecret, 0, sizeof(flashdata.deviceSecret));
 	memset(flashdata.productKey, 0, sizeof(flashdata.productKey));
 	memset(flashdata.deviceName, 0, sizeof(flashdata.deviceName));
-	delay_ms(10);
+	my_delay_ms(10);
 	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
 }
 
@@ -72,10 +71,10 @@ void storedata(void)
 	strcpy(flashdata.productKey, regist_params_struct.productKey);
 	strcpy(flashdata.deviceName, regist_params_struct.deviceName);
 	
-	delay_ms(10);
+	my_delay_ms(10);
 	STMFLASH_Write(FLASH_SAVE_ADDR,(uint16_t*)&flashdata,sizeof(flashdata));
 	flashdata.read_flag=0;
-	delay_ms(10);
+	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);
@@ -90,7 +89,7 @@ uint8_t regist_Handle()
 	uint32_t ci = 0;
 	enum Result result = Result_None;
 	ec800m.exit_sleep();//退出休眠
-	delay_ms(10);
+	my_delay_ms(10);
 	result=ec800m.set_sleep_sync(1);//设置休眠模式
 	if(result==Result_Success)
 	{
@@ -105,7 +104,7 @@ uint8_t regist_Handle()
 	if(result==Result_Success)
 	{
 		for(int i=0;i<20;i++){
-			delay_ms(400);
+			my_delay_ms(400);
 			result=ec800m.query_cgreg_sync(&mode,&stat,&lac,&ci);//循环查询网络状态最多20次
 			if(stat==1)
 			{
@@ -167,7 +166,7 @@ uint8_t regist_device_sync(void)
 	//读取flash
 	Log_Printf_Debug("读取前read_flag:%d\r\n",flashdata.read_flag);
 	STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)&flashdata,sizeof(flashdata));//读取flash
-	delay_ms(10);
+	my_delay_ms(10);
 	//已经注册。读取flash成功
 	if(flashdata.read_flag == 1)
 	{

Hardware/GPIOA.c

@@ -2,10 +2,10 @@
 #include "CONFIG.h"
 void GPIOA_Init(void)
 {
+	#if  EC800M
 	RCC_APB2PeriphClockCmd(WAKE_GPIO_RCC, ENABLE);
 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
 	GPIO_InitTypeDef GPIO_InitStructure;
-	#if  EC800M
 	
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
 	GPIO_InitStructure.GPIO_Pin = WAKE_GPIO_Pin;
@@ -15,13 +15,13 @@ void GPIOA_Init(void)
 	 #endif
 
 	#if  BC260Y
-	GPIO_InitStructure.GPIO_Pin 	= GPIO_Pin_7;
-	GPIO_InitStructure.GPIO_Mode	= GPIO_Mode_Out_PP;
-	GPIO_InitStructure.GPIO_Speed 	= GPIO_Speed_50MHz;	
-	GPIO_Init(GPIOA, &GPIO_InitStructure);
-	GPIO_ResetBits(GPIOA, GPIO_Pin_7); // nbÀ­µÍ
+//	GPIO_InitStructure.GPIO_Mode	= GPIO_Mode_Out_PP;
+//	GPIO_InitStructure.GPIO_Pin 	= WAKE_GPIO_Pin;
+//	GPIO_InitStructure.GPIO_Speed 	= GPIO_Speed_50MHz;	
+//	GPIO_Init(WAKE_GPIO, &GPIO_InitStructure);
+//	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // nbÀ­µÍ
 	
-    #endif
+  #endif
 }
 
 

User/main.c

@@ -38,6 +38,7 @@ int main(void)
 	OLED_ShowString(1, 1, "MS:");
 	
 	Log_Printf_Debug("1234\r\n");
+//	my_delay_ms(5000);
 	
 	//×¢²áÉ豸,×î¶àʧ°ÜÈý´Î