HAL_DMA_IRQHandler()代码详细分析

最新推荐文章于 2024-08-29 16:39:38 发布
最新推荐文章于 2024-08-29 16:39:38 发布
阅读量9.7k 收藏 19
点赞数 4
分类专栏： # STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lljss1980/article/details/109586591
版权

这里使用ADC1联动DMA1， 开启半传输中断、传输中断。debug时，dma也一直在工作，所以半传输中断、传输中断会同时生效。

1. adc1使用了DMA1_Stream0，Instance表示如下

在这里插入图片描述
在这里插入图片描述
一个DMA数据流中断标志占6个bit(在DMA_LISR)。Stream0 ：hdma->StreamIndex=0，Stream1：hdma->StreamIndex=6
DMA_Base_Registers *regs_dma = (DMA_Base_Registers *)hdma->StreamBaseAddress;
tmpisr_dma = regs_dma->ISR;

tmpisr_dma表示
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
(hdma->StreamIndex & 0x1FU) 保证在0~31之间。
DMA_FLAG_TEIF0_4 ((uint32_t)0x00000008U)
在这里插入图片描述
在这里插入图片描述

2. 代码
/**
  * @brief  Handles DMA interrupt request.
  * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
  *               the configuration information for the specified DMA Stream.
  * @retval None
  */
