stm32HAL库 串口接收不定长数据（DMA传输）

已于 2023-12-15 14:21:35 修改
阅读量4.2k 收藏 49
点赞数 10
文章标签： stm32 单片机 arm
于 2022-05-20 14:27:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33954661/article/details/124882073
版权

相信大家很多初学者都会遇到串口接收不定长数据的情况。
对于初学者可能看着有点难理解，多看几遍就好，亲测能用。
话不多说上菜上菜！！！！

此代码是本人在具体工程应用，实测稳定。

有不足之处还请发现问题的小伙伴指出，大家共同进步。

此处省略stm32CubeIDE 配置过程*********************************
串口配置过程如下：
其他几个串口也是如下进行配置（正常使用的话只使能DMA接收即可）

波特率设置
波特率设置
NVIC中断配置
在这里插入图片描述
DMA配置
在这里插入图片描述

新建usr_uart_rec.h头文件，内容如下：

#ifndef USR_UART_REC_USR_UART_REC_H_
#define USR_UART_REC_USR_UART_REC_H_

#include "main.h"

#define MAX_REC_COUNT  36//可随根据实际使用情况进行调整

typedef struct
{
	uint8_t ReciveBuff[MAX_REC_COUNT];//接收缓冲区
	uint8_t uartRecCount;//接收数据的计数器
	uint8_t RecFlag:1;//接收标志位  主要用于数据处理
}DMAuartReciveBuff;


typedef struct
{
	DMAuartReciveBuff userUart1;
	DMAuartReciveBuff userUart2;
	DMAuartReciveBuff userUart3;
	DMAuartReciveBuff userUart4;
	DMAuartReciveBuff userUart5;
	DMAuartReciveBuff userUart6;
}UART_REC;


typedef struct
{
	uint8_t DMAbuff[MAX_REC_COUNT];
}uBbuffer;

typedef struct
{
	uBbuffer usr_uart1;
	uBbuffer usr_uart2;
	uBbuffer usr_uart3;
	uBbuffer usr_uart4;
	uBbuffer usr_uart5;
	uBbuffer usr_uart6;
}UART_MEMCPY_BUFF;//复制DMA的数据  用于解析

extern UART_MEMCPY_BUFF usr_dma_Data;
extern UART_REC userUart;

void USR_UART_Init();//串口初始化函数
void UART1_IRQ_DataGet();//在串口中断服务函数中添加此函数用于缓存数据
void UART2_IRQ_DataGet();
void UART3_IRQ_DataGet();
void UART4_IRQ_DataGet();
void UART5_IRQ_DataGet();
void UART6_IRQ_DataGet();

#endif /* USR_UART_REC_USR_UART_REC_H_ */

新建usr_uart_rec.c头文件，内容如下：


#include "main.h"
#include "usart.h"
#include "usr_uart_rec.h"
#include "string.h"



UART_REC userUart;
UART_MEMCPY_BUFF usr_dma_Data;


void USR_UART_Init()//串口初始化函数
{
	__HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);//启动IDLE中断
	__HAL_UART_ENABLE_IT(&huart3,UART_IT_IDLE);//启动IDLE中断
	__HAL_UART_ENABLE_IT(&huart4,UART_IT_IDLE);//启动IDLE中断
	__HAL_UART_ENABLE_IT(&huart5,UART_IT_IDLE);//启动IDLE中断
	__HAL_UART_ENABLE_IT(&huart6,UART_IT_IDLE);//启动IDLE中断
	__HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);//启动IDLE中断

	userUart.userUart1.uartRecCount = 0;

