Professional Documents
Culture Documents
ARIA and Matlab Integration With Applications
ARIA and Matlab Integration With Applications
Supervisor:
Thomas Hellstrm
Abstract
The course Intelligent Robotics at Ume University let, like many other simi-
lar courses, their students explore different algorithms and architectures using real
mobile robots. There is unfortunately no standardized way to interface with robots.
Instead each manufacturer provide software developers kits (SDKs) for their own
products. This is especially troublesome for robotics courses where students should
be able to concentrate on the actual subject and not be forced to spend a lot of time
learning to use complex SDKs and even new programming languages. The course
at the Ume University uses robots from two different manufacturers. Khepera
robots are controlled from Matlab and AmigoBot robots from C++. Most students
are already familiar with the Matlab programming language and feel a bit intimi-
dated by the AmigoBots powerful but complex C++ SDK named ARIA.
This masters thesis project is divided into two parts. The first part describes
the design and implementation of an adapter layer between the ARIA library and
Matlab. This adapter layer allows ARIA-based robots to be controlled directly
from within Matlab without using the C++ SDK directly. In the second part of
this project a full scale SLAM-application is created that explores some important
topics in the robotics field, such as map making and continuous localization.
Contents
1 Introduction 1
1.1 Goal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Report Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3 Adapter Layer 9
3.1 MEX-Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 C++ Classes In MEX-Extensions . . . . . . . . . . . . . . . . . . 9
3.3 The aria_adapter Extension . . . . . . . . . . . . . . . . . . . . . 10
3.4 Extending the Adapter Layer . . . . . . . . . . . . . . . . . . . . 12
3.5 Using the Adapter Layer . . . . . . . . . . . . . . . . . . . . . . 13
3.6 A Sample Program . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.7 Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.8 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.9 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
iii
iv CONTENTS
7 Acknowledgementes 37
References 38
A Programming Tutorial 41
B API Documentation 47
v
List of Tables
vii
Chapter 1
Introduction
The course Intelligent Robotics at Ume University let, like many other similar
courses, their students explore different algorithms and architectures using real
robots. Unfortunately there is no standardized way to interface with robots. In-
stead each manufacturer provide SDKs1 for their own products. This is especially
troublesome for robotics courses where students should be able to concentrate on
the actual subject and not be forced to spend a lot of time learning how to use
different SDKs and even new programming languages.
The course uses two different types of robots: AmigoBots from ActivMedia
and Khepera robots from K-Team. Khepera robots are controlled from Matlab and
AmigoBot robots from C++ or Java. Most students are already familiar with the
Matlab programming language and the dynamic nature makes it very suitable for
the trial and error way of working that is common when experimenting with
robots and algorithms. AmigoBots use an advanced C++ SDK called ARIA. This
SDK is very powerful and well designed but has a prominently steeper learning
curve compared to the rather simplistic Khepera SDK.
1.1 Goal
The goal of this masters thesis project can be divided into two parts:
The first part is to create an easy to use adapter layer between Matlab and
ARIA-based robot. This layer should provide students and other developers with
an easy to use and stimulating developing environment in which a few lines of
Matlab code should be enough to create simple robotics programs.
In the second part, a full-scaled SLAM2 application is developed. The purpose
is to explore important topics within the robotics field such as map making and
continuous localization. This application also serves as a test-framework for the
adapter layer developed in part one. Experiments with this application illustrate
1 Software Development Kit.
2 Simultaneous Localization And Mapping.
1
2 Chapter 1. Introduction
how odometry errors affect map making and how efficient continuous localization
is when dealing with this problem.
1.2 Method
In order to determine the best design and implementation for the adapter layer, the
ARIA and Matlab documentation and API was studied in great detail. Effort was
also made to make sure the resulting API was simple and self-explanatory enough
for new users without extensive training. Furthermore it should have enough simi-
larities with the existing C++ API for existing ARIA developers to feel comfortable
and at home.
Building a SLAM-application required a lot of information searching. Search-
ing for SLAM-related articles using search terms such as localization and map-
ping on CiteSeer3 and Google were the primary sources of information. Besides
searching for and reading articles a lot of time was spent on the actual implemen-
tation and experiments. The algorithms used and the application itself required a
lot of tweaking and testing in order to produce good results.
Chapter 2 Contains a detailed study of the ARIA and Matlab internals in order to
determine the best design of the adapter layer.
Chapter 7 Acknowledgements.
3 http://citeseer.ist.psu.edu/
Chapter 2
This chapter introduces ARIA and Matlab, the two major components involved in
the creation of the adapter layer.
2.1 ARIA
ARIA1 is an open source object oriented interface to ActivMedia mobile robots
(see section 2.2 for a complete list of compatible robots). The interface is imple-
mented as a cross platform2 C++ library. Besides a lot of robot related function-
ality the library also contains wrappers around platform specific functions such as
threading and networking.
The ARIA library is primarily designed for professional developers and is
meant to be used as a solid base for large-scale applications. The library architec-
ture is very flexible so the library can be used by both multi-threaded and single-
threaded applications. ARIA communicates with the robot using either a serial
tether or a TCP/IP connection.
Coordinate System
While a robot navigates in the environment, ARIA always keeps track of the robots
pose using the built in shaft encoders. The robots believed pose can always be
accessed and updated using the getpose and move methods.
The robots pose is expressed as a point on the xy-plane and an angle . When
the robot powers up the initial pose is set to x = 0, y = 0, = 0, and the robot is
looking along the positive x-axis. If the robot rotates +90 degrees (counter clock
wise) it will be looking along the positive y-axis. The x, y position is expressed in
unit of millimeters and the angle in the interval of +-180 degrees counter clock
wise.
1 Active Robotics Interface Application.
2 So far only supported on Linux and Microsoft Windows.
3
4 Chapter 2. ARIA and Matlab
ARIA supports robots of all difference sizes and shapes. The smallest supported
robot is the AmigoBot, it weighs 3.6 kg and is equipped with eight sonar sensors.
On the other side of the spectrum is the PowerBot, the largest supported robot
which weighs 120 kg and is equipped with 28 sonar sensors, laser mapping and a
gripper arm.
Most, if not all robots manufactured by ActivMedia are supported by the ARIA
library, table 2.2 contains a complete list.
ARIA has a large and powerful API [1]. The API contains a set of high-level
functions that allow developers to control the robot using both built-in and user
defined actions3 . ARIA allows programmers to define new actions by subclassing
ArAction and overriding a few class methods. These actions are run in a back-
ground thread allowing the main application thread to deal with other things than
the robots basic behavior.
It is also possible to directly control the robots movements and sensors using a
set of lower-level functions. These functions command the robot to perform differ-
ent tasks such as Give me the range reading from sonar sensor X, Move forward
with velocity Y, etc. ARIA also contains an even lower-level API that allows users
to communicate with and send commands directly to the robots onboard computer,
this approach however requires detailed knowledge about the properitary protocol
used between ARIA and the robot.
Figure 2.1: ARIA API block diagram. Figure taken from the ActivMedia Robotics
Inc web page.
2.4 Matlab
Matlab is a high-level technical computing language developed by MathWorks.
Their goal was to provide engineers and scientists with a more powerful and pro-
ductive environment than was provided by popular programming languages like
Fortran, C and C++ [11].
Matlab is not only a high-level language for technical computing. The Matlab
application is more of a development environment with features like code manage-
ment, interactive tools for iterative exploration, design and problem solving.
The other way around is also possible. Functions written in languages such
as C and Fortran can also be used from within Matlab. This is achieved
6 Chapter 2. ARIA and Matlab
The main reason why people sometimes use MEX-extensions instead of plain
Matlab code is performance. Implementing computationally expensive algorithms
in compiled languages like C/C++ or Fortran sometimes yield significant perfor-
mance improvements.
MEX-extensions are also required when accessing some operating system de-
pendent functions and use external libraries, or when communicating directly with
hardware.
Not thread-safe: The ARIA library can be run both single-threaded and
multi-threaded, but Matlab itself is a strictly single-threaded application.
This means that some of the functionality in the ARIA library will not be
available from within Matlab. Fortunately most of the functionality is still
available for single-threaded applications.
to the operating system. This missing feature might not seem that important
given that Matlabs garbage collection will take care of values no longer
used. Unfortunately this is only true as long as no MEX-extensions are used.
Some MEX-extensions may allocate memory that explicitly has to be freed
in order to avoid memory leaks. This limitation makes it hard to export C++
class instances into Matlab. Chapter 3 presents a (partial) solution to this
problem.
One way communication between a MEX-routine and the Matlab core: The
MEX-API in combination with the single-threaded nature of Matlab makes
it impossible for an extension to notify the main Matlab process of events,
unless Matlab explicitly asks (polls) for them. With this limitation it is not
possible to (from within Matlab) register callback-functions for ARIA to call
when special events like lost contact with the robot occurs.
6 MEX-extensions have a platform specific file type, .dll on Windows and .mexglx on Linux.
Chapter 3
Adapter Layer
This chapter describes the design and implementation of the adapter layer between
ARIA and Matlab. The core of this layer is a single MEX-extension. The Matlab
MEX API [11] is originally designed to make it possible to create and use highly
optimized C/C++ or Fortran versions of individual algorithms and not to expose
an entire C++ API. Fortunately that does not make it impossible. This chapter will
describe how to embed multiple functions in a single MEX-extension.
3.1 MEX-Extensions
Another way to look at MEX-extensions is that a MEX-extension is basically noth-
ing more than a way to pass a Matlab matrix to a C/C++ or Fortran function in a
shared library, and a way for that function to send another matrix back to Matlab.
Matlab contains some additional functionality that allows users to invoke these
extensions just like any other Matlab function-call. The parameters used in this
function-call will be passed to the extensions gateway routine. The gateway can
also return a matrix back to Matlab that will be treated as the functions return value.
9
10 Chapter 3. Adapter Layer
For example the robot class constructor (file @robot/robot.m) only needs to
contain the following Matlab code:
function o = robot(address)
self.cnx = aria_adapter(1, address);
o = class(self, robot);
return
The routine number four in aria_adapter is invoked with the ArRobot instance
identifier as the only parameter. The wrapper function invokes the ArRobot::getPose()
C++ method and converts the pose (position and heading) into a Matlab matrix and
returns it back to Matlab.
void
mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
if (nrhs < 1)
mexErrMsgTxt("At least one rhs argument is required.");
if (mxGetM(prhs[0]) != 1 || mxGetN(prhs[0]) != 1 ||
!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0])) {
mexErrMsgTxt("The first rhs argument has to be a scalar double.");
}
arg1 = mxGetPr(prhs[0]);
fid = (int)arg1[0];
The function table contains one entry for each embedded function wrapper.
Besides the function id and function name every function entry also contains the
correct number of left-hand side (return values) and right-hand side arguments (pa-
rameters) and a pointer to the wrapper function.
Using this information the gateway routine can take care of things such as
verifying that the function id is correct and that the correct number of left and
right hand side arguments are used. If the concept of one MEX-extension for each
routine was used, this code would have to be duplicated in every extension.
functiontable[] = {
{1, "robot_connect", 1, 1, robot_connect},
{2, "robot_disconnect", 0, 1, robot_disconnect},
{3, "robot_setvel", 0, 2, robot_setvel},
{4, "robot_getpose", 1, 1, robot_getpose},
{5, "robot_readsonar", 1, 1, robot_readsonar},
{6, "robot_isleftmotorstalled", 1, 1, robot_isleftmotorstalled},
...
};
from Matlab matrices into the format expected by the C++ method. Afterwards
the ARIA C++ method is invoked and value returned by the method is afterwards
converted back into a Matlab matrix.
static void
robot_getpose(int nlhs, mxArray *plhs[], int nrhs,
const mxArray *prhs[])
{
int rid = get_robot_id(prhs);
ArRobot *robot = cnxTable[rid].robot;
ArPose pose = robot->getPose();
if (nlhs == 1) {
plhs[0] = mxCreateDoubleMatrix(1, 3, mxREAL);
*((double *)mxGetPr(plhs[0])) = pose.getX();
*(((double *)mxGetPr(plhs[0]))+1) = pose.getY();
*(((double *)mxGetPr(plhs[0]))+2) = pose.getTh();
}
}
The Java-equivalent of the above Matlab program would look something like this:
conn.setPort("192.168.100.11", 8101);
robot.setDeviceConnection(conn);
if (!robot.blockingConnect())
{
System.err.println("Could not connect to robot, exiting.\n");
System.exit(1);
}
robot.comInt((short)ArCommands.ENABLE, (short)1);
robot.runAsync(true);
while(robot.isLeftMotorStalled() != true &&
robot.isRightMotorStalled() != true) {
double dir = 0;
for(int i = 0; i<8;i++) {
dir += (robot.getSonarRange(i) - 7500) * weights[i];
}
dir /= 1000;
robot.setVel2(70 - dir, 70 + dir);
}
robot.stopRunning(true);
robot.disconnect();
Aria.shutdown();
}
}
3.7 Performance
The adapter layer introduces almost no overhead. The Matlab statement below
is a crude benchmark that times how long it takes to call the wrapped function
sleep(0) one million times. Running this benchmark on an AMD Duron 1.5Ghz
system estimates the overhead added for one function call by the adapter layer to
be less than 30s. Most of this overhead is probably caused by Matlabs normal
MEX-extension invocation overhead and not by the wrapper itself.
3.8 Limitations
With the ARIA C++ library programmers can control the robots behavior by defin-
ing a set of custom actions. A custom action is created by subclassing ArAction
and overloading a few methods. These actions are run in a separate thread to allow
the programmer to focus on other things.
Unfortunately as outlined in section 2.6 Matlab is a strictly single-threaded ap-
plication and in combination with the unflexible class system makes it impossible
to use or define custom actions from within Matlab. This does however not affect
the possibility to control robots using the ARIA APIs ordinary motion commands.
This chapter covers the theory behind map making and localization.
A mobile robot exploring and mapping an unknown environment generate
maps by accumulating sensor information while exploring the environment. Unfor-
tunately readings from range sensors are only useful for the map making process
if the position of the sensor at the time the reading took place is known. Shaft-
encoders are the most commonly used source of odometry information. However
it usually suffers from both systematic errors like inaccurate wheel measurements,
and non-systematic errors like wheel slippage. These errors cause the odometry
error to quickly accumulate over time. When a robot is not being localized in the
environment, the quality and accuracy of the generated map will be degraded.
17
18 Chapter 4. Map Making and Localization
hit a non-perpendicular surface before the other side. The reflection from that side
of the wave will reach the sonar sensor before the reflection from the center of
the wave. This causes the measured time-of-flight to be shorter, and the object to
appear closer than it actually is [8].
Region 3: The state of elements in this region is unknown because they are
located behind whatever reflected the sonar pulse.
Region 4: Nothing is known about elements outside the sonar sensors field
of view.
4.4. Updating occupancy grids 19
3 Beta
2 R
Figure 4.1: Grid elements are divided into four regions depending on their position
relative to the sonar response. R is the sonars maximum range and is half of the
sensor cone angle width.
Given a range reading, elements in region 2 are more likely to be empty than
elements in region 1. Readings are also more likely to be correct for elements close
to the acoustic axis than elements at the edge of the sonar cone.
Sensor models can be generated in many different ways. Empirical models
are based on interpretations of data collected from experiments. Analytical sensor
models are based on an understanding of the underlying physical properties of the
sensor device.
Many methods exist to convert sensor modes into numerical values and update
occupancy grids. Bayesian sensor fusion is one of the most popular methods [7].
Rr
R +
P(Occupied) = Maxoccupied (4.1)
2
P(Empty) = 1.0 P(Occupied) (4.2)
0.5
Certainty
0.5
1
80
60
40
70 80
20 50 60
30 40
10 20
0
Distance
Figure 4.2: A 3D-representation of the Bayesian sonar sensor model. Notice that
the certainty values are higher close to the sensor position and close to the acoustic
axis.
The variables in the formulas have the following meaning: R represents the
maximum range the sonar sensor can detect, is half of the sensor cone angle
width.
4.5. Localization 21
The effect of the ( Rr
R ) and the ( ) parts of the formulas is that elements
close to the acoustic axis and close to the origin of the sonar pulse get higher
probabilities than elements farther away.
These probabilities are projected onto an occupancy grid at the position and
direction of the sensor, and are merged with the grids existing spatial knowledge
using Bayesian sensor fusion.
The sensor model provides conditional probabilities of the form P(s|H) but the
form P(H|s), the probability that a grid cell is occupied given sensor reading s, is
of more interest when updating an occupancy grid. Bayes rule states that:
P(s|H)P(H)
P(H|s) = (4.5)
P(s|H)P(H) + P(s|H)P(H)
With our sensor model notation it becomes:
P(s|Occupied)P(Occupied)
P(Occupied|s) = (4.6)
P(s|Occupied)P(Occupied) + P(s|Empty)P(Empty)
Where P(Occupied) and P(Empty) probabilities represent the initial uncondi-
tional belief about the state of a grid element. P(Occupied) = P(Empty) = 0.5 is
often used for empty occupancy grids, but could be set to some other values if the
information is available for the environment being mapped.
Using equation 4.5 it is possible to populate an occupancy grid with probability
values from a single sensor reading. With multiple sensor readings the equation
becomes:
P(s1 , s2 , . . . sn |H)P(H)
P(H|s1 , s2 , . . . sn ) = (4.7)
P(s1 , s2 , . . . sn |H)P(H) + P(s1, s2 , . . . sn |H)P(H)
Equation 4.7 has one software implementation problem. It requires the pro-
gram to keep track of all sensor readings while updating an element to be able
to update it in the future. This is problematic because it is not known how many
times each grid element will be updated. Fortunately, clever use of the relation
P(H|s)P(s) = P(s|H)P(H), a recursive version of equation 4.7 can be created:
P(sn |H)P(H|sn1 )
P(H|sn ) = (4.8)
P(sn |H)P(H|sn1 ) + P(sn |H)P(H|sn1 )
With this equation, only the previous grid value P(H|sn1 ) needs to be saved in
order to be able to update the element in the future.
4.5 Localization
For a mobile robot to be able to carry out most tasks, it needs to be able to figure out
its position in the environment. Localization is the process of updating the pose3
3 Position and heading (x, y, )
22 Chapter 4. Map Making and Localization
using sensor readings. J. Gutmann et al. divided the localization techniques into
three different categories [5]:
Behavior-based: behavior-based localization relies on the robots actions in
the environment in order to navigate. For example a Follow-Right-Wall be-
havior can be used to navigate in a maze. Simply inverting that behavior
would allow the robot to find the way back to the start position.
Landmark-based (feature-based): Landmark-based localization works by
identifying landmarks in the environment. Impressive geometrical local-
ization can be achieved using landmark-based localization, the best known
example is probably the GPS satellite system. One major drawback with
landmark-based localization is the requirement of an adequate set of land-
marks in order to work. Landmarks have to be known in advance (like the
GPS satellites) or located while mapping the environment. The overall ef-
fectiveness of this method depends on the effectiveness of the landmark ex-
traction method used.
Dense sensor matching (iconic): Unlike the landmark-based approach, dense
sensor matching does not require the object recognition problem to be solved.
Dense sensor matching uses whatever sensor information is available and at-
tempt to match that information against the environments surface map, the
occupancy grid.
There has been a lot of progress in the field of localization during the last few
years. A lot of different techniques exist. The remaining sections of this chapter
will cover the techniques used by the application described in chapter 5.
tion (CL) (see figure 4.3) technique proposed by Schultz et al. [10, 4, 14] takes
advantage of the fact that positioning errors from shaft encoders usually accumu-
late over time. CL tries to perform small positioning corrections often instead of
large corrections far apart in time.
Continuous localization is an exteroceptive method that builds temporary occu-
pancy grids called short-term maps that contain recent sensor information. Given
that these maps are constructed during a relatively short period of time, it is as-
sumed that they contain relatively small amounts of odometry errors.
A priori knowledge
n
Sensor readings Short-term map Map Registration
k
Shaft encoders pose generator
During each localization, n sensor sweeps are fused into each short term map.
The variable n is a run-time parameter that depends on the environment and the
equipment being used.
When a short-term map contains enough information, an operation called map
registration takes place. The short-term map is matched against the robots a priori
knowledge about the environment, the long-term map. The overall effectiveness
of continuous localization depends heavily on the completeness and correctness of
the robots a priori knowledge. Schultz et al. shows that the odometry error can
be reduced to a constant error if the registration process has access to complete
and correct spatial information [10]. Continuous localization is still effective even
without any initial spatial information. An ordinary occupancy grid simultaneously
updated using map making can also be used. This approach will of course not be as
effective as with complete and correct spatial information, the odometry error, will
slowly accumulate in the long-term map but not at all in the same rate as without
using any localization.
The actual registration process is more complicated than it might appear. The
fact that the short-term map is only a partial map makes it very likely that it will
fit well in more than one place on the long-term map. In order to limit the risk
of false matches the search is limited to k probable poses. The function pose gen-
24 Chapter 4. Map Making and Localization
erator generates a set of k possible poses given the robots believed pose and the
navigation performed during the lifespan of the short-term map.
For each of these k poses the match is performed by overlaying the short-term
map centered over the pose k onto the global map. The match is then scored by
calculating the sum of the difference between every element common to both maps
using for example the following formula:
This chapter summarizes the work done on the second part of this thesis project,
and discusses obtained results and future work.
5.1 SLAM
In the second part of this masters thesis project a SLAM1 application is devel-
oped. This application also serves as a test application for the Matlab adapter layer
developed during the first part of this thesis project.
The SLAM problem tries to answer the following question: Is it possible for
an autonomous vehicle starting at an unknown location in an unknown environ-
ment to incrementally build a map of the environment while simultaneously using
this map to compute the vehicles location? This is a very central problem in
the robotics community. Solving it would allow autonomous vehicles placed in an
unknown environment to build a map using only relative sensor observations, and
then to use this map to navigate around the environment to perform different tasks.
The main advantage of SLAM, is that no previous knowledge (apriori information)
about the environment is required, everything will be accumulated at run time.
The SLAM-application created as a part of this thesis project combines tech-
niques discussed in chapter 4 such as sensor models, occupancy grids, Bayesian
sensor fusion and continuous localization. It is well known that shaft encoders are
not very exact, so using the robots built in shaft encoders as the only source of
odometry information is not good enough to produce maps of reasonable quality.
Continuous localization will be used to compensate for this problem. A number of
tests will be performed, in order to determine how well the continuous localization
technique used in this application, is able to compensate for the odometry error
produced by the robots internal shaft encoders.
25
26 Chapter 5. Full Scale SLAM-Application
5.2 Design
Long-term map
n
Sensor readings Short-term map Map Registration
k
Shaft encoders pose generator
Best matching pose
Obstacle avoidance
Figure 5.1: Block diagram illustrating how map making and continuous localiza-
tion can be combined in a SLAM-application.
ical components are interconnected, and how the short-term map is fused with the
long-term map after each map registration phase. The best matching pose is also
used by pose generator to update the robots position. The process will be described
in more detail in section 5.6.
5.3 Equipment
An AmigoBot robot (figure 5.2) from ActivMedia Robotics Inc. was used to
test this application. AmigoBot is an affordable classroom robot with good mobil-
ity in indoor environment. The robot has the following technical specification:
Six front and two rear rangefinding sonars.
Two 500-tick shaft encoders.
Two wheels with individual motors and a rear caster.
IEEE 802.11b wireless ethernet communication.
The application itself is implemented as a Matlab program, and tested on a
PC running Microsoft Windows XP Professional, Matlab 7 and ARIA 2.1. The
adapter layer developed as a part of this thesis project was used to communicate
with the robot. Appendix C contains the full Matlab source code for both parts of
the application.
room 1 room 2
edges of the rooms creating a closed environment. The edges consists mainly of
wood and metal surfaces but fortunately no glass surfaces, so the risk of specular
reflection (see section 4.1) is somewhat limited. The main difference between the
room configurations is that the first room consists of fairly narrow passages. The
second room on the other hand contains a fairly large open area, section 5.7 ex-
plains what type of problems open areas can cause when it comes to continuous
localization.
5.5 Navigation
The robot was programmed with an avoid-obstacle behavior. This behavior was
implemented using one ArActionConstantVelocity and two ArActionAvoidFront
ARIA actions. Simple avoid-obstacle behaviors are usually poor choices when it
comes to efficient exploration of unknown environments. However this behavior
fitted these rooms configuration quite well and was able to explore the entire room
rather quickly without getting stuck in corners or visiting some regions a lot more
frequently than others.
The applications two-part design imposes one limitation on the choice of nav-
igation behavior. Because the navigation takes place in first part of the application
but the map is generated by the second part, the behavior has to be purely reactive
and can not require access to the long-term map.
Room 1. Room 2.
However the apriori knowledge requirement, is not compatible with the SLAM-
problem. The SLAM-problem explicitly states that an autonomous vehicle should
be able to build a map of an unknown environment. In order to comply with this
requirement, the map registration process used in this application is altered to work
like this:
The long-term map (the map being generated) is initially empty. Each local-
ization starts with an empty short-term map. The short-term map is fused with
sensor readings until it is considered mature (see the short-term map maturity pa-
rameter in section 5.8). The map registration process registers the short-term map
by overlaying it on the long-term map for each of the k poses returned by the pose
generator. The map registration search space parameter determines which poses
the pose generator will return. The difference between the robots believed pose
and the best matching pose is considered to be the odometry error. After the robots
pose has been updated, the short-term map is fused with the long-term map and a
new localization starts with a new and empty short-term map.
30 Chapter 5. Full Scale SLAM-Application
Figure 5.5: This figure illustrates how the sensor model for a single sonar reading
from a wall may look like.
long-term maps current information about that area, which consists of only the
information from the previous short-term maps single sensor reading. This is usu-
ally not enough information for the map registration process to perform an accu-
rate match. A single sensor reading contains for example not enough information
to determine the actual angle of the wall only the presense of an obstacle. This
lack of information might result in an inaccurate registration of the short-term map
and thus introducing additional odometry error into the system. This application
tries to avoid this worst-case senario by making sure every short-term map con-
tains enough information. This is done by measuring short-term map maturity by
the number of actual (in range) sensor readings fused, and not by the map age in
seconds. This will cause a single short-term map to be active longer if the robot
navigates through an open area.
5.8 Parameters
This application contains a set of parameters that all control different aspects of the
application. This section describes these parameters, their effect on the application
and the values found to produce good results.
Map registration search space: The registration process can not match the short-
term map with the long-term map for every possible robot pose. This would
be both too computationally expensive and error prone. The pose generator
function is used to limit the search to k probable poses. It is not easy to
calculate the k most probable poses the robot could have, the robot could
have different odometry errors in all three degrees of freedom (x, y, ) since
the last localization was made. An ideal pose generator function should
probably consider aspects such as current position, current speed and the
movements performed since the last localization when generating the list of
probable poses.
The pose generator function used in this application is fairly simple but ef-
ficient. The function assumes the accumulated odometry error since the last
localization is in the range of 1 grid elements in the xy-plane. The error on
the axis is assumed to be in the range of 3 . With a resolution of 1 grid
element and 1 this yields a total of 63 poses for the registration process to
evaluate during each localization.
Short-term map maturity: The short-term map maturity determines how much
information (sensor readings) to store in each short-term map. The short-
term map maturity can either be measured in age, i.e. the number of seconds
readings are fused into a map before it is considered to be mature, or in
the actual number of (in range) sensor readings fused. Fusing 45 (in-range)
sensor readings into each short-term map was found to be a good setting for
this application.
32 Chapter 5. Full Scale SLAM-Application
Grid Resolution: The short-term map and the long-term map both uses the same
grid resolution. This resolution determines how fine-grained the information
stored in the maps will be. The higher resolution used the more computa-
tionally expensive the application will become. A grid resolution of 35mm
x 35mm was used in these experiments.
Sensor Sweep frequency and vehicle velocity: The sensor sweep frequency and
the vehicle velocity determines the density of the gathered information. Dur-
ing these experiments the robot traveled with an average velocity of 80 mm/s
and collected four full sensor sweeps every second.
5.9 Results
The continuous localization process relies heavily on the accuracy of the long-term
map. However the quality of the long-term map simultaneously depends on the
accuracy of the continuous localization process. The parameters described in sec-
tion 5.8 all control the quality and accuracy of the resulting map, in one way or
another. Besides these parameters, the room configuration and the robot, all affect
the end result. These complex dependencies makes it difficult, or even impossible
to find the optimal parameter settings to use. Figure 5.6 shows the resulting map,
using three different map registration search spaces. One conclusion that can be
made from these maps is, that using a larger search space is not only more compu-
tationally expensive, but can also generate worse results. Using a too large search
space can result in incorrect registration of short-term maps, which results in extra
odometry error being added to the map and robots pose. Similarly, using a too
small search space will stop the continuous localization process from being able
to remove the odometry error introduced by the robots shaft encoders. With the
equipment and room configurations used in this thesis a search space of 1 grid
element and 3 gave the best results.
5.10 Limitations
As mentioned before, continuous localization tries to correct the robots position
by matching the short-term map with the long-term map. The accuracy of this
matching process is crucial to the overall effectiveness. The method works well as
long as the short-term map contains sensor readings from at least one object in the
environment, that is also in the long-term map. This is usually the case if the robot
is equipped with enough sonar sensors and the environment does not contain large
open spaces.
When a robot navigates through large open spaces, sonar sensors will be un-
able to get any readings because all obstacles are out of range and as a result the
short-term map will become empty. The map registration process will be unable
to estimate the odometry error because the short-term map will be overlayed over
5.10. Limitations 33
Room 1 Room 2
an equally empty part of the long-term map and no correction can be performed.
The sonar sensors on the AmigoBot robot can only detect obstacles less than 800
mm away. This means that this approach is most effective in environment where
the robot most of the time will be less than 800 mm away from obstacles.
This chapter summarizes the work and the conclusions that can be drawn from the
two parts this thesis project consists of.
35
36 Chapter 6. Summary and Conclusion
One conclusion that can be made is that continuous localization can be very
useful and vastly improve the quality of generated maps. The technique is effective
both with and without any previous knowledge about the room configuration.
Chapter 7
Acknowledgementes
37
References
[6] M ORAVEC , H., AND E LFES , A. E. High resolution maps from wide angle
sonar. In Proceedings of the 1985 IEEE International Conference on Robotics
and Automation (March 1985), pp. 116121.
39
40 REFERENCES
and Integration for Intelligent Systems, Washington D.C (Dec. 811, 1996),
pp. 705712.
[14] YAMAUCHI , B., S CHULTZ , A. C., AND A DAMS , W. Mobile robot explo-
ration and map-building with continuous localization. pp. 37153720.
Appendix A
Programming Tutorial
The purpose of this ARIA adapter is to provide a simple yet powerful API for Mat-
lab users. Only a few lines of code is required to create a simple robot application.
This tutorial covers topics such as installing the software on your computer,
example programs and troubleshooting. By the time you reach the end of this
tutorial you will be able to install ARIA for Matlab adapter layer on your computer
and write simple Matlab programs that interacts with your ARIA-based robot.
Installation
The installation is quite straight forward and consists of only two steps:
1. Download and install the ARIA distribution from the ActivMedia web-site.
This distribution contains some data files required by the adapter layer. The
installation program will also install the file necessary to use ARIA from
C++ And Java.
2. Extract the zip-archive containing the compiled Aria For Matlab files to
somewhere on your hard-drive, for example to C:\AriaMatlab\
3. In order for this extension to work Matlab must be able to find the @robot-
class directory in the Matlab search path. A new directory can be added to
the search path using the Set Path dialog (see fig A.1) accessible from the
File-menu. Another option is to use the addpath command like this:
addpath c:\AriaMatlab\
Note: The addpath command only affects the currently running Matlab in-
stance and has to be re-run every time Matlab is restarted.
41
42 Chapter A. Programming Tutorial
Figure A.1: The Set Path dialog can be used to tell Matlab where to find the @robot
directory.
Connecting
ARIA communicates with the robots using TCP/IP connections. Each robot is
identified by an ip-address. It is generally a good idea to verify that the robots
ip-address is reachable from the computer running Matlab before trying to use the
adapter layer.
ping <your-robots-ip-address>
If no ping reply is received from the robot when running the above command in
the command prompt please verify your network setup before continuing with this
tutorial.
Before a program can communicate with a robot a TCP/IP connection has to
be established between the ARIA library and the robot. When creating a new robot
instance by calling the robot constructor with an ip-address as the only argument,
a new connection is automatically established.
myrobot = robot(192.168.1.11);
This instance should be passed as the first argument to all class methods to let
ARIA know which robot to send the commands to. At the end of a program it is
good practice to disconnect from the robot. This will stop the robot and disable the
sonar sensors. The following line will disconnect a robot:
disconnect(myrobot);
43
Coordinate System
While a robot navigates in the environment, ARIA always keeps track of the robots
pose using the robots built in shaft encoders. The robots believed pose can always
be accessed and updated using the getpose and move methods.
The robots pose is expressed as a point on the xy-plane and an angle . When
the robot powers up the initial pose is set to x = 0, y = 0, = 0, and the robot is
looking along the positive x-axis. If the robot rotates +90 degrees (counter clock
wise) it will be looking along the positive y-axis. The x, y position is expressed in
unit of millimeters and the angle in the interval of +-180 degrees counter clock
wise.
Examples
This section contains three simple Matlab programs that are using the ARIA adapter
API. Please see appendix B for a complete API documentation.
Example 1 demonstrates how easy it is to implement a simple Braitenberg vehicle.
This avoid obstacle behavior will be repeated until the robot collides with some
object and at least one wheel gets stuck.
weights = [1 1.5 2 -2 -1.5 -1 0 0];
myrobot = robot(192.168.1.11);
for i=1:10
% Move 0.5 meters forward
move(myrobot, 500);
% Wait until the robot has reached the target
while ~ismovedone(myrobot)
sleep(100);
end
44 Chapter A. Programming Tutorial
Troubleshooting
When I try to create a robot instance I get the following error message:
Undefined command/function robot.
Matlab is unable to find the @robot directory in the search path. Please make
sure the directory is added using either the Set Path dialog or the addpath
command.
Every time I try to create a robot instance I get the following error message:
connect failed.
ARIA failed to reach the robot. Please verify that the correct ip-address is
used and that the robot responds to ping.
45
When I call a class method I get the following error message: invalid robot
id.
This happens when calling class methods after disconnecting from the robot.
Calling class methods after disconnecting from a robot is not allowed.
Is there a way to make sure the robot always stops if some unexpected error
happens in my program?
Yes, one way is to use a try, catch statement to make sure the disconnect()
command is always executed:
function myprogram()
myrobot = robot(192.168.1.11)
try
myrealprogram(myrobot)
catch
lasterr
end
disconnect(myrobot)
function myrealprogram(myrobot)
<Put your real program here>
return
Appendix B
API Documentation
The API is basically a subset of the full Aria C++ API that has been slightly mod-
ified to get a more Matlab-like look and feel. Among the changes are the use of
vectors and matrices instead of helper classes like ArPose where feasible.
myrobot = robot(192.168.1.11)
The string argument to the robot constructor is the robots network address. It can
be a hostname or an numerical ip-address. The constructor returns a new robot
instance on success. On failure an exception is raised.
The methods listed in the rest of this section are robot class-methods:
47
48 Chapter B. API Documentation
name: disconnect
arguments: Nothing
returns: Nothing
description: Disconnects from the robot associated with the robot instance.
This function returns resources associated with this instance
back to the operating system. The instance should not be used
after this.
name: setvel
arguments: [x, y, ] (1x3 matrix)
returns: Nothing
description: Sets the velocity for the wheels independently.
name: getpose
arguments: Nothing
returns: [x, y, ] (1x3 matrix)
description: Returns the robots current pose (position and heading).
name: readsonar
arguments: Nothing
returns: 1xn matrix (mm)
description: Returns range readings from all of the robots n sonar sensors.
The readings are returned as a 1xn matrix. Missing values are
indicated with the value 6842.
name: isleftmotorstalled
arguments: Nothing
returns: 1 if stalled else 0
description: Returns the state of the left motor. A return value of 1 indicates
that the left motor is unable to rotate the left wheel, this is
usually indicates that the robot is stuck due to a collision.
name: isrightmotorstalled
arguments: Nothing
returns: 1 if stalled else 0
description: Returns the state of the right motor. A return value of 1 indi-
cates that the right motor is unable to rotate the right wheel,
this is usually indicates that the robot is stuck due to a colli-
sion.
name: lock
arguments: Nothing
returns: Nothing
description: Locks the robot instance. As long as the robot instance is
locked, the ARIA background thread will not update values
such as pose or sonar readings. This function can be used to
collect readings from the robot in a consistent manner.
49
name: unlock
arguments: Nothing
returns: Nothing
description: Unlocks the robot instance. See the lock method.
name: moveto
arguments: [x, y, ] (1x3 matrix)
returns: Nothing
description: Updates the robots idea of its position. Calling this method
will not physically move the robot only update the robots be-
lieved position.
name: cleardirectmotion
arguments: Nothing
returns: Nothing
description: A direct motion command (setvel, move, setheading . . . ) over-
rides ARIA actions. This method clears whatever direct mo-
tion command that has been gives so actions work again.
name: stop
arguments: Nothing
returns: Nothing
description: Stops the robot by setting the wheel and rotational velocity to
0.
name: move
arguments: distance (mm)
returns: Nothing
description: Moves the robot distance mm forward or backward. The is-
movedone method can be used to determine when the move is
completed.
name: ismovedone
arguments: Nothing
returns: 1 if no move command is running else 0
description: Determines if any move command is running.
name: setheading
arguments: heading in degrees
returns: Nothing
description: Rotates the robot to the given heading angle. The isheading-
done method can be used to determine when the rotation is
completed.
50 Chapter B. API Documentation
name: setdeltaheading
arguments: delta heading in degrees (relative to the robots current head-
ing)
returns: Nothing
description: Rotates the robot to the given heading angle. The isheading-
done method can be used to determine when the rotation is
completed.
name: isheadingdone
arguments: Nothing
returns: 1 if no set(delta)heading command is running else 0
description: Determines if any set(delta)heading command is running.
name: setrotvel
arguments: velocity (deg/s)
returns: Nothing
description: Tells the robot to rotate at a certain speed.
name: absolutemaxtransvel
arguments: velocity (mm/s)
returns: Nothing
description: Sets the robots absolute maximum translational velocity. This
serves as an upper limit for the rotvelmax method.
name: absolutemaxrotvel
arguments: velocity (deg/s)
returns: Nothing
description: Sets the robots absolute maximum rotational velocity. This
servers as an upper limit for the transvelmax method.
name: rotvelmax
arguments: velocity (deg/s)
returns: Nothing
description: Sets the maximum rotational velocity. This method controls
how fast motion commands such as setheading and setdelta-
heading will rotate.
name: transvelmax
arguments: velocity (mm/s)
returns: Nothing
description: Sets the maximum translational velocity. This method con-
trols how fast the robot will move while performing move
commands.
name: avoid
arguments: velocity (mm/s)
returns: Nothing
description: Starts a built in avoid obstacle behavior. This behavior is im-
plemented using one ArActionConstantVelocity and two
ArActionAvoidFront ARIA actions.
51
Utility Functions
name: sleep
arguments: time (s)
returns: Nothing
description: Sleep time microseconds using the ArUtils::sleep() function.
Appendix C
part1.m
function save_readings()
r = robot(192.168.100.11);
try
setabsolutemaxrotvel(r, 40);
avoid(r, 80);
save_map(r, 30 .* 16);
catch
lasterr
setvel(r, [0, 0]);
disconnect(r);
return;
end
stop(r);
disconnect(r);
53
54 Chapter C. SLAM Source Code
part2.m
SCALE = 35;
world_size = 300;
world = zeros(world_size, world_size);
world(:,:)= 0.5; % 0.5 = unknown
overlap = 0;
degrees = [0 -1 1 -2 2 -3 3];
off = 1;
while off < length(readings) - overlap
stm_size = 0;
num = 0;
% Determine how many sensor sweeps required to find
% at least 45 in-range readings
while num < 45 && off+stm_size < length(readings)
num = num + sum(readings(off+stm_size,:) < 6000);
stm_size = stm_size + 1;
end
rpos = [];
rstm = [];
rposes = [];
rscore = [];
rdegrees = [];
% Generate LENGTH(DEGREES) different versions of the stm. All rotated
% differently to allow us to correct odometry errors on the theta axis
tic;
for k = 1:length(degrees)
% Start with an empty short time map
stm = zeros(world_size, world_size);
% Everything is unknown
stm(:,:) = 0.5;
for j = 1:stm_size
pos = ceil((pose(off+j,:) ./ SCALE) + (world_size ./ 2) - 40);
% Generate a sensor model
model = sonar_model(readings(off+j,:), pose(off+j,3)+degrees(k));
% Add it to the short term map
stm = bayes(stm, model, pos);
end
% We are only interested in a smaller square of the stm with the first
% robot pose in the center.
margin = 15;
pos = ceil((pose(off+1,:) ./ SCALE) + (world_size ./ 2) - 40 - margin);
stm = stm(pos(1)+1:pos(1)+length(model)+2*margin, ...
pos(2)+1:pos(2)+length(model)+2*margin);
left = off+stm_size-overlap:length(readings);
a = -rdegrees(idx) / 180 * pi; T = [cos(a) -sin(a); sin(a) cos(a)];
pos = [pose(left,1)-pose(off+1,1) pose(left,2)-pose(off+1,2)];
pos = pos * T;
pose(left,1:2) = [pos(:,1)+pose(off+1,1) pos(:,2)+pose(off+1,2)];
pose(left,1) = pose(left,1) + (SCALE .* rposes(idx,1));
pose(left,2) = pose(left,2) + (SCALE .* rposes(idx,2));
pose(left,3) = pose(left,3) + rdegrees(idx);
% Display the short-time-map and the long-term map in two different figures
figure(1);
colormap(gray);
imagesc(stm, [0 1]);
figure(2);
colormap(gray);
imagesc(world, [0 1]);
drawnow;
off = off + stm_size - overlap;
end
% Display a clearer map using some crude image manipulation
figure(3);
colormap(gray);
world(find(world < 0.7)) = 0;
world(find(world >= 0.7)) = 1;
imagesc(world, [0 1]);
for yi = 1:model_size
for xi = 1:model_size
for si = 1:size(sonars, 1)
x = xi - model_size / 2;
y = yi - model_size / 2;
% optimized version of norm()
r = ((x - sonars(si,1))^2 + (y - sonars(si,2))^2)^0.5;
b = abs(atan2(y - sonars(si,2), x - ...
sonars(si,1)) / pi * 180 - sonars(si,3));
while b > 180
b = abs(b - 360);
end
if b > B || r > ranges(si) + TOLERANCE/2
continue
end
if abs(r - ranges(si)) <= TOLERANCE
psn = ((((R - r) / R) + ((B-b) / B)) / 2) * MAXOCCUPIED;
psn = 0.5 * psn + 0.5;
else
psn = (((R - r) / R) + ((B-b) / B)) / 2;
psn = 1 - (0.5 * psn + 0.5);
end
model(xi, yi) = psn;
end
end
end