RT-Thread-串口DMA,串口数据瞬时密集接收不覆盖处理方法RT-Thread问答社区

串口DMA,串口数据瞬时密集接收不覆盖处理方法

发布于 2023-10-08 16:11:38 浏览：909 订阅该版

```c
#include "uart_serial.h"
/*
 * 程序清单：这是一个串口设备 DMA 接收使用例程
 * 例程对外共有4个函数
 * mes_init函数是邮箱初始化函数,调用1次即可
 * serial_init函数是串口初始化函数可以调用多次初始化不同串口
 * 程序功能：通过DMA接收数据并通过邮箱转发数据,程序特点是可以在短时间内接收多条数据不覆盖,数据保存位置是通过
	malloc开辟的空间,可以按实际情况动态的开辟内存.节约内存使用.
	
********使用DMA时注意避免数据被分包需要更改以下两个函数*****
	void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
	{
		struct stm32_uart *uart;
		RT_ASSERT(huart != NULL);
		uart = (struct stm32_uart *)huart;
	#ifndef RT_SERIAL_USING_DMA
		dma_recv_isr(&uart->serial, UART_RX_DMA_IT_TC_FLAG);
	#endif
	}
	void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
	{
		struct stm32_uart *uart;
		RT_ASSERT(huart != NULL);
		uart = (struct stm32_uart *)huart;
	#ifndef RT_SERIAL_USING_DMA
		dma_recv_isr(&uart->serial, UART_RX_DMA_IT_HT_FLAG);
	#endif
	}
*/

#include <rtthread.h>
#include <rtdevice.h>

/* 串口信息结构*/
struct rx_msg
{
    rt_device_t dev;	//dev串口的设备句柄,含有串口相关的信息
    rt_size_t size;		//size串口DMA接收数据大小
};
/*串口数据处理结构体*/
typedef struct{
	uint8_t *buffer_p;		//串口数据
	uint16_t buffer_len;	//串口数据大小
	rt_device_t dev;		//dev串口的设备句柄,含有串口相关的信息
}uart_date;
/*串口DMA接收中断邮箱控制块 */
struct rt_mailbox uart_dma_recvmb;
/*用于放DMA邮件的内存池 邮件总数32 / 4 = 8个*/
static char uart_dma_mb_pool[32];
/*串口数据处理邮箱控制块*/
struct rt_mailbox uart_recvmb;
/*用于放数据处理邮件的内存池 邮件总数32 / 4 = 8个*/
static char uart_mb_pool[32];
/**************************
函数名:uart_input
参  数:dev串口的设备句柄,含有串口相关的信息,size串口DMA接收数据大小
作  用:DMA接收数据回调函数
返回值:
******************************/
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    struct rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;
    if(dev != RT_NULL && size != 0)
		rt_mb_send(&uart_dma_recvmb,  (rt_uint32_t)&msg);
    return result;
}
/**************************
函数名:mes_init
参  数:
作  用:邮箱初始化,应该在串口初始化前调用
返回值:
******************************/
int mes_init(void)
{
	rt_err_t result;
	/* 初始化一个 mailbox */
	result = rt_mb_init(&uart_dma_recvmb,
						"dma_mb",                      /* 名称是 dma_mb */
						&uart_dma_mb_pool[0],                /* 邮箱用到的内存池 */
						sizeof(uart_dma_mb_pool) / 4,        /* 邮箱中的邮件数目，因为一封邮件占 4 字节 */
						RT_IPC_FLAG_FIFO);          /* 采用 FIFO 方式进行线程等待 */
	if (result != RT_EOK)
	{
		rt_kprintf("init dma_mb failed.\n");
	}
	/* 初始化一个 mailbox */
	result = rt_mb_init(&uart_recvmb,
						"urt_mb",                      /* 名称是 urt_mb */
						&uart_mb_pool[0],                /* 邮箱用到的内存池 */
						sizeof(uart_mb_pool) / 4,        /* 邮箱中的邮件数目，因为一封邮件占 4 字节 */
						RT_IPC_FLAG_FIFO);          /* 采用 FIFO 方式进行线程等待 */
	if (result != RT_EOK)
	{
		rt_kprintf("init urt_mb failed.\n");
	}
	//最好添加一个内存池初始化,可以避免内存碎片化
	return result;
}
/**************************
函数名:serial_init
参  数:uart_name串口名称,eg:uart1/uart2,baud_rate波特率,bufsz:dma缓冲区大小
作  用:
返回值:
******************************/
int serial_init(char *uart_name,uint32_t baud_rate,uint16_t bufsz)
{
	rt_device_t serial;/* 串口设备句柄 */
	struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; /* 配置参数 */
    serial = rt_device_find(uart_name);/* 查找串口设备 */
    if (!serial)
    {
        rt_kprintf("find %s failed! \n", uart_name);
        return RT_ERROR;
    }
    rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX);/* 以 DMA 接收及轮询发送方式打开串口设备 */
	config.baud_rate = baud_rate;	
	config.bufsz = bufsz;
	rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);	/* 打开设备后才可修改串口配置参数 */	
    rt_device_set_rx_indicate(serial, uart_input);/* 设置接收回调函数 */
}
/**************************
函数名:serial_recv_thread_entry
参  数:
作  用:串口接收数据转发线程
返回值:
******************************/
void serial_recv_thread_entry(void *parameter)
{
    struct rx_msg *msg_p;
    rt_uint32_t rx_length;
	uint8_t *rx_buffer_p = RT_NULL;
	uart_date *uart_date_p;
	rt_uint32_t level;
    while (1)
    {
		if(rt_mb_recv(&uart_dma_recvmb, (rt_ubase_t *)&msg_p, RT_WAITING_FOREVER) == RT_EOK)
        {
			rx_buffer_p = (uint8_t *)rt_malloc(msg_p->size + 1);
			if(rx_buffer_p != RT_NULL)
			{
				if(msg_p->dev->parent.type != 0x89)
				{
					rt_kprintf("dev->parent->type %d \n",msg_p->dev->parent.type);
					rt_free(rx_buffer_p);
					return;
				}
				/* 关闭全局中断 */
				level = rt_hw_interrupt_disable();
				rx_length = rt_device_read(msg_p->dev, 0, rx_buffer_p, msg_p->size);
				/* 恢复全局中断 */
				rt_hw_interrupt_enable(level);
				//LOG_D("dev->parent->type %d ",msg_p->dev->parent.type);
				rx_buffer_p[rx_length++] = '\0';
				uart_date_p = (uart_date *)rt_malloc(sizeof(uart_date));
				if(uart_date_p != RT_NULL)
				{
					uart_date_p->buffer_p = rx_buffer_p;
					uart_date_p->buffer_len = rx_length;
					uart_date_p->dev = msg_p->dev;
					if(rt_mb_send(&uart_recvmb, (rt_uint32_t)uart_date_p) != RT_EOK)
					{
						if(uart_date_p->buffer_p)
						{
							rt_free(uart_date_p->buffer_p);
							uart_date_p->buffer_p = RT_NULL;
						}
						if(uart_date_p)
						{
							rt_free(uart_date_p);
							uart_date_p = RT_NULL;
						}
					}
				}
			}
           
        }
    }
}
/**************************
函数名:serial_dispose_thread_entry
参  数:
作  用:串口数据处理线程
返回值:
******************************/
void serial_dispose_thread_entry(void *parameter)
{
	rt_err_t ret = RT_EOK;
	uart_date *str;
	rt_uint32_t level;
	while(1)
	{
		if(rt_mb_recv(&uart_recvmb, (rt_ubase_t *)&str, RT_WAITING_FOREVER) == RT_EOK)
		{//接收到的数据在指针str中,处理后需要释放指针.
			if(str)
			{
				if(str->buffer_p)
				{
					rt_kprintf("%s recv date %s \n",str->dev->parent.name,str->buffer_p);
					if (!strcmp(str->dev->parent.name, "uart1"))
					{//串口数据解析程序放在此处
						rt_thread_mdelay(20);
					}
					else if (!strcmp(str->dev->parent.name, "uart2"))
					{//串口数据解析程序放在此处
						rt_thread_mdelay(20);
					}
					else if (!strcmp(str->dev->parent.name, "uart3"))
					{//串口数据解析程序放在此处
						rt_thread_mdelay(20);
					}
					if(str->dev->parent.type != 0x89)
					{
						rt_kprintf("dev->parent->type %d \n",str->dev->parent.type);
						rt_free(str->buffer_p);
						str->buffer_p = RT_NULL;
						rt_free(str);
						str = RT_NULL;
						return;
					}
					rt_device_write(str->dev, 0, str->buffer_p,str->buffer_len);/*串口发送数据*/
					rt_free(str->buffer_p);
					str->buffer_p = RT_NULL;
					rt_free(str);
					str = RT_NULL;
				}
			}
		}
		rt_thread_mdelay(20);
	}
}

```