nz_circularBuffer.h

Go to the documentation of this file.

//  Circular Buffer - documentation module
#ifndef NZ_CIRCULARBUFFER_H
#define    NZ_CIRCULARBUFFER_H


// Default values if none are defined

//If no circular buffers are defined, define CIRBUF_USE_CIRCULAR_BUFFER_PWR2
#if !defined(CIRBUF_USE_CIRCULAR_BUFFER_STD) && !defined(CIRBUF_USE_CIRCULAR_BUFFER_PWR2)
#define    CIRBUF_USE_CIRCULAR_BUFFER_PWR2      //Use nz_circularBufferPwr2
#endif


//Defines minimum size allowed for a circular buffer. Default is 8
#if !defined(CIRBUF_MIN_SIZE)
#define    CIRBUF_MIN_SIZE     8
#endif

//#define CIRBUF_DISABLE_CONTIGUOUS_PACKETS


//Default Escape Character
#if !defined(CIRBUF_ESC_CHAR)
#define     CIRBUF_ESC_CHAR     '^'
#endif



// Buffer Type Defines

#define CIRBUF_TYPE_STREAMING   0x0000

#define CIRBUF_TYPE_PACKET      0x0001

#define CIRBUF_TYPE_LARGE_PACKET    0x0003

#define CIRBUF_FLAGS_POWER2     0x0020



// Byffer Format Defines

#define CIRBUF_FORMAT_NONE      0x0000
#define BUFFORMAT_NONE          0

#define CIRBUF_FORMAT_ASCII     0x0004
#define BUFFORMAT_ASCII         1

#define CIRBUF_FORMAT_ASCII_ESC     0x0008
#define BUFFORMAT_ASCII_ESC         2

#define CIRBUF_FORMAT_BIN           0x000C
#define BUFFORMAT_BIN               3


#define CIRBUF_FORMAT_BIN_ESC       0x0010
#define BUFFORMAT_BIN_ESC           4


//CIRBUF is defined in nz_netcruzer.h
//typedef struct __attribute__((aligned(2), packed)) _CIRBUF
typedef struct __attribute__((__packed__)) _CIRBUF
{
    WORD  put;          //Put Pointer(offset) for Buffer, a value from 0-(bufSize)
    WORD  get;          //Get Pointer(offset) for Buffer, a value from 0-(bufSize)
    BYTE* buf;          //Pointer to start of buffer.
    WORD  maxOffset;    //Max value offset can have = usable buffer size. Actual buffer size is maxOffset+1 (because put=get is used to indicate empty buffer)
                        //When buffer size is power of 2, this is also the mask used for updating put and get offsets.
    union {
        struct
        {
            unsigned int bPacket : 1;      
            unsigned int bPacketLarge : 1; 
            unsigned int format : 3;       
            unsigned int bSizePower2 : 1;  
            unsigned int fill6_7 : 2;      
            unsigned int fill8_15 : 8;
        } flagBits;
        struct
        {
            unsigned int type : 2;         
            unsigned int format : 3;       
            unsigned int fill : 11;
        } flagTF;  //Type and Format
        struct {
            unsigned int val : 5;           
            unsigned int fill5_7 : 3;       
            unsigned int fill : 8;
        } typeFormat;  //Type and Format
        struct
        {
            BYTE    LB;                 
            BYTE    HB;                 
        } flagBytes;
        WORD flagVal;
    };
} CIRBUF;



// Function Prototypes

void cbufInitDefault(CIRBUF* pBuf, BYTE* bufArray, WORD size);


void cbufInit(CIRBUF* pBuf, BYTE* bufArray, WORD size, BYTE typeFormat);


void cbufTask(void);


void cbufSetTypeAndFormat(CIRBUF* pBuf, BYTE typeFormat);


void cbufEmpty(CIRBUF* pBuf);


BOOL cbufIsEmpty(CIRBUF* pBuf);


BOOL cbufIsFull(CIRBUF* pBuf);


BOOL cbufHasData(CIRBUF* pBuf);


#define cbufHasSpace(pBuf)  (cbufIsFull(pBuf)==0)


WORD cbufGetCount(CIRBUF* pBuf);


WORD cbufGetFree(CIRBUF* pBuf);


BYTE cbufGetFormat(CIRBUF* pBuf);


BYTE cbufGetType(CIRBUF* pBuf);


WORD cbufGetEscapedSizeRequired(CIRBUF* pBuf, BYTE* buf, WORD size);


#define cbufGetEscapeCharacter(pBuf)    (CIRBUF_ESC_CHAR)


BYTE cbufPeekByte(CIRBUF* pBuf);


BYTE cbufPeekByteAt(CIRBUF* pBuf, WORD offset);


BYTE cbufPeekEscapedByte(CIRBUF* pBuf, BYTE* b);


WORD cbufFindByte(CIRBUF* pBuf, WORD offset, BYTE value);


void cbufRemoveByte(CIRBUF* pBuf);


