DMA on CLing

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（HAL 库）

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

DMA — 内存到内存搬运（SRAM → SRAM）（HAL 库）

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

功能简介

DMA（Direct Memory Access，直接存储器访问）允许在不占用 CPU 的情况下让数据在存储器之间或存储器与外设之间自动搬运。CPU 只需“下单”，DMA 控制器在后台搬运，搬完产生中断通知 CPU。

本示例演示最直观的 内存→内存（Memory-to-Memory） 模式：

在源缓冲 aSRC_Const_Buffer[32] 填入 0,1,2,…31；
启动 DMA 把 32 个 32 位字 搬到 aDST_Buffer[32]；
用传输完成中断回调校验数据是否一致；
一致则点亮绿灯，不一致/出错则闪烁报警。

BUFFER_SIZE 在 main.h 中定义为 32。这是理解“DMA 替 CPU 干活”的最佳入门示例；后面接 ADC/SPI 时都是同样的套路，只是源/目的换成外设寄存器。

硬件准备

PY32F030 开发板
板载 LED（观察结果）
无需外接，纯内部 SRAM 搬运

完整代码

#include "main.h"

DMA_HandleTypeDef DmaHandle;
uint32_t aSRC_Const_Buffer[BUFFER_SIZE];  /* 源缓冲 */
uint32_t aDST_Buffer[BUFFER_SIZE];        /* 目的缓冲 */
__IO uint32_t transferCompleteDetected = 0; /* 传输完成标志 */
__IO uint32_t transferErrorDetected    = 0; /* 传输错误标志 */
__IO uint32_t transferFailedDetected   = 0; /* 数据校验失败标志 */

int main(void)
{
  HAL_Init();
  BSP_LED_Init(LED_GREEN);

  /* 准备源数据 0~31 */
  for (uint8_t i = 0; i < BUFFER_SIZE; i++)
    aSRC_Const_Buffer[i] = i;

  APP_DmaConfig();  /* 配置并注册回调、使能中断 */

  /* 启动 DMA 传输（中断方式，CPU 立即返回） */
  if (HAL_DMA_Start_IT(&DmaHandle,
                       (uint32_t)&aSRC_Const_Buffer,  /* 源地址 */
                       (uint32_t)&aDST_Buffer,        /* 目的地址 */
                       BUFFER_SIZE) != HAL_OK)        /* 传输个数（单位=数据宽度） */
  {
    APP_ErrorHandler();
  }

  while (1)
  {
    if (transferFailedDetected == 1 && transferCompleteDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); HAL_Delay(500); } /* 数据错：快闪 */
    }
    if (transferFailedDetected == 0 && transferCompleteDetected == 1)
    {
      BSP_LED_On(LED_GREEN);   /* 成功：绿灯常亮 */
      while (1) {}
    }
    if (transferErrorDetected == 1)
    {
      BSP_LED_On(LED_GREEN);
      while (1) { BSP_LED_Toggle(LED_GREEN); HAL_Delay(500); } /* 出错：闪烁 */
    }
  }
}

/**
  * @brief  DMA 配置
  */
static void APP_DmaConfig(void)
{
  __HAL_RCC_DMA_CLK_ENABLE();                 /* 开启 DMA 时钟 */

  DmaHandle.Init.Direction           = DMA_MEMORY_TO_MEMORY;  /* 内存到内存 */
  DmaHandle.Init.PeriphInc           = DMA_PINC_ENABLE;       /* 外设(源)地址自增 */
  DmaHandle.Init.MemInc              = DMA_MINC_ENABLE;       /* 内存(目的)地址自增 */
  DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;   /* 源数据宽度 32 位 */
  DmaHandle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;   /* 目的数据宽度 32 位 */
  DmaHandle.Init.Mode                = DMA_NORMAL;            /* 普通模式（非循环） */
  DmaHandle.Init.Priority            = DMA_PRIORITY_HIGH;     /* 通道优先级高 */

  DmaHandle.Instance = DMA1_Channel1;          /* 使用 DMA1 通道 1 */
  if (HAL_DMA_Init(&DmaHandle) != HAL_OK) APP_ErrorHandler();

  /* 注册“传输完成”和“传输错误”两个回调 */
  HAL_DMA_RegisterCallback(&DmaHandle, HAL_DMA_XFER_CPLT_CB_ID,  APP_TransferComplete);
  HAL_DMA_RegisterCallback(&DmaHandle, HAL_DMA_XFER_ERROR_CB_ID, APP_TransferError);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);      /* 使能 DMA 中断 */
}

/* 传输完成回调：校验数据 */
static void APP_TransferComplete(DMA_HandleTypeDef *DmaHandle)
{
  for (uint16_t i = 0; i < BUFFER_SIZE; i++)
  {
    if (aDST_Buffer[i] != aSRC_Const_Buffer[i])
    {
      transferFailedDetected = 1;
      break;
    }
  }
  transferCompleteDetected = 1;
}

/* 传输错误回调 */
static void APP_TransferError(DMA_HandleTypeDef *DmaHandle)
{
  transferErrorDetected = 1;
}

代码分段讲解

1. 地址自增与数据宽度

PeriphInc / MemInc = ENABLE：搬运时源、目的地址都自动 +1（按数据宽度递增）。若对固定寄存器（如 USART TDR）搬运，应把对应端设为 DISABLE。
PDATAALIGN_WORD / MDATAALIGN_WORD：每次搬 4 字节。传输个数 BUFFER_SIZE 的单位是“次”，不是字节；32 字 × 4 = 128 字节。

2. 模式 Normal vs Circular

DMA_NORMAL：搬完一次即停。
DMA_CIRCULAR：搬完自动从头再来，常用于 DAC 波形输出、ADC 连续采样等持续场景。

3. 中断回调

HAL_DMA_Start_IT 启动后 CPU 立刻返回，搬运在后台进行；完成后硬件触发 DMA1_Channel1_IRQn，HAL 在中断里调用你注册的 APP_TransferComplete。这就是 DMA “解放 CPU” 的核心。

实验现象

DMA 在后台把 32 个字从源搬到目的；
校验一致：绿灯常亮；不一致或出错：绿灯闪烁。

常见问题

编译报 BUFFER_SIZE 未定义？
- 它在 main.h（#define BUFFER_SIZE 32）中，确认工程包含该头文件。
传输没完成/不进回调？
- 确认 __HAL_RCC_DMA_CLK_ENABLE() 已调用，且 HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn) 已使能。
- 确认 DMA1_Channel1_IRQHandler 在 startup 中正确指向 HAL 的中断处理（库工程默认已连）。
数据错位？
- 检查源/目的地址自增与数据宽度是否匹配；外设寄存器做源/目的时要把对应端 Inc 设为 DISABLE。
想连续搬运？
- 把 Mode 改为 DMA_CIRCULAR，并配合外设（如 ADC/DAC）使用。

小结

DMA 四要素：方向、地址自增、数据宽度、模式（普通/循环）。
内存↔内存、内存↔外设都用同一套 HAL_DMA_* API，区别只在地址与 Inc 配置。
中断方式让 CPU “下单后就去干别的”，搬完由回调通知，是提升效率的关键。

拓展应用

ADC_ContinuousConversion_DMA：ADC 连续采样，DMA 自动把结果搬进数组。
SPI/DMA（见 SPI_TwoBoards_FullDuplexMaster_DMA）：大批量 SPI 数据后台收发。
DMA_CIRCULAR + DAC：播放波形/音频。
双缓冲（Double Buffer）：一边 DMA 搬当前块，CPU 处理上一块，实现零等待流式处理。

AT32 — 直接存储器访问 (DMA)

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

AT32 — 直接存储器访问 (DMA)

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

什么是直接存储器访问 (DMA)?

DMA（直接存储器访问）可以在不占用 CPU 的情况下搬运数据。ADC、SPI、USART 等外设配合 DMA 可以大幅提升效率。

示例列表

DMA 灵活输出到 GPIO — data_to_gpio_flexible
Flash → SRAM 搬运 — flash_to_sram

AT32 DMA — DMA 灵活输出到 GPIO

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

DMA — DMA 灵活输出到 GPIO

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

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

