Network-Modules/Drivers/Modules/ec800m/ec800m.c

#include "CONFIG.h"
#if  EC800M

#include "stm32f10x.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>

#include "ec800m.h"
#include "Common_Util.h"
#include "Log_Module.h"
#include "At_Module.h"

/**
* 龙三郎
**/

// 方法声明

void ec800m_reset(void); // 重置状态。该文件中的方法共用状态，在使用下面的方法前需要重置一下状态。
void ec800m_exit_sleep(void); // 退出休眠
void ec800m_enter_sleep(void); // 进入休眠
/**
* 查询休眠模式
* 输入<<
* 
* 输出>>
* n 睡眠模式。0 禁用，默认；1 启用。
**/
enum Result ec800m_query_sleep(uint8_t * n); // 查询休眠模式。
enum Result ec800m_query_sleep_sync(uint8_t * n); // 查询休眠模式。同步
/**
* 设置休眠模式
* 输入<<
* n 参数。0 禁用；1启用。
* 输出>>
* 
**/
enum Result ec800m_set_sleep(uint8_t n); // 设置休眠模式。
enum Result ec800m_set_sleep_sync(uint8_t n); // 设置休眠模式。同步
/**
* 设置功能模式
* 输入<<
* fun 0 最小功能模式；1 全功能模式。
* 输出>>
* 
**/
enum Result ec800m_set_cfun(uint8_t fun);
enum Result ec800m_set_cfun_sync(uint8_t fun); // 同步
/**
* 设置ps域网络注册状态
* 输入<<
* n 0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
* 输出>>
* 
**/
enum Result ec800m_set_cgreg(uint8_t n);
enum Result ec800m_set_cgreg_sync(uint8_t n); // 同步
/**
* 查询ps域网络注册状态
* 输入<<
* 
* 输出>>
* n 控制指定URC的上报。0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
* stat 网络注册状态。0 未注册；1 已注册，归属地网络； 2 未注册；3 注册被拒绝；4 未知；5 已注册，漫游。
* lac 基站位置区号。用于基站定位，2个字节。
* ci 基站小区ID。用于基站定位，4个字节。
*
**/
enum Result ec800m_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci);
enum Result ec800m_query_cgreg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci); // 同步
/** 
* 查询socket服务状态
* 输入<<
* connectID Socket ID。范围1-11
* 
* 输出>>
* state Socket服务状态。0 未连接；1 正在连接；2 已建立连接；3 服务正在监听；4 连接断开。
*
* 
**/
enum Result ec800m_query_socket_state(uint8_t connectID, uint8_t * state);
enum Result ec800m_query_socket_state_sync(uint8_t connectID, uint8_t * state); // 同步
/** 
* 打开socket服务
* 输入<<
* connectID Socket ID。范围1-11
* service_type Socket服务类型。取值为"UDP", "TCP"。
* IP_address 远程服务器地址
* remote_port 远程服务器端口
* access_mode Socket服务的数据访问模式。0 缓存模式；1 直吐模式；2 透传模式。
*
* 输出>>
* err 操作错误代码。0 表示没有错误；其余参考移远文档。
*
**/
enum Result ec800m_open_socket(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err);
enum Result ec800m_open_socket_sync(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err); // 同步
/** 
* 关闭socket服务
* 输入<<
* connectID Socket ID。范围1-11
*
* 输出>>
* 
**/
enum Result ec800m_close_socket(uint8_t connectID);
enum Result ec800m_close_socket_sync(uint8_t connectID); // 同步
/** 
* 解释：控制是否回显AT+QISEND要发送的数据
* 为了便于处理返回，发送数据时需要关闭回显。
* 输入<<
* echo 是否回显AT+QISEND要发送的数据。0 不回显；1 回显。默认是回显
*
* 输出>>
* 
**/
enum Result ec800m_set_qisde(uint8_t echo);
enum Result ec800m_set_qisde_sync(uint8_t echo); // 同步

