学习目标

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

    学习内容

    需求

    ```c uint8_t data; 串口接收(&data);

data有数据了

  1. 实现串口的数据接收，要求采用dma的方式。
  2. <a name="CZdgS"></a>
  3. ### 数据交互流程
  4. ![image.png](https://cdn.nlark.com/yuque/0/2023/png/27903758/1700722229113-bcfb93d1-e2a9-494a-9b3c-db00ec1be748.png#averageHue=%23fbe2c3&clientId=ucf437be5-16f9-4&from=paste&height=403&id=u33f91ca2&originHeight=504&originWidth=915&originalType=binary&ratio=1.25&rotation=0&showTitle=false&size=32837&status=done&style=none&taskId=u8b430d54-0e2f-4961-928f-d7edf0e7094&title=&width=732)
  6. 1. CPU配置好DMA
  7. 2. 外部数据发送给串口外设
  8. 3. 串口外设触发中断
  9. 4. CPU处理中断逻辑，通知DMA干活
  10. 5. DMA请求源数据
  11. 6. DMA获取源数据
  12. 7. DMA将获取的源数据交给目标
  13. <a name="ayYkU"></a>
  14. ### 开发流程
  15. <a name="Ee1EY"></a>
  16. #### 依赖引入
  17. 添加标准库中的`gd32f4xx_dma.c`文件
  18. <a name="KGhto"></a>
  19. #### DMA初始化
  20. ```c
  21. /**************** DMA p2m *******************/
  22. // 时钟
  23. rcu_periph_clock_enable(RCU_DMA1);
  24. // 重置dma
  25. dma_deinit(DMA1, DMA_CH5);
  27. //////// dma 配置
  28. dma_single_data_parameter_struct dsdps;
  29. dma_single_data_para_struct_init(&dsdps);
  30. // 方向
  31. dsdps.direction = DMA_PERIPH_TO_MEMORY;
  32. // 内存: dst
  33. dsdps.memory0_addr = (uint32_t)(g_recv_buff);
  34. dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  35. // 外设: src
  36. dsdps.periph_addr = (uint32_t)(&USART_DATA(USART0));
  37. dsdps.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  38. // 数据长度
  39. dsdps.number = USART_RECEIVE_LENGTH;
  40. // dst数据宽度
  41. dsdps.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  42. // 传输优先级
  43. dsdps.priority = DMA_PRIORITY_ULTRA_HIGH;
  44. dma_single_data_mode_init(DMA1, DMA_CH5, &dsdps);
  46. //////// 配置 dma 子连接
  47. dma_channel_subperipheral_select(DMA1, DMA_CH5, DMA_SUBPERI4);
  50. // 默认开启接收
  51. dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
  52. dma_channel_enable(DMA1, DMA_CH5);
  1. 配置时钟
  2. 初始化dma通道
  3. 配置dma与外设间的子链接

  4. 开启dma接收功能

    接收中断

    1. if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) {
    2.  //读取缓冲区,清空缓冲区
    3.  usart_data_receive(USART0);
    5.  // 停止DMA传输，防止数据污染
    6.  dma_channel_disable(DMA1, DMA_CH5);
    8.  // 计算接收的数据长度
    9.  g_recv_length = USART_RECEIVE_LENGTH - dma_transfer_number_get(DMA1, DMA_CH5);
    10.  if(g_recv_length) {
    11.      g_recv_buff[g_recv_length] = '\0';
    12.      // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
    13.      printf("rcv: %s\r\n", g_recv_buff);
    14.  }
    16.  g_recv_length = 0;
    17.  dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
    18.  dma_channel_enable(DMA1, DMA_CH5);
    19. }
  • dma_channel_enable： 请求dma数据传输

  • DMA_FLAG_FTF：为传输完成标记

    串口外设DMA开启

    1. // DMA接收功能配置
    2. usart_dma_receive_config(usartx, USART_RECEIVE_DMA_ENABLE);

  • 需要开启dma接收配置，才可以打开dam的功能

    完整代码

    ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include

    include “main.h”

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

