Circular buffer for streaming data in Signal Processing - Step-by-Step Execution

Concept Flow - Circular buffer for streaming data

Start: Initialize buffer and pointers

↓

Receive new data sample

↓

Store sample at write position

↓

Update write pointer (wrap if needed)

↓

If buffer full, update read pointer (wrap if needed)

↓

Buffer ready for reading or processing

↓

Repeat for next sample

The circular buffer stores incoming data in a fixed-size array, overwriting oldest data when full, by moving write and read pointers in a loop.

Execution Sample

Signal Processing

buffer = [0]*5
write_pos = 0
read_pos = 0
count = 0

for sample in [10,20,30,40,50,60]:
    buffer[write_pos] = sample
    write_pos = (write_pos + 1) % 5
    if count == 5:
        read_pos = (read_pos + 1) % 5
    else:
        count += 1

This code adds samples to a circular buffer of size 5, updating write and read positions as new data arrives.

Execution Table

Step	Sample	write_pos Before	Action	write_pos After	read_pos After	count After	Buffer State
1	10	0	Store 10 at pos 0; write_pos=1; count=1	1	0	1	[10, 0, 0, 0, 0]
2	20	1	Store 20 at pos 1; write_pos=2; count=2	2	0	2	[10, 20, 0, 0, 0]
3	30	2	Store 30 at pos 2; write_pos=3; count=3	3	0	3	[10, 20, 30, 0, 0]
4	40	3	Store 40 at pos 3; write_pos=4; count=4	4	0	4	[10, 20, 30, 40, 0]
5	50	4	Store 50 at pos 4; write_pos=0 (wrap); count=5	0	0	5	[10, 20, 30, 40, 50]
6	60	0	Buffer full; overwrite pos 0 with 60; write_pos=1; read_pos=1	1	1	5	[60, 20, 30, 40, 50]

💡 After step 6, buffer is full and oldest data is overwritten; read_pos moves to keep track of oldest data.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6
write_pos	0	1	2	3	4	0	1
read_pos	0	0	0	0	0	0	1
count	0	1	2	3	4	5	5
buffer	[0,0,0,0,0]	[10,0,0,0,0]	[10,20,0,0,0]	[10,20,30,0,0]	[10,20,30,40,0]	[10,20,30,40,50]	[60,20,30,40,50]

Key Moments - 2 Insights

Why does the read_pos only move after the buffer is full?

Because before the buffer is full, we are just filling empty slots, so no data is overwritten. The read_pos moves only when new data overwrites old data to keep track of the oldest valid data, as shown in step 6 of the execution_table.

Why does write_pos wrap back to 0 after reaching the buffer size?

The write_pos uses modulo operation with buffer size to wrap around, so it cycles through positions 0 to 4 repeatedly. This is shown in step 5 where write_pos changes from 4 to 0.

Visual Quiz - 3 Questions

Look at the execution_table at step 4. What is the buffer state?

A [10, 20, 30, 40, 0]

B [10, 20, 30, 0, 0]

C [0, 0, 0, 0, 0]

D [10, 20, 30, 40, 50]

💡 Hint

Check the 'Buffer State' column at step 4 in the execution_table.

At which step does the read_pos first change from 0 to 1?

A Step 5

B Step 6

C Step 3

D Step 2

💡 Hint

Look at the 'read_pos After' column in the execution_table to find when it changes.

If the buffer size was increased to 6, how would the count variable change after step 6?

A It would be 6

B It would remain 5

C It would reset to 0

D It would be 7

💡 Hint

Count increases until it reaches buffer size; with size 6, after 6 inserts count would be 6.

Concept Snapshot

Circular buffer stores streaming data in fixed size array.
Write pointer moves forward, wraps around using modulo.
Read pointer moves only when buffer is full and data is overwritten.
Count tracks how many valid items are in buffer.
Oldest data is overwritten when buffer is full.

Full Transcript

A circular buffer is a fixed-size storage that loops back when full. We start with empty buffer and pointers at zero. Each new data sample is stored at the write position. The write pointer moves forward and wraps around to zero after reaching the end. When the buffer is not full, the count increases. Once full, the read pointer moves forward to track the oldest data being overwritten. This way, the buffer always holds the most recent data samples. The execution table shows each step with variable values and buffer state. Key moments clarify why pointers move as they do. The visual quiz tests understanding of buffer state and pointer updates. This method is useful for streaming data where old data is replaced by new data continuously.

Practice

1. What is the main purpose of a circular buffer in streaming data processing?

easy

A. To compress data for storage

B. To sort data in ascending order

C. To permanently save all incoming data without deletion

D. To store a fixed amount of recent data by overwriting old data

Solution

1. Step 1: Understand circular buffer concept

   A circular buffer stores data in a fixed-size space and overwrites old data when full.

