Embedded Prep

Introduction

Interrupts in Embedded Systems : An interrupt is a way for hardware or software to get the processor’s attention when something important happens. It’s like someone tapping you on the shoulder while you are busy working, saying, “Hey, look at this right now!”

When an interrupt happens, the processor doesn’t stop immediately. It first finishes the instruction it is currently working on. After that, it quickly moves to a special piece of code called the Interrupt Service Routine (ISR) or Interrupt Handler.

The ISR is like a small program that tells the processor what to do when a specific interrupt occurs. For example, if you press a button connected to your device, the processor will run the ISR to check which button was pressed and what action should be taken.

In the world of embedded systems, interrupts are powerful tools that help a device respond quickly to important events. Instead of constantly checking (polling) whether something has happened, interrupts alert the processor immediately, saving time and power.

What is an Interrupt?

An interrupt is a signal that pauses the normal flow of a program and forces the CPU to run a special piece of code called an Interrupt Service Routine (ISR).

After the ISR finishes, the CPU resumes its previous work as if nothing happened.

In simple words:
An interrupt is like someone tapping your shoulder to get your attention while you are busy working.

Why are Interrupts Important?

Interrupts offer several benefits in embedded systems:

• Real-time Response: Immediate reaction to critical events like button presses, sensor readings, or incoming data.
• Efficiency: No need to waste CPU time constantly checking for events.
• Power Saving: Processor can stay in low-power modes and wake up only when needed.
• Multitasking: Perform multiple tasks effectively without missing important signals.

How Interrupts Work: Step-by-Step

Here’s a simple flow of how interrupts work:

1. Normal Execution: CPU is busy running the main program.
2. Interrupt Event: An external or internal event occurs (like a button press).
3. Interrupt Request: The event triggers an interrupt request to the CPU.
4. Interrupt Handling:
   • CPU pauses the main program.
   • CPU saves the current program state (so it can return later).
   • CPU jumps to the Interrupt Service Routine (ISR).
5. ISR Execution: Special code in ISR runs to handle the event.
6. Return to Main Program: CPU restores the saved state and continues where it left off.

Real-World Example of Interrupt

Imagine a smart doorbell:

• Normally, the microcontroller is managing Wi-Fi or saving battery in sleep mode.
• When a visitor presses the doorbell button, it sends an interrupt.
• The microcontroller wakes up immediately and rings the chime or sends a notification.

Without interrupts, the microcontroller would have to keep checking the button all the time, wasting energy.

Key Components of an Interrupt System

• Interrupt Request (IRQ): The signal that notifies the CPU about an event.
• Interrupt Vector Table (IVT): A table that holds the addresses of all ISRs.
• Interrupt Service Routine (ISR): A short program that handles the interrupt.
• Interrupt Controller: Manages multiple interrupts and prioritizes them if needed.

Simple Code Example (Pseudocode)

#include <some_microcontroller_library.h>

// Define Interrupt Service Routine
void button_press_ISR(void) {
    // Code to handle button press
    turnOnLED();
}

int main() {
    setupButtonInterrupt(button_press_ISR); // Link ISR to button press
    while (1) {
        // Main program continues
        doOtherTasks();
    }
}

Explanation:

• setupButtonInterrupt() configures the button to generate an interrupt.
• When the button is pressed, button_press_ISR() runs.
• The main program (doOtherTasks()) keeps working without constantly checking the button.

Best Practices When Using Interrupts

• Keep ISR Short: The interrupt service routine should be as fast as possible.
• Avoid Heavy Operations: No complex calculations or long delays inside the ISR.
• Protect Shared Data: Use techniques like disabling interrupts or using volatile variables when accessing shared data.
• Set Priorities Wisely: If multiple interrupts can occur, assign proper priorities.

Types of Interrupts

Interrupts are mainly divided into two big categories:

• Hardware Interrupts
• Software Interrupts

And under these, there are some more types based on behavior.

Let’s dive into each of them :

1. Hardware Interrupts

Definition:
Hardware interrupts are triggered by external hardware devices like a keyboard, mouse, sensor, timer, or network card.

