/*************************************************************
*                               SOON WRITING                              		    		*
*                       Copyright (c) Robulink, 2014-2024                     			*
*************************************************************/

/*  Create Date:    2014/08/20
*
*  Modify Record:
*  <date>       	<author>      <version>        <desc>
*  -------------------------------------------------------------------
*  2014/08/20	SOON		 	1.0   		Create the file.
*/

/**
******************************************************************************
*  @file	  gprs.c
*  @author  SOON
*  @version V1.0.0
*  @date	  2014-08-20
*  @brief   GPRS通信处理任务
*  
******************************************************************************
*  @attention 
*  
*  <h2><center>&copy; COPYRIGHT 2014 Robulink </center></h2>
******************************************************************************
*/ 


/*******************************************************************************
*
*	需要包括的头文件.
*
*******************************************************************************
*/

//#include <includes.h>

#include "Cmd.h"
#include <math.h>
#include "include.h"
#include "debug_printf.h"
#include "Rtc.h"
#include "addr.h"
#include "uart.h"
#include "storage.h"
#include "apl.h"
#include "PHY.h"
#include "rtc_ext.h"
#include "update.h"
#include "gprs.h"
#include "poweroffon.h"

extern void frame_process(u8 * val,u16 len);
extern void concent_send_gprs();
extern void gprs_load();
extern void rpprocess();
extern void gprs_device_ctl_h();
extern void gprs_device_poweron();
extern void gprs_device_poweroff();
extern u8* GetCurrentTime( void );
extern void COM_led_off(u8 led);
extern void set_PLC_UART_gprs();
extern bool get_update_process();
extern void set_PLC_UART_update();
extern void datacount_read();


#define GPRS_DEBUG

#define GPRS_RECV_BUF_MAX	512

/*test*/

CPU_INT08U gprs_send_tms=0; //发送5-10次登陆报文无应答，重新启动

CPU_INT08U gprs_loading_flag = 0;
CPU_INT08U gprs_set_APN[16];
CPU_INT08U gprs_CCID[GPRS_CCID_LEN];
CPU_INT08U gprs_GMR[GPRS_GMR_LEN];
/*send cmd*/
const CPU_INT08U  AT_AT[]="AT\r";
const CPU_INT08U  AT_CLOSE_ECHO[]="ATE0\r";
const CPU_INT08U  AT_CHECK_CCID[]="AT$MYCCID\r";
const CPU_INT08U  AT_CHECK_CSQ[]="AT+CSQ\r";
const CPU_INT08U  AT_CHECK_CREG[]="AT+CREG?\r";
const CPU_INT08U  AT_MYGMR[]="AT$MYGMR\r";



//AT+CPIN?
const CPU_INT08U  AT_CPIN[]="AT+CPIN?\r";


/*$MYNETURC=<ONOFF>*/
const CPU_INT08U  AT_MYNET_URC[]="AT$MYNETURC=1\r";

/*$MYNETCON=<channel>,<type>,<type_name>*/
const CPU_INT08U  AT_SET_APN[]="AT$MYNETCON=";

/*$MYNETACT=<channel>,<action>*/
const CPU_INT08U  AT_MYNET_ACT[]="AT$MYNETACT=0,1\r";
const CPU_INT08U  AT_MYNET_DEACT[]="AT$MYNETACT=0,0\r";
const CPU_INT08U  AT_MYNET_ACTCHECK[]="AT$MYNETACT?\r";

/*$MYNETCLOSE=<SocketID>*/
const CPU_INT08U  AT_MYNETCLOSE[]="AT$MYNETCLOSE=";
const CPU_INT08U  AT_CGATT0[]="AT+CGATT=0\r";


//CPU_INT08U mynetinfo_type = 0;
//CPU_INT08U mynetinfo_cnt = 0;

const CPU_INT08U  AT_MYNETINFO1[]="AT$MYSYSINFO=1\r";

const CPU_INT08U  AT_MYNETINFO5[]="AT$MYSYSINFO=5\r";


const CPU_INT08U  AT_MYNETINFOQRY[]="AT$MYSYSINFO\r";



/*$MYNETSRV=<Channel>,<SocketID>,<nettype>, <viewMode>,<ip:port>*/
const CPU_INT08U  AT_MYNET_SRV[]="AT$MYNETSRV=";

/*$MYNETOPEN=<SocketID>*/
const CPU_INT08U  AT_MYNET_OPEN[]="AT$MYNETOPEN=";

/*$MYNETWRITE=<SocketID>,<data_len>*/
const CPU_INT08U  AT_MYNET_WRITE[]="AT$MYNETWRITE=";
const CPU_INT08U  AT_MYNET_WRITERET[]="$MYNETWRITE:";

/*$MYNETREAD=<SocketID>,<data_len>*/
const CPU_INT08U  AT_MYNET_READ[]="AT$MYNETREAD=";
const CPU_INT08U  AT_MYNET_READRET[]="$MYNETREAD:";

const CPU_INT08U  AT_POWEROFF[]="AT$MYPOWEROFF\r";


#define GPRS_100MS_DELAY		OS_TICKS_PER_SEC/10		/*任务延时10ms*/

//CPU_INT08U AT_TCP_SEND[]="AT+TCPSEND=";

/*receive cmd*/
const CPU_INT08U AT_PBREADY[] ="+PBREADY";
const CPU_INT08U  AT_CSQ_RESULT[]="99,99";
const CPU_INT08U  AT_CREG_0[]="+CREG: 0";		//"+CREG: 0,1";
const CPU_INT08U  AT_CREG_1[]="+CREG: 0,5";
const CPU_INT08U  AT_OK[]="OK";
const CPU_INT08U  AT_ERROR[]="ERROR";
const CPU_INT08U  AT_MYURCACT[]="MYURCACT:";
const CPU_INT08U  AT_MYNET_ACKRET[]="$MYNETACK:";
const CPU_INT08U  AT_MYNET_OPENRET[]="$MYNETOPEN:";
const CPU_INT08U  AT_ACK_CCID[]="$MYCCID:";


const CPU_INT08U  AT_TCPRECV[]="+TCPRECV:";
//CPU_INT08U  AT_COMMA_OK[]=",OK";
//CPU_INT08U  AT_COMMA_FALSE[]=",-1";

//CPU_INT08U  AT_ERROR1[]="ERROR 1";
//CPU_INT08U  AT_ERROR2[]="ERROR 2";
//CPU_INT08U  AT_FAIL[]="FAIL";
//CPU_INT08U  AT_CGATT_RET0[]="+CGATT: 0";
//CPU_INT08U  AT_CGATT_RET1[]="+CGATT: 1";
//CPU_INT08U  AT_CHECK_RET0[]="+XIIC:    0,";
//CPU_INT08U  AT_CHECK_RET1[]="+XIIC:    1,";
//CPU_INT08U  AT_TCPCLIENT_RET0[]="+TCPSETUP:0,OK";
//CPU_INT08U AT_SEND_READY[]=">";


CPU_INT08U port_0_status = PORT_STATUS_IDLE;
CPU_INT08U port_0_read = 0;

//
//OS_SEM* gprs_read0_sem;


/*test*/
CPU_INT08U server_ip_default[]="119.97.214.18";
CPU_INT16U server_port_default = 7001;


/*test*/
//CPU_INT08U server_ip_default[]="119.28.130.53";
//CPU_INT16U server_port_default = 16482;



CPU_INT08U gprs_tmp_buf[2000];
//gprs_byte_count gbc = {0};	//流量

//CPU_INT08U write_error_count = 0;
CPU_INT16U ack_fail_count = 0;
CPU_INT08U setsrv_count = 0;
OS_SEM gprs_count_sem;

CPU_INT08U config_server_flag = 0;
CPU_INT08U server_ip_main[16];
CPU_INT08U server_ip_bak[16];
CPU_INT16U server_port_main;
CPU_INT16U server_port_bak;
CPU_INT08U bak_ip_flag= 0;
CPU_INT08U re_connect_times = 0;

CPU_INT32U csq_time = 0;
CPU_INT08U csq_value = 0;

/*******************************************************************************
*
*	局部常量定义.
*
*******************************************************************************
*/
typedef enum {FAILED = 0, PASSED = !FAILED} AtStatus;

#define GPRS_CHANNEL		0	//0-5通道号
#define GPRS_SOCKETID		0	//0-5
#define GPRS_NETTYPE		0	//0,TCP client 1,TCP server 2,UDP
#define GPRS_VIEWMODE		0	//0,Hex 1,txt
#define GPRS_MAXDATALEN		1400	//最大报文数据长度



/*******************************************************************************
*
*	局部函数定义.
*
*******************************************************************************
*/

void gprs_remote_revled_on(void);
void gprs_remote_revled_off(void);
void gprs_remote_sendled_on(void);
void gprs_remote_sendled_off(void);
void gprs_online_off();


/** @brief	GPRS通信模块处理任务主任务函数
*
*  完成GPRS模块正常运行状态机
*
*	@param[in, out]	in: 任务初始化参数   out:无
*  
*
*	@return	无
*	@retval	无
*	@note	
*/
CPU_INT08U gprs_init_flag;
CPU_INT08U gprs_connect_flag;
CPU_INT08U gprs_socket_flag;
CPU_INT08U gprs_port0_state;
gprssend_ctrl gprs_send_ctrl;

