/*******************************************************************************************
 * File Name: Serial.c
 * Function Describe:device for serial	
 * Relate Module:
 * Explain:
	½ÓÊÕ²ÉÓÃÖжϷ½Ê½
	UART1: Á¬½Óβ²å£¬ÓÃÓÚÓëPCÏàÁ¬	  ÁíÍ⣬printfÓ³Éäµ½UART1
	UART2: Á¬½ÓModem
	È«¾Ö±äÁ¿g_ucUARTSel µ÷ÊÔÑ¡Ôñ¿ØÖÆ£¬¾ö¶¨ÁË3¸ö´®¿ÚµÄת·¢¹Øϵ,Æäֵͨ¹ýÒÔÏÂ3¸öºê¿Ø·Ö±ð´ú±í£º
	COM_SEL_MCU   Õý³£Ê¹Óò»×ª·¢,β²åÓÃÓÚMCU´òÓ¡LOG»ò MCUÈí¼þÉý¼¶
	COM_SEL_MODEM	  UART1<-->UART2,β²åÓÃÓÚMODEM LOG´òÓ¡
 * Writer:  ShiLiangWen
 * Date:	2015.1.20
********************************************************************************************/
#define THIS_FILE_ID 4
/* Includes ------------------------------------------------------------------*/
#include "includes.h"
#define USART1_DR_Base  0x40013804   
#define USART2_DR_Base  0x40004404 



unsigned char g_ucUARTSel=0;//0--MCU  1--Modem  2--GPS
unsigned char g_ucUART1RxMode=0;
unsigned short g_usUSART_WordLength = 0x0000;//ÓÃÓÚ´®¿Ú³õʼ»¯£¬ÎÞУÑéλʱΪ0x0000,ÓÐУÑéλʱΪ0x1000
unsigned char g_ucDebugLog=0;//0--²»´òÓ¡DEBUGÐÅÏ¢  1--´òÓ¡DEBUGÐÅÏ¢
//UART1 ¶ÔÍâ½Ó¿Ú
unsigned char RxBuffer1[UART1_RX_BUFFER_SIZE];
unsigned char TxBuffer1[UART1_TX_BUFFER_SIZE];
 unsigned short rx1_ct;
 unsigned char rx1_ct_max=0;
unsigned char g_ucUart1Sending;
unsigned char g_usUart1RecvLen=0;

//UART2  ÓÃÓÚÓëMODEMͨѶ

unsigned char RxBuffer2[UART2_RX_BUFFER_SIZE];
unsigned char TxBuffer2[UART2_TX_BUFFER_SIZE];
unsigned char DMATxBuffer2[UART2_TX_BUFFER_SIZE];
static unsigned short susRx2In=0;                              
static unsigned short susRx2Len=0;
static unsigned short susRx2Out=0;

unsigned char recevstatue=0;

/********************************************************************
*Uart1DMAInit
*´®¿Ú1 DMAÉèÖÃ 
*´®¿Ú1 ·¢ËͱØÐëÓÃͨµÀ4£¬½ÓÊÕ±ØÐëÓÃͨµÀ5
*********************************************************************/
void Uart1DMAInit(void)
{	
	NVIC_InitTypeDef NVIC_InitStructure;
	DMA_InitTypeDef DMA_InitStructure;
	//Æô¶¯DMAʱÖÓ
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
#if UART1_TX_USE_DMA!=0
	//DMA ͨµÀ4ÓÃÓÚUART1 TX
	DMA_DeInit(DMA1_Channel4);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);//ÍâÉèµØÖ·
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer1;//ÄÚ´æµØÖ·
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;//DMA´«Êä·½Ïòµ¥Ïò
	DMA_InitStructure.DMA_BufferSize = UART1_TX_BUFFER_SIZE; //ÉèÖÃDMAÔÚ´«Êäʱ»º³åÇøµÄ³¤¶È
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //ÉèÖÃDMAµÄÍâÉèµÝÔöģʽ
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;	//ÉèÖÃDMAµÄÄÚ´æµÝÔöģʽ
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//ÍâÉèÊý¾Ý×Ö³¤	
	DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;//ÄÚ´æÊý¾Ý×Ö³¤
	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //ÉèÖÃDMAµÄ´«Êäģʽ
	DMA_InitStructure.DMA_Priority = DMA_Priority_Low;	//ÉèÖÃDMAµÄÓÅÏȼ¶±ð
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//ÉèÖÃDMAµÄ2¸ömemoryÖеıäÁ¿»¥Ïà·ÃÎÊ
	DMA_Init(DMA1_Channel4,&DMA_InitStructure);