//	  注意串口DMA 发送时候应该如下顺序初始化DMA 和串口
//	  MX_DMA_Init();
//	  MX_USART1_UART_Init();
//	  MX_UART4_Init();
//	  MX_UART5_Init();
//	  MX_USART2_UART_Init();
//	  MX_USART3_UART_Init();
//	  MX_USART6_UART_Init();

	HAL_UART_Receive_DMA(&huart1, (uint8_t *)&userUart.userUart1.ReciveBuff, sizeof(userUart.userUart1.ReciveBuff));
	HAL_UART_Receive_DMA(&huart2, (uint8_t *)&userUart.userUart2.ReciveBuff, sizeof(userUart.userUart2.ReciveBuff));
	HAL_UART_Receive_DMA(&huart3, (uint8_t *)&userUart.userUart3.ReciveBuff, sizeof(userUart.userUart3.ReciveBuff));
	HAL_UART_Receive_DMA(&huart4, (uint8_t *)&userUart.userUart4.ReciveBuff, sizeof(userUart.userUart4.ReciveBuff));
	HAL_UART_Receive_DMA(&huart5, (uint8_t *)&userUart.userUart5.ReciveBuff, sizeof(userUart.userUart5.ReciveBuff));
	HAL_UART_Receive_DMA(&huart6, (uint8_t *)&userUart.userUart6.ReciveBuff, sizeof(userUart.userUart6.ReciveBuff));
}



void UART1_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(USART1 == huart1.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart1);
			userUart.userUart1.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//用于统计DMA接收到了多少数据
			userUart.userUart1.RecFlag = true;
//			printf("userUart.userUart1.uartRecCount is %d",userUart.userUart1.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart1.DMAbuff,&userUart.userUart1.ReciveBuff,userUart.userUart1.uartRecCount);
//			memset((uint8_t *)&userUart.userUart1.ReciveBuff,0,sizeof(userUart.userUart1.ReciveBuff));
//			userUart.userUart1.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart1, (uint8_t *)&userUart.userUart1.ReciveBuff, sizeof(userUart.userUart1.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		}
	}
}

void UART2_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(USART2 == huart2.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart2);
			userUart.userUart2.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart2_rx);//用于统计DMA接收到了多少数据
			userUart.userUart2.RecFlag = true;
//			printf("userUart.userUart2.uartRecCount is %d",userUart.userUart2.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart2.DMAbuff,&userUart.userUart2.ReciveBuff,userUart.userUart2.uartRecCount);
//			memset((uint8_t *)&userUart.userUart2.ReciveBuff,0,sizeof(userUart.userUart2.ReciveBuff));
//			userUart.userUart2.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart2, (uint8_t *)&userUart.userUart2.ReciveBuff, sizeof(userUart.userUart2.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		}
	}
}

void UART3_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(USART3 == huart3.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart3);
			userUart.userUart3.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart3_rx);//用于统计DMA接收到了多少数据
			userUart.userUart3.RecFlag = true;
//			printf("userUart.userUart3.uartRecCount is %d",userUart.userUart3.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart3.DMAbuff,&userUart.userUart3.ReciveBuff,userUart.userUart3.uartRecCount);
//			memset((uint8_t *)&userUart.userUart3.ReciveBuff,0,sizeof(userUart.userUart3.ReciveBuff));
//			userUart.userUart3.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart3, (uint8_t *)&userUart.userUart3.ReciveBuff, sizeof(userUart.userUart3.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart3);
		}
	}
}

void UART4_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(UART4 == huart4.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart4);
			userUart.userUart4.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_uart4_rx);//用于统计DMA接收到了多少数据
			userUart.userUart4.RecFlag = true;
//			printf("userUart.userUart1.uartRecCount is %d",userUart.userUart1.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart4.DMAbuff,&userUart.userUart4.ReciveBuff,userUart.userUart4.uartRecCount);
//			memset((uint8_t *)&userUart.userUart4.ReciveBuff,0,sizeof(userUart.userUart4.ReciveBuff));
//			userUart.userUart4.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart4, (uint8_t *)&userUart.userUart4.ReciveBuff, sizeof(userUart.userUart4.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart4);

			//顺便处理收到的数据
		}
	}
}

