lifo.c

串口LIFO代码+CRC! 串口队列可以用下

//定义数据类型
typedef        unsigned char         BOOLEAN;
typedef        unsigned char         INT8U;
typedef        signed char         INT8S;
typedef        unsigned int         INT16U;
typedef        signed int         INT16S;
typedef        unsigned long         INT32U;
typedef        signed long         INT32S;
typedef        float                   FP32;
typedef        double                FP64;

typedef         INT8S                BYTE;
typedef        INT8U                UBYTE;
typedef        INT16S                WORD;
typedef        INT16U                UWORD;
typedef        INT32U                ULONG;
typedef        INT32S                LONG;
typedef        FP32                FP;
typedef        FP64                DFP;

//定义常熟，表示缓冲器访问函数返回的缓冲器的状态
#define                BUFFER_NO_ERR        0                /*缓冲器无错*/
#define                BUFFER_FULL        1                /*缓冲器满*/
#define                BUFFER_FLUSH        2                /*缓冲器空*/

//定义缓冲器控制块的数据类型
typedef        struct
{
        void        *BuffStart;        //指向缓冲器的起始单元的地址
        void        *BuffEnd;                //执行缓冲器的结束单元的下一个地址
        void        *MemberIn;        //插入成员的指针
        void        *MemberOut;        //取出成员的指针(在LIFO方式下也是插入成员的指针)(取出成员时总是从该指针指向的地址取出)
        UWORD        BuffSize;                //缓冲区大小(成员总数)
        UWORD        BuffEntries;        //可使用的成员数
        UWORD        MemberSizeof;        //成员的类型
} STR_BufferCB;                        //缓冲器控制块类型定义

//定义初始化缓冲器控制块的函数：参数1－控制块指针；参数2－缓冲器的首地址；参数3－缓冲器大小(最大成员数)；参数4－成员数据类型，可由sizeof函数得到
void        InitBufferCB(STR_BufferCB *pbcb,void *pbufs,UWORD bsize,UWORD bsizeof)
{

        pbcb->BuffStart=(void *)pbufs;
        pbcb->MemberIn=(void *)pbufs;
        pbcb->MemberOut=(void *)pbufs;
        pbcb->BuffSize=bsize;
        pbcb->MemberSizeof=bsizeof;
        pbcb->BuffEntries=bsize;
        pbcb->BuffEnd=(void *)((UBYTE *)pbufs+bsize*bsizeof);
}
//定义晴空缓冲器控制块的函数：参数－控制块指针
void        BufferCBFlush(STR_BufferCB *pbcb)
{
        pbcb->BuffEntries=pbcb->BuffSize;
        pbcb->MemberOut=pbcb->MemberIn;
}
//定义缓冲器中放入一个成员的函数(FIFO方式)：参数1－控制块指针；参数2－指向成员的指针
UWORD        BufferMemberPush(STR_BufferCB *pbcb,void *pmenber)        //FIFO
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries==0)
                {
                return(BUFFER_FULL);
                }

        psrc=(UBYTE *)pmenber;
        pdest=(UBYTE *)(pbcb->MemberIn);

        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }

        pbcb->BuffEntries--;
        pbcb->MemberIn=(void *)pdest;
        
        if(pbcb->MemberIn==pbcb->BuffEnd)
                {
                pbcb->MemberIn=pbcb->BuffStart;
                }
        return(BUFFER_NO_ERR);
}
//定义缓冲器中放入一个成员的函数(LIFO方式)：参数1－控制块指针；参数2－指向成员的指针
UWORD        BufferMemberPushFront(STR_BufferCB *pbcb,void *pmenber)        //LIFO
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries==0)
                {
                return(BUFFER_FULL);
                }

        if(pbcb->MemberOut==pbcb->BuffStart)
                {
                pbcb->MemberOut=pbcb->BuffEnd;
                }

        pdest=(UBYTE *)(pbcb->MemberOut);
        pdest=pdest-(pbcb->MemberSizeof);
        pbcb->MemberOut=(void *)pdest;
        psrc=(UBYTE *)pmenber;
        
        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }
        pbcb->BuffEntries--;

        return(BUFFER_NO_ERR);
}
//定义从缓冲区中取出一个成员的函数：参数1－控制块指针；参数2－保存取出来的成员的变量的指针
UWORD        BufferMemberPop(STR_BufferCB *pbcb,void *pmenber)
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries>=pbcb->BuffSize)
                {
                return(BUFFER_FLUSH);
                }

        pdest=(UBYTE *)pmenber;
        psrc=(UBYTE *)(pbcb->MemberOut);
        
        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }
                
        pbcb->BuffEntries++;

        pbcb->MemberOut=(void *)psrc;

        if(pbcb->MemberOut==pbcb->BuffEnd)
                {
                pbcb->MemberOut=pbcb->BuffStart;
                }

        return(BUFFER_NO_ERR);
}
//得到缓冲器的大小(最大成员数)
UWORD        GetBufferSize(STR_BufferCB *pbcb)
{
        return(pbcb->BuffSize);
}
//得到缓冲器的可以使用的成员数
UWORD        GetBufferEntries(STR_BufferCB *pbcb)
{
        return(pbcb->BuffEntries);
}
//得到缓冲器的成员的数据类型
UWORD        GetBufferSizeof(STR_BufferCB *pbcb)
{
        return(pbcb->MemberSizeof);
}
//得到缓冲器的首地址
void *        GetBufferStartAddr(STR_BufferCB *pbcb)
{
        return(pbcb->BuffStart);
}
//得到缓冲器的最后一个成员的下一个单元的地址
void *        GetBufferEndAddr(STR_BufferCB *pbcb)
{
        return(pbcb->BuffEnd);
}
//得到缓冲器的在FIFO方式下插入下一个成员的地址
void *        GetBufferInAddr(STR_BufferCB *pbcb)
{
        return(pbcb->MemberIn);
}
//得到缓冲器的在LIFO方式下插入下一个成员的地址
void *        GetBufferInAddrFront(STR_BufferCB *pbcb)
{
        UBYTE        *pdest;
        void        *ptemp;
        
        ptemp=pbcb->MemberOut;
        if(ptemp==pbcb->BuffStart)
                {
                ptemp=pbcb->BuffEnd;
                }

        pdest=(UBYTE *)ptemp;
        pdest=pdest-(pbcb->MemberSizeof);
        return((void *)pdest);
}
//得到缓冲器的取出成员的地址
void *        GetBufferOutAddr(STR_BufferCB *pbcb)
{
        return(pbcb->MemberOut);
}