int main(void)
{
  system_clock_config();

  at32_board_init();

  /* enable dma2/gpioc/tmr2 clock */
  crm_periph_clock_enable(CRM_DMA2_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_TMR2_PERIPH_CLOCK, TRUE);

  /* config gpioc pin for output mode */
  gpio_init_struct.gpio_pins = GPIO_PINS_ALL;
  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init(GPIOC, &gpio_init_struct);

  tmr_base_init(TMR2, 0xFF, 0);
  tmr_cnt_dir_set(TMR2, TMR_COUNT_UP);

  /* enable tmr2 overflow dma request */
  tmr_dma_request_enable(TMR2, TMR_OVERFLOW_DMA_REQUEST, TRUE);

  /* dma2 channel1 configuration */
  dma_reset(DMA2_CHANNEL1);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)src_buffer;
  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)0x4001100C;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA2_CHANNEL1, &dma_init_struct);

  /* enable transfer full data interrupt */
  dma_interrupt_enable(DMA2_CHANNEL1, DMA_FDT_INT, TRUE);

  /* dma2 channel1 interrupt nvic init */
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  nvic_irq_enable(DMA2_Channel1_IRQn, 1, 0);

  /* tmr2 flexible function enable */
  dma_flexible_config(DMA2, FLEX_CHANNEL1, DMA_FLEXIBLE_TMR2_OVERFLOW);

  /* enable dma channel */
  dma_channel_enable(DMA2_CHANNEL1, TRUE);

  /* enable tmr2 */
  tmr_counter_enable(TMR2, TRUE);

  while(1)
  {
  }
}

代码讲解

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

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

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

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

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

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

AT32 TMR — 定时器 DMA 触发

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

TMR — 定时器 DMA 触发

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

功能简介

本示例演示定时器 DMA 触发。定时器事件自动触发 DMA 传输，无需 CPU 干预，适合波形生成等高速场景。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

int main(void)
{
  system_clock_config();

  at32_board_init();

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

  /* turn led2/led3/led4 on */
  at32_led_on(LED2);
  at32_led_on(LED3);
  at32_led_on(LED4);

  /* enable tmr1/gpioa/gpiob/dma clock */
  crm_periph_clock_enable(CRM_TMR1_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  /* timer1 output pin Configuration */
  gpio_init_struct.gpio_pins = GPIO_PINS_10;
  gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init(GPIOA, &gpio_init_struct);

  gpio_init_struct.gpio_pins = GPIO_PINS_15;
  gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init(GPIOB, &gpio_init_struct);

  /* tmr1 dma transfer example
  tmr1clk = system_core_clock, prescaler = 0, tmr1 counter clock = system_core_clock
  system_core_clock is set to 240 mhz.

  the objective is to configure tmr1 channel 3 to generate complementary pwm
  signal with a frequency equal to 17.57 khz:
     - tmr1_period = (system_core_clock / 17570) - 1
  and a variable duty cycle that is changed by the dma after a specific number of
  update dma request.

  the number of this repetitive requests is defined by the tmr1 repetition counter,
  each 3 update requests, the tmr1 channel 3 duty cycle changes to the next new
  value defined by the src_buffer. */
  /* compute the value to be set in arr regiter to generate signal frequency at 17.57 khz */
  timer_period = (crm_clocks_freq_struct.sclk_freq / 17570 ) - 1;
  /* compute c1dt value to generate a duty cycle at 50% */
  src_buffer[0] = (uint16_t) (((uint32_t) 5 * (timer_period - 1)) / 10);
  /* compute c1dt value to generate a duty cycle at 37.5% */
  src_buffer[1] = (uint16_t) (((uint32_t) 375 * (timer_period - 1)) / 1000);
  /* compute c1dt value to generate a duty cycle at 25% */
  src_buffer[2] = (uint16_t) (((uint32_t) 25 * (timer_period - 1)) / 100);

  tmr_base_init(TMR1, timer_period, 0);
  tmr_cnt_dir_set(TMR1, TMR_COUNT_UP);

  /* channel 3 configuration in output mode */
  tmr_output_default_para_init(&tmr_output_struct);
  tmr_output_struct.oc_mode = TMR_OUTPUT_CONTROL_PWM_MODE_B;
  tmr_output_struct.oc_output_state = TRUE;
  tmr_output_struct.oc_polarity = TMR_OUTPUT_ACTIVE_LOW;
  tmr_output_struct.oc_idle_state = TRUE;
  tmr_output_struct.occ_output_state = TRUE;
  tmr_output_struct.occ_polarity = TMR_OUTPUT_ACTIVE_LOW;
  tmr_output_struct.occ_idle_state = FALSE;
  /* channel 3 */
  tmr_output_channel_config(TMR1, TMR_SELECT_CHANNEL_3, &tmr_output_struct);
  tmr_channel_value_set(TMR1, TMR_SELECT_CHANNEL_3, src_buffer[0]);

  /* enable tmr1 overflow dma request */
  tmr_dma_request_enable(TMR1, TMR_OVERFLOW_DMA_REQUEST, TRUE);

  /* dma config for tmr1 overflow dma request */
  /* dma1 channel5 configuration */
  dma_reset(DMA1_CHANNEL5);
  dma_init_struct.buffer_size = 3;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)src_buffer;
  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)&TMR1->c3dt;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = TRUE;
  dma_init(DMA1_CHANNEL5, &dma_init_struct);

  dma_channel_enable(DMA1_CHANNEL5, TRUE);

  /* output enable */
  tmr_output_enable(TMR1, TRUE);
  /* enable tmr1 */
  tmr_counter_enable(TMR1, TRUE);

  while(1)
  {
  }
}

代码讲解

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

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

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

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

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

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

GD32 — 直接存储器访问 (DMA)

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

GD32 — 直接存储器访问 (DMA)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 3
推荐入门: Flash_to_ram（Flash → RAM）

什么是 DMA？

DMA（Direct Memory Access，直接存储器访问）可以理解为 MCU 里的一个**“自动搬运工”**。平时我们要把数据从 A 搬到 B（比如从 Flash 拷到 RAM、从 ADC 搬到数组、从数组发到 USART），都得 CPU 一条条 for 循环去读写。DMA 出现后，CPU 只要下个"指令"，剩下的成百上千字节就由 DMA 硬件自动搬完，搬完了再通知 CPU 一声。

一句话记忆：DMA = 不占用 CPU 的数据搬运器，CPU 去干计算/通信的活，搬运交给它。

没有 DMA vs 有 DMA

场景	不用 DMA	用 DMA
ADC 连续采样 1024 点	CPU 轮询/中断一个个读，忙得不可开交	DMA 自动搬进数组，CPU 去干别的
串口发 1KB 数据	CPU 一个字节一个字节等 TBE	DMA 一口气发完，发完进中断
大数组拷贝	`for` 循环占满 CPU	一条指令后台搬完

DMA 的"三要素"

配置一次 DMA 搬运，本质就是告诉它三件事：

从哪搬（源地址 / 外设地址）：periph_addr 或 memory_addr。
搬到哪（目标地址 / 内存地址）：另一个 memory_addr。
搬多少、怎么搬：
- number：总共搬多少"次"（注意是按"数据宽度"算次数）。
- periph_inc / memory_inc：搬完一个后，源/目标地址是否自动 +1（自增）。
- periph_width / memory_width：每次搬 8 位 / 16 位 / 32 位。
- direction：外设→内存、内存→外设、还是内存→内存。
- priority：多个 DMA 通道抢总线时谁优先。

三种传输方向

外设 → 内存（Peripheral to Memory）：典型如 ADC 采样值搬进数组、串口收到的数据搬进缓冲。
内存 → 外设（Memory to Peripheral）：典型如把发送数组搬给 USART/SPI 发出去。
内存 → 内存（Memory to Memory）：纯软件数据搬运，如本例的 Flash→RAM。⚠️ 注意：只有 DMA0 支持内存到内存模式。

搬运完成怎么知道？—— 中断

DMA 支持多种中断：传输完成（FTF，Full Transfer Finish）、半传输（HTF）、传输错误（ERR）等。本例用 DMA_INT_FTF：搬完 1024 字节后触发 DMA0_Channel0_IRQHandler，在函数里把 g_dmacomplete_flag 置 1，主循环 while(0 == g_dmacomplete_flag); 就解除了阻塞。

循环模式（Circular）：普通模式搬完一次就停；循环模式搬完自动从头再来，常用于 ADC 连续采样（环形缓冲）。本例 dma_circulation_disable，只搬一次。

GD32F30x 的 DMA 资源

通常有两路 DMA 控制器：DMA0 和 DMA1，每路有多个通道（CH0~CHx）。
不同外设的 DMA 请求固定映射到特定 DMA 通道（如 ADC0→DMA0_CH0、USART0_TX→DMA0_CH3 等），用时要查手册映射表。
内存到内存模式仅 DMA0 可用。

常用库函数速查

函数	作用
`dma_deinit(DMAx, CHx)`	复位 DMA 通道
`dma_init(DMAx, CHx, &init)`	按结构体配置通道
`dma_circulation_enable/disable()`	开/关循环模式
`dma_memory_to_memory_enable()`	开启内存到内存模式（仅 DMA0）
`dma_interrupt_enable(DMAx, CHx, flag)`	开启某种 DMA 中断
`dma_channel_enable(DMAx, CHx)`	启动传输
`dma_flag_get()` / `dma_interrupt_flag_clear()`	查询/清除标志

示例列表

Flash → RAM — Flash_to_ram ★ 入门推荐
RAM → RAM — Ram_to_ram
RAM → USART — Ram_to_usart

学习路径建议

