求大佬分享STM32多串口配置教程

Before

最近的问题是 串口不够用了~
我们需要打印 需要驱动串口屏 需要使用串口转以太网模块 等等等等 我感觉呀 我需要使用所有的串口
在网上收集了三种方法 和大家共勉
干活

方法一 参考于 Andrew

我们首要解决的就是 printf函数到底输出在哪一个串口中？ 很神奇~~
我们看这个fputc 这个函数

//重定义fputc函数，方便使用printf
int fputc(int Data, FILE *f)
{   
    while(!USART_GetFlagStatus(USART1,USART_FLAG_TXE));      //USART_GetFlagStatus：得到发送状态位
                                                          //USART_FLAG_TXE:发送寄存器为空 1：为空；0：忙状态
    USART_SendData(USART1,Data);                          //发送一个字符
   
    return Data;                                          //返回一个值
}
在我们使用printf函数的时候，首先必须重定义fputc函数，在这个函数中，实现数据的发送，然后在 USART_SendData(USART1,Data); 中选择需要的串口。一般是选择串口1，所以这种情况下，使用printf函数会打印到串口1。
那么我要用到串口2的printf函数该怎么办呢 ？
配置什么的还是和串口1一样，
1.配置usart2的串口配置，gpio,rcc enable。。。。
2.勾选u*** micro lib,
3.添加头文件#include ,编写USART2的printf函数：

void USART2_printf (char *fmt, ...)
{
        char buffer[CMD_BUFFER_LEN+1];  // CMD_BUFFER_LEN长度自己定义吧
        u8 i = 0;
        
        va_list arg_ptr;
        va_start(arg_ptr, fmt);  
        vsnprintf(buffer, CMD_BUFFER_LEN+1, fmt, arg_ptr);
        while ((i < CMD_BUFFER_LEN) && buffer)
        {
                USART_SendData(USART2, (u8) buffer[i++]);
                while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
        }
        va_end(arg_ptr);
}
仔细看我们会发现，其实这个函数中包含了fputc，然后吧 USART_SendData(USART1,Data); 改为 USART_SendData(USART2，(u8)buffer[i++]); 循环通过串口2发送。
方法二 自己实现printf函数 参考 秉火程序


/*
* 函数名：USART2_printf
* 描述  ：格式化输出，类似于C库中的printf，但这里没有用到C库
* 输入  ：-USARTx 串口通道，这里只用到了串口2，即USART2
*             -Data   要发送到串口的内容的指针
*               -...    其他参数
* 输出  ：无
* 返回  ：无
* 调用  ：外部调用
*         典型应用USART2_printf( USART2, "rn this is a demo rn" );
*                     USART2_printf( USART2, "rn %d rn", i );
*                     USART2_printf( USART2, "rn %s rn", j );
*/
void USART2_printf ( USART_TypeDef * USARTx, char * Data, ... )
{
    const char *s;
    int d;   
    char buf[16];


   
    va_list ap;
    va_start(ap, Data);


    while ( * Data != 0 )     // 判断是否到达字符串结束符
    {                                          
        if ( * Data == 0x5c )  //''
        {                                      
            switch ( *++Data )
            {
                case 'r':                                      //回车符
                USART_SendData(USARTx, 0x0d);
                Data ++;
                break;


                case 'n':                                      //换行符
                USART_SendData(USARTx, 0x0a);   
                Data ++;
                break;


                default:
                Data ++;
                break;
            }            
        }
        
        else if ( * Data == '%')
        {                                      //
            switch ( *++Data )
            {               
                case 's':                                        //字符串
                s = va_arg(ap, const char *);
               
                for ( ; *s; s++)
                {
                    USART_SendData(USARTx,*s);
                    while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );//程序死在了这
                }
               
                Data++;
               
                break;


                case 'd':            
                    //十进制
                d = va_arg(ap, int);
               
                itoa(d, buf, 10);
               
                for (s = buf; *s; s++)
                {
                    USART_SendData(USARTx,*s);
                    while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
                }
               
                Data++;
               
                break;
               
                default:
                Data++;
               
                break;
               
            }         
        }        
        else USART_SendData(USARTx, *Data++);        
        while ( USART_GetFlagStatus ( USARTx, USART_FLAG_TXE ) == RESET );
        
    }
}
然后我们只需要在这里面修改串口号就可以

