INSTALLATION OF

PLAYER/STAGE FOR THE

MPLEMENTATION OF BMO
1]chakravarthi jada RGUKT, Nuzvid, India(e-mail:[email protected])
2]kalidasu kokkiligadda(n150586) RGUKT, Nuzvid, India(e-mail:[email protected])
Abstract
The diversified ecology in the nature had various forms of swarm be-
haviors in many species. The butterfly species is one of the prominent
and a bit insight in their random flights and convert that into artificial
metaphor would leads to enormous possibilities. This paper considers
one such metaphor known as Butterfly Mating Optimization (BMO). In
BMO, the Bfly follows the patrolling mating phenomena and capture the
local optima of multimodal functions simultaneously. But it is impossi-
ble understand the process without the representaton.This paper studied
the various steps involved in the installation of player stage software for
the implementaion of BMO and envisaged to build the platform for multi
mobile-robots known as BflyBot, to simulate the detection of light source
by the bfly bots using player stage.

1 Introduction
Nature includes enormous number of species into it.Each one has its own
mechanism of survival and continue to extend their species.Butterflies is one of
the prominent species which has a special type of mechanism in mating.Many
complex activities involved in the process of butterfly mating.This paved the
path for the implementation of BMO(butterlfly mating optimization) in real
time applications.For the implementaton of this process a software is requred.Here
comes the importance of player project.
The Player Project (formerly the Player/Stage Project) is a project to
create free software for research into robotics and sensor systems.[1] Its compo-
nents include the Player network server and the Stage robot platform simulators.
Although accurate statistics are hard to obtain, Player is one of the most pop-
ular open-source robot interfaces in research and post-secondary education.[2]
Most of the major intelligent robotics journals and conferences regularly pub-
lish papers featuring real and simulated robot experiments using Player and
Stage. The Player Project is an umbrella under which two robotics-related
software projects are currently developed. These include the Player networked
robotics server, and the Stage 2D robot simulation environment. The project
was founded in 2000 by Brian Gerkey, Richard Vaughan and Andrew Howard
at the University of Southern California at Los Angeles, and is widely used in
robotics research and education.[3] It releases its software under the GNU Gen-
eral Public License with documentation under the GNU Free Documentation
License.

1
2 WHAT IS PLAYER/STAGE?

Figure 1: player project

2.1 Player
The Player software runs on Microsoft Windows and POSIX-compatible
operating systems, including Linux, Mac OS X, Solaris, and the BSD variants.
Player can be described as a ’robot abstraction layer,’ in that all devices are
abstracted into a set of pre-defined interfaces.
Player supports a wide variety of hardware (sensor devices and robot
platforms alike).[4] It also contains client library support for a number of pro-
gramming languages including C, C++, Python and Ruby. Third-party client
libraries are available in languages like Java and Tcl. Additional features in-
clude a minimal and flexible design, support for interfacing with multiple devices
concurrently, and on-the-fly server configuration.

2.2 Stage
The Stage simulator is a 2D multiple-robot simulation environment built
on top of FLTK. Stage provides a basic simulation environment that can be
scaled to model one to hundreds of robots at a time. Stage can be used alone
to simulate robot behaviors via user-defined control programs. Stage can also
interface with Player, allowing users of the Player to access simulated sensors
and devices through the Player interfaces.

2.3 Gazebo
The Gazebo 3D robot simulator was a component in the Player Project
from 2004 through 2011. Gazebo integrated the ODE physics engine, OpenGL
rendering, and support code for sensor simulation and actuator control. In 2011,
Gazebo became an independent project support by Willow Garage.

2
3 working of player/stage
Player is a network server for robot control. It provides an interface to the
robot’s sensors and actuators over the IP network. Your client program talks
to Player over a TCP socket, reading data from sensors, writing commands to
actuators and configuring devices on the fly.

Figure 2: working of player stage

A simulation is composed of three parts:

• Your code. This talks to Player.
• Player. This takes your code and sends instructions to a robot. From the
robot it gets sensor data and sends it to your code.
• Stage. It receives instructions from Player and moves a simulated robot
in a simulated world, it gets sensor data from the robot in the simulation
and sends this to Player.

4 Installation of player/stage
Install Player first, then Stage, using the standard GNU autotools build system:
download and extract the tarballs, then ./configure ; make install.
Standard installation procedure:
To install Stage in the default location, follow these steps:
• If you plan to use Player with Stage, make sure Player is installed and
working. See the Player documentation for instructions.
• Download the latest Stage source tarball (stage-src-¡version¿.tgz) from
http://playerstage.sf.net
• Uncompress and expand the tarball: tarxzvf stage− < version > .tgz‘cd0 intoStage0 ssourcedirectory :
cd stage-¡version¿

