USART

USART(Universal Synchronous/Asynchronous Receiver/Transmitter)是一个全双工通用同步/异步串行收发器，该接口是一个高度灵活的串行通信设备。对于USART常用的也是异步通信。

全双工通信（打电话）

通信允许数据在两个方向上同时传输，它在能力上相当于两个单工通信方式的结合。全双工指可以同时（瞬时）进行信号的双向传输（A→B且B→A）。指A→B的同时B→A，是瞬时同步的。通信允许数据在两个方向上同时传输，它在能力上相当于两个单工通信方式的结合。全双工指可以同时（瞬时）进行信号的双向传输（A→B且B→A）。指A→B的同时B→A，是瞬时同步的。

USART主要特征

全双工异步通信。

单线半双工通信。

单独的发送器和接收器使能位。

可配置使用DMA的多缓冲器通信。

多个带标志的中断源。

可编程数据字长度（8位或9位）。

● 可配置的停止位（支持1或2个停止位）。

字符帧

字符帧也叫数据帧，一帧数据由起始位、数据位、奇偶校验位和停止位组成，对于异步通信，要能够进行数据的正确传送，通信双方必须先约定好传送数据的速率和传送数据的组织格式，即波特率和字符帧的格式。

起始位：每开始一次通信时发送方先发出一个逻辑”0”的信号（低电平），表示传输字符的开始。

数据位：数据位可以是5、6、7、8，9位等，构成一个字符（一般都是8位）。如ASCII码（7位），扩展BCD码（8位）。先发送最低位，最后发送最高位，使用低电平表示‘0’高电平表示‘1’完成数据位的传输。

奇偶校验位：计算数据位中“1”的位数应为偶数(偶校验)或奇数(奇校验)，以此来校验数据传送的正确性，校验方式：

无校验（no parity）。

奇校验（odd parity）: 如果数据位中“1”的数目是偶数，则校验位为“1”，如果“1的数目是奇数，校验位为“0”。

偶校验（even parity）: 如果数据为中“1”的数目是偶数，则校验位为“0”，如果为奇数，校验位为“1”。

mark parity: 校验位始终为1 （不常用）。

parity: 校验位始终为0 （不常用）。

停止位：一个字符数据的结束标志。可以是0.5位、1位、1.5位、2位的高电平。

总之，使用UART串口协议传输数据时，需要规定双方的传输速率（波特率）一致，数据格式（起始位，数据位，奇偶校验为、停止位）也要保持一致。例如传递字符a时，字符a的一帧信息由起始位、数据位（字符a）、奇偶校验位（可选）、停止位组成。

设置USART的波特率

一般使用STM32CubeMX会自动配置波特率，不用自己进行配置。

USARTDIV = DIV_Mantissa + (DIV_Fraction / 16)，即当USARTDIV = 39.0625时，DIV_Mantissa为39（即0x27）,DIV_Fraction为0.625 * 16 = 1（即0x01）。

DIV_Mantissa：USARTDIV的整数部分

DIV_Fraction：USARTDIV的小数部分 * 16

USART相关寄存器介绍

寄存器	名称	作用
USART_CR1	控制寄存器1	配置USART工作参数
USART_CR2	控制寄存器2	配置USART工作参数
USART_CR3	控制寄存器3	配置USART工作参数
USART_SR	状态寄存器	查询当前USART传输状态（主要是位TC、RXNE）
USART_DR	数据寄存器	存放待发送数据和接收数据，有两个寄存器组成（TDR/RDR）

STM32的hal库关于USART的结构体

UART_HandleTypeDef

句柄结构体。

typedef struct __UART_HandleTypeDef
{
  USART_TypeDef  *Instance;  /* USARTx */

  UART_InitTypeDef  Init;  /* USART初始化结构体：通信参数 */

} UART_HandleTypeDef;

UART_InitTypeDef

USART初始化结构体。

typedef struct
{
  uint32_t BaudRate;  /* 波特率设置 */

  uint32_t WordLength;  /* 数据帧字长 */

  uint32_t StopBits;  /* 停止位设置 */

  uint32_t Parity;  /* 奇偶校验位控制 */

  uint32_t Mode;  /* UART模式选择 */

  uint32_t HwFlowCtl;  /* 硬件流控制选择 */

  uint32_t OverSampling;  /* 过采样选择 */

} UART_InitTypeDef;

STM32的hal库关于USART的函数

HAL_UART_Transmit()

以阻塞的方式向串口发送指定字节的数据，设定指定时间，超过指定时间后不再发送此次数据。

原型：HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)

参数：
UART_HandleTypeDef *huart：串口句柄
uint8_t *pData：向串口发送的数据的地址
uint16_t Size：向串口发送的数据的大小
uint32_t Timeout：此次数据发送的时间

