STM32F103(纯代码)-串口通信USART1-3 UART4-5

1.usart.h

#ifndef __USART_H
#define __USART_H

#include "stm32f10x.h"                  // Device header
#include "stdio.h"
#include "stdarg.h"
#include "string.h"
#include "sys.h" 

#define USART_REC_LEN  			200  	//¶¨Òå×î´ó½ÓÊÕ×Ö½ÚÊý 200


#define USART1_CLK RCC_APB2Periph_USART1 //USART1 ʱÖÓ
#define USART1_TX_GPIO_CLK RCC_APB2Periph_GPIOA //GPIOA ʱÖÓ
#define USART1_RX_GPIO_CLK RCC_APB2Periph_GPIOA //GPIOA ʱÖÓ
#define	USART1_TX_GPIO_PORT GPIOA //GPIOA
#define	USART1_RX_GPIO_PORT GPIOA //GPIOA
#define USART1_TX_GPIO_Pin GPIO_Pin_9 //Pin_9
#define USART1_RX_GPIO_Pin GPIO_Pin_10 //Pin_10
#define USART1_TX_GPIO_Mode GPIO_Mode_AF_PP //¸´ÓÃÍÆÍìÊä³ö
#define USART1_RX_GPIO_Mode GPIO_Mode_IN_FLOATING //¸¡¿ÕÊäÈë
extern u8  USART1_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.Ä©×Ö½ÚΪ»»Ðзû 
extern u16 USART1_RX_STA;         		//½ÓÊÕ״̬±ê¼Ç


#define USART2_CLK RCC_APB1Periph_USART2 //USART2 ʱÖÓ
#define USART2_TX_GPIO_CLK RCC_APB2Periph_GPIOA //GPIOA ʱÖÓ
#define USART2_RX_GPIO_CLK RCC_APB2Periph_GPIOA //GPIOA ʱÖÓ
#define	USART2_TX_GPIO_PORT GPIOA //GPIOA
#define	USART2_RX_GPIO_PORT GPIOA //GPIOA
#define USART2_TX_GPIO_Pin GPIO_Pin_2 //Pin_2
#define USART2_RX_GPIO_Pin GPIO_Pin_3 //Pin_3
#define USART2_TX_GPIO_Mode GPIO_Mode_AF_PP //¸´ÓÃÍÆÍìÊä³ö
#define USART2_RX_GPIO_Mode GPIO_Mode_IN_FLOATING //¸¡¿ÕÊäÈë
extern u8  USART2_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.Ä©×Ö½ÚΪ»»Ðзû 
extern u16 USART2_RX_STA;         		//½ÓÊÕ״̬±ê¼Ç	


#define USART3_CLK RCC_APB1Periph_USART3 //USART3 ʱÖÓ
#define USART3_TX_GPIO_CLK RCC_APB2Periph_GPIOB //GPIOB ʱÖÓ
#define USART3_RX_GPIO_CLK RCC_APB2Periph_GPIOB //GPIOB ʱÖÓ
#define	USART3_TX_GPIO_PORT GPIOB //GPIOB
#define	USART3_RX_GPIO_PORT GPIOB //GPIOB
#define USART3_TX_GPIO_Pin GPIO_Pin_10 //Pin_10
#define USART3_RX_GPIO_Pin GPIO_Pin_11 //Pin_11
#define USART3_TX_GPIO_Mode GPIO_Mode_AF_PP //¸´ÓÃÍÆÍìÊä³ö
#define USART3_RX_GPIO_Mode GPIO_Mode_IN_FLOATING //¸¡¿ÕÊäÈë
extern u8  USART3_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.Ä©×Ö½ÚΪ»»Ðзû 
extern u16 USART3_RX_STA;         		//½ÓÊÕ״̬±ê¼Ç	

#define UART4_CLK RCC_APB1Periph_UART4 //UART4 ʱÖÓ
#define UART4_TX_GPIO_CLK RCC_APB2Periph_GPIOC //GPIOC ʱÖÓ
#define UART4_RX_GPIO_CLK RCC_APB2Periph_GPIOC //GPIOC ʱÖÓ
#define	UART4_TX_GPIO_PORT GPIOC //GPIOC
#define	UART4_RX_GPIO_PORT GPIOC //GPIOC
#define UART4_TX_GPIO_Pin GPIO_Pin_10 //Pin_10
#define UART4_RX_GPIO_Pin GPIO_Pin_11 //Pin_11
#define UART4_TX_GPIO_Mode GPIO_Mode_AF_PP //¸´ÓÃÍÆÍìÊä³ö
#define UART4_RX_GPIO_Mode GPIO_Mode_IN_FLOATING //¸¡¿ÕÊäÈë
extern u8  UART4_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.Ä©×Ö½ÚΪ»»Ðзû 
extern u16 UART4_RX_STA;         		//½ÓÊÕ״̬±ê¼Ç