//	//DMAÖжÏÉèÖÃ
//	NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
//	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
//	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//	NVIC_Init(&NVIC_InitStructure);
	DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);//ÖжÏÉèÖÃ
	DMA_Cmd(DMA1_Channel4, DISABLE); //µÈµ½ÐèÒª·¢Ë͵ÄʱºòÔÙʹÄÜ
#endif	      
	//DMA ͨµÀ5ÓÃÓÚUART1 RX
	DMA_DeInit(DMA1_Channel5);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);//ÍâÉèµØÖ·
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer1;//ÄÚ´æµØÖ·
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//DMA´«Êä·½Ïòµ¥Ïò
	DMA_InitStructure.DMA_BufferSize = UART1_RX_BUFFER_SIZE; //ÉèÖÃDMAÔÚ´«Êäʱ»º³åÇøµÄ³¤¶È
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //ÉèÖÃDMAµÄÍâÉèµÝÔöģʽ
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;	//ÉèÖÃDMAµÄÄÚ´æµÝÔöģʽ
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//ÍâÉèÊý¾Ý×Ö³¤	
	DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;//ÄÚ´æÊý¾Ý×Ö³¤
	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //ÉèÖÃDMAµÄ´«Êäģʽ
	DMA_InitStructure.DMA_Priority = DMA_Priority_High;	//ÉèÖÃDMAµÄÓÅÏȼ¶±ð
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//ÉèÖÃDMAµÄ2¸ömemoryÖеıäÁ¿»¥Ïà·ÃÎÊ
	DMA_Init(DMA1_Channel5,&DMA_InitStructure);  
	//DMA_Cmd(DMA1_Channel5, ENABLE); //ʹÄÜͨµÀ                                        
}

static unsigned char uart_data_last=0;


void UART2RxTxISRHandler(void)                               
{
	__IO unsigned char uart_data;
	__IO static unsigned char uart_last_data=0;
	int i;
	
	RunMake(THIS_FILE_ID);
	
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET){
		
		uart_data = USART_ReceiveData(USART2);
		
			RxBuffer2[susRx2In++]=uart_data;
			susRx2Len++;
			if(susRx2In>=(UART2_RX_BUFFER_SIZE)){
			susRx2In=0;	
		}
			isr_sem_send(&ModemUartSem);
		
		USART_ClearITPendingBit(USART2,  USART_IT_RXNE); 
	}else if(USART_GetFlagStatus(USART2,USART_FLAG_IDLE)!=RESET){	
		
				USART2->SR;
				USART2->DR;
#if 0
				//recevstatue=1;
			//if(numbIn>UART2_RX_BUFFER_SIZE) numbIn= UART2_RX_BUFFER_SIZE;
				RxBuffer2[susRx2In]='\0';
				RS485_DIR_HIGH;
					for(i=0;i<susRx2In;i++){
					USART_SendData(USART1,RxBuffer2[i]);
					while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);	  
					}		
					RS485_DIR_LOW;
					susRx2In=0;
#else 
				//isr_sem_send(&ModemUartSem);		
				//SlwTrace(DEBUG,"xxxxxxxxxxxxxx\r\n");			
#endif									
					
		}
			uart_last_data=uart_data;
	
	if(USART_GetFlagStatus(USART2,USART_FLAG_ORE)==SET)
	{
		USART_ReceiveData(USART2);    //
		USART_ClearFlag(USART2,USART_FLAG_ORE); // 
	}
	
} 