实例：HAL_UART_Transmit(&huart1,(uint8_t *)"jiangxiaoya\n",strlen("jiangxiaoya\n"),100);

HAL_UART_Receive()

以阻塞的方式从串口接收指定字节的数据，设定指定时间，超过指定时间后不再接收此次数据。

原型：HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)

参数：
UART_HandleTypeDef *huart：串口句柄
uint8_t *pData：从串口接收的数据的存放地址
uint16_t Size：从串口接收的数据的大小（留一个字符存放 '\0' ）
uint32_t Timeout：此次数据接收的时间

实例：HAL_UART_Receive(&huart1,myData,sizeof(myData) - 1,100);

HAL_UART_Transmit_IT()

以中断的方式发送指定字节的数据。

原型：HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)

参数：
UART_HandleTypeDef *huart：串口句柄
uint8_t *pData：向串口发送的数据的地址
uint16_t Size：向串口发送的数据的大小

HAL_UART_Receive_IT()

以中断的方式接收指定字节的数据。

原型：HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)

参数：
UART_HandleTypeDef *huart：串口句柄
uint8_t *pData：从串口接收的数据的存放地址
uint16_t Size：从串口接收的数据的大小（留一个字符存放 '\0' ）

HAL_UART_TxCpltCallback()

串口发送数据完成回调函数，也就是串口每发送完x（x的值由HAL_UART_Transmit_IT函数决定）个字节数据会产生执行该函数，该函数是一个虚函数，我们可以在main.c文件中完成它的函数体

原型：__weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)

参数：
UART_HandleTypeDef *huart：串口句柄

HAL_UART_RxCpltCallback()

串口接收数据完成回调函数，也就是串口每接收完x（x的值由HAL_UART_Receive_IT函数决定）个字节数据会产生执行该函数，该函数是一个虚函数，我们可以在main.c文件中完成它的函数体

原型：__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)

参数：
UART_HandleTypeDef *huart：串口句柄

串口之非中断法

使用STM32CubeMX创建工程

配置SYS

配置RCC

配置串口信息

配置工程名称、工程路径

选择固件库

生成工程

使用MicroLIB库

main函数编写

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include <string.h>
#include <stdio.h>

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

//重写stdio.c文件中的prinft()里的fputc()函数
int fputc(int my_data,FILE *p)
{
    unsigned char temp = my_data;
    //改写后，使用printf()函数会将数据通过串口1发送出去
    HAL_UART_Transmit(&huart1,&temp,1,0xffff);  //0xfffff为最大超时时间
    return my_data;
}
    
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
    uint8_t myData[20] = {0};
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  //串口以阻塞的方式发送数据，超过时间后不再发送此次数据
  HAL_UART_Transmit(&huart1,(uint8_t *)"jiangxiaoya\n",strlen("jiangxiaoya\n"),100);  //单片机复位后，会发送一个数据

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    //串口以阻塞的方式接收数据，超过时间后不再接收此次数据
    HAL_UART_Receive(&huart1,myData,sizeof(myData) - 1,100);  
        
    printf("%s\r\n",myData);  //向串口发送数据
    memset(myData,0,sizeof(myData));
        
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

疑难点分析

改写stdio.c中的fputc()函数，以便能使用printf()向串口发送数据

//重写stdio.c文件中的prinft()里的fputc()函数
int fputc(int my_data,FILE *p)
{
    unsigned char temp = my_data;
    //改写后，使用printf()函数会将数据通过串口一发送出去
    HAL_UART_Transmit(&huart1,&temp,1,0xffff);  //0xfffff为最大超时时间
    return my_data;
}

串口之中断法

串口中断流程

USART1_IRQHandler()：由硬件调用，当串口收到中断就会调用此函数，此函数一般调用HAL_UART_IRQHandler()函数。

HAL_UART_IRQHandler()：该函数用来判断是串口发送数据还是串口接收数据引起的中断，如果是串口接收数据引起的中断则调用UART_Receive_IT()函数。

UART_Receive_IT()：此函数可以指定串口每接收几个字节数据调用一次回调函数，即HAL_UART_RxCpltCallback()函数。

HAL_UART_RxCpltCallback()：串口接收完成回调函数，一般用来对串口接收的数据进行处理。

串口数据接收的状态标记变量

该变量可以自行命名，是一个uint16_t 类型的变量如uint16_t UART1_RX_STA = 0。串口每接收到一个数据时，该变量就自增1，当串口接收到回车（0x0d和0x0a），即串口的缓存数据全部接收完成，让该变量的bit16置1，表示数据全部接收完成。

uint16_t UART1_RX_STA
bit 15	bit 14	bit 13~0
接收数据完成标志	接收0x0d标志	接收到有效数据个数标志

串口接收缓存和接收缓冲

接收缓存：存放串口每次接收的数据（uint8_t buf=0;）