/** 
* 发送数据
* 输入<<
* connectID Socket ID。范围1-11。
* send_length 发送长度。
* data 待发送的数据。
*
*
**/
enum Result ec800m_send(uint8_t connectID, uint8_t * data, uint16_t data_length);
enum Result ec800m_send_sync(uint8_t connectID, uint8_t * data, uint16_t data_length); // 同步
/** 
* 接收数据
* 输入<<
* connectID Socket ID。范围0-11。
*
* 输出>>
* data 接收的数据。
* data_length 接收的数据长度。
**/
enum Result ec800m_recv(uint8_t connectID, uint8_t * data, uint16_t * data_length); // 接收数据
/** 
* 接收数据。带计时
* 输入<<
* connectID Socket ID。范围0-11。
*
* 输出>>
* data 接收的数据。
* data_length 接收的数据长度。
*
**/
enum Result ec800m_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out);
enum Result ec800m_recv_with_time_sync(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out); // 同步
/** 
* 解释：关闭模块
* 关闭模块，关闭后会自动重启。
* 输入<<
* n 模块关机方式。0 立即关机；1 正常关机。默认是1
*
*
**/
enum Result ec800m_power_down(uint8_t n);
enum Result ec800m_power_down_sync(uint8_t n); // 同步
/** 
* 模块是否启动成功
* 输入<<
*
* 输出>>
*
**/
enum Result ec800m_ready(void);

/** 
* 查询信号质量
* 输入<<
*
* 输出>>
* RSRP 
* RSRQ
* RSSI
* SINR
**/
enum Result ec800m_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SINR);
enum Result ec800m_qeng_servingcell_sync(int * RSRP, int * RSRQ, int * RSSI, int * SINR);


/** 
* 查询ICCID
* 输入<<
*
* 输出>>
* iccid SIM卡卡号
**/
enum Result ec800m_query_qccid(char * iccid);
enum Result ec800m_query_qccid_sync(char * iccid);


// AT指令
static char AT_CMD[256];


// EC800M提供的一些方法
struct EC800M_Struct ec800m =
{
	.timer = {
		.time = 0,
		.flag = 0
	},
	.reset = ec800m_reset,
	.exit_sleep = ec800m_exit_sleep,
	.enter_sleep = ec800m_enter_sleep,
	.query_sleep = ec800m_query_sleep,
	.query_sleep_sync = ec800m_query_sleep_sync,
	.set_sleep = ec800m_set_sleep,
	.set_sleep_sync = ec800m_set_sleep_sync,
	.set_cfun = ec800m_set_cfun,
	.set_cfun_sync = ec800m_set_cfun_sync,
	.set_cgreg = ec800m_set_cgreg,
	.set_cgreg_sync = ec800m_set_cgreg_sync,
	.query_cgreg = ec800m_query_cgreg,
	.query_cgreg_sync = ec800m_query_cgreg_sync,
	.query_socket_state = ec800m_query_socket_state,
	.query_socket_state_sync = ec800m_query_socket_state_sync,
	.open_socket = ec800m_open_socket,
	.open_socket_sync = ec800m_open_socket_sync,
	.close_socket = ec800m_close_socket,
	.close_socket_sync = ec800m_close_socket_sync,
	.set_qisde = ec800m_set_qisde,
	.set_qisde_sync = ec800m_set_qisde_sync,
	.send = ec800m_send,
	.send_sync = ec800m_send_sync,
	.recv = ec800m_recv,
	.recv_with_time = ec800m_recv_with_time,
	.recv_with_time_sync = ec800m_recv_with_time_sync,
	.power_down = ec800m_power_down,
	.power_down_sync = ec800m_power_down_sync,
	.ready = ec800m_ready,
	.qeng_servingcell = ec800m_qeng_servingcell,
	.qeng_servingcell_sync = ec800m_qeng_servingcell_sync,
	.query_qccid = ec800m_query_qccid,
	.query_qccid_sync = ec800m_query_qccid_sync
};


// 发送AT指令
static void send_data(uint8_t * data, uint16_t length)
{
	// 发送AT指令
	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;
}



