Defining Base Addresses for Embedded Memory and Peripherals

A solid foundation in MCU driver development starts with correctly setting up the base addresses for embedded memories and peripheral buses. In this article, we dive into how to define these addresses using C macros, ensuring that your drivers can accurately control and interact with hardware components.

Embedded Memory Base Addresses

Every microcontroller has built-in memory regions like Flash and SRAM that serve as the core for program storage and runtime data. When defining these base addresses, you typically create macros. For example:

• Flash Memory:
  The Flash memory usually starts at an address like 0x08000000.

  #define FLASH_BASEADDR 0x08000000U
  

• SRAM:
  The main SRAM is commonly labeled as SRAM1 and might start at 0x20000000.

  #define SRAM1_BASEADDR 0x20000000U
  

  For microcontrollers with multiple SRAM segments (e.g., SRAM2), you can calculate the base address of SRAM2 by adding the size of SRAM1 to its base address. For instance, if SRAM1 is 112 KB, then:

  #define SRAM2_BASEADDR (SRAM1_BASEADDR + (112 * 1024U))
  

• 


Using the 'U' suffix informs the compiler that these values are unsigned integers, which is important because addresses should not be treated as signed numbers.

Peripheral Bus Base Addresses

Beyond the on-chip memories, microcontrollers manage peripheral devices over dedicated bus domains. For example, in many STM32 microcontrollers, peripheral registers start at 0x40000000. The peripheral memory is then subdivided into different bus domains such as:

• APB1 Peripheral Base:
  This is the starting address for peripherals connected to the APB1 bus.

• APB2 Peripheral Base:
  The starting address for peripherals on the APB2 bus.

• AHB1 and AHB2 Peripheral Base:
  High-speed peripherals, such as some GPIOs and camera interfaces, may reside on these buses.

Each of these base addresses is defined by the MCU’s memory map and is essential for deriving the register addresses of specific peripherals.

Defining Peripheral Base Addresses in Code

Once you have the base address of the peripheral domain (for instance, 0x40000000), you can calculate the individual peripheral addresses using offsets from this base. For example, suppose the reference manual indicates that GPIOA is the first peripheral on AHB1 with an offset of 0x0000; then you define:

#define GPIOA_BASEADDR (AHB1_PERIPH_BASEADDR + 0x0000U)

Similarly, for GPIOB with an offset of 0x0400, you would write:

#define GPIOB_BASEADDR (AHB1_PERIPH_BASEADDR + 0x0400U)

This approach continues for each GPIO port and other peripheral devices, such as I2C, SPI, and UART. It ensures consistency, making your driver code easier to manage and more portable across different MCUs. Adopting a uniform naming convention—using all capital letters for macros—is a standard practice in embedded programming to instantly recognize these definitions.

Project Integration and Next Steps

The device-specific header file, which contains all these base addresses and other MCU details, is included in both your driver layer and your application layer. This makes it a critical piece for any driver development project since your driver functions will directly reference these macros to access hardware registers.

After successfully defining these base addresses, the next step is to calculate the addresses of individual registers within each peripheral by adding specific offsets. This forms the core of your driver’s ability to configure, control, and troubleshoot the hardware.

Conclusion

Setting up correct base addresses for memory and peripherals is essential for robust MCU driver development. With carefully defined C macros and a well-documented device-specific header file, you lay the groundwork for a reliable and maintainable embedded system. By ensuring every memory region and peripheral bus is mapped accurately, you prepare your project for seamless hardware interaction and efficient code development.

Written By: Musaab Taha

This article was improved with the assistance of AI.