The french academic system requires that people pass yet another diploma higher than the PhD before applying for a full professor position. The diploma is called “Habilitation à Diriger les Recherches” (HDR for short) which stands for “Ability to Supervise Research”. It requires writing a thesis presenting how the candidate co-supervised PhD students and Post-Doc, and the strategy  of conducted research.

Since all 3 reviewers approved my thesis, I can proceed with the defense. So, I’m glad to announce that it will be held on 10:30, the 6th December 2013, at Ecole des Mines de Douai of course. My talk is entitled: “On Flexible Autonomous and Mobile Multi-Robot Systems”. You’ll find below a summary as well as names of jury members. The defense is public and you are welcome to attend.

Last, I would like to acknowledge that I have been supported for this work by several people, for many years. Unfortunately, I can name here only a few of them: Stéphane Ducasse, Luc Fabresse, Serge Stinckwich, Georg Heeg, Jannik Laval, Anaud Doniec, Anthony Fleury,  Cécile Labarre, Christine Delille, and Muriel Morgan.


Research I have been conducting and co-supervising so far address control software for robots that are both mobile and autonomous. Such  a robot is able to perform its missions and to move in a partially known changing environment, without any human assistance. I have been targeting solutions which assist software developers in different stages of the process of building flexible multi-robot systems. I have relied on a thought framework structured around four pillars: software components, aspect-oriented programming, dynamic languages and multi-agent systems. Part of my contributions address the microscopic scale of multi-robot systems, that is robots considered as individuals. We have thus proposed programming models, that merge aspect-oriented programming and components. Our goal is to favor modularity in order to introduce flexibility during software development and maintenance. Then, we have studied flexibility at run-time by introduce software architecture that support dynamic self-adaptation. As a result, such an architecture enables robots to evolve their behavior at run-time according to environmental changes and to the task at hand. We have complemented these contributions by introducing  development tools and execution infrastructures that take into account resource constraints. For instance, we have introduced a model of an application-driven object-oriented virtual memory. It allows adapting RAM usage by dynamically loading/unloading object graphs. We have also proposed a framework for remote debugging that is required for software-hardware integration tests. This proposal relies on a remote meta-level located on the developer machine, that controls a base-level located on a robot. Another facet of my research tackles the macroscopical level, that is multi-robot systems considered as a whole. Part of this work is a follow up to our use of components in robot control architectures. It consists in making robots coordinate their decisions for local dynamic adaptations by exchanging software components. These interactions as well as any high-level coordination require remote communications. However, network infrastructures are not always available. We have addressed this issue by proposing a light-weight distributed algorithm where robots organize themselves to set up an ad hoc mobile network. We have built on top of this solution a distributed multi-robot exploration strategy. It allows a robotic fleet to collaboratively build a map while maintaining a network connectivity and compensating for possible disconnections.


Promotor: Stéphane DUCASSE, Research Director at INRIA, Scientific Director of INRIA Lille, Head of the RMoD Team – Lille  (France)


  • Michel OCCELLO, Professor at Université Pierre Mendes France (Grenoble 2), Head of the COSY team (LCIS) – Grenoble  (France)
  • Rachid ALAMI, Research Director at CNRS, Head of the RIS team (LAAS) – Toulouse (France)
  • Theo D’HONDT, Professor at Vrije Universiteit Brussel, Software Languages Lab – Brussels (Belgium)


  • Davide BRUGALI, Professor at Università Degli Studi Di Bergamo, Head of the Software for Experimental Robotics Lab – Bergamo (Italy)
  • Jacques FERBER, Professor at Université de Montpellier 2, SMILE team (LIRMM) – Montpellier (France)


As part of the Robotics Week 2013 organized  by the non-profit euRobotics, we will be presenting demos featuring some robots we are using for our research. Our goal is to increase awareness of the general public to current status of robotics and what robots can actually do. We will present different kinds of robots and demo their capabilities through some application scenarios.

Demos will be held in the Département Informatique et Automatique at the Ecole des Mines de Douai (Northern France). If you wish to attend, please drop us an email: car @ minesdouai . fr. We scheduled demos the 28th of november 2013 at the following hours:
* morning from 10:00am to 12:00am
* afternoon from 2:30pm to 4:30pm

You can find more info on this event on the dedicated page.