static unsigned short susTcpRecvDataLen=0;//Èç¹ûÊÇ$MYNETREAD: 0,8µÄATÏìÓ¦£¬ÔòÓ¦¸Ã¼Ç¼Æ䳤¶È²¢´æ·ÅÔÚsusTcpRecvDataLenÖУ¬È»ºóÆäºóµÄÓ볤¶ÈÏàÆ¥ÅäÊý¾ÝÒ²Ò»Æð´ò°ü³ÉÓ¦ÓòãµÄÏûÏ¢
/**********************************************************************
Uart2RecvProcess  //´¦Àí½ÓÊÕ
´ÓUART2½ÓÊÕ»º³åÇøRxBuffer2ÖÐÌáÈ¡ÏûÏ¢£¬·ÅÈë»·ÐÎÏûÏ¢¶ÓÁÐUart2MsgQueueÖÐ
RxBuffer2Ò²ÊÇ»·Ðλº³åÇø¡

+IPD,len:data\r\n
>\r\n   ¿ÉÒÔ·¢ËÍÊý¾Ý  z×îÉÙ3¸ö×Ö½Ú

************************************************************************/
void Uart2RecvProcess(void)
{
	char data,flag;
	unsigned short Rx2Len,out;
	char preData[10];
	char lastData1,lastData2;
	unsigned short i,j,len;
	char num[5];
	char buf[20];
	//snprintf(buf,sizeof(buf),"susRx2Len==%d\r\n",susRx2Len);
	//SlwTrace(DEBUG,buf);
	RunMake(THIS_FILE_ID);
	
	if(susRx2Len<2){//½ÓÊÕ»º³åÇøÄÚµÄÊý¾Ý³¤¶ÈÖÁÉÙ2×Ö½Ú ¼´0x0D 0x0A		
		RunMake(THIS_FILE_ID);		
		
		return;
	}
	
	//Èç¹û³¤¶ÈÒç³ö£¬Çå¿Õ²¢ÖØÖûº³åÇø¡£
	
	if(susRx2Len>(UART2_RX_BUFFER_SIZE-2)){
		sprintf(buf,"RX2BUF====%d\r\n",susRx2Len);
		SlwTrace(INF,buf);	
		USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);  //¹Ø±Õ´®¿Ú½ÓÊÜÖжÏ	
		susRx2In=0;
		susRx2Out=0;
		susRx2Len=0;
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
		SlwTrace(DEBUG,"[Rx2Buf Over]\r\n"); 
		RunMake(THIS_FILE_ID);
		return;
	}
	
	//Ëø¶¨»·Ðλº³åÇøµ±Ç°×´Ì¬
	Rx2Len=susRx2Len;
	//Ô¤¶ÁÈ¡Ç°n×Ö½Ú 
	if(Rx2Len<4) len=Rx2Len; //2
	else len=4;
	out=susRx2Out;
	for(i=0;i<len;i++){
		preData[i]=RxBuffer2[out];
		if(++out>=UART2_RX_BUFFER_SIZE)out=0;
	}
	
	RunMake(THIS_FILE_ID);

	if(0!=ModemStrCmp(preData,"+IPD")){	
		//·Ç·þÎñÆ÷ÏÂÐÐÊý¾Ý
			//·Ç"+IPD",ÔòÖ±½ÓÕÒµ½×î½üµÄ0x0A×÷Ϊ½áÊø·û£¬¶ÁÈ¡²¢ÐγÉÒ»°üÏûÏ¢
		out=susRx2Out;
		for(i=0;i<Rx2Len;i++)
	  {
			if(RxBuffer2[out]==0x0A)break;
			if(++out>=UART2_RX_BUFFER_SIZE)out=0;
		}
		//123/n/0
		if(i<Rx2Len)
		{//ÕÒµ½ÁË0x0A£¬´Ó»·Ðλº³åÇøÖжÁÈ¡Êý¾Ý²¢¿½±´µ½ÏûÏ¢»º³åÇø£¬·¢ËÍÏûÏ¢
			len=i+1;//ÏûÏ¢³¤¶È
			RunMake(THIS_FILE_ID);
			if(len<(MODEM_AT_MSG_DATA_LEN-2))
			{
				sutAtm.MsgLen=len;
				for(i=0;i<len;i++)
				{
					sutAtm.MsgData[i]=RxBuffer2[susRx2Out];
					if(++susRx2Out>=UART2_RX_BUFFER_SIZE)susRx2Out=0;
				}
				
				sutAtm.MsgData[i]=0;//ÏûÏ¢×îºó²¹0×÷Ϊ½áÊø·û£¬·½±ã´òÓ¡
				SlwTrace(DEBUG,"[START]\r\n");
				SlwTrace(DEBUG,sutAtm.MsgData);
				SlwTrace(DEBUG,"[END]\r\n");
				
				
				//¸üÐÂg_usRx3Len£¬ÐèÒª·ÀÖ¹ÖжÏÐ޸ijåÍ»
				USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); //DISABLE UART3 RX IT	
				#if 0
				sprintf(buf,"len==%d\r\n",len);
				SlwTrace(INF,buf);	
				sprintf(buf,"surplus11==%d\r\n",susRx2Len);
				SlwTrace(INF,buf);		
				susRx2Len=susRx2Len-len;
				sprintf(buf,"surplus22==%d\r\n",susRx2Len);
				SlwTrace(INF,buf);		
        #else
				susRx2Len=susRx2Len-len;
        #endif				
				USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ENABLE UART3 RX IT
				RunMake(THIS_FILE_ID);
				
				//·¢ËÍÏûÏ¢
				sutAtm.MsgLen+=1;
				if(0 != MsgQueuePost(sutAtm.MsgData,sutAtm.MsgLen)) SlwTrace(DEBUG, "MQueue Full1");				
				return; 
			}else
			{//ÏûÏ¢¶ÓÁеÄÄÚ´æ¿é³¤¶È²»¹»£¬ÐèÒªÌØÊâ´¦Àí,ÈÓµôºóÃ沿·Ö
				
				SlwTrace(DEBUG,"66666666666666666\r\n");
				sutAtm.MsgLen=len;
				for(i=0;i<len;i++)
				{
					data=RxBuffer2[susRx2Out];
					if(i<(MODEM_AT_MSG_DATA_LEN-2)) sutAtm.MsgData[i]=data;
					if(++susRx2Out>=UART2_RX_BUFFER_SIZE)  susRx2Out=0;
				}
				sutAtm.MsgData[MODEM_AT_MSG_DATA_LEN-1]=0;//ÏûÏ¢×îºó²¹0×÷Ϊ½áÊø·û
			//¸üÐÂg_usRx3Len£¬ÐèÒª·ÀÖ¹ÖжÏÐ޸ijåÍ»
				USART_ITConfig(USART2, USART_IT_IDLE, DISABLE); //DISABLE UART2 RX IT
				susRx2In=susRx2In-len;
				USART_ITConfig(USART2, USART_IT_IDLE, ENABLE); //ENABLE UART2 RX IT
				RunMake(THIS_FILE_ID);
				//·¢ËÍÏûÏ¢
				if(0 != MsgQueuePost(sutAtm.MsgData,sutAtm.MsgLen)) SlwTrace(INF, "MQueue Full2");
				return;
			}
		}
		return;	
	}

			//·þÎñÆ÷ÏÂÐÐÊý¾Ý
	//+IPD,len:data\r\n
	if(Rx2Len<8) {
		//SlwTrace(INF,"IPD len short \r\n");
		return;//×îÉÙ9×Ö½Ú
	}
			out=susRx2Out;
			flag=0;//ÕÒµ½','µÄ±êÖ¾
			j=0;//ÓÃÀ´´æ´¢xxxµÄϱ꣬xxx·¶Î§"1" -> "9999"

		for(i=0;i<Rx2Len;i++)
		{
				data=RxBuffer2[out];
			if(','==data || ':'==data){
				if(flag<1)flag++;
				else break;
				}else if(flag==1 && j<4){
				num[j++]=data;
			}
			if(++out>=UART2_RX_BUFFER_SIZE)out=0;
		}
		
			if(i>=Rx2Len){//δÕÒµ½ÁË2¸ö','ÔòÖ±½ÓºöÂÔ
				SlwTrace(DEBUG,"<2<\r\n");
			return;
			}
	RunMake(THIS_FILE_ID);
			//ÕÒµ½ÁË2¸ö',' ¼ÆËãxxx³¤¶È
	num[j]=0;
	len=atoi(num);
	if(len<10)j=1;
	else if(len<100)j=2;
	else if(len<1000)j=3;
	else j=4;
	len=len+j+6;  //Ðè½÷É÷ÅÐ¶Ï  
			
			
	if(Rx2Len<len){
		snprintf(buf, sizeof(buf), "len:%d,%d\r\n",Rx2Len,len);
		SlwTrace(INF,buf);
		return;//³¤¶È²»¹»£¬ºöÂÔ
	}
	
	//³¤¶È¹»£¬²úÉúÏûÏ¢
	if(len<(MODEM_AT_MSG_DATA_LEN-2)){
		sutAtm.MsgLen=len;
		
		for(i=0;i<len;i++){
			sutAtm.MsgData[i]=RxBuffer2[susRx2Out];
			if(++susRx2Out>=UART2_RX_BUFFER_SIZE)susRx2Out=0;
		}
		sutAtm.MsgData[i]=0;//ÏûÏ¢×îºó²¹0×÷Ϊ½áÊø·û£¬·½±ã´òÓ¡
		
			SlwTrace(DEBUG,sutAtm.MsgData);	
			SlwTrace(INF,"\r\n");
		
		//¸üÐÂg_usRx3Len£¬ÐèÒª·ÀÖ¹ÖжÏÐ޸ijåÍ»
		USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); //DISABLE UART2 RX IT	
		
		SlwTrace(INF,"/*****************************************************/\r\n");
				sprintf(buf,"len2==%d\r\n",len);
				SlwTrace(INF,buf);	
				sprintf(buf,"surplus33==%d\r\n",susRx2Len);
				SlwTrace(INF,buf);		
				susRx2Len=susRx2Len-len;
				sprintf(buf,"surplus44==%d\r\n",susRx2Len);
				SlwTrace(INF,buf);	
		SlwTrace(INF,"/*****************************************************/\r\n");
		
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ENABLE UART2 RX IT
		//·¢ËÍÏûÏ¢
		sutAtm.MsgLen +=1;
		if(0 != MsgQueuePost(sutAtm.MsgData,sutAtm.MsgLen)) SlwTrace(DEBUG, "MQueue Full3");
	}else{
		snprintf(preData, sizeof(preData),"AtMsgBuf Over [%u]",i);
		SlwTrace(DEBUG,preData);
		return;
	}
	RunMake(THIS_FILE_ID);
	
}
 

