Adc on CLing

PUYA ADC — 软件触发单次转换（多通道）

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 软件触发单次转换（多通道）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_MultiChannelSingleConversion_TriggerSW/Src/main.c

功能简介

ADC（模数转换器）把引脚上的模拟电压转换成数字量，是读取电位器、温湿度、光照等模拟传感器的基础。

本示例演示软件触发 + 单次转换 + 轮询等待的经典用法：

配置 ADC1，12 位分辨率，扫描通道 0、1、4；
上电后先做校准（Calibration），再用 HAL_ADC_Start() 由软件启动一次转换；
用 HAL_ADC_PollForConversion() 轮询等待转换结束，读取结果；
通过串口（USART2，PA2/PA3，115200）把采样值打印出来。

文件名虽带 MultiChannel，但 ContinuousConvMode = DISABLE、ExternalTrigConv = ADC_SOFTWARE_START，本质就是“软件触发、扫描多个通道、各转换一次”的模式，最贴合“软件触发单次转换”的教学需求。

硬件准备

PY32F030 开发板
可调电位器（中间抽头接 PA0 / PA1 / PA4 任一处）或信号源
串口调试工具（USB 转串口接 PA2=TX、PA3=RX，波特率 115200）
板载串口打印由 BSP_USART_Config() 初始化（见 py32f030xx_Start_Kit.c）

完整代码

#include "main.h"

/* ADC 句柄与通道配置、保存 3 路采样值 */
ADC_HandleTypeDef       AdcHandle;
ADC_ChannelConfTypeDef  sConfig;
uint32_t adc_value[3];

/* 静态函数声明 */
static void APP_AdcInit(void);

int main(void)
{
  /* 1. HAL 初始化（含 SysTick 时基） */
  HAL_Init();

  /* 2. 初始化 ADC（含校准） */
  APP_AdcInit();

  /* 3. 初始化调试串口（printf 重定向到 USART2） */
  DEBUG_USART_Config();

  while (1)
  {
    /* 4. 软件启动一次 ADC 转换 */
    HAL_ADC_Start(&AdcHandle);

    for (uint8_t i = 0; i < 3; i++)
    {
      /* 5. 轮询等待本通道转换完成（超时 10000ms） */
      HAL_ADC_PollForConversion(&AdcHandle, 10000);
      /* 6. 读取转换结果（12 位，右对齐） */
      adc_value[i] = HAL_ADC_GetValue(&AdcHandle);
      printf("adc[%u]:%u\r\n", i, (unsigned int)adc_value[i]);
    }

    HAL_Delay(1000);   /* 每秒采样一轮 */
  }
}

/**
  * @brief  ADC 初始化：先复位与校准，再配时钟/分辨率/通道
  */
static void APP_AdcInit(void)
{
  /* 复位 ADC 外设，保证起始状态干净 */
  __HAL_RCC_ADC_FORCE_RESET();
  __HAL_RCC_ADC_RELEASE_RESET();
  __HAL_RCC_ADC_CLK_ENABLE();                    /* 开启 ADC 时钟 */

  AdcHandle.Instance = ADC1;
  /* 上电校准：必须在使用 ADC 前执行，否则精度受影响 */
  if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  AdcHandle.Instance = ADC1;
  AdcHandle.Init.ClockPrescaler      = ADC_CLOCK_SYNC_PCLK_DIV4;   /* ADC 时钟 = PCLK/4 */
  AdcHandle.Init.Resolution          = ADC_RESOLUTION_12B;         /* 12 位分辨率 */
  AdcHandle.Init.DataAlign           = ADC_DATAALIGN_RIGHT;        /* 数据右对齐 */
  AdcHandle.Init.ScanConvMode        = ADC_SCAN_DIRECTION_FORWARD; /* 按通道号顺序扫描 */
  AdcHandle.Init.EOCSelection        = ADC_EOC_SINGLE_CONV;        /* 每完成一次转换产生 EOC */
  AdcHandle.Init.LowPowerAutoWait    = ENABLE;                     /* 等待转换模式，省功耗 */
  AdcHandle.Init.ContinuousConvMode  = DISABLE;                    /* 单次转换（不连续） */
  AdcHandle.Init.DiscontinuousConvMode = DISABLE;                  /* 关闭间断模式 */
  AdcHandle.Init.ExternalTrigConv    = ADC_SOFTWARE_START;         /* 软件触发 */
  AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* 无外部触发边沿 */
  AdcHandle.Init.DMAContinuousRequests = DISABLE;                  /* 不使用 DMA */
  AdcHandle.Init.Overrun             = ADC_OVR_DATA_OVERWRITTEN;   /* 溢出时覆盖旧值 */
  AdcHandle.Init.SamplingTimeCommon  = ADC_SAMPLETIME_239CYCLES_5; /* 采样时间 239.5 周期 */
  if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  /* 依次把通道 0、1、4 加入扫描序列（Rank 方式排队） */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank    = ADC_RANK_CHANNEL_NUMBER;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();

  sConfig.Channel = ADC_CHANNEL_1;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();

  sConfig.Channel = ADC_CHANNEL_4;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();
}

void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. 校准与时钟

PY32F0xx 的 SAR ADC 上电后必须执行 HAL_ADCEx_Calibration_Start() 消除内部失调，否则读数偏差很大。ADC 时钟通过 ADC_CLOCK_SYNC_PCLK_DIV4 分频得到，需满足数据手册规定的最大 ADC 时钟（通常 ≤ 16MHz）。

2. 软件触发 vs 硬件触发

ExternalTrigConv = ADC_SOFTWARE_START 表示转换由 HAL_ADC_Start() 启动；若用定时器触发，则设为 ADC_EXTERNALTRIGCONV_Tx_TRGO 等并配置边沿。教学阶段用软件触发最简单直观。

3. 单次 / 连续 / 扫描

ContinuousConvMode = DISABLE：每调用一次 HAL_ADC_Start() 只转换一轮（这里 3 个通道各一次）。
ScanConvMode = FORWARD：多通道时按 Rank 顺序自动切换通道。
每个通道转换完都会置 EOC，HAL_ADC_PollForConversion() 就是在等这个标志。

4. 结果换算

12 位右对齐时，读数与电压关系为：

`1`	`电压(V) = 读数 / 4095 × VREF+`

PY32F030 内部参考电压 VREF+ 一般等于 VDDA（多为 3.3V）。

实验现象

串口助手（115200-8-N-1）每秒打印一次：
1 2 3

adc[0]:1234 adc[1]:2047 adc[2]:888
转动接在 PA0/PA1/PA4 的电位器，对应通道数值随之变化（0~4095）。

常见问题

读数一直是 0 或 4095（满偏）？
- 检查引脚是否真的接到模拟信号；悬空输入会被上/下拉拉到极端值。
- 确认 VREF+/VDDA 供电正常。
读数跳动很大？
- 增大 SamplingTimeCommon（采样时间），给内部采样电容更长的充电时间；信号源内阻大时尤其需要。
- 软件上可做多次采样取平均。
想用 DMA 自动搬运多路数据？
- 参考同目录 ADC_ContinuousConversion_DMA，把 DMAContinuousRequests 打开并用 HAL_ADC_Start_DMA()。
想固定单通道采样？
- 只 ConfigChannel 一个通道即可，for 循环删掉多余通道。

小结

ADC 标准流程：开时钟 → 校准 → 配参数 → 配通道 → 启动 → 等待 EOC → 读值。
软件触发 + 轮询是最易理解的入门方式；对实时性要求高时用定时器触发 + DMA。
12 位分辨率下满量程 4095，注意参考电压与采样时间对精度的影响。

拓展应用

接 NTC 热敏电阻做温度计（查表/公式换算温度）。
接光敏电阻做光照检测，配合 PWM 自动调光。
用 DMA + 定时器触发做“示波器”式连续采样，再用串口绘图。
读取内部 ADC_CHANNEL_VREFINT（参考电压）与 ADC_CHANNEL_TEMPSENSOR（温度）做自校准/测温。

AT32 — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

AT32 — 模数转换器 (ADC)

固件库: AT32F403A_407_Firmware_Library V2.2.2
示例数: 8

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

双 ADC 联合规则同步模式 — combine_mode_ordinary_simult
内部参考电压 & 电流检测 — current_vref_value_check
外部中断触发分区采样 — exint_trigger_partitioned
内部温度传感器读取 — internal_temperature_sensor
循环重复转换 + DMA — repeat_conversion_loop_transfer
定时器触发自动抢占 — tmr_trigger_automatic_preempted
三 ADC 同步触发 — triple_adc_synchro_trigger
模拟看门狗电压监测 — voltage_monitoring

AT32 ADC — 定时器触发自动抢占

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 定时器触发自动抢占

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/tmr_trigger_automatic_preempted/src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint16_t adc1_ordinary_valuetab[3] = {0};
__IO uint16_t adc1_preempt_valuetab[3] = {0};
__IO uint16_t dma_trans_complete_flag = 0;
__IO uint16_t ordinary_conversion_times_index = 0;
__IO uint16_t preempt_conversion_count = 0;
__IO uint16_t preempt_conversion_times_index = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6 | GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);

  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1;
  gpio_init(GPIOB, &gpio_initstructure);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(DMA1_Channel1_IRQn, 0, 0);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);
}

