011 - STM32学习笔记 - 串口通讯

最新推荐文章于 2024-10-12 22:35:47 发布

放学校门口见

最新推荐文章于 2024-10-12 22:35:47 发布

阅读量645

点赞数

分类专栏： stm32 文章标签： stm32 单片机学习

本文链接：https://blog.csdn.net/guanxiaozhi/article/details/131168843

版权

stm32 专栏收录该内容

35 篇文章 26 订阅

订阅专栏

011 - STM32学习笔记 - 串口通讯

关于串口的相关概念各位可以在网上查一下相关介绍，这里直接开始学习STM32上的串口配置和通讯测试了

在学习相关寄存器之前，先看一下USART的功能框图

在这里插入图片描述

1、USART引脚

引脚名称	引脚功能
TX	数据发送端
RX	数据接收端
SW_RX	单线或者智能卡模式下使用，属于内部引脚，未引出外部引脚
SCLK	时钟，同步通讯时使用
nRTS	请求发送
nCTS	允许发送

F429提供了8个串口，其中USART1和USART6挂载于APB2总线下，其余挂载在APB1总线，其中1、2、3、6为同步串口，其余的均为异步串口，从下面的表中可以看出，1、2、3、6均具备SCLK、nCTS、nRTS引脚，其余的没有。

	USART1	USART6	USART2	USART3	UART4	UART5	UART7	UART8
TX	PA9/PB6	PC6/PG14	PA2/PD5	PB10/PD8/PC10	PA0/PC10	PC12	PF7/PE8	PE1
RX	PA10/PD7	PC7/PG9	PA3/PD6	PB11/PD9/PC11	PA1/PC11	PD2	PF6/PE7	PE0
SCLK	PA8	PG7/PC8	PA4/PD7	PB12/PD10/PC12	/	/	/	/
nCTS	PA11	PG13/PG15	PA0/PD3	PB13/PD11	/	/	/	/
nRTS	PA12	PG8/PG12	PA1/PD4	PB14/PD12	/	/	/	/

2、数据控制寄存器

a、数据寄存器USART_DR

包含一个发送数据寄存器TDR和一个解手数据寄存器RDR，9位有效，接收到数据字符或已发送的数据字符，具体取决于所执行的操作是“读取”操作还是
“写入”操作，即当向USART_DR中写入数据时，为TDR，当从USART_DR中读取数据时，作为RDR。

b、USART_CR1控制寄存器1

位13：UE，USART使能，写0：禁止，写1：使能。

位12：M，控制串口数据的字长，该位写0时，表示1起始位、8数据位、n停止位，写1时，1起始位、9数据位、n停止位。在发送和接受期间改为不得更改。

位10：PCE，奇偶校验控制使能，写0禁止，写1使能，是能后计算出的奇偶校验位将被插入MSB位（当M=0时，插入第8位，M=1，插入第9位）。

位9：PS，奇偶校验选择，写0，为偶校验，写1，为奇校验。

位8：PEIE，PE 中断使能，写0：禁止中断，写1：当 USART_SR 寄存器中 PE=1 时，即出现奇偶校验错误时，生成 USART 中断

位3：TE，发送器使能，UE位使能后，该位写1使能发送，写0禁止发送；

位2：RE，接收器使能，UE位使能后，该位写1允许接收，写0禁止接收；

c、USART_CR2控制寄存器2

位13：12用来设置停止位。写00： 1 个停止位，写01： 0.5 个停止位，写10： 2 个停止位，写11： 1.5 个停止位，其中0.5和1.5个停止位不适用于UART4和UART5.

d、USART_SR状态寄存器

位7：TXE，发送数据寄存器为空，当串口发送数据时，会先读取此位状态，若此位为空，系统会将USART_DR中的数据送入TDR寄存器中后，此位由硬件置1，通过发送位移控制器将数据一位一位的发送出去，当数据全部下发完成后，此位会由硬件置0。

位5：RXNE，读取数据寄存器不为空，当RDR 移位寄存器的内容已传输到USART_DR寄器时，该位由硬件置1，如果USART_CR1 寄存器中 RXNEIE = 1，则会生成中断。通过对 USART_DR 寄存器执行读入操作将该位清零。

3、USART_BRR 波特率寄存器

波特率的计算公式为：
$B a u d r a t e = f pl c k / (8 * (2 - O V ER 8) * U S A RT D I V)$
其中fplck为串口时钟，这里需要注意当前操作的串口时钟是在APB1还是APB2上，USARTDIV为无符号的定点数，OVER8为过采样模式（在USART_CR1中，该位寄存器写0为16倍过采样，写1为8倍过采样）

