RT-Thread-STM32F407ZGT6 ADC+DMA 多路输出结果有误RT-Thread问答社区

10 STM32F407ZGT6 ADC+DMA 多路输出结果有误

发布于 2021-11-28 03:00:25 浏览：1730 订阅该版

在网上借鉴了ADC+DMA的写法改写了rtthread的adc框架，可以正常的获取单个通道的值，但是当读取多通道时发现其他的值只与第一个通道值有关，且有一定的差值。

[借鉴的地址](https://blog.csdn.net/qq_30659437/article/details/107282070)

```c
#ifdef BSP_USING_ADC_DMA
#define BSP_DMA_BUF_COUNT 1
#define BSP_ADC_TOTAL_CHANNELS 3
#define BSP_ADC_CHN_DEF {5,6,7}
#define BSP_ADC_SAMPLE_CYC_DEF ADC_SAMPLETIME_56CYCLES
#endif
#define ADC1_CONFIG                                                 \
    {                                                               \
        .Instance = ADC1,                                           \
        .Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4,        \
        .Init.Resolution = ADC_RESOLUTION_12B,                      \
        .Init.DataAlign = ADC_DATAALIGN_RIGHT,                      \
        .Init.ScanConvMode = ENABLE,                                \
        .Init.EOCSelection = ADC_EOC_SINGLE_CONV,                   \
        .Init.ContinuousConvMode = ENABLE,                          \
        .Init.NbrOfConversion = BSP_ADC_TOTAL_CHANNELS,             \
        .Init.DiscontinuousConvMode = DISABLE,                      \
        .Init.NbrOfDiscConversion = 0,                              \
        .Init.ExternalTrigConv = ADC_SOFTWARE_START,                \
        .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,                       \
    }
```
ADC和DMA的配置

```
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_PIN_6 | GPIO_PIN_7;
        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, 0, 0);
        HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);

#endif
    }
}
```
GPIO初始化

```c
static int stm32_adc_init(void)
{
    int result = RT_EOK;
    /* save adc name */
    char name_buf[5] = {'a', 'd', 'c', '0', 0};
    int i = 0;

for (i = 0; i < sizeof(adc_config) / sizeof(adc_config[0]); i++)
    {
        /* ADC init */
        name_buf[3] = '0';
        stm32_adc_obj[i].ADC_Handler = adc_config[i];
#if defined(ADC1)
        if (stm32_adc_obj[i].ADC_Handler.Instance == ADC1)
        {
            name_buf[3] = '1';
        }
#endif
#if defined(ADC2)
        if (stm32_adc_obj[i].ADC_Handler.Instance == ADC2)
        {
            name_buf[3] = '2';
        }
#endif
#if defined(ADC3)
        if (stm32_adc_obj[i].ADC_Handler.Instance == ADC3)
        {
            name_buf[3] = '3';
        }
#endif
        if (HAL_ADC_Init(&stm32_adc_obj[i].ADC_Handler) != HAL_OK)
        {
            LOG_E("%s init failed", name_buf);
            result = -RT_ERROR;
        }
        else
        {
#ifdef BSP_USING_ADC_DMA
            int j;
            ADC_ChannelConfTypeDef sConfig = {0};
            rt_uint32_t chn[BSP_ADC_TOTAL_CHANNELS] = BSP_ADC_CHN_DEF;
            sConfig.SamplingTime = BSP_ADC_SAMPLE_CYC_DEF;
            for (j = 0; j < BSP_ADC_TOTAL_CHANNELS; j++)
            {
                sConfig.Channel = stm32_adc_get_channel(chn[j]);
                sConfig.Rank = j + 1;
                if (HAL_ADC_ConfigChannel(&stm32_adc_obj[j].ADC_Handler, &sConfig) != HAL_OK)
                {
                    rt_kprintf("channel error\n");
                    return 1;
                }
            }
#endif
            /* register ADC device */
            if (rt_hw_adc_register(&stm32_adc_obj[i].stm32_adc_device, name_buf, &stm_adc_ops, &stm32_adc_obj[i].ADC_Handler) == RT_EOK)
            {
                LOG_D("%s init success", name_buf);
            }
            else
            {
                LOG_E("%s register failed", name_buf);
                result = -RT_ERROR;
            }
        }
    }

return result;

}
INIT_BOARD_EXPORT(stm32_adc_init);

#endif /* BSP_USING_ADC */
```

```c
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;
    DMA_HandleTypeDef dma_init_handler = {0};
    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_init_handler = dma_config[0];
                HAL_DMA_Init(&dma_init_handler);
                __HAL_LINKDMA(stm32_adc_handler, DMA_Handle, dma_init_handler);
                HAL_DMA_Start(&dma_init_handler, ((rt_uint32_t)ADC1 + 0x4c), (rt_uint32_t)device->dma_buf, BSP_ADC_TOTAL_CHANNELS * BSP_DMA_BUF_COUNT);
            }

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;
}
```
改写的驱动部分

```c
rt_device_t adc1_dev;
rt_uint16_t joystick_value[3][1];
static int rt_adc1_init(void)
{
    adc1_dev = rt_device_find("adc1");
    if (adc1_dev == RT_NULL)
    {
        rt_kprintf("adc sample run failed! can't find %s device!\n", "adc1");
    }
    rt_device_control(adc1_dev, RT_ADC_CMD_SET_DMA_BUF, joystick_value);
    rt_device_control(adc1_dev, RT_ADC_CMD_ENABLE, RT_NULL);
    return RT_EOK;
}
INIT_APP_EXPORT(rt_adc1_init);
```
启动的部分

![QQ截图20211128025852.png](https://oss-club.rt-thread.org/uploads/20211128/62dd0ea9e52daa8e234e9ca9a7d57ad2.png)
![QQ截图20211128025906.png](https://oss-club.rt-thread.org/uploads/20211128/a340bcf5ee29e120ca542c9daaa45155.png)
![QQ截图20211128025916.png](https://oss-club.rt-thread.org/uploads/20211128/c5635d46bed02f996697e7c058d6ec41.png)
仅仅改变PA5的输入电平，三个输出都会变，且值都不相同，而改变PA6，7则完全没影响