gprs_at_cmd gprs_at_cmd_cur;	//当前命令

void gprs_close_all();





//moidify by jerry
//begin



#define OSSemPend(a,b,c,d,e) NULL
#define OSSemPost(a,b,c)	 NULL
#define OSQPend(a,b,c,d,e,f) NULL

#define LED_WDI 1


#define OS_ERR_NONE             1
#define OS_ERR_Q_FULL           2        

#define MSG_GPRS_ERROR 0
#define MSG_GPRS_INFO  1
#define LED_RUN_GPRSONLINE 1
#define LED_GPRSONLINE_YES 1


#define LED_CSQ_UNKNOW		0	//信号未知
#define LED_CSQ_LOW			1	//信号弱(红)
#define LED_CSQ_MIDDLE		2	//信号中(红绿)
#define LED_CSQ_HIGH		3	//信号中(绿)


#define LED_ONLINE_NO		0	//常灭
#define LED_GPRSONLINE_YES		1	//常亮(绿)
#define LED_NETONLINE_YES	2	//常亮(绿)

#define LED_LOCAL_IDLE		0	//本地通信休眠
#define LED_LOCAL_SEND		1	//本地通信发送(绿)
#define LED_LOCAL_RECV		2	//本地通信接收(红)

#define LED_REMOTE_IDLE		0	//远程通信休眠
#define LED_REMOTE_SEND		1	//远程通信发送(绿)
#define LED_REMOTE_RECV		2	//远程通信接收(红)


#define  MAX_MSG_LEN 2000

#define  OS_OPT_PEND_BLOCKING                (int)(0x0000u)
#define  OS_OPT_PEND_NON_BLOCKING            (int)(0x8000u)


int led_online_status = 0;
int led_run_status = 0;// &= ~LED_RUN_GPRSONLINE;
int led_csq_status = 0;
int net_link_status = 0;
int net_connect_first = 0;
CPU_INT08U mynetinfo_type = 0;
CPU_INT08U mynetinfo_cnt = 0;
int led_remote_status = 0;
u32	m3761_recv_time = 0;
u32 time_cur = 0;

AtStatus gprs_write_at(CPU_INT08U *cmd_snd,CPU_INT08U *good_rcv);

static u8 is_gprs_send = 0;

typedef  struct{
	CPU_INT08U port;
	CPU_INT16U  head;
	CPU_INT16U  tail;
	CPU_INT16U  used_len;
	CPU_INT16U  max_len;
	//    OS_SEM  buf_sem;
	CPU_INT08U* buf;
	CPU_INT16U count_len;  /*一包字节数*/
}uart_ringbuf_ctrl;



typedef struct _uart_driver_msg{
	CPU_INT08U   port;        					//端口号,见上面的宏定义
	CPU_INT08U   status;     					//状态标识，标识驱动缓冲区状态，（0为满，1为超时）；
	CPU_INT08U   *buf;	    				//驱动缓冲区首地址
	CPU_INT16U   len;       					//缓冲区长度
}uart_driver_msg;//串口消息队列

uart_ringbuf_ctrl gprs_cmd_ctrl;


afn04_F3_st comm_04F3_param = {0};





//数据格式15
typedef struct GB376_DATA_TYPE_15
{
	CPU_INT08U byMin;		// BCD 码十位 BCD 码个位	
	CPU_INT08U byHour;	// BCD 码十位 BCD 码个位
	CPU_INT08U byDay;		// BCD 码十位 BCD 码个位
	CPU_INT08U byMon;		// BCD 码十位 BCD 码个位
	CPU_INT08U byYear;	// BCD 码十位 BCD 码个位
}GB376_DATA_TYPE_15;


// 终端月冻结月电压统计的结构体 
typedef struct month_v_exceed_data
{
	CPU_INT08U month_year[2];
	CPU_INT16U a_v_yss_ct;
	CPU_INT16U a_v_yxx_ct;
	CPU_INT16U a_v_ys_ct;
	CPU_INT16U a_v_yx_ct;
	CPU_INT16U a_v_ok_ct;
	CPU_INT16U b_v_yss_ct;
	CPU_INT16U b_v_yxx_ct;
	CPU_INT16U b_v_ys_ct;
	CPU_INT16U b_v_yx_ct;
	CPU_INT16U b_v_ok_ct;
	CPU_INT16U c_v_yss_ct;
	CPU_INT16U c_v_yxx_ct;
	CPU_INT16U c_v_ys_ct;
	CPU_INT16U c_v_yx_ct;
	CPU_INT16U c_v_ok_ct;
	CPU_INT08U a_v_max[2];      
	CPU_INT08U a_v_max_tm[3];
	CPU_INT08U a_v_min[2];
	CPU_INT08U a_v_min_tm[3];
	CPU_INT08U b_v_max[2];
	CPU_INT08U b_v_max_tm[3];
	CPU_INT08U b_v_min[2];
	CPU_INT08U b_v_min_tm[3];
	CPU_INT08U c_v_max[2];
	CPU_INT08U c_v_max_tm[3];
	CPU_INT08U c_v_min[2];
	CPU_INT08U c_v_min_tm[3]; 
	CPU_INT08U a_v_average[2];
	CPU_INT08U b_v_average[2];
	CPU_INT08U c_v_average[2];
	CPU_INT08U a_v_ys_lv[3];
	CPU_INT08U a_v_yx_lv[3];
	CPU_INT08U a_v_ok_lv[3];
	CPU_INT08U b_v_ys_lv[3];
	CPU_INT08U b_v_yx_lv[3];
	CPU_INT08U b_v_ok_lv[3];
	CPU_INT08U c_v_ys_lv[3];
	CPU_INT08U c_v_yx_lv[3];
	CPU_INT08U c_v_ok_lv[3];

}month_v_exceed_data;    //ii_terminal


typedef struct terminal_data_s
{
	CPU_INT16U reset_times; 				/**<复位次数*/
	CPU_INT16U poweron_time;				/**<工作时间*/
	CPU_INT32U gprs_count;					/**<流量统计*/
	month_v_exceed_data mved;				/*电压统计*/

}terminal_data;


typedef struct 
{
	//一般事件	
	CPU_INT08U	byNorRPtr;		///<一般事件读指针
	CPU_INT08U	byNorWPtr;		///<一般事件写指针
	//重要事件		
	CPU_INT08U	byImpRPtr;		///<重要事件读指针
	CPU_INT08U	byImpWPtr;		///<重要事件写指针

	CPU_INT08U	byImpTotal;		///<重要事件总数
	CPU_INT08U	byNorTotal;		///<重要事件总数

	GB376_DATA_TYPE_15 PowerDownTime;	//掉电时间

	terminal_data terminal_day;	//终端日数据
	terminal_data terminal_mon;	//终端月数据

	terminal_data meter_day;				/*测量点2电压统计*/
	terminal_data meter_mon;				

	CPU_INT32U dly_save;			//通信静默5s后保存

	CPU_INT08U	checksum;		///<参数校验和
} COLLECT_PARAM;


COLLECT_PARAM	collect_param;	///<采集数据任务参数，含事件读写指针

//int uart_gprs_q = 0;



void gprs_init_first()
{
	strcpy((char*)comm_04F3_param.APN,"CMNET");

}

void print_str(u8 * buf,u16 len)
{
	for(int i = 0;i<len;i++)
	{
		printf("%c",buf[i]);
	}
	printf( "\r\n");
	vTaskDelay(50 / portTICK_RATE_MS );
}

//printf("PASSED:connect_flag=%d\r\n",gprs_connect_flag);

void STM_GPRS_ONOFF_H(void)
{
	//ONOFF_GPIO_PORT->BSRRL = ONOFF_GPIO_PIN;
}

void STM_GPRS_ONOFF_L(void)
{
	//ONOFF_GPIO_PORT->BSRRH = ONOFF_GPIO_PIN;
}

void STM_GPRS_VGPCTRL_H(void)
{
	//VGRST_GPIO_PORT->BSRRL = VGPCTRL_GPIO_PIN;
}

void STM_GPRS_VGPCTRL_L(void)
{
	//VGRST_GPIO_PORT->BSRRH = VGPCTRL_GPIO_PIN;
}
void STM_GPRS_VGRST_H(void)
{
	//VGRST_GPIO_PORT->BSRRL = VGRST_GPIO_PIN;
}

void STM_GPRS_VGRST_L(void)
{
	//VGRST_GPIO_PORT->BSRRH = VGRST_GPIO_PIN;
}

void STM_GPRS_PCTRL_ON(void)
{
	//PCTRL_GPIO_PORT->BSRRH = PCTRL_GPIO_PIN;
}

void STM_GPRS_PCTRL_OFF(void)
{
	//PCTRL_GPIO_PORT->BSRRL = PCTRL_GPIO_PIN;
}


void STM_EVAL_LEDToggle(int Led)
{
	//GPIO_PORT[Led]->ODR ^= GPIO_PIN[Led];
}