先跑通 Flash_to_ram：理解"配好三要素 + 启动 + 等中断"这条最干净的 DMA 主线。
再看 Ram_to_usart：体会 DMA 如何给串口"减负"（内存→外设方向）。
需要 ADC 批量采样时，把方向换成"外设→内存"即可。

下一篇：Flash → RAM

GD32 DMA — Flash → RAM

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

DMA — Flash → RAM

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/DMA/Flash_to_ram/main.c
配套: gd32f30x_it.c 中的 DMA0_Channel0_IRQHandler（置完成标志）

功能简介

本示例演示 DMA 最纯粹的用途：把一块 Flash 上的数据，自动搬到 RAM 数组里。为了"造出"可搬运的 Flash 内容，例程先做了三件事：

擦除 Flash 的 0x08004000 起始处的若干页（擦成全 0xFF）。
编程这些 Flash 页，每 4 字节写一个固定值 0x3210ABCD。
用 DMA0 通道0（内存到内存模式）把这 0x400（1024）字节从 Flash 自动搬进 RAM 数组 g_destbuf[]。

搬运结束后，在 DMA 完成中断里把 g_dmacomplete_flag 置 1，主循环解除等待，再逐字节比对：如果 g_destbuf 里全是 0x3210ABCD，说明 DMA 搬运成功 → 4 颗 LED 全亮；否则只亮 LED2、LED4 表示出错。

为什么搬 Flash 还要先擦再写？ 因为 Flash 只能把 1 写成 0、不能把 0 直接写成 1，所以写入前必须整页擦除（擦除后全为 1，即 0xFF）。这是 Flash 的物理特性，和前面 FMC 例程一致。本例的重点其实不是 Flash 操作，而是"DMA 怎么搬"——Flash 那部分只是给 DMA 准备一个数据源。

硬件准备

GD32F30x 评估板一块（LED2/LED3/LED4/LED5 由 gd_eval_led_init 初始化）。
无需任何外部接线。本例完全是片内 Flash ↔ RAM 的搬运，下载程序即可观察 LED。
若用调试器（如 J-Link / DAP），可在搬运前后观察 g_destbuf[] 和 0x08004000 处的内容，验证搬运正确性。

⚠️ 地址安全提醒：BANK0_WRITE_START_ADDR = 0x08004000。这个地址在 Flash 靠前的"用户区"，务必确认它不在你的程序代码区，否则擦写会破坏正在运行的代码。评估板例程默认这里空闲；你自己移植时请选程序末尾之后的空闲页。

完整代码（带中文注释）

注：DMA0_Channel0_IRQHandler 在 gd32f30x_it.c 里，搬运完成后被调用，把标志位置 1。此处一并列出。

#include "gd32f30x.h"
#include <string.h>
#include "gd32f307c_eval.h"

#define TRANSFER_NUM           0x400    /* 搬运总字节数：1024 字节 */
#define FMC_PAGE_SIZE          ((uint16_t)0x800)        /* Flash 每页 2KB */
#define BANK0_WRITE_START_ADDR ((uint32_t)0x08004000)   /* 被读/写的 Flash 起始地址 */

void rcu_config(void);
void nvic_config(void);
void led_config(void);

/* DMA 完成标志：中断里置 1，主循环里等待它 */
__IO uint32_t g_dmacomplete_flag = 0;
/* DMA 的目标缓冲区（在 RAM 里） */
uint8_t g_destbuf[TRANSFER_NUM];
/* 要写进 Flash 的固定数据 */
const uint32_t transdata = 0x3210ABCD;
fmc_state_enum fmcstatus = FMC_READY;

int main(void)
{
    uint32_t i, count;
    uint32_t *ptrd;
    uint32_t address = 0x00;
    ErrStatus access_flag = SUCCESS;
    dma_parameter_struct dma_init_struct;
    uint32_t wperror = 0;

    rcu_config();        /* 开 DMA0 时钟 */
    nvic_config();       /* 配置 DMA0 通道0 中断 */
    led_config();        /* LED 初始化 */
    fmc_unlock();        /* 解锁 Flash 控制器（写 Flash 前必须） */

    /* ---- 第 1 步：擦除 Flash 页（擦成 0xFF）---- */
    count = TRANSFER_NUM / FMC_PAGE_SIZE;   /* 1024/2048 = 0，循环会擦 2 页(0,1) */
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    for(i = 0; i <= count; i++){
        fmcstatus = fmc_page_erase(BANK0_WRITE_START_ADDR + (FMC_PAGE_SIZE * i));
        wperror += (fmcstatus == FMC_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    }
    if(wperror != 0){ while(1); }   /* 擦除出错就卡死 */
    fmc_lock();                      /* 擦完先上锁 */

    /* 校验：擦除后读出来应该全是 0xFFFFFFFF */
    ptrd = (uint32_t*)BANK0_WRITE_START_ADDR;
    count = TRANSFER_NUM / sizeof(*ptrd);   /* 按 32 位（4字节）算个数 */
    for(i = 0; i < count; i++){
        if(0xFFFFFFFF != *ptrd){
            access_flag = ERROR;
            break;
        }
        ptrd++;
    }
    if(ERROR == access_flag){ while(1); }

    /* ---- 第 2 步：编程 Flash，每 4 字节写 0x3210ABCD ---- */
    fmc_unlock();
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    address = BANK0_WRITE_START_ADDR;
    wperror = 0;
    count = BANK0_WRITE_START_ADDR + TRANSFER_NUM;   /* 结束地址 */
    while(address < count){
        fmcstatus = fmc_word_program(address, transdata);
        address = address + 4;
        wperror += (FMC_WPERR == fmcstatus);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    }
    if(wperror != 0){ while(1); }
    fmc_lock();

    /* 先把 RAM 目标缓冲清零，方便后面比对 */
    memset(g_destbuf, 0, TRANSFER_NUM);

    /* ---- 第 3 步：配置并启动 DMA，把 Flash 搬到 RAM ---- */
    dma_deinit(DMA0, DMA_CH0);
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;  /* 方向：外设(Flash)→内存(RAM) */
    dma_init_struct.memory_addr  = (uint32_t)g_destbuf;       /* 目标：RAM 数组 */
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;/* 目标地址自增 */
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;     /* 每次搬 8 位 */
    dma_init_struct.number       = TRANSFER_NUM;              /* 共搬 1024 次 */
    dma_init_struct.periph_addr  = (uint32_t)BANK0_WRITE_START_ADDR; /* 源：Flash 地址 */
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_ENABLE;/* 源地址自增 */
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; /* 每次搬 8 位 */
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;   /* 最高优先级 */
    dma_init(DMA0, DMA_CH0, &dma_init_struct);

    dma_circulation_disable(DMA0, DMA_CH0);          /* 不循环，只搬一次 */
    dma_memory_to_memory_enable(DMA0, DMA_CH0);      /* 开启内存到内存模式（仅 DMA0 支持） */
    dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);/* 搬运完成(FTF)时进中断 */
    dma_channel_enable(DMA0, DMA_CH0);               /* 启动！DMA 开始自动搬运 */

    /* 主循环在此等待 DMA 完成中断置位标志（CPU 此时是"被通知"而非死等外设） */
    while(0 == g_dmacomplete_flag);

    /* ---- 第 4 步：比对搬运结果 ---- */
    ptrd = (uint32_t *)g_destbuf;
    count = TRANSFER_NUM / sizeof(*ptrd);
    for(i = 0; i < count; i++){
        if(transdata != *ptrd){
            access_flag = ERROR;
            break;
        }
        ptrd++;
    }

    /* 搬运成功 → 4 颗 LED 全亮；失败 → 只亮 LED2、LED4 */
    if(access_flag != ERROR){
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
        gd_eval_led_on(LED4);
        gd_eval_led_on(LED5);
    } else {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
    }

    while(1);
}

/* LED 初始化 */
void led_config(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_init(LED5);
}

/* 开 DMA0 时钟 */
void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_DMA0);
}

/* 使能 DMA0 通道0 中断 */
void nvic_config(void)
{
    nvic_irq_enable(DMA0_Channel0_IRQn, 0, 0);
}

gd32f30x_it.c 中的 DMA 完成中断（搬运结束后自动调用）：

void DMA0_Channel0_IRQHandler(void)
{
    if(dma_interrupt_flag_get(DMA0, DMA_CH0, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF);  /* 清中断标志 */
        g_dmacomplete_flag = 1;   /* 通知主循环：搬运完成！ */
    }
}

代码分段讲解

1. Flash 操作：先擦、再写、再读

DMA 之前那一长串其实是"给 DMA 准备数据源"：

fmc_unlock();                       // 写 Flash 前必须解锁
fmc_page_erase(0x08004000 + i*0x800);  // 按页擦除（2048 字节/页）
...
fmc_word_program(address, 0x3210ABCD); // 每 4 字节写固定值
fmc_lock();                         // 写完上锁

