博客

STM32串口介绍

STM32F103串口

STM32F103ZET6 最多可提供 5 路串口，有分数波特率发生器、支持同步单线通信和半双工单线通讯、支持 LIN、支持调制解调器操作、智能卡协议和 IrDA SIR ENDEC 规范、具有 DMA等。

• 三个通用同步异步收发器USART
• 两个通用异步收发器UART
  • 二者区别就在于一根时钟线，UART少一根线
  • Universal Asynchronous Receiver/Transmitter
    
    

STM32F407串口结构

最多可提供 6 路串口

中文参考手册26.3，P678







六个串口对应引脚

串口对printf的支持

F4开发指南5.3.1，P142

//
//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
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;
}
#endif

串行通信过程

串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很简单并且能够实现远距离通信。

串口的物理层

接收字节的方式：

串口相关寄存器

USART_BRR 波特率寄存器

F407中文参考手册26.6.3， 713

Baud rate register

15-4 DIV_Mantissa 波特率尾数

• 波特率计算

3-0 IDV-fraction 波特率小数

状态寄存器 USART_SR

7 TXE发送数据寄存器为空

6 TC（发送完成）

当该位被置位的时候，表示 USART_DR 内的数据已经被发送完成了。如果设置了这个位的中断，则会产生中断。该位也有两种清零方式：1）读 USART_SR，写USART_DR。2）直接向该位写 0。

5 RXNE（读数据寄存器非空）

当该位被置 1 的时候，就是提示已经有数据被接收到了，并且可以读出来了。这时候我们要做的就是尽快去读取 USART_DR，通过读 USART_DR 可以将该位清零，也可以向该位写 0，直接清除。

0 奇偶校验错误

数据寄存器(USART_DR)

8-0 DR数据

控制寄存器 1(USART_CR1)

control register

中文参考手册26.6.4，P714

13 UE串口使能

3 TE发送使能

2 RE接收使能

控制寄存器 2(USART_CR2)

控制寄存器 3(USART_CR3)

串口相关函数

串口状态

串口的状态可以通过状态寄存器

USART_SR 状态寄存器

读取。

在固件库函数里面，读取串口状态的函数是：

FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)；

串口状态与中断状态很类似，这里不多说了

#define USART_IT_PE ((uint16_t)0x0028)
#define USART_IT_TXE ((uint16_t)0x0727)
#define USART_IT_TC ((uint16_t)0x0626)
#define USART_IT_RXNE ((uint16_t)0x0525)
#define USART_IT_IDLE ((uint16_t)0x0424)
#define USART_IT_LBD ((uint16_t)0x0846)
#define USART_IT_CTS ((uint16_t)0x096A)
#define USART_IT_ERR ((uint16_t)0x0060)
#define USART_IT_ORE ((uint16_t)0x0360)
#define USART_IT_NE ((uint16_t)0x0260)
#define USART_IT_FE ((uint16_t)0x0160)

数据发送

数据寄存器 USART_DR 来实现的，这是一个双寄存器，包含了 TDR 和 RDR。

当向该寄存器写数据的时候，串口就会自动发送，当收到数据的时候，也是存在该寄存器内。

STM32 库函数操作 USART_DR 寄存器发送数据的函数是：

void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

/**
  * @brief  Transmits single data through the USARTx peripheral.
  * @param  USARTx: where x can be 1, 2, 3, 4, 5, 6, 7 or 8 to select the USART or 
  *         UART peripheral.
  * @param  Data: the data to transmit.
  * @retval None
  */
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  assert_param(IS_USART_DATA(Data)); 
    
  /* Transmit Data */
  USARTx->DR = (Data & (uint16_t)0x01FF);
}

通过该函数向串口寄存器 USART_DR 写入一个数据。

数据接收

STM32 库函数操作 USART_DR 寄存器读取串口接收到的数据的函数是：

uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

