Common embedded bugs and fixes in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this embedded C code snippet?

Consider the following code running on an embedded system. What will be printed?

Embedded C

#include <stdio.h>

volatile int flag = 0;

void interrupt_handler() {
    flag = 1;
}

int main() {
    while (!flag) {
        // wait for interrupt
    }
    printf("Flag set!\n");
    return 0;
}

A Flag set!

B No output (infinite loop)

C Compilation error due to volatile usage

D Runtime error due to interrupt_handler

💡 Hint

Think about the role of volatile in embedded systems.

The volatile keyword tells the compiler that flag can change unexpectedly (e.g., by an interrupt). Without volatile, the compiler might optimize the loop to an infinite loop. Here, flag is volatile, so the loop exits when flag is set by the interrupt.

❓ Predict Output

intermediate

What is the output of this pointer arithmetic code?

What will be printed by this embedded C code?

Embedded C

#include <stdio.h>

int main() {
    char buffer[5] = {1, 2, 3, 4, 5};
    char *p = buffer;
    printf("%d\n", *(p + 3));
    return 0;
}

A 3

B 5

C 4

D Compilation error due to pointer usage

💡 Hint

Remember that pointer arithmetic moves by element size.

The pointer p points to buffer[0]. Adding 3 moves it to buffer[3], which contains the value 4.

🔧 Debug

advanced

What error does this code cause?

Analyze the following embedded C code. What error will it cause when run?

Embedded C

#include <stdio.h>

int main() {
    int *ptr = NULL;
    *ptr = 10;
    printf("%d\n", *ptr);
    return 0;
}

A Undefined behavior but no crash

B Prints 10

C Compilation error due to NULL pointer assignment

D Segmentation fault (null pointer dereference)

💡 Hint

Think about what happens when you write to a null pointer.

Dereferencing a NULL pointer causes a segmentation fault (crash) because it points to an invalid memory location.

📝 Syntax

advanced

Which option causes a syntax error?

Which of the following code snippets will cause a syntax error in embedded C?

A

int x = 10
int y = 20;

B int *p = &arr[0];

C void func() { return; }

D int arr[5] = {1, 2, 3, 4, 5};

💡 Hint

Look for missing semicolons.

Option A is missing a semicolon after int x = 10, causing a syntax error.

🚀 Application

expert

How many bytes does this struct occupy?

Given the following struct on a 32-bit embedded system, how many bytes does it occupy?

Embedded C

struct Data {
    char a;
    int b;
    char c;
};

A 8 bytes

B 12 bytes

C 9 bytes

D 10 bytes

💡 Hint

Consider padding and alignment on a 32-bit system.

On a 32-bit system, int requires 4-byte alignment. The struct layout is:
- a: 1 byte
- 3 bytes padding
- b: 4 bytes
- c: 1 byte
- 3 bytes padding
Total: 12 bytes.

Practice

1. What is a common cause of unpredictable behavior in embedded C programs related to variables?

easy

A. Using uninitialized variables before setting a value

B. Using too many comments in the code

C. Writing functions with too many parameters

D. Using global variables only

Solution

1. Step 1: Understand variable initialization

   Uninitialized variables contain garbage values, causing unpredictable behavior.

2. Step 2: Recognize the impact in embedded systems

   Embedded systems rely on precise values; uninitialized variables can cause errors or crashes.

3. Final Answer:

   Using uninitialized variables before setting a value -> Option A

4. Quick Check:

   Uninitialized variables = unpredictable values [OK]

Hint: Always initialize variables before use to avoid surprises [OK]

Common Mistakes:

• Assuming variables start at zero automatically
• Ignoring compiler warnings about uninitialized variables
• Thinking only pointers need initialization

2. Which of the following is the correct way to clear an interrupt flag in embedded C?

easy

A. interrupt_flag++;

B. interrupt_flag = 1;

C. interrupt_flag = 0;

D. interrupt_flag = -1;

Solution

1. Step 1: Identify interrupt flag clearing method

   Interrupt flags are cleared by setting them to 0 to indicate the interrupt is handled.

2. Step 2: Understand why other options fail

   Setting to 1 or incrementing does not clear the flag; negative values are invalid.

3. Final Answer:

   interrupt_flag = 0; -> Option C

4. Quick Check:

   Clear interrupt flag = 0 [OK]

Hint: Clear interrupt flags by setting them to zero [OK]

Common Mistakes:

• Setting flag to 1 instead of 0
• Incrementing flag instead of clearing
• Ignoring the need to clear flags causing repeated interrupts

3. What will be the output of this embedded C code snippet?

volatile int flag = 0;
void ISR() {
  flag = 1;
}
int main() {
  while(flag == 0) {
    // wait
  }
  return 0;
}

medium

A. Program waits until ISR sets flag to 1, then exits

B. Program exits immediately

C. Compilation error due to volatile keyword

D. Program runs indefinitely without stopping

Solution

1. Step 1: Understand volatile keyword usage

   Volatile tells compiler the variable can change anytime, so it won't optimize the loop away.

2. Step 2: Analyze program flow

   Main waits in loop until ISR sets flag to 1, then loop ends and program exits.

3. Final Answer:

   Program waits until ISR sets flag to 1, then exits -> Option A

4. Quick Check:

   Volatile flag updated by ISR = loop ends [OK]

Hint: Use volatile for variables changed by interrupts [OK]

Common Mistakes:

• Ignoring volatile causing infinite loop
• Assuming ISR runs automatically without setup
• Thinking volatile causes compile errors

4. Identify the bug in this embedded C code and the best fix:

int counter;
void setup() {
  // No initialization of counter
}
void loop() {
  counter++;
  if(counter > 10) {
    counter = 0;
  }
}

medium

A. Change counter to volatile

B. Initialize counter to 0 in setup()

C. Remove the if condition

D. Declare counter as static

Solution

1. Step 1: Identify uninitialized variable usage

   Counter is used without initialization, causing unpredictable start value.

2. Step 2: Fix by initializing counter

   Set counter = 0 in setup() to ensure predictable counting behavior.

3. Final Answer:

   Initialize counter to 0 in setup() -> Option B

4. Quick Check:

   Initialize variables before use = correct count [OK]

Hint: Always initialize counters before incrementing [OK]

Common Mistakes:

• Assuming global variables start at zero
• Using volatile without need
• Ignoring initialization causing wrong counts

5. You have a sensor reading stored in a variable that updates via interrupt. Which combination of fixes ensures safe and correct reading in main code?

volatile int sensor_value;
int safe_value;

void ISR() {
  sensor_value = read_sensor();
}

int main() {
  // What should be done here?
}

hard

A. Make sensor_value non-volatile and copy it

B. Directly use sensor_value without copying

C. Use a delay loop before reading sensor_value

D. Disable interrupts, copy sensor_value to safe_value, enable interrupts

Solution

1. Step 1: Understand volatile and interrupt safety

   Volatile ensures compiler reads fresh value, but reading multi-byte data can be interrupted causing corruption.

2. Step 2: Use interrupt disable-copy-enable pattern

   Disable interrupts, copy sensor_value to safe_value, then enable interrupts to get consistent snapshot.

3. Final Answer:

   Disable interrupts, copy sensor_value to safe_value, enable interrupts -> Option D

4. Quick Check:

   Disable interrupts to safely copy volatile data [OK]

Hint: Disable interrupts when copying multi-byte volatile data [OK]

Common Mistakes:

• Reading volatile multi-byte data without protection
• Making volatile variable non-volatile
• Using delay instead of disabling interrupts