Obsidian-Knowledge-Base/X-Knowledge-Base/raw/Joplin/嵌入式+Linux/STM32学习笔记(三教程综合)/10-ADC模数转换.md

ADC 模数转换

上图：逐次逼近型 SAR ADC 结构示意图（来源：STM32入门教程 PPT 第87页）

上图：STM32 ADC 模块整体框图（来源：STM32入门教程 PPT 第88页）

SAR ADC 基本原理

ADC（Analog-to-Digital Converter）将连续变化的模拟电压信号转换为离散的数字量。

逐次逼近型 ADC（SAR ADC） 工作原理类似于天平称重：

1. 采样保持电路对输入电压采样并保持
2. 从最高位（MSB）开始，依次尝试每一位（相当于砝码）
3. 比较器比较 DAC 输出与输入电压：
   • 若 DAC 输出 ≤ 输入，保留该位（保留砝码）
   • 若 DAC 输出 > 输入，清除该位（取下砝码）
4. 12 位逐次逼近需要 12 次比较

内部结构：采样保持电路（开关 + 电阻 + 电容）→ 比较器 → 结果寄存器（12 位）→ DAC（电压发生器）。

采样深度（分辨率）: 12 位，即用 12 位二进制数表示转换结果，范围为 0~4095。量程 0~3.3V 时，分辨率为 $3.3V / 4095 \approx 0.806mV$。

采样时间与转换时间

ADC 转换过程分为两个阶段：

采样时间

采样开关闭合、对采样电容充电的时间。与信号源内阻有关：

$$T{sample} = (R{source} + R{ADC}) \times C{ADC} \times \ln(2^{N+2}) \times \frac{1}{f_{ADC}}$$

• $R_{ADC}$ = 1 kΩ（采样电阻）
• $C_{ADC}$ = 8 pF（采样电容）
• $N$ = 12（采样深度）
• 信号源内阻越大，采样时间越长

转换时间

12 位逐次逼近需要 12 个 ADC 时钟周期 + 0.5 个额外周期 = 12.5 个周期。

ADC 时钟

ADC 时钟来自 PCLK2（72 MHz）经过分频器分频，最高不超过 14 MHz。常用配置为 6 分频 → 12 MHz。

在标准库中配置：RCC_ADCCLKConfig(RCC_PCLK2_Div6);

单通道转换

驱动代码 AD.c

void AD_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);       // ADCCLK = 72MHz / 6 = 12MHz

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_Init(GPIOA, &GPIO_InitStructure);  // PA0 模拟输入

    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_55Cycles5);

    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; // 软件触发
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStructure);

    ADC_Cmd(ADC1, ENABLE);
    // 校准
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1) == SET);
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1) == SET);
}

uint16_t AD_GetValue(void)
{
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);            // 软件触发启动
    while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); // 等待转换结束
    return ADC_GetConversionValue(ADC1);               // 读取结果
}

ADC_HandleTypeDef hadc1;

void AD_Init(void)
{
    __HAL_RCC_ADC1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_0;
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    hadc1.Instance = ADC1;
    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
    hadc1.Init.ContinuousConvMode = DISABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;
    HAL_ADC_Init(&hadc1);

    ADC_ChannelConfTypeDef sConfig = {0};
    sConfig.Channel = ADC_CHANNEL_0;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

uint16_t AD_GetValue(void)
{
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
    return (uint16_t)HAL_ADC_GetValue(&hadc1);
}
```

### 寄存器：单通道ADC（尚硅谷风格）

```c
void ADC1_Init(void) {
    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
    RCC->CFGR |= RCC_CFGR_ADCPRE_1; RCC->CFGR &= ~RCC_CFGR_ADCPRE_0;  // 6分频=12MHz

    GPIOC->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);  // PC0: 模拟输入

    ADC1->CR1 &= ~ADC_CR1_SCAN;    // 非扫描模式
    ADC1->CR2 |= ADC_CR2_CONT;     // 连续转换
    ADC1->CR2 &= ~ADC_CR2_ALIGN;   // 右对齐
    ADC1->SMPR1 |= ADC_SMPR1_SMP10_0;  // 采样时间7.5周期
    ADC1->SQR3 |= 10 << 0;         // 规则序列1: 通道10(PC0)
}

