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

#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