// 获取状态
static enum STATUS getStatus(void)
{
	return ec800m.status;
}
// 设置状态
static void setStatus(enum STATUS status)
{
	ec800m.status = status;
}
// 获取定时
static uint32_t getTimerMs(void)
{
	return time_get_delay(&ec800m.timer);
}
// 清除定时
static void clearTimer(void)
{
	time_clear(&ec800m.timer);
}
// 设置定时
//static void setTimerMs(uint32_t time)
//{
//	ec800m.timer_ms = time;
//}
// 获取ID
static uint8_t getActiveID(void)
{
	return ec800m.activeID;
}
static void setActiveID(uint8_t activeID)
{
	ec800m.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;
}



// 重置状态。该文件中的方法共用状态，在使用方法前需要重置一下状态。
void ec800m_reset(void)
{
	setStatus(Status_None); // 重置状态
	setActiveID(0); // 重置ID
	clearTimer(); // 重置计时
	AT_Clear(); // 清除AT指令
}

// 退出休眠
void ec800m_exit_sleep(void)
{
	GPIO_ResetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉低io口，唤醒模组
}

// 进入休眠
void ec800m_enter_sleep(void)
{
	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin); // 拉高io口，进入睡眠
}
// 发送指令并改变状态
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; // 失败结果
	}
}



/**
* 查询休眠模式
* 输入<<
* 
* 输出>>
* n 睡眠模式。0 禁用，默认；1 启用。
*
**/
enum Result ec800m_query_sleep(uint8_t * n)
{
	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+QSCLK?\r\r\n"); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期1，请重置状态\r\n"); // 打印日志
		
		result = failed(); // 失败
	}
	else if(getTimerMs() > time) // 正在发送状态。判断超时
	{
		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
		result = overtime(); // 超时
	}
	if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
	
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		char * Line1 = strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 拆解第二行
		char * saveptr_inner = NULL;
		char * split_inner = ": ";
		strtok_r(Line2, split_inner, &saveptr_inner);
		// 获取mode
		* n = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		
		result = success(); // 成功
	}
	else if(strstr((char * )AT_result(), "ERROR\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		result = failed(); // 失败
	}
	return result;
}



/**
* 查询休眠模式。同步方法
* 输入<<
* 
* 输出>>
* n 睡眠模式。0 禁用，默认；1 启用。
*
**/
enum Result ec800m_query_sleep_sync(uint8_t * n)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_query_sleep(n);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}



/**
* 设置休眠模式
* n 参数。0 禁用；1启用。
**/
enum Result ec800m_set_sleep(uint8_t n)
{
	enum Result result = Result_None;
	int activeID = 2, time = 500; // 活动ID, 超时时间
	if(!verifyActiveID(activeID)){ return Result_Failed; } // 校验ID
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QSCLK=%d\r\r\n", 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;
}

/**
* 设置休眠模式。同步
* n 参数。0 禁用；1启用。
**/
enum Result ec800m_set_sleep_sync(uint8_t n)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_set_sleep(n);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}

