Tutorial 10 for Arduino Interrupts and Hardware Debouncing Video Lecture

everybody Jeremy Blum here with Arduino
tutorial number 10 sponsored by
element14 this is the last consecutive
video tutorial that I'll be doing I hope
to continue doing more of these in the
future but this is the last one that
I'll be doing on a weekly basis this
week I'm going to be talking about
interrupts on the Arduino now there's
two types of interrupts that you can use
at timer interrupted or Hardware
interrupt Arduino has good libraries
built in to handle hardware interrupts
how our timer interrupts were quite a
bit more difficult I'm not going to
focus on them in this video but if
you're interested in using timer
interrupts for some reason go visit my
blog I made a post a few months ago
about timer interrupts and I have a very
long detailed code example about how you
use them and it's well commented so that
should help you get get you started with
that if you want to use hardware
interrupts that you know you're in the
right place that's where we're going to
start today hardware interrupts are
really great because they allow you to
execute code on the Arduino while still
looking from input from the outside
world so for example you could be
running some code that turns a motor or
something but still look for a button
press that that changes the speed of the
motor or anything like that ordinarily
you'd have to accomplish this by pulling
the button state continuously in the
loop but if you're doing something in
the loop that takes a while like running
a for loop for example then you might
not be able to do that interrupts
handles it by letting you feed something
into a pan their Arduino that's
constantly pulling it and checking it to
see if it changes state and then if it
does it'll execute a subroutine then you
can specify so let's start talking about
the technical details of interrupts now
let's talk about the different kinds of
interrupts of the Arduino supports there
are four in total the first time is low
this means any time an input to the
Arduinos interrupts pin is low it will
keep executing that interrupts function
over and over again usually we don't
want to do this one I've never used it
personally
the next kind is called change this
means it will execute a function any
time the pin changes from high to low or
from low to high so if we have a pin
input that looks like this it'll change
at these three points the next kind is
called rising rising execute a certain
subroutine any time it detects that an
interrupt pin goes
low to high so wouldn't execute here but
it would execute here and here
falling as the exact opposite falling
interrupts execute when an input goes
from high to low just like it does here
and here but it wouldn't execute here
these are the two that we'll use most
commonly especially when you're using a
button input let's not talk about
debouncing I first mentioned - bouncing
in episode 2 of the tutorial series
when we first hook the button up to the
Arduino to control something in the
software we ran into this issue where
when you push a button instead of just
going from low to high it actually jumps
up and down first a little bit before it
settles on a value of 5 volts this is
going to be huge problem in interrupts
because one we can't use the delay
function inside interrupts and delay was
our primary means and software appealing
with this we would just read it and then
delay until after this had passed and
then read it again to get the actual
value but if we can't use delay
functions and interrupts how are we
going to deal with this if we use this
straight up in an interrupt function
we're going to have a problem because
there's several rising edges that occur
here and we only want one rising edge so
what will happen is we'll actually
execute the interrupt function several
times instead of just one which is going
to cause errors in our program the
reason you can't use the delay function
in interrupts is because it depends on
the same timer that's used to handle the
interrupt on the harder we know let's
talk about how we can fix this the
answer is our hardware solution so that
we don't have to use any functions in
the Arduino software
here's what our circuit looked like the
first time we hooked the button up to
the Arduino we had a 10k pulldown
resistor to ground a connection from
that resistor to the pin and a button
that connected from there to 5 volts
when the button was undepressed the pin
was pulled down to ground through the
10k resistor when the button was pressed
it was pulled up to 5 volts through the
button now let's figure out how we can
use a similar setup but do it with a
deep bounce signal coming out this is
the setup we'll use to accomplish a
debouncing in hardware before it ever
gets into the software of the Arduino
first off we're going to change our
pulldown resistor to a pull-up resistor
I'll explain why that is in a minute
we're still going to use a 10k resistor
but
we're going to add a capacitor across
the button I'll also explain that in
just a moment this is an inverting
Schmitt trigger the inverting Schmitt
trigger will smooth out the signal that
we're going to create from this RC
circuit or resistor capacitor circuit
and then invert it back the reason we
use the pull-up resistor is because
we're using an inverting Schmitt trigger
which changes the signal from high to
low and from low to high therefore we
wanted to change the default state from
low default state here to high default
state here and then this will switch it
back to what we want
after we implement this the signal going
in will look like this exactly what we
want for an interrupt awesome but now
let's see why that's happening the
reason behind this circuits ability to
debounce our signal in hardware is
called an RC circuit RC stands for
resistor capacitor and it just means
that we have a resistor and a capacitor
in series so let's take a simple example
here if we have five volts going through
a 10k resistor and a 10 micro farad
capacitor
exactly is set up in the schematic I
just showed you we can find a time
constant called tau time constant equals
the resistance times the capacitance
value the time constants is the amount
of time it takes for the signal to decay
from five volts down to ground there's a
decay time because capacitors store a
charge that means it's going to take a
little while from to go to five volts
down to ground because this holds
charging it if we do this calculation
out we'll see it the decay time is 0.1
seconds more than enough time to allow
the button to be bounced but less than
ordinary human reaction time so if we
now look at this graph here which shows
voltage verse time this explains the RC
constant that I was talking about if I
push the button down right here it's
going to take some time for a ZK from
five volts down to ground you'll see
that the capacitor helps smooth the
bouncing that we saw before but makes it
no longer linear and no longer just drop
straight down now it decays down to
ground when we release the button right
here it will slowly curve back up from
ground to five volts this is also
determined by the RC time constant
now let's add our inverting Schmitt
trigger the environment trigger does two
things the first thing is is it flips
all logic levels one becomes zero and
zero become one but the more important
thing is that it's going to smooth out
this curve it has very certain voltage
points after which it's sets the signal
to it default value so at a certain
point when it hits a certain voltage
decaying here the Schmitt trigger is
going to set it high which is what
happens right here and then the same
thing going back up once it hits a
certain voltage value it'll get set low
so there Schmitt trigger turns this
inverted
into a square wave and that gives us
exactly what we want to go into the
interrupt on the Arduino awesome here's
what the circuit looks like wired up
we're using the same push button as
before here's our 10 micro farad
capacitor and a 10 kilo ohm resistor
this is our inverting Schmitt trigger I
see it actually comes with six inverting
Schmitt triggers in it we're just using
one of them it gets power on the top
right most pin and is connected to
ground on the bottom left most pin this
is a very common configuration for 74
series integrated circuits of which this
is one here's the code that we're going
to be running on this circuit to see if
our hardware debouncing works does it
look familiar it should it's the exact
same code that we ran into toriel 2
before we added software debouncing when
we ran this in tutorial 2 we ran into
all kinds of issues with the not LED not
turning on when it should and not
turning off when it should now we're
using that exact same code that was
prone to error in tutorial 2 and it
should work thanks to our hardware
debouncing in tutorial 10 so let's load
it onto the Arduino and see how well it
works ok now that the software is
downloaded onto the Arduino keep an eye
on this LED which is connected to pin 13
and we'll control with this button as we
set up in the program on-off on-off
works perfectly and we didn't have to do
any software debouncing remember what a
pain that was last time and all we had
to do was add two components to the
circuit awesome now that we know how to
do a button correctly in hardware we can
use it as an interrupt into the circuit
without have
to worry about any bouncing issues so
let's use a switch input into the
circuit to do something interesting and
make a kind of mood color LED chooser
that you control with your hands here's
what we'll need to accomplish this first
off we'll have three different colored
LEDs you can choose a W color you want I
chose yellow red and green these should
be connected to three PWM enabled pins
in the Arduino so you can change their
brightness each one will have a current
limiting resistor of 150 ohms as we
usually do next up I'm going to attach
an infrared distance sensor this is one
that we've used in several tutorials
before it's a sharp infrared distance
sensor it has voltage connection a
ground connection and outputs an analog
value which will attach to analog input
0 on the Arduino lastly we have our D
bounce button input so just like I
showed you before we have our 10k
resistor our 10 micro farad capacitor if
you're using electrolytic capacitor make
sure the negative end goes to ground
because those are polarized and we have
our switch here and our inverting
Schmitt trigger here which then feeds
into pin 2 I've chosen pin 2 because pin
2 is one of the two interrupts enabled
pins on the Arduino
it's interrupt zero so we refer to it in
the program will actually be referring
to zero not - okay great and what this
switch will do is when we push a button
it will change between the LEDs and the
distance sensor will allow us to the
brightness of each LED so you can place
your hand above the distance the
distance sensor to change the brightness
of the LED that's currently selected get
it to brightness you like push the
button and let go the next LED and then
you can set the brightness for that LED
and so you'll be able to set the
brightness for all three LEDs and then
leave them set at that value just by
moving your hand up and down over the
circuit it should be pretty cool so
let's write the code for it I've already
set up a framework for our code let's
start by going through all the comments
that I made and filling in the
appropriate information the first thing
we have to do is choose which interrupt
we're connected to so instead of saying
we're connected to pin 2 we're going to
say we're connected to interrupt 0
because that's really what we care about
so we'll say the button interrupt is to
have the button pin is equal to 0 which
is pin 2 on the
arduino i will just comment that so we
know next when you can figure all the
pins the LEDs are connected to int
yellow LED is connected to 11 int red
LED is connected 10 and green LED is
connected to 9 now I'm gonna do
something interesting here which is
create a fake LED that I'm going to call
null LED the reason I'm doing this is
that we can lock the LEDs to a certain
brightness level because we'll be
scrolling through each of the LEDs to
set their brightness we want to choose
the opportunity to scroll tooling it
doesn't exist so that these stay where
they are without currently flux always
fluctuating with the infrared sensor
you'll see what I mean in a minute when
I implement this and then the last thing
is to set the pin for the distance
sensor int just pin equals 0 analog
input 0 okay now let's set the pin modes
when you set these all these outputs pin
mode red LED is an output pin mode green
LED is also an output yellow LED also an
output and we don't really need set this
well just do it anyway
pin mode null LED and output I just
chose 6 because there's another pwm pin
but doesn't really even have to be a pwm
pin to be honest ok and now let's attach
our interrupt so to do that we use a
command called attach interrupt and we
feed it three things what interrupt or
connected to which we defined earlier is
button and so interrupt 0 a function
that we want to run when the interrupt
is detected and when we want to run the
interrupt so remember I talked about
this earlier in this episode rising we
wanted to tap on the button goes from
low to high which should be perfect
based on the setup of our button where
are connecting to interrupts zero which
is sent by button int and we're going to
run this function called swap whenever
that button is detected and will write
swap in just a moment okay
before we write swap let's write the the
loop here so the loop is just going to
be doing what we want the program to do
whatever led it happens to have selected
at the moment we'll have it change the
brightness based on the infrared
distance value so we've done this before
we'll do list equals analog read the
distance pin well change that to your
brightness by mapping it distance zero
1023 0 255 okay good and then we'll just
have it write that to the LED but gee
how do we know which LED we're currently
on well okay let's put it in and then
we'll make a variable to control it
analog right we'll call it selected LED
and brightness so now you can see
exactly we need to do here we need to
use this swap function to change what
selected LED is so let's define selected
LED up at the top here there's one very
important thing though which is that you
need to define anything that gets
modified by an interrupt function as a
volatile so we put volatile and selected
LED equals let's start it off on the
green LED to begin so what volatile
means is that this integer can
potentially change in the middle of
execution here if you don't define it as
volatile you're going to run into all
kinds of weird things happening ok
perfect that's to do what we want and
we'll start it off as green LED now all
I have to do is write swap so what's
swap should do is every time the button
is pressed it should increment through
the LEDs and change selected LED from
green to red and then red to yellow and
then yellow to null so that it locks the
LEDs on whatever brightness setting we
have them and then from the all black
tea greens that we can do it again
such is going to be a couple of
statements that's free
straightforward right so if selected led
is currently set to green LED remember
we use our double equal sign and if
statements then we'll change it to red
LED and if selected or we can do else if
actually to save us some processing time
else if selected LED equals red LED
we'll change it to yellow else if again
oops I have a spelling error up here huh
else if selected LED I also forgot my
double equal sign hopefully you guys
caught that right and I have a capital S
I'm making yards all over the place here
selected LED equals yellow LED then we
want to change it to null and last but
not least otherwise we'll change it back
to green all right let's just check it
over for mistakes that looks good good
good good good good okay that looks good
and remember you don't actually need
brackets and if you only have one line
of code after an if statement or a while
loop or a for loop
you don't need brackets always okay so
this code looks done now
let's run it on the Arduino and see how
our neat little visualizer works we have
the code on here now so let's see how it
works let's choose a brightness for
green first we can see the brightness
changes with distance pick something
right there okay now it moves to red
will make read a little bit dimmer I
think about there and now we can set
yellow
let's make yellow nice and bright okay
cool and then we press it again and it
goes to that null LED and they're all
set at those levels and then we can of
course go through and change them again
if we want awesome thanks for watching
my tenth Arduino tutorial I hope you
guys enjoyed learning that interrupts
they're really really useful and maybe
you guys got some good ideas from the
project we did today I think you can
make a really cool musical theremin out
of it maybe you guys want to experiment
with that I'd love to see any
suggestions that you guys have or
projects you could work on using that
code that I showed you this is going to
be the last consecutive Arduino video
that I'm making as I mentioned at the
beginning I hope to make more of them in
the future but I can't continue making
them every week during the semester it's
too crazy hopefully I'll be able to do
some written tutorials though and I'll
be able to answer you guys questions if
you have any questions always remember
you can post them on YouTube on my blog
or on element14.com and I will check
them out so thanks again for watching I
really appreciate anyone who watched
through the whole series and all the
people who gave me feedback it was
really spectacular and I really enjoyed
making these because of all the great
feedback I got from you guys so thanks
again and I'll see you soon thanks to
element14 for helping me to sponsor this
video series they were kind enough to
provide a lot of the materials that I'll
be using to create these tutorials
feel free to go visit their website and
element
or team comm check out their community
which is a great place talk to you about
electronics the Arduino and basically
anything else engineering related and
they all have a store where you can buy
a lot of the parts that we'll be using
in these videos