![\"ESP32](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/ESP32-Interrupts.jpg?resize=1200%2C675&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nSetting an ESP32 Input Pin as an interrupt allows you to quickly detect events (changes in the GPIO state) and react to them by halting the main program and running a callback function (also called an interrupt service routine\u2014ISR). This can be useful to detect the press of a pushbutton, when a sensor passes a certain threshold, when motion is detected, etc.<\/p>\n\n\n\n
Table of Contents<\/h2>\n\n\n\n
In this tutorial, we’ll cover the following subjects:<\/p>\n\n\n\n
- \n
- Introducing Interrupts<\/a>\n
- \n
- What are Interrupts?<\/a><\/li>\n\n\n\n
- Types of Interrupts<\/a><\/li>\n<\/ul>\n<\/li>\n\n\n\n
- Using Interrupts with the ESP32<\/a><\/li>\n\n\n\n
- Example 1: ESP32 – Detecting a Button Press with an Interrupt<\/a><\/li>\n\n\n\n
- Example 2: ESP32 with a PIR Sensor – Detect Motion with an Interrupt<\/a><\/li>\n<\/ul>\n\n\n\n
Prerequisites<\/h2>\n\n\n\n
Before proceeding with this tutorial, you should have the ESP32 boards installed in your Arduino IDE. Follow this next tutorial to install the ESP32 on the Arduino IDE, if you haven\u2019t already.<\/p>\n\n\n\n
- \n
- Installing ESP32 Board in Arduino IDE 2 (Windows, Mac OS X, Linux)<\/a><\/li>\n<\/ul>\n\n\n\n
Introducing Interrupts<\/h2>\n\n\n\n
Interrupts are useful for making things happen automatically in microcontroller programs and can help solve timing problems. <\/p>\n\n\n\n
Interrupts provide mechanisms to respond to external events, enabling your ESP32 boards to react quickly to changes without continuously polling (continuously checking the current value of a pin or variable).<\/p>\n\n\n\n
What are Interrupts?<\/h3>\n\n\n\n
Interrupts are signals that pause the normal execution flow of a program to handle a specific event. When an interrupt happens, the processor stops the execution of the main program to execute a task and then gets back to the main program. That task is also referred to as an interrupt handling routine<\/em> (or interrupt service routine<\/em>, ISR), as shown in the figure below.<\/p>\n\n\n
\n![\"How](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2019\/03\/interrupt.png?resize=992%2C291&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nIn summary, with interrupts, you don\u2019t need to constantly check the current value of a pin. With interrupts, when a change is detected, a callback function is triggered.<\/p>\n\n\n\n
Types of Interrupts<\/h3>\n\n\n\n
There are different types of interrupts: external interrupts (hardware-based) and timer interrupts (software interrupts).<\/p>\n\n\n\n
- \n
- External Interrupts<\/strong>: triggered by external signals and detected on the ESP32 GPIOs, such as a button press or a sensor reading\u2014this is hardware-based and associated with a specific GPIO pin. When the state of a pin changes, it will trigger the interrupt service routine (ISR). We’ll focus on these in this tutorial.<\/li>\n\n\n\n
- Timer Interrupts (software timers)<\/strong>: initiated based on time intervals, enabling periodic actions\u2014this is software-based. You can learn more about software interrupts with the ESP32 in this tutorial<\/a>.<\/li>\n<\/ol>\n\n\n\n
Using Interrupts with the ESP32<\/h2>\n\n\n\n
To set an interrupt in the Arduino IDE, you use the attachInterrupt()<\/strong> function, that accepts as arguments: the GPIO pin, the name of the function to be executed, and the mode:<\/p>\n\n\n\n
attachInterrupt(GPIO, callback_function, mode);<\/code><\/pre>\n\n\n\nThis instruction should be added to the setup()<\/span> of your Arduino code.<\/p>\n\n\n\n
Let’s take a look at the arguments you should pass to that function.<\/p>\n\n\n\n
GPIO Interrupt<\/h3>\n\n\n\n
The first argument of the attachInterrupt()<\/span> function is the GPIO number where we’ll detect the change. For example, if you want to use GPIO 27 as an interrupt, you can use:<\/p>\n\n\n\n
digitalPinToInterrupt(27)<\/code><\/pre>\n\n\n\nWith an ESP32 board, all the pins that can act as inputs can be set as interrupts.<\/p>\n\n\n\n
Callback Function<\/h3>\n\n\n\n
The second argument of the attachInterrupt()<\/span> function is the name of the function that will be called when the interrupt is triggered.<\/p>\n\n\n\n
Now, there are a few important rules you should be aware of when defining your ISR (callback function).<\/p>\n\n\n\n
- \n
- The ISR should not return anything.<\/li>\n\n\n\n
- ISRs should be as short and fast as possible because they halt the normal execution of the code.<\/li>\n\n\n\n
- They should have the ARDUINO_ISR_ATTR<\/span> attribute, so that they run in the ESP32 Internal RAM and not in Flash. IRAM access is much faster, which is critical for ISRs to run reliably without timing issues or crashes during interrupts.<\/li>\n\n\n\n
- Variables that are used inside ISRs and throughout the code should preferably be volatile<\/span>. This prevents the compiler from caching values in registers (and skipping memory access), so reads\/writes always access the actual memory location and reflect unexpected changes caused by the interrupt.<\/li>\n<\/ol>\n\n\n\n
Here’s an example of an ISR so that you can check its syntax:<\/p>\n\n\n\n
void ARDUINO_ISR_ATTR my_callback() {\n \/\/ Any code you want to run\n}<\/code><\/pre>\n\n\n\nAnother important thing about ISRs is that you should keep their code as fast and simple as possible and avoid things like complex operations, writing to the Serial Monitor, or using delay()<\/span>. Instead, you should use a flag or counter to indicate that the interrupt happened, and then handle whatever you need to do in the main code or loop()<\/span> section.<\/p>\n\n\n\n
Mode<\/h3>\n\n\n\n
The third argument is the mode. There are 5 different modes:<\/p>\n\n\n\n
- \n
- LOW<\/span>: to trigger the interrupt whenever the pin is LOW;<\/li>\n\n\n\n
- HIGH<\/span>: to trigger the interrupt whenever the pin is HIGH;<\/li>\n\n\n\n
- CHANGE<\/span>: to trigger the interrupt whenever the pin changes value – for example, from HIGH to LOW or LOW to HIGH;<\/li>\n\n\n\n
- FALLING<\/span>: for when the pin goes from HIGH to LOW;<\/li>\n\n\n\n
- RISING<\/span>: to trigger when the pin goes from LOW to HIGH.<\/li>\n<\/ul>\n\n\n\n
The following picture will help you better understand the different trigger modes.<\/p>\n\n\n
\n![\"Interrupt](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/05\/interrupt-modes.png?resize=750%2C438&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nAttach an Interrupt with Arguments<\/h3>\n\n\n\n
Besides the attachInterrupt()<\/span> function, you can alternatively use the attachInterruptArg()<\/span> function instead. The function attachInterruptArg()<\/span> is used to attach the interrupt to the defined pin using argumentsthis means you can pass arguments to the callback function.<\/p>\n\n\n\n
attachInterruptArg(uint8_t pin, void callback_function, void * arg, int mode);<\/code><\/pre>\n\n\n\n- \n
- pin<\/span> defines the GPIO pin number.<\/li>\n\n\n\n
- callback_function<\/span> set the callback function.<\/li>\n\n\n\n
- arg<\/span> pointer to the interrupt arguments.<\/li>\n\n\n\n
- mode<\/span> set the interrupt mode.<\/li>\n<\/ul>\n\n\n\n
Detaching\/Disabling an Interrupt from a GPIO Pin<\/h3>\n\n\n\n
When you don’t want the ESP32 to no longer monitor the pin, you can call the detachInterrupt()<\/span> function and pass as argument the GPIO pin.<\/p>\n\n\n\n
detachInterrupt(digitalPinToInterrupt(interruptPin));<\/code><\/pre>\n\n\n\nExample 1: ESP32 – Detecting a Button Press with an Interrupt<\/h2>\n\n\n\n
In this section, we’ll create a simple example to detect a button press using an interrupt. We’re using a pushbutton in this example, but you can use a sensor with a threshold, like a PIR Motion Sensor, for example (we’ll take a look at that later in this guide).<\/p>\n\n\n
\n![\"ESP32](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/ESP32-with-pushbutton.jpg?resize=750%2C421&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nParts Required<\/h3>\n\n\n\n
- \n
- ESP32 Board<\/a> (model of your choice)<\/li>\n\n\n\n
- 1x Pushbutton<\/a><\/li>\n\n\n\n
- Jumper Wires<\/a><\/li>\n\n\n\n
- Breadboard<\/a><\/li>\n<\/ul>\n\n\n
You can use the preceding links or go directly to MakerAdvisor.com\/tools<\/a> to find all the parts for your projects at the best price!<\/p>
![](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2017\/10\/header-200.png?w=1200&quality=100&strip=all&ssl=1\")
<\/a><\/p>\n\n\n\nWiring Diagram<\/h3>\n\n\n\n
For this example, you need to connect a pushbutton to GPIO 18. We won’t use any resistors for the pushbutton because we’ll use the ESP32 internal pull-up resistors. Wire one lead of the pushbutton to GPIO 18 and the other one to GND, as shown in the diagram below.<\/p>\n\n\n
\n![\"ESP32](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/ESP32-pushbutton-schematic-diagram_bb.png?resize=719%2C792&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nAlternatively, you can use any other suitable GPIO as long as you modify the code. Make sure to check our ESP32 Pinout Guide<\/a>.<\/p>\n\n\n\n
Code<\/h3>\n\n\n\n
Upload the following code to your ESP32. It detects the pushbutton presses and prints the number of presses in the Serial Monitor.<\/p>\n\n\n
\/*********\n Rui Santos & Sara Santos - Random Nerd Tutorials\n Complete project details at https:\/\/RandomNerdTutorials.com\/esp32-gpio-interrupts-arduino\/\n*********\/\n#include <Arduino.h>\n\n\/\/ Global variables for the button\nconst uint8_t buttonPin = 18;\nvolatile int32_t counter = 0;\nvolatile bool pressed = false;\n\n\/\/ Interrupt Service Routine (ISR)\nvoid ARDUINO_ISR_ATTR buttonISR() {\n counter++;\n pressed = true;\n}\n\nvoid setup() {\n Serial.begin(115200);\n pinMode(buttonPin, INPUT_PULLUP);\n attachInterrupt(buttonPin, buttonISR, RISING);\n Serial.println("Press the button on GPIO 18.");\n}\n\nvoid loop() {\n if (pressed) {\n Serial.print("Button pressed ");\n Serial.print(counter);\n Serial.println(" times.");\n pressed = false;\n }\n delay(10);\n}<\/code><\/pre>\n\tView raw code<\/a><\/p>\n\n\n\n
How Does the Code Work?<\/h3>\n\n\n\n
Let’s take a look at how the code works so that you can understand how to use interrupts in your code.<\/p>\n\n\n\n
Pushbutton Global Variables<\/h4>\n\n\n\n
First, define global variables for the pushbutton. We’re defining the buttonPin<\/span> as a const variable because it won’t change throughout the code. The counter<\/span> variable will count the number of pushbutton presses. Finally, pressed<\/span> is a boolean variable that will indicate whether the button was pressed or not. It starts as false<\/span>.<\/p>\n\n\n\n
\/\/ Global variables for the button\nconst uint8_t buttonPin = 18;\nvolatile uint32_t counter = 0;\nvolatile bool pressed = false;<\/code><\/pre>\n\n\n\nNotice that counter<\/span> and pressed<\/span> are volatile<\/span> variables because they will be used inside the ISR and also throughout the code (in the loop()<\/span>).<\/p>\n\n\n\n
Interrupt Service Routine<\/h4>\n\n\n\n
Define the interrupt service routine, which is the callback function that will run when the interrupt is triggered. In this case, the function is called buttonISR()<\/span> and it has the ARDUINO_ISR_ATTR<\/span> attribute so that the function runs on the ESP32 IRAM as we’ve seen previously.<\/p>\n\n\n\n
void ARDUINO_ISR_ATTR buttonISR() {<\/code><\/pre>\n\n\n\nIn this function, we increase the counter<\/span> variable and set the pressed<\/span> variable to true<\/span>, indicating that a button press happened.<\/p>\n\n\n\n
counter++;\npressed = true;<\/code><\/pre>\n\n\n\nsetup()<\/h4>\n\n\n\n
In the setup()<\/span>, initialize the Serial Monitor for debugging purposes.<\/p>\n\n\n\n
void setup() {\n Serial.begin(115200);<\/code><\/pre>\n\n\n\nSetting an Interrupt<\/h4>\n\n\n\n
Set the interrupt pin first as an input with an internal pull-up resistor as follows.<\/p>\n\n\n\n
pinMode(buttonPin, INPUT_PULLUP);<\/code><\/pre>\n\n\n\nSet the pin as an interrupt and assign it a callback function with RISING<\/span> mode (this means the interrupt will be triggered when the interrupt pin goes from LOW to HIGH\u2014when the pushbutton is pressed).<\/p>\n\n\n\n
attachInterrupt(buttonPin, buttonISR, RISING);<\/code><\/pre>\n\n\n\nloop()<\/h4>\n\n\n\n
In the loop()<\/span>, we check whether the pushbutton was pressed. If it was pressed, we print how many times it was pressed so far.<\/p>\n\n\n\n
void loop() {\n if (pressed) {\n Serial.print(\"Button pressed \");\n Serial.print(counter);\n Serial.println(\" times.\");<\/code><\/pre>\n\n\n\nIn the end, we set it to false<\/span> again, so that we can print when there’s a new press.<\/p>\n\n\n\n
pressed = false;<\/code><\/pre>\n\n\n\nTesting the Example<\/h3>\n\n\n\n
Upload the code to your ESP32. After uploading, open the Serial Monitor at a baud rate of 115200. Press the ESP32 RST button so that it starts running the code.<\/p>\n\n\n\n
Press the pushbutton.<\/p>\n\n\n
\n![\"Pressing](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/ESP32-Pressing-Pushbutton.jpg?resize=750%2C421&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nSee the number of presses increasing in the Serial Monitor.<\/p>\n\n\n
\n![\"ESP32:](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/Pushbutton_interrupt_no_debouncing.png?resize=666%2C326&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nIssue<\/strong>: notice that when you press the pushbutton, sometimes it catches more presses than it should. This is an issue related to mechanical buttons called mechanical bouncing. This can be solved via software or via hardware.<\/p>\n\n\n
\n![\"debounce](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/05\/button-bounce.png?resize=750%2C476&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nThis happens because the electrical contacts inside the button connect and disconnect very quickly before reaching a steady state, which will cause the system to register multiple press events, causing an inaccurate count.<\/p>\n\n\n\n
We’ll show you how you can add debouncing to your code to prevent false pushbutton presses.<\/p>\n\n\n\n
Detecting a Button Press with an Interrupt (with Debouncing)<\/h3>\n\n\n\n
The following code is similar to the previous one, but includes the lines of code required for debouncing the pushbutton.<\/p>\n\n\n
\/*********\n Rui Santos & Sara Santos - Random Nerd Tutorials\n Complete project details at https:\/\/RandomNerdTutorials.com\/esp32-gpio-interrupts-arduino\/\n*********\/\n#include <Arduino.h>\n\n\/\/ Global variables for the button\nconst uint8_t buttonPin = 18;\nvolatile uint32_t counter = 0;\nvolatile bool pressed = false;\n\n\/\/ For debouncing the pushbutton\nconst unsigned long DEBOUNCE_DELAY = 50; \/\/ in milliseconds\nvolatile unsigned long lastPressTime = 0;\n\n\/\/ Interrupt Service Routine (ISR)\nvoid ARDUINO_ISR_ATTR buttonISR() {\n unsigned long now = millis();\n if (now - lastPressTime > DEBOUNCE_DELAY) {\n counter++;\n pressed = true;\n }\n lastPressTime = now;\n}\n\nvoid setup() {\n Serial.begin(115200);\n pinMode(buttonPin, INPUT_PULLUP);\n attachInterrupt(buttonPin, buttonISR, HIGH);\n Serial.println("Press the button on GPIO 18.");\n}\n\nvoid loop() {\n if (pressed) {\n Serial.print("Button pressed ");\n Serial.print(counter);\n Serial.println(" times.");\n pressed = false;\n }\n delay(10);\n}\n<\/code><\/pre>\n\tView raw code<\/a><\/p>\n\n\n\n
In this code, we’ve added variables to handle debouncing for the pushbutton. <\/p>\n\n\n\n
\/\/ For debouncing the pushbutton\nconst unsigned long DEBOUNCE_DELAY = 50; \/\/ in milliseconds\nvolatile unsigned long lastPressTime = 0;<\/code><\/pre>\n\n\n\nDEBOUNCE_DELAY<\/span> defines the minimum time required between button presses to register a valid event (preventing false triggers from mechanical bounce). The 50 milliseconds should be enough. If you continue to have false positives, increase the debounce time.<\/p>\n\n\n\n
The lastPressTime<\/span> saves the time of the last button press.<\/p>\n\n\n\n
In the buttonISR()<\/span> function, before considering a valid pushbutton press, we first check if at least 50 milliseconds have passed since the last press. We get the time that has passed since the program started with millis()<\/span> (in milliseconds) and save it in the now<\/span> variable.<\/p>\n\n\n\n
unsigned long now = millis();\nif (now - lastPressTime > DEBOUNCE_DELAY) {<\/code><\/pre>\n\n\n\nIf yes, we consider that we have a valid button press and we increase the counter<\/span> variable and set the pressed<\/span> variable to true<\/span>.<\/p>\n\n\n\n
counter++;\npressed = true;<\/code><\/pre>\n\n\n\nAfter that, update the lastPressTime<\/span> with the current time.<\/p>\n\n\n\n
lastPressTime = now;<\/code><\/pre>\n\n\n\nTesting the Example<\/h4>\n\n\n\n
Now, if you test this new example, you’ll see you no longer get false positive presses (if you do, increase the debounce delay in your code).<\/p>\n\n\n
\n![\"ESP32:](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/Pushbutton_interrupt_with_debouncing.png?resize=676%2C315&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\n
\n\n\n\nExample 2: ESP32 with a PIR Sensor – Detect Motion with an Interrupt<\/h2>\n\n\n\n
As we mentioned previously, you can also detect events caused by sensors that change their output state when they reach a certain threshold, like for example a PIR Motion sensor.<\/p>\n\n\n
\n![\"PIR](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2025\/10\/PIR-Motion-Sensors.jpeg?resize=750%2C422&quality=100&strip=all&ssl=1\")
Two of the most popular motion sensors used by hobbyists
electronics projects: mini PIR motion sensor (AM312) and PIR motion sensor
(HC-SR501).<\/figcaption><\/figure><\/div>\n\n\nThese sensors output a HIGH<\/span> signal when movement is detected, or a LOW<\/span> signal if no movement is detected. The digital output from the PIR sensor can be read by an ESP32 GPIO pin, allowing you to program specific actions based on the detected motion status. <\/p>\n\n\n\n
Example Overview<\/h3>\n\n\n\n
We\u2019ll create a simple example that will light up an LED when motion is detected. After learning how it works, the same way of thinking can be applied to useful applications, such as sending an email or triggering an alarm.<\/p>\n\n\n
\n![\"ESP32](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2019\/03\/pir-motion-sensor-with-micropython-esp32-esp8266.png?resize=750%2C135&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\nHere’s how the example works:<\/p>\n\n\n\n
- \n
- The sensor detects motion.<\/li>\n\n\n\n
- The ESP32 detects this event.<\/li>\n\n\n\n
- It prints in the Serial Monitor that motion was detected.<\/li>\n\n\n\n
- It turns on an LED for 20 seconds.<\/li>\n\n\n\n
- During those 20 seconds, we don’t print anything else to the Serial Monitor.<\/li>\n\n\n\n
- After those 20 seconds and if motion was not detected, we turn off the LED, print a message to the Serial Monitor indicating that motion has stopped.<\/li>\n<\/ul>\n\n\n\n
Parts Required<\/h3>\n\n\n\n
For this example, you need the following parts:<\/p>\n\n\n\n
- \n
- ESP32 DOIT DEVKIT V1 Board<\/a> or other model of your choice<\/li>\n\n\n\n
- 1x Mini PIR motion sensor (AM312)<\/a> or PIR motion sensor (HC-SR501)<\/a><\/li>\n\n\n\n
- 1x 5mm LED<\/a><\/li>\n\n\n\n
- 1x 220 Ohm resistor<\/a> (or similar value)<\/li>\n\n\n\n
- Jumper wires<\/a><\/li>\n\n\n\n
- Breadboard<\/a><\/li>\n<\/ul>\n\n\n\n
Circuit Diagram<\/h3>\n\n\n\n
PIR sensors have a GND, VCC, and a data line. Connect the GND to the ESP32 GND, VCC to 3.3V, and the data line to an available GPIO. We\u2019ll use the following pins:<\/p>\n\n\n\n
- 1x Mini PIR motion sensor (AM312)<\/a> or PIR motion sensor (HC-SR501)<\/a><\/li>\n\n\n\n
- ESP32 DOIT DEVKIT V1 Board<\/a> or other model of your choice<\/li>\n\n\n\n
- 1x Pushbutton<\/a><\/li>\n\n\n\n
- callback_function<\/span> set the callback function.<\/li>\n\n\n\n
- HIGH<\/span>: to trigger the interrupt whenever the pin is HIGH;<\/li>\n\n\n\n
- Variables that are used inside ISRs and throughout the code should preferably be volatile<\/span>. This prevents the compiler from caching values in registers (and skipping memory access), so reads\/writes always access the actual memory location and reflect unexpected changes caused by the interrupt.<\/li>\n<\/ol>\n\n\n\n
- Timer Interrupts (software timers)<\/strong>: initiated based on time intervals, enabling periodic actions\u2014this is software-based. You can learn more about software interrupts with the ESP32 in this tutorial<\/a>.<\/li>\n<\/ol>\n\n\n\n
- External Interrupts<\/strong>: triggered by external signals and detected on the ESP32 GPIOs, such as a button press or a sensor reading\u2014this is hardware-based and associated with a specific GPIO pin. When the state of a pin changes, it will trigger the interrupt service routine (ISR). We’ll focus on these in this tutorial.<\/li>\n\n\n\n
- Types of Interrupts<\/a><\/li>\n<\/ul>\n<\/li>\n\n\n\n
- What are Interrupts?<\/a><\/li>\n\n\n\n
![\"AM312](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2023\/04\/AM312-PIR-Motion-Sensor.jpg?resize=750%2C422&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2018\/07\/pir_esp32_interrupts.jpg?resize=1024%2C567&quality=100&strip=all&ssl=1\")
<\/figure><\/div>\n\n\n