/**
* 设置功能模式
* fun 0 最小功能模式；1 全功能模式。
**/
enum Result ec800m_set_cfun(uint8_t fun)
{
	enum Result result = Result_None;
	int activeID = 4, time; // 活动ID, 超时时间
	// 校验参数
	if(fun == 0){ time = 3000; }
	else if(fun == 1){ time = 5000; }
	else
	{
		Log_Printf_Debug("set_cfun params error!\r\n");
		return Result_Failed; 
	} 
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+CFUN=%d\r\r\n", fun); // 拼接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) // 查询是否返回
	{
		// 防止接收不完整
		if(AT_wait_time() > 10) // 过10ms之后再取数据，避免数据截断。
		{
			// 发送日志
			Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
			Log_SendArray_Debug(AT_result(), AT_result_length());
			
			result = success(); // 成功
		}
	}
	else if(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;
}
/**
* 设置功能模式
* 输入<<
* fun 0 最小功能模式；1 全功能模式。
* 输出>>
* 
**/
enum Result ec800m_set_cfun_sync(uint8_t fun)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_set_cfun(fun);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/**
* 设置ps域网络注册状态
* n 0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
**/
enum Result ec800m_set_cgreg(uint8_t n)
{
	enum Result result = Result_None;
	int activeID = 6, time = 500; // 活动ID, 超时时间
	// 校验参数
	if(n > 2)
	{
		Log_Printf_Debug("set_cgreg params error!\r\n");
		return Result_Failed; 
	} 
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+CGREG=%d\r\r\n", 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;
}

/**
* 设置ps域网络注册状态
* 输入<<
* n 0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
* 输出>>
* 
**/
enum Result ec800m_set_cgreg_sync(uint8_t n)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_set_cgreg(n);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/**
* 查询ps域网络注册状态
* 输入<<
* 
* 输出>>
* n 控制指定URC的上报。0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
* stat 网络注册状态。0 未注册；1 已注册，归属地网络； 2 未注册；3 注册被拒绝；4 未知；5 已注册，漫游。
* lac 基站位置区号。用于基站定位，2个字节。
* ci 基站小区ID。用于基站定位，4个字节。
*
**/
enum Result ec800m_query_cgreg(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
{
	enum Result result = Result_None;
	int activeID = 9, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+CGREG?\r\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"); // 打印日志
		setStatus(Status_Overtime); // 超时
		result = Result_Failed; // 结果
	}
	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 拆解第二行
		char * saveptr_inner = NULL;
		char * split_inner = ": ,\"";
		strtok_r(Line2, split_inner, &saveptr_inner);
		* n = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		* stat = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		* lac = strtoul(strtok_r(NULL, split_inner, &saveptr_inner), NULL, 16);
		* ci = strtoul(strtok_r(NULL, split_inner, &saveptr_inner), NULL, 16);
		// 打印
		Log_Printf_Debug("mode: %d, stat: %d, lac: %d, ci: %d\r\n", * n, * stat, * lac, * ci);
		
		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;
}

/**
* 查询ps域网络注册状态
* 输入<<
* 
* 输出>>
* n 控制指定URC的上报。0 禁止上报网络注册；1 允许上报网络注册；2 允许上报网络注册和位置信息
* stat 网络注册状态。0 未注册；1 已注册，归属地网络； 2 未注册；3 注册被拒绝；4 未知；5 已注册，漫游。
* lac 基站位置区号。用于基站定位，2个字节。
* ci 基站小区ID。用于基站定位，4个字节。
*
**/
enum Result ec800m_query_cgreg_sync(uint8_t * n, uint8_t * stat, uint16_t * lac, uint32_t * ci)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_query_cgreg(n, stat, lac, ci);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/** 
* 查询socket服务状态
* connectID Socket ID。范围1-11
* state Socket服务状态。0 未连接；1 正在连接；2 已建立连接；3 服务正在监听；4 连接断开。
*
* activeID 9
**/
enum Result ec800m_query_socket_state(uint8_t connectID, uint8_t * state)
{
	enum Result result = Result_None;
	int activeID = 9, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QISTATE=1,%d\r\r\n", connectID); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
		result = failed(); // 失败
	}
	else if(getTimerMs() > time) // 正在发送状态。判断超时
	{
		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
		result = overtime(); // 超时
	}
	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 查询结果为空
		if(strcmp(Line2, "OK") == 0){ * state = 0; }
		else
		{
			// 拆解第二行
			char * saveptr_inner = NULL;
			char * split_inner = ": ,\"";
			strtok_r(Line2, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			* state = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		}
		// 打印
		Log_Printf_Debug("result: %d\r\n", * state);
		
		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;
}

/** 
* 查询socket服务状态
* connectID Socket ID。范围1-11
* state Socket服务状态。0 未连接；1 正在连接；2 已建立连接；3 服务正在监听；4 连接断开。
*
* activeID 9
**/
enum Result ec800m_query_socket_state_sync(uint8_t connectID, uint8_t * state)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_query_socket_state(connectID, state);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/** 
* 打开socket服务
* 输入<<
* connectID Socket ID。范围1-11
* service_type Socket服务类型。取值为"UDP", "TCP"。
* IP_address 远程服务器地址
* remote_port 远程服务器端口
* access_mode Socket服务的数据访问模式。0 缓存模式；1 直吐模式；2 透传模式。
*
* 输出>>
* err 操作错误代码。0 表示没有错误；其余参考移远文档。
*
* activeID 19
**/
enum Result ec800m_open_socket(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err)
{
	enum Result result = Result_None;
	int activeID = 19, time = 3000; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QIOPEN=1,%d,\"%s\",\"%s\",%d,%d,%d\r\r\n", connectID, service_type, IP_address, remote_port, 0, access_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(), "+QIOPEN: ") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 第三行
		char * Line3 = strtok_r(NULL, split, &saveptr);
		// 查询结果为空
		if(strcmp(Line2, "OK") == 0)
		{
			// 拆解第三行
			char * saveptr_inner = NULL;
			char * split_inner = ": ,\"";
			strtok_r(Line3, split_inner, &saveptr_inner);
			uint8_t connID = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
			* err = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
			Log_Printf_Debug("result: %d, %d\r\n", connID, * err);
		}
		
		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;
}

