ESP32 Interrupts

Introduction to Interrupts

What are Interrupts?

Interrupts are a fundamental feature in embedded systems and computer architecture that allow a processor to temporarily halt its current task and execute a function called an Interrupt Service Routine (ISR) in response to an event. After the ISR completes, the processor resumes its previous task. This mechanism enables responsive and efficient handling of time-critical events.

• Definition: An interrupt is a signal to the processor emitted by hardware or software indicating an event that needs immediate attention.
• Purpose: Interrupts are used to handle asynchronous events such as input from sensors, timers, or user inputs like button presses.

Importance and Use Cases in Embedded Systems

Interrupts are crucial in embedded systems for several reasons:

1. Responsiveness: Interrupts allow the system to respond immediately to critical events without polling or constantly checking the status of external devices, which can be inefficient and resource-consuming.
2. Efficiency: By using interrupts, the system can perform other tasks and only stop to handle events when necessary, leading to better overall performance.
3. Power Saving: In systems where power consumption is a concern, such as battery-powered devices, interrupts can help save power by allowing the processor to enter low-power states and wake up only when an interrupt occurs.

Common Use Cases:

• Sensor Data Collection: Handling data from sensors that generate data at unpredictable times.
• User Inputs: Responding to button presses or other user interactions.
• Communication Protocols: Managing data transfer over communication interfaces like UART, I2C, or SPI.
• Real-Time Systems: Ensuring timely execution of tasks in real-time operating systems.

Interrupts In ESP32

The ESP32 microcontroller supports multiple types of interrupts, making it highly versatile for various applications. Here’s a brief overview of how interrupts are implemented and managed on the ESP32:

• External Interrupts: Triggered by changes on GPIO pins.
• Timer Interrupts: Triggered by timers.
• Peripheral Interrupts: Triggered by peripherals such as UART, I2C, ADC, etc.

In this article, we will cover only the GPIO interrupt feature of the ESP32 microcontroller. It’s important to note that while the ESP32 also supports timer interrupts, they are not as widely supported or have limitations within the Arduino framework. Therefore, our focus will be on understanding and utilizing GPIO interrupts.

Introduction to GPIO Interrupts on ESP32

General Purpose Input/Output (GPIO) pins are one of the key features of any microcontroller, including the ESP32. These pins can be configured as either input or output, allowing them to interface with a variety of external components and devices. One powerful feature of GPIO pins is the ability to generate interrupts, which are essential for responding to events or changes in state without constantly polling the pin’s status in the main program loop.

GPIO Interrupts on the ESP32

The ESP32 microcontroller has extensive support for GPIO interrupts. You can configure any GPIO pin to generate an interrupt on various conditions, such as:

• Rising edge (when the signal goes from low to high)
• Falling edge (when the signal goes from high to low)
• Change (either rising or falling edge)
• Low level
• High level

These interrupt types allow the ESP32 to react to a wide range of events, making it suitable for numerous applications.

Configuring GPIO Interrupts in the Arduino Framework

To use GPIO interrupts in the Arduino framework, you need to follow these steps:

1. Define the Interrupt Service Routine (ISR): This is the function that will be called when the interrupt occurs.
2. Attach the Interrupt to a GPIO Pin: Use the attachInterrupt() function to link the ISR to the desired GPIO pin and specify the interrupt condition.

Here’s a basic example demonstrating how to set up a GPIO interrupt on the ESP32 using the Arduino framework:

const int buttonPin = 12;  // GPIO pin connected to the button

volatile bool buttonPressed = false;  // A flag to indicate button press

// ISR function to handle the interrupt
void IRAM_ATTR handleButtonPress() {

  buttonPressed = true;  // Set the flag when interrupt occurs
}

void setup() {

  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);  // Set the button pin as input with internal pull-up resistor
  attachInterrupt(digitalPinToInterrupt(buttonPin), handleButtonPress, FALLING);  // Attach interrupt

}

void loop() {

  if (buttonPressed) {
    Serial.println("Button pressed!");
    buttonPressed = false;  // Reset the flag
  }
}

Code Explaination

1. Setting Up the GPIO Pin

const int buttonPin = 12;  // GPIO pin connected to the button

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);  // Set button pin as input with pull-up resistor
}

First, you need to configure the GPIO pin that will be used as the interrupt source. This involves setting the pin mode to input and optionally enabling an internal pull-up or pull-down resistor.

2. Defining the Interrupt Service Routine (ISR)

volatile bool buttonPressed = false;

void IRAM_ATTR handleButtonPress() {
  buttonPressed = true;
}

The ISR is the function that will be called when the interrupt occurs. This function should be short and efficient to avoid blocking other operations.

• IRAM_ATTR is used to place the ISR in the IRAM (Instruction RAM), which is faster and ensures the ISR executes quickly.
• volatile is used for the buttonPressed variable to indicate that it can be modified within an ISR.

3. Attaching the Interrupt

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin), handleButtonPress, FALLING);  // Trigger on falling edge
}

The next step is to attach the interrupt to the GPIO pin. This involves specifying the pin, the ISR, and the condition that triggers the interrupt (e.g., rising edge, falling edge, or change in state).

4. Handling the Interrupt in the Main Loop

void loop() {
  if (buttonPressed) {
    Serial.println("Button pressed!");
    buttonPressed = false;  // Reset the flag
  }
}

Finally, in the main loop, you can check if the interrupt has occurred and handle it accordingly. This often involves resetting the flag set by the ISR.

Advanced Topics

Debouncing

When dealing with mechanical buttons, it is common to encounter noise or “bounce” when the button is pressed or released. This can cause multiple interrupts to be triggered for a single button press. Debouncing can be handled in software by adding a small delay or by using a timer.

Example of Software Debouncing:

void IRAM_ATTR handleButtonPress() {

  static unsigned long lastInterruptTime = 0;

  unsigned long interruptTime = millis();
  if (interruptTime - lastInterruptTime > 200) {  // 200 ms debounce time
    buttonPressed = true;
  }
  lastInterruptTime = interruptTime;

}

Conclusion

GPIO interrupts on the ESP32 provide a powerful way to handle asynchronous events efficiently and responsively. By configuring GPIO pins to trigger interrupts, defining ISRs, and handling the events in the main loop, developers can create robust embedded applications that react promptly to external inputs.