学习目标

  1. 理解DMA数据传输过程
  2. 掌握DMA的初始化流程
  3. 理解源和目标的配置
  4. 理解数据传输特点
  5. 能够动态配置源数据

  6. 能够实现DMA中断

    学习内容

    需求

    1. #define ARR_LEN 1024
    2. char src[ARR_LEN] = "hello\0";
    3. char dst[ARR_LEN] = {0};

    将src这个数组的值，赋值到dst这个数组中，不可以采取直接赋值的方式，需要通过DMA将数据进行传递。

    数据交互流程

    image.png

  7. CPU配置好DMA

  8. CPU通知DMA干活
  9. DMA请求源数据
  10. DMA获取源数据
  11. DMA将获取的源数据交给目标

    开发流程

    依赖引入

    添加标准库中的gd32f4xx_dma.c文件

    DMA初始

    ```c /* DMA m2m */ // 时钟 rcu_periph_clock_enable(RCU_DMA1); // 重置dma dma_deinit(DMA1, DMA_CH0);

//////// dma 配置 dma_single_data_parameter_struct dsdps; dma_single_data_para_struct_init(&dsdps); // 方向 dsdps.direction = DMA_MEMORY_TO_MEMORY;
// 内存 dsdps.memory0_addr = (uint32_t)dst; dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 外设 dsdps.periph_addr = (uint32_t)src; dsdps.periph_inc = DMA_PERIPH_INCREASE_ENABLE; // 数据长度 dsdps.number = ARR_LEN; // 数据宽度 dsdps.periph_memory_width = DMA_PERIPH_WIDTH_8BIT; dma_single_data_mode_init(DMA1, DMA_CH0, &dsdps);

  2. 1. 配置时钟
  3. 2. 初始化dma通道
  4. <a name="ZK7mP"></a>
  5. #### DMA传输请求
  6. ```c
  7. dma_channel_enable(DMA1, DMA_CH0);
  8. while(RESET == dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF));
  9. dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);
  • dma_channel_enable： 请求dma数据传输
  • DMA_FLAG_FTF：为传输完成标记

    完整代码

    ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include

    include “main.h”

    include “Usart0.h”

define ARR_LEN 1024

char src[ARR_LEN] = “hello\0”; char dst[ARR_LEN] = {0};

void Usart0_recv(uint8_t* data, uint32_t len) { printf(“recv: %s\r\n”, data);

  1. dma_channel_enable(DMA1, DMA_CH0);
  2. while(RESET == dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF));
  3. dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);
  5. printf("dst: %s\n", dst);

}

static void DMA_config() {

  1. /***************** DMA m2m *******************/
  2. // 时钟
  3. rcu_periph_clock_enable(RCU_DMA1);
  4. // 重置dma
  5. dma_deinit(DMA1, DMA_CH0);
  7. //////// dma 配置
  8. dma_single_data_parameter_struct dsdps;
  9. dma_single_data_para_struct_init(&dsdps);
  10. // 方向
  11. dsdps.direction = DMA_MEMORY_TO_MEMORY;    
  12. // 内存
  13. dsdps.memory0_addr = (uint32_t)dst;
  14. dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  15. // 外设
  16. dsdps.periph_addr = (uint32_t)src;
  17. dsdps.periph_inc = DMA_PERIPH_INCREASE_ENABLE;
  18. // 数据长度
  19. dsdps.number = ARR_LEN;
  20. // 数据宽度
  21. dsdps.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  22. dma_single_data_mode_init(DMA1, DMA_CH0, &dsdps);
  24. //        // 中断配置
  25. //        nvic_irq_enable(DMA1_Channel0_IRQn, 2, 2);
  26. //        // 中断使能
  27. //        dma_interrupt_enable(DMA1, DMA_CH0, DMA_CHXCTL_FTFIE);
  28. //        // 开启DMA通道
  29. // dma_channel_enable(DMA1, DMA_CH0);

}

//void DMA1_Channel0_IRQHandler() { // // 判断中断标记 // if(SET == dma_interrupt_flag_get(DMA1, DMA_CH0, DMA_INT_FLAG_FTF)) { // printf(“dst: %s\n”, dst); // } // // 清理标记位 // dma_interrupt_flag_clear(DMA1, DMA_CH0, DMA_INT_FLAG_FTF); //}

