devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

16、STM32——DMA详解_stm32 dma详解

作者：Gausst松鼠会 | 2024-05-17 16:55:49

赞

踩

stm32 dma详解

1、DMA简介

DMA(Direct Memory Access) ：直接存储器存取，是单片机的一个外设，它的主要功能是用来搬数据，但是不需要占用 CPU，即在传输数据的时候， CPU 可以干其他的事情，好像是多线程一样。数据传输支持从外设到存储器或者存储器到存储器，这里的存储器可以是 SRAM 或者是 FLASH。

DMA 控制器包含了 DMA1 和 DMA2，其中 DMA1 有 7 个通道， DMA2 有 5 个通道，这里的通道可以理解为传输数据的一种管道。要注意的是 DMA2 只存在于大容量的单片机中。

2、DMA 功能框图

DMA 控制器独立于内核，属于一个单独的外设，结构比较简单，从编程的角度来看，我们只需掌握功能框图中的三部分内容即可

在这里插入图片描述

2.1 DMA 请求

如果外设要想通过 DMA 来传输数据，必须先给 DMA 控制器发送 DMA 请求，DMA 收到请求信号之后，控制器会给外设一个应答信号，当外设应答后且 DMA 控制器收到应答信号之后，就会启动 DMA 的传输，直到传输完毕。

DMA 有 DMA1 和 DMA2 两个控制器， DMA1 有 7 个通道， DMA2 有 5 个通道，不同的 DMA 控制器的通道对应着不同的外设请求，这决定了我们在软件编程上该怎么设置，具体见 DMA 请求映像表。

ADC2没有 DMA 功能。

在这里插入图片描述
在这里插入图片描述
其中 ADC3、 SDIO 和 TIM8 的 DMA 请求只在大容量产品中存在，这个在具体项目时要注意。

2.2 通道

DMA 具有 12 个独立可编程的通道，其中 DMA1 有 7 个通道， DMA2 有 5 个通道，每个通道对应不同的外设的 DMA 请求。虽然每个通道可以接收多个外设的请求，但是同一时间只能接收一个，不能同时接收多个。

2.3、仲裁器

当发生多个 DMA 通道请求时，就意味着有先后响应处理的顺序问题，这个就由仲裁器也管理。仲裁器管理 DMA 通道请求分为两个阶段。第一阶段属于软件阶段，可以在 DMA_CCRx 寄存器中设置，有 4 个等级：非常高、高、中和低四个优先级。第二阶段属于硬件阶段，如果两个或以上的 DMA 通道请求设置的优先级一样，则他们优先级取决于通道编号，编号越低优先权越高，比如通道 0 高于通道 1。在大容量产品和互联型产品中， DMA1 控制器拥有高于 DMA2 控制器的优先级。

3、DMA 数据配置

使用 DMA，最核心就是配置要传输的数据，包括数据从哪里来，要到哪里去，传输的数据的单位是什么，要传多少数据，是一次传输还是循环传输等等。

3.1 从哪里来到哪里去

我们知道 DMA 传输数据的方向有三个：从外设到存储器，从存储器到外设，从存储器到存储器。具体的方向 DMA_CCR 位 4 DIR 配置： 0 表示从外设到存储器， 1 表示从存储器到外设。这里面涉及到的外设地址由 DMA_CPAR 配置，存储器地址由 DMA_CMAR 配置。

外设到存储器：

当我们使用从外设到存储器传输时，以 ADC 采集为例。 DMA 外设寄存器的地址对应的就是 ADC 数据寄存器的地址， DMA 存储器的地址就是我们自定义的变量（用来接收存储 AD 采集的数据）的地址。方向我们设置外设为源地址。

存储器到外设：

当我们使用从存储器到外设传输时，以串口向电脑端发送数据为例。 DMA 外设寄存器的地址对应的就是串口数据寄存器的地址， DMA 存储器的地址就是我们自定义的变量（相当于一个缓冲区，用来存储通过串口发送到电脑的数据）的地址。方向我们设置外设为目标地址。

存储器到存储器：