Example:

• Pressing a key on the keyboard
• Clicking a mouse
• Receiving data from a sensor

When these hardware components want CPU attention, they send a signal to the CPU — “Hey, I need you now!”

Types inside hardware interrupts:

a) Maskable Interrupt

• Meaning:
  These are interrupts that can be ignored (masked) by the CPU if needed.
• Example:
  • You have a low-priority temperature sensor reading.
    CPU may postpone or disable it temporarily if a higher-priority task is running.
• Real use:
  Useful for less urgent tasks.

b) Non-Maskable Interrupt (NMI)

• Meaning:
  These interrupts cannot be ignored by the CPU. They are critical.
• Example:
  • Hardware failure like memory errors
  • Power failure warning
• Real use:
  To handle very serious issues that must be fixed immediately to prevent damage.

2. Software Interrupts

Definition:
Software interrupts are triggered by programs or instructions inside the CPU — not by external hardware.

Example:

• A program might intentionally request a service from the operating system, like asking to print a document 🖨️.

How it works:
The software uses a special instruction (often called INT) to generate an interrupt.

Real-world Example:

• A C program calling an operating system function like printf() indirectly uses a software interrupt to talk to the printer or screen.

Special Classifications

Apart from the basic two types, interrupts are often further classified based on how they are handled:

3. Synchronous Interrupts

• Meaning:
  Happen at predictable times, usually caused by the instruction flow of the program.
• Example:
  • Division by zero error (mathematical mistake)
  • Invalid memory access (segmentation fault)
• Real use:
  Catching software bugs or errors.

4. Asynchronous Interrupts

• Meaning:
  Happen at unpredictable times, triggered by external hardware.
• Example:
  • User pressing a keyboard key at any moment.
  • Receiving network data.
• Real use:
  Handling random real-world events.

5. Vectored Interrupts

• Meaning:
  CPU knows exactly where the Interrupt Service Routine (ISR) is located — because the address is predefined.
• Example:
  • In ARM Cortex-M processors, vector tables store all ISR addresses.
• Real use:
  Faster because CPU jumps directly to the correct code.

6. Non-Vectored Interrupts

• Meaning:
  CPU does not know directly where to go — it must find the ISR address first.
• Example:
  • Older systems using interrupt controllers.
• Real use:
  Slower but more flexible for dynamic interrupt management.

Quick Summary Table

Type of Interrupt	Triggered By	Can Be Masked?	Predictability
Hardware Interrupt	External device	Maskable/Non-Maskable	Asynchronous
Software Interrupt	Software program	Generally Maskable	Synchronous
Synchronous Interrupt	Program execution	Depends	Predictable
Asynchronous Interrupt	External event	Depends	Unpredictable
Vectored Interrupt	Predefined address	–	Fast access
Non-Vectored Interrupt	Dynamic address	–	Slower

Final Picture

Think of interrupts like urgent notifications in your phone:

• 🛎️ Hardware interrupts = Phone call from someone (external event)
• 🛎️ Software interrupts = Reminder set by yourself (internal event)
• 🔕 Maskable = You can put it on silent
• 🔔 Non-Maskable = Emergency call — can’t ignore
• 📍 Vectored = Direct link to caller
• 🔍 Non-Vectored = You have to search who’s calling first

What is an Interrupt Service Routine (ISR)?

Imagine you are watching your favorite TV show and suddenly your phone rings.
You pause the show, answer the call, finish talking, and then return to watching the show.

This is exactly what an interrupt is in a microcontroller!

• The TV show = Main program running normally
• Phone call = Interrupt (something urgent needing immediate attention)
• Answering the call = Executing the Interrupt Service Routine (ISR)
• Returning to TV = Going back to the main program after handling the interrupt

In technical words:
An interrupt is a signal that temporarily stops the main program and forces the microcontroller to do something else immediately.

When an interrupt happens, the microcontroller needs to know:

• What to do?
• Which code to run?

The special piece of code that runs when an interrupt occurs is called the Interrupt Service Routine (ISR).

