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.
cmake -DPYMORSE_SUPPORT=ON -DCMAKE_BUILD_TYPE=Release -DBUILD_ROS_SUPPORT=ON -DPYTHON_EXECUTABLE=`which python3` .. 

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

Conclusion

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>

to

#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
gateway: 10.1.1.1
netmask: 255.255.0.0
Proxy: 10.1.1.3:8080

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 10.1.1.2

7- modify the file

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

On the workstation

1- Install Chrony

 sudo apt-get install chrony

2- manually sync NTP

sudo ntpdate 10.1.1.2

3- fix ip address

ip: 10.1.161.xx
gateway: 10.1.1.1
netmask: 255.255.0.0
Proxy: 10.1.1.3:8080

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

Verification:

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:

echo $ROS_MASTER_URI
rostopic echo /diagnostics
echo $ROS_HOSTNAME

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.

 

Finally

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:

VMWare:

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:
export LIBGL_ALWAYS_SOFTWARE=1
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.

Requirements

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

Bootstrapping

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-2.9.4.0-cocoa-py2.7.dmg

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

sudo installer -pkg /Volumes/wxPython2.9-osx-2.9.4.0-cocoa-py2.7/wxPython2.9-osx-cocoa-py2.7.pkg/ -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

rosinstall

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.

cmake .. -DCMAKE_INSTALL_PREFIX=/opt/ros/fuerte -DSETUPTOOLS_DEB_LAYOUT=OFF

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:

/opt/ros/fuerte/bin/roscore

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

The 11th IEEE International Symposium on Safety, Security, and Rescue Robotics continues its tradition of attracting cutting-edge papers in the theory and practice of robots for all types of safety, security, and rescue applications such as disaster response, mitigation and recovery; rapid and secure inspection of critical infrastructure; detection of chemical, biological and radiological risks, and operations in these dangerous sites.

SSRR 2013 also serves as an entry point for researchers and technologists who want to learn more about safety, security and rescue robotics, through tutorials and keynotes.

A Rescue Robotics Camp, attached to the conference, gives participants the opportunity to learn about the state of the art algorithms for Search and Rescue Robots and their use. The camp is organized in collaboration with the NIFTi EU project and RoboCup.

Papers and participation fall into:

  • Regular papers (4-6 pages) describing original work in SSR or work that can be applied to SSR domains.
  • Center/project papers (2-4 pages) describing work at centers or active multi-institutional projects.
  • Vision papers (2-4) presenting long-term challenges or new ideas outside of the mainstream in computing for SSR robotics.
  • Late Breaking Reports (1-2 pages) contributing novel directions or work which has not been fully analyzed or explored. Late Breaking Reports are reviewed and the relevance of the material to the SSR domains must be clear.

Topics include but are not limited to:

  • Biologically inspired solutions
  • Casualty assessment, care and extraction
  • Chemical, biological, or radiological events
  • Computer vision
  • GPS-denied navigation and mapping
  • Humanoid robots
  • Humanitarian demining
  • Human-robot interaction
  • Inspection of critical infrastructure
  • Manipulation
  • Multi-agent coordination
  • Nuclear decommissioning
  • Sensing and sensor fusion
  • SLAM in extreme environments
  • Structural assessment
  • Telemedicine
  • Unmanned ground, aerial, and marine vehicles
  • Urban search and rescue
  • Wildland fire fighting

In addition, SSRR 2013 encourages the submission of “non-traditional” papers which contribute to understanding robot systems for Public Safety and have an explicit link to Public Safety but may not have results in a high fidelity SSRR domain.

SSRR 2013 will have three paper awards:

  • Best Paper Award
  • Best Student Paper Award
  • Outrageous Visions Award

Important Dates

  • Jun 14, 2013 Submission of proposals for tutorials and special sessions
  • Jul 19, 2013 Submission of regular papers, center/project papers, and vision papers
  • Aug 26, 2013 Notification of acceptance
  • Sep 6, 2013 Submission of Late Breaking Reports
  • Sep 16, 2013 Notification of acceptance of Late Breaking Reports
  • Sep 27, 2013 Submission of final papers