int main(void) { nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2); systick_config(); Usart0_init();

  1. DMA_config();
  3. while(1) {
  5. }

}

  1. <a name="EFWCI"></a>
  2. ### 关心的内容
  3. ```c
  4. uint32_t dmax = DMA1;
  5. uint32_t dmax_rcu = RCU_DMA1;
  6. uint32_t dmax_ch = DMA_CH0;
  8. uint32_t dmax_dirction = DMA_MEMORY_TO_MEMORY;
  10. uint32_t dmax_src = (uint32_t)src;
  11. uint32_t dmax_src_inc = DMA_PERIPH_INCREASE_ENABLE;
  12. uint32_t dmax_src_width = DMA_PERIPH_WIDTH_8BIT;
  13. uint32_t dmax_src_len = ARR_LEN;
  15. uint32_t dmax_dst = (uint32_t)dst;
  16. uint32_t dmax_dst_inc = DMA_MEMORY_INCREASE_ENABLE;
  17. /***************** DMA m2m *******************/
  18. // 时钟
  19. rcu_periph_clock_enable(dmax_rcu);
  20. // 重置dma
  21. dma_deinit(dmax, dmax_ch);
  23. //////// dma 配置
  24. dma_single_data_parameter_struct dsdps;
  25. dma_single_data_para_struct_init(&dsdps);
  26. // 方向
  27. dsdps.direction = dmax_dirction;    
  28. // 内存
  29. dsdps.memory0_addr = dmax_dst;
  30. dsdps.memory_inc = dmax_dst_inc;
  31. // 外设
  32. dsdps.periph_addr = dmax_src;
  33. dsdps.periph_inc = dmax_src_inc;
  34. // 数据长度
  35. dsdps.number = dmax_src_len;
  36. // 数据宽度
  37. dsdps.periph_memory_width = dmax_src_width;
  38. dma_single_data_mode_init(dmax, dmax_ch, &dsdps);
  • 哪个dma：DMA0或者DMA1
  • dma的哪个通道：ch0到ch7
  • 传输方向是什么：内存到内存，内存到外设，外设到内存
  • 源地址是多少？源的数据长度是多少（几个byte）？源的数据宽度是多少（几个bit）？
  • 目标地址是什么？
  • 从源地址向目标地址传输数据时，源地址的指针是否需要增长。
  • 从源地址向目标地址传输数据时，目标地址的指针是否需要增长。

    数据传输理解

    025.png

    源地址和目标地址

    源地址和目标地址都是提前配置好的，当传输时，就会从源地址将数据传递给目标地址。

    自增长

    每传输一个字节数据，地址是否需要增长。这里包含了源地址是否需要增长，也包含了目标地址是否需要增长。

    数据宽度

    数据宽度表示一次传递多上个bit

    数据长度

    传输了多少个数据宽度的数据。

    源的数据未定

    这里主要指的是在配置DMA的源和目标的时候，我们无法给出一个具体的源地址和源的数据长度。
    026.png
    通常我们要解决的也是初始化和数据传输请求。

    DMA初始化

    ```c uint32_t dmax = DMA1; uint32_t dmax_rcu = RCU_DMA1; uint32_t dmax_ch = DMA_CH0;

uint32_t dmax_dirction = DMA_MEMORY_TO_MEMORY;

//uint32_t dmax_src = (uint32_t)src; uint32_t dmax_src_inc = DMA_PERIPH_INCREASE_ENABLE; uint32_t dmax_src_width = DMA_PERIPH_WIDTH_8BIT; //uint32_t dmax_src_len = ARR_LEN;

uint32_t dmax_dst = (uint32_t)dst; uint32_t dmax_dst_inc = DMA_MEMORY_INCREASE_ENABLE; /* DMA m2m */ // 时钟 rcu_periph_clock_enable(dmax_rcu); // 重置dma dma_deinit(dmax, dmax_ch);

