Huyi 1 年之前
父节点
当前提交
74471c1cfa

+ 231 - 0
Drivers/Modules/esp32/Esp32.Initialize.c

@@ -0,0 +1,231 @@
+#include "CONFIG.h"
+#if  ESP32
+
+#include "stm32f10x.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "Regist.h"
+#include "UDP_Client.h"
+#include "Initialize.h"
+#include "esp32.h"
+#include "PumpBusiness.h"
+#include "Log_Module.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 Step{
+	STEP_NONE,				// 空闲
+	STEP_START, 			// 开始
+	STEP_READY,				// 模块是否唤醒
+	STEP_EXIT_DEEP_SLEEP, 	// 退出深睡眠
+	STEP_ENTER_DEEP_SLEEP, 	// 进入深睡眠
+	STEP_WAIT, 				// 等待
+	
+	STEP_CONNECT_AP,		// 连接AP
+	
+	
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_FINISH,  // 流程结束
+};
+
+// 步骤跳转时的监听
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置esp32状态
+	esp32.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+//	if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 1)
+//	{
+//		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)
+{
+	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 =esp32.ready();
+		if(result==Result_Success)
+		{
+			Log_Printf_Debug("初始化诱因处理!!!\r\n");
+			INITIALIZE_Start();
+		}
+	}
+}
+
+static enum Result result = Result_None;
+
+static void INITIALIZE_Process(void)
+{
+	switch(pctrl.current_step)
+	{
+		case STEP_NONE: break;	// 空闲
+		case STEP_START: 		// 开始	
+						PCTRL_GotoStep(&pctrl, STEP_EXIT_DEEP_SLEEP, "退出深休眠");
+						break;
+		case STEP_EXIT_DEEP_SLEEP:		// 退出深休眠
+						esp32.exit_deepsleep();
+						PCTRL_GotoStep(&pctrl, STEP_READY, "判断模块是否启动");
+						break;
+		case STEP_READY: 				// 判断模块是否启动
+						result = esp32.ready();
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_CONNECT_AP, "连接AP");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("WiFi模块启动失败");
+						}
+						break;
+		case STEP_CONNECT_AP:			// 连接AP
+						result = esp32.connect_ap(WIFI_ID,WIFI_PASSWORD);
+						if(result == Result_Success)
+						{
+							goto_success();
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("连接AP失败");
+						}
+						break;
+		case STEP_WAIT: 			// 等待
+						PCTRL_Wait(&pctrl);
+						break;
+		case STEP_SUCCESS: 			// 成功
+						PCTRL_GotoStep(&pctrl, STEP_ENTER_DEEP_SLEEP, "泵数据发送成功,进入深休眠");
+						break;
+		case STEP_FAILURE: 			// 失败
+						PCTRL_GotoStep(&pctrl, STEP_ENTER_DEEP_SLEEP, "泵数据发送失败,进入深休眠");
+						break;	
+		case STEP_ENTER_DEEP_SLEEP:
+						esp32.enter_deepsleep();
+						Log_Printf_Debug("WiFi模块进入深休眠模式\r\n");
+						goto_finish();
+						break;
+		case STEP_FINISH: 			// 流程结束
+						break;
+		default: 		goto_failure("步骤不存在");
+						break;			
+	}
+}
+
+#endif
+
+
+

+ 330 - 0
Drivers/Modules/esp32/Esp32.Regist.c

