attachInterrupt() function in Arduino - Step-by-Step Execution

Concept Flow - attachInterrupt() function

Setup interrupt pin

↓

Call attachInterrupt()

↓

Wait for interrupt event

↓

Interrupt triggers ISR

↓

ISR runs quickly

↓

Return to main program

The attachInterrupt() function sets up a pin to watch for a signal change and runs a small special function (ISR) when that happens.

Execution Sample

Arduino

volatile int count = 0;
void setup() {
  attachInterrupt(digitalPinToInterrupt(2), increment, RISING);
}
void increment() {
  count++;
}

This code increases 'count' by 1 every time pin 2 detects a rising signal.

Execution Table

Step	Action	Pin State	Interrupt Triggered?	ISR Called?	count Value
1	Setup starts	LOW	No	No	0
2	attachInterrupt called on pin 2 for RISING edge	LOW	No	No	0
3	Pin 2 signal changes from LOW to HIGH	HIGH	Yes	Yes	0
4	ISR 'increment' runs	HIGH	Yes	Yes	1
5	ISR finishes, main continues	HIGH	No	No	1
6	Pin 2 signal stays HIGH	HIGH	No	No	1
7	Pin 2 signal changes from HIGH to LOW	LOW	No	No	1
8	Pin 2 signal changes from LOW to HIGH again	HIGH	Yes	Yes	1
9	ISR 'increment' runs again	HIGH	Yes	Yes	2
10	ISR finishes, main continues	HIGH	No	No	2

💡 No more signal changes, program continues running main loop.

Variable Tracker

Variable	Start	After Step 4	After Step 9	Final
count	0	1	2	2

Key Moments - 3 Insights

Why does the ISR run only when the pin signal changes from LOW to HIGH?

Because attachInterrupt() was set with the RISING mode, it triggers the ISR only on a LOW to HIGH change, as shown in steps 3 and 8 in the execution_table.

Why must the variable 'count' be declared volatile?

Because 'count' is changed inside the ISR and read outside, declaring it volatile tells the compiler it can change anytime, preventing wrong optimizations. This is important as seen in variable_tracker.

What happens if the ISR takes too long to run?

The main program pauses during the ISR, so long ISRs can cause delays or missed interrupts. Here, the ISR just increments 'count' quickly (step 4 and 9), keeping the program responsive.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'count' after the ISR runs the second time?

A 1

B 0

C 2

D 3

💡 Hint

Check the 'count Value' column at step 9 where ISR runs again.

At which step does the interrupt trigger for the first time?

A Step 2

B Step 3

C Step 5

D Step 7

💡 Hint

Look at the 'Interrupt Triggered?' column to find the first 'Yes'.

If the attachInterrupt mode changed from RISING to FALLING, when would the ISR run?

A When pin changes from HIGH to LOW

B When pin stays HIGH

C When pin changes from LOW to HIGH

D When pin stays LOW

💡 Hint

RISING triggers on LOW to HIGH; FALLING triggers on HIGH to LOW signal changes.

Concept Snapshot

attachInterrupt(pin, ISR, mode)
- Sets an interrupt on 'pin'
- Runs ISR function when 'mode' condition met
- Modes: RISING, FALLING, CHANGE, LOW
- ISR should be short and fast
- Use volatile for variables shared with ISR

Full Transcript

The attachInterrupt() function in Arduino sets up a pin to watch for signal changes. When the specified event happens, it runs a small special function called an ISR (Interrupt Service Routine). In the example, the program watches pin 2 for a rising edge (signal going from LOW to HIGH). When this happens, the ISR 'increment' runs and increases the 'count' variable by one. The variable 'count' is declared volatile because it changes inside the ISR and is used outside. The ISR runs quickly so the main program can continue without delay. The execution table shows each step: setting up, waiting, detecting signal changes, running ISR, and updating 'count'. This helps beginners see how interrupts work step-by-step.