本示例说明如何使用 ADC 连续读取模式（DMA 模式）通过片内 ADC 模块从 GPIO 引脚读取数据。

代码流程

graph TD 配置DMA驱动程序-->配置ADC数字控制器-->配置每个通道的参数-->启动转换-->打印数据-->停止转换-->取消初始化

头文件

#include <string.h>
#include <stdio.h>
#include "sdkconfig.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/adc.h"

变量与宏定义

#define TIMES              256
#define GET_UNIT(x)        ((x>>3) & 0x1)

#if CONFIG_IDF_TARGET_ESP32
#define ADC_RESULT_BYTE     2//结果字节数
#define ADC_CONV_LIMIT_EN   1//For ESP32, this should always be set to 1 是否限制转换时间
#define ADC_CONV_MODE       ADC_CONV_SINGLE_UNIT_1//ESP32 only supports ADC1 DMA mode
#define ADC_OUTPUT_TYPE     ADC_DIGI_OUTPUT_FORMAT_TYPE1//输出12位数据
#elif CONFIG_IDF_TARGET_ESP32S2
#define ADC_RESULT_BYTE     2
#define ADC_CONV_LIMIT_EN   0
#define ADC_CONV_MODE       ADC_CONV_BOTH_UNIT//ADC1和ADC2同时转换
#define ADC_OUTPUT_TYPE     ADC_DIGI_OUTPUT_FORMAT_TYPE2//输出11位数据
#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
#define ADC_RESULT_BYTE     4
#define ADC_CONV_LIMIT_EN   0
#define ADC_CONV_MODE       ADC_CONV_ALTER_UNIT//ESP32C3只支持轮换模式
#define ADC_OUTPUT_TYPE     ADC_DIGI_OUTPUT_FORMAT_TYPE2
#elif CONFIG_IDF_TARGET_ESP32S3
#define ADC_RESULT_BYTE     4
#define ADC_CONV_LIMIT_EN   0
#define ADC_CONV_MODE       ADC_CONV_BOTH_UNIT
#define ADC_OUTPUT_TYPE     ADC_DIGI_OUTPUT_FORMAT_TYPE2
#endif

#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32H2
static uint16_t adc1_chan_mask = BIT(2) | BIT(3);
static uint16_t adc2_chan_mask = BIT(0);
static adc_channel_t channel[3] = {ADC1_CHANNEL_2, ADC1_CHANNEL_3, (ADC2_CHANNEL_0 | 1 << 3)};
#endif
#if CONFIG_IDF_TARGET_ESP32S2
static uint16_t adc1_chan_mask = BIT(2) | BIT(3);
static uint16_t adc2_chan_mask = BIT(0);
static adc_channel_t channel[3] = {ADC1_CHANNEL_2, ADC1_CHANNEL_3, (ADC2_CHANNEL_0 | 1 << 3)};
#endif
#if CONFIG_IDF_TARGET_ESP32
static uint16_t adc1_chan_mask = BIT(7);
static uint16_t adc2_chan_mask = 0;
static adc_channel_t channel[1] = {ADC1_CHANNEL_7};
#endif

static const char *TAG = "ADC DMA";

连续读写初始化

static void continuous_adc_init(uint16_t adc1_chan_mask, uint16_t adc2_chan_mask, adc_channel_t *channel, uint8_t channel_num)
{
    //ADC DMA 驱动程序配置
    adc_digi_init_config_t adc_dma_config = {
        //驱动程序在处理之前可以存储的转换数据的最大长度
        .max_store_buf_size = 1024,
        //可在 1 个中断中转换的数据字节数
        .conv_num_each_intr = TIMES,
        //要初始化的ADC1的通道列表
        .adc1_chan_mask = adc1_chan_mask,
        //要初始化的ADC2的通道列表
        .adc2_chan_mask = adc2_chan_mask,
    };
    //初始化ADC DMA模式
    ESP_ERROR_CHECK(adc_digi_initialize(&adc_dma_config));

    //ADC数字控制器设置
    adc_digi_configuration_t dig_cfg = {
        //限制ADC转换时间
        .conv_limit_en = ADC_CONV_LIMIT_EN,
        //ADC转换的最大次数，范围为1~255
        .conv_limit_num = 250,
        //预期的ADC采样频率，单位为Hz。范围：611Hz ~ 83333Hz 
        .sample_freq_hz = 10 * 1000,
        //ADC DMA 转换模式
        .conv_mode = ADC_CONV_MODE,
        //ADC DMA转换输出格式
        .format = ADC_OUTPUT_TYPE,
    };

    //配置ADC每个通道的参数
    adc_digi_pattern_config_t adc_pattern[SOC_ADC_PATT_LEN_MAX] = {0};
    dig_cfg.pattern_num = channel_num;
    for (int i = 0; i < channel_num; i++) {
        uint8_t unit = GET_UNIT(channel[i]);
        uint8_t ch = channel[i] & 0x7;
        adc_pattern[i].atten = ADC_ATTEN_DB_0;//配置该通道的衰减
        adc_pattern[i].channel = ch;
        adc_pattern[i].unit = unit;//ADC单元
        adc_pattern[i].bit_width = SOC_ADC_DIGI_MAX_BITWIDTH;//ADC输出位宽

        ESP_LOGI(TAG, "adc_pattern[%d].atten is :%x", i, adc_pattern[i].atten);
        ESP_LOGI(TAG, "adc_pattern[%d].channel is :%x", i, adc_pattern[i].channel);
        ESP_LOGI(TAG, "adc_pattern[%d].unit is :%x", i, adc_pattern[i].unit);
    }
    dig_cfg.adc_pattern = adc_pattern;
    ESP_ERROR_CHECK(adc_digi_controller_configure(&dig_cfg));
}

