

1


KINODYNAMIC FLIGHT PLANNING OF AEROSONDE UAV
EE
586
Project Report, June 2010
Numan
YAVUZ
(
numanyavuz@gmail.com)
Ferit
ÇAKICI
(feritcakici@yahoo.com.tr)
1.
INTRODUCTION
Unmanned Aerial Vehicles
(
UAVs
)
are multi

purpose robotic systems they have
wide application
spectrum f
rom
weather forecasting, to border and
homeland security operations. In military services;
data acquired through UAVs could be analyzed and
reliable activity information generated, these
information could be used to make battlefi
eld
decisions, resulting in enormous cost reductions. For
the military, UAVs have the potential to collect
intelligence data throughout the day and night from
anywhere in enemy territory, regardless of weather,
and feed the command post. UAVs have capabili
ties
of flying close to the target, long dwell and loitering,
and if provided with low observable capabilities,
these machines could overfly the target even if it is
heavily defended.
It has recently shown that a saving of over $10
million will result
when 15 F

15 pilots are replaced
with equivalent UAVs. Besides, like many other
autonomous robotic systems; UAVs have several
advantages
over
man
ned aircrafts
; having much
greater endurance than manned flights, capable of
responding rapidly and
requiring
l
ess maintenance
cost
s
.
Another area of UAV application is
weather
forecasting
this action
can be more accurate with
respect to satellite based systems.
Also l
ocal climatic
changes can be observed more precisely using
UAVs.
In both cases (military or civ
ilian applications)
there are some common specifications to be held by
UAVs such as; making consistent decisions, acting
rationally plus reasonable cost of action
s
. These
requirements point out
“Machine In
telli
gence” or
“A
rtificial
In
telligence” notion. Th
e A.I. concept offers
several
solution
s for robotic systems to overcome
any kind of problem with sensible ways. The main
goal of UAVs (and other robotic systems) has to be
totally automatic task achievement skill. Very first
step of this issue starts with
sensing the environment
and continue with motion planning. Basically motion
planning is the problem of taking
a
system from a
given starting position (also known as start state) to
a desired goal position (goal state) of course
considering a number of cons
traints. For our UAV
case
,
there is a strong need for a general purpose,
efficient motion planning technique that determines
control inputs to drive UAV from initial configuration
to a goal configuration while obeying physically

based dynamic model of it a
nd avoiding obstacles in
the environment.
There are several different motion planning (or
trajectory finding) techniques in the literature,
Visibility Graph, Approximate Cell Decomposition
,
Voronoi Diagrams,
and Rapidly Exploring Random
Trees (RRTs) are
the most common and widely used
techniques. In the scope of this
study,
these motion
planning techniques tested on a
special UAV
,
“
Aerosonde”
(shown in Figure 1)
;
considering the
physical capabilities of the Aerosonde plus its
kinodynamic constraints.
Fi
gure 1. Aerosonde UAV and its properties.
Endurance
= 14 hrs
,
Wingspan
= 2.9 m
Cruise Speed
=
25 m/s,
MTOW
= 13.1 kg
Ceiling
= 4.
500 m
,
Range
= 3000 km

2

The test environment is design
ed
to reflect
Aerosonde’s real workspace. Aerosonde is utilized in
the Black Sea Region, where the mountains are high
and clouds are dense.
That means; i
t has to follow a
predefined t
rajectory
at
a fixed altitude to collect
visual information
f
rom
the
environment
,
while
avoiding from high mountains and cloudy regions.
Basic path planning methods were mentioned in the
second section in order to inform reader about those
concepts. Then
,
designed testbed and
implementation of the algorithms are explained
i
n the
fourth sect
ion together with the
results of the
simulations and co
mparison between all methods
.
And finally, the last chapter contains conclusion and
propose future work at final se
ction
2.
THEORET
I
CHAL BACKGROUND
A basic motion planning problem is to produce a
continuous motion that connects a start configuration
S and a goal configuration G, while avoiding
collisions with known obstacles
[1]
. The robot and
obstacle geometry is d
escribed in a 2D or 3D
workspace, while the motion is represented as a
path in (possibly higher

dimensional) configuration
space.
2.1. Related Concepts
This section presents a summary of the
definitions of related concepts, going from the most
general t
o more specific.
2.1
.1.
Configuration Space
A configuration describes the pose of the robot,
and the configuration space C is the set of all
possible configurations. For example:
If the robot is a single point (zero

sized)
translating in a 2

dimensiona
l plane (the
workspace), C is a plane, and a
configuration can be represented using two
parameters (x, y) of position.
If the robot is a 2D shape that can translate
and rotate, the workspace is still 2

dimensional. However, C is the special
Euclidean grou
p
SE
(2) =
R
2
x
SO
(2) (where
SO
(2) is the special orthogonal group of 2D
rotations), and a configuration can be
represented using 3 p
arameters (x, y, θ).
If the robot is solid 3D shape that can
translate and rotate, the workspace is 3

dimensional, but C is the special Euclidean
group
SE(3)
=
R
3
SO
(3), and a
configuration requires 6 parameters: (x, y, z)
for translation, and Euler angles (α, β, γ).
If the robot is a fixed

base manipulator with
N revolute joints (and no closed

loops), C is
N

dimensional.
2.
1.
2. Free Space
The set of configurations that avoids collision
with obstacles is called the free space C
free
. The
complement of C
free
in C is called the obstacle or
forbidden region.
Often, it is prohibitively difficult to
explicitly compute the shape of C
free
. Howeve
r,
testing whether a given configuration is in C
free
is
efficient. First, forward kinematics determine the
position of the robot's geometry, and collision
detection tests if the robot's geometry collides with
the environment's geometry.
2.2. Algorithms
Low

