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.

Practice

1.

What is the main purpose of memory-mapped I/O in embedded C?

easy

A. To perform file input/output operations

B. To allocate dynamic memory for variables

C. To manage network communication protocols

D. To control hardware devices using specific memory addresses

Solution

1. Step 1: Understand memory-mapped I/O concept

   Memory-mapped I/O assigns special memory addresses to hardware devices so the CPU can control them by reading/writing these addresses.

2. Step 2: Differentiate from other memory uses

   Unlike dynamic memory allocation or file/network I/O, memory-mapped I/O directly interfaces with hardware registers.

3. Final Answer:

   To control hardware devices using specific memory addresses -> Option D

4. Quick Check:

   Memory-mapped I/O = hardware control via memory [OK]

Hint: Memory-mapped I/O means hardware control via memory addresses [OK]

Common Mistakes:

• Confusing memory-mapped I/O with file or network I/O
• Thinking it allocates memory for variables
• Assuming it manages software protocols

2.

Which of the following is the correct way to declare a pointer for a memory-mapped hardware register at address 0x40021000 in embedded C?

easy

A. int *reg = (int *)0x40021000;

B. volatile int *reg = (volatile int *)0x40021000;

C. volatile int reg = 0x40021000;

D. int reg = (int *)0x40021000;

Solution

1. Step 1: Use volatile keyword for hardware registers

   Hardware registers can change anytime, so pointer must be declared volatile to prevent compiler optimizations.

2. Step 2: Correct pointer type and casting

   The pointer should be of type volatile int* and cast the address to (volatile int *) to access the register correctly.

3. Final Answer:

   volatile int *reg = (volatile int *)0x40021000; -> Option B

4. Quick Check:

   Use volatile pointer with correct cast [OK]

Hint: Always use volatile pointer cast for hardware addresses [OK]

Common Mistakes:

• Omitting volatile keyword
• Assigning address to int variable instead of pointer
• Wrong casting or missing pointer declaration

3.

Consider the following code snippet in embedded C:

volatile unsigned int *LED_REG = (volatile unsigned int *)0x50000000;
*LED_REG = 0xFF;
unsigned int value = *LED_REG;

What is the value of value after execution?

medium

A. 0x00

B. Compiler error

C. 0xFF

D. Undefined behavior

Solution

1. Step 1: Write 0xFF to hardware register

   The statement *LED_REG = 0xFF; writes the value 0xFF to the memory address 0x50000000.

2. Step 2: Read back the value from the same register

   The next line reads the value from the same address, so value will be 0xFF as written.

3. Final Answer:

   0xFF -> Option C

4. Quick Check:

   Write then read same register = same value [OK]

Hint: Read returns last written value to hardware register [OK]

Common Mistakes:

• Assuming value resets to 0
• Thinking reading hardware register causes error
• Ignoring volatile keyword effects

4.

Identify the error in the following embedded C code snippet for memory-mapped I/O:

unsigned int *TIMER_REG = (unsigned int *)0x60000000;
*TIMER_REG = 0x01;

medium

A. Missing volatile keyword for pointer declaration

B. Incorrect address casting syntax

C. Pointer should be declared as int, not unsigned int

D. Cannot assign value directly to pointer

Solution

1. Step 1: Check pointer declaration for hardware register

   Hardware registers must be accessed via volatile pointers to prevent compiler optimizations that may skip reads/writes.

2. Step 2: Identify missing volatile keyword

   The pointer is declared as unsigned int * without volatile, which is incorrect for memory-mapped I/O.

3. Final Answer:

   Missing volatile keyword for pointer declaration -> Option A

4. Quick Check:

   Hardware pointers need volatile keyword [OK]

Hint: Always use volatile for hardware register pointers [OK]

Common Mistakes:

• Ignoring volatile keyword
• Confusing pointer type with variable type
• Thinking casting syntax is wrong

5.

You want to toggle a hardware LED connected to a memory-mapped register at address 0x70000000. The LED turns on when bit 0 is set to 1 and off when it is 0. Which code snippet correctly toggles the LED state without affecting other bits?

hard

A. volatile unsigned int *LED = (volatile unsigned int *)0x70000000;
*LED = *LED ^ 0x01;

B. volatile unsigned int *LED = (volatile unsigned int *)0x70000000;
*LED = 0x01;

C. unsigned int *LED = (unsigned int *)0x70000000;
*LED |= 0x01;

D. volatile unsigned int LED = 0x70000000;
LED ^= 0x01;

Solution

1. Step 1: Use volatile pointer to access hardware register

   Declare LED as volatile unsigned int pointer to ensure proper hardware access and prevent compiler optimization.

2. Step 2: Toggle bit 0 without affecting other bits

   Use XOR (^ 0x01) on *LED to flip bit 0 while leaving other bits unchanged.

3. Step 3: Check other options for errors

   volatile unsigned int *LED = (volatile unsigned int *)0x70000000; *LED = 0x01; overwrites all bits, C lacks volatile, D treats LED as variable not pointer.

4. Final Answer:

   volatile unsigned int *LED = (volatile unsigned int *)0x70000000; *LED = *LED ^ 0x01; -> Option A

5. Quick Check:

   Toggle bit with XOR on volatile pointer [OK]

Hint: Use XOR on volatile pointer to toggle bits safely [OK]

Common Mistakes:

• Overwriting entire register instead of toggling bit
• Missing volatile keyword causing optimization issues
• Using variable instead of pointer for hardware address