Bird
Raised Fist0
Embedded Cprogramming~20 mins

Startup sequence and reset vector in Embedded C - Practice Problems & Coding Challenges

Choose your learning style10 modes available
Challenge - 5 Problems
🎖️
Embedded Startup Master
Get all challenges correct to earn this badge!
Test your skills under time pressure!
❓ Predict Output
intermediate
2:00remaining
What is the output of this startup sequence code snippet?

Consider this simplified embedded C startup code snippet. What will be printed when the microcontroller resets?

Embedded C
#include <stdio.h>

void Reset_Handler(void) {
    printf("System Reset\n");
    main();
}

int main(void) {
    printf("Main Application Started\n");
    return 0;
}
ASystem Reset\nMain Application Started
BMain Application Started\nSystem Reset
CSystem Reset
DMain Application Started
Attempts:
2 left
💡 Hint

Think about the order in which functions are called during reset.

🧠 Conceptual
intermediate
1:30remaining
What is the role of the reset vector in embedded systems?

Choose the best description of the reset vector's role in an embedded system.

AIt holds the main application code in memory.
BIt stores the address where the CPU starts executing after a reset.
CIt manages interrupts during normal operation.
DIt stores configuration settings for peripherals.
Attempts:
2 left
💡 Hint

Think about what happens immediately after powering on or resetting the device.

🔧 Debug
advanced
2:00remaining
Identify the error in this startup code snippet

What error will this embedded C startup code cause when the microcontroller resets?

Embedded C
void Reset_Handler(void) {
    main();
}

int main(void) {
    // Application code
    return 0;
}

void Reset_Handler(void);
ANo error, runs correctly
BStack overflow due to infinite recursion
CCompilation error due to duplicate declaration of Reset_Handler
DLinker error due to missing vector table
Attempts:
2 left
💡 Hint

Look carefully at the function declarations and definitions.

📝 Syntax
advanced
2:30remaining
Which option correctly defines the reset vector in a linker script?

In embedded systems, the reset vector is often defined in the linker script. Which of these linker script snippets correctly sets the reset vector to the start of Reset_Handler?

A
ENTRY(Reset_Handler)
SECTIONS {
  .data : { *(.data) }
}
B
ENTRY(main)
SECTIONS {
  .text : { *(.text) }
}
C
ENTRY(Reset_Handler)
SECTIONS {
  .reset_vector : { KEEP(*(.reset_vector)) }
}
D
ENTRY(Reset_Handler)
SECTIONS {
  .text : { *(.text) }
}
Attempts:
2 left
💡 Hint

The ENTRY command sets the program start address.

🚀 Application
expert
3:00remaining
How many instructions execute before main() in this startup sequence?

Given this startup code, how many instructions are executed before main() starts?

Embedded C
void Reset_Handler(void) {
    // 1
    init_data(); // 2
    init_bss();  // 3
    SystemInit(); // 4
    main();       // 5
}

void init_data(void) { /* copies initialized data */ }
void init_bss(void) { /* clears zero data */ }
void SystemInit(void) { /* sets up clocks */ }

int main(void) {
    return 0;
}
A4
B5
C3
D6
Attempts:
2 left
💡 Hint

Count the function calls before main() inside Reset_Handler.

Practice

(1/5)
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
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard