DMA模式的串口通信

最新推荐文章于 2024-07-20 15:19:57 发布
最新推荐文章于 2024-07-20 15:19:57 发布
阅读量398 收藏 1
点赞数
文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45247630/article/details/131824742
版权

之前试过了DMA的ADC，这次用DMA结合串口的收发。

初始化一些需要用到的参数

#define USART_MAX_BUFFER_SIZE 512
typedef struct usartRT {
	uint8_t status;
	uint16_t rxBufferSize;
	uint16_t txBufferSize;
	uint8_t txBuffer[USART_MAX_BUFFER_SIZE]; 
	uint8_t rxBuffer[USART_MAX_BUFFER_SIZE];
}usartPacket_s;
typedef struct serialHandle {
	USART_Type* USARTx;
	DMA_Channel_Type* rxChannel;//接收频道
	DMA_Channel_Type* txChannel;//发送频道
	usartPacket_s packet;
	usartPacket_s DMApacket;
}SerialHandle_s;
//以串口1为例
SerialHandle_s serialHandle[serialCount] = {
	[serial1] = {
		.USARTx = USART1,
		.rxChannel = DMA1_Channel5,
		.txChannel = DMA1_Channel4,
		.packet.rxBufferSize = 0,
		.DMApacket.rxBufferSize = 0,
	},
}

初始化DMA

void USART_DMA_INIT(DMA_Channel_Type* DMAchannelx, uint32_t periphAddr, uint32_t bufferAddr, uint16_t bufferSize, uint32_t Direction)
{
	DMA_InitType DMA_InitStructure;

	DMA_Reset(DMAchannelx);
	DMA_DefaultInitParaConfig(&DMA_InitStructure);
	DMA_InitStructure.DMA_PeripheralBaseAddr = periphAddr;						//传输地址
	DMA_InitStructure.DMA_MemoryBaseAddr = bufferAddr;							//缓存地址
	DMA_InitStructure.DMA_Direction = Direction;								//传输方向（收发）
	DMA_InitStructure.DMA_BufferSize = bufferSize;								//缓存大小
	DMA_InitStructure.DMA_PeripheralInc = DMA_PERIPHERALINC_DISABLE;			//外设地址寄存器不变
	DMA_InitStructure.DMA_MemoryInc = DMA_MEMORYINC_ENABLE;						//内存地址寄存器递增
	DMA_InitStructure.DMA_PeripheralDataWidth = DMA_PERIPHERALDATAWIDTH_BYTE;	//数据宽度8位
	DMA_InitStructure.DMA_MemoryDataWidth = DMA_MEMORYDATAWIDTH_BYTE;			//数据宽度8位
	DMA_InitStructure.DMA_Mode = DMA_MODE_NORMAL;								//正常模式
	DMA_InitStructure.DMA_Priority = DMA_PRIORITY_LOW;							//优先级低
	DMA_InitStructure.DMA_MTOM = DMA_MEMTOMEM_DISABLE;							//不使用内存到内存传输
	DMA_Init(DMAchannelx, &DMA_InitStructure);
}

设置DMA参数

void USART_DMA_SETUP(SerialHandle_s* serialx)
{
	USART_DMA_INIT(serialx->txChannel, (uint32_t) & (serialx->USARTx->DT), (uint32_t)(serialx->DMApacket.txBuffer), USART_MAX_BUFFER_SIZE, UART_TX);
	USART_DMA_INIT(serialx->rxChannel, (uint32_t) & (serialx->USARTx->DT), (uint32_t)(serialx->DMApacket.rxBuffer), USART_MAX_BUFFER_SIZE, UART_RX);
	// DMA_ChannelEnable(serialx->txChannel, ENABLE);
	DMA_ChannelEnable(serialx->rxChannel, ENABLE);
	/* Enable USARTx DMA Rx and TX request */
	USART_DMACmd(serialx->USARTx, USART_DMAReq_Rx, ENABLE);
	USART_DMACmd(serialx->USARTx, USART_DMAReq_Tx, ENABLE);
	}

初始化串口

void USART_ClkCmd(USART_Type* USARTx, FunctionalState NewState)
{
	if (USARTx == USART1)
	{
	RCC_APB2PeriphClockCmd(RCC_APB2PERIPH_USART1, NewState);				//不同的串口硬件时钟不同，要注意
	}
}

void USART_NVIC_Cmd(USART_Type* USARTx, FunctionalState NewState)
{
	if (USARTx == USART1)
	{
		NVIC_Config(USART1_IRQn, 4, 1, NewState);
	}
}