void Uart1Send(char *txbuf,int len)
{
	int i;
	RS485_DIR_HIGH;
	for(i=0;i<len;i++){
		USART_SendData(USART1,txbuf[i]);
		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);	  
	}
	RS485_DIR_LOW;
}
void Uart2Send(char *txbuf,int len)
{
	int i;
	for(i=0;i<len;i++){
		USART_SendData(USART2,txbuf[i]);
		while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);	
	}
	
}

/*************************************************************************************
 * º¯ÊýÃû£ºUSART1_Send
 * ÃèÊö  £º´®¿Ú1·¢ËÍÊý¾Ýº¯Êý  ͨ¹ýDMAʵÏÖ
 * ÊäÈë  £ºÒª·¢ËÍÊý¾ÝµÄÊ×µØÖ·£¬·¢ËÍÊý¾ÝµÄ¸öÊý¡£·¢ËÍÊý¾ÝµÄµØÖ·ÈÎÒ⣬²¢²»Óù̶¨ÎªTxd1Buffer
 * Êä³ö  : ÎÞ
 * ¾ÙÀý  £ºUsart1_Send("Hello word!",11); Usart1_Send(Txd1Buffer,11);
 **************************************************************************************/
void USART1_Send(char *pbuffer, unsigned short size)
{
	
#if UART1_TX_USE_DMA==1
	char buf[20];
	unsigned short i;
	unsigned short len;
	char *pData;
	if(size==0)return;
	//µÈ´ýÉÏÒ»´Î·¢ËÍÍê³É
	while(g_ucUart1Sending!=0){
		os_dly_wait(1);
	}
#if	0 //Ôö¼Óʱ¼ä´Á
	sprintf((char *)TxBuffer1,"%010u: ",os_time_get());
	if(size>(UART1_TX_BUFFER_SIZE-12))len=UART1_TX_BUFFER_SIZE-12;
	else len=size;
	len+=12;
	pData=(char *)&TxBuffer1[12];
#else
	if(size>UART1_TX_BUFFER_SIZE)len=UART1_TX_BUFFER_SIZE;
	else len=size;
	pData=(char *)&TxBuffer1[0];
#endif	
	for(i=0;i<len;i++)pData[i]=pbuffer[i];
	DMA_Cmd (DMA1_Channel4,DISABLE);
	DMA1_Channel4->CMAR =  (u32)TxBuffer1;
	DMA1_Channel4->CNDTR = len;
	g_ucUart1Sending=1; 
	DMA_Cmd (DMA1_Channel4,ENABLE);  //ʹÄÜDMA,¿ªÊ¼·¢ËÍ  
#else
	
	Uart1Send(pbuffer,size);
#endif
}
void USART1_SendWaitCompleted(void)
{
#if UART1_TX_USE_DMA==1
	while(g_ucUart1Sending!=0){
		os_dly_wait(1);
	}
#endif
}
//void USART2_SendWaitCompleted(void)
//{
//#if UART2_TX_USE_DMA==1
//	while(g_ucUart2Sending!=0){
//		os_dly_wait(1);
//	}
//#endif
//}




