Xuan Sang Le is a PhD student who has joined our team mid-february. His work is co-supervized by Ecole des Mines and ENSTA is about speed optimization of Smalltalk robotic software by means of FPGAs. The first step is to develop an application fully in Smalltalk and our PhaROS Robotics framework that will serve as a reference for our metrics. The app we have chosen is a simple tracker robot that follows an object of a particular color. Beside being fun, the result shown by the video below is interesting. As we have initially expected we can’t pretend to be real-time. Still, Pharo is capable of fetching an image through wifi, process it and discover the position of the object 650 milliseconds. And this is with non-optimized code. Figures are likely to be better after optimization.

Do you know Lego MindStorms ? The last one is the Ev3 serie (http://www.lego.com/fr-fr/mindstorms/). One particularity of this version compared to the previous ones is the possibility to plug a Wifi key and connect via TCP.

So, if you have this material (one Mindstorms Ev3, one compatible Wifi key), you can control your robot with Pharo !

Just load these lines:

Gofer it
     url: 'http://smalltalkhub.com/mc/JLaval/JetStorm/main'      username: '' 
     password: ''; 
     package: 'ConfigurationOfJetStorm';
(Smalltalk at: #ConfigurationOfJetStorm) loadBleedingEdge.

I know also that for Christmas, it is not possible to learn a new API, we all have a lot of other things to do ! So, you can play with it into Phratch.

For that, just load Phratch and the package EV3Phratch as follow.

Gofer it
       url: 'http://smalltalkhub.com/mc/JLaval/Phratch/main'        username: '' 
       password: ''; 
       package: 'ConfigurationOfPhratch';
(Smalltalk at: #ConfigurationOfPhratch) loadBleedingEdge.
Gofer it
       url: 'http://smalltalkhub.com/mc/JLaval/JetStorm/main'        username: '' 
       password: ''; 
       package: 'EV3Phratch';

Have fun !


Since a bit more than one year of hard work, we are glad to be able to show the world our pharo client framework for ROS.

  ROS (Robot Operating System) provides libraries and tools to help software developers create robot applications. It provides hardware abstraction, device drivers, libraries, visualizers, message-passing, package management, and more. 

In order to make your life easy, we present here a virtualization with all the things needed installed and configured for the Groovy Galapagos version. Sadly, in this version of ROS (the last stable) the Gazebo simulator is not working, and also the most stable code of the previous version (Fuerte) is not working with gazebo anymore. Thats why the examples we show here are based on the easiest ROS simulator, the turtlesim.

We expect to be able to make a better showing up of all this world with the next version (Hydromedusa) which still unstable, but promise to have a whole new way to interact to simulators and so to let us show you a full simulated robot managed from your pharo image.


After you have downloaded the virtualization, and import it into your virtualbox installation, you need to get started into this new world. Remind always that currently, ROS is almost managed thought console commands, so, in order to interact with ROS and PhaROS you will need to use it, and of course, in order to use it you need to know some commands.


Yeah, cool, but you know, i just want to see something working, and i hate to waste my time understanding commands

So, open a terminal and execute:

rosrun esug pharos turtlesimpharo


Ok, you got my attention, i want to know a bit more about how to use ROS 

roscd {package name} ” This command step into the folder of the package ”

roscd esug ” This application will drive you to the esug package folder ”

rosrun { package name } { package-binary-name } { arguments } ” This command execute a binary of a package, generally this means a ROS Node that will have some responsibility”

rosrun esug pharos {script name} “punctually this command will execute a given script. ”
rosrun esug headless { script name } ” this command works like pharos command, but starts with a headless VM. Regard the inspects and halts before use this”
rosrun esug edit ” this command will open the image related without execute anything. This way, each package has its own image, and is easy to point to it and edit or browse it”
In order to change IP/Port of the ROS master, you need to change both, ~/.bashrc file (Changing the Environment variables) and also the constructors used by the scripts.


It is there any cheat sheet to have all the commands ? 

Yes of course: right here


Ok, i just execute the turtlesimpharo script, nice, there are more examples right? 

yes of course :), here you have an other one a bit more complex

rosrun esug turtlesimpursuitturtles


 Yeah! I love it, how do i make my own code?

A great way to begin is browsing PhaROSEsug package, it has commented methods and uses all the basic stuff. We will make some tutorials for advanced usage, but mean while you can have fun with that and browsing code and tests is always allowed ;).


 I made roscd esug, and i found a lot of folders! i don’t understand anything!

├── bin
│   ├── edit
│   ├── headless
│   └── pharos
├── build
├── CMakeLists.txt
├── ex.launch
├── image
│   ├── Pharo.changes
│   ├── PharoDebug.log
│   ├── Pharo.image
│   ├── PharoV10.sources
│   └── scripts
│   ├── turtlesimpharo
│   ├── turtlesimpursuitturtles
├── include
├── msg
├── package.xml
├── src
└── vm
└── pharo -> /home/pharos/vm/pharo


we have the commands to interact with the related package-image


Is here to keep layout compatibility with ROS. Maybe will store package-cache in the future.

ROS give a make tool in order to generate infrastructure code, like the structures related with topic messages. Actually this file should be mantained by hand.
In this folder we encounter the related image, the common source/changes bundle, and the scripts folder


In this folder we have all the scripts that we can run with this package. This files are actually generated and related with script methods in the package-related-object in the image side. (To look for the object of esug package punctually, browse PhaROSEsug ).



This folder is for ROS layout compatibility. We are not currently using this folder.
This folder is for message definition files ( .msg extention). This folder is mantained automatically with the type generation from image side, but you can also add your own types with no relation with the image side. In any case, messages and it dependancies should be updated in the ros infraestructure files (CMakeLists.txt, package.xml)

This is the package description file that ROS use to define compile-time / runtime dependancies, author, etc. You should not worry about this file in any case but in the case of new types definition.

This folder is for ROS-fuerte layout compatibility. Is actually deprecated and it will be removed soon.
This folder has the vm needed to run the exisiting image and code. Commonly is a symbolic link to the VM that the image creator of the package.
This folder and vm are usually pointed by the scripts at the bin folder.







At the ESUG 2013 conference, we presented the current status of the RoboShop project. Santiago did a great job and now we are able to run tests of our scenario of a helper robot  in a shopping mall. Based on a map built using laser SLAM, the robot computes the shortest path to fetch items listed by a customer in a shopping list. The slides below include a video of the first tests. They also give a bird’s eye view of the architecture, where we use Pharo for orchestration. We also reuse existing software from the ROS community through our client PhaROS.

Location: Mines de Douai and ENSTA Brest (France)

Advisor and contacts:
Noury Bouraqadi, Luc Fabresse, Jannik Laval (car _at_ mines-douai.fr, website: http://car.mines-douai.fr/)
Loïc Lagadec (loic.lagadec _at_ ensta-bretagne.fr)

Profile: the candidate must hold a recent Master of Science degree in Computer Science or Software Engineering and must have solid skills in dynamic reflective language and OOP.

Description of the work:
The goal of this PhD is to study Smalltalk integration with FPGAs for robotic applications. This integration will enable us get the best from both worlds. Developers are provided with a high-level dynamic reflective language (Smalltalk) for building and debugging their applications. Still, we can have high performances by projecting part of the programs into FPGAs. These reconfigurable hardware chips can achieve performance faster than C programs, while consuming much less energy.

The work to do can decompose into the following tasks:
-Build reference robotic applications fully in Pharo Smalltalk using actual robots (see http://car.mines-douai.fr/robots/)
-Analyze these applications to identify critical parts to project on FPGAs to significantly increase performances (speed, energy)
-Do the actual projection to FPGA and evaluate performances of the transformed applications
-Generalize the approach and define a methodology for turning Smalltalk code into FPGA
-Propose a solution to automate the methodology

The Ph.D student will receive a grant which net amount is approximately 1420 euros per month for 3 years (36 months).
He will be co-supervised by Loïc Lagadec from the ENSTA-Bretagne (Lab-STICC, Brest) and Jannik Laval, Luc Fabresse and Noury Bouraqadi from Ecole des Mines de Douai (CAR, http://car.mines-douai.fr/).
The first 18th month will be spent in Douai (Lille area), while the last half of the PhD will be spent in Brest.
However, during the full 3 years, there will be a strong interaction with co-supervisers from both labs.

-A Robust Layered Control System For A Mobile Robot. R. Brooks. IEEE Journal of Robotics and Automation. Vol. 2. Num 1. March, 1985.
-RCS: A Cognitive Architecture for Intelligent MultiAgent Systems. J.S. Albus and A. J. Barbera. Proceedings of the 5th IFAC/EURON Symposium on Intelligent Autonomous Vehicles (IAV 2004). Lisbon, Portugal, 2004.
-Handbook of Robotics. Bruno Siciliano and Oussama Khatib editors. Springer. 2008.
-Multi-Level Simulation of Heterogeneous Reconfigurable Platforms. D. Picard and L. Lagadec. International Journal of Reconfigurable Computing. 2012.
-High-level synthesis for FPGAs: From Prototyping to Deployment. Jason cong and stephen neuendorffer and juanjo noguera and kees vissers and zhiru zhang. IEEE Transactions on Computer-aided design of integrated circuits and systems. Vol. 30. Num 4. April, 2011.
-The MOLEN Polymorphic Processor. S. Vassiliadis and S. Wong and G. Gaydadjiev and K. Bertels and G. Kuzmanov and E. Moscu Panainte. IEEE Transactions on Computers. 2004.

Last may, Dr. Luc Fabresse presented at the ICRA 2013 workshop on Software Development and Integration in Robotics (SDIRIII) our first results in the CAIRE project. It’s about a first version of BoTest, a first version of a UnitTest framework based on the work done in eXtreme Programming, that we adapted to the context of robotics. We give a glimpse of experiments we are doing with our robots. The slides of the presentation are available below.


My objective is to have:

  • A virtual image: VirtualBox (preferred), VMWare
  • with Ubuntu: precise? 12.04 (preferred because LTS), quantal 12.10, raring 13.04
  • ROS: Groovy (preferred because latest stable), Hydro (but still unstable), Fuerte (no because no Catkin)
  • MORSE simulator: 1.0 (latest stable), newer

If you don’t want to install it yourself, you can download my VMWare 4.1.4 image of a ROS Groovy on an Ubuntu Quantal 12.10 with MORSE (updated 2013-05-13).

If it works on a newer version of VMWare, please let me know.

Constraints & Incompatible Combinations

I learnt the hard way the multiple incompatible combinations ;-)
Here some constraints:

  • Ubuntu and ROS. You can find here a really good help. So, Groovy works on 12.04 and Quantal (12.10) but not Raring (13.04) which can be used with Hydro.
  • VirtualBox and Ubuntu. The following report on using the latest VirtualBox on OSX 4.2.x :
    • Ubuntu 12.04: no problem but Groovy cannot be installed on top of it.
    • Ubuntu 12.10: it is really slow. It seems to be 3D support problem but I did not succeed to fix it.
    • Ubuntu 13.04: it works perfectly after installing VBox tools and 3D acceleration (cf. here) but Groovy cannot be installed on top of it.
  • ROS and MORSE. MORSE requires Python>=3 but ROS is currently Python 2.7 compliant, even Hydro. However, the MORSE installations notes describes a solution to make install.

Finally I went for:

  • VMWare 4.1.4
  • Ubuntu 12.10
  • ROS Groovy
  • MORSE bleeeding edge

Step 1: Ubuntu Quantal (12.10) on VMWare 4.1.4

It has been straightforward. Steps:

  1. Download Ubuntu iso (ubuntu-12.10-desktop-i386.iso)
  2. Create a VM image in VMWare
  3. Boot on Iso mounted in CD
  4. Install
  5. VMWare Tools should install automatically
  6. Ensure that 3D acceleration checkbox is cheked in the VM preferences
  7. Ensure 3D acceleration is working well by doing in command line:

    /usr/lib/nux/unity_support_test -p

  8. I advise you to do a VM snapshot here ;-)

Step 2: ROS Groovy Installation

Documentation is here.

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu quantal main" > /etc/apt/sources.list.d/ros-latest.list'
wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
sudo apt-get update
sudo apt-get install ros-groovy-desktop-full
sudo rosdep init
rosdep update
echo "source /opt/ros/groovy/setup.bash" >> ~/.bashrc
source ~/.bashrc

Test that ROS is working

TODO: Je ne suis plus sûr de cette ligne ;-)
roscheck ?

You can also do the ROS tutorials.

Step 3: MORSE Installation

Documentation is here.
But we must make ROS Python 3 compliant first.

ROS and Python 3

Documentation is here.

Doing sudo apt-get install morse-simulator did not work for me because of Python problems.

Manual installation steps:

  1. Re-install ROS catkin_pkg from sources to make it use Python 3.
  2. git clone git://github.com/ros-infrastructure/catkin_pkg.git -b 0.1.9
    cd catkin_pkg
    sudo python3 setup.py install
  3. Re-install ROS catkin from sources to make it use Python 3. However, cloning the regular catkin repository on github did not work for me because of syntax changes in Python 3 (u"xxx" not supported anymore). So I use here my cloned and modified version. However, I advise you to first check if it has been corrected in the official repository.
  4. # slightly modified version of catkin to support Python 3
    git clone git://github.com/LucFabresse/catkin.git
    cd catkin
    sudo python3 setup.py install

MORSE real Installation

sudo apt-get install python3-dev    
cd ~
git clone https://github.com/laas/morse.git
cd morse    

# if you want a stable version, just checkout the right branch or skip the next command
git checkout -b 1.0_STABLE -t origin/1.0_STABLE

mkdir build && cd build     

# compile with the support you need. have a look at cmake --help.

sudo make install

You can now test that MORSE is working by executing:

morse check

Step 4: Post-Install

Congrats, if you reached this step, everything is done and you can work.

But I advise you to do a VM snapshot or better a VM clone ;-)

