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 设置中断的抢占优先级和子优先级。数字越小优先级越高。

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 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

功能简介

完整代码

代码讲解

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 库）

功能简介

硬件准备

完整代码

代码分段讲解

1. 开 DMA 时钟

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

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

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