1、HAL库UART 中断|DMA 自动回显接收数据

原创 已于 2025-07-31 19:04:09 修改 · 1.1k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单片机 #stm32 #嵌入式硬件

于 2023-02-15 14:46:58 首次发布
文章详细介绍了如何在STM32F4微控制器上使用HAL库配置UART，包括开启宏定义、初始化函数、DMA和中断设置。通过HAL_UART_Init()和HAL_UART_MspInit()函数进行硬件层和外设层的初始化，实现了UART的DMA中断接收和中断接收两种模式，同时提供了串口重定向函数fputc()以支持printf()功能。此外，文章还提到了CubeMX配置中断和DMA接收数据回显的步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、实现代码：

stm32f4xx_hal_conf.h文件开启UART宏定义

#define HAL_UART_MODULE_ENABLED

添加stm32f4xx_hal_uart.c和stm32f4xx_hal_dma.c到自己工程；
编写好的代码：usart_Driver.c

/**********************************************************************
*file:串口驱动
*author:残梦
*date:2023.2.13
*note:
**********************************************************************/
#include "usart_Driver.h"

#define UART1_BAUDRATE 2000000 //波特率
#define UART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
#define UART1_RX_GPIO_PORT              GPIOA
#define UART1_RX_GPIO_PIN               GPIO_PIN_10
#define UART1_RX_AF                     GPIO_AF7_USART1

#define UART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
#define UART1_TX_GPIO_PORT              GPIOA
#define UART1_TX_GPIO_PIN               GPIO_PIN_9
#define UART1_TX_AF                     GPIO_AF7_USART1

UART_HandleTypeDef huart1;

#ifndef _UART1_RX_MODE
    DMA_HandleTypeDef hdma_usart1_rx;
#endif
uint8_t huart1_RxData[50] = {0};
/****************************************************
@function:串口1初始化
@param:void
@return:void
@date:2023.2.13
@note:
****************************************************/
void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1;
    huart1.Init.BaudRate = UART1_BAUDRATE;
    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();}

    #ifdef _UART1_RX_MODE
        HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));
    #else
        HAL_UART_Receive_DMA(&huart1,huart1_RxData,sizeof(huart1_RxData));
    #endif
}

/****************************************************
@function:串口1
@param:void
@return:void
@date:2023.2.13
@note:
****************************************************/
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    __HAL_RCC_USART1_CLK_ENABLE();
    UART1_RX_GPIO_CLK_ENABLE();
    UART1_TX_GPIO_CLK_ENABLE();

    //外设引脚初始化
    GPIO_InitStruct.Pin = UART1_RX_GPIO_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = UART1_RX_AF;
    HAL_GPIO_Init(UART1_RX_GPIO_PORT, &GPIO_InitStruct);
    GPIO_InitStruct.Pin = UART1_TX_GPIO_PIN;
    GPIO_InitStruct.Alternate = UART1_TX_AF;
    HAL_GPIO_Init(UART1_TX_GPIO_PORT, &GPIO_InitStruct);

    #ifdef _UART1_RX_MODE
        HAL_NVIC_SetPriority(USART1_IRQn,1,0);
        HAL_NVIC_EnableIRQ(USART1_IRQn);
    #else
        __HAL_RCC_DMA2_CLK_ENABLE();
        hdma_usart1_rx.Instance = DMA2_Stream2;
        hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
        hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
        hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
        hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
        hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
        hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
        hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;
        hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
        hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
        hdma_usart1_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;
        hdma_usart1_rx.Init.MemBurst = DMA_MBURST_SINGLE;
        hdma_usart1_rx.Init.PeriphBurst = DMA_PBURST_SINGLE;
        if(HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK){Error_Handler();}

        __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);//关联DMA句柄
        HAL_NVIC_SetPriority(DMA2_Stream2_IRQn,0,0);
        HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
    #endif
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发

    #ifdef _UART1_RX_MODE
        HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));//中断方式接收则需开启，否则会导致接收完指定数据个数后自动关闭
    #endif
}

