STM32CubeMX之串口使用（中断方式）

程序员文章站 2022-06-08 20:49:51

...

概述

上一篇说了 STM32CubeMX之串口的使用 (阻塞模式) ，这一章来说说串口中断模式收发数据。

文章目录

概述
一. 在STM32CubeMX 图形化中开启串口中断
二. 串口中断相关函数介绍
三. 串口中断函数使用实例
四. HAL库中的串口相关源码介绍

环境：

开发板：STM32F4探索者（正点原子）

一. 在STM32CubeMX 图形化中开启串口中断

在前一篇 STM32CubeMX之串口的使用 (阻塞模式) 的文章的基础上，打开串口中断，如下图所示：

STM32CubeMX之串口使用（中断方式）

然后就可以生成工程了

二. 串口中断相关函数介绍

串口中断函数

如串口1中断函数： USART1_IRQHandler()

发送接收函数

串口中断模式发送: HAL_UART_Transmit_IT()

HAL_StatusTypeDef HAL_UART_Transmit_IT(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)

串口实例的指针
接收数据缓冲块的首地址，如数组的首地址
想要接收数据的个数

三. 串口中断函数使用实例

在 stm32f4xx_it.c 中，先看一下串口中断函数有没有添加上，如下图所示：

STM32CubeMX之串口使用（中断方式）

现在就可以使用中断相关发送接收函数了

在这里为了方便测试,我添加了一个如下结构体并进行了初始化：

STM32CubeMX之串口使用（中断方式）

发送数据

在主函数中，5s 进行一次发送

STM32CubeMX之串口使用（中断方式）

发送成功产生回调，该函数在main.c 中

STM32CubeMX之串口使用（中断方式）

然后在主程序中查询到发送成功，打印 send done

STM32CubeMX之串口使用（中断方式）

接收数据

在进入循环的之前，就说明串口要进行10个字节的数据接收

STM32CubeMX之串口使用（中断方式）

接收10个字节成功产生回调，该函数在main.c 中

STM32CubeMX之串口使用（中断方式）

然后在主函数中，查询是否接收成功

STM32CubeMX之串口使用（中断方式）

最后运行程序，可以在串口调试助手上显示

STM32CubeMX之串口使用（中断方式）

注意:

若定长串口中断接收数据，数据溢出，将会产生数据溢出错误，中断不再接收数据，如下图：

STM32CubeMX之串口使用（中断方式）

错误回调函数如下：

//错误回调
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    if( rxtx_it_usart.huart1 == huart)
    {
       printf("error %d\r\n",huart->ErrorCode); 
    }
}

以上例子，代码已上传

四. HAL库中的串口相关源码介绍

串口中断函数中的处理函数 HAL_UART_IRQHandler

/**
  * @brief  This function handles UART interrupt request.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
  uint32_t isrflags   = READ_REG(huart->Instance->SR);
  uint32_t cr1its     = READ_REG(huart->Instance->CR1);
  uint32_t cr3its     = READ_REG(huart->Instance->CR3);
  uint32_t errorflags = 0x00U;
  uint32_t dmarequest = 0x00U;

  /* If no error occurs */
  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
  if (errorflags == RESET)
  {
    /* UART in mode Receiver -------------------------------------------------*/
    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    {
      UART_Receive_IT(huart);
      return;
    }
  }

  /* If some errors occur */
  if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
  {
    /* UART parity error interrupt occurred ----------------------------------*/
    if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
    {
      huart->ErrorCode |= HAL_UART_ERROR_PE;
    }

    /* UART noise error interrupt occurred -----------------------------------*/
    if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
    {
      huart->ErrorCode |= HAL_UART_ERROR_NE;
    }

    /* UART frame error interrupt occurred -----------------------------------*/
    if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
    {
      huart->ErrorCode |= HAL_UART_ERROR_FE;
    }

    /* UART Over-Run interrupt occurred --------------------------------------*/
    if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
    {
      huart->ErrorCode |= HAL_UART_ERROR_ORE;
    }

    /* Call UART Error Call back function if need be --------------------------*/
    if (huart->ErrorCode != HAL_UART_ERROR_NONE)
    {
      /* UART in mode Receiver -----------------------------------------------*/
      if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
      {
        UART_Receive_IT(huart);
        //  printf("rcv agin error %d\r\n",huart->ErrorCode);
      }

      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
         consider error as blocking */
      dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
      if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
      {
        /* Blocking error : transfer is aborted
           Set the UART state ready to be able to start again the process,
           Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
        UART_EndRxTransfer(huart);

        /* Disable the UART DMA Rx request if enabled */
        if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
        {
          CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);

          /* Abort the UART DMA Rx stream */
          if (huart->hdmarx != NULL)
          {
            /* Set the UART DMA Abort callback :
               will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
            huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
            if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
            {
              /* Call Directly XferAbortCallback function in case of error */
              huart->hdmarx->XferAbortCallback(huart->hdmarx);
            }
          }
          else
          {
            /* Call user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
            /*Call registered error callback*/
            huart->ErrorCallback(huart);
#else
            /*Call legacy weak error callback*/
            HAL_UART_ErrorCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
          }
        }
        else
        {
          /* Call user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
          /*Call registered error callback*/
          huart->ErrorCallback(huart);
          
#else
          /*Call legacy weak error callback*/
          HAL_UART_ErrorCallback(huart);
          //printf("dma over error \r\n");
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
        }
      }
      else
      {
        /* Non Blocking error : transfer could go on.
           Error is notified to user through user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
        /*Call registered error callback*/
        huart->ErrorCallback(huart);
       
#else
        /*Call legacy weak error callback*/
        HAL_UART_ErrorCallback(huart);
        //printf("usart over error \r\n");
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

        huart->ErrorCode = HAL_UART_ERROR_NONE;
      }
    }
    return;
  } /* End if some error occurs */

  /* UART in mode Transmitter ------------------------------------------------*/
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  {
    UART_Transmit_IT(huart);
    return;
  }

  /* UART in mode Transmitter end --------------------------------------------*/
  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
  {
    UART_EndTransmit_IT(huart);
    return;
  }
}