static void tmr1_config(void)
{
  gpio_init_type gpio_initstructure;
  tmr_output_config_type tmr_oc_init_structure;
  crm_clocks_freq_type crm_clocks_freq_struct = {0};
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_8;
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_NONE;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init(GPIOA, &gpio_initstructure);

  /* get system clock */
  crm_clocks_freq_get(&crm_clocks_freq_struct);

  crm_periph_clock_enable(CRM_TMR1_PERIPH_CLOCK, TRUE);

  /* (systemclock/(systemclock/10000))/10000 = 1Hz(1s) */
  tmr_base_init(TMR1, 9999, (crm_clocks_freq_struct.sclk_freq/10000 - 1));
  tmr_cnt_dir_set(TMR1, TMR_COUNT_UP);
  tmr_clock_source_div_set(TMR1, TMR_CLOCK_DIV1);

  tmr_output_default_para_init(&tmr_oc_init_structure);
  tmr_oc_init_structure.oc_mode = TMR_OUTPUT_CONTROL_PWM_MODE_A;
  tmr_oc_init_structure.oc_polarity = TMR_OUTPUT_ACTIVE_LOW;
  tmr_oc_init_structure.oc_output_state = TRUE;
  tmr_oc_init_structure.oc_idle_state = FALSE;
  tmr_output_channel_config(TMR1, TMR_SELECT_CHANNEL_1, &tmr_oc_init_structure);
  tmr_channel_value_set(TMR1, TMR_SELECT_CHANNEL_1, 5000);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  nvic_irq_enable(ADC1_2_IRQn, 0, 0);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_TMR1CH1, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);

  adc_preempt_channel_length_set(ADC1, 3);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_7, 1, ADC_SAMPLETIME_239_5);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_8, 2, ADC_SAMPLETIME_239_5);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_9, 3, ADC_SAMPLETIME_239_5);
  adc_preempt_conversion_trigger_set(ADC1, ADC12_PREEMPT_TRIG_SOFTWARE, TRUE);
  adc_preempt_auto_mode_enable(ADC1, TRUE);
  adc_interrupt_enable(ADC1, ADC_PCCE_INT, TRUE);

  adc_enable(ADC1, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  tmr1_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("tmr_trigger_automatic_preempted \r\n");
  tmr_counter_enable(TMR1, TRUE);
  tmr_channel_enable(TMR1, TMR_SELECT_CHANNEL_1, TRUE);
  tmr_output_enable(TMR1, TRUE);
  while(1)
  {
    /* wait ordinary conversion end */
    if(ordinary_conversion_times_index != dma_trans_complete_flag)
    {
      ordinary_conversion_times_index = dma_trans_complete_flag;
      printf("ordinary_conversion_times_index = %d\r\n",ordinary_conversion_times_index);
      printf("adc1_ordinary_valuetab[0] = 0x%x\r\n", adc1_ordinary_valuetab[0]);
      printf("adc1_ordinary_valuetab[1] = 0x%x\r\n", adc1_ordinary_valuetab[1]);
      printf("adc1_ordinary_valuetab[2] = 0x%x\r\n", adc1_ordinary_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED2);
    }

    /* wait preempt conversion end */
    if(preempt_conversion_times_index != preempt_conversion_count)
    {
      preempt_conversion_times_index = preempt_conversion_count;
      printf("preempt_conversion_times_index = %d\r\n",preempt_conversion_times_index);
      printf("adc1_preempt_valuetab[0] = 0x%x\r\n", adc1_preempt_valuetab[0]);
      printf("adc1_preempt_valuetab[1] = 0x%x\r\n", adc1_preempt_valuetab[1]);
      printf("adc1_preempt_valuetab[2] = 0x%x\r\n", adc1_preempt_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED3);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 模拟看门狗电压监测

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 模拟看门狗电压监测

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/voltage_monitoring/src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint16_t adc1_ordinary_valuetab[3] = {0};
__IO uint16_t vmor_flag_index = 0;
__IO uint16_t error_times_index = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6;
  gpio_init(GPIOA, &gpio_initstructure);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  nvic_irq_enable(ADC1_2_IRQn, 0, 0);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);
  adc_voltage_monitor_enable(ADC1, ADC_VMONITOR_SINGLE_ORDINARY);
  adc_voltage_monitor_threshold_value_set(ADC1, 0xBBB, 0xAAA);
  adc_voltage_monitor_single_channel_select(ADC1, ADC_CHANNEL_5);
  adc_interrupt_enable(ADC1, ADC_VMOR_INT, TRUE);

  adc_enable(ADC1, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("voltage_monitoring \r\n");
  while(1)
  {
    at32_led_toggle(LED2);
    delay_sec(1);
    if(error_times_index != vmor_flag_index)
    {
      error_times_index = vmor_flag_index;
      printf("error_times_index = %d\r\n",error_times_index);
      printf("out of range:adc1_channel_5 value is = %x!\r\n", adc1_ordinary_valuetab[1]);
    }
    adc_ordinary_software_trigger_enable(ADC1, TRUE);
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 内部温度传感器读取

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 内部温度传感器读取

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/internal_temperature_sensor/src/main.c

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define ADC_VREF                         (3.3)
#define ADC_TEMP_BASE                    (1.28)
#define ADC_TEMP_SLOPE                   (-0.00426)
__IO uint16_t adc1_ordinary_value = 0;

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 1;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)&adc1_ordinary_value;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = FALSE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = FALSE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 1;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_16, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);
  adc_tempersensor_vintrv_enable(TRUE);

  adc_enable(ADC1, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("internal_temperature_sensor \r\n");
  adc_ordinary_software_trigger_enable(ADC1, TRUE);
  while(1)
  {
    /* ordinary software start conversion */
    adc_ordinary_software_trigger_enable(ADC1, TRUE);

    /* wait conversion end */
    while(dma_flag_get(DMA1_FDT1_FLAG) == RESET)
    {
    }
    dma_flag_clear(DMA1_FDT1_FLAG);
    printf("internal_temperature = %f deg C\r\n",(ADC_TEMP_BASE - (double)adc1_ordinary_value * ADC_VREF / 4095) / ADC_TEMP_SLOPE + 25);
    at32_led_toggle(LED2);
    delay_sec(1);
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 三 ADC 同步触发

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 三 ADC 同步触发

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/triple_adc_synchro_trigger/src/main.c

功能简介

本示例演示多 ADC 协同工作。多个 ADC 同时采样不同通道，适用于需要同步采集多路信号的场景（如三相电压/电流）。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint32_t adc1_ordinary_valuetab[3];
__IO uint16_t adc3_ordinary_valuetab[3];
__IO uint32_t dma1_trans_complete_flag = 0;
__IO uint16_t adc12_ordinary_conversion_times_index = 0;
__IO uint32_t dma2_trans_complete_flag = 0;
__IO uint16_t adc3_ordinary_conversion_times_index = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6 | GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);

  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1;
  gpio_init(GPIOB, &gpio_initstructure);

  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1 | GPIO_PINS_2;
  gpio_init(GPIOC, &gpio_initstructure);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_DMA2_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(DMA1_Channel1_IRQn, 0, 0);
  nvic_irq_enable(DMA2_Channel4_5_IRQn, 0, 0);
  dma_reset(DMA1_CHANNEL1);
  dma_reset(DMA2_CHANNEL5);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_WORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_WORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  dma_init_struct.memory_base_addr = (uint32_t)adc3_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC3->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init(DMA2_CHANNEL5, &dma_init_struct);

  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);
  dma_interrupt_enable(DMA2_CHANNEL5, DMA_FDT_INT, TRUE);
}

static void tmr1_config(void)
{
  crm_clocks_freq_type crm_clocks_freq_struct = {0};

  /* get system clock */
  crm_clocks_freq_get(&crm_clocks_freq_struct);

  crm_periph_clock_enable(CRM_TMR1_PERIPH_CLOCK, TRUE);

  /* (systemclock/(systemclock/10000))/10000 = 1Hz(1s) */
  tmr_base_init(TMR1, 9999, (crm_clocks_freq_struct.sclk_freq/10000 - 1));
  tmr_cnt_dir_set(TMR1, TMR_COUNT_UP);
  tmr_clock_source_div_set(TMR1, TMR_CLOCK_DIV1);
  tmr_primary_mode_select(TMR1, TMR_PRIMARY_SEL_OVERFLOW);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_ADC2_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_ADC3_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  adc_reset(ADC2);
  adc_reset(ADC3);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_ORDINARY_SMLT_ONLY_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_TMR1TRGOUT, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);

  /* ADC2 config */
  adc_base_config(ADC2, &adc_base_struct);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_7, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_8, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_9, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC2, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);

  /* ADC3 config */
  adc_base_config(ADC3, &adc_base_struct);
  adc_ordinary_channel_set(ADC3, ADC_CHANNEL_10, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC3, ADC_CHANNEL_11, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC3, ADC_CHANNEL_12, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC3, ADC3_ORDINARY_TRIG_TMR1TRGOUT, TRUE);
  adc_dma_mode_enable(ADC3, TRUE);

  adc_enable(ADC1, TRUE);
  adc_enable(ADC2, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
  adc_calibration_init(ADC2);
  while(adc_calibration_init_status_get(ADC2));
  adc_calibration_start(ADC2);
  while(adc_calibration_status_get(ADC2));

  adc_enable(ADC3, TRUE);
  adc_calibration_init(ADC3);
  while(adc_calibration_init_status_get(ADC3));
  adc_calibration_start(ADC3);
  while(adc_calibration_status_get(ADC3));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  tmr1_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);
  dma_channel_enable(DMA2_CHANNEL5, TRUE);

  printf("triple_adc_synchro_trigger \r\n");

  tmr_counter_enable(TMR1, TRUE);
  while(1)
  {
    /* wait ordinary conversion end */
    if(adc12_ordinary_conversion_times_index != dma1_trans_complete_flag)
    {
      adc12_ordinary_conversion_times_index = dma1_trans_complete_flag;
      printf("adc12_ordinary_conversion_times_index = %d\r\n",adc12_ordinary_conversion_times_index);
      printf("adc1_ordinary_valuetab[0] = 0x%x\r\n", adc1_ordinary_valuetab[0]);
      printf("adc1_ordinary_valuetab[1] = 0x%x\r\n", adc1_ordinary_valuetab[1]);
      printf("adc1_ordinary_valuetab[2] = 0x%x\r\n", adc1_ordinary_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED2);
    }

    /* wait preempt conversion end */
    if(adc3_ordinary_conversion_times_index != dma2_trans_complete_flag)
    {
      adc3_ordinary_conversion_times_index = dma2_trans_complete_flag;
      printf("adc3_ordinary_conversion_times_index = %d\r\n",adc3_ordinary_conversion_times_index);
      printf("adc3_ordinary_valuetab[0] = 0x%x\r\n", adc3_ordinary_valuetab[0]);
      printf("adc3_ordinary_valuetab[1] = 0x%x\r\n", adc3_ordinary_valuetab[1]);
      printf("adc3_ordinary_valuetab[2] = 0x%x\r\n", adc3_ordinary_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED3);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 双 ADC 联合规则同步模式

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 双 ADC 联合规则同步模式

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/combine_mode_ordinary_simult/src/main.c

功能简介

本示例演示多 ADC 协同工作。多个 ADC 同时采样不同通道，适用于需要同步采集多路信号的场景（如三相电压/电流）。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint32_t adc1_ordinary_valuetab[3];
__IO uint32_t dma1_trans_complete_flag = 0;
__IO uint32_t conversion_times_index = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6 | GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);

  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1;
  gpio_init(GPIOB, &gpio_initstructure);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(DMA1_Channel1_IRQn, 0, 0);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_WORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_WORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_ADC2_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  adc_reset(ADC2);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_ORDINARY_SMLT_ONLY_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);

  /* ADC2 config */
  adc_base_config(ADC2, &adc_base_struct);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_7, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_8, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC2, ADC_CHANNEL_9, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC2, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);

  adc_enable(ADC1, TRUE);
  adc_enable(ADC2, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
  adc_calibration_init(ADC2);
  while(adc_calibration_init_status_get(ADC2));
  adc_calibration_start(ADC2);
  while(adc_calibration_status_get(ADC2));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("combine_mode_ordinary_simult \r\n");
  while(1)
  {
    /* ordinary software start conversion */
    adc_ordinary_software_trigger_enable(ADC1, TRUE);

    /* wait conversion end */
    while(conversion_times_index == dma1_trans_complete_flag)
    {
    }
    conversion_times_index = dma1_trans_complete_flag;
    printf("conversion_times_index = %d\r\n",conversion_times_index);
    printf("adc1_ordinary_channel4 = 0x%x\r\n", adc1_ordinary_valuetab[0] & 0xFFFF);
    printf("adc1_ordinary_channel5 = 0x%x\r\n", adc1_ordinary_valuetab[1] & 0xFFFF);
    printf("adc1_ordinary_channel6 = 0x%x\r\n", adc1_ordinary_valuetab[2] & 0xFFFF);
    printf("adc2_ordinary_channel7 = 0x%x\r\n", (adc1_ordinary_valuetab[0] >> 16) & 0xFFFF);
    printf("adc2_ordinary_channel8 = 0x%x\r\n", (adc1_ordinary_valuetab[1] >> 16) & 0xFFFF);
    printf("adc2_ordinary_channel9 = 0x%x\r\n", (adc1_ordinary_valuetab[2] >> 16) & 0xFFFF);
    printf("\r\n");
    at32_led_toggle(LED2);
    delay_sec(1);
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 外部中断触发分区采样

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 外部中断触发分区采样

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/exint_trigger_partitioned/src/main.c

功能简介

本示例演示 ADC 分区采样模式，通过外部中断触发不连续的通道组采样。适合多路信号按需切换采集的场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint16_t adc1_ordinary_valuetab[3] = {0};
__IO uint16_t adc1_preempt_valuetab[3] = {0};
__IO uint16_t dma_trans_complete_flag = 0;
__IO uint16_t ordinary_conversion_times_index = 0;
__IO uint16_t preempt_trigger_count = 0;
__IO uint16_t preempt_conversion_times_index = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6 | GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);

  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1;
  gpio_init(GPIOB, &gpio_initstructure);
}

static void exint_config(void)
{
  gpio_init_type gpio_initstructure;
  exint_init_type exint_init_struct;

  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);

  gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOC, GPIO_PINS_SOURCE11);
  gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOA, GPIO_PINS_SOURCE15);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_pull           = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode           = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins           = GPIO_PINS_11;
  gpio_init(GPIOC, &gpio_initstructure);
  gpio_initstructure.gpio_pull           = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode           = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins           = GPIO_PINS_15;
  gpio_init(GPIOA, &gpio_initstructure);

  exint_default_para_init(&exint_init_struct);
  exint_init_struct.line_enable = TRUE;
  exint_init_struct.line_mode = EXINT_LINE_EVENT;
  exint_init_struct.line_select = EXINT_LINE_11;
  exint_init_struct.line_polarity = EXINT_TRIGGER_RISING_EDGE;
  exint_init(&exint_init_struct);

  exint_init_struct.line_select = EXINT_LINE_15;
  exint_init(&exint_init_struct);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(DMA1_Channel1_IRQn, 0, 0);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  nvic_irq_enable(ADC1_2_IRQn, 0, 0);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = FALSE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_EXINT11_TMR8TRGOUT, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);
  adc_ordinary_part_count_set(ADC1, 1);
  adc_ordinary_part_mode_enable(ADC1, TRUE);

  adc_preempt_channel_length_set(ADC1, 3);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_7, 1, ADC_SAMPLETIME_239_5);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_8, 2, ADC_SAMPLETIME_239_5);
  adc_preempt_channel_set(ADC1, ADC_CHANNEL_9, 3, ADC_SAMPLETIME_239_5);
  adc_preempt_conversion_trigger_set(ADC1, ADC12_PREEMPT_TRIG_EXINT15_TMR8CH4, TRUE);
  adc_interrupt_enable(ADC1, ADC_PCCE_INT, TRUE);

  adc_enable(ADC1, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  exint_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("exint_trigger_partitioned \r\n");
  while(1)
  {
    /* wait ordinary conversion end */
    if(ordinary_conversion_times_index != dma_trans_complete_flag)
    {
      ordinary_conversion_times_index = dma_trans_complete_flag;
      printf("ordinary_conversion_times_index = %d\r\n",ordinary_conversion_times_index);
      printf("adc1_ordinary_valuetab[0] = 0x%x\r\n", adc1_ordinary_valuetab[0]);
      printf("adc1_ordinary_valuetab[1] = 0x%x\r\n", adc1_ordinary_valuetab[1]);
      printf("adc1_ordinary_valuetab[2] = 0x%x\r\n", adc1_ordinary_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED2);
    }

    /* wait preempt conversion end */
    if(preempt_conversion_times_index != preempt_trigger_count)
    {
      preempt_conversion_times_index = preempt_trigger_count;
      printf("preempt_conversion_times_index = %d\r\n",preempt_conversion_times_index);
      printf("adc1_preempt_valuetab[0] = 0x%x\r\n", adc1_preempt_valuetab[0]);
      printf("adc1_preempt_valuetab[1] = 0x%x\r\n", adc1_preempt_valuetab[1]);
      printf("adc1_preempt_valuetab[2] = 0x%x\r\n", adc1_preempt_valuetab[2]);
      printf("\r\n");
      at32_led_toggle(LED3);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

AT32 ADC — 循环重复转换 + DMA

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 循环重复转换 + DMA

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/adc/repeat_conversion_loop_transfer/src/main.c

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
__IO uint16_t adc1_ordinary_valuetab[3] = {0};
__IO uint16_t dma_trans_complete_flag = 0;

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_initstructure);
  gpio_initstructure.gpio_mode = GPIO_MODE_ANALOG;
  gpio_initstructure.gpio_pins = GPIO_PINS_4 | GPIO_PINS_5 | GPIO_PINS_6;
  gpio_init(GPIOA, &gpio_initstructure);
}

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(DMA1_Channel1_IRQn, 0, 0);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)adc1_ordinary_valuetab;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);
}

static void adc_config(void)
{
  adc_base_config_type adc_base_struct;
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);
  crm_adc_clock_div_set(CRM_ADC_DIV_4);
  adc_base_default_para_init(&adc_base_struct);

  /* select combine mode */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC1 config */
  adc_base_struct.sequence_mode = TRUE;
  adc_base_struct.repeat_mode = TRUE;
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT;
  adc_base_struct.ordinary_channel_length = 3;
  adc_base_config(ADC1, &adc_base_struct);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_4, 1, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_5, 2, ADC_SAMPLETIME_239_5);
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_6, 3, ADC_SAMPLETIME_239_5);
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);
  adc_dma_mode_enable(ADC1, TRUE);

  adc_enable(ADC1, TRUE);

  /* ADC calibration */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));
}

int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  uart_print_init(115200);
  gpio_config();
  dma_config();
  adc_config();

  /* enable DMA after ADC activation */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("repeat_conversion_loop_transfer \r\n");
  printf("please_debug_check_data_and_conversion_times \r\n");

  /* ordinary software start conversion */
  adc_ordinary_software_trigger_enable(ADC1, TRUE);

  at32_led_on(LED2);
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

串口初始化：配置串口波特率（这里是 115200），使能 printf 重定向。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

CIU32 — 模数转换器 (ADC)

固件库: CIU32F003_STDLib V1.0.3
示例数: 7

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

ADC 不连续转换定时触发 — ADC_DiscontinuousConversion_TriggerTime_Poll
ADC 外部中断触发单次转换 — ADC_SingleConversion_TriggerEXTI_Poll
ADC 软件触发 + 模拟看门狗 — ADC_SingleConversion_TriggerSW_AWD
ADC 内部基准校准 — ADC_SingleConversion_TriggerSW_BGRCalibration
ADC 软件触发单次转换 (中断) — ADC_SingleConversion_TriggerSW_Interrupt
ADC_SingleConversion_TriggerSW_Poll — ADC_SingleConversion_TriggerSW_Poll
ADC 唤醒单次转换 — ADC_Wakeup_SingleConversion_TriggerSW_Poll

CIU32 ADC — ADC 不连续转换定时触发

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 不连续转换定时触发

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_DiscontinuousConversion_TriggerTime_Poll/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define VREF_ADC_VDDA_VOLTAGE        (3300U)
#define ADC_CHANNEL_NUM              (1U)
__IO uint32_t g_voltage_buf[ADC_CHANNEL_NUM];

