Recently in repositories Category

From David Butterworth at Kaist on ROS-users

Hi all,

I've created some new packages for using the Webots simulator with ROS: http://www.ros.org/wiki/kaist_webots

webots_run Allows you to start Webots directly from a ROS launch file.

webots_joy_demo A new version of the Webots joystick teleop demo, using the C++ API.

webots_controllers

Currently contains only a simple P controller with joint state publisher. The controller configuration is specified in a yaml file, making it easy to test new robot models.

Any suggestions or corrections are appreciated.

Regards,

David Butterworth.

From Lionel Heng of the Computer Vision and Geometry Lab at ETH Zurich

Hi,

I would like to submit a new repository for indexing: https://github.com/cvg/px-ros-pkg

This repository currently contains a ROS package for interfacing to the soon-to-be-released PX4Flow optical flow board (coming soon from 3D Robotics). We have plans to add a ROS interface to the PX4FMU autopilot, and software for MAV autonomy as showcased in our recent IROS paper (http://www.cvg.ethz.ch/MAV ) in the coming weeks ahead.

Best Regards, Lionel Heng

From Roberto Guzmán of Robotnk

Hi ROS community!

A ROS stack for the SummitXL robot is available. The repository includes the necessary simulation nodes, teleoperation for different pads, and some autonomous navigation.

Please add the Google Code repository to the index:

http://code.google.com/p/summit-xl-ros-stack/

Best Regards,

Robert

From Kevin Walchko

Hello,

I would like to submit a new repository. Since the current ROS joystick drivers for the PS3 controller don't support OSX, I was able to use glfw ( a cross platform library) to build a node that publishes the sensor_msgs/Joy message.

The git repository is located: https://github.com/walchko/osx_joystick

I also documented how to connect the controller to OSX 10.8 via bluetooth. Welcome any suggestions or comments.

Kevin

A new package from Paul Bouchier

A new package: rosserial_embeddedlinux, that's part of the rosserial stack and gives embedded linux systems the ability to run ROS nodes is now available.

With the rosserial_embeddedlinux package, you can use ROS with Linux systems that don't or can't run full-blown ROS. The package provides a ROS communication protocol that works over your embedded linux system's wifi or network connection (or its serial port) and communicates with a ROS message proxy running on a native ROS system. It allows your embedded linux system to run apps that are close to full fledged ROS nodes that can publish and subscribe to ROS topics, provide services, and get the ROS system time over any of the supported connection types.

Rosserial_embeddedlinux extends the rosserial_arduino code that enabled arduino to present a ros node. It supports multiple nodes.

A description of the architecture and overview is on the wiki here: http://ros.org/wiki/rosserialembeddedlinux Tutorials including installation, and hardware-neutral and vendor-specific examples are here: http://ros.org/wiki/rosserialembeddedlinux/Tutorials

The package is general purpose, and not tied to any particular hardware vendor.

Access to the source code and bug tracker is provided on kforge here: https://kforge.ros.org/projects/rosserial/

ROS indexer maintainers, please add this package to the indexer.

Thanks to Mike Ferguson and Tully Foote for their encouragement at ROSCON to build this.

Regards

Paul Bouchier Dallas Personal Robotics Group

From Sebastian on ROS Users

Dear ROS users,

we, the Robotics and Biology Laboratory (RBO) at TU Berlin, are currently preparing the public release of our robotic software. Therefore, we would like to kindly request to index our new ROS package repository at https://github.com/tu-rbo/turbo-ros-pkg

The repository already contains the stack "iap", consisting of our Interactive Perception library. It contains modules for feature tracking, image segmentation and detection of kinematic structures.

More infos coming soon!

Thank you and best regards, Sebastian

From Wouter Caarls on ros-users

Hi all,

We would like to announce the ROS repository of the Delft Robotics Institute. It currently contains stacks for extremum seeking control and saliency detection, as well as some miscellaneous packages. Expect more soon!

https://svn.3me.tudelft.nl/dri-ros-pkg/trunk

With kind regards,

Wouter Caarls.

From Steve on ros-users

Hi Everybody,

I am happy to announce that the NASA-GM Robonaut 2 Simulator stack is now available for download.

Information on how to rosmake and run it can be found here: http://ros.org/wiki/nasa_r2_simulator

The git repo is still being indexed (and will be available shortly), but in the meantime you can download the package directly:

Ø sudo apt-get install ros-fuerte-nasa-r2-simulator

Included are a few Gazebo launch files for viewing the robot alone, in the International Space Station (ISS) US-Lab module, or with the "ISS Task Board," which is a structure with a number of articulate buttons and switches that the robot can manipulate. Also, there is an interactive marker script that can be used to teleop the robot.

Of course, this is a beta version, and we hope to make improvements over time. But I invite anyone who is so interested to take a look and see what they can do!

Any feedback, even if you just have downloaded it and liked it, is welcome.

Enjoy! Steve

From Luis Roalter on ros-users

Hi all,

We are happy to announce our current status on enabling IPv6 on ROS Nodes. It is still beta and in progress as part of a Diploma Thesis in our research group.

For questions please use ros-network@lists.vmi.ei.tum.de to directly contact us; or just use this mailing list.

See also http://ros.org/wiki/ros_comm6

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

With ros_comm6 we are introducing an IPv6 enabled variant of the ros_comm stack.

It features an IPv6 enabled master as well as IPv6 enabled client libraries for C++ and Python. The roswtf utility has also been modified to support IPv6.

You can find the code for the stack at:

https://svn.vmi.ei.tum.de/vmi-ros-pkg/trunk/ros_comm6/

The IPv6 features of the stack are enabled by setting the environment variable ROS_IPv6 to 'on'. The master then starts to listen on IPv4 and IPv6 addresses and nodes try to connect using IPv6. Nodes using IPv4 will still be able to connect to servers and publishers using IPv6.

IPv6 capable subscribers are currently not able to connect to publishers using IPv4, but is on our TODO list. (Trying to connect to all available addresses, until a successful connection can be made)

To use the stack a few steps have to be performed (it is assumed that you build ROS from source):

1) Replace your 'ros_comm/' directory in 'ros-underlay/' with the 'ros_comm6/' directory from the repository.

2) Remove your ROS installation from '/opt/ros/fuerte'. The reason for this is that the includes from the original ros_comm stack confuse the build system. 3) Build and install ROS again. 4) Check '/etc/hosts'. Make sure that 'localhost' and your hostname also point to '::1'. 5) Add 'export ROS_IPv6=on' to your .bashrc or other startup scripts.

The code is currently tested using Linux. Your millage on Windows or other Unix distributions might vary. This especially affects the dual stack behavior. (The IPV6_V6ONLY socket option is currently not modified)

We have tested the stack in a small test environment at our lab. Yet most of the code is probably untested, as it handles a lot of corner cases and configuration parameters. If you run into any problems using the stack please contact us or send us a patch.

From Dmitry Berenson

Hi everyone,

We're happy to announce a new package that uses a robot's previous experience to plan paths faster than planning-from-scratch alone.

The package is called LightningROS, and it is an implementation of the Lightning Path Planning Framework described in this paper:

A Robot Path Planning Framework that Learns from Experience Dmitry Berenson, Pieter Abbeel, and Ken Goldberg IEEE International Conference on Robotics and Automation (ICRA), May, 2012. http://automation.berkeley.edu/~berenson/lightning.pdf

This package uses OMPL planners to implement each component in lightning and can be called the same way as any other OMPL planner.

The package website is here: http://sourceforge.net/projects/lightningros/ .

The wiki describing installation, examples, etc. is here: https://sourceforge.net/p/lightningros/wiki/Home/

