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

Challenge - 5 Problems

❓ Predict Output

intermediate

Reading a 32-bit hardware register value

What is the output of this code snippet that reads a 32-bit hardware register and prints its value?

Embedded C

#include <stdio.h>
#include <stdint.h>

volatile uint32_t *REG = (uint32_t *)0x40000000;

int main() {
    uint32_t value = *REG;
    printf("Register value: 0x%08X\n", value);
    return 0;
}

A Register value: 0x00000000

B Register value: 0xFFFFFFFF

C Compilation error due to volatile pointer

D Runtime segmentation fault

💡 Hint

The register is assumed to be zero-initialized in this example.

The pointer REG points to a hardware register at address 0x40000000. Reading the value gives 0x00000000 as the register is assumed zeroed. The volatile keyword prevents compiler optimization but does not cause errors.

❓ Predict Output

intermediate

Effect of volatile on hardware register read

What will be the output of this code reading a hardware register twice with and without volatile?

Embedded C

#include <stdio.h>
#include <stdint.h>

uint32_t REG_VALUE = 0x12345678;

uint32_t read_register_nonvolatile() {
    uint32_t *reg = (uint32_t *)&REG_VALUE;
    return *reg;
}

uint32_t read_register_volatile() {
    volatile uint32_t *reg = (volatile uint32_t *)&REG_VALUE;
    return *reg;
}

int main() {
    printf("Non-volatile read: 0x%08X\n", read_register_nonvolatile());
    printf("Volatile read: 0x%08X\n", read_register_volatile());
    return 0;
}

A

Non-volatile read: 0x12345678
Volatile read: 0x00000000

B

Non-volatile read: 0x00000000
Volatile read: 0x12345678

C Compilation error due to volatile pointer

D

Non-volatile read: 0x12345678
Volatile read: 0x12345678

💡 Hint

Volatile affects compiler optimization but does not change the actual value read.

Both functions read the same memory location. Volatile ensures the compiler does not optimize away the read, but since the value is constant, both print the same value.

❓ Predict Output

advanced

Reading a hardware register with bit masking

What is the output of this code that reads a hardware register and extracts bits 4 to 7?

Embedded C

#include <stdio.h>
#include <stdint.h>

volatile uint32_t *REG = (uint32_t *)0x40000000;

int main() {
    uint32_t reg_val = *REG; // Suppose *REG = 0xABCD1234
    uint32_t masked = (reg_val >> 4) & 0xF;
    printf("Extracted bits 4-7: 0x%X\n", masked);
    return 0;
}

A Extracted bits 4-7: 0x1

B Extracted bits 4-7: 0x3

C Extracted bits 4-7: 0x2

D Extracted bits 4-7: 0x4

💡 Hint

Shift right by 4 bits then mask with 0xF to get bits 4 to 7.

The register value is 0xABCD1234. Bits 4 to 7 correspond to the second nibble from the right. Shifting right by 4 gives 0xABCD123, masking with 0xF extracts 0x3.

❓ Predict Output

advanced

Reading a hardware register with pointer arithmetic

What is the output of this code reading the second 32-bit register in a memory-mapped array?

Embedded C

#include <stdio.h>
#include <stdint.h>

volatile uint32_t *REGS = (uint32_t *)0x40000000;

int main() {
    uint32_t val = *(REGS + 1); // Suppose *(REGS+1) = 0xDEADBEEF
    printf("Second register value: 0x%X\n", val);
    return 0;
}

A Second register value: 0x00000000

B Second register value: 0x40000004

C Second register value: 0xDEADBEEF

D Runtime segmentation fault

💡 Hint

Pointer arithmetic moves by the size of the data type (4 bytes for uint32_t).

REGS points to the first register at 0x40000000. Adding 1 moves to 0x40000004, reading the second register which holds 0xDEADBEEF.

🧠 Conceptual

expert

Understanding volatile and hardware register reads

Which statement best explains why the volatile keyword is essential when reading hardware registers?

A Volatile tells the compiler to always read the value from memory and not optimize it away, ensuring the program sees the latest hardware state.

B Volatile allows the compiler to cache the register value in a CPU register for faster access.

C Volatile automatically synchronizes the hardware register with the CPU cache.

D Volatile converts the hardware register address into a constant value at compile time.

💡 Hint

Think about how hardware registers can change independently of the program flow.

Hardware registers can change at any time. Volatile prevents the compiler from optimizing away repeated reads, ensuring the program always reads the current value from the hardware.