USARTDIV的计算公式应该为：
$USARTDIV = DIV\_Mantissa + DIV\_Fraction / 16$
其中DIV_Mantissa 为整数部分，DIV_Fraction 为小数部分（小数部分取整即可）。

波特率以115200为例，USART1挂载在APB2下，时钟为90M，OVER8设置为0，16倍过采样，那么计算下来USARTDIV = 48.5125，整数部分为48，即DIV_Mantissa = 0x30，小数部分DIV_Fraction = 0.825125 * 16 ≈ 13 = 0xD。（这里火哥自己也绕进去了，没有详细讲明白，查了一些资料才知道是这么算）所以最终往USART_BRR中写入的应该是0x30D。

串口相关的结构体定义位于stm32f4xx_usart.h中，常用的结构体如下：

//串口初始化结构体
typedef struct
{
  uint32_t USART_BaudRate;            	/* 串口波特率BRR */
  uint16_t USART_WordLength;          	/* 串口数据位CR1_M */
  uint16_t USART_StopBits;            	/* 串口停止位CR2_STOP */
  uint16_t USART_Parity;              	/* 串口校验CR1_PCE、CR1_PS */
  uint16_t USART_Mode;                	/* 串口模式CR1_TE、CR1_RE */
  uint16_t USART_HardwareFlowControl; 	/* 指定是否启用硬件流控CR3_CTSE、CR3_RTSE */
} USART_InitTypeDef;

//同步时钟初始化结构体
typedef struct
{
  uint16_t USART_Clock;   	/* 串口时钟使能 CR2_CLKEN */
  uint16_t USART_CPOL;    	/* 极性 CR2_CPOL */
  uint16_t USART_CPHA;    	/* 相位 CR2_CPHA */
  uint16_t USART_LastBit; 	/* 最后一个位的时钟脉冲 CR2_LBC */
} USART_ClockInitTypeDef;

再看一下USART的初始化函数

void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)
{
  uint32_t tmpreg = 0x00, apbclock = 0x00;
  uint32_t integerdivider = 0x00;
  uint32_t fractionaldivider = 0x00;
  RCC_ClocksTypeDef RCC_ClocksStatus;

  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate));  
  assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength));
  assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits));
  assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity));
  assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode));
  assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl));

  /* The hardware flow control is available only for USART1, USART2, USART3 and USART6 */
  if (USART_InitStruct->USART_HardwareFlowControl != USART_HardwareFlowControl_None)
  {
    assert_param(IS_USART_1236_PERIPH(USARTx));
  }
/*---------------------------- USART CR2 Configuration -----------------------*/
  tmpreg = USARTx->CR2;
  /* Clear STOP[13:12] bits */
  tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);
  /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit :
      Set STOP[13:12] bits according to USART_StopBits value */
  tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits;
  /* Write to USART CR2 */
  USARTx->CR2 = (uint16_t)tmpreg;
/*---------------------------- USART CR1 Configuration -----------------------*/
  tmpreg = USARTx->CR1;
  /* Clear M, PCE, PS, TE and RE bits */
  tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK);
  /* Configure the USART Word Length, Parity and mode: 
     Set the M bits according to USART_WordLength value 
     Set PCE and PS bits according to USART_Parity value
     Set TE and RE bits according to USART_Mode value */
  tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity |
            USART_InitStruct->USART_Mode;
  /* Write to USART CR1 */
  USARTx->CR1 = (uint16_t)tmpreg;
/*---------------------------- USART CR3 Configuration -----------------------*/  
  tmpreg = USARTx->CR3;
  /* Clear CTSE and RTSE bits */
  tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK);
  /* Configure the USART HFC : 
      Set CTSE and RTSE bits according to USART_HardwareFlowControl value */
  tmpreg |= USART_InitStruct->USART_HardwareFlowControl;
  /* Write to USART CR3 */
  USARTx->CR3 = (uint16_t)tmpreg;
