ADC 模数转换

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

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

SAR ADC 基本原理

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

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

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

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

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

ADC采样时间与转换时间详解（尚硅谷风格）

采样时间： ADC内部有个采样电容，需要一定时间充到输入电压

可配置为1.5/7.5/13.5/28.5/41.5/55.5/71.5/239.5个ADC时钟周期
输入阻抗越大，需要的采样时间越长
传感器输出阻抗通常几kΩ~十几kΩ，建议使用28.5周期以上

转换时间： STM32F103的ADC是12位，需要12个时钟周期

总时间 = 采样时间 + 12个转换周期
例如：采样=7.5周期，总时间=7.5+12=19.5个ADC时钟周期
ADC时钟14MHz时：19.5/14MHz ≈ 1.39μs

规则通道组的转换顺序：

SQR1的L[3:0]位：规则序列长度（决定转换多少个通道）
SQR1/2/3：寄存器队列，依次存放要转换的通道号
例如：双通道时，L=1，SQR3[4:0]=10(通道10), SQR3[14:10]=12(通道12)
转换结果依次存入ADC_DR，DMA可自动搬运

采样时间与转换时间

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;  // |= 按位或: 保持APB2ENR其他位不变, 只将ADC1外设时钟使能位(bit9)置1

    // === ADC时钟分频: ADCPRE[1:0]位于RCC->CFGR的bit9:8 ===
    // ADCPRE两位编码决定分频系数: 00=2分频, 01=4分频, 10=6分频(常用→12MHz), 11=8分频
    RCC->CFGR |= RCC_CFGR_ADCPRE_1;      // |= 按位或: ADCPRE高位(bit9)置1
    RCC->CFGR &= ~RCC_CFGR_ADCPRE_0;     // &= ~ 按位与+取反: ADCPRE低位(bit8)清零 → ADCPRE[1:0]=10=6分频

    // === GPIO配置: PC0模拟输入 ===
    // CRL寄存器的MODE0[1:0](bit3:2)和CNF0[1:0](bit1:0)控制端口0
    GPIOC->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);  // &= ~ 按位与+取反: 清零MODE0和CNF0所有位
                                                        // MODE[1:0]=00(输入模式), CNF[1:0]=00(模拟输入)

    // === ADC功能配置 ===
    ADC1->CR1 &= ~ADC_CR1_SCAN;          // &= ~ 按位与+取反: SCAN位(bit8)清零→非扫描模式
                                          // 单通道时只转换规则序列1中指定的通道，不会自动扫描多个通道

    ADC1->CR2 |= ADC_CR2_CONT;           // |= 按位或: CONT位(bit1)置1→连续转换模式
                                          // 启动后ADC自动连续转换，无需每次手动触发

    ADC1->CR2 &= ~ADC_CR2_ALIGN;         // &= ~ 按位与+取反: ALIGN位(bit11)清零→数据右对齐
                                          // ADC_DR[11:0]存放有效12位数据, 高4位补0
                                          // 若ALIGN=1则为左对齐(ADC_DR[15:4]存放数据)

    // === 采样时间配置: SMP10[2:0]位于SMPR1的bit15:14:13 ===
    ADC1->SMPR1 |= ADC_SMPR1_SMP10_0;    // |= 按位或: SMP10[2:0]中bit14(SMP10_0)置1
                                          // SMP10[2:0]=001 → 7.5个ADC时钟周期采样时间
                                          // 其他可选值: 000=1.5, 010=13.5, 011=28.5, 100=41.5, 101=55.5, 110=71.5, 111=239.5

    // === 规则序列: SQ1[4:0]位于SQR3的bit4:0 ===
    ADC1->SQR3 |= (uint32_t)10 << 0;     // |= 按位或: SQ1[4:0]=通道号10
                                          // << 左移0位: 通道号10直接填入低5位, 规则序列第1个=ADC_IN10(PC0)
}