void cbufRemoveBytes(CIRBUF* pBuf, WORD n);


void cbufRemovePutByte(CIRBUF* pBuf);


BYTE cbufGetByte(CIRBUF* pBuf);


BYTE cbufGetByte_MACRO(CIRBUF* pBuf);



BYTE cbufGetEscapedByte(CIRBUF* pBuf, BYTE* b);


WORD cbufGetString(CIRBUF* pBuf, BYTE* pDstArr, WORD size);


WORD cbufGetArray(CIRBUF* pBuf, BYTE* pDstArr, WORD size);


WORD cbufGetArrayTillByte(CIRBUF* pBuf, BYTE* pDstArr, BYTE value, WORD size);


WORD cbufGetRdArrSize(CIRBUF* pBuf);


BYTE* cbufGetRdArr(CIRBUF* pBuf);


BYTE cbufPutByte(CIRBUF* pBuf, BYTE b);


void cbufPutByteNoCheck(CIRBUF* pBuf, BYTE b);


BYTE cbufPutWord(CIRBUF* pBuf, WORD w);


BYTE cbufPutByteAscii(CIRBUF* pBuf, BYTE b);


BYTE cbufPutByteAsciiHex(CIRBUF* pBuf, BYTE b);


BYTE cbufPutWordAscii(CIRBUF* pBuf, WORD w);


BYTE cbufPutWordAsciiHex(CIRBUF* pBuf, WORD w);


BYTE cbufShaddowPutByte(CIRBUF* pBuf, BYTE b, WORD putShaddow);


void cbufShaddowPutCommit(CIRBUF* pBuf, WORD putShaddow);


BYTE cbufPutControlChar(CIRBUF* pBuf, BYTE b);


BYTE cbufPutEscapedByte(CIRBUF* pBuf, BYTE b);


WORD cbufPutString(CIRBUF* pBuf, const char * s);


#define ASCIIESC_ADD_S_AND_P 0x0001


WORD cbufPutAsciiEscString(CIRBUF* cbufDst, CIRBUF* cbufSrc, const char* pStrSrc, WORD flags);


WORD cbufPutStringWait(CIRBUF* pBuf, const char * s);


WORD cbufPutArray(CIRBUF* pBuf, const BYTE* pSrcArr, WORD size);


WORD cbufPutArrayWait(CIRBUF* pBuf, const BYTE* pSrcArr, WORD size);


WORD cbufMove(CIRBUF* pBufSrc, CIRBUF* pBufDst);


WORD cbufGetWrArrSize(CIRBUF* pBuf);


BYTE* cbufGetWrArr(CIRBUF* pBuf);


void cbufUpdatePut(CIRBUF* pBuf, WORD n);


BOOL cbufGetError(CIRBUF* pBuf);


void cbufClearError(CIRBUF* pBuf);


BOOL cbufIsPacket(CIRBUF* pBuf);


BOOL cbufIsPacketLarge(CIRBUF* pBuf);


WORD cbufHasWholePacket(CIRBUF* pBuf);


WORD cbufPacketStrcmp(CIRBUF* pBuf, const char* str);


WORD cbufGetFreeForPacket(CIRBUF* pBuf);


WORD cbufGetContiguousPacket(CIRBUF* pBuf, BYTE** ppData);


WORD cbufGetPacketDataSize(CIRBUF* pBuf);


BYTE cbufPeekPacketByte(CIRBUF* pBuf);


WORD cbufPeekPacketDataSize(CIRBUF* pBuf);


WORD cbufPutPacket(CIRBUF* pBuf, const BYTE* pSrcArr, WORD size);


void cbufRemovePacket(CIRBUF* pBuf);


// Include cirbuf implementation include files

#if !defined(CIRBUF_USE_CIRCULAR_BUFFER_STD) && !defined(CIRBUF_USE_CIRCULAR_BUFFER_PWR2)
//Use nz_circularBufferStd by default if projdefs.h does not define a circular buffer
#define     CIRBUF_USE_CIRCULAR_BUFFER_STD
#endif

#if defined(CIRBUF_USE_CIRCULAR_BUFFER_STD)
    #if defined(CIRBUF_USE_CIRCULAR_BUFFER_PWR2)
    #error "Configured to use multiple Circular Buffers! Only one can be used! Ensure only one CIRBUF_USE_XXX macro is defined (projdefs.h), and it matches circular buffer *.c file included with project!"
    #endif
    #include "nz_circularBufferStd.h"
#endif

#if defined(CIRBUF_USE_CIRCULAR_BUFFER_PWR2)
    #if defined(CIRBUF_USE_CIRCULAR_BUFFER_STD)
    #error "Configured to use multiple Circular Buffers! Only one can be used! Ensure only one CIRBUF_USE_XXX macro is defined (projdefs.h), and it matches circular buffer *.c file included with project!"
    #endif
    #include "nz_circularBufferPwr2.h"
#endif

#endif    /* NZ_CIRCULARBUFFER_H */