21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 什么是HAL(Hardware Abstraction Layer)?
123下一页
返回列表 发新帖我要提问

[其他ST产品] 什么是HAL(Hardware Abstraction Layer)?

[复制链接]
2176|54
 楼主| 雨果喝水 发表于 2023-8-27 17:27 | 显示全部楼层
回调函数

回调函数
回调函数是一个通过指针调用的函数。如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就将该函数称之为回调函数。
回调函数不是由该函数的实现方法直接调用的，而是在特定的事件或条件发生时由另外一方调用的，用于对该事件或条件进行的响应。
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:27 | 显示全部楼层
这里我们以串口中断为例介绍HAL库对中断的封装（关于中断的详细介绍查看：STM32 NVIC 调试心得）
复制
  1. 第一个重要函数，存放在stm32fxxx.it.c文件中
    

  2. void USART2_IRQHandler(void)
    

  3. {
    

  4.   /* USER CODE BEGIN USART2_IRQn 0 */
    


  5. 

  6.   /* USER CODE END USART2_IRQn 0 */
    

  7.   HAL_UART_IRQHandler(&huart2);
    

  8.   /* USER CODE BEGIN USART2_IRQn 1 */
    


  9. 

  10.  
    

  11.   /* USER CODE END USART2_IRQn 1 */
    

  12. }
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:28 | 显示全部楼层
用过中断的同学都知道这个函数，但大部分都将注意力集中在HAL_UART_IRQHandler(&huart2);这个HAL库的中断接口函数上，于是有了第一个问题——>是谁调用了USART2_IRQHandler（）这个函数呢？这就需要了解MCU对中断的响应机制（详细说明见STM32 NVIC 调试心得），当中断发生时，微控制器暂停当前运行的程序，由内部的硬件机制跳转执行USART2_IRQHandler（），下面我们再看HAL_UART_IRQHandler(&huart2);中的相关代码
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:28 | 显示全部楼层
复制
  1. void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
    

  2. {
    

  3.   uint32_t isrflags   = READ_REG(huart->Instance->SR);
    

  4.   uint32_t cr1its     = READ_REG(huart->Instance->CR1);
    

  5.   uint32_t cr3its     = READ_REG(huart->Instance->CR3);
    

  6.   uint32_t errorflags = 0x00U;
    

  7.   uint32_t dmarequest = 0x00U;
    


  8. 

  9.   /* If no error occurs */
    

  10.   errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
    

  11.   if (errorflags == RESET)
    

  12.   {
    

  13.     /* UART in mode Receiver -------------------------------------------------*/
    

  14.     if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    

  15.     {
    

  16.       UART_Receive_IT(huart);
    

  17.       return;
    

  18.     }
    

  19.   }
    


  20. 

  21.   /* If some errors occur */
    

  22.   if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
    

  23.   {
    

  24.     /* UART parity error interrupt occurred ----------------------------------*/
    

  25.     if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
    

  26.     {
    

  27.       huart->ErrorCode |= HAL_UART_ERROR_PE;
    

  28.     }
    


  29. 

  30.     /* UART noise error interrupt occurred -----------------------------------*/
    

  31.     if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
    

  32.     {
    

  33.       huart->ErrorCode |= HAL_UART_ERROR_NE;
    

  34.     }
    


  35. 

  36.     /* UART frame error interrupt occurred -----------------------------------*/
    

  37.     if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
    

  38.     {
    

  39.       huart->ErrorCode |= HAL_UART_ERROR_FE;
    

  40.     }
    


  41. 

  42.     /* UART Over-Run interrupt occurred --------------------------------------*/
    

  43.     if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
    

  44.     {
    

  45.       huart->ErrorCode |= HAL_UART_ERROR_ORE;
    

  46.     }
    


  47. 

  48.     /* Call UART Error Call back function if need be --------------------------*/
    

  49.     if (huart->ErrorCode != HAL_UART_ERROR_NONE)
    

  50.     {
    

  51.       /* UART in mode Receiver -----------------------------------------------*/
    

  52.       if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    

  53.       {
    

  54.         UART_Receive_IT(huart);
    

  55.       }
    


  56. 

  57.       /* If Overrun error occurs, or if any error occurs in DMA mode reception,
    

  58.          consider error as blocking */
    

  59.       dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
    

  60.       if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
    

  61.       {
    

  62.         /* Blocking error : transfer is aborted
    

  63.            Set the UART state ready to be able to start again the process,
    

  64.            Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
    

  65.         UART_EndRxTransfer(huart);
    


  66. 

  67.         /* Disable the UART DMA Rx request if enabled */
    

  68.         if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
    

  69.         {
    

  70.           CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
    


  71. 

  72.           /* Abort the UART DMA Rx channel */
    

  73.           if (huart->hdmarx != NULL)
    

  74.           {
    

  75.             /* Set the UART DMA Abort callback :
    

  76.                will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
    

  77.             huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
    

  78.             if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
    

  79.             {
    

  80.               /* Call Directly XferAbortCallback function in case of error */
    

  81.               huart->hdmarx->XferAbortCallback(huart->hdmarx);
    

  82.             }
    

  83.           }
    

  84.           else
    

  85.           {
    

  86.             /* Call user error callback */
    

  87. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    

  88.             /*Call registered error callback*/
    

  89.             huart->ErrorCallback(huart);
    

  90. #else
    

  91.             /*Call legacy weak error callback*/
    

  92.             HAL_UART_ErrorCallback(huart);
    

  93. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    

  94.           }
    

  95.         }
    

  96.         else
    

  97.         {
    

  98.           /* Call user error callback */
    

  99. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    

  100.           /*Call registered error callback*/
    

  101.           huart->ErrorCallback(huart);
    

  102. #else
    

  103.           /*Call legacy weak error callback*/
    

  104.           HAL_UART_ErrorCallback(huart);
    

  105. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    

  106.         }
    

  107.       }
    

  108.       else
    

  109.       {
    

  110.         /* Non Blocking error : transfer could go on.
    

  111.            Error is notified to user through user error callback */
    

  112. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    

  113.         /*Call registered error callback*/
    

  114.         huart->ErrorCallback(huart);
    

  115. #else
    

  116.         /*Call legacy weak error callback*/
    

  117.         HAL_UART_ErrorCallback(huart);
    

  118. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    


  119. 

  120.         huart->ErrorCode = HAL_UART_ERROR_NONE;
    

  121.       }
    

  122.     }
    

  123.     return;
    

  124.   } /* End if some error occurs */
    


  125. 

  126.   /* Check current reception Mode :
    

  127.      If Reception till IDLE event has been selected : */
    

  128.   if (  (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
    

  129.       &&((isrflags & USART_SR_IDLE) != 0U)
    

  130.       &&((cr1its & USART_SR_IDLE) != 0U))
    

  131.   {
    

  132.     __HAL_UART_CLEAR_IDLEFLAG(huart);
    


  133. 

  134.     /* Check if DMA mode is enabled in UART */
    

  135.     if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
    

  136.     {
    

  137.       /* DMA mode enabled */
    

  138.       /* Check received length : If all expected data are received, do nothing,
    

  139.          (DMA cplt callback will be called).
    

  140.          Otherwise, if at least one data has already been received, IDLE event is to be notified to user */
    

  141.       uint16_t nb_remaining_rx_data = (uint16_t) __HAL_DMA_GET_COUNTER(huart->hdmarx);
    

  142.       if (  (nb_remaining_rx_data > 0U)
    

  143.           &&(nb_remaining_rx_data < huart->RxXferSize))
    

  144.       {
    

  145.         /* Reception is not complete */
    

  146.         huart->RxXferCount = nb_remaining_rx_data;
    


  147. 

  148.         /* In Normal mode, end DMA xfer and HAL UART Rx process*/
    

  149.         if (huart->hdmarx->Init.Mode != DMA_CIRCULAR)
    

  150.         {
    

  151.           /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
    

  152.           CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    

  153.           CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
    


  154. 

  155.           /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
    

  156.              in the UART CR3 register */
    

  157.           CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
    


  158. 

  159.           /* At end of Rx process, restore huart->RxState to Ready */
    

  160.           huart->RxState = HAL_UART_STATE_READY;
    

  161.           huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;
    


  162. 

  163.           CLEAR_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);
    


  164. 

  165.           /* Last bytes received, so no need as the abort is immediate */
    

  166.           (void)HAL_DMA_Abort(huart->hdmarx);
    

  167.         }
    

  168. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    

  169.         /*Call registered Rx Event callback*/
    

  170.         huart->RxEventCallback(huart, (huart->RxXferSize - huart->RxXferCount));
    

  171. #else
    

  172.         /*Call legacy weak Rx Event callback*/
    

  173.         HAL_UARTEx_RxEventCallback(huart, (huart->RxXferSize - huart->RxXferCount));
    

  174. #endif
    

  175.       }
    

  176.       return;
    

  177.     }
    

  178.     else
    

  179.     {
    

  180.       /* DMA mode not enabled */
    

  181.       /* Check received length : If all expected data are received, do nothing.
    

  182.          Otherwise, if at least one data has already been received, IDLE event is to be notified to user */
    

  183.       uint16_t nb_rx_data = huart->RxXferSize - huart->RxXferCount;
    

  184.       if (  (huart->RxXferCount > 0U)
    

  185.           &&(nb_rx_data > 0U) )
    

  186.       {
    

  187.         /* Disable the UART Parity Error Interrupt and RXNE interrupts */
    

  188.         CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
    


  189. 

  190.         /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    

  191.         CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
    


  192. 

  193.         /* Rx process is completed, restore huart->RxState to Ready */
    

  194.         huart->RxState = HAL_UART_STATE_READY;
    

  195.         huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;
    


  196. 

  197.         CLEAR_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);
    

  198. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    

  199.         /*Call registered Rx complete callback*/
    

  200.         huart->RxEventCallback(huart, nb_rx_data);
    

  201. #else
    

  202.         /*Call legacy weak Rx Event callback*/
    

  203.         HAL_UARTEx_RxEventCallback(huart, nb_rx_data);
    

  204. #endif
    

  205.       }
    

  206.       return;
    

  207.     }
    

  208.   }
    


  209. 

  210.   /* UART in mode Transmitter ------------------------------------------------*/
    

  211.   if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
    

  212.   {
    

  213.     UART_Transmit_IT(huart);
    

  214.     return;
    

  215.   }
    


  216. 

  217.   /* UART in mode Transmitter end --------------------------------------------*/
    

  218.   if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    

  219.   {
    

  220.     UART_EndTransmit_IT(huart);
    

  221.     return;
    

  222.   }
    

  223. }
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:28 | 显示全部楼层
仔细阅读这部分代码，这部分代码其实就是接收中断、发送中断、异常中断、DMA中断等的再次封装，其实是中断类型判定与跳转执行回调函数的过程，在看HAL库代码时一定要注意ST官方对HAL库函数的解释与说明，以下ST公司是对HAL_UART_IRQHandler()的解释与说明
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:28 | 显示全部楼层
复制
  1.  [url=home.php?mod=space&uid=247401]@brief[/url]  This function handles UART interrupt request.
    

  2.  @param  huart  Pointer to a UART_HandleTypeDef structure that contains
    

  3.          the configuration information for the specified UART module.
    

  4.  @retval None
    


  5. 

  6.  @简要说明：该函数处理串口中断请求
    

  7.  @参数：    指向UART\U HandleTypeDef结构的param huart指针，该结构包含指定UART模块的配置信息。
    

  8.  @返回值：  无返回值
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:29 | 显示全部楼层
仔细阅读完代码后，我们不难发现HAL_UART_IRQHandler()中还调用了 HAL_UARTEx_RxEventCallback(huart, nb_rx_data); HAL_UART_ErrorCallback(huart)等回调函数，在keil中右键点击go to Defination,我们发现这些函数前均有weak关键字
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:29 | 显示全部楼层
复制
  1. /**
    

  2.   * @brief  Rx Transfer completed callbacks.
    

  3.   * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
    

  4.   *                the configuration information for the specified UART module.
    

  5.   * @retval None
    

  6.   */
    

  7. __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    

  8. {
    

  9.   /* Prevent unused argument(s) compilation warning */
    

  10.   UNUSED(huart);
    

  11.   /* NOTE: This function should not be modified, when the callback is needed,
    

  12.            the HAL_UART_RxCpltCallback could be implemented in the user file
    

  13.    */
    

  14. }
    


  15. 

  16. /**
    

  17.   * @brief  Rx Half Transfer completed callbacks.
    

  18.   * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
    

  19.   *                the configuration information for the specified UART module.
    

  20.   * @retval None
    

  21.   */
    

  22. __weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
    

  23. {
    

  24.   /* Prevent unused argument(s) compilation warning */
    

  25.   UNUSED(huart);
    

  26.   /* NOTE: This function should not be modified, when the callback is needed,
    

  27.            the HAL_UART_RxHalfCpltCallback could be implemented in the user file
    

  28.    */
    

  29. }
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:29 | 显示全部楼层
什么是weak关键字呢？其实函数名称前面加上__weak 修饰符，我们一般称这个函数为“弱函数”。
加上了__weak 修饰符的函数，用户可以在用户文件中重新定义一个同名函数，最终编译器编译的时候，会选择用户定义的函数，如果用户没有重新定义这个函数，那么编译器就会执行__weak 声明的函数，并且编译器不会报错。所以我们可以在别的地方定义一个相同名字的函数，而不必也尽量不要修改原始函数，于是这便实现了回调，回调给用户，使中断服务程序最终由用户设计，这种方式增强了代码的逻辑性：中断发生后先由内部硬件托管给HAL，HAL调用用户自己编写的回调函数实现功能，增加了文件的嵌套程度
回复