void ADC1_StartConvert(void) {
    // === ADON双写序列原理 ===
    // STM32的ADC模块有独立的电源开关，从断电状态到正常工作需要两步:
    // 第1次写ADON=1: 唤醒ADC(内部模拟电路上电, 等待稳定)
    // 第2次写ADON=1: 在CONT=1模式下开始连续转换
    ADC1->CR2 |= ADC_CR2_ADON;           // |= 按位或: ADON位(bit0)置1→第1次写入, 唤醒ADC模块退出断电模式

    // === 校准流程 ===
    ADC1->CR2 |= ADC_CR2_CAL;            // |= 按位或: CAL位(bit2)置1→启动校准
                                          // ADC自动计算内部电容阵列偏移值(约76个ADC时钟周期)
    while (ADC1->CR2 & ADC_CR2_CAL) {}   // & 按位与: 测试CAL位状态
                                          // 校准完成后硬件自动将CAL位清零, 循环等待直到CAL=0

    ADC1->CR2 |= ADC_CR2_ADON;           // |= 按位或: ADON位(bit0)再置1→第2次写入, 启动连续转换

    // === 等待首次转换完成 ===
    while ((ADC1->SR & ADC_SR_EOC) == 0) {}  // & 按位与: 测试EOC位(bit1)
                                              // 转换完成后硬件将EOC置1, 循环等待直到EOC=1
}

double ADC1_ReadV(void) { return ADC1->DR * 3.3 / 4095; }  // ADC_DR[11:0] × 分辨率(3.3V/4095≈0.806mV) = 实际电压
```

### 主函数（单通道）
```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;     // |= 按位或: SCAN位(bit8)置1→扫描模式
                                 // 使能后ADC自动依次转换规则组中所有通道, 从SQ1到SQn
                                 // 每通道转换完成后自动切换到下一通道, 无需软件干预

// SQR1的L[3:0]位(bit23:20)决定规则序列的通道数量, 实际通道数 = L[3:0] + 1
ADC1->SQR1 |= ADC_SQR1_L_0;    // |= 按位或: L[3:0]中最低位(bit20)置1→L[3:0]=0001
                                 // 序列长度 = 1 + 1 = 2 个通道

ADC1->SQR3 |= (uint32_t)10 << 0;  // |= 按位或: SQ1[4:0]位(bit4:0)=10
                                   // << 左移0位: 通道号10填入低5位
                                   // 规则序列第1个转换通道 = ADC_IN10(PC0)

ADC1->SQR3 |= (uint32_t)12 << 5;  // |= 按位或: SQ2[9:5]位(bit9:5)=12
                                   // << 左移5位: 通道号12从位5开始写入
                                   // 规则序列第2个转换通道 = ADC_IN12(PC2)

}

void ADC1_DMA_Init(void) {

// === DMA时钟使能 ===
RCC->AHBENR |= RCC_AHBENR_DMA1EN;  // |= 按位或: DMA1时钟使能位(bit0)置1, 使能DMA1(AHB总线外设)

// === 配置DMA通道1的CCR寄存器 ===
// CCR寄存器各控制位详解:
DMA1_Channel1->CCR &= ~DMA_CCR1_DIR;        // &= ~ 按位与+取反: DIR位(bit4)清零
                                              // DIR=0: 从外设(Peripheral)到存储器(Memory)
                                              // DIR=1: 从存储器到外设
DMA1_Channel1->CCR |= DMA_CCR1_MSIZE_0;     // |= 按位或: MSIZE[1:0]低位(bit9)置1
                                              // MSIZE[1:0]=01 → 存储器数据宽度=16位
                                              // 其他: 00=8位, 10=32位
DMA1_Channel1->CCR |= DMA_CCR1_PSIZE_0;     // |= 按位或: PSIZE[1:0]低位(bit7)置1
                                              // PSIZE[1:0]=01 → 外设数据宽度=16位(与ADC_DR匹配)
                                              // 数据宽度不一致时DMA自动做对齐转换
DMA1_Channel1->CCR |= DMA_CCR1_MINC;        // |= 按位或: MINC位(bit6)置1→存储器地址递增
                                              // 每次传输后存储地址自动+2(16位), 节省CPU更新地址
DMA1_Channel1->CCR |= DMA_CCR1_CIRC;        // |= 按位或: CIRC位(bit5)置1→循环模式
                                              // CNDTR减到0后自动重装初始值, 实现连续循环采集

// === ADC DMA请求使能 ===
ADC1->CR2 |= ADC_CR2_DMA;                   // |= 按位或: DMA位(bit8)置1
                                              // 使能ADC的DMA请求, 每次EOC事件后硬件自动向DMA发送传输请求

}