void Usart_Setup(SerialHandle_s* serialx, uint32_t baudrate, uint16_t Wordlength, uint16_t Stopbits, uint16_t Parity, uint16_t Mode, uint16_t HardwareFlowControl)
{
	USART_Reset(serialx->USARTx);
	USART_ClkCmd(serialx->USARTx, ENABLE);									//开启串口时钟
	USART_NVIC_Cmd(serialx->USARTx, ENABLE);								//串口中断
	USART_InitType USARTx_InitStructure;
	USARTx_InitStructure.USART_BaudRate = baudrate;							//波特率		
	USARTx_InitStructure.USART_WordLength = Wordlength;						//数据长度
	USARTx_InitStructure.USART_StopBits = Stopbits;							//停止位
	USARTx_InitStructure.USART_Parity = Parity;								//校验位
	USARTx_InitStructure.USART_Mode = Mode;									//收发模式
	USARTx_InitStructure.USART_HardwareFlowControl = HardwareFlowControl;	//无硬件数据流控制
	USART_Init(serialx->USARTx, &USARTx_InitStructure);
	USART_DMA_SETUP(serialx);												//设置DMA
	USART_INTConfig(serialx->USARTx, USART_INT_IDLEF, ENABLE);				//串口空闲中断开启
	USART_INTConfig(serialx->USARTx, USART_INT_TRAC, ENABLE);
	USART_Cmd(serialx->USARTx, ENABLE);										//串口使能
}

使用串口1发数据