#define UART5_CLK RCC_APB1Periph_UART5 //UART5 ʱÖÓ
#define UART5_TX_GPIO_CLK RCC_APB2Periph_GPIOC //GPIOC ʱÖÓ
#define UART5_RX_GPIO_CLK RCC_APB2Periph_GPIOD //GPIOD ʱÖÓ
#define	UART5_TX_GPIO_PORT GPIOC //GPIOC
#define	UART5_RX_GPIO_PORT GPIOD //GPIOD
#define UART5_TX_GPIO_Pin GPIO_Pin_12 //Pin_12
#define UART5_RX_GPIO_Pin GPIO_Pin_2 //Pin_2
#define UART5_TX_GPIO_Mode GPIO_Mode_AF_PP //¸´ÓÃÍÆÍìÊä³ö
#define UART5_RX_GPIO_Mode GPIO_Mode_IN_FLOATING //¸¡¿ÕÊäÈë
extern u8  UART5_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.Ä©×Ö½ÚΪ»»Ðзû 
extern u16 UART5_RX_STA;         		//½ÓÊÕ״̬±ê¼Ç	


void Usart1_Init(u32 bound);
void Usartl_SendByte(uint8_t Byte);
void Usart1_SendArray(uint8_t *Array, uint16_t Length);
void Usartl_SendString(char *String);
uint32_t Usart1_Pow(uint32_t X, uint32_t Y);
void Usart1_SendNumber(uint32_t Number, uint8_t Length);


void Usart2_Init(u32 bound);
void Usart2_SendByte(uint8_t Byte);
void Usart2_SendArray(uint8_t *Array, uint16_t Length);
void Usart2_SendString(char *String);
uint32_t Usart2_Pow(uint32_t X, uint32_t Y);
void Usart2_SendNumber(uint32_t Number, uint8_t Length);
void Usart2_printf(char* fmt,...);

void Usart3_Init(u32 bound);
void Usart3_SendByte(uint8_t Byte);
void Usart3_SendArray(uint8_t *Array, uint16_t Length);
void Usart3_SendString(char *String);
uint32_t Usart3_Pow(uint32_t X, uint32_t Y);
void Usart3_SendNumber(uint32_t Number, uint8_t Length);
void Usart3_printf(char* fmt,...) ;

void Uart4_Init(u32 bound);
void Uart4_SendByte(uint8_t Byte);
void Uart4_SendArray(uint8_t *Array, uint16_t Length);
void Uart4_SendString(char *String);
uint32_t Uart4_Pow(uint32_t X, uint32_t Y);
void Uart4_SendNumber(uint32_t Number, uint8_t Length);
void Uart4_printf(char* fmt,...);

void Uart5_Init(u32 bound);
void Uart5_SendByte(uint8_t Byte);
void Uart5_SendArray(uint8_t *Array, uint16_t Length);
void Uart5_SendString(char *String);
uint32_t Uart5_Pow(uint32_t X, uint32_t Y);
void Uart5_SendNumber(uint32_t Number, uint8_t Length);
void Uart5_printf(char* fmt,...);

#endif

2.usart.c

#include "usart.h"	  

struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
//¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//Öض¨Òåfputcº¯Êý 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//Ñ­»··¢ËÍ,Ö±µ½·¢ËÍÍê±Ï   
    USART1->DR = (u8) ch;      
	return ch;
}

//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u8 USART1_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
u16 USART1_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	  

u8 USART2_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
u16 USART2_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	  

u8 USART3_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
u16 USART3_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	  

u8 UART4_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
u16 UART4_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	  

u8 UART5_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
u16 UART5_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	  


