HS121L/HS121L-IAP/USER/ucCos_App/Serial.c

/*******************************************************************************************
 * File Name: Serial.c
 * Function Describe:device for serial	
 * Relate Module:
 * Explain:
	接收采用中断方式
	UART1: 连接尾插，用于与PC相连	  另外，printf映射到UART1
	UART3: 连接Modem
	

 * Writer:  ShiLiangWen
 * Date:	2015.1.20
********************************************************************************************/
#include "Serial.h"
#include "stm32f10x_dma.h"
#include "includes.h"

#define USART1_DR_Base  0x40013804   
#define USART2_DR_Base  0x40004404 
#define USART3_DR_Base (u32)&USART3->DR 

unsigned char g_ucUARTSel=0;//0--MCU  1--Modem  2--GPS


//UART1 Trace
unsigned char RxBuffer1[UART1_RX_BUFFER_SIZE];
unsigned char TxBuffer1[UART1_TX_BUFFER_SIZE];
//unsigned char g_ucUart1Received=0;//接受到一包数据标志位
//unsigned char g_ucUart1Sending=0;//仍有数据待发送标志
static unsigned short rx1_ct=0,rx1_ct_max=0,rx1_len=0;
//static unsigned short tx1_ct=0,tx1_len=0;

//UART2 用于与GPS通讯
//unsigned char RxBuffer2[UART2_RX_BUFFER_SIZE];
//unsigned char TxBuffer2[UART2_TX_BUFFER_SIZE];
//unsigned char g_ucUart2Received=0;//接受到一包数据标志位
//unsigned char g_ucUart2Sending=0;//仍有数据待发送标志
//static unsigned short rx2_ct=0,rx2_ct_max=0,rx2_len=0;
//static unsigned short tx2_ct=0,tx2_len=0;
//UART3 用于与MODEM通讯
unsigned char RxBuffer3[UART3_RX_BUFFER_SIZE];
unsigned char TxBuffer3[UART3_TX_BUFFER_SIZE];
//unsigned char g_ucUart3Received=0;//接受到一包数据标志位
//unsigned char g_ucUart3Sending=0;//仍有数据待发送标志
static unsigned short rx3_ct=0,rx3_ct_max=0,rx3_len=0;
//static unsigned short tx3_ct=0,tx3_len=0;
static unsigned short datalen;


/********************************************************************
*Uart1DMAInit
*串口1 DMA设置 
*串口1 发送必须用通道4，接收必须用通道5
*********************************************************************/
void Uart1DMAInit(void)
{	
	NVIC_InitTypeDef NVIC_InitStructure;
	DMA_InitTypeDef DMA_InitStructure;
	//启动DMA时钟
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	//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 = 3;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);//中断设置
	DMA_Cmd(DMA1_Channel4, DISABLE); //等到需要发送的时候再使能
	      
	//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); //使能通道                                            
}

/********************************************************************
*Uart2DMAInit
*串口2 DMA设置 
*串口2接收必须使用DMA通道6
*********************************************************************/
void Uart2DMAInit(void)
{	
//	NVIC_InitTypeDef NVIC_InitStructure;
	DMA_InitTypeDef DMA_InitStructure;
	//启动DMA时钟
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	DMA_DeInit(DMA1_Channel6);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART2->DR);//外设地址
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer2;//内存地址
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//DMA传输方向单向
	DMA_InitStructure.DMA_BufferSize = UART2_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_Medium;	//设置DMA的优先级别
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//设置DMA的2个memory中的变量互相访问
	DMA_Init(DMA1_Channel6,&DMA_InitStructure);	  
	DMA_Cmd(DMA1_Channel6, ENABLE); 	//使能通道                                             
}
/********************************************************************
*Uart3DMAInit
*串口3 DMA设置 
*串口3 发送必须用通道2，接收必须用通道3
*********************************************************************/
void Uart3DMAInit(void)
{	
	NVIC_InitTypeDef NVIC_InitStructure;
	DMA_InitTypeDef DMA_InitStructure;
	//启动DMA时钟
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	//DMA 通道2用于UART3 TX
	DMA_DeInit(DMA1_Channel2);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART3->DR);//外设地址
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer3;//内存地址
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;//DMA传输方向单向
	DMA_InitStructure.DMA_BufferSize = UART3_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_High;	//设置DMA的优先级别
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//设置DMA的2个memory中的变量互相访问
	DMA_Init(DMA1_Channel2,&DMA_InitStructure);
	//DMA中断设置
	NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	DMA_ITConfig(DMA1_Channel2,DMA_IT_TC,ENABLE);//中断设置
	DMA_Cmd(DMA1_Channel2, DISABLE); //等到需要发送的时候再使能
	      
	//DMA 通道3用于UART3 RX
	DMA_DeInit(DMA1_Channel3);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART3->DR);//外设地址
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer3;//内存地址
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//DMA传输方向单向
	DMA_InitStructure.DMA_BufferSize = UART3_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_VeryHigh;	//设置DMA的优先级别
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//设置DMA的2个memory中的变量互相访问
	DMA_Init(DMA1_Channel3,&DMA_InitStructure);  
	DMA_Cmd(DMA1_Channel3, ENABLE); //使能通道                                              
}