当我们使用从存储器到存储器传输时，以内部 FLASH 向内部 SRAM 复制数据为例。 DMA 外设寄存器的地址对应的就是内部 FLASH（我们这里把内部 FALSH 当作一个外设来看）的地址， DMA 存储器的地址就是我们自定义的变量（相当于一个缓冲区，用来存储来自内部 FLASH 的数据）的地址。方向我们设置外设（即内部 FLASH）为源地址。跟上面两个不一样的是，这里需要把 DMA_CCR 位 14： MEM2MEM：存储器到存储器模式配置为 1，启动 M2M 模式。

3.2 要传多少，单位是什么

当我们配置好数据要从哪里来到哪里去之后，我们还需要知道我们要传输的数据是多少，数据的单位是什么。

以串口向电脑发送数据为例，我们可以一次性给电脑发送很多数据，具体多少由 DMA_CNDTR 配置，这是一个 32 位的寄存器，前16位为数据传输数量，一次最多只能传输 65535 个数据。

要想数据传输正确，源和目标地址存储的数据宽度还必须一致，串口数据寄存器是 8 位的，所以我们定义的要发送的数据也必须是 8 位。外设的数据宽度由 DMA_CCR 的 PSIZE[1:0] 配置，可以是 8/16/32 位，存储器的数据宽度由 DMA_CCR 的 MSIZE[1:0] 配置，可以是 8/16/32 位。

在 DMA 控制器的控制下，数据要想有条不紊的从一个地方搬到另外一个地方，还必须正确设置两边数据指针的增量模式。外设的地址指针由 DMA_CCRx 的 PINC 配置，存储器的地址指针由 MINC 配置。以串口向电脑发送数据为例，要发送的数据很多，每发送完一个，那么存储器的地址指针就应该加 1，而串口数据寄存器只有一个，那么外设的地址指针就固定不变。具体的数据指针的增量模式由实际情况决定。

3.3 什么时候传输完成

数据什么时候传输完成，我们可以通过查询标志位或者通过中断的方式来鉴别。每个 DMA 通道在 DMA 传输过半、传输完成和传输错误时都会有相应的标志位，如果使能了该类型的中断后，则会产生中断。有关各个标志位的详细描述请参考 DMA 中断状态寄存器 DMA_ISR 的详细描述。

传输完成还分两种模式，是一次传输还是循环传输，一次传输很好理解，即是传输一次之后就停止，要想再传输的话，必须关断 DMA 使能后再重新配置后才能继续传输。循环传输则是一次传输完成之后又恢复第一次传输时的配置循环传输，不断的重复。具体的由 DMA_CCR 寄存器的 CIRC 循环模式位控制。

4、DMA 初始化结构体详解

标准库函数对每个外设都建立了一个初始化结构体 xxx_InitTypeDef(xxx 为外设名称)，结构体成员用于设置外设工作参数，并由标准库函数 xxx_Init() 调用这些设定参数进入设置外设相应的寄存器，达到配置外设工作环境的目的。

结构体 xxx_InitTypeDef 和库函数 xxx_Init 配合使用是标准库精髓所在，理解了结构体 xxx_InitTypeDef 每个成员意义基本上就可以对该外设运用自如。结构体 xxx_InitTypeDef 定义在 stm32f10x_xxx.h(后面 xxx 为外设名称) 文件中，库函数 xxx_Init 定义在 stm32f10x_xxx.c 文件中，编程时我们可以结合这两个文件内注释使用。

DMA_ InitTypeDef 初始化结构体

typedef struct
{
    uint32_t DMA_PeripheralBaseAddr; 	// 外设地址
    uint32_t DMA_MemoryBaseAddr; 		// 存储器地址
    uint32_t DMA_DIR; 					// 传输方向
    uint32_t DMA_BufferSize; 			// 传输数目
    uint32_t DMA_PeripheralInc; 		// 外设地址增量模式
    uint32_t DMA_MemoryInc; 			// 存储器地址增量模式
    uint32_t DMA_PeripheralDataSize; 	// 外设数据宽度
    uint32_t DMA_MemoryDataSize; 		// 存储器数据宽度
    uint32_t DMA_Mode; 					// 模式选择
    uint32_t DMA_Priority; 				// 通道优先级
    uint32_t DMA_M2M; 					// 存储器到存储器模式
} DMA_InitTypeDef;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

1、DMA_PeripheralBaseAddr：外设地址，设定 DMA_CPAR 寄存器的值；一般设置为外设的数据寄存器地址，如果是存储器到存储器模式则设置为其中一个存储器地址。

