-
[MUSIC]
-
Hi everyone, my name is Patrick, and I'm a
web developer from Sydney.
-
I've recently been looking into using
JavaScript to control devices such as
-
Arduinos, the Elite Emotion, Ninja Blocks
-
and hopefully very soon this, Pebble
watch.
-
Today I'm gonna be going over the
-
absolute basics of controlling an Arduino
using Node.
-
We're gonna cover connecting up to a
-
computer, getting Node to communicate with
the
-
Arduino, and hopefully, by the very end,
blinking this LED light on and off.
-
I'll be sticking to absolute basics here,
so we're
-
not going to be doing anything too
advanced, hopefully.
-
In future tutorials, I'll go over this and
it gets a little bit more complicated.
-
But, for this one, we're gonna show you
how to get started.
-
So, let's do that and get started.
-
What is an Arduino?
-
A lot of people have read the name online,
or they've heard it
-
mentioned, but they've never actually seen
one in action, so this is it.
-
It's a single board micro-controller
that's
-
open source which basically means that you
-
can control electronics using a platform
that anyone can build and tinker with.
-
The people at Arduino are lovely enough to
have open sourced it, which
-
means that anybody can make their own
Arduino boards that really want to.
-
This one here, in particular, is the
Arduino Uno.
-
It's one of a variety, of different models
-
that the lovely people at Arduino have
released.
-
You can have a whole range of components
-
connected to it, too, like LED light
bulbs, sensors,
-
and even shields, which are things you
kind of
-
stack on top of Arduinos to add more
functionality.
-
This one in particular is a MIDI, shield
which has
-
the ability for, to play sounds, like a
MIDI Keyboard does.
-
-
Node.js is a platform that takes
-
JavaScripts, a scripting language most
commonly used
-
for web pages, unless you're writing up
network applications such as web servers.
-
We'll be using it today, to run a web
server that'll talk to our Aduino.
-
If you haven't used Node.js before, get
started by
-
heading over to Node.js.org, which I'm
showing on screen here.
-
Click that Install button and get it
installed
-
and running on your computer, so that
you'll
-
be able to continue and follow along with
the example code that I'll be putting up.
-
[BLANK_AUDIO]
-
So why Node.js and Arduinos?
-
Why link these two technologies together?
-
Well, one of the strengths of JavaScript
is that there are quite a few APIs
-
out there, which you can join in different
ways to make ideas come to life.
-
Want to develop a robot that takes
-
instructions from your Twitter followers,
or a
-
coffee machine that makes you a different
-
style of coffee, depending on the weather
outside?
-
If you want to add a Leap Motion as an
input
-
device, or feed in data from your Jawbone
or FitBit fitness products.
-
The possibilities are going all the time.
-
And JavaScript is becoming an easy to use
bridge between technologies,
-
because we've got a whole bunch of APIs
we've got access to.
-
And what is Johnny-Five?
-
Johnny-Five, is one of those open APIs
that makes JavaScript such
-
a valuable language to be developing this
sort of thing in.
-
It allows you to control your Arduino
using
-
very similar functions to those that you'd
use
-
if you were programming it just using the
-
Arduino platform that comes with the
Arduino itself.
-
We'll be doing a lot of this stuff in the
-
tutorial that it's explaining here, so
don't worry too much.
-
But you can see, there's a lot of cool
-
things that people have started to make
with it.
-
Wireless Nodebot Kinnect controlled robot
arm, and LCD Running Man.
-
So, you know, the possibilities get pretty
exciting.
-
Okay, to get started we'll need to connect
our, our Arduino to our computer.
-
So, we'll do this by connecting the USB
port to our Arduino.
-
It serves as both the power to the
Arduino,
-
and the way to upload software to our
Arduino.
-
As you can see, once you plug it in,
you'll
-
have the on lights flicker on, which is a
good sign.
-
In this demo today, I'll be doing a really
-
basic example of turning this LED light on
and off.
-
I've already got the jumper leads in where
they should be.
-
So if you need to pause this to be able to
follow along, feel free to
-
pause it now, and put the jumper leads in,
in the way that I've got them.
-
Connecting up the Arduino is pretty
simple.
-
Connect up the green one here, to pin 13
on your Arduino.
-
Then connect up the red one to the 5 volt
pin.
-
And finally we connect up the black one,
to the ground pin.
-
Doesn't really matter about colors, you
can
-
use whatever color jumper wire you'd like.
-
Now that that's all done, we're ready to
go into the software part
-
of the tutorial with what code we've gotta
run, and where to talk to our Arduino.
-
Node application is extremely simple.
-
We've only got two files, an index
JavaScript file and a package Jason file.
-
If you are new to Node the package Jason
file is what we use to provide any details
-
about the application, and what other Node
modules are required for that application.
-
So, to start with, I'll go over this
packaged
-
up Jason file, and show you what's going
on.
-
So, here we've got what the name of
-
our application is in this case, Node in
Johnny-Five.
-
Can name this whatever you'd like, totally
up to you, but keep it all to one word.
-
It doesn't seem to like spaces.
-
It'll start complaining at you, so
definitely stick to one word.
-
We've got a version number.
-
Once again, you can pretty much use any
version
-
number you'd like, really, for simple
basic test applications.
-
I've called it 0.0.1, because really this
application is very,
-
very early stages and isn't going to be
doing too much.
-
So, I'm keeping it at a very early
version.
-
Then the very important thing, which will
definitely prevent
-
our application working with Arduinos is
our dependency section here.
-
This is where we say what other modules we
need,
-
running and in our Node application for
this to work.
-
So, we only need Johnny-Five, which is the
module I was showing earlier.
-
And this here is the version.
-
So, in this case, we want the latest
Johnny-Five version of that module.
-
Basically, we're doing such simple stuff,
just basic turning
-
an LED light on and off, not likely to
change.
-
So, we're gonna assume that, in every
future version of
-
Johnny-Five, it'll be compatible with what
we're gonna be doing here.
-
So, there's no need to really be, specific
on which version we're wanting.
-
Now we'll go on to the index JavaScript
file.
-
Our index JavaScript file contains all
-
of the functionality, but the node
application.
-
So, this pretty much is our note
application
-
in 19 lines, two of which are Console
logs.
-
So, very, very small application here.
-
I'll go through it step by step and
-
explain what everything is and why it's
there.
-
Firstly, we've got our five variable.
-
Our five variable just requires the
Johnny-Five module.
-
Once again, the reason that we've got it
here as well as in the package Jason file,
-
is that we're assigning all of the
different objects and functionality.
-
That we gain from the Johnny-Five module
into this five
-
variable so we can access it throughout
the node application.
-
An example of that is our next line here,
which is board.
-
Our board variable, is creating a new
board
-
object which is part of the Johnny-Five
module.
-
So we're looking into the Johnny-Five
object here, that
-
we've required here, and we're grabbing
the board object.
-
Which is all the part of the Jonny-Five
module.
-
We don't have to worry about any of this.
-
We don't have to really create any of
this.
-
It's all been there.
-
Thanks to the geniuses who have come
before us.
-
Next up, we are declaring a few more
variables that we use later on,
-
so we are declaring the LED variable, and
we are declaring toggle state variable.
-
I'll explain these a bit later on.
-
[BLANK_AUDIO]
-
To begin, look at this here actually.
-
This is an important one because this is
what
-
will come up first, when we run our
application.
-
It's just a console log saying waiting for
device to connect.
-
What that means is that, that will come up
first, as soon as the known application
-
is starts up just to let us know that the
new application is at least running.
-
But we don't know yet whether our Arduino
has
-
connected up, and whether we can talk to
it.
-
What then happens, is, using this baud
variable here that we created.
-
Which is a Johnny-Five board object.
-
We say, on ready, which means, when we've
got
-
the event of ready fired from the board,
which means.
-
The board's pretty faster, sends any sort
of commands and requests to it.
-
We run this function right here, and this
function
-
starts off with a console log saying board
ready.
-
This will just let us know, if we're
watching the console while
-
our node application is running, that the
board is ready to receive.
-
Our request.
-
It also is a good way to devote whether,
or not the board is connected properly.
-
You are doing a board.
-
Next up, we use this LED variable that we
declared earlier, and
-
we create a new LED, once again part of
the Johnny-Five module.
-
We're basically just letting it know that
we've got an LED.
-
At pin 13 which is what we plugged into
earlier.
-
Then we get to the JavaScript bit which
is, we're setting an interval using the
-
JavaScript function which many of you
might
-
be used to if you are JavaScript gurus.
-
Basically set interval means that we're
gonna use this function here, toggle LED.
-
Every 200 milliseconds, and you can play
around with this
-
number if you'd like later on, just to
experiment, and change
-
how often the LED light gonna toggle on
and off,
-
but basically we're gonna say, run this
function every 200 milliseconds.
-
What isn't that function well, the
function here has.
-
Three lines and one life line which is
just there for user reading.
-
Basically we use this variable here,
toggle state,
-
which we set up earlier to be false.
-
And each time toggle LED runs, will change
the value of
-
toggle state from true to false or from
false to true.
-
So, it basically just changes it the
opposite of what it was.
-
Then, if total state is true, we turn our
LED light on, otherwise turn it off.
-
So, basically, we keep changing toggle
state on and off, on and off,
-
in turn, turning our LED light on and off
and on and off.
-
[BLANK_AUDIO]
-
You've.
-
You're following this now and kind of,
-
picturing the function running in your
head.
-
If you'll notice there is nothing that
turns off
-
this LED, so it will theoretically go on
forever continually
-
turning on and off, on and off until we
either
-
disconnect our Arduino or we turn off this
node application.
-
And I'll be showing you how to do that to.
-
Theoretically, you could also include some
other functionality, in the
-
error to turn off the, Intel by clearing
Intel if you'd
-
like to but in this tutorial to keep
things simple,
-
we're just gonna give it to the basics I'm
showing you.
-
This is how you can control the Arduino
from Node, and
-
then you can add as much functionality as
you'd like to.
-
On top of this and have a bit of fun.
-
Now that we have those two files up there
and ready to run our Node application, we
-
do have to make sure those dependencies we
mentioned, are there and available to run.
-
So, what I've done is I've opened up a
tunnel, and I've gone to
-
the same folder that we put those two
files in to prove that to you.
-
I'll just show you there.
-
So, you've got the index JavaScript file,
and our package JSON file.
-
So.
-
How you would usually run a node
application is just Node index.js.
-
And we're gonna attempt to run it.
-
And what we see here is that is says,
cannot find Module Johnny-Five.
-
Which is fair enough.
-
We've told it in the Index JavaScript
file.
-
That there's gonna be a node module called
Johnny-Five and it's gone and looked for
-
it and can't find and it is now very upset
at us for lying to it.
-
So, we need to get it installed.
-
To install it you can use an incredible
package manager called MPM.
-
MPM just runs through your package.jason
file,
-
and installs any dependencies that you've
got listed.
-
If you don't have MPM on your machine just
do a
-
quick Google search for MPM, and install
it on your computer.
-
It's quite a simple process, so I won't
cover it here.
-
So basically, once you've got MPM
installed, you type in MPM space install.
-
And, it will go through looking through
our package Jason file.
-
It also does a nice bunch of warning us,
saying we
-
don't have a few of those that we could
have had.
-
Description I think and a few other ones.
-
So, basically, it's gone through and
installed
-
our modules here so we've got all the
-
Johnny-Five Modules, and all this other
stuff
-
that it deems necessary to run our
application.
-
So now, I'm going
-
to clear this, but before we run our
actual.
-
Application we're gonna need to set up our
Arduino, so
-
that it's able to receive communication
from our Arduino application.
-
To get this communication working between
our Arduino and the computer,
-
we just need to upload a bit of code to
our Arduino.
-
Arduino calls these bits of code sketches.
-
Which you upload and then install onto the
Arduino and then the Arduino knows
-
what it needs to do, In our case we don't
need the Arduino to do too much.
-
Most of our functionality is in Node, all
we need to do is install
-
a bit of code to ensure it understands how
to communicate with the computer.
-
First off, before we install it, if you
haven't used the Arduino software
-
before, double check that your serial port
is pointing to the correct USB port.
-
You might need to do a bit of trial, and
error with
-
this one if you're not sure which USB port
is the correct one.
-
But in my case, it was this TTY USB modem.
-
Do a bit of trial and error to check which
will work
-
if you are having any issues with
uploading your code to your Arduino.
-
Definitely check that setting right there.
-
I've also got the board set up to
-
be Arduino set up to whichever board
[INAUDIBLE].
-
Then top load the sketch.
-
We're going to go to file, examples.
-
And then you'll have this on yours too
-
Fermata, we want the standard Fermata,
sketch here, and
-
this as it says here is a generic protocol
-
for communicating with micro controls,
from software on computer.
-
That is convenient, because that's exactly
what we want to do.
-
We want to communicate from our notes
software
-
to our micro control, which is our
Arduino.
-
So, to upload this to our Arduino, make
sure you've
-
got it plugged into your computer still,
and click upload.
-
It'll compile the sketch.
-
It'll upload it onto the Arduino.
-
And then in a few seconds it should be
done.
-
There we go.
-
So, it's done uploading, which mean's
you've now got
-
the standard Fermata software or a
standard Fermata sketch.
-
On your Arduino, which means we're ready
now, to move on to the
-
next very exciting bit of running our Node
code and communicating with that Arduino.
-
We've got our two files set up.
-
Our index JavaScript which has all the
code for our Node application.
-
We've installed all our dependencies,
using MPM.
-
We've also got our Arduino connected and
-
running the standard Fermata, sketch code;
which means
-
it's now ready to accept all commands that
will come to it from our computer.
-
So, all that's left is to be in our
terminal
-
and type in Node index.js, and when we run
this,
-
we've got our, waiting for device to
connect, message along
-
with a few messages that come from the
Johnny-Five Module.
-
It's found our serial port, which is the
-
USB port that we've got the Arduino
connected to.
-
Your one might be very different to this.
-
Doesn't really matter.
-
The main important thing, is that our
console log
-
that we set up, which said, board ready,
has appeared.
-
And if you turn to face your LED light,
you'll see that it's now flashing.
-
Which is lovely.
-
It means that our code is working.
-
We're sending our commands to the 13th
pin, telling
-
it to turn an LED light on and off.
-
And so it's turning on and off, and on and
off, on and off.
-
Just as we requested it to.
-
The only important question is how do you
get it to turn off?
-
How do you stop it from constantly
running?
-
This note application.
-
If we go back to the terminal here, what
you've gotta do is just press Ctrl C and
-
then Ctrl C again and it'll close the
board and it'll stop that light blinking.
-
If you timed it correctly, the light'll be
off.
-
If you time it slightly differently, the
light will stay on.
-
And that's okay, really.
-
It's not a big deal.
-
If you want to completely turn it off, you
can just unplug the
-
USB from the computer, and it will turn
off all power to your Arduino.
-
It won't harm it in any way.
-
It's just a quick way of getting it to.
-
Stop doing what it was doing that you
really didn't want it to do.
-
And that, my friends, is how you turn a
LED light on and off, and on and off
-
in an infinite loop using node Johnny-Five
and Arduino.
-
If you followed along, you should now have
an
-
LED light, bending to your node
application as well.
-
Good work.
-
This is the basics.
-
There's a lot more to do from here.
-
If you've got any questions, or if there's
anything that
-
I've missed, feel free to get in touch
with me.
-
My name once again is Patrick Catanzariti.
-
I am on Twitter at thatpatrickguy or I've
got a website Patcat.me.
-
So, feel free to get in touch, if you make
anything really cool with Arduinos
-
following up from this tutorial,
definitely get
-
in touch as well, we'd love to see.
-
Thanks for taking the time, to watch, and
I hope you learned something new.
-
See you.
-