/*********************************************************************************************
*UART3RxTxISRHandler
*串口3中断处理函数
**********************************************************************************************/
void UART3RxTxISRHandler(void)
{
	__IO unsigned char uart_data;
	static __IO unsigned char uart_last_data;
	char *p;
	int i;
	int temp;
	//----接收中断--------
	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
	{
		uart_data = USART_ReceiveData(USART3); // Read one byte from the receive data register
		
		if(g_ucUARTSel==COM_SEL_MODEM){
			USART_SendData(USART1, uart_data);
			USART_ClearITPendingBit(USART3,  USART_IT_RXNE);  //清除中断标志
			return;
		}
		//MCU 处理Modem
	    RxBuffer3[rx3_ct++]= uart_data;
		if(rx3_ct>=UART3_RX_BUFFER_SIZE) rx3_ct=0;
		if(uart_last_data==0x0d && uart_data==0x0a){ //收到回车换行符
			if(rx3_ct<2){ //独立的回车换行直接忽略
				rx3_ct=0;  
			}else{
				//先判断是否+ZIPRECV，如果是则需特殊处理
				datalen=0;
				if(RxBuffer3[0]=='+' && RxBuffer3[7]=='V' && RxBuffer3[1]=='Z' && RxBuffer3[3]=='P' && RxBuffer3[5]=='E')	{	   //+ZIPRECV
					//获取ZIPRECV接收数据长度
					if(rx3_ct>11 && RxBuffer3[11]>0x2f && RxBuffer3[11]<0x3a){
						if(RxBuffer3[12]>0x2f && RxBuffer3[12]<0x3a){
							if(RxBuffer3[13]>0x2f && RxBuffer3[13]<0x3a){
								datalen=100*(RxBuffer3[11]-0x30);
								datalen+=10*(RxBuffer3[12]-0x30);
								datalen+=RxBuffer3[13];
								datalen+=15;
							}else{
								datalen=10*(RxBuffer3[11]-0x30);
								datalen+=(RxBuffer3[12]-0x30);
								datalen+=14;
							}
						}else{
							datalen= RxBuffer3[11]-0x30;
							datalen+=13;

						}
					}
				}	
				//非+ZIPRECV包，或大于+ZIPRECV包长的包，则认为完成一包数据接收
				if(rx3_ct>datalen){
					//以'+'开头的才处理	 或 OK
					if(RxBuffer3[0]=='+' || (RxBuffer3[0]=='O' && RxBuffer3[1]=='K')  ){
//						//数据拷贝
//						p=&ModemMsgBuf[ModemMsgBufIndex][0];
//						for(i=0;i<rx3_ct;i++){
//							p[i]=RxBuffer3[i];
//						}
//						ModemMsgBuf[ModemMsgBufIndex][rx3_ct]=0;
//						//发消息
//						OSQPost(ModemQ, (void *)&ModemMsgBuf[ModemMsgBufIndex][0]);
//						if(++ModemMsgBufIndex>=MODEM_Q_NUM)ModemMsgBufIndex=0;
					}
					rx3_ct=0;
				}
			}	
		}
//		else if(uart_last_data==0x0a && uart_data=='>'){ //GPRS 才有
//			if(RxBuffer3[2]=='+' && RxBuffer3[3]=='Z' && RxBuffer3[4]=='I' && RxBuffer3[5]=='P' \
//				&& RxBuffer3[6]=='S' && RxBuffer3[7]=='E' && RxBuffer3[8]=='N'&& RxBuffer3[9]=='D'){//AT+ZIPSEND
//				ModemMsgBuf[ModemMsgBufIndex][0]='>';
//				ModemMsgBuf[ModemMsgBufIndex][1]=0x20;
//				OSQPost(ModemQ, (void *)&ModemMsgBuf[ModemMsgBufIndex][0]);	
//				if(++ModemMsgBufIndex>=MODEM_Q_NUM)ModemMsgBufIndex=0;
//				rx3_ct=0;
//			}			
//		}
		uart_last_data = uart_data; 
		USART_ClearITPendingBit(USART3,  USART_IT_RXNE);  //清除中断标志 
		
	}
	//接收空闲中断
	if(USART_GetITStatus(USART3, USART_IT_IDLE) != RESET){ 	
		//printf("UART3_IDLE\r\n");
		temp = USART3->SR;//先读SR,再读DR
    	temp = USART3->DR;//方可清USART_IT_IDLE标志 
		temp = UART3_RX_BUFFER_SIZE -  DMA1_Channel3->CNDTR;
		DMA_Cmd(DMA1_Channel3,DISABLE);
		//处理数据
		if(temp>3){
			//拷贝数据
//			p=&ModemMsgBuf[ModemMsgBufIndex][0];
//			for(i=0;i<temp;i++){
//				p[i]=RxBuffer3[i];
//			}
//			ModemMsgBuf[ModemMsgBufIndex][temp]=0;
//			//发消息
//			OSQPost(ModemQ, (void *)&ModemMsgBuf[ModemMsgBufIndex][0]);
//			if(++ModemMsgBufIndex>=MODEM_Q_NUM)ModemMsgBufIndex=0;	
		}
		//重设DMA传输数据长度
		DMA1_Channel3->CNDTR = UART3_RX_BUFFER_SIZE;
    	//打开DMA
		DMA_Cmd(DMA1_Channel3,ENABLE);
	}
}