dimensional problems can be solved with
grid

based algorithms that overlay a grid on top of
configuration space, or geometric algorithms that
compute the shape and connectivity of C
free
.
Exact motion planning for high

dimensional
systems under compl
ex constraints is
computationally intractable. Potential

field algorithms
are efficient, but fall prey to local minima (an
exception is the harmonic potential fields). Sampling

based algorithms avoid the problem of local minima,
and solve many problems qui
te quickly. They are
unable to determine that no path exists, but they
have a probability of failure that decreases to zero as
more time is spent.
Sampling

based algorithms are currently
considered state

of

the

art for motion planning in
high

dimensional
spaces, and have been applied to
problems which have dozens or even hundreds of
dimensions (robotic manipulators, biological
molecules, animated digital characters, and legged
robots).

3

2.2.1.
Grid

Based Search
Grid

based approaches overlay a grid on
c
onfiguration space, and assume each configuration
is identified with a grid point. At each grid point, the
robot is allowed to move to adjacent grid points as
long as the line between them is completely
contained within C
free
(this is tested with collision
detection). This discr
e
t
esi
zes the set of actions, and
search algorithms (like A*) are used to find a path
from the start to the goal.
These approaches require
setting a grid resolution. Search is faster with coarser
grids, but the algorithm will fail to
find paths through
narrow portions of C
free
. Furthermore, the number of
points on the grid grows exponentially in the
configuration space dimension
which
make
s
them
inappropriate for high

dimensional problems.
Traditional grid

based approaches produce
pa
ths whose heading changes are constrained to
multiples of a given base angle, often resulting in
suboptimal paths. Any

angle path planning
approaches find shorter paths by propagating
information along grid edges (to search fast) without
constraining their
paths to grid edges (to find short
paths).Grid

based approaches often need to search
repeatedly, for example, when the knowledge of the
robot about the configuration space changes or the
configuration space itself changes during path
following. Incrementa
l heuristic search algorithms
replan fast by using experience with the previous
similar path

planning problems to speed up their
search for the current one.
2.2.2.
Geometric Algorithms
Point robots among polygonal obstacles. That is
automated robot trie
s to move goal state avoiding
sets of polygonal obstacles. In the literature the
following methods are widely used;
2.
2.2.1
.
Visib
i
lity Graph
s
In computational geometry and robot motion
planning, a
visibility graph
is a graph of intervisible
locations,
typically for a set of points and obstacles in
the Euclidean plane. Each node in the graph
represents a point location, and each edge
represents a visible connection between them. That
is, if the line segment connecting two locations does
not pass through
any obstacle, an edge is drawn
between them in the graph. To make it clear i
magine
our C

Space containing p
o
l
ygonal obstacles, and as
usual we want to reach the goal state from the start
state. If there is no obstacle, robot can reach the
goal state by fol
lowing the shortest path; a straight
line that connects start state to goal state. On the
other hand if there are several number
s
of obstacles,
visibility graph connects a sequence of straight lines
shaving the corners of obstacles and again
maintains the
shortest path. Typical applications of
visibility graphs are; GPS navigation systems,
placement of radio antennas and urban planning
[3].
Figure
2.
Steps of Visibility Graph algorithm
.
Figure
3.
Typical Visibility Graph Algorithm
examples.
2.
2.2.2
.
C
ell Decomposition Method Approaches
The basic idea behind this method is that a path
between the initial configuration and the goal
configuration can be determined by subdividing the
free space of the robot's configuration int
o smaller
regions called cel
ls
, as shown in Figure 4.
.
After this
decomposition, a connectivity graph is constructed
according to the adjacency relationships between the
cells, where the nodes represent the cells in the free
space, and the links between the nodes show that
the corres
ponding cells are adjacent to each other.
From this connectivity graph, a continuous path, or
channel, can be determined by simply following
adjacent free cells from the initial point to the goal
point. These steps are illustrated below using both
an exact
cell decomposition method and an
approximate cell decomposition method
[4].

4

Figure
4.
Cell Decomposition method
.
C
ell decomposition can be used for path
planning in the following way
:
[5]
1.
The free space of the polygonal two

dimensional configuration s
pace is
determined.
2.
The free space is partitioned into a collection
of cells.
3.
A connectivity gra
p
h is constructed by
connecting the cells that share a common
boundary. (A hole in the bounding polygon
corresponds to a cycle in the connectivity
graph.)
4.
A
sequence of cells that the robot must
traverse in order to go from the start state to
th
e goal state is o
btained from the
connectivity graph.
5.
A free path is constructed with these
sequence
s
of cells.
2.
2.2.2.1
.
Exact Cell Decomposition
The first step
in this type of cell decomposition is
to decompose the free space, which is bounded both
externally and internally by polygons, into trapezoidal
and triangular cells by simply drawing parallel line
segments
from each vertex of each interior polygon in the
configuration space to the exterior boundary. Then each
cell is numbered and represented as a node in the
connectivity graph.
Nodes that are adjacent in the
configuration space are linked in the connectivity
graph. A path in this graph corresponds to a cha
nnel
in free space, which is illustrated by the sequence of
striped cells. This channel is then translated into a
free path by connecting the initial configuration to the
goal configuration through the midpoints of the
intersections of the adjacent cells i
n the channel.
2.2.2.2.2.
Approximate Cell Decomposition
This
approach to cell decomposition uses fixed
area cells. The free space is divided into a grid of
cells. Then, the cells which are completely in the free
space are considered. The solution path
is
determined with an appropriate search algorithm.
2
.
2.2.2.
3
.
Variable
Cell Decomposition
This approach to cell decomposition is different
because it uses a recursive method to continue
subdividing the cells until one of the following
scenarios occur
s:
Each cell lies either completely in free space
or completely in the C

