一文详解FIFO处理机制

一、FIFOFIFO

是First Input First Output的缩写，先入先出队列。

使用的场景：一般是在不同的时钟域之间的数据传输（简单理解即：一个（读写）快，另外的一个（读写）慢的场景中。）

本质操作：就是将收的数据存储的一个线性的数组中，通过指针指向该数组的自加1（偏移）来遍历数据，达到读取或者写入的目的。

作用：起到缓冲环节，可防止数据的丢失。

对数据量大的进行存储，避免频繁的总线操作。并且可满足dma的操作。

在fifo中需要理解连个重要成员：

宽度：指一次写读操作的数据位数。

深度：存储多少个宽度的数据。（如：存储8个16位宽的数据）。

第一类、FIFO处理机制如下：

FIFO信息的定义：

/*
该结构体定义成员有
缓存区，
长度，
输出，
输入的计数。
*/
typedefstructfifo_t{
uint8_t*buf;
uint32_tsize;
uint32_tin;
uint32_tout;
}_fifo_str;
#definemin(x,y)((x)< (y)?(x):(y))  
1234567891011121314

1、初始化FIFO

fifo_strfifo_str;

intFifoInit(uint8_t*fifo_addr,uint32_tfifo_size)//初始化fifo
{
_fifo_str*p=&fifo_str;

if(fifo_addr==NULL||fifo_size==0)//判断数据是否为空
return-1;

memset((char*)p,0,sizeof(_fifo_str));//初始化结构体
p->buf=fifo_addr;//对应宽度
p->in=0;//输入计数
p->out=0;//输出计数
p->size=fifo_size;//对应深度
return0;
}
12345678910111213141516

2、数据的长度获取

//数据的实际使用数据空间长度
intFifoDataLen(void)
{
_fifo_str*p=&fifo_str;
return(p->in-p->out);//输入计数-输出计数
}
//剩余数据空间长度
intFifoSpaceLen(void)
{
_fifo_str*p=&fifo_str;

return(p->size-(p->in-p->out));//定义长度-（实际长度）
}
12345678910111213

3、FIFO的进和出处理

//获取fifo数据
//数据的内容缓存区，要读的长度
intFifoRead(uint8_t*buf,uint32_tlen)
{
uint32_ti=0,j=0;
_fifo_str*p=&fifo_str;

j=(p->out%p->size);//获取剩余空间长度未读量
len=min(len,p->in-p->out);//防止长度为超出实际拥有的数据长度，即让读取的长度在（0<设定len<定义的缓存区长度len ）这间的实际长度
i=min(len,p->size-j);//获取实际内容的长度，的数据长度
memcpy(buf,p->buf+j,i);//将数据通道里的数据拷贝给缓存区
memcpy(buf+i,p->buf,len-i);//将未有数据的区域存入，对应为写入数据的区域数据（即，有数据的填数据，没数据的地方补0）
p->out+=len;//已读的数据量
returnlen;//实际读到的数据长度
}
//对fifo写入数据
intFifoWrite(uint8_t*buf,uint32_tlen)
{
uint32_ti=0,j=0;
_fifo_str*p=&fifo_str;

j=p->in%p->size;//获取要写入的剩余空间长度
len=min(len,p->size-p->in+p->out);//得到实际写入的长度
i=min(len,p->size-j);//实际写入数据的长度
memcpy(p->buf+j,buf,i);//将写入的数据的内容拷贝值数据中。
memcpy(p->buf,buf+i,len-i);//补充多余空间的内容
p->in+=len;//记录实际写入数据的数量
returnlen;//返回写入的长度
}

123456789101112131415161718192021222324252627282930

4、置位记录量

//清空fifo中的记录量
voidFifoClear(void)
{
_fifo_str*p=&fifo_str;
p->in=0;
p->out=0;
}
1234567

5、应用处理机制

#defineLEN2048
uint8_tpdata[LEN]={0};
FifoInit(pdata,LEN);//初始化FIFO
uint8_tbuf[32]={0};
inttx_len=0;
uint8_ttx_buf[100]={0};

HAL_UART_Receive_IT(&huart1,buf,IT_LEN);//串口的接收中断开启
while(1)
{
tx_len=FifoDataLen();//获取数据长度
if(tx_len>0)
{
tx_len=(tx_len>100)?100:tx_len;//判读数据长度是否越界
FifoRead(tx_buf,tx_len);//读取在中断中写入FIFO缓存的数据
HAL_UART_Transmit(&huart1,tx_buf,tx_len,1000);//将读到的数据通过串口发送出来
}
}