/******************************************************************************
*
*******************************************************************************/
unsigned char Uart1GetPack(unsigned char *pCmd,unsigned char *pData)
{
	unsigned char datalen;
	unsigned short checksum;
	int i,j;
	//引导码检查
	if(RxBuffer1[0]!=UART_HEAD0 || RxBuffer1[1]!=UART_HEAD1)return 0xff;
	//地址码检查
	if(RxBuffer1[2]!=0 && RxBuffer1[2]!=0)return 0xff;
	//命令码检查
	if(RxBuffer1[3]==0)return 0xff;//命令不能为0
	//获取长度
	datalen=RxBuffer1[4];
	//校验码
	checksum=chksum(0,RxBuffer1,datalen+5);
	//校验码检查
	if(RxBuffer1[datalen+5]!=(checksum/256) || RxBuffer1[datalen+6]!=(checksum%256))return 0xff;
	//
	*pCmd=RxBuffer1[3];
	j=5;
	for(i=0;i<datalen;i++){
		pData[i]=RxBuffer1[j++];
	}
	return datalen;
}
 
   /********************************************************************************
 *Uart1Send
 *串口1启动发送
 *********************************************************************************/
void Uart1Send(void)
{
 	//if(tx1_len==0 || tx1_len>UART1_BUFFER_SIZE)return;
	//启动新一轮发送
	//g_ucUart1Sending=tx1_len;
	//tx1_ct=0;
	//发送
	//USART_ClearITPendingBit(USART2,  USART_IT_TXE);//Clean interrupt flag 
	//USART_ITConfig(USART2, USART_IT_TXE, ENABLE);
	for(tx1_ct=0;tx1_ct<tx1_len;tx1_ct++){
		USART_SendData(USART1, TxBuffer1[tx1_ct]);	
		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
	}
}
/*********************************************************************************************
*UART1RxTxISRHandler
*串口1中断处理函数
**********************************************************************************************/
void UART1RxTxISRHandler(void)
{
	__IO unsigned char uart_data;
	//----接收中断--------
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{
		uart_data = USART_ReceiveData(USART1);
		if(g_ucUart1Received){//上一批没处理，不接受新数据
			rx1_ct=0;
		}else if(rx1_ct==0 && uart_data==UART_HEAD0){
   				RxBuffer1[rx1_ct++]=uart_data;
   		}else if(rx1_ct==1 && uart_data==UART_HEAD1){
   			RxBuffer1[rx1_ct++]=uart_data;
   			rx1_ct_max=6;//先默认最大长度
   		}else if(rx1_ct>1){
   			RxBuffer1[rx1_ct++]=uart_data;
   			if(rx1_ct==5){
   				rx1_ct_max=uart_data+7;//更新数据长度
				if(rx1_ct_max>(UART1_RX_BUFFER_SIZE-1))rx1_ct_max=(UART1_RX_BUFFER_SIZE-1);
   			}else if(rx1_ct>=rx1_ct_max){
   				g_ucUart1Received=1;
				rx1_ct=0;
   			}
   		}else{
   			rx1_ct=0;
   		}
		USART_ClearITPendingBit(USART1,  USART_IT_RXNE);  //清除中断标志
	}
}