接收缓冲：存放接收缓存（uint8_t UART1_RX_Buffer[USART_REC_LEN] = {'\0'}; ）

串口每接收一个字节就会调用一次串口接收数据完成回调函数（HAL_UART_RxCpltCallback()），因此，需要在串口接收数据完成回调函数中对串口每一次接收的数据进行处理，即把数据存放到接收缓冲中。

使用STM32CubeMX创建工程

配置SYS

配置RCC

配置串口信息

配置NVIC

配置工程名称、工程路径

选择固件库

生成工程

usart.c文件编写

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "usart.h"

/* USER CODE BEGIN 0 */

#include <stdio.h>
#include <string.h>

#define USART_REC_LEN 200

//串口接收缓存（1字节）
uint8_t buf=0;

uint8_t UART1_RX_Buffer[USART_REC_LEN];  //接收缓冲，串口接收的数据存放地点

//串口接收状态，16位
uint16_t UART1_RX_STA = 0;
//bit15： 如果是1表示接收完成
//bit14： 如果是1表示接收到回车(0x0d)
//bit13~bit0： 接收到的有效字节数目

/* USER CODE END 0 */

UART_HandleTypeDef huart1;

/* USART1 init function */

void MX_USART1_UART_Init(uint32_t my_baud)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = my_baud;  /* 波特率可以自己传入 */
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

    /* 开启串口1的接收中断 */
    HAL_UART_Receive_IT(&huart1,&buf,1);  /* 每接收一个串口数据调用一次串口接收完成回调函数 */
    
  /* USER CODE END USART1_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* USART1 clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);  
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspDeInit 0 */

  /* USER CODE END USART1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART1_CLK_DISABLE();

    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);

    /* USART1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/* 重写stdio.h文件中的prinft()里的fputc()函数 */
int fputc(int my_data,FILE *p)
{
    unsigned char temp = my_data;
    //改写后，使用printf()函数会将数据通过串口一发送出去
    HAL_UART_Transmit(&huart1,&temp,1,0xffff);  //0xfffff为最大超时时间
    return my_data;
}

/* 串口接收完成回调函数 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    //判断中断是哪个串口触发的
    if(huart->Instance == USART1){
        
        //判断接收是否完成，即判断UART1_RX_STA的bit15是否为1
        if(!(UART1_RX_STA & 0x8000)){  //如果没接收完成就进入接收流程
            
            //判断是否接收到回车0x0d
            if(UART1_RX_STA & 0x4000){
                
                //判断是否接收到换行0x0a
                if(buf == 0x0a){
                    
                    //如果回车和换行都接收到了，则表示接收完成,即把bit15拉高
                    UART1_RX_STA |= 0x8000;
                }else{  //如果接收到回车0x0d没有接收到换行0x0a
                    
                    //则认为接收错误，重新开始接收
                    UART1_RX_STA = 0;
                }
            }else{  //如果没有接收到回车0x0d
                
                //则判断收到的这个字符是否是回车0x0d
                if(buf == 0x0d){  
                    
                    //如果这个字符是回车，则将将bit14拉高，表示接收到回车
                    UART1_RX_STA |= 0x4000;   
                }else{  //如果不是回车
                    
                    //则将这个字符存放到缓存数组中
                    UART1_RX_Buffer[UART1_RX_STA & 0x3ffff] = buf;
                    UART1_RX_STA++;
                    
                    //如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
                    if(UART1_RX_STA > USART_REC_LEN - 1){
                        UART1_RX_STA = 0;
                    }
                }
            }
        }
        //如果接收完成则重新开启串口1的接收中断
        HAL_UART_Receive_IT(&huart1, &buf, 1);  
    }
}

/* 对串口接收数据的处理 */
void usart1_receive_data_handle()
{
  /* 判断判断串口是否接收完成 */
  if (UART1_RX_STA & 0x8000)
  {
    printf("接收完成\r\n");

    // 串口接收完数据后，对串口数据进行处理
    // 接收到open，点灯
    if (!strcmp((const char *)UART1_RX_Buffer, "open"))
    {
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);

      if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
      {
        printf("%s\r\n", "开灯");
      }
    }
    // 接收到close，关灯
    else if (!strcmp((const char *)UART1_RX_Buffer, "close"))
    {
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);

      if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
      {
        printf("%s\r\n", "关灯");
      }
    }
    // 接收到其他数据，进行报错
    else
    {
      if (UART1_RX_Buffer[0] != '\0')
      {
        printf("%s\r\n", "输入错误");
      }
    }

    // 换行，重新开始下一次接收
    memset(UART1_RX_Buffer, 0, USART_REC_LEN);
    //printf("\r\n");
    UART1_RX_STA = 0;
  }
}

/* USER CODE END 1 */