#if !CONFIG_IDF_TARGET_ESP32
static bool check_valid_data(const adc_digi_output_data_t *data)
{
    const unsigned int unit = data->type2.unit;
    if (unit > 2) return false;
    if (data->type2.channel >= SOC_ADC_CHANNEL_NUM(unit)) return false;

    return true;
}
#endif

主函数

void app_main(void)
{
    esp_err_t ret;
    uint32_t ret_num = 0;
    uint8_t result[TIMES] = {0};
    //初始化result
    memset(result, 0xcc, TIMES);

    //初始化ADC DMA驱动、控制器、通道
    continuous_adc_init(adc1_chan_mask, adc2_chan_mask, channel, sizeof(channel) / sizeof(adc_channel_t));
    //启动数字ADC和DMA外设。在此之后，硬件开始工作。
    adc_digi_start();

    while(1) {
        //开始从ADC以DMA模式读取数据
        //TIMES表示期望的数据长度，ret_num为实际数据长度
        //ADC_MAX_DELAY为等待读数的时间，单位为ms
        ret = adc_digi_read_bytes(result, TIMES, &ret_num, ADC_MAX_DELAY);
        if (ret == ESP_OK || ret == ESP_ERR_INVALID_STATE) {
            if (ret == ESP_ERR_INVALID_STATE) {
                /**
                 * @note 1
                 * Issue:
                 * 在这个例子中，我们只是打印出结果，这是超级慢的。
                 * 因此，转换速度太快，无法处理任务。在这种情况下，某些转换结果会丢失
                 * Reason:
                 * 发生此错误时，您通常也会看到任务看门狗超时问题。因为转换太快，而调用“adc_digi_read_bytes”的任务很慢。
                 * 所以“adc_digi_read_bytes”几乎不会阻止。
                 * 因此，空闲任务几乎没有机会运行。在此示例中，我们在下面添加了“vTaskDelay（1）”，以防止任务看门狗超时。
                 * Solution:
                 * 要么降低转换速度，要么增加调用“adc_digi_read_bytes”的频率
                 */
            }

            //打印数据
            ESP_LOGI("TASK:", "ret is %x, ret_num is %d", ret, ret_num);
            for (int i = 0; i < ret_num; i += ADC_RESULT_BYTE) {
                adc_digi_output_data_t *p = (void*)&result[i];
    #if CONFIG_IDF_TARGET_ESP32
                ESP_LOGI(TAG, "Unit: %d, Channel: %d, Value: %x", 1, p->type1.channel, p->type1.data);
    #else
                //ADC1和ADC2同时或轮流进行转换
                if (ADC_CONV_MODE == ADC_CONV_BOTH_UNIT || ADC_CONV_MODE == ADC_CONV_ALTER_UNIT) {
                    if (check_valid_data(p)) {
                        ESP_LOGI(TAG, "Unit: %d,_Channel: %d, Value: %x", p->type2.unit+1, p->type2.channel, p->type2.data);
                    } else {
                        // abort();
                        ESP_LOGI(TAG, "Invalid data [%d_%d_%x]", p->type2.unit+1, p->type2.channel, p->type2.data);
                    }
                }
    #if CONFIG_IDF_TARGET_ESP32S2
                else if (ADC_CONV_MODE == ADC_CONV_SINGLE_UNIT_2) {//ADC2单独转换
                    ESP_LOGI(TAG, "Unit: %d, Channel: %d, Value: %x", 2, p->type1.channel, p->type1.data);
                } else if (ADC_CONV_MODE == ADC_CONV_SINGLE_UNIT_1) {//ADC1单独转换
                    ESP_LOGI(TAG, "Unit: %d, Channel: %d, Value: %x", 1, p->type1.channel, p->type1.data);
                }
    #endif  //#if CONFIG_IDF_TARGET_ESP32S2
    #endif
            }
            //See `note 1`
            vTaskDelay(1);
        } else if (ret == ESP_ERR_TIMEOUT) {
            /**
             * ``ESP_ERR_TIMEOUT``: If ADC conversion is not finished until Timeout, you'll get this return error.
             * Here we set Timeout ``portMAX_DELAY``, so you'll never reach this branch.
             */
            ESP_LOGW(TAG, "No data, increase timeout or reduce conv_num_each_intr");
            vTaskDelay(1000);
        }

    }

    //停止数字ADC和DMA外设。在此之后，硬件停止工作
    adc_digi_stop();
    //取消初始化数字ADC
    ret = adc_digi_deinitialize();
    assert(ret == ESP_OK);
}

\peripherals\adc\dma_read例程分析（ADC 连续采样模式）