obstacle region
An arbitrary limit resolution is reached.
Figure
5.
Variable Cell Decomposition method
.
Once a cell fulfills one of these criteria, it stops
decomposing.
This
method is also called a
"quadtree" decomposition because a cell is divided

5

into four smaller cells of the same shape each time it
gets decomposed
, as shown in Figure 5
. After the
decomposition step, the free path can then easily be
found by following the a
djacent, decomposed cells
through free space.
2.
2.2.3
.
Voronoi Diagrams
Any position within a specific cell is closer to the
point which generated the cell than any other point in
the diagram. The Voronoi diagram can be very
useful in robot path planni
ng. If the points represent
obstacles in a space, then restricting a robot to
traverse the edges created by the Voronoi diagram
will insure that it is the maximum distance away from
the nearest surrounding points at all times. In short,
a Voronoi diagram r
ecords information about the
distances between sets of points in any dimensional
space. For path planning, Voronoi tends to be used
in two dimensional space, where sets of points all lie
within a plane.
A
plane is divided into cells so that
each cell conta
ins exactly one site. For every point in
the cell, the Euclidean distance of the point to the
site within the cell, must be smaller than the distance
of that point to any other site in the plane. If this rule
is followed across the entire plane, then the
b
oundaries of the cells, known as Voronoi edges, will
represent points equidistance from the nearest 2
sites
.
The point where multiple boundaries meet,
called a Voronoi vertex, is equidistance from its 3
nearest sites
[2]
, as shown in Figure 6
.
Figure
6.
Voronoi Diagram Method
.
The safest route would have the robot move in a
path such that it is as far away from the nearest
obstacles as possible. In order to generate this route,
you would need to first generate the Voronoi diagram
for the room to obtain
the Voronoi edges which
represent the maximum distance between the
nearest objects.
The next step is to then follow the associated
Voronoi edges to the end goal. Finding the optimal
path or even any path to the goal itself requires using
search algorithm
s
.
Drawbacks of the Voronoi Diagram Method:
Not suitable for higher dimensional spaces,
Difficult to construct for arbitrary shaped
obstacles in C

Space,
In some cases noise affects its stability,
small changes in obstacle configuration
changes the V
oronoi Diagram.
May lead very conservative paths.
There are many possible applications for the
Voronoi diagrams: nearest neighbor queries for data
structure problems in computational geometry,
computational morphology such as modeling how
fire spreads a
nd crystals grow, and also business
applications such as determining where to locate a
store so it is no closer to any existing store of its
kind. As stated earlier, Voronoi diagrams can also be
used for path planning. Imagine you have a robot
that needs t
o move through a cluttered room without
hitting any objects.
2.2.3.
Potential Fields
One approach is to treat the robot's configuration
as a point in a potential field that combines attraction
to the goal, and repulsion from obstacles. The
resulting tra
jectory is output as the path. This
approach has advantages in that the trajectory is
produced with little computation. However, they can
become trapped in local minima of the potential field,
and fail to find a path. More in detail;
t
he potential
field me
thod involves modeling the robot as a
particle moving under the influence of a potential
field that is determined by the set of obstacles and
the target destination. This method is usually very
efficient because at any moment the motion of the

6

robot is det
ermined by the potential field at its
location. Thus, the only computed information has
direct relevance to the robot's motion and no
computational power is wasted. It is also a powerful
method because it easi
ly yields itself to extensions.
For example, si
nce potential fields are additive,
adding a new obstacle is easy because the field for
that obstacle can be simply added to the old one
, as
shown in Figure 7
.
Figure
7.
Potential Field Method
.
The method's only major drawback is the
existence of local
minima
s
. Because the potential
field approach is a local rather than a global method
(it only considers the immediate best course of
action), the robot can get "stuck" in a local minimum
of the potential field function rather than heading
towards the glob
al minimum, which is the target
destination. This is frequently resolved by coupling
the method with techniques to escape local minima,
or by constructing potential field functions that
contain no local minima.
2.2.4. Sampling

Based Algorithms
Sampling

based algorithms represent the
configuration space with a roadmap of sampled
configurations. A basic algorithm samples N
configurations in C, and retains those in C
free
to use
as
milestones
. A roadmap is then constructed that
connects two milestones P and
Q if the line segment
PQ is completely in C
free
. Again, collision detection is
used to test inclusion in C
free
. To find a path that
connects S and G, they are added to the roadmap. If
a pa
th in the roadmap links S and G
, the planner
succeeds, and returns t
hat path. If not, the reason is
not definitive: either there is no path in C
free
, or the
planner did not sample enough milestones.
These algorithms work well for high

dimensional
configuration spaces, because unlike combinatorial
algorithms, their runnin
g time is not (explicitly)
exponentially dependent on the dimension of C.
They are also (generally) substantially easier to
implement. They are probabilistically complete,
meaning the probability that they will produce a
solution approaches 1 as more time
is spent.
However, they cannot determine if no solution exists.
Given basic
visibility
conditions on C
free
, it has
been proven that as the number of configurations N
grows higher, the probability that the above algorithm
finds a solution approaches 1 exp
onentially. Visibility
is not explicitly dependent on the dimension of C; it is
possible to have a high

dimensional space with
"good" visibility or a low dimensional space with
"poor" visibility. The experimental success of
sample

based methods suggests th
at most
commonly seen spaces have good visibility.
There are many variants of this basic scheme:
It is typically much faster to only test
segments between nearby pairs of
milestones, rather than all pairs.
Nonuniform sampling distributions attempt to
p
lace more milestones in areas that improve
the connectivity of the roadmap.
Quasirandom samples typically produce a
better covering of configuration space than
pseudorandom ones, though some recent
work argues that the effect of the source of
randomness i
s minimal compared to the
effect of the sampling distribution.
If only one or a few planning queries are
needed, it is not always necessary to
construct a roadmap of the entire space.
Tree

