Interrupt vector table in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the interrupt vector table array.

Embedded C

void (*interrupt_vector_table[])() = { [1] };

Drag options to blanks, or click blank then click option'

AReset_Handler, NMI_Handler, HardFault_Handler

Bint, void, char

Cmain, setup, loop

D0, 1, 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using data types instead of function names.

Using numbers instead of handler names.

The interrupt vector table is an array of function pointers to handlers like Reset_Handler.

2fill in blank

medium

Complete the code to define the Reset_Handler function.

Embedded C

void [1]() {
    // Initialization code
}

Drag options to blanks, or click blank then click option'

AReset_Handler

BNMI_Handler

CHardFault_Handler

DDefault_Handler

Attempts:

3 left

💡 Hint

Common Mistakes

Naming the function incorrectly.

Using a handler meant for other interrupts.

The Reset_Handler is the function called on system reset.

3fill in blank

hard

Fix the error in the vector table declaration by completing the blank.

Embedded C

void (*vector_table[])() = { Reset_Handler, [1], HardFault_Handler };

Drag options to blanks, or click blank then click option'

Amain

Bloop

Csetup

DNMI_Handler

Attempts:

3 left

💡 Hint

Common Mistakes

Using main or setup functions instead of interrupt handlers.

Confusing the order of handlers.

The second entry in the vector table is the NMI_Handler function pointer.

4fill in blank

hard

Fill both blanks to complete the vector table with correct handlers.

Embedded C

void (*vector_table[])() = { [1], [2], HardFault_Handler };

Drag options to blanks, or click blank then click option'

AReset_Handler

BDefault_Handler

CNMI_Handler

Dmain

Attempts:

3 left

💡 Hint

Common Mistakes

Using main or Default_Handler in wrong positions.

Swapping the order of handlers.

The vector table starts with Reset_Handler, then NMI_Handler, followed by HardFault_Handler.

5fill in blank

hard

Fill all three blanks to create a vector table with uppercase handler names and a default handler.

Embedded C

void (*vector_table[])() = { [1], [2], [3] };

Drag options to blanks, or click blank then click option'

ARESET_HANDLER

BDEFAULT_HANDLER

CNMI_HANDLER

DMAIN_HANDLER

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase handler names here.

Mixing up the order of handlers.

This vector table uses uppercase handler names. The first is MAIN_HANDLER, then DEFAULT_HANDLER, and finally NMI_HANDLER.

Practice

1.

What is the main purpose of an interrupt vector table in embedded C programming?

easy

A. To store global variables for the program

B. To link interrupt events to their handler functions

C. To manage memory allocation dynamically

D. To perform arithmetic operations automatically

Solution

1. Step 1: Understand the role of interrupt vector table

   The interrupt vector table is a special array that holds addresses of interrupt handler functions.

2. Step 2: Identify its purpose in program flow

   When an interrupt occurs, the processor uses this table to jump to the correct handler automatically.

3. Final Answer:

   To link interrupt events to their handler functions -> Option B

4. Quick Check:

   Interrupt vector table = links interrupts to handlers [OK]

Hint: Interrupt vector table connects interrupts to handlers [OK]

Common Mistakes:

• Thinking it stores variables
• Confusing with memory management
• Assuming it performs calculations

2.

Which of the following is the correct way to declare an interrupt vector table as an array of function pointers in embedded C?

