HS191L/IAP-191L-161L/IAP_HS191L-HS161L/USER/Serial.c

/*******************************************************************************************
 * File Name: Serial.c
 * Function Describe:device for serial	
 * Relate Module:
 * Explain:
	接收采用中断方式
	UART1: 连接尾插，用于与PC相连	  另外，printf映射到UART1
	UART2: 连接GPS
	UART3: 连接Modem
	全局变量g_ucUARTSel 调试选择控制，决定了3个串口的转发关系,其值通过以下3个宏控分别代表：
	COM_SEL_MCU   正常使用不转发,尾插用于MCU打印LOG或 MCU软件升级
	COM_SEL_GPS	  UART1<-->UART2,尾插用于GPS LOG打印
	COM_SEL_MODEM UART1<-->UART3,尾插用于MODEM AT momand 或模块软件升级
 * 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;//仍有数据待发送标志
unsigned short rx1_ct=0,rx1_len=0;
unsigned short tx1_ct=0,tx1_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;



/********************************************************************
*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); //使能通道                                        
}


/********************************************************************
*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;
	__IO unsigned short datalen;
	__IO int i;
	__IO int temp;
	static __IO unsigned char uart_last_data;
	__IO char *p;
	//----接收中断--------
	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
	{
		uart_data = USART_ReceiveData(USART3); // Read one byte from the receive data register
		//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{
				//先判断是否+ZIPRECVU，如果是则需特殊处理
				datalen=0;
				if(RxBuffer3[0]=='+' && RxBuffer3[7]=='V' && RxBuffer3[1]=='Z' && RxBuffer3[3]=='P' && RxBuffer3[5]=='E')	{//+ZIPRECVU
					//获取ZIPRECV接收数据长度  +ZIPRECVU:0,1024,xxxx/r/n
					if(RxBuffer3[12]>0x2f && RxBuffer3[12]<0x3a){
						if(RxBuffer3[13]>0x2f && RxBuffer3[13]<0x3a){
							if(RxBuffer3[14]>0x2f && RxBuffer3[14]<0x3a){
								if(RxBuffer3[15]>0x2f && RxBuffer3[15]<0x3a){
									datalen=1000*(RxBuffer3[12]-0x30);
									datalen+=100*(RxBuffer3[13]-0x30);
									datalen+=10*(RxBuffer3[14]-0x30);
									datalen+=(RxBuffer3[15]-0x30);
									datalen+=19;	
								}else{
									datalen=100*(RxBuffer3[12]-0x30);
									datalen+=10*(RxBuffer3[13]-0x30);
									datalen+=(RxBuffer3[14]-0x30);
									datalen+=18;
								}
							}else{
								datalen=10*(RxBuffer3[12]-0x30);
								datalen+=(RxBuffer3[13]-0x30);
								datalen+=17;
							}
						}else{
							datalen= RxBuffer3[12]-0x30;
							datalen+=16;

						}
					}
				}	
				//非+ZIPRECVU包，或大于+ZIPRECV包长的包，则认为完成一包数据接收
				if(rx3_ct>=datalen && rx3_ct>0){
					//以'+'开头的才处理	 或 OK
					if((RxBuffer3[0]=='+') || (RxBuffer3[0]=='O' && RxBuffer3[1]=='K')){
						//发消息
						MsgQueuePost(&ModemMsgQueue,(char *)RxBuffer3,rx3_ct);
					}
					rx3_ct=0;
				}
			}	
		}
		uart_last_data = uart_data; 
		USART_ClearITPendingBit(USART3,  USART_IT_RXNE);  //清除中断标志 
		
	}
	if(USART_GetFlagStatus(USART3,USART_FLAG_ORE)==SET)
	{
		assert_param(IS_USART_CLEAR_FLAG(USART_FLAG_ORE));
		USART_ReceiveData(USART3);    //
		USART_ClearFlag(USART3,USART_FLAG_ORE); // 
	}
*/
}
 


/********************************************************************************
 *Uart1Send
 *串口1启动发送
 *********************************************************************************/