TRANSFER_NUM = 0x400 = 1024 字节，每页 0x800 = 2048 字节，所以 count = 0，for(i=0; i<=0; i++) 实际擦了 2 页（i=0 和 i=1，地址 0x08004000 与 0x08004800），足够覆盖 1024 字节。
擦除后先校验是否全 0xFFFFFFFF，写之前再校验，是为了提前发现 Flash 操作异常，避免"脏数据"被 DMA 搬走。

这一部分本质就是 FMC（Flash 控制器）的用法，详见同模块的 Erase_Program 例程。本例的重点始终是 DMA，Flash 只是"造数据"。

2. DMA 配置：告诉它"从哪搬、搬到哪、搬多少"

这是全例的灵魂，对应 dma_init_struct 的字段：

字段	取值	含义
`direction`	`DMA_PERIPHERAL_TO_MEMORY`	源是"外设侧"，目标是"内存侧"（内存到内存也用这个枚举）
`periph_addr`	`0x08004000`	源地址 = Flash 起始
`periph_inc`	`ENABLE`	搬完一个字节，源地址 +1
`periph_width`	`8BIT`	每次搬 1 字节
`memory_addr`	`g_destbuf`	目标地址 = RAM 数组
`memory_inc`	`ENABLE`	搬完一个字节，目标地址 +1
`memory_width`	`8BIT`	每次搬 1 字节
`number`	`0x400`	一共搬 1024 次（共 1024 字节）
`priority`	`ULTRA_HIGH`	总线仲裁优先级最高

number 的"单位"容易踩坑：它是"传输次数"，每次搬运的字节数由 width 决定。这里 width=8bit、number=1024，所以总共搬 1024 字节。若 width 改成 32bit，则 1024 次会搬 4096 字节——要和你的缓冲区大小匹配。

3. 三种关键"开关"

1
2
3

dma_circulation_disable(DMA0, DMA_CH0);       // 普通模式：搬完一次就停
dma_memory_to_memory_enable(DMA0, DMA_CH0);   // 内存到内存模式（仅 DMA0 支持！）
dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);  // 搬完触发"全传输完成"中断

循环模式关：本例只搬一次。若开循环（如 ADC 连续采样），搬完会自动从头再来。
内存到内存开：Flash→RAM 本质是"内存到内存"。注意这是 DMA0 的专属能力，DMA1 不支持。
FTF 中断开：搬完 1024 字节后硬件自动进 DMA0_Channel0_IRQHandler。

4. 启动与"等通知"

1
2

dma_channel_enable(DMA0, DMA_CH0);   // 发令枪：DMA 开始自动搬运
while(0 == g_dmacomplete_flag);      // 等中断把标志置 1

DMA 一旦使能，硬件就在后台把 Flash 的 1024 字节逐字节搬进 g_destbuf，CPU 不用参与搬运。主循环这句 while(0 == g_dmacomplete_flag) 看起来像"死等"，但和"CPU 一个个字节轮询读 Flash"不同——这里是等中断通知，DMA 在搬的时候 CPU 本可以去干别的事（本例只是简单等待）。

5. 完成中断里做了什么？

void DMA0_Channel0_IRQHandler(void) {
    dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF); // 必须清中断标志
    g_dmacomplete_flag = 1;
}

进中断第一件事清标志，否则会反复进中断。
置 g_dmacomplete_flag = 1，主循环随即跳出 while，进入最后的"比对"环节。

6. 结果比对与 LED 指示

`1`	`if(transdata != *ptrd) access_flag = ERROR; // 任一字不等于 0x3210ABCD 即判失败`

成功：4 颗 LED 全亮。
失败：只亮 LED2 + LED4（方便肉眼区分）。

实验现象

下载程序并复位后，DMA 自动把 Flash 内容搬到 RAM。
搬运成功（绝大多数情况）：LED2、LED3、LED4、LED5 全部常亮。
若失败（如 Flash 地址被程序占用、擦写异常）：仅 LED2、LED4 亮起。
用调试器查看：g_destbuf[0..1023] 全部为 0xCD 0xAB 0x10 0x32（小端，对应 0x3210ABCD）；0x08004000 处 Flash 内容与之一致。

常见问题

Q1：为什么我的板子烧进去后不亮灯 / 程序跑飞？
最可能是 0x08004000 这个 Flash 地址落在了你的代码区。擦写代码所在页会破坏正在运行的程序。请改 BANK0_WRITE_START_ADDR 到程序之后的空闲页（可用链接脚本/map 文件确认空闲区），或确认评估板例程默认该地址空闲。

Q2：DMA_PERIPHERAL_TO_MEMORY 方向用在 Flash→RAM，名字是不是搞反了？
没有反。GD32 的 DMA 结构体里"peripheral"侧和"memory"侧是逻辑角色：这里把 Flash 当作"源（peripheral 侧）"、RAM 数组当"目标（memory 侧）"，所以方向是 peripheral→memory。内存到内存搬运也复用这个枚举，关键是 dma_memory_to_memory_enable 开了。理解"谁源谁目标"即可，名字不必纠结。

Q3：内存到内存模式为什么只能用 DMA0？
这是 GD32 硬件设计限制：内存到内存的传输请求只能由 DMA0 产生。若你用 DMA1 开 dma_memory_to_memory_enable 是不会工作的。

Q4：想搬 32 位数据（比如整型数组）怎么改？
把 periph_width / memory_width 都改成 DMA_xxx_WIDTH_32BIT，同时 number 相应减半（字节数 / 4）。注意源/目标地址都要 4 字节对齐，否则可能出错。

Q5：搬运过程中 CPU 真的空闲吗？while(0==flag) 不是占着 CPU 吗？
DMA 搬运本身不占 CPU，全是硬件在做。本例主循环只是"等通知"，没干别的；真实项目里你可以把这段等待换成"去做其他任务 / 进低功耗"，等中断来了再回来处理数据，这正是 DMA 的价值。

Q6：和直接 memcpy 有什么区别？
memcpy 是 CPU 一条条指令搬，占满 CPU；DMA 是独立硬件搬，CPU 可并行。数据量越大、越频繁，DMA 优势越明显（如音频流、LCD 刷屏、ADC 连续采样）。

小结

本示例把 DMA 的"三要素 + 启动 + 中断"主线讲透：

准备数据：先用 FMC 擦除并编程 Flash，造出可被搬运的固定内容（重点在 DMA，Flash 只是数据源）。
开时钟 + 配中断：RCU_DMA0 + nvic_irq_enable(DMA0_Channel0_IRQn)。
填 DMA 三要素：源地址（Flash）、目标地址（RAM）、次数/宽度/自增。
开开关：关循环、开内存到内存、开 FTF 中断。
启动 + 等通知：dma_channel_enable 后靠中断置标志，主循环解除等待。
校验结果：比对 RAM 内容，用 LED 给出成功/失败指示。

记住 DMA = 不占 CPU 的搬运工，凡是"大块数据搬来搬去"的地方，都该想到它。

拓展应用

掌握基础 DMA 后，可以把它用到大量"数据搬运"场景：

RAM → USART（串口）：同目录 Ram_to_usart 例程，把发送数组交给 DMA 自动发出，CPU 不用死等 TBE。适合长文本/日志输出。
ADC → RAM（连续采样）：开启 ADC 的 DMA 请求 + 循环模式，ADC 每转换完一个点 DMA 自动搬进数组，实现"无 CPU 干预"的高速采样（如示波器、音频采集）。
内存 → SPI（刷屏）：驱动 SPI LCD 时，把显存数组用 DMA 发往 SPI，刷屏不再卡 CPU。
双缓冲（Ping-Pong）：配合半传输(HTF) + 全传输(FTF)中断，一块在 DMA 搬、一块 CPU 处理，实现流水线式数据流（音频、图像）。
与大数组拷贝结合：任何 for 循环批量拷贝，都可考虑用 DMA0 内存到内存替代以释放 CPU。

想把 DMA 接到"真外设"上，建议直接看同目录 Ram_to_usart，体会"内存 → 外设"方向和"减轻串口发送负担"的效果。

GD32 DMA — RAM → RAM

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

DMA — RAM → RAM

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

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

#include "gd32f30x.h" 
#include "gd32f307c_eval.h"
#include <string.h>
#define DATANUM                  16
__IO ErrStatus transferflag1 = ERROR;
__IO ErrStatus transferflag2 = ERROR;
__IO ErrStatus transferflag3 = ERROR;
__IO ErrStatus transferflag4 = ERROR;