@@ -0,0 +1,330 @@
+#include "CONFIG.h"
+#if  ESP32
+
+/**
+  ******************************************************************************
+  * 版   本       :V1.0.0
+  * 作   者       :huyi
+  * 版权所有,盗版必究。
+  * Copyright(C) All rights reserved
+  ******************************************************************************
+  *                             历史记录
+  *     序号      版本        变更内容          作者              日期
+  *      1        V0.0.1      实现WIFI注册      胡一          2024/10/15
+  *
+  ******************************************************************************
+  */
+
+#include "stm32f10x.h"
+#include "Regist.h"
+#include "esp32.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"
+
+/**************************************** 相关变量定义 ******************************************/
+//系统初始的WiFi连接参数 
+char INITIAL_WIFI_ID[10]="tuoren";
+char INITIAL_WIFI_PASSWORD[10]="123456789";
+
+
+// 注册参数
+static struct TUORENIOT_RegistRequestStruct regist_request = {
+	.version = 1,
+	.networkType = 3,
+	.networkProtocol = 1,
+	.deviceId = "3431228A1936013C",
+	.userId = "1000"
+};
+
+/******************************************* 函数声明 *******************************************/
+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_NONE,
+	STEP_START, 			// 开始
+	STEP_READY,				// 模块是否唤醒
+	STEP_EXIT_DEEP_SLEEP, 	// 退出深睡眠
+	STEP_ENTER_DEEP_SLEEP, 	// 进入深睡眠
+	STEP_WAIT,				// 等待
+	
+	STEP_CLOSE_AUTOCONNECT,	// 关闭自动连接AP
+	STEP_CONNECT_AP,		// 连接AP
+	STEP_QUERY_SIGNAL,		// 查询WiFi信号强度
+	STEP_SET_CIPMODE,		// 设置传输模式
+	STEP_CONNECT_NETWORK, 	// 连接TCP/UDP网络
+
+	STEP_JOIN_REGIST_MESSAGE, //拼接注册数据
+	STEP_HANDLE,			// 处理数据(数据发送+等待发送结果)
+	
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_FINISH,  // 流程结束
+	
+};
+
+/******************************************* 注册相关函数 *******************************************/
+
+// 步骤跳转时的监听
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置esp32状态
+	esp32.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	
+//	if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 1)
+//	{
+//		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)
+{
+	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)
+{
+  if(TUORENIOT_GetCodeOfRegistResponse() == 200){
+    regist_result = REGIST_Result_Success;
+  }
+  else
+  {
+    regist_result = REGIST_Result_None;
+  }
+	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;
+
+static void REGIST_Process()
+{
+	switch(pctrl.current_step)
+	{
+		case STEP_NONE: break;	// 空闲
+		case STEP_START: 		// 开始	
+						PCTRL_GotoStep(&pctrl, STEP_EXIT_DEEP_SLEEP, "退出休眠");
+						break;
+		case STEP_EXIT_DEEP_SLEEP:		// 退出深休眠
+						esp32.exit_deepsleep();
+						PCTRL_GotoStep(&pctrl, STEP_READY, "判断模块是否启动");
+						
+						break;
+		case STEP_READY: 				// 判断模块是否启动
+						result = esp32.ready();
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_CLOSE_AUTOCONNECT, "关闭自动连接AP模式");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("WiFi模块启动失败");
+						}
+						break;
+		case STEP_CLOSE_AUTOCONNECT:	// 关闭自动连接AP模式
+		
+						result = esp32.autoconnect_ap(0);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_CONNECT_AP, "连接AP");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("关闭自动连接AP模式失败");
+						}
+						break;
+		case STEP_CONNECT_AP:			// 连接AP
+						result = esp32.connect_ap(INITIAL_WIFI_ID,INITIAL_WIFI_PASSWORD);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_SET_CIPMODE, "设置普通传输模式");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("连接AP失败");
+						}
+						break;
+		case STEP_SET_CIPMODE:			//设置普通传输模式
+						result = esp32.set_cipmode(0);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_CONNECT_NETWORK, "连接TCP网络");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("设置传输模式失败");
+						}
+						break;
+		case STEP_CONNECT_NETWORK:		//连接TCP网络
+		
+						result = esp32.connect_network("TCP", REGIST_SERVER, REGIST_PORT);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_JOIN_REGIST_MESSAGE, "拼接注册信息");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("连接TCP网络失败");
+						}
+						break;
+	    case STEP_JOIN_REGIST_MESSAGE:	//拼接注册信息
+						memset(regist_request.deviceId, 0, sizeof(regist_request.deviceId));
+						memset(regist_data, 0, sizeof(regist_data));
+						TUORENIOT_PackRegistRequest(regist_data, &regist_data_length, &regist_request);
+						TUORENIOT_PrintfRegistRequestStruct(&regist_request);
+						PCTRL_GotoStep(&pctrl, STEP_HANDLE, "处理数据");
+						
+						break;
+		case STEP_HANDLE:				//处理数据
+						result = esp32.handle_data(regist_data, regist_data_length, &regist_data_length);
+						if(result == Result_Success)
+						{
+						
+							uint8_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_SUCCESS: 			// 成功
+						PCTRL_GotoStep(&pctrl, STEP_ENTER_DEEP_SLEEP, "注册成功,模块进入深休眠");	
+						break;
+		case STEP_FAILURE: 			// 失败
+						PCTRL_GotoStep(&pctrl, STEP_ENTER_DEEP_SLEEP, "注册失败,模块进入深休眠");
+						break;	
+		case STEP_ENTER_DEEP_SLEEP: // 模块进入深休眠
+						esp32.enter_deepsleep();
+						Log_Printf_Debug("模块进入深休眠模式\r\n");
+						goto_finish();
+						break;
+		case STEP_FINISH: 			// 流程结束
+						break;				
+		
+		default: 		break;
+	}
+}
+
+
+
+#endif
+
+

+ 410 - 0
Drivers/Modules/esp32/Esp32_UDP_Client5.c