2、DMA_Memory0BaseAddr：存储器地址，设定 DMA_CMAR 寄存器值；一般设置为我们自定义存储区的首地址。

3、DMA_DIR：传输方向选择，可选外设到存储器、存储器到外设。它设定 DMA_CCR 寄存器的 DIR[1:0] 位的值。这里并没有存储器到存储器的方向选择，当使用存储器到存储器时，只需要把其中一个存储器当作外设使用即可。

4、DMA_BufferSize：设定待传输数据数目，初始化设定 DMA_CNDTR 寄存器的值。

5、DMA_PeripheralInc：如果配置为 DMA_PeripheralInc_Enable，使能外设地址自动递增功能，它设定 DMA_CCR 寄存器的 PINC 位的值；一般外设都是只有一个数据寄存器，所以一般不会使能该位。

6、DMA_MemoryInc：如果配置为 DMA_MemoryInc_Enable，使能存储器地址自动递增功能，它设定 DMA_CCR 寄存器的 MINC 位的值；我们自定义的存储区一般都是存放多个数据的，所以要使能存储器地址自动递增功能。

7、DMA_PeripheralDataSize：外设数据宽度，可选字节 (8 位)、半字 (16 位) 和字 (32 位)，它设定 DMA_CCR 寄存器的 PSIZE[1:0] 位的值。

8、DMA_MemoryDataSize：存储器数据宽度，可选字节 (8 位)、半字 (16 位) 和字 (32 位)，它设定 DMA_CCR 寄存器的 MSIZE[1:0] 位的值。当外设和存储器之间传数据时，两边的数据宽度应该设置为一致大小。

9、DMA_Mode： DMA 传输模式选择，可选一次传输或者循环传输，它设定 DMA_CCR 寄存器的 CIRC 位的值。例程我们的 ADC 采集是持续循环进行的，所以使用循环传输模式。

10、DMA_Priority：软件设置通道的优先级，有 4 个可选优先级分别为非常高、高、中和低，它设定 DMA_CCR 寄存器的 PL[1:0] 位的值。 DMA 通道优先级只有在多个 DMA 通道同时使用时才有意义，如果是单个通道，优先级可以随便设置。

11、DMA_M2M：存储器到存储器模式，使用存储器到存储器时用到，设定 DMA_CCR 的位 14 MEN2MEN 即可启动存储器到存储器模式。

5、程序设计

  • FLASH to SRAM 把内部 FLASH 的数据传输到内部的 SRAM 中
    把 flash 定义为外设，sram 定义为存储器

bsp_dma_mtm.h

#ifndef _BSP_DMA_MTM_H_
#define _BSP_DMA_MTM_H_

#include "stm32f10x.h"

#define   BUFFER_SIZE     32

void MtM_DMA_Config(void);
uint8_t BuffCmp(const uint32_t* pBuffer, uint32_t* pBufferl, uint16_t BufferLength);


#endif  /*_BSP_DMA_MTM_H_*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

bsp_dma_mtm.c

#include "bsp_dma_mtm.h"

//常量存储在 flash 中
const uint32_t aSRC_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};

//变量存储在ram中
uint32_t aDST_Buffer[BUFFER_SIZE];

void MtM_DMA_Config(void)
{
    DMA_InitTypeDef DMA_InitStructure;
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)aSRC_Const_Buffer;			//flash为外设地址
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)aDST_Buffer;					//自定义数组地址
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;								//方向为 外设为源地址
    
    DMA_InitStructure.DMA_BufferSize = BUFFER_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;					//外设地址增量模式
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;							//存储器地址自动递增功能
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;			//32位
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;					//32位
    
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;									//发送一次
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
    
    DMA_Init(DMA1_Channel6, &DMA_InitStructure);
    DMA_ClearFlag(DMA1_FLAG_TC6);													//通道随便选
    DMA_Cmd(DMA1_Channel6, ENABLE);
}