int main(void)
{
    uint32_t i;
    
    /* ϵͳʱ(RCH 48MHz) */
    system_clock_config(); 
    
    /* ʱʼ */
    std_delay_init();

    /* GPIOʼ */
    gpio_init();

    /* TIM3ʼ */
    tim3_init();

    /* ADCʼ */
    adc_init();
    
    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();
    
    /* ʹTIM3 */
    std_tim_enable(TIM3);
    
    /* ת */
    std_adc_start_conversion();

    while(1)
    {
        /* ǰʾ1ͨͨ޸ADC_CHANNEL_NUMͬʱʹܶӦͨԼ */
        for(i=0; i<ADC_CHANNEL_NUM; i++)
        {
            /* TIM31sһADCADCǰͨѹֵ */
            while(std_adc_get_flag(ADC_FLAG_EOC) == 0U);

            /* EOC־ */
            std_adc_clear_flag(ADC_FLAG_EOC);
            
            /* ȡֵתΪѹֵλmV */
            g_voltage_buf[i] = std_adc_get_conversion_value() * VREF_ADC_VDDA_VOLTAGE / ADC_CONVER_SCALE;  
        }
        
        /* ȴһת */
        while(std_adc_get_flag(ADC_FLAG_EOS) == 0U);
        
        /* EOS־ */
        std_adc_clear_flag(ADC_FLAG_EOS);
        
    } 
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC 唤醒单次转换

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 唤醒单次转换

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_Wakeup_SingleConversion_TriggerSW_Poll/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"

int main(void)
{    
    /* ϵͳʱ */
    system_clock_config();

    /* Systickʼ */
    std_delay_init();
    
    /* GPIOʼ */
    gpio_init();
    
    /* UARTʼ */
    uart_init();
    
    /* ADCʼ */
    adc_init();
       
    /* NVICʼ */
    nvic_init(); 
    
    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();
    
    /* ȴ3Sû */
    std_delayms(3000); 
    
    while(1)
    {
        /* ʹͨVBGR */
        std_adc_internal_channel_vbgr_enable();
        
        /* ȴڲVBGRͨȶ */
        std_delayus(ADC_VBGR_CHANNEL_DELAY);
        
        /* ʹADC */
        std_adc_enable();
        
        /* ȴADCʹ״̬ȶ */
        std_delayus(ADC_EN_DELAY);
        
        /* ȡֵתΪѹֵλmV*/
        bsp_adc_get_channel_voltage(g_voltage_buf);
        
        /* ֹADC */
        std_adc_disable();
        
        /* رͨVBGR */
        std_adc_internal_channel_vbgr_disable();
        
        for(uint8_t i = 0; i < ADC_CHANNEL_NUM; i++)
        {
            /* ڴӡADCⲿͨתѹ */
            printf("ADC sample voltage: %d mV\r\n",g_voltage_buf[i]); 
        }

        /* deepstopģʽ */  
        std_pmu_enter_stop(PMU_MODE_DEEPSTOP, PMU_ENTRY_LOWPOWER_MODE_WFI);
        
        /* Ѻ󣬻ָϵͳʱ */
        system_clock_config();
        
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC 内部基准校准

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 内部基准校准

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_SingleConversion_TriggerSW_BGRCalibration/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
__IO uint32_t g_ref_voltage;

int main(void)
{
    /* ϵͳʱ */
    system_clock_config(); 
    
    /* ʱʼ */
    std_delay_init();

    /* ADCʼ */
    adc_init();

    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();
        
    /* ȡֵУ׼οѹֵλmV*/
    g_ref_voltage = bsp_adc_get_channel_voltage(); 
    
    while(1)
    {
        
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC 软件触发 + 模拟看门狗

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 软件触发 + 模拟看门狗

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_SingleConversion_TriggerSW_AWD/Source/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define VREF_ADC_VDDA_VOLTAGE        (3300U)
__IO uint32_t g_voltage;

int main(void)
{
    /* ϵͳʱӣRCH48MHz*/
    system_clock_config();
    
    /* ʱʼ */
    std_delay_init();
    
    /* GPIOʼ */
    gpio_init();
            
    /* ADCʼ */
    adc_init();

    /* NVICʼ */
    nvic_init();
    
    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();

    while(1)
    {
        /* ת */
        std_adc_start_conversion();
        
        /* ȴADCͨת */
        while(std_adc_get_flag(ADC_FLAG_EOC) == 0);
        
        /* EOC־ */
        std_adc_clear_flag(ADC_FLAG_EOC);
        
        /* ȡֵתΪѹֵλmV*/
        g_voltage = std_adc_get_conversion_value() * VREF_ADC_VDDA_VOLTAGE / ADC_CONVER_SCALE;
        
        if(g_interrupt_status == 0x01U)
        {
            g_interrupt_status = 0;
            
            /* LEDת */
            std_gpio_toggle_pin(LED_GPIO_PORT, LED_PIN);
        }
        
        /* 1sתһ*/
        std_delayms(1000); 
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC 软件触发单次转换 (中断)

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 软件触发单次转换 (中断)

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_SingleConversion_TriggerSW_Interrupt/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
__IO uint32_t g_voltage;

int main(void)
{
    /* ϵͳʱ */
    system_clock_config(); 
    
    /* ʱʼ */
    std_delay_init();

    /* GPIOʼ */
    gpio_init();

    /* ADCʼ */
    adc_init();
  
    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();

    /* NVICʼ */
    nvic_init();
 
    while(1)
    {
        /* ȡͨɼѹ */
        g_voltage = bsp_adc_get_channel_voltage();
        
        /* ȴ500ms */
        std_delayms(500);

    } 
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC 外部中断触发单次转换

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 外部中断触发单次转换

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_SingleConversion_TriggerEXTI_Poll/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define VREF_ADC_VDDA_VOLTAGE        (3300U)
__IO uint32_t g_voltage;

int main(void)
{
    /* ϵͳʱ */
    system_clock_config(); 
    
    /* ʱʼ */
    std_delay_init();

    /* GPIOʼ */
    gpio_init();
    
    /* ADCʼ */
    adc_init();

    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();
    
    /* ת */
    std_adc_start_conversion();  
    
    while(1)
    {
        /* ȴADCͨת */
        while(std_adc_get_flag(ADC_FLAG_EOC) == 0U);

        /* EOC־ */
        std_adc_clear_flag(ADC_FLAG_EOC);
        
        /* ȡֵתΪѹֵλmV */
        g_voltage = std_adc_get_conversion_value() * VREF_ADC_VDDA_VOLTAGE / ADC_CONVER_SCALE;  
        
        std_delayms(500);
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

CIU32 ADC — ADC_SingleConversion_TriggerSW_Poll

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerSW_Poll

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/ADC/ADC_SingleConversion_TriggerSW_Poll/Source/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
__IO uint32_t g_voltage;

int main(void)
{
    /* ϵͳʱ */
    system_clock_config(); 
    
    /* ʱʼ */
    std_delay_init();

    /* GPIOʼ */
    gpio_init();

    /* ADCʼ */
    adc_init();
    
    /* ADCУ׼ϵȣϵͳλִֻһ */ 
    bsp_adc_software_calibrate();
    
    while(1)
    {
        /* ȡֵתΪѹֵλmV*/
        g_voltage = bsp_adc_get_channel_voltage();
        /* ȴ500ms */
        std_delayms(500);
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

GD32 — 模数转换器 (ADC)

固件库: GD32F30x_Firmware_Library V3.0.3 示例数: 8

什么是 ADC？

ADC 是 Analog-to-Digital Converter（模数转换器）的缩写。它干的事只有一件：

把一个电压值，翻译成一个整数。

MCU 的世界只有 0 和 1，它天生不认识"1.65 伏"这种连续量。而现实世界全是连续量：温度、光照、压力、声音、电池电压、旋钮位置……这些物理量经过传感器变成电压后，必须由 ADC 转成数字，程序才能处理。

打个比方：ADC 就是 MCU 的"感官神经"。GPIO 输入只能告诉你"有没有"（高/低两档），ADC 能告诉你"有多少"（几千档）。

12 位分辨率意味着什么

GD32F30x 的 ADC 是 12 位 的，也就是把参考电压范围切成 2^12 = 4096 份（0 ~ 4095）。

假设参考电压 VREF+ = 3.3V，那么：

`1`	`数字量 = 输入电压 / 3.3V × 4095`

输入电压	ADC 读数
0 V	0
0.825 V	约 1024
1.65 V	约 2048
3.3 V	4095

分辨率（能分辨的最小电压变化）：

`1`	`3.3V / 4096 ≈ 0.806 mV`

也就是说输入电压变化不到 0.8mV，ADC 读数不会变。这个精度对测电池电压、读电位器、测温度都完全够用。

反算电压的标准公式（写代码必用）：

`1`	`float voltage = (float)adc_value * 3.3f / 4095.0f;`

注意：分母到底用 4095 还是 4096 有争议。严格说满量程码 4095 对应的是 4095/4096 × VREF，工程上直接用 4095 更方便，误差不到 0.03%，可以忽略。

GD32F30x ADC 的硬件资源

项目	参数
ADC 数量	最多 3 个（ADC0 / ADC1 / ADC2）
分辨率	12 位（部分型号支持 6/8/10/12 位可配）
外部通道	16 个（ADC_CHANNEL_0 ~ 15）
内部通道	温度传感器（CH16）、内部参考电压 VREFINT（CH17）
最大采样率	约 2.6 MSPS（ADC 时钟 14MHz 时）
ADC 时钟上限	14 MHz（超频会导致精度严重下降）
触发方式	软件触发、定时器触发、外部引脚触发

ADC 时钟必须分频到 14MHz 以下

这是 ADC 最容易被忽视的一条硬约束。GD32F307 的 APB2 总线跑 120MHz，直接给 ADC 用会烧不了但精度全废。所以必须分频：

`1`	`rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6); /* 120MHz / 6 = 20MHz */`

可选的分频系数有 DIV2 / DIV4 / DIV6 / DIV8 / DIV12 / DIV16。

官方示例用了 DIV6 得到 20MHz，其实已经略微超出 14MHz 的推荐值。追求精度的项目建议用 DIV12（10MHz） 或 DIV16（7.5MHz）。速度慢一点，读数稳定很多。

两组通道：常规组 vs 注入组

这是 ADC 里最让新手困惑的概念，但理解了就很简单。

	常规组（Routine / Regular）	注入组（Inserted / Injected）
通道数上限	16	4
优先级	低	高，可以打断常规组
数据寄存器	只有 1 个，会被覆盖	4 个独立寄存器
典型用途	常态巡检各路电压	紧急采样（如过流保护）
是否需要 DMA	多通道时强烈建议	不需要

类比理解：常规组像是普通门诊，病人按顺序排队看；注入组像是急诊，来了就插队优先处理。

关键坑点：常规组只有一个 ADC_RDATA 数据寄存器。如果你配了 4 个通道连续转换，第 2 个通道的结果会把第 1 个的覆盖掉。解决办法有两个：

一次只转一个通道，转完立刻读走（本模块的软件触发轮询示例就是这个思路，最简单）；
用 DMA 自动把每次结果搬到数组里（参考 ADC0_routine_channel_with_DMA 示例，实际项目标准做法）。

GD32 库把 STM32 里的 Regular/Injected 改叫 Routine/Inserted，所以函数名是 ADC_ROUTINE_CHANNEL 和 ADC_INSERTED_CHANNEL。看 STM32 教程时要做个心理转换。

采样时间怎么选

ADC 采样的物理过程是"给内部一个电容充电到和输入电压相等"。如果信号源内阻大（比如热敏电阻、高阻分压网络），充电就慢，采样时间必须给足，否则读数偏低。

GD32 提供 8 档采样时间：

ADC_SAMPLETIME_1POINT5     /*  1.5 个 ADC 时钟周期 */
ADC_SAMPLETIME_7POINT5     /*  7.5 —— 常用默认值 */
ADC_SAMPLETIME_13POINT5
ADC_SAMPLETIME_28POINT5
ADC_SAMPLETIME_41POINT5
ADC_SAMPLETIME_55POINT5
ADC_SAMPLETIME_71POINT5
ADC_SAMPLETIME_239POINT5   /* 239.5 —— 最慢最准 */

选择原则：

信号源类型	推荐采样时间
低阻源（运放输出、电位器 10kΩ 以下）	`7POINT5` ~ `13POINT5`
中阻源（分压电阻网络、热敏电阻）	`28POINT5` ~ `55POINT5`
内部温度传感器	至少 `239POINT5`（手册明确要求 ≥17.1μs）
高阻源 / 读数不稳	加大到 `239POINT5` 试试

总转换时间计算：

转换时间 = (采样时间 + 12.5 个周期) / ADC时钟频率

例：ADC 时钟 20MHz、采样时间 7.5
   = (7.5 + 12.5) / 20MHz = 1μs

实用经验：读数跳动大的时候，第一件事就是把采样时间加到最大档试试。这个改动一行代码，往往能解决 80% 的"ADC 不准"问题。

五种工作模式

`1`	`adc_mode_config(ADC_MODE_FREE); /* 独立模式 —— 最常用 */`

模式	含义
`ADC_MODE_FREE`	独立模式：每个 ADC 各干各的，互不影响
`ADC_DAUL_REGULAL_PARALLEL`	双 ADC 常规组并行：两个 ADC 同时采两路，采样率翻倍
`ADC_DAUL_REGULAL_FOLLOW_UP_FAST`	快速交替：交错采样，等效采样率翻倍
`ADC_DAUL_INSERTED_PARALLEL`	双 ADC 注入组并行
`ADC_DAUL_REGULAL_PARALLEL_INSERTED_PARALLEL`	常规 + 注入都并行

99% 的项目用 ADC_MODE_FREE 就够了。双 ADC 模式主要用在电机 FOC 控制（需要同一时刻采三相电流）这类高实时性场合。

必须做的两件事：使能后延时 + 校准

1
2
3

adc_enable(ADC0);
delay_1ms(1U);                    /* 等 ADC 上电稳定，手册要求至少 1μs */
adc_calibration_enable(ADC0);      /* 校准，消除内部电容偏差 */

为什么要延时？ ADC 内部有模拟电路，adc_enable() 之后需要一段稳定时间（手册标称 tSTAB ≈ 1μs）。不等就校准，校准结果不准。

为什么要校准？ 芯片制造时内部电容会有工艺偏差，校准过程让 ADC 自己测出偏差值并存起来，后续每次转换都自动补偿。跳过校准会带来几个 LSB 的固定误差，这在测精密电压时不能接受。

校准函数内部会阻塞等待校准完成，所以调用后可以直接开始转换，不用额外等待。注意：校准必须在 adc_enable() 之后做，顺序反了无效。

常用 API 速查

/* ===== 时钟 ===== */
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_ADC0);
rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);      /* ADC 时钟分频，必做 */

/* ===== GPIO：模拟输入 ===== */
gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);

/* ===== ADC 基本参数 ===== */
adc_mode_config(ADC_MODE_FREE);                                    /* 独立模式 */
adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);              /* 右对齐 */
adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);          /* 序列长度 */
adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);    /* 连续转换 */
adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);          /* 扫描模式 */

/* ===== 通道与采样时间 ===== */
adc_routine_channel_config(ADC0, 0U, ADC_CHANNEL_1, ADC_SAMPLETIME_7POINT5);
/*                              ↑序号  ↑通道号        ↑采样时间 */

/* ===== 使能与校准 ===== */
adc_enable(ADC0);
delay_1ms(1U);
adc_calibration_enable(ADC0);

/* ===== 启动转换与读值 ===== */
adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
while(!adc_flag_get(ADC0, ADC_FLAG_EOC));                /* 等转换完成 */
adc_flag_clear(ADC0, ADC_FLAG_EOC);
uint16_t val = adc_routine_data_read(ADC0);

学习路线建议

ADC0_software_trigger_routine_channel_polling ← 从这里开始，最简单最直白，理解 ADC 完整流程
ADC0_temperature_Vref — 用内部温度传感器，不用接任何外部器件就能玩
ADC0_routine_channel_with_DMA — 学会多通道自动采集，这是实际项目的标准做法
ADC1_analog_watchdog — 硬件自动监测超限并中断，做过压/过流保护必学
ADC1_oversample_shift — 过采样提高有效位数，把 12 位提到 16 位精度
ADC0_ADC1_routine_parallel — 双 ADC 同步采样，电机控制场景

示例列表

双 ADC 并行采集 — ADC0_ADC1_routine_parallel
ADC 不连续模式 — ADC0_routine_channel_discontinuous_mode
ADC + DMA 采集 — ADC0_routine_channel_with_DMA
ADC 软件触发轮询 — ADC0_software_trigger_routine_channel_polling ← 建议从这里开始
ADC 温度 & Vref — ADC0_temperature_Vref
ADC 模拟看门狗 — ADC1_analog_watchdog
ADC 过采样 — ADC1_oversample_shift
ADC 分辨率配置 — ADC1_resolution

GD32 ADC — ADC + DMA 采集

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC + DMA 采集

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC0_routine_channel_with_DMA/main.c

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    while(1){
        delay_1ms(1000);
        printf("\r\n //*******************************//");
        printf("\r\n ADC0 routine channel data = %04X", adc_value[0]);
        printf("\r\n ADC0 routine channel data = %04X", adc_value[1]);
        printf("\r\n ADC0 routine channel data = %04X", adc_value[2]);
        printf("\r\n ADC0 routine channel data = %04X\r\n", adc_value[3]);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_0);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr  = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;  
    dma_data_parameter.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number       = 4;
    dma_data_parameter.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC continuous function enable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);
    /* ADC scan function enable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 4);

    /* ADC routine channel config */ 
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);

    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 不连续模式

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 不连续模式

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC0_routine_channel_discontinuous_mode/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    while(1){
        /* delay 1s */
        delay_1ms(1000);
        printf("\r\n ***********************************\r\n");
        printf("\r\n ADC0 routine channel data 0, PA0 = %04X \r\n", adc_value[0]);
        printf("\r\n ADC0 routine channel data 1, PA1 = %04X \r\n", adc_value[1]);
        printf("\r\n ADC0 routine channel data 2, PA2 = %04X \r\n", adc_value[2]);
        printf("\r\n ADC0 routine channel data 3, PA3 = %04X \r\n", adc_value[3]);
        printf("\r\n ADC0 routine channel data 4, PA4 = %04X \r\n", adc_value[4]);
        printf("\r\n ADC0 routine channel data 5, PA5 = %04X \r\n", adc_value[5]);
        printf("\r\n ADC0 routine channel data 6, PA6 = %04X \r\n", adc_value[6]);
        printf("\r\n ADC0 routine channel data 7, PA7 = %04X \r\n", adc_value[7]);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC0 clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
    /* config the GPIO as floating input mode, for EXTI */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_MAX,GPIO_PIN_11);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;  
    dma_data_parameter.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number = 8;
    dma_data_parameter.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC continuous function disable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, DISABLE);
    adc_special_function_config(ADC0, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_EXTTRIG_ROUTINE_EXTI_11); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 8);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 4, ADC_CHANNEL_4, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 5, ADC_CHANNEL_5, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 6, ADC_CHANNEL_6, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 7, ADC_CHANNEL_7, ADC_SAMPLETIME_55POINT5);

    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC discontinuous mode */
    adc_discontinuous_mode_config(ADC0, ADC_ROUTINE_CHANNEL, 3);

    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);
}