void destbuf_init(void);
void led_config(void);
ErrStatus uc_data_compare(uint8_t* src, uint8_t* dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    int i = 0;
    dma_parameter_struct dma_init_struct;
    
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* initialize LED */
    led_config();
    /* all LED off */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    
    destbuf_init();
    /* initialize DMA channel1 */
    dma_deinit(DMA0, DMA_CH1);
    
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)destination_address1;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = DATANUM;
    dma_init_struct.periph_addr = (uint32_t)source_address;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_ENABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_enable(DMA0, DMA_CH1);
        
    /* initialize DMA channel2 */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.memory_addr = (uint32_t)destination_address2;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_enable(DMA0, DMA_CH2);
        
    /* initialize DMA channel3 */
    dma_deinit(DMA0, DMA_CH3);
    dma_init_struct.memory_addr = (uint32_t)destination_address3;
    dma_init(DMA0, DMA_CH3, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH3);
    dma_memory_to_memory_enable(DMA0, DMA_CH3);
        
    /* initialize DMA channel4 */
    dma_deinit(DMA0, DMA_CH4);
    dma_init_struct.memory_addr = (uint32_t)destination_address4;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH4);
    dma_memory_to_memory_enable(DMA0, DMA_CH4);

    /* enable DMA channel1~channel4 */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA0, DMA_CH3);
    dma_channel_enable(DMA0, DMA_CH4);

    /* wait for DMA transfer complete */
    for(i = 0; i < 200; i++);
    /* compare the data of source_address with data of destination_address */
    transferflag1 = uc_data_compare(source_address, destination_address1, DATANUM);
    transferflag2 = uc_data_compare(source_address, destination_address2, DATANUM);
    transferflag3 = uc_data_compare(source_address, destination_address3, DATANUM);
    transferflag4 = uc_data_compare(source_address, destination_address4, DATANUM);

    /* if DMA channel1 transfer success,light LED2 */
    if(SUCCESS == transferflag1){
        gd_eval_led_on(LED2);
    }
    /* if DMA channel2 transfer success,light LED3 */
    if(SUCCESS == transferflag2){
        gd_eval_led_on(LED3);
    }
    /* if DMA channel3 transfer success,light LED4 */
    if(SUCCESS == transferflag3){
        gd_eval_led_on(LED4);
    }
    /* if DMA channel4 transfer success,light LED5 */
    if(SUCCESS == transferflag4){
        gd_eval_led_on(LED5);
    }
    
    while (1);
}

void destbuf_init(void)
{
    memset(destination_address1, 0, DATANUM);
    memset(destination_address2, 0, DATANUM);
    memset(destination_address3, 0, DATANUM);
    memset(destination_address4, 0, DATANUM);
}

void led_config(void)
{
    gd_eval_led_init (LED2);
    gd_eval_led_init (LED3);
    gd_eval_led_init (LED4);
    gd_eval_led_init (LED5);
}

代码讲解

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

GD32 DMA — RAM → USART

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

DMA — RAM → USART

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

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

#include "gd32f30x.h" 
#include "gd32f307c_eval.h"
#define USART0_DATA_ADDRESS      ((uint32_t)0x40013804)
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))

void led_config(void);
void nvic_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* USART configure */
    gd_eval_com_init(EVAL_COM0);
    /*configure DMA interrupt*/
    nvic_config();
    /* initialize LED2 */
    led_config();   
    /* turn off LED2 */
    gd_eval_led_off(LED2);
    
    /* initialize DMA channel3 */
    dma_deinit(DMA0, DMA_CH3);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)welcome;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(welcome);
    dma_init_struct.periph_addr = USART0_DATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH3, &dma_init_struct);
    
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH3);
    dma_memory_to_memory_disable(DMA0, DMA_CH3);

    /* USART DMA enable for transmission */
    usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);
    
    /* enable DMA transfer complete interrupt */
    dma_interrupt_enable(DMA0, DMA_CH3, DMA_INT_FTF);
    
    /* enable DMA channel3 */
    dma_channel_enable(DMA0, DMA_CH3);
   
    /* waiting for the transfer to complete*/
    while(RESET == g_transfer_complete);
    
    /* light LED2 */
    gd_eval_led_on(LED2);

    while (1);
}

void led_config(void)
{
    gd_eval_led_init (LED2);
}

void nvic_config(void)
{
    nvic_irq_enable(DMA0_Channel3_IRQn, 0, 0);
}

代码讲解

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

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

PUYA — 直接存储器访问 (DMA)

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

PUYA — 直接存储器访问 (DMA)

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

什么是直接存储器访问 (DMA)?

DMA（直接存储器访问）可以在不占用 CPU 的情况下搬运数据。ADC、SPI、USART 等外设配合 DMA 可以大幅提升效率。

示例列表

DMA_SramToSram — DMA_SramToSram

重点推荐：DMA 内存到内存搬运已整理为完整教学文档，讲解地址自增、数据宽度、中断回调，是理解 ADC/SPI+DMA 的基础。

PUYA — 直接存储器访问 (DMA)

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

PUYA — 直接存储器访问 (DMA)

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

什么是直接存储器访问 (DMA)?

DMA（直接存储器访问）可以在不占用 CPU 的情况下搬运数据。ADC、SPI、USART 等外设配合 DMA 可以大幅提升效率。

示例列表

DMA_SramToSram — DMA_SramToSram

PUYA DMA — DMA_SramToSram

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

DMA — DMA_SramToSram

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/DMA/DMA_SramToSram/Src/main.c

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

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

代码讲解

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

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（LL 库）

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

DMA — 内存到内存搬运（SRAM → SRAM）（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/DMA/DMA_SramToSram/Src/main.c

功能简介

本示例演示 DMA 最基础的能力：内存到内存（M2M）搬运。程序在源缓冲区填入 0~31 共 32 个字，然后让 DMA 控制器在后台把它们整批复制到目的缓冲区，期间 CPU 完全空闲。传输完成后在中断里校验数据是否一致：一致则点亮 LED，不一致/出错则 LED 闪烁。

与 HAL 版（HAL_DMA_Start_IT() + HAL_DMA_XferCpltCallback）相比，LL 版让你自己填 LL_DMA_InitTypeDef 并调用 LL_DMA_Init()，再显式使能 TC/TE 中断、配置 NVIC。每一步都对应一个 DMA 寄存器字段，适合想“看清 DMA 怎么配”的读者。

硬件准备

PY32F030 开发板
板载绿 LED（用于指示传输结果）
纯软件示例，无需外部连线

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define BUFFER_SIZE 32

uint32_t aSRC_Const_Buffer[BUFFER_SIZE];   /* 源缓冲 */
uint32_t aDST_Buffer[BUFFER_SIZE];         /* 目的缓冲 */
__IO uint32_t transferCompleteDetected = 0;
__IO uint32_t transferErrorDetected    = 0;
__IO uint32_t transferFailedDetected   = 0;

static void APP_DmaConfig(void);
static void APP_SystemClockConfig(void);

int main(void)
{
  APP_SystemClockConfig();
  BSP_LED_Init(LED_GREEN);

  /* 源缓冲填入 0..31 */
  for (uint8_t i = 0; i < BUFFER_SIZE; i++)
    aSRC_Const_Buffer[i] = i;

  APP_DmaConfig();     /* 配置并启动 DMA */

  while (1)
  {
    if (transferFailedDetected == 1 && transferCompleteDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); LL_mDelay(500); }  /* 数据错误 */
    }
    if (transferFailedDetected == 0 && transferCompleteDetected == 1)
    {
      BSP_LED_On(LED_GREEN);     /* 数据正确 */
      while (1) {}
    }
    if (transferErrorDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); LL_mDelay(500); }  /* 传输错误 */
    }
  }
}

/**
  * @brief  DMA 配置：M2M，32 位，地址自增，普通模式
  */
static void APP_DmaConfig(void)
{
  LL_DMA_InitTypeDef dma_initstruct = {0};

  LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1);   /* 开 DMA1 时钟 */

  dma_initstruct.PeriphOrM2MSrcAddress  = (uint32_t)&aSRC_Const_Buffer;  /* 源地址 */
  dma_initstruct.MemoryOrM2MDstAddress  = (uint32_t)&aDST_Buffer;        /* 目的地址 */
  dma_initstruct.Direction              = LL_DMA_DIRECTION_MEMORY_TO_MEMORY; /* M2M */
  dma_initstruct.Mode                   = LL_DMA_MODE_NORMAL;     /* 普通模式(非循环) */
  dma_initstruct.PeriphOrM2MSrcIncMode  = LL_DMA_PERIPH_INCREMENT;/* 源地址自增 */
  dma_initstruct.MemoryOrM2MDstIncMode  = LL_DMA_MEMORY_INCREMENT;/* 目的地址自增 */
  dma_initstruct.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD; /* 32 位 */
  dma_initstruct.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD; /* 32 位 */
  dma_initstruct.NbData                 = BUFFER_SIZE;
  dma_initstruct.Priority               = LL_DMA_PRIORITY_HIGH;
  if (LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &dma_initstruct) != SUCCESS)
    APP_ErrorHandler();

  /* 使能传输完成 / 传输错误中断，并配置 NVIC */
  LL_DMA_EnableIT_TC(DMA1, LL_DMA_CHANNEL_1);
  LL_DMA_EnableIT_TE(DMA1, LL_DMA_CHANNEL_1);
  NVIC_SetPriority(DMA1_Channel1_IRQn, 0);
  NVIC_EnableIRQ(DMA1_Channel1_IRQn);

  LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);   /* 启动通道 */
}

