一个循环队列在linux下的应用

typedef struct 
{
int ReadPt;    /* 循环队列只能在队列头读操作 */
int WritePt;/* 循环队列只能在队列尾写操作 */
unsigned char DataQueue[RingBufferMaxSize];

}RingBuffer;

/**************************************************
*Function:    InitQueue( RingBuffer *Queue )
*
*ShortDesc:    创建一个空队列
*
*Inputs:    循环队列地址
*
****************************************************/
void InitQueue( RingBuffer *Queue )
{
     int i;

    Queue->ReadPt = Queue->WritePt = 0;
    
    for (i = 0; i < RingBufferMaxSize; i++ )
    {
        Queue->DataQueue[i] = 0;
    }
}
/**************************************************
*Function:    IsFullQueue(RingBuffer *Queue)
*
*ShortDesc:    判断队列是否是满
*
*Inputs:    循环队列地址
*
****************************************************/
bool IsFullQueue( RingBuffer *Queue )
{
    /* 写指针+1等于读指针 */
    if ( (Queue->WritePt + 1) % RingBufferMaxSize == Queue->ReadPt )
        return true;
    else
        return false;
}
/**************************************************
*Function:    IsEmptyQueue(RingBuffer *Queue)
*
*ShortDesc:    判断队列是否是空
*
*Inputs:    循环队列地址
*


****************************************************/
bool IsEmptyQueue( RingBuffer *Queue )
{
    /* 读指针等于写指针 */
    if ( Queue->ReadPt == Queue->WritePt )
        return true;
    else
        return false;
}
/**************************************************
*Function:    WriteQueue( RingBuffer *Queue,int inData )
*
*ShortDesc:    向循环队列中写入数据
*
*Inputs:    循环队列地址,写入的数据
*


****************************************************/
bool WriteQueue( RingBuffer *Queue,unsigned char inData )
{
    /* 判断是否是满 */
    if ( IsFullQueue( Queue ) )
        return false;
    else
    {
        Queue->DataQueue[Queue->WritePt] = inData;            //写入数据
        Queue->WritePt = ( Queue->WritePt + 1 ) % RingBufferMaxSize;    //写指针加1
        return true;
    }
}
/**************************************************
*Function:    ReadQueue( RingBuffer *Queue,int OutData )
*
*ShortDesc:    从循环队列中读出数据
*
*Inputs:    循环队列地址
*
*Outputs:    读出的数据
*
****************************************************/
bool ReadQueue( RingBuffer *Queue,unsigned char *outData )
{
    /* 判断是否是空*/
    if ( IsEmptyQueue( Queue ) )
    {
return false;
    }
    else
    {
        *outData = Queue->DataQueue[Queue->ReadPt];            //读出数据
        Queue->DataQueue[Queue->ReadPt] = 0;
        Queue->ReadPt = ( Queue->ReadPt + 1 ) % RingBufferMaxSize;    //读指针加1
        return true;
    }


}


/**************************************************
*Function:    CalcNumNotRead( RingBuffer *Queue )
*
*ShortDesc:    计算没有被读到的个数
*
*Inputs:    循环队列地址
*
****************************************************/
int CalcNumNotRead( RingBuffer *Queue )
{
    return ( Queue->WritePt + RingBufferMaxSize - Queue->ReadPt ) % RingBufferMaxSize;
}


/**************************************************
*Function:    CalcNumRevSpace( RingBuffer *Queue )
*
*ShortDesc:    计算剩余空间个数(保留空间)
*
*Inputs:    循环队列地址
*
****************************************************/
int CalcNumRevSpace( RingBuffer *Queue )
{
    return RingBufferMaxSize - CalcNumNotRead( Queue );
}




/**************************************************
*Function:   udelay(int us_count)
*
*ShortDesc:    延时函数
*
*Inputs:    延时时间um
*
****************************************************/
void udelay(int us_count)
{
struct timeval  tpStart,tpEnd;
float timeUse;
gettimeofday(&tpStart, NULL);
do {
gettimeofday(&tpEnd, NULL);
timeUse = 1000000 * (tpEnd.tv_sec - tpStart.tv_sec) + (tpEnd.tv_usec - tpStart.tv_usec);
} while(timeUse < us_count);

return;
}