@@ -0,0 +1,410 @@
+#include "CONFIG.h"
+#if  ESP32
+
+#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 "esp32.h"
+#include "Pump_Dicts_Util.h"
+#include "Regist.h"
+#include "PumpBusiness.h"
+#include "Initialize.h"
+#include "Tuoreniot.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_READY,				// 模块是否唤醒
+	STEP_EXIT_DEEP_SLEEP, 	// 退出深睡眠
+	STEP_ENTER_DEEP_SLEEP, 	// 进入深睡眠
+	STEP_WAIT, 				// 等待
+	
+	STEP_SELECT_AP,			// 选择AP
+	STEP_CONNECT_AP,		// 连接AP
+	STEP_QUERY_SIGNAL,		// 查询WiFi信号强度
+	STEP_SET_CIPMODE,		// 设置传输模式
+	STEP_CONNECT_NETWORK, 	// 连接TCP/UDP网络
+	
+	STEP_HANDLE,			// 处理数据(数据发送+等待发送结果)
+	STEP_JUDGE_AUTH_OR_DATA,// 判断认证还是发送
+	STEP_JOIN_AUTH_MESSAGE, // 拼接认证报文
+	STEP_JOIN_DATA_MESSAGE, // 拼接数据报文
+	STEP_CLOSE_AP, 			// 断开AP连接
+	STEP_CLOSE_NETWORK, 	// 断开TCP/UDP网络
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_FINISH,  // 流程结束
+};
+
+// 步骤跳转时的监听
+static uint8_t STEP_JOIN_AUTH_MESSAGE_times = 0; // 认证的次数
+static void initialize()
+{
+	STEP_JOIN_AUTH_MESSAGE_times = 0;
+}	
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置esp32状态
+	esp32.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_JOIN_AUTH_MESSAGE && STEP_JOIN_AUTH_MESSAGE_times++ >= 1)
+	{
+		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;
+
+//获取最佳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_DEEP_SLEEP, "退出深休眠");
+						break;
+		case STEP_EXIT_DEEP_SLEEP:		// 退出深休眠
+						esp32.exit_deepsleep();
+						PCTRL_GotoStep(&pctrl, STEP_READY, "判断模块是否启动");
+						break;
+		case STEP_READY: 				// 判断模块是否启动
+						result = esp32.ready();
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "选择AP");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("WiFi模块启动失败");
+						}
+						break;
+						
+		case STEP_SELECT_AP:	
+		
+						if(wifi_number < regist_response.wifiNumber)
+						{
+							result = esp32.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++;
+								PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "继续选择AP");
+							}
+						}
+						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_CONNECT_AP, "连接AP");
+						}
+						break;
+				
+		case STEP_CONNECT_AP:			// 连接AP
+						result = esp32.connect_ap(WIFI_ID,WIFI_PASSWORD);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_QUERY_SIGNAL, "查询WiFi信号强度");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("连接AP失败");
+						}
+						break;
+		case STEP_QUERY_SIGNAL:			//查询WiFi信号强度
+						result = esp32.query_signal(&signal.RSSI);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_SET_CIPMODE, "设置普通传输模式");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("查询WiFi信号强度失败");
+						}
+						break;
+		case STEP_SET_CIPMODE:			//设置普通传输模式
+						result = esp32.set_cipmode(0);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_CONNECT_NETWORK, "连接UDP网络");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("设置传输模式失败");
+						}
+						break;
+		case STEP_CONNECT_NETWORK:		//连接UDP网络
+						result = esp32.connect_network("UDP", regist_response.remoteAddress,regist_response.remotePort);
+						if(result == Result_Success)
+						{
+							PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证还是发送");
+						}
+						else if(result == Result_Failed)
+						{
+							goto_failure("连接UDP网络失败");
+						}
+						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_HANDLE, "发送认证报文");
+						break;	
+		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
+						// 泵数据更新
+						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_HANDLE, "发送数据报文");
+						break;				
+		case STEP_HANDLE:
+						
+						result = esp32.handle_data(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_DEEP_SLEEP, "泵数据发送成功,进入深休眠");
+						break;
+		case STEP_FAILURE: 			// 失败
+						PCTRL_GotoStep(&pctrl, STEP_ENTER_DEEP_SLEEP, "泵数据发送失败,进入深休眠");
+						break;	
+		case STEP_ENTER_DEEP_SLEEP:
+						esp32.enter_deepsleep();
+						Log_Printf_Debug("WiFi模块进入深休眠模式\r\n");
+						goto_finish();
+						break;
+		case STEP_FINISH: 			// 流程结束
+						break;
+		default: 		goto_failure("步骤不存在");
+						break;			
+	}
+}
+
+
+#endif

+ 1157 - 0
Drivers/Modules/esp32/esp32.c

