Rising, falling, and change triggers in Arduino - Step-by-Step Execution

Concept Flow - Rising, falling, and change triggers

Start

↓

Read Pin State

↓

Compare Current and Previous State

↓

If Rising Edge?

Yes→Trigger Rising Event

↓

If Falling Edge?

Yes→Trigger Falling Event

↓

If Change?

Yes→Trigger Change Event

↓

Update Previous State

↓

Repeat

The program repeatedly reads a pin's state, compares it to the previous state, and triggers events on rising, falling, or any change.

Execution Sample

Arduino

const int buttonPin = 2;
int lastButtonState = LOW;

void loop() {
  int reading = digitalRead(buttonPin);

This code reads a button pin state and compares it to the last state to detect rising, falling, or any change.

Execution Table

Step	reading	lastButtonState	Condition	Action	Output
1	LOW	LOW	reading != lastButtonState? LOW != LOW	No action	None
2	HIGH	LOW	reading != lastButtonState? HIGH != LOW	Rising edge detected	Print 'Rising edge'
3	HIGH	HIGH	reading != lastButtonState? HIGH != HIGH	No action	None
4	LOW	HIGH	reading != lastButtonState? LOW != HIGH	Falling edge detected	Print 'Falling edge'
5	LOW	LOW	reading != lastButtonState? LOW != LOW	No action	None
6	HIGH	LOW	reading != lastButtonState? HIGH != LOW	Rising edge detected	Print 'Rising edge'
7	LOW	HIGH	reading != lastButtonState? LOW != HIGH	Falling edge detected	Print 'Falling edge'
8	LOW	LOW	reading != lastButtonState? LOW != LOW	No action	None
Exit	-	-	Loop continues indefinitely	Program runs continuously	-

💡 The loop runs forever, checking pin state changes continuously.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	After 8
reading	LOW	LOW	HIGH	HIGH	LOW	LOW	HIGH	LOW	LOW
lastButtonState	LOW	LOW	HIGH	HIGH	LOW	LOW	HIGH	LOW	LOW

Key Moments - 3 Insights

Why does the program detect a rising edge only when reading changes from LOW to HIGH?

Because the condition reading != lastButtonState is true only when the current reading differs from the last state. The rising edge is specifically when reading changes from LOW to HIGH, as shown in execution_table rows 2 and 6.

What happens if the reading stays the same as lastButtonState?

No event triggers because the condition reading != lastButtonState is false. This is shown in rows 1, 3, 5, and 8 where no action occurs.

How does the program detect a falling edge?

A falling edge is detected when reading changes from HIGH to LOW, which makes reading != lastButtonState true and reading is LOW. This is shown in rows 4 and 7 where 'Falling edge detected' is printed.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the value of lastButtonState?

A UNKNOWN

B HIGH

C LOW

D LOW but changed to HIGH

💡 Hint

Check the 'lastButtonState' column in row 2 of the execution_table.

At which step does the program detect a falling edge for the first time?

A Step 4

B Step 2

C Step 6

D Step 7

💡 Hint

Look for 'Falling edge detected' in the 'Action' column of the execution_table.

If the reading never changes from LOW, what will the output be according to the execution_table?

A Multiple falling edges

B No output

C Multiple rising edges

D Continuous change events

💡 Hint

Check rows where reading equals lastButtonState and see the 'Output' column.

Concept Snapshot

Rising, falling, and change triggers detect pin state changes.
Compare current reading with previous state.
Rising edge: LOW to HIGH transition.
Falling edge: HIGH to LOW transition.
Change: any difference triggers event.
Update previous state after each check.

Full Transcript

This visual execution shows how an Arduino program detects rising, falling, and change triggers on a digital input pin. The program reads the pin state repeatedly and compares it to the previous state. When the reading changes from LOW to HIGH, it triggers a rising edge event. When it changes from HIGH to LOW, it triggers a falling edge event. If the reading stays the same, no event triggers. The previous state is updated after each check to track changes. The execution table traces each step, showing variable values, conditions, and actions. This helps beginners understand how edge detection works in Arduino programming.

Practice

1. Which interrupt trigger type activates when a signal changes from LOW to HIGH on an Arduino pin?

easy

A. RISING

B. FALLING

C. CHANGE

D. LOW

Solution

1. Step 1: Understand the meaning of RISING trigger

   The RISING trigger activates when the signal goes from LOW (0) to HIGH (1).

2. Step 2: Compare with other triggers

   FALLING triggers on HIGH to LOW, CHANGE triggers on any change, LOW triggers when signal is LOW.

3. Final Answer:

   RISING -> Option A

4. Quick Check:

   LOW to HIGH = RISING [OK]

Hint: RISING means signal goes up from LOW to HIGH [OK]

Common Mistakes:

• Confusing RISING with FALLING
• Thinking CHANGE triggers only on RISING
• Mixing LOW trigger with RISING

2. Which of the following is the correct syntax to attach an interrupt on pin 2 for a FALLING trigger in Arduino?

easy

A. attachInterrupt(2, ISR, RISING);

B. attachInterrupt(digitalPinToInterrupt(2), ISR, FALLING);

C. attachInterrupt(2, ISR, CHANGE);

D. attachInterrupt(digitalPinToInterrupt(2), ISR, LOW);

Solution

1. Step 1: Identify correct function usage

   attachInterrupt requires pin number converted by digitalPinToInterrupt for portability.

2. Step 2: Match trigger type FALLING

   attachInterrupt(digitalPinToInterrupt(2), ISR, FALLING); uses digitalPinToInterrupt(2) and FALLING correctly.

3. Final Answer:

   attachInterrupt(digitalPinToInterrupt(2), ISR, FALLING); -> Option B

4. Quick Check:

   Use digitalPinToInterrupt with FALLING [OK]

Hint: Use digitalPinToInterrupt(pin) with trigger type [OK]

Common Mistakes:

• Using pin number directly without digitalPinToInterrupt
• Mixing trigger types with wrong syntax
• Using LOW trigger incorrectly

3. What will be the output on the serial monitor if the following Arduino code is run and the input pin changes from LOW to HIGH, then HIGH to LOW?

volatile int count = 0;
void ISR() { count++; }
void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT);
  attachInterrupt(digitalPinToInterrupt(2), ISR, CHANGE);
}
void loop() {
  Serial.println(count);
  delay(1000);
}

