STM32F4 ADC+DMA 怎么设置DMA转换完一次后中断？

发布于 2021-11-04 22:57:41 浏览：2724 订阅该版

改写了drv_adc.c 加入了DMA功能，采集ADC一切正常，现在想在一轮DMA转换完以后进中断，但是咋设置都进不去

```
#ifdef BSP_USING_ADC1
#ifndef ADC1_CONFIG
#ifdef BSP_USING_ADC_DMA
#define ADC1_CONFIG                                                 \
    {                                                               \
        .Instance = ADC1,                                           \
        .Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4,        \
        .Init.Resolution = ADC_RESOLUTION_12B,                      \
        .Init.DataAlign = ADC_DATAALIGN_RIGHT,                      \
        .Init.ScanConvMode = DISABLE,                               \
        .Init.EOCSelection = ADC_EOC_SEQ_CONV,                      \
        .Init.ContinuousConvMode = ENABLE,                          \
        .Init.NbrOfConversion = BSP_ADC_TOTAL_CHANNELS,             \
        .Init.DiscontinuousConvMode = DISABLE,                      \
        .Init.NbrOfDiscConversion = 0,                              \
        .Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE, \
        .Init.DMAContinuousRequests = ENABLE,                       \
    }

#define ADC1_DMA_CONFIG                                             \
{                                                                   \
    .Instance = DMA2_Stream0,                                       \
    .Init.Direction = DMA_PERIPH_TO_MEMORY,                         \
    .Init.PeriphInc = DMA_PINC_DISABLE,                             \
    .Init.MemInc = DMA_MINC_ENABLE,                                 \
    .Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD,            \
    .Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD,               \
    .Init.Mode = DMA_CIRCULAR,                                      \
    .Init.Priority = DMA_PRIORITY_HIGH,                             \
    .Init.FIFOMode = DMA_FIFOMODE_DISABLE,                          \
    .Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL,              \
    .Init.MemBurst = DMA_MBURST_SINGLE,                             \
    .Init.PeriphBurst = DMA_PBURST_SINGLE,                          \
    .Init.Channel = DMA_CHANNEL_0,                                  \
}
```

```
static rt_err_t stm32_adc_enabled(struct rt_adc_device *device, rt_uint32_t channel, rt_bool_t enabled)
{
    ADC_HandleTypeDef *stm32_adc_handler;
    ADC_ChannelConfTypeDef adc_channel_config = {0};
    DMA_HandleTypeDef dma_init_handler = {0};
    HAL_DMA_CallbackIDTypeDef callback_id;
    RT_ASSERT(device != RT_NULL);
    stm32_adc_handler = device->parent.user_data;

if (enabled)
    {
#ifdef BSP_USING_ADC_DMA
        if (device->dma_buf != RT_NULL)
        {
            if (stm32_adc_handler->Instance == ADC1)
            {
                dma_config[0].XferCpltCallback = HAL_ADC_DMA_ConvCpltCallback;
                dma_init_handler = dma_config[0];
                HAL_DMA_Init(&dma_init_handler);
                HAL_DMA_RegisterCallback(&dma_init_handler, callback_id, HAL_ADC_DMA_ConvCpltCallback);
                HAL_DMA_Start_IT(&dma_init_handler, ((rt_uint32_t)ADC1 + 0x4c), (rt_uint32_t)device->dma_buf, BSP_ADC_TOTAL_CHANNELS * BSP_DMA_BUF_COUNT);
            }

adc_channel_config.Channel = stm32_adc_get_channel(channel);
            adc_channel_config.Rank = 1;
            adc_channel_config.SamplingTime = ADC_SAMPLETIME_112CYCLES;
            adc_channel_config.Offset = 0;
            HAL_ADC_ConfigChannel(stm32_adc_handler, &adc_channel_config);
            HAL_ADC_Start_DMA(stm32_adc_handler, (rt_uint32_t *)device->dma_buf, BSP_ADC_TOTAL_CHANNELS * BSP_DMA_BUF_COUNT);
        }
#else
        __HAL_ADC_ENABLE(stm32_adc_handler);
#endif
    }
    else
    {
        __HAL_ADC_DISABLE(stm32_adc_handler);
    }

return RT_EOK;
}
```

```
void HAL_ADC_DMA_ConvCpltCallback(DMA_HandleTypeDef *hdma)
{
    if (hdma->Instance == DMA2_Stream0)
    {
        //conv_complete_flg = 1;
        rt_kprintf("conv completa\n");
    }
}
```

```
void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    if (hadc->Instance == ADC1)
    {
        /* Peripheral clock enable */
        __HAL_RCC_ADC1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();

GPIO_InitStruct.Pin = GPIO_PIN_5;
        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

#ifdef BSP_USING_ADC_DMA
        __HAL_RCC_DMA2_CLK_ENABLE();
        HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 3, 0);
        HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
#endif
    }
}
```

```
rt_adc_device_t adc1_dev;
rt_uint16_t convert_value[128];
static int rt_adc1_init(void)
{
    adc1_dev = (rt_adc_device_t)rt_device_find("adc1");
    if (adc1_dev == RT_NULL)
    {
        rt_kprintf("adc sample run failed! can't find %s device!\n", "adc1");
    }
    adc1_dev->dma_buf = convert_value;
    rt_adc_enable(adc1_dev, 5);
    return RT_EOK;
}
INIT_APP_EXPORT(rt_adc1_init);
```