接收回调函数中的处理
HAL_UART_RxCpltCallback(UART_HandleTypeDef*huart)
{
if(FifoSpaceLen()>=串口记录的接收数据长度)//判断写入FIFO空间的数据量是否大于接收的数据量
{
FifoWrite(huart->pRxBuffPtr,huart->RxXferCount);//想FIFO中写入数据
}
}
123456789101112131415161718192021222324252627

该FIFO的处理机制中用的记录是通过uint32t类型进行记录的，可能在遇到超出其数据极限的情况，导致数据通信异常。（该类型的数据极限较大，为特殊情况可能出现的情况）。

第二类、FIFO处理机制如下：

/*定义串口波特率和FIFO缓冲区大小，
分为发送缓冲区和接收缓冲区*/
#ifUART1_FIFO_EN==1
#defineUART1_BAUD115200
#defineUART1_TX_BUF_SIZE1*1024
#defineUART1_RX_BUF_SIZE1*1024
#endif

/*串口设备结构体
设置发送、接收缓存区（长度），
并设置两个变量，一个是指针，一个是计数
*/
typedefstruct
{
USART_TypeDef*uart;/*STM32内部串口设备指针*/

uint8_t*pTxBuf;/*发送缓冲区*/
uint8_t*pRxBuf;/*接收缓冲区*/
uint16_tusTxBufSize;/*发送缓冲区大小*/
uint16_tusRxBufSize;/*接收缓冲区大小*/

__IOuint16_tusTxWrite;/*发送缓冲区写指针*/
__IOuint16_tusTxRead;/*发送缓冲区读指针*/
__IOuint16_tusTxCount;/*等待发送的数据个数*/

__IOuint16_tusRxWrite;/*接收缓冲区写指针*/
__IOuint16_tusRxRead;/*接收缓冲区读指针*/
__IOuint16_tusRxCount;/*还未读取的新数据个数*/

void(*SendBefor)(void);/*开始发送之前的回调函数指针（主要用于RS485切换到发送模式）*/
void(*SendOver)(void);/*发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式）*/
void(*ReciveNew)(uint8_t_byte);/*串口收到数据的回调函数指针*/
uint8_tSending;/*正在发送中*/

}UART_T;

/*定义每个串口结构体变量*/
#ifUART1_FIFO_EN==1
staticUART_Tg_tUart1;
staticuint8_tg_TxBuf1[UART1_TX_BUF_SIZE];/*发送缓冲区*/
staticuint8_tg_RxBuf1[UART1_RX_BUF_SIZE];/*接收缓冲区*/
#endif

12345678910111213141516171819202122232425262728293031323334353637383940414243

怎样才叫做回调函数？回调函数，是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

区别指针函数和函数指针：

//指针函数：
int*fun（intx,inty）
int*x=fun(4,5);
在调用指针函数时，需要同类型的指针来接收函数返回值
是函数，返回值时指针
属于数据类型
123456
//函数指针：
int（*fun）（intx,inty）
intx(intx,inty);
x=fun;
fun=&x;
x=(*fun)(1，3);
是指针，指向函数。
属于函数名称
12345678

1.初始化串口FIFO对应的相关的变量

staticvoidUartVarInit(void)
{
#ifUART1_FIFO_EN==1
g_tUart1.uart=USART1;/*STM32串口设备*/
g_tUart1.pTxBuf=g_TxBuf1;/*发送缓冲区指针*/
g_tUart1.pRxBuf=g_RxBuf1;/*接收缓冲区指针*/
g_tUart1.usTxBufSize=UART1_TX_BUF_SIZE;/*发送缓冲区大小*/
g_tUart1.usRxBufSize=UART1_RX_BUF_SIZE;/*接收缓冲区大小*/
g_tUart1.usTxWrite=0;/*发送FIFO写索引*/
g_tUart1.usTxRead=0;/*发送FIFO读索引*/
g_tUart1.usRxWrite=0;/*接收FIFO写索引*/
g_tUart1.usRxRead=0;/*接收FIFO读索引*/
g_tUart1.usRxCount=0;/*接收到的新数据个数*/
g_tUart1.usTxCount=0;/*待发送的数据个数*/
g_tUart1.SendBefor=0;/*发送数据前的回调函数*/
g_tUart1.SendOver=0;/*发送完毕后的回调函数*/
g_tUart1.ReciveNew=0;/*接收到新数据后的回调函数*/
g_tUart1.Sending=0;/*正在发送中标志*/
#endif
}
1234567891011121314151617181920