void ADC1_StartConvert(void) {
    ADC1->CR2 |= ADC_CR2_ADON;     // 上电
    ADC1->CR2 |= ADC_CR2_CAL;      // 校准
    while (ADC1->CR2 & ADC_CR2_CAL) {}
    ADC1->CR2 |= ADC_CR2_ADON;     // 再次置位ADON开始转换
    while ((ADC1->SR & ADC_SR_EOC) == 0) {}
}

double ADC1_ReadV(void) { return ADC1->DR * 3.3 / 4095; }
```

### 主函数（单通道）
```c
int main(void)
{
    OLED_Init();
    AD_Init();
    OLED_ShowString(1, 1, "ADValue:");
    OLED_ShowString(2, 1, "Voltage:0.00V");
    while (1) {
        ADValue = AD_GetValue();
        Voltage = (float)ADValue / 4095 * 3.3;  // 线性变换到电压
        OLED_ShowNum(1, 9, ADValue, 4);
        OLED_ShowNum(2, 9, Voltage, 1);
        OLED_ShowNum(2, 11, (uint16_t)(Voltage * 100) % 100, 2);
        Delay_ms(100);
    }
}
```

## 多通道转换

多通道方案：每次转换前动态配置规则组通道。

### AD.c（多通道）

```c 标准库
void AD_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    ADC_InitTypeDef ADC_InitStructure;
    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStructure);

    ADC_Cmd(ADC1, ENABLE);
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1) == SET);
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1) == SET);
}

uint16_t AD_GetValue(uint8_t ADC_Channel)
{
    ADC_RegularChannelConfig(ADC1, ADC_Channel, 1, ADC_SampleTime_55Cycles5);
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
    while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
    return ADC_GetConversionValue(ADC1);
}
```

c HAL库 ADC_HandleTypeDef hadc1;

void AD_Init(void) {

__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
RCC_ADCCLKConfig(RCC_PCLK2_Div6);

GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
HAL_ADC_Init(&hadc1);

}

uint16_t AD_GetValue(uint8_t ADC_Channel) {

ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0 + ADC_Channel;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);

HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
return (uint16_t)HAL_ADC_GetValue(&hadc1);

}

### 主函数（多通道）

```c
while (1) {
    AD0 = AD_GetValue(ADC_Channel_0);
    AD1 = AD_GetValue(ADC_Channel_1);
    AD2 = AD_GetValue(ADC_Channel_2);
    AD3 = AD_GetValue(ADC_Channel_3);
    OLED_ShowNum(1, 5, AD0, 4);
    OLED_ShowNum(2, 5, AD1, 4);
    OLED_ShowNum(3, 5, AD2, 4);
    OLED_ShowNum(4, 5, AD3, 4);
    Delay_ms(100);
}
```

### 定时器触发 + 注入序列

使用定时器的 TRGO 作为外部触发信号，定时启动 ADC 注入序列转换，配合串口将数据发送到 PC 绘制曲线。

定时器配置：72MHz 时钟，PSC=71（72 分频得 1MHz），ARR=999（周期 1ms），TRGO 设置为 Update 模式，每毫秒输出一个脉冲。

注入序列的特点：
- 最多 4 个通道
- 每个通道有独立的结果寄存器（JDR1~JDR4）
- 优先级高于常规序列，可打断常规序列执行

### 扫描模式

使能扫描模式后，ADC 可对规则组中多个通道依次转换。配合连续模式 + DMA 可实现多通道自动连续采集。

## DMA + ADC 多通道自动采集

使用 DMA 自动将 ADC 多通道转换结果转运到内存数组，无需 CPU 干预。

### AD.c（DMA 模式）

```c 标准库
#include "stm32f10x.h"

uint16_t AD_Value[4];