/*******************************************************************************
*  @brief:  gprs_online_on()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
void gprs_online_on()
{
	//    led_ctrl(LED_GPRS_ONLINE, LED_ON);
}


/*******************************************************************************
*  @brief:  gprs_remote_revled()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/

void gprs_remote_revled_on(void)
{
	//   led_ctrl(LED_REMOTE_REV, LED_ON);
}

void gprs_remote_revled_off(void)
{
	//   led_ctrl(LED_REMOTE_REV, LED_OFF);
}


/*******************************************************************************
*  @brief:  gprs_remote_revled()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
void gprs_remote_sendled_on(void)
{
	//   led_ctrl(LED_REMOTE_SND, LED_ON);
}

void gprs_remote_sendled_off(void)
{
	//   led_ctrl(LED_REMOTE_SND, LED_OFF);
}


/*******************************************************************************
*  @brief:  gprs_online_off()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
void gprs_online_off()
{
	//led_ctrl(LED_GPRS_ONLINE, LED_OFF);
}
//end





struct st_plc_uart_buff
{
	SemaphoreHandle_t   xSemaphore;
	u8 buff[512];
	u16 len;
};


struct st_plc_uart_buff plc_uart_buff;

void plc_buff_sem_give()
{
	xSemaphoreGive(plc_uart_buff.xSemaphore);
}

void plc_uart_buff_set(u8 * buff,u16 len)
{
//	memmove(&plc_uart_buff.buff[plc_uart_buff.len],buff,len);
//	plc_uart_buff.len = plc_uart_buff.len+len;
	memmove(plc_uart_buff.buff,buff,len);
	plc_uart_buff.len = len;

}


void plc_buff_sem_clear()
{
	xQueueReset((QueueHandle_t)plc_uart_buff.xSemaphore);
}

void plc_buff_sem_init()
{
	vSemaphoreCreateBinary(plc_uart_buff.xSemaphore);


	xSemaphoreTake(plc_uart_buff.xSemaphore, 0);
}




/*******************************************************************************
*  @brief:  strstrex() 
*  @param[in, out] 
*  @in: 
* 	  port	-- port number
* 	  buf --  data buf
* 	  len -- data lenth
*  @out: NA
*  @return: send lenth  
*  @retval: NA
*  @note	 
******************************************************************************/
CPU_INT08U* strstrex(CPU_INT08U* src, CPU_INT16U src_len, CPU_INT08U* dst)
{
	CPU_INT16U i,j = 0;
	CPU_INT08U *head = src;


	for (i=0; i<src_len ; i++)
	{
		if(NULL == dst[j])	
			return head;	//

		if(src[i] == dst[j])	
			j++;
		else
		{
			j=0;
			head = &src[i+1];
		}
	}
	return NULLP;

}




CPU_INT08U gprs_power_on()
{
	printf("gprs 开机 开始\r\n");
	gprs_init_flag= 0;
	gprs_connect_flag = 0;
	gprs_socket_flag = 0;
	led_online_status = LED_ONLINE_NO;		//在线
	led_csq_status = LED_CSQ_UNKNOW;			//信号强度

	STM_GPRS_PCTRL_ON();

	/*
	vTaskDelay(200/portTICK_RATE_MS);
	STM_GPRS_ONOFF_L();
	vTaskDelay(1/portTICK_RATE_MS);
	STM_GPRS_ONOFF_H();
	vTaskDelay(10/portTICK_RATE_MS);

	printf("gprs_power_on finish\r\n");
	*/

	gprs_device_poweron();

	printf("gprs 开机 结束\r\n");
	return 0;
}

//如果关机大于5次，重新启动。
static u8 poweroff_count = 0;

CPU_INT08U gprs_power_off()
{

	gprs_init_flag= 0;
	gprs_connect_flag = 0;
	gprs_socket_flag = 0;
	port_0_status = PORT_STATUS_IDLE;

	printf("gprs 关机 开始\r\n");

	if(poweroff_count > 6)
	{
		poweroff_count=0;
		gprs_device_poweroff();
		return 0;
	}
	poweroff_count ++;

	led_online_status = LED_ONLINE_NO;		//在线
	led_csq_status = LED_CSQ_UNKNOW;			//信号强度

	//网络没有连接的情况，关电源
	//	if((net_link_status & 0x04 )!= 0x04)
	//		STM_GPRS_PCTRL_OFF();

	//	vTaskDelay(5/portTICK_RATE_MS);

	gprs_device_poweroff();
	printf("gprs 关机 结束 等待15秒，等灯灭，再开机 次数大于5此，将重新启动系统。次数=%d\r\n",poweroff_count);
	vTaskDelay(15000/portTICK_RATE_MS);

	return 0;
}

CPU_INT08U gprs_power_offon()
{
	printf("\r\n 先关机再开机 开始\r\n");
	gprs_power_off();
	gprs_power_on();
	printf("\r\n 先关机再开机 结束\r\n");
	return 0;
}

void gprs_close_all()
{
	printf("\r\n 先关gprs,再关机\r\n");
	gprs_power_off();

	SysReset();
}




/*******************************************************************************
*  @brief:  gprs_handle_urc() 
*  @param[in, out]	
*  @in: 
*       port  -- port number
*       buf --  data buf
*       len -- data lenth
*  @out: NA
*  @return: send lenth  
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_handle_urc(void* pst, CPU_INT16U str_len)
{


	if (NULL == pst) 
	{
		printf("Parameter error\r\n");
		return -1;
	}

	if (str_len < MIN_MYURC_LEN)
	{
		return 0;
	}

	if ((NULL != strstrex(pst,str_len,"$MYURCCLOSE:"))
		||(NULL != strstrex(pst,str_len, "ERROR: 911"))		//连接超时
		||(NULL != strstrex(pst,str_len, "ERROR: 913")))		//连接断开
	{       
		printf("Tcp Close\r\n");
		port_0_status = PORT_STATUS_IDLE;
		gprs_at_cmd_cur.status = GPRS_AT_STATUS_ACKERR; 

		//led
		led_online_status &= ~LED_GPRSONLINE_YES;
		led_run_status &= ~LED_RUN_GPRSONLINE;


		COM_led_off(3);

		//这情况，重新开关gprs
		//if((NULL != strstrex(pst,str_len, "ERROR: 911")) || (NULL != strstrex(pst,str_len, "ERROR: 913")))
		//{
		//	gprs_power_offon();
		//}
		return 1;
	}
	if((NULL != strstrex(pst,str_len,"ERROR:"))
		||(NULL != strstrex(pst,str_len,"99,99")))
	{
		gprs_at_cmd_cur.status = GPRS_AT_STATUS_ACKERR;    
		//return 1;
	}

	if(NULLP != strstrex(pst,str_len,"$MYURCREAD:"))
	{
		port_0_read=1;    
		gprs_remote_revled_on();
		return 1;
	}
	if ((NULL != strstrex(pst,str_len, "ERROR: 902")) 		//此PDP已经激活
		||(NULL != strstrex(pst,str_len, "ERROR: 912")))	//Socket连接已经存在
	{		
		gprs_at_cmd_cur.status = GPRS_AT_STATUS_ACKOK;    
		return 1;
	}

	if((NULLP == gprs_at_cmd_cur.good_rcv)
		||(NULLP != strstrex(pst,str_len,gprs_at_cmd_cur.good_rcv)))
	{
		gprs_at_cmd_cur.status = GPRS_AT_STATUS_ACKOK;    
		return 1;
	}

	return 0;         
}


CPU_INT16S gprs_getatcmddata(CPU_INT16S  read_len, uart_ringbuf_ctrl* src,  CPU_INT08U*dest, CPU_INT16U dest_len )
{
	CPU_INT16U count = 0;
	CPU_INT16U max;
	CPU_INT16U head;
	OS_ERR err = 0;
	//	CPU_TS ts;
	CPU_INT16U len;

	if ((NULL == src)  ||(NULL==dest))    
		return -1;

	if (read_len<0)
		return -1;

	len = (CPU_INT16U)read_len;

	if ( len> dest_len)
	{
		return -1;
	}

	/*get sem*/
	OSSemPend(&src->buf_sem,1000,OS_OPT_PEND_BLOCKING,&ts,&err);

	//OSSemPend(src->buf_sem, 1000 ,&err);
	if (OS_ERR_NONE !=err)
	{
		return -1;
	}

	max = src->max_len;
	head = src->head;

	if (0== src->used_len)
	{        
		//OSSemPost(src->buf_sem);
		OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return 0;
	}

	while( (0< (src->used_len) )  &&(count < len))
	{
		dest[count] = src->buf[head];
		count++;
		head= (head + 1)%max;
		if(src->used_len > 0)
			src->used_len= src->used_len-1;   
	}

	src->head = (src->head + count)%max;

	//OSSemPost(src->buf_sem);
	OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
	//if(OS_ERR_NONE != err)
	return count;
}


/*******************************************************************************
*  @brief:  gprs_getatcmd() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_getatcmd(uart_ringbuf_ctrl* src,  CPU_INT08U*dest, CPU_INT16U dest_len )
{
	CPU_INT16U count = 0;
	CPU_INT16U max;
	CPU_INT16U head;
	OS_ERR err = 0;
	//	CPU_TS ts;

	if ((NULL == src)  ||(NULL==dest))    
		return -1;

	/*get sem*/
	//OSSemPend(src->buf_sem, 1000 ,&err);
	OSSemPend(&src->buf_sem,1000,OS_OPT_PEND_BLOCKING,&ts,&err);

	if (OS_ERR_NONE !=err)
	{
		return -1;
	}

	max = src->max_len;
	head = src->head;
