Ring buffer for UART receive in Embedded C - Mini Project: Build & Apply

Ring buffer for UART receive

📖 Scenario: You are working on a small embedded system that receives data from a UART (serial) interface. To handle incoming data smoothly, you need to store the bytes in a ring buffer (circular buffer) so the main program can process them later without losing any data.

🎯 Goal: Build a simple ring buffer in C to store bytes received from UART. You will create the buffer, set up the indexes, write a function to add bytes to the buffer, and finally print the buffer contents to verify it works.

📋 What You'll Learn

Create a fixed-size byte array as the ring buffer

Create two index variables: head and tail

Write a function uart_buffer_write to add a byte to the buffer

Write code to print the buffer contents from tail to head

💡 Why This Matters

🌍 Real World

Ring buffers are used in embedded systems to handle continuous data streams like UART without losing data.

💼 Career

Understanding ring buffers is important for embedded software engineers working on communication protocols and real-time data processing.

1

Create the ring buffer array and index variables

Create a byte array called uart_buffer with size 8. Also create two integer variables called head and tail and initialize both to 0.

Embedded C

unsigned char uart_buffer[8];
int head = 0;
int tail = 0;
// Your code here

Need a hint?

Think of uart_buffer as a small box with 8 slots to hold bytes. head and tail tell us where to add or remove data.

2

Create a variable for buffer size

Create an integer constant called BUFFER_SIZE and set it to 8. This will help us manage the buffer size easily.

Embedded C

unsigned char uart_buffer[8];
int head = 0;
int tail = 0;
const int BUFFER_SIZE = 8;
// Your code here

Need a hint?

Using BUFFER_SIZE makes your code easier to change later if you want a bigger buffer.

3

Write the function to add a byte to the ring buffer

Write a function called uart_buffer_write that takes an unsigned char data parameter. Inside the function, store data at uart_buffer[head]. Then increase head by 1 and wrap it around using BUFFER_SIZE (use modulo).

Embedded C

unsigned char uart_buffer[8];
int head = 0;
int tail = 0;
const int BUFFER_SIZE = 8;

void uart_buffer_write(unsigned char data) {
    // Your code here
}

Need a hint?

Think of head as the next empty slot. After adding data, move head forward. If it reaches the end, start again at 0.

4

Print the contents of the ring buffer from tail to head

Write code to print all bytes in uart_buffer starting from tail up to but not including head. Use a while loop. Print each byte as a decimal number followed by a space. Stop when the index reaches head. Assume the buffer has some data already.

Embedded C

unsigned char uart_buffer[8];
int head = 0;
int tail = 0;
const int BUFFER_SIZE = 8;

void uart_buffer_write(unsigned char data) {
    uart_buffer[head] = data;
    head = (head + 1) % BUFFER_SIZE;
}

int main() {
    uart_buffer_write(10);
    uart_buffer_write(20);
    uart_buffer_write(30);
    int index = tail;
    // Print buffer contents from tail to head
    // Your code here
    return 0;
}

Need a hint?

Use a loop that moves index forward and wraps around using modulo. Stop when index equals head.