/* 以下回调在 DMA1_Channel1_IRQHandler 中被调用 */
void APP_TransferCompleteCallback(void)
{
  /* 校验目的缓冲是否等于源缓冲 */
  for (uint16_t i = 0; i < BUFFER_SIZE; i++)
  {
    if (aDST_Buffer[i] != aSRC_Const_Buffer[i])
    {
      transferFailedDetected = 1;
      break;
    }
  }
  transferCompleteDetected = 1;
}
void APP_TransferErrorCallback(void)
{
  transferErrorDetected = 1;
}

/* APP_SystemClockConfig / APP_ErrorHandler 略 */

代码分段讲解

1. 开 DMA 时钟

DMA 挂在 AHB1 上，要用 LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1) 开时钟。漏掉这步 DMA 不工作——和所有外设一样，LL 不会自动帮你开。

2. 配置结构体：每个字段一个寄存器位

LL_DMA_InitTypeDef 的字段几乎与 DMA 通道配置寄存器一一对应：

Direction = MEMORY_TO_MEMORY：内存到内存（需硬件支持 M2M 的通道）。
PeriphOrM2MSrcIncMode / MemoryOrM2MDstIncMode：源/目的地址是否自增（默认外设不自增、内存自增，M2M 下两者都自增）。
PeriphOrM2MSrcDataSize / MemoryOrM2MDstDataSize：数据宽度，这里 32 位（WORD）。
Mode = NORMAL：传完 NbData 个就停（循环模式用 LL_DMA_MODE_CIRCULAR）。
Priority：通道优先级，多通道竞争时生效。

3. 启动：使能中断 + 使能通道

HAL 里 HAL_DMA_Start_IT() 一句把“填寄存器 + 使能中断 + 使能通道”全做了；LL 里你要：先 LL_DMA_Init() 写配置，再 LL_DMA_EnableIT_TC/TE() 开中断，配 NVIC，最后 LL_DMA_EnableChannel() 真正启动。顺序很重要——先配好再使能。

4. 完成回调里校验

传输完成进 APP_TransferCompleteCallback()，这里逐字比对源/目的缓冲。注意：DMA 只是“搬数据”，不会告诉你数据对不对，校验逻辑得你自己写（HAL 同样要你自己在 XferCpltCallback 里校验）。

实验现象

下载运行后，DMA 自动把 32 个字从源搬到目的。
校验一致 → 板载绿 LED 常亮。
若把源缓冲改成随机/未初始化，或人为制造不匹配 → LED 闪烁（数据错误分支）。

常见问题

DMA 完全没动作 / LED 不亮？
- 确认 LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1) 已调用。
- 确认 LL_DMA_EnableChannel() 在配置和中断使能之后调用。
- M2M 搬运需要 DMA 支持内存到内存（PY32F0 的 DMA1 支持）。
中断没进？
- 检查 NVIC_EnableIRQ(DMA1_Channel1_IRQn) 是否配置；确认中断服务程序里调用了 APP_TransferCompleteCallback()。
想连续搬运（如 ADC+DMA 循环采样）？
- 把 Mode 改为 LL_DMA_MODE_CIRCULAR，并去掉 NbData 完成后停止的逻辑。

小结

LL 的 DMA = 开时钟 → 填 LL_DMA_InitTypeDef → LL_DMA_Init → 使能中断 → 使能通道。
相比 HAL 的 HAL_DMA_Start_IT，LL 让你精确控制每个寄存器字段和启动顺序。
DMA 只负责“搬”，数据正确性要靠自己在完成回调里校验。

拓展应用

改成 LL_DMA_MODE_CIRCULAR 做 ADC 连续采样（参考 ADC_MultiChannelSingleConversion_TriggerSW_DMA）。
外设到内存：把源地址换成 &ADC1->DR、方向设为 PERIPH_TO_MEMORY，实现“ADC 自动存数组”。
内存到外设：把目的地址换成 &USARTx->DR，用 DMA 自动发串口大数据块。
多通道搬运时用不同 LL_DMA_CHANNEL_x 并分别配 NVIC 优先级。

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

AT32 I2C — 读写 EEPROM（最常用的 I2C 从设备）

Tue, 08 Sep 2026 15:03:00 +0800

I2C — 读写 EEPROM

难度: ⭐⭐（需要了解 I2C 基本概念）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/i2c/eeprom/src/main.c

这个实验是干嘛的？

EEPROM（Electrically Erasable Programmable Read-Only Memory）是一种掉电不丢失的存储芯片。它不像 Flash 那样需要擦除整块扇区，可以逐字节读写，非常适合存储配置参数、校准数据、用户设置等小量关键数据。

AT24C02 是最经典的 EEPROM 芯片，容量 256 字节，I2C 接口，只要 2 根线就能通信。

本实验做的事情：

准备 3 组不同的测试数据
分别用轮询、中断、DMA 三种方式写入 EEPROM
读回数据并比对
三种方式都成功 → LED 亮

硬件准备

你需要一个 AT24C02 EEPROM 模块（淘宝 2~3 块）：

开发板            AT24C02 模块
  PB10 (SCL) ──→  SCL
  PB11 (SDA) ←──→ SDA
  3.3V       ──→  VCC
  GND        ──→  GND

重要：

I2C 总线需要上拉电阻（一般 4.7KΩ）
大多数模块已经焊好了上拉电阻，不用你加
如果自己搭电路，SCL 和 SDA 各接一个 4.7K 上拉到 VCC

I2C 基础知识

I2C 只需要 2 根线就能连接多个设备：

信号	全称	说明
SCL	Serial Clock	时钟信号，主机产生
SDA	Serial Data	数据信号，双向

I2C 的核心概念

1. 主从模式

主机（Master）：发起通信，产生时钟
从机（Slave）：被动响应，每个从机有唯一地址

2. 7 位地址

每个 I2C 设备有一个 7 位地址（如 AT24C02 的地址是 0x50）
一根总线上可以挂多个设备，靠地址区分

3. 读写操作

写操作：主机发送 [从机地址+W] + [数据]
读操作：主机发送 [从机地址+R]，然后从机返回数据

I2C vs SPI 对比

特性	I2C	SPI
线数	2 根（SCL+SDA）	4 根（SCK+MOSI+MISO+CS）
速度	100K/400K/1M	几十 MHz
多设备	地址区分，同一总线挂多个	每个设备一根 CS 线
全双工	否（半双工）	是
适用场景	低速传感器、EEPROM	高速 Flash、LCD

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "eeprom.h"

/* ===== I2C 配置参数 ===== */
#define I2C_TIMEOUT    0xFFFFFFFF
#define I2Cx_SPEED     100000       // 100KHz 标准模式
#define I2Cx_ADDRESS   0xA0         // EEPROM 地址（7位地址左移1位）
#define I2Cx_PORT      I2C2
#define I2Cx_SCL_PIN   GPIO_PINS_10 // PB10 = SCL
#define I2Cx_SDA_PIN   GPIO_PINS_11 // PB11 = SDA
#define BUF_SIZE       12

/* 3 组测试数据 */
uint8_t tx_buf1[BUF_SIZE] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C};
uint8_t tx_buf2[BUF_SIZE] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xA0, 0xB0, 0xC0};
uint8_t tx_buf3[BUF_SIZE] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC};
uint8_t rx_buf1[BUF_SIZE] = {0};
uint8_t rx_buf2[BUF_SIZE] = {0};
uint8_t rx_buf3[BUF_SIZE] = {0};

i2c_handle_type hi2cx;

/* 缓冲区比对 */
uint32_t buffer_compare(uint8_t* buf1, uint8_t* buf2, uint32_t len)
{
  for(uint32_t i = 0; i < len; i++)
  {
    if(buf1[i] != buf2[i]) return 1;
  }
  return 0;
}

/* 错误处理：LED 快闪 */
void error_handler(uint32_t error_code)
{
  while(1)
  {
    at32_led_toggle(LED2);
    delay_ms(500);
  }
}

/* I2C 底层初始化（GPIO + 中断 + DMA） */
void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  /* 使能时钟 */
  crm_periph_clock_enable(CRM_I2C2_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  /* GPIO 配置：开漏输出，复用功能 */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
  gpio_initstructure.gpio_pull = GPIO_PULL_NONE;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

  gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
  gpio_init(GPIOB, &gpio_initstructure);

  gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
  gpio_init(GPIOB, &gpio_initstructure);

  /* 中断配置 */
  nvic_irq_enable(I2C2_EVT_IRQn, 0, 0);
  nvic_irq_enable(I2C2_ERR_IRQn, 0, 0);
  nvic_irq_enable(DMA1_Channel4_IRQn, 0, 0);
  nvic_irq_enable(DMA1_Channel5_IRQn, 0, 0);

  /* DMA 配置 */
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  hi2c->dma_tx_channel = DMA1_CHANNEL4;
  hi2c->dma_rx_channel = DMA1_CHANNEL5;

  /* I2C 初始化：100KHz，7位地址 */
  i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);
  i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
}

