Ring buffer for UART receive in Embedded C - Step-by-Step Execution

Concept Flow - Ring buffer for UART receive

UART receives byte

↓

next = (write_index + 1) % 4

↓

if (next != read_index)

↓

Discard byte

↓

write_index = next

↓

Read & process when ready

↓

Repeat

This flow shows how bytes received from UART are stored in a ring buffer only if space available (next != read_index), handling wrap-around and overflow by discarding.

Execution Sample

Embedded C

volatile uint8_t buffer[4];
volatile uint8_t write_index = 0;
volatile uint8_t read_index = 0;

void uart_receive_byte(uint8_t byte) {
  uint8_t next = (write_index + 1) % 4;
  if (next != read_index) {
    buffer[write_index] = byte;
    write_index = next;
  } // else buffer full, byte lost
}

This code stores incoming UART bytes into a 4-byte ring buffer (effective capacity 3), advancing write_index and avoiding overwrite if next == read_index (full).

Execution Table

Step	Action	write_index	read_index	next	Buffer State	Overflow?
1	Start: write_index=0, read_index=0	0	0	-	[_, _, _, _]	No
2	Receive byte 'A' (65)	0	0	1	[65, _, _, _]	No
3	Update write_index to 1	1	0	-	[65, _, _, _]	No
4	Receive byte 'B' (66)	1	0	2	[65, 66, _, _]	No
5	Update write_index to 2	2	0	-	[65, 66, _, _]	No
6	Receive byte 'C' (67)	2	0	3	[65, 66, 67, _]	No
7	Update write_index to 3	3	0	-	[65, 66, 67, _]	No
8	Receive byte 'D' (68)	3	0	0	[65, 66, 67, _]	Yes (buffer full, byte lost)
9	Read byte at read_index=0 ('A')	3	0	-	[65, 66, 67, _]	No
10	Increment read_index to 1	3	1	-	[65, 66, 67, _]	No
11	Receive byte 'D' (68) retry	3	1	0	[65, 66, 67, 68]	No
12	Update write_index to 0 (wrap)	0	1	-	[65, 66, 67, 68]	No
13	End

💡 Execution demonstrates filling to capacity (3/4 slots), overflow discard, read to free space, then store with wrap-around.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	After Step 8	After Step 10	After Step 11	After Step 12	Final
write_index	0	1	2	3	3	3	3	0	0
read_index	0	0	0	0	0	1	1	1	1
buffer	[_, _, _, _]	[65, _, _, _]	[65, 66, _, _]	[65, 66, 67, _]	[65, 66, 67, _]	[65, 66, 67, _]	[65, 66, 67, 68]	[65, 66, 67, 68]	[65, 66, 67, 68]

Key Moments - 3 Insights

Why does the buffer reject the byte 'D' at step 8 even though there is space in the array?

At step 8, next = (3 + 1) % 4 = 0 equals read_index = 0, indicating the buffer is logically full (3 bytes stored). The check prevents overwrite of unread data by discarding when next == read_index.

How does the buffer handle wrapping around when write_index reaches the end?

At step 12, after storing 'D' at index 3, write_index = (3 + 1) % 4 = 0, wrapping around to reuse the buffer circularly.

What happens when read_index is incremented at step 10?

Incrementing read_index from 0 to 1 frees logical space. Now next = 0 != read_index = 1, allowing storage of 'D' at step 11 without overflow.

Visual Quiz - 3 Questions

Look at the execution table at step 8. Why is the byte 'D' not stored in the buffer?

A Because the byte 'D' is invalid

B Because next equals read_index, indicating buffer full

C Because the buffer array is physically full of zeros

D Because read_index is ahead of write_index

💡 Hint

Check the 'Overflow?' column at step 8 and the condition comparing 'next' and 'read_index'.

At which step does write_index wrap back to 0?

A Step 12

B Step 8

C Step 10

D Step 11

💡 Hint

Look at the 'write_index' column and see when it changes from 3 to 0.

If read_index was not incremented at step 10, what would happen when byte 'D' arrives again?

A The byte 'D' would be stored successfully

B The buffer would overflow and overwrite unread data

C The byte 'D' would be rejected again due to full buffer

D The write_index would move forward anyway

💡 Hint

Refer to the buffer full check condition and the variable_tracker values for read_index remaining 0.

Concept Snapshot

Ring buffer stores UART bytes in a fixed-size array.
Use write_index and read_index to track positions.
Increment indices with modulo to wrap around.
Check if next = (write_index + 1) % SIZE == read_index to detect full.
If full, discard new bytes until read advances.
Read bytes by advancing read_index similarly (separate logic).

Full Transcript

This example shows a ring buffer for UART receive in embedded C. Incoming bytes compute next = (write_index + 1) % 4. If next != read_index, store at write_index and advance. This leaves one slot empty to distinguish empty (write==read) from full (next==read). After 3 bytes, full detected on 4th (next wraps to read pos), discarded. Reading advances read_index, freeing space for more writes with wrap-around. Efficient for streams without data copies.