/*---------------------------- USART BRR Configuration -----------------------*/
  /* Configure the USART Baud Rate */
  RCC_GetClocksFreq(&RCC_ClocksStatus);
  if ((USARTx == USART1) || (USARTx == USART6))
  {
    apbclock = RCC_ClocksStatus.PCLK2_Frequency;
  }
  else
  {
    apbclock = RCC_ClocksStatus.PCLK1_Frequency;
  }
  /* Determine the integer part */
  if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
  {
    /* Integer part computing in case Oversampling mode is 8 Samples */
    integerdivider = ((25 * apbclock) / (2 * (USART_InitStruct->USART_BaudRate)));    
  }
  else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
  {
    /* Integer part computing in case Oversampling mode is 16 Samples */
    integerdivider = ((25 * apbclock) / (4 * (USART_InitStruct->USART_BaudRate)));    
  }
  tmpreg = (integerdivider / 100) << 4;
  /* Determine the fractional part */
  fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
  /* Implement the fractional part in the register */
  if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
  {
    tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
  }
  else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
  {
    tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
  }
  /* Write to USART BRR register */
  USARTx->BRR = (uint16_t)tmpreg;
}

使用到的固件库函数

//GPIO复用功能配置
void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF)；		//位于stm32f4xx_gpio.h
    
//中断配置函数
void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);	//位于stm32f4xx_usart.h

//串口使能函数
void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);						  //位于stm32f4xx_usart.h

//数据发送函数
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);								 //位于stm32f4xx_usart.h

//数据接收函数
uint16_t USART_ReceiveData(USART_TypeDef* USARTx);										//位于stm32f4xx_usart.h

//中断状态位获取函数
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);					 //位于stm32f4xx_usart.h

在使用串口时，这里我用到的的是PA9和PA10这两个GPIO，其中，PA9作为发送端口，PA10作为接收端口，对于这两个IO口的外设，在配置是需要配置为复用功能，英雌这里需要对引脚进行端口复用功能设置。

/* 初始化GPIO */
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;          /* 配置GPIO端口为推挽 */
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;            /* 配置GPIO端口为上拉 */
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;       /* 配置GPIO端口输出速度为50MHz */

/* 配置TX端口为复用功能 */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;            /* 配置GPIO端口输出模式为复用 */
GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_TX_PIN;      /* 配置GPIO端口输出为串口模式 */
GPIO_Init(DEBUG_USART1_TX_PORT,&GPIO_InitStructure);    /* 初始化端口 */

/* 配置RX端口为复用功能 */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;            /* 配置GPIO端口输出模式为复用 */
GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_RX_PIN;      /* 配置GPIO端口输出为串口模式 */
GPIO_Init(DEBUG_USART1_RX_PORT,&GPIO_InitStructure);    /* 初始化端口 */

/* 连接PX到USARTx_Tx */
GPIO_PinAFConfig(DEBUG_USART1_TX_PORT,DEBUG_USART1_TX_SOURCE,DEBUG_USART1_TX_AF);

/* 连接PX到USARTx_Rx */
GPIO_PinAFConfig(DEBUG_USART1_RX_PORT,DEBUG_USART1_RX_SOURCE,DEBUG_USART1_RX_AF);

上面程序中，第7行和第12行，分别对PA9和PA10端口配置为复用功能，到第17行和20行，是将端口GPIOA中的GPIO_PinSource9和GPIO_PinSource10，分别连接到串口发送和串口接收功能。关于串口复用功能的定义在stm32f4xx_gpio中有函数实现和声明，可以看一下，后面学习到IIC或者CAN的时候还会用到。

/* 配置串口模式 波特率设置为DEBUG_USART1_BAUDRATE = 115200，8位字长，1位停止位，无校验，收发模式 */
USART_InitStructure.USART_BaudRate = DEBUG_USART1_BAUDRATE;
/* 设置字长：8位 */
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
/* 设置停止位：1个停止位 */
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;

上面程序中，对串口进行了详细配置，如果我们需要用中断进行串口的收发，还需要配置NVIC

static void NVIC_Configuration()
{
    NVIC_InitTypeDef NVIC_InitStructure;
    /* 嵌套向量控制器组选择为组2 */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    /* 配置USART1为中断源 */
    NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART1_IRQ;
    /* 主优先级为1 */
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    /* 子优先级为1 */
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    /* 使能中断 */
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    /* 初始化配置NVIC */
    NVIC_Init(&NVIC_InitStructure);
}

以上配置完成后，可以对串口、中断进行初始化，并且使能串口。

/* 初始化串口 */
USART_Init(DEBUG_USART1,&USART_InitStructure);
/* 配置中断向量控制器 */
NVIC_Configuration();
/* 使能串口接收中断 */
USART_ITConfig(DEBUG_USART1, USART_IT_RXNE, ENABLE);
/* 串口使能 */
USART_Cmd(DEBUG_USART1,ENABLE);