Please join our users list (click the Mailing Lists tab on the http://sourceforge.net/projects/lightningros/ page) to post questions/comments, we'd love to hear your feedback!

The code was developed at UC Berkeley by Cameron Lee and Dmitry Berenson under the supervision of Prof. Pieter Abbeel and Prof. Ken Goldberg.

Dear ROS'er,

With this email I want to announce the "geometric-relations-semantics" software (http://www.orocos.org/wiki/geometric-relations-semantics-wiki and http://www.ros.org/wiki/geometric_relations_semantics ).

The geometric relations semantics software (C++) implements the geometric relation semantics theory, hereby offering support for semantic checks for your rigid body relations calculations. This will avoid commonly made errors, and hence reduce application and, especially, system integration development time considerably. The proposed software is to our knowledge the first to offer a semantic interface for geometric operation software libraries.

The goal of the software is to provide semantic checking for calculations with geometric relations between rigid bodies on top of existing geometric libraries, which are only working on specific coordinate representations. Since there are already a lot of libraries with good support for geometric calculations on specific coordinate representations (The Orocos Kinematics and Dynamics library, the ROS geometry library, boost, ...) we do not want to design yet another library but rather will extend these existing geometric libraries with semantic support. The effort to extend an existing geometric library with semantic support is very limited: it boils down to the implementation of about six function template specializations.

The software already includes orocos typekits and already supports the KDL geometry types and ROS geometry types. Furthermore, it is fully Orocos and ROS compatible.

The wiki page (http://www.orocos.org/wiki/geometric-relations-semantics-wiki) contains background information, software design discussion, API, Quick start, User guide, tutorials, FAQs, and use cases.

We will be happy to receive any kind of feedback!

Kind regards,

Tinne De Laet

PS: The software is based on the paper "Geometric Relations between Rigid Bodies: Semantics for Standardization" (available at http://people.mech.kuleuven.be/~tdelaet/geometric_relations_semantics/geometric_relations_semantics_theory.pdf ), which is accepted for publication as a tutorial in IEEE Robotics and Automation Magazine.

From Pablo Ramirez at UT Dallas

Hello,

I'm a student at UT Dallas, and we have a ROS driver for the AR.Drone. It is an early version, and it has almost the same functionality as the ardrone_brown package. The main difference and advantage is that it is written using rosjava and javadrone.

This means that no matter how broken the official SDK is on current or future versions of Linux, we could always have a ROS driver as long as a Java Virtual Machine is present. Moreover, if somebody has the skills this could be ported to Windows or Android, since it does not use native code at all.

You can find this package at https://github.com/jpiramirez/ardrone_utd

There are a couple of Wiki entries explaining how to install and use it.

Suggestions and bug fixes are very welcome!

From Martin Makovička

I would like announce my ROS repository http://sourceforge.net/p/fmrp/code

It contains multirobot planner on graph structure.

From Martin Günther at Universität Osnabrück

Dear ROS users,

the University of Osnabrück's uos-ros-pkg has been split into separate repositories; a rosinstall file is available here:

http://kos.informatik.uos.de/uos-ros-pkg.rosinstall

As a bonus, we added a driver for the brand new SICK TiM 310 laser scanner.

Cheers, Martin

From Alexander Tiderko of Fraunhofer FKIE

Dear ROS users,

I would like to create a new repository: fkie-ros-pkg

Please add that to the indexer.

The content is developed by Fraunhofer FKIE at Wachtberg in Germany. Currently under development are tools for discovering and synchronizing ROS masters in a multi robot system.

http://github.com/fkie/fkie-ros-pkg.git

From Hai Nguyen of the Healthcare Robotics Lab @ Georgia Tech

Hello ROS community,

I would like to announce the result of our work here at Georgia Tech in collaboration with Willow. This is the first release of RCommander (version 0.5), a visual framework for easy construction of SMACH state machines allowing users to interactively construct, tweak, execute, load and save state machines. There are two stacks. The rcommander_pr2 stack contains an implementation with basic states for controlling the PR2 robot. rcommander_core contains the framework's essentials allowing the construction of custom RCommander interfaces for robots other than the PR2. The wiki doc links below also has a few tutorials for getting started with either rcommander_pr2 or rcommander_core.

Wiki-docs: http://www.ros.org/wiki/rcommander_core Repository: https://code.google.com/p/gt-ros-pkg.rcommander-core/

Wiki-docs: http://www.ros.org/wiki/rcommander_pr2 Repository: https://code.google.com/p/gt-ros-pkg.rcommander-pr2/

Just some notes: I've tested this on ROS Electric and have not done much with Fuerte yet but it will be supported soon. The wiki docs point to an older Mercurial repository, it should point to the newer git repository when the Ros indexer gets updated.

From Hendrik Skubch at the University of Kassel

Dear ROS community,

we are happy to announce three new ROS repositories:

• cn-roscs-ros-pkg http://code.google.com/p/cn-roscs-ros-pkg/

This stack contains a single package: roscs, which provides C# wrappers for ROS. It does not support the complete ROS functionality, but the parts we deemed most important, namely publish / subscribe, service calls, limited support for parameters and some minor functionality. We are using this under Linux with mono, Windows is not tested and will probably not work.

• cn-util-ros-pkg http://code.google.com/p/cn-util-ros-pkg/

This stack contains some useful utility libraries, namely:

• cstf, which wraps some tf methods in C#,
• Castor, a utility library for reading and writing configuration files from C++ and C#,
• udp_proxy_generator - Generates multicast proxies for ros topics. It is a very simple approach to a multi master environment, no namespace or topic remappings are done, messages are simply relayed. Given a configuration file, which specifies topics and message types, C++ code for a proxy is generated and compiled.

• cn-alica-ros-pkg http://code.google.com/p/cn-alica-ros-pkg/

This stack holds ALICA, a framework to coordinate and control multiple robots. It consists of three packages:

• Planmodeller - an Eclipse-based IDE to model multi-robot behaviour.
• AlicaEngine - an execution layer for the designed programs.
• AlicaClient - a simple monitoring GUI.

At its core, ALICA, similar to SMACH, uses hierarchies of state-automata to define behaviour. In contrast to SMACH, it is geared at teams of robots, and features task and role allocation algorithms and coordinated constraint solving and optimisation facilities.

This is part of an ongoing effort to make the source code of the RoboCup Mid-Size Team Carpe Noctem publicly available. All this software is used on our MSL robots. Documentation will be added to the wiki once indexed. This video: http://www.youtube.com/watch?v=HhIrhU19PG4 shows the software in action during the Dutch Open 2012 tournament.

Many thanks, Hendrik Skubch Distributed Systems Group University of Kassel Carpe Noctem

From Kyle Maroney at Barrett Technology

ROS Users,

In advance of ICRA 2012 and the first annual ROSCon, Barrett Technology is happy to announce a ROS repository created and maintained by Barrett Technology for control of the WAM Arm and BH8-280 BarrettHand. Barrett Technology's ROS repository is an abstraction of Libbarrett, a real-time controls library written in C++.

We look forward to contributing to the ROS community, as well as supporting current and future customers.

svn: http://web.barrett.com/svn/barrett-ros-pkg

Regards,

From Jon Claassens

Hi All,

For the past few months I've been developing a Python scriptable GUI for ROS that can substitute for RViz, but the main focus was to create something that would allow a developer to rapidly craft a user interface for a nontechnical user. It's still very early days and I'd hazard to call the repository even alpha yet, however anyone interested in having a look can find it at https://github.com/jonclaassens/cri/wiki

Key features are that ROS nodes can submit scripts to the visualizer to associate them with standard rViz markers. Scripts can be made to execute when the marker is interacted with in a number of ways. The menu environment of the visualizer is written entirely in PyQT and interacts with a C++ core through published getter-setter functions and callbacks.

I'll be maturing the program over the next few weeks and adding a few tutorials. Comments/suggestions/criticisms would be appreciated...

Best regards Jon

From Todor Stoyanov of Mobile Robotics and Olfaction Lab at the Center for Applied Autonomous Sensor Systems (AASS) at Örebro University, Sweden

Hi everyone,

We are pleased to announce the release of a new ROS packages source code repository! The repository contains several packages for perception and grasping, developed at the Mobile Robotics and Olfaction Lab at the Center for Applied Autonomous Sensor Systems (AASS) at Örebro University, Sweden. The source code is available at

http://code.google.com/p/oru-ros-pkg/

with some rudimentary documentation at the wiki page. Future releases are going to also include packages for artificial olfaction, so stay tuned! The released packages contain source code for some of our publications, in particular Three-Dimensional Normal Distributions Transform (3D-NDT) pointcloud registration and Independent Contact Regions(ICR) computation for multi-finger grasping.

In case you are going to attend the ICRA 2012 conference, you can get first hand information on several of the packages by attending the corresponding talks:

RGB-D registration: SPME workshop, Mon. 11:20 ICR on noisy real-world data: TuC210.3 3D-NDT registration: ThD06.1 ICR on a patch contact model: ThB02.2

Don't hesitate to contact us with comments or questions about the packages.

-- The AASS MRO team

Announced by Takashi Ogura on ROS-users mailing list

Hi ros-users.

I'm ROS hobby user in Japan.

I start rosruby project (which means ruby ROS client), and now you can try it.

Here is document for install and try some pub/sub, service samples.

https://github.com/OTL/rosruby/wiki/rosruby (I'm testing electirc, ruby 1.8.7 and ubuntu 11.10)

rosruby is not tested fully yet, but it works with simple applications.

I want your precious feedbacks!

Because trunk is not stable, I released current version as v0.1.0. you can also download it from here.

https://github.com/OTL/rosruby/tags

I am not heavy ruby user. Honestly, rosruby is my first ruby application....

Thank you.

Posted on ROS-users mailing list

Hello,

My name is Ganesh P Kumar, and I'm a student at Autonomous System Technologies Research & Integration Laboratory (ASTRIL), at Arizona State University, USA.

This to announce the phspline_trajectory_planner ROS stack, developed by my advisor, Dr. Srikanth Saripalli and myself. This stack extends the navigation_experimental stack to make goal_passer follow a path generated by a certain spline called PH Spline.

Documentation: http://robotics.asu.edu/2012/04/phspline-trajectory-planner/

Repository (hg) : https://bitbucket.org/pkganeshpk/phspline_planner

Could the ROS indexers please take note and let me know?

Regards, Ganesh P Kumar

From Mrinal Kalakrishnan of USC to ros-users

Hello ros-users,

We've had this repository around for a while, but it wasn't indexed because I never made an announcement here. So, here it is:

https://bitbucket.org/usc_clmc/usc-clmc-ros-pkg

These packages are from Stefan Schaal's CLMC lab at the University of Southern California. It currently includes stacks/packages for the following:

• Dynamic Movement Primitives
• STOMP motion planning
• PI^2: path integral reinforcement learning
• Xenomai-compatible version of rosrt
• Generic inverse kinematics with constraints
• Various other random utility packages

Many of these packages also exist in the Willow repositories, but the ones here are usually newer. Disclaimer: we tend to run a little behind on upgrading packages to newer ROS releases. Please email the package maintainer if you have trouble getting something to work.

This bitbucket repository is a read-only hg mirror of the actual git repository where we develop code https://github.com/usc-clmc/usc-clmc-ros-pkg. The mirror exists so that we can continue to use git and still be able to have all our stacks in a single repository. Please let me know if there's a better way to deal with this.

Thanks, Mrinal

Announcement from Andrew Straw of HacDC on the ros-users mailing list

I wanted to announce a ros repository maintained by HacDC:

http://code.google.com/p/hacdc-ros-pkg/source

It contains packages useful for doing the assignments and such from the HacDC robotics course material located here: http://wiki.hacdc.org/index.php/RoboticsClass2011. It's been a while since I last announced a repository, so I'm not sure what info is required in an announcement these days. If the repository crew needs more info than the link above, just let me know.

My personal favorite package from this repository is floating_faces -- a set of cubes suitable for use in gazebo that are texture mapped with faces of students from the robotics class. These cubes are useful for experimenting with the opencv face tracking while using gazebo.

best regards, -andrew

Announcement by Stephan Wirth of University of the Balearic Islands to ros-users

Dear ROS users,

I am happy to announce our new public repository for ROS software developed and/or maintained by the Systems, Robotics, and Vision Group of the University of the Balearic Islands, Spain. You can find the top-level rosinstall file here:

https://raw.github.com/srv/srv-ros-pkg/master/srv-ros-pkg.rosinstall

Please add that to the indexer.

The first stack we would like to share with the community is srv_vision which contains a ROS package for libviso2, a library for visual odometry (mono and stereo) developed by Andreas Geier from the Karlsruhe Institute of Technology, Germany. You can find the package here (or install it using the rosinstall file above):

https://github.com/srv/srv_vision

We are currently participating in two EU-funded projects (aerial & underwater robotics) , both using ROS. We expect to release more of our software in the near future and are looking forward to your feedback.

Best regards,
Stephan Wirth

Announcement by Juan Antonio Breña Moral to ros-users

Good night,

my colleague Lawrie Griffiths and me, Juan Antonio Breña Moral, are developing a new software to bind a Lego Mindstorms NXT with ROS using the Open Source Project, LeJOS, A Java Virtual Machine for Lego Mindstorms. LeJOS has a rich API based on Java to build Robots with NXT: http://lejos.sourceforge.net/nxt/nxj/api/

This development is an alternative for the current support for NXT with ROS. The main difference between nxt_ros and nxt_lejos is the technology used to connect with a NXT brick. In this case we use LeJOS with ROSJava working together. Besides, we are testing other projects as JavaCV.

Our ROS development is located in the following URL:

https://lejos.svn.sourceforge.net/svnroot/lejos/trunk/ros/

Our preliminar roadmap is:

• SLAM/MCL with Kinect and NXT
• A new vision API for NXT

Cheers

Juan Antonio & Lawrie
http://www.lejos.org

Announcement from Kevin LeBlanc to ros-users

Hi everyone,

I'd like to let you know about a teleop stack I've developed to allow generic tele-operation "source" devices (such as keyboards, joysticks, etc.) to be used interchangeably to control generic tele-operation "sink" devices (such as robot bases, pan-tilt units, robot arms, etc.).

I know there are a number of tele-operation and joystick stacks and packages out there, but many of them are doing nearly identical things in slightly (and frustratingly) different ways. The purpose of this stack is to avoid the rewriting of source or sink specific code for different source-sink combinations, and to provide a common interface for a variety of tele-operation sources.

The code can be downloaded here:

https://github.com/skynetish/teleop

More information can be found here:

https://github.com/skynetish/teleop/wiki

Comments and feedback welcome!

Best,
Kevin

Hello ROS users,

I am announcing the release of ros_rt_wmp. The ros_rt_wmp is a ROS node capable of replicating whatever ROS topic or service in another computer wirelessly connected with the source without the need of sharing the same roscore.

As an example consider a team of robots building cooperatively a map. The robots have to exchange their laser and pose information. However if the network that connect the robots is not completely connected and they can't use an infrastructure network (an outdoor chain network for example) there is no way to share data among robots using the ROS.

The ros_rt_wmp allows to distribute/decentralize a complex robotics system in multiple computation units in a transparent form: the only requisite is to know which data from other robots we need in each one of them.

Links:

• Source code: https://github.com/dantard/unizar-rt-wmp-ros-pkg
• Documentation (and step-by-step tutorial): https://github.com/dantard/unizar-rt-wmp-ros-pkg/wiki

The package is young (it is probable you'll find bugs) but it seems to work quite well.

Best regards,
Danilo

Dear ROS community,

I would like to announce our robot stacks:

• https://github.com/neobotix/neo_driver
• https://github.com/neobotix/neo_common
• https://github.com/neobotix/neo_apps
• https://github.com/neobotix/neo_navigation

In these stacks you can find hardware drivers for all the robots by neobotix. Additionally there are example configurations for the mobile robots mp-500 and mpo-500.

see also (videos):

• the first tests of our mpo prototype
• payload tests

Best regards
Timo Hackel

Announcement from Roberto Guzman from Robotnik to ros-users

Hi ROS community!

A ROS stack for the Summit robot is available. The repository includes the necessary simulation nodes, teleoperation and some autonomous navigation.

Please add the Google Code repository to the index:

http://code.google.com/p/summit-ros-stack/

Best Regards,

Robert

Announcement from Shaun Edwards of Southwest Research Institute®

Dear ROS community:

We are proud to announce the ROS-Industrial software repository.

ROS-Industrial is a BSD-licensed ROS stack that contains libraries, tools and drivers for industrial hardware. The goals of ROS-Industrial are to:

• Create a community supported by industrial robotics researchers and professionals
• Provide a one-stop location for industry-related ROS applications
• Develop robust and reliable software that meets the needs of industrial applications
• Combine the relative strengths of ROS with existing industrial technologies (i.e. combining ROS high-level functionality with the low-level reliability and safety of industrial robot controllers).
• Create standard interfaces to stimulate "hardware-agnostic" software development (using standardized ROS messages)
• Provide an easy path to apply cutting-edge research in industrial applications, using a common ROS architecture
• Provide simple, easy-to-use, well-documented APIs

ROS-Industrial is at pre-1.0-release level. It currently supports ROS control (arm navigation with collision free path planning) for the Motoman SIA10D and DX100 controller. The software works with actual hardware or a simulated robot in rviz.

Check out a video of our progress so far:

We'd like to invite others to use this software and contribute new applications and interfaces, particularly ROS drivers for different industrial robot platforms.

Special thanks to early contributors:

Southwest Research Institute®
Yaskawa Motoman Robotics
Willow Garage

Link: swri-ros-pkg

Announcement by Dominic Létourneau (IntRoLab, Université de Sherbrooke) to ros-users

Hello ROS users,

The ManyEars project propose a robust sound source localization and tracking method using an array of eight microphones. The method is based on a frequency-domain implementation of a steered beamformer along with a particle filter-based tracking algorithm. Tests on a mobile robot show that the algorithm can localize and track in real-time multiple moving sources of different types over a range of 7 meters. These new capabilities allow robots to interact using more natural means with people in real life settings.

The ManyEars project is available here :

http://manyears.sourceforge.net

IntRoLab has released new ROS packages for the ManyEars library on GitHub. IntRoLab's packages and documentation are available here :

http://introlab.github.com/introlab-ros-pkg/

Enjoy!

Regards,

Dominic Létourneau, ing., M.Sc.A.
IntRoLab - Intelligent / Interactive / Integrated / Interdisciplinary Robot Lab
Université de Sherbrooke

Announcement by Michael Carroll (Auburn University) to ros-users

Greetings ROS Users,

I am please to announce a new stack that I've been working on: ROSOSC. Code and documentation for my "beta" release are available immediately on the ROS.org wiki.

ROSOSC is a set of utilities and nodes for interacting with Open Sound Control hardware and software devices.

One of the main features is the ability to interact with TouchOSC (created by hexler: http://hexler.net), the iOS application, to create dynamic, touch-interactive, control surfaces that can be used with ROS. These control surfaces can be composed of several different types of controls, such as push buttons, toggle buttons, faders, rotary knobs, labels and LEDs. Most of the controls support two-way communication with ROS, which allows users to change color, position, size, and visibility of all of the controls on the page via ROS topics.

There are two main ways of interacting with TouchOSC with ROS:

• Using a "default handler" - Simply create a layout file in the freely available TouchOSC editor, and then launch the ROS touchosc_bridge node. All of the controls on the page will show up as topics that can be published to/subscribed to using ROS.
• Using a "tabpage handler" - Users can also create a python module that can directly interface with OSC clients. There are many features available to developers, including multiple client support, client join/quit callbacks, and client tabpage switching callbacks. More can be found out on the wiki and API documents.
  • API Docs are available on the ROS wiki
  • Two tabpage handlers are included out of the box:
    • Diagnostics_handler - a tabpage for viewing diagnostics and aggregate diagnostics data
    • teleop_handler - a tabpage for broadcasting command velocity messages to holonomic and differential drive robots.

I hope that you find this useful in your robotics projects, and I'm excited to see some of the future uses of the TouchOSC and Open Sound Control interfaces.

To get an idea of the basic features, I have made some YouTube videos:

• Loading Layouts using ROSOSC
• Using the Diagnostics Tabpage
• Using the Teleop Tabpage

Thanks,

~mc

Announcement by Morgan Cormier (CoroWare) to ros-users

Dear ROS community,

I would like to announce a new ROS repository which include a stack of packages for the robot Corobot, made by CoroWare:

http://sourceforge.net/p/roscorobot/code/

...

Thank you for your attention,
Morgan Cormier
CoroWare

Announcement from Jose Luis Rivero to ros-users

Dear ROS community:

The Robotics Lab at Institut de Robòtica i Informàtica Industrial (CSIC-UPC), research centre in Barcelona, wants to announce its official supported ROS repository.

Overview

The code is mainly related to "Mobile Robotics" and "Perception and Manipulation" at this moment. Full list of our robots, stacks and packages can be found here

Stacks and Packages

The repository hosts ROS stacks for drivers and devices, as well as IRI robots stacks:

• Generic drivers
  • asterx1
  • firewire_camera (auto configuration of format 7)
  • hokuyo_laser
  • leuze_laser
  • loquendo_tts
  • pmd_camera (camcube and camboard)
  • tcm3_compass
• WAM Arm stack (supports new libbarret library)
• Segway RMP Stack
  • rmp200
  • rmp400
• EstiraBot (WAM Arm based robot. Deformable objects manipulation)
• Zyonz (WAM Arm based robot. Gardening, plants manipulation)
• Tibi/Dabo (SegwayRMP200 based robot. Urban HRI interaction)
• Teo (SegwayRMP400 based robot. Navigation/Mapping operations)

Source code

The full SVN can be downloaded here.

If you want to get a working "out-of-the-box" copy in a ROS enviroment, please follow our docs about how to make a rosinstall checkout.

Enjoy.

David Kotfis from the Personal Robotics group at Cornell University writes

Hello ROS Users!

The Personal Robotics group at Cornell University would like to add its repository to the ROS.org list. Our package, called semantic_label_3d, is used in research applications using the Kinect sensor to "label" objects in a scene. Our repository is located at http://pr.cs.cornell.edu/sceneunderstanding/data/data.php.

Sincerely,
David Kotfis

Stefan Kohlbrecher & Johannes Meyer from team HECTOR Darmstadt write:

Hi ROS community,

we'd like to announce tu-darmstadt-ros-pkg, a repository providing ROS compatible software developed at TU Darmstadt. From the start, we provide packages developed in the scope of team HECTOR Darmstadt related to SLAM and object tracking in harsh environments such as those encountered in the simulated Urban Search and Rescue (USAR) environments of the RoboCup Rescue League. This is the SLAM system we used to score top places at various competitions (1st place overall RoboCup German 2011, close 2nd best in class autonomy RoboCup 2011, 3rd place SICK robot day 2010 etc.). Example videos of hectormapping from the hectorslam stack used in a handheld mapping system can be seen here:

We provide the following stacks:

hector_slam stack:

• hector_mapping is a fast SLAM system that does not require any odometry information and is able to learn accurate grid maps of small and medium scale scenarios. It can be used interchangeably with gmapping. The system provides 2D pose estimates at 40Hz (with a Hokuyo UTM-30LX) but does not perform explicit loop closure like gmapping does.
• hector_trajectory_server saves tf based trajectories given a source and target frame. They are made available as a nav_msgs/Path using both a service and topic. The travelled path of a robot can thus easily be visualized in rviz as well as plotted into the Geotiff generated by the hector_geotiff node.
• hector_geotiff generates RoboCup Rescue League rules compliant GeoTiff maps with georeference information, showing both the map and the robot path. It uses nav_msgs/OccupancyGrid and nav_msgs/Path messages retrieved via services, so it can also be used with gmapping and other mapping systems.
• hector_map_tools provides some tools related to extracting information from nav_msgs/OccupancyGrid data, like retrieving the rectangular of the map that actually contains non-unknown data.

hector_worldmodel stack:

• object_tracker provides a probabilistic (gaussian representation) system for tracking and mapping the pose of objects of interest in the world (used for victim mapping in RoboCup Rescue).
• world_model_msgs provides a ROS message based interface for updating the object_tracker.

hector_common stack:

• bfl_eigen is a patched version of BFL that uses Eigen.
• hector_marker_drawing is a class for helping with publishing marker messages.

vrmagic_camera stack: Driver for vrmagic four sensor cameras, unstable development code.

Documentation and Tutorials will be added in the coming days once the repository is indexed on ros.org.

on behalf of all members of team HECTOR Darmstadt,
Stefan Kohlbrecher & Johannes Meyer

Announcement by Daniel Stonier (Yujin Robot) to ros-users

Hi all,

We would like to announce a new stack:

https://github.com/snorridj/zeroconf-ros-pkg

It is intended to be a building block that can be used to conveniently provide c++/java/ros api for handling zero-configuration services in a ros framework.

Right now it has a fairly complete linux avahi implementation and some testing code for java/android, but we'd like to also include bonjour and embedded implementations for completeness. Before going any further though, there are various open design issues that would ideally be best served by gathering interested parties to seek a consensus. Once the wiki pages are up with some info so people can do some browsing/testing, we'll invite people for an official api review to help refine the development process.

Stay tuned!

Regards,
Daniel Stonier (Yujin Robot)

Announcement by Inkyu Sa of Queensland University of Technology to ros-users

We are pleased to announce our ros repository to the ros group.

We only have few packages for the falcon driver, xsens, GPS, RemodeControl on the repository at this moment.

However, we are planning to put more open-source code on our repository aiming for development of knowledge by sharing and collaborations with our colleagues from around the world.

The address of our repository is

bzr lp:cyphy

And you can check out using "bzr" command:

bzr co lp:cyphy

Thank you.

Announcement by Miltiadis Allamanis to ros-users

Hello ROS Community!

The PANDORA Robotics Team at the Department of Electrical & Computer Engineering of the Aristotle University of Thessaloniki, Greece wants to announce our new ROS repository at https://github.com/pandora-auth-ros-pkg/pandora-auth-ros-pkg.

The repository contains, for now, two stacks:

• ros_pandora_generic contains packages that are platform-independent. Packages include utilities such as a remote watchdog timer, a remote mutex/counter. We have also implemented a wrap-around the Google Mocking framework and created mock objects for Subscribers/ Service Servers/ ActionLib Servers to be used for testing (such as range tests). There are also a number of other utility classes for testing. Finally, we include an EPOS Gateway implementation, that we have used for our motors.
• ros_pandora_platform_specific contains packages that are specific to our PANDORA robot, build for the RoboCup Rescue 2011 Competition. More specifically, there are currently two packages using our testing utilities to test interfaces and perform range tests and one package implementing our Qt GUI.

We will continue to update our repository with new packages throughout the next months.

Best regards

Three more repositories were announced over the weekend:

LASA-ros-pkg: ROS node for position control of the Barrett WAM from EPFL-LASA.

roblab-whge-ros-pkg: The first contributed project is the ROSScan3D stack which creates 3D point clouds with semantic information like floors, walls, celling, room dimensions and the text of the doorplates found in this scan area. The 3D scan is created by a mobile robot, in this case a Roomba from iRobot, a Sick laser scanner LMS 100 and a Canon standard high resolution digital camera.

TYROS: The first published source there is TIChronos/src/ti_chronos_joy.cpp, which turns a Texas Instruments Chronos watch into a ROS-compatible joystick publisher. The included launch file works with turtlesim demo.

Announcement by Fred Pauling to ros-users

CSIRO's Autonomous Systems Lab is pleased to announce the public availability of two ROS stacks:

1. csiro-asl-drivers: is intended to contain hardware drivers, and currently contains a driver for the SICK LD-MRS 400001 Laser Scanner.

2. csiro-asl-openrave-plugins: is intended to contain plugins for OpenRave, and currently contains an odephysics plugin.

The csiro-asl-ros-pkg project page is located at https://launchpad.net/csiro-asl-ros-pkg

The code for these stacks is available from the trunk of our bazaar repository on launchpad:

bzr branch lp:csiro-asl-ros-pkg

Further announcements will be made as other software is released.

Regards,

Fred Pauling
CSIRO Autonomous Systems Lab

All,

I would like to announce the availability of a simple driver for the Neato Robotics XV-11 for ROS. The neato_robot stack contains a neato_driver (generic python based driver) and neato_node package. The neato_node subscribes to a standard cmd_vel (geometry_msgs/Twist) topic to control the base, and publishes laser scans from the robot, as well as odometry. The neato_slam package contains our current move_base launch and configuration files (still needs some work).

I've uploaded two videos thus far showing the Neato:

I also have to announce our repository, since we've never officially done that: albany-ros-pkg.googlecode.com

I hope to have documentation for this new stack on the ROS wiki later today/tonight.

Mike Ferguson
ILS Social Robotics Lab SUNY Albany

Announcement from Stéphane Magnenat of ETH Zurich/ASL

Hello,

We have developed in-house drivers for EPOS/ELMO controllers, which are based on the CanOpen/CiA DSP 402 protocol.

These drivers are written in C, and we are currently in the process of re-factoring these libraries in C++, with the goal of doing a clean ROS driver afterwards. Initially, the library will contain implementations of subsets of both CanOpen and CiA DSP 402, with quirks for EPOS and ELMO. On the longer run, we will probably split the CanOpen part into another library and add more complete CiA DSP 402 support, including PDO.

I guess that this might be of interest for the ROS user community. We are committed to an open-development model and so contributions are very welcome.

Kind regards,

Stéphane

Repository Link

Announcement from Gonçalo Cabrita of ISR - University of Coimbra

Hi everyone!

The ISR-UC ROS repository has just been updated! Everything is now well organized and in place. This includes projects like:

• The WifiComm multi-robot communication package;
• The CerealPort C++ serial port class;
• Our Roomba stacks with a bunch of new stuff;
• PlumeSim, the plume simulator;
• Scout driver for ROS (Scouts used to be quite popular).

In the following days we'll be creating wiki pages for all the new stuff including some tutorials.

We hope our contribution can be of some help to the ROS community.

Gonçalo Cabrita
ISR - University of Coimbra
Portugal

Taylor Veltrop has announced veltrop-ros-pkg as well as tools for Roboard-based humanoids

I am pleased to announce the Veltrop ROS Repository!

If any of you out there are using using small servo based robots, especially humanoid, then then check this out!

The Veltrop ROS Repository leverages ROS to get hobbyists and researchers quickly up and running with the Roboard operating a humanoid robot.

The Roboard is a small 1Ghz 486 platform that has built in PWM control, and many IO ports:

Info on KHR style humanoid

The repository consists of a stack suitable for the Roboard, and another stack specialized for small joint based robots.

The hobby community seems to be reinventing the wheel with each person that combines an embedded PC with one of these humanoid robots. When the beginner tries to do this it's too daunting, and for others it is very time consuming. So I hope to alleviate this, and get some help back too.

Here's a summary of some of the features:

• Pose the robot based on definitions in an XML file
• Execute motions by running a series of timed poses (XML)
• Stabilization via gyro data
• Definition of a KHR style robot linkage for 3D virtual modeling and servo control (URDF)
• Calibrate trim of robot with GUI
• Calibrate gyro stabilization with GUI
• Import poses and trim (not motions) from Kondo's Heart2Heart RCB files
• Control robot remotely over network with keyboard
• Control robot with PS3 controller over bluetooth
• Support for HMC6343 compass/tilt sensor
• Support for Kondo gyro sensors
• Stereo video capture and processing into point cloud
• CPU heavy tasks (such as stereo processing) can be executed on remote computer
• Controls Kondo PWM servos

Here's some missing parts (maybe others would like to contribute here?)

• Control Kondo serial servos
• GUI for editing and running poses/motions
• Tool to capture poses
• More sophisticated motion scripting
• GUI for calibration of A/D inputs

My next goals for this project are to incorporate navigation, and arm/gripper trajectory planning.

The documentation is here: http://taylor.veltrop.com/robotics/khrhumanoidv2.php?topic=veltrop-ros-pkg There's a lot of other relevant information to the robot throughout the site.

The repository is hosted on sourceforge: http://sourceforge.net/projects/veltrop-ros-pkg

I hope someone out there has a chance to try this out and contribute!

Taylor

Nate Roney from the Mobile Robotics Lab at SIUE has announced drivers for the Parrot AR.Drone, as well as the siue-ros-pkg repository

Greetings everyone,

I'd like to share a project I've been working on with the ROS community.

Some may be familiar with the Parrot AR.Drone: an inexpensive quadrotor helicopter that came out in September. My lab got one, but I was pretty disappointed that it didn't have ROS support out of the box. It does have potential, though, with 2 cameras and a full IMU, so it seemed like a worthwhile endeavor to create a ROS interface for it.

So, I would like to announce the first public release of the ROS interface for the AR.Drone. Currently, it allows control of the AR.Drone using a geometry_msgs/Twist message, and I'm working on getting the video feed, IMU data and other relevant state information published as well. Unfortunately, the documentation on how the Drone transmits it's state information is a bit sparse, so getting at the video (anyone with experience converting H.263 to a sensor_msgs/Image, get in touch!) and IMU data are taking more time than I'd hoped, but it's coming along. Keep an eye on the ardrone stack, it will be updated as new features are added.

For now, anyone hoping to control their AR.Drone using ROS, this is the package for you! Either send a Twist from your own code, or use the included ardrone_teleop package for manual control.

You can find the ardrone_driver and ardrone_teleop packages on the experimental-ardrone branch of siue-ros-pkg, which itself never had a proper public release. This repository represents the Mobile Robotics Lab at SIUE, and contains a few utility nodes I have developed for some of our past projects, with more packages staged for addition to the repository once we have time to document them properly for a formal release.

http://github.com/siue-cs/siue-ros-pkg

http://github.com/siue-cs/siue-ros-pkg/tree/experimental-ardrone

I'm hopeful that someone will find some of this useful. Feel free to contact me with any questions!

Cheers,
Nate Roney

Daniel Stonier from Yujin Robot has been bringing up an embedded project for ROS, eros. Below is his announcement to ros-users

Lets bring down ROS! ...to the embedded level.

Greetings all,

Firstly, my apologies - couldn't resist the pun.

This is targeted at anyone who is either working with a fully cross-compiled ros or simply using it as a convenient build environment to do embedded programming with toolchains.

Some of you might remember myself sending out an email to the list about getting together on collaborating for the ROS at the embedded level rather than having us all flying solo all the time. Since then, I'm happy to say, Willow has generously offered us space on their server to create a repository for supporting embedded/cross-compiling development which has now been kick-started with a relatively small, but convenient framework that we've been using and testing at Yujin Robot for a while. The lads there have been excellent guinea pigs, particularly since most of them were very new to linux and had absolutely no or little experience in cross-compiling.

Eros

A quick summary of what we have there so far:

• A project server
• A home page on the ROS wiki
• Some python tools to assist in cross-compilation
• Toolchain and platform cmake module libraries
• Patches until they get merged upstream
• A toolchain bridge that will convert an existing toolchain into a read-to-go ros toolchain
• Some build recipes for embedded versions of packages, e.g. opencv.
• Some tutorials, e.g. instructions for doing a partial cross or a full cross of the ros.
• ...and various other things

If you want to take the tools for a test run, simply svn eros into your stacks directory of your ros install. e.g.

roscd cd ../stacks svn co https://code.ros.org/svn/eros/trunk ./eros

Getting Involved

But, what would be great at this juncture would be to have other embedded beards jump on board and get involved.

• Tutorials on the wiki - platform howtos, system building notes...
• General discussion on the eros forums.
• Feedback on the current set of tools.
• New ideas.
• Diagnostic packages.
• New toolchain/platform modules.
• Future development

If you'd like to get involved, create an account on the wiki/project server and send me an email (d.stonier@gmail.com).

Future Plans

The goals page outlines where I've been thinking of taking eros, but of course this is not fixed and as its early, very open to new ideas. However, two big components I'd like to address in the future include:

Embedded package installer - a package+dependency chain (aka rosmake) installer. This is a bit different to Willow's planned stack installer, but will need to co-exist alongside it and should use as much of its functionality as possible.

Abstracted System Builder as an Os - hooking in something like OpenEmbedded as an abstracted OS that can work with rosdeps.

and of course, making the eros wiki alot more replete with embedded knowledge.

Kind Regards,
Dr. Daniel Stonier.

We first covered Takashi Ogura's (aka OTL) robot projects back in March when he got the ROS PS3 joystick driver working with an i-Sobot. He has many more fun projects that are too numerous to cover: White Bear Robot (Roomba + Navigation stack), Arduino board for the i-Sobot, Twitter control for humanoid robot, and an all-time classic, humanoid robot with iPhone 3GS head.

Along the way, OTL has been putting together tutorials and previews of ROS libraries for his Japanese audience on ros-robot.blogspot.com, such as a Japanese speech node, Twitter for ROS using OAuth, URDF tutorial, Euslisp demos, and many more.

Many of those tutorials and projects came together in the video above: Kitemas LV1. Kitemas LV1 is a fun drink ordering robot that lets you order a drink and then pours it for you. Judging from previous posts, it looks like Kitemas is using a Roomba with Hokuyo laser range finder for autonomous navigation, as well as a USB web camera. Drink selection can be done either through colored coasters or a Twitter API, and the robot can be driven manually with a PS3 joystick.

Here's a software diagram that shows the various ROS nodes working together:

OTL has also created otl-ros-pkg, so readers of his blog can get code samples for his various tutorials and even see code for robots like Kitemas above. You can watch a video with a more dressed up version of Kitemas LV1 here.

Jeff Rousseau announced a basic URDF model for the iRobot Create as well as new aptima-ros-pkg code repository

Hi all,

I've put together a basic URDF for the iRobot Create platform. It's available for download through our new svn repo:

svn checkout http://aptima-ros-pkg.googlecode.com/svn/trunk/irobotcreatedescription

(Note: currently it relies on the erratic_gazebo_plugins pkg to implement its diff-drive)

Comments, bug reports and patches are appreciated

I plan to add/fix in the not too distant future:

• a working bumper
• tweak mass/friction params to be more realistic (they're fudged at the moment)
• fix intermittent 'wobble' when transitioning between translation and rotations (friction coeff issue?)

enjoy,
Jeff

Announcement from Trevor Jay of Brown's RLAB

Brown is pleased to announce our beta version of rosjs, a light-weight Javascript binding for ROS.

rosjs is designed to enable users and developers to use the functionality of ROS through standard web browsers. Applications developers can leverage all of the power of HTML to build engaging applications and interfaces for robots as quickly as possible without recompiling ROS nodes. Additionally, users can access and run ROS-based applications from standard browsers without the need for any plugins.

rosjs consists of a server and a pure Javascript library. rosjs is not tied to any particular web-server or framework; it even works when served locally. Using websockets, latency is low enough for teleoperation or closed loop control. For example, the following video shows a user teleoperating the PR2 via rosjs from Providence to Palo Alto:

rosjs is currently available for download from the brown-ros-pkg repository via:

svn co https://brown-ros-pkg.googlecode.com/svn/trunk/experimental/rosjs rosjs

and you can view preliminary documentation here:

http://code.google.com/p/brown-ros-pkg/wiki/rosjs

We are making rosjs available now for the ROS community to use and provide feedback. Please play, create, and break stuff; then tell us about it.

Thanks again to the kind people at Bosch and Willow for use of their PR2.

_Robot Learning and Autonomy @ Brown (RLAB)

DKFI Safe and Secure Cognitive Systems at the University of Bremen in Germany has created the dfki-sks-ros-pkg repository, which is open source with a BSD license. They are currently providing a driver for the Leuze rotoScan ROD-4 laser rangefinder.

Institute of Systems and Robotics at the University of Coimbra in Portugal has created the isr-uc-ros-pkg repository, which has a collection of packages with a BSD license. In addition to support for the iRobot Rooma, they have contributed a wifi_discovery_node. The wifi_discovery_node uses the experimental foreign_relay package to enable multi-robot communication over wireless. This node is available as a separate download, or you can checkout the entire repository.

announcement from the CCNY Robotics lab on ros-users

Dear ROS community,

The Robotics Lab at the City College of New York is releasing a collection of ROS tools that we are developing for our research. The packages, which are BoxTurtle-compatible, are grouped in the ccny-ros-pkg stack. Documentation is available on the ROS wiki.

We have made an effort to include a screenshot and youtube video demonstrating the usage of each single package on the corresponding wiki page. The packages also come with a pre-recorded bag and demo launch files, allowing developers to quickly test and get started with using the tools.

The current collection of packages includes:

• gpsd_viewer: a map viewer for GPS position data provided by gpsd_client.
• artoolkit - a meta-package which downloads and installs ARToolkit locally.
• ar_pose - an ROS wrapper for ARToolkit, capable of tracking the position of single or multiple AR markers relative to the camera, broadcasting the corresponding transforms, as well as publishing visualization markers to rviz.
• laser_scan_splitter - a tool which takes a LaserScan message as input and splits it into an arbitrary number of segments.
• laser_ortho_projector - a tool which takes a LaserScan, as well as a position of the laser in a fixed frame, and outputs the orthogonal projection of the scan, invariant to the roll-, pitch- and z- position of the laser.
• point_cloud_filter - a threshold filter for PointCloud messages, which filters points based on values from any of the cloud's additional channels, such as "confidence" or "intensity"

Additional tools scheduled for release this summer include a driver for the AscTec Autopilot for use with AscTec quadrotor UAVs. We are looking forward to hearing back from you with comments and suggestions on how to improve our software.

William Morris,
Ivan Dryanovski,
Gautier Dumonteil

Brown is pleased to announce the first of a series of summer software releases, beginning with a new BoxTurtle-compatible release of the Brown ROS Pkg.

As usual, the full details are available at:

http://code.google.com/p/brown-ros-pkg/

Highlights include:

• the aforementioned BoxTurtle compatibility
• probe has become gscam, and is now compatible with the ROS camera interface, this means any camera or image source available to gstreamer can now be a calibrated part of an image_proc pipeline
• a new node, ar_recog, exposing most of the functionality of ARToolKit through ROS messages
• pr2_keyboard_teleoperator, providing full teleoperation of the PR2 from the keyboard
• position_tracker, a simple odometry correction service

Please check it out and help us make improvements, and be on the look-out for more releases in the coming weeks, including: an ARTag odometry system, an improved NAO v1.6 compatible version of our NAO drivers, and more.

_Trevor

The Media and Machines Lab at Washington University in St. Louis has integrated several of their robots with ROS, including an iRobot B21r and several Videre ERRATICs. They are also maintaining wu-ros-pkg, which is a repository of research projects, drivers, and utilities related to these robots.

Wash U.'s B21r, known as Lewis, is best known for being a mobile robot photographer. Lewis is currently being used for HRI research, and they are also reimplementing the photographer functionality in ROS. Lewis is fully integrated with ROS, including sensor data from 48 sonar sensors, 56 bump sensors, 2 webcams, and a Hokuyo laser rangerfinder. There is also Directed Perception PTU-46 pan-tilt unit that they have mounted the webcams on (driver).

The B21r community will be happy to know that Wash U. has deeply integrated this platform with ROS. They have created an urdf model, complete with meshes for visualizing in rviz, and they have also integrated the B21r with the ROS navigation stack. They are also providing an rwi stack, which includes their rflex driver. The rflex driver is capable of driving other iRobot/RWI robot platforms, including the B18, ATRV, and Magellan Pro.

Wash U. has also integrated their four Videre ERRATICs with ROS. They've named these robots Blood, Sweat, Toil, and Tears, and have equipped them with Hokuyo laser rangerfinders and webcams. The ERRATICs enable them to explore research in multi-robot coordination and control. They're also developing on iRobot Creates using drivers from brown-ros-pkg.

The research at the Media and Machines Lab has led to several interfaces and visualizations for using robots. This includes RIDE (Robot Interactive Display Environment), which takes cues from Real Time Strategy (RTS) video games to provide an interface for easily controlling multiple robots simultaneously. They have also developed a visualization for mapping sensor data over time for search tasks and a 3D interface for binocular robots. RIDE is available in the ride stack, and much of their other research will soon be released in wu-ros-pkg.

The 11 recipients for the PR2 Beta Program have been announced! You can read the announcement on willowgarage.com.

While the program will leverage the common hardware platform of the PR2, it is also a big benefit to the broader ROS community as a whole. All of the participants will be releasing work as open source, and much of this work will be immediately applicable to other robot platforms. For example:

• KU Leuven will be working on improving integration between ROS and Orocos, as well as integrating ROS with other open-source libraries like Blender.
• JSK will be working on integrating ROS, OpenRAVE, and EusLisp.
• Bosch will be providing sensors like accelerometers, gyros, pressure sensors, and skins to participants, which will hopefully lead to new approaches and libraries for these types of sensors.

These are just a few examples, and you can read the announcement for more. There will be numerous libraries in perception, mapping, planning, manipulation, and more that we hope the ROS community will be able to build upon.

Many of the participating institutions have already started ROS repositories, including:

• alufr-ros-pkg
• bosch-ros-pkg
• gt-ros-pkg
• kul-ros-pkg
• lis-ros-pkg
• mod-ros-pkg
• sail-ros-pkg
• tum-ros-pkg
• usc-ros-pkg

These repositories and more will be very active over the next two years, and we encourage the greater ROS community to take part by using the many open-source libraries for ROS in exciting new applications for robotics.

The ROS community has grown an amazing amount this year. As the Robots Using ROS has illustrated, there are all types of robots using ROS, from mobile manipulators, to autonomous cars, to small humanoids. As the types of robots has increased, so too has the variety of software you can use with ROS, whether it be hardware drivers, libraries like exploration, or even code for research papers. This diversity has allowed all types of developers, including researchers, software engineers, and students, to participate in this growing community.

Today we officially crossed the 1000 ROS package milestone. This is due in no small part to the many new ROS repositories that have come online this year. We are now tracking 25 separate ROS repositories that are providing open source code, including repositories from:

• CU Boulder
• UT Austin/Austin Robot Technology
• Albert-Ludwigs-Universität in Freiburg
• University of Arizona
• Georgia Tech
• Bosch
• University of Maryland
• Care-O-bot
• Brown University
• Technische Universität München
• Stanford AI Lab
• Willow Garage
• Washington University in St. Louis
• I Heart Robotics
• Carnegie Mellon University
• MIT LIS
• WPI
• ModLab at Penn
• USC
• Columbia University
• KU Leuven
• Cornell
• Tully Foote (personal)
• Andrew Harris (personal)

We're excited to see the expansion of such an amazing and vibrant ROS community. Thank you all for taking part.

The Intelligent Autonomous Systems Group at TU München (TUM) built TUM-Rosie with the goal of developing a robotics system with a high-degree of cognition. This goal is driving research in 3D perception, cognitive control, knowledge processing, and highlevel planning. TUM is building their research on TUM-Rosie using ROS and has setup the open-source tum-ros-pkg repository to share their research, libraries, and hardware drivers. TUM has already released a variety of ROS packages and is in the process of releasing more.

TUM-Rosie is a mobile manipulator built on a Kuka mecanum-wheeled omnidrive base, with two Kuka LWR-4 arms and DLR-HIT hands. It has a variety of sensors for accomplishing perception tasks, including a SwissRanger 4000, FLIR thermal camera, Videre stereo camera, SVS-VISTEK eco274 RGB cameras, a tilting "2.5D" Hokuyo UTM-30LX lidar, and both front and rear Hokuyo URG-04LX lidars.

One of the new libraries that TUM is developing is the cloud_algos package for 3D perception of point cloud data. cloud_algos is being designed as an extension of the pcl (Point Cloud Library) package. The cloud_algos package consists of a set of point-cloud-processing algorithms, such as a rotational object estimator. The rotational object estimator enables a robot to create models for objects like pitchers and boxes from incomplete point cloud data. TUM has already released several packages for semantic mapping and cognitive perception.

TUM is also working on systems that combine knowledge reasoning with perception. The K-COPMAN (Knowledge-enabled Cognitive Perception for Manipulation) system in the knowledge stack generates symbolic representations of perceived objects. This symbolic representation allows a robot to make inferences about what is seen, like what items are missing from a breakfast table.

In the field of knowledge processing and reasoning for personal robots, TUM developed the KnowRob system that can provide:

• spatial knowledge about the world, e.g. the positions of obstacles
• ontological knowledge about objects, their types, relations, and properties
• common-sense knowledge, for instance, that objects inside a cupboard are not visible from outside unless the door is open
• knowledge about the functions of objects like the main task a tool serves for or the sequence of actions required to operate a dishwasher

KnowRob is part of the tum-ros-pkg repository, and there is a wiki with documentation and tutorials.

At the high level, TUM is working on CRAM (Cognitive Robot Abstraction Machine), which provides a language for programming cognitive control systems. The goal of CRAM is to allow autonomous robots to infer decisions, rather than just having pre-programmed decisions. Practically, the approach will enable tackling of the complete pick-and-place housework cycle, which includes setting the table, cleaning the table as well as loading the dishwasher, unloading it and returning the items to their storage locations. CRAM features showcased in this scenario include the probabilistic inference of what items should be placed where on the table, what items are missing, where items can be found, which items can and need to be cleaned in the dishwasher, etc. As robots become more capable, it will be much more difficult to explicitly program all of their decisions in advance, and the TUM researchers hope that CRAM will help drive AI-based robotics.

Researchers at TUM have also made a variety of contributions to the core ROS system, including many features for the roslisp client library. They are also maintaining research datasets for the community, including a kitchen dataset and a semantic database of 3d objects, and they have contributed to a variety of other open-source robotics systems, like YARP and Player/Stage.

Research on the TUM-Rosie robot has been enabled by the Cluster of Excellence CoTeSys (Cognition for Technical Systems). For more information:

• TUM-Rosie hardware and software description
• IAS Video Channel
• tum-ros-pkg on ROS.org
• Datasets
• Overview Article: Towards Performing Everyday Manipulation Activities
• Overview Article: Towards Automated Models of Activities of Daily Life
• Overview Article: Generality and Legibility in Mobile Manipulation

The Modlab at Penn designed the CKBot (Connector Kinetic roBot) module to be fast, small, and inexpensive. These qualities enable it to be used to explore the promise of modular robotics systems, including adaptability, reconfigurability, and fault tolerance. They've researched dynamic rolling gaits, which use a loop configuration to achieve speeds of up to 1.6/ms, as well as bouncing gaits by attaching passive legs. They are also using the CKBots to research the difficult problem of configuration recognition, and, for the Terminator 2 fans, they have even demonstrated "Self re-Assembly after Explosion" (SAE).

More recently, Modlab has developed ROS packages that can be used when the CKBots are connected to a separate ROS system. They have also created an open source repository, modlab-ros-pkg, for CKBot ROS users. The CKBot modules only have a few PIC processors -- not enough to run ROS -- so an off-board system enables them to use algorithms that require more processing power. In one experiment, they used a camera to locate AR tags on the CKBot modules. The locations were stored in tf, which was used to calculate coordinate transforms between modules. They have also used rviz to display the estimated position of modules during SAE when AR tags were not in use.

One of the projects Modlab is currently working on is a "mini-PR2" made out of CKBot modules. The mini-PR2 will be kinematically similar to the Willow Garage PR2 and is powered by a separate laptop. You can see an early prototype of mini-PR2 opening an Odwalla fridge:

CKbots trace their ancestry back to Professor Mark Yim's work on the PolyBot system at PARC. The PolyBot system had an impressive range of demonstrations, including fence and stair climbing, tricycle riding, and even transforming from a loop, to a snake, to a spider.

Modlab does a variety of other modular robotics research, and has even demonstrated a quick-change end effector for the PR2.

Bosch's Research and Technology Center (RTC) has a Segway-RMP based robot that they have been using with ROS for the past year to do exploration, 3D mapping, and telepresence research. They recently released version 0.1 of their exploration stack in the bosch-ros-pkg repository, which integrates with the ROS navigation stack to provide 2D-exploration capabilities. You can use the bosch_demos stack to try this capability in simulation.

The RTC robot uses:

• 1 Mac Mini
• 2 SICK scanners
• 1 Nikon D90
• 1 SCHUNK/Amtec Powercube pan-tilt unit
• 1 touch screen monitor
• 1 Logitech webcam
• 1 Bosch gyro
• 1 Bosch 3-axis acceleromoter

Like most research robots, it's frequently reconfigured: they added an additional Mac mini, Flea camera, and Videre stereo camera for some recent work with visual localization.

Bosch RTC has been releasing drivers and libraries in the bosch-ros-pkg repository. They will be presenting their approach for mapping and texture reconstruction at ICRA 2010 and hope to release the code for that as well. This approach constructs a 3D environment using the laser data, fits a surface to the resulting model, and then maps camera data onto the surfaces.

Researchers at Bosch RTC were early contributors to ROS, which is remarkable as bosch-ros-pkg is the first time Bosch has ever contributed to an open source project. They have also been involved with the ros-pkg repository to improve the SLAM capabilities that are included with ROS Box Turtle, and they have been providing improvements to a visual odometry library that is currently in the works.

The Healthcare Robotics Lab focuses on robotic manipulation and human-robot interaction to research improvements in healthcare. Researchers at HRL have been using ROS on EL-E and Cody, two of their assistive robots. They have also been publishing their source code at gt-ros-pkg.

HRL first started using ROS on EL-E for their work on Physical, Perceptual, and Sematic (PPS) tags (paper). EL-E has a variety of sensors and Katana arm mounted on a Videre ERRATIC mobile robot base. The video below shows off many of EL-E's capabilities, including a laser pointer interface -- people select objects in the real-world for the robot to interact with using a laser pointer.

HRL does much of their research work in Python, so you will find Python-friendly wrappers for much of EL-E's hardware, including the Hokuyo UTM laser rangefinder, Thing Magic M5e RFID antenna, and Zenither linear actuator. You can also get CAD diagrams and source code for building your own tilting Hokuyo 3D scanner.

HRL also has a new robot, Cody, which you can see in the video below:

Update: you can read more on Cody at Hizook.

The end effector and controller are described in the paper, "Pulling Open Novel Doors and Drawers with Equilibrium Point Control" (Humanoids 2009). They've also published the CAD models of the end effector and the source code can be found in the 2009_humanoids_epc_pull ROS package.

Whether it's providing open source drivers for commonly used hardware, CAD models of their experimental hardware, or source code to accompany their papers, HRL has embraced openness with their research. For more information:

• Healthcare Robotics Lab homepage
• gt-ros-pkg documentation ROS.org
• gt-ros-pkg source code on Google Code

Like the Aldebaran Nao, the "Prairie Dog" platform from the Correll Lab at Colorado University is an example of the ROS community building on each others' results, and the best part is that you can build your own.

Prairie Dog is an integrated teaching and research platform built on top of an iRobot Create. It's used in the Multi-Robot Systems course at Colorado University, which teaches core topics like locomotion, kinematics, sensing, and localization, as well as multi-robot issues like coordination. The source code for Prairie Dog, including mapping and localization libraries, is available as part of the prairiedog-ros-pkg ROS repository.

Prairie Dog uses a variety of off-the-shelf robot hardware components: an iRobot Create base, a 4-DOF CrustCrawler AX-12 arm, a Hokuyo URG-04LX laser rangefinder, a Hagisonic Stargazer indoor positioning system, and a Logitech QuickCam 3000. The Correll Lab was able to build on top of existing ROS software packages, such as brown-ros-pkg's irobot_create and robotis packages, plus contribute their own in prairiedog-ros-pkg. Prairie Dog is also integrated with the OpenRAVE motion planning environment.

Starting in the Fall of 2010, RoadNarrows Robotics will be offering a Prairie Dog kit, which will give you all the off-the-shelf components, plus the extra nuts and bolts. Pricing hasn't been announced yet, but the basic parts, including a netbook, will probably run about $3500.

For more information, please see:

• Prairie Dog homepage
• prairiedog-ros-pkg documentation on ROS.org

Photo: Prairie Dogs busy creating maps for kids and parents

The Care-O-bot 3 is a mobile manipulation robot designed by Fraunhofer IPA that is available both as a commercial robotic butler, as well as a platform for research. The Care-O-bot software has recently been integrated with ROS, and, in just short period of time, already supports everything from low-level device drivers to simulation inside of Gazebo.

The robot has two sides: a manipulation side and an interaction side. The manipulation side has a SCHUNK Lightweight Arm 3 with SDH gripper for grasping objects in the environment. The interaction side has a touchscreen tray that serves as both input and "output". People can use the touchscreen to select tasks, such as placing drink orders, and the tray can deliver objects to people, like their selected beverage.

The goals of the Care-O-bot research program are to:

• provide a common open source repository for the hardware platform
• provide simulation models of hardware components
• provide remote access to the Care-O-bot 3 hardware platform

Those first two goals are supported by the care-o-bot open source repository for ROS, which features libraries for drivers, simulation, and basic applications. You can easily download the source code and perform a variety of tasks in simulation, such as driving the base and moving the arm. These support the third goal of providing remote access to physical Care-O-Bot hardware via their webportal.

For sensing, the Care-O-bot uses two SICK S300 laser scanners, a Hokuyu URG-04LX laser scanner, two Pike F-145 firewire cameras for stereo, and Swissranger SR3000/SR4000s. The cob_driver stack provides ROS software integration for these sensors.

The Care-O-bot runs on a CAN interface with a SCHUNK LWA3 arm, SDH gripper, and a tray mounted on a PRL 100 for interacting with its environment. It also has a SCHUNK PW 90 and PW 70 pan/tilt units, which give it the ability to bow through its foam outer shell. The CAN interface is supported through several Care-O-bot ROS packages, including cob_generic_can and cob_canopen_motor, as well as wrappers for libntcan and libpcan. The SCHUNK components are also supported by various packages in the cob_driver stack.

The video below shows the Care-O-bot in action. NOTE: as the Care-O-bot source code is still being integrated with ROS, the capabilities you see in the video are not part of the ROS repository.

The Aldebaran Nao is a commercially available, 60cm tall, humanoid robot targeted at research lab and classrooms. The Nao is small, but it packs a lot into its tiny frame: four microphones, two VGA cameras, touch sensors on the head, infrared sensors, and more. The use of Nao with ROS has demonstrated how quickly open-source code can enable a community to come together around a common hardware platform.

The first Nao driver for ROS was released by Brown University's RLAB in November of 2009. This initial release included head control, text-to-speech, basic navigation, and access to the forehead camera. Just a couple of days later, the University of Freiburg's Humanoid Robot Lab used Brown's Nao driver to develop new capabilities, including torso odometry and joystick-based tele-operation. Development didn't stop there: in December, the Humanoid Robot Lab put together a complete ROS stack for the Nao that added IMU state, a URDF robot model, visualization of the robot state in rviz, and more.

The Nao SDK already comes with built-in support for the open-source OpenCV library. It will be exciting to see what additional capabilities the Nao will gain now that it can be connected to the hundreds of different ROS packages that are freely available.

Brown is also using open source and ROS as part of their research process:

Publishing our ROS code as well as research papers is now an integral part of disseminating our work. ROS provides the best means forward for enabling robotics researchers to share their results and more rapidly advance the state-of-the-art.

-- Chad Jenkins, Professor, Brown University

The University of Freiburg's Nao stack is available on alufr-ros-pkg. Brown's Nao drivers are available on brown-ros-pkg, along with drivers for the iRobot Create and a Gstream-based webcam driver.

With so many open-source repositories offering ROS libraries, we'd like to highlight the many different robots that ROS is being used on. It's only fitting that we start where ROS started with STAIR 1: STanford Artificial Intelligence Robot 1. Morgan Quigley created the Switchyard framework to provide a robot framework for their mobile manipulation platform, and it was the lessons learned from building software to address the challenges of mobile manipulation robots that gave birth to ROS.

Solving problems in the mobile manipulation space is too large for any one group. It requires multiple teams tackling separate challenges, like perception, navigation, vision, and grasping. STAIR 1 is research robot built to address these challenges: a Neuronics Katana Arm, a Segway base, and an ever-changing array of sensors, including a custom laser-line scanner, Hokuyo laser range finder, Axis PTZ, and more. The experience developing for this platform in a research environment provided many lessons for ROS: small components, simple reconfiguration, lightweight coupling, easy debugging, and scalable.

STAIR 1 has tackled a variety of research challenges, from accepting verbal commands to locate staplers, to opening doors, to operating elevators. You can watch the video of STAIR 1 operating an elevator below, and you can watch more videos and learn more about the STAIR program at stair.stanford.edu. You can also read Morgan's slides on ROS and STAIR from an IROS 2009 workshop.

In addition to the many contribution made to the core, open-source ROS system, you can also find STAIR-specific libraries at sail-ros-pkg.sourceforge.net/, including the code used for elevator operation.

We're pleased to announce that all of the packages within the Brown Ros Pkg collection have been updated for ROS-1.0.X compatibility. The Brown automated install script has also been updated to reflect these changes as well. This update should fix any problems caused by using the (formerly) 0.9.0 release with an updated roscore.

We encourage anyone interested to visit brown-ros-pkg . We currently have a driver for the iRobot Create, a basic driver for the Aldebaran Nao, and some basic vision packages.

Additions and improvements include:

probe

A ROS webcam capture node new to this release. Probe leverages Gstreamer, making it compatible with almost every Linux camera and video system available. In addition Gstreamer's software video processing can be used to emulate advanced features (e.g. white-balancing) even for cameras that don't have the appropriate v4l hardware support.

teleop_twist_keyboard

A simple keyboard-based teleop interface inspired by teleop_base. It's only dependencies are on the necessary geometry messages.

As always, we're interested in the communities feedback and suggestions.

_Trevor

Fast on the heels of the Brown Nao driver, Armin Hornung of Albert-Ludwigs-Unversität Freiburg has announced joy-package compatibility and torso odometry additions for the Nao driver -- as well as the alufr-ros-pkg repository. Armin's announcement is below.

Based on the recently announced Nao driver by Brown University, there is now a regular joystick teleoperation node available. It operates Nao using messages from the "joy" topic, so it should work with any gamepad or joystick in ROS. In addition, the control node running on Nao returns some basic torso odometry estimate. The code is available at http://code.google.com/p/alufr-ros-pkg/ to checkout via SVN. A README with more details can be found in the "nao" stack there.

I'm open for feedback and suggestions!

-- Armin

ROS is set up for distributed Open Source development. The system is designed to be built from a federation of repositories, each potentially run by a different organization. We've been happy to see three new ROS package repositories sprout up (besides those already hosted by Stanford, CMU, MIT, and TUM).

bosch-ros-pkg: Bosch has been extending our navigation stack to support frontier-based exploration and they have been contributing patches back to the personalrobots repository. Their wrapper for libgphoto2 has also been getting some use on the ros-users mailing list

gt-ros-pkg: Georgia Tech's Healthcare Robotics Lab has already contributed several packages and the Humanoid Robotics Lab and Socially Intelligent Machines Lab will be participating as well.

wu-ros-pkg: Washington University is also setting up a ROS package repository (which the many Wash-U alumni at Willow Garage are happy to see). Bill Smart's presentation, "Is a Common Middleware for Robotics Possible?" at IROS 2007 helped guide the philosophy and goals of ROS in its earliest stages, especially the focus on making reusable libraries.

Update: the personalrobots repository is now ros-pkg and wg-ros-pkg

A lot of people ask, "How is ROS different from X?" where X is another robotics software platform. For us, ROS was never about creating a platform with the most features, though we knew that the PR2 robot would drive many requirements. Instead, ROS is about creating a platform that would support sharing and collaboration. This may seem like an odd goal for a software framework, especially as it means that we want our code to be useful with or without ROS, but we think that one of the catalysts for robotics will be broad libraries of robotics drivers and algorithms that are freely available and easily integrated into any framework.

We're excited to see so many public ROS package repositories have already emerged. Here's the list that we know of:

• personalrobots.sourceforge.net: (see update) focused on Personal Robotics applications. Willow Garage is helping to maintain this repository with contributions from many others (Stanford, UPenn, TUM, CMU, MIT, etc...).
• sail-ros-pkg.sourceforge.net: started by ROS lead developer Morgan Quigley to house code from the Stanford AI Lab (SAIL) code.
• cmu-ros-pkg.sourceforge.net: maintained by Rosen Diankov of CMU, who has also integrated OpenRAVE with ROS.
• tum-ros-pkg.sourceforge.net: contains several drivers released by Radu Rusu of TUM, who has also been busy with his many contributions to the personalrobots repository (e.g. point_cloud_mapping).
• code.google.com/p/lis-ros-pkg: contains an interface for the Barrett WAM and Hand, written by Kaijen Hsiao of MIT's Learning and Intelligent Systems Group

An ecosystem of federated package repositories is as important to ROS as the ROS node is for powering the distributed system of processes. Just as the ROS node is the unit of a ROS runtime, the ROS package is the unit of code sharing and the ROS package repository is the unit of collaboration. Each provides the opportunity for independent decisions about development and implementation, but all can be brought together with ROS infrastructure tools.

One of the tools we've written to support these federated repositories is roslocate. roslocate solves the problem of "where is package X?" For example, you can type "svn co `roslocate svn imagesift`" to quickly checkout the source code for the "imagesift" package from cmu-ros-pkg. As more ROS repositories emerge, we will continue to refine our tools so that multiple repositories can easily be an integral component of ROS development.

If you have any public repositories of your own that you'd like to share, drop us a note on ros-users and we'll add it to our list.