medium

A. 0 0 0 ... (no change)

B. 1 1 1 ... (count increments once)

C. 2 2 2 ... (count increments twice)

D. Error: ISR cannot increment variable

Solution

1. Step 1: Understand CHANGE trigger behavior

   CHANGE triggers on any signal change: LOW to HIGH and HIGH to LOW, so ISR runs twice.

2. Step 2: Count increments in ISR

   Each ISR call increments count by 1, so after two changes count = 2.

3. Final Answer:

   2 2 2 ... (count increments twice) -> Option C

4. Quick Check:

   CHANGE triggers twice, count = 2 [OK]

Hint: CHANGE triggers on both edges, count increments twice [OK]

Common Mistakes:

• Assuming CHANGE triggers only once
• Forgetting volatile keyword importance
• Thinking ISR cannot modify variables

4. Identify the error in this Arduino code snippet that tries to attach an interrupt on pin 3 for a RISING trigger:

void ISR() {
  // interrupt code
}
void setup() {
  attachInterrupt(3, ISR, RISING);
}

medium

A. ISR function must have parameters

B. attachInterrupt must be called in loop(), not setup()

C. RISING is not a valid trigger type

D. Pin number 3 should be converted using digitalPinToInterrupt()

Solution

1. Step 1: Check attachInterrupt pin argument

   Pin number must be converted with digitalPinToInterrupt(pin) for correct interrupt mapping.

2. Step 2: Validate other parts

   ISR has correct signature (no parameters), RISING is valid, attachInterrupt is correctly called in setup.

3. Final Answer:

   Pin number 3 should be converted using digitalPinToInterrupt() -> Option D

4. Quick Check:

   Use digitalPinToInterrupt for pin numbers [OK]

Hint: Always convert pin with digitalPinToInterrupt() [OK]

Common Mistakes:

• Passing raw pin number directly
• Thinking ISR needs parameters
• Calling attachInterrupt in loop()

5. You want to count how many times a button connected to pin 4 changes state (pressed or released). Which interrupt trigger should you use and why?

hard

A. CHANGE, because it counts both presses and releases

B. FALLING, because it counts only releases

C. RISING, because it counts only presses

D. LOW, because it triggers when button is held down

Solution

1. Step 1: Understand button state changes

   A button press changes signal from HIGH to LOW or LOW to HIGH depending on wiring.

2. Step 2: Choose trigger to count all changes

   CHANGE triggers on any signal change, so it counts both presses and releases.

3. Final Answer:

   CHANGE, because it counts both presses and releases -> Option A

4. Quick Check:

   Count all changes = use CHANGE trigger [OK]

Hint: Use CHANGE to count all button state changes [OK]

Common Mistakes:

• Using RISING or FALLING and missing half the events
• Confusing LOW trigger with change detection
• Not considering both press and release