Power-electronicsHow-ToBeginner · 4 min read

How to Define Register Addresses in Embedded C

In embedded C, you define register addresses using #define macros or const pointers that point to specific memory locations. This allows your program to read from or write to hardware registers by accessing these fixed addresses directly.

📐

Syntax

Register addresses are usually defined as macros or pointers to fixed memory locations. The common syntax uses #define for constants or volatile pointers to ensure the compiler does not optimize away hardware access.

#define: Creates a constant for the register address.
volatile: Tells the compiler the value can change anytime (hardware updates).
Pointer dereference: Accesses the value at the register address.

#define REGISTER_NAME (*(volatile unsigned int*)0x40021000)

💻

Example

This example shows how to define a register address and write a value to it. It simulates writing to a hardware register at address 0x40021000.

#include <stdio.h>

// Define a register at address 0x40021000
#define REG (*(volatile unsigned int*)0x40021000)

int main() {
    // Simulate writing to the register
    REG = 0xABCD1234;

    // Normally, you can't print hardware registers, but for demo, print the value
    printf("Register value: 0x%X\n", REG);
    return 0;
}

Output

⚠️

Common Pitfalls

Common mistakes include:

Not using volatile, which can cause the compiler to optimize away register reads/writes.
Using incorrect data types or sizes that don't match the hardware register width.
Forgetting to cast the address to a pointer type before dereferencing.
Using magic numbers directly instead of named macros, which reduces code readability.

#include <stdio.h>

// Wrong: missing volatile and no pointer cast
#define WRONG_REG 0x40021000

// Correct:
#define CORRECT_REG (*(volatile unsigned int*)0x40021000)

int main() {
    // WRONG_REG = 0x1234; // This is just a number, not a memory access
    CORRECT_REG = 0x1234;  // Correct way to write to register
    return 0;
}

📊

Quick Reference

Concept	Example	Purpose
#define REGISTER ((volatile type)address)	#define REG ((volatile unsigned int)0x40021000)	Defines a register at fixed address
volatile keyword	volatile unsigned int*	Prevents compiler optimization on hardware registers
Pointer dereference	(volatile unsigned int)0x40021000	Accesses the value at the register address
Use macros	#define LED_CTRL ((volatile unsigned int)0x50000000)	Improves readability and maintainability

✅

Key Takeaways

Use #define with volatile pointers to define hardware register addresses safely.

Always cast the register address to a pointer type before dereferencing.

Use volatile to prevent compiler optimizations on hardware registers.

Avoid magic numbers by using named macros for register addresses.

Match the data type size to the hardware register width for correct access.