uint8_t BuffCmp(const uint32_t* pBuffer, uint32_t* pBufferl, uint16_t BufferLength)
{
    uint8_t ret = 0;
    while(BufferLength--)
    {
        if(*pBuffer != *pBufferl)
        {
            ret = 0;
            break;
        }
        pBuffer++;
        pBufferl++;
        ret = 1;
    }
    
    return ret;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

main.c

#include "stm32f10x.h"
#include "bsp_led.h"
#include "bsp_dma_mtm.h"
#include "delay.h"

extern const uint32_t aSRC_Const_Buffer[BUFFER_SIZE];
extern uint32_t aDST_Buffer[BUFFER_SIZE];

int main(void)
{
    uint8_t Transfer_Status = 0;
    
    delay_init();
    LED_GPIO_Config();
    
    LED_G(ON);
    LED_R(OFF);
    LED_B(OFF);
    delay_ms(1000);
    
    MtM_DMA_Config();
    Transfer_Status = BuffCmp(aSRC_Const_Buffer, aDST_Buffer, BUFFER_SIZE);
    
    while(DMA_GetFlagStatus(DMA1_FLAG_TC6) == RESET);
    
    if(Transfer_Status == 0)
    {
        LED_G(ON);
        LED_B(OFF);
        LED_R(OFF);
    }
    else
    {
        LED_B(ON);
        LED_G(OFF);
        LED_R(OFF);  
    }
    
    while(1)
    {
        
    } 
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • SRAM to USART 把内部 sram 的数据传输到外部的 usart 中
    usart 为外设，sram 定义为存储器

bsp_dma_mtm.h

#ifndef _BSP_DMA_MTP_H_
#define _BSP_DMA_MTP_H_

#include "stm32f10x.h"
#include <stdio.h>

void USART1_Config(void);
void USART1_DMA_Config(void);

#define   SENDBUFF_SIZE     5000

#endif  /*_BSP_DMA_MTP_H_*/


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

bsp_dma_mtm.c

#include "bsp_dma_mtp.h"

uint8_t SendBuff[SENDBUFF_SIZE];

//内存到外设                                    
void USART1_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
   
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = 115200;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_Init(USART1, &USART_InitStructure);
    
    NVIC_InitTypeDef NVIC_InitStructure;
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_Init(&NVIC_InitStructure);
    
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART1, ENABLE); 
}
                                    
void USART1_DMA_Config(void)
{
    DMA_InitTypeDef DMA_InitStructure;
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(USART1_BASE + 0x04);		//DR 寄存器
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SendBuff;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;								//方向  sram 到 串口
    
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
    DMA_ClearFlag(DMA1_FLAG_TC4);
    DMA_Cmd(DMA1_Channel4, ENABLE);													//查表，USART1_TX
}

void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data)
{
    USART_SendData(pUSARTx, data);
    while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}

void Usart_SendHalfWord(USART_TypeDef* pUSARTx, uint16_t data)
{
    uint8_t temp_h, temp_l;
    temp_h = (data & 0xff00) >> 8;
    temp_l = data & 0xff;
    
    USART_SendData(pUSARTx, temp_h);
    while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
    
    USART_SendData(pUSARTx, temp_l);
    while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}

void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t* array, uint8_t num)
{
    for(uint8_t i = 0; i < num; i++)
    {
        Usart_SendByte(pUSARTx, array[i]); 
    }
    while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
}

void Usart_SendString(USART_TypeDef* pUSARTx, uint8_t* str)
{
    do
    {
        Usart_SendByte(pUSARTx, *(str++)); 
        
    }while((*str) != '\0');
    
    while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
}

int fputc(int ch, FILE* f)
{
    USART_SendData(USART1, (uint8_t)ch);
    
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
        
    return ch;
}

int fgetc(FILE* f)
{
    while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET);
        
    return (int)USART_ReceiveData(USART1);
}


void USART1_IRQHandler(void)
{
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        USART_SendData(USART1, USART_ReceiveData(USART1));
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129

main.c

#include "stm32f10x.h"
#include "bsp_dma_mtp.h"
#include "delay.h"

extern uint8_t SendBuff[SENDBUFF_SIZE];

int main(void)
{
    USART1_Config();
    USART1_DMA_Config();
    delay_init();
    
    for(uint16_t i = 0; i < SENDBUFF_SIZE; i++)
    {
        SendBuff[i] = 'x';
    }
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
    
    while(1)
    {
        
    } 
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

问题点一：代码中为什么会用到 DMA1_Channel4（通道4）呢？
答：因为我们要把 ram 中接收到的数据放到 USART1_TX 中发送出去， USART1_TX 对应的就是 DMA1_Channel4（通道4）。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/584430
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号