/***********************************************************************
*
************************************************************************/
void UART2RxTxISRHandler(void)                               
{   
	uint32_t temp = 0;
	uint16_t i = 0;
	char *p;
	char *msg;
	__IO unsigned char uart_data;
	__IO static unsigned char uart_last_data=0;
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET){
		uart_data = USART_ReceiveData(USART2);
		if(g_ucUARTSel==COM_SEL_GPS){
			USART_SendData(USART1, uart_data);
			USART_ClearITPendingBit(USART2,  USART_IT_RXNE);  //Clean interrupt flag		
		}else{
			RxBuffer2[rx2_ct]= uart_data;
			if(RxBuffer2[0]!='$')rx2_ct=0;
			else rx2_ct++;
			if(rx2_ct>=UART2_RX_BUFFER_SIZE) rx2_ct=0;
			if(uart_last_data==0x0d && uart_data==0x0a){ //收到回车换行符
				if(RxBuffer2[1]=='G' && RxBuffer2[3]=='R' && RxBuffer2[5]=='C'){//$GPRMC
//					//拷贝数据
//					p=&GpsMsgBuf[GpsMsgBufIndex][0];
//					for(i=0;i<rx2_ct;i++){
//						p[i]= RxBuffer2[i];
//					}
//					GpsMsgBuf[GpsMsgBufIndex][rx2_ct] = 0;
//					//Send message
//					OSQPost(GpsQ, (void *)&GpsMsgBuf[GpsMsgBufIndex][0]);
//					if(++GpsMsgBufIndex>=GPS_Q_NUM)GpsMsgBufIndex=0;	
				}
				rx2_ct=0;
			}
			USART_ClearITPendingBit(USART2,  USART_IT_RXNE);  //Clean interrupt flag		
		}		
		uart_last_data=uart_data;
	} 
} 
/*******************************************************************************
 校验
 *******************************************************************************/