/** 
* 打开socket服务
* 输入<<
* connectID Socket ID。范围1-11
* service_type Socket服务类型。取值为"UDP", "TCP"。
* IP_address 远程服务器地址
* remote_port 远程服务器端口
* access_mode Socket服务的数据访问模式。0 缓存模式；1 直吐模式；2 透传模式。
*
* 输出>>
* err 操作错误代码。0 表示没有错误；其余参考移远文档。
*
* activeID 19
**/
enum Result ec800m_open_socket_sync(uint8_t connectID, char * service_type, char * IP_address, uint16_t remote_port, uint8_t access_mode, uint16_t * err)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_open_socket(connectID, service_type, IP_address, remote_port, access_mode, err);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}



/** 
* 关闭socket服务
* 输入<<
* connectID Socket ID。范围1-11
*
* activeID 29
**/
enum Result ec800m_close_socket(uint8_t connectID)
{
	enum Result result = Result_None;
	int activeID = 29, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QICLOSE=%d\r\r\n", connectID); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
		result = 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;
}
/** 
* 关闭socket服务
* 输入<<
* connectID Socket ID。范围1-11
*
* activeID 29
**/
enum Result ec800m_close_socket_sync(uint8_t connectID)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_close_socket(connectID);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/** 
* 解释：控制是否回显AT+QISEND要发送的数据
* 为了便于处理返回，发送数据时需要关闭回显。
* 输入<<
* echo 是否回显AT+QISEND要发送的数据。0 不回显；1 回显。默认是回显
*
* activeID 45
**/
enum Result ec800m_set_qisde(uint8_t echo)
{
	enum Result result = Result_None;
	int activeID = 45, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QISDE=%d\r\r\n", echo); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
		result = 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;
}

/** 
* 解释：控制是否回显AT+QISEND要发送的数据
* 为了便于处理返回，发送数据时需要关闭回显。
* 输入<<
* echo 是否回显AT+QISEND要发送的数据。0 不回显；1 回显。默认是回显
*
* activeID 45
**/
enum Result ec800m_set_qisde_sync(uint8_t echo)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_set_qisde(echo);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}

/** 
* 发送数据
* 输入<<
* connectID Socket ID。范围1-11。
* send_length 发送长度。
* data 待发送的数据。
*
* activeID 49
**/

enum Result ec800m_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
{
	enum Result result = Result_None;
	int activeID = 49, time = 10000; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QISEND=%d,%d\r\r\n", connectID, data_length); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
		result = Result_Failed; 
	}
	else if(getTimerMs() > time) // 正在发送状态。判断超时
	{
		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
		result = overtime(); // 超时
	}
	else if(strstr((char * )AT_result(), "> ") != NULL) // 有响应
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
//		Log_Printf_Debug("coap:\r\n");
//		Log_SendHex(data, data_length);
//		Log_Printf_Debug("\r\n");
		// 发送数据
		send_data(data, data_length);
		// 清理一下AT返回结果缓存
		AT_Clear_Result();
	}
	else if(strstr((char * )AT_result(), "SEND OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		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(), "SEND FALL\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		result = failed(); // 失败
	}
	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;
}