usart_Driver.h

#ifndef _usart_Driver_H_
#define _usart_Driver_H_
#include "Common_Driver.h"
//#define _UART1_RX_MODE //未定义--DMA方式接收,定义--中断接收方式

extern UART_HandleTypeDef huart1;
extern void MX_USART1_UART_Init(void);

#endif

在stm32f4xx_it.c文件中添加中断处理函数：

/* USER CODE BEGIN 1 */
#include "usart_driver.h"
#ifdef _UART1_RX_MODE
void USART1_IRQHandler(void)
{
  extern UART_HandleTypeDef huart1;
  HAL_UART_IRQHandler(&huart1);
}
#else
void DMA2_Stream2_IRQHandler(void)
{
  extern DMA_HandleTypeDef hdma_usart1_rx;
  HAL_DMA_IRQHandler(&hdma_usart1_rx);
}
#endif
/* USER CODE END 1 */
```c
/****************************************************
@function:串口重定义
@param:void
@return:void
@date:2023.2.14
@note:使用printf时需要此函数，并在Keil魔术棒中勾选User MicroLIB库
****************************************************/
int fputc(int ch,FILE *f)
{
    uint8_t data = ch;
	HAL_UART_Transmit(&huart1,&data,1,1);
	return(ch);
}

主函数调用MX_USART1_UART_Init();即可实现自收自发
在这里插入图片描述

2、电路推荐：CH340N

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3、初始化处理框架 MX_USART1_UART_Init()

void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1;
    huart1.Init.BaudRate = UART1_BAUDRATE;
    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();}

    #ifdef _UART1_RX_MODE
        HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));
    #else
        HAL_UART_Receive_DMA(&huart1,huart1_RxData,sizeof(huart1_RxData));
    #endif
}

OverSampling ：过采样
8倍过采样速度更快，最高速度可达fPCLK/8，fPCLK为USART时钟；
16倍过采样速度虽然没有8倍过采样那么快，但得到的数据更加精准，其最大速度为fPCLK/16；

那么HAL_UART_Init()里面做了什么呢？

移除参数检查，提取主要后

HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
{
  if (huart->gState == HAL_UART_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    huart->Lock = HAL_UNLOCKED;
    /* Init the low level hardware : GPIO, CLOCK */
    HAL_UART_MspInit(huart);
  }

  huart->gState = HAL_UART_STATE_BUSY;

  /* Disable the peripheral */
  __HAL_UART_DISABLE(huart);

  /* Set the UART Communication parameters */
  UART_SetConfig(huart);

  /* In asynchronous mode, the following bits must be kept cleared:
     - LINEN and CLKEN bits in the USART_CR2 register,
     - SCEN, HDSEL and IREN  bits in the USART_CR3 register.*/
  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

  /* Enable the peripheral */
  __HAL_UART_ENABLE(huart);

  /* Initialize the UART state */
  huart->ErrorCode = HAL_UART_ERROR_NONE;
  huart->gState = HAL_UART_STATE_READY;
  huart->RxState = HAL_UART_STATE_READY;

  return HAL_OK;
}

所以这个函数顺序则先通过函数HAL_UART_MspInit()初始化底层硬件:GPIO, CLOCK
再调用UART_SetConfig()设置时串口通信参数
__HAL_UART_ENABLE()启用外围设备

那么HAL_UART_MspInit()里面做了什么呢？

该函数主要是初始化底层硬件：GPIO、CLOCK、DMA、中断
开启DMA时需要关联句柄

__HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);//关联DMA句柄

为什么使用的是DMA2_Stream2 且通道4呢
在这里插入图片描述
可以看到USART1挂载在APB2上
在这里插入图片描述
在这里插入图片描述
由此知晓DMA使用的流和通道

启动中断|DMA去接收数据

中断接收函数：HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
1、使用此函数值得注意的是此函数Size参数代表接收的数据个数，在接收完该个数后会自动关闭中断，导致后续数据不去接收了**
所以在接收到数据回调函数中需要再次调用此函数

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发

    #ifdef _UART1_RX_MODE
        HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));//中断方式接收则需开启，否则会导致接收完指定数据个数后自动关闭
    #endif
}

2、使用前需开启串口中断

    HAL_NVIC_SetPriority(USART1_IRQn,1,0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);

**DMA中断接收函数：HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
1、使用前需要开启DMA中断并关联DMA句柄

    __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);//关联DMA句柄
    HAL_NVIC_SetPriority(DMA2_Stream2_IRQn,0,0);
    HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);

中断函数调用HAL库处理函数中的处理

在stm32f4xx_it.c文件中添加中断处理函数：HAL_外设名_IRQHandler（）；
如HAL_UART_IRQHandler()或者HAL_DMA_IRQHandler()；
注意：在HAL_UART_IRQHandler（）函数中会调用函数：
函数中会在接收完指定数据个数后会执行的关闭中断（在使用函数HAL_UART_Receive_IT（）时）

static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
{
 ......省略
    if (--huart->RxXferCount == 0U)//此处就是在接收完指定数据个数后会执行的关闭中断
    {
      /* Disable the UART Data Register not empty Interrupt */
      __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);

      /* Disable the UART Parity Error Interrupt */
      __HAL_UART_DISABLE_IT(huart, UART_IT_PE);

      /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
      __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);

      /* Rx process is completed, restore huart->RxState to Ready */
      huart->RxState = HAL_UART_STATE_READY;

      /* Check current reception Mode :
         If Reception till IDLE event has been selected : */
      if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
      {
      	......
      }
      else
      {
        /*Call legacy weak Rx complete callback*/
        HAL_UART_RxCpltCallback(huart);
      }
    }
 ......省略
}

HAL_DMA_IRQHandler（）函数可是不会去关闭的哈

4、CubeMx UART 中断接收回显数据

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
生成代码即可
在这里插入图片描述
1、main.h中包含stdio.h文件

/* USER CODE BEGIN Includes */
#include "stdio.h"
/* USER CODE END Includes */

2、usart.c中
定义接收数据区变量

/* USER CODE BEGIN 0 */
uint8_t huart1_RxData[50] = {0};
/* USER CODE END 0 */

MX_USART1_UART_Init（）函数中添加数据中断接收函数：

  /* USER CODE BEGIN USART1_Init 2 */
  HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));
  /* USER CODE END USART1_Init 2 */

添加回调函数并发送接收到的数据

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发
  HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));//中断方式接收则需开启，否则会导致接收完指定数据个数后自动关闭
}

编写串口重定义函数，方便使用printf()

/****************************************************
@function:串口重定义
@param:void
@return:void
@date:2023.2.14
@note:使用printf时需要此函数，并在Keil魔术棒中勾选User MicroLIB库
****************************************************/
int fputc(int ch,FILE *f)
{
    uint8_t data = ch;
	HAL_UART_Transmit(&huart1,&data,1,1);
	return(ch);
}

在这里插入图片描述
usart.c

/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */

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

/* USER CODE BEGIN 0 */
uint8_t huart1_RxData[50] = {0};
/* USER CODE END 0 */

UART_HandleTypeDef huart1;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  /* 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 = 2000000;
  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 */
  HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));
  /* 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_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    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 */
/****************************************************
@function:串口重定义
@param:void
@return:void
@date:2023.2.14
@note:使用printf时需要此函数，并在Keil魔术棒中勾选User MicroLIB库
****************************************************/
int fputc(int ch,FILE *f)
{
    uint8_t data = ch;
	HAL_UART_Transmit(&huart1,&data,1,1);
	return(ch);
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发
  HAL_UART_Receive_IT(&huart1, huart1_RxData, sizeof(huart1_RxData));//中断方式接收则需开启，否则会导致接收完指定数据个数后自动关闭
}

/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

UART 中断接收完整工程：
链接：https://pan.baidu.com/s/1p34JFrjOUl2_IsnvZBSn0w
提取码：au2o

## 5、CubeMx UART DMA中断接收回显数据

注意：除了USART1外其他配置和CubeMx UART 中断接收回显数据一样
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
产生工程代码
1、usart.c中
定义接收数据区变量

/* USER CODE BEGIN 0 */
uint8_t huart1_RxData[50] = {0};
/* USER CODE END 0 */

MX_USART1_UART_Init（）函数中添加数据DMA中断接收函数：

  /* USER CODE BEGIN USART1_Init 2 */
  HAL_UART_Receive_DMA(&huart1,huart1_RxData,sizeof(huart1_RxData));
  /* USER CODE END USART1_Init 2 */

添加回调函数并发送接收到的数据

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发
}

在这里插入图片描述
usart.c

/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */

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

/* USER CODE BEGIN 0 */
uint8_t huart1_RxData[50] = {0};
/* USER CODE END 0 */

UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_rx;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  /* 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 = 2000000;
  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 */
  HAL_UART_Receive_DMA(&huart1,huart1_RxData,sizeof(huart1_RxData));
  /* 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_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART1 DMA Init */
    /* USART1_RX Init */
    hdma_usart1_rx.Instance = DMA2_Stream2;
    hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);

  /* 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 DMA DeInit */
    HAL_DMA_DeInit(uartHandle->hdmarx);
  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    HAL_UART_Transmit(&huart1,huart1_RxData,sizeof(huart1_RxData),10);//自收自发
}
/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

UART DMA接收完整工程：
链接：https://pan.baidu.com/s/15aVMAqIVg8DrLjlPVGY5ag
提取码：3nmu

UART DMA或者中断发送完成可以依靠如下实现：
while(!(huart1.Instance->SR & (0x01 << 6)))osDelay(1);//判断TC发送完成标志

回调函数传参c++_STM32Cube HAL库中断处理机制，以及回调函数实现原理
weixin_39851008的博客
10-22 1801
置顶/星标公众号，不错过每一条消息！ 最近有较多关于STM32Cube HAL的问题，侧面反应了使用STM32CubeMX的人不少。所以，最近可能会重点写这方面内容。1写在前面很多人都知道STM32CubeMX这套工具的一个目的：减少开发者对STM32底层驱动的开发时间，把重心放在应用代码上。但是，STM32CubeMX只是生成了底层驱动的初始化代码。所以，我们还需要掌握：应用层代...
HAL库(STM32CubeMX)——USART串口配置学习(中断接收/STM32G431RBT6)
贾saisai的博客
03-17 1万+
UART与USART介绍： USART(universal synchronous asynchronous receiver and transmitte): 通用同步异步收发器 USART是一个串行通信设备，可以灵活地与外部设备进行全双工数据交换。 UART(universal asynchronous receiver and transmitter): 通用异步收发器 异步串行通信口(UART)就是我们在嵌入式中常说的串口，它还是一种通用的数据通信议。 区别： USART是指单片机
STM32 Hal库(学习记录)三、DMA的中断回调
2301_81080862的博客
02-15 1232
在HAL_SPI_Transmit_DMA这类函数内部将DMA的回调函数指向了SPI的回调函数，最终在使用SPI的DMA发送时，实际的回调函数是SPI的回调函数。为 SPI_HandleTypeDef中的（DMA_HandleTypeDef *hdmatx;在spi.c对dma和spi初始化中就将hdma_spi1_tx和hspi联系起来了。DMA回调函数定义在DMA_HandleTypeDef（作用是另 hspi1->hdmatx = &为 hdma_spi1_tx。
【DMA专栏】DMA 回调函数的实时性
u010971180的博客
06-16 725
优化方向方法效果轻量化回调只唤醒主任务，不处理复杂逻辑降低中断延迟延后处理机制使用 workqueue / tasklet / softirq提升实时性和并发能力绑定CPU核心设置 affinity减少上下文切换使用 RT 内核开启 PREEMPT_RT 支持支持硬实时调度创建实时线程使用SCHED_FIFO线程精确控制调度优先级避免睡眠操作不用mutexkmallocprintk提高稳定性零拷贝机制减少数据复制开销。
基于HAL库的串口通信（使用中断收发数据）
m0_63061253的博客
10-26 4737
了解串口协议和RS-232标准，以及RS232电平与TTL电平的区别；了解"USB/TTL转232"模块（以CH340芯片模块为例）的工作原理。使用HAL库创建项目之后，实现以下功能：当上位机给stm32发送一个字符“#”后，stm32暂停发送“hello windows！”；发送一个字符“*”后，stm32继续发送
通讯的分类—UART的工作原理及其使用方法—HAL库的代码解读—利用USART回显
weixin_67335336的博客
08-15 2295
通讯的分类、USART的工作原理及其使用方法、HAL库的代码解读、利用USART回显。
STM32CubeMX HAL库串口+DMA+IDLE空闲中断不定长度数据接收和发送
热门推荐
CSDN_Xu_xue的博客
02-22 1万+
本文开发环境： MCU型号：STM32F103ZET6 IDE环境： MDK 5.29 代码生成工具：STM32CubeMx 5.3.0 HAL库版本：STM32Cube_FW_F1_V1.8.0（STM32Cube MCU Package for STM32F1xx Series） 本文内容： 不定长数据接收的原理 IDLE空闲中断介绍 串口接收IDLE空闲中断的配置 串口收发DMA线的...
真正实现了STM32 HAL串口不定长数据的接收发送功能(DMA方式，不用限定单次接收长度和添加结束标志)
06-08
自己阅读STM32 HAL的文档，写出了一个Demo程序，可以实现回显功能(就是通过给STM32发送不定长的数据，可以实现一模一样接收发送的数据），在STM32F429IGT6上验证过，跑了一天没有出现丢失数据的问题，使用DMA发送与...
STM32HAL库CubeMx FreeRTOS 消息队列 DMA串口空闲中断接收消息
Troubadour~的博客
04-21 5698
本文主要讲在FreeRTOS中使用消息队列传输串口接收到的不定长数据，主要传指针。串口方面使用DMA接收，然后串口空闲中断进行接收数据的管理。原理：创建一个消息队列、创建串口数据缓冲区结构体数组。数组长度多少，队列长度就有多长。该结构体至少包含数据缓冲区和数据大小，后面有代码演示的。创建完成后让DMA接收的数据放在结构体里的数据缓冲区里面，然后用指针指向这整个结构体，最后通过消息队列发送出去。
(USART接收溢出卡死)STM32CUBEMX HAL库 USART+DMA+ESP8266模块透传，接收不定长数据的一些踩坑点
m0_57259932的博客
09-27 887
STM32CUBEMX HAL库 USART+DMA+ESP8266模块透传，接收不定长数据的一些踩坑点
第 72 天：UART + DMA 实现无阻塞串口通信 —— 嵌入式高效数据交互的工程实战
最新发布
努力分享一些人工智能、计算机视觉、影像等相关的知识干货！
07-06 672
在嵌入式系统中，串口（UART）是最常用的通信接口之一。传统串口采用轮询或中断方式，在数据量较大或通信频繁场景下容易造成 CPU 阻塞或丢包。借助 DMA，可以实现 UART 的**无阻塞发送与接收**，极大提高数据处理效率。本文以 STM32 系列芯片为基础，深入解析 UART + DMA 的配置方法、发送与接收的独立路径设计、空闲中断机制与环形缓冲区管理，最终通过实战案例实现一个高效、稳定的嵌入式串口通信框架。
stm32f103基于HAL库下DMA+空闲中断实现任意长度数据接收
07-27
stm32f103基于HAL库下DMA+串口空闲中断实现任意长度数据接收，减小CPU占用。
处理STM32 DMA方式下的HAL_UART_ERROR_ORE错误
jingling122的博客
06-03 1581
1. 检查并调整DMA和UART配置 确保初始化顺序：需要确保USART的CR寄存器UE位开关留到最后打开，即完成USART和DMA的所有配置初始化后再使能USART。这样可以避免初始化顺序不当导致的通信问题。 配置合适的DMA缓冲区：确保DMA缓冲区足够大，可以容纳预期接收的数据量。参考文章中没有直接提及DMA缓冲区大小的具体建议，但这是一个需要考虑的因素。 2. 优化中断处理 定期检测ORE错误：需要定期检测ORE溢出错误，并通过读取寄存器、清空ORE标志来处理。这可以通过在主循环中检查USA
c++ 回调函数_STM32 HAL库学习系列第8篇---回调函数总结
weixin_39917791的博客
11-26 520
原文首发于同名微信公号「Allen5G」，欢迎大家搜索关注！普通函数与回调函数的区别：就是ST将中断封装，给使用者的API，就是标准库的中断函数对普通函数的调用：调用程序发出对普通函数的调用后，程序执行立即转向被调用函数执行，直到被调用函数执行完毕后，再返回调用程序继续执行。从发出调用的程序的角度看，这个过程为“调用-->等待被调用函数执行完毕-->继续执行”对回调函数调用：调用程序发...
stm32f0xx 的HAL 库 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart) 函数异常
Terrys0518的专栏
06-16 6521
最近使用stm32f030c8t6串口，使用DMA的方式接收和发送数据。DMA使用IDLE中断接收不定长数据void HAL_UART_IDLEHandler(UART_HandleTypeDef * huartx) { uint32_t tmp_flag = 0; uint32_t temp; tmp_flag = __HAL_UART_GET_IT(huartx,UART_IT_IDL...
HAL库——UART的DMA接收中的一些问题
jcsm__的博客
10-23 1万+
上篇简单的说明了如何通过DMA的方式接收UART数据，看着这个UART的DMA接收很简单，为了弄明白DMA中断和UART中断之间的关系，还是要看一下程序是如何完成这些看似简单的操作。首先先说一下整个接收的过程： 启动UART的DMA接收（这里面还定义了DMA回调函数）：HAL_UART_Receive_DMA 接收完成后，请求DMA中断（判断中断的类型）：HAL_DMA_IRQHandler ...
STM32—HAL库中断/DMA控制和完成串口通信
cainiao1311的博客
12-06 3925
串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式，因为它简单、便捷，因此大部分电子设备都支持该通讯方式，电子工程师在调试设备时也经常使用该通 讯方式输出调试信息。在计算机科学里，大部分复杂的问题都可以通过分层来简化。如芯片被分为内核层和片上外设；STM32标准库则是在寄存器与用户代码之间的软件层。对于通讯协议，我们也以分层的方式来理解，最基本的是把它分为物理层和协议层。名称组成作用物理层具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输协议层。
HAL库STM32串口开启DMA接收数据
m0_58832575的博客
11-18 1498
此博客仅仅作为记录，这个像是有bug一样，有时候好使，有时候不好，所以趁现在好使赶紧记录一下，很多地方用到串口接收数据，DMA又是一种非常好的接收方式，可以节约CPU的时间，提高利用率，首先是在CubeMX的配置，这个很简单，首先配置成异步收发。最后需要在串口中断函数stm32f1xx_it.c操作一些东西，首先在此函数中引用usart.h文件，否则会报错。在while（1）中的代码操作，就是判断标志位，然后把接收到的数据打印出来。首先就是必须勾选，要不然打印不了数据，使用DMA发送数据的时候，可能。
STM32 hal库DMA中断实验
sea1216的博客
02-17 8796
//DMA内存传输到串口完成中断实验，自己编写回调函数并注册到dma句柄即可 usart.h--------extern DMA_HandleTypeDef hdma_usart1_tx; main.c---------- int i=0; void USART1_DMA_TX_CpltCallback( struct __DMA_HandleTypeDef * hdma); int main(v...
stm32hal库串口中断接收
03-21
<think>嗯，用户想了解如何使用STM32 HAL库实现串口中断接收功能，还要示例代码。首先，我需要回顾一下HAL库的串口中断处理流程。记得HAL库提供了中断处理函数，比如HAL_UART_IRQHandler，但用户需要自己编写回调函数来处理接收完成的事件。 首先，用户可能已经用STM32CubeMX配置了串口，但需要确认是否开启了中断。在CubeMX中，启用USART的全局中断是必须的，否则无法触发中断。然后，初始化部分要调用HAL_UART_Init，接着启动接收，使用HAL_UART_Receive_IT函数，这个函数会启动中断接收，并设置接收缓冲区和长度。 接下来，中断服务函数的问题。HAL库已经处理了大部分底层的中断标志，用户只需要在stm32f1xx_it.c中调用HAL_UART_IRQHandler，然后实现HAL_UART_RxCpltCallback回调函数。这个回调函数会在接收完成时被调用，用户可以在里面处理接收到的数据，比如回显或者存储。 用户可能遇到接收卡死的问题，比如没有及时重启接收中断，或者在回调函数中做了太多操作，导致中断被阻塞。这时候需要确保在回调函数中尽快处理数据，并重新启动接收。例如，在回调函数里调用HAL_UART_Receive_IT再次启动接收，以等待下一个数据。 示例代码方面，可能需要展示CubeMX的配置步骤，比如选择USART1，设置波特率，开启中断，生成代码。然后添加用户代码，在main函数中启动接收，并实现回调函数。还要注意volatile变量来存储接收数据，避免编译器优化导致的问题。 另外，用户可能对HAL库的函数不太熟悉，需要解释HAL_UART_Receive_IT的参数，比如huart指向串口句柄，pData是缓冲区指针，Size是接收的字节数。还要提醒错误处理，检查返回值，确保接收启动成功。 可能还需要提到DMA方式与中断方式的区别，但用户明确要求中断接收，所以可以暂不展开。不过如果提到性能优化，可能可以建议在后续问题中探讨。 最后，确保回答结构清晰，分步骤说明配置和代码实现，并给出常见问题的解决方法，比如接收卡死的可能原因，如未重新启动接收中断。同时引用提供的参考资料，比如引用[1]提到的接收卡死问题，引用[2]和[3]中的HAL库函数说明。</think>### STM32 HAL库串口中断接收实现方法 #### 一、实现步骤 1. **CubeMX配置** - 启用USART模块并配置参数（波特率/数据位/校验位） - 在NVIC Settings中勾选USART全局中断使能 - 生成代码时选择生成HAL库初始化代码 2. **关键代码实现** ```c // 在main.c中添加全局变量 volatile uint8_t rx_buffer[1]; // 单字节接收缓冲区 int main(void) { HAL_Init(); SystemClock_Config(); MX_USART1_UART_Init(); // 启动中断接收 HAL_UART_Receive_IT(&huart1, rx_buffer, 1); while (1) { // 主循环处理其他任务 } } // 中断回调函数 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART1) { // 处理接收到的数据（示例：回显） HAL_UART_Transmit(&huart1, rx_buffer, 1, 100); // 重新启动接收 HAL_UART_Receive_IT(&huart1, rx_buffer, 1); } } ``` #### 二、关键函数说明 1. `HAL_UART_Receive_IT()`：启动非阻塞接收 - 参数：串口句柄/接收缓冲区指针/接收数据长度 - 返回值：HAL_OK表示启动成功 2. `HAL_UART_RxCpltCallback()`：接收完成回调函数 - 在中断服务程序中被自动调用 - 必须重新调用`HAL_UART_Receive_IT()`以持续接收 #### 三、常见问题解决 1. **接收卡死**：确保在回调函数中重新启动接收[^1] 2. **数据丢失**：使用循环缓冲区并提高中断优先级 3. **波特率误差**：通过CubeMX时钟树配置确保波特率精度 #### 四、完整示例流程图 ``` CubeMX配置 ↓ 生成初始化代码 ↓ main()启动中断接收 ↓ 中断触发→调用HAL_UART_IRQHandler ↓ 自动调用RxCpltCallback ↓ 处理数据并重启接收 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值