void UART5_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(UART5 == huart5.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart5,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart5);
			userUart.userUart5.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_uart5_rx);//用于统计DMA接收到了多少数据
			userUart.userUart5.RecFlag = true;
//			printf("userUart.userUart1.uartRecCount is %d",userUart.userUart1.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart5.DMAbuff,&userUart.userUart5.ReciveBuff,userUart.userUart5.uartRecCount);
//			memset((uint8_t *)&userUart.userUart5.ReciveBuff,0,sizeof(userUart.userUart5.ReciveBuff));
//			userUart.userUart5.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart5, (uint8_t *)&userUart.userUart5.ReciveBuff, sizeof(userUart.userUart5.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart5);
		}
	}
}




void UART6_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
{
	if(USART6 == huart6.Instance)
	{
		if(__HAL_UART_GET_FLAG(&huart6,UART_FLAG_IDLE))
		{
			HAL_UART_DMAStop(&huart6);
			userUart.userUart6.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart6_rx);//用于统计DMA接收到了多少数据
			userUart.userUart6.RecFlag = true;
//			printf("userUart.userUart1.uartRecCount is %d",userUart.userUart1.uartRecCount);
//			memcpy(&usr_dma_Data.usr_uart6.DMAbuff,&userUart.userUart6.ReciveBuff,userUart.userUart6.uartRecCount);
//			memset((uint8_t *)&userUart.userUart6.ReciveBuff,0,sizeof(userUart.userUart6.ReciveBuff));
//			userUart.userUart1.uartRecCount = 0;
			HAL_UART_Receive_DMA(&huart6, (uint8_t *)&userUart.userUart6.ReciveBuff, sizeof(userUart.userUart6.ReciveBuff));
			__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		}
	}
}

注释掉的部分可用于调试，本人不建议在中断中处理大量数据，因为容易死机哦。

在使用串口DMA的时候需要注意以下问题：
在使用 stm32CubeIDE生成代码之后，按照官方的初始化流程有点点问题，会导致串口接收不到数据，所以要稍作修改，改变初始化流程：如下所示（最主要的是先初始化DMA 再初始化相关串口）这是一位博主针对DMA串口接收数据失败写的文章

  MX_DMA_Init();
  MX_USART1_UART_Init();
  MX_UART4_Init();
  MX_UART5_Init();
  MX_USART2_UART_Init();
  MX_USART3_UART_Init();
  MX_USART6_UART_Init();

最后在stm32f4xx_it.c 如下，将自定义的函数加到中断服务函数中即可 例如：

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */

  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */
  UART1_IRQ_DataGet();
  /* USER CODE END USART1_IRQn 1 */
}

void USART2_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */

  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE BEGIN USART2_IRQn 1 */
  UART2_IRQ_DataGet();
  /* USER CODE END USART2_IRQn 1 */
}

void USART3_IRQHandler(void)
{
  /* USER CODE BEGIN USART3_IRQn 0 */

  /* USER CODE END USART3_IRQn 0 */
  HAL_UART_IRQHandler(&huart3);
  /* USER CODE BEGIN USART3_IRQn 1 */
  UART3_IRQ_DataGet();
  /* USER CODE END USART3_IRQn 1 */
}

void UART4_IRQHandler(void)
{
  /* USER CODE BEGIN UART4_IRQn 0 */

  /* USER CODE END UART4_IRQn 0 */
  HAL_UART_IRQHandler(&huart4);
  /* USER CODE BEGIN UART4_IRQn 1 */
  UART4_IRQ_DataGet();
  /* USER CODE END UART4_IRQn 1 */
}

void UART5_IRQHandler(void)
{
  /* USER CODE BEGIN UART5_IRQn 0 */

  /* USER CODE END UART5_IRQn 0 */
  HAL_UART_IRQHandler(&huart5);
  /* USER CODE BEGIN UART5_IRQn 1 */
  UART5_IRQ_DataGet();
  /* USER CODE END UART5_IRQn 1 */
}

