Efforts are underway to develop a navigation stack for the arms analogous to the navigation stack for mobile bases. This includes a wide range of libraries that can be used for collision detection, trajectory filtering, motion planning for robot manipulators, and specific implementations of kinematics for the PR2 robot.

As part of this effort, Willow Garage is happy to announce the release of our first set of research stacks for arm motion planning. These stacks include a high-level arm_navigation stack, as well as general-purpose stacks called motion_planners, motion_planning_common, motion_planning_environment, motion_planning_visualization, kinematics, collision_environment, and trajectory_filters. There are also several PR2-specific stacks. All of these stacks can be installed on top of Box Turtle:

Installation Page

Significant contributions were made to this set of stacks by our collaborators and interns over the past two years:

• Ioan Şucan (from Lydia Kavraki's lab at Rice) developed the initial version of this framework while an intern at Willow Garage over the summer of 2008 and 2009 and has continued to contribute significantly since. His contributions include the OMPL planning library that contains a variety of probabilistic planners including ones developed by Lydia Kavraki's lab over the years.
• Maxim Likhachev's group at Penn (including Ben Cohen, who was a summer intern at Willow Garage in 2009) contributed the SBPL planning library that incorporates the latest techniques in search based motion planning.
• Mrinal Kalakrishnan from USC developed the CHOMP motion planning library while he was an intern at Willow Garage in 2009. This library is based on the work of Nathan Ratliff, Matthew Zucker, J. Andrew Bagnell and Siddhartha Srinivasa.

Additional contributions also came from Radu Rusu, Matei Ciocarlei and Kaijen Hsiao (from Willow Garage) and Rosen Diankov (from CMU).

These stacks are currently classified as research stacks, which means that they have unstable APIs and are expected to change. We expect the core libraries to reach maturity fairly quickly and be released as stable software stacks, while other stacks will continue to incorporate the latest in motion planning research from the world-wide robotics community. We encourage the community to try them out to provide feedback and contribute. A good starting point for is the arm_navigation wiki page. There is also a growing list of tutorials.

Here are some blog posts of demos that show these stacks in use:

1. JSK demo (pr2_kinematics)
2. Robot replugged (pr2_kinematics)
3. Hierarchical planning (OMPL, move_arm)
4. Towers of Hanoi (move_arm)
5. Detecting tabletop objects (move_arm)

You can also watch the videos below that feature the work of Ben Cohen, Mrinal Kalakrishnan, and Ioan Şucan.

The individual stack and package wiki pages have descriptions of the current status. We have undergone a ROS API review for most packages, but the C++ APIs have not yet been reviewed. We encourage you to use the ROS API -- we will make our best effort to keep this API stable. The C++ APIs are being actively worked on (see the Roadmap on each Wiki page for more details) and we expect to be able to stabilize a few of them in the next release cycle.

Please feel free to point out bugs, make feature requests, and tell us how we can do better. We particularly encourage developers of motion planners to look at integrating their motion planners into this effort. We have made an attempt to modularize the architecture of this system so that components developed by the community can be easily plugged in. We also encourage researchers who may use these stacks on other robots to get back to us with feedback about their experience.

Best Regards,

Your friendly neighborhood arm navigation development team

Sachin Chitta, Gil Jones (Willow Garage)
Ioan Sucan (Rice University)
Ben Cohen (University of Pennsylvania)
Mrinal Kalakrishnan (USC)

Videos

Ioan Şucan, OMPL (blog post):

Ben Cohen, SBPL (blog post):

Mrinal Kalakrishnan, CHOMP (blog post):

In recent posts, we've showcased the rviz 3-D visualizer and navigation stack, two of the many useful libraries and tools included in the ROS Box Turtle distribution. Now, we'd like to highlight what we're developing for future distribution releases.

The first is the PR2 calibration stack. The PR2 has two stereo cameras, two forearms cameras, one high-resolution camera, and both a tilting and base laser rangefinder. That's a lot of sensor data to combine with the movement of the robot.

The PR2 calibration stack recently made our lives simpler when updating our plugging-in code. Eight months ago, without accurate calibration between the PR2 kinematics and sensors, the original plugging-in code applied a brute force spiralling approach to determining an outlet's position. Our new calibration capabilities give the PR2 the new-found ability to plug into an outlet in one go.

The video above shows how we're making calibration a simpler, more automated process for researchers. The PR2 robot can calibrate many of its sensors automatically by moving a small checkerboard through various positions in front of its sensors. You can start the process before lunch, and by the time you get back, there's a nicely calibrated robot ready to go. We're also working on tools to help researchers understand how well each individual sensor is calibrated.

The PR2 calibration stack is still under active development, but can be used by PR2 robot users with Box Turtle. In the future, we hope this stack will become a mature ROS library capable of supporting a wide variety of hardware platforms.

The Kawada HRP-2V is a variant of the HRP-2 "Promet" robot. It uses the torso, arms, and sensor head of the HRP-2, but it is mounted to an omni-directional mobile base instead of the usual humanoid legs. The JSK Lab at Tokyo University uses this platform for hardware and software research.

In May of 2009 at the ICRA conference, the HRP-2V was quickly integrated with the ROS navigation stack as a collaboration between JSK and Willow Garage. Previously, JSK had spent two weeks at Willow Garage integrating their software with ROS and the PR2. ICRA 2009 was held in Kobe, Japan, and Willow Garage had a booth. With laptops and the HRP-2V setup next to the booth, JSK and Willow Garage went to work getting the navigation stack on the HRP-2V. By the end of the conference, the HRP-2V was building maps and navigating the exhibition hall.

Logging and playback is one of the most critical features when developing software for robotics. Whether you're a hardware engineer recording diagnostic data, a researcher collecting data sets, or a developer testing algorithms, the ability to record data from a robot and play it back is crucial. ROS supports these needs with "Bag files" and tools like rosbag and rxbag.

rosbag can record data from any ROS data source into a bag file, whether it be simple text data or large sensor data, like images. The tool can also record data from programs running on multiple computers. rosbag can play back this data just as it was recorded -- it looks identical. This means that data can be recorded from a physical robot and used to create virtual robots to test software. With the appropriate bag file, you don't even need to own a physical robot.

There are a variety of tools to help you manage your stored data, such as tools for filtering data and updating data formats. There are also tools to manage research workflows for sending bag files to Amazon's Mechanical Turk for dataset labeling. For data visualization, there is the versatile rxbag tool. rxbag can scan through camera data like a movie editor, plot numerical data, and view the raw message data. You can also write plugins to define viewers for your own data types.

You can watch the video to see rosbag and rxbag in action. Both of these tools are part of the ROS Box Turtle release, which you can download from ROS.org.

Several stacks have transitioned to 1.1 unstable development branches: common_msgs 1.1.1, image_pipeline 1.1.0, and vision_opencv 1.1.0. These are unstable development releases: it is recommended for users to keep using the 1.0 branch in Box Turtle. Our stack version policy describes our general development model for stable and unstable releases.

common 1.1

The primary part of this release is the addition of the nodelet package. There was discussion on the ros-users mailing list earlier about how this can be used as an optimization. If you are interested please take a look at the documentation or code. Feedback is always appreciated.

image_pipeline 1.1

The major new features are in stereo_image_proc. It takes advantage of improvements to the OpenCV stereo block matcher, particularly to reduce fringe artifacts at edges. For comparison, the reference implementation of stereo block matching (on which OpenCV's was based) can be used instead, but they should now give roughly the same results. stereo_image_proc now advertises a separate point cloud topic using the new and improved PointCloud2 message type.

Change lists

• common_msgs
• image_pipeline
• vision_opencv

Several stacks have been updated with patches for Box Turtle.

• camera_drivers 0.9.2
• geometry 1.0.2
• laser_drivers 1.0.4
• vision_opencv 1.0.1
• web_interface 0.3.11

pr2_calibration, which is still in unstable development, was also updated to 0.3.0.

Change lists

• camera_drivers
• geometry
• laser_drivers
• pr2_calibration
• vision_opencv
• web_interface

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 cob3_driver stack provides ROS software integration for these sensors in the sick_s300, cob3_camera_sensors, and cob3_hokuyo packages.

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 generic_can and canopen_motor, as well as wrappers for libntcan and libpcan. The SCHUNK components are supported by the sdh, powercube_chain, libm5api packages.

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.

Junior is the Stanford Racing team's autonomous car that most famously finished in a close second at the DARPA Urban Challenge. It successfully navigated a difficult urban environment that required obeying traffic rules, parking, passing and many other challenges of real-world driving.

Those of you familiar with Junior are probably saying, "Junior doesn't use ROS! It uses IPC!"

That's mostly true, but researchers have recently started using ROS-based perception libraries in Junior's obstacle classification system.

From the very start, one of the goals of ROS was to keep libraries small and separable so that you could use as little, or as much, as you want. In the case of the tiny i-Sobot, a developer was able to just use ROS's PS3 joystick driver. When frameworks get too large, they becomes much more difficult to integrate with other systems.

In the case of Junior, Alex Teichman was able to bring his image descriptor library for ROS onto Junior. He has been using this library, along with ROS point cloud libraries, to develop Junior's obstacle classification system. Other developers on the team will also be allowed to choose ROS for their programs where appropriate.

You can find out more about Alex's image descriptor library at ros.org/wiki/descriptors_2d.

In addition to core robotics libraries, like navigation, the ROS Box Turtle release also comes with a variety of tools necessary for developing robotics algorithms and applications. One of the most commonly used tools is rviz, a 3-D visualization environment that is part of the ROS Visualization stack.

Whether it's 3D point clouds, camera data, maps, robot poses, or custom visualization markers, rviz can display customizable views of this information. rviz can show you the difference between the physical world and how the robot sees it, and it can also help you create displays that show users what the robot is planning to do.

You can watch the video above for more details about what the ROS rviz tool has to offer, and you can read documentation and download the source code at: ros.org/wiki/rviz.