方法三 参考于逐风少年
这里我们配置 usart1 2 3 和 uart4


usart1 初始化+中断配置+中断接收函数
/*===============================================================================
Copyright:
Version:
Author:   
Date: 2017/11/3
Description:
    配置独立看门狗初始化函数，在主函数中运行IWDG_ReloadCounter进行喂狗主函数必须在4s内进行一次喂狗不然系统会复位；
    函数功能是将接收固定长度的字符串，并将接收后的字符串通过串口发送出去
revise Description:
===============================================================================*/
#include "stm32f10x_usart.h"
#include "stm32f10x.h"
#include "stm32f10x_iwdg.h"


u8 USART1_RX_BUF[21];
u8 USART1_RX_CNT=0;


void IWDG_Configuration(void);


void Usart1_Init(u32 bound)
{
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
     
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC, ENABLE);//使能USART1,GPIOA,C时钟
      
    //USART1_TX   GPIOA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9


    //USART1_RX      GPIOA.10初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  


    //Usart1 NVIC 配置
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置NVIC中断分组2:2位抢占优先级，2位响应优先级   0-3;
   
    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
}
/**
* USART1发送len个字节.
* buf:发送区首地址
* len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
**/
void USART1_Send_Data(u8 *buf,u16 len)
{
    u16 t;
    GPIO_SetBits(GPIOC,GPIO_Pin_9);
//  RS485_TX_EN=1;            //设置为发送模式
    for(t=0;t     {           
        while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET); //循环发送,直到发送完毕   
        USART_SendData(USART1,buf[t]);
    }     
    while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);        
    GPIO_ResetBits(GPIOC,GPIO_Pin_9);
//    RS485_TX_EN=0;                //设置为接收模式   
}
void main(void)
{
    Usart1_Init(9600);//串口1波特率设置为9600
    IWDG_Configuration();
    while(1)
    {
        IWDG_ReloadCounter();//4s内必须喂狗不然复位
        if(USART1_RX_CNT==21)//数据接收完成
        {
            USART1_RX_CNT=0;//指针复位
            //将接收到的数据发送出去
            USART1_Send_Data(USART1_RX_BUF,21);//通过串口1将接收到的固定长度字符发送出去            
        }
    }
   
}
/**
* 接收指定长度的字符串
* 比如接收固定大小为21个字节的字符串
**/
void USART1_IRQHandler(void)                    //串口1中断服务程序
{
    u8 Res;
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
        {
            Res =USART_ReceiveData(USART1);    //读取接收到的数据     
            if(USART1_RX_CNT<21)//对于接收指定长度的字符串
            {
                USART1_RX_BUF[USART1_RX_CNT]=Res;        //记录接收到的值   
                USART1_RX_CNT++;                                        //接收数据增加1
            }            
     }
         //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
    if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) == SET)
    {
        USART_ReceiveData(USART1);
        USART_ClearFlag(USART1,USART_FLAG_ORE);
    }
     USART_ClearFlag(UART1,USART_IT_RXNE); //一定要清除接收中断
}
/*===============================================================================
Copyright:
Version:
Author:   
Date: 2017/11/3
Description:配置独立看门狗初始化函数，在主函数中运行IWDG_ReloadCounter进行喂狗
    主函数必须在4s内进行一次喂狗不然系统会复位
revise Description:
===============================================================================*/
void IWDG_Configuration(void)
{
     /* 写入0x5555,用于允许狗狗寄存器写入功能 */
    IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
     /* 狗狗时钟分频,40K/256=156HZ(6.4ms)*/  
    IWDG_SetPrescaler(IWDG_Prescaler_256);    /* 喂狗时间 5s/6.4MS=781 .注意不能大于0xfff*/  
    IWDG_SetReload(781);//781（5s时间）
    IWDG_SetReload(3125);//781（20s时间）
    IWDG_Enable();//启用定时器
    IWDG_ReloadCounter();
}


