PERFORMANCE COMPARISON OF BUG ALGOR

PERFORMANCE COMPARISON OF BUG ALGORITHMS
FOR MOBILE ROBOTS
Alpaslan YUFKAa, * and Osman PARLAKTUNAb
a, * Eskişehir Osmangazi University, Eskişehir, Turkey, E-mail: [e-mail] b Eskişehir Osmangazi University, Eskişehir, Turkey, E-mail: [e-mail]
Abstract
In this study, Bug1, Bug2, and DistBug motion planning
algorithms for mobile robots are simulated and their
performances are compared. These motion planning
algorithms are applied on a Pioneer mobile robot on the
simulation environment of MobileSim. Sonar range
sensors are used as the sensing elements. This study
shows that mobile robots build a new motion planning
using the bug’s algorithms only if they meet an unknown
obstacle during their motion to the goal. Each of the bug’s
algorithms is tested separately for an identical
configuration space. At the end of this study, the
performance comparison of the bug’s algorithms is shown.
Keywords: Bug, pioneer, robots, sonar, MobileSim
1. Introduction
Based on the configuration space and the goal position,
generating a path for a mobile robot means finding a
continuous route starting from the initial point, S, to the
goal point, G, which is in a 2D environment with unknown
obstacles of an arbitrary shape. Implementing this, the
navigation takes an important place, and is a general
problem for mobile robots.
In the literature, there are several distinct approaches
related to the navigation [1].The Bug’s algorithms [2, 3]
construct a path to move the robot to the goal in a straight
line, if the path to the goal is clear. The robot follows the
boundary of the obstacle when it encounters an unknown
obstacle until the path is clear again [1]. In addition, these
algorithms have advantages compared with the other
planning algorithms [1]. At that point, the mobile robot does
not have to map its environment if one of the Bug’s
algorithms is used. The robot is only interested in reaching
its goal location if the goal is reachable; however, if it is
unreachable, the robot is able to terminate the given task.
Each described Bug’s algorithm has this termination
property [4].
The described algorithms in this paper are Bug1 [5], Bug2
[5], and DistBug [6] which are the part of the Bug’s family.
Bug1 and Bug2 are the original algorithms of the Bug’s
family which need minimum memory requirements but not
to be capable of making the best use of the available
sensory data to generate short paths [12]. In contrast,
DistBug uses range sensors efficiently to define a new
leaving condition [12]. Beside this, the Bug’s algorithms
exhibit a statistically better performance depending on the
structure of the environment, but at different environments
the one of them may have an advantage over another
algorithm [4].
Figure 1. The empirical indoor-environment created by
Mapper3 software.
This paper presents a comparison among the Bug’s
algorithms, as well as Bug1, Bug2 and DistBug, in order to
show which one exhibits the best performance based on
experimental data provided from the simulation
environment of MobileSim [13]. The test area, which has
10m length, 8m width and two convex-shaped obstacles, is
created by Mapper3 [13], as shown in Fig.1. A Pioneer
mobile robot is used in the simulation. The objective of the
robot is to reach the goal position using each of the Bug’s
algorithms discussed. The aim of the study is to compare
the algorithms in terms of the total travelled path-length.
The assumptions are that the mobile robot never
encounters a localization problem and it uses its odometry
to localize itself.
2. The Bug Family
The Bug’s algorithms are simple planners with provable
guarantees [14]. When they face an unknown obstacle,
they are able to easily produce their own path contouring
the object in the 2D surface if a path to the goal exists. The
purpose is to generate a collision-free path by using the
boundary-following and the motion-to-goal behaviors. In
addition, the Bug’s family has three assumptions about the
mobile robot: i) the robot is a point, ii) it has a perfect
localization, and iii) its sensors are precise [4].
The following Bug’s algorithms are considered and
implemented in this study: Bug1 [5-14-15], Bug2 [5-14-15],
and DistBug [4, 6]
2.1. Bug1 and Bug2 Algorithms
Both of these algorithms are not only the original and
earlier sensor-based planners but they also offer minimum
memory requirements because of their simplicity [12, 14].
Their senses are based on tactile sensors but in this study
the sonar sensors are used to implement the experiment
instead of tactile sensors.
© IATS’09, Karabük University, Karabük, Turkey
YUFKA, A. and PARLAKTUNA, O.
Bug1 is an algorithm in the sense, the mobile robot moves
towards the goal directly, unless it encounters an obstacle,
in which case the robot explores the external lines of the
obstacle until the motion to the goal is available again [8,
14]. Using sonar sensors, the mobile robot faces the
unknown obstacle during the motion to the goal. Once it
encounters an obstacle as indicated in figure 2, it goes
around the obstacle in clockwise sense (default), and then
determines the leave point by calculating the distance
between the current position and the goal position, G,
during travelling around the object. The leave point is the
closest point around the obstacle to the goal. Then, the
robot determines the shortest path to this closest point in
order to reach the leaving point, and changes or keeps its
direction of the wall following according to the shortest
path to return to the leave point. Next, the robot goes to
the leave point and departures the obstacle towards G
along a new line. When it faces the second obstacle, the
same procedure is applied. This method is inefficient but
guarantees that the mobile robot is able to arrive any
reachable goal point, [1].
Figure 2. Path generated by Bug1
The algorithm Bug2 is a greedy algorithm that the mobile
robot follows a constant slope computed initially between
the positions of S and G. The mobile robot maintains its
motion to G unless the path on the slope is interrupted by
an obstacle. If the robot faces it, the robot follows edges of
the obstacle by using its sonar sensors in the clockwise
sense until it finds its initial slope again. This property
leads to shorter paths than Bug1’s but in some cases the
path may get longer than Bug1’s, for example, maze
searching [12, 17]. In figure 3, it is obvious that Bug 2’s
path is the shorter than Bug1’s in figure 2.
Figure 3. Path generated by Bug2
2.2. DistBug Algorithm
Some Bug’s algorithms such as DistBug algorithm
originate from Sankaranarayanan's Alg1 and Alg2 [7, 8].
They use different data structures to store the hit and the
leave points together with some useful information about
the followed path [12, 18].
Figure 4. Path generated by DistBug.
In this algorithm, the robot has a maximum detection
whose range is R and it has two basic behaviors which are
boundary-following and motion-to-goal actions. Firstly, the
robot moves through G until it faces an obstacle. Then, its
boundary-following action is activated in the clockwise
sense (default). During the boundary following, the robot
records the minimum distance, dmin(G), to G achieved
since the last hit point. The robot also senses the distance
in free space, F, which is a distance of an obstacle from
the robot’s location, X, in the direction of G. If no obstacle
is sensed, F is set to R. The robot leaves the obstacle
boundary as indicated in figure 4 only when the path to G
is clear or the equation, d(X, G) – F ≤ dmin(G) – Step, is
satisfied where d(X, G) is the distance from X to G, and
Step is a predefined constant, [6].
3. Implementation
Generally the Bug’s algorithms are published as pseudo
code [4]. We have written them as C++ code executed in
Linux platform using ARIA library [19] and used MobileSim
simulator [13] which is compatible with real Pioneer mobile
robots. The identical indoor-environment, which has 10m
length, 8m width and two convex-shaped obstacles, is
used for each of the Bug’s algorithm as indicated in fig. 1
and fig. 5, and the map created by Mapper3 [13].
Figure 5. The environment simulated by MobileSim
YUFKA, A. and PARLAKTUNA, O.
During the implementation, the mobile robot updates its
position and navigation data, uses its sonar sensors,
moves towards the goal, and by wall-following or
boundary-following, follows the edges of the unknown
obstacle.
In the simulation environment, the mobile robot uses the
odometry to localize itself and to update its position and
orientation data. It’s important that the mobile robot
refreshes its localization frequently in order not to pass
over the hit and the leave points and also not to skip the
slope discussed in the algorithm Bug2. Note that the
localization of the mobile robot is perfect in the simulation
whereas in the real world it is difficult to become the
localization perfect.
Some Bug’s algorithms, as well as TangentBug [11-14]
and DistBug, need range sensors whereas Bug1 and Bug2
do not [4]. Bug1 and Bug2 require tactile sensors, but in
this study, the sonar sensors instead of tactile sensors are
used to sense the environment and to manage the
operations such as wall following and detecting the
unknown obstacles.
The most important task for the mobile robot is reaching
the goal position, G, therefore, it tries to move towards G
until it replans its motion according to the algorithm
The obstacle detection and the wall following are
implemented by using sonar sensors whose layout [16] is
denoted in figure 6. The robot uses front sensors
numbered as 1, 2, 3, 4, 5 and 6 to sense obstacles that
block the path, and uses sidelong sensors numbered as 7,
8 for the boundary-following in the clockwise sense and
0,15 in the counter-clockwise sense.
Figure 6. Sonar layout.
4. Experiments and Results
Three applications are carried out to compare the
performance of each previously described the Bug’s
algorithm. In these appli

