About | Support | Discussion Forum | Index | Service Status | ros @ Robotics Stack Exchange

Using cob_arm_navigation to plan collision-free arm movements for Care-O-bot 3.

Description: This tutorial will explain which launch files need to be started to plan collision-free movements for the care-o-bot mobile manipulator.

Tutorial Level: INTERMEDIATE

Initial Notes

At the moment we are restructuring and simplifying our cob_manipulation stack. Thus, this tutorial might not be up to date the time you are running it. We'll try to always make it cover the current version. However, if you have problems running this tutorial, contact us on the Care-O-bot MailingList.

August 2012

Since the latest changes within the cob_manipulation stack have not been released yet. You need to get overlays for both cob_manipulation and cob_manipulation_sandbox (https://github.com/ipa320/cob_manipulation_sandbox). You can find instructions here.

Prerequisites

• Be familiar with cob_bringup
  • This tutorial assumes that you are familiar with either:

    • starting a simulated care-o-bot in gazebo (see cob_bringup_sim) OR

    • starting a real care-o-bot (see cob_bringup)

• Compile the code

  • Please compile cob_arm_navigation to make sure all dependencies can be found.

      rosdep install cob_arm_navigation
      rosmake cob_arm_navigation

• Update cob_manipulation_config

  • All configurations needed for cob_arm_navigation can be found in cob_manipulation_config. The configuration files should already exist for your robot (cob3-X or raw3-X). However, whenever you change the robot description (i.e. the urdf), we recommend you update the config files by running the script provided in cob_manipulation_config.

      roscd cob_manipulation_config/bin
      python update_planning_description.sh robot_name

    where robot_name is the name of your robot (i.e. cob3-X or raw3-X). The script takes some time to finish. It creates config files similar to the planning description configuration wizard. For understanding the files please refer to this tutorial. Once created by the script, the config files should not be changed manually!

Start the planning environment

After bringing up the Care-O-bot (simulated or real), the planning environment can be started with

roslaunch cob_arm_navigation start_planning_environment.launch

This currently supports motion-planning considering self-collision and static collision objects.

The consideration of sensor data for collision-checking is currently validated and therefore not yet supported.

Perform planned motion

There are to ways to use the planning environment to perform planned collision-free motion on the Care-O-bot.

Planned motion using the dashboard

The easiest way to plan collision-free paths to predefined configurations is to use the cob_dashboard which is started by

roslaunch cob_bringup dashboard.launch

On the cob_dashboard you can move all modules of the care-o-bot. However, planned motion can only be performed for the arm. To do so, enable the "Planning" check-box on the left side of the dashboard. As long as "Planning" is active all arm movements are planned.

Please note that the robot's initial configuration needs to be collision-free. If you are in a collision, simply deactivate "Planning" and move the arm without planned motion until it is collision-free again.

Planned motion within a script

We are restructuring our scripting environment to augment it with new features (e.g. plan a sequence of motions in advance before executing). Also, it will be easier to use in the future.

Up-to-date instructions will follow as soon as work is completed.

Adding collision objects

Please refer to the planning_scene to get a general understanding how collision objects within the environment are considered during a planning step.

In general, collision objects are added to the planning scene by publishing a collision object message on the /collision_object topic.

There are more tutorials on this available here.

We created a simple interface for setting up a planning_scene with various collision_objects. These collision_objects can either be real or just virtual.

The interface is provided by the cob_object_handler. The cob_object_handler allows you to add, remove, attach and detach collision_objects to the planning_scene. The objects can either be described by primitive geometric shapes (sphere, cylinder, box), by meshes (supported are various file formats, e.g. *.stl, *.obj, *.dae) or by an urdf/urdf.xacro file. It is also possible to handle objects detected using the cob_object_perception.

You can find an example file showing the full potential here.

To run the script use:

roscd cob_object_handler/scripts
python load_scene_tutorial.py

This will add the following to your planning scene:

By running

roscd cob_object_handler/scripts
python reset_scene.py

you can clear the planning scene (all collision_objects and attached_collision_objects are removed).

Visualizing and Debugging

To see the current planning scene with the collision objects you can use the following rviz configuration.

roslaunch cob_arm_navigation rviz.launch

This starts rviz with preconfigured plugins for visualizing and debugging a planning step. Including:

• CollisionObjects: displays all collision objects that are published onto the /planning_scene_markers_array topic.

• CollisionContacts: displays the points where collisions occured during a planning step.

• Planned Path: shows the trajectory computed by the used motion planner

• Filtered Path: shows the trajectory that has been post-processed by the trajectory_filters.