static void DMA_tx_config() { uint32_t dmax = DMA1; uint32_t dmax_rcu = RCU_DMA1; uint32_t dmax_ch = DMA_CH7; uint32_t damx_sub = DMA_SUBPERI4;

  1. uint32_t dmax_dirction = DMA_MEMORY_TO_PERIPH;
  3. //    uint32_t dmax_src = (uint32_t)src;
  4. uint32_t dmax_src_inc = DMA_MEMORY_INCREASE_ENABLE;
  5. uint32_t dmax_src_width = DMA_MEMORY_WIDTH_8BIT;
  6. //    uint32_t dmax_src_len = ARR_LEN;
  8. uint32_t dmax_dst = (uint32_t)(&USART_DATA(USART0));
  9. uint32_t dmax_dst_inc = DMA_PERIPH_INCREASE_DISABLE;
  11. /***************** DMA m2p *******************/
  12. // 时钟
  13. rcu_periph_clock_enable(dmax_rcu);
  14. // 重置dma
  15. dma_deinit(dmax, dmax_ch);
  17. //////// dma 配置
  18. dma_single_data_parameter_struct dsdps;
  19. dma_single_data_para_struct_init(&dsdps);
  20. // 方向
  21. dsdps.direction = dmax_dirction;
  22. // 内存: src
  23. //    dsdps.memory0_addr = (uint32_t)src;
  24. dsdps.memory_inc = dmax_src_inc;
  25. // 外设: dst
  26. dsdps.periph_addr = dmax_dst;
  27. dsdps.periph_inc = dmax_dst_inc;
  28. //    // 数据长度
  29. //    dsdps.number = ARR_LEN;
  30. // 数据宽度
  31. dsdps.periph_memory_width = dmax_src_width;
  32. // 传输优先级
  33. dsdps.priority = DMA_PRIORITY_ULTRA_HIGH;
  34. dma_single_data_mode_init(dmax, dmax_ch, &dsdps);
  36. //////// 配置 dma 子连接
  37. dma_channel_subperipheral_select(dmax, dmax_ch, damx_sub);

}

static void dma_send_byte(uint8_t data) { // 数据来源 和 长度 dma_memory_address_config(DMA1, DMA_CH7, DMA_MEMORY_0, (uint32_t)(&data)); dma_transfer_number_config(DMA1, DMA_CH7, 1);

  1. // 触发传输
  2. dma_channel_enable(DMA1, DMA_CH7);
  4. // 等待DMA传输完成
  5. while(RESET == dma_flag_get(DMA1, DMA_CH7, DMA_FLAG_FTF));
  6. // 清理标记
  7. dma_flag_clear(DMA1, DMA_CH7, DMA_FLAG_FTF);

}

static void dma_send(uint8_t* data, uint32_t len) { // 数据来源 和 长度 dma_memory_address_config(DMA1, DMA_CH7, DMA_MEMORY_0, (uint32_t)(&data)); dma_transfer_number_config(DMA1, DMA_CH7, len);

  1. // 触发传输
  2. dma_channel_enable(DMA1, DMA_CH7);
  4. // 等待DMA传输完成
  5. while(RESET == dma_flag_get(DMA1, DMA_CH7, DMA_FLAG_FTF));
  6. // 清理标记
  7. dma_flag_clear(DMA1, DMA_CH7, DMA_FLAG_FTF);

}

static void dma_send_string(const char str) { dma_send((uint8_t)str, strlen(str)); }