usart 2 初始化+中断配置+中断接收函数
/*===============================================================================
Copyright:
Version:
Author:   
Date: 2017/11/3
Description:
    函数功能是将接收固定长度的字符串，并将接收后的字符串通过串口发送出去
revise Description:
===============================================================================*/
#include "stm32f10x_usart.h"
#include "stm32f10x.h"
#include "stm32f10x_iwdg.h"




u8 USART2_RX_BUF[250];
u8 USART2_RX_CNT=0;
u16 USART2_RX_STA=0;       //接收状态标记   


void Usart2_Init(u32 bound)
{  
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    //|RCC_APB2Periph_AFIO
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能GPIOA时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟


    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;    //PA2
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽
    GPIO_Init(GPIOA, &GPIO_InitStructure);


    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);  


    RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,ENABLE);//复位串口2
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,DISABLE);//停止复位


    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置NVIC中断分组2:2位抢占优先级，2位响应优先级   0-3;
    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //使能串口2中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; //先占优先级2级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //从优先级2级
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
    NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器


    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); ; //初始化串口
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启中断
    USART_Cmd(USART2, ENABLE);                    //使能串口


}
/**
* USART2发送len个字节.
* buf:发送区首地址
* len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
**/
void USART2_Send_Data(u8 *buf,u16 len)
{
    u16 t;
      for(t=0;t     {           
        while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);      
        USART_SendData(USART2,buf[t]);
    }     
    while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);         
}
/**
* 这也是一个接收函数，可以用，也可以用下面main函数的方法调用
* USART2查询接收到的数据
* buf:接收缓存首地址
* len:读到的数据长度
**/
void USART2_Receive_Data(u8 *buf)
{
    u8 rxlen=USART2_RX_CNT;
    u8 i=0;
    delay_ms(10);        //等待10ms,连续超过10ms没有接收到一个数据,则认为接收结束
    while(rxlen!=USART2_RX_CNT)
    {
        rxlen=USART2_RX_CNT;
        delay_ms(10);
    }
        for(i=0;i<(USART2_RX_CNT);i++)
        {
            buf = USART2_RX_BUF;   
            USART2_RX_BUF = 0;
        }        
        USART2_RX_CNT=0;        //清零
   
}


void main(void)
{
    Usart2_Init(9600);//串口1波特率设置为9600
    while(1)
    {
        if(USART2_RX_STA)//数据接收完成
        {
            USART2_RX_STA=0;            
            //将接收到的数据发送出去
            USART2_Send_Data(USART2_RX_BUF,USART2_RX_CNT);//通过串口1将接收到的固定长度字符发送出去   
            USART2_RX_CNT=0;//指针复位
        }
    }   
}




void USART2_IRQHandler(void)
{
    u8 res;        
     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收到数据
    {         
        res =USART_ReceiveData(USART2);     //读取接收到的数据        
        if(USART2_RX_STA==0)
        {
            USART2_RX_BUF[USART2_RX_CNT] = res;        //记录接收到的值   
            //当数据结尾收到0xA0和0xA1代表数据接收完成，是一串完整的数据
            if(USART2_RX_BUF[USART2_RX_CNT-1]==0xA0&&USART2_RX_BUF[USART2_RX_CNT]==0xA1)
                USART2_RX_STA=1;//表示接收数据结束
            USART2_RX_CNT++;                        //接收数据增加1
        }
        }
    }  
    //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
    if(USART_GetFlagStatus(USART2,USART_FLAG_ORE) == SET)
    {
        USART_ReceiveData(USART2);
        USART_ClearFlag(USART2,USART_FLAG_ORE);
    }
     USART_ClearFlag(UART2,USART_IT_RXNE); //一定要清除接收中断   
}