bsp_usart.c完整程序如下

#include "bsp_usart.h"
static void NVIC_Configuration()
{
    NVIC_InitTypeDef NVIC_InitStructure;
    /* 嵌套向量控制器组选择为组2 */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    /* 配置USART1为中断源 */
    NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART1_IRQ;
    /* 主优先级为1 */
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    /* 子优先级为1 */
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    /* 使能中断 */
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    /* 初始化配置NVIC */
    NVIC_Init(&NVIC_InitStructure);
}

void DEBUG_USART1_Config(void)
{
    /* 初始化串口GPIO  */
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    /* 只要是操作外设，一定要先打开外设的时钟！！！！！ */
    /* 打开PA9,PA10端口时钟 */
    RCC_AHB1PeriphClockCmd(DEBUG_USART1_RX_CLK|DEBUG_USART1_TX_CLK,ENABLE);
    /* 打开USART1时钟 */
    RCC_APB2PeriphClockCmd(DEBUG_USART1_CLK,ENABLE);
    /* 初始化GPIO */
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;          /* 配置GPIO端口为推挽 */
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;            /* 配置GPIO端口为上拉 */
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;       /* 配置GPIO端口输出速度为50MHz */
    
    /* 配置TX端口为复用功能 */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;            /* 配置GPIO端口输出模式为复用 */
    GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_TX_PIN;      /* 配置GPIO端口输出为串口模式 */
    GPIO_Init(DEBUG_USART1_TX_PORT,&GPIO_InitStructure);    /* 初始化端口 */
    
    /* 配置RX端口为复用功能 */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;            /* 配置GPIO端口输出模式为复用 */
    GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_RX_PIN;      /* 配置GPIO端口输出为串口模式 */
    GPIO_Init(DEBUG_USART1_RX_PORT,&GPIO_InitStructure);    /* 初始化端口 */
    
    /* 连接PX到USARTx_Tx */
    GPIO_PinAFConfig(DEBUG_USART1_TX_PORT,DEBUG_USART1_TX_SOURCE,DEBUG_USART1_TX_AF);
    /* 连接PX到USARTx_Rx */
    GPIO_PinAFConfig(DEBUG_USART1_RX_PORT,DEBUG_USART1_RX_SOURCE,DEBUG_USART1_RX_AF);
    
    /* 配置串口模式 波特率设置为DEBUG_USART1_BAUDRATE = 115200，8位字长，1位停止位，无校验，收发模式 */
    USART_InitStructure.USART_BaudRate = DEBUG_USART1_BAUDRATE;
    /* 设置字长：8位 */
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    /* 设置停止位：1个停止位 */
    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(DEBUG_USART1,&USART_InitStructure);
    /* 配置中断向量控制器 */
    NVIC_Configuration();
    /* 使能串口接收中断 */
	USART_ITConfig(DEBUG_USART1, USART_IT_RXNE, ENABLE);
    /* 串口使能 */
    USART_Cmd(DEBUG_USART1,ENABLE);
}

以上完成后，可以在进一步实现串口的收发功能函数了。

void Usart_SendByte(USART_TypeDef *pUSARTx,uint8_t ch)
{
    /* 发送一个字节到USART1 */
    USART_SendData(pUSARTx,ch);
    /* 等待发送完成 */
    while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TXE) == RESET);
}

/*****************  发送字符串 **********************/
void Usart_SendString( USART_TypeDef * pUSARTx, char *str)
{
    unsigned int k=0;
    do 
    {
        Usart_SendByte( pUSARTx, *(str + k) );
        k++;
    }while(*(str + k)!='\0');
    /* 等待发送完成 */
    while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET);
}
/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
    uint8_t temp_h, temp_l;

    /* 取出高八位 */
    temp_h = (ch&0XFF00)>>8;
    /* 取出低八位 */
    temp_l = ch&0XFF;

    /* 发送高八位 */
    USART_SendData(pUSARTx,temp_h);	
    while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);

    /* 发送低八位 */
    USART_SendData(pUSARTx,temp_l);	
    while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

测试一下串口的发送功能：

#include "stm32f4xx.h"
#include "bsp_systick.h"
#include "bsp_usart.h"
#include <stdio.h>

int main(void)
{ 
    SysTick_Init();
    DEBUG_USART1_Config();
    while(1)
    {
 
        Usart_SendString(DEBUG_USART1,"串口发送数据1\n");
        Delay_us(100000);
        printf("串口发送数据2\n");
        Delay_us(100000);
    }
}