明确中断服务程序的顺序：中断函数处理：void USART1_IRQHandler(void)—》UART中断请求：HAL_UART_IRQHandler(UART_HandleTypeDef *huart)—》中断使能：UART_Receive_IT— 》中断回调函数 HAL_UART_RxCpltCallback(huart);

#ifUART1_FIFO_EN==1
voidUSART1_IRQHandler(void)//系统中串口的中断函数入口
{
UartIRQ(&g_tUart1);
}
#endif

1234567

2.编辑自定义的UART中断请求

staticvoidUartIRQ(UART_T*_pUart)
{
uint32_tisrflags=READ_REG(_pUart->uart->ISR);
uint32_tcr1its=READ_REG(_pUart->uart->CR1);
uint32_tcr3its=READ_REG(_pUart->uart->CR3);

if((isrflags&USART_ISR_RXNE)!=RESET)
{
/*从串口接收数据寄存器读取数据存放到接收FIFO*/
uint8_tch;
ch=READ_REG(pUart->uart->RDR);
/*读串口接收数据寄存器*/
_pUart->pRxBuf[_pUart->usRxWrite]=ch;/*填入串口接收FIFO*/
if(++_pUart->usRxWrite>=_pUart->usRxBufSize)/*接收FIFO的写指针+1*/
{
_pUart->usRxWrite=0;
}
if(_pUart->usRxCount< _pUart->usRxBufSize)/*统计未处理的字节个数*/
{
_pUart->usRxCount++;
}
/*回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记*/
//if(_pUart->usRxWrite==_pUart->usRxRead)
//if(_pUart->usRxCount==1)
{
if(_pUart->ReciveNew)
{
_pUart->ReciveNew(ch);/*比如，交给MODBUS解码程序处理字节流*/
}
}
}
/*处理发送缓冲区空中断*/
if(((isrflags&USART_ISR_TXE)!=RESET)&&(cr1its&USART_CR1_TXEIE)!=RESET)
{
//if(_pUart->usTxRead==_pUart->usTxWrite)
if(_pUart->usTxCount==0)/*发送缓冲区已无数据可取*/
{
/*发送缓冲区的数据已取完时，禁止发送缓冲区空中断（注意：此时最后1个数据还未真正发送完毕）*/
//USART_ITConfig(_pUart->uart,USART_IT_TXE,DISABLE);
CLEAR_BIT(_pUart->uart->CR1,USART_CR1_TXEIE);/*使能数据发送完毕中断*/
//USART_ITConfig(_pUart->uart,USART_IT_TC,ENABLE);
SET_BIT(_pUart->uart->CR1,USART_CR1_TCIE);
}
Else/*还有数据等待发送*/
{
_pUart->Sending=1;/*从发送FIFO取1个字节写入串口发送数据寄存器*/
//USART_SendData(_pUart->uart,_pUart->pTxBuf[_pUart->usTxRead]);
_pUart->uart->TDR=_pUart->pTxBuf[_pUart->usTxRead];
if(++_pUart->usTxRead>=_pUart->usTxBufSize)
{
_pUart->usTxRead=0;
}
_pUart->usTxCount--;
}
}
/*数据bit位全部发送完毕的中断*/
if(((isrflags&USART_ISR_TC)!=RESET)&&((cr1its&USART_CR1_TCIE)!=RESET))
{
//if(_pUart->usTxRead==_pUart->usTxWrite)
if(_pUart->usTxCount==0)
{/*如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断*/
//USART_ITConfig(_pUart->uart,USART_IT_TC,DISABLE);
CLEAR_BIT(_pUart->uart->CR1,USART_CR1_TCIE);/*回调函数,一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线*/
if(_pUart->SendOver)
{
_pUart->SendOver();
}
_pUart->Sending=0;
}

else
{/*正常情况下，不会进入此分支*/
/*如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器*/
//USART_SendData(_pUart->uart,_pUart->pTxBuf[_pUart->usTxRead]);
_pUart->uart->TDR=_pUart->pTxBuf[_pUart->usTxRead];
if(++_pUart->usTxRead>=_pUart->usTxBufSize)
{
_pUart->usTxRead=0;
}
_pUart->usTxCount--;
}
}/*清除中断标志*/
SET_BIT(_pUart->uart->ICR,UART_CLEAR_PEF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_FEF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_NEF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_OREF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_IDLEF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_TCF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_LBDF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_CTSF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_CMF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_WUF);
SET_BIT(_pUart->uart->ICR,UART_CLEAR_TXFECF);
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394

3.填写数据到UART发送缓冲区。

并启动发送中断，中断处理函数发送完毕后，自动关闭发送中断 .

staticvoidUartSend(UART_T*_pUart,uint8_t*_ucaBuf,uint16_t_usLen)
{
uint16_ti;
for(i=0;i< _usLen; i++)  
 {  /*如果发送缓冲区已经满了，则等待缓冲区空*/
while(1)
{
__IOuint16_tusCount;DISABLE_INT();
usCount=_pUart->usTxCount;
ENABLE_INT();
if(usCount< _pUart->usTxBufSize)
{
break;
}
elseif(usCount==_pUart->usTxBufSize)/*数据已填满缓冲区*/
{
if((_pUart->uart->CR1&USART_CR1_TXEIE)==0)
{
SET_BIT(_pUart->uart->CR1,USART_CR1_TXEIE);
}
}
}/*将新数据填入发送缓冲区*/
_pUart->pTxBuf[_pUart->usTxWrite]=_ucaBuf[i];
DISABLE_INT();
if(++_pUart->usTxWrite>=_pUart->usTxBufSize)
{
_pUart->usTxWrite=0;
}
_pUart->usTxCount++;
ENABLE_INT();
}
SET_BIT(_pUart->uart->CR1,USART_CR1_TXEIE);/*使能发送中断（缓冲区空）*/
}

12345678910111213141516171819202122232425262728293031323334

4.向串口发送一组数据。

数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送

voidcomSendBuf(COM_PORT_E_ucPort,uint8_t*_ucaBuf,uint16_t_usLen)
{
UART_T*pUart;
pUart=ComToUart(_ucPort);
if(pUart==0)
{
return;
}
if(pUart->!=0)
{
pUart->SendBefor();/*如果是RS485通信，可以在这个函数中将RS485设置为发送模式*/
}
UartSend(pUart,_ucaBuf,_usLen);
}

123456789101112131415

向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送

voidcomSendChar(COM_PORT_E_ucPort,uint8_t_ucByte)
{
comSendBuf(_ucPort,&_ucByte,1);
}

123456

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

5.将COM端口号转换为UART指针

UART_T*ComToUart(COM_PORT_E_ucPort)
{
if(_ucPort==COM1)
{
#ifUART1_FIFO_EN==1
return&g_tUart1;
#else
return0;
#endif
}
else
{
Error_Handler(__FILE__,__LINE__);
return0;
}
}

1234567891011121314151617

6.从串口接收缓冲区读取1字节数据

staticuint8_tUartGetChar(UART_T*_pUart,uint8_t*_pByte)
{

uint16_tusCount;/*usRxWrite变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护*/

DISABLE_INT();usCount=_pUart->usRxCount;ENABLE_INT();/*如果读和写索引相同，则返回0*/

//if(_pUart->usRxRead==usRxWrite)
if(usCount==0)/*已经没有数据*/
{
return0;
}
else
{
*_pByte=_pUart->pRxBuf[_pUart->usRxRead];/*从串口接收FIFO取1个数据*/
/*改写FIFO读索引*/

DISABLE_INT();

if(++_pUart->usRxRead>=_pUart->usRxBufSize)
{
_pUart->usRxRead=0;
}
_pUart->usRxCount--;
ENABLE_INT();
return1;
}

}
1234567891011121314151617181920212223242526272829

从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

uint8_tcomGetChar(COM_PORT_E_ucPort,uint8_t*_pByte)
{

UART_T*pUart;
pUart=ComToUart(_ucPort);
if(pUart==0)
{
return0;
}
returnUartGetChar(pUart,_pByte);
}
123456789101112

接收数据的调用顺序是：comGetChar–》UartGetChar

7.判断发送缓冲区是否为空

uint8_tUartTxEmpty(COM_PORT_E_ucPort)
{
UART_T*pUart;
uint8_tSending;

pUart=ComToUart(_ucPort);
if(pUart==0)
{
return0;
}

Sending=pUart->Sending;

if(Sending!=0)
{
return0;
}
return1;
}

1234567891011121314151617181920

8.清零串口接收缓冲区

voidcomClearRxFifo(COM_PORT_E_ucPort)
{
UART_T*pUart;
pUart=ComToUart(_ucPort);
if(pUart==0)
{
return;
}
pUart->usRxWrite=0;
pUart->usRxRead=0;
pUart->usRxCount=0;
}
123456789101112

9.清零串口发送缓冲区

voidcomClearTxFifo(COM_PORT_E_ucPort)
{
UART_T*pUart;

pUart=ComToUart(_ucPort);
if(pUart==0)
{
return;
}

pUart->usTxWrite=0;
pUart->usTxRead=0;
pUart->usTxCount=0;
}
1234567891011121314

10.输入输出的重定向

intfputc(intch,FILE*f)
{
#if1/*将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回*/
comSendChar(COM1,ch);
returnch;
#else/*采用阻塞方式发送每个字符,等待数据发送完毕*/
/*写一个字节到USART1*/
USART1->DR=ch;
/*等待发送结束*/
while((USART1->SR&USART_SR_TC)==0)
{}
returnch;
#endif
}


intfgetc(FILE*f)
{
#if1/*从串口接收FIFO中取1个数据,只有取到数据才返回*/
uint8_tucData;
while(comGetChar(COM1,&ucData)==0);
returnucData;
#else
/*等待接收到数据*/
while((USART1->SR&USART_SR_RXNE)==0)
{}
return(int)USART1->DR;
#endif
}
1234567891011121314151617181920212223242526272829

11.应用层初始化：

//FIFO串口初始化
UartVarInit(void);
//串口参数配置
voidbsp_SetUartParam(USART_TypeDef*Instance,uint32_tBaudRate,uint32_tParity,uint32_tMode)
{
UART_HandleTypeDefUartHandle;
/*##-1-配置串口硬件参数######################################*/
/*异步串口模式(UARTMode)*/
/*配置如下:
-字长=8位
-停止位=1个停止位
-校验=参数Parity
-波特率=参数BaudRate
-硬件流控制关闭(RTSandCTSsignals)*/
UartHandle.Instance=Instance;
UartHandle.Init.BaudRate=BaudRate;
UartHandle.Init.WordLength=UART_WORDLENGTH_8B;
UartHandle.Init.StopBits=UART_STOPBITS_1;
UartHandle.Init.Parity=Parity;
UartHandle.Init.HwFlowCtl=UART_HWCONTROL_NONE;
UartHandle.Init.Mode=Mode;
UartHandle.Init.OverSampling=UART_OVERSAMPLING_16;

if(HAL_UART_Init(&UartHandle)!=HAL_OK)
{
Error_Handler(__FILE__,__LINE__);
}
}
//对应的串口波特率配置
voidcomSetBaud(COM_PORT_E_ucPort,uint32_t_BaudRate)
{
USART_TypeDef*USARTx;
USARTx=ComToUSARTx(_ucPort);
if(USARTx==0)
{
return;
}
bsp_SetUartParam(USARTx,_BaudRate,UART_PARITY_NONE,UART_MODE_TX_RX);
}
//硬件初始化
voidInitHardUart(void)
{
GPIO复用....
/*配置NVICtheNVICforUART*/
HAL_NVIC_SetPriority(USART1_IRQn,0,1);
HAL_NVIC_EnableIRQ(USART1_IRQn);

/*配置波特率、奇偶校验*/
bsp_SetUartParam(USART1,UART1_BAUD,UART_PARITY_NONE,UART_MODE_TX_RX);

CLEAR_BIT(USART1->SR,USART_SR_TC);/*清除TC发送完成标志*/
CLEAR_BIT(USART1->SR,USART_SR_RXNE);/*清除RXNE接收标志*/
//USART_CR1_PEIE|USART_CR1_RXNEIE
SET_BIT(USART1->CR1,USART_CR1_RXNEIE);/*使能PE.RX接受中断*/
}
在主循环中

comGetChar(COM1,&read);//获取一个字节数据
comSendBuf(COM1,(uint8_t*)buf,strlen(buf));//发送数据
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061

审核编辑：汤梓红