单片机与物联网 / 系统课时

ADC 与 DMA 连续采样

ADC 与 DMA 连续采样

逐点轮询 ADC 会让 CPU 长时间等待转换完成,也难以保持稳定采样间隔。本课使用 TIM3 定时触发 ADC1,再由 DMA 循环搬运转换结果,通过半缓冲和全缓冲事件完成连续采样与批量处理。

学习目标

  • 理解定时触发、ADC 转换、DMA 搬运和缓冲区处理之间的关系。
  • 配置 STM32F103 的 ADC1、TIM3 与 DMA1 Channel1,实现固定频率连续采样。
  • 使用半传输与全传输回调处理数据,并判断缓冲区覆盖期限。

连续采样链路

稳定采样需要把“何时采样”和“如何搬运”分开。TIM3 每 1 ms 产生一次更新事件,并通过 TRGO 触发 ADC1 通道 0。每次转换结束后,DMA1 Channel1 自动把 ADC1->DR 的 12 位结果搬入 uint16_t 数组,CPU 不参与逐点读取。

DMA 采用循环模式,长度为 64 的缓冲区被分成两个 32 点半区。前半区写满时触发半传输回调,后半区写满时触发全传输回调;主循环收到标志后处理对应半区。DMA 到达末尾后会回到数组起点,因此每个半区都必须在下一次被覆盖前处理完毕。

TIM3 触发 ADC 并由 DMA 循环搬运到双半区缓冲区

配置参数与边界

本例使用 STM32F103C8T6、72 MHz 系统时钟和 12 MHz ADC 时钟。ADC 的采样时间为 55.5 个周期,加上 12.5 个转换周期,一次转换约需 5.67 μs,明显小于 1 ms 触发周期,不会因上一轮尚未结束而丢失触发。

配置项 示例值 作用
TIM3 触发频率 1 kHz 决定采样间隔为 1 ms
ADC 通道 ADC1 Channel 0 对应 PA0 模拟输入
DMA 映射 DMA1 Channel1 STM32F1 中 ADC1 的固定 DMA 通道
DMA 数据宽度 外设半字、存储器半字 与 16 位缓冲元素匹配
DMA 模式 Circular 写到末尾后自动回到起点
缓冲区长度 64 点 每个半区包含 32 点

半区可用处理时间由采样率和半区长度决定,本例为 32/1000=32 ms32/1000=32\text{ ms}。若主循环一次处理超过 32 ms,DMA 可能开始覆盖尚未处理的数据。扩大缓冲区可以增加处理余量,但也会增加批量结果的延迟。

完整工程示例

下面的 main.c 适用于 STM32CubeIDE 创建的 STM32F103 HAL 工程。工程仍需保留启动文件、链接脚本和 HAL 驱动;代码已经包含时钟、PA0、TIM3、ADC1、DMA1 Channel1、USART1 以及 DMA 中断处理。USART1 使用 PA9 和 PA10,以 115200 bit/s 输出最新平均值。

c
#include "stm32f1xx_hal.h"

#include <stdint.h>
#include <stdio.h>

#define ADC_BUFFER_LENGTH 64U
#define ADC_HALF_LENGTH   (ADC_BUFFER_LENGTH / 2U)

ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;
TIM_HandleTypeDef htim3;
UART_HandleTypeDef huart1;

static uint16_t adcBuffer[ADC_BUFFER_LENGTH];
static volatile uint8_t firstHalfReady;
static volatile uint8_t secondHalfReady;
static volatile uint16_t latestAverage;
static volatile uint32_t processedBlocks;

static void SystemClock_Config(void);
static void MX_ADC1_Init(void);
static void MX_TIM3_Init(void);
static void MX_USART1_UART_Init(void);
static uint16_t AverageBlock(const uint16_t *data, uint32_t length);
static void Error_Handler(void);

int _write(int file, char *data, int length) {
    (void)file;
    HAL_UART_Transmit(
        &huart1,
        (uint8_t *)data,
        (uint16_t)length,
        HAL_MAX_DELAY
    );
    return length;
}