主要是分为四个部分：

先读寄存器状态

  uint32_t isrflags   = READ_REG(huart->Instance->SR);
  uint32_t cr1its     = READ_REG(huart->Instance->CR1);
  uint32_t cr3its     = READ_REG(huart->Instance->CR3);

如果没有错误状态产生，且是接收中断，就进行数据接收

  if (errorflags == RESET)
  {
    /* UART in mode Receiver -------------------------------------------------*/
    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    {
      UART_Receive_IT(huart);
      return;
    }
  }

错误处理

//当有parity error,noise error,frame error,Over-Run 错误产生的时候，通过以下回调来处理
HAL_UART_ErrorCallback(huart);

注意：

通过查看HAL库，会发现该函数的定义用了关键字__weak (弱符号声明) ,如下：

__weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(huart);
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_ErrorCallback could be implemented in the user file
   */
}

意味着，它可以由用户自定义函数，如果用户未自定义，否则就使用上述代码

串口数据发送

数据发送

  /* UART in mode Transmitter ------------------------------------------------*/
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  {
    UART_Transmit_IT(huart);
    return;
  }

结束数据发送

  /* UART in mode Transmitter end --------------------------------------------*/
  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
  {
    UART_EndTransmit_IT(huart);
    return;
  }

串口中断发送数据函数 HAL_UART_Transmit_IT()

HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Tx process is not already ongoing */
  if (huart->gState == HAL_UART_STATE_READY)
  {
    if ((pData == NULL) || (Size == 0U))
    {
      return HAL_ERROR;
    }

    /* Process Locked */
    __HAL_LOCK(huart);

    huart->pTxBuffPtr = pData;
    huart->TxXferSize = Size;
    huart->TxXferCount = Size;

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->gState = HAL_UART_STATE_BUSY_TX;

    /* Process Unlocked */
    __HAL_UNLOCK(huart);

    /* Enable the UART Transmit data register empty Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);

    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

对一些状态进行初始化，解释如下

huart->pTxBuffPtr = pData; //指向我们传递进来的数组
huart->TxXferSize = Size;  //要发送数据的个数
huart->TxXferCount = Size; //用来计数，未接收数据的个数，发送一个数据就自减，减为0时，发送完成

huart->ErrorCode = HAL_UART_ERROR_NONE;
huart->gState = HAL_UART_STATE_BUSY_TX;

使能当数据寄存器为空时，发生中断

    /* Enable the UART Transmit data register empty Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);

串口中断接收函数 HAL_UART_Receive_IT

HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */
  if (huart->RxState == HAL_UART_STATE_READY)
  {
    if ((pData == NULL) || (Size == 0U))
    {
      return HAL_ERROR;
    }

    /* Process Locked */
    __HAL_LOCK(huart);

    huart->pRxBuffPtr = pData;
    huart->RxXferSize = Size;
    huart->RxXferCount = Size;

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->RxState = HAL_UART_STATE_BUSY_RX;

    /* Process Unlocked */
    __HAL_UNLOCK(huart);

    /* Enable the UART Parity Error Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_PE);

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

    /* Enable the UART Data Register not empty Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);

    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

对一些状态进行初始化，解释如下

    huart->pRxBuffPtr = pData; //指针指向接收数据缓冲区，我们传送进来的数组首地址
    huart->RxXferSize = Size;  //要接收数据的个数
    huart->RxXferCount = Size; //用来计数，未接收数据的个数，接收一个数据就自减，减为0时，接收完成

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->RxState = HAL_UART_STATE_BUSY_RX;

使能校验错误中断，帧错误，噪声错误中断，数据溢出中断
```
    /* Enable the UART Parity Error Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_PE);

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

    /* Enable the UART Data Register not empty Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
```
后续还会继续分享串口的其他基础知识和使用，感兴趣的小伙伴记得关注我！
-----------------------------------------------结束--------------------------------------------------------
文章有价值，请各位看官点个赞，关注我或者点右边打个赏吧

STM32CubeMX之串口使用（中断方式）

概述

文章目录

一. 在STM32CubeMX 图形化中开启串口中断

二. 串口中断相关函数介绍

三. 串口中断函数使用实例

四. HAL库中的串口相关源码介绍

Android开发之串口编程原理和实现方式

MyBatis之自查询使用递归实现 N级联动效果(两种实现方式)

Android开发之串口编程原理和实现方式

Linux进程间通信方式之socket使用实例

MyBatis之自查询使用递归实现 N级联动效果(两种实现方式)

nuxt踩坑之Vuex状态树的模块方式使用详解

Volley源码之使用方式和使用场景详解

Spring实战之使用XML方式管理声明式事务操作示例

Web开发基础之JS中创建对象的方式及对象使用

WPS表格美化之文字对齐方式的使用让表格更加美观