1

Drivers/CONFIG.h

@@ -14,7 +14,8 @@
 
 //#define EC800M 1 //4G¿ª¹Ø£¬²»ÄÜÊý×Ö¿ªÍ·
 //#define BC260Y 1  // NB
-#define ESP32 1		//WiFi
+//#define ESP32 1		//WiFi
+#define AIWB2	1	//WIFI_AIWB2-32S
 
 
 

Drivers/Modules/aiwb2-32s/Aiwb2_Initialize.c

@@ -0,0 +1,237 @@
+#include "CONFIG.h"
+#if  AIWB2
+
+#include "stm32f10x.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "Regist.h"
+#include "PumpBusiness.h"
+#include "Log_Module.h"
+#include "Initialize.h"
+#include "aiwb2.h"
+#include "Process_Control.h"
+#include "UDP_Client.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{
+	STEP_START, // 开始
+	STEP_START_AT,//开始AT
+	STEP_EXIT_SLEEP, // 退出睡眠
+	STEP_ENTER_SLEEP, // 进入睡眠
+	STEP_SET_SLEEP ,// 设置休眠模式
+	STEP_WAIT, // 等待
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_FINISH,//结束流程
+};
+
+
+// 步骤跳转时的监听
+//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)
+{
+	// 重置aiwb2状态
+	aiwb2.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 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 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)
+{
+	udpclient_status = status;
+}
+// 获取状态
+enum INITIALIZE_StatusEnum INITIALIZE_GetStatus(void)
+{
+	return udpclient_status;
+}
+// 设置结果
+static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result)
+{
+	udpclient_result = result;
+}
+// 获取结果
+enum INITIALIZE_ResultEnum INITIALIZE_GetResult(void)
+{
+	return udpclient_result;
+}
+// 重置
+enum EXECUTE_ResultEnum INITIALIZE_Reset(void)
+{
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
+	{
+		Log_Printf_Debug("初始化流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	INITIALIZE_SetStatus(INITIALIZE_Status_None);
+	INITIALIZE_SetResult(INITIALIZE_Result_None);
+	return EXECUTE_Result_Success;
+}
+// 开始
+enum EXECUTE_ResultEnum INITIALIZE_Start(void)
+{
+	INITIALIZE_Reset();
+	if(INITIALIZE_GetStatus() != INITIALIZE_Status_None)
+	{
+		Log_Printf_Debug("初始化流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	goto_start();
+	INITIALIZE_SetStatus(INITIALIZE_Status_Being);
+	return EXECUTE_Result_Success;
+}
+// 流程处理，放到循环里
+void INITIALIZE_ProcessHandle(void)
+{
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
+	{
+		INITIALIZE_Process();
+	}
+}
+
+// 初始化诱因处理
+void INITIALIZE_TriggerHandle(void)
+{
+	if((REGIST_GetStatus() != REGIST_Status_Being) && (UDPCLIENT_GetStatus() != UDPCLIENT_Status_Being))
+	{
+		enum Result result =aiwb2.ready();
+		if(result==Result_Success)
+		{
+			Log_Printf_Debug("初始化诱因处理！！！\r\n");
+			INITIALIZE_Start();
+		}
+	}
+}
+
+
+
+
+static enum Result result = Result_None;
+
+
+
+/**
+  * @brief  WiFi_Aiwb2模块初始化
+  * @param  无
+  * @retval 无
+  */
+static void INITIALIZE_Process(void)
+{
+	switch(pctrl.current_step)
+	{
+		case STEP_START: //开始
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
+			break;			
+		case STEP_EXIT_SLEEP: //退出休眠
+			aiwb2.exit_sleep_io();
+			PCTRL_GotoStepWait(&pctrl,STEP_START_AT, 350,"开始AT");
+			break;			
+		case STEP_START_AT:	//开始AT,检测模块是否唤醒
+			result = aiwb2.test_at();
+			if(result == Result_Success)
+			{
+				goto_success();
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("发送AT失败,模块未唤醒");
+			}
+			break;		
+		case STEP_WAIT:   //等待
+			PCTRL_Wait(&pctrl);
+			break;
+		case STEP_SUCCESS: // 成功
+			Log_Printf_Debug("初始化成功\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
+			break;
+		case STEP_FAILURE:// 失败
+			Log_Printf_Debug("初始化失败\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入休眠");
+			break;
+		case STEP_ENTER_SLEEP:// 进入睡眠
+			aiwb2.enter_sleep_io();
+			goto_finish();
+			break;		
+		case STEP_FINISH: // 结束流程
+			break;
+		default:
+			goto_failure("步骤不存在");
+			break;
+	}
+}
+
+#endif
+
+

Drivers/Modules/aiwb2-32s/Aiwb2_Regist.c

@@ -0,0 +1,349 @@
+#include "CONFIG.h"
+#if  AIWB2 
+
+#include "stm32f10x.h"
+#include "Regist.h"
+#include "FlashSetup.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "cJSON.h"
+#include "mbedtls_util.h"
+#include "Log_Module.h"
+#include "At_Module.h"
+#include "Common_Util.h"
+#include "Tuoreniot.h"
+
+#include "aiwb2.h"
+
+// 泵号
+extern uint8_t mcu_id[8];
+
+
+// 注册参数使用的网络名称,密码
+char WIFI_RegistID[50]="AA";
+char WIFI_RegistPASSWORD[30]="123456789";
+
+// 注册参数
+static struct TUORENIOT_RegistRequestStruct regist_request = {
+	.version = 1,
+	.networkType = 3,
+	.networkProtocol = 1,
+	.deviceId = "3431228A1936013C",
+	.userId = "0001"
+};
+
+
+
+///*************************************** 注册信息打包函数 ***************************************/
+//void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams)
+//{
+//	
+//	//InitClientId_2();	
+//	sprintf((char *)(pack_data + 2), "{\"version\":\"%d\",\"networkType\":\"%d\",\"networkProtocol\":\"%d\",\"productId\":\"%s\",\"deviceId\":\"%s\",\"userId\":\"%s\"}", 
+//	registParams->version, registParams->networkType, registParams->networkProtocol, registParams->productId, registParams->deviceId, registParams->userId); // ?′?ó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;//头两个字节赋值字节长度
+//	pack_data[1] = datalen;
+
+//	* pack_data_length = datalen + 2;
+//}
+
+
+// 函数声明
+static void REGIST_Process(void); // 注册流程
+static void REGIST_SetStatus(enum REGIST_StatusEnum status); // 设置注册状态
+static void REGIST_SetResult(enum REGIST_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{
+	STEP_START, // 开始
+	STEP_EXIT_SLEEP, // 退出睡眠
+	STEP_START_AT,//发送AT，检测模块是否唤醒
+	STEP_SET_QISDE_0,//关闭发送回显
+	STEP_SET_WORKMODE,//设置WIFI工作模式
+	STEP_SET_RECEIVEMODE,//设置socket接收模式
+	STEP_WIFI, //模块连接wifi
+	STEP_OPEN,//打开客户端
+	STEP_SEND,//发送send
+	STEP_WAIT,//等待
+	STEP_ENTER_SLEEP,// 进入深度睡眠
+	STEP_SUCCESS,// 成功
+	STEP_FAILURE,// 失败
+ 	STEP_FINISH,// 结束流程
+	
+	STEP_EXIT_WIFICONNECT, // 关闭所有WIFI连接
+	STEP_QUERY_CGREG,//查询网络状态
+		
+};
+
+
+
+// 步骤跳转时的监听
+//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)
+{
+	// 重置aiwb2状态
+	aiwb2.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 char info[40];
+// 开始
+static void goto_start(void)
+{
+//	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 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)
+{
+	return regist_result;
+}
+// 重置注册
+enum EXECUTE_ResultEnum REGIST_Reset(void)
+{
+	if(REGIST_GetStatus() == REGIST_Status_Being)
+	{
+		Log_Printf_Debug("注册流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	REGIST_SetStatus(REGIST_Status_None);
+	REGIST_SetResult(REGIST_Result_None);
+	return EXECUTE_Result_Success;
+}
+// 开始注册
+enum EXECUTE_ResultEnum REGIST_Start(void)
+{
+	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;
+}
+// 注册流程处理，放到大循环里
+void REGIST_ProcessHandle(void)
+{
+	if(REGIST_GetStatus() == REGIST_Status_Being)
+	{
+		REGIST_Process();
+	}
+}
+
+
+
+// 发送数据的逻辑
+static enum Result result = Result_None;
+
+extern uint8_t conID;
+uint8_t  TCPID = 4;
+
+//发送数据的流程
+static void REGIST_Process(void)
+{
+	// 流程
+	switch(pctrl.current_step)
+	{
+		case STEP_START: // 开始
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
+			break;
+		case STEP_EXIT_SLEEP: // 退出休眠
+			aiwb2.exit_sleep_io();
+			PCTRL_GotoStepWait(&pctrl, STEP_START_AT,350, "发送AT,检测模块是否唤醒");
+			break;
+		case STEP_START_AT:	//开始AT,检测模块是否唤醒
+			result = aiwb2.test_at();
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_0, "关闭发送回显");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("发送AT失败,模块未唤醒");
+			}
+			break;			
+		case STEP_SET_QISDE_0: // 关闭发送回显
+			result = aiwb2.set_qisde(0);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_WORKMODE, "设置WIFI工作模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("关闭发送回显失败");
+			}
+			break;
+		case STEP_SET_WORKMODE://设置WIFI工作模式
+			result = aiwb2.set_workmode(1,1);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStepWait(&pctrl,STEP_SET_RECEIVEMODE, 3 , "设置socket接收模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置WIFI工作模式失败");
+			}
+			break;
+		case STEP_SET_RECEIVEMODE://设置socket接收模式
+			result = aiwb2.set_receivingmode(1);
+			if(result == Result_Success)
+			{
+				 PCTRL_GotoStepWait(&pctrl,STEP_WIFI, 3 , "模块连接wifi");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置socket接收模式失败");
+			}
+			break;
+		case STEP_WIFI: //模块连接wifi
+			result = aiwb2.set_connect_WIFI(WIFI_RegistID, WIFI_RegistPASSWORD);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStepWait(&pctrl,STEP_OPEN, 3 , "连接TCP");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("模块连接wifi失败");
+			}
+		break;
+		case STEP_OPEN: // 打开客户端
+			result = aiwb2.open_socket(TCPID,REGIST_SERVER, REGIST_PORT);
+			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 = aiwb2.send(conID, regist_data, regist_data_length, &regist_data_length);
+			if(result == Result_Success)
+			{
+						
+				 int8_t res = TUORENIOT_AnalysisRegistData(regist_data, regist_data_length);
+			if(res == 1) // 成功
+			{
+				goto_success();
+			}
+			else // 失败
+			{
+				goto_failure("解析失败");
+			}
+			 }
+			else if(result == Result_Failed)
+			 {
+				goto_failure("注册数据处理失败");
+			 }
+				break;
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;	
+		case STEP_ENTER_SLEEP: // 进入深度睡眠
+			aiwb2.enter_sleep_io();
+			goto_finish();
+			break;
+		case STEP_SUCCESS: // 成功
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入深度睡眠");
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入深度休眠");
+			break;
+		case STEP_FINISH: // 结束流程STEP_FAILURE
+			break;
+		default:
+			goto_failure("步骤不存在");
+			break;				
+	}
+
+	
+}
+#endif
+

Drivers/Modules/aiwb2-32s/Aiwb2_UDP_Client5.c

@@ -0,0 +1,471 @@
+#include "CONFIG.h"
+#if  AIWB2
+
+#include "stm32f10x.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "UDP_Client.h"
+#include "Timer_Module.h"
+#include "Log_Module.h"
+
+#include "mbedtls_util.h"
+
+#include "cJSON.h"
+#include "Pump_Dicts_Util.h"
+#include "Regist.h"
+#include "PumpBusiness.h"
+#include "Initialize.h"
+#include "Tuoreniot.h"
+
+
+#include "aiwb2.h"
+
+
+//WiFi连接参数 
+char WIFI_ID[50]="tuoren";
+char WIFI_PASSWORD[30]="123456789";
+
+// 测试模式
+uint8_t UDPCLIENT_TestModeFlag = 0;
+
+// 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{
+	STEP_NONE, // 空闲状态，无操作
+	STEP_START, // 开始
+	STEP_EXIT_SLEEP, // 退出睡眠
+	STEP_START_AT,//发送AT，检测模块是否唤醒
+	STEP_SET_QISDE_0,//关闭发送回显
+	STEP_SET_WORKMODE,//设置WIFI工作模式
+	STEP_SET_RECEIVEMODE,//设置socket接收模式
+	STEP_WIFI_RSSI, //设定查询wifi的信息输出
+	STEP_SELECT_AP,//查询WIFI信号强度,设置WIFI
+	STEP_WIFI, //模块连接wifi
+	STEP_QUERY_SIGNAL,//查询WiFi信号强度
+	STEP_OPEN,//打开客户端
+	STEP_JUDGE_AUTH_OR_DATA,//判断认证还是发送
+	STEP_JOIN_AUTH_MESSAGE,//拼接认证报文
+	STEP_JOIN_DATA_MESSAGE,//拼接数据报文
+	STEP_SEND,// 发送send
+	STEP_WAIT, // 等待
+	STEP_SUCCESS,//成功
+	STEP_ENTER_SLEEP,// 进入睡眠
+	STEP_FAILURE,// 失败
+	STEP_FINISH,// 结束流程
+
+};
+
+
+// 步骤跳转时的监听
+//static uint8_t STEP_JOIN_AUTH_MESSAGE_times = 0; // 认证的次数
+//static uint8_t STEP_QUERY_CGREG_times = 0; // 查询网络状态的次数
+//static void initialize()
+//{
+//	STEP_JOIN_AUTH_MESSAGE_times = 0;
+//	STEP_QUERY_CGREG_times = 0;
+//}	
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置ec800m状态
+	aiwb2.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;
+}
+
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
+
+
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
+{
+//	initialize();
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
+}
+// 成功
+static void goto_success(void)
+{
+	UDPCLIENT_SetResult(UDPCLIENT_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
+}
+// 失败
+static void goto_failure(char * _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);
+}
+// 结束
+static void goto_finish(void)
+{
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
+}
+
+
+// 状态
+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)
+{
+	udpclient_status = status;
+}
+// 获取状态
+enum UDPCLIENT_StatusEnum UDPCLIENT_GetStatus(void)
+{
+	return udpclient_status;
+}
+// 设置结果
+static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result)
+{
+	udpclient_result = result;
+}
+// 获取结果
+enum UDPCLIENT_ResultEnum UDPCLIENT_GetResult(void)
+{
+	return udpclient_result;
+}
+// 重置
+enum EXECUTE_ResultEnum UDPCLIENT_Reset(void)
+{
+	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;
+}
+// 开始
+enum EXECUTE_ResultEnum UDPCLIENT_Start(void)
+{
+	UDPCLIENT_Reset();
+	if(UDPCLIENT_GetStatus() != UDPCLIENT_Status_None)
+	{
+		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 int wifi_number = 0; //wifi信息编号变量
+int wifi_rssi[10];			//各wifi信号值存储数组
+static enum Result result = Result_None;
+//UDPID=2 表示建立UDP连接
+static uint8_t UDPID = 2;
+//static uint16_t socket_err = 0;
+
+//获取最佳wifi_rssi中最佳信号位置
+int get_BestWifiSignal(int* rssi, int number)
+{
+	int signal=0;   //假设首个wifi信号最好
+	int value=-99;	//初始化比较值
+	for(int i=0; i<number; i++)
+	{
+		if((rssi[i] > value) && (rssi[i] != 0))
+		{
+			value = rssi[i];
+			signal = i;
+		}
+	}
+	return signal;
+}
+
+
+static void UDPCLIENT_Process(void)
+{
+		// 流程
+	switch(pctrl.current_step)
+	{
+		case STEP_NONE: // 空闲
+		break;
+		case STEP_START: // 开始
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
+			break;
+		case STEP_EXIT_SLEEP: // 退出休眠
+			result = aiwb2.exit_sleep_io_test();
+			aiwb2.exit_sleep_io();
+			PCTRL_GotoStepWait(&pctrl, STEP_START_AT,350, "设定模块查询信息的输出");
+			break;
+		case STEP_START_AT:	//开始AT,检测模块是否唤醒
+			result = aiwb2.test_at();
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl,STEP_SET_QISDE_0,"关闭发送回显");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("发送AT失败,模块未唤醒");
+			}
+			break;		
+		case STEP_SET_QISDE_0: // 关闭发送回显
+			result = aiwb2.set_qisde(0);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_WORKMODE, "设置WIFI工作模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("关闭发送回显失败");
+			}
+			break;	
+		case STEP_SET_WORKMODE://设置WIFI工作模式
+			result = aiwb2.set_workmode(1,1);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStepWait(&pctrl,STEP_SET_RECEIVEMODE,3,"设置socket接收模式");
+			}	
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置WIFI工作模式失败");
+			}
+			break;
+		case STEP_SET_RECEIVEMODE://设置socket接收模式
+			result = aiwb2.set_receivingmode(1);
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStepWait(&pctrl,STEP_WIFI_RSSI,3,"设定模块查询信息的输出");
+			}
+			else if(result == Result_Failed)
+			{
+					goto_failure("设置socket接收模式失败");
+			}
+			break;			
+		case STEP_WIFI_RSSI: //设定模块查询信息的输出
+			 result = aiwb2.set_dataout();
+			if(result == Result_Success)
+			{
+			 PCTRL_GotoStepWait(&pctrl, STEP_SELECT_AP, 3, "查询WIFI信号强度,设定连接wifi");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设定模块查询信息的输出失败");
+			}
+		break;	
+		case STEP_SELECT_AP://查询WIFI信号强度,设置WIFI
+		if(wifi_number < regist_response.wifiNumber)
+		{
+			result = aiwb2.query_id_signal(regist_response.wifi[wifi_number].wifiName, &wifi_rssi[wifi_number]);
+			if(result == Result_Success || result == Result_Failed)
+			{
+				Log_Printf_Debug("wifi%d的信号值RSSI=%d\r\n",wifi_number,wifi_rssi[wifi_number]);
+				Log_Printf_Debug("wifi_number=%d\r\n",wifi_number);
+				wifi_number++;
+				if(wifi_number == regist_response.wifiNumber)
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "wifi查询完成");
+				}else 
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "继续wifi的RSSI,选择wifi");
+				}
+			}
+		}
+		else
+		{
+			//获取信号最佳的wifi在数组中的位置
+			int i=get_BestWifiSignal(wifi_rssi, wifi_number);
+			//拷贝wifi信息
+			strcpy(WIFI_ID,regist_response.wifi[i].wifiName);
+			strcpy(WIFI_PASSWORD,regist_response.wifi[i].wifiPassword);
+			Log_Printf_Debug("选择信号最好的第%d组wifi\r\n",i);
+			Log_Printf_Debug("WIFI_ID=%s\r\n",WIFI_ID);
+			Log_Printf_Debug("WIFI_PASSWORD=%s\r\n",WIFI_PASSWORD);
+			PCTRL_GotoStep(&pctrl, STEP_WIFI, "模块连接wifi");
+		}
+		break;
+		case STEP_WIFI: //模块连接wifi
+			result = aiwb2.set_connect_WIFI(WIFI_ID, WIFI_PASSWORD);
+			if(result == Result_Success)
+			{
+			 PCTRL_GotoStepWait(&pctrl, STEP_QUERY_SIGNAL, 3, "查询已连接的wifi信号强度");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("模块连接wifi失败");
+			}
+		break;
+		case STEP_QUERY_SIGNAL://查询已连接的WiFi信号强度
+    		result = aiwb2.query_signal(&signal.RSSI);
+    		if(result == Result_Success)
+    		{
+    			PCTRL_GotoStep(&pctrl, STEP_OPEN, "打开客户端");
+    		}
+    		else if(result == Result_Failed)
+    		{
+    			goto_failure("查询WiFi信号强度失败");
+    		}
+    		break;  
+		case  STEP_OPEN:// 打开客户端
+			result = aiwb2.open_socket(UDPID,regist_response.address,regist_response.port);
+			if(result == Result_Success)
+			{
+				 PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证还是发送");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("客户端打开失败");
+			}
+		break;
+		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
+				if(TUORENIOT_IsAuthentication() == 1) // 已认证
+			{
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
+			}
+			else
+			{
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_AUTH_MESSAGE, "拼接认证报文");
+			}
+			break;	
+		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
+			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: // 拼接数据报文
+			
+			//
+			strcpy(regist_response.deviceSecret,"7bd7eaa33860ce9a2bd1b33633127f04");
+		
+			PUMPBUSINESS_ParamsRefresh();// 编码
+			memset(data, 0, sizeof(data));
+			PUMPDICTS_ProtocolEncode(&pump_params, data, &data_length);
+			memset(coap_message, 0, sizeof(coap_message));
+			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 = aiwb2.send(conID, coap_message, coap_message_length,&coap_message_length);
+			if(result == Result_Success)
+			{
+			uint8_t res	= TUORENIOT_AnalysisMessage(coap_message, coap_message_length);
+			 if(res == 0) 		// 发送失败
+			{
+			 PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "重新认证"); // 重新认证
+			}
+			 else if(res == 1) 	// 认证成功
+			{
+			 PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
+			}
+			else if(res == 2) 	// 发送成功
+			{
+			 goto_success();
+			 }
+			}
+			else if(result == Result_Failed)
+			{
+			 goto_failure("等待结果失败");
+		    }
+			break;	
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;			
+		case STEP_SUCCESS: // 成功
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
+			break;
+		case STEP_ENTER_SLEEP: // 进入睡眠
+			aiwb2.enter_sleep_io();
+			goto_finish();
+			break;
+		case STEP_FINISH: // 结束流程
+			Log_Printf_Debug("流程结束");
+			break;
+		default:
+			goto_failure("步骤不存在");
+			break;
+		
+	}
+}	
+
+#endif

