STM32小技巧(1) HAL自定义串口中断回调 模块化代码进行解耦

已于 2022-07-12 17:34:35 修改
阅读量5.4k 收藏 46
点赞数 18
分类专栏： STM32小技巧 文章标签： stm32 shell
于 2021-01-31 21:24:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38942623/article/details/113481160
版权

STM32小技巧(1) HAL自定义串口中断回调 模块化代码进行解耦

STM32小技巧(1) HAL自定义串口中断回调 模块化代码进行解耦
STM32小技巧(2) STM32CubeProgrammer解除读保护的方法

文章目录

前言

用STM32CubeMx生成初始化配置代码是十分方便的，但是在处理多个项目的时候，就会发现，自动生成的中断函数调用的都是同一个回调函数，在这个回调函数中又要根据不同的句柄来处理，不同的项目外设又有所区别，还是要花点时间来进行移植。
比如说，我在项目A中使用到了串口1、串口2、串口3，但是在项目B中，我只使用到了串口2，并且在项目B中，串口2的功能是项目A的串口1的功能，在这种情况下，我就需要再定义一次 HAL_UART_RxCpltCallback() ，然后移植对应的功能。当然也可以重新 define 一个宏，来对应所使用的串口，这样移植上也会快许多。但是假如，后面新来了一个需求，需要实现项目C的串口3的功能，原本只要添加对应的头文件，模块处理这些外设是最简便的，但是这时候会发现，项目C中也定义了HAL_UART_RxCpltCallback()，这就需要人工去移植这部分的代码了。
而我就在想，项目C的串口3是已经实现的模块，且这个模块是单独的.c文件和.h文件，并且不和其他的串口耦合在一起，这样的轮子造起车子来就快了许多了。但是找遍全网，会发现，关于HAL库中串口中断的教程都是基本的实现，没有更深层次的解释了，在学习MEMS库的过程中，看到官方的代码，在使用按钮触发外部中断的时候，竟然可以自定义外部中断的回调函数，进行一番学习之后，终于掌握了自定义中断回调的方法，不仅限于串口中断函数的回调，其他的外设都是相类似的，都是可以自定义中断的回调函数。
高手可以直接跳过第一节的内容，直接跳到第二节看如何进行操作。

一、HAL库的中断实现

中断的原理网上到处都有，也可以参考正点原子这种开源的教程。
我们正常在STM32CubeMX配置好中断后，通过 GENERATE CODE 生成代码，在 stm32f7xx_it.c 中，就会自动生成中断的处理函数，比如 USART2_IRQHandler，可以看到串口2的全局中断仅仅调用了 HAL_UART_IRQHandler 函数，该函数用于处理UART中断请求。

/**
  * @brief This function handles USART2 global interrupt.
  */
void USART2_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */

  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE BEGIN USART2_IRQn 1 */

  /* USER CODE END USART2_IRQn 1 */
}

我们进入 HAL_UART_IRQHandler 看看里面具体的实现。这个实现虽然很长，但是逻辑比较简单。首先判断是否有错误产生，没有错误就会调用 UART_Receive_IT，用于在非阻塞模式下接收大量数据。如果在接收的过程中有错误发生，那么就会进行标志位的处理，再下面一点就可以看到 USE_HAL_UART_REGISTER_CALLBACKS 这个宏定义，这就是我们自定义中断函数的关键了。如果我们定义了 USE_HAL_UART_REGISTER_CALLBACKS，那么我们通过注册自定义的中断函数后，在这里 huart->ErrorCallback(huart) 就可以直接跳转到我们的自定义的接收异常函数了，而不是 HAL_UART_ErrorCallback(huart) 这个HAL通用的接收异常处理函数。
注：F7的板子在公司，写这个教程的时候手头只有 NUCLEO-L152RE 的开发板，使用的库是 STM32Cube_FW_L1_V1.10.2。 STM32CubeMx生成的代码有所区别，但原理上是一样的。F767ZI 是通过 huart->RxISR(huart) 这个方式来调用中断处理函数的，最终调用的是 UART_RxISR_8BIT 这样子的函数。当然后面推出了新的固件版本，也可能导致具体的实现有所区别。

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;

  /* 如果没有错误发生 */
  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
  if (errorflags == RESET)
  {
    /* UART处于接收模式 -------------------------------------------------*/
    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    {
      UART_Receive_IT(huart);
      return;
    }
  }

  /* 如果发生一些错误 */
  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);
      }

      /* 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 channel */
          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);