➡️ In short:
ISR = A function that is automatically called when an interrupt happens.

How Does the Microcontroller Know Which ISR to Run?

Every interrupt has a fixed place in memory where the microcontroller looks to find the address of the ISR.
This fixed list of addresses is called the Interrupt Vector Table.

• Think of it like an emergency contact list.
• Each type of interrupt (like Timer, UART, External Pin) has its own slot in this table.
• The table points to the correct ISR for that interrupt.

So, Interrupt Vector Table = List of addresses that point to ISRs.

Step-by-Step Flow of What Happens During an Interrupt:

1. Interrupt Occurs
   (Example: A timer overflow, a button press, or a sensor signal)
2. Microcontroller Pauses Main Program
   (It saves where it was in the main code.)
3. Microcontroller Looks at Interrupt Vector Table
   (Finds the address of the ISR.)
4. Microcontroller Jumps to the ISR
   (Starts executing the interrupt service routine.)
5. ISR Executes
   (Handles the emergency or event.)
6. Return to Main Program
   (After ISR finishes, the microcontroller goes back exactly where it left off.)

Important Points About ISRs

• Fast and Short: ISRs should be quick. Don’t put slow operations inside ISR.
• No Return Value: ISRs usually do not return any value.
• Special Syntax: In some programming languages (like C), you have to tell the compiler that a function is an ISR (using special keywords or attributes).
• Global Variables: If you change variables inside an ISR, be careful — you might need to use volatile keyword.

Real Life Example

Suppose you have a doorbell system:

• The microcontroller is busy displaying the time on a screen.
• When someone presses the doorbell button, it triggers an interrupt.
• The microcontroller pauses updating the time, rings the bell (by running the ISR), and then returns to updating the time.

Simple, right?

In a Simple Diagram:

Main Program --> [Interrupt Occurs] --> ISR Runs --> Main Program Continues

Simple External Interrupt ISR in C

Imagine:

• You have a button connected to a GPIO pin (say Pin 2).
• When the button is pressed, the microcontroller should turn ON an LED.

C Code Example:

#include <avr/io.h>      // Header for I/O functions (AVR microcontrollers)
#include <avr/interrupt.h> // Header for Interrupt functions

void setup()
{
    // Set Pin 2 (PD2) as input (button)
    DDRD &= ~(1 << PD2);

    // Set Pin 5 (PB5) as output (LED)
    DDRB |= (1 << PB5);

    // Enable external interrupt INT0 (which is usually on PD2)
    EIMSK |= (1 << INT0);

    // Set interrupt on rising edge (button press)
    EICRA |= (1 << ISC01) | (1 << ISC00);

    // Enable global interrupts
    sei();
}

ISR(INT0_vect)
{
    // This function will run when the button is pressed
    PORTB ^= (1 << PB5); // Toggle LED (ON if OFF, OFF if ON)
}

int main(void)
{
    setup(); // Call the setup function

    while (1)
    {
        // Main program loop does nothing
        // Microcontroller waits here until interrupt happens
    }
}

Now let’s explain this code line-by-line:

1. Header Files

#include <avr/io.h> 
#include <avr/interrupt.h>

• avr/io.h: To control input/output pins.
• avr/interrupt.h: To use interrupt-related functions and macros.

2. Setup Function