#if 0
	if (src->used_len > dest_len)
	{
		printf("gprs_getatcmd_all len error\r\n");
		OSSemPost(src->buf_sem);
		return -1;
	}
#endif
	if (0== src->used_len)
	{        
		//OSSemPost(src->buf_sem);
		OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return 0;
	}

	if ((2<=src->used_len)&&('\r'==src->buf[src->head])
		&&('\n'==src->buf[(src->head) + 1]))
	{
		/*pass 2 char*/
		src->head = (src->head + 2)%max;
		src->used_len = src->used_len -2;
		//OSSemPost(src->buf_sem);
		OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return 0;
	}
	while((0< (src->used_len) )&&('\n' != src->buf[head]) &&(count < dest_len))
	{
		dest[count] = src->buf[head];
		count++;
		head= (head + 1)%max;
		if(src->used_len > 0)
			src->used_len= src->used_len-1;   
	}

	if ('\n' == src->buf[head])
	{
		dest[count]= '\n';
		count++;
		dest[count] = 0;
		if(src->used_len > 0)
			src->used_len = src->used_len -1;        
	}
	else{
		dest[count] = 0;
	}

	src->head = (src->head + count)%max;


	//OSSemPost(src->buf_sem);
	OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
	//if(OS_ERR_NONE != err)

	return count;
}

/*******************************************************************************
*  @brief:  gprs_send_atcmd()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
void gprs_send_atcmd(CPU_INT08U* buf, CPU_INT32U len)
{
	st_rtc_ext * time = (st_rtc_ext *)GetCurrentTime();
	printf("\r\n%02x-%02x-%02x %02x:%02x:%02x 集中器->移动模块 长度=%d 值=\r\n", time->year,time->month,time->day,time->hour,time->min,time->sec,len);

	//print_str(buf,len);
//        printf("\r\n%02x%02x%02x\r\n",buf[0],buf[5],buf[len-1]);
	plc_uart_Tx(buf,len);

}

void gprs_send_atcmd2(CPU_INT08U* buf, CPU_INT32U len)
{
	plc_uart_Tx(buf,len);

}

/*******************************************************************************
*  @brief:  gprs_checkat()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
void gprs_recv_data(void)
{
	//	uart_driver_msg* p_msg;
	//	OS_ERR err = 0;
	//	CPU_TS ts;
	//	OS_MSG_SIZE msg_size = 0;

	//	p_msg = OSQPend(&uart_gprs_q,100,OS_OPT_PEND_BLOCKING,&msg_size,&ts,&err);

	xSemaphoreTake(plc_uart_buff.xSemaphore, 100/portTICK_RATE_MS);

	plc_buff_sem_clear();

	if(plc_uart_buff.len>0)
	{
		plc_uart_buff.buff[plc_uart_buff.len] = 0;	

		print_str(plc_uart_buff.buff,plc_uart_buff.len);


		gprs_handle_urc(plc_uart_buff.buff,plc_uart_buff.len);

		plc_uart_buff.len = 0;
	}


	/*	
	if (OS_ERR_NONE == err)
	{
	p_msg->buf[p_msg->len] = 0;	
	printf("%s", p_msg->buf);

	gprs_handle_urc(p_msg->buf,p_msg->len);
	}
	*/
}


/*******************************************************************************
*  @brief:  gprs_checkat()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
AtStatus gprs_write_at(CPU_INT08U *cmd_snd,CPU_INT08U *good_rcv)
{
	CPU_INT08U timeout = 0;
	CPU_INT08U waittime = 0;
	//    CPU_INT08U *p;
	//	uart_driver_msg* p_msg;
	//	OS_ERR err = 0;
	//	CPU_TS ts;
	//	OS_MSG_SIZE msg_size = 0;

	do
	{
		timeout++;

		gprs_send_atcmd(cmd_snd,strlen((char const *)cmd_snd)); // 通过串口发送AT+CSQ回车

		gprs_at_cmd_cur.good_rcv = good_rcv;
		gprs_at_cmd_cur.status = GPRS_AT_STATUS_SEND;

		do
		{
			waittime++;
			xSemaphoreTake(plc_uart_buff.xSemaphore, 10000/portTICK_RATE_MS);

			plc_buff_sem_clear();


			if(plc_uart_buff.len)
			{
				gprs_handle_urc(plc_uart_buff.buff,plc_uart_buff.len);

				plc_uart_buff.len = 0;

				if(GPRS_AT_STATUS_ACKOK == gprs_at_cmd_cur.status)
					return PASSED;
				if(GPRS_AT_STATUS_ACKERR== gprs_at_cmd_cur.status)
					return FAILED;
			}
		}while(waittime<3);
	}while(timeout<5);	  

	return FAILED;
}


void gprs_get_CCID(CPU_INT08U* buf)
{
	memcpy(buf, gprs_CCID, GPRS_CCID_LEN);

}



/*******************************************************************************
*  @brief:  gprs_check_CSQ() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT08S gprs_check_CSQ()
{
	CPU_INT08U *p;


	gprs_send_atcmd((CPU_INT08U *)AT_CHECK_CSQ,strlen((char const *)AT_CHECK_CSQ)); // 通过串口发送AT+CSQ回车


	xSemaphoreTake(plc_uart_buff.xSemaphore, 10000/portTICK_RATE_MS);

	plc_buff_sem_clear();

	gprs_handle_urc(plc_uart_buff.buff,plc_uart_buff.len);

	p = strstrex(plc_uart_buff.buff,plc_uart_buff.len,"+CSQ: ");
	if(NULLP != p)
	{
		csq_value = atoi((char const *)p+strlen((char const *)"+CSQ: ")); 

		plc_uart_buff.len = 0;

		if ((99==csq_value) ||( 10>csq_value) )
		{
			led_csq_status = LED_CSQ_LOW;
		}
		else if ((10 <= csq_value) && (  22 > csq_value ))
		{
			led_csq_status = LED_CSQ_MIDDLE;
		}
		else if (22<=csq_value) {
			led_csq_status = LED_CSQ_HIGH;
		}     
	}
	return 0;
}


/*******************************************************************************
*  @brief:  gprs_init() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT08U tmp_buf[50]={0};
bool gprs_init()
{
	// CPU_INT08S ret;
	//CPU_INT08U err_count=0;
	//CPU_INT08U err_index =GPRS_MAX_FLAG;

	while((GPRS_MAX_FLAG !=gprs_init_flag)&&(0==net_connect_first))
	{
		switch(gprs_init_flag)
		{
		case 0:  /*0. 检查上电*/
			/*检查at命令是否可执行*/
			if (PASSED == gprs_write_at((CPU_INT08U *)AT_AT,(CPU_INT08U *)AT_OK))
			{
				printf("STEP 0: CHECK AT Ok!!!\r\n\r\n");
				//gprs_device_ctl_h();
				gprs_init_flag = 1;
			}
			else
			{
				printf("STEP 0: CHECK AT ERR !! \r\n");
				printf("\r\n\r\n *******发送命令 GPRS 串口没有回应数据，关机再开机 !!!******* \r\n\r\n");
				gprs_power_offon();
				return false;
			}
			break;

		case 1:  /*1.关闭回显*/
			if (PASSED == gprs_write_at((CPU_INT08U *)AT_CLOSE_ECHO,(CPU_INT08U *)AT_OK))
			{
				printf("STEP 1: CLOSE ECHO Ok!!!\r\n\r\n");
				gprs_init_flag = 2;
			}
			else
			{
				printf("STEP 1: CLOSE ECHO ERR!!!\r\n\r\n");
				printf("\r\n\r\n *******发送命令 GPRS 串口没有回应数据，关机再开机 !!!******* \r\n\r\n");
				gprs_power_offon();
				return false;
			}
			break;

		case 2: /*2.获取SIM 卡标识*/
			if (PASSED == gprs_write_at((CPU_INT08U *)AT_CHECK_CCID,(CPU_INT08U *)AT_ACK_CCID))
			{
				printf("STEP 2: CHECK CCID Ok!!!\r\n\r\n");    
				gprs_init_flag = 3;
			}
			else
			{  
				printf("STEP 2: GET  SIM CCID ERROR!!!\r\n");

				gprs_init_flag =0;
				vTaskDelay(30000/portTICK_RATE_MS);
				printf("\r\n\r\n *******发送命令 GPRS 串口没有回应数据，关机再开机 !!!******* \r\n\r\n");
				gprs_power_offon();
				return false;
			}
			break;

		case 3: /*3.检查信号的强度*/
			if (PASSED == gprs_write_at((CPU_INT08U *)AT_CHECK_CSQ,(CPU_INT08U *)AT_OK))
			{
				printf("STEP 3: CHECK CSQ Ok!!!\r\n\r\n");    
				gprs_init_flag = 4;
			}
			else
			{	
				printf("STEP 3: CHECK  CSQ ERROR!!!\r\n");                           
				gprs_init_flag =0;
				vTaskDelay(30000/portTICK_RATE_MS);
				printf("\r\n\r\n *******发送命令 GPRS 串口没有回应数据，关机再开机 !!!******* \r\n\r\n");
				gprs_power_offon();
				return false;
			}
			break;

		case 4: /*4.检查网络注册状态*/   
			if (PASSED == gprs_write_at((CPU_INT08U *)AT_CHECK_CREG,(CPU_INT08U *)AT_CREG_0))
			{
				printf("STEP 4: CHECK CREG Ok!!!\r\n\r\n");    
				printf("GPRS init OK!!!\r\n");
				gprs_init_flag = GPRS_MAX_FLAG;
			}
			else
			{
				printf("STEP 4: CHECK CREG ERROR!!!\r\n");
				gprs_init_flag =0;
				vTaskDelay(30000/portTICK_RATE_MS);
				printf("\r\n\r\n *******发送命令 GPRS 串口没有回应数据，关机再开机 !!!******* \r\n\r\n");
				gprs_power_offon();
				return false;
			}
			break;

		default:
			break;
		}
	}

	return false;

}



