万能的FIFO篇-阿里云开发者社区

前言

在计算机中，先入先出队列是一种传统的按序执行方法，先进入的指令先完成并引退，跟着才执行第二条指令（指令就是计算机在响应用户操作的程序代码，对用户而言是透明的）。当CPU在某一时段来不及响应所有的指令时，指令就会被安排在FIFO队列中，比如0号指令先进入队列，接着是1号指令、2号指令……当CPU完成当前指令以后就会从队列中取出0号指令先行执行，此时1号指令就会接替0号指令的位置，同样，2号指令、3号指令……都会向前挪一个位置。

在数据处理上也是同理，所以引入了万能的FIFO篇，可移植性强，更便于我们工程中处理数据(感谢前辈，顺手牵羊~)

lib_fifo.h

/**
 * @ 摘要:
 * 
 * @file lib_fifo.h
 * @author xin.han
 * @ 完成日期: 2021-02-07
 */
#ifndef __LIB_FIFO_H__
#define __LIB_FIFO_H__
#ifdef __cplusplus
extern "C"{
#endif
#include "lib_cfg.h"
#define pri_min(x,y) ((x) < (y) ? (x) : (y)) /*x和y取小值*/
#define pri_max(x,y) ((x) > (y) ? (x) : (y)) /*x和y取大值*/
/*
 * 1. size/in/out type must be unsinged
 * 2. in/out type must be same
 * 3. size must be pow o two
 * */
/*fifo数据结构 缓冲区指针,换成去长度,写入缓冲区指针,读取缓冲区指针*/
typedef struct 
{
  INT8U *buffer;
  INT16U size;
  volatile INT16U in;
  volatile INT16U out;
}/*__attribute__((packed))*/ FIFO, *pFIFO;
/***********************************************************
 * fifo缓冲区初始化
 * @param fifo缓冲区指针
 * @param 分配空间数组指针
 * @param 分配空间长度
 * @return 初始化是否正确 1正确 0错误
 */
BOOLEAN FifoInit( pFIFO ,INT8U * ,INT16U );
/*************************************************************
 * 释放fifo缓冲区 fifo指针为空
 * @param fifo缓冲区指针
 */
void FifoCancel( pFIFO );
/*************************************************************
 * 清空fifo缓冲区 将fifo缓冲区数据清空
 * @param
 */
void FifoClear( pFIFO );
/***************************************************************
 * 写入fifo缓冲区,将已知长度的数据写入fifo缓冲区
 * @param fifo缓冲区指针
 * @param 数据区指针
 * @param 数据长度
 * @return写入数据长度
 */
INT16U FifoWrite( pFIFO , INT8U *, INT16U );
/***************************************************************
 * 读取fifo缓冲区数据,从fifo缓冲区读取已知长度的数据放入数据区
 * @param fifo缓冲区指针
 * @param 数据区指针
 * @param 要读取数据长度
 * @return 读取数据的长度
 */
INT16U FifoRead( pFIFO , INT8U *, INT16U );
/****************************************************************
 * 获取fifo缓冲区剩余空间大小
 * @param fifo缓冲区指针
 * @return fifo缓冲区剩余空间大小
 */
INT16U FifoGetFreeSize( pFIFO );
/*****************************************************************
 * 获取fifo缓冲区存储数据长度
 * @param fifo缓冲区指针
 * @return fifo缓冲区存储数据长度
 */
INT16U FifoGetDataSize( pFIFO );
/******************************************************************
 * 向fifo写入一个字节数据
 * @param fifo缓冲区指针
 * @param 要写入的数据值
 * @return 返回0 写入失败,返回1 写入成功
 */
INT16U FifoWriteByte(  pFIFO , INT8U );
/******************************************************************
 * 从fifo读取一个字节数据
 * @param fifo缓冲区指针
 * @param 读取数据存放地址
 * @return 返回0 读取失败,返回1 读取成功
 */
INT16U FifoReadByte(  pFIFO , INT8U *);
#ifdef __cplusplus
}
#endif
#endif

lib_fifo.c

/**
 * @ 摘要:
 * 
 * @file lib_fifo.c
 * @author xin.han
 * @ 完成日期: 2021-02-07
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "lib_fifo.h"
/*******************************************************
 * 查找2的整次幂最大数
 * @param size
 * @return
 */
