Double buffer technique in Embedded C - Mini Project: Build & Apply

Double Buffer Technique in Embedded C

📖 Scenario: You are working on a simple embedded system that controls an LED display. To avoid flickering on the display, you will use the double buffer technique. This means you will prepare the next frame of data in a separate buffer while the current frame is being shown. When the next frame is ready, you swap the buffers to update the display smoothly.

🎯 Goal: Build a program that uses two buffers to hold LED states. You will fill one buffer with new data while the other buffer is being displayed. Then you will swap the buffers to update the display without flicker.

📋 What You'll Learn

Create two buffers to hold LED states

Use a variable to track the active buffer

Write code to fill the inactive buffer with new LED data

Swap the active and inactive buffers

Print the active buffer contents to simulate display output

💡 Why This Matters

🌍 Real World

Double buffering is used in embedded systems to update displays smoothly without flicker by preparing data in a hidden buffer before showing it.

💼 Career

Understanding double buffering is important for embedded developers working on display drivers, real-time systems, and graphics programming.

1

Create two LED buffers

Create two integer arrays called buffer1 and buffer2, each with 5 elements initialized to 0.

Embedded C

# Create two integer arrays called buffer1 and buffer2, each with 5 elements initialized to 0
// Your code here

Hint

Use int buffer1[5] = {0, 0, 0, 0, 0}; and similarly for buffer2.

2

Add a variable to track the active buffer

Create an integer variable called active_buffer and set it to 1 to indicate buffer1 is active.

Embedded C

int buffer1[5] = {0, 0, 0, 0, 0};
int buffer2[5] = {0, 0, 0, 0, 0};
// Create an integer variable active_buffer and set it to 1
// Your code here

Hint

Use int active_buffer = 1; to track which buffer is active.

3

Fill the inactive buffer with new LED data

Write code to fill the inactive buffer with the values 1, 2, 3, 4, 5. Use an integer pointer inactive to point to the inactive buffer based on active_buffer. Use a for loop with variable i to assign values.

Embedded C

int buffer1[5] = {0, 0, 0, 0, 0};
int buffer2[5] = {0, 0, 0, 0, 0};
int active_buffer = 1;
// Create a pointer inactive to point to the inactive buffer
// Use a for loop with i to fill inactive buffer with 1, 2, 3, 4, 5
// Your code here

Hint

Use a pointer inactive to select the buffer not active, then fill it with values 1 to 5 using a for loop.

4

Swap buffers and print active buffer

Swap the value of active_buffer between 1 and 2. Then create a pointer active to point to the active buffer. Use a for loop with variable i to print each element of the active buffer separated by spaces using printf. End with a newline.

Embedded C

int buffer1[5] = {0, 0, 0, 0, 0};
int buffer2[5] = {0, 0, 0, 0, 0};
int active_buffer = 1;

int *inactive = (active_buffer == 1) ? buffer2 : buffer1;
for (int i = 0; i < 5; i++) {
    inactive[i] = i + 1;
}
// Swap active_buffer between 1 and 2
// Create pointer active to point to active buffer
// Print active buffer elements separated by spaces
// Your code here

Hint

Toggle active_buffer between 1 and 2. Use a pointer active to the active buffer. Print each element with printf("%d ", active[i]). Finish with printf("\n").

Practice

1. What is the main purpose of using the double buffer technique in embedded systems?

easy

A. To prevent flickering and tearing on the display

B. To increase the CPU clock speed

C. To reduce memory usage by using only one buffer

D. To simplify the code by avoiding buffer swaps

Solution

1. Step 1: Understand flickering and tearing issues

   Flickering and tearing happen when the display updates while drawing is in progress.

2. Step 2: Role of double buffering

   Double buffering uses two buffers so one can be drawn while the other is shown, preventing flicker.

3. Final Answer:

   To prevent flickering and tearing on the display -> Option A

4. Quick Check:

   Double buffering = prevent flickering [OK]

Hint: Double buffer means two buffers for smooth display updates [OK]

Common Mistakes:

• Thinking double buffer reduces CPU speed
• Believing it uses less memory
• Assuming it avoids buffer swaps

2. Which of the following code snippets correctly declares two buffers for double buffering in embedded C?

easy

A. char buffer[128]; char buffer[128];

B. char buffer1[128]; char buffer2[128];