/** 
* 发送数据
* 输入<<
* connectID Socket ID。范围1-11。
* send_length 发送长度。
* data 待发送的数据。
*
* activeID 49
**/
enum Result ec800m_send_sync(uint8_t connectID, uint8_t * data, uint16_t data_length)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_send(connectID, data, data_length);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}



/** 
* 接收数据
* 输入<<
* connectID Socket ID。范围0-11。
*
* 输出>>
* data 接收的数据。
* data_length 接收的数据长度。
*
**/
enum Result ec800m_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 > 11)
	{
		Log_Printf_Debug("recv params error!\r\n");
		return Result_Failed; 
	}
	char cmp[20];
	sprintf(cmp, "+QIURC: \"recv\",%d", connectID); // 拼接AT指令
	// 判断是否接收到
	if(strstr((char * )AT_result(), cmp) != NULL)
	{
		// 防止接收不完整
		uint32_t last_time = AT_wait_time();
		if(last_time > 10) // 过10ms之后再取数据，避免数据截断。
		{
			// 发送日志
			Log_Printf_Debug("AT返回: %d, time_diff: %d\r\n", AT_result_length(), last_time);
//			Log_SendArray_Debug(AT_result(), AT_result_length());
			
			char * saveptr = NULL;
			char * split = "\r\n";
			char * Line1 = strtok_r((char * )AT_result(), split, &saveptr);
			uint8_t Line1_Len = strlen(Line1);
			Log_Printf_Debug("Line1(%d): %s\r\n",Line1_Len ,Line1);
			
			// 分割Line1，获取报文长度
			char * saveptr_inner = NULL;
			char * split_inner = ",";
			strtok_r(Line1, split_inner, &saveptr_inner);
			strtok_r(NULL, split_inner, &saveptr_inner);
			* data_length = strtoul(strtok_r(NULL, split_inner, &saveptr_inner), NULL, 10);
			
			uint16_t line_length = Line1_Len + 4;
			// 内存拷贝
			memcpy(data, AT_result() + line_length, * data_length);
	
			// 成功
			result = Result_Success;
			// 清理一下AT返回结果缓存
			AT_Clear_Result();
		}
	}
	return result;
}




/** 
* 接收数据。带计时
* 输入<<
* connectID Socket ID。范围0-11。
*
* 输出>>
* data 接收的数据。
* data_length 接收的数据长度。
*
**/
enum Result ec800m_recv_with_time(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out)
{
	enum Result result = Result_None;
	int activeID = 59, time = time_out; // 活动ID, 超时时间
	// 校验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 = Result_Failed; 
	}
	else if(getTimerMs() > time) // 正在发送状态。判断超时
	{
		Log_Printf_Debug("等待时间超时\r\n"); // 打印日志
		result = overtime(); // 超时
	}
	else
	{
		// 接收数据
		result = ec800m.recv(connectID, data, data_length);
		if(result == Result_Success)
		{
			result = success(); // 成功
		}
	}
	return result;
}

/** 
* 接收数据。带计时
* 输入<<
* connectID Socket ID。范围0-11。
*
* 输出>>
* data 接收的数据。
* data_length 接收的数据长度。
*
**/
enum Result ec800m_recv_with_time_sync(uint8_t connectID, uint8_t * data, uint16_t * data_length, uint32_t time_out)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_recv_with_time(connectID, data, data_length, time_out);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/** 
* 解释：关闭模块
* 关闭模块，关闭后会自动重启。
* 输入<<
* n 模块关机方式。0 立即关机；1 正常关机。默认是1
*
* activeID 69
**/
enum Result ec800m_power_down(uint8_t n)
{
	enum Result result = Result_None;
	int activeID = 69, time = 3000; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QPOWD=%d\r\r\n", n); // 拼接AT指令
		result = send_at(AT_CMD, activeID);
	}
	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
	{
		Log_Printf_Debug("返回结果过期，请重置状态\r\n"); // 打印日志
		result = Result_Failed; 
	}
	else if(getTimerMs() > time) // 正在发送状态。判断超时
	{
		Log_Printf_Debug("AT指令返回超时\r\n"); // 打印日志
		result = overtime();
	}
	else if(strstr((char * )AT_result(), "POWERED DOWN\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		// 成功结果
		result = success();
	}
	return result;
}