void AD_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_55Cycles5);
    ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 2, ADC_SampleTime_55Cycles5);
    ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 3, ADC_SampleTime_55Cycles5);
    ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 4, ADC_SampleTime_55Cycles5);

    ADC_InitTypeDef ADC_InitStructure;
    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    ADC_InitStructure.ADC_ScanConvMode = ENABLE;
    ADC_InitStructure.ADC_NbrOfChannel = 4;
    ADC_Init(ADC1, &ADC_InitStructure);

    DMA_InitTypeDef DMA_InitStructure;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)AD_Value;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = 4;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    DMA_Init(DMA1_Channel1, &DMA_InitStructure);

    DMA_Cmd(DMA1_Channel1, ENABLE);
    ADC_DMACmd(ADC1, ENABLE);
    ADC_Cmd(ADC1, ENABLE);

    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1) == SET);
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1) == SET);

    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
}
```

c HAL库 ADC_HandleTypeDef hadc1; DMA_HandleTypeDef hdma_adc1; uint16_t AD_Value[4];

void AD_Init(void) {

__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
RCC_ADCCLKConfig(RCC_PCLK2_Div6);

GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 4;
HAL_ADC_Init(&hadc1);

ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_1;
sConfig.Rank = ADC_REGULAR_RANK_2;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_2;
sConfig.Rank = ADC_REGULAR_RANK_3;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_3;
sConfig.Rank = ADC_REGULAR_RANK_4;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);

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_MEDIUM;
HAL_DMA_Init(&hdma_adc1);

__HAL_LINKDMA(&hadc1, DMA_Handle, hdma_adc1);

HAL_ADC_Start_DMA(&hadc1, (uint32_t*)AD_Value, 4);

} ~~~

主函数（DMA 模式）

#include "AD.h"
#include "OLED.h"
#include "Delay.h"

int main(void)
{
    OLED_Init();
    AD_Init();

    OLED_ShowString(1, 1, "AD0:");
    OLED_ShowString(2, 1, "AD1:");
    OLED_ShowString(3, 1, "AD2:");
    OLED_ShowString(4, 1, "AD3:");

    while (1)
    {
        OLED_ShowNum(1, 5, AD_Value[0], 4);
        OLED_ShowNum(2, 5, AD_Value[1], 4);
        OLED_ShowNum(3, 5, AD_Value[2], 4);
        OLED_ShowNum(4, 5, AD_Value[3], 4);
        Delay_ms(100);
    }
}

### 寄存器：双通道+DMA（尚硅谷风格）

c void ADC1_Init(void) {

ADC1->CR1 |= ADC_CR1_SCAN;     // 扫描模式
ADC1->SQR1 |= ADC_SQR1_L_0;    // 序列长度=2
ADC1->SQR3 |= 10 << 0;         // 第1个: 通道10
ADC1->SQR3 |= 12 << 5;         // 第2个: 通道12

}

void ADC1_DMA_Init(void) {

RCC->AHBENR |= RCC_AHBENR_DMA1EN;
DMA1_Channel1->CCR &= ~DMA_CCR1_DIR;        // 外设到存储器
DMA1_Channel1->CCR |= DMA_CCR1_MSIZE_0;     // 16位
DMA1_Channel1->CCR |= DMA_CCR1_PSIZE_0;
DMA1_Channel1->CCR |= DMA_CCR1_MINC;        // 存储器递增
DMA1_Channel1->CCR |= DMA_CCR1_CIRC;        // 循环模式
ADC1->CR2 |= ADC_CR2_DMA;                   // ADC DMA使能

}

void ADC1_DMA_StartConvert(uint32_t destAddr, uint8_t len) {

DMA1_Channel1->CPAR = (uint32_t)&(ADC1->DR);
DMA1_Channel1->CMAR = destAddr;
DMA1_Channel1->CNDTR = len;
DMA1_Channel1->CCR |= DMA_CCR1_EN;
ADC1->CR2 |= ADC_CR2_ADON;    // 上电
ADC1->CR2 |= ADC_CR2_CAL;     // 校准
while (ADC1->CR2 & ADC_CR2_CAL) {}
ADC1->CR2 |= ADC_CR2_ADON;    // 开始转换
while ((ADC1->SR & ADC_SR_EOC) == 0) {}

}