Startup sequence and reset vector in Embedded C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the reset vector in embedded systems?

The reset vector is the specific memory address where the processor starts executing code after a reset. It points to the startup code that initializes the system.

beginner

Describe the startup sequence in an embedded system.

The startup sequence is the set of steps the processor follows after reset, including setting the stack pointer, initializing data and bss sections, and then calling the main program.

intermediate

Why is the stack pointer initialized early in the startup sequence?

The stack pointer is set early to ensure that function calls and local variables have a safe place in memory to work with during program execution.

intermediate

What happens to the .data and .bss sections during startup?

The .data section is copied from flash to RAM to initialize variables with predefined values, while the .bss section is cleared to zero to initialize uninitialized variables.

beginner

How does the processor know where to find the reset vector?

The processor has a fixed memory location, often at the start of memory, reserved for the reset vector. On reset, it reads this address to jump to the startup code.

What is the first action the processor takes after a reset?

A Clear the stack pointer

B Initialize all variables

C Start executing main() directly

D Jump to the reset vector address

After reset, the processor jumps to the reset vector address to start the startup sequence.

During startup, what is the purpose of copying the .data section from flash to RAM?

A To start the main program

B To initialize variables with predefined values

C To set the stack pointer

D To clear all variables to zero

The .data section contains variables with initial values stored in flash; copying it to RAM sets those variables correctly.

What does the .bss section contain before startup?

A Uninitialized variables

B Initialized variables

C Code instructions

D Stack data

The .bss section holds uninitialized variables that are set to zero during startup.

Why must the stack pointer be set before calling main()?

A To provide space for function calls and local variables

B To initialize global variables

C To reset the processor

D To copy the .data section

The stack pointer defines where the stack starts, which is needed for function calls and local variables.

Where is the reset vector usually located?

A At the end of RAM

B Inside the main() function

C At a fixed memory address at the start of memory

D In the .bss section

The reset vector is stored at a fixed address so the processor knows where to jump after reset.

Explain the steps the processor takes from reset to starting the main program.

Think about what needs to be ready before main() runs.

Describe the role of the reset vector in the startup sequence.

It is the first instruction address after reset.

Practice

1. What is the primary role of the reset vector in an embedded C program?

easy

A. It manages power consumption modes.

B. It initializes all global variables to zero.

C. It handles interrupts during program execution.

D. It tells the microcontroller where to start executing code after a reset.

Solution

1. Step 1: Understand the reset vector concept

   The reset vector is a special address in memory that points to the first instruction executed after a reset.

2. Step 2: Identify its role in program start

   When the microcontroller resets, it jumps to the reset vector to begin running the startup code.

3. Final Answer:

   It tells the microcontroller where to start executing code after a reset. -> Option D

4. Quick Check:

   Reset vector = start address after reset [OK]

Hint: Reset vector points to start code after reset [OK]

Common Mistakes:

• Confusing reset vector with interrupt vector
• Thinking reset vector initializes variables
• Assuming reset vector manages power modes

2. Which of the following is the correct way to declare the reset vector in embedded C?

easy

A. int ResetVector = 0x0000;

B. void ResetVector() { main(); }

C. void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler;

D. char *ResetVector = "Reset_Handler";

Solution

1. Step 1: Understand reset vector declaration

   The reset vector is usually a pointer to a function placed in a special memory section.

2. Step 2: Check syntax correctness

   void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; correctly declares a constant function pointer to Reset_Handler placed in the ".reset_vector" section using GCC attribute syntax.

3. Final Answer:

   void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; -> Option C

4. Quick Check:

   Function pointer in reset vector section = correct declaration [OK]

Hint: Reset vector is a function pointer in special section [OK]

Common Mistakes:

• Declaring reset vector as int or char pointer
• Defining reset vector as a function instead of pointer
• Missing section attribute for placement

3. Given the following code snippet, what will be the output after reset?

void Reset_Handler(void) {
    int x = 5;
    x += 10;
    while(1) {}
}

void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler;

medium

A. The program will enter an infinite loop after setting x to 15.

B. The program will run main() and print 15.

C. The program will cause a runtime error due to missing main.

D. The program will reset repeatedly.

Solution

1. Step 1: Analyze Reset_Handler behavior

   Reset_Handler sets x to 5, adds 10 making x = 15, then enters an infinite loop.

2. Step 2: Understand program flow after reset

   After reset, the microcontroller jumps to Reset_Handler and stays in the infinite loop; no main() is called.

3. Final Answer:

   The program will enter an infinite loop after setting x to 15. -> Option A