C. char buffer1; char buffer2;

D. int buffer1[128]; char buffer2[64];

Solution

1. Step 1: Check buffer declarations

   Buffers must be arrays of the same size and type to hold display data.

2. Step 2: Validate each option

   char buffer1[128]; char buffer2[128]; declares two char arrays of size 128, suitable for double buffering.

3. Final Answer:

   char buffer1[128]; char buffer2[128]; -> Option B

4. Quick Check:

   Two same-size arrays = correct buffers [OK]

Hint: Two buffers must be separate arrays of same size [OK]

Common Mistakes:

• Declaring two arrays with the same name
• Using single variables instead of arrays
• Using different sizes or types for buffers

3. Consider this code snippet using double buffering:

char frontBuffer[5] = {1, 2, 3, 4, 5};
char backBuffer[5] = {6, 7, 8, 9, 10};

// Swap buffers
char *temp = frontBuffer;
frontBuffer = backBuffer;
backBuffer = temp;

printf("%d", frontBuffer[0]);

What will be the output?

medium

A. Compilation error

B. 6

C. 1

D. Runtime error

Solution

1. Step 1: Analyze buffer declarations

   frontBuffer and backBuffer are arrays, not pointers, so they cannot be assigned directly.

2. Step 2: Understand pointer assignment error

   Assigning arrays like pointers causes compilation error in C.

3. Final Answer:

   Compilation error -> Option A

4. Quick Check:

   Arrays cannot be assigned directly = compilation error [OK]

Hint: Arrays can't be assigned directly in C [OK]

Common Mistakes:

• Assuming arrays can be swapped by assignment
• Expecting output 6 without fixing code
• Ignoring pointer vs array difference

4. The following code attempts to implement double buffering but causes flickering. What is the likely bug?

char buffer1[100];
char buffer2[100];
char *front = buffer1;
char *back = buffer2;

void updateDisplay() {
  // Draw to back buffer
  for (int i = 0; i < 100; i++) {
    back[i] = i;
  }
  // Swap buffers
  front = back;
  back = front;
}

medium

A. Buffers should be global, not local

B. Buffers are too small for display data

C. Buffers are not swapped correctly; back and front point to same buffer

D. Drawing loop uses wrong index range

Solution

1. Step 1: Examine buffer swap logic

   Swapping front and back pointers as done causes both to point to the same buffer.

2. Step 2: Identify correct swap method

   Need a temporary pointer to swap buffers properly to avoid flickering.

3. Final Answer:

   Buffers are not swapped correctly; back and front point to same buffer -> Option C

4. Quick Check:

   Incorrect pointer swap = flickering [OK]

Hint: Use temp pointer to swap buffers correctly [OK]

Common Mistakes:

• Swapping pointers without temp variable
• Assuming buffers auto-swap
• Ignoring flicker cause from wrong swap

5. You want to implement double buffering for a 2D LED matrix display of size 8x8. Which approach correctly updates the display without flicker?

char frontBuffer[8][8];
char backBuffer[8][8];

void drawPixel(int x, int y, char value) {
  backBuffer[x][y] = value;
}

void swapBuffers() {
  // Swap pointers to buffers
  char (*temp)[8] = frontBuffer;
  frontBuffer = backBuffer;
  backBuffer = temp;
}

void refreshDisplay() {
  // Send frontBuffer data to LED matrix hardware
}

What is the main problem with this code?

hard

A. refreshDisplay should clear backBuffer before swapping

B. drawPixel writes to frontBuffer instead of backBuffer

C. swapBuffers uses wrong pointer type for temp

D. Cannot assign arrays directly; frontBuffer and backBuffer are arrays, not pointers

Solution

1. Step 1: Understand array vs pointer assignment

   In C, arrays cannot be assigned directly; frontBuffer and backBuffer are arrays, not pointers.

2. Step 2: Identify correct buffer swapping method

   To swap buffers, pointers to arrays should be used instead of arrays themselves.

3. Final Answer:

   Cannot assign arrays directly; frontBuffer and backBuffer are arrays, not pointers -> Option D

4. Quick Check:

   Arrays can't be swapped by assignment = problem [OK]

Hint: Use pointers to arrays for swapping buffers [OK]

Common Mistakes:

• Trying to assign arrays directly
• Ignoring pointer type mismatch
• Assuming drawPixel writes to wrong buffer