unsigned char max_len=0;




/*********************************************************************************************
*UART1RxTxISRHandler
*´®¿Ú1Öжϴ¦Àíº¯Êý
**********************************************************************************************/
void UART1RxTxISRHandler(void)
{
	__IO unsigned long temp;
	__IO unsigned char uart_data;
	__IO static unsigned char uart_last_data=0;
	char *p;
	unsigned char i;
	
	//----½ÓÊÕÖжÏ--------
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{
		
		uart_data = USART_ReceiveData(USART1);
		
		USART_ClearITPendingBit(USART1,  USART_IT_RXNE);  //Çå³ýÖжϱêÖ¾
		
		if(g_usUart1RecvLen!=0){//ÉÏÒ»°üÊý¾Ýδ´¦ÀíÍ꣬²»´¦ÀíÐÂÀ´µÄÊý¾Ý£¬Ö±½ÓÈÓµô£¡
			rx1_ct=0;
			RxBuffer1[0]=0;
			return;
		}
		RxBuffer1[rx1_ct++]=uart_data;
		
if(AuthIng==1)
	{
		if(rx1_ct>3){
			if( RxBuffer1[0]==0xAA && RxBuffer1[1]==0xBB){
				if(rx1_ct==4) max_len=uart_data;
				else if(rx1_ct>max_len){
					rx1_ct=0;
					max_len=0;
					RxBuffer1[0]=0;
					//SlwTrace(INF,"erro len\r\n");
					return;
				}
				if(uart_last_data==0xDD && uart_data==0x55){
					g_usUart1RecvLen=rx1_ct;
					RxBuffer1[rx1_ct]=0;//ĩβ²¹0,·½±ãÓ¦Óòãµ÷ÊÔÖ±½Ó´òÓ¡ÏûÏ¢ÄÚÈÝ¡£
					//SlwTrace(INF,"ture go\r\n");
					rx1_ct=0;
				}
			}else if((RxBuffer1[0]=='R'|| RxBuffer1[0]=='A') && RxBuffer1[1]=='T'){
				
				if(uart_last_data=='\r' && uart_data=='\n'){
					g_usUart1RecvLen=rx1_ct;
					RxBuffer1[rx1_ct]=0;//ĩβ²¹0,·½±ãÓ¦Óòãµ÷ÊÔÖ±½Ó´òÓ¡ÏûÏ¢ÄÚÈÝ¡£
					rx1_ct=0;
					max_len=0;
				}
			}else{
				rx1_ct=0;
				max_len=0;
				RxBuffer1[0]=0;
			}
		}else if(rx1_ct==1 && uart_data!=0xAA && uart_data!='R' && uart_data!='A'){
			rx1_ct=0;
			max_len=0;
			RxBuffer1[0]=0;
		}else if(rx1_ct==2 && uart_data!=0xBB && uart_data!='T'){
			rx1_ct=0;
			max_len=0;
			RxBuffer1[0]=0;
		}
	}
else 
{
	if(RxBuffer1[0] == PRO_HEADER){
			if(rx1_ct>=3){
				temp=RxBuffer1[2]+3;
				if(rx1_ct >= temp){
					g_usUart1RecvLen=rx1_ct; 
					rx1_ct=0;
				}
			}
		}else{
			rx1_ct=0;
			RxBuffer1[0]=0;
		}
}
		if(rx1_ct>=(UART1_RX_BUFFER_SIZE-1)){//Êý¾Ý³¬¹ý»º³åÇøµÄÊý¾Ý£¬¹ýÂ˲»´¦Àí
			rx1_ct=0;
			max_len=0;
			g_usUart1RecvLen=0;
		}	
		uart_last_data=uart_data;	
	}
  //---Òì³£ÖжÏ---
	if(USART_GetFlagStatus(USART1,USART_FLAG_ORE)==SET)
	{
		USART_ReceiveData(USART1);    //
		USART_ClearFlag(USART1,USART_FLAG_ORE); // 
	}
	
}