void setup()
{
    // Set Pin 2 as Input
    DDRD &= ~(1 << PD2);

• DDRD is the Data Direction Register for Port D.
• PD2 means Pin 2 of Port D.
• &= ~(1 << PD2) sets that pin as input.

    // Set Pin 5 as Output
    DDRB |= (1 << PB5);

• DDRB is the Data Direction Register for Port B.
• PB5 usually controls the on-board LED.
• |= (1 << PB5) sets it as output.

3. Enable External Interrupt

    EIMSK |= (1 << INT0);

• EIMSK is the External Interrupt Mask Register.
• INT0 is the external interrupt for Pin 2.
• This enables external interrupt 0.

4. Set Interrupt Trigger (Rising Edge)

    EICRA |= (1 << ISC01) | (1 << ISC00);

• EICRA is the External Interrupt Control Register A.
• ISC01 and ISC00 bits control how the interrupt is triggered.
• Setting both = trigger interrupt on rising edge (button press).

5. Enable Global Interrupts

    sei();

• sei() function enables global interrupts.
• Without this, no interrupt would happen!

6. Interrupt Service Routine (ISR)

ISR(INT0_vect)
{
    PORTB ^= (1 << PB5);
}

• ISR(INT0_vect) defines the Interrupt Service Routine for External Interrupt 0.
• Inside the ISR, we toggle the LED:
  • If LED was OFF, it turns ON.
  • If LED was ON, it turns OFF.

7. Main Loop

int main(void)
{
    setup();
    while (1)
    {
        // Main code does nothing
    }
}

• We call setup() once to configure pins and interrupts.
• Then, we sit in a forever loop.
• The real work (turning the LED ON/OFF) happens inside the ISR when the button is pressed.

Important Note:

• Never put delay or slow code inside an ISR.
  (Because it blocks the microcontroller from responding to new interrupts!)
• Keep ISRs short and fast!

Final Big Picture Diagram:

Button Press (on PD2) --> Trigger INT0 Interrupt --> Run ISR(INT0_vect) --> Toggle LED --> Return to Main Loop

Quick Summary

Term	Meaning
Interrupt	A sudden event that needs immediate attention
ISR	Special function that runs when an interrupt occurs
Interrupt Vector Table	List that stores addresses of all ISRs

Why Do We Need to Enable or Disable Interrupts?

• Enable interrupts when you want your system to listen and respond to external or internal events.
• Disable interrupts temporarily if:
  • You are performing a critical task that should not be interrupted (example: updating shared memory).
  • You want to avoid conflicts between normal code and interrupt code.

How to Enable and Disable an Interrupt?

In general, enabling and disabling interrupts can happen in two ways:

• Globally — affecting all interrupts.
• Individually — affecting a specific interrupt.

Let’s see both!

Enabling and Disabling Global Interrupts

When you disable global interrupts, all interrupts are temporarily ignored.
When you enable global interrupts, the CPU starts accepting interrupts again.

Common in C programming (Microcontrollers like AVR, ARM):

// Disable all interrupts globally
__disable_irq();  // For ARM Cortex (CMSIS standard)
cli();            // For AVR (Atmel chips)

// Enable all interrupts globally
__enable_irq();   // For ARM Cortex
sei();            // For AVR

Notes:

• cli() = Clear Interrupt Flag (disable all interrupts)
• sei() = Set Interrupt Flag (enable all interrupts)

Enabling and Disabling Specific Interrupts

Sometimes you don’t want to disable all interrupts — only a specific one (like just disabling the timer interrupt).

Example: Disabling specific interrupt in C

// Assuming you're using an AVR microcontroller
TIMSK0 &= ~(1 << TOIE0); // Disable Timer0 Overflow Interrupt

// To enable it back
TIMSK0 |= (1 << TOIE0);  // Enable Timer0 Overflow Interrupt

• TIMSK0 is the Timer Interrupt Mask Register.
• TOIE0 is the Timer Overflow Interrupt Enable bit.

Important Best Practices for Beginners

• Only disable interrupts for a very short time (few microseconds) to avoid missing important events.
• Always re-enable interrupts after your critical code section.
• Never disable interrupts during long tasks like delays, communication, etc.

Example of correct usage:

__disable_irq();   // Disable interrupts

// Critical section starts
shared_variable = 10;  // Safely update
// Critical section ends

__enable_irq();    // Enable interrupts

What Happens if You Forget to Enable Interrupts?

If you disable interrupts and forget to enable them again:

• Your system may stop responding to events.
• Timers, communication (UART, SPI, I2C), and other peripherals may fail.
• It can freeze parts of your program.

Always double-check: if you disable interrupts, enable them back!

Summary for Enable / Disable Interrupts

Task	C Code (ARM Cortex)	C Code (AVR)
Disable all interrupts	__disable_irq();	cli();
Enable all interrupts	__enable_irq();	sei();
Disable specific interrupt	Clear relevant bit in interrupt mask register	Same
Enable specific interrupt	Set relevant bit in interrupt mask register	Same

Interrupt Priority in 8051 Microcontroller

Interrupt Priority means deciding which interrupt should be serviced first if two or more interrupts happen at the same time.

The 8051 microcontroller allows us to assign priorities to each interrupt:

• Higher priority interrupt gets serviced first.
• Lower priority interrupt waits until higher priority one finishes.

Thus, even if multiple events occur together, the CPU always knows which one is more important to handle first.

How Many Interrupts Are There in 8051?

The standard 8051 microcontroller has five interrupt sources:

Interrupt Name	Type	Description
INT0	External	External Interrupt 0 (P3.2 pin)
Timer 0	Internal	Timer 0 Overflow
INT1	External	External Interrupt 1 (P3.3 pin)
Timer 1	Internal	Timer 1 Overflow
Serial	Internal	Serial Communication (Receive/Transmit Complete)

How is Interrupt Priority Set in 8051?

In 8051, interrupt priorities are set using a special register called the Interrupt Priority Register (IP).

Each bit of the IP register corresponds to one interrupt:

• Bit = 1 → High Priority
• Bit = 0 → Low Priority

Structure of IP Register:

Bit	Name	Interrupt
7	–	(Reserved)
6	–	(Reserved)
5	PS	Serial Port
4	PT1	Timer 1
3	PX1	External Interrupt 1
2	PT0	Timer 0
1	PX0	External Interrupt 0
0	–	(Reserved)

Example:

IP = 0x10; // Set Timer 1 (PT1) as high priority

Default Interrupt Priority Order (Without Manual Setting)

If you don’t set anything manually, the default priority order is:

1. External Interrupt 0 (INT0)
2. Timer 0 Overflow
3. External Interrupt 1 (INT1)
4. Timer 1 Overflow
5. Serial Communication

👉 Lower number = Higher default priority

Example: Practical Understanding

Suppose:

• External Interrupt 0 (INT0) is set to high priority.
• Timer 1 Overflow is set to low priority.

If both interrupts occur together:

• INT0 will be serviced immediately.
• Timer 1 must wait until INT0’s ISR is completed.

Can Higher Priority Interrupt Interrupt an Ongoing ISR?

✅ Yes!
If the CPU is executing a low-priority ISR and a high-priority interrupt occurs, the CPU pauses the low-priority ISR, services the high-priority ISR, and then returns back to complete the low-priority ISR.

But if two interrupts have the same priority, no interrupt nesting happens. The CPU finishes the current ISR first and then services the next interrupt.

Comparison between Interrupts and Polling:

Aspect	Interrupts	Polling
Definition	CPU is alerted by hardware when attention is needed.	CPU repeatedly checks the device status at regular intervals.
CPU Usage	Efficient; CPU works on other tasks until interrupted.	Inefficient; CPU wastes cycles checking status.
Response Time	Immediate (when interrupt occurs).	Depends on polling frequency; can be delayed.
System Efficiency	High, as CPU can perform other tasks.	Low, especially if polling rate is high.
Complexity	More complex to implement (needs ISR – Interrupt Service Routine).	Simpler to implement.
Power Consumption	Lower (saves power by sleeping/waiting).	Higher (continuous checking uses more power).
Suitability	Best for time-critical applications.	Suitable for simple, non-time-critical tasks.
Example Use Case	Keyboard input handling, real-time systems.	Reading sensor data at fixed intervals.

Interrupt Triggering Methods

Interrupts can be triggered in multiple ways, each with its own behavior and use case:

1. Level Triggered Interrupts

Level-triggered interrupts occur when a signal stays high (or low) for a certain period. The interrupt is triggered as long as the level condition is met.

• Example: A button connected to the GPIO pin. If the button is pressed, the voltage level changes, and the interrupt is triggered as long as the button remains pressed.

2. Edge Triggered Interrupts

Edge-triggered interrupts occur when the signal changes state, such as from low to high (rising edge) or high to low (falling edge). These are often used when you only want to respond once to a signal transition.

• Example: An external clock or pulse generator. You might want to trigger an interrupt every time the signal transitions from low to high.

3. Both Edge Triggered Interrupts

Some systems support interrupts on both rising and falling edges. This means the interrupt will be triggered whenever the signal transitions from low to high or high to low.

• Example: A system that needs to respond to every clock pulse, whether it’s rising or falling.

Setting Up Interrupts in Embedded Systems

Setting up interrupts typically involves the following steps:

1. Configure the Interrupt: Set the interrupt priority, triggering method (rising edge, falling edge, level triggered), and the pin to which the interrupt is connected.
2. Enable the Interrupt: Enable the interrupt in the processor’s interrupt controller to start listening for the event.
3. Write an Interrupt Service Routine (ISR): The ISR is the function executed when the interrupt occurs. The ISR should be as fast as possible to avoid interrupting other important processes.
4. Enable Global Interrupts: After setting up the individual interrupt, enable global interrupts in the system to allow interrupts to occur.

Example Code for Setting up an Interrupt in C (Embedded Systems)

#include <avr/io.h>
#include <avr/interrupt.h>

void init_interrupt()
{
    // Set INT0 (external interrupt 0) to trigger on the rising edge
    EICRA |= (1 << ISC01) | (1 << ISC00);   // ISC01 and ISC00 bits for rising edge
    EIMSK |= (1 << INT0);                    // Enable INT0 interrupt
    sei();                                   // Enable global interrupts
}

ISR(INT0_vect)
{
    // Interrupt Service Routine (ISR) for INT0
    // This code will execute when the interrupt occurs
    PORTB ^= (1 << PB0);  // Toggle LED on PB0
}

int main()
{
    DDRB |= (1 << PB0);   // Set PB0 as output for LED
    init_interrupt();      // Initialize interrupt
    while (1)
    {
        // Main program loop
        // The program will continue running while waiting for interrupts
    }
}

Common Interrupts in Embedded Systems

• Timer Interrupts: Used to trigger an interrupt after a specific time delay.
• External Interrupts: Triggered by external events such as a button press or signal change on a GPIO pin.
• USART Interrupts: Triggered when there is data received or transmitted via UART/USART.
• ADC Interrupts: Triggered when an Analog-to-Digital Conversion (ADC) is completed.

Best Practices for Handling Interrupts

1. Keep ISRs Short and Efficient: Interrupts should be serviced as quickly as possible to avoid blocking other interrupts or tasks.
2. Minimize Global Variables in ISR: Avoid using global variables directly in the ISR. If needed, mark them volatile to prevent optimization issues.
3. Use Interrupt Priorities: In complex systems, interrupt priorities ensure that more important interrupts are processed first.
4. Disable Interrupts When Necessary: In critical sections of your code, disable interrupts temporarily to avoid unexpected behavior.

Differentiating the level-triggered and edge-triggered interrupt methods:

Aspect	Level-Triggered Interrupts	Edge-Triggered Interrupts
Triggering Condition	Triggered when the signal remains at a specific level (high or low) for a period of time.	Triggered when there is a transition in the signal, either from low to high (rising edge) or from high to low (falling edge).
Behavior	Interrupt remains active as long as the condition (level) is met.	Interrupt is triggered only once per signal transition.
Examples	A button press (signal stays high or low while the button is pressed).	A pulse generator (interrupt triggered on each pulse).
Type of Signal	Continuous (signal level stays constant).	Discrete (signal changes state).
Use Case	Typically used for continuous monitoring of a signal state (e.g., power-on signals, continuous sensor readings).	Used for detecting specific events like edges of clock signals, pulse counting, or event-driven systems.
Complexity	Simpler to implement but may result in longer interrupt durations.	More complex but allows for precise handling of events at the signal transition.
Example Application	Button press detection, monitoring constant voltage levels.	Clock edge detection, signal pulse measurement.

Frequently Asked Questions (FAQ) on Embedded System Interrupts

Q1: What is an interrupt in embedded systems?

• An interrupt is a mechanism by which a processor’s normal execution flow is interrupted to handle an event or a condition that needs immediate attention. It allows the processor to deal with high-priority tasks in real-time.

Q2: What are the types of interrupts?

• Hardware Interrupts: Triggered by external devices like sensors or timers, which notify the processor of the need for attention.
• Software Interrupts: Generated by software instructions to request specific services, such as system calls.

Q3: What are interrupt vectors?

• Interrupt vectors are memory addresses associated with each interrupt. When an interrupt occurs, the processor looks up the corresponding interrupt vector to find the appropriate service routine.

Q4: What is an interrupt vector table (IVT)?

• The Interrupt Vector Table (IVT) is a table of addresses that defines where the processor should jump when an interrupt occurs. It contains the addresses of interrupt service routines (ISR) for each interrupt source.

Q5: What is an Interrupt Service Routine (ISR)?

• An ISR is a function or routine that is executed when a specific interrupt occurs. It handles the interrupt, performs necessary tasks, and then returns control back to the main program.

Q6: What is interrupt priority?

• Interrupt priority determines the order in which multiple interrupts are handled. High-priority interrupts are handled before low-priority ones, ensuring time-sensitive tasks are addressed first.

Q7: What are nested interrupts?

• Nested interrupts allow a higher-priority interrupt to interrupt the ISR of a lower-priority interrupt. This ensures that critical tasks can preempt less important tasks.

Q8: How does interrupt masking work?

• Interrupt masking is used to disable or enable specific interrupts. The processor may mask certain interrupts to prevent them from interrupting the current process, which can be useful for critical sections in the code.

Q9: What is the difference between edge-triggered and level-triggered interrupts?

• Edge-triggered interrupts: Triggered by a change in the signal (either rising or falling edge).
• Level-triggered interrupts: Triggered when the interrupt signal remains at a certain level (high or low) for a period of time.

Q10: How are interrupts managed in microcontrollers?

• Microcontrollers usually have a dedicated interrupt controller (such as a Nested Vectored Interrupt Controller – NVIC) to handle and prioritize interrupts. This controller determines the response and execution order for interrupts.

Q11: What are the common uses of interrupts in embedded systems?

• Interrupts are used in time-sensitive applications like handling external sensors, timers, communication protocols (e.g., UART, SPI, I2C), and real-time processing.

Q12: What is interrupt latency?

• Interrupt latency is the time taken by the processor to start executing an ISR after an interrupt has occurred. Lower latency is critical for real-time applications.

Q13: What is the importance of context switching in interrupt handling?

• Context switching refers to saving the state of the current process and loading the state of the ISR when an interrupt occurs. It ensures that the main program can resume after the ISR is executed.

Q14: How do you avoid interrupt handling issues like jitter and race conditions?

• Proper synchronization techniques such as disabling interrupts, using flags, or employing atomic operations can help avoid issues like jitter (variability in interrupt response time) and race conditions (conflict between interrupt and main program).

Q15: What is the difference between polling and interrupt-based systems?

• Polling: The processor continuously checks if an event has occurred.
• Interrupt-based: The processor is alerted to an event only when it happens, reducing unnecessary CPU usage.

Q16: What are interrupt-driven I/O systems?

• In interrupt-driven I/O systems, the processor is interrupted when I/O operations (such as reading from a sensor or writing to a peripheral) are ready to be processed, instead of constantly checking the status.

Q17: How do you implement an interrupt in an embedded system?

• Steps include:
  1. Enable the interrupt source (e.g., a peripheral or timer).
  2. Configure the interrupt vector table.
  3. Write the ISR to handle the interrupt.
  4. Enable global interrupts.
  5. Ensure proper return from the ISR to resume normal execution.

You can also Visit other tutorials of Embedded Prep 

• What is eMMC (Embedded MultiMediaCard) memory ?
• Top 30+ I2C Interview Questions
• Bit Manipulation Interview Questions
• Structure and Union in c
• Little Endian vs. Big Endian: A Complete Guide
• Merge sort algorithm

Special thanks to @embedded-prep for contributing to this article on Embedded Prep