Ring buffer for UART receive in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the ring buffer size.

Embedded C

volatile char uart_buffer[[1]];

Drag options to blanks, or click blank then click option'

A64

B256

C512

D128

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing too large a buffer wastes memory.

Choosing too small a buffer may cause overflow.

The ring buffer size is set to 64 bytes to balance memory and performance.

2fill in blank

medium

Complete the code to increment the head index in the ring buffer.

Embedded C

head = (head + [1]) % BUFFER_SIZE;

Drag options to blanks, or click blank then click option'

A0

B2

C1

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 does not move the head.

Using -1 causes underflow.

Incrementing by 1 moves the head to the next position in the buffer.

3fill in blank

hard

Fix the error in the condition to check if the buffer is full.

Embedded C

if (((head + 1) % BUFFER_SIZE) == [1]) { /* buffer full */ }

Drag options to blanks, or click blank then click option'

A0

Bhead

CBUFFER_SIZE

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing to head causes wrong condition.

Comparing to BUFFER_SIZE is invalid index.

The buffer is full when the next head position equals the tail.

4fill in blank

hard

Fill both blanks to read a byte from the buffer and update the tail index.

Embedded C

char data = uart_buffer[[1]];
tail = (tail [2] 1) % BUFFER_SIZE;

Drag options to blanks, or click blank then click option'

Atail

B+

C-

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of tail to read data.

Decrementing tail causes errors.

Read data at tail, then increment tail by 1 wrapping around.

5fill in blank

hard

Fill all three blanks to write a byte to the buffer and update the head index safely.

Embedded C

if (((head + 1) % BUFFER_SIZE) != [1]) {
    uart_buffer[[2]] = data;
    head = (head [3] 1) % BUFFER_SIZE;
}

Drag options to blanks, or click blank then click option'

Atail

Bhead

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Writing data at tail instead of head.

Using '-' instead of '+' to increment head.

Check buffer not full by comparing next head to tail, write data at head, then increment 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