/*******************************************************************************
*  @brief:  task_gprs() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
//	CPU_INT08U tmp_buf[50];
bool gprs_connect()
{
	AtStatus status;

	//modify by jerry begin
	gprs_connect_flag = 0;
	//modify by jerry end

	while((GPRS_MAX_FLAG !=gprs_connect_flag)&&(0==net_connect_first))
	{
		switch(gprs_connect_flag)
		{
		case 0:  /*0. 设置类型为GPRS */
			gprs_check_CSQ();
			status = PASSED;
			break;

		case 1:  /*1. 设置apn*/
			//sprintf((char *)tmp_buf,"%s%d,APN,%s\r",AT_SET_APN ,GPRS_CHANNEL,comm_04F3_param.APN);
			sprintf((char *)tmp_buf,"%s%d,\"APN\",\"%s\"\r",AT_SET_APN ,GPRS_CHANNEL,comm_04F3_param.APN);
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;

              case 2: //密码 用户名
			sprintf((char *)tmp_buf,"%s%d,\"USERPWD\",\"%s,%s\"\r",AT_SET_APN ,GPRS_CHANNEL,comm_04F3_param.user,comm_04F3_param.password);
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;

		case 3: //AUTH
			sprintf((char *)tmp_buf,"AT$MYNETCON=0,\"AUTH\",1\r");
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;
		case 4: //AT$MYIPFILTER
			sprintf((char *)tmp_buf,"AT$MYIPFILTER=0,2\r");
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;
		case 5: //关闭连接
			sprintf((char *)tmp_buf,"AT$MYNETURC=1\r");
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;
		case 6: /*3. 建立PPP 连接*/
			sprintf((char *)tmp_buf,"AT$MYNETACT=0,1\r");
			status =gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
                        break;

		case 7: /*4. 察看PPP是否建立成功*/
			gprs_connect_flag = GPRS_MAX_FLAG;
			return true;

		default:
			break;             
		}

		if(PASSED == status)
		{
			gprs_connect_flag ++;
			//printf("PASSED:connect_flag=%d\r\n",gprs_connect_flag);
			printf("PASSED:connect_flag=%d %s\r\n",gprs_connect_flag,tmp_buf);
		}
		else	
		{
			gprs_connect_flag = 0;
			gprs_init_flag = 0;
			gprs_socket_flag = 0;
			printf("\r\n\r\n\r\n ******* gprs_connect() 失败，开关GPRS ******\r\n\r\n\r\n");
			gprs_power_offon();

		}
	}
	return false;
}

/*******************************************************************************
*  @brief:  gprs_tcpsetup_0() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
//	CPU_INT08U tmp_buf[50];
AtStatus gprs_setsrv(CPU_INT08U try_times)
{
	//CPU_INT08U timeout = 0;
	//CPU_INT08U cmd_buf[GPRS_CMD_LEN];
	CPU_INT08U *server_used_ip;
	CPU_INT16U server_used_port;

	if(config_server_flag)
	{
		if (0 == try_times%2)
		{
			/*main*/
			server_used_ip =  server_ip_main;
			server_used_port = server_port_main;
		}
		else
		{
			/*bak*/
			server_used_ip =  server_ip_bak;
			server_used_port = server_port_bak;
		}
	}
	else{
		/*default*/
		server_used_ip =  server_ip_default;
		server_used_port = server_port_default;
	}

	/*$MYNETSRV=<Channel>,<SocketID>,<nettype>, <viewMode>,<ip:port>*/

	sprintf((char*)tmp_buf,"%s%d,%d,%d,%d,\"%s:%d\"\r", AT_MYNET_SRV ,
		GPRS_CHANNEL,GPRS_SOCKETID,GPRS_NETTYPE,GPRS_VIEWMODE,server_used_ip,server_used_port);


	printf("server_ip=%s , server_port=%d....\r\n",server_used_ip,server_used_port );

	return gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);

}

/*******************************************************************************
*  @brief:  gprs_socket_create() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
//	CPU_INT08U tmp_buf[50];
bool gprs_socket_create()
{
	AtStatus status;
	CPU_INT08U try_times = 0;


	while((GPRS_MAX_FLAG !=gprs_socket_flag)&&(0==net_connect_first))
	{
		switch(gprs_socket_flag)
		{
		case 0:  /*0.关闭tcp 连接*/
			/*$MYNETCLOSE=<SocketID>*/
			sprintf((char *)tmp_buf,"%s%d\r", AT_MYNETCLOSE,GPRS_SOCKETID);

			gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			status = PASSED;
			break;        
		case 1:  /*0.设置服务器参数*/
			status = gprs_setsrv(try_times);

			break;

		case 2: /*1.OPEN NET*/
			/*$MYNETOPEN=<SocketID>*/
			sprintf((char*)tmp_buf,"%s%d\r", AT_MYNET_OPEN ,GPRS_SOCKETID);
			status = gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
			break;

		case 3: 
			gprs_socket_flag = GPRS_MAX_FLAG;
			port_0_status = PORT_STATUS_CONNECTED;

			//led
			led_run_status |= LED_RUN_GPRSONLINE;

			//COM_led_on(3);

			gprs_loading_flag = 1;	//通知3761发送登录报文
			return true;	
		default:
			break;
		}

		if(FAILED == status)
		{
			gprs_socket_flag = 0;


			try_times ++;
			if(try_times > 10)
			{
				gprs_close_all();

			}
			printf("FAILED:connect retry=%d\r\n",try_times);
                        vTaskDelay( 20*1000 / portTICK_RATE_MS );


		}
		else
		{
			gprs_socket_flag++;
			printf("PASSED:gprs_socket_flag=%d\r\n",gprs_socket_flag);
		}
	}
	return false;
}





/*******************************************************************************
*  @brief:  gprs_sendbuf_get()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_sendbuf_get(CPU_INT08U *buf, gprssend_ctrl *p_send_ctrl)
{  
	OS_ERR err =0;
	//	CPU_TS ts;

	CPU_INT16U head;
	CPU_INT08U struct_len;
	CPU_INT16U i;
	gprs_msg_head* pst_msg;
	CPU_INT08U* ops;
	CPU_INT16U len;



	if ((NULL == buf) || (NULL ==p_send_ctrl))
		return -1;

	/*获取信号量*/ 
	//OSSemPend(p_send_ctrl->buf_sem, 0 ,&err);
	OSSemPend(&p_send_ctrl->buf_sem,0,OS_OPT_PEND_BLOCKING,&ts,&err);

	if (OS_ERR_NONE !=err)
	{                           
		printf("uart_sendbuf_get: call OSQPend buf_mutex Error\r\n");
		return -1;
	}

	if (0==p_send_ctrl->count)	
	{
		//OSSemPost(p_send_ctrl->buf_sem);
		OSSemPost(&p_send_ctrl->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		printf("gprs count ==0\r\n");
		return -1;
	}

	p_send_ctrl->count= p_send_ctrl->count -1;

	head = p_send_ctrl->head;
	struct_len = sizeof(gprs_msg_head);
	ops =buf;

	for(i=0;i<struct_len; i++)
	{
		*ops = p_send_ctrl->databuff[head];
		ops++;
		head = (head +1)%MAX_GPRSSEND_BUF;
	}

	pst_msg = (gprs_msg_head*)buf;
	len = pst_msg->len;

	for(i=0;i<len; i++)
	{
		*ops = p_send_ctrl->databuff[head];
		ops++;
		head = (head +1)%MAX_GPRSSEND_BUF;
	}

	*ops = 0;

	p_send_ctrl->head =( p_send_ctrl->head + len + struct_len )%MAX_GPRSSEND_BUF;
	p_send_ctrl->used_len = p_send_ctrl->used_len - ( len + struct_len );

	/*释放信号量*/

	//if ( OS_ERR_NONE != OSSemPost(p_send_ctrl->buf_sem))

	OSSemPost(&p_send_ctrl->buf_sem,OS_OPT_POST_ALL,&err);
	if(OS_ERR_NONE != err)
	{                 
		printf("OSSemPost Error\r\n");           
	}

	return  len;
}