int main(void)
{
  i2c_status_type i2c_status;

  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;
  i2c_config(&hi2cx);  // 调用底层初始化

  while(1)
  {
    /* 等待按键按下 */
    while(at32_button_press() != USER_BUTTON) {}

    /* ===== 方式一：轮询模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_POLL, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf1, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);  // EEPROM 写入需要时间
    eeprom_read_buffer(&hi2cx, EE_MODE_POLL, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf1, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* ===== 方式二：中断模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_INT, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf2, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);
    eeprom_read_buffer(&hi2cx, EE_MODE_INT, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf2, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* ===== 方式三：DMA 模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_DMA, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf3, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);
    eeprom_read_buffer(&hi2cx, EE_MODE_DMA, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf3, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* 验证三组数据 */
    if(buffer_compare(tx_buf1, rx_buf1, BUF_SIZE) == 0 &&
       buffer_compare(tx_buf2, rx_buf2, BUF_SIZE) == 0 &&
       buffer_compare(tx_buf3, rx_buf3, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);  // 全部成功
    }
    else
    {
      error_handler(i2c_status);  // 失败，LED 快闪
    }
  }
}

代码分段讲解

1. I2C 地址

`1`	`#define I2Cx_ADDRESS 0xA0`

AT24C02 的 7 位地址是 0x50，左移 1 位变成 0xA0。为什么？

I2C 传输时，地址后面跟一个读写位：

写操作：0x50 << 1 | 0 = 0xA0
读操作：0x50 << 1 | 1 = 0xA1

2. GPIO 配置

`1`	`gpio_initstructure.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;`

I2C 必须用开漏输出！ 为什么？

I2C 总线上有多个设备，任何设备都可以拉低 SDA/SCL
开漏模式：只能拉低，不能主动拉高（靠上拉电阻拉高）
如果用推挽输出，两个设备同时输出不同电平会短路！

3. 三种传输模式

模式	原理	优点	缺点
轮询	CPU 不断检查标志位	简单直接	占用 CPU
中断	传输完成触发中断	CPU 可以做其他事	需要中断服务函数
DMA	DMA 自动搬运数据	CPU 完全不参与	配置复杂

4. 写入后延时

`1`	`delay_ms(1); // EEPROM 写入需要时间`

EEPROM 写入是一个内部编程过程，需要几毫秒。在编程期间，EEPROM 不会应答（NACK），主机必须等待。

实验现象

按下 USER 按键
三种模式依次写入并读回
LED3 亮起 → 三种模式全部成功
LED2 快闪 → 有失败，检查接线

常见问题

Q: I2C 通信超时？

检查上拉电阻（4.7KΩ）
检查地址是否正确（7 位 vs 8 位地址的区别）
检查 SCL/SDA 是否接反

Q: 写入后读出来不对？

EEPROM 写入需要时间，写入后至少等 5ms 再读
检查 EEPROM 地址引脚（A0/A1/A2）是否与代码一致

Q: 7 位地址和 8 位地址的区别？

7 位地址：0x50（芯片手册上的地址）
8 位地址：0xA0（左移 1 位，包含读写位）
不同库函数可能要求不同格式，注意区分

小结

概念	说明
I2C	2 线制低速通信总线
EEPROM	掉电不丢失，逐字节读写
开漏输出	I2C 必须用，避免短路
上拉电阻	4.7KΩ，必须有
7 位地址	芯片手册上的地址
写入延时	EEPROM 编程需要几毫秒

学了 I2C 能做什么？

I2C 是连接"低速外设"的万能总线，几乎所有传感器都支持 I2C：

传感器

项目	原理	难度
温湿度检测	SHT30/DHT20 + I2C → 温湿度数据	⭐⭐
气压检测	BMP280 + I2C → 气压/海拔	⭐⭐
光照检测	BH1750 + I2C → 光照强度	⭐
加速度/陀螺仪	MPU6050 + I2C → 6 轴姿态	⭐⭐⭐
RTC 时钟	DS3231 + I2C → 精确时间	⭐⭐
磁场检测	QMC5883L + I2C → 电子罗盘	⭐⭐⭐
触摸检测	TTP223 电容触摸 + I2C	⭐⭐

存储与显示

项目	原理	难度
配置参数存储	AT24C02 + I2C → 存校准数据	⭐
OLED 显示	SSD1306 + I2C → 0.96 寸 OLED	⭐⭐
LCD 显示	I2C 接口的字符 LCD	⭐⭐

实际应用场景

气象站：I2C 温湿度 + 气压 + 光照 → 环境监测
平衡车：I2C MPU6050 → 姿态检测 + PID 控制
智能手表：I2C 心率 + 加速度 + RTC → 健康监测
工业仪表：I2C ADC（ADS1115）→ 高精度电压测量

核心思路：I2C 的核心优势是省线。2 根线就能挂 128 个设备。传感器、EEPROM、RTC、OLED……几乎所有低速外设都用 I2C。掌握了 I2C，你就有了连接整个传感器世界的能力。

下一步：学会了 I2C，可以学 TIM PWM 输出，用定时器生成 PWM 信号控制 LED 亮度、电机转速。

AT32 DMA — Flash 到 SRAM 数据搬运（CPU 完全不参与）

Tue, 08 Sep 2026 15:11:00 +0800

DMA — Flash 到 SRAM 数据搬运

难度: ⭐⭐（理解 DMA 概念即可）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/dma/flash_to_sram/src/main.c

这个实验是干嘛的？

DMA（Direct Memory Access，直接存储器访问）是 MCU 里最强大的"搬运工"。

没有 DMA 时：CPU 自己一个字节一个字节地从 Flash 复制到 SRAM，复制 128 字节就要执行 128 次循环，CPU 什么都干不了。

有了 DMA 时：你告诉 DMA “把这块数据从这里搬到那里”，DMA 硬件自动完成，CPU 空闲了。搬运完成后 DMA 发一个中断通知 CPU。

本实验用 DMA 的内存到内存模式，把 Flash 中的 32 个 32 位数据搬到 SRAM，搬运完成后触发中断，然后比对数据。

硬件准备

不需要任何外部硬件！ 这是纯内部操作，Flash → SRAM。

DMA 核心概念

DMA 的三种搬运方向

方向	说明	典型用途
外设→内存	从外设读数据存到内存	ADC 采样、串口接收
内存→外设	从内存取数据发到外设	串口发送、DAC 输出
内存→内存	内存之间复制数据	数据搬运、缓冲区拷贝

DMA 的关键参数

参数	含义
源地址	数据从哪来
目标地址	数据搬到哪去
数据宽度	每次搬运多少字节（字节/半字/字）
地址递增	搬完一个后地址是否 +1
传输数量	总共搬多少个
循环模式	搬完后是否自动重新开始

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

#define BUFFER_SIZE  32

/* 源数据：存在 Flash 中（const 修饰） */
const uint32_t src_const_buffer[BUFFER_SIZE] = {
  0x01020304, 0x05060708, 0x090A0B0C, 0x0D0E0F10,
  0x11121314, 0x15161718, 0x191A1B1C, 0x1D1E1F20,
  0x21222324, 0x25262728, 0x292A2B2C, 0x2D2E2F30,
  0x31323334, 0x35363738, 0x393A3B3C, 0x3D3E3F40,
  0x41424344, 0x45464748, 0x494A4B4C, 0x4D4E4F50,
  0x51525354, 0x55565758, 0x595A5B5C, 0x5D5E5F60,
  0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70,
  0x71727374, 0x75767778, 0x797A7B7C, 0x7D7E7F80
};

/* 目标缓冲区：存在 SRAM 中 */
uint32_t dst_buffer[BUFFER_SIZE];

dma_init_type dma_init_struct = {0};
__IO uint32_t data_counter_end = 0x01;  // 初始值不能为 0！
error_status transfer_status = ERROR;

/* DMA 中断服务函数 */
void DMA1_Channel1_IRQHandler(void)
{
  if(dma_interrupt_flag_get(DMA1_FDT1_FLAG) != RESET)
  {
    data_counter_end = 0;  // 标记搬运完成
    dma_flag_clear(DMA1_FDT1_FLAG);  // 必须清标志位！
  }
}

/* 缓冲区比对 */
error_status buffer_compare(const uint32_t* p1, const uint32_t* p2, uint16_t len)
{
  while(len--)
  {
    if(*p1 != *p2) return ERROR;
    p1++;
    p2++;
  }
  return SUCCESS;
}

