Circular buffer for streaming data in Signal Processing - Mini Project: Build & Apply

Circular buffer for streaming data

📖 Scenario: Imagine you are working with a device that continuously collects sensor data. To efficiently store the latest data points without running out of memory, you use a circular buffer. This buffer overwrites the oldest data when it is full, keeping only the most recent values.

🎯 Goal: You will build a simple circular buffer in Python that stores a fixed number of data points. When new data arrives and the buffer is full, it will overwrite the oldest data. Finally, you will print the current state of the buffer.

📋 What You'll Learn

Create a list to hold the buffer data

Create a variable to track the current position in the buffer

Write code to add new data to the buffer using circular logic

Print the final buffer contents

💡 Why This Matters

🌍 Real World

Circular buffers are used in real-time data streaming, audio processing, and sensor data collection to efficiently manage limited memory and keep the most recent data.

💼 Career

Understanding circular buffers is important for roles in data engineering, embedded systems, and signal processing where continuous data streams must be handled efficiently.

1

Create the circular buffer list

Create a list called buffer with exactly 5 zeros to represent empty slots in the circular buffer.

Signal Processing

# Create the buffer list with 5 zeros
# Your code here

Hint

Use square brackets and commas to create a list with five zeros.

2

Create the position tracker

Create a variable called pos and set it to 0. This will track the current position in the buffer where new data will be stored.

Signal Processing

buffer = [0, 0, 0, 0, 0]
# Create the position variable and set it to 0
# Your code here

Hint

Just assign 0 to the variable pos.

3

Add new data to the buffer with circular logic

Given a list new_data = [10, 20, 30, 40, 50, 60, 70], write a for loop that adds each value to buffer at the current pos. After adding each value, update pos to the next position using modulo to wrap around the buffer size.

Signal Processing

buffer = [0, 0, 0, 0, 0]
pos = 0
new_data = [10, 20, 30, 40, 50, 60, 70]
# Add each value from new_data to buffer at pos, then update pos with modulo
# Your code here

Hint

Use a for loop over new_data. Assign each value to buffer[pos]. Then update pos by adding 1 and using modulo with len(buffer) to wrap around.

4

Print the final buffer contents

Write a print statement to display the current contents of the buffer list.

Signal Processing

buffer = [0, 0, 0, 0, 0]
pos = 0
new_data = [10, 20, 30, 40, 50, 60, 70]
for value in new_data:
    buffer[pos] = value
    pos = (pos + 1) % len(buffer)
# Print the buffer list
# Your code here

Hint

Use print(buffer) to show the buffer contents.

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