In a recent experiment we demoed a scenario of how a robot can be used to help shoppers (see Video below). The robot computes the optimal path for picking items of an arbitrary shopping list. It carries the bag and guides the shopper to items locations.  As we explain in the slideshow (below the video), there are other possible applications of mobile robots in a shopping. We also give a quick overview of hardware and software. We reused some existing ROS packages that we combined with our own software built using the PhaROS client based on Pharo a Smalltalk inspired OO dynamic language.

Video: A Robot Made to Help Shoppers

Slideshow about the RoboShop project

Firstly, assuming you have already installed ROS Groovy and MORSE 1.x.x.

Then you need two additional packages p2os and exploration:

git clone
svn co

Finally, download the attachment (yz_morse_sim), decompress it and enter into the folder morse_sim.

Now, let’s start the simulation!

1. Launch roscore in a terminal window:


2. Launch MORSE simulator in a new terminal window:

morse run

3. Launch ROS nodes in a new terminal window (This step will also launch gmapping and rivz):

roslaunch single_robot.launch

4. Save the map if you want, in a new terminal window:

rosrun map_server map_saver


Firstly, assuming you have already installed ROS Groovy and Stage 3.x.x.

Then you need two additional packages p2os and exploration:

git clone
svn co

Finally, download the attachment (yz_stage_sim), decompress it and enter into the folder stage_sim.

Now, let’s start the simulation!

1. Launch roscore in a terminal window:


2. So, you have three options to implement the exploration: teleoperation, exploration and exploration with SLAM, in a new terminal window:

roslaunch teleop.launch (or explore.launch, or explore_slam.launch)

3. You can track the exploration progress by using rviz, in a new terminal window:

rosrun rviz rviz -d stage.rviz

4. If you want build a map by teleoperation, in a new terminal window:

rosrun gmapping slam_gmapping scan:=base_scan

5. Save the map, in a new terminal window:

rosrun map_server map_saver


Being a TDD fan, I’m writing tests all the time. And I sometimes ended up having groups of nearly identical tests:

  • they use exactly the same objects, send the same messages,
  • but they differ only by values.

In a discussion on the Pharo-dev mailing list, Laurent Laffont pointed what is done in PhpUnit and suggested to have something similar in Pharo. After a few hours hacking I’ve my parametrized tests working and integrated with the test runner to ease debugging.

I’ve introduced a ParameterizedTestCase which supports both “plain” tests as well as parametrized tests. This class should be subclassed as in the following example:

ParameterizedTestCase subclass: #ExampleOfParameterizedTestCase
        instanceVariableNames: ”
        classVariableNames: ”
        poolDictionaries: ”
        category: ‘ParameterizedTests’

A test method is any method that is marked with the pragma testParametersSelector: as in the following example:

ExampleOfParameterizedTestCase>>#should: value1 plus: value2 equals: expectedSum
        <testParametersSelector: #givenValuesAndTheirExpectSum>
        self assert: value1 + value2 equals: expectedSum

The argument of the pragma testParametersSelector: is the selector of a method that provides a collection of arrays. Each array gathers parameters for a different test case. In our example the method givenValuesAndTheirExpectSum is defined as following:

        ^{{1. 2. 3}.
        {10. 20. 30}.
        {100. 200. 300}}

Since we have three arrays of parameters, we will have 3 different test cases all three with the same test selector, but each with a different parameters array. This is displayed by the test runner as shown in picture 1.


Picture 1: Passing Parametrized Test

If any of the parameters arrays leads to a test failure, the Test Runner will display the failing test selector as well as the parameters that lead to the defect. For demo purpose, let’s introduce some invalid parameters and change the previous givenValuesAndTheirExpectSum method as following:

        ^{{1. 2. 3}.
        {10. 2. 30}.
        {100. 200. 0}}

I have changed the second and the third parameter arrays. The Test Runner detects indeed 2 failing tests out of 3 runs as shown in picture 2. As you can see the parameters that lead to the defect are displayed so, one can identify the origin of the defect.


Picture 2: Failing Parametrized Test

I have developed and tested parametrized tests under Pharo 2.0. If you want to try it, you can install it by evaluating the following expression in a workspace.

Gofer it
        url: ‘’;
        package: ‘ParameterizedTests’;