static void Usart_config() { // 哪个串口 uint32_t usartx = USART0; uint32_t usartx_rcu = RCU_USART0; uint32_t usartx_irq = USART0_IRQn;

  1. // 波特率
  2. uint32_t usartx_p_baudrate = 115200;
  4. // tx和rx，用了哪个引脚
  5. uint32_t usartx_tx_port_rcu = RCU_GPIOA;
  6. uint32_t usartx_tx_port = GPIOA;
  7. uint32_t usartx_tx_pin = GPIO_PIN_9;
  8. // 复用功能编号
  9. uint32_t usartx_tx_af = GPIO_AF_7;
  11. // tx和rx，用了哪个引脚
  12. uint32_t usartx_rx_port_rcu = RCU_GPIOA;
  13. uint32_t usartx_rx_port = GPIOA;
  14. uint32_t usartx_rx_pin = GPIO_PIN_10;
  15. // 复用功能编号
  16. uint32_t usartx_rx_af = GPIO_AF_7;
  19. /*************** gpio *****************/
  20. // TX
  21. // 配置时钟
  22. rcu_periph_clock_enable(usartx_tx_port_rcu);
  23. // 配置模式: 复用功能
  24. gpio_mode_set(usartx_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_tx_pin);
  25. // 配置复用功能
  26. gpio_af_set(usartx_tx_port, usartx_tx_af, usartx_tx_pin);
  27. gpio_output_options_set(usartx_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_tx_pin);
  29. // RX
  30. // 配置时钟
  31. rcu_periph_clock_enable(usartx_rx_port_rcu);
  32. gpio_mode_set(usartx_rx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_rx_pin);
  33. gpio_af_set(usartx_rx_port, usartx_rx_af, usartx_rx_pin);
  34. // 配置输出参数
  35. gpio_output_options_set(usartx_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_rx_pin);
  37. /*************** usart ****************/
  38. // 串口时钟
  39. rcu_periph_clock_enable(usartx_rcu);
  40. // USART复位
  41. usart_deinit(usartx);
  43. // 波特率
  44. usart_baudrate_set(usartx, usartx_p_baudrate);
  45. // 校验位
  46. usart_parity_config(usartx, USART_PM_NONE);
  47. // 数据位数
  48. usart_word_length_set(usartx, USART_WL_8BIT);
  49. // 停止位
  50. usart_stop_bit_set(usartx, USART_STB_1BIT);
  51. // 先发送高位还是低位
  52. usart_data_first_config(usartx, USART_MSBF_LSB);
  54. // 发送功能配置
  55. usart_transmit_config(usartx, USART_TRANSMIT_ENABLE);
  57. // 接收功能配置
  58. usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  59. // 接收中断配置
  60. nvic_irq_enable(usartx_irq, 2, 2);
  61. usart_interrupt_enable(usartx, USART_INT_RBNE);
  62. usart_interrupt_enable(usartx, USART_INT_IDLE);
  64. // DMA发送功能配置
  65. usart_dma_transmit_config(usartx, USART_TRANSMIT_DMA_ENABLE);
  66. // DMA接收功能配置
  67. usart_dma_receive_config(usartx, USART_RECEIVE_DMA_ENABLE);
  69. // 使能串口
  70. usart_enable(usartx);

}

static void send_byte(uint8_t data) { //通过USART发送 usart_data_transmit(USART0, data);

  1. //判断缓冲区是否已经空了
  2. //FlagStatus state = usart_flag_get(USART_NUM,USART_FLAG_TBE);
  3. while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));

}

static void send_string(char data) { while(data && data) { send_byte((uint8_t)(*data)); data++; } }

int fputc(int ch, FILE *f) { send_byte((uint8_t)ch); return ch; }

define USART_RECEIVE_LENGTH 1024

//串口接收缓冲区大小 uint8_t g_recv_buff[USART_RECEIVE_LENGTH]; // 接收缓冲区 //接收到字符存放的位置 uint32_t g_recv_length = 0;

void USART0_IRQHandler(void) { if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) { //读取缓冲区,清空缓冲区 usart_data_receive(USART0);

  1.     // 停止DMA传输，防止数据污染
  2.     dma_channel_disable(DMA1, DMA_CH5);
  4.     // 计算接收的数据长度
  5.     g_recv_length = USART_RECEIVE_LENGTH - dma_transfer_number_get(DMA1, DMA_CH5);
  6.     if(g_recv_length) {
  7.         g_recv_buff[g_recv_length] = '\0';
  8.         // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
  9.         printf("rcv: %s\r\n", g_recv_buff);
  10.     }
  12.     g_recv_length = 0;
  13.     dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
  14.     dma_channel_enable(DMA1, DMA_CH5);
  15. }

}