void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
  uint32_t tmpisr_dma, tmpisr_bdma;
  uint32_t ccr_reg;
  __IO uint32_t count = 0U;
  uint32_t timeout = SystemCoreClock / 9600U;

  /* calculate DMA base and stream number */
  DMA_Base_Registers  *regs_dma  = (DMA_Base_Registers *)hdma->StreamBaseAddress;
  BDMA_Base_Registers *regs_bdma = (BDMA_Base_Registers *)hdma->StreamBaseAddress;

  tmpisr_dma  = regs_dma->ISR;
  tmpisr_bdma = regs_bdma->ISR;

  if(IS_DMA_STREAM_INSTANCE(hdma->Instance) != 0U)  /* DMA1 or DMA2 instance */
  {
//hdma->Instance = DMA1_Stream0 = 0x40020010
    /* Transfer Error Interrupt management ***************************************/
    if ((tmpisr_dma & (DMA_FLAG_TEIF0_4 << (hdma->StreamIndex & 0x1FU))) != 0U)	//发生了Transfer error中断
{
//tmpisr_dma = DMA_LISR寄存器
//hdma->StreamIndex = 0
//DMA_FLAG_TEIF0_4 = 	((uint32_t)0x00000008U)
//(hdma->StreamIndex & 0x1FU)  0~31之间

      if(__HAL_DMA_GET_IT_SOURCE(hdma, DMA_IT_TE) != 0U)	//数据流x的传输错误中断使能，在DMA_SxCR
      {
//DMA_IT_TE		((uint32_t)DMA_SxCR_TEIE)
 /* Disable the transfer error interrupt */
        ((DMA_Stream_TypeDef   *)hdma->Instance)->CR  &= ~(DMA_IT_TE);
//停止数据流x的error中断

        /* Clear the transfer error flag */
        regs_dma->IFCR = DMA_FLAG_TEIF0_4 << (hdma->StreamIndex & 0x1FU);
//清数据流x的error标志

        /* Update error code */
        hdma->ErrorCode |= HAL_DMA_ERROR_TE;
      }
    }
    /* FIFO Error Interrupt management ******************************************/
    if ((tmpisr_dma & (DMA_FLAG_FEIF0_4 << (hdma->StreamIndex & 0x1FU))) != 0U)	//发生了FIFI error中断
{
//DMA_FLAG_FEIF0_4 = ((uint32_t)0x00000001U)
      if(__HAL_DMA_GET_IT_SOURCE(hdma, DMA_IT_FE) != 0U)		//数据流x的FIFO错误中断使能，在DMA_DxFCR
      {
        /* Clear the FIFO error flag */
        regs_dma->IFCR = DMA_FLAG_FEIF0_4 << (hdma->StreamIndex & 0x1FU);
//清数据流x的FIFO error标志

        /* Update error code */
        hdma->ErrorCode |= HAL_DMA_ERROR_FE;
      }
    }
    /* Direct Mode Error Interrupt management ***********************************/
if ((tmpisr_dma & (DMA_FLAG_DMEIF0_4 << (hdma->StreamIndex & 0x1FU))) != 0U)	//发生了Direct Mode Error中断
{
//DMA_FLAG_DMEIF0_4 = ((uint32_t)0x00000004U)	DMEIE
      if(__HAL_DMA_GET_IT_SOURCE(hdma, DMA_IT_DME) != 0U)		//直接模式错误中断使能，在DMA_SxCR
      {
        /* Clear the direct mode error flag */
        regs_dma->IFCR = DMA_FLAG_DMEIF0_4 << (hdma->StreamIndex & 0x1FU);
//清数据流x的Direct error标志

        /* Update error code */
        hdma->ErrorCode |= HAL_DMA_ERROR_DME;
      }
    }
    /* Half Transfer Complete Interrupt management ******************************/
    if ((tmpisr_dma & (DMA_FLAG_HTIF0_4 << (hdma->StreamIndex & 0x1FU))) != 0U)	//发生了半传输中断
    {
      if(__HAL_DMA_GET_IT_SOURCE(hdma, DMA_IT_HT) != 0U)		//半传输中断使能，在DMA_SxCR
      {
//DMA_IT_HT ((uint32_t)DMA_SxCR_HTIE)
/* Clear the half transfer complete flag */
        regs_dma->IFCR = DMA_FLAG_HTIF0_4 << (hdma->StreamIndex & 0x1FU);	//清半传输中断标志

        /* Multi_Buffering mode enabled */
        if(((((DMA_Stream_TypeDef   *)hdma->Instance)->CR) & (uint32_t)(DMA_SxCR_DBM)) != 0U)//双缓存开启，代码没开启
        {
          /* Current memory buffer used is Memory 0 */
          if((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_CT) == 0U)
          {
            if(hdma->XferHalfCpltCallback != NULL)
            {
              /* Half transfer callback */
              hdma->XferHalfCpltCallback(hdma);
            }
          }
          /* Current memory buffer used is Memory 1 */
          else
          {
            if(hdma->XferM1HalfCpltCallback != NULL)
            {
              /* Half transfer callback */
              hdma->XferM1HalfCpltCallback(hdma);
            }
          }
        }
        else
        {
          /* Disable the half transfer interrupt if the DMA mode is not CIRCULAR */
          if((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_CIRC) == 0U)	//循环模式，则清半传输中断
          {
            /* Disable the half transfer interrupt */
            ((DMA_Stream_TypeDef   *)hdma->Instance)->CR  &= ~(DMA_IT_HT);
          }

          if(hdma->XferHalfCpltCallback != NULL)	//回调函数不为空，则调用回调函数
          {
            /* Half transfer callback */
            hdma->XferHalfCpltCallback(hdma);		//半传输中断，循环模式下，就只调用了这行
//HAL_ADC_Start_DMA()  hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;

          }
        }
      }
    }
    /* Transfer Complete Interrupt management ***********************************/
    if ((tmpisr_dma & (DMA_FLAG_TCIF0_4 << (hdma->StreamIndex & 0x1FU))) != 0U)	//发生了传输中断
    {
      if(__HAL_DMA_GET_IT_SOURCE(hdma, DMA_IT_TC) != 0U)	//传输中断使能，在DMA_SxCR
      {
        /* Clear the transfer complete flag */
        regs_dma->IFCR = DMA_FLAG_TCIF0_4 << (hdma->StreamIndex & 0x1FU);	//清传输中断标志

        if(HAL_DMA_STATE_ABORT == hdma->State)		//HAL_DMA_Abort_IT() hdma->State=HAL_DMA_STATE_ABORT，手动关闭DMA中断，我的代码没用到
        {
          /* Disable all the transfer interrupts */
          ((DMA_Stream_TypeDef   *)hdma->Instance)->CR  &= ~(DMA_IT_TC | DMA_IT_TE | DMA_IT_DME);	
//清传输完成、传输错误、直接模式错误中断使能标志
          ((DMA_Stream_TypeDef   *)hdma->Instance)->FCR &= ~(DMA_IT_FE);
//清FIFO错误中断使能标志

          if((hdma->XferHalfCpltCallback != NULL) || (hdma->XferM1HalfCpltCallback != NULL))
          {
            ((DMA_Stream_TypeDef   *)hdma->Instance)->CR  &= ~(DMA_IT_HT);
          }

          /* Clear all interrupt flags at correct offset within the register */
          regs_dma->IFCR = 0x3FUL << (hdma->StreamIndex & 0x1FU);

          /* Process Unlocked */
          __HAL_UNLOCK(hdma);

          /* Change the DMA state */
          hdma->State = HAL_DMA_STATE_READY;

          if(hdma->XferAbortCallback != NULL)
          {
            hdma->XferAbortCallback(hdma);
          }
          return;
        }

        if(((((DMA_Stream_TypeDef   *)hdma->Instance)->CR) & (uint32_t)(DMA_SxCR_DBM)) != 0U)		//双缓存开启，我的代码没用到
        {
          /* Current memory buffer used is Memory 0 */
          if((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_CT) == 0U)
          {
            if(hdma->XferM1CpltCallback != NULL)
            {
              /* Transfer complete Callback for memory1 */
              hdma->XferM1CpltCallback(hdma);
            }
          }
          /* Current memory buffer used is Memory 1 */
          else
          {
            if(hdma->XferCpltCallback != NULL)
            {
              /* Transfer complete Callback for memory0 */
              hdma->XferCpltCallback(hdma);
            }
          }
        }
        /* Disable the transfer complete interrupt if the DMA mode is not CIRCULAR */
        else
        {
          if((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_CIRC) == 0U)	//循环模式没开
          {
            /* Disable the transfer complete interrupt */
            ((DMA_Stream_TypeDef   *)hdma->Instance)->CR  &= ~(DMA_IT_TC);	//清传输完成中断

            /* Process Unlocked */
            __HAL_UNLOCK(hdma);

            /* Change the DMA state */
            hdma->State = HAL_DMA_STATE_READY;
          }

          if(hdma->XferCpltCallback != NULL)
          {
            /* Transfer complete callback */
            hdma->XferCpltCallback(hdma);			//传输中断，循环模式下，就只调用了这行
      		 // HAL_ADC_Start_DMA()  hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;

          }
        }
      }
    }

    /* manage error case */
    if(hdma->ErrorCode != HAL_DMA_ERROR_NONE)		//有DMA错误
    {
      if((hdma->ErrorCode & HAL_DMA_ERROR_TE) != 0U)	//有DMA传输错误
      {
        hdma->State = HAL_DMA_STATE_ABORT;

        /* Disable the stream */
        __HAL_DMA_DISABLE(hdma);		//关闭DMA，关闭一个DMA数据流

        do
        {
          if (++count > timeout)
          {
            break;
          }
        }
        while((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_EN) != 0U);//等待关闭

        /* Process Unlocked */
        __HAL_UNLOCK(hdma);		//hdma开锁

        if((((DMA_Stream_TypeDef   *)hdma->Instance)->CR & DMA_SxCR_EN) != 0U)	//DMA数据流没关闭，出错
        {
          /* Change the DMA state to error if DMA disable fails */
          hdma->State = HAL_DMA_STATE_ERROR;
        }
        else
        {
          /* Change the DMA state to Ready if DMA disable success */
          hdma->State = HAL_DMA_STATE_READY;
        }
      }

      if(hdma->XferErrorCallback != NULL)
      {
        /* Transfer error callback */
        hdma->XferErrorCallback(hdma);
      }
    }
  }
  else if(IS_BDMA_CHANNEL_INSTANCE(hdma->Instance) != 0U)  /* BDMA instance(s) */
  {
    ccr_reg = (((BDMA_Channel_TypeDef   *)hdma->Instance)->CCR);

    /* Half Transfer Complete Interrupt management ******************************/
    if (((tmpisr_bdma & (BDMA_FLAG_HT0 << (hdma->StreamIndex & 0x1FU))) != 0U) && ((ccr_reg & BDMA_CCR_HTIE) != 0U))
    {
      /* Clear the half transfer complete flag */
      regs_bdma->IFCR = (BDMA_ISR_HTIF0 << (hdma->StreamIndex & 0x1FU));

      /* Disable the transfer complete interrupt if the DMA mode is Double Buffering */
      if((ccr_reg & BDMA_CCR_DBM) != 0U)
      {
        /* Current memory buffer used is Memory 0 */
        if((ccr_reg & BDMA_CCR_CT) == 0U)
        {
          if(hdma->XferM1HalfCpltCallback != NULL)
          {
            /* Half transfer Callback for Memory 1 */
            hdma->XferM1HalfCpltCallback(hdma);
          }
        }
        /* Current memory buffer used is Memory 1 */
        else
        {
          if(hdma->XferHalfCpltCallback != NULL)
          {
            /* Half transfer Callback for Memory 0 */
            hdma->XferHalfCpltCallback(hdma);
          }
        }
      }
      else
      {
        if((ccr_reg & BDMA_CCR_CIRC) == 0U)
        {
          /* Disable the half transfer interrupt */
          __HAL_DMA_DISABLE_IT(hdma, DMA_IT_HT);
        }

        /* DMA peripheral state is not updated in Half Transfer */
        /* but in Transfer Complete case */

       if(hdma->XferHalfCpltCallback != NULL)
        {
          /* Half transfer callback */
          hdma->XferHalfCpltCallback(hdma);
        }
      }
    }

    /* Transfer Complete Interrupt management ***********************************/
    else if (((tmpisr_bdma & (BDMA_FLAG_TC0 << (hdma->StreamIndex & 0x1FU))) != 0U) && ((ccr_reg & BDMA_CCR_TCIE) != 0U))
    {
      /* Clear the transfer complete flag */
      regs_bdma->IFCR = (BDMA_ISR_TCIF0) << (hdma->StreamIndex & 0x1FU);

      /* Disable the transfer complete interrupt if the DMA mode is Double Buffering */
      if((ccr_reg & BDMA_CCR_DBM) != 0U)
      {
        /* Current memory buffer used is Memory 0 */
        if((ccr_reg & BDMA_CCR_CT) == 0U)
        {
          if(hdma->XferM1CpltCallback != NULL)
          {
            /* Transfer complete Callback for Memory 1 */
            hdma->XferM1CpltCallback(hdma);
          }
        }
        /* Current memory buffer used is Memory 1 */
        else
        {
          if(hdma->XferCpltCallback != NULL)
          {
            /* Transfer complete Callback for Memory 0 */
            hdma->XferCpltCallback(hdma);
          }
        }
      }
      else
      {
        if((ccr_reg & BDMA_CCR_CIRC) == 0U)
        {
          /* Disable the transfer complete and error interrupt, if the DMA mode is not CIRCULAR */
          __HAL_DMA_DISABLE_IT(hdma, DMA_IT_TE | DMA_IT_TC);

          /* Process Unlocked */
          __HAL_UNLOCK(hdma);

          /* Change the DMA state */
          hdma->State = HAL_DMA_STATE_READY;
        }

        if(hdma->XferCpltCallback != NULL)
        {
          /* Transfer complete callback */
          hdma->XferCpltCallback(hdma);
        }
      }
    }
    /* Transfer Error Interrupt management **************************************/
    else if (((tmpisr_bdma & (BDMA_FLAG_TE0 << (hdma->StreamIndex & 0x1FU))) != 0U) && ((ccr_reg & BDMA_CCR_TEIE) != 0U))
    {
      /* When a DMA transfer error occurs */
      /* A hardware clear of its EN bits is performed */
      /* Disable ALL DMA IT */
      __HAL_DMA_DISABLE_IT(hdma, (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE));

      /* Clear all flags */
      regs_bdma->IFCR = (BDMA_ISR_GIF0) << (hdma->StreamIndex & 0x1FU);

      /* Update error code */
      hdma->ErrorCode = HAL_DMA_ERROR_TE;

      /* Process Unlocked */
      __HAL_UNLOCK(hdma);

      /* Change the DMA state */
      hdma->State = HAL_DMA_STATE_READY;

      if (hdma->XferErrorCallback != NULL)
      {
        /* Transfer error callback */
        hdma->XferErrorCallback(hdma);
      }
    }
    else
    {
      /* Nothing To Do */
    }
  }
  else
  {
    /* Nothing To Do */
  }
}