ผลลัพธ์ (อังกฤษ) 2:

COMPARISON OF PERFORMANCE algorithms BUG
FOR MOBILE robots
Alpaslan YUFKAa, and Osman PARLAKTUNAb *
a, * Eskişehir Osmangazi University, Eskişehir, Turkey, E-mail: Eskişehir Osmangazi University [e-mail] B, Eskişehir, Turkey, E-mail: @ Oparlak. Ogu.edu.tr
Abstract
In this Study, Bug1, Bug2, and DistBug Motion planning
algorithms for Mobile robots are simulated and their
performances are compared. Motion planning these
algorithms are Applied on a Pioneer Mobile robots on the
Simulation Environment of MobileSim. Sonar Range
sensors are used as the sensing Elements. This Study
shows that Build a New Mobile robots Motion planning
algorithms using the bug's only if they Unknown Meet an
Obstacle during their Motion to the Goal. Each of the bug's
algorithms is separately tested for an identical
Configuration Space. At the End of this Study, the
Performance comparison of the bug's algorithms is shown.
Keywords: Bug, PIONEER, robots, Sonar, MobileSim
1. Introduction
Based on the Configuration Space and the Goal position,
Generating a path for a Mobile robots means Finding a
continuous Route Starting from the Initial Point, S, to the
Goal Point, G, which is in a 2D Environment with Unknown
obstacles of an arbitrary. shape. Implementing this, the
navigation Takes an important Place, and is a general
Problem for Mobile robots.
In the literature, there are several Distinct approaches
related to the navigation [1] .The Bug's algorithms [2, 3]
Construct a path to Move the. Straight to the Goal robots in a
line, if the path to the Goal is Clear. The robots follows the
Boundary of the Obstacle when it encounters an Unknown
Obstacle until the path is Clear again [1]. In addition, these
algorithms have advantages compared with the Other
planning algorithms [1]. At that Point, the Mobile robots does
not have to Map of the Bug's one if its Environment
algorithms is used. The robots is only interested in reaching
its Goal Location is if the Reachable Goal; however, if it is
unreachable, the robots is Able to terminate the Given Task.
Each described Bug's algorithm has this termination
Property [4].
The described algorithms in this Paper are Bug1 [5], Bug2
[5], and DistBug [6. ] which are the Part of the Bug's Family.
Bug1 and Bug2 are the Original algorithms of the Bug's
Family which Need Minimum memory requirements but not
to be Capable of Making the Best use of the available
sensory Data to Generate short Paths [12]. In contrast,
DistBug Range uses sensors to efficiently define a New
Leaving condition [12]. Beside this, the Bug's algorithms
Exhibit a statistically better Performance depending on the
structure of the Environment, but at different environments
the one of them May have an Advantage over another
algorithm [4].
Figure 1. The empirical Indoor-Environment Created by
Mapper3 Software. .
This Paper Presents a comparison among the Bug's
algorithms, as well as Bug1, Bug2 and DistBug, in Order to
Show which one exhibits the Best Performance based on
Experimental Data provided from the Simulation
Environment of MobileSim [13]. The Test Area, which has
10m Length, width and 8m Two convex-shaped obstacles, is
Created by Mapper3 [13], as shown in Fig.1. A Pioneer
Mobile robots is used in the Simulation. The Objective of the
robots is to reach the Goal Bug's position using each of the
algorithms discussed. The AIM of the Study is to compare
the algorithms in terms of the total traveled path-Length.
The assumptions are that the Mobile robots Never
encounters a Localization Problem and it uses its Odometry
to localize Itself.
2. The Bug Family
Bug's The Simple algorithms are Provable Planners with
guarantees [14]. When they Unknown Face an Obstacle,
they are easily Able to Produce their own path contouring
the Object in the 2D surface if a path exists to the Goal. The
purpose is to Generate a Collision-free path by using the
Boundary-following and the Motion-to-Goal behaviors. In
addition, the Bug's Family has Three assumptions About the
Mobile robots: I) the robots is a Point, II) it has a Perfect
Localization, and III) its sensors are Precise [4].
The following Bug's algorithms are considered and
implemented in. Study this: Bug1 [5-14-15], Bug2 [5-14-15],
and DistBug [4, 6]
2.1. Bug1 and Bug2 Algorithms
Both of these algorithms are not only the Original and
earlier sensor-based Planners but they also Offer Minimum
memory requirements because of their simplicity [12, 14].
Their Senses are based on tactile sensors but in this Study
the Sonar sensors. are used to IMPLEMENT the experiment
instead of tactile sensors.
© IATS'09, Karabuk University, Karabuk, Turkey
Yufka, and PARLAKTUNA A., O.
Bug1 is an algorithm in the Sense, the Mobile robots Moves
towards the Goal directly, unless it. encounters an Obstacle,
in which the robots Case explores the External Lines of the
Obstacle until the Motion to the Goal is available again [8,
14]. Using Sonar sensors, the Mobile robots faces the
Unknown Obstacle during the Motion to the Goal. Once it
encounters an Obstacle as indicated in figure 2, Goes
Around Obstacle in the clockwise Sense (default), and then
the Leave Point Determines by calculating the Distance
between the current position and the position Goal, G,
during traveling Around the Object. Leave the Point is the
Closest Point Around the Obstacle to the Goal. Then, the
robots Determines the Shortest path to this Closest Point in
Order to reach the Leaving Point, and keeps or changes its
direction of the following according to the Wall Shortest
path to Return to the Leave Point. Next, the robots Goes to
the Leave Point and Departures Obstacle towards the G
along a New line. When it faces the Second Obstacle, the
Same procedure is Applied. This method is inefficient but
guarantees that the Mobile robots is Able to Arrive any
Reachable Goal Point, [1].
Figure 2. Path Generated by Bug1
Bug2 The algorithm is a Greedy algorithm that the Mobile
robots follows a Constant Slope initially computed between
the Positions. of S and G. The Mobile robots maintains its
Motion to G unless the path on the Slope is Interrupted by
an Obstacle. If it faces the robots, the robots follows edges of
the Obstacle by using its Sonar sensors in the clockwise
Sense until it finds its Initial Slope again. This Property
Leads to shorter than Bug1's Paths in Some Cases but the
path May Get Longer than Bug1's, for example, maze
searching [12, 17]. In figure 3, it is Obvious that Bug 2's
path is shorter than the Bug1's in figure 2.
Figure 3. Path Generated by Bug2
2.2. DistBug Algorithm
Some Bug's algorithms such as DistBug algorithm
Originate from Sankaranarayanan's Alg1 and Alg2 [7, 8].
They use different Data Structures to Store the hit and the
Leave points Together with Some useful information About
the followed path [12, 18].
Figure. 4. Path Generated by DistBug.
In this algorithm, the robots has a maximum detection
whose Range is R and it has Two Basic behaviors which are
following and Boundary-Motion-to-Goal Actions. Firstly, the
robots Moves Through G until it faces an Obstacle. Then, its
Boundary-Action is activated in the following clockwise
Sense (default). Boundary during the following, the robots
records the Minimum Distance, DMin (G), to G achieved
since the last hit Point. The robots also the Senses Distance
in free Space, F, which is a Distance of an Obstacle from
the robots's Location, X, in the direction of G. If no Obstacle
is sensed, F is SET to R. The robots leaves the Obstacle
Boundary. as indicated in figure 4 only when the path to G
is Clear or the Equation, D (X, G) - F ≤ DMin (G) - Step, is
satisfied where D (X, G) is the Distance from X to G,. and
Step is a predefined Constant, [6].
3. Implementation
Generally the Bug's algorithms are Published as Pseudo
code [4]. We have written as C ++ code executed them in
Linux Platform using ARIA Library [19] and used MobileSim
Simulator [13] which is Compatible with Pioneer Mobile Real
robots. The identical Indoor-Environment, which has 10m
Length, width and 8m Two convex-shaped obstacles, is
used for each of the Bug's algorithm as indicated in fig. 1
and fig. 5, and the Map Created by Mapper3 [13].
Figure 5. The Environment simulated by MobileSim
Yufka, and PARLAKTUNA A., O.
During the implementation, the Mobile robots Updates its
position and navigation Data, Sonar uses its sensors,
Moves towards. the Goal, and by Wall-following or
Boundary-following, follows the edges of the Unknown
Obstacle.
In the Simulation Environment, the Mobile robots uses the
Odometry to localize Itself and to update its position and
orientation Data. It's important that the robots Mobile
Refreshes its Localization Frequently in Order not to Pass
over the hit and the Leave points and also not to skip the
Slope discussed in the algorithm Bug2. Note that the
Localization of the Mobile robots in the Simulation is Perfect
whereas in the Real World it is difficult to Become the
Perfect Localization.
Some Bug's algorithms, as well as TangentBug [11-14]
and DistBug, whereas Bug1 Need Range sensors and Bug2.
do not [4]. Bug1 and Bug2 Require tactile sensors, but in
this Study, the Sonar sensors instead of tactile sensors are
used to Sense the Environment and to Manage the
Operations such as Wall following and detecting the
Unknown obstacles.
The Most important Task for the Mobile robots is reaching.
the Goal position, G, therefore, tries to Move towards G
until it Replans its Motion according to the algorithm
The Wall Obstacle detection and the following are
implemented by using Sonar sensors whose layout [16] is
denoted in figure 6. The robots uses. Front sensors
numbered as 1, 2, 3, 4, 5 and 6 to Sense obstacles that
Block the path, and uses sensors Sidelong numbered as 7,
8 for the Boundary-Sense following in the clockwise and
counter-clockwise 0,15 in the. Sense.
Figure 6. Sonar layout.
4. Results and experiments
are carried out to compare the Three Applications
Performance of each previously described the Bug's
algorithm. In these appli

