Dear friends welcome to another Arduino Tutorial. In this video we are going to learn how to
use interrupts with Arduino, an advanced but extremely useful feature of the Arduino. There is a lot to cover, so without any further
delay let’s get started! Hello guys, I am Nick and welcome to educ8s.tv,
a channel that is all about DIY electronics projects with Arduino, Raspberry Pi, ESP8266
and other popular boards. Subscribe to the channel now if you don’t
want miss any future video. In this video we are going to learn how to
use interrupts in our projects by building two simple projects. Be sure to watch until the end of the video
because the trick we use in the second example is very useful for our future projects. But what is an interrupt? Most microprocessors have interrupts. Interrupts let you respond to external events
while doing something else. Suppose you are sitting at home waiting for
the new ESP32 board, you have ordered a few days ago, to arrive at your mailbox. You are very excited so you check your mailbox
every ten minutes to see if the board has arrived. This procedure is called polling, and we were
using this technique a lot in our projects. But what if we had told the mailman to ring
the doorbell at his arrival? This way, we are free to do anything we want
and at the time the board arrives at the mailbox we get notified and we can use it at once. This example explains exactly how an interrupt
causes a processor to act. The Arduino program is running and performing
some function. However, when an interrupt occurs the main
program stops executing and another function is called. When this function finishes, the processor
goes back to the main program again and resumes its execution from the point it was stopped. The function that the processor executes when
an interrupt happened is the ISR, the Interrupt Service Routine. Interrupts can come from various sources. In this video we are going to learn about
hardware interrupts which are triggered by a state change on one of the digital pins. In other words, an interrupt can be triggered
when a digital pin goes from LOW to HIGH or from HIGH to LOW. With most Arduino boards, you can use only
certain pins as interrupts. Interrupts are referred to by an ID number
that correspond to particular digital pin. So, interrupt 0 and an Arduino Uno corresponds
to digital pin 2. The Arduino Uno, the Arduino Nano and the
Arduino pro mini support only two external interrupts, on digital pins 2 and 3. The Arduino Mega supports 6 external interrupts
whereas the ESP8266 chip can support 16 external interrupts. Let’s now see how to use an interrupt on
a digital pin of the Arduino with an example. We are going to use an Arduino Nano which
is actually a small Arduino Uno. You can use an Arduino Uno if you wish, the
code and the connections are exactly the same. In this first example, we are going to build
a simple project in which, each time we press the button, an interrupt will be triggered
and the ISR will change the state of the LED. I have connected the LED to digital pin 13,
and the button to digital pin 2 which supports hardware interrupts. In order to make a digital pin to interrupt
the main Arduino sketch we use the attachInterrupt function. The first argument is the interrupt ID so
if we are using an Arduino Uno, the interrupt 0 corresponds to digital pin 2. The next argument is the function that is
going to be executed when the interrupt is triggered. In other words, this is the ISR function. In this example we name the ISR buttonPressed. The last argument tells the Arduino what triggers
the interrupt. RISING means that an interrupt will be triggered
when the state of Digital Pin 2 goes from LOW to HIGH. We can also use the word FALLING which means
that an interrupt will be triggered when the state of the pin goes from HIGH to LOW. Another option is to use the word CHANGE which
will trigger an interrupt whenever a change in the state of the pin occurs. Now that we have enabled the interrupt, we
need to create the ISR. We can name the ISR buttonPressed. The function checks turns the LED ON or OFF
depending its state. In order to remember the LED state it uses
a Boolean global variable. Each variable the ISR function uses must be
declared as volatile. There are some things to have in mind when
you are writing an Interrupt Service Routine: • Keep it short (This is very important)
• Don’t use delay • Don’t do serial prints
• Make variables shared with the main code volatile So, we have created a very short function,
we don’t use any delays or Serial prints, and we have declared the variable as volatile. We are ready to test the code. As you can see, the code of the project works
as expected. When I press the button, an interrupt is triggered
and the LED goes on or OFF. Our first sketch that uses interrupts is ready! If we check the code once more, we can see
that the loop function is empty! We have a working project with no code in
the loop function. If we wanted to build the same project without
interrupts, we would check the state of the button many times per second in order to detect
any change to its state and the turn the LED on or OFF. This is how we were doing things so far. Now let’s move on to the second project. In this project I am using a PIR sensor to
trigger an interrupt. The PIR sensor works like this. It has only three pin, Vcc, GND and the signal
out pin. When the sensor detects movement, the signal
pin goes from LOW to HIGH and stays on for 10 seconds. If it does not detect any movement in that
10sec period it goes back to LOW. In this example we want to use interrupts
to turn the LED on when a movement is detected, and turn it OFF again when the sensor signal
goes LOW. We are going to use two interrupts. We are going to interrupt once when the state
of the signal from the sensor goes from LOW to HIGH in order to turn the LED on, and we
are going to use another interrupt to turn the LED OFF when the signal from the sensor
goes from HIGH to LOW. We connect Vcc of the sensor to 5V, GND to
GND and the signal pin to digital pin 2, and digital pin 3. Both these pins use hardware interrupts. Now in the code, the first interrupt will
trigger when the signal goes from LOW to HIGH so we use the RISING word. When that happens the turnLEDOn ISR function
will be called. The second interrupt has the id 1 which corresponds
to digital pin 3. We will use the FALLING word as a trigger
and it will call the turnLEDOff function when triggered. The ISRoutines are very simple and short. We just turn the LED on or off. That’s it. The project is ready. We add a command to the loop function in order
to put Arduino to sleep to conserve power. We are using the LowPower library to achieve
that. This command will put Arduino to sleep forever. The interrupts can wake up the Arduino, execute
the ISR function and get back to sleep at once. So, in this example, the Arduino is sleeping
all the time, when it detects motion, an interrupt is triggered so the Arduino wakes up and executes
the turnLEDOn function. When this function has completed its execution
the Arduino goes back to sleep at once! When the signal from the sensor goes from
HIGH to LOW another interrupt is triggered, the ISR function of this interrupts turns
the LED off and the Arduino goes back to sleep. This is great! We don’t waste any time at all. Let’s test the project to see if everything
works as expected. The Arduino is now sleeping and PIR sensor
has not detected any movement. If I place my hand close to the sensor, the
sensor will trigger an interrupt and the Interrupt Service routine for the first interrupt will
turn the LED ON and the Arduino will get back to sleep. If we wait for 10 seconds without moving in
front of the sensor, the output of the sensor will go LOW. The Arduino is going to wake up again in order
to execute the second interrupt service routine which will turn the LED OFF. After the LED is turned OFF the Arduino goes
back to sleep. As you can see we can greatly reduce the power
consumption of our projects with the use of interrupts! This trick is very useful and I am going to
use it a lot in the future to reduce the power consumption of our projects and extend their
battery life. As always you can find the code of both projects
in the description of the video below. That’s it. Now that we have built some simple projects
that use interrupts we can use this very useful feature to more advanced projects. This will allow us to build more complex projects
that use less energy! This video was quick demonstration of how
to use hardware interrupts with Arduino. There are many more things to discuss about
interrupts but what we learned today is what we are going to use the most. I would love to hear your thoughts on interrupts. Are you going to use interrupts in any of
your projects now that you know how they work? Please post your comments below and don’t
forget to like the video if you find useful. Also consider subscribing to the channel and
do click that bell or YouTube might not show you updates as new videos come out. If you are going to be shopping for parts
check out the affiliate links from the video description. That’s it for today, thanks for watching,
I will see you in the next video!