usart 3 初始化+中断配置+中断接收函数
/*===============================================================================
Copyright:
Version:
Author:   
Date: 2017/11/3
Description:
    函数功能是将接收固定长度的字符串，并将接收后的字符串通过串口发送出去
    通过滴答定时器方式获取数据
revise Description:
===============================================================================*/
#include "stm32f10x_usart.h"
#include "stm32f10x.h"


#define USART3_TIMEOUT_Setting 800  //(ms)


u8 USART3_RX_BUF[250];
u16 USART3_RX_CNT=0;
u16 USART3_RX_TIMEOUT=0;       //接收状态标记   


void Timer1CountInitial(void);


void USART3_Init(u32 baud)   
{  
    USART_InitTypeDef USART_InitStructure;  
    NVIC_InitTypeDef NVIC_InitStructure;   
    GPIO_InitTypeDef GPIO_InitStructure;    //声明一个结构体变量，用来初始化GPIO  
    //使能串口的RCC时钟  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE); //使能UART3所在GPIOB的时钟  
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);  


    //串口使用的GPIO口配置  
    // Configure USART3 Rx (PB.11) as input floating   
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
    GPIO_Init(GPIOB, &GPIO_InitStructure);  


    // Configure USART3 Tx (PB.10) as alternate function push-pull  
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  
    GPIO_Init(GPIOB, &GPIO_InitStructure);  


    //配置串口  
    USART_InitStructure.USART_BaudRate = baud;  
    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;  




    // Configure USART3   
    USART_Init(USART3, &USART_InitStructure);//配置串口3
    // Enable USART3 Receive interrupts 使能串口接收中断  
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);  
    // Enable the USART3   
    USART_Cmd(USART3, ENABLE);//使能串口3  


    //串口中断配置  
    //Configure the NVIC Preemption Priority Bits     
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  


    // Enable the USART3 Interrupt   
    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;   
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        //子优先级3
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    NVIC_Init(&NVIC_InitStructure);      
      
}


void USART3_Sned_Char(u8 temp)        
{  
    USART_SendData(USART3,(u8)temp);      
    while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)==RESET);  
      
}


