noury « CAR: Components, Agents, and Robots

Faisant suite aux différentes précédentes éditions des JNRH et JNCAR, les GT Robotique Humanoïde et Architecture de Contrôle en Robotique (http://www.gdr-robotique.org) et l’Université de Versailles Saint Quentin (Laboratoire LISV) ont le plaisir de vous annoncer la tenue des journées nationales de la robotique humanoïde et des architectures de contrôle des robots les lundi 23 et mardi 24 juin 2014.

Ces journées ont pour objectif de réunir les communautés nationales de la recherche et de l’industrie autour des problématiques de la robotique humanoïde et des architectures de contrôle des robots.
Ces problématiques concernent par exemple la conception mécanique de nouvelles structures anthropomorphes, la modélisation, la commande, ou l’optimisation pour la gestion de la redondance ou la planification de trajectoires.
Pour ce qui est des architectures de contrôle, les préoccupations concernent les logiciels embarqués pour contrôler des robots individuels ou coordonner des systèmes multi-robots. L’intégration logicielle des fonctionnalités du robot est devenu une problématique centrale pour la future industrie de la robotique de service (médicale, d’assistance, industrielle, etc.), amenant à considérer de multiples aspects dont par exemple la montée en abstraction via l’ingénierie dirigée par les modèles et les langages dédiés, les problèmes d’exécution distribuée, la validation et la simulation (e.g. hardware in the loop).
Un deuxième objectif, sera de renforcer les liens entre la communauté des architectures de contrôle en robotique et celle de la robotique humanoïde afin de pouvoir s’enrichir mutuellement des connaissances et résultats réciproques. Cela se traduira notamment par des sessions uniques pour favoriser les échanges entre les deux communautés.

Participation et déroulement de ces journées :
Nous invitons la communauté scientifique à proposer des présentations autour des thèmes précédemment cités. Cette proposition sera faite sous la forme d’un résumé d’une page à soumettre au format pdf à l’adresse suivante :
jnrh-car@lisv.uvsq.fr
Ces présentations seront d’une durée d’environ 30mn avec une place importante accordée aux questions et à la discussion (15mn).
Ces journées débuteront lundi 23 juin à 9h30 et se termineront le mardi 24 juin à 17h.
Agenda des journées :
- Soumission du résumé avant le 09/05/2014
- Programme des journées disponible le 30/05/2014

A team of our students is competing for the 2014 edition of the Eurobot contest (french chapter). Their PhaROS-based robot came to life. You can see it in action in the videos below.

As part of the PhaROS and related projects, Santiago Bragagnolo had developed TaksIt a framework for to ease handling concurrency. Expressing and managing concurrent computations is indeed a concern of importance to develop applications that scale. A robotic application often have different processes dealing with different activities (e.g. preception, planning, …).

TaskIT provides abstractions to schedule and/or parallelize of the execution of pieces of code. They will be described in the forthcoming chapter of the Pharo for the Entreprise book. First content is already available online. You can also get the code by evaluating the following expression in a Pharo workspace:

Gofer it smalltalkhubUser: 'sbragagnolo' project: 'TaskIT'; configurationOf: 'TaskIT'; loadVersion: #bleedingEdge

After 3 years of work, Nick is about to finish his PhD. His defense is planned on the 19th of December 2013 at 10:00. It will be held at Ecole des Mines de Douai. You’ll find below the abstract and the keywords that describe his work entitled: “Remote debugging and reflection in resource constrained devices”. The committee gathers the following people:

Reviewers:

Marianne Huchard, Professor at University of Montpellier, LIRMM Laboratory, France
Alain Plantec, Associate Professor at University of Brest, Lab-STICC Laboratory, France

Members:

Roel Wuyts, Professor at K University of Leuven, Belgium
Serge Stinckwich, Associate Professor at University of Brest, and member of the IRD research Institute, Bondy, France

Advisor: Stéphane DUCASSE, Research Director at INRIA, Scientific Director of INRIA Lille, Head of the RMoD Team, France

Co-Advisors:

Luc Fabresse, Associate Professor at Ecole des Mines of Douai, France
Marcus Denker, Researcher at INRIA Lille, RMoD Team, France
Noury Bouraqadi, Associate Professor at Ecole des Mines de Douai, France

Summary of the PhD

Building software for devices that cannot locally support development tools can be challenging. These devices have either limited computing power to run an IDE (e.g smartphones), lack appropriate input/output interfaces (display, keyboard, mouse) for programming (e.g mobile robots) or are simply unreachable for local development (e.g cloud servers). In these situations developers need appropriate infrastructure to remotely develop and debug applications.

Yet remote debugging solutions can prove awkward to use due to their distributed nature. Empirical studies show us that on average 10.5 minutes per coding hour (over five 40-hour work weeks per year) are spend for re-deploying applications while fixing bugs or improving functionality. Moreover current solutions lack facilities that would otherwise be available in a local setting because its difficult to reproduce them remotely (e.g., object-centric debugging). This fact can impact the amount of experimentation during a remote debugging session – compared to a local setting.

In this dissertation in order to overcome these issues we first identify four desirable properties that an ideal solution for remote debugging should exhibit, namely: interactiveness, instrumentation, distribution and security. Interactiveness is the ability of a remote debugging solution to incrementally update all parts of a remote application without losing the running context (i.e without stopping the application). Instrumentation is the ability of a debugging solution to alter the semantics of a running process in order to assist debugging. Distribution is the ability of a debugging solution to adapt its framework while debugging a remote target. Finally security refers to the availability of prerequisites for authentication and access restriction.

Given these properties we propose Mercury, a remote debugging model and architecture for reflective OO languages. Mercury supports interactiveness through a mirror-based remote meta-level that is causally connected to its target, instrumentation through reflective intercession by reifying the underlying execution environment, distribution through an adaptable middleware and security by decomposing and authenticating access to reflective facilities. We validate our proposal through a prototype implementation in the Pharo programming language using a diverse experimental setting of multiple constraint devices. We exemplify remote debugging techniques supported by Mercury’s properties, such as remote agile debugging and remote object instrumentation and show how these can solve in practice the problems we have identified.

Keywords: Remote Debugging, Reflection, Mirrors, Interactiveness, Instrumentation, Distribution, Security, Agile Development

After initials tests we have made at the lab, we presented our RoboShop project on the 16th of October, as well as during 3 days from 21st to 23rd october in two different events outside our university. The stand was small. Yet we managed to successfully run our demo of a helper robot that targets shopping malls (see video below). We will be presenting even more demos to the public on thursday 28th november as part of the European Robotics Week. We will report them here. Stay tuned.

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.

SUMMARY

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.

JURY

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

Reviewers:

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)

Members:

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 @ mines – douai . 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

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:

ExampleOfParameterizedTestCase>>#givenValuesAndTheirExpectSum
        ^{{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:

ExampleOfParameterizedTestCase>>#givenValuesAndTheirExpectSum
        ^{{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: ‘http://car.mines-douai.fr/squeaksource/BoTest’;
        package: ‘ParameterizedTests’;
        load.

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.

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.

First Tests of a Helper Robot in a Shopping Mall from nourybouraqadi

CAR: Components, Agents, and Robots

with Dynamic Languages

Author Archives: noury

Journées Nationale Robotique Humanoïde et Architecture de Contrôle en Robotique (JNRH-CAR) 2014

PhaROS in a Student’s Robot

TaskIt: a Framework for Concurrency

PhD Defense of Nick Papoulias on 19th December 2013

Video of the Public Demo of Our Helper Robot in a Shopping Mall (16 oct 2013)

HDR Defense of Noury on 6 December 2013

Come Celebrate the euRobotics Week with Us

Our Robots Can Help You Shopping

Parametrized Tests

First Tests of a Helper Robot in a Shopping Mall