Thread: Char Buffer

Hi,


I need some advise on how to implement a circular buffer, I do not really understand why it is used. I want to read a string from a 8 bit, 1 byte port on a micro. So if I read hello in on this port, this would be 6 bytes including the null char. At this point I think why cant I write this into a standard char array of a fixed size. Why is it recommended to use a circular buffer?

Thanks,

RocketMan46

Hi Matticus,

Thanks for your detailed reply, that was very helpful.

My next problem is, after reading numerous examples, I do not understand how to implement a circular buffer. Most examples have a buffer, push and pop functions.

So I understand main should be something like below, but I do not really understand. I want to read in hello, put in buffer, then print out buffer contents. I have tried to assemble an example I have found on another site but it is not working.

* read char
* push char into buffer
* pop last char out of buffert
* print out buffer

Code:

#include <stdio.h>
#include <stdlib.h>


#define CIRCBUF_DEF(x,y) unsigned char x##_space[y]; circBuf_t x = { x##_space,0,0,y}




typedef struct
{
    unsigned char * const buffer;
    int head;
    int tail;
    const int maxLen;
}circBuf_t;


CIRCBUF_DEF(cb, 6);


int circBufPush(circBuf_t *c, unsigned char data)
{
    int next = c->head + 1;
    if (next >= c->maxLen)
        next = 0;


    // Cicular buffer is full
    if (next == c->tail)
        return -1;  // quit with an error


    c->buffer[c->head] = data;
    c->head = next;
    return 0;
}


int circBufPop(circBuf_t *c, unsigned char *data)
{
    // if the head isn't ahead of the tail, we don't have any characters
    if (c->head == c->tail)
        return -1;  // quit with an error


    *data = c->buffer[c->tail];
    c->buffer[c->tail] = 0;  // clear the data (optional)


    int next = c->tail + 1;
    if(next >= c->maxLen)
        next = 0;


    c->tail = next;


    return 0;
}


unsigned char buffer(unsigned char data)
{
    if (circBufPush(&cb, data))
    {
            printf("Out of space in CB\n");
    }


    if (circBufPop(&cb, &data))
    {
            printf("CB is empty\n");
    }


return data;
}


int main()
{
    char i;
    unsigned char text[6] = "hello";
    unsigned char data;


    for(i = 0; i < 5; i++)
    {
        printf("%c", text[i]);
        
        // I cant push data into the buffer
        circBufPush(1,text[i]);
    }

    // print buffer contents


    return 0;
}

Wouldn't the modulus operator be a very nice way to iterate through a circular buffer Matticus? The reason I'm mentioning the modulus operator is because the very nature of the modulus operator is circular. This means if we have a buffer that can hold 8 characters and the buffer is completely full, the modulus operator will take us back to the beginning of the buffer and from there we can continue to overwrite characters.

Originally Posted by deathslice

Wouldn't the modulus operator be a very nice way to iterate through a circular buffer Matticus? The reason I'm mentioning the modulus operator is because the very nature of the modulus operator is circular. This means if we have a buffer that can hold 8 characters and the buffer is completely full, the modulus operator will take us back to the beginning of the buffer and from there we can continue to overwrite characters.

Generally speaking, yes, the modulus operator works very well in an indexing expression for a circular array. In fact, such an expression is very straight-forward and succinct.

However, if one is programming a simpler microcontroller (as the OP appears to be doing), they should be aware that modulus can be an expensive operation. While this may have minimal impact on your average desktop application, it can be very costly in a memory-limited device such as this (depending upon the specific device in question, of course).

I recently had an application where I had to squeeze out every byte I possible could to meet design constraints. I originally reset my state machine with a modulus in this manner - switching to a "if max, then zero" operation reduced my code size by almost a hundred bytes (which was significant for this application).

But again, yes, modulus works well for this purpose in general.

I see, sounds to me like embedded programming is not only challenging but very brutal if even a modulus operation is considered to be an expensive operation. In that situation, it makes sense to have an if statement that simply reset the index to zero whenever you reach the end of the buffer.

OK, I will try and write my own buffer and come back with my solution in steps.

Currently I never use a debugger only print to screen in both windows and embedded. Would you say this is a major disadvantage to the progression in my development?

Thanks,

Rocketman46.