linux使用循环队列,一个循环队列在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;

}