static INT16U roundup_pow_of_two(INT16U size)
{
  int l;
  int i;
  //如果数据个数为0则返回错误
  if(size == 0)
  return 0;
  //字节个数乘以8 = 32
  l = sizeof(size)*8;
  // if pow of two, bin format:inlcude one bit-1
  //如果size是2的整次幂,则返回size
  if (!(size & (size - 1)))
  return size;
  //4INT8Us max (pow of two) is 0x8000
  //如果size大于等于0x8000,返回0x8000
  if (size >= 0x8000)
  return 0x8000;
  //l - 2: exclude 0x8000
  //从size最高位查询,找出为1的最高位,则返回的size也是2的整次幂
  for (i = l-2; i >= 0; i--) {
  if ((size >> i) == 1) {
    size = (1 << (i+1));
    //logwarn("i is %d\n", i);
    break;
  }
  }
  return size;
}
/********************************************************************
 * Fifo初始化 给fifo分配空间 并将fifo参数初始化
 * @param pfifo Fifo指针
 * @param pbyData 数据包指针
 * @param size 数据个数
 * @return
 */
BOOLEAN FifoInit(pFIFO pfifo, INT8U *pbyData, INT16U size)
{
  INT8U *buffer = NULL;//定义空指针
  // if not pow of two
  //如果数据个数不是2的整次幂
  if (size & (size - 1)){
  //logwarn("size is not pow of two, size is 0x%x\n", size);
  //找出size最大2的整次幂数
  size = roundup_pow_of_two( size );
  //如果大于等于最大要求值则返回错误
  if (size >= 0x8000){
    return FALSE;
  }
  }
  //check pfifo->in/out
  //如果fifo缓冲区的插入值类型与取出值类型不一样则返回错误
  if (sizeof(pfifo->in) != sizeof(pfifo->out))
  {
  // printf("sizeof(pfifo->in) != sizeof(pfifo->out)\n");
  return FALSE;
  }
  //给Fifo定义空间
  buffer = pbyData;//(INT8U *)malloc( size ); //calloc
  //如果缓冲区空间为0则返回错误
  if (!buffer){
  //logerr("malloc(%d) failed!\n", size);
  return FALSE;
  }
  //log("malloc() is ok, size is %d(0x%x)\n", size, size);
  //给fifo缓冲区赋值
  pfifo->buffer = buffer;
  pfifo->size = size;
  pfifo->in = pfifo->out = 0;
//  printf("FifoInit pfifo_buffer is %p\n",buffer);
//  printf("FifoInit pfifo_size is %d(0x%x)\n",size, size);
  return TRUE;
}
/*****************************************************************
 * 释放fifo缓冲区
 * @param pfifo
 */
void FifoCancel(pFIFO pfifo)
{
  //如果fifo缓冲区指针为空,则已经释放
  if (pfifo == NULL)
  return;
  //如果fifo缓冲区指向的空间不为空则需要释放空间,将指针赋值为空
  if (pfifo->buffer != NULL)
  pfifo->buffer = NULL;//free (pfifo->buffer);
  pfifo->size = 0;//缓冲区长度赋值为0
  pfifo->in = pfifo->out = 0;//fifo缓冲区的提取和插入标志赋值为0
}
/*******************************************************************
 * 清空fifo缓冲区
 * @param pfifo
 */
void FifoClear(pFIFO pfifo)
{
  //如果fifo缓冲区指针为空,则返回
  if (pfifo == NULL)
  return;
  //初始化fifo缓冲区提取和插入值
  pfifo->in = pfifo->out = 0;
}
/***********************************************************************
 * 写fifo缓冲区,将buffer数据写入fifo缓冲区
 * @param pfifo fifo指针
 * @param buffer 数据区指针
 * @param len 数据长度
 * @return
 */