#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);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

        huart->ErrorCode = HAL_UART_ERROR_NONE;
      }
    }
    return;
  } /* 如果发生错误则结束 */

  /* UART 处于发送模式，准备在非阻塞模式下发送大量数据。 ---------------------------*/
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  {
    UART_Transmit_IT(huart);
    return;
  }

  /*  UART 处于发送结束模式，在非阻塞模式下结束传输。 -------------------------------*/
  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
  {
    UART_EndTransmit_IT(huart);
    return;
  }
}

然后我们看看没有接收错误发生时，调用的函数 UART_Receive_IT(huart)。这个首先根据数据位的长度来进行接收数据，（9bit和少于9bit的处理是不一样的），串口数据就保存在 huart->pRxBuffPtr，每接收一个数据，那么 huart->RxXferCount 就减一，直至为0，这时候就会触发接收完成的中断了。至于需要接收几个字节来触发中断，就取决于初始化时候的设置了。
huart->pRxBuffPtr变为0后，会先关闭中断，如果使能了USE_HAL_UART_REGISTER_CALLBACKS ，就会调用 huart->RxCpltCallback(huart)，我们就可以通过注册中断处理函数来跳转到我们自定义的函数，而不是HAL库本身的接收完成中断函数HAL_UART_RxCpltCallback(huart)。而如果我们使能了USE_HAL_UART_REGISTER_CALLBACKS，却没有去注册自定义函数，最终调用的还是HAL库本身的中断处理函数，这是因为在 HAL_UART_Init 初始化中会调用函数 UART_InitCallbacksToDefault，这个函数会将所有的回调函数初始化为其默认值。
注：接收完成后，这个会自动将关闭中断，接收完指定的字节之后，还需要继续接收的话就需要再次打开中断了。

static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
{
  uint16_t *tmp;

  /* 检查接收进程是否正在进行 */
  if (huart->RxState == HAL_UART_STATE_BUSY_RX)
  {
    if (huart->Init.WordLength == UART_WORDLENGTH_9B)
    {
      tmp = (uint16_t *) huart->pRxBuffPtr;
      if (huart->Init.Parity == UART_PARITY_NONE)
      {
        *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x01FF);
        huart->pRxBuffPtr += 2U;
      }
      else
      {
        *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x00FF);
        huart->pRxBuffPtr += 1U;
      }
    }
    else
    {
      if (huart->Init.Parity == UART_PARITY_NONE)
      {
        *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF);
      }
      else
      {
        *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x007F);
      }
    }

    if (--huart->RxXferCount == 0U)
    {
      /* 禁止UART数据寄存器不为空的中断 */
      __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);

      /* 禁用UART奇偶校验错误中断 */
      __HAL_UART_DISABLE_IT(huart, UART_IT_PE);

      /* 禁用UART错误中断：（帧错误，噪声错误，溢出错误） */
      __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);

      /* Rx进程完成，将huart-> RxState还原为Ready */
      huart->RxState = HAL_UART_STATE_READY;

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
      /* 调用注册的Rx完成回调函数 */
      huart->RxCpltCallback(huart);
#else
      /*调用旧版弱Rx完成回调函数*/
      HAL_UART_RxCpltCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

      return HAL_OK;
    }
    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

二、使用方法

原理性的代码解析已经在前面一章节解析了，这一章节就是讲要如何实现，其他的都不难，重点是要知道 USE_HAL_UART_REGISTER_CALLBACKS 这个宏，其他的不懂的地方就可以根据这个线索来一步一步的追踪了。

图2.1 设置串口参数
在这里插入图片描述
图2.2 使能串口中断并设置优先级
在这里插入图片描述
前两步都是设置串口中断的设置，按照常规来设置就可以了，重点了如何使能 USE_HAL_UART_REGISTER_CALLBACKS 这个宏，这个宏在 Project Manager 中的 Advanced Settings 右边的 Register Callback 中，选择 UART 为 ENABLE ,注意不是 USART，别选错了。
当然也可以在生成的项目中搜索 USE_HAL_UART_REGISTER_CALLBACKS 手工改成1，但是假如后续又通过STM32CubeMX修改配置的话，再生成代码，会将这里的配置覆盖过去，如果没注意这个点的就很容易出错，建议还是在这里修改比较稳妥一些。
在这里插入图片描述
代码生成之后，默认是没有打开串口中断的，通过 HAL_UART_RegisterCallback() 自定义回调函数，再开启中断就完成了我们的目的。
我们可以专门在一个.c文件来自定义接收完成的回调函数并打开中断，在main函数中调用这个初始化函数就可以了。这样就能和其他串口解耦，移植起来就很方便了。比如我需要指定一个串口来使用 Letter Shell( github上的开源项目，我的文章中也有这个教程)，那么我就写一个 shell_port.c 文件，仅仅需要通过宏来指定使用shell 的串口句柄，其他的都不需要修改，直接添加这个 c文件，在main函数中使用 userShellInit() 来初始化，就能直接使用这个扩展模块了，相比于其他的方式，这个移植过程可以说是相当简便省事了（其他的形式需要在 usart.c 中定义串口接收的数组，再定义接收的个数，再在中断中移植自己的功能，再在main函数中打开串口中断，每建立一个新的项目都需要这么做，尤其时间长了之后，要配置串口中断的函数的时候就容易忘记函数名称，真的很烦）。