/**
  * @brief  Returns the most recent received data by the USARTx peripheral.
  * @param  USARTx: where x can be 1, 2, 3, 4, 5, 6, 7 or 8 to select the USART or 
  *         UART peripheral.
  * @retval The received data.
  */
uint16_t USART_ReceiveData(USART_TypeDef* USARTx)
{
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  
  /* Receive Data */
  return (uint16_t)(USARTx->DR & (uint16_t)0x01FF);
}

通过该函数可以读取串口接受到的数据。

Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据

串口连接

USART主机接USART从机

USART主机接电脑USB

一般的单片机硬件设计都会预留一个USART连接电脑，用于在调试程序时可以将调试信息打印在电脑端的串口调试助手。

但单片机的USART无法直接与PC通讯，需要借助CH340或CP2102等芯片实现USB与USART的相互转化。

STM32F103 板载的 USB 串口和 STM32F103ZET6 的串口是通过 P4 连接起来的

P4 是 PA9 和 PA10 的引出口。这里我们把 P4 的 RXD 和 TXD 用跳线帽与 PA9 和 PA10 连接起来。

TXD/RXD 是相对 CH340G 来说的，也就是 USB 串口的发送和接收引脚。

• 这样设计的好处就是使用上非常灵活。比如需要用到外部 TTL 串口和 STM32 通信的时候，只需要拔了跳线帽，通过杜邦线连接外部 TTL 串口，就可以实现和外部设备的串口通信了；

USART主机接RS232从机

单片机的USART无法直接与232设备通讯，需要借助MAX232等芯片实现232与USART的相互转化。

USART主机接RS485从机

串口初始化设置

F4开发指南5.3.2，P143

配置中断优先级

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 设 置 NVIC 中 断 分 组 2

设置抢占优先级值和响应优先级

NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //Usart1 中断配置
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级 3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //响应优先级 3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ 通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化 VIC 寄存器

串口时钟使能，GPIO时钟使能

串口1是挂载在APB2 下面的外设，所以使能函数为：

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能 GPIOA 时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能 USART1 时钟

配置相应的引脚复用器映射

GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); //PA9 复用为 USART1
GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); //PA10复用为USART1

详细不分可以参考F4开发指南4.4，IO 引脚复用器和映射P117

#define IS_GPIO_AF(AF) (((AF) == GPIO_AF_RTC_50Hz) ||((AF) == GPIO_AF_TIM14) || \
((AF) == GPIO_AF_MCO) || ((AF) == GPIO_AF_TAMPER) || \
((AF) == GPIO_AF_SWJ) || ((AF) == GPIO_AF_TRACE) || \
((AF) == GPIO_AF_TIM1) || ((AF) == GPIO_AF_TIM2) || \
((AF) == GPIO_AF_TIM3) || ((AF) == GPIO_AF_TIM4) || \
((AF) == GPIO_AF_TIM5) || ((AF) == GPIO_AF_TIM8) || \
((AF) == GPIO_AF_I2C1) || ((AF) == GPIO_AF_I2C2) || \
((AF) == GPIO_AF_I2C3) || ((AF) == GPIO_AF_SPI1) || \
((AF) == GPIO_AF_SPI2) || ((AF) == GPIO_AF_TIM13) || \
((AF) == GPIO_AF_SPI3) || ((AF) == GPIO_AF_TIM14) || \
((AF) == GPIO_AF_USART1) || ((AF) == GPIO_AF_USART2) || \
((AF) == GPIO_AF_USART3) || ((AF) == GPIO_AF_UART4) || \
((AF) == GPIO_AF_UART5) || ((AF) == GPIO_AF_USART6) || \
((AF) == GPIO_AF_CAN1) || ((AF) == GPIO_AF_CAN2) || \
((AF) == GPIO_AF_OTG_FS) || ((AF) == GPIO_AF_OTG_HS) || \
((AF) == GPIO_AF_ETH) || ((AF) == GPIO_AF_OTG_HS_FS) || \
((AF) == GPIO_AF_SDIO) || ((AF) == GPIO_AF_DCMI) || \
((AF) == GPIO_AF_EVENTOUT) || ((AF) == GPIO_AF_FSMC))

