学习目标

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

  6. 能够动态配置源数据

    学习内容

    需求

    1. uint8_t data = 0x01;
    2. 串口发送(data);

    实现串口的发送数据， 要求采用dma的方式

    数据交互流程

    image.png

  7. CPU配置好DMA

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

    开发流程

    依赖引入

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

    DMA初始化

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

//////// dma 配置 dma_single_data_parameter_struct dsdps; dma_single_data_para_struct_init(&dsdps); // 方向 dsdps.direction = DMA_MEMORY_TO_PERIPH; // 内存: src // dsdps.memory0_addr = (uint32_t)src; dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 外设: dst dsdps.periph_addr = (uint32_t)(&USART_DATA(USART0)); dsdps.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 数据长度 // dsdps.number = ARR_LEN; // 数据宽度 dsdps.periph_memory_width = DMA_MEMORY_WIDTH_8BIT; // 传输优先级 dsdps.priority = DMA_PRIORITY_ULTRA_HIGH; dma_single_data_mode_init(DMA1, DMA_CH7, &dsdps);

//////// 配置 dma 子连接 dma_channel_subperipheral_select(DMA1, DMA_CH7, DMA_SUBPERI4);

  2. 1. 配置时钟
  3. 2. 初始化dma通道
  4. 3. 配置dma与外设间的子链接
  5. <a name="ZK7mP"></a>
  6. #### DMA传输请求
  7. ```c
  8. // 数据来源 和 长度
  9. dma_memory_address_config(DMA1, DMA_CH7, DMA_MEMORY_0, (uint32_t)(&data));
  10. dma_transfer_number_config(DMA1, DMA_CH7, len);
  12. // 触发传输
  13. dma_channel_enable(DMA1, DMA_CH7);
  15. // 等待DMA传输完成
  16. while(RESET == dma_flag_get(DMA1, DMA_CH7, DMA_FLAG_FTF));
  17. // 清理标记
  18. dma_flag_clear(DMA1, DMA_CH7, DMA_FLAG_FTF);
  • dma_channel_enable： 请求dma数据传输

  • DMA_FLAG_FTF：为传输完成标记

    串口外设DMA开启

    1. // DMA发送功能配置
    2. usart_dma_transmit_config(usartx, USART_TRANSMIT_DMA_ENABLE);

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

    发送功能

    1. static void dma_send_byte(uint8_t data) {
    2.   // 数据来源 和 长度
    3.   dma_memory_address_config(DMA1, DMA_CH7, DMA_MEMORY_0, (uint32_t)(&data));
    4.   dma_transfer_number_config(DMA1, DMA_CH7, 1);
    6.   // 触发传输
    7.   dma_channel_enable(DMA1, DMA_CH7);
    9.   // 等待DMA传输完成
    10.   while(RESET == dma_flag_get(DMA1, DMA_CH7, DMA_FLAG_FTF));
    11.   // 清理标记
    12.   dma_flag_clear(DMA1, DMA_CH7, DMA_FLAG_FTF);
    13. }
    1. static void dma_send(uint8_t* data, uint32_t len) {
    2.   // 数据来源 和 长度
    3.   dma_memory_address_config(DMA1, DMA_CH7, DMA_MEMORY_0, (uint32_t)(&data));
    4.   dma_transfer_number_config(DMA1, DMA_CH7, len);
    6.   // 触发传输
    7.   dma_channel_enable(DMA1, DMA_CH7);
    9.   // 等待DMA传输完成
    10.   while(RESET == dma_flag_get(DMA1, DMA_CH7, DMA_FLAG_FTF));
    11.   // 清理标记
    12.   dma_flag_clear(DMA1, DMA_CH7, DMA_FLAG_FTF);
    13. }
    1. static void dma_send_string(const char* str) {
    2.   dma_send((uint8_t*)str, strlen(str));
    3. }

    完整代码

    ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include

    include “main.h”

static void DMA_config() { /* DMA m2p */ // 时钟 rcu_periph_clock_enable(RCU_DMA1); // 重置dma dma_deinit(DMA1, DMA_CH7);

  1. //////// dma 配置
  2. dma_single_data_parameter_struct dsdps;
  3. dma_single_data_para_struct_init(&dsdps);
  4. // 方向
  5. dsdps.direction = DMA_MEMORY_TO_PERIPH;
  6. // 内存: src 
  7. //    dsdps.memory0_addr = (uint32_t)src;
  8. dsdps.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  9. // 外设: dst
  10. dsdps.periph_addr = (uint32_t)(&USART_DATA(USART0));
  11. dsdps.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  12. //    // 数据长度
  13. //    dsdps.number = ARR_LEN;
  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_CH7, &dsdps);
  20. //////// 配置 dma 子连接
  21. dma_channel_subperipheral_select(DMA1, DMA_CH7, DMA_SUBPERI4);

}

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);
  67. // 使能串口
  68. 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; }

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

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

}

  1. <a name="Wqo9o"></a>
  2. ### 关心的内容
  3. ```c
  4. uint32_t dmax = DMA1;
  5. uint32_t dmax_rcu = RCU_DMA1;
  6. uint32_t dmax_ch = DMA_CH7;
  7. uint32_t damx_sub = DMA_SUBPERI4;
  9. uint32_t dmax_dirction = DMA_MEMORY_TO_PERIPH;
  11. //    uint32_t dmax_src = (uint32_t)src;
  12. uint32_t dmax_src_inc = DMA_MEMORY_INCREASE_ENABLE;
  13. uint32_t dmax_src_width = DMA_MEMORY_WIDTH_8BIT;
  14. //    uint32_t dmax_src_len = ARR_LEN;
  16. uint32_t dmax_dst = (uint32_t)(&USART_DATA(USART0));
  17. uint32_t dmax_dst_inc = DMA_PERIPH_INCREASE_DISABLE;
  19. /***************** DMA m2p *******************/
  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 = dmax_dirction;
  30. // 内存: src
  31. //    dsdps.memory0_addr = (uint32_t)src;
  32. dsdps.memory_inc = dmax_src_inc;
  33. // 外设: dst
  34. dsdps.periph_addr = dmax_dst;
  35. dsdps.periph_inc = dmax_dst_inc;
  36. //    // 数据长度
  37. //    dsdps.number = ARR_LEN;
  38. // 数据宽度
  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);
  • 哪个dma：DMA0或者DMA1
  • dma的哪个通道：ch0到ch7
  • dma的哪个子级：0到7
  • 传输方向是什么：内存到内存，内存到外设，外设到内存
  • 源地址是多少？源的数据长度是多少（几个byte）？源的数据宽度是多少（几个bit）？
  • 目标地址是什么？
  • 从源地址向目标地址传输数据时，源地址的指针是否需要增长。
  • 从源地址向目标地址传输数据时，目标地址的指针是否需要增长。

    串口发送理解

    028.png

    源地址和目标地址

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

    自增长

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

    数据宽度

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

    数据长度

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

    练习

  1. 实现串口数据的发送