How to Update the Installation

For Ubuntu and ROS:

apt-get update
apt-get upgrade

Be careful, it may install a non Python3-compliant ROS version!

cd ~/morse
git pull
cd build
sudo make install

Use it remotely

You can even use it remotely through ssh -X


That’s all folks.
I hope it saved some time for someone out there.

I created a repository that will contain my new packages:

rosinstall ~/ros /opt/ros/groovy/ 
echo "source ~/ros/setup.bash" >> ~/.bashrc 
source .bashrc

Do a checkout manually of the sources:

svn co https://svn.code.sf.net/p/bosch-ros-pkg/code/trunk/stacks/exploration ~/ros/exploration

There is an broken link to btVector3 in the following file: ~/ros/exploration/explore/include/explore/explore_frontier.h

Just change the line

#include <LinearMath/btVector3.h>


#include <tf2/LinearMath/btVector3.h>

Then you can build the project:

rosmake exploration

Before running explore, launch turtlebot and gmapping:

roslaunch turtlebot_bringup turtlebot.launch
roslaunch turtlebot_navigation gmapping_demo.launch

To run the explore node, run this command line:

roslaunch ~/ros/exploration/explore_stage/explore.xml

On the Turtlebot:

1- update via apt-get

sudo apt-get update
sudo apt-get upgrade