/** 
* 解释：关闭模块。同步
* 关闭模块，关闭后会自动重启。
* 输入<<
* n 模块关机方式。0 立即关机；1 正常关机。默认是1
*
* activeID 69
**/
enum Result ec800m_power_down_sync(uint8_t n)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_power_down(n);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}


/** 
* 模块是否启动成功
* 输入<<
*
* 输出>>
*
**/
enum Result ec800m_ready(void)
{
	if(AT_Get_Status() != AT_Status_None)
	{
		return Result_None;
	}
	enum Result result = Result_None;
	// 判断是否接收到
	uint8_t  RDY[5]="RDY";
	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;
}

/** 
* 查询信号质量
* 输入<<
*
* 输出>>
* RSRP 
* RSRQ
* RSSI
* SINR
**/
enum Result ec800m_qeng_servingcell(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
{
	enum Result result = Result_None;
	int activeID = 71, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QENG=\"servingcell\"\r\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"); // 打印日志
		setStatus(Status_Overtime); // 超时
		result = Result_Failed; // 结果
	}
	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 拆解第二行
		char * saveptr_inner = NULL;
		char * split_inner = ": ,\"";
		strtok_r(Line2, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		strtok_r(NULL, split_inner, &saveptr_inner);
		* RSRP = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		* RSRQ = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		* RSSI = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		* SINR = atoi(strtok_r(NULL, split_inner, &saveptr_inner));
		// 打印
		Log_Printf_Debug("RSRP: %d, RSRQ: %d, RSSI: %d, SINR: %d\r\n", * RSRP, * RSRQ, * RSSI, * SINR);
		
		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 ec800m_qeng_servingcell_sync(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_qeng_servingcell(RSRP, RSRQ, RSSI, SINR);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}

/** 
* 查询ICCID
* 输入<<
*
* 输出>>
* iccid SIM卡卡号
**/
enum Result ec800m_query_qccid(char * iccid)
{
	enum Result result = Result_None;
	int activeID = 75, time = 500; // 活动ID, 超时时间
	// 校验ID
	if(!verifyActiveID(activeID)){ return Result_Failed; }
	// 判断状态
	if(getStatus() == Status_None) // 空闲状态
	{
		sprintf(AT_CMD, "AT+QCCID\r\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"); // 打印日志
		setStatus(Status_Overtime); // 超时
		result = Result_Failed; // 结果
	}
	else if(strstr((char * )AT_result(), "OK\r\n") != NULL) // 查询是否返回
	{
		// 发送日志
		Log_Printf_Debug("AT返回: %d\r\n", AT_result_length());
		Log_SendArray_Debug(AT_result(), AT_result_length());
		
		// 处理返回结果
		char * saveptr = NULL;
		char * split = "\r\n";
		// 第一行
		strtok_r((char * )AT_result(), split, &saveptr);
		// 第二行
		char * Line2 = strtok_r(NULL, split, &saveptr);
		// 拆解第二行
		char * saveptr_inner = NULL;
		char * split_inner = ": ,\"";
		
		strtok_r(Line2, split_inner, &saveptr_inner);
		// 字符串拷贝
		strcpy(iccid, strtok_r(NULL, split_inner, &saveptr_inner));
		
		// 打印
		Log_Printf_Debug("ICCID: %s\r\n", iccid);
		
		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 ec800m_query_qccid_sync(char * iccid)
{
	enum Result result = Result_None;
	while(1)
	{
		result = ec800m_query_qccid(iccid);
		if(result != Result_None)
		{
			// 重置
			ec800m.reset();
			break;
		}
	}
	return result;
}

#endif