growing variants are typically faster for
this case (single

query
planning). Roadmaps
are still useful if many queries are to be
made on the same space (multi

query
planning)
2.3. RAPIDLY EXPLORING RANDOM TREES
(RRTs)
2.3.1 Overview of RRT
Formally speaking; A Rapidly

exploring Random
Tree (RRT) is a data structure a
nd algorithm
designed for efficiently searching non

convex, high

dimensional search spaces. Simply put, the tree is
constructed in such a way that any sample in the
space is added by connecting it to the closest
sample already in the tree.
RRTs are constru
cted

7

incrementally in a way that quickly reduces the
expected distance of a randomly

chosen point to the
tree. RRTs are particularly suited for path planning
problems that involve obstacles and differential
constraints (non

holonomic or kinodynamic). RRTs
can be considered as a technique for generating
open

loop trajectories for nonlinear systems with
state constraints. An RRT can be intuitively
considered as a Monte

Carlo way of biasing search
into largest Voronoi regions. Some variations can be
considered
as stochastic fractals. Usually, an RRT
alone is insufficient to solve a planning problem.
Thus, it can be considered as a component that can
be incorporated into the development of a variety of
different planning algorithms
[7]
.
2.3.2. R
R
T Operation:
As it is mentioned in overview; the fundamental
operation used in growing an RRT is the Extend
operation
depicted in
Figure 8
.
Given a target
configuration (randomly selected or not), a distance
metric defined on the configuration space is used to
calculat
e the node q_near in the existing tree that is
nearest to a target configuration q_target. If the
distance to the target configuration is less than the
parameter e (the RRT step size), then the algorithm
attempts to grow a new branch connecting directly to
q_target. Otherwise, an intermediate node q_new is
generated at a distance of e along the straight line
between q_near and q_target. That is;
a
t each step
of RRT

building, a random point is selected in the
configuration space, with some bias toward the go
al
configuration. The nearest node in the tree is found,
and a path is created from it toward the random
point, either for a set distance or until an obstacle is
encountered, whichever comes first. The final
collision

free configuration on this path is ad
ded to
the tree [
8
].
2.3.3. RRT in Detail:
Motion planning regarded as a search in a metric
space X, it starts with initial state x
int
and ends with
goal state X
goal
. For general problems X = C (C
stands for Configuration Space). For kinodynamic
problem
X =T(C), that is; the tangent bundle
configuration space (states includes configuration
plus velocity). In the configuration space there is also
X
obs
which are obstacles to be avoided. States in X
obs
results with a collision. RRT will be constructed so
th
at all of its vertices are states in X
free
(complement
of X
obs
).
Figure
8.
RRT Branch expansion
.
For non

holonomic constraint state transition
equation
is defined in following way;
u
x
f
x
,
(The vector u is selected from inputs.)
More
generally
u
x
f
x
x
new
,
Figure
8
: Basic RRT construction algorithm.

8

Let ρ denote a distance metric on the state
space. First vertex of
is x
int
. In each iteration
s
a
random state x
rand
, is selected from X. In step
4 finds
closest vertex to x
rand
in terms of ρ. Step 5 selects an
input ,u, that minimizes the distance from x
near
to x
rand
and checks whether or not it is in X
free
(for collision
detection). NEW_STATE is called to add potential
new state. x
new
obtained by
applying u, is added as a
vertex to
also an edge between x
near
to x
new
added.
Key advantages of RRT:
RRT tends to explore unexplored portion
of configuration space,
RRT is probabilistically complete,
RRT is relatively simple,
RRt can be adapted to various planning
problems,
For reaching the ideal performance defining a
metric ρ is crucial, which determines the length of the
shortest path between two states, on the other hand
it is hard to determine the metric. All path planning
methods suffer from this bottleneck. For kinodyn
amic
planning, the ideal metric would be the optimal
trajectory between ay two states. Another bottleneck
is collision detection but RRT allows fastest collision
detection algorithms.
2.3.4. What Kind of Problems do RRT Solve?
Generally speaking, appli
cations of RRT fall into
three academic disciplines, corresponding to three
classes of problems in practice.
Holonomic Motion Planning
—
Also known
as the
piano moving
problem. “Holonomic”
means that the constraints on the system do
not depend on the velo
city or momentum.
Nonholonomic Motion Planning
—
Th
at
is
the
driving cars
problem, because the
constraints on the object don’t depend only
on its coordinates (velocity and momentum
comes into play).
Kinodynamic Motion Planning
—
It
involves
thrusting spa
cecrafts
around. This
is the most complex type of problem and is
still under

researched [
9
].
RRT is very useful in non

holonomic motion
planning because of its directly applicable manner to
this kind of problems also it needs as few heuristics
and arbitra
ry parameters as possible.
2.
4
. COMPLETENESS AND PERFORMANCE
A motion planner
is said to be complete if the
planner always produces a feasible path, when one
exists. Most complete algorithms are geometry

based. The performance of a complete planner is
assessed by its computational complexity.
Resolution completeness
is the property that the
planner is guaranteed to find a path if the resolution
of an underlying grid is fine enough. Most resolution
complete planners are grid

based. The
computational co
mplexity of resolution complete
planners is dependent on the number of points in the
underlying grid, which is O(1/h
d
), where h is the
resolution (the length of one side of a grid cell) and d
is the configuration space dimension.
Probabilistic completene
ss
is the property that as
more “work” is performed, the probability that the
planner fails to find a path, if one exists,
asymptotically approaches zero. Several sample