收藏 举报

 楼主| 雨果喝水 发表于 2023-8-27 17:29 | 显示全部楼层
（四）HAL库编程方式

HAL库提供了三种编程方式，分别是轮询模式、中断模式、DMA模式。
具体三种方式的编程案例详见STM32 ppp调试经验
回复

收藏 举报

Bowclad 发表于 2024-5-12 23:03 | 显示全部楼层
hal库移植起来确实是很方便
回复

收藏 举报

Clyde011 发表于 2024-9-16 07:24 | 显示全部楼层

它们之间的间距应至少为0.5mm。
回复

收藏 举报

公羊子丹 发表于 2024-9-16 08:17 | 显示全部楼层

会占用PCB的空间，成本也会更高。
回复

收藏 举报

万图 发表于 2024-9-16 09:20 | 显示全部楼层

对于信号回路的峰值电压防护电路不应动作，通常在信号回路中，防护电路的动作电压是信号回路的峰值电压的1.3～1.6倍。
回复

收藏 举报

Uriah 发表于 2024-9-16 10:23 | 显示全部楼层

它们通常用于分线板或小模块。
回复

收藏 举报

帛灿灿 发表于 2024-9-16 12:19 | 显示全部楼层

开关管T交替工作于通/断两种状态，当开关管关断时，脉冲变压器处于“空载”状态，其中储存的磁能将被积累到下一个周期
回复

收藏 举报

Bblythe 发表于 2024-9-16 13:22 | 显示全部楼层

在印刷电路板制造中
回复

收藏 举报

周半梅 发表于 2024-9-16 15:18 | 显示全部楼层

选择测试方法和测试参数是检测过程中的重要步骤
回复

收藏 举报

Pulitzer 发表于 2024-9-16 16:21 | 显示全部楼层

它产生的噪声是对地噪声
回复

收藏 举报

童雨竹 发表于 2024-9-16 18:17 | 显示全部楼层

对于环氧树脂而言，一般把导热系数为0.5W/M·K的导热性能已经被定义为高导热
回复

收藏 举报

下一页 »
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部