void USART6_IRQHandler(void)
{
  /* USER CODE BEGIN USART6_IRQn 0 */

  /* USER CODE END USART6_IRQn 0 */
  HAL_UART_IRQHandler(&huart6);
  /* USER CODE BEGIN USART6_IRQn 1 */
  UART6_IRQ_DataGet();  
  /* USER CODE END USART6_IRQn 1 */
}

需要注意的是 此代码在接收完成后会有一个软件标志位被置1，使用完数据之后需要用户手动清零。

userUart.userUart1.RecFlag = true;//串口1接收完成的中断标志

userUart.userUart1.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//用于统计DMA接收到了多少数据

具体如何使用呢，举个例子（串口1）：

uint8_t PowerRecBuff[23];

void PowerDataAnalyze()//解析电池的数据
{
	if(userUart.userUart1.RecFlag )
	{
		userUart.userUart1.RecFlag = false;//清除标志位
		memcpy((uint8_t *)&PowerRecBuff,(uint8_t *)&userUart.userUart1.ReciveBuff, userUart.userUart1.uartRecCount);
		RSOC = PowerRecBuff[23];
	/*
	使用者亦可在此处进行数据处理
	具体怎么处理不用我多说了吧---哈哈 加油。
	*/
		userUart.userUart1.uartRecCount = 0;
		memset((uint8_t *)&userUart.userUart1.ReciveBuff,0, sizeof(userUart.userUart1.ReciveBuff));
	}
}

自此完结。此代码亲测可用，对于初学者可能有点难理解，加油！共勉。