/*******************************************************************************
Uart1Init
mcu<->PC
*******************************************************************************/
void Uart1Init(void)
{ 
	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure; 

	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1,ENABLE);
	/*
	*  USART1_TX -> PA9 , USART1_RX ->	PA10 , RS485_DIR ->	PA8
	*/				
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;	         
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);		   

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;	         
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);		
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;	        
	GPIO_InitStructure.GPIO_Mode =GPIO_Mode_IN_FLOATING;// GPIO_Mode_IPU;//GPIO_Mode_IN_FLOATING;  
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	USART_InitStructure.USART_BaudRate =115200;// 9600;//sutProductPara.UartBaud;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode =  USART_Mode_Tx|USART_Mode_Rx;
	USART_Init(USART1, &USART_InitStructure); 
	USART_Cmd(USART1, ENABLE);

	USART_ClearFlag(USART1,USART_FLAG_TC);
	USART_ITConfig(USART1, USART_IT_TXE,  DISABLE); //ENABLE DISABLE
	USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //ENABLE DISABLE
	USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
	USART_DMACmd(USART1,USART_DMAReq_Rx,DISABLE); 	//ʹÄÜUSART1µÄ½ÓÊÕDMAÇëÇóENABLE
	USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE); 	//ʹÄÜUSART1µÄ·¢ËÍDMAÇëÇó
	Uart1DMAInit();
	rx1_ct=0;
	g_usUart1RecvLen=0;
	g_ucUart1Sending=0;
	g_ucUART1RxMode=0;
	RS485_DIR_LOW;
	Uart1RxEnable(1);
	
}
void Uart1RxEnable(int en)
{
	static unsigned char sucEn=0;
	USART_InitTypeDef USART_InitStructure; 
	if(sucEn!=en)sucEn=en;
	else return;
	
	if(en){
		USART_InitStructure.USART_BaudRate =115200;//sutProductPara.UartBaud;
		USART_InitStructure.USART_WordLength = USART_WordLength_8b;
		USART_InitStructure.USART_StopBits = USART_StopBits_1;
		USART_InitStructure.USART_Parity = USART_Parity_No;
		USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
		USART_InitStructure.USART_Mode =  USART_Mode_Rx | USART_Mode_Tx;// 
		USART_Init(USART1, &USART_InitStructure); 
		USART_Cmd(USART1, ENABLE);
		USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
	//	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);	//USART_IT_IDLE USART_IT_RXNE
		//USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE); 	//ʹÄÜUSART1µÄ½ÓÊÕDMAÇëÇóENABLE
		//DMA_Cmd(DMA1_Channel5, ENABLE); //ʹÄÜͨµÀ   
	}else{
		USART_InitStructure.USART_BaudRate =115200;// 115200;
		USART_InitStructure.USART_WordLength = USART_WordLength_8b;
		USART_InitStructure.USART_StopBits = USART_StopBits_1;
		USART_InitStructure.USART_Parity = USART_Parity_No;
		USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
		USART_InitStructure.USART_Mode =  USART_Mode_Tx;// 
		USART_Init(USART1, &USART_InitStructure); 
		USART_Cmd(USART1, ENABLE);
		USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
		USART_DMACmd(USART1,USART_DMAReq_Rx,DISABLE); 	//ʹÄÜUSART1µÄ½ÓÊÕDMAÇëÇóENABLE
		//DMA_Cmd(DMA1_Channel5, DISABLE); //ʹÄÜͨµÀ   
	}
}
/***************************************************************************
Uart2Init
Use for MainBoard
****************************************************************************/
void Uart2Init(void)
{

	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure; 
	memset(RxBuffer2,0,sizeof(RxBuffer2));
	susRx2In=0;                              
	susRx2Len=0;
	susRx2Out=0;
	//³õʼ»¯½ÓÊÕÏûÏ¢¶ÓÁÐ
	MsgQueueSet();
	/*ʹÄÜ´®¿Ú2ʹÓõÄGPIOʱÖÓ*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	/*ʹÄÜ´®¿Ú2ʱÖÓ*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);  
          
	/*´®¿Ú2 RX¹Ü½ÅÅäÖÃ*/
	/* Configure USART2 Rx as input floating */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);  

	/*´®¿Ú2 TX¹Ü½ÅÅäÖÃ*/ 
	/* Configure USART2 Tx as alternate function push-pull */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);  

	USART_InitStructure.USART_BaudRate = 115200;//57600;//115200;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART2, &USART_InitStructure); 

  USART_ClearFlag(USART2,USART_FLAG_TC);
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
	USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);	//USART_IT_IDLE USART_IT_RXNE
	USART_DMACmd(USART2,USART_DMAReq_Tx,DISABLE);
	USART_DMACmd(USART2,USART_DMAReq_Rx,DISABLE);
	USART_Cmd(USART2, ENABLE);

	//USART_DMACmd(USART2,USART_DMAReq_Rx,ENABLE); //ʹÄÜUSART1µÄ½ÓÊÕDMAÇëÇó
	//Uart2DMAInit();
}


