【STM32标准库】DMA双缓冲模式_stm32 dma双缓冲模式

1.双缓冲模式简介

设置DMA_SxCR寄存器的DBM位为1可启动双缓冲传输模式，并自动激活循环模式，所以设置普通模式或者循环模式都可以。

双缓冲不应用与存储器到存储器的传输。可以应用在从存储器到外设或者外设到存储器。

双缓冲模式下， 两个存储器地址指针都有效，即DMA_SxM1AR寄存器将被激活使用。开始传输使用DMA_SxM0AR寄存器的地址指针所对应的存储区， 当这个存储区数据传输完DMA控制器会自动切换至DMA_SxM1AR寄存器的地址指针所对应的另一块存储区， 如果这一块也传输完成就再切换至DMA_SxM0AR寄存器的地址指针所对应的存储区，这样循环调用。

所以我们需要配置传输完成中断，在中断服务函数中，我们可以获取正在使用哪一个buffer，然后可以去填充另一个buffer的数据。

2.示例

#ifndef __BSP_USART_H
#define __BSP_USART_H

#ifdef __cplusplus
extern "C"{

#endif

#include "stm32f4xx.h"
#include "stdio.h"

#define LOGGER_USART              USART1
#define LOGGER_USART_BAUDRATE     115200
#define LOGGER_USART_CLK          RCC_APB2Periph_USART1
#define LOGGER_USART_IRQHandler   USART1_IRQHandler
#define LOGGER_USART_IRQ          USART1_IRQn

#define USART1_TX_PIN             GPIO_Pin_9
#define USART1_TX_GPIO_Port       GPIOA
#define USART1_TX_GPIO_CLK        RCC_AHB1Periph_GPIOA
#define USART1_TX_AF              GPIO_AF_USART1
#define USART1_TX_SOURCE          GPIO_PinSource9

#define USART1_RX_PIN             GPIO_Pin_10
#define USART1_RX_GPIO_Port       GPIOA
#define USART1_RX_GPIO_CLK        RCC_AHB1Periph_GPIOA
#define USART1_RX_AF              GPIO_AF_USART1
#define USART1_RX_SOURCE          GPIO_PinSource10


//usart1_tx只能使用到DMA2_Stream7  Channel_4
#define USART1_TX_DMA_STREAM               DMA2_Stream7
#define USART1_TX_DMA_CHANNEL              DMA_Channel_4
#define USART1_TX_DMA_STREAM_CLK           RCC_AHB1Periph_DMA2
#define USART1_TX_DMA_IT_TCIF              DMA_IT_TCIF7
#define USART1_TX_DMA_IT_HTIF              DMA_IT_HTIF7
#define USART1_TX_DMA_STREAM_IRQn          DMA2_Stream7_IRQn
#define USART1_TX_DMA_STREAM_IRQHandler    DMA2_Stream7_IRQHandler

#define TX_BUFFER_SIZE                     5
#define USART1_TX_DR_BASE                  (&USART1->DR)  //(USART1_BASE+0x04)

void Init_USART(void);
void Init_USART_DMA(void);
void USART_DMA_SEND(uint8_t* data,uint32_t size);

#ifdef __cplusplus
}
#endif

#endif


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

#include "bsp_usart.h"
#include "string.h"

uint8_t USART_TX_BUFFER[TX_BUFFER_SIZE]={0x00,0x02,0x04,0x06,0x08};
uint8_t USART_TX_BUFFER1[TX_BUFFER_SIZE]={0x01,0x03,0x05,0x07,0x09};

