nb发送流程修改，兼容sim卡新号段

Drivers/CONFIG.h

@@ -15,12 +15,12 @@
 
 // 何龙祥的配置
 //睡眠相关IO配置 
-//#define WAKE_GPIO_RCC RCC_APB2Periph_GPIOA
-//#define WAKE_GPIO GPIOA
-//#define WAKE_GPIO_Pin GPIO_Pin_6 // 睡眠的引脚
-////flash相关配置
-//#define FLASH_SIZE 64
-//#define SAVE_ADDR 0X0800FC00
+#define WAKE_GPIO_RCC RCC_APB2Periph_GPIOA
+#define WAKE_GPIO GPIOA
+#define WAKE_GPIO_Pin GPIO_Pin_6 // 睡眠的引脚
+//flash相关配置
+#define FLASH_SIZE 64
+#define SAVE_ADDR 0X0800FC00
 
 
 
@@ -28,12 +28,12 @@
 
 // 刘艳斌的配置
 //睡眠相关IO配置
-#define WAKE_GPIO_RCC RCC_APB2Periph_GPIOE
-#define WAKE_GPIO GPIOE
-#define WAKE_GPIO_Pin GPIO_Pin_5 // 睡眠的引脚
-//flash相关配置
-#define FLASH_SIZE 512
-#define SAVE_ADDR 0X0807E000
+//#define WAKE_GPIO_RCC RCC_APB2Periph_GPIOE
+//#define WAKE_GPIO GPIOE
+//#define WAKE_GPIO_Pin GPIO_Pin_5 // 睡眠的引脚
+////flash相关配置
+//#define FLASH_SIZE 512
+//#define SAVE_ADDR 0X0807E000
 
 
 #endif

Drivers/Modules/Aliyuniot.c

@@ -23,7 +23,7 @@ static char ClientID[60];
 static uint16_t Port = 5682;
 static char Host[60];
 
-static uint32_t SeqOffset = 65534;
+static uint32_t SeqOffset = 0;
 static char Random[20];
 static char Token[50];
 