3
 • To configure Stage with default settings: ”./configure”
• Compile Stage: ”make”
• Test to see if Stage works by running the stest program: src/stest worlds/simple.world
robot1

• If you see a robot running around, your build was successful. If not, you
need to debug. See the website and user groups for debugging help.
• Install Stage. By default, Stage will be installed in /usr/local so you need
to become root for this step. Remember to return to your normal user ID
afterwards. make install

For the installation of player stage we have used ubuntu 12.04.

step1:
• Download the player software from the url–http://playerstage.sourceforge.net/projects/playerstage/files/p
3.0.2.tar.gz/download

• download the stage software from the url–http://playerstage.sourceforge.net/projects/playerstage/files/sta

3.2.2-source.tar.gz/download
step2:
we need to install following softwares for the proper runnning of player/stage.
1.Fast-light toolkit 2.OpenGL utility toolkit 3.OpenGL utility toolkit de-
velopment files 4.PNG library development 5.Generic library support script
6.Guile’s patched verson of libtool’s libltdl libguile-ltdi-1
step3:
Now we need to run the following commands to configure the player/stage
software

• sudo apt-get install cmake–installaton of cmake

• sudo apt-get install g**
• sudo apt-get install cmake-curses-gul
• sudo apt-get install robot-player

• sudo apt-get install python2.7.dev

• After the innstallation of player and stage,access the directory of player
and run-/Desktop/player-3.0.2/builds cmake..
• Now access the stage directory and run-/Desktop/stage-3.2.2.source/builds
sudo make install
After the installation a window appears like this,

4
 Figure 3: player project

5 File types, Interfaces, Drivers and Device

• a .world file tells Player/Stage what things are available to put in the
world. You describe your robot, any items which populate the world and
the layout of the world.
• a .cfg (configuration) file is what Player reads to get all the information
about the robot that you are going to use. This file tells Player which
drivers it needs to use in order to interact with the robot (if you use
simulation, the driver is always Stage). It also tells Player how to talk to
the driver, and how to interpret any data from the driver so that it can
be presented to your code.
• a .inc file, which follows the same syntax and format of a .world file but
it can be included, which is easily reusable.

• Interface: A specification of how to interact with robotic hardware. The

interface defines the syntax and semantics of all messages that can be
exchanged with entities in the same class.
• Driver: A piece of software (usually written in C++) that talks to hard-
ware and translates its inputs and outputs to conform to one or more
interfaces.
• Device: A driver bound to an interface so that Player can talk to it directly.

6 Building a world
We can run a world and configuration file that comes bundled with Stage. By
default, it’s in the /usr/local/share/stage/worlds folder. Once in the correct
folder, you can run the following command: ”player simple.cfg”.

5
 Figure 4: working of player stage

A worldfile is a list of models that describes all the stuff in the simulation, in-
cluding the basic environment, robots and other objects.
Let’s look at map.inc for an example.
include ”map.inc”
configure the GUI window
window
(size[700.000700.000]//sizeof thesimulationwindowinpixels[widthheight]scale41//howmanypixelseachmeter
windows ize/f loorplansize)
load an environment bitmap
floorplan
( bitmap ”bitmaps/cave.png” can by type bmp, jpeg, gif or png size [15 15 1.5]
size in meters [x y z] dimensions )
Writing a Configuration (.cfg) File
For each model in the simulation or device on the robot that you want to in-
teract with, you will need to specify a driver. The driver specification is in the
form:
driver

(name”drivern ame”alistof supporteddrivernamesisintheP layerM anual, withStage, theonlyoneneededis”sta

In your configuration file (.cfg), it always starts with the following for simu-
lation:
driver
(
name ”stage” there is a driver called stage plugin ”stageplugin” in the stage-
plugin library

provides [”simulation: 0”] it conforms to the simulation interface

load the named file into the simulator worldfile ”empty.world”

6
)

The input to the provides parameter is a ”device address”, which has the
format ”key:host:robot:interface:index” and parameters are separated by white
space. For Stage, the key field doesn’t need to be used. The default host is
”localhost” which means the computer on which Player is running. The robot
field is the port number. The default port is 6665. The interface and index
fields are mandatory.
driver
( name ”stage”
provides [”6665:position2d:0”
”6665:sonar:0”
”6665:blobfinder:0”
”6665:laser:0” ]
model ”bot1”
)

Figure 5: sample program for scanning the root

7 Conclusions
This paper presented the various phases in the installation and working of
player/stage for the implementation of BMO(Butterfly mating optimization).