2. Step 2: Compare options with concept

   Only To store a fixed amount of recent data by overwriting old data describes overwriting old data to keep recent data, matching the circular buffer purpose.

3. Final Answer:

   To store a fixed amount of recent data by overwriting old data -> Option D

4. Quick Check:

   Circular buffer = overwrite old data [OK]

Hint: Circular buffers overwrite old data to keep recent only [OK]

Common Mistakes:

• Thinking circular buffer sorts data
• Assuming it stores all data permanently
• Confusing with data compression

2. Which of the following Python code snippets correctly initializes a circular buffer of size 5 using a list?

easy

A. buffer = [None] * 5

B. buffer = list(range(5))

C. buffer = []

D. buffer = [0]

Solution

1. Step 1: Identify circular buffer initialization

   A circular buffer needs a fixed-size list to hold data, initialized with placeholders like None.

2. Step 2: Check each option

   buffer = [None] * 5 creates a list of size 5 with None values, suitable for a circular buffer. Others do not create fixed-size buffers.

3. Final Answer:

   buffer = [None] * 5 -> Option A

4. Quick Check:

   Fixed-size list = [None]*5 [OK]

Hint: Use [None]*size for fixed-size buffer list [OK]

Common Mistakes:

• Using empty list which is size zero
• Using range which creates fixed values, not placeholders
• Using single element list instead of fixed size

3. Given this Python code for a circular buffer of size 3, what will be the content of buffer after all writes?

buffer = [None] * 3
write_pos = 0
for val in [10, 20, 30, 40]:
    buffer[write_pos] = val
    write_pos = (write_pos + 1) % 3
print(buffer)

medium

A. [40, 20, 30]

B. [30, 40, 10]

C. [40, 10, 20]

D. [10, 20, 30]

Solution

1. Step 1: Trace buffer writes and positions

   Writes happen at positions 0,1,2, then wrap to 0 again. Values written: 10->pos0, 20->pos1, 30->pos2, 40->pos0 (overwrite 10).

2. Step 2: Determine final buffer content

   After all writes, buffer = [40, 20, 30] because 40 overwrites 10 at position 0.

3. Final Answer:

   [40, 20, 30] -> Option A

4. Quick Check:

   Last write overwrites pos0 = 40 [OK]

Hint: Last write overwrites oldest position using modulo [OK]

Common Mistakes:

• Ignoring wrap-around and overwriting
• Assuming buffer grows beyond fixed size
• Miscalculating write_pos modulo

4. Identify the error in this circular buffer update code snippet:

buffer = [None] * 4
write_pos = 0
for val in [5, 6, 7, 8, 9]:
    buffer[write_pos] = val
    write_pos = write_pos + 1  # Missing modulo operation
print(buffer)

medium

A. buffer initialization with None is incorrect

B. buffer size should be 5 instead of 4

C. write_pos should reset to 0 after reaching buffer size

D. Loop should run only 4 times

Solution

1. Step 1: Analyze write_pos update logic

   write_pos increments but never resets or wraps, so it will go out of buffer index range.

2. Step 2: Identify fix for circular behavior

   write_pos must use modulo with buffer size to wrap around and overwrite old data correctly.

3. Final Answer:

   write_pos should reset to 0 after reaching buffer size -> Option C

4. Quick Check:

   Modulo needed for circular index [OK]

Hint: Use modulo to wrap write_pos in circular buffer [OK]

Common Mistakes:

• Forgetting modulo causes index error
• Changing buffer size instead of fixing index
• Thinking initialization is wrong

5. You have a circular buffer of size 4 storing sensor readings. After 6 readings, the buffer contains [15, 18, 20, 22]. Which readings were overwritten and what is the order of readings from oldest to newest?

hard

A. The first two readings overwritten; order is [15, 18, 20, 22]

B. Readings 15 and 18 overwritten; order is [20, 22, 15, 18]

C. The first two readings overwritten; order is [20, 22, 15, 18]

D. Readings 20 and 22 overwritten; order is [15, 18, 20, 22]

Solution

1. Step 1: Understand buffer size and writes

   Buffer size is 4, but 6 readings were written, so first 2 readings were overwritten by the last 2.

2. Step 2: Determine overwritten readings and order

   First two readings (positions 0 and 1) were overwritten. The buffer shows latest 4 readings: 15,18,20,22. The oldest is at write_pos (2), so order from oldest to newest is [20, 22, 15, 18].

3. Final Answer:

   Readings 15 and 18 overwritten; order is [20, 22, 15, 18] -> Option B

4. Quick Check:

   Overwrite first 2; order starts at write_pos [OK]

Hint: Oldest data starts at write_pos after wrap [OK]

Common Mistakes:

• Confusing which readings are overwritten
• Not understanding order after wrap
• Assuming buffer grows beyond fixed size