/*******************************************************************************
*  @brief:  task_gprs()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_handle_read(CPU_INT08U*  src)
{
	CPU_INT08U* ret_string;

	CPU_INT16U len;

	if (NULL == src)
		return -1;

	if (NULL != (ret_string = (CPU_INT08U*)strstr((char*)src,(const char*)AT_ERROR))) 
	{    
		printf("MYNET=%s\r\n",src);
		printf("MYNET READ Error\r\n"); 

		return -1;
	}          

	if(NULL != (ret_string = (CPU_INT08U*)strstr((char*)src,(const char*)AT_MYNET_READRET)))
	{                       
		/*读入字节*/
		if (NULL != (ret_string = (CPU_INT08U*)strstr((char*)src,(const char*)",")))
		{
			len =  atoi((const char *)(ret_string+1));

			if (0 == len)
			{                                                                   
				return 0;
			}                           
			else
			{
				//len = len + 6;
				return len;
			}
		}
		else
		{
			return -1;
		}
	}              

	return -1;
}



/*******************************************************************************
*  @brief:  gprs_handle_write()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_handle_write(CPU_INT08U*  src, CPU_INT16U write_len)
{
	CPU_INT08U* ret_string;

	CPU_INT16S len;

	if (NULL == src)
		return -1;

	if (NULL != (ret_string = (CPU_INT08U *)strstr((char*)src,(const char*)AT_ERROR))) 
	{
		printf("err:%s\r\n",src );
		return -1;        
	}

	if(NULL != (ret_string = (CPU_INT08U *)strstr((char*)src,(const char*)AT_MYNET_WRITERET)))
	{                            
		if (NULL == (ret_string = (CPU_INT08U *)strstr((char*)src,(const char*)",")))
		{
			printf(",,,error\r\n");
			printf("err:%s\r\n",src );
			return -1;
		}
		else
		{
			len = atoi((const char*)(ret_string+1));
			if (write_len > len){

				printf("err:%s\r\n",src );
				printf("len = %d, write_len=%d", len,write_len);
				return -1;
			}
			return len;
		}
	}

	printf("end,,,error\r\n");
	printf("err:%s\r\n",src );      

	return -1;
}

static CPU_INT08U gprs_recv_buffer[GPRS_RECV_BUF_MAX];
static CPU_INT32U gprs_recv_buffer_len = 0;
CPU_INT32U frame_len = 0;


void gprs_buff_clear()
{
	memset(gprs_recv_buffer,0,sizeof(gprs_recv_buffer));
	gprs_recv_buffer_len = 0;
}
//	CPU_INT08U tmp_buf[50];


#define GPRS_RECV_ERR        0
#define  GPRS_RECV_END        1
#define  GPRS_RECV_NEXT        2


bool gprs_recv_proc()
{

	printf("\r\n **********GPRS读取数据开始********\r\n");
	OS_MSG_SIZE msg_size;
	u8 type = 0;
	CPU_INT08U *p = NULL;
	CPU_INT08U waittime = 0;

	for(u8 j = 0;j<4;j++)
	{
		sprintf((char *)tmp_buf,"%s%d,%d\r", AT_MYNET_READ,GPRS_SOCKETID,GPRS_RECV_BUF_MAX);
		gprs_send_atcmd(tmp_buf,strlen((char const *)tmp_buf));
		do
		{
			waittime++;
			xSemaphoreTake(plc_uart_buff.xSemaphore, 100/portTICK_RATE_MS);
			plc_buff_sem_clear();

//#ifdef GPRS_DEBUG
//                        printf("\r\n *** len=%d\r\n",plc_uart_buff.len);
//			for(u8 i=0;i<plc_uart_buff.len;i++)
//				printf("%02x", plc_uart_buff.buff[i]);

//			printf("\r\n *** \r\n");
//#endif



			if(plc_uart_buff.len>0)
			{
				p = strstrex(plc_uart_buff.buff,plc_uart_buff.len,"$MYNETREAD:");
				if(NULLP != p)
				{
					msg_size = atoi((char const *)p+strlen((char const *)"$MYNETREAD: 0,")); //0-5,长度一样
					if(msg_size != 0)
					{
						//led
						led_remote_status |= LED_REMOTE_RECV;
						if(msg_size >= 1000)		p+=strlen("$MYNETREAD: 0,1000\r\n");
						else if(msg_size >= 100)	p+=strlen("$MYNETREAD: 0,100\r\n");
						else if(msg_size >= 10)		p+=strlen("$MYNETREAD: 0,10\r\n");
						else						p+=strlen("$MYNETREAD: 0,1\r\n");

						if(gprs_recv_buffer_len<GPRS_RECV_BUF_MAX)
						{
							memmove(gprs_recv_buffer+gprs_recv_buffer_len,p,msg_size);
							gprs_recv_buffer_len = gprs_recv_buffer_len + msg_size;
							plc_uart_buff.len = 0;
							type = GPRS_RECV_NEXT;
							break;
						}
						else
						{
							//						gprs_buff_clear();
							type = GPRS_RECV_ERR;
							plc_uart_buff.len = 0;
							gprs_buff_clear();
							break;
						}


					}	
					else
					{
						type = GPRS_RECV_END;
						break;
					}
				}
                                
                                plc_uart_buff.len = 0;
			}
		}while(waittime<5);


		if(GPRS_RECV_END == type)
		{
                  
                  
#ifdef GPRS_DEBUG
                   printf("\r\n");
                 for(u16 i = 0;i<gprs_recv_buffer_len;i++)
                {
                 printf("%02x ",gprs_recv_buffer[i]);
                }
                  
                 printf("\r\n");

#endif                  
			//如果有有数据来
			frame_process(gprs_recv_buffer,gprs_recv_buffer_len);
			printf("\r\n **********GPRS读取数据结束*************\r\n");
			gprs_buff_clear();
			plc_uart_buff.len = 0;

			//这句话，是连续5此如果没有来数据，将复位gprs模块
			poweroff_count = 0;

			return true;
		}
		else if(GPRS_RECV_ERR == type)
		{
			//如果没有数据来，或者错误
			plc_uart_buff.len = 0;
			gprs_buff_clear();
			printf("\r\n\r\n ********GPRS没有数据1*****************\r\n\r\n");
			//return false;

		}
	}

	plc_uart_buff.len = 0;
	gprs_buff_clear();
	printf("\r\n\r\n ****************GPRS没有数据2***************\r\n\r\n");
	return false;

}


/*******************************************************************************
*  @brief:  gprs_send_proc()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT08U gprs_cmd_buf[128];



void gprs_send_proc_direct(u8 * val,u16 len )
{
	CPU_INT16S n;

	//led
	led_remote_status |= LED_REMOTE_SEND;
	n = len;
	printf("\r\n **********GPRS发送数据开始********\r\n");
	if (n>0) 
	{
		sprintf((char*)gprs_cmd_buf, "%s%d,%d\r", AT_MYNET_WRITE, 0, len);	

		st_rtc_ext * time = (st_rtc_ext *)GetCurrentTime();
		printf("\r\n%02x-%02x-%02x %02x:%02x:%02x 集中器->移动模块 长度=%d 值=\r\n", time->year,time->month,time->day,time->hour,time->min,time->sec,n);

                
                //if(n>20)
               // {
               //   for(int i = 0;i<n;i++)
               //   {
                    //            0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19
                          //printf("%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
                          //       val[i],val[i+1],val[i+2],val[i+2],val[i+4],val[i+5],val[i+6],val[i+7],val[i+8],val[i+9],val[i+10],val[i+11],val[i+12],val[i+13],val[i+14],val[i+15],val[i+16],val[i+17],val[i+18],val[i+19]);
                    
                //    printf("%02x",val[i]);
                //  }

                
		printf( "\r\n");
#ifdef GPRS_DEBUG
                  for(int i = 0;i<len;i++)
                  {
                    printf("%02x ",val[i]);
                  }
                
#endif               
                
		printf( "\r\n");
		vTaskDelay(50/portTICK_RATE_MS);
		gprs_send_atcmd(gprs_cmd_buf,strlen((char*)gprs_cmd_buf));
		xSemaphoreTake(plc_uart_buff.xSemaphore, 10000/portTICK_RATE_MS);
		plc_buff_sem_clear();
		if(plc_uart_buff.len)
		{
			if(NULL != strstrex((CPU_INT08U *)plc_uart_buff.buff,plc_uart_buff.len,(CPU_INT08U *)"$MYNETWRITE"))
			{
				gprs_send_atcmd2(val,n);
			} 
			plc_uart_buff.len = 0;
		}
		/*                
		if( PASSED == gprs_write_at(gprs_cmd_buf,NULLP))	//NULLP，不判断返回，提高发送速度，避免影响接收(CPU_INT08U *)AT_MYNET_WRITERET))
		{
		//这里不能有打印，为快速
		//vTaskDelay(500/portTICK_RATE_MS);

		gprs_send_atcmd2(val,n);
		//流量统计
		//gbc.send += n;
		//gbc.month +=n;
		//gbc.day +=n;
		//gbc.dly_save = time_cur + 5;	//5s后保存
		collect_param.terminal_day.gprs_count += n;
		collect_param.dly_save = time_cur + 5;	//5s后保存
		}
		*/
	}


}



