一文详解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
审核编辑：汤梓红
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。
举报投诉
-
fifo
+关注
关注
3文章
369浏览量
43086 -
FIRST
+关注
关注
0文章
11浏览量
11524 -
串口
+关注
关注
14文章
1485浏览量
74528
原文标题：对串口接收FIFO处理机制的解读
文章出处：【微信号：技术让梦想更伟大，微信公众号：技术让梦想更伟大】欢迎添加关注！文章转载请注明出处。
发布评论请先 登录
相关推荐
单片机的中断处理机制
单片机的中断处理机制什么是中断？为什么要使用中断(中断的特点)什么是中断源？中断源有哪些中断机制的流程中断优先级多个中断同时发生什么是中断？当CPU执行程序时，由于发生了某种随机的事件（内部或外部
发表于 12-07 11:14
ad7928采样的时候是如何处理机制的？
ad7928 采样的时候是如何处理机制的
AD7928Data2.Wriite_SEQ = 0X11;
AD7928Data2.DONT_TCARE_9_ADD2 = 0X01
发表于 12-08 07:36
VxWorks下MPC860的中断处理机制及其应用
嵌入式实时操作系统VxWorks提供的中断处理机制中断延迟小，应用编程方便。MPC860是目前在网络与通信领域应用非常广泛的一款微处理器芯片。论文详细分析了VxWorks及MPC860的中断处理
发表于 06-10 14:08
•12次下载
iFix组态软件中基于队列的命令处理机制研究
提出了一种在iFix 组态软件中创建消息队列的方法，利用这种消息队列实现了对控制命令的执行情况的跟踪与处理。这种基于队列的命令处理机制确保了组态软件的控制命令能够
发表于 12-23 14:06
•22次下载
Cortex-M3的异常处理机制分析
Cortex-M3的异常处理机制分析
详细阐述CortexM3异常的分类、优先级、进入和退出，以及在CortexM3异常处理机制中使用的新技术——迟到（late?arriving）和
发表于 03-29 15:07
•1812次阅读
异步fifo详解
异步fifo详解 一. 什么是异步FIFO FIFO即First in First out的英文简称，是一种先进先出的数据缓存器，与普通存储器的区别在于没有外部读写的地址线，缺点是只能
C++程序异常处理机制是什么
那么C++设计了一套异常处理机制，一方面能够使得异常处理和正常运行代码进行分离，使得程序更加模块化；另一方面，C++的异常处理可以不需要异常处理在异常发生时的同一个函数，而是可以在更上
工商网监
评论