HAL_UART_RegisterCallback()
这个函数的第一个参数是 huart ，要配置的串口句柄。
这个函数的第二个参数是 CallbackID ，不同的外设所支持的回调函数ID不同，对于串口来说，HAL_UART_CallbackIDTypeDef 列出了所支持的各个功能ID，我们要在串口接收完成后调用我们自定义的ID，使用的就是 HAL_UART_RX_COMPLETE_CB_ID 。
这个函数的第三个参数是 pCallback ，我们自定义的回调函数，但是这个函数有要求，参照 pUART_CallbackTypeDef 的定义。返回应该是void，并且需要一个参数 UART_HandleTypeDef *huart。

typedef void (*pUART_CallbackTypeDef)(UART_HandleTypeDef *huart); // pointer to an UART callback function

注：这里设置的是每接收一个字节就触发中断，但是HAL库本身处理串口中断标志位后，会关闭中断，所以我们就需要 HAL_UART_Receive_IT 再次开启中断。

#include "shell_port.h"
#include "usart.h"

Shell shell;
char shellBuffer[512];

#define userShellhuart     			huart2	//shell 使用到的串口句柄
#define SHELL_UART_REC_LEN_ONCE 	1   	//串口单次接收的个数
uint8_t uartRecBuffer[SHELL_UART_REC_LEN_ONCE];		//串口接收的buffer


/**
 * @brief 用户shell写
 * 
 * @param data 数据
 */
void userShellWrite(char data)
{
  HAL_UART_Transmit(&userShellhuart,(uint8_t *)&data, 1,1000);
}


/**
 * @brief 用户shell读
 * 
 * @param data 数据
 * @return char 状态
 */
signed char userShellRead(char *data)
{
  if(HAL_UART_Receive(&userShellhuart,(uint8_t *)data, 1, 0) == HAL_OK)
  {
      return 0;
  }
  else
  {
      return -1;
  }
}

/**
 * @brief 自定义函数串口接收完成中断 RxCpltCallback
 */
void ShellRxCpltCallback(UART_HandleTypeDef *huart)
{
  shellHandler(&shell, uartRecBuffer[0]);   //命令行处理函数
  HAL_UART_Receive_IT(huart, (uint8_t *)uartRecBuffer, SHELL_UART_REC_LEN_ONCE);//使能串口中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
}

/**
 * @brief 注册串口接收中断到自己的自定义函数
 */
void ShellReceiveCallbackRemap(void)
{
  HAL_UART_RegisterCallback(&userShellhuart,HAL_UART_RX_COMPLETE_CB_ID,ShellRxCpltCallback);    //注册串口接收中断到自己的自定义函数
  HAL_UART_Receive_IT(&userShellhuart, (uint8_t *)uartRecBuffer, SHELL_UART_REC_LEN_ONCE);      //使能串口中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
}


/**
 * @brief 用户shell初始化
 * 
 */
void userShellInit(void)
{
  shell.write = userShellWrite;         //指定串口写入的函数
  shell.read = userShellRead;           //指定串口读取的函数
  ShellReceiveCallbackRemap();          //注册串口接收中断到自己的自定义函数
  shellInit(&shell, shellBuffer, 512);
  
}

源工程

代码很简单，只要看 shell_port.c 就可以了。

项目中使用到了 Letter Shell ，不懂的同学可以看下我的这篇文章。
STM32CubeMX Nucleo F767ZI 教程(3) 串口调试工具 Letter Shell