/***********************************************************************************
*
************************************************************************************/
void SlwTrace(TRACE_TYPE type,char *buf)
{
	int len;
	//if(!sutProductPara.Debug) return;
#if UART1_TX_USE_DMA==0
	len=strlen(buf);
	//if(len>256)len=256;
	Uart1Send(buf,len);	
#else
	len=strlen(buf);
	if(len>512)len=512;
	if(len>UART1_TX_BUFFER_SIZE)len=UART1_TX_BUFFER_SIZE;
	USART1_Send(buf,len);
#endif
}

/*******************************************************************************
ComSelect
µ÷ÊÔ¿ÚÑ¡Ôñ
#define COM_SEL_MCU 	0
#define COM_SEL_GPS 	1
#define COM_SEL_MODEM 	2

*******************************************************************************/
void ComSelect(unsigned char sel)
{
	switch(sel)
	{
		case COM_SEL_MCU:
			SlwTrace(INF,"Debug COM selcet to MCU!\r\n");
			g_ucUARTSel=sel;	
			break;
		case COM_SEL_MODEM:
			SlwTrace(INF,"Debug COM selcet to Modem!\r\n");
			g_ucUARTSel=sel;
			//os_tsk_delete(idModemTask);
			//os_tsk_delete(idWLanTask);
			break;
	}
}
/**************************************************************************
* USART1_SendOK_IQ
* ´®¿Ú1·¢ËÍÊý¾ÝÍê±Ïºó£¬»áµ÷ÓõÄÖжϺ¯Êý£¬½«·¢ËͱêÖ¾ÖÃ0
* ´Ëº¯ÊýÐèÔÚstm32f10x_it.c µÄ DMA1_Channel4_IRQHandler()Öб»µ÷ÓÃ
***************************************************************************/
void USART1_SendOK_IQ(void)
{
	//ÅжÏÊÇ·ñΪDMA·¢ËÍÍê³ÉÖжÏ
	if(DMA_GetFlagStatus(DMA1_FLAG_TC4)==SET) 
	{  
        DMA_ClearITPendingBit(DMA1_IT_GL4);
        DMA_ClearFlag(DMA1_FLAG_TC4);
        DMA_Cmd (DMA1_Channel4,DISABLE);
        g_ucUart1Sending = 0; //Êý¾Ý·¢ËÍÍê±Ï       											 
	}      
	//printf("USART1_SendOK_IQ\r\n");
}


#ifdef __GNUC__
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
     set to 'Yes') calls __io_putchar() */
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */


/**
  * @brief  Retargets the C library printf function to the USART.
  * @param  None
  * @retval None
  */
PUTCHAR_PROTOTYPE
{
	RS485_DIR_HIGH;
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART */
  USART_SendData(USART1, (uint8_t) ch);

  /* Loop until the end of transmission */
  while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
  {
	
	}
	RS485_DIR_LOW;
  return ch;
}