NVIC (Nested Vectored Interrupt Controller) in ARM Architecture - Mini Project: Build & Apply

Understanding NVIC (Nested Vectored Interrupt Controller)

📖 Scenario: You are learning about how microcontrollers handle multiple interrupt signals efficiently. The NVIC (Nested Vectored Interrupt Controller) is a key part of ARM Cortex-M processors that manages these interrupts.Imagine you have a simple embedded system that needs to respond to different events like button presses, timers, and sensor alerts. The NVIC helps prioritize and manage these events so the system can react quickly and correctly.

🎯 Goal: Build a basic understanding of NVIC by creating a simple data structure representing interrupt priorities, setting a priority threshold, and selecting which interrupts are enabled based on that threshold.

📋 What You'll Learn

Create a dictionary with interrupt names and their priority levels

Define a priority threshold variable

Use a comprehension to filter interrupts enabled above the threshold

Add a final configuration step to list enabled interrupts

💡 Why This Matters

🌍 Real World

Microcontrollers use NVIC to prioritize and manage multiple interrupt signals efficiently, ensuring critical tasks get immediate attention.

💼 Career

Embedded systems engineers and firmware developers must understand NVIC to write responsive and reliable device software.

1

Create the interrupt priority dictionary

Create a dictionary called interrupt_priorities with these exact entries: 'Timer': 3, 'UART': 1, 'GPIO': 4, 'ADC': 2, 'I2C': 5.

ARM Architecture

# Create the interrupt_priorities dictionary with given entries
# Your code here

Hint

Use curly braces to create a dictionary with keys as interrupt names and values as their priority numbers.

2

Set the priority threshold

Create a variable called priority_threshold and set it to 3.

ARM Architecture

interrupt_priorities = {
    'Timer': 3,
    'UART': 1,
    'GPIO': 4,
    'ADC': 2,
    'I2C': 5
}
# Set priority_threshold to 3
# Your code here

Hint

Just assign the number 3 to the variable named priority_threshold.

3

Filter enabled interrupts by priority

Create a dictionary called enabled_interrupts using a dictionary comprehension that includes only interrupts from interrupt_priorities with priority less than or equal to priority_threshold.

ARM Architecture

interrupt_priorities = {
    'Timer': 3,
    'UART': 1,
    'GPIO': 4,
    'ADC': 2,
    'I2C': 5
}
priority_threshold = 3
# Create enabled_interrupts dictionary with interrupts having priority <= priority_threshold
# Your code here

Hint

Use a dictionary comprehension with for name, prio in interrupt_priorities.items() and filter with if prio <= priority_threshold.

4

List the enabled interrupts

Create a list called enabled_interrupt_names containing only the keys from enabled_interrupts.

ARM Architecture

interrupt_priorities = {
    'Timer': 3,
    'UART': 1,
    'GPIO': 4,
    'ADC': 2,
    'I2C': 5
}
priority_threshold = 3
enabled_interrupts = {name: prio for name, prio in interrupt_priorities.items() if prio <= priority_threshold}
# Create enabled_interrupt_names list from keys of enabled_interrupts
# Your code here

Hint

Use list() on enabled_interrupts.keys() to get the list of interrupt names.

Practice

1. What is the main purpose of the NVIC in ARM microcontrollers?

easy

A. To increase the clock speed of the processor

B. To manage and prioritize multiple interrupts efficiently

C. To store program instructions

D. To handle memory allocation

Solution

1. Step 1: Understand NVIC's role

   NVIC stands for Nested Vectored Interrupt Controller, which manages interrupts.

2. Step 2: Identify its main function

   It enables, disables, and prioritizes interrupts so the processor can respond quickly to important events.

3. Final Answer:

   To manage and prioritize multiple interrupts efficiently -> Option B

4. Quick Check:

   NVIC controls interrupts = B [OK]

Hint: NVIC is about interrupt control, not speed or memory [OK]

Common Mistakes:

• Confusing NVIC with clock or memory functions
• Thinking NVIC stores program code
• Assuming NVIC increases processor speed

2. Which of the following is the correct way to enable an interrupt using NVIC in ARM Cortex-M?

easy

A. NVIC_SetPriority(IRQn, priority);

B. NVIC_DisableIRQ(IRQn);