void exti_config(void)
{
    /* connect EXTI line to GPIO pin for routine sequence */
    gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_11);
    /* configure EXTI line for routine sequence */
    exti_init(EXTI_11, EXTI_EVENT, EXTI_TRIG_RISING);
    exti_flag_clear(EXTI_11);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 分辨率配置

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 分辨率配置

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC1_resolution/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3

void rcu_config(void);
void gpio_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();  
    /* GPIO configuration */
    gpio_config();
    /* ADC configuration */
    adc_config();
    /* configures COM port */
    gd_eval_com_init(EVAL_COM0); 

    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);

    while(1){
        adc_flag_clear(ADC1, ADC_FLAG_EOC);
        while(SET != adc_flag_get(ADC1, ADC_FLAG_EOC)){
        }
        adc_value = ADC_RDATA(ADC1);        
        printf("6B: 0x%x\r\n", adc_value);
        printf("\r\n ***********************************\r\n");
        delay_1ms(500);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC resolusion 6B */
    adc_resolution_config(ADC1, ADC_RESOLUTION_6B);  

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 过采样

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 过采样

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC1_oversample_shift/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3

void rcu_config(void);
void gpio_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* ADC configuration */
    adc_config();
    /* configures COM port */
    gd_eval_com_init(EVAL_COM0); 

    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);

    while(1){
        adc_flag_clear(ADC1, ADC_FLAG_EOC);
        while(SET != adc_flag_get(ADC1, ADC_FLAG_EOC)){
        }

        adc_value = ADC_RDATA(ADC1);
        printf("16 times sample, 4 bits shift: 0x%x\r\n", adc_value);
        delay_1ms(500);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* 16 times sample, 4 bits shift */
    adc_oversample_mode_config(ADC1, ADC_OVERSAMPLING_ALL_CONVERT, ADC_OVERSAMPLING_SHIFT_4B, ADC_OVERSAMPLING_RATIO_MUL16);
    adc_oversample_mode_enable(ADC1);

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 模拟看门狗

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 模拟看门狗

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC1_analog_watchdog/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3
#define ADC_WATCHDOG_HT     0x0A00
#define ADC_WATCHDOG_LT     0x0400

void rcu_config(void);
void gpio_config(void);
void nvic_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* NVIC configuration */
    nvic_config();
    /* ADC configuration */
    adc_config();

    while(1){
        delay_1ms(1000);
        adc_value = adc_routine_data_read(ADC1);
        printf("\r\n ADC1 watchdog low threshold: %04X \r\n",ADC_WATCHDOG_LT);
        printf("\r\n ADC1 watchdog hgih threshold: %04X \r\n",ADC_WATCHDOG_HT);
        printf("\r\n ADC1 routine channel data = %04X \r\n",adc_value);
        printf("\r\n ***********************************\r\n");
        if(1 == data){
            /* turn off LED2 */
            if((adc_value < ADC_WATCHDOG_HT) && (adc_value > ADC_WATCHDOG_LT)){
                data = 0;
                gd_eval_led_off(LED2);
            }
        }
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* configure led GPIO */
    gd_eval_led_init(LED2);
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    nvic_irq_enable(ADC0_1_IRQn, 0, 0);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);

    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);

    /* ADC analog watchdog threshold config */
    adc_watchdog_threshold_config(ADC1, ADC_WATCHDOG_LT, ADC_WATCHDOG_HT);
    /* ADC analog watchdog single channel config */
    adc_watchdog_single_channel_enable(ADC1, BOARD_ADC_CHANNEL);
    /* ADC interrupt config */
    adc_interrupt_enable(ADC1, ADC_INT_WDE);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 软件触发轮询

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 软件触发轮询

固件库: GD32F30x_Firmware_Library V3.0.3 芯片: GD32F307 (GD32307C-EVAL-V1.1 开发板) 源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC0_software_trigger_routine_channel_polling/main.c

功能简介

这是 ADC 的入门第一课，也是最容易看懂的一种 ADC 用法。

程序用 ADC0 依次采集 4 路模拟电压（PA1、PA2、PA3、PA4），把结果存到 adc_value[4] 数组里，然后不停地重复。

标题里三个关键词，拆开看：

关键词	含义
软件触发	转换不是由定时器或外部信号启动的，而是我们在程序里调用一个函数手动"发令"
常规通道	用的是常规组（Routine），相对于优先级更高的注入组（Inserted）
轮询	发令之后，CPU 在 `while` 里死等标志位，等到了就读数据（不用中断、不用 DMA）

为什么先学这个？ 因为它把 ADC 的完整流程一步不省地摊开在你眼前：

`1`	`配时钟 → 配引脚 → 配 ADC → 校准 → 选通道 → 发令 → 等完成 → 读数`

后面所有更高级的用法（DMA 自动搬运、定时器触发、双 ADC 并行），都只是把上面某几步换成硬件自动完成而已。先把手动流程走通，再去理解自动化才不会一头雾水。

硬件准备

器材	说明
GD32307C-EVAL-V1.1 开发板	或任意 GD32F30x 板子
电位器（可调电阻）1~4 个	10kΩ 卧式电位器，几毛钱一个
杜邦线	接线用
调试器（GD-Link / J-Link）	需要用 Watch 窗口看变量

使用的引脚

ADC 通道	引脚
`ADC_CHANNEL_1`	PA1
`ADC_CHANNEL_2`	PA2
`ADC_CHANNEL_3`	PA3
`ADC_CHANNEL_4`	PA4

通道号和引脚号的对应关系：GD32F30x 上 ADC 通道 0~~7 对应 PA0~~PA7，通道 8~~9 对应 PB0~~PB1，通道 10~~15 对应 PC0~~PC5。所以 ADC_CHANNEL_1 = PA1，规律很好记。

电位器接线

        3.3V
         │
        ┌┴┐
        │ │  ← 电位器（10kΩ）
        │ ├──────→ PA1（中间的滑动端接 ADC 引脚）
        │ │
        └┬┘
         │
        GND

旋转旋钮，中间抽头的电压就在 0V ~ 3.3V 之间连续变化，ADC 读数在 0 ~ 4095 之间跟着变。这是验证 ADC 是否正常工作的最直观办法。

如果暂时没有电位器，也可以：

直接把引脚接 GND → 读数应该接近 0
直接把引脚接 3.3V → 读数应该接近 4095
什么都不接（悬空）→ 读数会乱跳，这是正常现象（悬空引脚电压不确定）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

/* 存放 4 个通道的采样结果
   __IO 是 volatile 的宏，告诉编译器"这个变量可能被意外修改，
   不要做优化"。这样调试器的 Watch 窗口才能看到实时变化 */
__IO uint16_t adc_value[4];

void rcu_config(void);
void gpio_config(void);
void adc_config(void);
uint16_t adc_channel_sample(uint8_t channel);

/*!
    \brief      主函数
    \param[in]  无
    \param[out] 无
    \retval     无
*/
int main(void)
{
    /* 1. 时钟配置：开 GPIOA、ADC0 时钟，并给 ADC 分频 */
    rcu_config();
    /* 2. SysTick 配置，为了后面 delay_1ms 能用 */
    systick_config();
    /* 3. GPIO 配置：把 4 个引脚配成模拟输入 */
    gpio_config();
    /* 4. ADC 配置：模式、对齐、触发源、使能、校准 */
    adc_config();

    while(1){
        /* 依次采集 4 个通道，每采完一个立刻存进数组
           注意：必须一个一个来，因为常规组只有一个数据寄存器 */
        adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);   /* PA1 */
        adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);   /* PA2 */
        adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);   /* PA3 */
        adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);   /* PA4 */
    }
}

/*!
    \brief      配置各个系统时钟
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void rcu_config(void)
{
    /* 开 GPIOA 时钟 —— PA1~PA4 属于 GPIOA */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* 开 ADC0 外设时钟 */
    rcu_periph_clock_enable(RCU_ADC0);
    /* 配置 ADC 时钟分频：APB2(120MHz) / 6 = 20MHz
       ADC 时钟不能太高，手册推荐不超过 14MHz */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);
}

/*!
    \brief      配置 GPIO
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void gpio_config(void)
{
    /* 把 PA1~PA4 全部配成 AIN（Analog IN，模拟输入）模式
       这个模式会断开引脚上的数字输入电路和上下拉电阻，
       让引脚"纯净"地把电压送给 ADC */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_4);
}

/*!
    \brief      配置 ADC 外设
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void adc_config(void)
{
    /* 独立模式：ADC0 自己单独工作，不和 ADC1 联动 */
    adc_mode_config(ADC_MODE_FREE);

    /* 数据右对齐：12 位结果放在 16 位寄存器的低 12 位
       读出来直接就是 0~4095，不用移位 */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* 常规组序列长度设为 1：一次只转换 1 个通道
       因为常规组只有一个数据寄存器，转多个会互相覆盖 */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);

    /* 外部触发源设为 NONE：不使用定时器/引脚触发 */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL,
                                       ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    /* 使能外部触发通路 —— 这句必须有！
       软件触发在硬件上也走"外部触发"这条路，
       只是触发源选成了 NONE（即 SWRCST 软件触发） */
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* 使能 ADC0 */
    adc_enable(ADC0);
    /* 等 ADC 上电稳定（手册要求 tSTAB，至少 1μs，这里给 1ms 足够宽裕） */
    delay_1ms(1U);
    /* 启动校准，消除内部电容工艺偏差
       注意顺序：必须在 adc_enable 之后 */
    adc_calibration_enable(ADC0);
}

/*!
    \brief      采集指定通道的一次数据
    \param[in]  channel: 要采集的 ADC 通道号
    \param[out] 无
    \retval     该通道的 12 位转换结果（0~4095）
*/
uint16_t adc_channel_sample(uint8_t channel)
{
    /* 把要采的通道放到常规组序列的第 0 个位置，采样时间 7.5 个周期 */
    adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5);

    /* 发令：软件触发，启动这一次转换 */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);

    /* 死等 EOC（End Of Conversion）标志置位，表示转换完成 */
    while(!adc_flag_get(ADC0, ADC_FLAG_EOC));

    /* 手动清除 EOC 标志，为下一次转换做准备 */
    adc_flag_clear(ADC0, ADC_FLAG_EOC);

    /* 读取常规组数据寄存器，返回结果 */
    return (adc_routine_data_read(ADC0));
}

代码分段讲解

第 1 段：`__IO` 到底是干什么的

`1`	`__IO uint16_t adc_value[4];`

__IO 在 GD32 头文件里定义为 volatile：

`1`	`#define __IO volatile`

为什么必须加 volatile？

编译器很"聪明"，它会做优化。看到 adc_value 这个数组被赋值之后从来没有被读取过，优化器会认为"这些赋值是没用的死代码"，直接删掉！结果就是你在调试器 Watch 窗口里看到的永远是 0。

加上 volatile 之后，等于告诉编译器：“这个变量的值可能会被程序之外的东西（调试器、中断、硬件）读写，你老老实实每次都真的去内存里存取，不许优化。”

实战规则：以下三种变量必须加 volatile：

会被中断服务函数修改，同时又在主循环里读的全局变量

映射到硬件寄存器的指针

只用于调试观察的变量（本例的情况）

忘加 volatile 导致的 bug 极其难查 —— 因为 Debug 版本（不优化）跑得好好的，一开 -O2 优化就出问题。

第 2 段：GPIO_MODE_AIN 和其他模式的本质区别

`1`	`gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);`