zhao1peng
关注
  • 10
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
HAL库+CubeMX实现Stm32串口不定长接收
07-22
HAL库+CubeMX实现Stm32串口不定长接收，使用的版型为Stm32f407，详情请看：https://lindoglog.blog.csdn.net/article/details/107463926 HAL库+CubeMX实现Stm32串口不定长接收，使用的版型为Stm32f407，详情请看：https://lindoglog.blog.csdn.net/article/details/107463926
HAL库+CubeMX+Stm32F405实现串口DMA不定长收发
07-25
HAL库+CubeMX+Stm32F405实现串口DMA不定长收发 HAL库+CubeMX+Stm32F405实现串口DMA不定长收发，详情请看：
STM32 串口接收定长，不定长数据
最新发布
wuyiyu_的博客
04-12 1916
开启串口的接收中断：参数：huart：这是一个指向 UART_HandleTypeDef 结构体的指针，用于标识特定的 UART 外设实例。该结构体包含了该 UART 实例的各种配置和状态信息。pData：这是一个指向存储接收数据的缓冲区的指针。当接收到数据时，数据将被存储在该缓冲区中。Size：这是要接收的数据的字节数。函数将尝试从 UART 接收指定数量的字节到 pData 缓冲区中。串口接收完成回调函数：// 当串口接收到数据就调用该回调函数。
【STM32cubeMX+HAL库】RS485双机通讯
Porter_007的博客
05-07 7587
485(一般称作RS485/ELA-485)隶属于OSI模型物理层，是串行通讯的一种。电气特性规定为2线，半双工，多点通信的类型。它的电气特性和RS-232大不一样。用缆线两端的电压差值来表示传递信号。RS485仅仅规定了接受端和发送端的电气特性。它没有规定或推荐任何数据协议。RS485的特点包括：1,接口电平低，不易损坏芯片。RS485的电气特性：逻辑“1”以两线间的电压差为+(2-6)V表示；逻辑“0”以两线间的电压差为-(2~6)V表示。
【STM32 HAL库实战】串口DMA + 空闲中断 实现不定长数据接收
soledade的博客
12-25 5027
我们可以简单的理解为，在条件判断都满足的情况下，发生串口空闲中断以后，会开启DMA功能并调用回调函数HAL_UARTEx_RxEventCallback()。于是我们可以得知，调用HAL_UARTEx_ReceiveToIdle_DMA函数后只要发生了串口空闲事件，就会产生串口中断。HAL库中通过HAL_UARTEx_ReceiveToIdle_DMA()函数可以方便的实现串口空闲中断，下面来分析一下这个实现的过程。调用函数会将当前的串口接收类型设置为HAL_UART_RECEPTION_TOIDLE。
STM32使用HAL库DMA+空闲中断实现串口不定长数据接收
u012841414的博客
02-11 8465
环境： STM32CubeIDE STM32F103RB WIN10 HAL库V1.8 首先配置串口： 开启串口中断：开启DMA接收：配置中断分组：然后生成代码就可以了。 进入代码，添加串口1中断服务程序： #define UART_RX_LEN 1024 // 一次最大接收的数据量 uint8_t UART_RX_BUF[UART_RX_LEN]; // DMA数据接收缓存 __IO uint16_t UART_RX_STA = 0; // 第15bi.
【 STM32 HAL 详解】CubeIDE实现串口接收不定长数据DMA+串口重定向
qq_44078824的博客
04-03 3560
基于STM32G0,使用DMA方式，实现串口接收不定长的数据
STM32使用串口IDLE中断的两种接收不定长数据的方式
一个渣渣的世界博客
03-18 2万+
现在有很多数据处理都要用到不定长数据，而单片机串口的RXNE中断一次只能接收一个字节的数据，没有缓冲区，无法接收一帧多个数据，现提供两种利用串口IDLE空闲中断的方式接收一帧数据，方法如下:方法1：实现思路：采用STM32F103的串口1，并配置成空闲中断IDLE模式且使能DMA接收，并同时设置接收缓冲区和初始化DMA。那么初始化完成之后，当外部给单片机发送数据的时候，假设这帧数据长度是200个字节
STM32串口接收不定长数据的几种方法
weixin_44224427的博客
05-19 7389
在使用串口接收其他设备的数据时，应该针对数据的特点，譬如单字节与多字节、数据量大小、速度等，采用不同的接收方式。下面针对接收一帧含有多个字节的不定长数据接收方式进行讨论。 1、第一种方法：采用标志位(比如0X0D,0X0A)结束法 非常常见的一种接收方式，正点原子的例程便是采用的这种方式，以回车键作为一次数据结束的标志。缺点是在有些情况下会导致数据丢失（可能返回数据中0x0d、0a本身为有效数据）。所以，这种方法适合约定协议的数据帧，也就是说发送数据的设备也必须以相应的约定字节作为一次数据的结束。 .
STM32G系列 HAL串口DMA接收（不定长）2023年5月更新
qinxin4的专栏
11-11 1万+
stm32串口的使用，可以说是这个芯片的灵魂了，DMA、IDLE空闲中断、不定长接收，这些都让stm32的串口产生异常强大的力量。如何用好这些特性，并避免踩坑，本文对几点主要配置和逻辑做了整理。感谢CSDN上各位大虾的无偿分享，本文因知识点太零散，所以无法一一做好文章引用，如果哪位大虾发现本文的某些内容是来自您的文章，请私信我添加您的链接，这里先行谢过了。...
【STM32】HAL库 STM32CubeMX——DMA (串口DMA发送接收)
qq_52187415的博客
10-23 4806
DMA，全称Direct Memory Access，即直接存储器访问。DMA传输将数据从一个地址空间复制到另一个地址空间，提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。我们知道系统的运作核心是CPU，CPU无时无刻都在完成计算，控制，转存数据等大量事务，如果处理事务过多就会导致CPU运转不过来，因此有些程序就会出现卡顿；仔细想想如果将一些不重要的转移，存储数据交给其它外设来做，就可以减轻CPU负荷，让CPU转手去做其它更加复杂的事。如何实现呢？
STM32 HAL库串口+DMA空闲中断接收不定长数据
11-04
STM32 HAL库+串口DMA+空闲中断（IDLE）实现不定长数据接收，可以用来参考学习使用，简单易懂。
STM32_HAL+串口+DMA发送和不定长度数据接收
08-15
STM32_HAL+串口+DMA发送和接收,可做项目研发，串口用DMA发送和接收，减轻CPU负担。
真正实现了STM32 HAL串口不定长数据的接收发送功能(DMA方式，不用限定单次接收长度和添加结束标志)
06-08
网上使用HAL串口时很多都没有实现不定长数据的接收，要么是限定数据长度，要么是加“0x0a 0x0d”来控制接收完成，找了很久都没有真正找到一个能用的，在很多通信中不可能是定义的，或是加上“0x0a 0x0d”来实现的，...
STM32串口空闲中断DMA接收不定长数据消息队列
01-11
STM32串口空闲中断DMA接收不定长数据消息队列。 串口1空闲中断+DMA，接收不定长数据
STM32 HAL CubeMX 串口IDLE接收空闲中断+DMA
热门推荐
Z小旋
03-22 4万+
关于DMA原理部分讲解，及CubeMx配置部分，请参考该文章 【STM32】HAL库 STM32CubeMX教程十一—DMA (串口DMA发送接收) 本篇文章我们仅针对例程进行详解剖析 本篇文章提供两种方法： 一种是 ：IDLE 接收空闲中断+DMA 一种是： IDLE 接收空闲中断+RXNE接收数据中断 都可完成串口数据的收发 知识点介绍： STM32 IDLE 接收空闲中断 功能： 在使用...
DMA的原理--利用CubeMX配置DMA--HAL库实现DMA代码的解读
weixin_67335336的博客
08-05 1612
DMA的原理、DMA作用、如何配置DMA、DMA外设的HAL库实现、STM32CubeMX配置DMA、HAL库实现DMA代码解读
HAL库教程9：串口接收不定长数据
geekYatao
04-16 1万+
  串口收到的两组数据之间，往往会有一定的时间间隔。可以判断这个间隔，来实现无需结束符，无需指定长度，串口可接收不定长数据的功能。如果串口在一定的时间内没有收到新的数据，可以认为一组数据已经接收完毕了。思路是用定时器来设置一个“闹钟”，连续的一段时间没有收到新的数据，闹钟响起，就把已经收到的数据打包，做相应处理。 定时器溢出时间配置   首先修改定时器的溢出时间。本文规定使用5ms的间隔。在某些通...