2- fix ip address

ip: 10.1.161.xx

3- update ros

sudo apt-get install python-rosdep
rosdep update

4- install ros-turtlebot:

 sudo apt-get install ros-groovy-turtlebot ros-groovy-turtlebot-apps ros-groovy-turtlebot-viz

5- Install Chrony

sudo apt-get install chrony

6- manually sync NTP

sudo ntpdate

7- modify the file

/etc/chrony/chrony.conf with the correct ntp: add the line "server"
you can comment the other servers.

On the workstation

1- Install Chrony

 sudo apt-get install chrony

2- manually sync NTP

sudo ntpdate

3- fix ip address

ip: 10.1.161.xx

4- install:

sudo apt-get install ros-groovy-turtlebot ros-groovy-turtlebot-apps ros-groovy-turtlebot-viz 
. /opt/ros/groovy/setup.bash
rosrun kobuki_ftdi create_udev_rules
echo "source /opt/ros/groovy/setup.bash" >> ~/.bashrc

Then on robot computer: 

echo export ROS_MASTER_URI=http://IP_OF_TURTLEBOT:11311 >> .bashrc
echo export ROS_HOSTNAME=IP_OF_TURTLEBOT >> .bashrc
source .bashrc

Then on workstation:

echo export ROS_MASTER_URI=http://IP_OF_TURTLEBOT:11311 >> .bashrc
echo export ROS_HOSTNAME=IP_OF_WORKSTATION >> .bashrc
source .bashrc