串口复位

当外设出现异常的时候可以通过复位设置，实现该外设的复位，然后重新配置这个外设达到让其重新工作的目的。

一般在系统刚开始配置外设的时候，都会先执行复位该外设的操作。复位的是在函数 USART_DeInit()中完成：

USART_DeInit

void USART_DeInit(USART_TypeDef* USARTx);//串口复位

比如我们要复位串口 1，方法为：

USART_DeInit(USART1); //复位串口 1

GPIO端口设置及初始化

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10; //GPIOA9 与 GPIOA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速度 50MHz
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化 PA9，PA10

中文参考手册：

串口参数初始化

usart.c里面包含了2个函数

一个是void USART1_IRQHandler(void);

另外一个是void uart_init(u32bound);

串口初始化是通过 USART_Init()函数实现的，

void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)；

typedef struct
{
uint32_t USART_BaudRate;
uint16_t USART_WordLength;
uint16_t USART_StopBits;
uint16_t USART_Parity;
uint16_t USART_Mode;
uint16_t USART_HardwareFlowControl;
} USART_InitTypeDef;

这个结构体有 6 个成员变量，所以我们有 6 个参数需要初始化。

USART_BaudRate 波特率

• USART_BaudRate 为串口波特率，波特率可以说是串口最重要的参数了。参见波特率寄存器(USART_BRR)

USART_WordLength字长

• USART_WordLength 为字长，这里我们设置为 8 位字长数据格式。参见 控制寄存器 1(USART_CR1)

USART_StopBits停止位

• USART_StopBits 为停止位设置，我们设置为 1 位停止位。参见控制寄存器 2(USART_CR2)第12位
  
  

USART_Parity奇偶校验位

• USART_Parity 设定是否需要奇偶校验，我们设定为无奇偶校验位。参见控制寄存器 1(USART_CR1)第9位。

#define USART_Parity_No                      ((uint16_t)0x0000)
#define USART_Parity_Even                    ((uint16_t)0x0400)
#define USART_Parity_Odd                     ((uint16_t)0x0600) 
#define IS_USART_PARITY(PARITY) (((PARITY) == USART_Parity_No) || \
                                 ((PARITY) == USART_Parity_Even) || \
                                 ((PARITY) == USART_Parity_Odd))

过采样

按理说过采样越高越好，有8与16两个选项。选16就好。

由于过采样技术要求，1bit数据最少分配x8个采样时钟！默认一般是x16个采样时钟

USART_Mode串口模式

• USART_Mode 为串口模式，我们设置为全双工收发模式。参见 控制寄存器 3(USART_CR3)第三位
• 第六个参数为是否支持硬件流控制，我们设置为无硬件流控制。

代码

串口1的硬件连接

串口配置

USART_InitTypeDef USART_InitStructure;
//USART 初始化设置，接下来我们要设置串口 1 的初始化参数：
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); //初始化串口

如果有过采样的话有8和16可以选择，一般选择16。

主函数

 int main(void)
{ 
 
	u8 t;
	u8 len;	
	u16 times=0;  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
	delay_init(168);		//延时初始化 
	uart_init(115200);	//串口初始化波特率为115200
	LED_Init();		  		//初始化与LED连接的硬件接口  
	while(1)
	{
		if(USART_RX_STA&0x8000)
		{					   
			len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
			printf("\r\n您发送的消息为:\r\n");
			for(t=0;t<len;t++)
			{
				USART_SendData(USART1, USART_RX_BUF[t]);         //向串口1发送数据
				while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
			}
			printf("\r\n\r\n");//插入换行
			USART_RX_STA=0;
		}else
		{
			times++;
			if(times%5000==0)
			{
				printf("\r\nALIENTEK 探索者STM32F407开发板 串口实验\r\n");
				printf("正点原子@ALIENTEK\r\n\r\n\r\n");
			}
			if(times%200==0)printf("请输入数据,以回车键结束\r\n");  
			if(times%30==0)LED0=!LED0;//闪烁LED,提示系统正在运行.
			delay_ms(10);   
		}
	}
}