在这里插入图片描述

/**
  * @brief  DMA transfer complete callback.
  * @param hdma pointer to DMA handle.
  * @retval None
  */
void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
{
  /* Retrieve ADC handle corresponding to current DMA handle */
  ADC_HandleTypeDef *hadc = (ADC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  /* Update state machine on conversion status if not in error state */
  if ((hadc->State & (HAL_ADC_STATE_ERROR_INTERNAL | HAL_ADC_STATE_ERROR_DMA)) == 0UL)
  {
    /* Set ADC state */
    SET_BIT(hadc->State, HAL_ADC_STATE_REG_EOC);

    /* Determine whether any further conversion upcoming on group regular     */
    /* by external trigger, continuous mode or scan sequence on going         */
    /* to disable interruption.                                               */
    /* Is it the end of the regular sequence ? */
    if ((hadc->Instance->ISR & ADC_FLAG_EOS) != 0UL)	//系列转换完成
    {
      /* Are conversions software-triggered ? */
      if (LL_ADC_REG_IsTriggerSourceSWStart(hadc->Instance) != 0UL)		//软件触发？
      {
        /* Is CONT bit set ? */
        if (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_CONT) == 0UL)
        {
          /* CONT bit is not set, no more conversions expected */
          CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
          if ((hadc->State & HAL_ADC_STATE_INJ_BUSY) == 0UL)
          {
            SET_BIT(hadc->State, HAL_ADC_STATE_READY);
          }
        }
      }
    }
    else
    {
      /* DMA End of Transfer interrupt was triggered but conversions sequence
         is not over. If DMACFG is set to 0, conversions are stopped. */
      if (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_DMNGT) == 0UL)		//常规数据仅存储再DR中
      {
//DMNGT 数据管理配置
        /* DMACFG bit is not set, conversions are stopped. */
        CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
        if ((hadc->State & HAL_ADC_STATE_INJ_BUSY) == 0UL)
        {
          SET_BIT(hadc->State, HAL_ADC_STATE_READY);
        }
      }
    }

    /* Conversion complete callback */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
    hadc->ConvCpltCallback(hadc);
#else
    HAL_ADC_ConvCpltCallback(hadc);
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
  }
  else /* DMA and-or internal error occurred */
  {
    if ((hadc->State & HAL_ADC_STATE_ERROR_INTERNAL) != 0UL)
    {
      /* Call HAL ADC Error Callback function */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
      hadc->ErrorCallback(hadc);
#else
      HAL_ADC_ErrorCallback(hadc);
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
    }
    else
    {
      /* Call ADC DMA error callback */
      hadc->DMA_Handle->XferErrorCallback(hdma);
    }
  }

