Circular Buffers

The circular buffer component is part of the real-time kernel and provides byte-wide copy-in/copy-out storage of generic data. A buffer supports blocking of threads when reading and writing the buffer. Buffers also support being read and written from either a thread or an interrupt service routine (ISR).

Basic Usage

The code snippet below creates a static circular buffer that is written from an interrupt service routine while a thread is blocked waiting for the data to arrive.

#include "Kernel/kernel_buffer.h"
#include <assert.h>

/* Application-defined message that is transferred through a buffer */
typedef struct MSG {
    UINT32 time;
    UINT32 data;
} MSG;

static BUFFER buffer;                       /* Allocate a buffer */

void APP_Function(void* arg)
{
    static BYTE bufmem[256];                /* Allocate memory to be used by the buffer */
    STATUS status;
    MSG msg;


    status = BUFFER_Create(&buffer,         /* Create the circular buffer */
                           "Buffer1",       /* A name for the buffer (for debugging purposes) */
                           bufmem,          /* A pointer to the memory managed by the buffer */
                           sizeof(bufmem)); /* The size, in bytes, of the memory managed by the buffer */

    assert(status == SUCCESS);

    APP_EnableInterrupt();                  /* Enable the interrupt source that will write to the buffer... */


    for(;;) {

        status = BUFFER_Read(&buffer,       /* Block and wait for a message to be received */
                             &msg,          /* A pointer to receive the data from the buffer */
                             sizeof(MSG),   /* The number of bytes to receive from the buffer */
                             NULL,          /* A pointer to a variable to receive how many bytes were received (NULL for all or nothing) */
                             INFINITE);     /* Block indefinitely until a message arrives */

        if (status == SUCCESS) {

            /* A message has been received */
        }
    }
}

void ISR_Function(void)
{
    STATUS status;
    MSG msg;


    msg.time = KERNEL_Timestamp();          /* Create some random message */
    msg.data = rand();

    status = BUFFER_Write(&buffer,          /* Write the message to the buffer */
                          &msg,             /* A pointer to the data to be copied into the buffer */
                          sizeof(MSG),      /* The number of bytes to be copied into the buffer */
                          NULL,             /* A pointer to receive how many bytes were copied (NULL for all or nothing) */
                          0);               /* Don't block (unable to from ISR anyways) */
						  
    assert(status == SUCCESS);
}