AIN = Analog IN，模拟输入模式。它跟数字输入模式（IN_FLOATING / IPU / IPD）在硬件上完全是两回事：

数字输入模式（IN_FLOATING）:
  引脚 ──┬── [施密特触发器] ── 数字输入寄存器（读 0 或 1）
         └── [上下拉电阻网络]         ← 这些电路会影响模拟电压！
         └── [ESD 保护]

模拟输入模式（AIN）:
  引脚 ──┬── [直连] ─────────── ADC 采样开关 ── 采样电容
         └── 施密特触发器已关断，上下拉已断开

关键点：AIN 模式会关掉施密特触发器和上下拉电阻。这两个东西对数字信号无害，但对模拟测量是灾难：

施密特触发器一直在耗电（漏电流），会拉偏被测电压
上下拉电阻（约 40kΩ）会和你的信号源形成分压，读数直接错

新手常见错误：配成 GPIO_MODE_IN_FLOATING 也能读到数，但读数会有偏差（尤其信号源内阻大时）。所以ADC 引脚必须配 AIN，没有例外。

至于 GPIO_OSPEED_10MHZ 这个参数在 AIN 模式下是无意义的（引脚根本不输出），填什么都行，官方填 10MHz 只是习惯。

第 3 段：为什么"软件触发"要开"外部触发"

这是本例最容易让人困惑的一处：

1
2
3

adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL,
                                   ADC0_1_2_EXTTRIG_ROUTINE_NONE);
adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

明明是软件触发，为什么要配"外部触发源"还要 ENABLE？

原因在硬件设计上：GD32 的 ADC 内部只有一条"触发输入"通道。这条通道可以被连接到：

触发源选项	实际含义
`ADC0_1_2_EXTTRIG_ROUTINE_T0_CH0`	定时器 0 通道 0 事件
`ADC0_1_2_EXTTRIG_ROUTINE_T2_TRGO`	定时器 2 的 TRGO 事件
`ADC0_1_2_EXTTRIG_ROUTINE_EXTI_11`	外部中断线 11
`ADC0_1_2_EXTTRIG_ROUTINE_NONE`	不接任何硬件源，改由软件位 SWRCST 触发

所以逻辑是这样的：

adc_external_trigger_source_config(..., NONE) —— 把多路选择器拨到"软件"档
adc_external_trigger_config(..., ENABLE) —— 打开触发通道的总闸（ETERC 位）

如果第 2 句不写，总闸关着，无论你怎么调 adc_software_trigger_enable() 都不会启动转换。 程序会永远卡死在 while(!adc_flag_get(ADC0, ADC_FLAG_EOC)); 这一行。

这是新手实际会踩的坑。如果你自己精简代码把这句删了，就会遇到"程序卡死、ADC 不动"的现象。

第 4 段：序列长度为什么设成 1

`1`	`adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);`

“序列”（Sequence）是 ADC 常规组的一个重要概念。你可以配置一个最多 16 长的转换序列，比如：

1
2
3

序列位置 0 → 通道 3
序列位置 1 → 通道 7
序列位置 2 → 通道 1

配好之后触发一次，ADC 会按序列顺序把这 3 个通道都转一遍。

但问题来了：常规组只有一个 ADC_RDATA 数据寄存器。转完通道 3 结果放进去，接着转通道 7，结果又覆盖进去…… 最后你只能读到最后一个通道的值，前面全丢了。

所以只有两条路：

方案	做法	优缺点
本例的方案	序列长度设 1，每次只转一个通道，转完立刻读走，然后改通道再转	简单直观，CPU 全程参与
DMA 方案	序列长度设 4，开启扫描模式 + DMA，DMA 在每次 EOC 时自动把结果搬到数组	CPU 零参与，效率高，但配置复杂

本例用第一种，所以序列长度必须是 1，而且 adc_routine_channel_config() 的第二个参数（序列位置）永远填 0。

实际项目里多通道采集几乎都用 DMA 方案（参考 ADC0_routine_channel_with_DMA 示例）。但先理解本例的手动版本，你才知道 DMA 到底帮你省掉了什么。

第 5 段：一次完整采样的四步

uint16_t adc_channel_sample(uint8_t channel)
{
    adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5);  /* ① 选通道 */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);                 /* ② 发令 */
    while(!adc_flag_get(ADC0, ADC_FLAG_EOC));                               /* ③ 等完成 */
    adc_flag_clear(ADC0, ADC_FLAG_EOC);                                     /* ④ 清标志 */
    return (adc_routine_data_read(ADC0));                                   /* ⑤ 读数据 */
}

① 选通道 —— adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5)

四个参数：ADC 编号、序列位置（这里固定 0）、通道号、采样时间。

每次调用都重新设置一次，所以同一个函数可以采任意通道 —— 这就是函数复用的巧妙之处。

② 发令 —— adc_software_trigger_enable()

内部就是往控制寄存器的 SWRCST 位写 1。硬件看到这一位就开始干活：先接通对应引脚的采样开关给电容充电（持续 7.5 个 ADC 周期），然后断开开关做 12 次逐次逼近比较，最后把结果写进 ADC_RDATA。

③ 等完成 —— while(!adc_flag_get(ADC0, ADC_FLAG_EOC))

EOC = End Of Conversion。硬件转换完成会自动把这一位置 1。

在 20MHz ADC 时钟、7.5 采样时间下，这个等待时间是：

`1`	`(7.5 + 12.5) / 20MHz = 1 μs`

也就是说 CPU 大约白等 1 微秒，采 4 个通道总共 4 微秒。对于点灯级应用完全可以接受。

④ 清标志

有个容易忽略的细节：读 ADC_RDATA 寄存器本身也会自动清除 EOC 标志。所以理论上第④步是多余的。但显式写出来更清晰、更保险（万一你改代码把 read 挪走了呢），是好的编程习惯。

⑤ 读数据 —— adc_routine_data_read(ADC0)

返回的就是 0~4095 的原始码值。

第 6 段：主循环里数据是怎么流动的

while(1){
    adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
    adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);
    adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);
    adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);
}

时序图（每格约 1μs）：

时间 →
│ 采PA1 │ 采PA2 │ 采PA3 │ 采PA4 │ 采PA1 │ 采PA2 │ ...
   ↓       ↓       ↓       ↓
 [0]     [1]     [2]     [3]

注意这个循环转得极快：4 次采样加上函数调用开销，一轮大约 5~10 微秒，也就是每秒刷新 10 万次以上。

这对于测量慢变化的物理量（温度、电位器位置）是巨大的浪费，而且会让读数因为噪声而抖动。实际项目应该加延时并做滤波：

while(1){
    adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
    /* ...其他通道... */
    delay_1ms(100);       /* 每 100ms 采一轮就够了 */
}

实验现象

本例程没有任何 LED 或串口输出，必须用调试器观察。

用 Keil 的 Watch 窗口看

编译下载后，点击 Debug → Start/Stop Debug Session（或按 Ctrl+F5）。
点击 Run（F5）让程序跑起来。
打开 View → Watch Windows → Watch 1。
在 Watch 窗口里输入 adc_value，回车。
展开数组，就能看到 4 个通道的实时值。
转动接在 PA1 上的电位器，adc_value[0] 的数值会跟着变化。

预期看到的数值：

电位器位置	`adc_value[0]`	对应电压
旋到底（接 GND）	0 ~ 20	约 0V
中间	约 2048	约 1.65V
旋到顶（接 3.3V）	4070 ~ 4095	约 3.3V

Keil 小技巧：勾选 View → Periodic Window Update，Watch 窗口才会在程序运行时持续刷新。不勾的话只有暂停时才更新数值，看起来像"数据不变"。

更直观的办法：加串口打印

强烈建议自己改一版加上 printf，看起来爽多了：

#include "gd32f307c_eval.h"

int main(void)
{
    rcu_config();
    systick_config();
    gpio_config();
    adc_config();
    gd_eval_com_init(EVAL_COM0);         /* 初始化调试串口 */

    while(1){
        adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
        adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);
        adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);
        adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);

        /* 同时打印原始码值和换算后的电压（mV，避免用浮点） */
        printf("CH1=%4d(%4dmV)  CH2=%4d  CH3=%4d  CH4=%4d\r\n",
               adc_value[0], adc_value[0] * 3300 / 4095,
               adc_value[1], adc_value[2], adc_value[3]);

        delay_1ms(500);
    }
}

串口助手输出：

1
2
3

CH1=2047(1649mV)  CH2=   3  CH3=1024  CH4=4090
CH1=2531(2039mV)  CH2=   4  CH3=1023  CH4=4091
CH1=3102(2499mV)  CH2=   3  CH3=1025  CH4=4090

注意 adc_value[0] * 3300 / 4095 这个写法：先乘后除，全程整数运算，避免了浮点数的开销。这是嵌入式里换算电压的标准技巧。

小心溢出：adc_value 是 uint16_t，最大 4095，乘 3300 得到 13513500，超出了 uint16_t 范围。但因为 C 语言的整数提升规则，表达式会自动按 int（32 位）计算，所以这里是安全的。如果乘的系数更大（比如 33000），就要显式转成 uint32_t。

常见问题

Q1：程序卡死在 `while(!adc_flag_get(ADC0, ADC_FLAG_EOC));`

这是本例最高频的问题。EOC 永远不置位，说明转换根本没启动。按顺序检查：

少了 adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE); 前面详细讲过，这是触发通道的总闸。少了它软件触发无效。这是最常见的原因。
忘了 rcu_periph_clock_enable(RCU_ADC0); 外设时钟没开，所有 ADC 寄存器写进去都是无效的。
忘了 adc_enable(ADC0); ADC 没使能，硬件处于关断状态。
忘了 rcu_adc_clock_config() ADC 时钟源没配。虽然有默认值，但显式配置是好习惯。
改用了注入组的宏但 flag 还查常规组的 如果你把 ADC_ROUTINE_CHANNEL 改成了 ADC_INSERTED_CHANNEL，那 flag 也要改成 ADC_FLAG_EOIC。

Q2：读数一直是 0 或一直是 4095

读数恒为 0：

引脚没接信号，或者接到了 GND
引脚模式配错（没配成 GPIO_MODE_AIN）
通道号和引脚对不上（比如想采 PA1 但填了 ADC_CHANNEL_0）
GPIOA 时钟没开

读数恒为 4095：

输入电压超过了 VREF+（通常等于 VDDA = 3.3V）。注意 ADC 引脚绝对不能超过 VDD + 0.3V，否则会烧片！
引脚接错，接到了 3.3V

Q3：读数不停跳动，跳几十个数

这是 ADC 最典型的"精度"问题，几乎人人会遇到。按性价比从高到低排：

① 加大采样时间（改一行，立竿见影）

`1`	`adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_239POINT5);`

信号源内阻大时（热敏电阻、高阻分压），采样电容充不满，读数就会偏低且不稳。加大采样时间是第一选择。

② 降低 ADC 时钟

`1`	`rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV12); /* 120/12 = 10MHz，符合 ≤14MHz 要求 */`

原代码用 DIV6 得到 20MHz，已经超出手册推荐值。降到 10MHz 精度会明显改善。

③ 软件滤波（最有效的手段）

最简单的多次平均：

uint16_t adc_average_sample(uint8_t channel, uint8_t times)
{
    uint32_t sum = 0;
    uint8_t i;
    for(i = 0; i < times; i++){
        sum += adc_channel_sample(channel);
    }
    return (uint16_t)(sum / times);
}

/* 使用：采 16 次取平均 */
adc_value[0] = adc_average_sample(ADC_CHANNEL_1, 16);

更抗突发干扰的去极值平均（掐头去尾法）：

uint16_t adc_filter_sample(uint8_t channel)
{
    uint16_t buf[10];
    uint16_t max = 0, min = 0xFFFF;
    uint32_t sum = 0;
    uint8_t i;

    /* 连续采 10 次 */
    for(i = 0; i < 10; i++){
        buf[i] = adc_channel_sample(channel);
        sum += buf[i];
        if(buf[i] > max) max = buf[i];      /* 记录最大值 */
        if(buf[i] < min) min = buf[i];      /* 记录最小值 */
    }
    /* 去掉一个最高分、去掉一个最低分，剩下 8 个取平均 */
    return (uint16_t)((sum - max - min) / 8);
}

这个算法能有效滤掉偶发的尖峰干扰，是工程上非常实用的一招。

④ 硬件滤波

在 ADC 引脚和 GND 之间并一个 100nF 陶瓷电容。这是最便宜也最有效的措施，几乎所有正规产品的 ADC 输入都会加这个电容。

⑤ 检查 VREF 和布线

VREF+ 引脚要接干净的 3.3V，加 100nF + 1μF 去耦电容
模拟地（VSSA）和数字地要在一点汇合（单点接地）
ADC 信号线远离时钟线、PWM 输出线、开关电源

Q4：想读芯片内部温度怎么办

内部温度传感器接在 ADC_CHANNEL_16 上，需要额外使能：

/* 使能内部温度传感器和 VREFINT 通道 */
adc_tempsensor_vrefint_enable();

/* 采集温度通道，采样时间必须给足（手册要求 ≥17.1μs） */
uint16_t temp_raw = adc_channel_sample_with_time(ADC_CHANNEL_16,
                                                 ADC_SAMPLETIME_239POINT5);

/* 换算成摄氏度
   GD32F30x 手册给的公式：
   T(°C) = (V25 - Vsense) / Avg_Slope + 25
   其中 V25 = 1.43V（25°C 时的电压），Avg_Slope = 4.3mV/°C */
float v_sense = temp_raw * 3.3f / 4095.0f;
float temperature = (1.43f - v_sense) / 0.0043f + 25.0f;
printf("chip temp = %d.%d C\r\n", (int)temperature,
       (int)(temperature * 10) % 10);

别指望它测环境温度。这个传感器测的是芯片内部结温，会比环境温度高 5~15°C（取决于芯片负载），而且不同芯片个体差异能到 ±10°C。它的正确用途是监测芯片是否过热，或者做温度变化的相对判断，不能当温度计用。

Q5：4 个通道能不能一次全采完，不要一个个来？

可以，这就是扫描模式 + DMA 的方案。核心改动：

void adc_config_dma_version(void)
{
    dma_parameter_struct dma_init_struct;

    rcu_periph_clock_enable(RCU_DMA0);

    /* --- ADC 部分：序列长度改成 4，开扫描模式和连续模式 --- */
    adc_mode_config(ADC_MODE_FREE);
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 4U);      /* 4 个通道 */

    /* 把 4 个通道依次排进序列的 0/1/2/3 位置 */
    adc_routine_channel_config(ADC0, 0U, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1U, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2U, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3U, ADC_CHANNEL_4, ADC_SAMPLETIME_55POINT5);

    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);        /* 扫描模式 */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);  /* 连续转换 */

    /* --- DMA 部分：外设(ADC_RDATA) → 内存(adc_value 数组) --- */
    dma_deinit(DMA0, DMA_CH0);
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;   /* 外设地址不变 */
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.memory_addr  = (uint32_t)adc_value;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;    /* 内存地址自增 */
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_init_struct.number       = 4U;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_init_struct);

    dma_circulation_enable(DMA0, DMA_CH0);      /* 循环模式：搬完 4 个自动回到开头 */
    dma_channel_enable(DMA0, DMA_CH0);

    adc_dma_mode_enable(ADC0);                  /* ADC 每次 EOC 自动请求 DMA */

    adc_enable(ADC0);
    delay_1ms(1U);
    adc_calibration_enable(ADC0);
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);   /* 只需触发一次！ */
}