It is worth noting that although in the examples I have given above data is hard coded, nothing prevent from adopting an approach as suggested by Frank Shearar in his Squeak Check project. Method that return the array of parameters can rely on any arbitrary complex data generator class, that may produce different data randomly each time tests are run.

Zhi YAN (Web Page) is a new postdoc in our team since september, 15th 2013. He will work 12 months on our CAIRE project. Today, Zhi presented us some of its work during its PhD.

Presentation title: Tasks and motion planning for multi-robot systems

Summary: This presentation focuses on the issue of multi-robot coordination from the standpoint of planning, which contains task planning and motion planning.
Two new approaches are proposed for the task planning. The first one is a decentralized approach based on trading rules. This approach is designed to simulate the relationship between buyers and sellers in a business system, to achieve dynamic task allocation by using a mechanism of unsolicited bid. The second approach is an heuristic one which is based on an empirical model. It is designed to assign the transportation task to individual robots by estimating the production rate of goods in a centralized system.
Two new approaches are proposed for the motion planning. Both are sampling-based approaches, designed to plan separate kinematic paths for multiple robots to minimize the issue of waiting situation including congestion, collision and deadlock, in an effective way in order to improve the system planning efficiency. All these proposed approaches have been tested and evaluated through simulation experiments.

Slides (in French)



Well. after some administrative tasks, im happy to open to community the issue tracker for PhaROS!

So, any problem you have, please do not hesitate in submit a ticket.
 Thanks for the feedback :)





What ever base system you choose, we encourage you to install Ubuntu 12.04 or greater. (This how to is based on this distribution)


Install ROS –  (Based on tutorial


1- Add to the list of package repositories

sudo sh -c ‘echo “deb precise main” > /etc/apt/sources.list.d/ros-latest.list’

2- Add to your system ROS keys to allow identifying ROS packages as trusted

wget -O – | sudo apt-key add -

3- Ensure that the index of packages from server are up to date

sudo apt-get update

4- Install the appropriate ROS package. We chose the recommended option which is to install the full ROS

sudo apt-get install ros-groovy-desktop-full

5- Add ROS variables to the environment of your current terminal

source /opt/ros/groovy/setup.bash

6- Install the recommended standalone command-line tools rosinstall and rosdep. rosinstall eases downloading source trees for ROS packages and stacks. rosdep simplifies installing system dependencies for sources before compilation.

sudo easy_install -U rosinstall vcstools rosdep

7- Add to the .bashrc file environment variables that should be set on every session for ROS.

echo “source /opt/ros/groovy/setup.bash” >> ~/.bashrc

8- Add to the .bashrc file environment variables for ROS network setup. We provide here only the code required to run ROS on a single machine which is enough for running the ROS tutorials. If you plan to use more one machine, you should use an alternate configuration as suggested in our tutorial on ROS Networking.

echo “export ROS_HOSTNAME=localhost” >> ~/.bashrc
echo “export ROS_MASTER_URI=http://localhost:11311″ >> ~/.bashrc


Before go further, open a new terminal to let bash load new environment configuration


Creating catkin package

 mkdir -p ~/ros/workspace/src
cd ~/ros/workspace/src
cd ~/ros/workspace/
echo “source ~/ros/workspace/devel/setup.bash” >> ~/.bashrc




Before go further, open a new terminal to let bash load new environment configuration


Installing Pharo (Based on this post

#install the PPA repository

sudo add-apt-repository ppa:pharo/stable

sudo apt-get update


#install pharo vm for desktop (with graphical dependencies)

sudo apt-get install pharo-vm-desktop


mkdir pharo
wget -O- | bash


Installing PhaROS

$ ./pharo-ui Pharo.image

” Downloading code ”
“In a workspace”
Gofer it url: ‘’; package: ‘ConfigurationOfPhaROS’;load.

(Smalltalk at: #ConfigurationOfPhaROS) project load: ’1.0-Beta3′.

“Save image :) “


Installing example package


” Installing ESUG example package ”

PhaROSEsug install:’~/ros/workspace/src’.


” This line will deploy other image into the catkin workspace that is related with PhaROSEsug code.

So this image, the one that deploys is not the one that will be used, but you can keep using it for further installations “



rosrun esug headless turtlesimpursuitturtle




Please let us know if there is any problem =)