Documente Academic
Documente Profesional
Documente Cultură
This
lab
will
teach
you
how
to
set-‐up
serial
communication
between
the
Arduino
and
Matlab.
In
order
to
do
this
you
first
need
code
running
on
the
Arduino
that
will
communicate
with
Matlab.
Arduino
Set-‐‑up:
In
this
section
we
will
install
a
program
onto
the
Arduino
that
will
send
information
to
Matlab.
The
Arduino
and
Matlab
communicate
using
the
I2C
(Inter-‐Integrated
Circuit)Bus.
In
order
to
do
this
you
need
to
import
the
"Wire"
library,
found
here:
https://github.com/arduino/Arduino/blob/master/libraries/Wire
.
This
file
allows
you
to
use
I2C
to
communicate
between
the
Arduino
board
and
Matlab.
You
will
need
both
the
Wire.cpp
and
the
Wire.h
files.
If
you
cannot
directly
download
the
files,
try
copying
the
text
and
putting
it
into
a
text
document.
Then
save
the
documents
as
.h
and
and
.cpp
files.
Once
you
have
downloaded
(or
created)
the
files,
you
will
need
to
put
them
into
the
Arduino
library.
To
find
out
where
the
libraries
are
located,
right
click
on
the
Arduino
program
and
look
at
its
properties
(see
the
screenshot
below).
The
highlighted
address
is
where
the
libraries
are
located.
Figure
1-‐
Screenshot
of
Arduino
properties.
Highlighted
address
shows
location
of
libraries.
Save
the
Wire.cpp
and
Wire.h
files
in
the
library
inside
a
folder
called
Wire.
Once
the
libraries
are
in
place,
you
can
reference
them
from
any
function
or
class
by
using
the
#include
argument.
See
syntax
below.
#include <Wire.h>
Only the .h file needs to be included because it references the .cpp file.
Once
you
have
included
the
required
libraries,
you
are
ready
to
write
the
code
for
the
Arduino.
A
very
basic
example
of
code
that
will
send
the
numbers
0,1,2,3
and
4
continuously
to
Matlab
is
shown
in
Appendix
A.
If
you
want
to
check
the
output
of
this
function
before
sending
the
data
to
Matlab,
comment
out
the
establishContact()
function
and
open
the
Serial
port
(the
magnifying
glass
on
the
top
RH
corner
of
the
file).
You
should
see
the
following
output.
Figure
2-‐
Serial
port
output
when
Arduino
code
in
Appendix
A
is
uploaded
Remember
the
Arduino
needs
to
be
connected
to
the
computer
in
order
to
upload
the
sketch.
If
you
look
at
the
top
of
the
serial
port
screenshot
above,
you
will
notice
it
says
COM8.
That
is
because
this
Arduino
is
connected
to
communication
port
8.
This
port
will
be
different
for
each
Arduino.
To
check
which
COM
port
your
Arduino
is
connected
to,
go
to
Control
Panel
-‐
System
-‐
Device
Manager
-‐
Ports(COM
&
LPT)-‐
Arduino
Uno.
Note
the
example
below
is
connected
to
COM8
which
is
why
COM8
is
used
as
the
connection
port
in
the
code.
Figure
3-‐
Arduino
Uno
COM
connection
port
Now
you
should
have
your
Arduino
properly
connected
and
your
serial
communication
program
running.
Next
it's
time
to
set-‐up
the
Matlab
code.
Matlab
Set-‐‑up:
If
you
simply
want
to
read
raw
data
from
the
Arduino
and
manipulate
it
in
Matlab,
the
code
in
Matlab
is
very
simple.
However,
if
you
want
to
actually
control
the
Arduino
from
Matlab,
the
code
is
more
complicated.
We
will
go
over
this
in
the
next
section.
For
now,
let's
just
look
at
how
to
read
the
five
values
sent
from
the
Arduino
code
(in
Appendix
A)
above.
The
code
required
to
do
this
is
found
in
Appendix
B.
Notice
that
it
creates
a
new
serial
port
connection
which
is
connected
to
COM8.
It
also
defines
the
terminator
as
a
new
line.
This
means
that
Matlab
will
read
data
until
it
sees
a
newline
(println
function
in
the
Arduino)
so
the
data
sets
will
be
separated
by
new
lines.
Since
the
Arduino
runs
in
an
infinite
loop,
the
data
sets
are
also
infinite,
that
is
why
in
this
code
data
is
only
collected
for
five
seconds
(numSec
=
5).
Download this code onto Matlab and hit run. You should see the following in the Command Window.
Figure
4-‐
Command
window
output
when
running
Arduino
communication
function
This
Matlab
program
is
slightly
different
than
a
regular
program
because
it
stores
all
the
variables
declared
inside
the
function
on
the
command
window
workspace.
If
you
type
'v'
into
the
command
window
you
should
see
the
same
output
as
from
the
Arduino
serial
port.
You
do
not
need
to
use
this
type
of
function
to
read
data
from
the
Arduino,
but
it
makes
it
easy
to
see
all
the
data
without
having
to
have
your
function
output
everything.
Now
you
have
set
up
serial
I2C
communication
between
the
Arduino
and
Matlab.
However,
if
you
want
to
make
the
Arduino,
say
turn
on
an
LED
you
would
have
to
alter
the
Arduino
sketch.
The
section
below
shows
you
how
to
directly
control
the
Arduino
from
Matlab.
In
order
to
set-‐up
the
Arduino
communication,
we
will
be
using
object
oriented
Matlab
programming.
The
first
step
is
to
download
the
ArduinoIO
folder.
This
contains
the
'arduino'
class
(in
Matlab)
which
defines
the
arduino
object
and
creates
all
the
functions
that
control
the
Arduino
from
Matlab.
Once
this
is
installed
you
will
be
able
to
control
the
Arduino
directly
from
Matlab
instead
of
having
to
upload
a
different
Arduino
sketch
each
time
you
want
to
modify
the
code.
Right click on the Download Submission button on the top RHS of the screen. Select save file.
Once
it
is
finished
downloading,
open
the
folder.
It
should
contain
2
files:
license
and
ArduinoIO.
Drag
the
ArduinoIO
folder
into
your
Matlab
folder.
It
should
now
appear
on
your
Matlab
file
list
in
grey.
Right
click
on
the
folder
and
select
Add
to
Path-‐Selected
Folders
and
Subfolders
(see
below).
Figure
5-‐
Adding
Arduino
folder
to
Matlab
path
This
folder
contains
all
the
necessary
code
to
control
the
Arduino
from
Matlab,
however
it
does
not
include
I2C
communication.
If
you
want
to
send
data
from
the
Arduino
to
Matlab,
you
will
need
to
download
the
I2C
ArduinoIO
package
found
here:
http://www.mathworks.com/matlabcentral/fileexchange/41602-‐i2c-‐block-‐for-‐arduinoio-‐simulink-‐
package
Once
both
of
those
are
downloaded
we
are
ready
to
begin.
To
control
the
Arduino
from
Matlab,
the
Arduino
needs
to
be
running
the
'adiosrv'
sketch.
This
sketch
can
be
found
in
I2C_read_block_for_ArduinoIO_package
folder
than
you
downloaded
above.
Open
that
sketch
and
upload
it
to
the
Arduino.
Once
you
have
uploaded
this
sketch,
the
Arduino
will
continue
to
run
it
until
a
new
sketch
is
uploaded.
It
enables
Matlab
to
control
the
Arduino
directly
so
you
should
no
longer
need
to
use
the
Arduino
program.
Next,
open
the
install_arduino.m
file
(found
in
the
ArduinoIO
folder)
and
run
it
on
Matlab.
This
installs
the
Matlab
support
package
for
the
Arduino
and
only
needs
to
be
done
once.
The
arduino.m
file
is
the
Arduino
class.
It
initializes
the
arduino
object
that
connects
to
a
specified
port
(COM8
in
this
lab)
and
defines
all
the
functions
required
to
control
the
Arduino.
These
are
the
same
functions
that
are
defined
in
the
Arduino
system
(digitalWrite,
digitalRead,
pinMode
etc),
but
now
they
will
work
from
Matlab.
Since
the
original
arduino.m
file
does
not
have
I2C
communication,
you
will
need
to
replace
your
original
arduino.m
file
with
the
new
arduino.m
file
found
in
the
I2C_read_block_for_ArduinoIO_package
folder.
Now, let's check to see you did that correctly by creating an Arduino object.
Open the Matlab command line and type in the following code:
Example
=
arduino('COM8')
%
This
creates
an
instance
of
the
arduino
object
called
example
which
is
%
connect
to
COM
port
8.
You
should
get
the
following
output
when
you
enter
this
line
into
Matlab
command
window:
Figure
6-‐
Output
when
creating
an
instance
of
arduino
You
can
now
call
any
of
the
functions
defined
inside
the
arduino
object
because
you
have
created
an
instance
of
that
object.
To
reference
those
functions
you
must
use
example.function().
This
is
because
the
function()
exists
inside
example
(your
instance
of
the
arduino
class).
Here
is
some
code
that
will
turn
on
an
LED
if
you
connect
it
to
pin
4
on
your
arduino
(assuming
you
have
already
created
an
instance
of
the
arduino
class
called
example):
>> example.digitalWrite(4,0) %sets pin 4 to LOW which turns off the LED
Object
oriented
programming
is
complicated,
but
once
you
understand
it,
it
can
make
your
overall
code,
much
simpler.
A
class
can
contain
multiple
objects
and
functions
which
makes
it
useful
for
organizing
more
complicated
code.
Think
of
the
class
as
a
car.
The
objects
inside
car
would
be
door,
horn,
steering
wheel
etc.
The
functions
of
car
could
be
accelerate,
decelerate,
stop
etc.
All
those
functions
can
be
called
on
car.
so
to
call
those
functions
you
would
use
the
following
syntax:
Now
let's
assume
that
each
of
the
objects
also
contains
functions.
For
example,
the
horn
object
contains
a
function
called
honk.
To
reference
this
function
we
must
use
the
following
syntax:
Now
that
you
understand
how
classes
work
(hopefully),
let's
create
our
own
class.
We
will
call
it
ArduinoSystem.
It
will
contain
the
arduino
object
as
well
as
a
few
functions
that
we
define.
The
source
code
to
create
the
ArduinoSystem
class
can
be
found
in
Appendix
C.
Fill
in
this
code
so
that
it
contains
3
functions:
LED_ON,
LED_OFF
and
LED_BLINK.
That
turn
on,
turn
off
and
blink
three
LEDs.
Lab
Deliverables
Print
off
the
Matlab
code
of
the
completed
ArduinoSystem
class
as
well
as
a
screenshot
of
the
Matlab
command
prompt
where
you
call
LED_ON,LED_OFF
and
LED_BLINK,
pinMode,
digitalRead
and
digitalWrite.
If
you
are
unsure
about
the
syntax
or
inputs
of
the
functions,
look
in
the
arduino
object
where
they
are
defined.
A
write-‐up
is
not
required
for
this
lab.
Appendix A
Appendix
B
clear% Communications MatLab <--> Arduino
% Matlab file 1 for use with Arduino file 1
clc;
clear all;
v =[];
numSec = 5;
i=0;
t0=tic;
while (toc(t0)< numSec)
i=i+1;
%t(i)=toc(t0);
%t(i)=t(i)-t(1);
v(i,:)=fscanf(s1,'%d,%d,%d,%d,%d');
% must define the input %d or %s, etc. Data is coming in as text (always)
end
fclose(s1);
% if you need precise timing
% you better get it from the
% arduino (see file 2)
catch me
fclose(s1); % always, always want to close s1
end
Appendix
C
classdef ArduinoSystem < handle
%Class called ArduinoSystem that contains an Arduino object and some
%functions that can be used on the arduino object (can also contain
%other objects like motors, sensors etc)
properties
%properties of the class (global variables)
ard %an object called ard
end
methods
%% **************************** CONSTRUCTOR ******************************
%creates an instance of ArduinoSystem called obj
function obj = ArduinoSystem(comPort)
%creates an instance of arduino called ard which exists inside
%obj (an instance of ArduinoSystem)
obj.ard = arduino(comPort);