based methods are probabilistically complete. The
performance of a probabilistically c
omplete planner
is measured by the rate of convergence.
Incomplete
planners do not always produce a
feasible path when one exists. Sometimes
incomplete planners do work well in practice.
2.5.
PROBLEM VARIANTS
Many algorithms have been developed to han
dle
variants of this basic problem.
In robotics, holonomicity refers to the relationship
between the controllable and total degrees of
freedom of a given robot. If the controllable degrees
of freedom is equal to the total degrees of freedom
then the robo
t is said to be
holonomic
. If the
controllable degrees of freedom are less than the
total degrees of freedom it is
non

holonomic
. A
robot is considered to be redundant if it has more
controllable degrees of freedom than degrees of
freedom in its task space
[6
].

9

2.
5
.1.
Holonomic
In robotics, a system is holonomic, if the
controllable degrees of freedom
are
equal to the total
degrees of freedom of the robot.
A human arm, is a
holonomic
, redundant
system because it has seven degrees of freedom
(three in th
e shoulder

rotations about each axis,
two in the elbow

bending and rotation about the
lower arm axis, and two in the wrist, bending up and
down (i.e. pitch), and left and right (i.e. yaw)) and
there are only six physical degrees of freedom in the
task
of placing the hand (x, y, z, roll, pitch and yaw),
while fixing the seven degrees of freedom fixes the
hand.
2.
5
.2.
Non

Holonomic
In robotics, a system is non

holonomic if the
controllable degrees of freedom are less than the
total degrees of freedom.
An automobile is an example of a
non

holonomic
vehicle. The vehicle has three degrees
of freedom
—
its position in two axes, and its
orientation relative to a fixed heading. Yet it has only
two controllable degrees of freedom
—
acceleration/braking and the
angle of the steering
wheel
—
with which to control its position and
orientation. A car's heading (the direction in which it
is traveling) must remain aligned with the orientation
of the car, or 180° from it if the car is in reverse. It
has no other allowabl
e direction, assuming there is
no skidding or sliding. Thus, not every path in phase
space is achievable; however, every path can be
approximated
by a holonomic path
–
this is called a
(dense) homotopy principle. The non

holonomicity of
a car makes paralle
l parking and turning in the road
difficult, but the homotopy principle says that these
are always possible, assuming that clearance exists.
Examples of non

