Tutorial 06 for Arduino: Serial Communication and Processing Video Lecture | Arduino Programming: Step by Step (to become an Expert) - Electronics and Communication Engineering (ECE)

hey everybody Jeremy Blum here with my
sixth episode of the Arduino tutorial
series sponsored by element14
congratulations on making it through the
first five if you actually followed
through all of them if you haven't go
back and check them out now because
these are going to start to get a little
bit more difficult now not too bad but I
just want to give you a heads up so for
the next four episodes I'm going to be
talking about different types of serial
communication methods that you can use
with the Arduino this week I'm going to
be talking about specifically just
serial communication between the Arduino
and the computer simple tx/rx serial
communication we're going to use it with
a programming language called processing
which is the language that the order we
know programming environment is based
off of processing is great for drawing
graphics and doing things like that so
we'll experiment with that this week and
next and have the information from the
Arduino control processing and vice
versa and that should be pretty cool
after that in the coming tutorials we'll
move on to I to see SPI and wireless
communication techniques so I hope
you're looking forward to it I certainly
am let's get started with general serial
communication before we actually start
communicating to the computer let's talk
a little bit about how we do this with
the Arduino if you look at the unit
you'll see that there's a TX and rx pin
on digital pins you're on one now you
can use digital pin 0 on one while
you're running your program for input
and output but during programming these
pins are multiplex to be used as the
programming pins for the Arduino the RX
pin is to receive the transmit pin of
the transmit when we call serial
functions in the Arduino programming
language we're using these pins to talk
back and forth between the computer and
the Arduino when you do that you'll
notice that the TX and rx LEDs will
flash to indicate that you're sending or
receiving data the same story holds true
for the Nano here you can see the TX and
rx pins on the Nano the mega is a
different story you'll see that there's
still TX and rx on pin 0 and 1 but
there's also three more serial
interfaces that you can use for
communicating either with other artists
or just any other device that accepts
your communication this comes in useful
later on if you want to be able to
simultaneously program the device and
have it plugged into a separate serial
interface when you plug your Arduino
into the computer via USB you're
actually making a serial connection to
the Arduino you might have noticed that
the universal serial bus or
USB plug on your computer has four pins
on transmit/receive power and ground
just like on the Arduino an important
thing to note is that transmit always
gets hooked up to receive and receive
always gets hooked up to transmit that's
because the receiving line for the
computer is what's being transmitted
from the Arduino the same goes the other
way what's being transmitted from the
computer is received by the Arduino now
serial interfaces operated around plus
and minus 15 volts so in the case of
rs-232 or the interface that serially
uses negative 15 volts actually
represents a logic 1 and positive 15
volts actually represents a logic 0 this
is obviously much different from the 0 &
5 volt TTL or transistor transistor
logic that the Arduino uses to deal with
this a converter chip is using the
Arduino to translate between the two
logic levels you have to worry too much
about this the Arduino takes care of it
for you if in the future you're ever
using an atmega microcontroller directly
you'll have to put in a converter chip
yourself a common example is in Mac's
232 converter to get us started let's
just make a very simple program that we
can use to send one character to the
Arduino and receive that character back
just to confirm that the Arduino got it
and then we can use it to do something
more interesting like controlling LED or
a motor or something
so we'll start our serial session just
like we always do using serial dot begin
and this will allow us to communicate
with the arduino ver your serial 9600 is
the baud rate at which were
communicating the baud rate is just an
indication of the bits per second
basically the communication speed 9600
is a pretty common value to use but you
can use other ones too the first thing
we're going to do is wait until we get
something from the computer and that's
what this while loop is going to do
serial dot available equals zero so what
about what the available function of the
serial class does is it checks to see if
there's something waiting for the
Arduino that we've sent from the
computer if we haven't sent something
it'll just keep looking so it's just
going to stay on this line and keep look
looping through this line until it gets
something from the computer ok once it
does get something we're going to read
it into a variable and we'll just for
now assume that we're sending it in hint
just to make things easy
so we'll do serial dot read which is
going to read our input from that we
sent to
from the screen and we will echo the
output so we'll do serial dot print line
and we'll echo that output back to the
user so we have our Arduino plugged in
via USB on the other end there's nothing
connected to it just the Arduino we just
want to test the serial functionality so
if we send it a 1 we should get a 1 back
what a 49 oh that's weird what happens
if we fix 0 48 huh that's peculiar
ok let's try to look into why we're not
getting the same numbers back that we
send it all right the answer to our
problem lies in data types if you go to
Google and just look up an ASCII table
asci I you'll find something like this
and this breaks down to you the
different types of data types and how
they relate to each other so we're
sending a character or a char and we're
sending a character of 0 or 1 and you'll
notice if you look over here you can see
that the decimal representation of 0 1
is 40 and 49 exactly the numbers that we
were getting ok so here's what our
problem is we're clearly sending this
but telling it it's an integer when
really it's not an integer that we're
sending we're sending it a char which is
really a byte of data it's different so
we need to handle the conversion on the
Arduino end so that we print back out
the right stuff let's go do that there's
actually a very simple way to fix this
assuming you're only going to be
inputting integers from the computer and
this is a are you confused well let me
explain why this is happening the reason
why this fixes it is we're sending in a
char 0 not just a 0 note that the 0 is
in single brackets that indicates it's
of the character type to the Arduino
programming environment
remember we look at the ASCII table and
saw that 0 as a character is represented
as 48 in decimal so if we know that
we're sending it a 0 or 1 or 9 or
whatever through the terminal and we
subtract the char value of 0 and decimal
it will subtract the correct number and
return what the actual integer value is
so for example if we send it a 1 on the
terminal which has a char value of 14 or
a decimal value of 49 and then we
subtract the decimal value of 0 which is
48 we'll get a 1 back this should fix
our problem let's upload it and see what
happens
perfect that's more like it now we're
getting the numbers in that we send to
it okay now let's just
more interesting let's have this control
and LED and report to report back to us
whether or not the LED is on all right
we're just going to use the onboard led
to make this nice and simple for us
we'll set it to LED pin 13 which is the
one that's on the board already remember
we have to set it as an output pin mode
LED pin output okay so we've got our
weight we've got it reading it in and
making it into an integer correctly now
so let's take a look at what we're doing
here I will say if the value that we
read in is equal to one remember you use
a double equal sign and you're checking
for equality if the value is equal to 1
then we will serial dot print line a
nice little message back to the user
that says LED is on okay and let's put
this in brackets and if that's the case
we'll actually we also have to have it
actually turn the LED on of course
otherwise that want to do much do us
much good would it digital right LED pin
high okay and and now we need to check
if the value that we get is a zero so
we'll send a two one turn it on and is
zero to turn it off if Val equals zero
serial dot print line LED is off and you
can have this say whatever you want
digital right led pin and now we'll turn
it off okay make sure we get our
brackets in there okay that looks good
but we need to check one more thing
right you have to make sure that we
check for what happens if it's neither
of those so let's actually make this in
else if statement an else if statement
only bothers to look at this if this one
didn't happen it just makes the code
execution a little bit more efficient
you could have it as an if also but
we'll use an else if it makes a little
bit better and then we'll add in else so
this is what happens if this doesn't
happen and this doesn't happen it'll
execute the else statement and we'll
just have it saved back to the user
serial dot print line invalid so they
know they did something wrong okay and
we don't need to have this echo back
anymore let's see how that works out all
right let's see if this actually works
now something - one LED goes on sale
another one of course it should not do
anything soon - zero LED goes off one on
zero off okay
cool that looks good and you'll notice
that the TX and rx LEDs also blink
because we're sending and receiving data
but now what happens if I sin something
like a V invalid okay good
that does what we want now what happens
if I send a whole bunch of garbage whoa
it printed an invalid for every
character okay it looks like we need to
make one more simple change to our
program to get this doing exactly what
we want the last thing we're going to
add to make sure that we don't get a ton
of invalid inputs when we put in more
than one character is we're going to
flush out the serial buffer and to do
that you just do serial flush some OD
flushing a toilet you're basically just
removing all the garbage anything else
that we don't want gets removed so since
we're only looking for one character
here once we run serial that flush
within this loop it'll get rid of
everything else and then start looking
at new so now we should only see that
invalid problem happened just once let's
upload this and see how it works okay
I'll send it a zero LEDs off one LEDs on
and a bunch of garbage and just one
invalid okay perfect this programs not
doing we want we've got some simple
basic serial communication between the
Arduino in the computer and you can of
course expand upon this and send it all
kinds of different commands do all kinds
of interesting stuff but for now let's
move on to do something a little bit
different
we'll use the Arduino to control the
computer here I have a simple 10k
potentiometer hooked into the Arduino
remember we've used this one time before
you don't actually have to use a
breadboard for this because
we already have all the pins that we
need the red gets hooked into voltage
the black gets hooked into ground and
the green gets hooked into analog input
zero now let's go to the computer and
program it to read the input from the
potentiometer and send it back to the
computer so we can use it in a program
that can read inputs from a serial port
this program is going to be very simple
all it needs to do is get the data and
send it over USB to the computer so
let's define our pot pin to start off
that's where the pot is connected to and
I'll get input zero to our setup
function as we always do start our
serial object because we need that to
both send or receive 9600 and now we're
just going to loop through and keep
checking the value of the potentiometer
the important key here is that you add a
little bit of delay each time because if
you're sending data at 9600 baud that's
a lot and way more than you need and
it's not going to give time for the
analog the analog digital converter on
the Arduino to update fast enough so
we'll start off by reading the value and
mapping it now the reason I'm going to
map this right away is because where
I'll give you a little giveaway here
we're going to used to control the color
of something on the screen and colors
are controlled from 0 to 255 they're
eight bits unlike our analog input which
is ten bits so we read this in and we'll
convert it from a 10 bit number down to
an 8 bit number and we've done this
before remember so we'll go from 0
thousand to 23 to 0 to 255 so what we'll
be doing here is we're just sending the
computer a value between 0 and 255 and
we can use later on do something cool
serial print line remember print line
isn't just for sending as a terminal it
sends it to the computer so we'll print
that Val and I'm going to put a lay of
50 milliseconds should be sufficient you
could actually probably do less than
that like 10 milliseconds but this is
fast enough all right let's get that on
the Arduino and now we're going to write
our processing program to deal with
having that input and doing something
cool okay so we're going to be using a
programming environment called
processing to grab the input over serial
and use it to change a color of
something on the screen processing is
perfect for working with the Arduino
because the Arduino programming language
is actually based off of it so if we
just start processing in Google
processing that is the first thing that
comes up and that's where we want to go
all right so just click on download
processing and just like auger we know
you don't have to install it you just
download the folder and run it right
from there so pop it on your desktop or
wherever you want to put it extract it
and then run processing now our
processing programming environment is
open does it look familiar it should
because the Arduino programming
environment is heavily based off of it
so it should be familiar place for you
start working now I'm not going to go
over all the details of how to use
processing so I don't want to put you
through the terrors of learning an
entirely new programming language but
I'll just give you enough to get you
started you can use basically any
programming language to get input from
over a serial connection processing is
just one example so the first thing
we'll do very similar order we know
we're going to import a serial library
in Arduino serials imported by default
in processing you have to import it but
we've imported libraries in Arduino
before so you should be familiar with
that the next thing we're going to do is
create a serial object that we're going
to call port and I'm going to define an
initial variable called brightness
because we're going to be controlling
the brightness of the color on a screen
and now I'm going to initialize that to
zero this is the value that will be
changing using the potentiometer okay
now just like Arduino we're going to
have a setup portion of our program and
in processing and heavily graphics-based
so one of the things you set up in in
the setup part of the function is the
size of the graphical window that you
want to open so I'll make it 500 pixels
by 500 pixels and now I'm going to
initialize our serial port similarly to
how you do serial dup again in Arduino
it's a little bit different in in
processing but a similar idea we're
going to do port equals new
cereal this because we're running it on
on this class I happen to know that my
comm port is comm three go check what
your comm port is and your computer and
make sure you set up to that if you're
on a Mac it's going to be a little bit
different it's not going to be
represented like comm three same thing
goes for Linux
it'll be like /dev or something like
that and we'll do port dot buffer until
and backslash-n so let me explain what
that is doing umm buffer until is
essentially that same thing as that
while loop that we were running earlier
it's just waiting until it gets
something backslash n is a special
character that indicates a newline so
remember we're doing print line which
prints a carriage return after it sends
you each value every value you get on
the terminal is on a different line if
you remember the thing that tells it to
go to the next line is backslash n which
you can't see but the computer's
terminal program can so we're going to
know when we're getting a new value by
looking for that backslash N and now
we're going to have another thing called
draw and this is what updates the screen
is going to update our little 500 by 500
window and this keeps repeating draw
automatically keeps repeating to update
the screen and all we're going to do is
change the background color to get
started
background zero zero brightness now the
values for this are RGB values so I'm
just going to set the red value to zero
the green value to zero and what we'll
be changing with potentiometer is the
blue value so by brightness basically
what we doing is we'll be turning it
from black up to bright blue which is a
value of 255 okay and now we're going to
look for a serial event this when you
have the serial class running will
automatically check for that serial
event based on the buffer until that we
have specified serial event serial and
remember we named it upper case serial
remember we named our object port
and all we're going to do is we're going
to look for that value and we're going
to say brightness is equal to that value
that we get over the serial port
brightness equals float port dot read
string until and we're going to look for
that backslash n character organics we
want to read up to that and that should
get us our value and all this is doing
is converting that value into a float so
that we can use it in our background
function and that's it let's run this
and see how it works
always make sure you save first and then
you hit this little Run button to run
your processing program I'll turn the
potentiometer up and you can see the
screen gets brighter as I turn it all
the way up to the top the blue value
goes to 55 and I turn it back down and
we're back down to black alright awesome
you just wrote your first program that
sends data from the arduino to
processing you can do a million things
with this and we'll do more with it next
week but for now that should be enough
to get you started and remember you can
always go to the processing website and
look up tons of examples on how to use
it ok and that's our intro to serial
communication with the Arduino next week
I'm going to be talking about I 2c and
then the week after that SPI which are
two other methods for communicating
between the Arduino and integrated
circuits if you have any questions about
anything I did this this week feel free
to post a comment on youtube or an
element 14 or my blog Charlie bloom calm
and as always I'll be posting the source
code including the processing source
code that I use this week up on my
website and I'll have download links all
over the place that you can find that
and that's it I will see you guys next
week thanks a lot for watching 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 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