在这里插入图片描述

/**
  * @brief  Returns the DMA Stream base address depending on stream number
  * @param  hdma:       pointer to a DMA_HandleTypeDef structure that contains
  *                     the configuration information for the specified DMA Stream.
  * @retval Stream base address
  */
static uint32_t DMA_CalcBaseAndBitshift(DMA_HandleTypeDef *hdma)
{
  if(IS_DMA_STREAM_INSTANCE(hdma->Instance) != 0U) /* DMA1 or DMA2 instance */
  {
    uint32_t stream_number = (((uint32_t)((uint32_t*)hdma->Instance) & 0xFFU) - 16U) / 24U;

    /* lookup table for necessary bitshift of flags within status registers */
    static const uint8_t flagBitshiftOffset[8U] = {0U, 6U, 16U, 22U, 0U, 6U, 16U, 22U};
    hdma->StreamIndex = flagBitshiftOffset[stream_number & 0x7U];

    if (stream_number > 3U)
    {
      /* return pointer to HISR and HIFCR */
      hdma->StreamBaseAddress = (((uint32_t)((uint32_t*)hdma->Instance) & (uint32_t)(~0x3FFU)) + 4U);
    }
    else
    {
      /* return pointer to LISR and LIFCR */
      hdma->StreamBaseAddress = ((uint32_t)((uint32_t*)hdma->Instance) & (uint32_t)(~0x3FFU));
    }
  }
  else /* BDMA instance(s) */
  {
    /* return pointer to ISR and IFCR */
    hdma->StreamBaseAddress = ((uint32_t)((uint32_t*)hdma->Instance) & (uint32_t)(~0xFFU));
  }

  return hdma->StreamBaseAddress;
}
}
3. HAL_ADC_Start_DMA 中 DMA模式下ADC溢出中断强制使能
    /* With DMA, overrun event is always considered as an error even if
       hadc->Init.Overrun is set to ADC_OVR_DATA_OVERWRITTEN. Therefore,
       ADC_IT_OVR is enabled. */

__HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR); //原来是0，现在打开，DMA模式下ADC溢出中断强制使能
在这里插入图片描述
LL_ADC_REG_SetDataTransferMode(hadc->Instance, (uint32_t)hadc->Init.ConversionDataManagement);
在这里插入图片描述

4. 代码
/**
  * @brief  DMA error callback.
  * @param hdma pointer to DMA handle.
  * @retval None
  */
void ADC_DMAError(DMA_HandleTypeDef *hdma)
{
  /* Retrieve ADC handle corresponding to current DMA handle */
  ADC_HandleTypeDef *hadc = (ADC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  /* Set ADC state */
  SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_DMA);

  /* Set ADC error code to DMA error */
  SET_BIT(hadc->ErrorCode, HAL_ADC_ERROR_DMA);

  /* Error callback */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
  hadc->ErrorCallback(hadc);
#else
  HAL_ADC_ErrorCallback(hadc);
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
}

/**
  * @brief  DMA transfer complete callback.
  * @param hdma pointer to DMA handle.
  * @retval None
  */
void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
{
  /* Retrieve ADC handle corresponding to current DMA handle */
  ADC_HandleTypeDef *hadc = (ADC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  /* Update state machine on conversion status if not in error state */
  if ((hadc->State & (HAL_ADC_STATE_ERROR_INTERNAL | HAL_ADC_STATE_ERROR_DMA)) == 0UL)
//ADC_DMAError() 执行完之后HAL_ADC_STATE_ERROR_DMA
  {
    /* Set ADC state */
    SET_BIT(hadc->State, HAL_ADC_STATE_REG_EOC);

    /* Determine whether any further conversion upcoming on group regular     */
    /* by external trigger, continuous mode or scan sequence on going         */
    /* to disable interruption.                                               */
    /* Is it the end of the regular sequence ? */
    if ((hadc->Instance->ISR & ADC_FLAG_EOS) != 0UL)
    {
      /* Are conversions software-triggered ? */
      if (LL_ADC_REG_IsTriggerSourceSWStart(hadc->Instance) != 0UL)
      {
        /* Is CONT bit set ? */
        if (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_CONT) == 0UL)
        {
          /* CONT bit is not set, no more conversions expected */
          CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
          if ((hadc->State & HAL_ADC_STATE_INJ_BUSY) == 0UL)
          {
            SET_BIT(hadc->State, HAL_ADC_STATE_READY);
          }
        }
      }
    }
    else
    {
      /* DMA End of Transfer interrupt was triggered but conversions sequence
         is not over. If DMACFG is set to 0, conversions are stopped. */
      if (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_DMNGT) == 0UL)
      {
        /* DMACFG bit is not set, conversions are stopped. */
        CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
        if ((hadc->State & HAL_ADC_STATE_INJ_BUSY) == 0UL)
        {
          SET_BIT(hadc->State, HAL_ADC_STATE_READY);
        }
      }
    }

    /* Conversion complete callback */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
    hadc->ConvCpltCallback(hadc);
#else
    HAL_ADC_ConvCpltCallback(hadc);
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
  }
  else /* DMA and-or internal error occurred */
  {
if ((hadc->State & HAL_ADC_STATE_ERROR_INTERNAL) != 0UL)
//HAL_ADC_STATE_ERROR_INTERNAL位，HAL_ADC_Init()、ADC_Enable()、ADC_Disable()之后可能
    {
      /* Call HAL ADC Error Callback function */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
      hadc->ErrorCallback(hadc);
#else
      HAL_ADC_ErrorCallback(hadc);	//该回调可不实现
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
    }
    else
    {
      /* Call ADC DMA error callback */
      hadc->DMA_Handle->XferErrorCallback(hdma);
//有DMA错误，执行ADC_DMAError()之后，每次传输完成中断也不会调用用户回调，继续调用ADC_DMAError()
    }
  }
}
}