usart.h文件编写

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.h
  * @brief   This file contains all the function prototypes for
  *          the usart.c file
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USART_H__
#define __USART_H__

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

extern UART_HandleTypeDef huart1;

/* USER CODE BEGIN Private defines */

/* USER CODE END Private defines */

void MX_USART1_UART_Init(uint32_t my_baud);

/* USER CODE BEGIN Prototypes */

void usart1_receive_data_handle(void);

/* USER CODE END Prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __USART_H__ */

main.c文件编写

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init(115200);  /* 传入波特率115200 */
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
        
        usart1_receive_data_handle();
        HAL_Delay(40);
    }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

疑难点分析

fputc()函数分析

改写stdio.c中的fputc()函数，以便能使用printf()向串口发送数据

//重写stdio.c文件中的prinft()里的fputc()函数
int fputc(int my_data,FILE *p)
{
    unsigned char temp = my_data;
    //改写后，使用printf()函数会将数据通过串口一发送出去
    HAL_UART_Transmit(&huart1,&temp,1,0xffff);  //0xfffff为最大超时时间
    return my_data;
}

串口接收回调函数分析

当在main.c串口初始化后调用HAL_UART_Receive_IT()开始串口接收第一个字节数据，当接收到一个字节（即接收到接收缓存buf中）后就会产生中断进入接收回调函数对接收的数据进行处理

如果该字节不是0x0d或0x0a则存到接收缓冲中

如果该字节是0x0d，则串口数据接收的状态标记变量不再增加，等待接收到0x0a。

如果没有接收到0x0a则认为此次接收失败，则重新开始下一次接收。如果在接下来的100个字符内一直接收不到0x0a，则将UART1_RX_STA的bit14置0，表示没有接收到0x0d。

如果接收到了0x0a，则UART1_RX_STA的bit15置1表示数据全部接收完成，并等待该位被其他程序清除，重新开始下一次的串口接收。

如果迟迟没有接收到0x0d，那么在接收字节超过USART_REC_LEN时，摈弃前面的数据，重新开始接收数据。

/* 串口接收完成回调函数 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    //判断中断是哪个串口触发的
    if(huart->Instance == USART1){
        
        //判断接收是否完成，即判断UART1_RX_STA的bit15是否为1
        if(!(UART1_RX_STA & 0x8000)){  //如果没接收完成就进入接收流程
            
            //判断是否接收到回车0x0d
            if(UART1_RX_STA & 0x4000){
                
                //判断是否接收到换行0x0a
                if(buf == 0x0a){
                    
                    //如果回车和换行都接收到了，则表示接收完成,即把bit15拉高
                    UART1_RX_STA |= 0x8000;
                }else{  //如果接收到回车0x0d没有接收到换行0x0a
                    
                    //则认为接收错误，重新开始接收
                    UART1_RX_STA = 0;
                }
            }else{  //如果没有接收到回车0x0d
                
                //则判断收到的这个字符是否是回车0x0d
                if(buf == 0x0d){  
                    
                    //如果这个字符是回车，则将将bit14拉高，表示接收到回车
                    UART1_RX_STA |= 0x4000;   
                }else{  //如果不是回车
                    
                    //则将这个字符存放到缓存数组中
                    UART1_RX_Buffer[UART1_RX_STA & 0x3ffff] = buf;
                    UART1_RX_STA++;
                    
                    //如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
                    if(UART1_RX_STA > USART_REC_LEN - 1){
                        UART1_RX_STA = 0;
                    }
                }
            }
        }
        //如果接收完成则重新开启串口1的接收中断
        HAL_UART_Receive_IT(&huart1, &buf, 1);  
    }
}

STM32之USART

USART

全双工通信（打电话）

USART主要特征

字符帧

设置USART的波特率

USART相关寄存器介绍

STM32的hal库关于USART的结构体

UART_HandleTypeDef

UART_InitTypeDef

STM32的hal库关于USART的函数

HAL_UART_Transmit()

HAL_UART_Receive()

HAL_UART_Transmit_IT()

HAL_UART_Receive_IT()

HAL_UART_TxCpltCallback()

HAL_UART_RxCpltCallback()

串口之非中断法

使用STM32CubeMX创建工程

配置SYS

配置RCC

配置串口信息

配置工程名称、工程路径

选择固件库

生成工程

使用MicroLIB库

main函数编写

疑难点分析

串口之中断法

串口中断流程

串口数据接收的状态标记变量

串口接收缓存和接收缓冲

使用STM32CubeMX创建工程

配置SYS

配置RCC

配置串口信息

配置NVIC

配置工程名称、工程路径

选择固件库

生成工程

usart.c文件编写

usart.h文件编写

main.c文件编写

疑难点分析

fputc()函数分析

串口接收回调函数分析

猜你喜欢