/* 主循环变成这样 —— 什么都不用做，随时读数组就有最新值 */
int main(void)
{
    /* ... 初始化 ... */
    adc_config_dma_version();
    while(1){
        printf("%d %d %d %d\r\n", adc_value[0], adc_value[1],
                                  adc_value[2], adc_value[3]);
        delay_1ms(500);
    }
}

这就是实际项目的标准写法：配置一次，之后 ADC + DMA 在后台自动持续采集刷新数组，CPU 完全解放。详细讲解见本模块的 ADC0_routine_channel_with_DMA 示例。

Q6：怎么提高精度到 12 位以上？

用过采样。原理是采样 N 次求和后右移，利用噪声的随机性提高有效位数：

采 4 次求和右移 1 位 → 等效 13 位
采 16 次求和右移 2 位 → 等效 14 位
采 64 次求和右移 3 位 → 等效 15 位
采 256 次求和右移 4 位 → 等效 16 位

GD32F30x 部分型号有硬件过采样器，配置一次就自动完成，见 ADC1_oversample_shift 示例。没有硬件支持的型号可以软件实现：

/* 软件 16 倍过采样，等效 14 位精度 */
uint16_t adc_oversample_14bit(uint8_t channel)
{
    uint32_t sum = 0;
    uint8_t i;
    for(i = 0; i < 16; i++){
        sum += adc_channel_sample(channel);
    }
    return (uint16_t)(sum >> 2);      /* 求和后右移 2 位，得到 0~16383 */
}

过采样有效的前提是噪声是随机白噪声。如果是 50Hz 工频串扰这种周期性干扰，过采样帮助有限，得靠屏蔽和硬件滤波。

小结

知识点	要记住的核心
ADC 引脚模式	必须 `GPIO_MODE_AIN`，不是 `IN_FLOATING`
ADC 时钟	必须用 `rcu_adc_clock_config()` 分频，推荐 ≤14MHz
三套时钟	GPIO 时钟 + ADC 外设时钟 + ADC 时钟分频，都要配
软件触发也要开 ETERC	`adc_external_trigger_config(..., ENABLE)` 少不了
使能后必须延时再校准	`adc_enable()` → `delay` → `adc_calibration_enable()`，顺序不能错
常规组只有一个数据寄存器	多通道要么一个个手动读，要么用 DMA
`volatile`	只用于调试观察的变量必须加，否则会被优化掉
电压换算	`mV = code * 3300 / 4095`，先乘后除全整数运算
读数跳动	加大采样时间 → 降低 ADC 时钟 → 软件滤波 → 加 100nF 电容

ADC 采样七步曲：

1. rcu_periph_clock_enable(RCU_GPIOA);          /* GPIO 时钟 */
2. rcu_periph_clock_enable(RCU_ADC0);           /* ADC 时钟 */
3. rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6); /* ADC 分频 */
4. gpio_init(..., GPIO_MODE_AIN, ...);          /* 引脚模拟输入 */
5. adc_mode_config / data_alignment / channel_length / trigger  /* 参数 */
6. adc_enable() → delay_1ms(1) → adc_calibration_enable()       /* 使能校准 */
7. channel_config → software_trigger → wait EOC → data_read     /* 采样 */

拓展应用

学会 ADC，你就能读取现实世界的连续量了。可做的项目一下子多起来：

入门级（一个电位器就能玩）

数字电压表：把 ADC 读数换算成电压，通过串口或 OLED 显示。加个电阻分压网络（比如 10:1）就能测 0~33V，做一个万用表的电压档。
旋钮调光灯：电位器读数映射到 PWM 占空比，转旋钮就能无级调节 LED 亮度。这是 ADC + TIMER 的第一个综合应用。
光照检测夜灯：光敏电阻（LDR）和固定电阻串联分压，ADC 读电压判断明暗，天黑自动开灯。
电池电量指示：分压后测锂电池电压，映射成 4 格电量图标。注意锂电池 4.2V 超过 3.3V，必须先分压。
摇杆/游戏手柄读取：双轴摇杆本质就是两个电位器，读 X/Y 两路 ADC 就能得到方向和力度。

进阶级（配合传感器和算法）

NTC 热敏电阻测温：这是最常见的低成本测温方案。ADC 读分压电压 → 算出电阻值 → 查 B 值公式或分段查表得到温度。精度可到 ±0.5°C，比内部温度传感器强得多。

  /* NTC 分压电路：3.3V — R固定(10k) — NTC — GND，ADC 接 NTC 上端 */
  float r_ntc = 10000.0f * adc_val / (4095.0f - adc_val);
  /* B 值公式：1/T = 1/T0 + (1/B) * ln(R/R0) */
  /* T0=298.15K(25°C), R0=10000Ω, B=3950 */

土壤湿度 / 水位检测：电容式或电阻式传感器输出模拟量，ADC 直接读，做自动浇花系统。
压力/称重（配合 HX711 或运放）：应变片桥式输出几毫伏，经运放放大后 ADC 采集，做电子秤。这时 12 位精度可能不够，要用过采样或外置 24 位 ADC。
多路电压巡检仪：16 路 ADC + DMA 自动扫描，做配电柜多回路电压监测。
红外测距（Sharp GP2Y0A21）：这类传感器输出的电压和距离成反比曲线，查表插值后能得到 10~80cm 的距离值，做避障小车。
气体传感器（MQ 系列）：MQ-2 烟雾、MQ-7 一氧化碳等都是模拟输出，ADC 读浓度做报警器。

信号处理级

示波器：ADC + DMA + 定时器触发实现固定采样率采集，数据传到电脑上位机画波形。GD32F307 的 2.6MSPS 采样率能做到 1MHz 带宽，足够看 I2C/UART 波形。
音频采集与 FFT 频谱：麦克风模块输出经运放偏置到 1.65V 中心，ADC 以 8kHz 采样，做 256 点 FFT 得到频谱，实现声控开关、音乐律动灯、简易调音器。
交流电流检测（互感器）：电流互感器输出正弦波，快速采样一个周期后算 RMS 有效值，做智能插座功率计量。

  /* 采一个周期(50Hz=20ms)的数据算 RMS */
  uint32_t sum_sq = 0;
  for(i = 0; i < 200; i++){                      /* 200 点，每点 100μs */
      int16_t ac = adc_channel_sample(ch) - 2048;  /* 减去 1.65V 直流偏置 */
      sum_sq += ac * ac;
      delay_us(100);
  }
  /* rms = sqrt(sum_sq / 200) */

PID 闭环控制：ADC 读反馈量（温度、转速、位置）→ PID 计算 → PWM 输出执行。这是自动控制的核心闭环，做恒温箱、电机调速、平衡车都靠这个。

工业与安全级

过压/过流保护（模拟看门狗）：不用 CPU 参与，ADC 硬件自动比较上下限，超限立刻触发中断关断输出。响应时间可以做到微秒级，比软件判断快几个数量级。见 ADC1_analog_watchdog 示例。
电机 FOC 控制：双 ADC 并行模式在 PWM 中心点同时采样三相电流，配合 Clarke/Park 变换实现磁场定向控制。这是无刷电机高性能驱动的标准方案。
4-20mA 工业信号采集：工业传感器普遍用 4-20mA 电流环（抗干扰强、可远传）。经过一个精密电阻（如 165Ω）转成 0.66~3.3V 电压后 ADC 采集。

下一步该学什么：ADC0_routine_channel_with_DMA（多通道自动采集，实际项目标准做法）→ ADC0_temperature_Vref（读内部温度和参考电压）→ TIMER1_pwmout（学会 PWM 输出，就能做 ADC 读旋钮 → PWM 调光的完整闭环了）。

GD32 ADC — ADC 温度 & Vref

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 温度 & Vref

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC0_temperature_Vref/main.c

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void rcu_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure systick */
    systick_config();
    /* system clocks configuration */
    rcu_config();
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();
    /* USART configuration */
    gd_eval_com_init(EVAL_COM0);

    while(1){
        /* delay a time in milliseconds */
        delay_1ms(2000);

        /* value convert */
        temperature = (1.43 - adc_value[0]*3.3/4096) * 1000 / 4.3 + 25;
        vref_value = (adc_value[1] * 3.3 / 4096);

        /* value print */
        printf(" the temperature data is %2.0f degrees Celsius\r\n", temperature);
        printf(" the reference voltage data is %5.3fV \r\n", vref_value);
        printf(" \r\n");
    }
}

void rcu_config(void)
{
    /* enable ADC clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr  = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_data_parameter.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number       = 2;
    dma_data_parameter.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE);
    /* ADC contineous function disable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);
    /* ADC scan mode disable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 2);
    /* ADC temperature sensor channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_16, ADC_SAMPLETIME_239POINT5);
    /* ADC internal reference voltage channel config */
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_17, ADC_SAMPLETIME_239POINT5);

    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC temperature and Vrefint enable */
    adc_tempsensor_vrefint_enable();

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — 双 ADC 并行采集

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 双 ADC 并行采集

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ADC/ADC0_ADC1_routine_parallel/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include "gd32f307c_eval.h"
#include <stdio.h>

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void timer_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();  
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* TIMER configuration */
    timer_config();
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    /* enable TIMER1 */
    timer_enable(TIMER1);

    while(1){
        delay_1ms(1000);
        printf("\n ADC0: PA0, adc_value[0] = %08X \n",adc_value[0]);
        printf("\n ADC1: PA1, adc_value[1] = %08X \n",adc_value[1]);
        printf("\n ******************* \n");
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC0 clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);  
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);  
    /* enable timer1 clock */
    rcu_periph_clock_enable(RCU_TIMER1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_0|GPIO_PIN_1);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA data mode */
    dma_data_parameter.periph_addr = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_32BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_32BIT;
    dma_data_parameter.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number = 2;
    dma_data_parameter.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void timer_config(void)
{
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 8399;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 9999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

    timer_channel_output_struct_para_init(&timer_ocintpara);
    /* CH0 configuration in PWM mode1 */
    timer_ocintpara.ocpolarity  = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.outputstate = TIMER_CCX_ENABLE;
    timer_channel_output_config(TIMER1, TIMER_CH_1, &timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_1, 3999);
    timer_channel_output_mode_config(TIMER1, TIMER_CH_1, TIMER_OC_MODE_PWM1);
    timer_channel_output_shadow_config(TIMER1, TIMER_CH_1, TIMER_OC_SHADOW_DISABLE);
}