void ADC1_DMA_StartConvert(uint32_t destAddr, uint8_t len) {

// === 设置DMA传输参数(直接赋值, 非位运算) ===
DMA1_Channel1->CPAR = (uint32_t)&(ADC1->DR);  // 直接赋值: CPAR=ADC数据寄存器地址(外设源地址)
DMA1_Channel1->CMAR = destAddr;                 // 直接赋值: CMAR=用户缓冲区地址(存储器目标地址)
DMA1_Channel1->CNDTR = len;                     // 直接赋值: CNDTR=待传输次数(多通道时=通道数)
                                                  // CIRC模式下CNDTR会自动回到初始值

DMA1_Channel1->CCR |= DMA_CCR1_EN;              // |= 按位或: EN位(bit0)置1→使能DMA通道1, 等待外设请求

// === ADC启动转换(同单通道) ===
ADC1->CR2 |= ADC_CR2_ADON;    // |= 按位或: ADON置1→第1次写入, 唤醒ADC
ADC1->CR2 |= ADC_CR2_CAL;     // |= 按位或: CAL置1→启动校准
while (ADC1->CR2 & ADC_CR2_CAL) {}  // & 按位与: 等待硬件自动清零CAL
ADC1->CR2 |= ADC_CR2_ADON;    // |= 按位或: ADON置1→第2次写入, 启动连续转换
while ((ADC1->SR & ADC_SR_EOC) == 0) {}  // & 按位与: 等待首次转换完成
                                           // 之后DMA自动转运, CPU不再干预

}


### ADC核心函数速查（标注版）

**单次转换：**
- `ADC1->CR2 |= ADC_CR2_ADON;`  // |= 按位或: ADON(bit0)位置1→第1次写入=上电唤醒ADC
- `ADC1->CR2 |= ADC_CR2_CAL;`   // |= 按位或: CAL(bit2)位置1→启动校准, 等待硬件自动清零
- `ADC1->CR2 |= ADC_CR2_ADON;`  // |= 按位或: ADON(bit0)再置1→第2次写入=触发开始转换
- `while (!(ADC1->SR & ADC_SR_EOC));`  // & 按位与: 测试EOC(bit1), 等待转换完成(硬件置1)
- `ADC1->DR`  // 读取ADC_DR[11:0]→12位转换结果(右对齐)

**配置关键点：**
- `ADC1->CR2 |= ADC_CR2_CONT;`  // |= 按位或: CONT(bit1)置1→连续转换模式(一次触发持续转换)
- `ADC1->CR1 &= ~ADC_CR1_SCAN;` // &= ~ 按位与+取反: SCAN(bit8)清零→非扫描模式(仅转换规则序列1)
- `ADC1->SMPR1 |= SMP10_x;`     // |= 按位或: SMP10[2:0]设置采样时间: 001=7.5周期, 111=239.5周期
- `ADC1->SQR3 |= ch << 0;`      // |= 按位或: SQ1[4:0]填入ch(ch<<0), 设置规则序列1的通道号(0~17)

```

10-ADC模数转换.md 23 KB Vēsture Neapstrādāts