4. Quick Check:

   Reset_Handler runs then loops forever = infinite loop [OK]

Hint: Reset_Handler runs then loops forever, no main called [OK]

Common Mistakes:

• Assuming main() is called automatically
• Expecting output or print statements
• Confusing variable x scope and effect

4. Identify the error in this startup code snippet:

void Reset_Handler(void) {
    // Initialize data
    extern int _sidata, _sdata, _edata;
    int *src = &_sidata;
    int *dst = &_sdata;
    while(dst < &_edata) {
        *dst++ = *src++;
    }
    main();
}

void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler;

medium

A. Reset_Handler should not call main() directly.

B. The pointers _sidata, _sdata, _edata should be declared as extern char, not int.

C. The while loop condition should use <= instead of <.

D. ResetVector should not be a function pointer.

Solution

1. Step 1: Check pointer types for memory copy

   Memory sections like _sidata, _sdata, _edata represent byte addresses and should be pointers to char or unsigned char, not int.

2. Step 2: Understand pointer arithmetic impact

   Using int pointers causes incorrect copying because pointer arithmetic advances by sizeof(int), skipping bytes.

3. Final Answer:

   The pointers _sidata, _sdata, _edata should be declared as extern char, not int. -> Option B

4. Quick Check:

   Memory pointers for data init = char* not int* [OK]

Hint: Use char pointers for memory copy in startup [OK]

Common Mistakes:

• Using int pointers for byte-wise memory copy
• Changing loop condition incorrectly
• Thinking main() call is wrong here

5. You want to create a startup sequence that initializes .data and .bss sections and then jumps to main(). Which of the following code snippets correctly implements this in embedded C?

hard

A. void Reset_Handler(void) {
extern char _sidata, _sdata, _edata, _sbss, _ebss;
char *src = &_sidata;
char *dst = &_sdata;
while(dst < &_edata) *dst++ = *src++;
dst = &_sbss;
while(dst < &_ebss) *dst++ = 0;
main();
}
void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler;

B. void Reset_Handler(void) {
int *src = &_sidata;
int *dst = &_sdata;
while(dst <= &_edata) *dst++ = *src++;
main();
}
void ResetVector = Reset_Handler;

C. void Reset_Handler(void) {
main();
}
void (* ResetVector)(void) = Reset_Handler;

D. void Reset_Handler(void) {
extern char _sidata, _sdata, _edata;
char *src = &_sdata;
char *dst = &_sidata;
while(src < &_edata) *dst++ = *src++;
main();
}
void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler;

Solution

1. Step 1: Verify .data section initialization

   void Reset_Handler(void) { extern char _sidata, _sdata, _edata, _sbss, _ebss; char *src = &_sidata; char *dst = &_sdata; while(dst < &_edata) *dst++ = *src++; dst = &_sbss; while(dst < &_ebss) *dst++ = 0; main(); } void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; correctly copies initialized data from flash (_sidata) to RAM (_sdata to _edata) using char pointers and proper loop.

2. Step 2: Verify .bss section zero initialization

   void Reset_Handler(void) { extern char _sidata, _sdata, _edata, _sbss, _ebss; char *src = &_sidata; char *dst = &_sdata; while(dst < &_edata) *dst++ = *src++; dst = &_sbss; while(dst < &_ebss) *dst++ = 0; main(); } void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; zeroes the .bss section (_sbss to _ebss) by setting bytes to 0 before calling main().

3. Step 3: Check reset vector declaration

   void Reset_Handler(void) { extern char _sidata, _sdata, _edata, _sbss, _ebss; char *src = &_sidata; char *dst = &_sdata; while(dst < &_edata) *dst++ = *src++; dst = &_sbss; while(dst < &_ebss) *dst++ = 0; main(); } void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; declares ResetVector as a constant function pointer placed in the reset vector section, which is correct.

4. Final Answer:

   Option A correctly implements startup sequence with .data and .bss initialization and reset vector. -> Option A

5. Quick Check:

   Proper .data/.bss init + correct reset vector = void Reset_Handler(void) { extern char _sidata, _sdata, _edata, _sbss, _ebss; char *src = &_sidata; char *dst = &_sdata; while(dst < &_edata) *dst++ = *src++; dst = &_sbss; while(dst < &_ebss) *dst++ = 0; main(); } void (* const ResetVector)(void) __attribute__((section(".reset_vector"))) = Reset_Handler; [OK]

Hint: Initialize .data from flash, zero .bss, then call main() [OK]

Common Mistakes:

• Using int pointers instead of char pointers
• Swapping source and destination pointers
• Missing .bss zero initialization
• Incorrect reset vector declaration