int main(void)
{
  system_clock_config();
  at32_board_init();

  /* 第一步：使能 DMA1 时钟 */
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);

  /* 第二步：配置 DMA1 通道 1 */
  dma_reset(DMA1_CHANNEL1);

  dma_init_struct.direction = DMA_DIR_MEMORY_TO_MEMORY;  // 内存到内存
  dma_init_struct.peripheral_base_addr = (uint32_t)src_const_buffer;  // 源地址（Flash）
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_WORD;  // 32 位
  dma_init_struct.peripheral_inc_enable = TRUE;  // 源地址递增

  dma_init_struct.memory_base_addr = (uint32_t)dst_buffer;  // 目标地址（SRAM）
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_WORD;  // 32 位
  dma_init_struct.memory_inc_enable = TRUE;  // 目标地址递增

  dma_init_struct.buffer_size = BUFFER_SIZE;  // 搬 32 个
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;  // 单次搬运

  dma_init(DMA1_CHANNEL1, &dma_init_struct);

  /* 第三步：使能传输完成中断 */
  dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);

  /* 第四步：配置 NVIC 中断优先级 */
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  nvic_irq_enable(DMA1_Channel1_IRQn, 1, 0);

  /* 第五步：启动 DMA */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);

  /* 等待 DMA 搬运完成（中断会把 data_counter_end 清零） */
  while(data_counter_end != 0) {}

  /* 第六步：比对数据 */
  transfer_status = buffer_compare(src_const_buffer, dst_buffer, BUFFER_SIZE);

  if(transfer_status == SUCCESS)
  {
    at32_led_on(LED2);
    at32_led_on(LED3);
    at32_led_on(LED4);  // 3 个 LED 全亮 = 成功
  }

  while(1) {}
}

代码分段讲解

1. 源数据和目标缓冲区

1
2

const uint32_t src_const_buffer[BUFFER_SIZE] = { ... };  // Flash 中
uint32_t dst_buffer[BUFFER_SIZE];                         // SRAM 中

const 修饰 → 编译器把它放在 Flash 中（只读）
没有 const → 放在 SRAM 中（可读写）
DMA 就是从 Flash 的地址搬到 SRAM 的地址

2. DMA 方向

`1`	`dma_init_struct.direction = DMA_DIR_MEMORY_TO_MEMORY;`

本实验是内存到内存模式。ADC+DMA 那个实验用的是外设到内存。

3. 地址递增

1
2

dma_init_struct.peripheral_inc_enable = TRUE;  // 源地址递增
dma_init_struct.memory_inc_enable = TRUE;       // 目标地址递增

两个都要递增！因为我们要搬 32 个数据：

第 1 个：从 src[0] 搬到 dst[0]
第 2 个：从 src[1] 搬到 dst[1]
…
第 32 个：从 src[31] 搬到 dst[31]

如果地址不递增，就会一直搬同一个位置的数据。

4. 中断通知

`1`	`dma_interrupt_enable(DMA1_CHANNEL1, DMA_FDT_INT, TRUE);`

FDT = Full Data Transfer，全部数据传输完成。

中断服务函数中：

1
2

data_counter_end = 0;  // 标记完成
dma_flag_clear(DMA1_FDT1_FLAG);  // 必须清标志位！不清会反复进中断

5. 等待完成

`1`	`while(data_counter_end != 0) {}`

data_counter_end 初始值设为 1，中断把它清零。主循环在这里等待。

注意：这个变量必须用 volatile 修饰（__IO），否则编译器可能优化掉这个循环。

实验现象

3 个 LED 全部亮起 → DMA 搬运成功，数据一致
LED 不亮 → 数据比对失败（不应该发生）

DMA 传输速度

DMA 搬运 32 个 32 位数据（128 字节）需要多少时间？

DMA 时钟 = 系统时钟（240MHz）
每个字需要 2 个时钟周期（读 + 写）
32 个字 = 64 个时钟周期 = 64 / 240MHz ≈ 267ns

267 纳秒搬完 128 字节！ 如果用 CPU 循环复制，至少需要 100+ 个时钟周期。

常见问题

Q: 数据比对失败？

检查源地址和目标地址是否正确
检查数据宽度是否匹配（本例用 32 位字）
检查 buffer_size 是否正确

Q: 中断不触发？

是否使能了 DMA 中断？
NVIC 是否配置了优先级？
中断标志是否清除？

Q: 想用循环模式？

loop_mode_enable = TRUE：搬完后自动重新开始
适合 ADC 连续采样：DMA 反复把 ADC 数据搬到缓冲区

小结

概念	说明
DMA	硬件自动搬运数据，不占 CPU
内存到内存	最简单的 DMA 模式
地址递增	搬多个数据时必须使能
FDT 中断	全部搬完后触发
volatile	防止编译器优化掉等待循环

学了 DMA 能做什么？

DMA 是"高性能嵌入式系统"的基石：

数据采集

项目	原理	难度
高速 ADC 采集	定时器触发 ADC + DMA 自动存储	⭐⭐⭐
音频录音	I2S + DMA → 高速音频数据采集	⭐⭐⭐
示波器	ADC + DMA + 双缓冲 → 连续波形采集	⭐⭐⭐⭐
多通道同步采集	多 ADC + DMA → 同时采集多路信号	⭐⭐⭐⭐

数据输出

项目	原理	难度
DMA 波形生成	DMA + DAC → 输出任意波形（正弦、三角）	⭐⭐⭐
LED 灯带驱动	DMA + GPIO 精确时序 → WS2812 驱动	⭐⭐⭐
高速串口发送	DMA + USART → 大数据量快速发送	⭐⭐
LCD 刷屏	DMA + SPI → 高速刷新屏幕	⭐⭐⭐

性能优化

项目	原理	难度
内存拷贝加速	DMA 内存到内存 → 比 CPU 循环快	⭐⭐
双缓冲技术	DMA 搬 A 缓冲时，CPU 处理 B 缓冲	⭐⭐⭐⭐
零拷贝通信	DMA 直接在外设和内存之间搬运，不经过 CPU	⭐⭐⭐⭐

核心思路：DMA 的价值在于解放 CPU。没有 DMA，CPU 要亲自搬运每一个字节，什么都干不了。有了 DMA，CPU 只需要"发号施令"，然后去做更重要的事（计算、控制、通信）。在高速数据采集、音频处理、显示刷新等场景，DMA 是不可或缺的。

下一步：学会了 DMA，可以学 FLASH 读写，了解如何用内部 Flash 存储用户数据。

DMA on CLing

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（HAL 库）

DMA — 内存到内存搬运（SRAM → SRAM）（HAL 库）

功能简介

硬件准备

完整代码

代码分段讲解

1. 地址自增与数据宽度

2. 模式 Normal vs Circular

3. 中断回调

实验现象

常见问题

小结

拓展应用

AT32 — 直接存储器访问 (DMA)

AT32 — 直接存储器访问 (DMA)

什么是 直接存储器访问 (DMA)?

示例列表

AT32 DMA — DMA 灵活输出到 GPIO

DMA — DMA 灵活输出到 GPIO

功能简介

完整代码

代码讲解

AT32 TMR — 定时器 DMA 触发

TMR — 定时器 DMA 触发

功能简介

完整代码

代码讲解

GD32 — 直接存储器访问 (DMA)

GD32 — 直接存储器访问 (DMA)

什么是 DMA？

没有 DMA vs 有 DMA

DMA 的"三要素"

三种传输方向

搬运完成怎么知道？—— 中断

GD32F30x 的 DMA 资源

常用库函数速查

示例列表

学习路径建议

GD32 DMA — Flash → RAM

DMA — Flash → RAM

功能简介

硬件准备

完整代码（带中文注释）

代码分段讲解

1. Flash 操作：先擦、再写、再读

2. DMA 配置：告诉它"从哪搬、搬到哪、搬多少"

3. 三种关键"开关"

4. 启动与"等通知"

5. 完成中断里做了什么？

6. 结果比对与 LED 指示

实验现象

常见问题

小结

拓展应用

GD32 DMA — RAM → RAM

DMA — RAM → RAM

功能简介

完整代码

代码讲解

GD32 DMA — RAM → USART

DMA — RAM → USART

功能简介

完整代码

代码讲解

PUYA — 直接存储器访问 (DMA)

PUYA — 直接存储器访问 (DMA)

什么是 直接存储器访问 (DMA)?

示例列表

PUYA — 直接存储器访问 (DMA)

PUYA — 直接存储器访问 (DMA)

什么是 直接存储器访问 (DMA)?

示例列表

PUYA DMA — DMA_SramToSram

DMA — DMA_SramToSram

功能简介

完整代码

代码讲解

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（LL 库）

DMA — 内存到内存搬运（SRAM → SRAM）（LL 库）

什么是直接存储器访问 (DMA)?

什么是直接存储器访问 (DMA)?

什么是直接存储器访问 (DMA)?