static void DMA_rx_config() { /** DMA p2m */ // 时钟 rcu_periph_clock_enable(RCU_DMA1); // 重置dma dma_deinit(DMA1, DMA_CH5);

  1. //////// dma 配置
  2. dma_single_data_parameter_struct dsdps;
  3. dma_single_data_para_struct_init(&dsdps);
  4. // 方向
  5. dsdps.direction = DMA_PERIPH_TO_MEMORY;
  6. // 内存: dst
  7. dsdps.memory0_addr = (uint32_t)(g_recv_buff);
  8. dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  9. // 外设: src
  10. dsdps.periph_addr = (uint32_t)(&USART_DATA(USART0));
  11. dsdps.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  12. // 数据长度
  13. dsdps.number = USART_RECEIVE_LENGTH;
  14. // dst数据宽度
  15. dsdps.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  16. // 传输优先级
  17. dsdps.priority = DMA_PRIORITY_ULTRA_HIGH;
  18. dma_single_data_mode_init(DMA1, DMA_CH5, &dsdps);
  20. //////// 配置 dma 子连接
  21. dma_channel_subperipheral_select(DMA1, DMA_CH5, DMA_SUBPERI4);
  24. // 默认开启接收
  25. dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
  26. dma_channel_enable(DMA1, DMA_CH5);

}

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

  1. DMA_tx_config();
  2. DMA_rx_config();
  4. uint8_t cnt = 0;
  5. while(1) {
  6.     // dma_send_byte(cnt++);
  7.     //printf("hello %d\r\n", cnt++);
  8.     delay_1ms(1000);
  9. }

}

  1. <a name="BZwJW"></a>
  2. ### 关心的内容
  3. ```c
  4. uint32_t dmax = DMA1;
  5. uint32_t dmax_rcu = RCU_DMA1;
  6. uint32_t dmax_ch = DMA_CH5;
  7. uint32_t damx_sub = DMA_SUBPERI4;
  9. uint32_t dmax_dirction = DMA_PERIPH_TO_MEMORY;
  11. uint32_t dmax_src = (uint32_t)(&USART_DATA(USART0));
  12. uint32_t dmax_src_inc = DMA_PERIPH_INCREASE_DISABLE;
  13. uint32_t dmax_src_width = DMA_PERIPH_WIDTH_8BIT;
  14. uint32_t dmax_src_len = USART_RECEIVE_LENGTH;
  16. uint32_t dmax_dst = (uint32_t)(g_recv_buff);
  17. uint32_t dmax_dst_inc = DMA_MEMORY_INCREASE_ENABLE;
  19. /**************** DMA p2m *******************/
  20. // 时钟
  21. rcu_periph_clock_enable(dmax_rcu);
  22. // 重置dma
  23. dma_deinit(dmax, dmax_ch);
  25. //////// dma 配置
  26. dma_single_data_parameter_struct dsdps;
  27. dma_single_data_para_struct_init(&dsdps);
  28. // 方向
  29. dsdps.direction = DMA_PERIPH_TO_MEMORY;
  30. // 内存: dst
  31. dsdps.memory0_addr = dmax_dst;
  32. dsdps.memory_inc = dmax_dst_inc;
  33. // 外设: src
  34. dsdps.periph_addr = dmax_src;
  35. dsdps.periph_inc = dmax_src_inc;
  36. // 数据长度
  37. dsdps.number = dmax_src_len;
  38. // dst数据宽度
  39. dsdps.periph_memory_width = dmax_src_width;
  40. // 传输优先级
  41. dsdps.priority = DMA_PRIORITY_ULTRA_HIGH;
  42. dma_single_data_mode_init(dmax, dmax_ch, &dsdps);
  44. //////// 配置 dma 子连接
  45. dma_channel_subperipheral_select(dmax, dmax_ch, damx_sub);
  48. // 默认开启接收
  49. dma_flag_clear(dmax, dmax_ch, DMA_FLAG_FTF);
  50. dma_channel_enable(dmax, dmax_ch);
  • 哪个dma：DMA0或者DMA1
  • dma的哪个通道：ch0到ch7
  • dma的哪个子级：0到7
  • 传输方向是什么：内存到内存，内存到外设，外设到内存
  • 源地址是多少？源的数据长度是多少（几个byte）？源的数据宽度是多少（几个bit）？
  • 目标地址是什么？
  • 从源地址向目标地址传输数据时，源地址的指针是否需要增长。
  • 从源地址向目标地址传输数据时，目标地址的指针是否需要增长。

    串口接收理解

    030.png

    地址和目标地址

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

    自增长

    每传输一个字节数据，地址是否需要增长。这里包含了源地址是否需要增长，也包含了目标地址是否需要增长。
    串口中，寄存器地址不变，大小不变，我们只是向这个里面放数据，所以不需要增长。

    数据宽度

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

    数据长度

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

练习题

  1. 实现dma的串口接收