@@ -123,6 +123,9 @@ static char sign[50];
 static uint8_t payload[256];
 void aliyuniot_get_auth_message(uint8_t * coap_message, uint16_t * coap_message_length)
 {
+	Log_Printf_Debug("<<STEP: 拼接认证报文\r\n");
+	SeqOffset = 888;
+	aliyuniot_printf_params();
 	// 先初始化clientID和Host
 	initClientIdAndHost();
 	// CoAP协议
@@ -146,12 +149,12 @@ void aliyuniot_get_auth_message(uint8_t * coap_message, uint16_t * coap_message_
 	// 签名相关
 	memset(StrForSignature, 0, sizeof(StrForSignature));
 	sprintf(StrForSignature, "clientId%sdeviceName%sproductKey%sseq%d", ClientID, DeviceName, ProductKey, SeqOffset);
-//	Log_Printf_Debug("认证报文StrForSignature:%s\r\n", StrForSignature);
+//	Log_Printf_Debug("认证报文StrForSignature:\r\n%s\r\n", StrForSignature);
 	// 签名
 	memset(sign, 0, sizeof(sign));
-	
 	utils_hmac_sha1_str(StrForSignature, strlen((char * )StrForSignature), sign, DeviceSecret, strlen(DeviceSecret));
 
+//	Log_Printf_Debug("签名sign:\r\n%s\r\n", sign);
 
 	// payload
 	memset(payload, 0, sizeof(payload));
@@ -159,8 +162,12 @@ void aliyuniot_get_auth_message(uint8_t * coap_message, uint16_t * coap_message_
 	// 设置payload
 	CoAP_Set_Payload_Str((char *)payload);
 	
+	
+//	Log_Printf_Debug("payload:\r\n%s\r\n", payload);
+	
 	// 生成报文
 	* coap_message_length = CoAP_Get_Length();
+	Log_Printf_Debug("STEP: 拼接认证报文>>\r\n");
 }
 
 
@@ -175,26 +182,36 @@ static char Rand2089[10] = {'\0'};
 static uint8_t Opt2089[20];
 void aliyuniot_get_data_message(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length)
 {
-//	aliyuniot_printf_params();
+	Log_Printf_Debug("<<STEP: 拼接数据报文\r\n");
+	aliyuniot_printf_params();
 	// 先初始化clientID和Host
 	initClientIdAndHost();
-	SeqOffset++;
 
-//	Log_Printf_Debug("STEP: 拼接数据报文,seqOffset=%d\r\n", SeqOffset);
+//	Log_Printf_Debug("SeqOffset：%d\r\n", SeqOffset);
 	
 	// 获取密钥
 	memset(sha256_source, 0, sizeof(sha256_source));
 	snprintf(sha256_source, sizeof(sha256_source), "%s,%s" ,DeviceSecret ,Random);
+//	Log_Printf_Debug("sha256_source:\r\n%s\r\n", sha256_source);
 	memset(out, 0, sizeof(out));
 	utils_sha256(sha256_source, strlen(sha256_source), out);
+	
+//	Log_Printf_Debug("out:\r\n");
+//	Log_SendHex((uint8_t *)out, strlen(out));
+//	Log_Printf_Debug("\r\n");
+	
+	
 	memset(aes_key, 0, sizeof(aes_key));
 	memcpy(aes_key, out+8, 16); //获取key
+//	Log_Printf_Debug("aes_key:\r\n");
+//	Log_SendHex(aes_key, 16);
+//	Log_Printf_Debug("\r\n");
 	
 	// CoAP协议
 	CoAP_Init(coap_message);
 	CoAP_Set_T(0);
 	CoAP_Set_Code(2);
-	CoAP_Set_MessageID(SeqOffset);
+	CoAP_Set_MessageID(++SeqOffset);
 	// option
 	// host
 	CoAP_Set_Option_Str(3, Host);
@@ -221,14 +238,26 @@ void aliyuniot_get_data_message(uint8_t * data, uint8_t data_length, uint8_t * c
 	int Opt2089_Length = utils_aes128_cbc_enc_with_length(aes_key, iv, (uint8_t *)Rand2089, strlen(Rand2089), Opt2089);
 	CoAP_Set_Option(2089,Opt2089_Length, Opt2089);
 	
+//	Log_Printf_Debug("Opt2089:\r\n");
+//	Log_SendHex(Opt2089, Opt2089_Length);
+//	Log_Printf_Debug("\r\n");
+	
+//	Log_Printf_Debug("data:\r\n");
+//	Log_SendHex(data, data_length);
+//	Log_Printf_Debug("\r\n");
 	// payload
 	memset(payload, 0, sizeof(payload));
 	int payload_length = utils_aes128_cbc_enc_with_length(aes_key, iv, data, data_length, payload);
 	
 	CoAP_Set_Payload(payload, payload_length);
 	
+//	Log_Printf_Debug("payload:\r\n");
+//	Log_SendHex(payload, payload_length);
+//	Log_Printf_Debug("\r\n");
+	
 	// 生成报文
 	* coap_message_length = CoAP_Get_Length();
+	Log_Printf_Debug("STEP: 拼接数据报文>>\r\n");
 }
 
 
@@ -238,11 +267,17 @@ void aliyuniot_get_data_message(uint8_t * data, uint8_t data_length, uint8_t * c
 static uint8_t plaintext[256]; // 明文
 uint8_t aliyuniot_recv_data_handle(uint8_t * coap_message, uint16_t coap_message_length)
 {
+//	Log_Printf_Debug("coap_message(%d):\r\n", coap_message_length);
+//	Log_SendHex(coap_message, coap_message_length);
+//	Log_Printf_Debug("\r\n");
+	
 	memset(payload, 0, sizeof(payload));
 	uint16_t payload_length = CoAP_Get_Payload(coap_message, coap_message_length, payload);
 	
 	Log_Printf_Debug("payload长度: %d\r\n", payload_length);
 	
+	
+	
 	// 判断是认证返回，还是数据发送返回
 	if(payload_length == 0) // 无返回
 	{

Drivers/Modules/Tuoreniot.c

@@ -46,7 +46,7 @@ uint8_t analysisRegistData(uint8_t * regist_data, uint16_t regist_data_length, s
 
 	uint8_t result;
 	utils_aes128_ECB_base64_dec((char *)key,regist_data,regist_data_length);
-	Log_Printf_Debug("½âÃÜÊý¾Ý(%d):%s\r\n", regist_data_length, (char *)regist_data);
+//	Log_Printf_Debug("½âÃÜÊý¾Ý(%d):%s\r\n", regist_data_length, (char *)regist_data);
 
 	cJSON *json = cJSON_Parse((char *)regist_data);
 	if(!json)

Drivers/Modules/bc260y/BC260Y_UDP_Client5.c

@@ -76,7 +76,12 @@ enum Step{
 	STEP_FINISH, // 流程结束
 	STEP_VERIFY_REGIST,//验证注册
 	STEP_VERIFY_INITIALIZE, // 验证初始化
-	STEP_QUERY_SOCKET,
+	STEP_QUERY_SOCKET, // 查询连接
+	STEP_QUERY_DNS, // 查询DNS
+	STEP_SET_DNS, // 设置DNS
+	
+	STEP_QUERY_CFUN_DNS, // 设置完dns后，查询功能模式
+	STEP_SET_CFUN_0_DNS, // 设置完dns后，设置最小功能模式
 };
 // 当前
 static enum Step step = STEP_NONE;
@@ -223,7 +228,7 @@ static void goto_failure(char * info)
 // 成功
 static void goto_success(char * info)
 {
-    Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
+	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
 	client.status = Client_Status_Success;
 	strcpy(client.info, info);
 	goto_step(STEP_SUCCESS);
@@ -251,6 +256,9 @@ static uint16_t socket_err = 0;
 static uint8_t auth_or_data = 0;
 static enum Initialize_Result InitializeResult;
 
+// dns
+static char pridnsaddr[20];
+
 static uint8_t resend_counter = 0;//nb失败重发标志
 static uint8_t cfun_mode = 0;
 static uint8_t connectstate = 0;
@@ -269,17 +277,17 @@ void UDP_Client_Handle(void)
 		case STEP_NONE: // 空闲
 			break;
 		case STEP_START: // 开始
-			Log_Printf_Debug("开始\r\n");
+			Log_Printf_Debug("\r\n>>发送流程开始\r\n");
 			auth_times = 0; // 认证次数
-//			goto_step(STEP_EXIT_SLEEP);
 			goto_step(STEP_EXIT_SLEEP);
+			Log_Printf_Debug("\r\n>>退出休眠\r\n");
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			result = bc260y.exit_sleep_2();
 		  if(result == Result_Success)
 			{
-				Log_Printf_Debug("退出休眠成功\r\n");
 				goto_step(STEP_SET_QISDE_1);
+				Log_Printf_Debug("\r\n>>开启回显\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -291,6 +299,7 @@ void UDP_Client_Handle(void)
 			if(result == Result_Success)
 			{
 				goto_step(STEP_SET_SLEEP);
+				Log_Printf_Debug("\r\n>>设置休眠模式\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -302,23 +311,90 @@ void UDP_Client_Handle(void)
 			if(result == Result_Success)
 			{
 				goto_step(STEP_DATAFORMAT);
+				Log_Printf_Debug("\r\n>>配置发送格式\r\n");
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("设置休眠模式失败");
 			}
 			break;
-		case STEP_DATAFORMAT:
+		case STEP_DATAFORMAT: // 配置发送格式
 			result = bc260y.dataformat(1);
 			if(result == Result_Success)
 			{
-			 goto_step(STEP_QUERY_CFUN);
+				goto_step(STEP_QUERY_DNS);
+				Log_Printf_Debug("\r\n>>查询DNS\r\n");
+				memset(pridnsaddr, 0, sizeof(pridnsaddr));
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("配置发送格式失败");
 			}
 		   break;
+		case STEP_QUERY_DNS: // 查询DNS
+			result = bc260y.query_dns(pridnsaddr);
+			if(result == Result_Success)
+			{
+				if(strlen(pridnsaddr) <= 1)
+				{
+					goto_step(STEP_SET_DNS);
+					Log_Printf_Debug("\r\n>>设置DNS\r\n");
+				}
+				else
+				{
+					goto_step(STEP_QUERY_CFUN);
+					Log_Printf_Debug("\r\n>>查询功能模式\r\n");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询DNS失败");
+			}
+			break;
+		case STEP_SET_DNS:
+			result = bc260y.set_dns("114.114.114.114", "8.8.8.8"); // 设置DNS
+			if(result == Result_Success)
+			{
+				goto_step(STEP_QUERY_CFUN_DNS);
+				Log_Printf_Debug("\r\n>>设置完dns，查询功能模式\r\n");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询功能模式失败");
+			}
+		   break;
+		case STEP_QUERY_CFUN_DNS: // 设置完dns，查询功能模式
+			result = bc260y.query_cfun(&cfun_mode);
+			if(result == Result_Success)
+			{
+				if(cfun_mode == 1)
+				{
+					goto_step(STEP_SET_CFUN_0_DNS);
+					Log_Printf_Debug("\r\n>>设置完dns，先设置最小功能模式\r\n");
+				}
+				else
+				{
+					goto_step(STEP_SET_CFUN_1);
+					Log_Printf_Debug("\r\n>>设置完dns，设置全功能模式\r\n");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询功能模式失败");
+			}
+		   break;
+		case STEP_SET_CFUN_0_DNS: // 设置完dns，设置最小功能模式
+			result = bc260y.set_cfun(0);
+			if(result == Result_Success)
+			{
+				goto_step(STEP_SET_CFUN_1);
+				Log_Printf_Debug("\r\n>>设置完dns，设置全功能模式\r\n");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置完dns，设置最小模式失败");
+			}
+			break;
 		case STEP_QUERY_CFUN: // 查询功能模式
 			result = bc260y.query_cfun(&cfun_mode);
 			if(result == Result_Success)
@@ -326,10 +402,12 @@ void UDP_Client_Handle(void)
 				if(cfun_mode == 0)
 				{
 					goto_step(STEP_SET_CFUN_1);
+					Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
 				}
 				else
 				{
 					goto_step(STEP_SET_CGREG_2);
+					Log_Printf_Debug("\r\n>>设置ps域\r\n");
 				}
 			}
 			else if(result == Result_Failed)
@@ -341,11 +419,13 @@ void UDP_Client_Handle(void)
 			result = bc260y.set_cfun(1);
 			if(result == Result_Success)
 			{
-				Log_Printf_Debug("设置全功能模式成功\r\n");
+				resend_counter++;
 				goto_step(STEP_SET_CGREG_2);
+				Log_Printf_Debug("\r\n>>设置ps域\r\n");
 			}
 			else if(result == Result_Failed)
 			{
+				resend_counter++;
 				goto_failure("设置全功能模式失败");
 			}
 			break;
@@ -353,7 +433,9 @@ void UDP_Client_Handle(void)
 			result = bc260y.set_cereg(2);
 			if(result == Result_Success)
 			{
-				goto_step_wait(STEP_QUERY_CGREG, 400);
+//				goto_step_wait(STEP_QUERY_CGREG, 400);
+				goto_step(STEP_QUERY_CGREG);
+				Log_Printf_Debug("\r\n>>查询ps域\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -374,10 +456,12 @@ void UDP_Client_Handle(void)
 					if(test_flag == 0)
 					{
 						goto_step(STEP_QUERY_SOCKET);
+						Log_Printf_Debug("\r\n>>查询连接\r\n");
 					}
 					else
 					{
 						goto_step(STEP_QUERY_QENG_SERVINGCELL);
+						Log_Printf_Debug("\r\n>>查询信号质量\r\n");
 					}
 				}
 				else
@@ -395,6 +479,7 @@ void UDP_Client_Handle(void)
 			if(result == Result_Success)
 			{
 				goto_step(STEP_QUERY_SOCKET);
+				Log_Printf_Debug("\r\n>>查询连接\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -402,17 +487,19 @@ void UDP_Client_Handle(void)
 			}
 			break;
 	
-		case STEP_QUERY_SOCKET:		 
-			 result =bc260y.query_socket_state(connectID,&connectstate);
-		    if(result == Result_Success)
+		case STEP_QUERY_SOCKET: // 查询连接
+			result =bc260y.query_socket_state(connectID,&connectstate);
+		  if(result == Result_Success)
 			{
 				if(connectstate==2)
 				{
-				goto_step(STEP_JUDGE_AUTH_OR_DATA);
+					goto_step(STEP_JUDGE_AUTH_OR_DATA);
+					Log_Printf_Debug("\r\n>>判断认证还是发送\r\n");
 				}
 				else
 				{
-				 goto_step(STEP_CLOSE);
+					goto_step(STEP_CLOSE);
+					Log_Printf_Debug("\r\n>>关闭连接\r\n");
 				}
 			}
 			else if(result == Result_Failed)
@@ -425,6 +512,7 @@ void UDP_Client_Handle(void)
 			if(result == Result_Success)
 			{
 				goto_step(STEP_OPEN);
+				Log_Printf_Debug("\r\n>>打开客户端\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -438,6 +526,7 @@ void UDP_Client_Handle(void)
 				if(socket_err == 0)
 				{
 					goto_step(STEP_JUDGE_AUTH_OR_DATA);
+					Log_Printf_Debug("\r\n>>判断认证还是发送\r\n");
 				}
 				else
 				{
@@ -454,14 +543,15 @@ void UDP_Client_Handle(void)
 			if(auth_or_data == 1) // 已认证
 			{
 				goto_step(STEP_JOIN_DATA_MESSAGE);
+				Log_Printf_Debug("\r\n>>拼接数据报文\r\n");
 			}
 			else
 			{
 				goto_step(STEP_JOIN_AUTH_MESSAGE);
+				Log_Printf_Debug("\r\n>>拼接认证报文\r\n");
 			}
 			break;
 		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
-			Log_Printf_Debug("拼接认证报文\r\n");
 			if(auth_times > 0) // 最多重新认证一次
 			{
 				goto_failure("认证次数过多");
@@ -470,12 +560,15 @@ void UDP_Client_Handle(void)
 			{
 				memset(coap_message, 0, sizeof(coap_message));
 				aliyuniot_get_auth_message(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");
 				goto_step(STEP_SEND);
+				Log_Printf_Debug("\r\n>>发送认证报文\r\n");
 				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();
@@ -484,14 +577,20 @@ void UDP_Client_Handle(void)
 			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);
+//			Log_Printf_Debug("数据报文：%d\r\n", coap_message_length);
+//			Log_SendHex(coap_message, coap_message_length);
+//			Log_Printf_Debug("\r\n");
 			goto_step(STEP_SEND);
+			Log_Printf_Debug("\r\n>>发送数据报文\r\n");
 			break;
  
 		case STEP_SEND: // 发送send
 			result = bc260y.send_rai(connectID, coap_message, coap_message_length, 2);
 			if(result == Result_Success)
 			{
+				memset(coap_message, 0, sizeof(coap_message));
 				goto_step(STEP_RECV);
+				Log_Printf_Debug("\r\n>>等待接收数据\r\n");
 			}
 			else if(result == Result_Failed)
 			{
@@ -499,17 +598,19 @@ void UDP_Client_Handle(void)
 			}
 			break;
 		case STEP_RECV: // 等待结果
-			result = bc260y.recv_with_time(connectID, coap_message, &coap_message_length, 10000);
+			result = bc260y.recv_with_time(connectID, coap_message, &coap_message_length, 4000);
 			if(result == Result_Success)
 			{
 				uint8_t res = aliyuniot_recv_data_handle(coap_message, coap_message_length);
 				if(res == 0) // 发送失败
 				{
 					goto_step(STEP_JUDGE_AUTH_OR_DATA); // 重新认证
+					Log_Printf_Debug("\r\n>>重新认证\r\n");
 				}
 				else if(res == 1) // 认证成功
 				{
 					goto_step(STEP_JOIN_DATA_MESSAGE);
+					Log_Printf_Debug("\r\n>>拼接数据报文\r\n");
 				}
 				else if(res == 2) // 发送成功
 				{
@@ -526,33 +627,38 @@ void UDP_Client_Handle(void)
 			break;
 		case STEP_SUCCESS: // 成功
 			goto_step(STEP_ENTER_SLEEP);
+			Log_Printf_Debug("\r\n>>成功，进入睡眠\r\n");
 			break;
 		case STEP_FAILURE: // 失败
 			resend_counter++;
 			goto_step(STEP_SET_CFUN_0);
+			Log_Printf_Debug("\r\n>>失败，设置最小功能模式\r\n");
 			break;
 		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);
+					Log_Printf_Debug("\r\n>>重发次数%d > 1，结束发送，进入睡眠\r\n", resend_counter);
 				}
 				else
 				{
 					goto_step(STEP_START);
+					Log_Printf_Debug("\r\n>>重发次数%d < 1，重新发送\r\n", resend_counter);
 				}
 			}
 			else if(result == Result_Failed)
 			{
 				goto_step(STEP_ENTER_SLEEP);
+				Log_Printf_Debug("\r\n>>设置最小功能模式失败，进入睡眠\r\n");
 			}
 			break;
 		case STEP_ENTER_SLEEP: // 进入睡眠
 			resend_counter=0;//失败重发置0
 			goto_step(STEP_FINISH);
+			Log_Printf_Debug("\r\n>>发送流程结束\r\n");
 			break;
 		case STEP_FINISH: // 结束流程
 			break;

Drivers/Modules/bc260y/Bc260y_Regist.c

@@ -34,7 +34,7 @@
 
 static uint8_t register_status;//注册成功，向flash存储标志
 static Coefficient_Data flashdata;
-static uint8_t mcu_id[8]="ceshi002";
+static uint8_t mcu_id[8]="ceshi005";
 // 生成环境
 static char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
 static uint16_t REGIST_PORT = 8888; //端口号
@@ -54,6 +54,9 @@ static struct Regist_Params_Struct regist_params_struct = {
 static uint8_t regist_data[512];
 static uint16_t regist_data_length;
 
+// dns
+static char pridnsaddr[20];
+
 
 //清空flash
 void clearflash(void){
@@ -90,72 +93,89 @@ uint8_t regist_Handle()
 	uint32_t ci = 0;
 	enum Result result = Result_None;
 //	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin);
+	Log_Printf_Debug("\r\n>>退出休眠\r\n");
 	result = bc260y.exit_sleep_2_sync();//退出休眠
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("退出休眠成功\r\n");
+		Log_Printf_Debug("\r\n>>开启回显\r\n");
 		result = bc260y.set_qisde_sync(1);//开启回显
 	}
-  if(result==Result_Success)
+	if(result==Result_Success)
 	{
-		Log_Printf_Debug("开启回显成功\r\n");
-		result=bc260y.set_sleep_sync(2);//设置休眠模式
+		Log_Printf_Debug("\r\n>>查询DNS\r\n");
+		memset(pridnsaddr, 0, sizeof(pridnsaddr));
+		result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
+		Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
 	}
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("设置休眠模式成功\r\n");
-		result = bc260y.dataformat_sync(1); // 设置数据格式, 十六进制
+		if(strlen(pridnsaddr) <= 1)
+		{
+			Log_Printf_Debug("\r\n>>设置DNS\r\n");
+			result = bc260y.set_dns_sync("114.114.114.114", "8.8.8.8"); // 设置DNS
+		}
 	}
-	
-  if(result==Result_Success)
+	if(result==Result_Success)
 	{
-		Log_Printf_Debug("设置数据格式成功\r\n");
+		Log_Printf_Debug("\r\n>>查询功能模式\r\n");
 		result=bc260y.query_cfun_sync(&cfun_mode);//查询功能模式
 	}
   if(result==Result_Success)
 	{
-		Log_Printf_Debug("查询功能模式成功\r\n");
-		if(cfun_mode == 0)
+		if(cfun_mode == 1)
 		{
-			result=bc260y.set_cfun_sync(1);//设置全功能模式
+			Log_Printf_Debug("\r\n>>设置最小功能模式\r\n");
+			result=bc260y.set_cfun_sync(0);//设置最小功能模式
 		}
 	}
+  if(result==Result_Success)
+	{
+		Log_Printf_Debug("\r\n>>设置休眠模式\r\n");
+		result=bc260y.set_sleep_sync(2);//设置休眠模式
+	}
+	if(result==Result_Success)
+	{
+		Log_Printf_Debug("\r\n>>设置数据格式\r\n");
+		result = bc260y.dataformat_sync(1); // 设置数据格式, 十六进制
+	}
+	
+	
+	if(result==Result_Success)
+	{
+		Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
+		result=bc260y.set_cfun_sync(1);//设置全功能模式
+	}
+	
+	
+  
  
   if(result==Result_Success)
 	{
-		Log_Printf_Debug("设置全功能模式成功\r\n");
+		Log_Printf_Debug("\r\n>>设置网络状态\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);
-		}
+		Log_Printf_Debug("\r\n>>查询网络状态\r\n");
+		result=bc260y.query_cereg_sync(&mode,&stat,&lac,&ci);// 查询网络状态
 	}
 
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("网络注册成功\r\n");
+		Log_Printf_Debug("\r\n>>断开tcp连接\r\n");
 		result=bc260y.close_socket_sync(tcpconnectID);//防止以前链接没断开，断开tcp链接
 	}
 	
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("断开tcp链接成功\r\n");
+		Log_Printf_Debug("\r\n>>连接tcp\r\n");
 		result=bc260y.open_socket_sync(tcpconnectID,"TCP",REGIST_SERVER,REGIST_PORT,1,&err);//连接tcp
 	}
 	
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("连接tcp成功\r\n");
+		Log_Printf_Debug("\r\n>>发送数据\r\n");
 		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));
@@ -166,7 +186,7 @@ uint8_t regist_Handle()
 	
 	if(result==Result_Success)
 	{
-		Log_Printf_Debug("数据发送成功\r\n");
+		Log_Printf_Debug("\r\n>>接收数据\r\n");
 		memset(regist_data, 0, sizeof(regist_data));
 		result =bc260y.recv_with_time_sync(tcpconnectID,regist_data,&regist_data_length,10000);
 //		Log_Printf_Debug("解密前：\r\n");
@@ -177,26 +197,21 @@ uint8_t regist_Handle()
 	
 	if(result == Result_Success)
 	{
-		Log_Printf_Debug("数据返回成功\r\n");
+		Log_Printf_Debug("\r\n>>解析数据\r\n");
 		// 解析注册数据
 		regist_flag = analysisRegistData(regist_data, regist_data_length, &regist_params_struct);
 		printf_regist_param_struct(regist_params_struct);
 		
+		Log_Printf_Debug("\r\n>>断开tcp连接\r\n");
 		result=bc260y.close_socket_sync(tcpconnectID);//断开tcp连接
 	}
 	
- 
-  if(result==Result_Success)
-	{
-		Log_Printf_Debug("断开tcp连接成功\r\n");
-	}
-	
-	
+
 	// 注册失败，进入最小功能模式，防止耗电
   if(result == Result_Failed)
 	{
-		Log_Printf_Debug("设置最小功能模式\r\n");
-//		bc260y.set_cfun_sync(0);//设置最小功能模式
+		Log_Printf_Debug("\r\n>>设置最小功能模式\r\n");
+		bc260y.set_cfun_sync(0);//设置最小功能模式
 	}
 	
 

Drivers/Modules/bc260y/bc260y.c

@@ -224,6 +224,23 @@ enum Result bc260y_dataformat(uint8_t n);
 enum Result bc260y_dataformat_sync(uint8_t n);
 // 
 
+
+
+/** 
+* 查询dns
+**/
+enum Result bc260y_query_dns(char * pridnsaddr);
+enum Result bc260y_query_dns_sync(char * pridnsaddr);
+
+
+/** 
+* 设置dns
+**/
+enum Result bc260y_set_dns(char * pridnsaddr, char * secdnsaddr);
+enum Result bc260y_set_dns_sync(char * pridnsaddr, char * secdnsaddr);
+
+
+
 // AT指令
 static char AT_CMD[1024];
 
@@ -276,7 +293,11 @@ struct BC260Y_Struct bc260y =
 	.query_qccid = bc260y_query_qccid,
 	.query_qccid_sync = bc260y_query_qccid_sync,
 	.dataformat= bc260y_dataformat,
-	.dataformat_sync= bc260y_dataformat_sync
+	.dataformat_sync= bc260y_dataformat_sync,
+	.query_dns = bc260y_query_dns,
+	.query_dns_sync = bc260y_query_dns_sync,
+	.set_dns = bc260y_set_dns,
+	.set_dns_sync = bc260y_set_dns_sync,
 };
 
 
@@ -469,7 +490,7 @@ enum Result bc260y_exit_sleep_sync()
 enum Result bc260y_exit_sleep_2(void)
 {
 	enum Result result = Result_None;
-	int activeID = 123, time = 100; // 活动ID, 超时时间
+	int activeID = 123, time = 400; // 活动ID, 超时时间
 	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
 	// 判断状态
 	if(getStatus() == Status_None) // 空闲状态
@@ -791,7 +812,7 @@ enum Result bc260y_set_cfun(uint8_t fun)
 	int activeID = 4, time; // 活动ID, 超时时间
 	// 校验参数
 	if(fun == 0){ time = 3000; }
-	else if(fun == 1){ time = 7000; }
+	else if(fun == 1){ time = 10000; }
 	else
 	{
 		Log_Printf_Debug("set_cfun params error!\r\n");
@@ -983,8 +1004,7 @@ enum Result bc260y_query_cereg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
@@ -1166,7 +1186,7 @@ enum Result bc260y_query_socket_state_sync(uint8_t connectID, uint8_t * state)
 enum Result bc260y_open_socket(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err)
 {
 	enum Result result = Result_None;
-	int activeID = 19, time = 3000; // 活动ID, 超时时间
+	int activeID = 19, time = 5000; // 活动ID, 超时时间
 	// 校验ID
 	if(!verifyActiveID(activeID)){ return Result_Failed; }
 	// 判断状态
@@ -1283,7 +1303,7 @@ enum Result bc260y_close_socket(uint8_t connectID)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1355,7 +1375,7 @@ enum Result bc260y_set_qisde(uint8_t echo)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1430,7 +1450,7 @@ enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1527,6 +1547,7 @@ enum Result bc260y_send_rai(uint8_t connectID, uint8_t * data, uint16_t data_len
 		sprintf(AT_CMD + strlen(AT_CMD), "AT+QISEND=%d,%d,", connectID, data_length); // 拼接AT指令
 		for(uint16_t i = 0; i < data_length; i++)
 		{
+//			sprintf(AT_CMD + strlen(AT_CMD), "%02X", *(data + i));
 			sprintf(AT_CMD + strlen(AT_CMD), "%02X", data[i]);
 		}
 		sprintf(AT_CMD + strlen(AT_CMD), ",%d\r\n", rai); // 拼接AT指令
@@ -1535,7 +1556,7 @@ enum Result bc260y_send_rai(uint8_t connectID, uint8_t * data, uint16_t data_len
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1677,7 +1698,7 @@ enum Result bc260y_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t *
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1747,7 +1768,7 @@ enum Result bc260y_power_down(uint8_t n)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1851,8 +1872,7 @@ enum Result bc260y_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SI
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
@@ -1936,8 +1956,7 @@ enum Result bc260y_query_qccid(char * iccid)
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
@@ -2061,5 +2080,156 @@ enum Result bc260y_dataformat_sync(uint8_t n)
 }
 
 
+
+
+/** 
+* 查询dns
+* 输入<<
+*
+* 输出>>
+* dns dns服务器IP
+**/
+enum Result bc260y_query_dns(char * pridnsaddr)
+{
+	enum Result result = Result_None;
+	int activeID = 87, time = 500; // 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+QIDNSCFG=0\r\n"); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		result = failed(); // 失败
+	}
+	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());
+		
+		// 处理返回结果
+		char * saveptr = NULL;
+		char * split = "\r\n";
+		// 第一行
+		char * Line1 =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);
+		// 字符串拷贝
+		strcpy(pridnsaddr, 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_dns_sync(char * pridnsaddr)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = bc260y_query_dns(pridnsaddr);
+		if(result != Result_None)
+		{
+			// 重置
+			bc260y.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+
+
+/** 
+* 设置dns
+* 输入<<
+* pridnsaddr 主dns服务器
+* secdnsaddr 次dns服务器
+* 输出>>
+**/
+enum Result bc260y_set_dns(char * pridnsaddr, char * secdnsaddr)
+{
+	enum Result result = Result_None;
+	int activeID = 87, time = 500; // 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+QIDNSCFG=0,\"%s\",\"%s\"\r\n", pridnsaddr, secdnsaddr); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		result = failed(); // 失败
+	}
+	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(); // 失败
+	}
+	return result;
+}
+enum Result bc260y_set_dns_sync(char * pridnsaddr, char * secdnsaddr)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = bc260y_set_dns(pridnsaddr, secdnsaddr);
+		if(result != Result_None)
+		{
+			// 重置
+			bc260y.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+
+
+
 #endif
 

Drivers/Modules/bc260y/bc260y.h

@@ -79,6 +79,12 @@ struct BC260Y_Struct
 	enum Result (* dataformat)(uint8_t n); // 配置发送数据格式
 	enum Result (* dataformat_sync)(uint8_t n); // 配置发送数据格式
 	
+	enum Result (* query_dns)(char * pridnsaddr); // 查询DNS
+	enum Result (* query_dns_sync)(char * pridnsaddr); // 查询DNS
+	
+	enum Result (* set_dns)(char * pridnsaddr, char * secdnsaddr); // 设置DNS
+	enum Result (* set_dns_sync)(char * pridnsaddr, char * secdnsaddr); // 设置DNS
+	
 };
 
 

Drivers/Modules/ec800m/ec800m.c

@@ -720,8 +720,8 @@ enum Result ec800m_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
@@ -1016,7 +1016,7 @@ enum Result ec800m_close_socket(uint8_t connectID)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1088,7 +1088,7 @@ enum Result ec800m_set_qisde(uint8_t echo)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1164,7 +1164,7 @@ 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 = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1327,7 +1327,7 @@ 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 = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1396,7 +1396,7 @@ enum Result ec800m_power_down(uint8_t n)
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
 		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
-		result = Result_Failed; 
+		result = failed(); // 失败
 	}
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
@@ -1499,8 +1499,8 @@ enum Result ec800m_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SI
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{
@@ -1597,8 +1597,8 @@ enum Result ec800m_query_qccid(char * iccid)
 	else if(getTimerMs() > time) // 正在发送状态。判断超时
 	{
 		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
-		setStatus(Status_Overtime); // 超时
-		result = Result_Failed; // 结果
+		
+		result = overtime(); // 超时
 	}
 	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
 	{

Start/startup_stm32f10x_md.s

@@ -30,7 +30,7 @@
 ;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
 ; </h>
 
-Stack_Size      EQU     0x00000800
+Stack_Size      EQU     0x00000800;0x00000800
 
                 AREA    STACK, NOINIT, READWRITE, ALIGN=3
 Stack_Mem       SPACE   Stack_Size

User/main.c

@@ -29,6 +29,7 @@
 static struct TIMER_Struct timer;
 //static uint8_t send_flag = 1;
 //static char AT_CMD[512];
+//static char pridnsaddr[20];
 
 int main(void)
 {
@@ -66,29 +67,38 @@ int main(void)
 		
 //		if(send_flag == 1)
 //		{
-//			uint8_t connectID = 1;
-//			uint16_t data_length = 6;
-//			uint8_t data[10] = {0x03, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38};
-//			uint8_t rai = 2;
-//			
-//			
-//			memset(AT_CMD, 0, sizeof(AT_CMD));
-//			sprintf(AT_CMD + strlen(AT_CMD), "AT+QISEND=%d,%d,\"", connectID, data_length); // 拼接AT指令
-//			for(uint16_t i = 0; i < data_length; i++)
+//			enum Result result = bc260y.exit_sleep_2_sync();
+//			if(result==Result_Success)
 //			{
-//				sprintf(AT_CMD + strlen(AT_CMD), "%02X", data[i]);
+//				Log_Printf_Debug("退出休眠成功\r\n");
+//				result = bc260y.set_qisde_sync(1);//开启回显
+//			}
+//			if(result==Result_Success)
+//			{
+//				Log_Printf_Debug("开启回显成功\r\n");
+//				memset(pridnsaddr, 0, sizeof(pridnsaddr));
+//				result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
+//				Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
+//			}
+//			if(result==Result_Success)
+//			{
+//				Log_Printf_Debug("查询DNS成功\r\n");
+//				if(strlen(pridnsaddr) <= 1)
+//				{
+//					result = bc260y.set_dns_sync("114.114.114.114", "8.8.8.8"); // 设置DNS
+//					if(result==Result_Success)
+//					{
+//						Log_Printf_Debug("设置DNS成功\r\n");
+//						memset(pridnsaddr, 0, sizeof(pridnsaddr));
+//						result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
+//						Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
+//					}
+//				}
+//				
 //			}
-//			sprintf(AT_CMD + strlen(AT_CMD), "\",%d\r\n", rai); // 拼接AT指令
-//			
-//			
-//			
-//			Log_Printf_Debug("\r\n");
-//			Log_Printf_Debug(AT_CMD);
-//			Log_Printf_Debug("\r\n");
 //			
 //			send_flag = 0;
 //		}
-//		
 //		AT_Handle();
 		
 		pump_business_loop_execution();