void Usart1_Init(u32 bound)
{
  //GPIO¶Ë¿ÚÉèÖÃ
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(USART1_CLK | USART1_TX_GPIO_CLK | USART1_RX_GPIO_CLK, ENABLE);	//ʹÄÜUSART1£¬GPIOAʱÖÓ
  
	//USART1_TX   GPIOA.9
  GPIO_InitStructure.GPIO_Pin = USART1_TX_GPIO_Pin; //PA.9
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = USART1_TX_GPIO_Mode;	//¸´ÓÃÍÆÍìÊä³ö
  GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOA.9
   
  //USART1_RX	  GPIOA.10³õʼ»¯
  GPIO_InitStructure.GPIO_Pin = USART1_RX_GPIO_Pin;//PA10
  GPIO_InitStructure.GPIO_Mode = USART1_RX_GPIO_Mode;//¸¡¿ÕÊäÈë
  GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOA.10  

  //Usart1 NVIC ÅäÖÃ
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
  
  //USART ³õʼ»¯ÉèÖÃ
	USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ
	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); //³õʼ»¯´®¿Ú1
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖжÏ
  USART_Cmd(USART1, ENABLE);                    //ʹÄÜ´®¿Ú1 

}

void USART1_IRQHandler(void)                	//´®¿Ú1ÖжϷþÎñ³ÌÐò
	{
	u8 Res;

	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ(½ÓÊÕµ½µÄÊý¾Ý±ØÐëÊÇ0x0d 0x0a½áβ)
		{
		Res =USART_ReceiveData(USART1);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý
		
		if((USART1_RX_STA&0x8000)==0)//½ÓÊÕδÍê³É
			{
			if(USART1_RX_STA&0x4000)//½ÓÊÕµ½ÁË0x0d
				{
				if(Res!=0x0a)USART1_RX_STA=0;//½ÓÊÕ´íÎó,ÖØпªÊ¼
				else USART1_RX_STA|=0x8000;	//½ÓÊÕÍê³ÉÁË 
				}
			else //»¹Ã»ÊÕµ½0X0D
				{	
				if(Res==0x0d)USART1_RX_STA|=0x4000;
				else
					{
					USART1_RX_BUF[USART1_RX_STA&0X3FFF]=Res ;
					USART1_RX_STA++;
					if(USART1_RX_STA>(USART_REC_LEN-1))USART1_RX_STA=0;//½ÓÊÕÊý¾Ý´íÎó,ÖØпªÊ¼½ÓÊÕ	  
					}		 
				}
			}   		 
     } 

} 

void Usartl_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

void Usartl_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Usartl_SendByte(Array[i]);
	}
}

void Usartl_SendString(char *String)
{
	uint16_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Usartl_SendByte(String[i]);
	}
}

uint32_t Usart1_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

void Usart1_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		Usartl_SendByte(Number / Usart1_Pow(10, Length - i - 1) % 10 + '0');
	}
}

void Usart2_Init(u32 bound){
  //GPIO¶Ë¿ÚÉèÖÃ
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB1PeriphClockCmd(USART2_CLK, ENABLE);//ʹÄÜUSART2ʱÖÓ
	RCC_APB2PeriphClockCmd(USART2_TX_GPIO_CLK | USART2_RX_GPIO_CLK, ENABLE);	//ʹÄÜGPIOAʱÖÓ
  
	//USART2_TX   GPIOA.2
  GPIO_InitStructure.GPIO_Pin = USART2_TX_GPIO_Pin; //PA2
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = USART2_TX_GPIO_Mode;	//¸´ÓÃÍÆÍìÊä³ö
  GPIO_Init(USART2_TX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOA2
   
  //USART2_RX	  GPIOA.3
  GPIO_InitStructure.GPIO_Pin = USART2_RX_GPIO_Pin;//PA3
  GPIO_InitStructure.GPIO_Mode = USART2_RX_GPIO_Mode;//¸¡¿ÕÊäÈë
  GPIO_Init(USART2_RX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOA3 

  //Usart2 NVIC ÅäÖÃ
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
  
   //USART ³õʼ»¯ÉèÖÃ

	USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ
	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); //³õʼ»¯´®¿Ú2
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖжÏ
  USART_Cmd(USART2, ENABLE);                    //ʹÄÜ´®¿Ú2

}

void USART2_IRQHandler(void)                	//´®¿Ú2ÖжϷþÎñ³ÌÐò
	{
	u8 Res;

	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ(½ÓÊÕµ½µÄÊý¾Ý±ØÐëÊÇ0x0d 0x0a½áβ)
		{
		Res =USART_ReceiveData(USART2);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý
		
		if((USART2_RX_STA&0x8000)==0)//½ÓÊÕδÍê³É
			{
			if(USART2_RX_STA&0x4000)//½ÓÊÕµ½ÁË0x0d
				{
				if(Res!=0x0a)USART2_RX_STA=0;//½ÓÊÕ´íÎó,ÖØпªÊ¼
				else USART2_RX_STA|=0x8000;	//½ÓÊÕÍê³ÉÁË 
				}
			else //»¹Ã»ÊÕµ½0X0D
				{	
				if(Res==0x0d)USART2_RX_STA|=0x4000;
				else
					{
					USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res ;
					USART2_RX_STA++;
					if(USART2_RX_STA>(USART_REC_LEN-1))USART2_RX_STA=0;//½ÓÊÕÊý¾Ý´íÎó,ÖØпªÊ¼½ÓÊÕ	  
					}		 
				}
			}   		 
     } 

} 
	
void Usart2_SendByte(uint8_t Byte)
{
	USART_SendData(USART2, Byte);
	while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
}

void Usart2_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Usart2_SendByte(Array[i]);
	}
}