fafuwxm
关注
  • 18
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
STM32串口中断接收发送数据
07-11
该程序编写了STM32F103三个串口初始化程序，可快速调用，同时支持接收和发送单个字符和多个字符，并存储数据，方便接收数据后的通信协议校验，支持自定义接收数据最大长度，重写printf函数。
STM32H7 串口 空闲中断 任意长接收 Hal库 IDLE
01-06
今天主要记录一下STM32H7系列串口的使用，正点原子、野火等各大家都有教程，当然用起来也没有问题。 解决方法后边有红色大字提醒，直接看后边就可以，如果你没有时间想去了解HAL库的接收思想。 ST推的HAL库，在整个接收过程中，是没有用到串口的接收空闲中断，它的处理有三种，分别是轮询，接收完成中断（每一个字节一次），DMA接收。 整个Hal库把接收和发送过程都封装好了，就用最简单的轮询方式看，先看库函数代码： /** * @brief Receive an amount of data in blocking mode. * @note When FIFO mode is enabl
嵌入式C语言基础总结
qq_42852559的博客
08-19 410
一、数据类型 二、关键字 1、extern 变量申明 C 语言中 extern 可以置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编 译器遇到此变量和函数时在其他模块中寻找其定义。 2、static 声明静态变量 使用static其值就会在编译时设定，并且无法在运行时改变 3、const 声明只读变量 4、typedef 用以给数据类型取别名（增强代码可移植性），例如 typedef signed char uint8_t; typedef signed
HAL库 UART通信
weixin_44685702的博客
02-18 408
先判断中断来源，再将收到的数据以符号变量printf出，再设定一个16位的USART1_RX_STA变量，该变量的低14位负责接收数据并存储到数组中，而高两位分别作为标志是否接收到回车键（/r/n,0x0d 0x0a）串口中断执行操作属于非阻塞通信,阻塞通信是一种同步通信方式，其中数据传输调用会阻塞调用线程，直到操作完成。：实现一个中断回调函数，这个函数将会在接收到串口数据时被自动调用。这个函数通常需要传入一个指向接收缓冲区的指针和希望接收的字节数。的回调函数，你可以在这个函数内实现你的数据处理逻辑。
STM32 之 HAL 库USART的DMA的使用
luoyu510183的博客
01-26 1万+
上一篇对于UART的使用是非常初级的。一般我也只会用来进行代码测试，不会运用到实际项目当中。因为阻塞式的询问串口数据非常占用CPU的使用率，即便每次询问1ms对于CPU来讲都是很长时间的空闲状态。上一篇讲的bug也只是出现在该情况下。因为对于串口数据的到来时间不确定，所以浪费了很多时间在等待信号。 非阻塞式的串口通信主要有IT和DMA。 IT是利用MCU的中断的硬件特性，就像是示波器的trig...
HAL库学习——串口中断
RealHero的博客
06-23 1万+
一、介绍 串口的传输方式包括：轮询、中断DMA，在此要介绍的是关于HAL库底层串口接收中断流程的讲解，包括串口错误的处理，中断回调函数以及错误中断回调函数的执行。 二、配置流程 首先使用STM32CubeMX配置串口参数和工作方式。如下图： 配置好基础参数波特率和数据长度，校验位，停止位后，选择NVIC Settings点击Enabled使能全局中断。 这样整个串口配置就完成了。 三、开启接收中断 ...
STM32F4 HAL库学习笔记之串口通讯 2
丁丁的博客
02-27 1866
STM32 HAL库学习笔记之串口通讯 2前言步骤函数使用串口初始化三级目录 前言 串口通讯开整 步骤 GPIO和串口时钟使能； 初始化GPIO，复用； 设置串口参数及中断； 使能串口； 编写中断服务函数。 函数使用 串口初始化 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); 串口初始化函数，这个函数有一个入口参数huart（句柄）， UART_HandleTypeDef 结构体指针类型，UART_HandleTypeDef 中包含
【MCU】寄存器、标准库、HAL库、LL库，这么多库！你叫我怎么选？
qq_33471732的博客
11-10 3565
1、聊一聊 今天跟大家推荐一首非常暖心的歌曲<What Are Words>，一首歌曲的灵魂并不是歌曲本身，而是歌曲后面的故事，"或许喜欢这首歌，却心疼这个故...
STM32学习笔记-SMT32使用HAL库UART中断方式使用
weixin_54778315的博客
10-20 1万+
发送数据 和 接受不定长度的数据 并对数据进行简单约定处理
STM32 HAL库串口回调机制详解
a_happy_ant的博客
10-29 1万+
在开始学习STM32的时候，会发现，怎么有个串口中断回调和串口中断不一样的概念啊，感觉很头晕，找了很久也没发现到底区别在哪儿，回调机制是怎么实现的。 下面就详解一下： 通过STM32CubeMx配置工程，生成代码，这一步就不操作了，读者自己熟悉吧。 在stm32h7xx_it.c保存着所有外设的中断入口函数，我们需要在这里添加UART2的重点函数。函数不需要声明，HAL库已经声明过了。所以当中断发生后，程序会通过USART2_IRQHandler函数进入到HAL_UART_IRQHandler中断处理函数。
STM32CubeMX-HAL库-UART串口接收中断回调函数代码分析
热门推荐
weixin_44322104的博客
06-09 2万+
STM32CubeMX-HAL库-UART串口接收中断回调函数代码分析
matlab串口收发及回调函数编程
08-20
matlab创建com对象。并采用中断方式响应回调函数，功能完整，包括创建初始化及关闭销毁。回调函数的格式，实现方法。
STM32CubeMX-HAL库-UART串口接收中断回调函数代码分析.docx
03-30
stm32cubemx串口中断回调 CubeMx中HAL库函数的调用不同于库函数调用，在学习CubeMx串口通信时，不理解HAL库中的回调函数是怎么被调用的，于是查看每个的定义，参考其他人写的博客，总算弄明白了HAL库中断调用与库函数不同之处。写下这篇博客一是加深自己的理解，二是希望对不理解HAL库中回调函数调用机制的朋友有所帮助。 工程代码参考：【STM32】-CubeMX-HAL库-UART-串口通信-STM32F103C8T6-收发测试
STM32F1系列Hal&amp;LL库使用手册（中文翻译）
01-09
STM32F1系列HAL库与LL库使用手册（中文翻译）---高清版 STM32F1系列Hal&LL库使用手册（英文原档） https://download.csdn.net/download/qq_35953617/87374686 STM32F1系列Hal&LL库使用手册（中英文对照） https://download.csdn.net/download/qq_35953617/87374673 STM32F1系列Hal&LL库使用手册（中文翻译） https://download.csdn.net/download/qq_35953617/87374670
stm32f4的HAL库例程代码，包括有所有模块使用的代码
02-23
STM32CubeMX 是 ST 意法半导体近几年来大力推荐的 STM32 芯片图形化配置工具， 允许用户使用图形化向导生成 C 初始化代码，可以大大减轻开发工作，时间和费用。 STM32CubeMX几乎覆盖了 STM32 全系列芯片。它具有如下...
STM32 HAL库串口+DMA空闲中断接收不定长数据
11-04
STM32 HAL库+串口DMA+空闲中断（IDLE）实现不定长数据接收，可以用来参考学习使用，简单易懂。
stm32 cubemx hal库 串口收发 中断接收 项目代码
09-10
stm32 cubemx hal库 串口收发 中断接收 包括 MDK项目 和 stm32的cubemx 项目 使用hal最新的库函数开发 cubemx 4.26.1 有中文注释
STM32—外部中断_按键控制 LED
nownow_的博客
04-15 954
STM32F103RCT6开发板——全集成开发板，外设齐全，资料详尽，新手学习好帮手！
STM32之不使用MicroLIB
最新发布
lushoumin的博客
04-18 68
microlib 是缺省 C 库的备选库，功能上不具备某些 ISO C 特性。microlib 进行了高度优化以使代码变得很小，功能比缺省 C 库少，用于必须在极少量内存环境下运行的深层嵌入式应用程序。Semihosting是用于ARM目标的一种机制，可将来自应用程序代码的输入/输出请求传送至运行调试器的主机。例如，使用此机制可以启用 C 库中的函数，如 printf() 和 scanf()，来使用主机的屏幕和键盘，而不是在目标系统上配备屏幕和键盘。
stm32hal库串口中断回调函数
09-20
stm32hal库中的串口中断回调函数是通过HAL库提供的回调函数机制来实现的。当串口接收到数据或发送完成时，HAL库会自动调用相应的回调函数来处理这些事件。在使用HAL库时，我们可以通过重写这些回调函数来实现自定义的串口中断处理逻辑。 具体的串口中断回调函数可以根据不同的串口进行配置，常见的回调函数包括： 1. HAL_UART_TxCpltCallback：当串口发送完成时调用的回调函数。 2. HAL_UART_RxCpltCallback：当串口接收到数据时调用的回调函数。 3. HAL_UART_ErrorCallback：当串口发生错误时调用的回调函数。 这些回调函数可以在用户代码中进行重写，以实现自定义的串口中断处理逻辑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值