INT16U FifoWrite(pFIFO pfifo, INT8U *buffer, INT16U len)   
{  
  INT16U l;  
  /*如果fifo缓冲区指针为空 数据区指针为空 数据长度为0 则返回错误*/
  if (pfifo == NULL || buffer == NULL || len == 0)
  return FALSE;
  /*如果fifo缓冲区中的数据区指针为空返回错误*/
  if (pfifo->buffer == NULL)
  return FALSE;
  /*选择数据长度和fifo缓冲区剩余空间长度中较小的值*/
  len = pri_min(len, pfifo->size - pfifo->in + pfifo->out);   
  /* first put the data starting from pfifo->in to buffer end */   
  l = pri_min(len, pfifo->size - (pfifo->in & (pfifo->size - 1)));   
  // printf("len is %d, l os %d, 2 is %d\n", len, l, (pfifo->in & (pfifo->size - 1)));
  /*先将数据插入到上次插入结束后的位置,插入直到fifo缓冲区最大值*/
  memcpy(pfifo->buffer + (pfifo->in & (pfifo->size - 1)), buffer, l);
  /* then put the rest (if any) at the beginning of the buffer */   
  /*然后将剩余的数据从fifo缓冲区开始位置插入*/
  memcpy(pfifo->buffer, buffer + l, len - l);
  /* Ensure that we add the INT8Us to the fifo before we update the pfifo->in index. */  
  pfifo->in += len;   
  return len;   
}  
/*********************************************************************
 * 从fifo缓冲区提取数据
 * @param pfifo
 * @param buffer
 * @param len
 * @return
 */
INT16U FifoRead(pFIFO pfifo, INT8U *buffer, INT16U len)   
{
  INT16U l;  
  /*如果fifo缓冲区指针为空 数据区指针为空 数据长度为0 则返回错误*/
  if (pfifo == NULL || buffer == NULL || len == 0)
  return FALSE;
  /*如果fifo缓冲区中的数据区指针为空返回错误*/
  if (pfifo->buffer == NULL)
  return FALSE;
  //选择fifo缓冲区有效数据长度和要读取的数据长度较小的值
  len = pri_min(len, pfifo->in - pfifo->out);   
//  printf("pri_min len is %d\n",len);
  /* Ensure that we sample the pfifo->in index -before- we start removing INT8Us from the fifo. */   
  /* first get the data from pfifo->out until the end of the buffer */   
  /*读取数据是否跨过fifo缓冲区最大值*/
  l = pri_min(len, pfifo->size - (pfifo->out & (pfifo->size - 1)));
//  printf("pri_min l is %d\n",l);
  memcpy(buffer, pfifo->buffer + (pfifo->out & (pfifo->size - 1)), l);   
  /* then get the rest (if any) from the beginning of the buffer */   
  memcpy(buffer + l, pfifo->buffer, len - l);   
  /* Ensure that we remove the INT8Us from the fifo -before- we update the pfifo->out index. */   
  pfifo->out += len;   
//  printf("return len is %d\n",len);
  return len;   
}  
/***************************************************************************
 * 获取fifo缓冲区剩余空间字节数
 * @param pfifo
 * @return
 */
INT16U FifoGetFreeSize(pFIFO pfifo)
{
  /*如果fifo缓冲区指针为空则返回0*/
  if (pfifo == NULL)
  return 0;
  /*否则返回fifo剩余空间字节数*/
  return (pfifo->size - pfifo->in + pfifo->out);
}
/****************************************************************************
 * 获取fifo存储数据字节数
 * @param pfifo
 * @return
 */
INT16U FifoGetDataSize(pFIFO pfifo)
{
  /*fifo缓冲区指针为空则返回0*/
  if (pfifo == NULL)
  return 0;
  /*否则返回fifo存储数据字节数*/
  return (pfifo->in - pfifo->out);
}
/*****************************************************************************
 *fifo写入单字节
 * @param pfifo
 * @param value
 * @return
 */
INT16U FifoWriteByte( pFIFO pfifo, INT8U value)
{ 
  INT16U index;
  /*fifo缓冲区指针为空则返回0*/
  if (pfifo == NULL)
  return 0;
  /*如果fifo缓冲区中的数据区指针为空返回错误*/
  if (pfifo->buffer == NULL)
  return 0;
  /*如果fifo已没有剩余空间则返回0*/
  if (pfifo->size - pfifo->in + pfifo->out == 0 )
          return 0;
  /*找出要插入的位置*/
  index = pfifo->in & (pfifo->size - 1);
  /*将该字节数据写入缓冲区*/
  pfifo->buffer[ index ] = value;
  /*插入指针加1*/
  pfifo->in++;
  return 1;
}
/**********************************************************
 * fifo读取单字节数据
 * @param pfifo
 * @param buffer
 * @return
 */