void Usart2_SendString(char *String)
{
	uint16_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Usart2_SendByte(String[i]);
	}
}

uint32_t Usart2_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

void Usart2_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		Usart2_SendByte(Number / Usart2_Pow(10, Length - i - 1) % 10 + '0');
	}
}

void Usart2_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)USART2_RX_BUF,fmt,ap);
	va_end(ap);
	//i=USART3_RX_STA&0x8000;		//´Ë´Î·¢ËÍÊý¾ÝµÄ³¤¶È
	i=strlen((const char*)USART2_RX_BUF);
	for(j=0;j<i;j++)							//Ñ­»··¢ËÍÊý¾Ý
	{
		Usart2_SendByte(USART2_RX_BUF[j]);
	} 
}

void Usart3_Init(u32 bound){
  //GPIO¶Ë¿ÚÉèÖÃ
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB1PeriphClockCmd(USART3_CLK, ENABLE);//ʹÄÜUSART3ʱÖÓ
	RCC_APB2PeriphClockCmd(USART3_TX_GPIO_CLK | USART3_RX_GPIO_CLK, ENABLE);	//ʹÄÜGPIOBʱÖÓ
  
	//USART3_TX   GPIOB.10
  GPIO_InitStructure.GPIO_Pin = USART3_TX_GPIO_Pin; //PB10
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = USART3_TX_GPIO_Mode;	//¸´ÓÃÍÆÍìÊä³ö
  GPIO_Init(USART3_TX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOB10
   
  //USART3_RX	  GPIOB.11
  GPIO_InitStructure.GPIO_Pin = USART3_RX_GPIO_Pin;//PB11
  GPIO_InitStructure.GPIO_Mode = USART3_RX_GPIO_Mode;//¸¡¿ÕÊäÈë
  GPIO_Init(USART3_RX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOB11

  //Usart3 NVIC ÅäÖÃ
  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
  
  //USART ³õʼ»¯ÉèÖÃ
	USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ
	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); //³õʼ»¯´®¿Ú3
  USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖжÏ
  USART_Cmd(USART3, ENABLE);                    //ʹÄÜ´®¿Ú3

}



void USART3_IRQHandler(void)                	//´®¿Ú3ÖжϷþÎñ³ÌÐò
	{
	u8 Res;

	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ(½ÓÊÕµ½µÄÊý¾Ý±ØÐëÊÇ0x0d 0x0a½áβ)
		{
		Res =USART_ReceiveData(USART3);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý
		
		if((USART3_RX_STA&0x8000)==0)//½ÓÊÕδÍê³É
			{
			if(USART3_RX_STA&0x4000)//½ÓÊÕµ½ÁË0x0d
				{
				if(Res!=0x0a)USART3_RX_STA=0;//½ÓÊÕ´íÎó,ÖØпªÊ¼
				else USART3_RX_STA|=0x8000;	//½ÓÊÕÍê³ÉÁË 
				}
			else //»¹Ã»ÊÕµ½0X0D
				{	
				if(Res==0x0d)USART3_RX_STA|=0x4000;
				else
					{
					USART3_RX_BUF[USART3_RX_STA&0X3FFF]=Res ;
					USART3_RX_STA++;
					if(USART3_RX_STA>(USART_REC_LEN-1))USART3_RX_STA=0;//½ÓÊÕÊý¾Ý´íÎó,ÖØпªÊ¼½ÓÊÕ	  
					}		 
				}
			}   		 
     } 

} 
void Usart3_SendByte(uint8_t Byte)
{
	USART_SendData(USART3, Byte);
	while (USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
}

void Usart3_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Usart3_SendByte(Array[i]);
	}
}

