Memory-mapped I/O concept in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Memory-mapped I/O Register Write

What will be the output of this embedded C code snippet that writes to a memory-mapped I/O register?

Embedded C

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

#define REG_ADDR ((volatile uint32_t*)0x40000000)

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

A Segmentation fault

B Register value: 0xABCD1234

C Register value: 0x00000000

D Compilation error

💡 Hint

Memory-mapped I/O registers behave like normal memory locations for read/write operations.

The code writes the value 0xABCD1234 to the memory address 0x40000000 and then reads it back. Since this is a memory-mapped register, the value read matches the value written.

🧠 Conceptual

intermediate

Purpose of volatile in Memory-mapped I/O

Why is the volatile keyword important when accessing memory-mapped I/O registers in embedded C?

A It prevents the compiler from optimizing away accesses to the register.

B It makes the variable read-only.

C It allocates the variable in faster cache memory.

D It automatically initializes the register to zero.

💡 Hint

Think about how the compiler treats variables that can change outside program control.

Memory-mapped I/O registers can change independently of the program flow, so volatile tells the compiler to always read/write them directly and not optimize those accesses away.

🔧 Debug

advanced

Identify the error in memory-mapped I/O access

What error will occur when running this code snippet that tries to read a memory-mapped I/O register?

Embedded C

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

#define REG_ADDR 0x40000000

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

A Compilation error: invalid use of integer as pointer

B Runtime segmentation fault

C Prints garbage value

D No error, prints correct value

💡 Hint

Check how REG_ADDR is defined and used as a pointer.

REG_ADDR is defined as an integer constant, but the code tries to dereference it as a pointer without casting. This causes a compilation error.

📝 Syntax

advanced

Correct syntax for writing to a memory-mapped register

Which option correctly writes the value 0x55 to the memory-mapped register at address 0x50000000?

A volatile uint8_t *reg = 0x50000000; *reg = 0x55;

B *(uint8_t)0x50000000 = 0x55;

C uint8_t reg = *(volatile uint8_t*)0x50000000; reg = 0x55;

D *((volatile uint8_t*)0x50000000) = 0x55;

💡 Hint

Casting the address to a pointer and dereferencing it is required.

Option D correctly casts the address to a volatile pointer and writes the value. Option D misses the cast, causing a type error. Option D writes to a local copy, not the register. Option D has invalid cast syntax.

🚀 Application

expert

Number of bytes accessed in memory-mapped I/O

Given this code accessing a 32-bit memory-mapped register, how many bytes does the program read from the hardware address?

Embedded C

#define REG32 ((volatile uint32_t*)0x60000000)

uint32_t read_value() {
    return *REG32;
}

A Depends on compiler optimization

B 1 byte

C 4 bytes

D 2 bytes

💡 Hint

Consider the size of the data type pointed to by REG32.

The pointer is to a 32-bit unsigned integer, which is 4 bytes. So the read accesses 4 bytes from the hardware address.