Writing to a hardware register in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this hardware register write simulation?

Consider this embedded C code simulating writing to a hardware register. What value will be stored in REG after execution?

Embedded C

volatile unsigned int REG = 0x00;

void write_register(unsigned int value) {
    REG = value | 0x0F;
}

int main() {
    write_register(0xF0);
    return REG;
}

A 0xF0

B 0xFF

C 0x0F

D 0x00

💡 Hint

Remember the bitwise OR operation sets bits that are set in either operand.

The function write_register sets REG to the bitwise OR of value and 0x0F. Since value is 0xF0, OR with 0x0F results in 0xFF.

🧠 Conceptual

intermediate

Which statement correctly describes volatile keyword in hardware register access?

Why is the volatile keyword important when declaring hardware registers in embedded C?

A It allows the variable to be shared between multiple threads.

B It makes the variable read-only to protect hardware registers.

C It initializes the variable to zero automatically.

D It tells the compiler the variable can change unexpectedly, preventing optimization.

💡 Hint

Think about how hardware registers can change outside program control.

The volatile keyword prevents the compiler from optimizing away reads or writes to the variable, because the value can change at any time due to hardware events.

🔧 Debug

advanced

Why does this hardware register write code cause a runtime error?

Examine the code below. It attempts to write to a hardware register but causes a runtime error. What is the cause?

Embedded C

unsigned int *REG = NULL;

void write_register(unsigned int value) {
    *REG = value;
}

int main() {
    write_register(0xAA);
    return 0;
}

A Dereferencing a NULL pointer causes a runtime error.

B The value 0xAA is invalid for hardware registers.

C Missing volatile keyword causes undefined behavior.

D The function write_register is missing a return statement.

💡 Hint

Check the pointer initialization before dereferencing.

The pointer REG is initialized to NULL. Dereferencing it to write causes a runtime crash (segmentation fault).

📝 Syntax

advanced

Which option correctly writes 0x55 to a hardware register at address 0x4000?

Choose the correct C code snippet to write the value 0x55 to a hardware register located at memory address 0x4000.

A *(volatile unsigned int *)0x4000 = 0x55;

B volatile unsigned int *reg = 0x4000; *reg = 0x55;

C *(unsigned int 0x4000) = 0x55;

D unsigned int reg = (volatile unsigned int *)0x4000; reg = 0x55;

💡 Hint

Remember how to cast an address to a pointer and write through it.

Option A correctly casts the address to a volatile pointer and dereferences it to assign the value.

🚀 Application

expert

How many bits are set in the hardware register after this write?

Given the following code, how many bits are set to 1 in the REG after execution?

Embedded C

volatile unsigned char REG = 0x00;

void set_bits(unsigned char mask) {
    REG |= mask;
}

int main() {
    set_bits(0x0F);  // sets lower 4 bits
    set_bits(0x33);  // sets bits 0,1,4,5
    return 0;
}

A 4

B 5

C 6

D 7

💡 Hint

Count the bits set after both OR operations.

After first call, REG = 0x0F (bits 0-3 set). After second call, REG |= 0x33 sets bits 0,1,4,5. Combined bits set are 0,1,2,3,4,5 = 6 bits.