/*
void Uart1Send(char *txbuf,int len)
{
	int i;
	unsigned char data;
	unsigned char last_data=~UART_TRANSFORM;
	//Send Head
	USART_SendData(USART1, UART_HEAD);	
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);

	for(i=0;i<len;i++){
		data=  txbuf[i];
		if(UART_TRANSFORM == data){
			USART_SendData(USART1,UART_TRANSFORM );
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
			USART_SendData(USART1,0x01 );
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);	
		}else if(UART_HEAD == data){
			USART_SendData(USART1,UART_TRANSFORM);
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
			USART_SendData(USART1,0x02 );
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
		}else if(UART_END == data){
			USART_SendData(USART1,UART_TRANSFORM);
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
			USART_SendData(USART1,0x03 );
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
		}else{
			USART_SendData(USART1,data);
			while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);	
		}	
	}
	//Send End
	USART_SendData(USART1, UART_END);	
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
}
*/
void Uart1Send(char *txbuf,int len)
{
	int i;
	for(i=0;i<len;i++){
		USART_SendData(USART1,txbuf[i]);
		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);	
	}
}
/*********************************************************************************************
*UART1RxTxISRHandler
*串口1中断处理函数
通讯协议
RxBuffer1接收缓冲区
sutMsg.Uart1Recv为1表明接受到一包数据，需要应用层处理数据后将其清零以便接受新的数据包
每包数据均以UART_HEAD开头，UART_END结尾。如解决数据包内容刚好有与UART_HEAD或UART_END相等的值，则需要转义
转义字符为UART_TRANSFORM，当收到UART_TRANSFORM开头时将根据紧挨其后的字符决定转义
如UART_HEAD=0x7a  UART_END=0x7b	   UART_TRANSFORM=0x7c 
如拟发送数据为： 01 02 7a 03 04 7b 05 06 7c 08 09 经过转换后的数据包为：
01 02 7c 02 03 04 7c 03 05 06 7c 01 08 09
加上包头包尾后：
7a 01 02 7c 02 03 04 7c 03 05 06 7c 01 08 09 7b
**********************************************************************************************
void UART1RxTxISRHandler(void)
{
	
	__IO unsigned char uart_data;
	__IO static unsigned char last_data;
	//----接收中断--------
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{
		uart_data = USART_ReceiveData(USART1);
		if(sutMsg.Uart1Recv){//上一批没处理，不接受新数据
			USART_ClearITPendingBit(USART1,  USART_IT_RXNE);  //清除中断标志
			rx1_ct=0;
			return;
		}
		
		if(uart_data==UART_HEAD){//包头
			RxBuffer1[0]=UART_HEAD;
   			rx1_ct=1;
		}else if(rx1_ct>=(UART1_RX_BUFFER_SIZE-1)){//超出接受缓冲区，丢掉此包数据，复位重新接收
			rx1_ct=0;	
		}else if(rx1_ct>0){
			if(uart_data==UART_END){//包尾
				RxBuffer1[rx1_ct++]=uart_data;
				rx1_len=rx1_ct;
				rx1_ct=0;
				sutMsg.Uart1Recv=1;
			}else if(uart_data==UART_TRANSFORM){//转义字符，忽略
			}else{
				if(last_data==UART_TRANSFORM){
					if(0x01==uart_data)RxBuffer1[rx1_ct++]=UART_TRANSFORM;	
					else if(0x02==uart_data)RxBuffer1[rx1_ct++]=UART_HEAD;
					else if(0x03==uart_data)RxBuffer1[rx1_ct++]=UART_END;
				}else{
					RxBuffer1[rx1_ct++]=uart_data;
				}	
			}
   		}
		last_data=uart_data;
		USART_ClearITPendingBit(USART1,  USART_IT_RXNE);  //清除中断标志
	}
	
}	
 */ 
/*********************************************************************************************
*UART1RxTxISRHandler
*串口1中断处理函数
**********************************************************************************************/
void UART1RxTxISRHandler(void)  
{
	__IO unsigned long temp;
	//接收空闲中断
	if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET){ 	
		temp = USART1->SR;//先读SR,再读DR
		temp = USART1->DR;//方可清USART_IT_IDLE标志 
		temp = UART1_RX_BUFFER_SIZE -  DMA1_Channel5->CNDTR;
		DMA_Cmd(DMA1_Channel5,DISABLE);
		
		//处理数据
		//if(RxBuffer1[0]=='P' && RxBuffer1[1]=='C' && RxBuffer1[2]=='T' && RxBuffer1[3]=='A'){
			if(sutMsg.Uart1Recv){//上一批没处理，不接受新数据
			}else{
				//数据拷贝
				memcpy(IapRxBuf,RxBuffer1,temp);
				IapRxLen=temp;
				sutMsg.Uart1Recv=1;
			}
		//}
		//重设DMA传输数据长度
		DMA1_Channel5->CNDTR = UART1_RX_BUFFER_SIZE;
    	//打开DMA
		DMA_Cmd(DMA1_Channel5,ENABLE);
	}
	if(USART_GetFlagStatus(USART3,USART_FLAG_ORE)==SET)
	{
		assert_param(IS_USART_CLEAR_FLAG(USART_FLAG_ORE));
		USART_ReceiveData(USART1);    //
		USART_ClearFlag(USART1,USART_FLAG_ORE); // 
	}
}
/*******************************************************************************
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_0);
	/* Enable the USART1 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	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, DISABLE);  //ENABLE DISABLE
	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);	//USART_IT_IDLE USART_IT_RXNE
	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE); 	 //使能USART1的接收DMA请求
	USART_DMACmd(USART1,USART_DMAReq_Tx,DISABLE); 	//使能USART1的发送DMA请求
	Uart1DMAInit();
}
void UART2RxTxISRHandler(void)                               
{   

} 
/***************************************************************************
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_0);
	/* Enable the USART3 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	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_ITConfig(USART1, USART_IT_PE, ENABLE);   
    USART_ITConfig(USART1, USART_IT_ERR, ENABLE);

	USART_Cmd(USART3, ENABLE);
	USART_DMACmd(USART3,USART_DMAReq_Tx,DISABLE); //使能USART1的DMA请求
	USART_DMACmd(USART3,USART_DMAReq_Rx,DISABLE); //使能USART1的DMA请求
	//Uart3DMAInit();
}


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

}




  


//调用函数： 
//my_func(data, "%s:%d\n", str, n);


/*
void IapTrace(char* format, ...) 
{ 
	static char TraceBuffer[512];
	va_list argptr;  
	int cnt;  
	va_start(argptr, format);  
	cnt = vsprintf(TraceBuffer, format, argptr);  
	va_end(argptr);  
	if(cnt>152){
		printf("TraceBuffer Error!\r\n");
		return;
	}
	DelayTick(10);
	printf("[IAP]");
	printf(TraceBuffer);
	DelayTick(10);

} 
*/
/***********************************************************************************
*
************************************************************************************/
void IapTrace(char *buf)
{
	char *p=buf;
	DelayTick(10);
	printf("[IAP]");
    while(0!=*p){
		USART_SendData(USART1, *p);
  		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
		p++;
	}
	DelayTick(10);
}
void SlwTrace(char *buf)
{
	char *p=buf;
	while(0!=*p){
		USART_SendData(USART1, *p);
  		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
		p++;
	}
}
#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;
}