DMA模式的串口通信

最新推荐文章于 2024-04-16 22:23:05 发布
最新推荐文章于 2024-04-16 22:23:05 发布
阅读量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
    评论
STM32采用串口DMA方式向上位机连续发送数据
pink_lemon的博客
11-05 1363
目录 一、DMA 1.DMA的概念 2.DMA传输数据的四个要素 3.STM32的DMA控制器特点 4.传输方式 二、用DMA方式连续向上位机发送数据 三、总结 四、参考资料 一、DMA 1.DMA的概念 DMA常用于在外设与存储器之间以及存储器与存储器之间进行高速数据传输。DMA传输过程的初始化和启动由CPU完成，传输过程由DMA控制器来执行，无需CPU参与，从而节省CPU资源，提高利用率。 2.DMA传输数据的四个要素 3.STM32的DMA控制器特点 1.STM32
串口(含DMA)——跟我一起写STM32(第五期)
DreamTrue520的博客
01-11 1073
DMA，全称Direct Memory Access，即直接存储器访问。众所周知，CPU无时不刻的在处理着大量的事务，但有些事情却没有那么重要，比方说数据的复制和存储数据，如果我们把这部分的CPU资源拿出来，让CPU去处理其他的复杂计算事务，是不是能够更好的利用CPU的资源呢？因此：转移数据（尤其是转移大量数据）是可以不需要CPU参与。比如希望外设A的数据拷贝到外设B，只要给两种外设提供一条数据通路，
使用DMA传输实现单片机高效串口转发——以STM32系列为例
u013441358的专栏
08-06 4953
STM32的DMA系统是一项强大的功能，允许高效的数据传输，同时减轻了CPU的负担。直接转发模式的核心实现过程为：对于接收数据的DMA通道，将串口的数据寄存器地址设置为源地址，并设置一个内存地址为目标地址。对于发送数据的DMA通道，将之前设置的内存地址设置为源地址，将另一个串口的数据寄存器地址设置为目标地址。中断服务程序处理：在USART1的中断服务程序中，读取接收到的数据，并触发与USART3关联的DMA传输。在USART3的中断服务程序中，读取接收到的数据，并触发与USART1关联的DMA传输。
基于中断/DMA方式的串口通信
m0_69439838的博客
11-02 50
DMA，即直接内存访问（Direct Memory Access），是一种计算机系统中的数据传输技术，旨在提高数据传输的效率和性能。DMA允许外设（如硬盘驱动器、网络适配器、图形卡等）直接访问系统内存，而不需要通过中央处理器（CPU）的干预，从而减轻CPU的负担。
STM32】 DMA原理，步骤超细详解，一文看懂DMA
modi000的博客
03-19 5508
如需转载请注明地址：https://blog.csdn.net/as480133937/article/details/104927922 DMA的基本介绍 什么是DMA (DMA的基本定义) DMA，全称Direct Memory Access，即直接存储器访问。 DM...
【嵌入式基础】串口中断通信VS串口DMA通信
qq_52791446的博客
10-21 4282
对比串口通信的不同方式，体味串口中断通信和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接口支持多种波特率，...
STM32F103标准库-串口使用DMA进行数据收发
qq_43476908的博客
11-08 5847
STM32F103标准库 串口使用DMA进行数据收发。
串口DMA方式发送&接收
热门推荐
且听风吟的博客
01-16 3万+
串口DMA方式收发         笔者使用的是STM32F407VET6，共包含6路串口，页尾处程序已将全部串口的DMA收发配置完成，本文仅以串口1为例进行讲解。（查看代码可直接跳至第二节或页尾处下载） 1 STM32F4 DMA  简介         DMA，全称为：Direct Memory Access，即直接存储器访问。DMA 传输方式无需 CPU 直接控制传输，也没有中断处理方...
STM32—DMA使用
自我升级中
01-23 1408
DMA是指外部设备不通过CPU而直接与系统内存交换数据的接口技术。为了好理解，可以称之为只能传输数据的CPU。
分别采用串口中断方式和串口DMA方式进行串口通信
m0_73659470的博客
11-10 1475
分别采用串口中断方式和串口DMA方式进行串口通信
STM32初学记录3(USART串口)
qq_64620475的博客
08-05 142
USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器： USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里。自带波特率发生器，最高达4.5Mbits/s可配置数据位长度（8/9）、停止位长度（0.5/1/1.5/2）可选校验位（无校验/奇校验/偶校验）
中断+3种串口收发方式（阻塞+中断+DMA）
cherish1211的博客
06-24 5069
中断+3种串口收发方式（阻塞+中断+DMA）
【STM32+HAL+Proteus】系列学习教程---串口USART（DMA 方式）定长，不定长收发。
最新发布
面包板扎的专栏
04-16 1619
DMA（Direct Memory Access）直接内存访问。
STM32的HAL库开发系列 - 串口DMA发送
ittuann的博客
01-14 1173
STM32的HAL库开发系列 - 串口DMA发送
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、付费专栏及课程。

余额充值