/*************************** (C) COPYRIGHT 2017 CXHY ****************************
 * 文件名  ：gsm_gprs.c
 * 描  述  ：gsm_gprs驱动代码     
 * 版  本  ：V1.0
 * 作  者  ：XuZhongPing
 * 日  期  ：2017/06/12 
*********************************************************************************/
#include "gsm_gprs.h"
#include "gsm_uart.h"		
#include "gsm_uart_conf.h"
#include "delay.h"	
#include "led.h"   	  	 	 	 	  
#include "string.h" 
#include "stdio.h"
#include "stdlib.h"   

#include "timer.h"
#include "data_typedef.h"	
#include "message.h"
#include "tcp_protocol.h"
#include "at_proc.h"


#define RCC_PeriphClock 	RCC_APB2Periph_GPIOB
#define GSM_POW_KEY_Port 	GPIOB
#define GSM_POW_KEY_Pin 	GPIO_Pin_12

uint8_t GSM_isPowerON = 0x00;									//GSM模块是否处于开机标志
uint8_t ConnectionStatus = OFFLINE;						//连接状态（当有数据包发送成功后置位为在线状态）

static uint8_t GSM_GPRS_Status = 0x00;				//GSM_GPRS的工作状态
static uint8_t GSM_GPRS_initStatus = 0x00;		//GSM模块加载时的工状态
static uint8_t TCP_createStatus = 0x00;				//GSM模块建立TCP链接时的工作状态
static uint8_t GSM_GPRS_workingState = 0x00;	//GSM模块TCP客户端的数据收发处理工作状态
static uint8_t errorStatus = 0x00;						//GSM模块异常错误处理状态
static uint8_t errorProcessCount = 0;					//错误处理次数
static uint8_t sendFailureCount = 0;					//发送失败计数
static uint8_t connectionFailureCount = 0;		//连接失败计数


/*
***********************************************************************
*	函 数 名: GSM_GPRS_Init
*	功能说明: GSM_GPRS模块初始化
*	形    参: 无
*	返 回 值: 无
***********************************************************************
*/
void GSM_GPRS_Init(void)
{
	GPIO_InitTypeDef  GPIO_InitStructure;
 	
 	RCC_APB2PeriphClockCmd(RCC_PeriphClock, ENABLE);	 			//使能PB端口时钟
	
	//GSM开关机控制引脚初始化配置
 	GPIO_InitStructure.GPIO_Pin = GSM_POW_KEY_Pin;	 				//开机键端口配置
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 		//推挽输出
 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;				
 	GPIO_Init(GSM_POW_KEY_Port, &GPIO_InitStructure);				
	GPIO_ResetBits(GSM_POW_KEY_Port, GSM_POW_KEY_Pin);			//默认输出低，相当于开机键处于没有按下状态
	
	GSM_GPRS_Uart_Init();
	gsm_msg.Running = 0;
}

/*
***********************************************************************
*	函 数 名: GSM_StatusReset
*	功能说明: GSM各工作状态复位
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void GSM_StatusReset(void)
{
	GSM_GPRS_Status = 0x00;							//GSM模块的运行时的状态复位
	GSM_GPRS_initStatus = 0x00;					//GSM模块加载时的状态复位
	TCP_createStatus = 0x00;						//GSM模块创建TCP客户端链接时的状态复位
	GSM_GPRS_workingState = 0x00;				//GSM模块TCP客户端的数据收发处理工作状态复位
	errorStatus = 0x00;									//GSM模块异常处理时的状态复位
}
   
/*
***********************************************************************
*	函 数 名: GSM_PowerON
*	功能说明: GSM模块开机
*	形    参: 无
*	返 回 值: 开机完成输出1；正在开机输出0
***********************************************************************
*/
uint8_t GSM_PowerON(void)
{
	uint8_t returnData = 0;
	static timer pullDown_Time;
	static timer pullUp_Time;
	static uint8_t timer_ok = 0;
	
	static uint8_t powerOnStatus = 0x00;
	
	if(timer_ok == 0)
	{
		timer_ok = 1;
		timer_set(&pullDown_Time, CLOCK_SECOND*2);  		//创建1个定时器，用于计算下拉为低电平时间
		timer_set(&pullUp_Time, CLOCK_SECOND*5);  			//创建1个定时器，用于计算上拉为高电平时间
	}
	switch(powerOnStatus)
	{
		case 0x00:			//最初进入状态
			printf("\r\nGSM模块正在开机\r\n");	
			GPIO_SetBits(GSM_POW_KEY_Port, GSM_POW_KEY_Pin);		//GSM模块的power_key引脚拉低		
			powerOnStatus = 0x01;
			timer_restart(&pullDown_Time);							//从当前时间重新开启定时器 
			break;
		case 0x01:			//大约等待2S钟的时间，power_key按键按下2S后松开启动模块		
			if(timer_expired(&pullDown_Time))
			{
				GPIO_ResetBits(GSM_POW_KEY_Port, GSM_POW_KEY_Pin);				//GSM模块的power_key引脚拉高
				powerOnStatus = 0x02;
				timer_restart(&pullUp_Time);							//从当前时间重新开启定时器
				break;
			}		
			break;
		case 0x02:
			if(timer_expired(&pullUp_Time))
			{
				powerOnStatus = 0x00;
				returnData = 1;
			}
			break;
		default:break;
	}
	return returnData;
}