/*******************************************************************************
*  @brief:  task_gprs()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/


static bool isupdatestate = false;


bool get_isupdatestate()
{
	return isupdatestate;
}


extern st_rtc_ext ERtctime;
extern bool datacount_dlsucess(u8 year,u8 month,u8 day,u8 hour);
extern void dl_485_start(u8 type,u8 *addr, u8 addrlen);

void task_gprs(void *pParam)
{        
	m3761_recv_time = time_cur;

	vTaskDelay(1000/portTICK_RATE_MS);                   





        datacount_read();


                        //如果当前抄表失败
                        if(!datacount_dlsucess(ERtctime.year,ERtctime.month,ERtctime.day,ERtctime.hour))
                        {
                                dl_485_start(1,NULL,0);
                                printf("\r\n[DL] start,poweron state\r\n");
                                vTaskDelay(5000/portTICK_RATE_MS);                   
                        }



	///////////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////

	set_PLC_UART_gprs();       


	//gprs_init_first();

	plc_buff_sem_init();

	gprs_device_init();

	while(1)
	{

		vTaskDelay(100 / portTICK_RATE_MS );

		//time_cur =(xTaskGetTickCount()/portTICK_RATE_MS)/1000;

		if((time_cur - m3761_recv_time) > (3*60*60))   //5分钟未收到数据
		{
			printf("3 hour  no recv data,reboot.*^_^*\r\n");
			gprs_close_all();
		}

		//一步步连接
		if (GPRS_MAX_FLAG !=gprs_init_flag)
		{
			printf("gprs_init\r\n");
			if(!gprs_init())
			{
				continue;
			}
			printf("gprs_init  end\r\n");
		}

		if (GPRS_MAX_FLAG !=gprs_connect_flag)
		{
			printf("gprs_connect\r\n");

			if(!gprs_connect())
			{
				continue;
			}

			printf("gprs_connect end\r\n");
		}

		if (GPRS_MAX_FLAG != gprs_socket_flag)
		{
			printf("gprs_socket_create\r\n");

			if(!gprs_socket_create())
			{
				continue;
			}

			printf("gprs_socket_create end\r\n");


		}
		/**连接服务器成功后，接收数据**/
		if(PORT_STATUS_CONNECTED==port_0_status)
		{
			gprs_recv_data();
			//port_0_read = 1;	//查询方式
			//testsend();
		}
		/*检测网络的状态*/       
		if (PORT_STATUS_IDLE == port_0_status)
		{
			gprs_connect_flag = 4; /*重新拨号并连接服务器*/
			gprs_socket_flag = 0;
			gprs_online_off();
			continue;
		}

		/*接收处理流程*/       
		if ((port_0_read > 0) && (PORT_STATUS_CONNECTED==port_0_status))
		{

			port_0_read=0; 

			//				 vTaskDelay(300/portTICK_RATE_MS);

			gprs_recv_proc();
			gprs_send_tms = 0;	
			csq_time = time_cur;	//无通信时查询信号强度
		}

		/*发送处理流程*/
		if ((1 == is_gprs_send) &&(PORT_STATUS_CONNECTED==port_0_status))
		{

			is_gprs_send = 0;
			concent_send_gprs();

			gprs_send_tms ++;			
			csq_time = time_cur;


			//vTaskDelay(5000 / portTICK_RATE_MS );

			printf("\r\n **********GPRS发送数据结束********\r\n");
		}

		//vTaskDelay(100/portTICK_RATE_MS);

		/*
		模块初始化正常且无通信时查询信号强度
		*/
		if(GPRS_MAX_FLAG == gprs_init_flag)
		{
			if(time_cur - csq_time >= 60)	//每60秒查询一次
			{
				csq_time = time_cur;
				gprs_check_CSQ();
			}
		}    
		//流量统计
		if(collect_param.dly_save)
		{
			if(time_cur > collect_param.dly_save)
			{
				collect_param.dly_save = 0;
				//流量越限事件
				//				Event_ERC32();
				//保存标志
				//param_update.comm_flag = 1;
			}
		}

		//登陆
		gprs_load();
		//上报
		//rpprocess();
		//
	}
}

void gprs_send_flag()
{
	is_gprs_send = 1;
}

bool gprs_connect_status()
{
	if(PORT_STATUS_CONNECTED == port_0_status)
	{
		return true;
	}
	return false;
}

///////////////////以下未用
///////////////////以下未用
///////////////////以下未用


//	CPU_INT08U tmp_buf[50] = {0};
/*
void gprs_close_all1()
{
//	AtStatus status;
//	CPU_INT08U try_times = 0;
//	OS_ERR err;


sprintf((char *)tmp_buf,"%s%d\r", AT_MYNETCLOSE,GPRS_SOCKETID);

gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);

vTaskDelay(1000/portTICK_RATE_MS);

tmp_buf[0] = 0;

sprintf((char *)tmp_buf,"%s\r", AT_CGATT0);
gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
vTaskDelay(1000/portTICK_RATE_MS);

#if 0
case 1:  //AT+CGATT/ //AT_CGATT0
sprintf((char *)tmp_buf,"%s\r", AT_CGATT0);
gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);

status = PASSED;
break;

#endif                             

}
*/
CPU_INT16S gprs_clear_send()
{
	OS_ERR err = 0;

	OSSemPend(&gprs_send_ctrl.buf_sem,0,OS_OPT_PEND_BLOCKING,&ts,&err);
	if (OS_ERR_NONE !=err)
	{                
		printf("gprs_send_ctrl: call gprs_clear_send  Error\r\n"); 

		printf("gprs_send_ctrl: call gprs_clear_send  Error\r\n");

		return -1;
	}

	gprs_send_ctrl.count =0;
	gprs_send_ctrl.head =0;
	gprs_send_ctrl.tail =0;
	gprs_send_ctrl.used_len =0;

	//if(OS_ERR_NONE != OSSemPost(gprs_send_ctrl.buf_sem))
	OSSemPost(&gprs_send_ctrl.buf_sem,OS_OPT_POST_ALL,&err);
	if(OS_ERR_NONE != err)
	{                  
		printf("OSSemPost Error\r\n");
	}

	return 0;
}

void gprs_send_proc()
{
	CPU_INT16S n;
	gprs_msg_head*p_msg;

	//led
	led_remote_status |= LED_REMOTE_SEND;


	n=gprs_sendbuf_get(gprs_tmp_buf, &gprs_send_ctrl);
	if (n>0) 
	{
		p_msg = (gprs_msg_head*)gprs_tmp_buf;
		sprintf((char*)gprs_cmd_buf, "%s%d,%d\r", AT_MYNET_WRITE, p_msg->send_port, p_msg->len);		 

		if( PASSED == gprs_write_at(gprs_cmd_buf,NULLP))	//NULLP，不判断返回，提高发送速度，避免影响接收(CPU_INT08U *)AT_MYNET_WRITERET))
		{
			gprs_send_atcmd(gprs_tmp_buf+4,n);
			//流量统计
			//gbc.send += n;
			//gbc.month +=n;
			//gbc.day +=n;
			//gbc.dly_save = time_cur + 5;	//5s后保存
			collect_param.terminal_day.gprs_count += n;
			collect_param.dly_save = time_cur + 5;	//5s后保存
		}
	}

}


/*******************************************************************************
*  @brief:  gprs_sendbuf_send()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_sendbuf_send(CPU_INT08U *pmsg, CPU_INT08U * data, CPU_INT16U len)
{
	OS_ERR err = 0;
	//	CPU_TS ts;

	CPU_INT16U tail;
	CPU_INT08U struct_len;
	CPU_INT16U i;
	CPU_INT08U *pos;
	CPU_INT16U total;


	if ((NULL ==pmsg) || (MAX_MSG_LEN <len) || (NULL ==data))
		return -1;

	//OSSemPend(gprs_send_ctrl.buf_sem, 0 , &err);

	OSSemPend(&gprs_send_ctrl.buf_sem,0,OS_OPT_PEND_BLOCKING,&ts,&err);
	if (OS_ERR_NONE !=err)
	{                

		printf("gprs_send_ctrl: call OSQPend buf_sem Error\r\n"); 

		return -1;
	}


	struct_len = sizeof(gprs_msg_head);
	if ((struct_len + len) > (MAX_GPRSSEND_BUF - gprs_send_ctrl.used_len))
	{
		printf("gprs send_buf is full\r\n");
		//OSSemPost(gprs_send_ctrl.buf_sem);
		OSSemPost(&gprs_send_ctrl.buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return -1;
	}

	gprs_send_ctrl.count++;
	tail = gprs_send_ctrl.tail;

	pos = pmsg;
	/*copy struct  to gprs send_buf*/ 
	for (i=0; i<struct_len; i++)
	{
		gprs_send_ctrl.databuff[tail] = *pos;
		pos++;
		tail =( (tail +1)%MAX_GPRSSEND_BUF);
	}

	pos = data;
	/*copy struct  to gprs send_buf*/
	for (i=0; i<len; i++)
	{
		gprs_send_ctrl.databuff[tail] = *pos;
		pos++;
		tail = (tail +1)%MAX_GPRSSEND_BUF;
	}

	total = struct_len + len;
	gprs_send_ctrl.tail =  (gprs_send_ctrl.tail  + total) %MAX_GPRSSEND_BUF;
	gprs_send_ctrl.used_len = gprs_send_ctrl.used_len + total;

	//if(OS_ERR_NONE != OSSemPost(gprs_send_ctrl.buf_sem))
	OSSemPost(&gprs_send_ctrl.buf_sem,OS_OPT_POST_ALL,&err);
	if(OS_ERR_NONE != err)
	{                  
		printf("OSSemPost Error\r\n");
	}

	return 0;
}