C. NVIC_EnableIRQ(IRQn);

D. NVIC_ClearPendingIRQ(IRQn);

Solution

1. Step 1: Identify function purpose

   NVIC_EnableIRQ is used to enable a specific interrupt request (IRQ).

2. Step 2: Compare other options

   NVIC_DisableIRQ disables interrupts, NVIC_SetPriority sets priority, NVIC_ClearPendingIRQ clears pending interrupts.

3. Final Answer:

   NVIC_EnableIRQ(IRQn); -> Option C

4. Quick Check:

   Enable interrupt function = NVIC_EnableIRQ [OK]

Hint: Enable interrupts with NVIC_EnableIRQ function [OK]

Common Mistakes:

• Confusing enable with disable functions
• Mixing priority setting with enabling
• Using clear pending instead of enable

3. Consider the following code snippet for ARM Cortex-M NVIC:

NVIC_SetPriority(TIM2_IRQn, 2);
NVIC_EnableIRQ(TIM2_IRQn);
NVIC_SetPriority(USART1_IRQn, 1);
NVIC_EnableIRQ(USART1_IRQn);

Which interrupt has higher priority?

medium

A. USART1_IRQn has higher priority

B. TIM2_IRQn has higher priority

C. Both have equal priority

D. Priority cannot be determined

Solution

1. Step 1: Understand priority values

   Lower numeric priority value means higher priority in NVIC.

2. Step 2: Compare priorities set

   TIM2_IRQn is set to 2, USART1_IRQn is set to 1, so USART1_IRQn has higher priority.

3. Final Answer:

   USART1_IRQn has higher priority -> Option A

4. Quick Check:

   Lower number = higher priority = USART1_IRQn [OK]

Hint: Lower priority number means higher priority [OK]

Common Mistakes:

• Assuming higher number means higher priority
• Ignoring priority values and focusing on enable order
• Confusing IRQ names

4. A developer wrote this code to disable an interrupt but it does not work as expected:

NVIC_EnableIRQ(EXTI0_IRQn);
NVIC_DisableIRQ(EXTI1_IRQn);

What is the likely mistake?

medium

A. The priority must be set before disabling

B. NVIC_DisableIRQ cannot disable interrupts

C. Interrupts must be disabled before enabling

D. They enabled EXTI0_IRQn but disabled EXTI1_IRQn instead

Solution

1. Step 1: Analyze the code

   The code enables EXTI0_IRQn but disables EXTI1_IRQn, which are different interrupts.

2. Step 2: Identify the mistake

   If the goal was to disable EXTI0_IRQn, disabling EXTI1_IRQn is incorrect.

3. Final Answer:

   They enabled EXTI0_IRQn but disabled EXTI1_IRQn instead -> Option D

4. Quick Check:

   Mismatch in IRQ numbers = mistake [OK]

Hint: Check IRQ names carefully when enabling/disabling [OK]

Common Mistakes:

• Disabling wrong interrupt number
• Believing disable function doesn't work
• Thinking priority affects disabling

5. You want to ensure that a critical sensor interrupt always preempts a less important communication interrupt. How should you configure NVIC priorities for SENSOR_IRQn and COMM_IRQn?

hard

A. Set SENSOR_IRQn priority lower than COMM_IRQn (e.g., SENSOR=0, COMM=1)

B. Set SENSOR_IRQn priority higher than COMM_IRQn (e.g., SENSOR=2, COMM=1)

C. Disable COMM_IRQn and enable SENSOR_IRQn only

D. Set both priorities equal and enable both

Solution

1. Step 1: Recall NVIC priority rules

   Lower numeric priority means higher priority and can preempt others.

2. Step 2: Apply to SENSOR and COMM interrupts

   To let SENSOR_IRQn preempt COMM_IRQn, SENSOR_IRQn must have a lower priority number.

3. Final Answer:

   Set SENSOR_IRQn priority lower than COMM_IRQn (e.g., SENSOR=0, COMM=1) -> Option A

4. Quick Check:

   Lower number = higher priority = SENSOR_IRQn preempts [OK]

Hint: Lower priority number means higher interrupt priority [OK]

Common Mistakes:

• Assigning higher number for higher priority
• Disabling interrupts instead of prioritizing
• Setting equal priorities expecting preemption