/*
***********************************************************************
*	函 数 名: GSM_PowerOFF
*	功能说明: GSM模块关机
*	形    参: 无
*	返 回 值: 无
***********************************************************************
*/
// uint8_t GSM_PowerOFF(void)
// {
// 	uint8_t returnData = 0;
// 	static timer pullDown_Time;
// 	static timer pullUp_Time;
// 	static timer responseTimeout;
// 	static uint8_t timer_ok = 0;
// 	
// 	static uint8_t powerOffStatus = 0x00;
// 	
// 	if(timer_ok == 0)
// 	{
// 		timer_ok = 1;
// 		timer_set(&pullDown_Time, CLOCK_SECOND*2);  		//创建1个定时器，用于计算下拉为低电平时间
// 		timer_set(&pullUp_Time, CLOCK_SECOND*2);  			//创建1个定时器，用于计算上拉为高电平时间
// 		timer_set(&responseTimeout, CLOCK_SECOND*2);
// 	}
// 	switch(powerOffStatus)
// 	{
// 		case 0x00:
// 			printf("\r\nGSM模块正在关机\r\n");
// 			GPIO_SetBits(GSM_POW_KEY_Port, GSM_POW_KEY_Pin);							//GSM模块的power_key引脚拉低				
// 			powerOffStatus = 0x01;
// 			timer_restart(&pullDown_Time);								//从当前时间重新开启定时器 
// 			break;
// 			
// 		case 0x01:
// 			if(timer_expired(&pullDown_Time))
// 			{
// 				GPIO_ResetBits(GSM_POW_KEY_Port, GSM_POW_KEY_Pin);					//GSM模块的power_key引脚拉高
// 				powerOffStatus = 0x02;
// 				timer_restart(&pullUp_Time);
// 			}
// 			break;
// 		case 0x02:
// 			if(timer_expired(&pullUp_Time))
// 			{
// 				GSM_SendCmd("AT", 0, 0);
// 				powerOffStatus = 0x03;
// 				timer_restart(&responseTimeout);							//从当前时间重新开启定时器 
// 			}
// 			break;
// 			
// 		case 0x03:			//等待模块应答“OK”		
// 			if(timer_expired(&responseTimeout))						//超时还未接收到应答
// 			{
// 				printf("\r\n模块已关机！！！\r\n");
// 				powerOffStatus = 0x00;	
// 				GSM_StatusReset();													//复位各种工作状态
// 				returnData = 1;
// 				break;
// 			}else{
// 				if(GSM_CheckCmd("OK"))
// 				{
// 					printf("\r\n模块还在运行\r\n");
// 					powerOffStatus = 0x00;
// 					break;
// 				}
// 				if(GSM_CheckCmd("AT"))
// 				{
// 					printf("\r\n模块还在运行\r\n");
// 					powerOffStatus = 0x00;
// 					break;
// 				}
// 			}
// 			break;
// 	}
// 	return returnData;
// }

/*
***********************************************************************
*	函 数 名: GSM_SignalCheck
*	功能说明: 查询信号质量
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void GSM_SignalCheck(void)
{
	uint8_t cnt = 0;
	GSM_SendAtCmd("AT+CSQ", AT_CMD_CSQ_NO);
	while((at_cmd_table[AT_CMD_CSQ_NO-1].result != AT_CMD_SUCCESS) && (cnt < 10))
	{
		delay_ms(1);
		cnt++;
	}
	
	if(at_cmd_table[AT_CMD_CSQ_NO-1].result == AT_CMD_SUCCESS)
	{
		if(signal > 0)
		{
			printf("\r\nGSM信号强度 = %d\r\n", signal);
			if(signal < 5)
			{
				printf("\r\nGSM信号弱，请检查天线连接是否正常\r\n");
			}
		}else{
			printf("\r\n无GSM信号！！！\r\n");
		}
	}
}

/*
***********************************************************************
*	函 数 名: GSM_GetHardInfo
*	功能说明: 取得GSM模块的硬件信息（IMEI）
*	形    参: msg：保存GSM模块信息结构体
*	返 回 值: 无
***********************************************************************
*/
void GSM_GetHardInfo(_gsm_msg *msg)
{
// 	uint8_t *p;
// 	
// 	printf("\r\n获取IMEI号\r\n");
// 	if(GSM_SendCmd("AT+CGSN", "OK", 200) == 0)						//查询产品序列号
// 	{ 
// 		p = (uint8_t*)strstr((const char*)(GPRS_RX_BUF+2),"\r\n");	//查找回车
// 		p[0] = 0;//加入结束符 
// 		sprintf(msg->IMEI, "%s", GPRS_RX_BUF+2);
// 		IMEI_TO_HEX(msg->IMEI);																	//将字符串的IMEI号转换成HEX格式为后面传输
// // 		printf("\r\nIMEI:%s\r\n", msg->IMEI);
// 	}
}

/*
***********************************************************************
*	函 数 名: GSM_Check
*	功能说明: GSM模块检查
*	形    参：无
*	返 回 值: 正常返回1，不正常返回0
***********************************************************************
*/
// uint8_t GSM_Check(void)
// {
// 	if(GSM_SendCmd("AT", "OK", 500))
// 	{
// 		return 0;	
// 	}else{
// 		return 1;
// 	}
// }

/*
***********************************************************************
*	函 数 名: GPRS_OnlineCheck
*	功能说明: GPRS与后台连接在线与否检查（发送心跳包来检测）
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
static void GPRS_OnlineCheck(void)
{
	sendMsg.msgType = 1001;														//心跳
	MessageSend(MSG_FIFO_PROTOCOL, sendMsg);
}

/*
***********************************************************************
*	函 数 名: GSM_GPRS_Reset
*	功能说明: GSM模块各种工作状态复位，重启
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
static void GSM_GPRS_Reset(void)
{
	GSM_GPRS_Status = 0x00;								//转到初始状态重启模块
	GSM_GPRS_initStatus = 0x00;
	TCP_createStatus = 0x00;
	GSM_GPRS_workingState = 0x00;
	errorStatus = 0x00;
	
	sendFailureCount = 0;	
	errorProcessCount = 0;
	connectionFailureCount = 0;
	
	ConnectionStatus = OFFLINE;
	signal = 0;
}

/*
***********************************************************************
*	函 数 名: GSM_GPRS_Loading
*	功能说明: GSM_GPRS模块加载（开机、查询模块的网络状态）
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void GSM_GPRS_Loading(void)
{
// 	static uint8_t GSM_GPRS_initStatus = 0;
	static uint8_t waitTimeOutCount = 0;
	
	static timer responseTimeout;
	static timer queryTime;
	static uint8_t timer_ok = 0;
	
	if(timer_ok == 0)
	{
		timer_ok = 1;
		timer_set(&responseTimeout, 3);  						//创建1个定时器，用于发送AT命令后等待应答的时间
		timer_set(&queryTime, CLOCK_SECOND*2);  		//创建1个定时器，用于查询网络注册情况
	}
	
	switch(GSM_GPRS_initStatus)
	{
		case 0x00:			//最初进入状态
			if(GSM_PowerON())
			{
				GSM_GPRS_initStatus = 0x01;
			}
			break;
			
		case 0x01:			//检测模块是否正常启动
			printf("\r\n检测模块\r\n");
			GSM_SendAtCmd("AT", AT_CMD_AT_NO);
			GSM_GPRS_initStatus = 0x02;
			timer_restart(&responseTimeout);							//从当前时间重新开启定时器 
			break;
			
		case 0x02:			//等待模块应答“OK”		
			if(at_cmd_table[AT_CMD_AT_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n模块正常\r\n");
				GSM_GPRS_initStatus = 0x03;									//接收到应答，跳转到0x
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n超时未见模块应答\r\n");
				GSM_GPRS_initStatus = 0x00;		
				break;
			}
			break;
			
		case 0x03:			//设置不回显
			printf("\r\n设置不回显\r\n");
			GSM_SendAtCmd("ATE0", AT_CMD_ATE0_NO);				//不回显							
			GSM_GPRS_initStatus = 0x04;
			timer_restart(&responseTimeout);
			break;
			
		case 0x04:			//等待AT指令应答
			if(at_cmd_table[AT_CMD_ATE0_NO-1].result == AT_CMD_SUCCESS)
			{
				GSM_GPRS_initStatus = 0x05;								//接收到应答，跳转到0x
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n设置不回显失败\r\n");
				GSM_GPRS_initStatus = 0x00;		
				break;
			}
			break;
			
		case 0x05:			//获取硬件信息
			GSM_SendAtCmd("AT+CGSN", AT_CMD_CGSN_NO);
			GSM_GPRS_initStatus = 0x06;
			timer_restart(&responseTimeout);
			break;
			
		case 0x06:			//等待AT指令应答			
			if(at_cmd_table[AT_CMD_CGSN_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\nIMEI = %s\r\n", gsm_msg.IMEI);
				waitTimeOutCount = 0;
				GSM_GPRS_initStatus = 0x07;
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n获取硬件信息超时\r\n");
				GSM_GPRS_initStatus = 0x00;		
				break;
			}
			break;
			
		case 0x07:			//查询SIM卡状态
			if(waitTimeOutCount > 3)											//超时还未查询到网络注册状态
			{
				waitTimeOutCount = 0;
				GSM_GPRS_initStatus = 0x00;									//返回到初始状态
				printf("\r\n查询SIM卡状态超时或SIM卡无效！！！\r\n");
				break;
			}
			GSM_SendAtCmd("AT+CPIN?", AT_CMD_CPIN_NO);
			GSM_GPRS_initStatus = 0x08;
			timer_restart(&queryTime);
			break;	
			
		case 0x08:			//等待AT指令应答
			if(at_cmd_table[AT_CMD_CPIN_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\nSIM卡已经就绪\r\n");
				printf("\r\n查询信号强度\r\n");
				waitTimeOutCount = 0;	
				GSM_GPRS_initStatus = 0x09;
				break;
			}
			
			if(timer_expired(&queryTime))						//超时还未接收到应答
			{
				GSM_GPRS_initStatus = 0x07;	
				waitTimeOutCount++;										//等待超时计数+1
				break;
			}
			break;
			
		case 0x09:		//查询网络信号强度
			if(waitTimeOutCount > 10)											//超时还未查询到网络注册状态
			{
				waitTimeOutCount = 0;
				GSM_GPRS_initStatus = 0x00;									//返回到初始状态
				printf("\r\n查询不到网络信号！！！\r\n");
				break;
			}
			GSM_SendAtCmd("AT+CSQ", AT_CMD_CSQ_NO);
			GSM_GPRS_initStatus = 0x10;
			timer_restart(&queryTime);							//从当前时间重新开启定时器
			break;
			
		case 0x10:		//等待网络信号应答正常
			if(at_cmd_table[AT_CMD_CSQ_NO-1].result == AT_CMD_SUCCESS)
			{
				if(signal > 0)
				{
					printf("\r\n信号强度正常 = %d\r\n", signal);
					printf("\r\n查询网络注册状态\r\n");
					waitTimeOutCount = 0;											//等待超时计数归零
					GSM_GPRS_initStatus = 0x11;
					break;
				}
			}
			
			if(timer_expired(&queryTime))						//超时还未接收到应答
			{
				GSM_GPRS_initStatus = 0x09;	
				waitTimeOutCount++;										//等待超时计数+1
				break;
			}
			break;
			
		case 0x11:			//查询网络注册状态
			if(waitTimeOutCount > 10)											//超时还未查询到网络注册状态
			{
				waitTimeOutCount = 0;
				GSM_GPRS_initStatus = 0x00;									//返回到初始状态
				printf("\r\n等待超时，尚未注册网络！！！\r\n");
				break;
			}
			GSM_SendAtCmd("AT+CREG?", AT_CMD_CREG_NO);
			GSM_GPRS_initStatus = 0x12;
			timer_restart(&queryTime);							//从当前时间重新开启定时器
			break;
			
		case 0x12:			//等待网络注册成功			
			if(at_cmd_table[AT_CMD_CREG_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n已经注册网络\r\n");
				printf("\r\n查询是否附着GPRS业务？\r\n");
				waitTimeOutCount = 0;											//等待超时计数归零
				GSM_GPRS_initStatus = 0x13;
				break;
			}
			
			if(timer_expired(&queryTime))						//超时还未接收到应答
			{
				GSM_GPRS_initStatus = 0x11;	
				waitTimeOutCount++;										//等待超时计数+1
				break;
			}
			break;
			
		case 0x13:			//检查GPRS附着状态
			if(waitTimeOutCount > 10)											//超时还未查询到GPRS附着状态
			{
				waitTimeOutCount = 0;
				GSM_GPRS_initStatus = 0x00;									//返回到初始状态
				printf("\r\n等待超时，尚未附着GPRS\r\n");
				break;
			}
			GSM_SendAtCmd("AT+CGATT?", AT_CMD_CGATT_NO);	//检查GPRS附着状态						
			GSM_GPRS_initStatus = 0x14;
			timer_restart(&queryTime);										//从当前时间重新开启定时器
			break;
			
		case 0x14:		//等待附着GPRS业务		
			if(at_cmd_table[AT_CMD_CGATT_NO-1].result == AT_CMD_SUCCESS)
			{
				waitTimeOutCount = 0;											//等待超时计数归零
				GSM_GPRS_initStatus = 0x00;	
				printf("\r\n已经附着GPRS业务\r\n");
				GSM_GPRS_Status = 0x01;	
				break;
			}
			
			if(timer_expired(&queryTime))									//超时还未接收到应答
			{
				GSM_GPRS_initStatus = 0x13;	
				waitTimeOutCount++;													//等待超时计数+1
				break;
			}
			break;
			
		default: 
			GSM_GPRS_initStatus = 0x00;
			break;
	}
}

/*
***********************************************************************
*	函 数 名: TCP_ClientCreate
*	功能说明: 建立TCP客户端
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void TCP_ClientCreate(void)
{
// 	static uint8_t createStatus = 0x00;
	
	static timer responseTimeout;
	static timer responseTimeout_3s;
	static timer registrationTime;
	static timer connectionWaitTime;
	static timer waitingTime_2s;
	static timer reconnectTimeout;
	static uint8_t timer_ok = 0;
	
	if(timer_ok == 0)
	{
		timer_ok = 1;
		timer_set(&responseTimeout, 3);  									//创建1个定时器，用于发送AT命令后等待应答的时间
		timer_set(&responseTimeout_3s, CLOCK_SECOND*3);  	//创建1个定时器，用于发送AT命令后等待应答的时间
		timer_set(&connectionWaitTime, CLOCK_SECOND*10);  //创建1个定时器，用于建立连接等待的超时时间
		timer_set(&registrationTime, CLOCK_SECOND*10);  	//创建1个定时器，用于检查网络注册情况的等待超时时间
		timer_set(&waitingTime_2s, CLOCK_SECOND*2);
		timer_set(&reconnectTimeout, CLOCK_SECOND*20);
	}
	
	switch(TCP_createStatus)
	{	
		case 0x00:			//开始建立TCP连接
			printf("\r\n开始任务，设置APN\r\n");
			GSM_SendAtCmd("AT+CSTT=\"CMNET\"", AT_CMD_CSTT_NO);			//设置GPRS移动台类别为B,支持包交换和数据交换 			
			TCP_createStatus = 0x01;
			timer_restart(&responseTimeout);							//从当前时间重新开启2秒定时器
			timer_restart(&reconnectTimeout);							//开始建立链接先初始化定时器，如果超时了，则需要重新开机
			break;
			
		case 0x01:			//等待应答		
			if(at_cmd_table[AT_CMD_CSTT_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n设置APN OK\r\n");
				TCP_createStatus = 0x02;									//接收到应答，跳转到0x02
				break;
			}
			if(at_cmd_table[AT_CMD_CSTT_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n设置APN ERROR\r\n");
				TCP_createStatus = 0x20;									//应答错误，跳转到0x
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n等待应答超时，设置APN错误\r\n");
				TCP_createStatus = 0x20;	
				break;
			}
			break;

		case 0x02:			//建立无线链路
			printf("\r\n建立无线链路\r\n");
			GSM_SendAtCmd("AT+CIICR", AT_CMD_CIICR_NO);		//设置PDP上下文,互联网接协议,接入点等信息
			TCP_createStatus = 0x03;
			timer_restart(&responseTimeout_3s);							//从当前时间重新开启2秒定时器
			break;
			
		case 0x03:			//等待应答				
			if(at_cmd_table[AT_CMD_CIICR_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n建立无线链路OK\r\n");
				TCP_createStatus = 0x04;									//接收到应答，跳转到0x
				break;
			}
			if(at_cmd_table[AT_CMD_CIICR_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n建立无线链路 ERROR\r\n");
				TCP_createStatus = 0x20;									//应答错误，跳转到0x00
				break;
			}
			
			if(timer_expired(&responseTimeout_3s))						//超时还未接收到应答
			{
				printf("\r\n应答OK超时，建立无线链路失败\r\n");
				TCP_createStatus = 0x20;	
				break;
			}
			break;
		
		case 0x04:			//设置接收数据显示IP头
			printf("\r\n设置接收数据显示IP头\r\n");
			GSM_SendAtCmd("AT+CIPHEAD=1", AT_CMD_CIPHEAD_NO);	 	//设置接收数据显示IP头(方便判断数据来源)
			TCP_createStatus = 0x05;
			timer_restart(&responseTimeout);							//从当前时间重新开启2秒定时器
			break;
			
		case 0x05:			
			if(at_cmd_table[AT_CMD_CIPHEAD_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n设置接收数据显示IP头OK\r\n");
				TCP_createStatus = 0x06;									//接收到应答，跳转到0x
				break;
			}
			if(at_cmd_table[AT_CMD_CIPHEAD_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n设置接收数据显示IP头失败\r\n");
				TCP_createStatus = 0x20;									//应答错误，跳转到0x
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n应答OK超时，设置接收数据显示IP头失败\r\n");
				TCP_createStatus = 0x20;	
				break;
			}
			break;
	
		case 0x06:			//获得本地IP
			printf("\r\n获得本地IP\r\n");
			GSM_SendAtCmd("AT+CIFSR", AT_CMD_CIFSR_NO);
			TCP_createStatus = 0x07;
			timer_restart(&responseTimeout);							//从当前时间重新开启n秒定时器
			break;
			
		case 0x07:
			if(at_cmd_table[AT_CMD_CIFSR_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n已获得IP地址\r\n");
				TCP_createStatus = 0x08;									//接收到应答，跳转到0x
				break;
			}
			if(at_cmd_table[AT_CMD_CIFSR_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n获得本地IP失败 ERROR\r\n");
				TCP_createStatus = 0x20;									//应答错误，跳转到0x00
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n应答OK超时，获得本地IP失败\r\n");
				TCP_createStatus = 0x20;	
				break;
			}
			break;
			
		case 0x08:			//开始链接远端服务器
			printf("\r\n开始链接远端服务器\r\n");
			GSM_SendAtCmd(TCP_IP_COM, AT_CMD_CIPSTART_NO);		//开始链接远端服务器
			TCP_createStatus = 0x09;
			timer_restart(&connectionWaitTime);						//从当前时间重新开启定时器
			break;	
			
		case 0x09:			//等待应答“CONNECT OK”								
			if(at_cmd_table[AT_CMD_CIPSTART_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n连接成功\r\n");
				
				//清除发送失败计数和重连接错误计数（为了防止在程序运行过程中出现错误处理而重新启动模块复位变量）
				sendFailureCount = 0;
				errorProcessCount = 0;
				connectionFailureCount = 0;
				
				TCP_createStatus = 0x00;											
				gsm_msg.Running = 1;											//标志模块已经连接上GPRS
				
				//连接成功发送心跳
				sendMsg.msgType = 1001;														//心跳
				MessageSend(MSG_FIFO_PROTOCOL, sendMsg);
				
				sendMsg.msgType = 6004;														//上传设备运行状态信息（温度、信号、测距）
				MessageSend(MSG_FIFO_PROTOCOL, sendMsg);
				
// 					GSM_SendCmd("AT+CSCLK=2", "OK", 200);			//休眠模式设置
// 					GSM_SendCmd("AT+CFUN=1", "OK", 200);		
				
				GSM_GPRS_Status = 0x02;										//建立TCP连接成功后，转到数据收发的处理状态
				break;
			}
			
			if(at_cmd_table[AT_CMD_CIPSTART_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n连接失败\r\n");
				TCP_createStatus = 0x20;
				break;
			}
			
			if(timer_expired(&connectionWaitTime))				//超时还未接收到应答
			{
				printf("\r\n连接超时!!!\r\n");		
				TCP_createStatus = 0x20;
				break;
			}
			
			break;
			
		case 0x10:		//查询GPRS状态间隔时间
			timer_restart(&waitingTime_2s);
			TCP_createStatus = 0x11;
			break;
			
		case 0x11:		
			if(timer_expired(&waitingTime_2s))
			{
				TCP_createStatus = 0x20;
			}
			break;
			
		case 0x20:			//查询GPRS状态
			if(timer_expired(&reconnectTimeout))
			{
				printf("\r\n建立TCP连接超时，重启模块！！！\r\n");
				
				GSM_GPRS_Reset();							//GSM模块复位，重启
				break;
			}
			
			connectionFailureCount++;				//连接失败计数
			printf("\r\n连接异常处理 %d 次\r\n", connectionFailureCount);
			if(connectionFailureCount >= 10)		//错误处理5次还不恢复正常，则重启模块
			{
				//执行到这一步则转到模块复位重启
				GSM_GPRS_Reset();							//GSM模块复位，重启	
				printf("\r\n连接异常超出异常处理次数，重启模块！！！\r\n");
				break;
			}
			
			printf("\r\n查询GPRS状态\r\n");
			GSM_SendAtCmd("AT+CIPSTATUS", AT_CMD_CIPSTATUS_NO);			//查询连接状态				
			TCP_createStatus = 0x21;	
			timer_restart(&responseTimeout_3s);				//从当前时间重新开启定时器
			break;
			
		case 0x21:		//处理GPRS的各种连接状态
			switch(at_cmd_table[AT_CMD_CIPSTATUS_NO-1].result)
			{
				case GPRS_STATUS_IP_INITIAL:		//GPRS初始化					
					printf("\r\nGPRS初始化\r\n");
					TCP_createStatus = 0x00;							
					break;
				
				case GPRS_STATUS_IP_START:		//开始TCP/UDP会话					
					printf("\r\n开始TCP/UDP会话\r\n");
					TCP_createStatus = 0x02;							
					break;
					
				case GPRS_STATUS_IP_CONFIG:		//配置PDP上下文					
					printf("\r\n配置PDP上下文\r\n");
					TCP_createStatus = 0x10;			//继续查询GPRS的状态						
					break;
					
				case GPRS_STATUS_IP_GPRSACT:	
					TCP_createStatus = 0x04;							
					printf("\r\n上下文已经激活\r\n");
					break;
					
				case GPRS_STATUS_IP_STATUS:		//得到本地IP地址
					printf("\r\n得到本地IP地址\r\n");
					TCP_createStatus = 0x08;							
					break;
					
				case GPRS_STATUS_TCP_CONNECTING:		//正在连接
					printf("\r\n正在连接服务器\r\n");
					TCP_createStatus = 0x10;							
					break;
					
				case GPRS_STATUS_CONNECT_OK:		//连接正常
					printf("\r\n连接正常\r\n");
					//清除发送失败计数和重连接错误计数（为了防止在程序运行过程中出现错误处理而重新启动模块复位变量）
					sendFailureCount = 0;
					errorProcessCount = 0;
					
					TCP_createStatus = 0x00;											
					gsm_msg.Running = 1;											//标志模块已经连接上GPRS
					
					GSM_GPRS_Status = 0x02;										//建立TCP连接成功后，转到数据收发的处理状态
					
					break;
					
				case GPRS_STATUS_TCP_CLOSING:
					printf("\r\n正在关闭链接\r\n");
					TCP_createStatus = 0x10;				//继续查询GPRS状态				
					break;
					
				case GPRS_STATUS_TCP_CLOSED:
					printf("\r\n链接已经关闭了\r\n");
					TCP_createStatus = 0x30;							
					break;
					
				case GPRS_STATUS_PDP_DEACT:		//上下文已经关闭
					printf("\r\nPDP上下文去激活\r\n");
					TCP_createStatus = 0x30;								
					break;
						
				default:
					break;
			}
			
			if(timer_expired(&responseTimeout_3s))			//超时还未接收到应答
			{
				printf("\r\nGPRS状态查询超时没有应答\r\n");
				TCP_createStatus = 0x20;
				break;
			}
			
			break;
		
		case 0x30:		//关闭移动场景
			printf("\r\n关闭移动场景\r\n");
			GSM_SendAtCmd("AT+CIPSHUT", AT_CMD_CIPSHUT_NO);				//关闭移动场景
			TCP_createStatus = 0x31;
			timer_restart(&responseTimeout_3s);						//从当前时间重新开启定时器
			break;
			
		case 0x31:		//等待关闭移动场景应答
			if(at_cmd_table[AT_CMD_CIPSHUT_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\n关闭移动场景成功\r\n");
				TCP_createStatus = 0x00;									//接收到应答，跳转到0x
				break;
			}
			if(at_cmd_table[AT_CMD_CIPSHUT_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\n关闭移动场景失败\r\n");
				TCP_createStatus = 0x20;
				break;
			}
			
			if(timer_expired(&responseTimeout_3s))						//超时还未接收到应答
			{
				printf("\r\n关闭移动场景超时未应答\r\n");
				TCP_createStatus = 0x20;	
				break;
			}
			break;

		default: 		//基它状态
			printf("\r\n未知状态，重启模块！！！\r\n");
			GSM_GPRS_Reset();							//GSM模块复位，重启
			break;	
	}
}

/*
***********************************************************************
*	函 数 名: TCP_ClientHandler
*	功能说明: TCP客户端的数据收发处理
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void TCP_ClientHandler(void)
{
	static Com_ProtocolMessage *pMsg;
// 	static uint8_t GSM_GPRS_workingState = 0x00;
	static uint16_t sendDataSize = 0;
// 	static uint8_t sendFailureCount = 0;								//发送失败计数
	
	static timer uploadIntervalTime;											//心跳上传时间间隔限制（限制同一时间内重复上传心跳包）
	static timer responseTimeout;													//应答超时时间间隔
	static timer sendTimeout;															//发送超时时间间隔
	
	static uint8_t timer_ok = 0;
	if(timer_ok == 0)
	{
		timer_ok = 1;
		timer_set(&uploadIntervalTime, CLOCK_SECOND*3);  			
		timer_set(&responseTimeout, CLOCK_SECOND*3);
		timer_set(&sendTimeout, CLOCK_SECOND*10);
	}
	
	switch(GSM_GPRS_workingState)
	{			
		case 0x00:				//当前处于连接正常，检查是否有数据要发送，有就对数据进行发送
			pMsg = MessageGet(MSG_FIFO_PROTOCOL);					//读取消息对列
			if(pMsg){		//如果消息对列中有消息则进行数据发送
// 				printf("\r\n有数据要发送，正在加载......\r\n");
				GSM_GPRS_workingState = 0x01;								//跳转到发送数据
// 				printf("\r\npThis->msgType = %x\r\n", pThis->msgType);
// 				printf("\r\npThis->msgData = %x\r\n", pThis->msgData);
			}else{
				GSM_GPRS_workingState = 0x00;								
			}
			break;
			
		case 0x01:				//发送AT+CIPSEND命令
			sendOrderCode = pMsg->msgType;										//取得发送的协议码
			
			//限制因长时间断开连接积压的未发送心跳包在同一时间段内重复发送
			if(sendOrderCode == 1001)
			{
				if(ConnectionStatus == ONLINE)									//当前处于在线状态				
				{
					if(timer_expired(&uploadIntervalTime))				//离上一次发送心跳的时间超过设定值（可以正常发送）
					{
						timer_restart(&uploadIntervalTime);					
					}else{																				//离上一次发送心跳的时间过短（丢弃本次心跳包上传）					
						GSM_GPRS_workingState = 0x00;		
						printf("\r\n连续的心跳包，取消发送\r\n");
						timer_restart(&uploadIntervalTime);					//重新开启定时，为一下次判断做准备
						break;		//返回
					}
				}else{																					//当前处于离线状态（有发送失败就置连接状态为离线状态）
					timer_restart(&uploadIntervalTime);						//重新开启定时，为一下次判断做准备
				}
			}			
			
			sendDataSize = ProtocolPackaging(sendOrderCode);	//通过消息的类型进行相应协议打包
			getCommand_CIPSEND(sendDataSize);									//取得发送指定长度数据AT指令
			
			//停止向后台发送数据调试用
// 			GSM_GPRS_workingState = 0x00;
			
// 			printf("\r\n发送命令 %s\r\n", command_CIPSEND);
			GSM_SendAtCmd(command_CIPSEND, AT_CMD_CIPSEND_NO);								//发送数据命令"AT+CIPSEND=<len>"
			GSM_GPRS_workingState = 0x02;
			timer_restart(&responseTimeout);									//从当前时间重新开启定时器
			break;
			
		case 0x02:				//等待返回应答“>”	
			if(at_cmd_table[AT_CMD_CIPSEND_NO-1].result == AT_CMD_CIPSEND_READY)
			{
				printf("\r\n应答 > OK\r\n");
				GSM_GPRS_workingState = 0x03;							//接收到应答					
				break;
			}
			
			if(at_cmd_table[AT_CMD_CIPSEND_NO-1].result == AT_CMD_SEND_FAIL)
			{
				printf("\r\n应答> ERROR\r\n");
				sendFailureCount ++;											//发送失败+1
				printf("\r\n发送失败次数 = %d\r\n", sendFailureCount);
				
				//当收到ERROR应答时直接转到错误处理
				GSM_GPRS_Status = 0x03;										//跳转到错误处理任务
				GSM_GPRS_workingState = 0x00;							//回到初始状态，待错误处理完成后从初始起点继续进行
				break;
			}
			
			if(at_cmd_table[AT_CMD_CIPSEND_NO-1].result == TCP_STATUS_CLOSED)
			{
				printf("\r\n连接已经关闭，发送失败\r\n");
				sendFailureCount ++;											//发送失败+1
				printf("\r\n发送失败次数 = %d\r\n", sendFailureCount);
				
				//当收到CLOSED应答时直接转到错误处理
				GSM_GPRS_Status = 0x03;										//跳转到错误处理任务
				GSM_GPRS_workingState = 0x00;							//回到初始状态，待错误处理完成后从初始起点继续进行						
				break;
			}
			
			if(timer_expired(&responseTimeout))						//超时还未接收到应答
			{
				printf("\r\n超时未应答>取消发送\r\n");	
				sendFailureCount ++;												//发送失败+1
				
				GSM_GPRS_workingState = 0x06;								//返回到连接成功状态
				break;
			}
			break;
			
		case 0x03:				//通过串口向模块发送要发送的数据
			memcpy(GPRS_TX_BUF, GPRS_DATA_BUF, sendDataSize);
			GSM_GPRS_SendOne(sendDataSize);
			printf("\r\nTCP Sending data......\r\n");
// 			printf("\r\nStartTime = %d\r\n", time_value);
			GSM_GPRS_workingState = 0x04;
			break;
			
		case 0x04:				//发送结束数据发送命令
			GSM_GPRS_workingState = 0x05;
			timer_restart(&sendTimeout);									//从当前时间重新开启N秒定时器
			break;
			
		case 0x05:				//等待返回应答“SEND OK”		
			if(at_cmd_table[AT_CMD_CIPSEND_NO-1].result == AT_CMD_CIPSEND_OK)
			{
// 				printf("\r\nEndTime = %d\r\n", time_value);
				printf("\r\n发送成功\r\n");
				
				ConnectionStatus = ONLINE;								//当发送成功时设置连接状态为在线状态
				
				SetSendProcotolSuccess();									//设置本次发送的协议已成功发出
				
				sendFailureCount = 0;											//当发送成功，发送失败计数归零
				errorProcessCount = 0;										//发送数据成功则重连次数归零
				
				if(sendOrderCode == 1001)									//发送心跳成功后查询GSM信号强度
				{
					GSM_SignalCheck();											//查询信号质量
				}
				GSM_GPRS_workingState = 0x00;							//接收到应答
				break;
			}
			
			if(at_cmd_table[AT_CMD_CIPSEND_NO-1].result == AT_CMD_SEND_FAIL)
			{
				printf("\r\nEndTime = %d\r\n", time_value);
				printf("\r\n发送失败\r\n");
				
				ConnectionStatus = OFFLINE;								//当发送失败时设置连接状态为离线状态	
				sendFailureCount ++;											//发送失败+1
				
				//当发送失败时发送心跳包来检查GPRS与后台连接是否还正常
				GPRS_OnlineCheck();
				
				GSM_GPRS_workingState = 0x06;							
				break;
			}
			
			if(timer_expired(&sendTimeout))							//超时还未接收到应答
			{
				printf("\r\nEndTime = %d\r\n", time_value);
				printf("\r\n超时数据尚未发出，发送失败\r\n");
				
				ConnectionStatus = OFFLINE;								//当发送失败时设置连接状态为离线状态	
				sendFailureCount ++;											//发送失败+1
				
				//当发送失败时发送心跳包来检查GPRS与后台连接是否还正常
				GPRS_OnlineCheck();
				
				GSM_GPRS_workingState = 0x06;							//返回到连接成功状态
				break;
			}
			break;
			
		case 0x06:		//检测是否超出发送失败次数
			printf("\r\n当前已发送失败次数 = %d\r\n", sendFailureCount);
			if(sendFailureCount > 0)		//当有数据发送失败则先检查GSM信号是否正常
			{
				GSM_SignalCheck();
			}
			
			if(sendFailureCount >= 3)		//超出发送失败次数，需要进行错误检查
			{
				printf("\r\n超出发送失败次数，转到错误检查\r\n");
				GSM_GPRS_workingState = 0x00;
				GSM_GPRS_Status = 0x03;											//跳转到错误处理任务
				break;
			}else{
				GSM_GPRS_workingState = 0x00;
			}
			break;
			
		default:		//未知状态
			GSM_GPRS_Reset();							//GSM模块复位，重启
			
			printf("\r\nException_未知状态，重启模块！！！\r\n");
			break;		
	}
}

/*
***********************************************************************
*	函 数 名: TCP_ErrorHandler
*	功能说明: TCP链接过程中的错误处理
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void TCP_ErrorHandler(void)
{
// 	static uint8_t errorStatus = 0x00;	
	
	static timer responseTimeout;
	static timer waitTCPConnectTime;
	static timer waitingTime2s;					//2S定时
	
	static uint8_t timer_ok = 0;
	if(timer_ok == 0)
	{
		timer_ok = 1;
		timer_set(&responseTimeout, CLOCK_SECOND*3); 
		timer_set(&waitTCPConnectTime, CLOCK_SECOND*10);
		timer_set(&waitingTime2s, CLOCK_SECOND*2);
	}
	
	switch(errorStatus)
	{	
		case 0x00:				//查询GPRS的状态	
			ConnectionStatus = OFFLINE;								//当发送失败时设置连接状态为离线状态
			
			//先进行异常处理次数检查，超出则模块重启
			errorProcessCount++;									//错误处理次数+1
			printf("\r\nException_异常处理 %d 次\r\n", errorProcessCount);
			if(errorProcessCount >= 5)		//错误处理5次还不恢复正常，则重启模块
			{
				//执行到这一步则转到模块复位重启
				GSM_GPRS_Reset();							//GSM模块复位，重启	
				printf("\r\nException_超出异常处理次数，重启模块！！！\r\n");
				break;
			}
			
			printf("\r\nException_查询GPRS状态\r\n");
			GSM_SendAtCmd("AT+CIPSTATUS", AT_CMD_CIPSTATUS_NO);			//查询连接状态				
			errorStatus = 0x01;	
			timer_restart(&responseTimeout);				//从当前时间重新开启定时器
			break;
			
		case 0x01:		//根据当前GPRS的工作状态进行相应处理
			switch(at_cmd_table[AT_CMD_CIPSTATUS_NO-1].result)
			{
				case GPRS_STATUS_IP_INITIAL:	
					printf("\r\nException_GPRS初始化\r\n");
					errorStatus = 0x12;			//转到关闭移动场景				
					break;
				
				case GPRS_STATUS_IP_START:
					printf("\r\nException_开始TCP/UDP会话\r\n");
					errorStatus = 0x10;			//转到关闭移动场景					
					break;
					
				case GPRS_STATUS_IP_CONFIG:
					printf("\r\nException_配置PDP上下文\r\n");
					errorStatus = 0x20;			//转到错误次数判断后再次查询GPRS状态				
					break;
					
				case GPRS_STATUS_IP_GPRSACT:
					printf("\r\nException_上下文已经激活\r\n");
					errorStatus = 0x10;							
					break;
					
				case GPRS_STATUS_IP_STATUS:
					printf("\r\nException_得到本地IP地址\r\n");
					errorStatus = 0x12;							
					break;
					
				case GPRS_STATUS_TCP_CONNECTING:		//正在连接
					printf("\r\nException_正在连接服务器\r\n");
					errorStatus = 0x20;							
					break;
					
				case GPRS_STATUS_CONNECT_OK:		//连接正常
					printf("\r\nException_连接正常\r\n");
					
					//当检测到连接还正常则发送心跳包来判断GPRS与后台连接是否真正连接
					GPRS_OnlineCheck();
					
					//到这一步虽然查询出来的状态为连接还正常，但是有可以已经连接异常了
					//所以错误处理计数和发送失败计数的变量都不该清除
					errorStatus = 0x00;								//连接成功
					GSM_GPRS_Status = 0x02;						//转到TCP客户端数据收发处理任务
					break;
					
				case GPRS_STATUS_TCP_CLOSING:
					printf("\r\nException_正在关闭链接\r\n");
					errorStatus = 0x20;							
					break;
					
				case GPRS_STATUS_TCP_CLOSED:
					printf("\r\nException_链接已经关闭了\r\n");
					errorStatus = 0x10;							
					break;
					
				case GPRS_STATUS_PDP_DEACT:		//上下文已经关闭
					printf("\r\nException_PDP上下文去激活\r\n");
					errorStatus = 0x20;								
					break;
						
				default:
					break;
			}
			
			if(timer_expired(&responseTimeout))			//超时还未接收到应答
			{
				printf("\r\nException_状态查询超时\r\n");
				errorStatus = 0x20;
				break;
			}
			break;
			
		case 0x10: 				//关闭移动场景“AT+CIPSHUT”
			GSM_SendAtCmd("AT+CIPSHUT", AT_CMD_CIPSHUT_NO);				//关闭移动场景 
			errorStatus = 0x11;
			timer_restart(&responseTimeout);					//从当前时间重新开启定时器
			printf("\r\nException_正在关闭场景\r\n");	
			break;
			
		case 0x11:			
			if(at_cmd_table[AT_CMD_CIPSHUT_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\nException_场景已经关闭\r\n");
				errorStatus = 0x12;								
			}
			if(at_cmd_table[AT_CMD_CIPSHUT_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\nException_场景关闭错误\r\n");
				errorStatus = 0x20;									
				break;
			}
			
			if(timer_expired(&responseTimeout))				//超时还未接收到应答
			{
				printf("\r\nException_场景关闭超时未应答\r\n");	
				errorStatus = 0x20;			
				break;
			}
			break;
			
		case 0x12:					//发送重新连接TCP命令“AT+CIPSTART='IP地址'”
			printf("\r\nException_重新连接\r\n");
			GSM_SendAtCmd(TCP_IP_COM, AT_CMD_CIPSTART_NO);		//开始链接远端服务器
			errorStatus = 0x13;
			timer_restart(&waitTCPConnectTime);								//从当前时间重新开启定时器
			printf("\r\nException_等待应答“CONNECT OK”\r\n");
			break;	
			
		case 0x13:					//等待应答“CONNECT OK”		
			if(at_cmd_table[AT_CMD_CIPSTART_NO-1].result == AT_CMD_SUCCESS)
			{
				printf("\r\nException_重新连接成功\r\n");
				
				GPRS_OnlineCheck();
				
				errorProcessCount = 0;
// 				sendFailureCount = 0;											//当发送成功，发送失败计数归零

				errorStatus = 0x00;									//接收到应答，跳转到0x10
				GSM_GPRS_Status = 0x02;							//转到TCP客户端处理状态
				break;
			}
			
			if(at_cmd_table[AT_CMD_CIPSTART_NO-1].result == AT_CMD_FAILED)
			{
				printf("\r\nException_重连接失败\r\n");
				errorStatus = 0x20;									
				break;
			}
			
			if(timer_expired(&waitTCPConnectTime))				//超时还未接收到应答
			{
				printf("\r\nException_等待应答“CONNECT OK”超时\r\n");		
				errorStatus = 0x20;										
				break;
			}
			break;
			
		case 0x20:		//开启2S定时器，2S过后重新查询GPRS工作状态
			errorStatus = 0x21;
			timer_restart(&waitingTime2s);
			break;
			
		case 0x21:		//2S后重新查询GPRS工作状态 
			if(timer_expired(&waitingTime2s))
			{
				errorStatus = 0x00;
			}
			break;
			
		default:		//未知状态
			GSM_GPRS_Reset();							//GSM模块复位，重启
			
			printf("\r\nException_未知状态，重启模块！！！\r\n");
			break;
	}
}

/*
***********************************************************************
*	函 数 名: GSM_GPRS_Task
*	功能说明: GSM_GPRS通讯任务
*	形    参：无
*	返 回 值: 无
***********************************************************************
*/
void GSM_GPRS_Task(void)
{
	switch(GSM_GPRS_Status)
	{
		case 0x00:		//初始状态，对模块进行开机及相关连网状态的查询
			GSM_GPRS_Loading();
			break;
			
		case 0x01:		//创建TCP客户端
			TCP_ClientCreate();
			break;
			
		case 0x02:		//TCP客户端处理（数据的收发）
			TCP_ClientHandler();
			break;
			
		case 0x03:		//TCP链接期间出现的错误处理
			TCP_ErrorHandler();
			break;
			
		default: 			//未知状态
			GSM_GPRS_Reset();							//GSM模块复位，重启
			
			printf("\r\nException_未知状态，重启模块！！！\r\n");
		break;
	}
}

/******************** (C) COPYRIGHT 2017 CXHY *****END OF FILE*******************/