void Init_USART(void)
{
	RCC_AHB1PeriphClockCmd(USART1_TX_GPIO_CLK|USART1_RX_GPIO_CLK,ENABLE);//使能GPIOA时钟
	RCC_APB2PeriphClockCmd(LOGGER_USART_CLK,ENABLE);//使能USART1时钟
	
    //USART1对应引脚复用映射
	GPIO_PinAFConfig(USART1_TX_GPIO_Port, USART1_TX_SOURCE,USART1_TX_AF);//PA9复用为USART1
	GPIO_PinAFConfig(USART1_RX_GPIO_Port, USART1_RX_SOURCE,USART1_RX_AF);//PA10复用为USART1
	
	//USART1端口配置
	GPIO_InitTypeDef GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Pin=USART1_TX_PIN;
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF;//复用功能
	GPIO_InitStruct.GPIO_OType=GPIO_OType_PP;//推挽复用输出
	GPIO_InitStruct.GPIO_PuPd=GPIO_PuPd_UP;//上拉
	GPIO_InitStruct.GPIO_Speed=GPIO_Fast_Speed;//速度50MHz
	GPIO_Init(USART1_TX_GPIO_Port,&GPIO_InitStruct);//初始化PA9
	
	GPIO_InitStruct.GPIO_Pin=USART1_RX_PIN;
	GPIO_Init(USART1_RX_GPIO_Port,&GPIO_InitStruct);//初始化PA10
		
	//配置USART参数
	USART_InitTypeDef USART_Init_Struct;
	USART_Init_Struct.USART_BaudRate=LOGGER_USART_BAUDRATE;
	USART_Init_Struct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_Init_Struct.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
	USART_Init_Struct.USART_Parity=USART_Parity_No;
	USART_Init_Struct.USART_StopBits=USART_StopBits_1;
	USART_Init_Struct.USART_WordLength=USART_WordLength_8b;
	USART_Init(LOGGER_USART,&USART_Init_Struct);
	
	//配置中断控制器并使能USART接收中断
	NVIC_InitTypeDef NVIC_Init_Struct;
	NVIC_Init_Struct.NVIC_IRQChannel=LOGGER_USART_IRQ;
	NVIC_Init_Struct.NVIC_IRQChannelCmd=ENABLE;
	NVIC_Init_Struct.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_Init_Struct.NVIC_IRQChannelSubPriority=0;
	NVIC_Init(&NVIC_Init_Struct);
	USART_ITConfig(LOGGER_USART,USART_IT_IDLE,ENABLE);
	
	//使能USART
	USART_Cmd(LOGGER_USART,ENABLE);
	
	//使能USART_DMA
	USART_DMACmd(LOGGER_USART,USART_DMAReq_Tx|USART_DMAReq_Rx,ENABLE);
}

void LOGGER_USART_IRQHandler(void)
{
	
}

//重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
    /* 发送一个字节数据到串口 */
    USART_SendData(LOGGER_USART, (uint8_t) ch);

    /* 等待发送完毕 */
    while (USART_GetFlagStatus(LOGGER_USART, USART_FLAG_TXE) == RESET);

    return (ch);
}


void USART_DMA_SEND(uint8_t* data,uint32_t size)
{
	while (DMA_GetCmdStatus(USART1_TX_DMA_STREAM) != DISABLE) {
    }

	memcpy(USART_TX_BUFFER,data,size);
  	
	DMA_Cmd(USART1_TX_DMA_STREAM,DISABLE);
	DMA_SetCurrDataCounter(USART1_TX_DMA_STREAM,size);
	DMA_Cmd(USART1_TX_DMA_STREAM,ENABLE);
}