on turtlebot:

1- the topics:

 rostopic list

>>I had an error, so I did:

sudo apt-get upgrade
sudo apt-get install ros-groovy-actionlib
sudo apt-get install ros-groovy-rosgraph
roslaunch turtlebot_bringup minimal.launch

>>Then, reexecute the line, it should work:

rostopic list

2- the environment:

rostopic echo /diagnostics

on workstation:

rostopic list
rostopic echo /diagnostics

Last verification:

on workstation:

rostopic pub -r10 /hello std_msgs/String "hello"

on turtlebot:

rostopic echo /hello

The message “hello” begin printed about 10 times a second.



All works now, you can run this line on the robot (I desactivated the automatic launch of the turtlebot nodes)

roslaunch turtlebot_bringup turtlebot.launch

Sometimes, this does not work. Just finish the process (Ctrl-C) and rerun it. Sometimes, I do that 3 or 4 times before it works.

To run the camera and 3d sensors, run this line:

roslaunch turtlebot_bringup 3dsensor.launch

On the workstation, you can open the diagnostic panel:

rqt -s kobuki_dashboard

Now, you can play with Turtlebot tutorials:

  • http://www.ros.org/wiki/turtlebot_bringup/Tutorials/groovy/3D%20Visualisation
  • http://www.ros.org/wiki/turtlebot_teleop/Tutorials/Keyboard%20Teleop
  • http://www.ros.org/wiki/turtlebot_navigation/Tutorials/Autonomously%20navigate%20in%20a%20known%20map