void Usart3_SendString(char *String)
{
	uint16_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Usart3_SendByte(String[i]);
	}
}

uint32_t Usart3_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

void Usart3_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		Usart3_SendByte(Number / Usart3_Pow(10, Length - i - 1) % 10 + '0');
	}
}

void Usart3_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)USART3_RX_BUF,fmt,ap);
	va_end(ap);
	//i=USART3_RX_STA&0x8000;		//´Ë´Î·¢ËÍÊý¾ÝµÄ³¤¶È
	i=strlen((const char*)USART3_RX_BUF);
	for(j=0;j<i;j++)							//Ñ­»··¢ËÍÊý¾Ý
	{
		Usart3_SendByte(USART3_RX_BUF[j]);
	} 
}

void Usart4_Init(u32 bound){
	
  //GPIO¶Ë¿ÚÉèÖÃ
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB1PeriphClockCmd(UART4_CLK, ENABLE);//ʹÄÜUART4ʱÖÓ
	RCC_APB2PeriphClockCmd(UART4_TX_GPIO_CLK | UART4_RX_GPIO_CLK, ENABLE);	//ʹÄÜGPIOCʱÖÓ
  
	//UART4_TX   GPIOC.10
  GPIO_InitStructure.GPIO_Pin = UART4_TX_GPIO_Pin; //PC10
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = UART4_TX_GPIO_Mode;	//¸´ÓÃÍÆÍìÊä³ö
  GPIO_Init(UART4_TX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOC10
   
  //UART4_RX	  GPIOC.11
  GPIO_InitStructure.GPIO_Pin = UART4_RX_GPIO_Pin;//PC11
  GPIO_InitStructure.GPIO_Mode = UART4_RX_GPIO_Mode;//¸¡¿ÕÊäÈë
  GPIO_Init(UART4_RX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOC11

  //Uart4 NVIC ÅäÖÃ
  NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
  
  //USART ³õʼ»¯ÉèÖÃ
	USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ
	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(UART4, &USART_InitStructure); //³õʼ»¯´®¿Ú4
  USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖжÏ
  USART_Cmd(UART4, ENABLE);                    //ʹÄÜ´®¿Ú4

}

void UART4_IRQHandler(void)                	//´®¿Ú4ÖжϷþÎñ³ÌÐò
	{
	u8 Res;

	if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ(½ÓÊÕµ½µÄÊý¾Ý±ØÐëÊÇ0x0d 0x0a½áβ)
		{
		Res =USART_ReceiveData(UART4);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý
		
		if((UART4_RX_STA&0x8000)==0)//½ÓÊÕδÍê³É
			{
			if(UART4_RX_STA&0x4000)//½ÓÊÕµ½ÁË0x0d
				{
				if(Res!=0x0a)UART4_RX_STA=0;//½ÓÊÕ´íÎó,ÖØпªÊ¼
				else UART4_RX_STA|=0x8000;	//½ÓÊÕÍê³ÉÁË 
				}
			else //»¹Ã»ÊÕµ½0X0D
				{	
				if(Res==0x0d)UART4_RX_STA|=0x4000;
				else
					{
					UART4_RX_BUF[UART4_RX_STA&0X3FFF]=Res ;
					UART4_RX_STA++;
					if(UART4_RX_STA>(USART_REC_LEN-1))UART4_RX_STA=0;//½ÓÊÕÊý¾Ý´íÎó,ÖØпªÊ¼½ÓÊÕ	  
					}		 
				}
			}   		 
     } 

} 

void Uart4_SendByte(uint8_t Byte)
{
	USART_SendData(UART4, Byte);
	while (USART_GetFlagStatus(UART4, USART_FLAG_TXE) == RESET);
}

void Uart4_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Uart4_SendByte(Array[i]);
	}
}

void Uart4_SendString(char *String)
{
	uint16_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Uart4_SendByte(String[i]);
	}
}

uint32_t Uart4_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

void Uart4_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		Uart4_SendByte(Number / Uart4_Pow(10, Length - i - 1) % 10 + '0');
	}
}

void Uart4_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)UART4_RX_BUF,fmt,ap);
	va_end(ap);
	//i=USART3_RX_STA&0x8000;		//´Ë´Î·¢ËÍÊý¾ÝµÄ³¤¶È
	i=strlen((const char*)UART4_RX_BUF);
	for(j=0;j<i;j++)							//Ñ­»··¢ËÍÊý¾Ý
	{
		Uart4_SendByte(UART4_RX_BUF[j]);
	} 
}

