AT32 — 模数转换器 (ADC) on CLing

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）

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 芯片。