char* myitoa(int num, char* str, int radix)
{ 
	char index[] = "0123456789ABCDEF";
	unsigned unum;
	int i = 0, j, k;

	if (radix == 10 && num < 0) 
	{
		unum = (unsigned)-num;
		str[i++] = '-';
	}
	else
		unum = (unsigned)num; 
	
	do
	{
		str[i++] = index[unum % (unsigned)radix];
		unum /= radix;
	} while (unum);
	str[i] = '\0';
	
	if (str[0] == '-')
		k = 1; 
	else
		k = 0;

	for (j = k; j <= (i - 1) / 2; j++)
	{
		char temp;
		temp = str[j];
		str[j] = str[i - 1 + k - j];
		str[i - 1 + k - j] = temp;
	}
	return str;
}
void Serial_puts(SerialHandle_s* serialx, const char* b)
{
	while (*b)
	{
		serialx->packet.txBuffer[serialx->packet.txBufferSize] = *b;
		serialx->packet.txBufferSize++;
		b++;
		if (serialx->packet.txBufferSize == USART_MAX_BUFFER_SIZE)
			Serial_flush(serialx);
	}
}
void Serial_put(SerialHandle_s* serialx, const char* buffer, uint16_t lenght)
{
	if (lenght + serialx->packet.txBufferSize > USART_MAX_BUFFER_SIZE)
	{
		uint16_t txSize = 0;
		txSize = USART_MAX_BUFFER_SIZE - serialx->packet.txBufferSize;
		memcpy(&(serialx->packet.txBuffer[serialx->packet.txBufferSize]), buffer, txSize);
		serialx->packet.txBufferSize = USART_MAX_BUFFER_SIZE;
		Serial_flush(serialx);
		memcpy(&(serialx->packet.txBuffer[0]), &buffer[txSize], lenght - txSize);
		serialx->packet.txBufferSize = lenght - txSize;
	}
	else
	{
		while (lenght)
		{
			serialx->packet.txBuffer[serialx->packet.txBufferSize] = *buffer;
			serialx->packet.txBufferSize++;
			buffer++;
			lenght--;
		}
	}
}
void dmaChannelFlush(SerialHandle_s* serialx)
{
	if (!serialx->packet.txBufferSize)
		return;
	/*wait for transmition complete*/
	uint16_t tryCount = 0;
	// delay_ms(10);
	while (serialx->DMApacket.status & txBusy)
	{
		delay_us(10);
		// usartPrintf("userial busy!!\n");
		if (tryCount++ > SystemCoreClock / 1000000)
			return;
	}
	/*close dma channel and USART_DMAReq_Tx*/
	DMA_ChannelEnable(serialx->txChannel, DISABLE);
	USART_DMACmd(serialx->USARTx, USART_DMAReq_Tx, DISABLE);

	/*copy data from packet.txBuffer to DMApacket.txBuffer*/
	memcpy(serialx->DMApacket.txBuffer, serialx->packet.txBuffer, serialx->packet.txBufferSize);
	serialx->DMApacket.txBufferSize = serialx->packet.txBufferSize;
	/*reset packet.txBufferSize to 0*/
	serialx->packet.txBufferSize = 0;

	/*IrDA modulate for usart3*/
	// if (serialx->USARTx == USART3) IrDA_Modulate_Cmd(ENABLE);
	/*reset dma current data counter to DMApacket.txBufferSize*/
	DMA_SetCurrDataCounter(serialx->txChannel, serialx->DMApacket.txBufferSize);
	/*reopen USART_DMAReq_Tx*/
	USART_DMACmd(serialx->USARTx, USART_DMAReq_Tx, ENABLE);
	/*reopen dma channel*/
	DMA_ChannelEnable(serialx->txChannel, ENABLE);
	/*tx busy*/
	serialx->DMApacket.status |= txBusy;
}
void Serial_flush(SerialHandle_s* serialx)
{
	dmaChannelFlush(serialx);
}
void uartPrintfloat(const char* format, ...)
{
	char str[30];
	char c = 0;
	char ch = 0;
	bool catchFloat = 0;
	union _floatHex
	{
		double _f;
		uint8_t _u8;
		int8_t _i8;
		uint16_t _u16;
		int16_t _i16;
		uint32_t _u32;
		int32_t _i32;
		uint64_t _u64;
		int64_t _i64;
		uint8_t hex[8];
	}ftmp;
	va_list ap;
	va_start(ap, format);
	char *p = 0;
	while ((c = *format))
	{
		switch (c)
		{
		case '%':
			ch = *++format;
			switch (ch)
			{
			case 'd':
			{
				if(catchFloat)
				{
					p = va_arg(ap, char[8]);
					memcpy(&ftmp.hex[4],p,4);
				}
				else
				{
					p = va_arg(ap, char[8]);
					memcpy(&ftmp.hex[0],p,8);
				}
				myitoa(ftmp._i64, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				break;
			}
			case 'f':
				
				if (!catchFloat)
				{
					catchFloat = 1;
					/**FIXME 第一次遇到浮点数据时，前面有4个不明字节数据, 跳过它！ */
					/**NOTE 不管什么类型都是8字节对齐的！ */
					p = va_arg(ap, char[8]);
					memcpy(ftmp.hex,&p[4],4);
				}
				p = va_arg(ap, char[8]);
				memcpy(&ftmp.hex[4],p,4);

				// hexFloatTest(f);
				int32_t n;
				n = ftmp._f;
				myitoa(n, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				Serial_putc(&serialHandle[serial1], '.');
				n = (ftmp._f - n) * 1000000;
				if (n < 0)
					n = (unsigned)-n;
				myitoa(n, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				memcpy(ftmp.hex,&p[4],4);
				break;
			case '%':
				Serial_putc(&serialHandle[serial1], '%');
				break;
			default:
				Serial_putc(&serialHandle[serial1], '%');
				Serial_putc(&serialHandle[serial1], ch);
				break;
			}
			break;
		default:
			Serial_putc(&serialHandle[serial1], c);
			break;
		}
		format++;
	}
	va_end(ap);
	Serial_flush(&serialHandle[serial1]);
}
void usartPrintf(const char* format, ...)
{
	char str[30];
	char c = 0;
	char ch = 0;
	bool catchFloat = 0;
	va_list ap;
	va_start(ap, format);
	while ((c = *format))
	{
		switch (c)
		{
		case '%':
		{
			ch = *++format;

			switch (ch)
			{
			case 'b':
			{
				uint32_t n = va_arg(ap, int);
				myitoa(n, str, 2);
				Serial_puts(&serialHandle[serial1], str);
				break;
			}
			case 'c':
			{
				char c = va_arg(ap, int);
				Serial_putc(&serialHandle[serial1], c);
				break;
			}
			case 'd':
			{
				uint32_t n = va_arg(ap, int);
				myitoa(n, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				break;
			}
			case 'x':
			{
				uint32_t n = va_arg(ap, int);
				myitoa(n, str, 16);
				Serial_puts(&serialHandle[serial1], str);
				break;
			}
			case 'f':
			{
				if (!catchFloat)
				{
					catchFloat = 1;
					/**FIXME 第一次遇到浮点数据时，前面有4个不明字节数据, 跳过它！ */
					// int nn = va_arg(ap, char[4]);
					// Serial_puts(&serialHandle[serial1], "catchFloat:");
					// // hexFloatTest(*(double*)p);
					// myitoa(nn, str, 16);
					// Serial_puts(&serialHandle[serial1], str);
				}
				double f = va_arg(ap, double);
				hexFloatTest(f);
				int32_t n;
				n = f;
				myitoa(n, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				Serial_putc(&serialHandle[serial1], '.');
				n = (f - n) * 1000000;
				if (n < 0)
					n = (unsigned)-n;
				myitoa(n, str, 10);
				Serial_puts(&serialHandle[serial1], str);
				break;
			}
			case 's':
			{
				char* p = va_arg(ap, char*);
				Serial_puts(&serialHandle[serial1], p);
				break;
			}
			case '%':
			{
				Serial_putc(&serialHandle[serial1], '%');
				break;
			}
			default:
			{
				/*Serial_puts(&serialHandle[serial1], "#error:format invalid: <%");*/
				Serial_putc(&serialHandle[serial1], '%');
				Serial_putc(&serialHandle[serial1], ch);
				/*Serial_puts(&serialHandle[serial1], ">#");*/

				break;
			}
			}
		}
		break;
		default:
			Serial_putc(&serialHandle[serial1], c);
			break;
		}
		format++;
	}
	va_end(ap);
	Serial_flush(&serialHandle[serial1]);
}

使用串口1接收数据

char Serial_getc(SerialHandle_s* serialx)
{
	return serialx->packet.rxBuffer[serialx->packet.rxBufferSize++];
}
/*
Input: SerialHandle,  rxBuffer pointer, bytesOfread pointer
ouput: pointer of rxBuffer
*/
char* Serial_gets(SerialHandle_s* serialx)
{
	return (char*)(serialx->packet.rxBuffer);
}
// serialHandle[serial].packet.rxBuffer
/*
Input: SerialHandle,  rxBuffer pointer, bytesOfread pointer, bytes to read
ouput: pointer of rxBuffer
*/
char Serial_get(SerialHandle_s* serialx, uint16_t byteIndex)
{
	if (byteIndex >= USART_MAX_BUFFER_SIZE)
		return 0;
	return serialx->packet.rxBuffer[byteIndex - 1];
}
uint16_t IsSerialRxHasData(SerialHandle_s* serialx)
{
	if (serialx->DMApacket.status & rxDone)
	{
		return serialx->packet.rxBufferSize;
	}
	else
		return 0;
}
/**清空串口接收缓存 */
void Serial_Pruge(SerialHandle_s* serialx)
{
	serialx->DMApacket.status &= ~rxDone;
	serialx->packet.rxBufferSize = 0;
	memset(serialx->packet.rxBuffer, 0, USART_MAX_BUFFER_SIZE);
}

中断处理

void Serial_IRQHandler(SerialHandle_s* serialx)
{
	uint16_t bufferCount = 0;
	//串口空闲中断处理
	if (USART_GetITStatus(serialx->USARTx, USART_INT_IDLEF))
	{
		USART_ClearITPendingBit(serialx->USARTx, USART_INT_IDLEF);
		(void)(serialx->USARTx->DT);
		DMA_ChannelEnable(serialx->rxChannel, DISABLE);
		serialx->DMApacket.status |= rxDone;
		bufferCount = DMA_GetCurrDataCounter(serialx->rxChannel);
		serialx->DMApacket.rxBufferSize = USART_MAX_BUFFER_SIZE - bufferCount;
		if (serialx->packet.rxBufferSize >= USART_MAX_BUFFER_SIZE)
			serialx->packet.rxBufferSize = 0;
		memcpy(&serialx->packet.rxBuffer[serialx->packet.rxBufferSize], serialx->DMApacket.rxBuffer, serialx->DMApacket.rxBufferSize);
		serialx->packet.rxBufferSize += serialx->DMApacket.rxBufferSize;

		DMA_SetCurrDataCounter(serialx->rxChannel, USART_MAX_BUFFER_SIZE);
		DMA_ChannelEnable(serialx->rxChannel, ENABLE);
		USART_DMACmd(serialx->USARTx, USART_DMAReq_Rx, ENABLE);
	}
	//DMA中断处理
	if (USART_GetITStatus(serialx->USARTx, USART_INT_TRAC))
	{
		USART_ClearITPendingBit(serialx->USARTx, USART_INT_TRAC);
		/*turn off IrDA moudulate of usart3*/
		// if (serialx->USARTx == USART3) IrDA_Modulate_Cmd(DISABLE);
		DMA_ChannelEnable(serialx->txChannel, DISABLE);
		serialx->DMApacket.status |= txDone;
		serialx->DMApacket.status &= (~txBusy);
		serialx->DMApacket.txBufferSize = 0;
	}
}
void USART1_IRQHandler(void)
{
	Serial_IRQHandler(&serialHandle[serial]);
}
koronekos
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
串口DMA
m0_59733083的博客
10-23 855
工具：STM32F103R8、STM32CubeMX、KeilDMA，全称Direct Memory Access，即直接存储器访问。DMA传输将数据从一个地址空间复制到另一个地址空间，提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。当CPU初始化这个传输动作，传输动作本身是由DMA控制器来实现和完成的。DMA传输方式无需CPU直接控制传输，也没有中断处理方式那样保留现场和恢复现场过程，通过硬件为RAM和IO设备开辟一条直接传输数据的通道，使得CPU的效率大大提高。
串口 DMA 通信
guiqulaix的博客
11-05 1343
1DMA的基本介绍 1.1DMA定义 DMA，全称Direct Memory Access，即直接存储器访问。 DMA传输将数据从一个地址空间复制到另一个地址空间，提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。 我们知道CPU有转移数据、计算、控制程序转移等很多功能，系统运作的核心就是CPU， CPU无时不刻的在处理着大量的事务，但有些事情却没有那么重要，比方说数据的复制和存储数据，如果我们把这部分的CPU资源拿出来，让CPU去处理其他的复杂计算事务，是不是能够更好的利用CPU的资源呢？ 因此
串口(含DMA)——跟我一起写STM32(第五期)
DreamTrue520的博客
01-11 1073
DMA，全称Direct Memory Access，即直接存储器访问。众所周知，CPU无时不刻的在处理着大量的事务，但有些事情却没有那么重要，比方说数据的复制和存储数据，如果我们把这部分的CPU资源拿出来，让CPU去处理其他的复杂计算事务，是不是能够更好的利用CPU的资源呢？因此：转移数据（尤其是转移大量数据）是可以不需要CPU参与。比如希望外设A的数据拷贝到外设B，只要给两种外设提供一条数据通路，
stm32 USART接收总线空闲中断--USART_IT_IDLE
08-10
IDLE位不会再次被置高直到RXNE位被置起（即又检测到一次空闲总线）
stm32学习
sdkdslx的博客
08-27 602
波特率：每秒传送的位数 DMA(Direct Memory Access，直接内存存取) 是所有现代电脑的重要特色，它允许不同速度的硬件装置来沟通，而不需要依赖于 CPU 的大量中断负载。否则，CPU 需要从来源把每一片段的资料复制到暂存器，然后把它们再次写回到新的地方。在这个时间中，CPU 对于其他的工作来说就无法使用。 DMA 传输将数据从一个地址空间复制到另外一个地址空间。当CPU 初始...
DMA详解以及在串口数据处理上的应用
白云苍狗
06-17 3675
DMA串口数据发送接收。
串口DMA发送接收
qq_52362275的博客
10-23 3875
DMA串口接收
DMA控制串口
qq_57244669的博客
10-22 337
DMA控制串口输出
STM32的使用之SPI通信DMA模式
08-03
SPI（Serial Peripheral Interface）是一种同步串行通信协议，广泛应用于嵌入式系统中。而DMA（Direct Memory Access）则是一种能够自动完成数据传输的技术，能够释放CPU的负载，提高系统的性能。 在STM32F303VC微...
STM32103 DMA串口接收通信.zip
02-20
首先，STM32F103ZET6是一款基于ARM Cortex-M3内核的微控制器，它拥有丰富的外设接口，包括多个串行通信接口（UARTs）和DMA控制器。串口通信是设备间进行数据交换的常用方式，而DMA则能够提高数据传输效率，减轻CPU...
STM32F103的串口2DMA通讯
11-21
STM32F103的UART2模块提供了全双工异步串行通信功能，支持多种波特率和数据格式，如8位数据、奇偶校验位选择、停止位数量等。通过UART2，微控制器可以与外部设备进行高速、可靠的串行通信。 二、DMA简介 DMA是一种...
STM32串口DMA通信
06-21
串口，全称通用异步收发传输器（UART），是微处理器与外部设备进行串行通信的标准接口。在STM32微控制器中，通常有多个串口可供选择，如USART或UART，它们支持多种波特率、数据位、停止位和奇偶校验设置，适应不同的...
STM32F4串口DMA双缓冲模式DEMO
09-01
在这个串口DMA双缓冲模式DEMO中，我们主要探讨的是如何利用STM32F4的串行通信接口（UART）与DMA（Direct Memory Access）功能来实现高效的数据传输。 1. **STM32F4串口通信**：STM32F4的UART接口支持多种波特率，...
基于DMA的串口通信
weixin_68811361的博客
10-30 509
使用HAL库（或标准库）方式，设置USART1 波特率为115200，1位停止位，无校验位，分别采用中断方式、DMA方式完成下列任务： STM32系统给上位机（win10）连续发送“hello windows！”；当上位机给stm32发送字符“stop”后，stm32暂停发送“hello windows！”；发送一个字符“start”后，stm32继续发送；
使用DMA传输实现单片机高效串口转发——以STM32系列为例
u013441358的专栏
08-06 4953
STM32的DMA系统是一项强大的功能，允许高效的数据传输，同时减轻了CPU的负担。直接转发模式的核心实现过程为：对于接收数据的DMA通道，将串口的数据寄存器地址设置为源地址，并设置一个内存地址为目标地址。对于发送数据的DMA通道，将之前设置的内存地址设置为源地址，将另一个串口的数据寄存器地址设置为目标地址。中断服务程序处理：在USART1的中断服务程序中，读取接收到的数据，并触发与USART3关联的DMA传输。在USART3的中断服务程序中，读取接收到的数据，并触发与USART1关联的DMA传输。
串口DMA的使用
Damon_Sandy的博客
02-27 1035
串口 DMA
串口DMA知识梳理以及在Stm32的应用（HAL库）
热门推荐
冬瓜的博客
07-25 1万+
一.关于DMA 1.什么是DMA? 答：DMA(Direct Memory Access，直接存储器访问) 是所有现代电脑的重要特色，它允许不同速度的硬件装置来沟通，而不需要依赖于CPU的大量中断负载。否则，CPU需要从来源把每一片段的资料复制到暂存器，然后把它们再次写回到新的地方。在这个时间中，CPU对于其他的工作来说就无法使用。 2.DMA的意义是什么? 答：简单的来说，能控制主存内部读写，这样有利于减轻CPU负担，加快读取速度。 3.串口使用DMA与不使用DMA有什么区别？ 答：区别可大了.
串口DMA传输模式
山有木兮
11-01 5874
DMA传输模式前言一、DMA简介（一）DMA系统框图（二）DMA传输通道（三）DMA传输模式1.外设与存储器之间2.存储器与存储器之间3.小结二、使用DMA配置1.打开USART1及DMA模式2.读入数据总结 前言 DMA(Direct Memory Access)—直接存储器存取，是单片机的一个外设，它的主要功能是用来搬移数据，但是不需要占用 CPU，即在传输数据的时候， CPU 可以干其他的事情，好像是多线程一样。 一、DMA简介 （一）DMA系统框图 上方的框图，我们可以看到STM32内核.
江科大/江协科技 STM32学习笔记P7
最新发布
sususu_2001的博客
07-20 835
新名字在左边。
dma模式 spi通信
10-16
DMA（Direct Memory Access）模式是一种数据传输方式，它允许外设直接与内存进行数据传输，而无需经过CPU的干预。这种模式可以提高数据传输效率，减轻CPU的负担。 SPI（Serial Peripheral Interface）是一种同步串行通信协议，用于在微控制器和外设之间进行数据传输。它使用一根时钟线、一根主设备输出引脚、一根主设备输入引脚和一根从设备输入引脚来进行通信。 当使用DMA模式进行SPI通信时，数据传输过程可以更加高效。首先，通过配置DMA控制器的相关参数，可以使得数据的传输过程变得自动化，减少了CPU的干预。其次，通过DMA通道与SPI外设进行连接，可以实现数据的直接传输，减少了数据从外设到内存、再从内存到外设的多次复制过程，提高了数据传输速度。 在使用DMA模式进行SPI通信时，需要正确配置DMA控制器的相关参数，如源数据地址、目标数据地址、数据长度等。同时，还需要注意不同外设的DMA通道分配问题，以确保DMA通道与SPI外设正确连接。 总的来说，通过使用DMA模式进行SPI通信，可以提高数据传输效率，减轻CPU负担，使通信过程更加高效。同时，为了实现正常的数据传输，需要正确配置DMA控制器和SPI外设，确保DMA通道与外设正确连接。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值