void Uart5_Init(u32 bound){
	
  //GPIO¶Ë¿ÚÉèÖÃ
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB1PeriphClockCmd(UART5_CLK, ENABLE);//ʹÄÜUART5ʱÖÓ
	RCC_APB2PeriphClockCmd(UART5_TX_GPIO_CLK | UART5_RX_GPIO_CLK, ENABLE);	//ʹÄÜGPIOC GPIODʱÖÓ
  
	//UART5_TX   GPIOC.12
  GPIO_InitStructure.GPIO_Pin = UART5_TX_GPIO_Pin; //PC12
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = UART5_TX_GPIO_Mode;	//¸´ÓÃÍÆÍìÊä³ö
  GPIO_Init(UART5_TX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOC12
   
  //UART5_RX	  GPIOD.2
  GPIO_InitStructure.GPIO_Pin = UART5_RX_GPIO_Pin;//PD2
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = UART5_RX_GPIO_Mode;//¸¡¿ÕÊäÈë
  GPIO_Init(UART5_RX_GPIO_PORT, &GPIO_InitStructure);//³õʼ»¯GPIOD2

  //Uart4 NVIC ÅäÖÃ
  NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
  
   //USART ³õʼ»¯ÉèÖÃ

	USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ
	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(UART5, &USART_InitStructure); //³õʼ»¯´®¿Ú5
  USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖжÏ
  USART_Cmd(UART5, ENABLE);                    //ʹÄÜ´®¿Ú5

}

void UART5_IRQHandler(void)                	//´®¿Ú5ÖжϷþÎñ³ÌÐò
	{
	u8 Res;

	if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ(½ÓÊÕµ½µÄÊý¾Ý±ØÐëÊÇ0x0d 0x0a½áβ)
		{
		Res =USART_ReceiveData(UART5);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý
		
		if((UART5_RX_STA&0x8000)==0)//½ÓÊÕδÍê³É
			{
			if(UART5_RX_STA&0x4000)//½ÓÊÕµ½ÁË0x0d
				{
				if(Res!=0x0a)UART5_RX_STA=0;//½ÓÊÕ´íÎó,ÖØпªÊ¼
				else UART5_RX_STA|=0x8000;	//½ÓÊÕÍê³ÉÁË 
				}
			else //»¹Ã»ÊÕµ½0X0D
				{	
				if(Res==0x0d)UART5_RX_STA|=0x4000;
				else
					{
					UART5_RX_BUF[UART5_RX_STA&0X3FFF]=Res ;
					UART5_RX_STA++;
					if(UART5_RX_STA>(USART_REC_LEN-1))UART5_RX_STA=0;//½ÓÊÕÊý¾Ý´íÎó,ÖØпªÊ¼½ÓÊÕ	  
					}		 
				}
			}   		 
     } 
} 

void Uart5_SendByte(uint8_t Byte)
{
	USART_SendData(UART5, Byte);
	while (USART_GetFlagStatus(UART5, USART_FLAG_TXE) == RESET);
}

void Uart5_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Uart5_SendByte(Array[i]);
	}
}

void Uart5_SendString(char *String)
{
	uint16_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Uart5_SendByte(String[i]);
	}
}

uint32_t Uart5_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

void Uart5_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		Uart5_SendByte(Number / Uart5_Pow(10, Length - i - 1) % 10 + '0');
	}
}

void Uart5_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)UART5_RX_BUF,fmt,ap);
	va_end(ap);
	//i=USART3_RX_STA&0x8000;		//´Ë´Î·¢ËÍÊý¾ÝµÄ³¤¶È
	i=strlen((const char*)UART5_RX_BUF);
	for(j=0;j<i;j++)							//Ñ­»··¢ËÍÊý¾Ý
	{
		Uart5_SendByte(UART5_RX_BUF[j]);
	} 
}

3.main

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "sys.h"
#include "stdio.h"

#include "Led.h"	
#include "Key.h"
#include "Beep.h"
#include "usart.h"


int main(void)
{
	
	Led_Init();
	Key_Init();
	Beep_Init();
	Usart1_Init(115200);
	Usart3_Init(115200);
	while(1)
	{
		printf("ok");
		Delay_s(2);
	
		if(USART3_RX_STA&0x8000)
		{	
			printf("%s\r\n",USART3_RX_BUF);
			USART3_RX_STA = 0;
		}

	}	
	
}