Startup Code in MCU: A Critical Component for Embedded Systems

When developing software for microcontroller units (MCUs), understanding the startup code is crucial. Startup code refers to the initial instructions that an MCU executes when it powers on or is reset. This code is typically written in C, assembly language, or a combination of both, and its primary role is to set up the environment for the main application to run. The startup code performs essential tasks like initializing hardware, setting up memory, and configuring peripherals. Without it, the MCU would not be able to run the application code properly.

In this article, we will explore the role of startup code in MCU development, its essential components, and how it’s typically implemented in C for embedded systems.

What is Startup Code?

Startup code is the first piece of software that runs after a microcontroller powers up or resets. This code prepares the MCU for normal operation by performing several tasks that are critical for the functioning of the system. The startup code is executed before the main program (often called main() in C) and is responsible for setting up hardware, memory initialization, interrupt handling, and sometimes basic system configurations.

The startup code includes:

• Reset Vector: When the MCU is powered on or reset, the program counter (PC) is set to a specific address known as the reset vector. This address points to the startup code, which initializes the system.
• System Initialization: The startup code configures various MCU settings, such as clock sources, system timers, and memory segments.
• Memory Initialization: It initializes critical sections of memory like the stack, heap, and data segments.
• Peripheral Initialization: The code sets up various peripherals such as UART, ADC, GPIOs, and more.
• Interrupt Vector Setup: In many systems, the startup code configures the interrupt vector table so that the MCU knows where to jump when an interrupt occurs.
• Calling the Main Program: Once the system is fully initialized, the startup code calls the main application (usually a main() function in C).

Example of Startup Code in C

Here’s a simple example of startup code written in C for an MCU. This example demonstrates initializing the system clock and setting up the interrupt vector table.

#include <stdint.h>

extern void main(void);  // Declaring the main function

// Define the memory sections
extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss, _estack;

// Stack pointer initialization
void reset_handler(void) __attribute__((naked, section(".reset")));
void reset_handler(void) {
    // Initialize the stack pointer
    __asm__("LDR SP, =_estack");

    // Initialize data section
    uint32_t *src = &_sidata;
    uint32_t *dst = &_sdata;
    while (dst < &_edata) {
        *dst++ = *src++;
    }

    // Zero out the BSS section
    uint32_t *bss_start = &_sbss;
    while (bss_start < &_ebss) {
        *bss_start++ = 0;
    }

    // Call main
    main();
}

// The interrupt vector table
__attribute__((section(".vectors"))) void (* const vector_table[])() = {
    (void (*)(void))(&_estack), // Stack pointer initialization
    reset_handler,               // Reset Handler
    // Add other interrupt handlers here
};

// Main program entry point
void main(void) {
    // Main program logic goes here
}

In this example:

• The reset_handler() function is the first piece of code executed after a reset. It sets up the stack pointer, initializes the data section, zeros out the BSS section, and then calls the main() function.
• The vector_table[] is the interrupt vector table, where the MCU looks for interrupt handlers.
• Memory addresses like _sidata, _sdata, _edata, etc., are defined in the linker script to match the corresponding sections in the MCU’s memory.

Linker Script

In addition to the C code, the linker script plays a crucial role in startup code. The linker script defines the memory layout and specifies where different sections (like code, data, BSS, stack) should be placed in memory. It ensures that the startup code is linked correctly to the appropriate memory addresses.

Example snippet from a linker script:

SECTIONS {
  .text : {
    *(.text)             /* Code section */
  } > FLASH

  .data : {
    *(.data)             /* Initialized data section */
  } > SRAM

  .bss : {
    *(.bss)              /* Uninitialized data section */
  } > SRAM

  .stack : {
    . = . + 0x1000;      /* Define stack size */
  }
}

Conclusion

The startup code in an MCU is an essential part of embedded systems development. It sets up the system, initializes memory, configures peripherals, and prepares the MCU to run the application code. Whether written in assembly or C, the startup code ensures that the microcontroller is correctly configured and that the main program can run without issues. Understanding how to write and modify this startup code is a critical skill for embedded systems developers.