void (*interrupt_vector_table[])(void) = {

easy

A. void interrupt_vector_table(void) = {handler1, handler2};

B. int interrupt_vector_table[] = {handler1, handler2};

C. void (*interrupt_vector_table[])(void) = {handler1, handler2};

D. void *interrupt_vector_table = {handler1, handler2};

Solution

1. Step 1: Recognize function pointer array syntax

   Function pointers to void functions with no parameters are declared as void (*name[])(void).

2. Step 2: Match declaration with initialization

   void (*interrupt_vector_table[])(void) = {handler1, handler2}; correctly declares an array of such pointers and initializes it with handler functions.

3. Final Answer:

   void (*interrupt_vector_table[])(void) = {handler1, handler2}; -> Option C

4. Quick Check:

   Function pointer array syntax = void (*interrupt_vector_table[])(void) = {handler1, handler2}; [OK]

Hint: Function pointer arrays use void (*name[])(void) syntax [OK]

Common Mistakes:

• Using int type instead of function pointers
• Declaring as a single function, not array
• Using void* without function pointer cast

3.

Given the following code snippet, what will be the output when the interrupt at index 1 occurs?

void handler0(void) { printf("Handler 0 called\n"); }
void handler1(void) { printf("Handler 1 called\n"); }
void (*interrupt_vector_table[])(void) = {handler0, handler1};

// Simulate interrupt 1
interrupt_vector_table[1]();

medium

A. Handler 1 called

B. Handler 0 called

C. No output, runtime error

D. Compilation error

Solution

1. Step 1: Identify the function called by interrupt_vector_table[1]

   Index 1 points to handler1, which prints "Handler 1 called".

2. Step 2: Understand the output of the function call

   Calling interrupt_vector_table[1]() executes handler1, printing the message.

3. Final Answer:

   Handler 1 called -> Option A

4. Quick Check:

   interrupt_vector_table[1]() calls handler1 [OK]

Hint: Index 1 calls handler1, prints its message [OK]

Common Mistakes:

• Confusing index 0 and 1
• Expecting no output or error
• Misreading function pointer call syntax

4.

Consider this interrupt vector table declaration:

void handlerA(void) { /* ... */ }
void handlerB(void) { /* ... */ }

void (*interrupt_vector_table[])(void) = {handlerA, handlerB};

// Somewhere else in code
interrupt_vector_table[2]();

What is the problem here?

medium

A. Index 2 is out of bounds, causing undefined behavior

B. handlerB is not a valid function pointer

C. interrupt_vector_table must be declared as int array

D. No problem, code runs fine

Solution

1. Step 1: Check the size of interrupt_vector_table

   The array has 2 elements at indices 0 and 1 only.

2. Step 2: Analyze the call to interrupt_vector_table[2]()

   Index 2 is outside the array bounds, leading to undefined behavior or crash.

3. Final Answer:

   Index 2 is out of bounds, causing undefined behavior -> Option A

4. Quick Check:

   Accessing beyond array size = out of bounds error [OK]

Hint: Array indices start at 0; index 2 is invalid here [OK]

Common Mistakes:

• Assuming array auto-expands
• Thinking handlerB is invalid
• Ignoring out-of-bounds errors

5.

You want to add a new interrupt handler handler2 to an existing vector table with 2 handlers. Which is the correct way to update the vector table to include handler2 at index 2?

void handler0(void) { /* ... */ }
void handler1(void) { /* ... */ }
void handler2(void) { /* ... */ }

// Existing vector table
void (*interrupt_vector_table[])(void) = {handler0, handler1};

// How to add handler2 correctly?

hard

A. No need to add; interrupts beyond index 1 are ignored

B. Assign handler2 directly: interrupt_vector_table[2] = handler2;

C. Use a pointer cast to add handler2 at index 2

D. Redefine the vector table with all three handlers: {handler0, handler1, handler2}

Solution

1. Step 1: Understand array size fixed at declaration

   Arrays in C have fixed size; you cannot add elements dynamically.

2. Step 2: Update vector table by redefining with all handlers

   To include handler2, redefine the array with three elements: {handler0, handler1, handler2}.

3. Final Answer:

   Redefine the vector table with all three handlers: {handler0, handler1, handler2} -> Option D

4. Quick Check:

   Arrays fixed size; redefine to add elements [OK]

Hint: Arrays fixed size; redefine to add handlers [OK]

Common Mistakes:

• Trying to assign beyond array size
• Using pointer casts unsafely
• Assuming interrupts beyond defined handlers work