holonomic systems may be
stated as;
Cars,
Unicycles,
Planes,
(
Aerosonde UAV is holonomic
)
Accele
ration bounded systems,
Moving obstacles (time can't go backward),
Bevel

tip steerable needle,
Differential Drive Robots.
3.
IMPLEMENTATION
This section is dedicated to mention testbed
(designed MATLAB GUI program) specifications and
simulation results.
3.1.
Testbed
, Aerosonde
A graphical user interface
, named as
“Aerosonde”,
is designed using Matlab 7.6.0
(R2008a), as shown in Figure 9.
The program
consists of two modes, Sky Design and Flight Path.
Figure
9
:
Aerosonde GUI Program
.
3.
1
.
1.
Sky Des
ign
Sky size may be selected using predefined
lengths. When the size is set, the whole sky area is
displayed on the graph. Then we can add clouds
(blue) and mountains (black) to the sky, as polygonal
objects. Finally, you can determine the start position
and orientation of the UAV, then enter waypoints to
the desired locations. The Sky design is completed
with setting the goal position.
3.
1.
2
.
Flight Path
This mode of the program is used to plan the
path of the UAV from start to goal via waypoints
, as
shown in Figure 10
. The method for planning
(Visibility Graph, Approximate Cell Decompositon,
Voronoi Diagram, Rapidly Exploring Random Trees
and Goal

Based Rapidly Exploring Random Trees)
is
selected with user interaction. Also there exists some
options o
f these algorithms, as configurable
parameters.

10

Figure
10
:
Aerosonde GUI Program, Flight Plan
Mode
.
After planning phase is completed, a flight
simulation is run in order inspect the success of the
flight path. We
have
also
defined some tuning
parame
ters for observing the tested algorithms’
performances on different settings. Making
comments
with respect to different setting
observations makes our comparisons more reliable.
Success Radius
(m)
:
s
uccess
condition is
achieved when Aerosonde
is
close t
o the waypoint
or goal with that radius.
Cell Width
(m)
:
determines the sizes of the
square

shaped cells of Approximate Cell
Decomposition Method.
Maximum Iteration count
:
determines to what
end RRT algorithm iterates, in finding new nodes.
Branch St
ep Time
(s)
:
is the time interval which
Aerosonde flies through the randomly generated
point in the free space.
We also defined some performance measures to
c
ompare path planning algorithms
objectively. These
measures are explained as follows;
Total Ex
ecution Time (s);
A timer is set to
measure total spending time of chosen algorithms
action from start to stop instance.
(Lower is better)
Total Memory Unit;
This
concept can be thought
as sum of expanded node count during the
algorithms action.
(Lower i
s better)
Path Distance (m);
Total length of the flight
distance from start node to goal node.
(Lower is
better)
Control Effort;
This measure is
the
sum of
the
square of the rudder inputs
changed during the flight
.
It implies how much the algorithm use
d the rudder to
navigate Aerosonde to
properly move on the
planned
path.
(Lower is better)
Flight Time (s)
;
The time spent for flying from
start to the goal.
(Lower is better)
3.3
.
Simulation
Results
of
t
he Path Planning
Algorithms
In this section eac
h path planning algorithms’,
which were told in the second chapter, test result
s
were given. All of the algorithms were run on same
maps and conditions.
Methodology of obtaining
simulation results is
start with
run
ning
the chosen
algorithm several times un
der different tuning
parameter settings and gathering all of the results to
make precise comments.
3.
3
.
1.
Visibility Graph Algorithm
First implementation of path planning algorithms
was Visibility Graph
method
.
We desire Aerosonde
to fly far away from
mountains and clouds, we want it
to follow a collusion free path from start state to goal
state
while passing on predefined check points
. We
first
defined
succe
s
s criteria for avoiding obstacles
and reaching goal points that is
safe flight distance
and cal
led
Success Radius. If Aerosonde is far away
from an obstacle about Success Radius and if it is
close to a check point about Success Radius we can
say that is a successful flight. In Visibility Graph
algorithm we use Success Radius for avoiding from
obstac
les. This algorithm transforms our workspace
limitations
, flying far away from obstacles about
Success Radius and getting closer
to
a check point
about Success Radius, to
configuration space
by
drawing vertices of obstacles far away from their
original pos
ition
s
about Success Radius
inside the
C

Space
and putting a node to those locations. Then
algorithm places a node on start state, goal state and
all checkpoints (one for each). At the end we get
several number
s
of nodes in our C

Space.
Our aim
is
to
conne
ct
start state to goal state with visiting all
predefined check points
(intermediate states) at the
same time following the shortest path from one node
to another
.
(one state to another).
As a part of

11

Visibility Graph method our algorithm draws straight
lin
es to connect each node. After that t
he search
action of finding the closest path between two nodes
is done by utilizing A* Search algorithm with
minimum Euclidian distance heuristic between two
nodes.
The closest path between two nodes is not
always a str
aight node because of the obstacles. All
about this
concept was depicted in
F
igure
11and
F
igure
12
.
Figure 11.
Visibility Graph solution for simple
case.
Figure
12.
Visibility Graph methods Path
for
another case
.
3.
3
.1.
1
Visibility Graph Algorithm R
esults
As second step we simulated
our
Visibility Graph
algorithm on a predefined “SKY” (aerial map)
called
“Big Cow” and received following results.
Figure
13.
Visibility Graph Algorithm’s out put
with configurations given in Table 1
.
It is seen fr
om Figure
13
that Visibility Graph
Method
found a collision free path from start state to
goal state. Relative results were given in Table 1.
Table 1
.
Results of Visibility Graph algorithm
.
Success Radius (m)
25
Solved
No Hit
Total Execution Time (s)
11
1.9324
Total Memory Units
553
Path Distance (m)
1245
Control Effort
38.2598
Total Flight Time (s)
49.8
Table 2 shows Visibility Graph method results
with Success Radius of 20m.
Table
2
.
Results of Visibility Graph algorithm
.
Success Radius (m)
20
Solved
No Hit
Total Execution Time (s)
106.7952
Total Memory Units
557
Path Distance (m)
1255
Control Effort
38.995
Total Flight Time (s)
50.2

12

Table 3 shows Visibility Graph method results
with Success Radius of 15m.
Table
3
.
Results of Visibility
Graph algorithm
.
Success Radius (m)
15
Solved
No Hit
Total Execution Time (s)
111.4216
Total Memory Units
562
Path Distance (m)
1267.5
Control Effort
39.9278
Total Flight Time (s)
50.7
Table
4
shows Visibility Graph method results
with Success Ra
dius of 15m.
Table
4
.
Results of Visibility Graph algorithm
.
Success Radius (m)
1
0
Solved
No Hit
Total Execution Time (s)
120.5699
Total Memory Units
565
Path Distance (m)
1275
Control Effort
40.6554
Total Flight Time (s)
51
Table
5
shows Visibil
ity Graph method results
with Success Radius of 15m.
Table
5
.
Results of Visibility Graph algorithm
Success Radius (m)
5
Solved
No Hit
Total Execution Time (s)
125.9038
Total Memory Units
570
Path Distance (m)
1287.5
Control Effort
42.2969
Total Fli
ght Time (s)
51.5
As Success Radius increasing all of the
performance measure becomes better. Higher the
Success Radius, better the results. Lower values of
Success Radius
push Aerosonde to move stressful,
it has to go closer to check points to do it Ae
rosonde
has to pay much control effort, needs more memory
units to make extra calculations, spends more time
while dealing with calculations and of course it takes
long time and distance to go closer to target points.
As a result; we can confidently say th
at higher
Success Radius values give more flexibility to
Aerosonde in all respects.
3.
3
.
2
.
Approximate Cell Decomposition Algorithm
In this algorithm we have two parameters
Success Radius and Cell Width. We lay down a user
defined “Cell Width” grid wi
th reducing any cells
which intersects an object that is, dividing C

Space
in discrete square regions (cells) where these
regions face with an obstacle we remove it from our
C

Space. After forming grids, algorithm search for
shortest path through other cel
ls up to an
intermediate or goal point.
Again searching the
shortest path action is done by A* Search algorithm
with Euclidian distance heuristics.
3.
3
.
2
.
1 Approximate Cell Decomposition
Algorithm Results
As
next
step we simulated our Approximate Cell
Decomposition algorithm, with different tuning
parameters, on a predefined
,
Big Cow
,
sky and
received following results
:
Table
6
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
25
Cell Width (m)
50
Not Solved
Hit
Total Executio
n Time (s)
110.0237
Total Memory Units
1184
Path Distance (m)
2262.5
Control Effort
280.0324
Total Flight Time (s)
90.5
Table
7
.
Results of
Approximate Cell
Decomposition
algorithm
Success Radius (m)
20
Cell Width (m)
50
Not Solved
Hit
Total Execu
tion Time (s)
106.0108
Total Memory Units
1130
Path Distance (m)
2127.5
Control Effort
287.3117
Total Flight Time (s)
85.1
Table
8
.
Results of
Approximate Cell
Decomposition
algorithm
Success Radius (m)
15
Cell Width (m)
50
Not Solved
Hit
Total Ex
ecution Time (s)
105.4941
Total Memory Units
870
Path Distance (m)
1477.5
Control Effort
160.9069
Total Flight Time (s)
59.1

13

Table
9
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
10
Cell Width (m)
50
Not Solved
Hit
Total
Execution Time (s)
108.6741
Total Memory Units
1403
Path Distance (m)
2810
Control Effort
351.8733
Total Flight Time (s)
112.4
Table 1
0
: Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
5
Cell Width (m)
50
Not Solved
Hit
Tot
al Execution Time (s)
99.2878
Total Memory Units
789
Path Distance (m)
1275
Control Effort
150.1434
Total Flight Time (s)
51
In lower cell width values Approximate Cell
Decomposition method did not create a collision free
path because
whenever Aeros
onde misses a check
point it
tries
to go back and
maneuver to take that
check point. However there is not enough room for
maneuvering in C

Space and unfortunately if one
Aerosonde misses a point, it is very hard to revisit
that point with lower cell with v
alues.
Now we have tested Approximate Cell
Decomposition algorithm, with tuning Cell Width
parameter to 80m on the same sky.
Table 1
1
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
5
Cell Width (m)
80
Not Solved
Hit
Total Ex
ecution Time (s)
34.8383
Total Memory Units
361
Path Distance (m)
600
Control Effort
56.6636
Total Flight Time (s)
24
Table 1
2
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
10
Cell Width (m)
80
Not Solved
Hit
Total
Execution Time (s)
38.6371
Total Memory Units
469
Path Distance (m)
870
Control Effort
104.2002
Total Flight Time (s)
71.6
Table 1
3
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
1
5
Cell Width (m)
80
Not Solved
Hit
Total
Execution Time (s)
47.233
Total Memory Units
837
Path Distance (m)
1790
Control Effort
218.8482
Total Flight Time (s)
71.6
Table 1
4
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
20
Cell Width (m)
80
Solved
No
Hit
Total E
xecution Time (s)
45.9644
Total Memory Units
661
Path Distance (m)
1350
Control Effort
117.4722
Total Flight Time (s)
54
Table 1
5
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
25
Cell Width (m)
80
Solved
No Hit
Total Exe
cution Time (s)
42.6205
Total Memory Units
653
Path Distance (m)
1330
Control Effort
105.6965
Total Flight Time (s)
53.2
Anyone can see that a rise in cell width result
s
better. Higher cell width combined with higher
Success Radius gives much better
results. As
Success Radius is increasing all performance
parameters becomes preferable. As Success Radius
is decreasing results becomes useless. Also lower
Success Radius values causes Aerosonde miss

14

more check point that’s why Aerosonde tries to
recover
this drawback but it crashes to a mountain or
goes in a cloudy region rapidly. Smaller the Success
Radius smaller the fligh time.
At last section Approximate Cell Decomposition
algorithm was tested with greater Cell Width and
observed the following resul
ts.
Figure
13.
Approximate Cell Decomposition
algorithm
path for Table 16 configurations.
Table 1
6
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
5
Cell Width (m)
100
Not Solved
Hit
Total Execution Time (s)
21.5181
Total M
emory Units
289
Path Distance (m)
552.5
Control Effort
47.4676
Total Flight Time (s)
22.1
Table 1
7
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
10
Cell Width (m)
100
Not Solved
Hit
Total Execution Time (s)
29.403
Total
Memory Units
691
Path Distance (m)
1557.5
Control Effort
179.3119
Total Flight Time (s)
62.3
Table 1
8
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
1
5
Cell Width (m)
100
Solved
No
Hit
Total Execution Time (s)
27.975
Total
Memory Units
629
Path Distance (m)
1402.5
Control Effort
164.8162
Total Flight Time (s)
56.1
Table 1
9
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
20
Cell Width (m)
100
Solved
No
Hit
Total Execution Time (s)
43.8932
To
tal Memory Units
613
Path Distance (m)
1362.5
Control Effort
134.4384
Total Flight Time (s)
54.5
Table
20
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
25
Cell Width (m)
100
Solved
No Hit
Total Execution Time (s)
27.4251
Total Memory Units
603
Path Distance (m)
1337.5
Control Effort
119.4253
Total Flight Time (s)
53.5
After these results
i
t can be said that low
Success Radius values is a bottleneck situation for
solution. Trade off between Cell Width and Success
Rad
ius must be done in
a
consistent fashion.
In testbed we have raised Cell Width values
slowly and
observed that higher cell width
correspond much better results
up to a scale. We
can reach goal state even under 5m Success Radius
case. That was very challe
nging. On the other hang
increasing Cell Width very much (e.g. C.W=200m)
causes intersection with obstacles hence algorithm
does not divide SKY to cell that includes necessary
intermediate points
.
3.3.3.
Voronoi Diagram Algorithm
A complete Voronoi Dia
gram is computationally
difficult to calculate. So we have modified the

15

algorithm, with dividing the free spaces into equal

sized cells. For every cell, the minimum distance with
an obstacle or boundary is calculated for arrows
emanating from the cell’s ce
nter throught 30 degrees
of angle steps.
A diffrent path is calculated from every waypoint,
start and goal states, which travels through the cells
with maximum distance parameter beginin from
waypoints origin. Then these paths are connected
from start to
the first intersecting cell in both of the
previously calculated paths. Iterating this approach
to all of the waypoints, the flight path is obtained,
which travels through the cells with high distance
metrics.
3.3.3.1 Voronoi Diagram
Algorithm
Results
Figure 14.
Voronoi Diagram
algorithm
results.
Table
2
1
.
Results of
Approximate Cell
Decomposition
algorithm
.
Success Radius (m)
2
0
Cell Width (m)
70
Not Solved
None
Total Execution Time (s)
2
0
.
8
Total Memory Units
742
Path Distance (m)
1545
Control
Effort
147
Total Flight Time (s)
61.8
3.3.4
. R
apidly
E
xploring
R
andom Trees
(RRTs)
Algorithm
In this relatively new method was examined.
RRT is based on selecting next points randomly in
search space. For a brief summary; at any point in
the
availab
le
search space RRT picks a random
point to move in
. A
lgorithm checks that randomly
selected point whether it is
a
goal point or not. If it is
a
goal node then we reach the solution, if it is not the
goal point, we pick another random point to move in
the
available
search space and algorithm does this
routine iteratively until it reaches a predefined
iteration
count
that restricts search action
not
to go
further.
In this algorithm we have three tuning
parameters; Success Radius, Max.
I
teration Count
and
Branch Step Time.
From our previous
experience we can refer considerable Success
Radius that is 20m. We can observe RRT’s effects
with tuning Max. Iteration Count and Branch Step
Time parameters.
3.
3
.
4
.
1
Rapidly Exploring Random Trees (RRTs)
Algorithm Res
ults
In this section we simulated our
RRT
algorithm,
with different tuning parameters, on a predefined, Big
Cow, sky and received following results
.
Figure
15.
RRT
method results
.

16

Table
22.
Results of
RRT
algorithm
.
Success Radius (m)
20
Max Iteratio
n Count
200
Branch Step Time
0,4
Not
Solved
No Hit
Total Execution Time (s)
94.3941
Total Memory Units
204
Path Distance (m)
0
Control Effort
0
Total Flight Time (s)
0
Table
23.
Results of
RRT
algorithm
.
Success Radius (m)
20
Max Iteration Count
40
0
Branch Step Time
0,4
Not
Solved
No Hit
Total Execution Time (s)
213.6847
Total Memory Units
401
Path Distance (m)
0
Control Effort
0
Total Flight Time (s)
0
RRT is not complete but it is probabilistic
ly
complete, that means while iteration co
unt goes to
infinity this method guarantees to reach goal state.
In
one configuration of tuning parameters solution could
not be found but running the algorithm with same
tuning parameters we may face with a solution, all
this process is only depending on
our luck.
Max.
iteration count provides
long search; we allow
algorithm to run more iterations. Branch step time is
another tuning parameter and its high value does not
guarante
e
a
rational solution. It allow us discover
search space more quickly
3.3.5
.
M
odified
R
apidly
E
xploring
R
andom Trees
(RRTs)
Algorithm
This algorithm is modified version of the original
RRT. Original RRT suffers from choosing all points
randomly in reaching to goal state. This handicap
can be fixed by pushing original RRT algo
r
i
t
hm
to
head
towards to known goal point location. In fact
this modified version of RRT chooses one point
randomly and another one on the direction of the
goal sate.
This second choice pushes fringe points of
random tree to move towards to goal point. This is
more reliable algorithm with respect to
original one.
We can name this algorithm as “Goal Based RRT”
Again i
n this algorithm we have three tuning
parameters; Success Radius, Max. Iteration Count
and
Branch Step Time and again we use a fixed
Success Rad
ius
(e.g.
20m
)
. We can observe RRT’s
effects with tuning Max. Iteration Count and Branch
Step Time parameters.
3.
3
.
5
.
1 Modified
Rapidly Exploring Random Trees
(RRTs) Algorithm Results
Figure 16.
Goal Based RRT method results.
Table
23.
Results of
RRT
algorithm
.
Success Radius (m)
20
Max Iteration Count
8
00
Branch Step Time
0,4
Solved
No Hit
Total Execution Time (s)
78.9
Total Memory Units
602
Path Distance (m)
1267
Control Effort
116.1
Total Flight Time (s)
50.7
5.
CONCLUSIONS
& FUTURE WORK
The flight planning algorithms are successfully
applied the various sky configurations. The success
of the algorithm depends heavily on the selection of
the parameters.
Visibility method resulted in optimal path, with a
high probability of hitting the o
bjects
.

17

Cell Decomposition method, resulted in sharp
corner around pointy object, which made it difficult
Aerosonde to turn, resulting in missing waypoints.
Voronoi Diagram method resulted safest paths at
the expense of nonoptimality.
RRTs method
requires large iteration counts in
order to reach the goal even though it is
probabilisticly complere.
Modified RRTs for goal based point selections
performed well at reasonable number of iteration
counts.
A simple model of Aerosonde is used in the
si
mulations. A more complex model may be used
with extension of the algorithms to 3

D space.
6.
REFERENCES
[
1
]
http://en.wikipedia.org/wiki/Motion_planning
[
2
]
http://dasl.mem.drexel.edu/Hing/Voronoi

Tutorial.htm
[
3
]
http://en.wikipedia.org/wiki/Visibil
ity_graph
[4
]
http://171.64.64.250/class/sophomore

college/projects98/robotics/basicmotion.html
[5
]
Exact Celll Decomposition of Arrangements
Used for Path Planning in
Robotics, Nora H.
Sleumer, Nadine Tschichold

Gürman
.
[6
]
http://en.wikipedia.org/wi
ki/Holonomic#Robotics
[7
]
http://en.wikipedia.org/wiki/Rapidly

exploring_random_tree
[8
]
http://www.kuffner.org/james/plan/algorithm.php
[9
]
http://aigamedev.com/open/highlights/rapidly

exploring

random

trees/
Comments 0
Log in to post a comment