Ring buffer for UART receive in Embedded C

Introduction

A ring buffer helps store incoming UART data smoothly without losing any bytes. It works like a circular queue that wraps around when full.

When receiving data from UART continuously without blocking the main program.

When you want to store incoming bytes temporarily before processing them.

When you need to handle data at different speeds between sender and receiver.

When you want to avoid losing data if the processor is busy.

When implementing serial communication in embedded systems.

Syntax

Embedded C

typedef struct {
    uint8_t buffer[BUFFER_SIZE];
    volatile uint16_t head;
    volatile uint16_t tail;
} RingBuffer;

void ring_buffer_init(RingBuffer *rb);
int ring_buffer_put(RingBuffer *rb, uint8_t data);
int ring_buffer_get(RingBuffer *rb, uint8_t *data);

The buffer array holds the data bytes.

Head points to where new data is added; tail points to where data is read.

Examples

Initialize the ring buffer by setting head and tail to zero.

Embedded C

RingBuffer uart_rx_buffer;

void ring_buffer_init(RingBuffer *rb) {
    rb->head = 0;
    rb->tail = 0;
}

Add a byte to the buffer if there is space; return error if full.

Embedded C

int ring_buffer_put(RingBuffer *rb, uint8_t data) {
    uint16_t next = (rb->head + 1) % BUFFER_SIZE;
    if (next == rb->tail) {
        return -1; // Buffer full
    }
    rb->buffer[rb->head] = data;
    rb->head = next;
    return 0;
}

Read a byte from the buffer if available; return error if empty.

Embedded C

int ring_buffer_get(RingBuffer *rb, uint8_t *data) {
    if (rb->head == rb->tail) {
        return -1; // Buffer empty
    }
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % BUFFER_SIZE;
    return 0;
}

Sample Program

This program creates a ring buffer for UART receive data. It simulates receiving 7 bytes and stores them in the buffer. Then it reads and prints all bytes from the buffer.

Embedded C

#include <stdio.h>
#include <stdint.h>

#define BUFFER_SIZE 8

typedef struct {
    uint8_t buffer[BUFFER_SIZE];
    volatile uint16_t head;
    volatile uint16_t tail;
} RingBuffer;

void ring_buffer_init(RingBuffer *rb) {
    rb->head = 0;
    rb->tail = 0;
}

int ring_buffer_put(RingBuffer *rb, uint8_t data) {
    uint16_t next = (rb->head + 1) % BUFFER_SIZE;
    if (next == rb->tail) {
        return -1; // Buffer full
    }
    rb->buffer[rb->head] = data;
    rb->head = next;
    return 0;
}

int ring_buffer_get(RingBuffer *rb, uint8_t *data) {
    if (rb->head == rb->tail) {
        return -1; // Buffer empty
    }
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % BUFFER_SIZE;
    return 0;
}

int main() {
    RingBuffer uart_rx_buffer;
    ring_buffer_init(&uart_rx_buffer);

    // Simulate receiving bytes from UART
    for (uint8_t i = 1; i <= 7; i++) {
        if (ring_buffer_put(&uart_rx_buffer, i) == 0) {
            printf("Received byte: %d\n", i);
        } else {
            printf("Buffer full, cannot receive byte: %d\n", i);
        }
    }

    // Read bytes from buffer
    uint8_t data;
    printf("Reading bytes from buffer:\n");
    while (ring_buffer_get(&uart_rx_buffer, &data) == 0) {
        printf("Byte: %d\n", data);
    }

    return 0;
}

Important Notes

Make sure the buffer size is a power of two for easier modulo operations (optional optimization).

Use volatile keyword for head and tail if they are changed in interrupt handlers.

Always check for buffer full before adding data to avoid overwriting unread data.

Summary

A ring buffer stores UART data in a circular way to avoid data loss.

Use head and tail pointers to track where to add and read data.

Check for full and empty conditions to manage buffer safely.

Practice

1. What is the main purpose of using a ring buffer for UART receive data?

easy

A. To encrypt UART data before processing

B. To increase the UART baud rate automatically

C. To convert UART data into parallel data

D. To store incoming data in a circular way to prevent data loss

Solution

1. Step 1: Understand UART data flow

   UART data arrives asynchronously and can be lost if not stored properly.

2. Step 2: Role of ring buffer

   A ring buffer stores data in a circular way so new data overwrites old only when full, preventing data loss.

3. Final Answer:

   To store incoming data in a circular way to prevent data loss -> Option D

4. Quick Check:

   Ring buffer = circular storage for UART data [OK]