ผลลัพธ์ (อังกฤษ) 3:

PERFORMANCE COMPARISON OF BUG ALGORITHMS
FOR MOBILE ROBOTS
Alpaslan YUFKAa, * and Osman PARLAKTUNAb
A, * Eski. Ehir Osmangazi. University Eski. Ehir,,, Turkey E-mail: [e-mail] B Eski. Ehir Osmangazi University Eski. Ehir,,, Turkey E-mail: [e-mail]

, Abstract In ,,, this study Bug1 Bug2 and DistBug motion planning
algorithms for mobile robots are simulated and their
.Performances are compared. These motion planning
algorithms are applied on a Pioneer mobile robot on the
simulation environment. Of MobileSim. Sonar range
sensors are used as the sensing elements. This study
shows that mobile robots build a new motion. Planning
using the bug 's algorithms only if they meet an unknown
obstacle during their motion to the goal. Each of the bug' s
.Algorithms is tested separately for an identical
configuration space. At the end of, this study the
performance comparison. Of the bug 's algorithms is shown.
Keywords: Bug pioneer robots,,,, sonar MobileSim
1. Introduction
Based on the configuration. Space and the, goal position
generating a path for a mobile robot means finding a
continuous route starting from the initial. ,, point S to the
.Goal, point G which is, in a 2D environment with unknown
obstacles of an arbitrary shape. Implementing, this the
navigation. Takes an important place and is, a general
problem for mobile robots.
In the literature there are, several distinct approaches
related. To the navigation [1]. The Bug 's algorithms [,]
2 3 construct a path to move the robot to the goal in a, straight
lineIf the path to the goal is clear. The robot follows the
boundary of the obstacle when it encounters an unknown
obstacle. Until the path is clear again []. In, 1 addition these
algorithms have advantages compared with the other
planning algorithms. []. At 1, that point the mobile robot does
not have to map its environment if one of the Bug 's
algorithms is used.The robot is only interested in reaching
its goal location if the goal is reachable; however if it, is
unreachable the,, Robot is able to terminate the given task.
Each described Bug 's algorithm has this termination
property [4].
The described. Algorithms in this paper are Bug1 [5], Bug2
[], and 5 DistBug [] which 6 are the part of the Bug 's family.
.Bug1 and Bug2 are the original algorithms of the Bug 's
family which need minimum memory requirements but not
to be capable. Of making the best use of the available
sensory data to generate short paths []. In, 12 contrast
DistBug uses range sensors. Efficiently to define a new
leaving condition []. Beside, 12 this the Bug 's algorithms
exhibit a statistically better performance. Depending on the
.Structure of, the environment but at different environments
the one of them may have an advantage over another
algorithm. []. 4
Figure 1. The empirical indoor-environment created by
Mapper3 software.
This paper presents a comparison among the. Bug ', s
algorithms as well as Bug1 Bug2 DistBug in, and, order to
show which one exhibits the best performance based on
.Experimental data provided from the simulation
environment of MobileSim [13]. The, test area which has
10m length 8m width,, And two, convex-shaped obstacles is
created by Mapper3 [13], as shown in Fig.1. A Pioneer
mobile robot is used in the, simulation. The objective of the
robot is to reach the goal position using each of the Bug 's
algorithms discussed. The aim of the study. Is to compare
.The algorithms in terms of the total travelled path-length.
The assumptions are that the mobile robot never
encounters. A localization problem and it uses its odometry
to localize itself.
2. The Bug Family
The Bug 's algorithms are simple planners. With provable
guarantees [14]. When they face an, unknown obstacle
they are able to easily produce their own path contouring
.The object in the 2D surface if a path to the goal exists. The
purpose is to generate a collision - free path by using the
boundary-following. And the motion-to-goal behaviors. In
addition the Bug ', s family has three assumptions about the
mobile robot: I) the robot. Is a point II), it has a perfect
localization and III), its sensors are precise [4].
.The following Bug 's algorithms are considered and
implemented in this study: Bug1 [5-14-15], [], Bug2 5-14-15
and DistBug. [,]
4 6 2.1. Bug1 and Bug2 Algorithms
Both of these algorithms are not only the original and
earlier sensor-based planners. But they also offer minimum
memory requirements because of their, simplicity [12 14].
Their senses are based on tactile. Sensors but in this study
.The sonar sensors are used to implement the experiment
instead of tactile sensors.
s IATS', K University 09 Karab V, V, Karab K. Turkey
, YUFKA A. And, PARLAKTUNA O.
Bug1 is an algorithm in, the sense the mobile robot moves
towards the, goal directly. Unless it encounters, an obstacle
in which case the robot explores the external lines of the
obstacle until the motion to. The goal is available, again [8