Drivers/Modules/aiwb2-32s/aiwb2.c

@@ -0,0 +1,1504 @@
+#include "CONFIG.h"   //  
+#if AIWB2 
+
+#include "stm32f10x.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "Aiwb2.h"
+#include "Common_Util.h"
+#include "Log_Module.h"
+#include "At_Module.h"
+#include "Tuoreniot.h"
+
+ 
+ 
+/**
+  * 版   本       ：V1.0.0 /2024.10.15
+  * 作   者       ：李宗辉
+  */ 
+
+// AT指令
+static char AT_CMD[256];
+uint8_t conID  = 0;  //socket
+
+// 方法声明
+//设置休眠
+enum Result aiwb2_set_sleep(void);
+
+//关闭回显
+enum Result aiwb2_set_qisde(uint8_t echo);
+	
+//返回成功结果
+static enum Result success_no_log(void);
+//返回成功结果,不打印结果
+static enum Result success_noPrintedresults(void);
+	
+//进入休眠
+enum Result aiwb2_exit_sleep(void);
+
+//判断模块是否重启
+enum Result aiwb2_ready(void);
+	
+//重置状态
+void aiwb2_reset(void); // 重置状态。该文件中的方法共用状态，在使用下面的方法前需要重置一下状态。
+void aiwb2_reset_no_ATClear(void);//不清理AT
+
+//WiFi_Aiwb2模块发送"AT+SOCKETRECVCFG"指令：设置socket 接收模式
+enum Result aiwb2_set_receivingmode(uint8_t  n);
+
+//iFi_Aiwb2模块发送"AT+WMODE"指令：设置WIFI 工作模式
+enum Result aiwb2_set_workmode(uint8_t  n,uint8_t  m);
+
+//WiFi_Aiwb2模块发送"AT"指令
+enum Result aiwb2_test_at(void);
+
+// 验证ID是否正确
+static uint8_t verifyActiveID(uint8_t activeID);
+
+//设定查询wifi的信息输出
+enum Result aiwb2_set_dataout(void);
+
+//查询指定ID的WiFi信号强度
+enum Result aiwb2_query_id_signal(char * ID, int * RSSI);		
+
+//查询已连接WiFi的信号强度
+enum Result aiwb2_query_signal(int * RSSI);		
+
+// WiFi_Aiwb2模块发送"AT+WJAP"指令：连接wifi
+enum Result aiwb2_connect_WIFI(char *WIFI_Name, char *WIFI_Password);
+
+//断块WIFI连接
+enum Result aiwb2_wdisconnet(void);
+
+//打开socket服务
+enum Result aiwb2_open_socket(uint8_t UDPID, char * IP_address, uint16_t remote_port);
+
+//接收数据，带计时
+enum Result aiwb2_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out);
+
+//接收数据，带计时（注册接收）
+enum Result aiwb2_recv_with_time_regist(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out);
+
+//接收数据（注册接收）
+enum Result aiwb2_recv_regist(uint8_t connectID, uint8_t * data, uint16_t * data_length);
+
+//关闭socket服务
+enum Result aiwb2_close_socket(uint8_t connectID);
+	
+//发送报文
+enum Result aiwb2_send(uint8_t connectID, uint8_t * data, uint16_t send_data_length, uint16_t * recv_data_length);
+
+//唤醒模块，并检测是否重启
+enum Result aiwb2_exit_sleep_io_test(void);
+
+
+
+// 发送AT指令
+static void send_data(uint8_t * data, uint16_t length)
+{
+	// 发送AT指令
+	AT_Send_Bytes(data, length);
+}
+/**
+  * @brief  设置状态
+  * @param  enum STATUS status：aiwb2 状态
+  * @retval 无
+  */
+static void setStatus(enum STATUS status)
+{
+	aiwb2.status = status;
+}
+
+
+/**
+  * @brief  模块是否启动成功
+  * @param  enum STATUS status：aiwb2 状态
+  * @retval 无
+  */
+enum Result aiwb2_ready(void)
+{
+	if(AT_Get_Status() != AT_Status_None)
+	{
+		return Result_None;
+	}
+	enum Result result = Result_None;
+	// 判断是否接收到
+	uint8_t  RDY[5]="ready";
+	if(memmem(AT_result(),AT_result_length(),RDY,strlen((char *)RDY)) != 0)
+	{
+		// 发送日志
+		Log_Printf_Debug("进入模块是否重启判断AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		// 成功结果
+		result = Result_Success;
+		// 清理一下AT返回结果缓存
+		AT_Clear_Result();
+	}
+	return result;
+}
+
+
+
+/**
+  * @brief  获取ID
+  * @param  activeID：AT指令标识符ID
+  * @retval 无
+  */
+static void setActiveID(uint8_t activeID)
+{
+	aiwb2.activeID = activeID;
+}
+
+/**
+  * @brief  清除定时
+  * @param  无
+  * @retval 无
+  */
+static void clearTimer(void)
+{
+	time_clear(&aiwb2.timer);
+}
+
+/**
+  * @brief  重置状态。该文件中的方法共用状态，在使用方法前需要重置一下状态。
+  * @param  无
+  * @retval 无
+  */
+void aiwb2_reset(void)
+{
+	setStatus(Status_None); // 重置状态
+	setActiveID(0); // 重置ID
+	clearTimer(); // 重置计时
+	AT_Clear(); // 清除AT指令
+}
+
+
+void aiwb2_reset_no_ATClear(void)
+{
+	setStatus(Status_None); // 重置状态
+	setActiveID(0); // 重置ID
+	clearTimer(); // 重置计时	
+	//AT_Clear_noclear_result(); // 清除AT指令
+}
+
+/**
+  * @brief  获取wifi当前模块状态
+  * @param  无
+  * @retval ec800m.status：模块状态
+  */
+static enum STATUS getStatus(void)
+{
+	return aiwb2.status;
+}
+
+/**
+  * @brief  获取AT指令的ID
+  * @param  activeID ： AT指令的ID
+  * @retval c800m.activeID：AT指令的ID
+  */
+static uint8_t getActiveID(void)
+{
+	return aiwb2.activeID;
+}
+
+
+
+/**
+  * @brief  发送AT指令
+  * @param  cmd：发送的AT指令
+  * @retval 无
+  */
+static uint8_t send_at_string(char * cmd)
+{
+	uint8_t state = 0;
+	if(AT_Get_Status() == AT_Status_None)
+	{
+		// 发送AT指令
+		AT_Send_String(cmd);
+		state = 1;
+	}
+	return state;
+}
+
+
+
+
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT"指令
+  * @param  cmd：AT指令      activeID：AT指令的ID
+  * @retval 无
+  */
+enum Result send_at(char * cmd, uint8_t activeID)
+{
+	Log_Printf_Debug(cmd);	//打印AT指令
+	if(send_at_string(cmd)) // 发送AT指令
+	{
+		setActiveID(activeID); // 活动ID
+		setStatus(Status_Sending); // 设置状态为已发送
+		clearTimer();//重置计时
+		return Result_None; // 未知结果
+	}else
+	{
+		Log_Printf_Debug("AT指令发送失败\r\n"); // 打印日志
+		return Result_Failed; // 失败结果
+	}
+}
+
+
+/**
+  * @brief  这是状态为失败
+  * @param  type
+  * @retval Result_Failed：失败
+  */
+static enum Result failed(int type)
+{
+	// 失败
+	setStatus(Status_Failed);
+	if(type == 1)
+	{
+		Log_Printf_Debug("activeID: %d, error: 接收结果过期，请重置状态\r\n", aiwb2.activeID); // 打印日志
+	}
+	else if(type == 2)
+	{
+		// 发送日志
+		Log_Printf_Debug("activeID: %d, AT接收失败: %d\r\n", aiwb2.activeID, AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+	}
+	else
+	{
+		Log_Printf_Debug("activeID: %d, error: 未知错误类型\r\n", aiwb2.activeID); // 打印日志
+	}
+	// 失败结果
+	return Result_Failed;
+}
+
+/**
+  * @brief  获取定时
+  * @param  无
+  * @retval Result_Failed：失败
+  */
+static uint32_t getTimerMs(void)
+{
+	return time_get_delay(&aiwb2.timer);
+}
+
+
+/**
+  * @brief  返回超时结果
+  * @param  无
+  * @retval Result_Failed：失败
+  */
+static enum Result overtime(void)
+{
+	setStatus(Status_Overtime); // 超时
+	return Result_Failed; // 结果
+}
+
+
+// 返回成功结果
+static enum Result success_no_log(void)
+{
+	// 成功
+	setStatus(Status_Success);
+	// 结果
+	return Result_Success;
+}
+
+
+/**
+  * @brief  返回成功结果
+  * @param  无
+  * @retval Result_Success：成功
+  */
+static enum Result success(void)
+{
+	// 成功
+	Log_Printf_Debug("接收成功: %d\r\n", AT_result_length());
+	Log_SendArray_Debug(AT_result(), AT_result_length());
+	
+//	setStatus(Status_Success);
+	// 结果
+	return success_no_log();
+}
+
+
+/**
+  * @brief  返回成功结果   不打印结果
+  * @param  无
+  * @retval Result_Success：成功
+  */
+static enum Result success_noPrintedresults(void)
+{
+	
+//	setStatus(Status_Success);
+	// 结果
+	return success_no_log();
+}
+
+
+
+/**
+  * @brief  验证ID是否正确
+  * @param  activeID ： AT指令的ID
+  * @retval 1：AT指令的ID正确     0：错误（重复）
+  */
+static uint8_t verifyActiveID(uint8_t activeID)
+{
+	if(getActiveID() == 0 || getActiveID() == activeID){ return 1; }
+	else
+	{ 
+		Log_Printf_Debug("activeID  repetition!\r\n");
+		return 0; 
+	}
+}
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT"指令
+  * @param  无
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_test_at(void)
+{
+	enum Result result = Result_None;
+	int activeID = 1, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None )
+	{
+		
+		sprintf(AT_CMD,	"AT\r\n");//拼接AT指令		
+		result = send_at(AT_CMD, activeID);	
+	
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
+		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(); // 成功
+		aiwb2_reset();
+	}	
+	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(2); // 失败
+	}
+
+	return result;
+	
+}	
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT+WMODE"指令：WIFI 工作模式
+  * @param  n：WIFI 工作模式，1：STA模式				m：保是否存到 flash，1：保存
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+
+enum Result aiwb2_set_workmode(uint8_t  n,uint8_t  m)
+{
+	enum Result result = Result_None;
+	int activeID = 6, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+WMODE=%d,%d\r\n", n,m); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		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(); // 成功
+		aiwb2_reset();
+	}
+	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(2); // 失败
+	}	
+	return result;
+}
+
+
+
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT+SOCKETRECVCFG"指令：设置socket 接收模式
+  * @param  0：不打印接受的数据内容		1：打印接收的数据内容
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_set_receivingmode(uint8_t  n)
+{
+	enum Result result = Result_None;
+	int activeID = 3, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SOCKETRECVCFG=%d\r\n", n); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+		else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		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(); // 成功
+		aiwb2_reset();
+	}
+	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(2); // 失败
+	}
+	return result;
+}
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT+WJAP"指令：连接wifi
+  * @param  WIFI_Name：wifi名字 		WIFI_Password：wifi密码
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_connect_WIFI(char *WIFI_Name, char *WIFI_Password)
+{
+	enum Result result = Result_None;
+	int activeID = 4, time = 5000; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+WJAP=\"%s\",\"%s\"\r\n", WIFI_Name, WIFI_Password); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
+		result = overtime(); // 超时
+	}
+	else if(strstr((char * )AT_result(), "WIFI_GOT_IP\r\n") != NULL) // 查询是否返回
+	{
+		// 发送日志
+//		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+//		Log_SendArray_Debug(AT_result(), AT_result_length());		
+		result = success(); // 成功
+		aiwb2_reset();
+	}	
+	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(2); // 失败
+	}
+	return result;	
+}	
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT+SOCKET"指令：打开socket服务
+  * @param  UDPID：2表示建立UDP连接		IP_address：远程服务器地址		remote_port：远程服务器端口
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_open_socket(uint8_t UDPID, char * IP_address, uint16_t remote_port)
+{
+	enum Result result = Result_None;
+	int activeID = 5, time = 5000; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SOCKET=%d,\"%s\",%d\r\n", UDPID,  IP_address, remote_port); // 拼接AT指令   为什么使用了两个
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		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());	
+
+		//处理返回结果  获取ConID
+		char *data = (char * )AT_result();
+		char *saveptr = NULL;
+		char *split = "\r\n";
+
+		// 解析第一行
+		char *line1 = strtok_r(data, split, &saveptr);
+
+		// 查找 "ConID=" 并提取连接ID
+		char *conID_str = strstr(line1, "ConID=");
+		if (conID_str != NULL) 
+		{
+		conID = atoi(conID_str + strlen("ConID="));
+		Log_Printf_Debug("conID: %d\r\n", conID);
+		
+		result = success(); // 成功
+		aiwb2_reset();
+		}
+	}		
+	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(2); // 失败
+	}
+	return result;	
+	
+	
+}	
+
+
+/**
+  * @brief  WiFi_Aiwb2模块发送"AT+SOCKETSEN"指令：发送报文
+  * @param  UDPID：2表示建立UDP连接		IP_address：远程服务器地址		remote_port：远程服务器端口
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_send(uint8_t connectID, uint8_t * data, uint16_t send_data_length, uint16_t * recv_data_length)
+{
+	enum Result result = Result_None;
+	int activeID = 6, time = 10000; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SOCKETSEND=%d,%d\r\r\n", connectID, send_data_length); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}	
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
+		result = overtime(); // 超时
+	}	
+	else if(strstr((char * )AT_result(), ">") != NULL &&  AT_result_length() == 1) // 有响应
+	{
+//			flag_Arrow = 1;
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+
+			Log_Printf_Debug("\r\ncoap:\r\n");
+			Log_SendHex(data, send_data_length);
+			Log_Printf_Debug("\r\n");
+			// 发送数据		
+			send_data(data, send_data_length);
+		
+			// 清理一下AT返回结果缓存
+			AT_Clear_Result();
+	}
+	else if(strstr((char * )AT_result(), "SocketDown") != NULL) // 查询是否返回
+	{
+			
+		uint32_t last_time = AT_wait_time();
+		if(last_time > 10) // 过10ms之后再取数据，避免数据截断。
+		{
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d, time_diff: %d\r\n", AT_result_length(), last_time);
+			// 清理一下AT返回结果缓存
+		    //AT_Clear_Result();	
+		    char * saveptr = NULL;
+			char * split = "\r\n";
+			char * douhao = ",";
+			//char * zuokuohao = "{";
+			char * Line0 = strtok_r((char * )AT_result(), split, &saveptr);
+			uint8_t Line0_Len = strlen(Line0);  //得到OK的长度
+
+		    Log_Printf_Debug("Line0: %s\r\n", Line0);
+			// 后续调用，传入 NULL
+			char * Line1 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line1_Len = strlen(Line1);  //得到+EVENT:SocketDown的长度
+			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
+			
+			char * Line2 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line2_Len = strlen(Line2);  //得到conID的长度
+			Log_Printf_Debug("Line2(%d): %s\r\n",Line2_Len ,Line2);
+
+			char * Line3 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line3_Len = strlen(Line3);  //得到认证返回数据的长度
+			Log_Printf_Debug("Line3(%d): %s\r\n",Line3_Len ,Line3);
+			
+			
+			Line1_Len = Line1_Len + Line0_Len;
+			uint8_t Line4_Len = Line1_Len + Line2_Len;
+			uint8_t Line5_Len = Line4_Len + Line3_Len;
+			
+			
+			* recv_data_length = strtoul(Line3, NULL, 10) ;
+			
+			uint16_t line_length = Line5_Len + 6 ;
+			
+			
+			Log_Printf_Debug("Line5_Len: %d\r\n", Line5_Len);
+			
+			// 内存拷贝
+			memcpy(data, AT_result() +  line_length, * recv_data_length);
+			
+			result = Result_Success;
+			
+			AT_Clear_Result();	
+		
+		
+		   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(2); // 失败
+	}
+
+	return result;
+	
+}
+
+/**
+  * @brief  接收数据。带计时
+  * @param   connectID：认证返回的conID		data ：接收的数据   data：length 接收的数据长度。
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out)
+{
+	
+
+	enum Result result = Result_None;
+	int activeID = 7, time = time_out; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		setStatus(Status_Sending);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("等待时间超时\r\n"); // 打印日志
+		result = overtime(); // 超时
+	}
+	else
+	{
+		// 接收数据
+		result = aiwb2.recv(connectID, data, data_length);
+		if(result == Result_Success)
+		{
+			result = success(); // 成功
+		}
+	}
+	return result;
+	
+}
+
+/**
+  * @brief  接收数据
+  * @param   connectID：认证返回的conID		data ：接收的数据   data：length 接收的数据长度。
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_recv(uint8_t connectID, uint8_t * data, uint16_t * data_length)
+{
+		// 设置AT为使用中，防止被其他程序占用
+	AT_Set_Status(AT_Status_Using);
+	enum Result result = Result_None;
+	if(connectID > 10)//认证返回的conID最大是4
+	{
+		Log_Printf_Debug("recv params error!\r\n");
+		return Result_Failed; 
+	}
+	
+//	Log_Printf_Debug("-------aiwb2_recv-------AT返回: %d\r\n", AT_result_length());
+//	Log_SendArray_Debug(AT_result(), AT_result_length());
+	
+	
+	char cmp[100];
+	sprintf(cmp, "+EVENT:SocketDown,%d", connectID); // 拼接AT指令
+	if(strstr((char * )AT_result(), cmp) != NULL)
+	{
+		Log_Printf_Debug("-------aiwb2_recv-------AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		// 防止接收不完整
+		uint32_t last_time = AT_wait_time();
+		if(last_time > 10) // 过10ms之后再取数据，避免数据截断。
+		{
+			Log_Printf_Debug("--------aiwb2_recv——2------AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+
+		// 发送日志
+			Log_Printf_Debug("AT返回: %d, time_diff: %d\r\n", AT_result_length(), last_time);
+		// 清理一下AT返回结果缓存
+		    //AT_Clear_Result();	
+		    char * saveptr = NULL;
+			char * split = "\r\n";
+			char * douhao = ",";
+			//char * zuokuohao = "{";
+			char * Line0 = strtok_r((char * )AT_result(), split, &saveptr);
+			uint8_t Line0_Len = strlen(Line0);  //得到OK的长度
+
+		    Log_Printf_Debug("Line0: %s\r\n", Line0);
+			// 后续调用，传入 NULL
+			char * Line1 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line1_Len = strlen(Line1);  //得到+EVENT:SocketDown的长度
+			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
+			
+			char * Line2 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line2_Len = strlen(Line2);  //得到conID的长度
+			Log_Printf_Debug("Line2(%d): %s\r\n",Line2_Len ,Line2);
+
+			char * Line3 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line3_Len = strlen(Line3);  //得到认证返回数据的长度
+			Log_Printf_Debug("Line3(%d): %s\r\n",Line3_Len ,Line3);
+			
+
+			Line1_Len = Line1_Len + Line0_Len;
+			uint8_t Line4_Len = Line1_Len + Line2_Len;
+			uint8_t Line5_Len = Line4_Len + Line3_Len;
+			
+			
+			* data_length = strtoul(Line3, NULL, 10) ;
+			
+			uint16_t line_length = Line5_Len + 6 ;
+			
+			
+			Log_Printf_Debug("Line5_Len: %d\r\n", Line5_Len);
+			
+			// 内存拷贝
+			memcpy(data, AT_result() +  line_length, * data_length);
+			
+			result = Result_Success;
+			
+			AT_Clear_Result();
+	}		
+		
+	}
+	return result;
+	
+}
+
+
+/**
+  * @brief  接收数据。带计时（注册接收）
+  * @param   connectID：认证返回的conID		data ：接收的数据   data：length 接收的数据长度。
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_recv_with_time_regist(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out)
+{
+	enum Result result = Result_None;
+	int activeID = 7, time = time_out; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		setStatus(Status_Sending);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("等待时间超时\r\n"); // 打印日志
+		result = overtime(); // 超时
+	}
+	else
+	{
+		// 接收数据
+		result = aiwb2.recv_regist(connectID, data, data_length);
+		if(result == Result_Success)
+		{
+			result = success(); // 成功
+		}
+	}
+	return result;
+	
+}
+
+/**
+  * @brief  接收数据(注册接收)
+  * @param   connectID：认证返回的conID		data ：接收的数据   data：length 接收的数据长度。
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_recv_regist(uint8_t connectID, uint8_t * data, uint16_t * data_length)
+{
+		// 设置AT为使用中，防止被其他程序占用
+	AT_Set_Status(AT_Status_Using);
+	enum Result result = Result_None;
+	if(connectID > 4)//认证返回的conID最大是4
+	{
+		Log_Printf_Debug("recv params error!\r\n");
+		return Result_Failed; 
+	}
+	char cmp[50];
+	
+	
+	
+	sprintf(cmp, "+EVENT:SocketDown,%d", connectID); // 拼接AT指令
+	if(strstr((char * )AT_result(), cmp) != NULL)
+	{
+
+		// 防止接收不完整
+		uint32_t last_time = AT_wait_time();
+		if(last_time > 10) // 过10ms之后再取数据，避免数据截断。
+		{
+
+		     // 清理一下AT返回结果缓存
+		    //AT_Clear_Result();	
+		    char * saveptr = NULL;
+			//char * split = "\r\n";
+			char * douhao = ",";
+
+			// 后续调用，传入 NULL
+			char * Line1 = strtok_r((char * )AT_result(), douhao, &saveptr);
+			uint8_t Line1_Len = strlen(Line1);  //得到+EVENT:SocketDown的长度
+			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
+			
+			char * Line2 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line2_Len = strlen(Line2);  //得到conID的长度
+			Log_Printf_Debug("Line2(%d): %s\r\n",Line2_Len ,Line2);
+
+			char * Line3 = strtok_r(NULL, douhao, &saveptr);
+			uint8_t Line3_Len = strlen(Line3);  //得到认证返回数据的长度
+			Log_Printf_Debug("Line3(%d): %s\r\n",Line3_Len ,Line3);
+			
+
+//			
+//			Log_Printf_Debug("--------------AT返回: %d\r\n", AT_result_length());
+//		    Log_SendArray_Debug(AT_result(), AT_result_length());
+//			
+			uint8_t Line4_Len = Line1_Len + Line2_Len;
+			uint8_t Line5_Len = Line4_Len + Line3_Len;
+			
+			
+			* data_length = strtoul(Line3, NULL, 10) ;
+			
+			uint16_t line_length = Line5_Len + 3;
+			
+			
+			Log_Printf_Debug("Line5_Len: %d\r\n", Line5_Len);
+			
+			// 内存拷贝
+			memcpy(data, AT_result() +  line_length, * data_length);
+			
+			result = Result_Success;
+			
+			AT_Clear_Result();
+	}		
+		
+	}
+	return result;
+	
+}
+
+
+
+/**
+  * @brief  设置休眠
+  * @param   无
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_set_sleep(void)
+{
+	enum Result result = Result_None;
+	int activeID = 8, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SYSIOMAP=38,NC,NC,NC,NC,11,NC,NC,14,17,3,20,22,0,21,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC, NC,NC,4,2,NC,1,5,NC,NC,NC,NC,12,NC,NC\r\n"); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
+		
+		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(); // 成功
+		aiwb2_reset();
+	}
+	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(2); // 失败
+	}
+	return result;
+	
+}
+
+
+/**
+  * @brief  进入休眠
+  * @param   无
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_exit_sleep(void)
+{
+	enum Result result = Result_None;
+	int activeID = 9, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+		if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SLEEP=2,2,7,0\r\n"); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
+		
+		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(); // 成功
+		aiwb2_reset();
+
+	}
+	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(2); // 失败
+	}
+	return result;
+}
+	
+
+
+/**
+  * @brief  关闭socket服务
+  * @param   connectID：socketID
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_close_socket(uint8_t connectID)
+{
+	enum Result result = Result_None;
+	int activeID = 10, time = 500; // 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SOCKETDEL=%d\r\r\n", connectID); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		result = overtime(); // 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
+	{
+		result = success(); // 成功
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
+	{
+		result = failed(2); // 失败
+	}
+	return result;
+}
+
+/**
+  * @brief  控制是否回显   要发送的AT指令数据
+  * @param   connectID：socketID
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_set_qisde(uint8_t echo)
+{
+	enum Result result = Result_None;
+	int activeID = 11, time = 500; // 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) // 空闲状态
+	{
+		sprintf(AT_CMD, "ATE%d\r\r\n", echo); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		result = failed(1); // 失败
+	}
+	else if(getTimerMs() > time) // 正在发送状态。判断超时
+	{
+		result = overtime(); // 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
+	{
+		result = success(); // 成功
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
+	{
+		result = failed(2); // 失败
+	}
+	return result;
+}
+
+
+
+/**
+  * @brief  断块WIFI连接
+  * @param  无
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_wdisconnet(void)
+{
+	enum Result result = Result_None;
+	int activeID = 12, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None )
+	{
+		
+		sprintf(AT_CMD,	"AT+WDISCONNECT\r\n");//拼接AT指令		
+		result = send_at(AT_CMD, activeID);	
+	
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
+		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(); // 成功
+		aiwb2_reset();
+	}	
+	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(2); // 失败
+	}
+
+	return result;
+}
+
+
+
+/**
+  * @brief  查询指定WIFI信号强度
+  * @param  RSSI：信号强度
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+
+enum Result aiwb2_query_id_signal(char * ID, int * RSSI)
+{
+	
+	enum Result result = Result_None;
+	int activeID = 14, time=5000; 	// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+WSCAN=\"%s\"\r\n",ID); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n");// 打印日志
+		result = failed(1);		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK") != NULL) 	// 查询是否返回
+	{
+		if(AT_result_length() != 52 )
+		{
+			// 发送日志
+//			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+//			Log_SendArray_Debug(AT_result(), AT_result_length());
+//			// 处理返回结果
+			char * saveptr = NULL;			
+			char * blank =" ";
+			char * split ="\r\n";
+			char *lin1 = strtok_r((char * )AT_result(), blank, &saveptr);
+			* RSSI = atoi(strtok_r(NULL, split, &saveptr));
+//				
+//			//打印信号强度值
+//			Log_Printf_Debug("指定ID的WiFi强度值:%d\r\n", * RSSI);
+			result = success(); // 成功				
+		}else if(AT_result_length() == 52) 
+		{
+			* RSSI = -99;
+			Log_Printf_Debug("指定\"%s\"的WiFi未检测到\r\n", ID);
+			result = success(); // 成功
+			
+		}		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL)
+	{
+			* RSSI = -99;
+			Log_Printf_Debug("指定的\"%s\"wifi接受失败: %d\r\n", ID,AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());		
+			result = success_noPrintedresults(); // 返回成功,得以判断后续的wifi的RSSI
+
+	}
+	return result;
+}	
+
+/**
+  * @brief 查询当前WiFi信号强度
+  * @param  RSSI：信号强度
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_query_signal(int * RSSI)
+{
+	enum Result result = Result_None;
+	int activeID = 19, time=1000; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+WRSSI?\r\n"); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n");// 打印日志
+		result = failed(1);		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK") != NULL) 	// 查询是否返回
+	{
+			if(strstr((char * )AT_result(), "WRSSI") != NULL)
+			{
+//				Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+//				Log_SendArray_Debug(AT_result(), AT_result_length());
+				
+				// 处理返回结果
+				char * saveptr = NULL;
+				char * colon = ":";
+				char * split = "\r\n";
+				
+				strtok_r((char * )AT_result(), colon, &saveptr);
+				* RSSI = atoi(strtok_r(NULL, split, &saveptr));
+				
+				//打印信号强度值
+				Log_Printf_Debug("WiFi信号强度RSSI值: %d\r\n", *RSSI);
+				result = success(); // 成功
+			}
+			else 
+			{
+				// 发送日志
+//				Log_Printf_Debug("返回: %d\r\n", AT_result_length());
+//				Log_SendArray_Debug(AT_result(), AT_result_length());
+				result = failed(2); // 失败
+			}
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR") != NULL)
+	{
+		// 发送日志
+//		Log_Printf_Debug("返回: %d\r\n", AT_result_length());
+//		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(2); // 失败
+	}
+	return result;
+}
+
+/**
+  * @brief  进入睡眠（改变IO口电平的方式）
+  * @param  无
+  * @retval 无
+  */
+void aiwb2_enter_sleep_io(void)
+{
+	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉低io口，进入深睡眠
+}
+
+/**
+  * @brief  退出睡眠（改变IO口电平的方式）
+  * @param  无
+  * @retval 无
+  */
+void aiwb2_exit_sleep_io(void)
+{
+	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉高io口，唤醒模组
+}
+
+
+/**
+  * @brief  退出睡眠并检测是否重启成功（改变IO口电平的方式）
+  * @param  无
+  * @retval enum Result :是否成功返回信息
+  */
+enum Result aiwb2_exit_sleep_io_test(void)
+{
+				
+	
+	enum Result result = Result_None;
+	int activeID = 20, time=500; 		// 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed;}
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉高io口，唤醒模组	
+		setActiveID(activeID); // 活动ID
+		setStatus(Status_Sending); // 设置状态为已发送
+		clearTimer();//重置计时
+//		return Result_None; // 未知结
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期，请重置状态\r\n");// 打印日志
+		result = failed(1);		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("退出睡眠步骤超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "ready") != NULL)
+	{
+		Log_Printf_Debug("退出休眠成功\r\n");// 打印日志
+		result = success_noPrintedresults(); // 成功
+	}
+	return result;
+}
+
+/**
+  * @brief  设定查询指定WIFI信息的输出数据
+  * @param  RSSI：信号强度
+  * @retval enum Result：AT指令是否成功发送并返回的结果
+  */
+enum Result aiwb2_set_dataout(void)
+{
+	enum Result result = Result_None;
+	int activeID = 21, time = 500; // 活动ID, 超时时间
+	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
+	if(getStatus() == Status_None )
+	{
+		
+		sprintf(AT_CMD,	"AT+WSCANOPT=232\r\n");//拼接AT指令		
+		result = send_at(AT_CMD, activeID);	
+	
+	}
+	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
+		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(); // 成功
+		aiwb2_reset();
+	}	
+	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(2); // 失败
+	}
+
+	return result;
+}
+
+
+
+
+/*
+注册wifi参数设置
+*/
+static char Name[50];
+static char Password[30];
+
+//初始化wifi名字
+static void initClient_WiFiName(void);
+
+//初始化密码
+static void initClient_WiFiPassword(void);
+
+//初始化wifi名字
+static void initClient_WiFiName(void)
+{
+	//获取name
+	memset(Name, 0, sizeof(Name));
+
+	strcat(Name, "zz");
+	
+	
+}
+
+//初始化wifi密码
+static void initClient_WiFiPassword(void)
+{
+	//获取密码
+	memset(Password, 0, sizeof(Password));
+	strcat(Password, "123456789");	
+	
+}
+
+// 获取wifi_name
+char * WIFI_Name(void)
+{
+	initClient_WiFiName();
+	return Name;
+}
+
+
+char * WIFI_Password(void)
+{
+	initClient_WiFiPassword();
+	return Password;
+}
+
+
+
+// aiwb2提供的一些方法
+struct AIWB2_Struct aiwb2 =
+{
+	.timer = {
+		.time = 0,
+		.flag = 0
+	},
+	.ready = aiwb2_ready,
+	.reset = aiwb2_reset,
+	.test_at = aiwb2_test_at,
+	.set_receivingmode = aiwb2_set_receivingmode,
+	.set_workmode = aiwb2_set_workmode,
+	.set_connect_WIFI =aiwb2_connect_WIFI,
+	.set_qisde = aiwb2_set_qisde,	
+	.set_dataout = aiwb2_set_dataout,	
+	.open_socket = aiwb2_open_socket,
+	.close_socket=aiwb2_close_socket,
+	.send = aiwb2_send,
+	.recv_with_time = aiwb2_recv_with_time,
+	.recv = aiwb2_recv,
+	.recv_with_time_regist =aiwb2_recv_with_time_regist,
+	.recv_regist=aiwb2_recv_regist,	
+	.enter_sleep_io = aiwb2_enter_sleep_io, 	
+	.wdisconnet = aiwb2_wdisconnet,	
+	.query_id_signal = aiwb2_query_id_signal,	
+	.query_signal = aiwb2_query_signal,
+	.exit_sleep_io_test = aiwb2_exit_sleep_io_test,
+	.exit_sleep_io = aiwb2_exit_sleep_io, 
+};
+
+
+#endif
+