void adc_config(void)
{
    /* ADC continous function enable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, DISABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_EXTTRIG_ROUTINE_T1_CH1);
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_DAUL_ROUTINE_PARALLEL); 
    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 2);
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 2);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC1, 0, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC1, 1, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);

    /* ADC external trigger enable */
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 模数转换器 (ADC)

固件库: PY32F002B_Firmware V1.2.1
示例数: 8

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

ADC_AnalogWatchdog — ADC_AnalogWatchdog
ADC_MultichannelSwitch — ADC_MultichannelSwitch
ADC 软件触发单次转换 (轮询) — ADC_SingleConversion_TriggerSW_Polling
ADC_SingleConversion_TriggerTimer_IT — ADC_SingleConversion_TriggerTimer_IT
ADC_StopForLowPower — ADC_StopForLowPower
ADC_TempSensor — ADC_TempSensor
ADC_Vrefbuf — ADC_Vrefbuf
ADC_Vrefint — ADC_Vrefint

PUYA — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 模数转换器 (ADC)

固件库: PY32F0xx_Firmware V1.5.0
示例数: 8

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

ADC_AnalogWatchdog — ADC_AnalogWatchdog
ADC_ContinuousConversion_DMA — ADC_ContinuousConversion_DMA
ADC_MultiChannelSingleConversion_TriggerSW — ADC_MultiChannelSingleConversion_TriggerSW
ADC_MultiChannelSwitch — ADC_MultiChannelSwitch
ADC_SingleConversion_TriggerTimer_DMA — ADC_SingleConversion_TriggerTimer_DMA
ADC_SingleConversion_TriggerTimer_IT — ADC_SingleConversion_TriggerTimer_IT
ADC_TempSensor — ADC_TempSensor
ADC_Vrefint — ADC_Vrefint

重点推荐：ADC 软件触发单次转换（多通道）已整理为完整教学文档，讲解校准、软件触发、轮询与 printf 打印。

PUYA — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 模数转换器 (ADC)

固件库: PY32F403_Firmware V1.4.5
示例数: 6

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

ADC_AnalogWatchdog — ADC_AnalogWatchdog
ADC_DualModeRegsimult — ADC_DualModeRegsimult
ADC_MultiChannelsSingleConversion_TriggerSW_DMA — ADC_MultiChannelsSingleConversion_TriggerSW_DMA
ADC_SingleConversion_TriggerTimer_IT — ADC_SingleConversion_TriggerTimer_IT
ADC_TempSensor — ADC_TempSensor
ADC_Vrefint — ADC_Vrefint

PUYA — 模数转换器 (ADC)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 模数转换器 (ADC)

固件库: PY32L020_Firmware V1.2.1
示例数: 8

什么是模数转换器 (ADC)?

ADC（模数转换器）将模拟电压信号转换为数字值。传感器输出的模拟信号（温度、光照、电压等）都需要 ADC 来采集。

示例列表

ADC_AnalogWatchdog — ADC_AnalogWatchdog
ADC_MultichannelSwitch — ADC_MultichannelSwitch
ADC 软件触发单次转换 (轮询) — ADC_SingleConversion_TriggerSW_Polling
ADC_SingleConversion_TriggerTimer_IT — ADC_SingleConversion_TriggerTimer_IT
ADC_StopForLowPower — ADC_StopForLowPower
ADC_TempSensor — ADC_TempSensor
ADC_Vrefbuf — ADC_Vrefbuf
ADC_Vrefint — ADC_Vrefint

PUYA ADC — ADC 软件触发单次转换 (轮询)

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 软件触发单次转换 (轮询)

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_SingleConversion_TriggerSW_Polling/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC 软件触发单次转换 (轮询)

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC 软件触发单次转换 (轮询)

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_SingleConversion_TriggerSW_Polling/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_AnalogWatchdog

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_AnalogWatchdog

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_AnalogWatchdog/Src/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_AnalogWatchdog

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_AnalogWatchdog

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_AnalogWatchdog/Src/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_AnalogWatchdog

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_AnalogWatchdog

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_AnalogWatchdog/Src/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_AnalogWatchdog

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_AnalogWatchdog

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_AnalogWatchdog/Src/main.c

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_ContinuousConversion_DMA

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_ContinuousConversion_DMA

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_ContinuousConversion_DMA/Src/main.c

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_DualModeRegsimult

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_DualModeRegsimult

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_DualModeRegsimult/Src/main.c

功能简介

本示例演示多 ADC 协同工作。多个 ADC 同时采样不同通道，适用于需要同步采集多路信号的场景（如三相电压/电流）。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_MultiChannelsSingleConversion_TriggerSW_DMA

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_MultiChannelsSingleConversion_TriggerSW_DMA

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_MultiChannelsSingleConversion_TriggerSW_DMA/Src/main.c

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_MultichannelSwitch

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_MultichannelSwitch

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_MultichannelSwitch/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_MultichannelSwitch

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_MultichannelSwitch

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_MultichannelSwitch/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_MultiChannelSwitch

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_MultiChannelSwitch

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_MultiChannelSwitch/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_SingleConversion_TriggerTimer_DMA

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerTimer_DMA

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_SingleConversion_TriggerTimer_DMA/Src/main.c

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_SingleConversion_TriggerTimer_IT

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerTimer_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_SingleConversion_TriggerTimer_IT/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_SingleConversion_TriggerTimer_IT

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerTimer_IT

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_SingleConversion_TriggerTimer_IT/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_SingleConversion_TriggerTimer_IT

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerTimer_IT

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_SingleConversion_TriggerTimer_IT/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_SingleConversion_TriggerTimer_IT

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_SingleConversion_TriggerTimer_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_SingleConversion_TriggerTimer_IT/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_StopForLowPower

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_StopForLowPower

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_StopForLowPower/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_StopForLowPower

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_StopForLowPower

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_StopForLowPower/Src/main.c

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_TempSensor

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_TempSensor

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_TempSensor/Src/main.c

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define HAL_ADC_TSCAL1   (*(uint32_t *)(0x1fff0114))                   /*!< Temperature Scale1 */
#define HAL_ADC_TSCAL2   (*(uint32_t *)(0x1fff0118))                   /*!< Temperature Scale2 */
#define Vcc_Power        3.30                                          /* VCC power supply voltage, modify according to actual situation  */
#define TScal1           (float)((HAL_ADC_TSCAL1) * 3.3 / Vcc_Power)   /* Voltage corresponding to calibration value at 30℃ */
#define TScal2           (float)((HAL_ADC_TSCAL2) * 3.3 / Vcc_Power)   /* Voltage corresponding to calibration value at 85℃ or 105℃ */
#define TStem1           30                                            /* 30℃ */
#define HighTemp_85
#define TStem2_85        85
#define TStem2_105       105
#define Temp_k_85        ((float)(TStem2_85-TStem1)/(float)(TScal2-TScal1))
#define Temp_k_105       ((float)(TStem2_105-TStem1)/(float)(TScal2-TScal1))

代码讲解

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_TempSensor

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_TempSensor

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_TempSensor/Src/main.c

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define HAL_ADC_TSCAL1                  (*(uint32_t *)(0x1fff5310))  /*!< Temperature Scale1 */
#define HAL_ADC_TSCAL2                  (*(uint32_t *)(0x1fff5400))  /*!< Temperature Scale2 */
#define Vcc_Power     3.3l                                            /* VCC power supply voltage, modify according to actual situation  */
#define TScal1        (float)((HAL_ADC_TSCAL1) * 3.3 / Vcc_Power)     /* Voltage corresponding to calibration value at 30 ℃ */
#define TScal2        (float)((HAL_ADC_TSCAL2) * 3.3 / Vcc_Power)     /* Voltage corresponding to calibration value at 85 or 105℃ */
#define TStem1        30l  
#define HighTemp_105
#define TStem2_85        85   
#define TStem2_105       105  
#define Temp_k_85        ((float)(TStem2_85-TStem1)/(float)(TScal2-TScal1))
#define Temp_k_105       ((float)(TStem2_105-TStem1)/(float)(TScal2-TScal1))

代码讲解

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_TempSensor

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_TempSensor

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_TempSensor/Src/main.c

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "main.h"
#define HAL_ADC_TSCAL1   (*(uint32_t *)(0x1fff0114))                   /*!< Temperature Scale1 */
#define HAL_ADC_TSCAL2   (*(uint32_t *)(0x1fff0118))                   /*!< Temperature Scale2 */
#define Vcc_Power        3.30                                          /* VCC power supply voltage, modify according to actual situation  */
#define TScal1           (float)((HAL_ADC_TSCAL1) * 3.3 / Vcc_Power)   /* Voltage corresponding to calibration value at 30℃ */
#define TScal2           (float)((HAL_ADC_TSCAL2) * 3.3 / Vcc_Power)   /* Voltage corresponding to calibration value at 85℃ or 105℃ */
#define TStem1           30                                            /* 30℃ */
#define HighTemp_85
#define TStem2_85        85
#define TStem2_105       105
#define Temp_k_85        ((float)(TStem2_85-TStem1)/(float)(TScal2-TScal1))
#define Temp_k_105       ((float)(TStem2_105-TStem1)/(float)(TScal2-TScal1))

代码讲解

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_TempSensor（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_TempSensor（HAL 库）

固件�?: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文�?: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_TempSensor/Src/main.c

功能简�?

本示例利�? MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法�?

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件�?

完整代码

#include "main.h"
#define HAL_ADC_TSCAL1                  (*(uint32_t *)(0x1fff0f14))  /*!< Temperature Scale1 */
#define HAL_ADC_TSCAL2                  (*(uint32_t *)(0x1fff0f18))  /*!< Temperature Scale2 */
#define Vcc_Power     3.3l                                            /* VCC power supply voltage, modify according to actual situation  */
#define TScal1        (float)((HAL_ADC_TSCAL1) * 3.3 / Vcc_Power)     /* Voltage corresponding to calibration value */
#define TScal2        (float)((HAL_ADC_TSCAL2) * 3.3 / Vcc_Power)     /* Voltage corresponding to calibration value  */
#define TStem1        30l                                             /* 30 ��? */
#define HighTemp_105
#define TStem2_85        85   
#define TStem2_105       105  
#define Temp_k_85        ((float)(TStem2_85-TStem1)/(float)(TScal2-TScal1))
#define Temp_k_105       ((float)(TStem2_105-TStem1)/(float)(TScal2-TScal1))

代码讲解

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高�?

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操�? ADC�?

实验现象

串口助手打印 ADC 采样�?
转动电位器时数值变�?
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精�?
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration�?

PUYA ADC — ADC_Vrefbuf

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefbuf

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_Vrefbuf/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_Vrefbuf

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefbuf

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_Vrefbuf/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_Vrefint

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefint

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/ADC/ADC_Vrefint/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_Vrefint

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefint

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_Vrefint/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_Vrefint

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefint

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/ADC/ADC_Vrefint/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — ADC_Vrefint

Tue, 08 Sep 2026 14:52:21 +0800

ADC — ADC_Vrefint

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/ADC/ADC_Vrefint/Src/main.c

功能简介

本示例通过 ADC 读取内部参考电压（Vrefint），反算出实际供电电压 VDDA。这在电池供电系统中非常实用——不用外部电压表就能监测电池电量。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

`1`	`#include "main.h"`

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

PUYA ADC — 单通道转换（内部温度传感器）（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 单通道转换（内部温度传感器）（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/ADC/ADC_TempSensor_Init/Src/main.c

功能简介

本示例演示如何用 ADC 读取芯片内部温度传感器的电压，并换算成摄氏度，通过串口打印出来。它是 LL 库里“单通道单次转换”最典型的代表——流程是：校准 ADC → 配置通道与触发源 → 软件触发 → 轮询结束标志 → 读结果 → 换算。

说明：PUYA 的 LL 示例库中没有 ADC_SingleConversion_TriggerSW_Polling 这个同名示例，但 ADC_TempSensor_Init 本质上就是“软件触发 + 单次转换 + 轮询读取”的范式，完全覆盖了你要学的 HAL ADC_SingleConversion_TriggerSW_Polling 的核心套路。把通道从“内部温度传感器”换成某个 GPIO 引脚（如 LL_ADC_CHANNEL_0），就是通用单端采样。

与 HAL 版（HAL_ADC_Start / HAL_ADC_PollForConversion / HAL_ADC_GetValue）相比，LL 把每一步都拆成独立函数，且校准过程需要你手动执行（HAL 在 HAL_ADC_Init 里已悄悄帮你校准过）。

硬件准备

PY32F030 开发板
串口线（用于打印温度，接 USART，由 BSP_USART_Config() 初始化）
无需外部传感器——温度传感器在芯片内部
注意：温度传感器的采样值受芯片自身发热影响，读数仅供参考

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define HighTemp_85        /* 按数据手册选择 85℃ 或 105℃ 标定 */
/* #define HighTemp_105 */

#define ADC_CALIBRATION_TIMEOUT_MS       ((uint32_t) 1)
#define VAR_CONVERTED_DATA_INIT_VALUE    (__LL_ADC_DIGITAL_SCALE(LL_ADC_RESOLUTION_12B) + 1)

__IO uint16_t uhADCxConvertedData = VAR_CONVERTED_DATA_INIT_VALUE;
__IO uint16_t uhADCxConvertedData_Temp = 0;

static void APP_SystemClockConfig(void);
static void APP_AdcConfig(void);
static void APP_AdcEnable(void);
static void APP_AdcCalibrate(void);
static void APP_QuickSort(int32_t arr[], int32_t length);

int main(void)
{
  APP_SystemClockConfig();

  BSP_USART_Config();              /* 初始化调试串口，用于 printf */

  LL_ADC_Reset(ADC1);             /* 复位 ADC */
  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_ADC1);  /* 开 ADC1 时钟 */

  APP_AdcCalibrate();             /* 校准（LL 必须手动做） */
  APP_AdcConfig();                /* 配置通道、触发源等 */
  APP_AdcEnable();                /* 使能 ADC */

  LL_ADC_REG_StartConversion(ADC1);   /* 软件触发一次转换 */
  while (1)
  {
    if (LL_ADC_IsActiveFlag_EOS(ADC1))    /* 等待“序列转换结束” */
    {
      LL_ADC_ClearFlag_EOS(ADC1);
      uhADCxConvertedData = LL_ADC_REG_ReadConversionData12(ADC1);  /* 读 12 位结果 */

      /* 按所选标定曲线换算温度 */
#if defined(HighTemp_85)
      uhADCxConvertedData_Temp = __LL_ADC_CALC_TEMPERATURE_85(3300, uhADCxConvertedData, LL_ADC_RESOLUTION_12B);
#else
      uhADCxConvertedData_Temp = __LL_ADC_CALC_TEMPERATURE_105(3300, uhADCxConvertedData, LL_ADC_RESOLUTION_12B);
#endif
      printf("Temperature: %d\r\n", uhADCxConvertedData_Temp);
      LL_mDelay(200);
      LL_ADC_REG_StartConversion(ADC1);  /* 再次软件触发 */
    }
  }
}

/**
  * @brief  ADC 配置：通道 + 触发源（软件触发）
  */
static void APP_AdcConfig(void)
{
  __IO uint32_t wait_loop_index = 0;

  LL_ADC_InitTypeDef     ADC_Init            = {0};
  LL_ADC_REG_InitTypeDef LL_ADC_REG_InitType = {0};

  /* ADC 基础参数 */
  ADC_Init.Clock         = LL_ADC_CLOCK_SYNC_PCLK_DIV4;   /* ADC 时钟 = PCLK/4 */
  ADC_Init.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;       /* 右对齐 */
  ADC_Init.LowPowerMode  = LL_ADC_LP_MODE_NONE;
  ADC_Init.Resolution    = LL_ADC_RESOLUTION_12B;         /* 12 位分辨率 */
  LL_ADC_Init(ADC1, &ADC_Init);

  /* 采样时间 */
  LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_239CYCLES_5);

  /* 规则转换（Regular）参数 */
  LL_ADC_REG_InitType.ContinuousMode    = LL_ADC_REG_CONV_CONTINUOUS;     /* 连续模式 */
  LL_ADC_REG_InitType.DMATransfer       = LL_ADC_REG_DMA_TRANSFER_NONE;
  LL_ADC_REG_InitType.Overrun           = LL_ADC_REG_OVR_DATA_OVERWRITTEN;
  LL_ADC_REG_InitType.SequencerDiscont  = LL_ADC_REG_SEQ_DISCONT_DISABLE;
  LL_ADC_REG_InitType.TriggerSource     = LL_ADC_REG_TRIG_SOFTWARE;       /* 软件触发 */
  LL_ADC_REG_Init(ADC1, &LL_ADC_REG_InitType);

  LL_ADC_REG_SetSequencerScanDirection(ADC1, LL_ADC_REG_SEQ_SCAN_DIR_BACKWARD);

  /* 打开内部温度传感器通道 */
  LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_PATH_INTERNAL_TEMPSENSOR);
  /* 等待温度传感器稳定 */
  wait_loop_index = ((LL_ADC_DELAY_TEMPSENSOR_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
  while (wait_loop_index != 0) { wait_loop_index--; }

  LL_ADC_REG_SetSequencerChannels(ADC1, LL_ADC_CHANNEL_TEMPSENSOR);  /* 选通道 11=温度传感器 */
}

/**
  * @brief  ADC 校准（LL 需手动执行，HAL 在 Init 时已做）
  */
static void APP_AdcCalibrate(void)
{
  /* 多次采样取中位数写入校准寄存器（厂商提供的校准流程） */
  uint32_t ADC_CALRR1_Buff[5];
  int32_t  ADC_CALRR1_BuffInt[5];
  if (LL_ADC_IsEnabled(ADC1) == 0)
  {
    for (int i = 0; i < 5; i++)
    {
      LL_ADC_StartCalibration(ADC1);
      while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0) {}
      ADC_CALRR1_Buff[i]     = *((__IO uint32_t *)(0x40012448));
      ADC_CALRR1_BuffInt[i]  = (int32_t)(ADC_CALRR1_Buff[i] << 9);
    }
    APP_QuickSort(ADC_CALRR1_BuffInt, 5);
    *((__IO uint32_t *)(0x40012450)) = (ADC_CALRR1_BuffInt[2] >> 9);
    *((__IO uint32_t *)(0x40012454)) = *((__IO uint32_t *)(0x4001244C));
    *((__IO uint32_t *)(0x40012444)) |= 0x8000;
    LL_mDelay(1);
  }
}

/**
  * @brief  ADC 使能并等待稳定
  */
static void APP_AdcEnable(void)
{
  LL_ADC_Enable(ADC1);
  LL_mDelay(1);
}

/* APP_QuickSort / APP_SystemClockConfig / APP_ErrorHandler 略（与前述示例同构） */

代码分段讲解

1. 校准：LL 与 HAL 的关键差异

HAL 里你几乎感觉不到“校准”的存在——HAL_ADC_Init() 内部已经帮你调好。LL 里校准是显式的：先 LL_ADC_StartCalibration()，等 LL_ADC_IsCalibrationOnGoing() 清零，再把结果写回校准寄存器。示例里采样 5 次取中位数，是对出厂标定的微调。忽略这步，读数会明显不准。

2. 触发源：软件触发

LL_ADC_REG_InitType.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE 表示“想转换时，由软件写寄存器启动”，对应你点名要学的 ADC_SingleConversion_TriggerSW_*。运行时调用 LL_ADC_REG_StartConversion(ADC1) 即启动一次（连续模式下会持续转换）。

3. 等待结束 + 读结果