int main(void) {
    uint32_t lastReportTick;
    uint32_t millivolts;

    HAL_Init();
    SystemClock_Config();
    MX_USART1_UART_Init();
    MX_TIM3_Init();
    MX_ADC1_Init();

    if (HAL_ADCEx_Calibration_Start(&hadc1) != HAL_OK) {
        Error_Handler();
    }

    /* 先让 ADC 与 DMA 等待触发,再启动 TIM3,避免丢失首个采样点。 */
    if (HAL_ADC_Start_DMA(
            &hadc1,
            (uint32_t *)adcBuffer,
            ADC_BUFFER_LENGTH
        ) != HAL_OK) {
        Error_Handler();
    }

    if (HAL_TIM_Base_Start(&htim3) != HAL_OK) {
        Error_Handler();
    }

    printf("ADC DMA started: 1000 samples/s, buffer=64\r\n");
    lastReportTick = HAL_GetTick();

    while (1) {
        if (firstHalfReady != 0U) {
            firstHalfReady = 0U;
            latestAverage = AverageBlock(&adcBuffer[0], ADC_HALF_LENGTH);
            processedBlocks++;
        }

        if (secondHalfReady != 0U) {
            secondHalfReady = 0U;
            latestAverage = AverageBlock(
                &adcBuffer[ADC_HALF_LENGTH],
                ADC_HALF_LENGTH
            );
            processedBlocks++;
        }

        /* 串口只按秒输出,避免日志速度反过来阻塞采样处理。 */
        if ((HAL_GetTick() - lastReportTick) >= 1000U) {
            lastReportTick += 1000U;
            millivolts =
                ((uint32_t)latestAverage * 3300U + 2047U) / 4095U;

            printf(
                "blocks=%lu avg=%u voltage=%lu mV\r\n",
                (unsigned long)processedBlocks,
                latestAverage,
                (unsigned long)millivolts
            );
        }
    }
}

void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef *hadc) {
    if (hadc->Instance == ADC1) {
        firstHalfReady = 1U;
    }
}

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) {
    if (hadc->Instance == ADC1) {
        secondHalfReady = 1U;
    }
}

void DMA1_Channel1_IRQHandler(void) {
    HAL_DMA_IRQHandler(&hdma_adc1);
}

static uint16_t AverageBlock(const uint16_t *data, uint32_t length) {
    uint32_t sum = 0U;

    for (uint32_t i = 0U; i < length; i++) {
        sum += data[i];
    }

    return (uint16_t)(sum / length);
}

static void MX_ADC1_Init(void) {
    ADC_ChannelConfTypeDef channel = {0};
    GPIO_InitTypeDef gpio = {0};

    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_ADC1_CLK_ENABLE();
    __HAL_RCC_DMA1_CLK_ENABLE();

    gpio.Pin = GPIO_PIN_0;
    gpio.Mode = GPIO_MODE_ANALOG;
    HAL_GPIO_Init(GPIOA, &gpio);

    hadc1.Instance = ADC1;
    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
    hadc1.Init.ContinuousConvMode = DISABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T3_TRGO;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;

    if (HAL_ADC_Init(&hadc1) != HAL_OK) {
        Error_Handler();
    }

    channel.Channel = ADC_CHANNEL_0;
    channel.Rank = ADC_REGULAR_RANK_1;
    channel.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;

    if (HAL_ADC_ConfigChannel(&hadc1, &channel) != HAL_OK) {
        Error_Handler();
    }

    hdma_adc1.Instance = DMA1_Channel1;
    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
    hdma_adc1.Init.Mode = DMA_CIRCULAR;
    hdma_adc1.Init.Priority = DMA_PRIORITY_HIGH;

    if (HAL_DMA_Init(&hdma_adc1) != HAL_OK) {
        Error_Handler();
    }

    __HAL_LINKDMA(&hadc1, DMA_Handle, hdma_adc1);

    HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1U, 0U);
    HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
}

static void MX_TIM3_Init(void) {
    TIM_MasterConfigTypeDef master = {0};

    __HAL_RCC_TIM3_CLK_ENABLE();

    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 7199U;
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = 9U;
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

    if (HAL_TIM_Base_Init(&htim3) != HAL_OK) {
        Error_Handler();
    }

    master.MasterOutputTrigger = TIM_TRGO_UPDATE;
    master.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

    if (HAL_TIMEx_MasterConfigSynchronization(
            &htim3,
            &master
        ) != HAL_OK) {
        Error_Handler();
    }
}

