STM32 Learning Notes-USART Interrupt

/************************************
* File name: main.c
* Description: This example demonstrates how to operate the USART receiving program (interrupt mode).
* Use the serial port debugging software to send a byte to the development board, and the development board will send the byte back to the PC
*/
#include "stm32f10x_lib.h"
/***************************************************
* Function name: void RCC_Configuration()
* Function description: Reset and clock control configuration
* Parameter: None
* Return value: None
* Global variables: None
* Global static variables: None
* Local static variables: None
***********************************************************/
void RCC_Configuration()
{
ErrorStatus HSEStartUpStatus; //Define the external high-speed crystal oscillator startup status enumeration variable
RCC_DeInit(); //Reset the RCC external register to the default value
RCC_HSEConfig(RCC_HSE_ON); //Turn on the external high-speed crystal oscillator
HSEStartUpStatus=RCC_WaitForHSEStartUp(); //Wait for the external high-speed clock to be readyif

(HSEStartUpStatus==SUCCESS){ //External high-speed clock is ready

FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); //Enable the FLASH pre-read buffer function to speed up the reading of FLASH. Required usage in all programs, location: in the RCC initialization subfunction, after the clock starts
FLASH_SetLatency(FLASH_Latency_2); //FLASH timing delays for several cycles, waiting for bus synchronization operation. It is recommended to follow the operating frequency of the microcontroller system, when 0-24MHz, take Latency=0; when 24-48MHz, take Latency=1; when 48~72MHz, take Latency=2.

RCC_HCLKConfig(RCC_SYSCLK_Div1); //Configure AHB (HCLK) == system clock / 1
RCC_PCLK2Config(RCC_HCLK_Div1); //Configure APB2 (high speed) (PCLK2) == system clock / 1
RCC_PCLK1Config(RCC_HCLK_Div2); //Configure APB1 (low speed) (PCLK1) == system clock / 2
//Note: AHB is mainly responsible for external memory clock. APB2 is responsible for AD, I/O, advanced TIM, serial port 1. APB1 is responsible for DA, USB, SPI, I2C, CAN, serial port 2345, ordinary TIM.


RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9); //Configure PLL clock == (external high-speed crystal clock/1) * 9 ==72MHz
RCC_PLLCmd(ENABLE); //Enable PLL clock
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET); //Wait for PLL clock to be ready
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); //Configure system clock == PLL clock
while(RCC_GetSYSCLKSource()!=0x08); //Wait for system clock source to start
}

//------------------------The following is the operation to enable peripheral clock-----------------------//
// RCC_AHBPeriphClockCmd (ABP2 device 1 | ABP2 device 2, ENABLE); //Start AHB device
// RCC_APB2PeriphClockCmd(ABP2 device 1 | ABP2 device 2, ENABLE); //Start ABP2 device
// RCC_APB1PeriphClockCmd(ABP2Device1 | ABP2Device2, ENABLE); //Start ABP1 device

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_USART1, ENABLE); //Open APB2 peripherals
}

/*************************************************
* Function name: NVIC_Configuration(void)
* Function description: NVIC (Nested Interrupt Controller) configuration
* Parameters: None
* Return value: None
* Global variables: None
* Global static variables: None
* Local static variables: None
*************************************************/
void NVIC_Configuration()
{
NVIC_InitTypeDef NVIC_InitStructure; //Define an interrupt structure

// NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0); //Set the starting address of the interrupt vector table to 0x08000000
// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); //Set the NVIC priority grouping method.
//Note: There are 16 priorities in total, divided into preemptive and responsive. The number of the two priorities is determined by this code. NVIC_PriorityGroup_x can be 0, 1, 2, 3, 4,
//representing the preemptive priority of 1, 2, 4, 8, 16 and the responsive priority of 16, 8, 4, 2, 1. After specifying the number of two priorities, all interrupt levels must be selected from them.
//The high preemptive level will interrupt other interrupts and give priority to execution, while the high responsive level will give priority to execution after other interrupts are executed.

NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel; //Channel is set to serial port 1 interrupt
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //Interrupt response priority 0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //Turn on interrupt
NVIC_Init(&NVIC_InitStructure); //Initialization
}

/********************************************
* Function name: GPIO_Configuration()
* Function description: GPIO configuration
* Parameters: None
* Return value: None
* Global variables: None
* Global static variables: None
* Local static variables: None
******************************************/
void GPIO_Configuration()
{
GPIO_InitTypeDef GPIO_InitStructure; //Define GPIO initialization structure

//--------Set USART1's TX Configured as multiplexed push-pull output AF_PP---------------------//
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //Pin position definition, the label can be NONE, ALL, 0 to 15.
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_2MHz; //Output speed 2MHz
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //Push-pull output mode Out_PP
GPIO_Init(GPIOA,&GPIO_InitStructure); //GPIO initialization of group E

//--------Configure the RX of USART1 as multiplexed floating input IN_FLOATING---------------------//
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10; //Pin position definition
//It is meaningless to configure the output speed in input mode
//GPIO_InitStructure.GPIO_Speed=GPIO_Speed_2MHz; //Output speed 2MHz
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING; //Floating input IN_FLOATING
GPIO_Init(GPIOA,&GPIO_InitStructure); //C group GPIO initialization


}

/********************************************************
* Function name: USART1_Configuration()
* Function description: Configure USART1 data format, baud rate and other parameters
* Parameters: None
* Return value: None
* Global variables: None
* Global static variables: None
* Local static variables: None
*******************************************************/
void USART1_Configuration()
{
USART_InitTypeDef USART_InitStructure; //Serial port settings restore default parameters

USART_InitStructure.USART_BaudRate = 115200; //Baud rate 115200
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //Word length 8 bits
USART_InitStructure.USART_StopBits = USART_StopBits_1; //1-bit stop byte
USART_InitStructure.USART_Parity = USART_Parity_No; //No parity check
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //No flow control
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //Turn on Rx receiving and Tx sending functions
USART_Init(USART1, &USART_InitStructure); //Initialize
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //If the receive data register is full, an interrupt is generated
USART_Cmd(USART1, ENABLE); //Start the serial port

//-----The following statement solves the problem that the first byte cannot be sent correctly-----//
USART_ClearFlag(USART1, USART_FLAG_TC); // Clear flag
}
/********This is the interrupt service subroutine, in stm32f10x_it.c****************************/
void USART1_IRQHandler(void)
{
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //If the receive data register is full
{
USART_SendData(USART1, USART_ReceiveData(USART1)); //Send back to PC
while(USART_GetFlagStatus(USART1, USART_IT_TXE)==RESET);//Wait for sending to be completed
}
}

/******************************************************
* Function name: main()
* Function description: Main function
* Parameter: None
* Return value: None
* Global variables: None
* Global static variables: None
* Local static variables: None
************************************************/
int main()
{
RCC_Configuration();
GPIO_Configuration();
NVIC_Configuration() );
USART1_Configuration();

while(1){
}
}