HAL：HAL_ADC_PollForConversion() 封装了等待。
LL：直接 LL_ADC_IsActiveFlag_EOS(ADC1) 轮询“序列结束”标志，再 LL_ADC_REG_ReadConversionData12() 读 12 位值。名字虽长，但语义一目了然。

4. 温度换算

__LL_ADC_CALC_TEMPERATURE_85() 是 LL 提供的宏，按 Vref(3300mV)、原始值、分辨率换算成摄氏温度。把通道换成外部 GPIO 引脚时，你只需用 LL_ADC_CHANNEL_x 替换 LL_ADC_CHANNEL_TEMPSENSOR，并去掉“内部通道”那几行。

实验现象

串口每约 200ms 打印一行 Temperature: xx（摄氏度）。
用手摸芯片或吹热气，读数会明显变化（注意：受自热影响，绝对值可能偏高）。

常见问题

读数一直是 0 或满量程？
- 几乎都是漏了“开 ADC1 时钟”或“校准”。LL 不会自动开时钟，也requires 手动校准。
- 确认 LL_ADC_REG_TRIG_SOFTWARE 后确实调用了 LL_ADC_REG_StartConversion()。
温度跳变很大？
- 温度传感器本身噪声较大，可多次采样取平均；示例只打印单次值。
想采样外部引脚怎么改？
- 把 LL_ADC_CHANNEL_TEMPSENSOR 换成 LL_ADC_CHANNEL_0~LL_ADC_CHANNEL_x，并删掉 LL_ADC_SetCommonPathInternalCh(...) 与稳定等待那几行。

小结

LL 的 ADC 使用范式：开时钟 → 校准 → 配置(通道/触发/分辨率) → 使能 → 软件触发 → 轮询 EOS → 读值。
与 HAL 最大的不同是“校准”和“启动转换”都暴露给你自己控制，没有任何隐藏动作。
单通道软件触发轮询，是 LL ADC 最基础也最常用的模板。

拓展应用

改成多通道扫描（LL_ADC_REG_SetSequencerChannels 设多个通道），轮流采样电压/温度。
触发源换成定时器（LL_ADC_REG_TRIG_EXT_TIMx_TRGO），实现固定采样率。
配合 DMA（ADC_MultiChannelSingleConversion_TriggerSW_DMA）让 CPU 完全不介入连续采样。
把温度换算后用于控制风扇/报警，做最简单的温控演示。

AT32 ADC — 读取内部参考电压，反算供电电压（ADC+DMA 入门）

Tue, 08 Sep 2026 14:56:00 +0800

ADC — 读取内部参考电压

难度: ⭐⭐（需要了解 ADC 和 DMA 概念）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/adc/current_vref_value_check/src/main.c

这个实验是干嘛的？

每个 MCU 芯片内部都有一个精确的参考电压源（Vrefint），典型值 1.2V。这个电压不随外部供电变化，是芯片出厂时校准好的。

本实验的思路：

用 ADC 采集这个内部 1.2V 参考电压
ADC 采样值会随实际供电电压（VDDA）变化
反过来，知道了 ADC 采样值和参考电压，就能算出实际 VDDA

公式：

`1`	`VDDA = 1.2V × 4095 / ADC采样值`

有什么用？

电池供电的设备：不用外部电压表就能监测电池电量
电源质量检测：发现供电不稳
ADC 精度校准：知道实际 VDDA 后，其他 ADC 测量更准

硬件准备

不需要任何外部硬件！ 内部参考电压是芯片自带的。

你只需要：

AT32F403A 开发板
USB 转串口模块（查看 printf 输出）

涉及的知识点

这个实验比较"硬核"，同时用到了 ADC 和 DMA 两个外设。先搞懂概念：

ADC（模数转换器）

ADC 把模拟电压转换成数字值。AT32F403A 的 ADC 是 12 位的，意味着：

输入 0V → 输出 0
输入 VDDA（3.3V）→ 输出 4095（2^12 - 1）
输入 1.2V → 输出约 1489（1.2 / 3.3 × 4095）

DMA（直接存储器访问）

ADC 采样完成后，数据存在 ADC 寄存器里。你可以：

不用 DMA：CPU 自己去读寄存器（轮询或中断）
用 DMA：DMA 硬件自动把数据搬到内存变量，CPU 完全不参与

本实验用 DMA，因为更高效——ADC 每次采样完，DMA 自动把结果搬到 adc1_ordinary_value 变量里。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

/* DMA 搬运的目标变量，ADC 采样结果会自动存到这里 */
__IO uint16_t adc1_ordinary_value = 0;

/* ========== DMA 配置 ========== */
static void dma_config(void)
{
  dma_init_type dma_init_struct;

  /* 使能 DMA1 时钟 */
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);

  /* 数据搬运方向：从外设（ADC）到内存 */
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;

  /* 源地址：ADC 数据寄存器 */
  dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD; // 16位
  dma_init_struct.peripheral_inc_enable = FALSE;  // 源地址不递增（始终读同一个寄存器）

  /* 目标地址：我们的变量 */
  dma_init_struct.memory_base_addr = (uint32_t)&adc1_ordinary_value;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD; // 16位
  dma_init_struct.memory_inc_enable = FALSE;  // 目标地址不递增（只存一个值）

  dma_init_struct.buffer_size = 1;              // 每次搬运 1 个数据
  dma_init_struct.priority = DMA_PRIORITY_HIGH; // 高优先级
  dma_init_struct.loop_mode_enable = TRUE;      // 循环模式（反复搬运）

  dma_init(DMA1_CHANNEL1, &dma_init_struct);
}

/* ========== ADC 配置 ========== */
static void adc_config(void)
{
  adc_base_config_type adc_base_struct;

  /* 使能 ADC1 时钟 */
  crm_periph_clock_enable(CRM_ADC1_PERIPH_CLOCK, TRUE);
  adc_reset(ADC1);

  /* ADC 时钟分频：系统时钟 / 4 */
  crm_adc_clock_div_set(CRM_ADC_DIV_4);

  adc_base_default_para_init(&adc_base_struct);

  /* 独立模式（不与其他 ADC 联动） */
  adc_combine_mode_select(ADC_INDEPENDENT_MODE);

  /* ADC 基础配置 */
  adc_base_struct.sequence_mode = FALSE;           // 非序列模式（只采一个通道）
  adc_base_struct.repeat_mode = FALSE;             // 不重复
  adc_base_struct.data_align = ADC_RIGHT_ALIGNMENT; // 右对齐
  adc_base_struct.ordinary_channel_length = 1;     // 只采 1 个通道
  adc_base_config(ADC1, &adc_base_struct);

  /* 选择通道 17 = 内部参考电压 Vrefint */
  adc_ordinary_channel_set(ADC1, ADC_CHANNEL_17, 1, ADC_SAMPLETIME_239_5);

  /* 软件触发（不用外部触发源） */
  adc_ordinary_conversion_trigger_set(ADC1, ADC12_ORDINARY_TRIG_SOFTWARE, TRUE);

  /* 使能 ADC 的 DMA 请求 */
  adc_dma_mode_enable(ADC1, TRUE);

  /* 使能内部温度传感器和参考电压 */
  adc_tempersensor_vintrv_enable(TRUE);

  /* 使能 ADC */
  adc_enable(ADC1, TRUE);

  /* ADC 校准（必须！消除工艺偏差） */
  adc_calibration_init(ADC1);
  while(adc_calibration_init_status_get(ADC1));  // 等待校准初始化完成
  adc_calibration_start(ADC1);
  while(adc_calibration_status_get(ADC1));        // 等待校准完成
}

/* ========== 主函数 ========== */
int main(void)
{
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();

  /* 关闭所有 LED */
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);

  /* 初始化串口（用于 printf 输出） */
  uart_print_init(115200);

  /* 初始化 DMA 和 ADC */
  dma_config();
  adc_config();

  /* 使能 DMA 通道（必须在 ADC 使能之后！） */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  printf("adc1_vref_check \r\n");

  while(1)
  {
    at32_led_toggle(LED2);
    delay_sec(1);

    /* 软件触发一次 ADC 转换 */
    adc_ordinary_software_trigger_enable(ADC1, TRUE);

    /* 等待 DMA 搬运完成（转换结束标志） */
    while(dma_flag_get(DMA1_FDT1_FLAG) == RESET);
    dma_flag_clear(DMA1_FDT1_FLAG);

    /* 计算并打印 VDDA 电压 */
    printf("vref_value = %f V\r\n", ((double)1.2 * 4095) / adc1_ordinary_value);
  }
}

代码分段讲解

DMA 配置详解

`1`	`dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;`

DMA 有 3 种方向：

PERIPHERAL_TO_MEMORY — 外设→内存（读取外设数据，本实验用这个）
MEMORY_TO_PERIPHERAL — 内存→外设（发送数据到外设）
MEMORY_TO_MEMORY — 内存→内存（数据搬运）

`1`	`dma_init_struct.peripheral_base_addr = (uint32_t)&(ADC1->odt);`

源地址是 ADC1 的数据输出寄存器（ODT），ADC 每次采样的结果存在这里。

`1`	`dma_init_struct.loop_mode_enable = TRUE;`

循环模式：DMA 搬完一次后自动重新开始。这样每次 ADC 转换完，DMA 都会自动把新数据搬过来。

ADC 配置详解

`1`	`adc_ordinary_channel_set(ADC1, ADC_CHANNEL_17, 1, ADC_SAMPLETIME_239_5);`

这行配置了 3 个东西：

通道 17 — 内部参考电压（Vrefint）固定映射到通道 17
序号 1 — 在序列中的位置（这里只采一个通道，所以是 1）
采样时间 239.5 个时钟周期 — 采样时间越长精度越高，但速度越慢

`1`	`adc_tempersensor_vintrv_enable(TRUE);`

这行很重要！ 必须使能内部参考电压，否则通道 17 读到的是 0。

1
2

adc_calibration_init(ADC1);
adc_calibration_start(ADC1);

ADC 校准是必须的步骤。芯片制造有工艺偏差，校准可以消除这个偏差。不校准的话，采样值可能偏差几百 LSB。

主循环

adc_ordinary_software_trigger_enable(ADC1, TRUE);  // 触发一次转换
while(dma_flag_get(DMA1_FDT1_FLAG) == RESET);       // 等 DMA 搬完
dma_flag_clear(DMA1_FDT1_FLAG);                      // 清标志位
printf("vref_value = %f V\r\n", ((double)1.2 * 4095) / adc1_ordinary_value);

公式：VDDA = 1.2V × 4095 / ADC采样值

举例：如果 ADC 读到 1489，那么 VDDA = 1.2 × 4095 / 1489 ≈ 3.30V

实验现象

串口助手每秒打印一行：

adc1_vref_check
vref_value = 3.302500 V
vref_value = 3.301800 V
vref_value = 3.303200 V
...

如果供电是 3.3V，读数应该在 3.28~3.32V 附近
如果用 USB 供电，可能会看到 3.25~3.35V 的波动（USB 供电不太稳）
如果用电池供电，电压会随电量慢慢下降

常见问题

Q: 读到的电压是 0 或者不对？

检查是否调用了 adc_tempersensor_vintrv_enable(TRUE) — 不开这个，Vrefint 通道没连接
检查是否做了 ADC 校准
检查 DMA 是否在 ADC 使能之后才使能

Q: 数值跳动很大？

增加采样时间（已经用了 239.5，比较长了）
可以做多次采样取平均值
检查电源是否稳定

Q: 想读取外部引脚的电压？

把 ADC_CHANNEL_17 换成对应的外部通道号（如 ADC_CHANNEL_0 对应 PA0）
去掉 adc_tempersensor_vintrv_enable() — 这个只用于内部通道

小结

概念	说明
Vrefint	芯片内部 1.2V 精密参考电压
12 位 ADC	输出范围 0~~4095，对应 0V~~VDDA
DMA	硬件自动搬运数据，不占 CPU
ADC 校准	必须做，消除工艺偏差
采样时间	越长精度越高，速度越慢

学了 ADC+DMA 能做什么？

ADC 是连接"物理世界"和"数字世界"的桥梁。温度、光照、电压、声音……所有模拟信号都要靠 ADC 来采集：

传感器数据采集

项目	原理	难度
温度检测	NTC 热敏电阻 + ADC → 查表得温度	⭐⭐
光照检测	光敏电阻 + ADC → 判断亮暗	⭐
电池电量	分压电阻 + ADC → 读电池电压	⭐⭐
电流检测	采样电阻 + 运放 + ADC → 读电流	⭐⭐⭐
声音采集	MEMS 麦克风 + ADC → 录音/声控	⭐⭐⭐
心率检测	光电传感器 + ADC → 心跳波形	⭐⭐⭐

控制与调节

项目	原理	难度
恒温控制	温度传感器 + ADC + PID + 加热器	⭐⭐⭐
光控灯	光敏电阻 + ADC + 继电器 → 天黑自动开灯	⭐⭐
可调电源	电位器 + ADC → 设定输出电压	⭐⭐⭐
示波器	高速 ADC + DMA + 显示屏 → 简易示波器	⭐⭐⭐⭐
功率计	电压 ADC + 电流 ADC → 计算功率（你正在做的 2UUL！）	⭐⭐⭐

DMA 的重要性

不用 DMA 也能读 ADC，但 DMA 有这些优势：

不占 CPU：ADC 采样 100 万次/秒，CPU 完全不用管
不丢数据：轮询方式可能来不及读就被覆盖了
配合定时器：定时器触发 ADC，DMA 自动搬运，实现精确采样率

核心思路：ADC + DMA = “自动采集系统”。ADC 负责把模拟信号变成数字，DMA 负责搬运数据，CPU 只需要在数据准备好后处理结果。这是所有数据采集系统的基础架构。

下一步：学会了 ADC，可以学 SPI 读写 Flash，用 SPI 接口读写外部 W25Q Flash 芯片。

Adc on CLing

PUYA ADC — 软件触发单次转换（多通道）

ADC — 软件触发单次转换（多通道）

功能简介

硬件准备

完整代码

代码分段讲解

1. 校准与时钟

2. 软件触发 vs 硬件触发

3. 单次 / 连续 / 扫描

4. 结果换算

实验现象

常见问题

小结

拓展应用

AT32 — 模数转换器 (ADC)

AT32 — 模数转换器 (ADC)

什么是 模数转换器 (ADC)?

示例列表

AT32 ADC — 定时器触发自动抢占

ADC — 定时器触发自动抢占

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 模拟看门狗电压监测

ADC — 模拟看门狗电压监测

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 内部温度传感器读取

ADC — 内部温度传感器读取

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 三 ADC 同步触发

ADC — 三 ADC 同步触发

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 双 ADC 联合规则同步模式

ADC — 双 ADC 联合规则同步模式

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 外部中断触发分区采样

ADC — 外部中断触发分区采样

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 ADC — 循环重复转换 + DMA

ADC — 循环重复转换 + DMA

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

CIU32 — 模数转换器 (ADC)

CIU32 — 模数转换器 (ADC)

什么是 模数转换器 (ADC)?

示例列表

CIU32 ADC — ADC 不连续转换定时触发

什么是模数转换器 (ADC)?

什么是模数转换器 (ADC)?