HAL库配置RS485通信
m0_61973119的博客
01-16 749
在配置好串口的基础上完成RS485的配置。
stm32hal库串口dma接收ad数据
07-27
在STM32 HAL库中，可以使用DMA方式进行串口接收AD数据。可以使用函数HAL_UART_Receive_DMA来实现。该函数的参数包括UART句柄、接收数据缓冲区的指针和待接收数据的个数。通过调用该函数，可以在DMA方式下接收一定数量的数据。\[2\] 例如，可以使用以下代码来实现DMA方式下的串口接收AD数据： ```c uint8_t adData\[10\]; // 定义接收数据缓冲区 HAL_UART_Receive_DMA(&huart1, adData, 10); // 使用DMA方式接收10个字节的数据 ``` 在接收完成后，可以在DMA中断中调用串口接收中断回调函数HAL_UART_RxCpltCallback进行后续处理。在该回调函数中，可以对接收到的AD数据进行处理。\[2\] ```c void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { // 在这里进行接收数据的处理 // adData数组中存放了接收到的AD数据 } ``` 需要注意的是，在使用DMA方式进行串口接收时，需要配置DMA通道和DMA传输方向。具体的配置可以参考STM32 HAL库的相关文档和例程。 #### 引用[.reference_title] - *1* *2* *3* [[016] [STM32] 串口HAL库轮询、中断、DMA方式传输数据](https://blog.csdn.net/kouxi1/article/details/123876915)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值