void USART3_Sned_Char_Buff(u8 buf[],u32 len)  
{  
    u32 i;  
    for(i=0;i     USART3_Sned_Char(buf);  
         
}


void main(void)
{
    Timer1CountInitial();
    Usart3_Init(9600);//串口1波特率设置为9600
    while(1)
    {
        if(USART3_RX_TIMEOUT==USART3_TIMEOUT_Setting)
        {            
            USART3_RX_TIMEOUT=0;
            USART3_Sned_Char_Buff(USART3_RX_BUF,USART3_RX_CNT);//将接收到的数据发送出去
            USART3_RX_CNT=0;
        }
        
    }   
}
void USART3_IRQHandler(void)                    //串口3中断服务程序
{
    u8 Res;
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  
    {   
        USART3_RX_TIMEOUT=0;
        USART3_RX_BUF[USART3_RX_CNT++] = USART_ReceiveData(USART3);    //读取接收到的数据        
    }
    //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
    if(USART_GetFlagStatus(USART3,USART_FLAG_ORE) == SET)
    {
        USART_ReceiveData(USART3);
        USART_ClearFlag(USART3,USART_FLAG_ORE);
    }
    USART_ClearITPendingBit(USART3, USART_IT_RXNE);


}


//放到主函数的初始化中初始化
void Timer1CountInitial(void)
{
    //定时=36000/72000x2=0.001s=1ms;
        TIM_TimeBaseInitTypeDef    TIM_TimeBaseStructure;
        ///
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
        
        TIM_TimeBaseStructure.TIM_Period = 100-1;//自动重装值（此时改为10ms）
        TIM_TimeBaseStructure.TIM_Prescaler = 7200-1;//时钟预分频
        TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
        TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;        //时钟分频1
        TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;            
        TIM_TimeBaseInit(TIM1,&TIM_TimeBaseStructure);
        
        TIM_ClearFlag(TIM1,TIM_FLAG_Update);
        TIM_ITConfig(TIM1,TIM_IT_Update,ENABLE);  
        TIM_Cmd(TIM1, ENABLE);
}
void TIM1_UP_IRQHandler(void)
{        
    //TIM_TimeBaseStructure.TIM_Period = 100-1;//自动重装值（此时改为10ms）
    if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET)
    {  
        if(USART3_RX_TIMEOUT                 USART3_RX_TIMEOUT++;        
    }
    TIM_ClearITPendingBit(TIM1,TIM_IT_Update);
}


uart 4 初始化+中断配置+中断接收函数 注意 没有贴出来中断优先级的配置
/*===============================================================================
Copyright:
Version:
Author:   
Date: 2017/11/3
Description:
    函数功能是将接收固定长度的字符串，并将接收后的字符串通过串口发送出去
    通过滴答定时器方式获取数据
revise Description:
===============================================================================*/
#include "stm32f10x_usart.h"
#include "stm32f10x.h"


#define USART4_TIMEOUT_Setting 800  //(ms)


u8 USART4_RX_BUF[250];
u16 USART4_RX_CNT=0;
u16 USART2_RX_STA=0;       //接收状态标记


void Systick_delay_init(u8 SYSCLK);
u8 virtual_delay(u32 num,u8 unit);


//通用异步收发器UART4
void UART4_Init(u32 bound)
{
    USART_InitTypeDef USART_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;


    //used for USART3 full remap
    //GPIO_PinRemapConfig(GPIO_FullRemap_USART3, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);//for UART4


    //Configure RS485_TX_EN PIN
    GPIO_InitStructure.GPIO_Pin = RS485_TX_EN_PIN;                 //PC9端口配置
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(RS485_TX_EN_PORT, &GPIO_InitStructure);


    RS485_TX_EN=0;            //设置485默认为接收模式


    /* Configure USART Tx as alternate function push-pull */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);


    /* Configure USART Rx as input floating */
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOC, &GPIO_InitStructure);




    USART_InitStructure.USART_BaudRate = bound;
    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(UART4, &USART_InitStructure);
    //USART_Init(USART3, &USART_InitStructure);
    /* Enable the USART */
    USART_Cmd(UART4, ENABLE);
    USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);//开启串口接受中断
    USART_ClearFlag(UART4,USART_FLAG_TC);   
}
//USART1查询接收到的数据
//buf:接收缓存首地址
//len:读到的数据长度
void UART4_Receive_Data(u8 *buf)
{
    u8 rxlen=21;
    u8 i=0;
    delay_ms(10);        //等待10ms,连续超过10ms没有接收到一个数据,则认为接收结束
   
    RS485_RX_FLAG = 0;
    if((UART4_RX_BUF[0]==0x01)&&(UART4_RX_BUF[1]==0x03))
    {
        for(i=0;i         {
            buf=UART4_RX_BUF;   
            UART4_RX_BUF = 0;
        }   
        RS485_RX_FLAG = 1;
    }
        UART4_RX_CNT=0;        //清零
}




//USART1发送len个字节.
//buf:发送区首地址
//len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
void UART4_Send_Data(u8 *buf,u16 len)
{
    u16 t;
    RS485_TX_EN=1;            //设置为发送模式
    for(t=0;t     {           
        while(USART_GetFlagStatus(UART4,USART_FLAG_TC)==RESET); //循环发送,直到发送完毕   
        USART_SendData(UART4,buf[t]);
    }     
    while(USART_GetFlagStatus(UART4, USART_FLAG_TC) == RESET);        
    RS485_TX_EN=0;                //设置为接收模式   
}


void main(void)
{
    Systick_delay_init(72);
    Usart4_Init(9600);//串口1波特率设置为9600
    while(1)
    {
        if(USART2_RX_STA)
        {
            if(virtual_delay(USART4_TIMEOUT_Setting,MS))//超过800ms空闲则可以读取数据
            {
                UART4_Send_Data(UART4_RX_BUF,UART4_RX_CNT);
                USART2_RX_STA=0;
                UART4_RX_CNT=0;               
            }
            
        }
        
    }   
}
void UART4_IRQHandler(void)                    //UART4 Receive Interrupt
{
    u8 Res;
   
    if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    {   
        Res =USART_ReceiveData(UART4);//(USART1->DR);    //读取接收到的数据   
        UART4_RX_BUF[UART4_RX_CNT&0XFF]=Res;        //回传的数据存入数组,0X3F限制为64个数值
            UART4_RX_CNT++;
        USART2_RX_STA=1;   
    }
   
    if( USART_GetITStatus(UART4, USART_IT_TC) == SET )
    {
        USART_ClearFlag(UART4, USART_FLAG_TC);
    }   
    //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
    if(USART_GetFlagStatus(UART4,USART_FLAG_ORE) == SET)
    {
        USART_ReceiveData(UART4);
        USART_ClearFlag(UART4,USART_FLAG_ORE);
    }
//    USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);//临时关闭接收中断
    USART_ClearFlag(UART4,USART_IT_RXNE); //一定要清除接收中断
   
}


//初始化延迟函数
//SYSTICK的时钟固定为HCLK时钟的1/8
//SYSCLK:系统时钟
void Systick_delay_init(u8 SYSCLK)
{
    SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
//    SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    fac_us=SYSCLK/8;            
    fac_ms=(u16)fac_us*1000;
}
/*===============================================================================
Author:peter pan
Date:
Description: 查询式分时或叫做轮询式（近似延时）。本函数是用于执行高效率场合的查询延时，但是一个for or while 循环中只能用一次。
revise Description:  
@ num :    //分时查询的周期计数值   
@ unit :    //分时查询的周期单位
    @@ParaValue ：
        MS    //周期单位为MS毫秒级
        US    //周期单位为US微秒级
@ virtual_delay_status :    //静态变量
    @@ParaValue ：
        SET    //SYSTICK正在占用中，请勿用
        RESET  //SYSTICK空闲，可以使用
@ReValue :
    with zero mean Time non-arrive ,one representative Time arrived ,you can do task;
##example             if(virtual_delay(1000,MS)) LedFlash();    //1000ms LED闪烁一下
===============================================================================*/
u8 virtual_delay(u32 num,u8 unit)
{
    u32 temp;           
    if(virtual_delay_status==RESET)    //  SYSTICK空闲，可以使用
      {
          if(unit==MS)
          {
                SysTick->LOAD=(u32)num*Delay_SYSCLK*125;//时间加载(SysTick->LOAD为24bit)
                SysTick->VAL =0x00;           //清空计数器
                SysTick->CTRL=0x01 ;          //开始倒数  
          }else if(unit==US)
          {
                SysTick->LOAD=num*Delay_SYSCLK/8; //时间加载               
                SysTick->VAL=0x00;        //清空计数器
                SysTick->CTRL=0x01 ;      //开始倒数     
          }
          virtual_delay_status=SET;
          return 0;
        }
    else
        {        //virtual_delay_status==SET SYSTICK被占用
        
            temp=SysTick->CTRL;
            if(!(temp&0x01&&!(temp&(1<<16))))//等待时间到达   
            {
                SysTick->CTRL=0x00;       //关闭计数器
                SysTick->VAL =0X00;       //清空计数器   
                virtual_delay_status=RESET;   
                return 1;
            }else return 0;
        }
}


开始使用这些串口吧~~print(“Hello,world!”);