Some other tips:


I installed ROS on a VMWare 5, Ubuntu 12.04.
Due to the generic drivers, RViz does not work well. You have to add this line in your .bashrc:
I also change the file /etc/ld.so.conf.d/GL.conf (not sure it has an impact): I removed the term “mesa” in the file (not the line, only the word).

Building the map:

To build the map, do not launch 3dsensor before.



This documentation is based on: http://www.ros.org/wiki/fuerte/Installation/OSX/Homebrew/Source.  Only the three points in red are different from the official documentation.

Start by installing Homebrew and configuring the environment to use Homebrew.


Install Homebrew

You can install Homebrew, after satisfying the requirements, by running this script in a terminal:

ruby <(curl -fsSkL raw.github.com/mxcl/homebrew/go)

Once the installation is completed update Homebrew to ensure the latest sources:

brew update

Prepare Environment for Homebrew

You will need to add these lines to your ~/.bash_profile to have Homebrew be at the front of the PATH.

export PATH=/usr/local/bin:$PATH

export PYTHONPATH=”/usr/local/lib/python2.7/site-packages:/usr/local/lib/python:$PYTHONPATH”

In order for the above changes to take effect reopen the terminal or run this command:

source ~/.bash_profile

Add the ROS Fuerte Homebrew Tap

Execute the following line to add the official ROS Fuerte Homebrew repository (“tap” in Homebrew terminology).

brew tap ros/fuerte


In order to install the first part of ROS some system dependencies need to manually be satisfied.

Env Setup

export ROS_OS_OVERRIDE=osx:homebrew

Python Dependencies

Change the permissions of your Python, Ruby, and Perl library directories to prevent the need for sudo when running pip. This is recommended by the Homebrew developers, but not strictly necessary.

sudo chown -R $USER /Library/Ruby /Library/Perl /Library/Python

Install pip and setup tools from easy_install:

easy_install pip
easy_install setuptools

Install the PyYAML dependency by executing the lines below:

brew install libyaml
pip install -U PyYAML

Install Mercurial:

pip install mercurial

Install some Catkin Python Dependencies:

pip install -U empy nose

Homebrew Dependencies

Install some other dependencies for the Catkin based ROS stacks to be installed:

brew install cmake
cd /usr/local && git checkout 57665ff /usr/local/Library/Formula/boost.rb
brew install boost
cd /usr/local/Library/Formula && curl -O https://raw.github.com/mxcl/homebrew/ac18935be50d603a64363ba9104b91c643992dce/Library/Formula/gtest.rb
brew install gtest
brew install log4cxx
brew install qt

To install swig-wx :

git clone –branch 1.3.29_fuerte git://github.com/ros/swig-wx.git /Library/Caches/Homebrew/swig-wx–git
2) cd /Library/Caches/Homebrew/swig-wx–git/
3) ./configure
4) make
5) make install

Binary Dependencies

Install wxPython by downloading and installing the binary distribution from their development website: http://downloads.sourceforge.net/wxpython/wxPython2.9-osx-

At least Mountain Lion has problems with package format. After mounting the image you have to run

sudo installer -pkg /Volumes/wxPython2.9-osx- -target /

After installing wxPython from the binary, you need to add this line to your ~/.bash_profile in order for ROS to find it:

export PATH=/usr/local/lib/wxPython/bin:$PATH

Make sure to make the changes take effect:

source ~/.bash_profile

Install the nVidia CG toolkit for rViz by download their installation package: http://developer.download.nvidia.com/cg/Cg_3.1/Cg-3.1_April2012.dmg


The core ROS libraries and tools are installed into /opt/ros/fuerte. The higher-level ROS libraries are simply built using rosmake, which is familiar to users of previous versions of ROS. The higher-level ROS stacks are downloaded and built in inside the ~/ros directory.

First install rosinstallrospkg and rosdep:

sudo pip install -U rosinstall
sudo pip install -U rospkg
sudo pip install -U rosdep

Install core libraries

The following instructions will create a system install of the core ROS libraries and tools. The installation is done using standard CMake/make tools, so experts can adjust to their liking.

rosinstall –catkin ~/ros-underlay http://ros.org/rosinstalls/fuerte-ros-full.rosinstall

Build and install the underlay into /opt/ros/fuerte:

cd ~/ros-underlay mkdir build cd build

Before running cmake, change the source code of the file: ~/ros-underlay/ros_comm/utilities/xmlrpcpp /src/XmlRpcSocket.cpp. Replace MSG_NOSIGNAL by 0. MSG_NOSIGNAL is a proprietary Linux manifest (i.e. it is non-posix/Xopen). Just replace it with 0 (the number 0).

Now, run cmake.


Finally, build and install the code:

make -j8
sudo make install

Verify the installed environment:

. /opt/ros/fuerte/setup.sh
which roscore

You should see:


You can delete ~/ros-underlay now, if you wish. The ROS core libraries are now installed onto your system.

Higher-level robotics libraries and tools

Desktop-Full Install: ROS Full, rviz, robot-generic libraries, 2D/3D simulators, navigation and 2D/3D perception

rosinstall ~/ros “http://packages.ros.org/cgi-bin/gen_rosinstall.py?rosdistro=fuerte&variant=desktop-full&overlay=no”

Environment Setup

You’ll now need to update your environment. You can do this by typing:

source ~/ros/setup.bash

It’s convenient if the ROS environment variables are automatically added to your bash session every time a new shell is launched, which you can do with the command below:

echo “source ~/ros/setup.bash” >> ~/.bash_profile . ~/.bash_profile

Build Higher-level/tools

First, initialize your rosdep. ROS Fuerte comes with rosdep 2. If you get a message that your default sources list exists, then don’t worry as it means you’ve done this before.

sudo rosdep init rosdep update

Before finishing installation: remove the <catkin/> tag in /opt/ros/fuerte/share/rospack/manifest.xml.

Now, use rosdep 2 to install system dependencies.

rosdep install -ay

Finally, build the ROS stacks using rosmake.

rosmake -a