Hint: Ring buffer means circular storage to avoid losing data [OK]

Common Mistakes:

• Confusing ring buffer with baud rate control
• Thinking it encrypts data
• Assuming it converts data format

2. Which of the following is the correct way to declare a ring buffer array of size 64 bytes in embedded C?

easy

A. char ringBuffer[64];

B. int ringBuffer = 64;

C. char ringBuffer();

D. char ringBuffer[;]

Solution

1. Step 1: Understand array declaration syntax

   In C, arrays are declared with type, name, and size in square brackets.

2. Step 2: Check each option

   char ringBuffer[64]; correctly declares a char array of size 64. Others are invalid syntax or wrong types.

3. Final Answer:

   char ringBuffer[64]; -> Option A

4. Quick Check:

   Array declaration = type name[size] [OK]

Hint: Arrays use type name[size] syntax in C [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Assigning size to variable instead of array
• Leaving size empty or incorrect

3. Given this code snippet for a ring buffer with size 8:

uint8_t buffer[8];
uint8_t head = 0;
uint8_t tail = 0;

// Add data
buffer[head] = 0x55;
head = (head + 1) % 8;

// Add data
buffer[head] = 0xAA;
head = (head + 1) % 8;

// Read data
uint8_t data = buffer[tail];
tail = (tail + 1) % 8;

What is the value of data after this code runs?

medium

A. 0xAA

B. 0x55

C. 0x00

D. Undefined

Solution

1. Step 1: Track buffer writes

   First, 0x55 is stored at buffer[0], head moves to 1. Then 0xAA stored at buffer[1], head moves to 2.

2. Step 2: Read from tail

   Tail is 0, so reading buffer[0] returns 0x55, then tail moves to 1.

3. Final Answer:

   0x55 -> Option B

4. Quick Check:

   Read at tail=0 returns first stored value 0x55 [OK]

Hint: Read from tail pointer, which points to oldest data [OK]

Common Mistakes:

• Reading from head instead of tail
• Forgetting modulo wrap-around
• Assuming data is 0xAA instead of 0x55

4. Identify the bug in this ring buffer code snippet for UART receive:

if ((head + 1) % BUFFER_SIZE == tail) {
    // Buffer full
    return;
}
buffer[head] = data;
head = (head + 1) % BUFFER_SIZE;

medium

A. Buffer full condition is correct, no bug

B. Buffer full check should use '==' instead of '!='

C. Buffer full check misses parentheses around addition

D. Buffer full condition should check if head == tail

Solution

1. Step 1: Understand buffer full condition

   Buffer is full when next head position equals tail, meaning no space to write.

2. Step 2: Analyze given condition

   The condition uses (head + 1) % BUFFER_SIZE == tail, which correctly detects full buffer.

3. Final Answer:

   Buffer full condition is correct, no bug -> Option A

4. Quick Check:

   Full when next head equals tail [OK]

Hint: Full buffer when next head equals tail [OK]

Common Mistakes:

• Using wrong comparison operator
• Forgetting modulo operation
• Checking head == tail for full (actually empty)

5. You want to implement a function uart_receive_byte() that reads one byte from the ring buffer if available, or returns -1 if empty. Which code snippet correctly implements this?

hard

A. int uart_receive_byte() {
if (tail == head) return 0;
uint8_t data = buffer[tail];
tail = (tail + 1) % BUFFER_SIZE;
return data;
}

B. int uart_receive_byte() {
if (head != tail) return -1;
uint8_t data = buffer[head];
head = (head + 1) % BUFFER_SIZE;
return data;
}

C. int uart_receive_byte() {
if (head == tail) return -1;
uint8_t data = buffer[tail];
tail = (tail + 1) % BUFFER_SIZE;
return data;
}

D. int uart_receive_byte() {
if (tail == head) return -1;
uint8_t data = buffer[head];
head = (head + 1) % BUFFER_SIZE;
return data;
}

Solution

1. Step 1: Check empty condition

   Buffer is empty when head equals tail, so return -1 in that case.

2. Step 2: Read data and update tail

   Read from buffer[tail], then move tail forward with modulo wrap.

3. Final Answer:

   Function returns -1 if empty, else data from tail and updates tail -> Option C

4. Quick Check:

   Empty if head==tail; read from tail pointer [OK]

Hint: Return -1 if head==tail; read from tail and advance tail [OK]

Common Mistakes:

• Checking wrong empty condition
• Reading from head instead of tail
• Returning 0 instead of -1 when empty