unsigned short chksum(unsigned short sum, unsigned char *data, unsigned short len)
{
  unsigned short t;
  unsigned char *dataptr;
  unsigned char *last_byte;

  dataptr = data;
  last_byte = data + len - 1;
  
  while(dataptr < last_byte) {	/* At least two more bytes */
    t = (dataptr[0] << 8) + dataptr[1];
    sum += t;
    if(sum < t) {
      sum++;		/* carry */
    }
    dataptr += 2;
  }
  
  if(dataptr == last_byte) {
    t = (dataptr[0] << 8) + 0;
    sum += t;
    if(sum < t) {
      sum++;		/* carry */
    }
  }

  /* Return sum in host byte order. */
  return sum;
}
/*******************************************************************************
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");
			SlwTraceWaitCompleted();
			g_ucUARTSel=sel;
			USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //ENABLE DISABLE
			USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);	//USART_IT_IDLE USART_IT_RXNE
			USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);
			USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);

			USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); //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,ENABLE);

			
			break;
		case COM_SEL_GPS:
			SlwTrace(INF,"Debug COM selcet to GPS!\r\n");
			SlwTraceWaitCompleted();
			g_ucUARTSel=sel;
			USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
			USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
			USART_DMACmd(USART1,USART_DMAReq_Tx,DISABLE);
			USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);

			USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
			USART_ITConfig(USART2, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
			USART_DMACmd(USART2,USART_DMAReq_Tx,DISABLE);
			USART_DMACmd(USART2,USART_DMAReq_Rx,DISABLE);
			break;
		case COM_SEL_MODEM:
			SlwTrace(INF,"Debug COM selcet to Modem!\r\n");
			SlwTraceWaitCompleted();
			g_ucUARTSel=sel;
			USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
			USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
			USART_DMACmd(USART1,USART_DMAReq_Tx,DISABLE);
			USART_DMACmd(USART1,USART_DMAReq_Rx,DISABLE);
			DMA_Cmd(DMA1_Channel4, DISABLE); //等到需要发送的时候再使能
			DMA_Cmd(DMA1_Channel5, DISABLE); //等到需要发送的时候再使能
			
			USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
			USART_ITConfig(USART3, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
			USART_DMACmd(USART3,USART_DMAReq_Tx,DISABLE);
			USART_DMACmd(USART3,USART_DMAReq_Rx,DISABLE);
			DMA_Cmd(DMA1_Channel2, DISABLE); //等到需要发送的时候再使能
			DMA_Cmd(DMA1_Channel3, DISABLE); //等到需要发送的时候再使能
			
			break;
	}
}
/*******************************************************************************
Uart1Init
Use for Trace 
*******************************************************************************/
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
	*/				
	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_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;// 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(USART1, &USART_InitStructure); 
	USART_Cmd(USART1, ENABLE);
	/* Configure the NVIC Preemption Priority Bits */  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	/* Enable the USART1 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	USART_ClearFlag(USART1,USART_FLAG_TC);
	USART_ITConfig(USART1, USART_IT_TXE,  DISABLE); //ENABLE DISABLE
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
	USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);	//USART_IT_IDLE USART_IT_RXNE
	USART_DMACmd(USART1,USART_DMAReq_Rx,DISABLE); 	//使能USART1的接收DMA请求
	USART_DMACmd(USART1,USART_DMAReq_Tx,DISABLE); 	//使能USART1的发送DMA请求
//	Uart1DMAInit();
					
}
/***************************************************************************
Uart2Init
Use for MainBoard
****************************************************************************/
void Uart2Init(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure; 

	/*使能串口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 = 9600;//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); 

	/* Configure the NVIC Preemption Priority Bits */  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	/* Enable the USART2 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
    USART_ClearFlag(USART2,USART_FLAG_TC);
	USART_ITConfig(USART2, USART_IT_TXE,  DISABLE); //ENABLE DISABLE
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
	USART_ITConfig(USART2, USART_IT_IDLE, DISABLE);//USART_IT_IDLE USART_IT_RXNE
	USART_Cmd(USART2, ENABLE);
	//USART_DMACmd(USART2,USART_DMAReq_Rx,ENABLE); //使能USART1的接收DMA请求
	//Uart2DMAInit();
}

/***************************************************************************
Uart3Init
****************************************************************************/
void Uart3Init(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure; 

	/*使能串口3使用的GPIO时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	/*使能串口3时钟*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);  
          
	/*串口3 RX管脚配置*/
	/* Configure USART3 Rx as input floating */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//GPIO_Mode_IPU;//GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);  

	/*串口3 TX管脚配置*/ 
	/* Configure USART2 Tx as alternate function push-pull */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//GPIO_Mode_AF_PP;
	GPIO_Init(GPIOB, &GPIO_InitStructure);  

	USART_InitStructure.USART_BaudRate = 115200;//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(USART3, &USART_InitStructure); 

	/* Configure the NVIC Preemption Priority Bits */  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	/* Enable the USART3 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	USART_ClearFlag(USART3,USART_FLAG_TC);
	USART_ITConfig(USART3, USART_IT_TXE,  DISABLE); //ENABLE DISABLE
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); //ENABLE DISABLE
	USART_ITConfig(USART3, USART_IT_IDLE, DISABLE);//USART_IT_IDLE USART_IT_RXNE
	USART_Cmd(USART3, ENABLE);
	USART_DMACmd(USART3,USART_DMAReq_Tx,DISABLE); //使能USART1的DMA请求
	USART_DMACmd(USART3,USART_DMAReq_Rx,DISABLE); //使能USART1的DMA请求
	//Uart3DMAInit();
}

void UartSetPinLowPower(void)
{
//	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
//	USART_InitTypeDef USART_InitStructure; 	
	//串口2 
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);  
	GPIOA->BRR = (GPIO_Pin_2|GPIO_Pin_3);
	//串口3 
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);  
	GPIOB->BRR = (GPIO_Pin_10|GPIO_Pin_11);
}

/********************************************************************************
 *Uart3Send
 *串口3启动发送
 *********************************************************************************/
void Uart3Send(void)
 {
 	if(tx3_len==0 || tx3_len>UART3_TX_BUFFER_SIZE)return;
//	//启动新一轮发送
//	g_ucUart2Sending=tx2_len;
//	tx2_ct=0;
//	//发送
//	//USART_ClearITPendingBit(USART2,  USART_IT_TXE);  //清除中断标志 
//	USART_ITConfig(USART2, USART_IT_TXE, ENABLE);
	for(tx3_ct=0;tx3_ct<tx3_len;tx3_ct++){
		USART_SendData(USART3, TxBuffer3[tx3_ct]);	
		while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
	}

}

#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
{
  /* 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)
  {}

  return ch;
}

/**************************************************************************
* 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; //数据发送完毕       											 
	}      
}
/**************************************************************************
* USART3_SendOK_IQ
* 串口3发送数据完毕后，会调用的中断函数，将发送标志置0
* 此函数需在stm32f10x_it.c 的 DMA1_Channel2_IRQHandler()中被调用
***************************************************************************/
void USART3_SendOK_IQ(void)
{
	//判断是否为DMA发送完成中断
	if(DMA_GetFlagStatus(DMA1_FLAG_TC2)==SET) 
	{  
        DMA_ClearITPendingBit(DMA1_IT_GL2);
        DMA_ClearFlag(DMA1_FLAG_TC2);
        DMA_Cmd (DMA1_Channel2,DISABLE);
        g_ucUart3Sending = 0; //数据发送完毕       											 
	}      
}


/*
 * 函数名：USART1_Send
 * 描述  ：串口1发送数据函数
 * 输入  ：要发送数据的首地址，发送数据的个数。发送数据的地址任意，并不用固定为Txd1Buffer
 * 输出  : 无
 * 举例         ：Usart1_Send("Hello word!",11); Usart1_Send(Txd1Buffer,11);
 */

void USART1_Send(char *pbuffer, int size)
{
	if(size<=0)return;
	DMA_Cmd (DMA1_Channel4,DISABLE);
	DMA1_Channel4->CMAR =  (u32)pbuffer;
	DMA1_Channel4->CNDTR = size;
	DMA_Cmd (DMA1_Channel4,ENABLE);                                        //使能DMA,开始发送
   g_ucUart1Sending=1;                                                                                //数据发送中                                                                             //灯亮
}
/*
 * 函数名：USART2_Send
 * 描述  ：串口1发送数据函数
 * 输入  ：要发送数据的首地址，发送数据的个数。发送数据的地址任意，并不用固定为Txd1Buffer
 * 输出  : 无
 * 举例         ：Usart1_Send("Hello word!",11); Usart1_Send(Txd1Buffer,11);
 */

void USART3_Send(char *pbuffer, int size)
{
	if(size<=0)return;
	DMA_Cmd (DMA1_Channel2,DISABLE);
	DMA1_Channel2->CMAR =  (u32)pbuffer;
	DMA1_Channel2->CNDTR = size;
	DMA_Cmd (DMA1_Channel2,ENABLE);                                        //使能DMA,开始发送
	g_ucUart3Sending=1;                                                                                //数据发送中                                                                             //灯亮
}
/***********************************************************************************
*
************************************************************************************/
void SlwTrace(TRACE_TYPE type,char *buf)
{
	int len;
	char *p=buf;
	char d;
#ifndef SLW_DEBUG
	if(type==DEBUG)return;
#endif

	if(g_ucUARTSel!=COM_SEL_MCU)return;

	//等待上一次发送完成
	while(g_ucUart1Sending){
	//	OSTimeDly(1);
	}

	len=0;
	if(0==*p)return;
    while(0!=*p && len<UART1_TX_BUFFER_SIZE){
		TxBuffer1[len]=(unsigned char)(*p);
		len++;
		p++;
	}
	if(len)USART1_Send(TxBuffer1,len);
}
void SlwTraceWaitCompleted()
{
	while(g_ucUart1Sending){
		//OSTimeDly(1);
	}	
}