static void MX_USART1_UART_Init(void) {
    GPIO_InitTypeDef gpio = {0};

    __HAL_RCC_AFIO_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_USART1_CLK_ENABLE();

    gpio.Pin = GPIO_PIN_9;
    gpio.Mode = GPIO_MODE_AF_PP;
    gpio.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &gpio);

    gpio.Pin = GPIO_PIN_10;
    gpio.Mode = GPIO_MODE_INPUT;
    gpio.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &gpio);

    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;

    if (HAL_UART_Init(&huart1) != HAL_OK) {
        Error_Handler();
    }
}

static void SystemClock_Config(void) {
    RCC_OscInitTypeDef oscillator = {0};
    RCC_ClkInitTypeDef clocks = {0};
    RCC_PeriphCLKInitTypeDef peripheral = {0};

    oscillator.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    oscillator.HSEState = RCC_HSE_ON;
    oscillator.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    oscillator.HSIState = RCC_HSI_ON;
    oscillator.PLL.PLLState = RCC_PLL_ON;
    oscillator.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    oscillator.PLL.PLLMUL = RCC_PLL_MUL9;

    if (HAL_RCC_OscConfig(&oscillator) != HAL_OK) {
        Error_Handler();
    }

    clocks.ClockType =
        RCC_CLOCKTYPE_HCLK |
        RCC_CLOCKTYPE_SYSCLK |
        RCC_CLOCKTYPE_PCLK1 |
        RCC_CLOCKTYPE_PCLK2;
    clocks.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    clocks.AHBCLKDivider = RCC_SYSCLK_DIV1;
    clocks.APB1CLKDivider = RCC_HCLK_DIV2;
    clocks.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&clocks, FLASH_LATENCY_2) != HAL_OK) {
        Error_Handler();
    }

    peripheral.PeriphClockSelection = RCC_PERIPHCLK_ADC;
    peripheral.AdcClockSelection = RCC_ADCPCLK2_DIV6;

    if (HAL_RCCEx_PeriphCLKConfig(&peripheral) != HAL_OK) {
        Error_Handler();
    }
}

static void Error_Handler(void) {
    __disable_irq();

    while (1) {
    }
}

连接 PA0 到稳定的 0~3.3 V 模拟信号,编译并烧录后打开串口终端。示例中的采样值取决于输入电压,因此预期输出使用占位符表示动态数据。

text
ADC DMA started: 1000 samples/s, buffer=64
blocks=<BLOCK_COUNT> avg=<ADC_AVERAGE> voltage=<MILLIVOLTS> mV
blocks=<BLOCK_COUNT> avg=<ADC_AVERAGE> voltage=<MILLIVOLTS> mV

<BLOCK_COUNT> 通常每秒增加约 31,另外两个值随 PA0 电压变化。若 PA0 接近 1.65 V,平均码值应接近 2048,换算结果应接近 1650 mV;实际值会受到 VDDA、电阻误差和噪声影响。

处理策略与调试

DMA 回调应只做通知,不应在中断中执行串口打印、浮点运算或长循环。示例在回调中仅设置 volatile 标志,真正的求平均放在主循环中。若采样率更高或处理时间不稳定,可把标志升级为事件计数器、任务通知或无锁队列,避免同一事件重复到来时丢失通知。

调试时先检查 TIM3 是否按预期产生更新事件,再查看 ADC1->DR 是否变化,最后观察 DMA 的剩余传输计数和缓冲数组。若数组始终为零,优先检查 PA0 是否为模拟模式、ADC 外部触发源是否为 TIM3 TRGO,以及 DMA 数据宽度是否与 uint16_t 缓冲区一致。

本课总结

  • 定时器负责稳定采样节拍,ADC 负责转换,DMA 负责逐点搬运,CPU 只处理成块数据。
  • 循环 DMA 的半传输与全传输事件构成双半区处理模型,处理必须在覆盖期限内完成。
  • 采样率、缓冲长度和处理时间共同决定系统是否会丢块或产生过大延迟。

下一课预告

下一课《校准、滤波与单位换算》将在 DMA 缓冲数据之上加入限幅、平均滤波和两点线性校准,把 ADC 码值转换为可直接使用的温度、电压或光照等物理量。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

ADC 与 DMA 连续采样

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通