Drivers/Modules/aiwb2-32s/aiwb2.h

@@ -0,0 +1,95 @@
+#include "CONFIG.h"
+#if  AIWB2
+
+#ifndef __AIWB2_H
+#define __AIWB2_H
+#include "stm32f10x.h"                  // Device header
+#include <stdint.h>
+#include "Timer_Module.h"
+
+
+extern uint8_t conID; //socket ID
+
+
+char * WIFI_Name(void);
+char * WIFI_Password(void);
+
+
+enum Result
+{
+	Result_None, // 未知
+	Result_Success, // 成功
+	Result_Failed, // 失败
+};
+
+enum STATUS
+{
+	Status_None, // 空闲
+	Status_Sending, // 正在发送
+	Status_Success, // 成功
+	Status_Failed, // 失败
+	Status_Overtime, // 超时
+};
+
+
+
+extern struct AIWB2_Struct aiwb2;
+
+// aiwb2的AT发送状态机
+struct AIWB2_Struct
+{
+	enum STATUS status; // 状态
+	uint16_t activeID;	//活动的编号，下面每个活动都有一个唯一的编号
+	struct TIMER_Struct timer; // 计时器
+	void (* reset) (void);     //重置接收区的状态
+	void (* exit_sleep)(void);  // 退出休眠
+	void (* exit_sleep_io)(void);  // 退出休眠
+	void (* enter_sleep_io)(void);//硬件的方式进入休眠
+	enum Result (* enter_sleep)(void); // 进入休眠	
+	enum Result (* exit_sleep_io_test)(void);//退出休眠并检测结果	
+	enum Result (* ready)(void); // 模块是否启动成功
+	enum Result (* test_at)(void);//发送AT
+	enum Result (* set_receivingmode)(uint8_t  n); //设置接收模式
+	enum Result (* set_workmode)(uint8_t  n,uint8_t m);
+	enum Result	(* set_connect_WIFI)(char *WIFI_Name, char *WIFI_Password);
+	enum Result (* set_sleep)(uint8_t n); // 设置休眠模式
+	enum Result (* set_dataout)(void);//设定回显的数据格式
+	enum Result (* set_qisde)(uint8_t echo); // 控制发送数据后是否回显
+	enum Result (* open_socket)(uint8_t UDPID,  char * IP_address, uint16_t remote_port); // 打开Socket服务
+	enum Result (* send)(uint8_t connectID, uint8_t * data, uint16_t data_length, uint16_t * regist_data_length); // 发送数据
+	enum Result (* recv_with_time)(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out); // 接收数据，带等待时间。
+	enum Result (* recv)(uint8_t connectID, uint8_t * data, uint16_t * data_length); // 接收数据	
+	enum Result (* recv_with_time_regist)(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out); // 接收数据，带等待时间。
+	enum Result (* recv_regist)(uint8_t connectID, uint8_t * data, uint16_t * data_length); // 接收数据					
+	enum Result (* wdisconnet)(void); // 断开WIFI连接	
+	enum Result (* close_socket)(uint8_t connectID); // 关闭socket服务		
+	enum Result (* query_id_signal)(char * ID, int * RSSI);		//查询未连接wifi的rssi	
+	enum Result (* query_signal)(int * RSSI);//查询连接wifi的rssi
+	
+		
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
+
+
+
+
+#endif
+
+
+

Hardware/GPIOA.c

@@ -32,7 +32,17 @@ void GPIOA_Init(void)
 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 	GPIO_Init(WAKE_GPIO, &GPIO_InitStructure);
 	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // WiFiÉîÐÝÃßÒý½ÅÀ­µÍ
-
+	#endif
+	
+	#if  AIWB2
+	RCC_APB2PeriphClockCmd(WAKE_GPIO_RCC, ENABLE);
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
+	GPIO_InitTypeDef GPIO_InitStructure;	
+	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_ResetBits(GPIOA, GPIO_Pin_6); //WIFI_AIWB2-32SÀ­µÍ	
 	#endif
 }