Volatile keyword and why it matters in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code using volatile?

Consider the following embedded C code snippet. What will be the output printed by the program?

Embedded C

#include <stdio.h>

volatile int flag = 0;

void setFlag() {
    flag = 1;
}

int main() {
    while(flag == 0) {
        // waiting for flag to change
    }
    printf("Flag changed!\n");
    return 0;
}

// Assume setFlag() is called asynchronously by an interrupt or another thread.

A The program crashes with a segmentation fault.

B The program runs forever and never prints anything.

C The program prints "Flag changed!" multiple times.

D The program prints "Flag changed!" and exits.

💡 Hint

Think about how the volatile keyword affects compiler optimizations and variable visibility.

The volatile keyword tells the compiler that the variable 'flag' can change at any time outside the current code flow, so it must reload its value every time it is accessed. This ensures the while loop will detect the change made by setFlag() and exit, printing the message once.

❓ Predict Output

intermediate

What happens if volatile is removed?

Given the same code as before but without the volatile keyword on 'flag', what is the most likely behavior?

Embedded C

#include <stdio.h>

int flag = 0;

void setFlag() {
    flag = 1;
}

int main() {
    while(flag == 0) {
        // waiting for flag to change
    }
    printf("Flag changed!\n");
    return 0;
}

// Assume setFlag() is called asynchronously by an interrupt or another thread.

A The program prints "Flag changed!" and exits.

B The program prints "Flag changed!" multiple times.

C The program runs forever and never prints anything.

D The program crashes with a segmentation fault.

💡 Hint

Consider how the compiler might optimize the loop without volatile.

Without volatile, the compiler may optimize the loop by reading 'flag' once and assuming it never changes, causing an infinite loop. The program never detects the change made by setFlag().

🔧 Debug

advanced

Identify the problem with this volatile usage

What is the main issue with the following code snippet regarding volatile usage?

Embedded C

volatile int *ptr = (volatile int *)0x40000000;

int main() {
    *ptr = 5;
    int val = *ptr;
    if(val == 5) {
        // do something
    }
    return 0;
}

A The data pointed to is volatile but the pointer is not volatile, which is correct.

B The pointer and the data it points to should both be volatile.

C The pointer is volatile but the data it points to is not volatile.

D The pointer itself should be volatile, not the data it points to.

💡 Hint

Think about what volatile means for pointers and the data they point to.

Declaring the data pointed to as volatile ensures every access to *ptr reads or writes the actual hardware register. The pointer itself does not need to be volatile unless the pointer variable changes unexpectedly.

📝 Syntax

advanced

Which declaration correctly uses volatile for a hardware register?

Choose the correct declaration for a volatile pointer to a 32-bit hardware register at address 0x40001000.

A volatile int *reg = (volatile int *)0x40001000;

B int volatile *reg = (int volatile *)0x40001000;

C int * volatile reg = (int *)0x40001000;

D volatile int volatile *reg = (volatile int volatile *)0x40001000;

💡 Hint

Remember that 'volatile' can appear before or after the type and applies to the pointed data.

Both 'volatile int *' and 'int volatile *' declare a pointer to volatile int data. Option B uses 'int volatile *' which is correct and common style. Option B makes the pointer volatile, not the data. Option B repeats volatile redundantly. Option B is also valid but B is the best style here.

🚀 Application

expert

Why is volatile critical in embedded interrupt handling?

In embedded systems, why is it important to declare variables shared between main code and interrupt service routines (ISRs) as volatile?

A Because volatile prevents the compiler from optimizing away reads and writes, ensuring the main code sees changes made by the ISR.

B Because volatile makes the variable thread-safe and automatically locks it during ISR execution.

C Because volatile increases the speed of variable access in ISRs.

D Because volatile allows the variable to be stored in faster CPU registers.

💡 Hint

Think about how the compiler treats variables that can change unexpectedly.

Volatile tells the compiler that the variable can change at any time, such as by an ISR, so it must always read the variable from memory and not cache it. This ensures the main code sees the latest value.