ISR best practices in Arduino - Step-by-Step Execution

Concept Flow - ISR best practices in Arduino

Interrupt Occurs

↓

CPU Pauses Main Code

↓

Jump to ISR Function

↓

Execute ISR Quickly

↓

Clear Interrupt Flag

↓

Return to Main Code

↓

Resume Main Code Execution

When an interrupt happens, the main program pauses, runs the ISR quickly, then resumes the main code.

Execution Sample

Arduino

volatile int count = 0;

void ISR() {
  count++;
}

void setup() {
  attachInterrupt(digitalPinToInterrupt(2), ISR, RISING);
}

void loop() {
  // main code here
}

This code sets up an interrupt on pin 2 that increases count each time the pin signal rises.

Execution Table

Step	Event	Main Code State	ISR Action	Variable Changes	Return to Main Code
1	Main code running	count=0	No ISR	count=0	Continue main code
2	Interrupt on pin 2 rising	count=0	ISR called	count=1	Resume main code
3	Main code running	count=1	No ISR	count=1	Continue main code
4	Interrupt on pin 2 rising	count=1	ISR called	count=2	Resume main code
5	Main code running	count=2	No ISR	count=2	Continue main code
Exit	No more interrupts	count=2	No ISR	count=2	Program runs normally

💡 No more interrupts occur, main code runs continuously.

Variable Tracker

Variable	Start	After 1	After 2	Final
count	0	1	2	2

Key Moments - 3 Insights

Why must ISR functions be very short and fast?

Because during ISR execution, the main program is paused (see execution_table steps 2 and 4). Long ISRs delay the main code and can cause missed interrupts.

Why is the variable 'count' declared as volatile?

Volatile tells the compiler the variable can change anytime (like in ISR). Without volatile, the main code might not see updates made inside ISR (see variable_tracker).

Can we use delay() or Serial.print() inside ISR?

No, these functions are slow and can cause problems inside ISR. ISR should only do quick, simple tasks (see concept_flow).

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the value of 'count' after ISR runs?

A 1

B 0

C 2

D Undefined

💡 Hint

Check the 'Variable Changes' column at step 2 in execution_table.

At which step does the main code resume after the ISR finishes?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Return to Main Code' column in execution_table after ISR actions.

If 'count' was not declared volatile, what might happen?

A ISR would not run

B Program would crash

C Main code might not see updated 'count'

D Interrupts would be disabled

💡 Hint

Refer to variable_tracker and key_moments about volatile keyword.

Concept Snapshot

ISR best practices in Arduino:
- Keep ISR functions very short and fast.
- Use volatile for variables shared with ISR.
- Avoid delay(), Serial.print(), or heavy code inside ISR.
- Clear interrupt flags if needed.
- Main code pauses during ISR and resumes after.
- Use attachInterrupt() to link ISR to pin events.

Full Transcript

In Arduino, when an interrupt happens, the main program pauses and runs a special function called ISR (Interrupt Service Routine). The ISR should be very short and fast to avoid delaying the main program. Variables shared between ISR and main code must be declared volatile so the main code always sees the latest value. Functions like delay() or Serial.print() should not be used inside ISR because they are slow. After ISR finishes, the main program resumes where it left off. This example shows an interrupt on pin 2 that increases a count variable each time the pin signal rises. The execution table traces how the count changes and when the ISR runs. Remember, keeping ISRs quick and using volatile variables are key best practices.