/*******************************************************************************
*  @brief:  gprs_handle_ack()
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_handle_ack(CPU_INT08U*  src, CPU_INT16U* gprs_innerbuf_len)
{
	CPU_INT08U* ret_string;

	CPU_INT16U ack;

	if (NULL == src)
		return -1;

	if (NULL == (ret_string = (CPU_INT08U*)strstr((char*)src,(const char*)AT_MYNET_ACKRET))) 
	{
		return -1;
	}

	if( NULL != (ret_string = (CPU_INT08U *)strstr((char*)src,(const char*)",")))
	{   
		ack = atoi((const char*)(ret_string+1));
		ret_string = ret_string + 1;
		if ( NULL != (ret_string = (CPU_INT08U *)strstr((char*)ret_string,(const char*)",")))
		{
			*gprs_innerbuf_len = atoi((const char*)(ret_string+1));
			return ack;
		}
		else{
			return -1;
		}
	}

	return -1;

}



CPU_INT08U get_module_status(void)
{

	//  OS_ERR err;
	CPU_INT08U state=0;

	//	if(GPIO_ReadInputDataBit(GPRS_STATE0_PORT,GPRS_STATE0_PIN))
	//		state |=0x01;
	//	if(GPIO_ReadInputDataBit(GPRS_STATE1_PORT,GPRS_STATE1_PIN))
	//		state |=0x02;
	//	if(GPIO_ReadInputDataBit(GPRS_STATE2_PORT,GPRS_STATE2_PIN))
	//		state |=0x04;

	return state;
}


#if 0
//modify by jerry begin
//			if(0 == mynetinfo_type || mynetinfo_type>1)
{
	//				mynetinfo_type = 0;
	sprintf((char *)tmp_buf,"%s\r", AT_MYNETINFO1);
	gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
	vTaskDelay(1000/portTICK_RATE_MS);
	//				mynetinfo_type ++;
}
//			else if(1 == mynetinfo_type)
//			{
//				sprintf((char *)tmp_buf,"%s\r", AT_MYNETINFO5);
//				gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
vTaskDelay(1000/portTICK_RATE_MS);
//				mynetinfo_type ++;
//			}
/*                                else if(2 == mynetinfo_type)
{
sprintf((char *)tmp_buf,"%s\r", AT_MYNETINFO7G);
gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);
vTaskDelay(1000/portTICK_RATE_MS);
mynetinfo_type ++;
}
*/                                



vTaskDelay(6000/portTICK_RATE_MS);

sprintf((char *)tmp_buf,"%s\r", AT_MYNETINFOQRY);

gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);                                

vTaskDelay(1000/portTICK_RATE_MS);

//modify by jerry end

//				sprintf((char *)tmp_buf,"%s\r", AT_CPIN);
//				gprs_write_at(tmp_buf,(CPU_INT08U *)AT_OK);

vTaskDelay(1000/portTICK_RATE_MS);

#endif


/*******************************************************************************
*  @brief:  gprs_set_cgatt() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
#if 0
CPU_INT08S gprs_set_cgatt()
{
	CPU_INT08U timeout = 0;
	CPU_INT08U cmd_buf[GPRS_CMD_LEN];
	OS_ERR err;

	do
	{
		timeout++;

		gprs_send_atcmd(AT_SET_CGATT,strlen(AT_SET_CGATT)); 
		printf("send AT+CGATT=1....\r\n");
		vTaskDelay(300/portTICK_RATE_MS);

		memset(cmd_buf,0,sizeof(cmd_buf));
		if (0 < gprs_getatcmd_all(&gprs_cmd_ctrl, cmd_buf, sizeof(cmd_buf)))
		{
			printf("@@@@@%s@@@@@\r\n", cmd_buf);
			if(NULL != strstr(cmd_buf,AT_OK))
			{
				break;
			}         
			vTaskDelay(500*timeout/portTICK_RATE_MS);
		}
	}while(timeout<5);	  

	if( timeout>=5)
	{	
		return -1;
	}

	return 0; 

}
#endif




/*******************************************************************************
*  @brief:  gprs_getatcmd_all() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT16S gprs_getatcmd_all(uart_ringbuf_ctrl* src,  CPU_INT08U*dest, CPU_INT16U dest_len)
{
	CPU_INT16U count = 0;
	CPU_INT16U max;
	CPU_INT16U head;
	OS_ERR err = 0;
	//	CPU_TS ts;

	if ((NULL == src)  ||(NULL==dest))    
		return -1;

	/*get sem*/

	OSSemPend(&src->buf_sem,1000,OS_OPT_PEND_BLOCKING,&ts,&err);
	//OSSemPend(src->buf_sem, 1000 ,&err);
	if (OS_ERR_NONE !=err)
	{
		return -1;
	}

	max = src->max_len;
	head = src->head;

	if (src->used_len > dest_len)
	{
		printf("gprs_getatcmd_all len error\r\n");

		src->used_len = 0;
		src->head = 0;
		src->tail = 0;
		src->count_len = 0;

		//OSSemPost(src->buf_sem);
		OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return -1;
	}

	if (0==src->used_len)
	{
		//OSSemPost(src->buf_sem);
		OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
		//if(OS_ERR_NONE != err)

		return 0;
	}

	while(0< (src->used_len))
	{
		dest[count] = src->buf[head];
		count++;
		head= (head + 1)%max;
		src->used_len= src->used_len-1;   
	}
	dest[count]= 0;
	src->used_len = 0;
	src->head = (src->head + count)%max;


	//OSSemPost(src->buf_sem);
	OSSemPost(&src->buf_sem,OS_OPT_POST_ALL,&err);
	//if(OS_ERR_NONE != err)


	return count;
}


/*******************************************************************************
*  @brief:  gprs_get_cgatt() 
*  @param[in, out]	
*  @in: 邋NA
*  @out: NA
*  @return: NA 
*  @retval: NA
*  @note	
******************************************************************************/
CPU_INT08U cmd_buf[GPRS_CMD_LEN];
CPU_INT08S gprs_mynet_urc()
{
	CPU_INT08U timeout = 0;

	do
	{
		timeout++;

		gprs_send_atcmd((CPU_INT08U *)AT_MYNET_URC,strlen((const char*)AT_MYNET_URC)); 

		printf("send AT$MYNETURC=1....\r\n");


		vTaskDelay(300/portTICK_RATE_MS);

		memset(cmd_buf,0,sizeof(cmd_buf));
		if (0 < gprs_getatcmd_all(&gprs_cmd_ctrl, cmd_buf, sizeof(cmd_buf)))
		{
			printf("@@@@@%s@@@@@\r\n", cmd_buf);


			if(NULL != strstrex((CPU_INT08U *)cmd_buf,sizeof(cmd_buf),(CPU_INT08U *)AT_OK))
			{
				break;
			}         
			vTaskDelay(500*timeout/portTICK_RATE_MS);
		}
	}while(timeout<5);	  

	if( timeout>=5)
	{	
		return -1;
	}

	return 0; 

}

void ipport_write()
{
	ipport_writefile((u8*)&comm_04F3_param,sizeof(afn04_F3_st));
}

void ipport_read()
{
	ipport_readfile((u8*)&comm_04F3_param,sizeof(afn04_F3_st));
}


// 16进制ip转换位ip字符串
void M3761_Hex_IP_To_Strip(CPU_INT08U *phexip, CPU_INT08U *strip)
{
	CPU_INT08U i = 0;
	CPU_INT08U value = 0;
	CPU_INT08U val_tmp = 0;
	CPU_INT08U flg = 0;

	for (i = 0; i < 4; i++)
	{
		flg = 0;
		value = phexip[i];

		val_tmp = value / 100;
		if (val_tmp || flg)
		{
			*strip++ = val_tmp + '0';
			flg = 1;
		}
		value = value % 100;

		val_tmp = value / 10;
		if (val_tmp || flg)
		{
			*strip++ = val_tmp + '0';
			flg = 1;
		}
		value = value % 10;

		*strip++ = value + '0';
		*strip++ = '.';
	}
	strip--;
	*(strip) = '\0';
}

void ipport_init()
{
	//主站ip
	M3761_Hex_IP_To_Strip((CPU_INT08U *)&comm_04F3_param.primary, (CPU_INT08U *)server_ip_main);
	server_port_main = comm_04F3_param.primary.port;
	M3761_Hex_IP_To_Strip((CPU_INT08U *)&comm_04F3_param.reserve, (CPU_INT08U *)server_ip_bak);
	server_port_bak = comm_04F3_param.reserve.port;
	config_server_flag = 1;

}