STM32串口环形缓冲区实现

stm32串口环形缓冲区

一、ringbuff.h

#ifndef _RING_BUFFER_H_
#define _RING_BUFFER_H_

enum
{
	RING_FALSE,
	RING_TRUE,
};

enum
{
	RING_ERR,
	RING_OK,
};

typedef struct ringBuff{
    unsigned int head;     //队列的头部            
    unsigned int tail;     //队列的尾部          
    unsigned int size;     //队列的大小         
    unsigned char *buffer; //数据缓冲区指针
}RingBuff_t, *pRingBuff_t;

void RingBuff_Init(RingBuff_t *pRingBuff, unsigned char *pBuff, unsigned int buf_size);
int RingBuff_ReadNByte (RingBuff_t *pRingBuff, unsigned char *pData, int size);
int RingBuff_WriteNByte(RingBuff_t *pRingBuff, unsigned char *pData, int size);
int RingBuff_GetLen(RingBuff_t *pRingBuff);
unsigned char RingBuff_GetHeadItem(RingBuff_t *pRingBuff);
unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index);

#endif

二、ringbuff.c

#include "ring_buffer.h"
#include "main.h"
#include "stdio.h"

//环形缓冲区初始化
void RingBuff_Init(RingBuff_t *pRingBuff, unsigned char *pBuff, unsigned int buf_size)
{
	if(NULL == pRingBuff || NULL == pBuff)
		return;
	
	pRingBuff->head = 0;
	pRingBuff->tail = 0;
	pRingBuff->size = buf_size;
	pRingBuff->buffer = pBuff;
}

//判断环形缓冲区是否为空
int RingBuff_isEmpty(RingBuff_t *pRingBuff) 
{
	if(NULL == pRingBuff)
		return RING_FALSE;
	
	if(pRingBuff->head == pRingBuff->tail)
	{
		return RING_TRUE;
	}
	return RING_FALSE;
}

//判断环形缓冲区是否为满
static int RingBuff_isFull(RingBuff_t *pRingBuff)
{
	if(NULL == pRingBuff)
		return RING_FALSE;

	if((pRingBuff->tail+1)%pRingBuff->size == pRingBuff->head)
	{
		return RING_TRUE;
	}
	return RING_FALSE;
}

//从环形缓冲区取出一个字节
int RingBuff_ReadOneByte(RingBuff_t *pRingBuff, unsigned char *pData)
{
	if(NULL == pRingBuff || NULL == pData)
		return RING_ERR;

	//判空
	if(RING_TRUE == RingBuff_isEmpty(pRingBuff))
	{
		//printf("ring buffer is empty!\r\n");
		return RING_ERR;
	}

	*pData = pRingBuff->buffer[pRingBuff->head];
	pRingBuff->head = (pRingBuff->head+1)%pRingBuff->size;
	return RING_OK;
}

//向环形缓冲区写入一个字节
static int RingBuff_WriteOneByte(RingBuff_t *pRingBuff, unsigned char *pData)
{
	if(NULL == pRingBuff || NULL == pData)
		return RING_ERR;

	//判满
	if(RING_TRUE == RingBuff_isFull(pRingBuff))
	{
		//printf("ring buffer is full!\r\n");
		return RING_ERR;
	}

	pRingBuff->buffer[pRingBuff->tail] = *pData;
	pRingBuff->tail = (pRingBuff->tail+1)%pRingBuff->size;
	return RING_OK;
}

//从环形缓冲区读多个字节
int RingBuff_ReadNByte(RingBuff_t *pRingBuff, unsigned char *pData, int size)
{
	if(NULL == pRingBuff || NULL == pData)
		return RING_ERR;

	for(int i = 0; i < size; i++)
	{
		RingBuff_ReadOneByte(pRingBuff, pData+i);
	}
	return RING_OK;
}

//向环形缓冲区写多个字节
int RingBuff_WriteNByte(RingBuff_t *pRingBuff, unsigned char *pData, int size)
{
	if(NULL == pRingBuff || NULL == pData)
		return RING_ERR;

	for(int i = 0; i < size; i++)
	{
		RingBuff_WriteOneByte(pRingBuff, pData+i);
	}
	return RING_OK;
}

//获取当前环形缓冲区中数据长度
int RingBuff_GetLen(RingBuff_t *pRingBuff)
{
	if(NULL == pRingBuff)
		return RING_ERR;

	if(pRingBuff->tail >= pRingBuff->head)
	{
		return pRingBuff->tail - pRingBuff->head;
	}
	
	return pRingBuff->tail + pRingBuff->size - pRingBuff->head;
}

//获取当前头部数据
unsigned char RingBuff_GetHeadItem(RingBuff_t *pRingBuff)
{
	if(NULL == pRingBuff)
		return RING_ERR;
	
	return pRingBuff->buffer[pRingBuff->head];
}

//获取指定下标数据
unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index)
{
	if(NULL == pRingBuff || index > pRingBuff->size-1)
		return RING_ERR;

	return pRingBuff->buffer[index%pRingBuff->size];
}

三、应用例程(配合串口接受DMA使用)

extern UART_HandleTypeDef huart1;
RingBuff_t Uart1_RingBuff;
uint8_t USART1_DMA_Buff[USART1_DMA_SIZE];
uint8_t USART1_RingBuff[USART1_RING_BUFF_SIZE];

//通讯接口环形缓冲区初始化
void Data_InterFace_Init(void)
{
	RingBuff_Init(&Uart1_RingBuff, USART1_RingBuff, USART1_RING_BUFF_SIZE);
}

//串口DMA接收完成回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(&huart1 == huart)
	{
		//将数据拷贝到串口环形缓冲区中
		RingBuff_WriteNByte(&Uart1_RingBuff, USART1_DMA_Buff, USART1_DMA_SIZE);
		
		//使能串口接收DMA
		HAL_UART_Receive_DMA(&huart1, USART1_DMA_Buff, USART1_DMA_SIZE);
	}
}
//使能串口DMA
void Board_Init(void)
{
	//接口缓冲区初始化
	Data_InterFace_Init();
	
	//使能串口1接收DMA
	HAL_UART_Receive_DMA(&huart1, USART1_DMA_Buff, USART1_DMA_SIZE);
}

/* USER CODE END Header_Uart_Dma_Task */
void Uart_Dma_Task(void const * argument)
{
  /* USER CODE BEGIN Uart_Dma_Task */
    pParameter_t parameter = NULL;
    pRingBuff_t pRingBuff = NULL;
	uint8_t data_buff[10];
	uint8_t flag, t_data;
	
	parameter = (pParameter_t)argument;
	pRingBuff = parameter->Data_InterFace[UART1_NUM].pRingBuffCB;
	/* Infinite loop */
	for(;;)
	{	
		while(!RingBuff_isEmpty(pRingBuff))
		{
			if(RingBuff_GetHeadItem(pRingBuff) == 0xEB
			 &&RingBuff_GetIndexItem(pRingBuff, pRingBuff->head+1) == 0x90)
			{
				if(RingBuff_GetLen(pRingBuff) >= 10)
				{
					RingBuff_ReadNByte(pRingBuff, data_buff, 10);
					flag = 1;
				}
				else
				{
					break;
				}
			}
			else
			{
				RingBuff_ReadOneByte(pRingBuff, &t_data);
			}
		}
		
		//判断是否有收到报文
		if(1 == flag)
		{
			flag = 0;
			BSP_Uart1_SendData(data_buff, 10);
		}
		
		osDelay(10);
	}
  /* USER CODE END Uart_Dma_Task */
}