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

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

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
}

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;
}

Hint

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

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