Tutorial 12 for Arduino: RFID Card Reading Video Lecture | Arduino Programming: Step by Step (to become an Expert) - Electronics and Communication Engineering (ECE)

hey guys Jerry Blum here with another
Arduino tutorial series is episode 12
focusing on Radio Frequency
Identification as always it's sponsored
by element14 and some parts for this
week's episode have been supplied by
cooking - hacks comm and those guys are
great so you should check them out
sorry it's been a little while since the
last video for those of you follow my
blog or on twitter you know that I'm
working at MakerBot industries this
summer so that's been keeping me very
busy it's a lot of fun you should
definitely check it out if you're not
familiar with the company they make
personal 3d printers but it's been a
great time and I'm busy but I'm going to
try to get as many are doing tutorials
out this summer as I can I have a few
suggestions from you guys that I'm going
to try to make happen alright so let's
talk a little bit now about what Radio
Frequency Identification is how works
the physics behind it and then we'll
learn how to read RFID cards and tags
and then we'll use that to make a simple
security system that you can use to bolt
or unbolt the door when someone with an
authenticated tag swiped in alright now
before we actually make an RFID system
using the Arduino let's talk a little
bit about how how RFID works all RFID
systems have two components a master
computer or some kind with database
information relating to the IDs on the
cards all cards have unique global
identification number so you can say
with confidence by looking it up in a
database if you find this ID then it
corresponds to this information so I be
stored in a computer of some kind we'll
be using the Arduino for this purpose
and then there's generally an integrated
circuit that works with the coil that
reads the RFID information so hook up to
that there's a big coil of copper wire
and we'll be playing with one of these
in a minute and that's what we're using
to transmit the RFID information or to
get it from the card rather so on the
other end we're going to have a card of
some kind it's going to be a passport
and ID card just about anything that has
an RFID tag in it
and over here you'll see that your
pricing is before in stores and they
come in DVD boxes and stuff now and
there's going to be another coil that
lays flat like this inside the card and
it mimics the
copper coil that we have on the other
end and then in the middle of the coil
or somewhere else on the card there is
another integrated circuit that stores
information about the identity of that
card so we have the information over
here but key mind there's no power
supply on this card it's entirely
passive so how do we read the
information off there we can't power up
the IC that's what's great about RFID so
what happens here is we send through
electromagnetic induction we're able to
power this and communicate with it we
send a current through this loop over
here the direction that looks something
like that and it goes around the loop
and this creates a magnetic magnetic
field and when you get close enough with
these two things you create something
called electromagnetic induction that
powers this coil and therefore the IC so
what will happen here is this makes a
magnetic field that looks something like
that created by the current in this loop
here and then over on the other end that
will induce a current in these coils
that is sufficient to power the
integrated circuit get the identity
information off of it and transmitted
wirelessly back to the main computer
which has database that can then look up
all the information on it and that's it
that's how it works electromagnetic
induction it's awesome it's the same way
that transformers work so that's our if
I need a nutshell now let's go play with
it okay here's everything we need for
our initial setup I have an Arduino mega
I'm using a mega today just because it's
what I happen to have around you can use
it you know as well I'm going to only
use pins that are available on the whoo
now also an XP shield if you just in the
past talk with our XP radios today
instead of plugging in a radio I plugged
in our RFID tag reading chip from
cooking hacks
don't forget the F change jumpers here
when you're programming or using this as
a serial interface because if you're
using tune all you only have one serial
interface and even on the mega we're
plugging the same serial interface that
we use to program the board via USB and
then I have a few different cards with
different serial numbers on them that
the RFID tag reader can read as well as
some keychain fobs as well that also
have unique serial numbers on them
that we can read and do some simple
security with so let's get our first
program written okay next up we're going
to get our simple program written that
can show us over serial the ID of the
card that we're putting up the rfid
reader now this gets a little
complicated so I've already written a
bunch of it down so let's go through it
the first thing is up here I just have
some variables set that we're going to
use to hold the ID of the card as it
comes in from the reader the important
stuff starts in the setup zero begin
we've done before that's just starting
our serial connection on our Arduino
here though I've set the baud rate to
19200 as opposed to the normal 9600
because this is the rate that the RFID
chip communicates that that's no big
deal the only thing you have to make
sure is when you go to your serum on a
later serial monitor later that you set
the the baud rate correctly so that you
don't get gibberish on the screen okay
here's the potentially confusing part
you can see I'm doing a serial print
here so this will print that information
out to the computer but more importantly
it will print the information to
whatever is connected the serial bus in
which case the XP shield with the RFID
tag later attached so it's going to be
expecting all this data and what all
this data is doing is putting it in the
proper mode you can save since it a
header reserved by length a particular
command this command is what puts it in
Auto read mode some data that goes along
with it
and some blank password information
because we're not going to be using that
right now and then last up is a checksum
that insures it receive the data that it
actually intended to receive so let's
look at how I actually figured out that
command that I'm going to send it's
actually pretty straightforward if you
go to the datasheet it talks about the
serial protocol structure for the RFID
reading chip and if you look at this
table here on page 19 it says exactly
what we need to send it in order to put
it in a particular mode so there's a
header a reserved length command data
and checksum which are the things that I
just showed you so if we want to put in
Auto read mode for example we can go to
the section the datasheet it talks about
Auto read mode in this case it's page 28
and it tells you all the things you need
to fill in to do that so the command for
example is 0 X 87 87 hex that will put
it into automatic read mode
automatic read mode basically just waits
until a car detected and then reports
serial number it's it's very
straightforward and then there's some
data that goes along with it that we
will fill in for our particular setup
and conveniently enough on the next page
there's an example command that does
exactly what we want we're going to be
reading decoded cars we just want to get
the serial number straight off no
password no nothing extremely
complicated and it gives us the exact
command that we used and if you
recognize this these are the exact same
numbers that I just showed in the
Arduino program so you can see that
there's a header just a fixed digit
there the length of the payload is nine
since the amount of data that we're
sending 0 X 87 I just showed you earlier
that's what tells it to enter Auto read
mode and then there's all the settings
for Auto read mode that are particular
to the kinds of cards that we're using
and these are basically the default
values for the password we're not using
a password so we basically just pass
these dummy values checksum is the
addition of all these values in hex that
gives us a value so that we can show
that the data got there properly so
that's that that's that's all the
information that you send in to put into
Auto read mode and that's just right
there literally copied straight out of
datasheet I didn't have to come up with
any of this on my own next we're going
to give it a quick delay to let enter on
a read mode flush the serial buffer
which we've done before put a new line
and tell us on the serial terminal ok
we've started it and we're ready to
start reading some values so how do we
now actually read the values that's
important obviously so the first thing
we're going to do is go back to
datasheet here and see what form we
expect the response to be in and I'm on
page 20 of the datasheet it says exactly
that the response structure for the
commands from the chip back to the host
in which case in our case of the Arduino
and this is what we're going to get back
so we're going to get back header which
is Oh a 0 X F F so this is perfect that
means we can look for that value because
that'll only come in in the header and
it'll say ok when we get that value or
at the beginning of a response from the
chip and we can look however many bytes
in and get our response which will be a
serial number of the card we're
interested in just like before there's a
reserved bit there's a length
the command for the response being sent
back and most importantly the response
which is the data that we're interested
in so we can basically just count
however long these have to be ignore
them and then grab the response which is
the serial number that that five byte
serial number that we actually care
about so if we know that we're looking
for 0xff to come back first then we can
go ahead and look for that so if you
remember for up top I had this value
called Val and we're just going to set
that equal to serial read and serial dot
read is just going to look at the serial
bus and read it one byte at a time as it
comes back from the RFID chip so while
that is not equal to zero x FF we know
that we have to keep looking for a time
when it is so each time around we're
going to read the next bit or the next
byte from the bus until we finally get
one that's what we want and then we'll
exit this while loop and get ready to
look at our data and I'm just going to
put the lane here so it's not reading
constantly every second it's going to
sample data again okay so that looks
good that should get us through the data
and so once it actually gets past this
wall loop here that means you know we
found data we're ready to start reading
some stuff in so let's get rid of the
garbage first every time you do read it
reads in one byte and removes it from
the incoming buffer so we've already
read the header so that's that's gone
and if we look at the data sheet again
we know that after the header there's a
reserved byte length byte in the command
by those are each one byte so we just
have to run the read command once for
each of them to get rid of them because
we don't really care about them so let's
do that
okay so that should take care of our
reserved length and command bytes
now here's data that we want if you
remember earlier I made this data array
that's five long that will hold each of
the bytes of data so into each of these
we're expecting five bytes because we
know that the serial number on all rfid
cards is five bytes long so we can read
this in to our data array by reading in
one byte from the buffer at a time until
we have all the bytes
okay so those are all of our bytes we
now have data one through five into our
array that we can now use and last but
not least we want to read out the
checksum I'm not going to bother
actually checking it I'm going to assume
that we got the data we wanted so we'll
just basically throw that out by reading
it and not do anything with it just for
now it'll make things easier okay so the
next thing that we're going to want to
do here is now that we have this data we
want to identify what the serial number
is on these cards that we have so we can
mark it down and use it in our database
as a security measure to ensure that
they are the cards that we want so I've
already written some of this code here
and so basically what this is going to
do is it's going to once we've found a
card because you know it got past this
while loop and it's read the data and
it's going to say okay I found a card
and it's going to print out the serial
number for it which is stored in this
data right so we'll go through a for
loop like we've done many times before
it'll start at 0 and go up to 4 and for
each one it'll print out the byte that
it found the only important thing to
consider here is if you have a byte
that's greater than in in decimal terms
16 or that's less than 16 then it's only
going to print out one digit and that's
not really what we want so for example
if the byte happens to be 9 it's not
going to print out 0 9 which is what it
should print out it's just going to
print out 9 so it's important that if
it's 16 because we're working with hex
and hex is base 16 we need to print out
a 0 first so that we know the actual
serial number of the device because the
zeros are relevant in that serial number
and you know go ahead and your code and
try commenting this out and see what
happens when you know the 0 and you'll
see that some pieces will be missing and
that's no good so this is perfect it'll
print out thing one after one and then
put a line break when we're done and
then start reading the next chip or the
next card that we pass in front of it so
this should do we want pretty simply
just show us the serial number of the
cards that are detected so let's load
this onto our Arduino and see how it
works alright so the code is loading
onto the Arduino and already
test it out and see how it actually
works so the first thing after I want to
do is to move our jumpers back over I
put them over on the USB pin so I can
program it so those back over to the xB
pins or this serial connector pins on
the xB shield the next thing we'll do is
grab one of our cards and pass it over
the reader you'll see that blanks right
indicating that it's reading and if we
look at the screen we can see that it
found a card great and it lists out the
serial number and it's doing exactly we
wanted to so that's really great now
let's try another card grab this one and
we can see that it finds that one and it
has a different serial number of course
as one would expect it to I mean look at
the tags too and just see what the
serial numbers on each of them and of
course they'll all be different okay
great
so it works and we can grab the serial
numbers off so the thing we're going to
do now is grab the two of the serial
numbers that I want to use for people to
actually gain access to our room or
vault or whatever and put them into the
security system as recognized users so
we'll use the first two that we gathered
for those the ones from the cards and
people with tags won't be allowed access
so let's now program that in so that we
can see who's actually entering by
associating them with a serial number
all right so we have some out some
serial numbers that we want to save in
the system and allow access later on so
now that we have them I wrote them down
from the screen earlier but you should
have done looking at the serial monitor
or not you can go back and read them
again but I'm going to note them down
now and make them into byte arrays here
so I'll allow myself and my brother
David access to the room and I'll note
down the ID numbers for each of our
cards so we can make an array of data
pre-populated so here this is just an
array ready to be populated we can fill
it in with data by using these little
curly brackets here and filling in the
data straight up so in case you're not
familiar with it the 0x and beginning
indicates that we're using hex data
and hex is just a base-16 number
representation so each of these two
digits can be between zero and f where a
b c d e and f are 10 11 12 13 14 and 15
so that you can continue to represent
them in one digit whereas normally you
can't do that with numbers above 9 so
that that's all this that's all that
means
that's because we're representing is
bytes here so we can pass that data in
that I saved as our ID numbers into this
array here let's make sure I have that
right
yep okay so that's mine now let's save
David's and we'll use this to compare to
the data that we're taking it
okay and those are our two serial
numbers that we want to recognize as as
known addresses that we're going to
allow entry to our system okay so now
that we have these saved let's go ahead
and look at where we're actually getting
the serial numbers back from the cards
and we can handle these so that we can
see if they're if they're recognized in
the system so down here where we're
identifying the RFID card we're going to
start off by assuming that it's either
my card or David's card and then as we
go through each byte if it doesn't match
up
we'll say sorry false you're no longer
permitted and this is just a very simple
way to go back doing this so use a
boolean which is just true or false and
we'll call it J card equals true so
we'll assume by default that it is my
card and that it is David's card
obviously though it can't be both
we'll set David's true by default as
well okay so we can go through look if a
card is found now now we'll do is each
time we get our byte of data that we
would normally just print out to the
screen instead of just printing AB we're
going to do a little check here check
the bite so if that byte data I so the
eighth position in the data array if
it's not equal to the Jeremy right at
that same position then we know that it
can't possibly be my card because the
bytes don't match up correctly so we'll
just use a shorthand if statement here
and we'll change this to false so
basically it just has to hit this one so
only one byte has to not match up and
this will be changed to false and then
we'll know that it wasn't me
and we can do the same thing with
David's card here so if data high it's
not equal to David at that same position
then D card will also be false okay so
that's pretty straightforward and then
once we get to the end here in addition
to just printing out the serial numbers
we can say oh hi Jeremy or hi David
depending on who it was and then in the
next step we'll use that as part of our
security system so if J card is still
true then it must have been my card
so we'll serial dot print line hello
Jeremy
so it'll know that it's me because it
has my ID number and then the same thing
goes for David's card
and most importantly our this actually
can be an else--if I guess it'll never
be both of them most importantly you
need to have an else statement because
most the time won't be either of us
there will be some deviants trying to
get into our system so if it's neither
of them we need to do a print line and
say get out of here because they are not
supposed to be in system they are not
recognized serial number and then we'll
just put another blank line after that
to keep the terminal looking clear okay
let's do it don't forget to move your
jumpers back to the usb position and
then hit program and we'll see how that
works
okay so I've programmed it and I move my
jumpers back to the shield position and
now we can read some cards and see if it
actually recognizes them so let's start
off with this one put on the reader and
we can say okay code found so this one
must be David's if I try this guy it
finds it it's Jeremy's alright now most
importantly though let's try one of the
ones that is not on to us and sure
enough yeah get out of here
it doesn't recognize this tag as a valid
ID number in our system so I won't let
us in alright great so now that we have
that signal system down let's go ahead
and expand this and make it a little bit
more complex and add a security aspect
to it here's this schematic that I've
put together for our final system and
this will be available for download of
course on my website so what I want to
do here is a few things first off let's
we're going to add a speaker to the to
the Arduino that will play some tones
based on what IDs were detected so if
the correct idea is tected it'll play
certain tone and if the wrong idea was
detected it will play a drawer kind of
thing like you failed so that's one
thing that we're going to add the next
thing I want to add is a servo so we've
played with a servo before in episode 5
I believe it was so what we'll do here
and what this is perfect I'm not gonna
actually hook it up to a door but a
servo is perfect for because it goes
from 0 to 180 degrees is you can start
in one position and
if you give it the right ID card the
server will open in one position for
five seconds let's say and then closed
again so this is perfect for like
opening a safe or unlocking a door when
you swipe an ID card in front of it so
we'll set that up as well and then the
last thing I want setup is another layer
of security here is implementing the
sleep functionality and the RFID chip so
if you look at the data sheet for the
chip something you find that's very
interesting is that on 1012 of the chip
there's a sleep functionality and if you
keep pin 12 high at a logic 1 or 5 volts
then that chip will fall asleep and what
that means is that it won't be able to
read cards but as soon as you take it
out of that sleep state it'll be able to
read cards again so by adding a push
button here that you have to hold down
in order to activate the RFID tag reader
it's just another layer of security and
it means that it can't accidentally pick
up something someone that's walking by
you have to actively be at the reader
and press the button if you want it to
read your ID card so that map's to pin 5
on the actual breakout board that we're
using so what we'll do here is we'll
have a pull-up resistor 2 5 volts about
1k let's say that goes from pin 5 on our
RFID control board up to 5 volts so by
default we'll have this switch here open
and this pin 5 will basically be
connected up to 5 volts and that'll keep
this in sleep mode and then so to
indicate that what we'll also have here
is um we'll have an LED connected
through a current limiting resistor
although you don't actually need it
because you have this resistor up here
but put in there anyway it doesn't
matter we'll have a red LED there so
when this is when this switch is
unconnected no one's pushing down or
actively trying to use a system this LED
will be connected up to the 5 volts as
well so when there's no one using the
system this red LED will be on
indicating that the system is inactive
when you close the switch it'll Britt
ground first off to the LED and so no
current will flow through the LED so
that LED will turn off indicating that
system is active
a green LED will turn on and that that
LED is located on the actual RFID board
you'll see it in a second and the other
thing that we'll do is when you bridge
that to ground that will overcome the 1k
pull-up resistor that we have to 5 volts
and so it will essentially connect
ground through the switch and we can
follow it around and over to pin 5 on
our board which will bring that into
active mode and allow us to read cards
so here's the finalized system let me
show it to you wire it up and of course
you can download this schematic and a
breadboard image version of the
schematic that's a little simpler to
follow with the video so here's the
system actually wired up here just like
I showed in the schematic the great part
of them the reset switch they talked
about as it requires absolutely no
software to make work it's ready to go
already you can see I have it hooked up
as shown this is the red LED I was
talking about two resistors on the
switch when I hold the switch down the
LED goes off because it gets connected
to ground and the green LED on the RFID
board goes on indicating that it's ready
to read cards so that's all you're ready
to go that's simple the only thing that
we actually have to program in here is
the code for the speaker which I'll show
you how to do in a minute as well as the
Sorbo code that will open and close the
servo based on what tags you read so
let's go take a look at the software and
get our security system set I've gone
ahead and finished up the code here I'll
just walk you through it to save time
all the servo stuff we've done before in
tutorial 5 I've included a steroid adage
here same thing we did last time and
then down below I added Cyril code and
then the speaker is new obviously but
you can learn all about that if you go
to file examples digital and go look at
tone melody I literally just stole it
right out of this file quite shamelessly
I might add so all that you know the the
tone is set up in the Arduino is is it's
sending different frequencies to the
speaker via pulse width modulation the
same thing that we've used to control
motors and LED brightness in the past so
this includes a pitches that h-file
which I stole and that just Maps
frequencies to notes on the scale that
we can then use to make use
and if we look at how they'd use they
set up the speaker here it's relatively
simple they include that file which I
include in - well I copied it over to
the local directory they make a little
melody so this is just an array that has
some notes in it so you just pick the
notes and these are all you know
different sounding notes different
frequencies you put them in order and
then for each of those notes you pick a
duration and if you want a break you
just use a zero instead of an actual
note value from the pitches h-file and
so the way this works here is you know
four is a quarter note eight is an
eighth note etc if you're familiar with
music then you'll understand that and
then all you do is when you actually
want to play the music you put in a
little for loop you have it go through
the total number of notes and for each
note it just figures out the duration
and uses tone which is standard Arduino
function you can read about it on the
Arduino DCC website where it puts it on
pin in this case it's pin eight but will
actually use a variable it grabs that
melody so that frequency that we're
going to use and then the duration which
is what we set in this array up here and
then it just plays it it adds a little
pause between notes and then plays the
next note and is as simple as that so I
literally just stole that file and mash
some notes together until is something
that I thought sounded nice so all I put
here is a little melody for me and for
David and for failure so for the Jeremy
melody it plays one group of notes and
you can see that I have the notes and
the durations there for David I defined
some different notes just different
octave and then for fail you know plays
a little failure noise and it has I have
the note durations for that as well the
other difference in this code is that
I've of course defined what pin the
speaker's hooked up to is pin eight the
Ray resistor and what pin the serve was
hooked up to I have depth to pin nine
and since I'm only using one servo I
didn't bother using an external voltage
source the built-in five volts should be
sufficient and setup you have to add the
servo pin attached so I called the servo
object door lock you can see I created
up here servo door lock and here I
attached it and again this is all from
tutorial five this is all repeat
information
all this is the same you know I still
identify the RFID card check if it's
Jeremy or if it's David and if not it's
false and you know we can print out
success the only difference here now is
instead of just saying on the command
line hello Jeremy we get a little bit
more complicated so if it detects on
Jeremy's card I added this for loop here
that's a you know that goes through the
notes just like I showed from the melody
file that Arduino provides in an example
that just plays my little music same
thing goes for David if it gets David's
it plays the David note
David note setup which I denoted with a
D instead of a J and then last but not
least if it's not recognized it plays
the failure note sound and then of
course we have to worry about the
locking mechanism so if it's either
David's card or my card remember the
double pipes they're mean or so if this
is true or this is true either of us
have access then we'll say to the server
I'll go to 180 degrees wait there for
five seconds and then go back to zero
degrees next should give you enough time
to open the door and then have the lock
return to the initial position and
that's it this is our new code this is
our nice little security system so let's
download it make sure you move the
jumpers to the USB programming position
and we will see our works alright so
we've programmed the system I've moved
the jumpers back don't forget some of
those back or won't work and we're ready
to test out our new RFID based security
system so that's kind of one of the tags
that you know should work this is either
mind
I'm not sure and first off let's just
see if our reset functionality works so
if I hold the card there nothing happens
which is exactly what we would expect
because the RFID tag reader is in the
disabled or sleep position however if I
push this button down the red LED goes
off green LED goes on this is ready to
read I can pass in front of it it leaves
it we get nice little music it turns the
servo to the open position and then it
turns it back closed again and the
serial display on our computer also says
hello Jeremy okay good now let's try one
of the cards that shouldn't work so once
again won't work unless we hold the
button down read it we get a failure
sound and of course the servo does not
open because they are not permitted
entry to the room and cereal says not
recognized get out of here now let's try
David's card hold down the button to
activate the system it plays a different
tone than mine but still success tone it
opens the servo wait three seconds
closes it again and it displays on the
computer hello David we recognize your
number and you're ready to enter so
that's it that's our security system you
can have a lot of fun with this all the
schematics and code and everything are
on my website if you have any questions
you know where to go so have fun I'm
sure you can make some really fun
security systems with this setup thanks
for watching this episode of my are
going to toriel series I hope you guys
enjoyed learning about RFID and if you
come up with any cool projects be sure
send them my way I'll either feature
them on my blog or I just love to see
what you guys are working on with Radio
Frequency Identification
if you have any questions or anything
about this feel free to post it on
element14.com on my blog or on the
comments on this youtube video and all
of the schematics source code parts list
everything is available open source on
my blog Jeremy Blum comm end on element
14 and there's links for all that in the
description of this video so go check
that out have fun and let me know how it
goes I'll see you guys soon with another
tutorial video thanks 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 the
tutorials feel free to go visit their
website at element14.com check out their
community which is a great place to talk
to you about electronics the Arduino and
basically anything else engineering
related and they also have a store where
you can buy a lot of the parts that
we'll be using in these videos