INT16U FifoReadByte( pFIFO pfifo, INT8U *buffer)
{ 
  INT16U index;
  /*fifo缓冲区指针为空则返回0*/
  if (pfifo == NULL || buffer == NULL)
  return 0;
  /*如果fifo缓冲区中的数据区指针为空返回错误*/
  if (pfifo->buffer == NULL)
  return 0;
  /*如果fifo已没有存储数据则返回0*/
  if ( pfifo->in - pfifo->out == 0 )
    return 0;
  /*找出要读取字节的位置*/
  index = pfifo->out & (pfifo->size - 1);
  *buffer = pfifo->buffer[ index ];
  pfifo->out++;
  return 1;
}

lib_ring.h

#ifndef __LIB_RING_H_
#define __LIB_RING_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include "lib_cfg.h"
typedef struct 
{
  INT32U ticks;
  INT8U item_len;
  INT8U data[24];
} RING_ITEM;
typedef struct
{
  INT8U capacity;
  INT8U pToBuf;   /* offset from start of buffer where to write next */
  INT8U pFromBuf; /* offset from start of buffer where to read next */
  INT8U bufSize;  /* size of ring in bytes */
  RING_ITEM *buf;    /* pointer to start of buffer */
} RING_BUFFER, *pRING_BUFFER;
INT8U clearRingBuffer( RING_BUFFER *buffer );
INT8U IsEmpty( RING_BUFFER *buffer );
INT8U initRingBuffer( RING_BUFFER *buffer, INT8U capacity, RING_ITEM *items );
INT8U putRing( RING_BUFFER *buffer, RING_ITEM *item );
INT8U getRing( RING_BUFFER *buffer, RING_ITEM *dest_item );
#ifdef __cplusplus
}
#endif
#endif /* __LIB_RING_H_ */

lib_ring.c

#include <stdio.h>
#include <stdlib.h>
#include "lib_ring.h"
INT8U IsEmpty( RING_BUFFER *buffer )
{
  return buffer->bufSize == 0;
}
static INT8U IsFull( RING_BUFFER *buffer )
{
    return buffer->bufSize == buffer->capacity;
}
INT8U clearRingBuffer(RING_BUFFER *buffer)
{
  if (buffer == NULL) {
    return 0;
  }
  buffer->bufSize = 0;
  buffer->pFromBuf = 0;
  buffer->pToBuf = 0;
  return 1;
}
INT8U initRingBuffer(RING_BUFFER *buffer, INT8U capacity, RING_ITEM *items)
{
  if (items != (void *)0)
  {
    buffer->buf = items;
    buffer->capacity = capacity;
    clearRingBuffer(buffer);
    return 0;
  }
  else
  {
    return 1;
  }
}
static INT8U Succ( RING_BUFFER *buffer, INT8U Value )
{
    if( ++Value == buffer->capacity )
        Value = 0;
    return Value;
}
INT8U putRing( RING_BUFFER *buffer, RING_ITEM *item )
{
    if ( buffer == NULL || item == NULL ) {
      return 0;
    }
    if( IsFull( buffer ) )
    {
      return 0;
    }
    else
    {
        buffer->buf[ buffer->pToBuf ] = *item;
        buffer->pToBuf = Succ( buffer, buffer->pToBuf );
        buffer->bufSize++;
        return 1;
    }
}
INT8U getRing(RING_BUFFER *buffer, RING_ITEM *dest_item)
{
  if ( buffer == NULL || dest_item == NULL )
  {
    return 0;
  }
  if( IsEmpty( buffer ) )
  {
    return 0;
  }
  else
  {
    *dest_item = buffer->buf[ buffer->pFromBuf ];
    buffer->pFromBuf = Succ( buffer, buffer->pFromBuf );
    buffer->bufSize--;
    return 1;
  }
}

万能的FIFO篇

前言

lib_fifo.h

lib_fifo.c

lib_ring.h

lib_ring.c

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

万能的FIFO篇

前言

lib_fifo.h

lib_fifo.c

lib_ring.h

lib_ring.c

热门文章

最新文章

相关电子书