然后采用中断实现串口的接收，实现内容为，串口接收到PC数据后，将数据在发送回PC：

void DEBUG_USART1_IRQHandler(void)
{
    uint8_t ucTemp;
    if(USART_GetFlagStatus(DEBUG_USART1,USART_IT_RXNE) != RESET)
    {
        ucTemp = USART_ReceiveData(DEBUG_USART1);
        printf("这是串口中断接收返回的数据：%c\n",ucTemp);
    }
}

之前在学习标准库的工程配置时，提到在KEIL中勾选上Use MircoLIB，是为了后续使用到串口时，可以方便的调用C的标注库函数printf，来直接输出串口信息。所以这里重定向C的标准库函数。

///重定向c库函数printf到串口，重定向后可使用printf函数，需调用#include <stdio.h>
int fputc(int ch, FILE *f)
{
    /* 发送一个字节数据到串口 */
    USART_SendData(DEBUG_USART1, (uint8_t) ch);
    /* 等待发送完毕 */
    while (USART_GetFlagStatus(DEBUG_USART1, USART_FLAG_TXE) == RESET);		
    return (ch);
}

///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
    /* 等待串口输入数据 */
    while (USART_GetFlagStatus(DEBUG_USART1, USART_FLAG_RXNE) == RESET);
    return (int)USART_ReceiveData(DEBUG_USART1);
}

学习以上内容后，可以实现PC通过串口下发指令，STM32接收到后，根据指令控制LED灯的亮灭和颜色。

#include "stm32f4xx.h"
#include "bsp_led.h"
#include "bsp_systick.h"
#include "bsp_usart.h"
#include <stdio.h>
void LED_CTRL(uint8_t ch)
{
    switch(ch)
    {
        case '1':				//指令1，红灯亮
            LED_RED;
            break;
        case '2':				//指令2，绿灯亮
            LED_GREEN;
            break;
        case '3':				//指令3，蓝灯亮
            LED_BLUE;
            break;
        default:				//其他，红灯亮
            LED_OFF;
    }
}
int main(void)                      //这里需要注意，必须关闭串口中断，否则字符会被中断接走，就没法控制灯了
{
    uint8_t ch;
    LED_Config();
    EXTI_Key_Config();
    SysTick_Init();
    DEBUG_USART1_Config();
    /* 关闭串口接收中断使能 */
	USART_ITConfig(DEBUG_USART1, USART_IT_RXNE, DISABLE);
    
    /* 关闭串口接收中断使能后，需要对串口重新使能 */
    USART_Cmd(DEBUG_USART1,ENABLE);
    while(1)
    {
        uint8_t ch = getchar();
        printf("%c\n",ch);
        USART_ITConfig(DEBUG_USART1, USART_IT_RXNE, DISABLE);
        LED_CTRL(ch);
    }
}

bsp_usart.h

#ifndef __BSP_USART_H__
#define __BSP_USART_H__

#include "stm32f4xx.h"
#include <stdio.h>

#define DEBUG_USART1             USART1
#define DEBUG_USART1_CLK         RCC_APB2Periph_USART1
#define DEBUG_USART1_BAUDRATE    115200

#define DEBUG_USART1_RX_PORT     GPIOA
#define DEBUG_USART1_RX_CLK      RCC_AHB1Periph_GPIOA
#define DEBUG_USART1_RX_PIN      GPIO_Pin_10
#define DEBUG_USART1_RX_AF       GPIO_AF_USART1
#define DEBUG_USART1_RX_SOURCE   GPIO_PinSource10

#define DEBUG_USART1_TX_PORT     GPIOA
#define DEBUG_USART1_TX_CLK      RCC_AHB1Periph_GPIOA
#define DEBUG_USART1_TX_PIN      GPIO_Pin_9
#define DEBUG_USART1_TX_AF       GPIO_AF_USART1
#define DEBUG_USART1_TX_SOURCE   GPIO_PinSource9

#define DEBUG_USART1_IRQHandler  USART1_IRQHandler
#define DEBUG_USART1_IRQ         USART1_IRQn

void DEBUG_USART1_Config(void);
void Usart_SendByte(USART_TypeDef *pUSARTx,uint8_t ch);
void Usart_SendString(USART_TypeDef *pUSARTx,char *ch);

void Usart_SendHalfWord(USART_TypeDef * pUSARTx, uint16_t ch);
#endif /* __BSP_USART_H__ */