//////// dma 配置 dma_single_data_parameter_struct dsdps; dma_single_data_para_struct_init(&dsdps); // 方向 dsdps.direction = dmax_dirction;
// 内存 dsdps.memory0_addr = dmax_dst; dsdps.memory_inc = dmax_dst_inc; // 外设 //dsdps.periph_addr = dmax_src; dsdps.periph_inc = dmax_src_inc; // 数据长度 //dsdps.number = dmax_src_len; // 数据宽度 dsdps.periph_memory_width = dmax_src_width; dma_single_data_mode_init(dmax, dmax_ch, &dsdps);

  1. 初始化时，不再初始化源地址和要传输的长度。
  2. <a name="A9RDs"></a>
  3. #### DMA数据传输请求
  4. ```c
  5. dma_periph_address_config(DMA1, DMA_CH0,(uint32_t)data);
  6. dma_transfer_number_config(DMA1, DMA_CH0, len);
  8. dma_channel_enable(DMA1, DMA_CH0);
  9. while(RESET == dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF));
  10. dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);

请求数据传输前，进行动态配置：

  • 在此需要注意的是，要分清楚当前是否是调用源的地址配置

    完整代码

    ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include

    include “main.h”

    include “Usart0.h”

define ARR_LEN 1024

char dst[ARR_LEN] = {0};

void Usart0_recv(uint8_t* data, uint32_t len) { printf(“recv: %s\r\n”, data);

  1. dma_periph_address_config(DMA1, DMA_CH0,(uint32_t)data);
  2. dma_transfer_number_config(DMA1, DMA_CH0, len);
  4. dma_channel_enable(DMA1, DMA_CH0);
  5. while(RESET == dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF));
  6. dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);
  8. dst[len] = '\0';
  9. printf("dst: %s\n", dst);

}

static void DMA_config() {

  1. uint32_t dmax = DMA1;
  2. uint32_t dmax_rcu = RCU_DMA1;
  3. uint32_t dmax_ch = DMA_CH0;
  5. uint32_t dmax_dirction = DMA_MEMORY_TO_MEMORY;
  7. //uint32_t dmax_src = (uint32_t)src;
  8. uint32_t dmax_src_inc = DMA_PERIPH_INCREASE_ENABLE;
  9. uint32_t dmax_src_width = DMA_PERIPH_WIDTH_8BIT;
  10. //uint32_t dmax_src_len = ARR_LEN;
  12. uint32_t dmax_dst = (uint32_t)dst;
  13. uint32_t dmax_dst_inc = DMA_MEMORY_INCREASE_ENABLE;
  14. /***************** DMA m2m *******************/
  15. // 时钟
  16. rcu_periph_clock_enable(dmax_rcu);
  17. // 重置dma
  18. dma_deinit(dmax, dmax_ch);
  20. //////// dma 配置
  21. dma_single_data_parameter_struct dsdps;
  22. dma_single_data_para_struct_init(&dsdps);
  23. // 方向
  24. dsdps.direction = dmax_dirction;    
  25. // 内存
  26. dsdps.memory0_addr = dmax_dst;
  27. dsdps.memory_inc = dmax_dst_inc;
  28. // 外设
  29. //dsdps.periph_addr = dmax_src;
  30. dsdps.periph_inc = dmax_src_inc;
  31. // 数据长度
  32. //dsdps.number = dmax_src_len;
  33. // 数据宽度
  34. dsdps.periph_memory_width = dmax_src_width;
  35. dma_single_data_mode_init(dmax, dmax_ch, &dsdps);

}

int main(void) { nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2); systick_config(); Usart0_init();

  1. DMA_config();
  3. while(1) {
  5. }

}

  1. <a name="ZBJS5"></a>
  2. ### DMA中断
  3. 通常，dma数据传输完成，我们也是可以知道的。可以通过中断的方式获取。
  4. <a name="KFYdv"></a>
  5. #### 开启中断
  6. ```c
  7. // 中断配置
  8. nvic_irq_enable(DMA1_Channel0_IRQn, 2, 2);
  9. // 中断使能
  10. dma_interrupt_enable(DMA1, DMA_CH0, DMA_CHXCTL_FTFIE);
  11. // 开启DMA通道
  12. dma_channel_enable(DMA1, DMA_CH0);

  • DMA_CHXCTL_FTFIE： 表示中断数据传输完成标记

    中断函数实现

    ```c void DMA1_Channel0_IRQHandler() { // 判断中断标记 if(SET == dma_interrupt_flag_get(DMA1, DMA_CH0, DMA_INT_FLAG_FTF)) {

    1.   printf("INT dst: %s\n", dst);

    } // 清理标记位 dma_interrupt_flag_clear(DMA1, DMA_CH0, DMA_INT_FLAG_FTF); }

  2. - DMA_INT_FLAG_FTF： 表示中断传输完成标记，需要在标记触发时做业务逻辑
  3. - 同时，需要配合寄存器，清除标记
  4. <a name="bo4Fk"></a>
  5. #### 完整代码
  6. ```c
  7. #include "gd32f4xx.h"
  8. #include "systick.h"
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include "main.h"
  12. #include "Usart0.h"
  14. #define ARR_LEN 1024
  15. char src[ARR_LEN] = "hello\0";
  16. char dst[ARR_LEN] = {0};
  19. void Usart0_recv(uint8_t* data, uint32_t len) {
  20.     printf("recv: %s\r\n", data);
  22.     memcpy(src, data, len);
  23.     src[len] = '\0';
  25.     dma_channel_enable(DMA1, DMA_CH0);
  27.     printf("dst: %s\n", dst);
  28. }
  30. static void DMA_config() {
  31.     uint32_t dmax = DMA1;
  32.     uint32_t dmax_rcu = RCU_DMA1;
  33.     uint32_t dmax_ch = DMA_CH0;
  35.     uint32_t dmax_dirction = DMA_MEMORY_TO_MEMORY;
  37.     uint32_t dmax_src = (uint32_t)src;
  38.     uint32_t dmax_src_inc = DMA_PERIPH_INCREASE_ENABLE;
  39.     uint32_t dmax_src_width = DMA_PERIPH_WIDTH_8BIT;
  40.     uint32_t dmax_src_len = ARR_LEN;
  42.     uint32_t dmax_dst = (uint32_t)dst;
  43.     uint32_t dmax_dst_inc = DMA_MEMORY_INCREASE_ENABLE;
  44.     /***************** DMA m2m *******************/
  45.     // 时钟
  46.     rcu_periph_clock_enable(dmax_rcu);
  47.     // 重置dma
  48.     dma_deinit(dmax, dmax_ch);
  50.     //////// dma 配置
  51.     dma_single_data_parameter_struct dsdps;
  52.     dma_single_data_para_struct_init(&dsdps);
  53.     // 方向
  54.     dsdps.direction = dmax_dirction;    
  55.     // 内存
  56.     dsdps.memory0_addr = dmax_dst;
  57.     dsdps.memory_inc = dmax_dst_inc;
  58.     // 外设
  59.     dsdps.periph_addr = dmax_src;
  60.     dsdps.periph_inc = dmax_src_inc;
  61.     // 数据长度
  62.     dsdps.number = dmax_src_len;
  63.     // 数据宽度
  64.     dsdps.periph_memory_width = dmax_src_width;
  65.     dma_single_data_mode_init(dmax, dmax_ch, &dsdps);
  67.     // 配置中断
  68.     nvic_irq_enable(DMA1_Channel0_IRQn, 2, 2);
  69.     dma_interrupt_enable(dmax, dmax_ch, DMA_CHXCTL_FTFIE);
  70. }
  72. void DMA1_Channel0_IRQHandler() {
  73.     // 判断中断标记
  74.     if(SET == dma_interrupt_flag_get(DMA1, DMA_CH0, DMA_INT_FLAG_FTF)) {
  75.         printf("INT dst: %s\n", dst);
  77.     }
  78.     // 清理标记位
  79.     dma_interrupt_flag_clear(DMA1, DMA_CH0, DMA_INT_FLAG_FTF);
  80. }
  83. int main(void)
  84. {
  85.     nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
  86.     systick_config();
  87.     Usart0_init();
  89.     DMA_config();
  91.     while(1) {
  93.     }
  94. }

练习

  1. 实现内存到内存数据传递。