/**
  * @brief  DMA half transfer complete callback.
  * @param hdma pointer to DMA handle.
  * @retval None
  */
void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
{
  /* Retrieve ADC handle corresponding to current DMA handle */
  ADC_HandleTypeDef *hadc = (ADC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  /* Half conversion callback */
#if (USE_HAL_ADC_REGISTER_CALLBACKS == 1)
  hadc->ConvHalfCpltCallback(hadc);
#else
  HAL_ADC_ConvHalfCpltCallback(hadc);
#endif /* USE_HAL_ADC_REGISTER_CALLBACKS */
}

/**
  * @brief  ADC error callback in non-blocking mode
  *         (ADC conversion with interruption or transfer by DMA).
  * @note   In case of error due to overrun when using ADC with DMA transfer
  *         (HAL ADC handle parameter "ErrorCode" to state "HAL_ADC_ERROR_OVR"):
  *         - Reinitialize the DMA using function "HAL_ADC_Stop_DMA()".
  *         - If needed, restart a new ADC conversion using function
  *           "HAL_ADC_Start_DMA()"
  *           (this function is also clearing overrun flag)
  * @param hadc ADC handle
  * @retval None
  */
__weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hadc);

  /* NOTE : This function should not be modified. When the callback is needed,
            function HAL_ADC_ErrorCallback must be implemented in the user file.
  */
}
lljss2020
关注
专栏目录
HAL_DMA_IRQHandler 代码分析
keke2015的博客
09-05 2838
void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma) { uint32_t flag_it = hdma->DmaBaseAddress->ISR; uint32_t source_it = hdma->Instance->CCR; /* Half Transfer Complete Interrupt management **...
stm32串口HAL库的DMA发送问题
G_Crisis的博客
08-01 7681
本文使用stm32f411ret的串口1的DMA方式发送数据，刚开始调试的时候发现串口只能发送一次数据，之后就把系统hang住了。通过网上搜资料和不断尝试，发现问题是中断回调函数没有写的原因。 使用HAL库的DMA，需要同时实现DMA中断回调函数和串口中断回调函数。 void DMA2_Stream7_IRQHandler(void) { HAL_DMA_IRQHandler(Uar...
【STM32】使用HAL库的“DMA+空闲中断”实现环形缓冲区进行串口收发数据（含详细思路）
最新发布
bjun54的博客
08-29 1657
过往一直在用标准库进行开发，最近手头上有一批不用的板子，一看MCU是STM32F4系列的（以前玩的都还是STM32F1），莫名产生了“踏上新时代的船”的想法，直接下载STM32CubeIDE，使用HAL库开发来调通这些板子。我第一步调试的就是几乎不管什么应用场景都会涉及到的串口，又因为看到好几篇使用串口DMA的文章，决定使用以前没用过的DMA+空闲中断来进行串口接收数据。
HAL库STM32常用外设教程（七）—— ADC
That_Assassin的博客
01-27 4187
2、STM32CubeMx软件3、keil5内容简述：通篇文章将涉及以下内容，如有错误，欢迎指出1、ADC基本原理2、轮询、中断、DMA方式下的ADC采集ADC 即模拟数字转换器，英文详称 Analog-to-digital converter，可以将外部的模拟信号转换为数字信号,是模拟信号数字化的必要器件。STM32F407有3个ADC，最高12位分辨率，最多16个外部通道，ADC1还有3个内部测量通道，可以测量内部温度、参考电压和备用电池电压。
笔记之STM32F0芯片SPI_DMA的使用（HAL库）
自由的天空
10-02 1万+
在调用HAL_SPI_TransmitReceive_DMA()函数前，拉低NSS，在DMA的传输完成中断进行拉高NSS，然后测试，效果是可以的，数据传输完后就立刻拉高了，就是NSS拉低到数据传输的时间较长，那么都可以在中断里拉高NSS了，那么在开启DMA传输前，拉低NSS不也是可以的吗。现在数据传输是在NSS拉低范围内了，但是NSS拉低到数据传输有9.96us，数据传输完到NSS拉高也有11.312us，字节间距倒是减少了不少，至少证明SPI+DMA这条路应该是没问题的，可以减少数据传输的时间。
STM32第十六课（DMA，HAL）
Huskar_Liu的博客
12-20 3456
有 2 个 DMA 控制器（DMA1 和 DMA2）， 共 16 个数据流（每个控制器 8 个）， 每一个 DMA 控制器都用于管理一个或多个外设的存储器访问请求。 每个 DMA 控制器有 8 个数据流，每个数据流有多达 8 个请求 5 个事件标志（DMA 半传输、 DMA 传输完成、 DMA 传输错误、 DMA FIFO 错误、直接模式错误），进行逻辑或运算，从而产生每个数据流的单个中断请求 仅 DMA2 控制器支持存储器到存储器的传输， DMA1 不支持。 DMA_SxCR 控制数据流到底使用哪一个通道
Stm32 HAL库 USART(发送+接收)全部采用DMA形式
热门推荐
xinghunlove123的博客
04-24 2万+
Stm32 HAL库 USART(发送+接收)全部采用DMA形式 主要参考的是俄国一位大神的文章 文章目录Stm32 HAL库 USART(发送+接收)全部采用DMA形式@[toc]1. 例程简介1.1 DMA1.2 U(S)ART2. 具体实现步骤2.1 CubeMx-5.1.0 界面操作2.2 编程展示3. 实验结果展示 1. 例程简介 1.1 DMA DMA （直接存储区访问，为实...
void TIMx_DMA_IRQHandler(void) { HAL_DMA_IRQHandler(TimHandle.hdma[TIM_DMA_ID_CC1]); }
06-06
这段代码定义了一个中断处理函数TIMx_DMA_IRQHandler，用于处理定时器通道1的DMA传输完成中断。在函数中，调用HAL库函数HAL_DMA_IRQHandler，将中断处理交给HAL库处理。具体地，通过传入定时器的DMA句柄中的hdma[TIM...
HAL_ADC_Start_DMA会启动DMA2_Stream0_IRQHandler中断吗？
07-12
是的，HAL_ADC_Start_DMA函数会启动DMA2_Stream0_IRQHandler中断。 DMA2_Stream0_IRQHandler是STM32微控制器中对应DMA2的第一个数据流的中断处理函数。在使用HAL_ADC_Start_DMA函数启动ADC的DMA转换后，当DMA转换...
HAL_DMA_IRQHandler函数的作用
05-24
HAL_DMA_IRQHandler函数是HAL库中的DMA中断处理函数，其作是处理DMA传输传输错误时所发的DMA中断。在DMA传输时，当传输完成或出现传输错误时，会触发DMA中断，此时会自动调用HAL_DMA_IRQHandler函数进行中断处理。在...
hal_dma_irqhandler
03-16
hal_dma_irqhandler是一个函数，用于处理DMA中断。它是在HAL库中定义的，用于处理DMA传输完成时产生的中断。在中断处理函数中，可以执行一些操作，例如清除中断标志位、处理传输完成后的数据等。
STM32Cube HAL库操作系统+串口+DMA收发配置
03-03
STM32Cube配置操作系统freertos，HAL库串口DMA接收程序。含STM32Cube工程配置，Keilv5工程，freertos/Uart收发/DMA。
STM32 HAL库 ADC配置
weixin_41997636的博客
10-24 5902
STM32 ADC的常用的三种工作模式，搭配一些AD转换芯片的可选择的类型会更加的丰富 1. 轮询模式 2. 中断模式 3. DMA模式 轮询模式 相对应于HAL库中的配置函数主要有： HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc);//轮询模式，需放在循环中不断开启 HAL_StatusTypeDef HAL_ADC_Stop...
STM32+ HAL+ DMA+ USART
戈扬的博客
02-01 6192
DMA中断进行数据收发 1.正常模式(一次传输)， 在DMA传输完成后会触发UART的　USART_CR1_TCIE　中断 2.循环模式， 会调用huart的或用户重写的 TxCpltCallback 函数 3 在我的程序中DMA都被配置为正常模式， 因此要处理DMA数据发送和接收完成的事件（中断），应该在串口中断处理程序中进行．循环模式应该可以通过指定huart->TxCpltCallba...
HAL库学习笔记- 9 DMA
kouqi627的博客
04-12 4093
目录DMA简介DMA数据传输的四个要素STM32F4xx系列的DMA特点一、STM32的DMA框图1.外设通道选择2.仲裁器3.FIFO4.端口存储器端口、外设端口编程端口二、DMA数据配置1.源、目标和传输模式2.指针递增3.流控制器4.循环模式5.传输类型6.直接模式7.双缓冲模式8.DMA中断三、HAL库中的DMA1.DMA_InitTypeDef初始化结构体2.DMA_HandleTypeDef 初始化结构体3.DMA常用接口函数示例1.空闲中断时序图2.设计思路3.使用CubeMX配置4.编写用户
STM32 DMA的学习理解2（基于HAL库）
SuperShuiShui’博客
03-23 1529
使用到了DMA，实现了串口接收不定长数据和串口接收定长数据。对DMA使用配置和程序运行的过程做了详细的理解和分析。文末附工程
HAL库——UART的DMA发送（对比接收）
jcsm__的博客
10-23 4801
前面讲到的UART接收执行过程： 启动UART的DMA接收（这里面还定义了DMA回调函数）：HAL_UART_Receive_DMA 接收完成后，请求DMA中断（判断中断的类型）：HAL_DMA_IRQHandler 调用DMA接收完成回调函数（同时关闭了DMA接收）：UART_DMAReceiveCplt 调用UART接收回调函数（处理数据，启动DMA接收）：HAL_UART_RxCpl...
STM32H7xx 串口DMA发送&接收（LL库）
只要思想不滑坡，想法总比问题多。
06-04 8854
LL库下STM32H7 串口DMA收发实现
STM32基础4--中断系统
qq_34343637的博客
04-16 4013
目录 为什么需要中断 中断系统的功能 中断控制器与中断向量表 为什么需要中断 在使用单片机时，最开始我们会使用一个Main函数，然后所有的功能都往里丢。在任务少的时候，并没有什么问题。例如在main函数添加点亮LED，添加延时函数，添加KEY扫描。 一切都好像完美运行，但是如果我们将延时的时间加长，然后去KEY，这时候我们可以发现，我们按的KEY时好是坏。这时候我们就会很痛苦了，我们需要长时间的延时，但是又想我们的KEY功能正常，我们不得不想办法解决这个问题，如果...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值