In the RoboShop project, we aim at developing a platform for robotic applications in a shopping mall. We took the decision to use ROS, the robotic middleware backed by the Open Source Robotic Foundation. We also wanted to continue using our favorite language Pharo. This is how we end up developing PhaROS, a client for Pharo-based ROS nodes.

Today, we are glad to announce that the first version of PhaROS is now officially available, that is there is :

There is still much to do in PhaROS, and more broadly in the RoboShop project. But, so far we already have a PhaROS node that wraps the robot that we are using. We connected it to the gmapping SLAM algorithm and we have used it to buid a map of our lab. More to come soon.

The CAR team  (http://car.mines-douai.fr) carries research at the frontier of Software Engineering and Robotics. We study software architectures, languages and tools for controlling individual robots. We have developed an expertise in reflective and dynamic languages, as well as component models, for a modular robotic software architectures. Besides, our research also addresses coordination and cooperation in robotic fleets. We mainly focus on communication models as well as emerging or predefined organizations for multi-agent robotic systems.

The post-doc position is part of the CAIRE project. The goal of the project is  to propose innovative solutions for the agile development of robotic software. The study will be validated by developing new robotic-based exploration and mapping solutions.

The candidate must have a PhD in Computer Science or Robotics, should demonstrate strong programming skills, and have research interests in at least one of the following areas:
- modularity and software composition
- programming languages design
- agile software development
- robotic middleware
- control architectures for robots
- multi-agent robotic systems

Important information:
-Workplace : Douai (Lille area), France
-Start: Between May and October 2013
-Duration : 18 months
-Salary approx. 2000 Euros.

To apply, please send your CV + references to : noury (DOT) bouraqadi (AT) mines-douai.fr

The goal of the RoboShop project is to make a robot for services into a shopping mall. From the hardware point of view, we are using two wheeled robots, equipped with a laser SICK 300 range finder, as well IR and sonar telemeters (see Picture 1). Each robot has a pole that is about 1.5 m heigh. It holds a tablet PC and Pan/Tilt camera.

Picture 1: Robots we use for the RoboShop project

On the software side, we have chosen the ROS middleware. The rational behind this choice is that ROS is backed by an active community, structured around Willow Garage and more recently the Open Source Robotics Foundation (OSRF). On the programming side, we took the reflective language Pharo. As Object-Oriented experts, we believe that Pharo is among the best (if not THE best) object-oriented programming language. Besides, it’s available under a free software license, and it’s community (backed by the INRIA french public research organization dedicated to computer science) is continuously improving it.

The first step was to develop a ROS client in Pharo: PhaROS = PHAro + ROS (initially named RoSt). So far, we have a first complete, running version. We have also developed a ROS node to control our robot. As a first validation, we drove the robot inside our lab and make it build a map (see Picture 2). That was also an opportunity to test our client with a third party ROS node, namely gmapping. We fed this Synchronous Localization And Mapping (SLAM) algorithm with data from the laser embedded on the robot.

Picture 2: Our lab’s map built by a robot

We are currently working on automatic map construction. The robot should be able to roam autonomously to build the map. This will lead us to test other parts of our infrastructure. Ultimately, the robot should be able to navigate in the building based on the existing map. It should be able to plan its trajectories to reach it destination while avoiding obstacles even if they are not on its initial map. Such obstacles include moving ones such as people or other robots.

The 8th french national conference on “Control Architectures of Robots” will be held this year in the beautiful city of Angers next 12-13 june. As for every edition since 2006, the CAR conference will gather researchers of the french robotics community interested in the transverse theme of embedded software for controlling autonomous robots. This event is an opportunity to get an overview of research currently conducted in french labs.

Important Dates

  • Paper submission (full paper or extended abstract) : 5th April 2013
  • Notification of acceptance : 26th April 2013
  • Camera ready due: 26th May 2013
  • Conference: 12-13 June 2013

Submission Guideline

  • Even if CAR is a french conference, we prefer article written in english
  • No specific style is required
  • No limit on article length, usually articles for CAR are between 6 and 17 pages long !
  • Send the PDF of  to car2013@contact.univ-angers.fr