void Init_USART_DMA(void)
{
	/* 使能DMA时钟 */
    RCC_AHB1PeriphClockCmd(USART1_TX_DMA_STREAM_CLK, ENABLE);
	
	 /* 复位初始化DMA数据流 */
    DMA_DeInit(USART1_TX_DMA_STREAM);

    /* 确保DMA数据流复位完成 */
    while (DMA_GetCmdStatus(USART1_TX_DMA_STREAM) != DISABLE) {
    }
	
	DMA_InitTypeDef  DMA_InitStructure;
	DMA_InitStructure.DMA_BufferSize=TX_BUFFER_SIZE;//一次DMA事务传输的数据个数
	DMA_InitStructure.DMA_Channel=USART1_TX_DMA_CHANNEL;
	DMA_InitStructure.DMA_DIR=DMA_DIR_MemoryToPeripheral;
	DMA_InitStructure.DMA_FIFOMode=DMA_FIFOMode_Disable;
	DMA_InitStructure.DMA_FIFOThreshold=DMA_FIFOThreshold_Full;
	DMA_InitStructure.DMA_Memory0BaseAddr= (uint32_t)USART_TX_BUFFER;
	DMA_InitStructure.DMA_MemoryBurst=DMA_MemoryBurst_Single;
	DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte;
	DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable;
	DMA_InitStructure.DMA_Mode=DMA_Mode_Normal;
	DMA_InitStructure.DMA_PeripheralBaseAddr=(uint32_t)USART1_TX_DR_BASE;
	DMA_InitStructure.DMA_PeripheralBurst=DMA_PeripheralBurst_Single;
	DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;
	DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable;
	DMA_InitStructure.DMA_Priority=DMA_Priority_Low;
	DMA_Init(USART1_TX_DMA_STREAM,&DMA_InitStructure);
	
	//配置双缓冲
	DMA_DoubleBufferModeConfig(USART1_TX_DMA_STREAM,(uint32_t)USART_TX_BUFFER1,DMA_Memory_0);
	DMA_DoubleBufferModeCmd(USART1_TX_DMA_STREAM,ENABLE);
	
	DMA_ITConfig(USART1_TX_DMA_STREAM,DMA_IT_TC|DMA_IT_HT,ENABLE);
	
	DMA_ClearITPendingBit(USART1_TX_DMA_STREAM,USART1_TX_DMA_IT_TCIF|USART1_TX_DMA_IT_HTIF);
	
	//配置中断控制器并使能中断
	NVIC_InitTypeDef NVIC_InitStruct;
	NVIC_InitStruct.NVIC_IRQChannel=USART1_TX_DMA_STREAM_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=2;
	NVIC_InitStruct.NVIC_IRQChannelSubPriority=0;
	NVIC_Init(&NVIC_InitStruct);
	
	DMA_Cmd(USART1_TX_DMA_STREAM,ENABLE);
}

void USART1_TX_DMA_STREAM_IRQHandler(void)
{
	if(SET==DMA_GetITStatus(USART1_TX_DMA_STREAM,USART1_TX_DMA_IT_HTIF))
	{
		//half transfer complete
		//printf("half transfer\r\n");
		DMA_ClearITPendingBit(USART1_TX_DMA_STREAM,USART1_TX_DMA_IT_HTIF);
	}
	else if(SET==DMA_GetITStatus(USART1_TX_DMA_STREAM,USART1_TX_DMA_IT_TCIF))
	{
		//transfer complete
		//printf("transfer complete\r\n");
		if(0==DMA_GetCurrentMemoryTarget(USART1_TX_DMA_STREAM))
		{
			//Current memory buffer used is Memory 0
			for(int i=0;i<TX_BUFFER_SIZE;i++)
			{
				USART_TX_BUFFER1[i]+=2;
			}
		}else
		{
			//Current memory buffer used is Memory 1
			for(int i=0;i<TX_BUFFER_SIZE;i++)
			{
				USART_TX_BUFFER[i]+=2;
			}
		}
		
		DMA_ClearITPendingBit(USART1_TX_DMA_STREAM,USART1_TX_DMA_IT_TCIF);
	}
}

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

有一个函数需要注意

	//配置双缓冲
	DMA_DoubleBufferModeConfig(USART1_TX_DMA_STREAM,(uint32_t)USART_TX_BUFFER1,DMA_Memory_0);
	DMA_DoubleBufferModeCmd(USART1_TX_DMA_STREAM,ENABLE);
1
2
3

配置双缓冲的主要函数。

DMA_GetCurrentMemoryTarget(USART1_TX_DMA_STREAM)
1

该函数可以获取DMA正在使用的buffer，然后我们就可以去填充另外一个buffer了。

3.疑问

双缓冲模式应用在对DMA连续传输要求比较高的地方，不需要一次DMA buffer传输结束后有过多的操作然后进行下一次传输。但是，我们使用half transfer和transfer complete两个中断好像也可以做到，当有half transfer中断时，我们去更新buffer的前一半数据，当有transfer complete中断时，我们去更新buffer的后一半数据，然后配置循环模式。
这种方式与使用双buffer有什么区别吗？可能单buffer在传输中去修改其中的值不是一个稳妥的方式吧！