串口中断

void USART1_IRQHandler(void)                	//串口1中断服务程序
{
	u8 Res;
#if SYSTEM_SUPPORT_OS 		//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
	{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	//读取接收到的数据
		
		if((USART_RX_STA&0x8000)==0)//接收未完成
		{
			if(USART_RX_STA&0x4000)//接收到了0x0d
			{
				if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
				else USART_RX_STA|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
				{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
				}		 
			}
		}   		 
  } 
#if SYSTEM_SUPPORT_OS 	//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
	OSIntExit();  											 
#endif
} 
#endif	

开启串口中断

如果需要开启中断的话。

void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT,FunctionalState NewState)

函数的第二个入口参数标识使能串口的类型，也就是使能哪种中断。

比如在接收到数据的时候（RXNE 读数据寄存器非空）要产生中断，那么我们开启中断的方法是：

USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断，接收到数据中断

我们在发送数据结束的时候（TC，发送完成）要产生中断，那么方法是：

USART_ITConfig(USART1，USART_IT_TC，ENABLE);

同时开启两个中断

USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断
USART_ITConfig(USART1, USART_IT_IDLE, ENABLE); //开启空闲中断

串口使能

串口使能是通过函数 USART_Cmd()来实现的，这个很容易理解，使用方法是：

USART_Cmd(USART1, ENABLE); //使能串口

函数

中断函数编写

void USART1_IRQHandler(void)函数是串口 1 的中断响应函数，当串口 1 发生了相应的中断后，就会跳到该函数执行。

 if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据

这里我们设计了一个小小的接收协议，具体协议参见F4开发指南5.3.3的145页。

具体函数：

void USART1_IRQHandler(void)                	//串口1中断服务程序
{
	u8 Res;
#if SYSTEM_SUPPORT_OS 		//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
	{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	//读取接收到的数据
		
		if((USART_RX_STA&0x8000)==0)//接收未完成
		{
			if(USART_RX_STA&0x4000)//接收到了0x0d
			{
				if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
				else USART_RX_STA|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
				{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
				}		 
			}
		}   		 
  } 
#if SYSTEM_SUPPORT_OS 	//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
	OSIntExit();  											 
#endif
} 

USART_GetITStatus

if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)   

使能了串口发送完成中断，那么当中断发生了， 我们便可以在中断处理函数中调用这个函数来判断到底是否是串口发送完成中断，方法是：

USART_GetITStatus(USART1, USART_IT_TC) 

USART_ReceiveData

STM32库函数操作USART_DR寄存器读取串口接收到的数据的函数是：

uint16_t USART_ReceiveData(USART_TypeDef* USARTx); 

通过该函数可以读取串口接受到的数据。

Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据

USART_SendData

STM32库函数操作USART_DR寄存器发送数据的函数是：

void USART_SendData(USART_TypeDef* USARTx, uint16_t Data); 

通过该函数向串口寄存器USART_DR写入一个数据。

USART_GetFlagStatus

读取串口状态的函数是：

FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)；

要判断读寄存器是否非空(RXNE)，操作库函数的方法是：

USART_GetFlagStatus(USART1, USART_FLAG_RXNE); 

#define USART_IT_PE                           ((uint16_t)0x0028) 
#define USART_IT_TC                           ((uint16_t)0x0626) 
#define USART_IT_RXNE                        ((uint16_t)0x0525) 
……//(省略部分代码) 
#define USART_IT_NE                           ((uint16_t)0x0260) 
#define USART_IT_FE                           ((uint16_t)0x0160) 

USART_ClearFlag

USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG); 

作用是清除相应的标志位，函数入口参数有两个，USART_TypeDef* USARTx和uint16_t USART_FLAG；

• USART_TypeDef* USARTx： 是对应的串口号，比如这里是串口1，就写USATR1；（注意：串口四在STM32F103里是UART4，少了一个‘S’，具体怎么表示可以右键，go to difinition 进行查看；

• uint16_t USART_FLAG：是清除的标志位，有接受标志位、发送标志位等等，结合使用情况，同样右键+go to difinition 进行查看，如下所示：

#define IS_USART_FLAG(FLAG) (((FLAG) == USART_FLAG_PE) || ((FLAG) == USART_FLAG_TXE) || \
                             ((FLAG) == USART_FLAG_TC) || ((FLAG) == USART_FLAG_RXNE) || \
                             ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_LBD) || \
                             ((FLAG) == USART_FLAG_CTS) || ((FLAG) == USART_FLAG_ORE) || \
                             ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE)) 

主函数调用

回到 main.c，在 main.c 里面编写如下代码：

int main(void)
{ 
 
	u8 t;
	u8 len;	
	u16 times=0;  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
	delay_init(168);		//延时初始化 
	uart_init(115200);	//串口初始化波特率为115200
	LED_Init();		  		//初始化与LED连接的硬件接口  
	while(1)
	{
		if(USART_RX_STA&0x8000)
		{					   
			len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
			printf("\r\n您发送的消息为:\r\n");
			for(t=0;t<len;t++)
			{
				USART_SendData(USART1, USART_RX_BUF[t]);         //向串口1发送数据
				while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
			}
			printf("\r\n\r\n");//插入换行
			USART_RX_STA=0;
		}else
		{
			times++;
			if(times%5000==0)
			{
				printf("\r\nALIENTEK 探索者STM32F407开发板 串口实验\r\n");
				printf("正点原子@ALIENTEK\r\n\r\n\r\n");
			}
			if(times%200==0)printf("请输入数据,以回车键结束\r\n");  
			if(times%30==0)LED0=!LED0;//闪烁LED,提示系统正在运行.
			delay_ms(10);   
		}
	}
}

串口使用总结

• 如果用到了中断，首先要配置嵌套中断向量组
• 嵌套中断向量组配置了就该配置中断优先级和中断通道
• 中断初始化，中断使能
• 根据串口挂载使能相应时钟，根据串口发送接收线使能相应端口
• 端口初始化
• 串口复位
• 设置串口参数(波特率，帧结构，收发模式)
• 串口初始化，串口使能
• 中断处理函数

端口重映射

为了使不同器件封装的外设 IO 功能数量达到最优，可以把一些复用功能重新映射到其他一些引脚上（remap）。

即一个外设的引脚除了具有默认的端口外，还可以通过设置重映射寄存器的方式，把这个外设的引脚映射到其它的端口。

简单的讲就是把管脚的外设功能映射到另一个管脚，但不是可以随便映射的，具体对应关系《STM32 中文参考手册 V10》

拿串口 1 为例来讲解。

从表中可以看出，默认情况下，串口 1 复用的时候的引脚位 PA9,PA10，同时我们可以将 TX 和 RX 重新映射到管脚 PB6 和 PB7 上面去。

串口重映射步骤

重映射我们同样要使能复用功能的时候讲解的 2 个时钟外，还要使能 AFIO 功能时钟，然后调用重映射函数。

1）使能 GPIOB 时钟：

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

2）使能串口 1 时钟：

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

3）使能 AFIO 时钟：

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

4）开启重映射：

GPIO_PinRemapConfig(GPIO_Remap_USART1, ENABLE);

USART1 只有一种重映射，而对于 USART3,存在部分重映射和完全重映射。所谓部分重映射就是部分管脚和默认的是一样的，而部分管脚是重新映射到其他管脚。而完全重映射就是所有管脚都重新映射到其他管脚。