@@ -0,0 +1,1157 @@
+#include "CONFIG.h"
+#if  ESP32
+
+#include "stm32f10x.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "esp32.h"
+#include "Common_Util.h"
+#include "Log_Module.h"
+#include "At_Module.h"
+
+
+/******************************************* 基于ESP32_C3模组的相关方法声明 *******************************************/
+
+void esp32_reset(void); 				//1.重置状态。该文件中的方法共用状态,在使用下面的方法前需要重置一下状态。
+void esp32_exit_deepsleep(void); 		//2.退出深休眠
+void esp32_enter_deepsleep(void); 		//3.进入深休眠
+void esp32_exit_lightsleep(void); 		//4.退出浅休眠
+void esp32_enter_lightsleep(void); 		//5.进入浅休眠
+enum Result esp32_set_lightsleep_wakeup(uint8_t source, uint8_t gpio, uint8_t mode);		//6.设置浅睡眠唤醒源
+enum Result esp32_set_lightsleep_wakeup_sync(uint8_t source, uint8_t gpio, uint8_t mode);	//7.设置浅睡眠唤醒源-同步
+enum Result esp32_set_sleep(uint8_t mode);				//8.设置睡眠模式
+enum Result esp32_set_sleep_sync(uint8_t mode);			//9.设置睡眠模式-同步
+
+enum Result esp32_connect_ap(char * id, char * password);				//10.连接AP
+enum Result esp32_connect_ap_sync(char * id, char * password);			//11.连接AP-同步
+
+enum Result esp32_set_cipmode(uint8_t mode);			//12.设置传输模式
+enum Result esp32_set_cipmode_sync(uint8_t mode);		//13.设置传输模式-同步
+enum Result esp32_connect_network(char * service_type, char * IP_address, uint16_t remote_port);			//14.连接TCP/UDP服务器
+enum Result esp32_connect_network_sync(char * service_type, char * IP_address, uint16_t remote_port);		//15.连接TCP/UDP服务器-同步
+
+enum Result esp32_query_id_signal(char * ID, int * RSSI);				//16.查询指定ID的WiFi信号强度
+enum Result esp32_query_id_signal_sync(char * ID, int * RSSI);		//17.查询指定ID的WiFi信号强度-同步
+
+enum Result esp32_close_network(void);							//18.关闭TCP/UDP连接
+enum Result esp32_close_network_sync(void);						//19.关闭TCP/UDP连接-同步
+enum Result esp32_autoconnect_ap(uint8_t mode);					//20.是否自动连接AP
+enum Result esp32_autoconnect_ap_sync(uint8_t mode);			//21.是否自动连接AP-同步
+enum Result esp32_close_ap(void);				//22.关闭AP连接
+enum Result esp32_close_ap_sync(void);			//23.关闭AP连接-同步
+//enum Result esp32_recv(uint8_t * data, uint16_t * data_length);										//24.接收数据
+//enum Result esp32_recv_with_time(uint8_t * data, uint16_t * data_length, uint32_t time_out);		//25.接收数据+等待时间
+//enum Result esp32_recv_with_time_sync(uint8_t * data, uint16_t * data_length, uint32_t time_out);	//26.接收数据+等待时间-同步
+enum Result esp32_query_signal(int * RSSI);			//27.查询已连接WiFi的信号强度
+enum Result esp32_query_signal_sync(int * RSSI);	//28.查询已连接WiFi的信号强度-同步
+enum Result esp32_ready(void);						//29.模块是否启动
+enum Result esp32_ready_sync(void);
+
+enum Result esp32_handle_data(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length);	//30.处理数据(数据发送+等待发送结果)
+enum Result esp32_handle_data_sync(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length);
+
+/*************************************************** AT指令相关函数 ***************************************************/
+
+//AT指令数组
+static char AT_CMD[256];
+
+//发送AT指令 二进制
+static void send_data(uint8_t * data, uint16_t length)
+{
+	AT_Send_Bytes(data, length);
+}
+
+// 发送AT指令 字符串
+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;
+}
+
+
+/******************************************* 基于ESP32_C3模组的相关执行函数 *********************************************/
+
+// 获取状态
+static enum STATUS getStatus(void)
+{
+	return esp32.status;
+}
+
+// 设置状态
+static void setStatus(enum STATUS status)
+{
+	esp32.status = status;
+}
+// 获取定时
+static uint32_t getTimerMs(void)
+{
+	return time_get_delay(&esp32.timer);
+}
+// 清除定时
+static void clearTimer(void)
+{
+	time_clear(&esp32.timer);
+}
+
+// 设置定时
+//static void setTimerMs(uint32_t time)
+//{
+//	esp32.timer_ms = time;
+//}
+
+// 获取ID
+static uint8_t getActiveID(void)
+{
+	return esp32.activeID;
+}
+
+//设置ID
+static void setActiveID(uint8_t activeID)
+{
+	esp32.activeID = activeID;
+}
+
+// 验证ID
+static uint8_t verifyActiveID(uint8_t activeID)
+{
+	if(getActiveID() == 0 || getActiveID() == activeID){ return 1; }
+	else
+	{ 
+		Log_Printf_Debug("activeID  repetition!\r\n");
+		return 0; 
+	}
+}
+
+// 返回超时结果
+static enum Result overtime(void)
+{
+	setStatus(Status_Overtime); // 超时
+	return Result_Failed; 		// 结果
+}
+
+// 返回成功结果
+static enum Result success(void)
+{
+	setStatus(Status_Success);	//成功
+	return Result_Success;		//结果
+}
+
+// 返回失败结果
+static enum Result failed(void)
+{
+	setStatus(Status_Failed);	//失败
+	return Result_Failed;		//结果
+}
+
+// 发送指令并改变状态
+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; 					// 失败结果
+	}
+}
+
+
+
+// 1.重置状态
+void esp32_reset(void)
+{
+	setStatus(Status_None); // 重置状态
+	setActiveID(0); 		// 重置ID
+	clearTimer(); 			// 重置计时
+	AT_Clear(); 			// 清除AT指令
+}
+
+//2.退出深休眠
+void esp32_exit_deepsleep(void)
+{
+	GPIO_SetBits(WAKE_GPIO, DEEP_SLEEP_GPIO_Pin); 	// 拉高IO口,使能ESP32_C3模组
+}		
+
+//3.进入深休眠
+void esp32_enter_deepsleep(void)
+{
+	GPIO_ResetBits(WAKE_GPIO, DEEP_SLEEP_GPIO_Pin); // 拉低IO口,使ESP32_C3模组失能
+}	
+
+//4.退出浅休眠	(使用此功能需先配置浅休眠模式)
+void esp32_exit_lightsleep(void)
+{
+	GPIO_SetBits(WAKE_GPIO, LIGHT_SLEEP_GPIO_Pin); 	// 拉高IO口,使ESP32_C3模组退出浅休眠
+}
+
+//5.进入浅休眠	(使用此功能需先配置浅休眠模式)
+void esp32_enter_lightsleep(void)
+{
+	GPIO_ResetBits(WAKE_GPIO, LIGHT_SLEEP_GPIO_Pin);// 拉低IO口,使ESP32_C3模组进入浅休眠
+}
+
+
+/******************************************************************************
+* 6.设置浅睡眠唤醒源
+* param1: source 代表唤醒源 (0:保留配置  1:保留配置  2:GPIO唤醒)
+* param2: gpio	(唤醒源为GPIO时,代表GPIO管脚)
+* param3: mode	(唤醒源为GPIO时,该参数表示唤醒电平。 0:低电平唤醒 1:高电平唤醒)
+*
+*******************************************************************************/
+enum Result esp32_set_lightsleep_wakeup(uint8_t source, uint8_t gpio, uint8_t mode)
+{
+	enum Result result = Result_None;
+	int activeID = 11, time=500; 		// 活动ID, 超时时间
+	//校验参数
+	if(source != 2)		//本模块浅休眠唤醒模式采用GPIO唤醒
+	{
+		Log_Printf_Debug("set lightsleep wakeup error!\r\n");
+		return Result_Failed;
+	}
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SLEEPWKCFG=%d,%d,%d\r\n",source,gpio,mode); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+//7.设置浅睡眠唤醒源-同步
+enum Result esp32_set_lightsleep_wakeup_sync(uint8_t source, uint8_t gpio, uint8_t mode)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_set_lightsleep_wakeup(source, gpio, mode);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 8.设置睡眠模式
+* param1: mode 代表睡眠模式 (0:禁用睡眠模式    1:Modem-sleep模式  
+							2:Light-sleep模式 3:Modem-sleep listen interval模式)
+*
+*******************************************************************************/
+enum Result esp32_set_sleep(uint8_t mode)
+{
+	enum Result result = Result_None;
+	int activeID = 12, time=500; 		// 活动ID, 超时时间
+	//校验参数
+	if(mode != 2)						//本模块采用浅休眠模式
+	{
+		Log_Printf_Debug("set sleep mode error!\r\n");
+		return Result_Failed;
+	}
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+SLEEP=%d\r\n",mode); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+//9.设置睡眠模式-同步
+enum Result esp32_set_sleep_sync(uint8_t mode)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_set_sleep(mode);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 10.连接AP
+* param1: id		目标名称
+* param2: password 	密码
+*
+*******************************************************************************/
+enum Result esp32_connect_ap(char * id, char * password)
+{
+	enum Result result = Result_None;
+	int activeID = 13, time=10000; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CWJAP=\"%s\",\"%s\"\r\n", id, password); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+//11.连接AP-同步
+enum Result esp32_connect_ap_sync(char * id, char * password)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_connect_ap(id, password);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/*************************************************************************************
+* 12.设置数据传输模式
+* param1: mode(0:普通传输模式  1:WiFi透传接收模式,支持TCP单连接、UDP固定通信对端的情况)
+*
+**************************************************************************************/
+enum Result esp32_set_cipmode(uint8_t mode)
+{
+	enum Result result = Result_None;
+	int activeID = 14, time=500; 		// 活动ID, 超时时间
+	//校验参数
+	if(mode != 0)						//本模块采用普通模式
+	{
+		Log_Printf_Debug("set cipmode error!\r\n");
+		return Result_Failed;
+	}
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CIPMODE=%d\r\n", mode); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+	
+}
+
+//13.设置传输模式-同步
+enum Result esp32_set_cipmode_sync(uint8_t mode)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_set_cipmode(mode);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 14.连接TCP/UDP服务器
+* param1: host远程地址
+* param2: port远程端口
+*
+*******************************************************************************/
+enum Result esp32_connect_network(char * service_type, char * IP_address, uint16_t remote_port)
+{
+	enum Result result = Result_None;
+	int activeID = 15, time=500; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CIPSTART=\"%s\",\"%s\",%d\r\n", service_type, IP_address, remote_port); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+//15.连接TCP/UDP服务器服务器-同步
+enum Result esp32_connect_network_sync(char * service_type, char * IP_address, uint16_t remote_port)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_connect_network(service_type, IP_address, remote_port);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 16.查询指定ID的WiFi信号强度
+* param1: ID 指定的WIFI名称
+*
+*******************************************************************************/
+enum Result esp32_query_id_signal(char * ID, int * RSSI)
+{
+	
+	enum Result result = Result_None;
+	int activeID = 66, time=5000; 	// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CWLAP=\"%s\"\r\n",ID); // 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK") != NULL) 	// 查询是否返回
+	{
+		if(strstr((char * )AT_result(), "CWLAP") != NULL)
+		{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+				
+			// 处理返回结果
+			char * saveptr = NULL;
+			char * split = ",";
+
+			strtok_r((char * )AT_result(), split, &saveptr);
+			strtok_r(NULL, split, &saveptr);
+			* RSSI = atoi(strtok_r(NULL, split, &saveptr));
+				
+			//打印信号强度值
+			Log_Printf_Debug("指定ID的WiFi强度值:%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(); // 失败
+		}
+			
+	}
+	return result;
+}				
+
+//17.查询指定ID的WiFi信号强度-同步
+enum Result esp32_query_id_signal_sync(char * ID, int * RSSI)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_query_id_signal(ID, RSSI);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 18.关闭TCP/UDP链接
+*
+*******************************************************************************/
+enum Result esp32_close_network(void)
+{
+	enum Result result = Result_None;
+	int activeID = 17, time=1000; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CIPCLOSE\r\n"); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			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());
+		
+		Log_Printf_Debug("当前无UDP网络连接\r\n");
+		
+		result = success(); // 同样返回成功
+	}
+	return result;
+}
+
+//19.关闭TCP/UDP连接-同步
+enum Result esp32_close_network_sync(void)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_close_network();
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 20.是否自动连接AP
+* param1: mode(0:上电不自动连接AP  1:上电自动连接 AP) 本设置保存到NVS区域
+*
+*******************************************************************************/
+enum Result esp32_autoconnect_ap(uint8_t mode)
+{
+	enum Result result = Result_None;
+	int activeID = 18, time=500; 		// 活动ID, 超时时间
+	//校验参数
+	if(mode != 0)		//本系统关闭自动连接AP模式
+	{
+		Log_Printf_Debug("set autoconnect mode error!\r\n");
+		return Result_Failed;
+	}
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CWAUTOCONN=%d\r\n", mode); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+//21.是否自动连接AP-同步
+enum Result esp32_autoconnect_ap_sync(uint8_t mode)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_autoconnect_ap(mode);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 22.关闭AP连接
+*
+*******************************************************************************/
+enum Result esp32_close_ap(void)
+{
+	enum Result result = Result_None;
+	int activeID = 17, time=500; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CWQAP\r\n"); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			result = success(); // 成功
+		
+	}
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+//23.关闭AP连接-同步
+enum Result esp32_close_ap_sync(void)
+{
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_close_ap();
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+
+
+
+/******************************************************************************
+* 26.查询WiFi信号强度
+* param1: RSSI信号强度值
+*
+*******************************************************************************/
+enum Result esp32_query_signal(int * RSSI)
+{
+	enum Result result = Result_None;
+	int activeID = 19, time=5000; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CWJAP?\r\n"); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK") != NULL) 	// 查询是否返回
+	{
+			if(strstr((char * )AT_result(), "CWJAP") != NULL)
+			{
+				// 发送日志
+				Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+				Log_SendArray_Debug(AT_result(), AT_result_length());
+				
+				// 处理返回结果
+				char * saveptr = NULL;
+				char * split = ",";
+				
+				strtok_r((char * )AT_result(), split, &saveptr);
+				strtok_r(NULL, split, &saveptr);
+				strtok_r(NULL, split, &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(); // 失败
+			}
+		
+	}
+	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(); // 失败
+	}
+	return result;
+}
+
+//26.查询WiFi信号强度-同步
+enum Result esp32_query_signal_sync(int * RSSI)
+{
+
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_query_signal(RSSI);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 29.模块是否重启
+*
+*******************************************************************************/
+enum Result esp32_ready(void)
+{
+	if(AT_Get_Status() != AT_Status_None)
+	{
+		return Result_None;
+	}
+	enum Result result = Result_None;
+	// 判断是否接收到
+	
+	if(strstr((char *)AT_result(),"ready") != 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;
+}
+
+enum Result esp32_ready_sync(void)
+{
+
+	enum Result result = Result_None;
+	while(1)
+	{
+		result = esp32_ready();
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+/******************************************************************************
+* 30.数据处理
+*
+*******************************************************************************/
+enum Result esp32_handle_data(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length)
+{
+	enum Result result = Result_None;
+	int activeID = 30, time=15000; 		// 活动ID, 超时时间
+	// 校验ID
+	if(!verifyActiveID(activeID)){ return Result_Failed; }
+	// 判断状态
+	if(getStatus() == Status_None) 		// 空闲状态
+	{
+		sprintf(AT_CMD, "AT+CIPSEND=%d\r\n",send_data_length); 	// 拼接AT指令
+		result = send_at(AT_CMD, activeID);
+	}
+	else if(getStatus() != Status_Sending) 		  		// 上一次的结果没有清除,返回错误,为了保证时效性,需要重置状态。重新调用
+	{
+		Log_Printf_Debug("返回结果过期,请重置状态\r\n");// 打印日志
+		result = failed();		// 失败
+	}
+	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+	{
+		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+		result = overtime(); 	// 超时
+	}
+	else if(strstr((char * )AT_result(), "OK\r\n\r\n>") != NULL) // 有响应
+	{
+			// 发送日志
+			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+			Log_SendArray_Debug(AT_result(), AT_result_length());
+			
+			//发送数据
+			send_data(data, send_data_length);
+			// 清理一下AT返回结果缓存
+			AT_Clear_Result();
+//			memset(data, 0, send_data_length);
+		
+	}
+
+	else if(strstr((char * )AT_result(), "+IPD") != NULL)
+	{
+				// 防止接收不完整
+				uint32_t last_time = AT_wait_time();
+				if(last_time > 20) // 过10ms之后再取数据,避免数据截断。
+				{
+					// 发送日志
+					Log_Printf_Debug("\r\nAT返回: %d, time_diff: %d\r\n", AT_result_length(), last_time);
+//					Log_SendHex(AT_result(), AT_result_length());
+					
+					char * saveptr1 = NULL;
+					char * saveptr2 = NULL;
+					char * split1 = ",";
+					char * split2 = ":";
+					
+					char * line1 = strtok_r((char * )AT_result(), split2, &saveptr1);
+					uint8_t Line1_Len = strlen(line1);
+					
+					strtok_r(line1, split1, &saveptr2); 
+					char * length = strtok_r(NULL, split1, &saveptr2);
+					* recv_data_length = strtoul(length, NULL, 10);
+					
+					//判断数据是否完整接收
+					if(* recv_data_length > AT_result_length())
+					{
+						Log_Printf_Debug("数据接收出错!!!\r\n");
+						// 失败
+						result = Result_Failed;
+						// 清理一下AT返回结果缓存
+						AT_Clear_Result();
+						return result;
+					}
+			
+					uint16_t line_length = Line1_Len+1;
+					// 内存拷贝
+					memcpy(data, AT_result() + line_length, * recv_data_length);
+					
+					// 成功
+					result = Result_Success;
+					// 清理一下AT返回结果缓存
+					AT_Clear_Result();
+				}
+	}
+
+	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+	{
+		// 发送日志
+		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
+		Log_SendArray_Debug(AT_result(), AT_result_length());
+		result = failed(); // 失败
+	}
+	return result;
+}
+
+enum Result esp32_handle_data_sync(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length)
+{
+
+	enum Result result = Result_None;
+	while(1)
+	{
+		result =  esp32_handle_data( data, send_data_length, recv_data_length);
+		if(result != Result_None)
+		{
+			// 重置
+			esp32.reset();
+			break;
+		}
+	}
+	return result;
+}
+
+///***************************************** 测试用*****************************************/
+//enum Result esp32_at(void)
+//{
+//	enum Result result = Result_None;
+//	int activeID = 88, time=500; 		// 活动ID, 超时时间
+//	
+//	// 校验ID
+//	if(!verifyActiveID(activeID)){ return Result_Failed; }
+//	// 判断状态
+//	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("返回结果过期,请重置状态\r\n");// 打印日志
+//		result = failed();		// 失败
+//	}
+//	else if(getTimerMs() > time) 						// 正在发送状态。判断超时
+//	{
+//		Log_Printf_Debug("AT指令返回超时\r\n"); 			// 打印日志
+//		result = overtime(); 	// 超时
+//	}
+//	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) 	// 查询是否返回
+//	{
+//			// 发送日志
+//			Log_Printf_Debug("测试命令AT返回: %d\r\n", AT_result_length());
+//			Log_SendArray_Debug(AT_result(), AT_result_length());
+//			result = success(); // 成功
+//		
+//	}
+//	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) 	// 查询是否返回
+//	{
+//		// 发送日志
+//		Log_Printf_Debug("测试命令AT返回: %d\r\n", AT_result_length());
+//		Log_SendArray_Debug(AT_result(), AT_result_length());
+//		result = failed(); // 失败
+//	}
+//	return result;
+//}
+
+//enum Result esp32_at_sync(void)
+//{
+//	enum Result result = Result_None;
+//	while(1)
+//	{
+//		result = esp32_at();
+//		if(result != Result_None)
+//		{
+//			// 重置
+//			esp32.reset();
+//			break;
+//		}
+//	}
+//	return result;
+//}
+
+/***************************************** 基于ESP32_C3模组的相关结构体声明 *****************************************/
+
+struct ESP32_Struct esp32=
+{
+	.timer = {
+		.time = 0,
+		.flag = 0
+	},
+	.reset = esp32_reset,	
+	.exit_deepsleep = esp32_exit_deepsleep,
+	.enter_deepsleep = esp32_enter_deepsleep,
+	.exit_lightsleep = esp32_exit_lightsleep,
+	.enter_lightsleep = esp32_enter_lightsleep,
+	.set_lightsleep_wakeup = esp32_set_lightsleep_wakeup,
+	.set_lightsleep_wakeup_sync = esp32_set_lightsleep_wakeup_sync,
+	.set_sleep = esp32_set_sleep,
+	.set_sleep_sync = esp32_set_sleep_sync,
+	.connect_ap = esp32_connect_ap,
+	.connect_ap_sync = esp32_connect_ap_sync,
+	.set_cipmode = esp32_set_cipmode,
+	.set_cipmode_sync = esp32_set_cipmode_sync,
+	.connect_network = esp32_connect_network,
+	.connect_network_sync = esp32_connect_network_sync,
+	.close_network = esp32_close_network,
+	.close_network_sync = esp32_close_network_sync,
+	.query_id_signal = esp32_query_id_signal,
+	.query_id_signal_sync = esp32_query_id_signal_sync,
+	.autoconnect_ap = esp32_autoconnect_ap,
+	.autoconnect_ap_sync = esp32_autoconnect_ap_sync,
+	.close_ap = esp32_close_ap,
+	.close_ap_sync = esp32_close_ap_sync,
+	.query_signal = esp32_query_signal,
+	.query_signal_sync = esp32_query_signal_sync,
+	.ready = esp32_ready,
+	.ready_sync = esp32_ready_sync,
+	.handle_data = esp32_handle_data,
+	.handle_data_sync = esp32_handle_data_sync,
+	
+};
+			
+
+#endif
+
+
+
+

+ 79 - 0
Drivers/Modules/esp32/esp32.h

@@ -0,0 +1,79 @@
+#include "CONFIG.h"
+#if  ESP32
+
+#ifndef __ESP32_H
+#define __ESP32_H
+#include <stdint.h>
+#include "Timer_Module.h"
+
+//系统初始的WiFi连接参数 
+extern char WIFI_ID[50];
+extern char WIFI_PASSWORD[30];
+
+enum Result
+{
+	Result_None, 	// 未知
+	Result_Success, // 成功
+	Result_Failed, 	// 失败
+};
+enum STATUS
+{
+	Status_None, 		// 空闲
+	Status_Sending, 	// 正在发送
+	Status_Success, 	// 成功
+	Status_Failed, 		// 失败
+	Status_Overtime, 	// 超时
+};
+
+extern struct ESP32_Struct esp32;
+
+// ESP32的AT发送状态机
+struct ESP32_Struct
+{
+	enum STATUS status; 					// 状态
+	uint16_t activeID; 						// 活动的编号。下面的每个活动都有一个唯一的编号
+	struct TIMER_Struct timer; 				// 计时器
+	
+	void (* reset)(void);					//1.重置状态
+	void (* exit_deepsleep)(void); 			//2.退出深休眠
+	void (* enter_deepsleep)(void); 		//3.进入深休眠
+	void (* exit_lightsleep)(void); 		//4.退出浅休眠
+	void (* enter_lightsleep)(void); 		//5.进入浅休眠
+	enum Result (* set_lightsleep_wakeup)(uint8_t source, uint8_t gpio, uint8_t mode);		//6.设置浅睡眠唤醒源
+	enum Result (* set_lightsleep_wakeup_sync)(uint8_t source, uint8_t gpio, uint8_t mode);	//7.设置浅睡眠唤醒源-同步
+	enum Result (* set_sleep)(uint8_t mode);		//8.设置睡眠模式
+	enum Result (* set_sleep_sync)(uint8_t mode);	//9.设置睡眠模式-同步
+	
+	enum Result (* connect_ap)(char* id, char* password);			//10.连接AP
+	enum Result (* connect_ap_sync)(char* id, char* password);		//11.连接AP-同步
+	
+	enum Result (* set_cipmode)(uint8_t mode);						//12.设置传输模式
+	enum Result (* set_cipmode_sync)(uint8_t mode);					//13.设置传输模式-同步
+	enum Result (* connect_network)(char * service_type, char * IP_address, uint16_t remote_port);			//14.连接TCP/UDP服务器
+	enum Result (* connect_network_sync)(char * service_type, char * IP_address, uint16_t remote_port);		//15.连接TCP/UDP服务器-同步
+
+	enum Result (* query_id_signal)(char * ID, int * RSSI);					//16.查询指定ID的WiFi信号强度
+	enum Result (* query_id_signal_sync)(char * ID, int * RSSI);			//17.查询指定ID的WiFi信号强度-同步
+	
+	enum Result (* close_network)(void);			//18.关闭TCP/UDP连接
+	enum Result (* close_network_sync)(void);		//19.关闭TCP/UDP连接-同步
+	enum Result (* autoconnect_ap)(uint8_t mode);					//20.是否自动连接AP
+	enum Result (* autoconnect_ap_sync)(uint8_t mode);				//21.是否自动连接AP-同步
+	enum Result (* close_ap)(void);					//22.关闭AP连接
+	enum Result (* close_ap_sync)(void);			//23.关闭AP连接-同步
+
+	enum Result (* query_signal)(int * RSSI);		//27.查询已连接WiFi的信号强度
+	enum Result (* query_signal_sync)(int * RSSI);	//28.查询已连接WiFi的信号强度-同步
+	enum Result (* ready)(void);					//29.模块是否启动
+	enum Result (* ready_sync)(void);
+	
+	enum Result (* handle_data)(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length);	//30.处理数据(数据发送+等待发送结果)
+	enum Result (* handle_data_sync)(uint8_t * data, uint16_t send_data_length, uint16_t *recv_data_length);
+	
+};
+
+
+
+#endif
+
+#endif