Circular buffer for streaming data in Signal Processing

Introduction

A circular buffer helps store streaming data efficiently by reusing space when old data is no longer needed. It keeps the newest data ready without running out of memory.

When reading live sensor data continuously, like temperature or sound.

When processing real-time audio or video streams.

When you want to keep a fixed-size window of recent data for analysis.

When memory is limited and you need to overwrite old data automatically.

When implementing queues that handle data flowing in and out smoothly.

Syntax

Signal Processing

class CircularBuffer:
    def __init__(self, size):
        self.size = size
        self.buffer = [None] * size
        self.start = 0
        self.count = 0

    def append(self, value):
        end = (self.start + self.count) % self.size
        self.buffer[end] = value
        if self.count == self.size:
            self.start = (self.start + 1) % self.size
        else:
            self.count += 1

    def get(self):
        return [self.buffer[(self.start + i) % self.size] for i in range(self.count)]

The buffer uses a fixed size and overwrites old data when full.

Indexes wrap around using modulo (%) to stay within buffer size.

Examples

Adds two values and prints current buffer: [10, 20]

Signal Processing

cb = CircularBuffer(3)
cb.append(10)
cb.append(20)
print(cb.get())

After adding two more values, oldest (10) is overwritten: [20, 30, 40]

Signal Processing

cb.append(30)
cb.append(40)
print(cb.get())

Sample Program

This program creates a circular buffer of size 4. It adds six values one by one. When the buffer is full, it overwrites the oldest values. After each addition, it prints the current buffer contents showing how data moves through the buffer.

Signal Processing

class CircularBuffer:
    def __init__(self, size):
        self.size = size
        self.buffer = [None] * size
        self.start = 0
        self.count = 0

    def append(self, value):
        end = (self.start + self.count) % self.size
        self.buffer[end] = value
        if self.count == self.size:
            self.start = (self.start + 1) % self.size
        else:
            self.count += 1

    def get(self):
        return [self.buffer[(self.start + i) % self.size] for i in range(self.count)]

# Create a buffer of size 4
cb = CircularBuffer(4)

# Simulate streaming data input
for val in [5, 10, 15, 20, 25, 30]:
    cb.append(val)
    print(f"Buffer contents after adding {val}: {cb.get()}")

Important Notes

Remember that the buffer size is fixed; adding more data overwrites the oldest entries.

Use circular buffers to avoid delays and memory issues in real-time data processing.

Summary

Circular buffers store streaming data in a fixed-size space by overwriting old data.

They are useful for real-time data like sensors or audio where only recent data matters.

Indexes wrap around to reuse buffer space efficiently.

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