Project completed and ongoing work on the results

I have completed the project in mid April, but I am still working on the packages in my free time – a project is never really finished, there’s always more to improve and add! My github pages will be updated and documentation is provided on the Wiki pages.

At the end of the project, I went to visit the offices at OSRF and held a presentation about the project and the results achieved. Aside from receiving useful feedback, the most pleasant about this trip was to meet the lovely team at OSRF. It is such a good vibe at their offices, I didn’t want to leave!

I’m very happy about the results of the project and my trip to OSRF – it has given me the opportunity to get involved in the Open Source community and meet other like-minded developers. I will continue working on my open-source code in the future, and am aiming to add more software packages on my github repository over time.

Automated grasp execution

In the last couple of weeks I have used most of the other packages I developed in this project and put them together to execute a grasp automatically: An object can be spawned at a random position close to the arm in Gazebo, the motion plan will be computed accordingly, and the robot reaches to and grasps the object using my ROS services and actions.

The tutorial for this is still under construction and will be finished in the next few days, including an insight into the source code required to make this example work, and showing that not much code is necessary to achieve the automated grasp when using the ROS services/actions in my repositories.

I have also improved the Gazebo grasp plugin, addressing this issue which was reported on my github.

Another thing I’ve been working on is getting the packages added as ROS package on ros.org. The GraspIt! packages have now been added as graspit_tools. The other packages are still to be changed frequently in the next few weeks, so I decided against adding them right away to ROS, in order to avoid re-releasing updates at a high rate. All other repositories of this project will be added in the next few weeks.

Migrated packages and started grasp execution

I have started working towards adding my packages to ros.org. For this, the sources and documentation have been re-packaged into new repositories (along with their own wikis):

My GraspIt! fork now compiles into a library in graspit-pkgs. No headers or libraries of the original GraspIt! source are installed. This was done in the process of preparing for ROS packages, because the original GraspIt! code is not in the ROS builds / ubuntu packages yet.

I have also started working on the grasp execution, with the first tutorials being available in grasp-execution-pkgs.

Trajectory execution and MoveIt!

The Jaco arm can now execute a joint trajectory with the implemented arm controllers in Gazebo. The trajectory can be computed with MoveIt!. Collision objects (like the cube to be grasped) are also sent to MoveIt! via the object information pipeline described in the wiki.

There has also been work on existing and new tutorials on the wiki, to which I would like to refer to in general. Probably the wiki contains more up-to-date information than this blog.

Added Jaco example

Most recent work on my packages include:

  • added the Kinova Jaco arm as example configuration
  • written control plugins for the Jaco arm in gazebo
  • tested ros_control with the Jaco arm
  • worked on the build system for my fork of GraspIt
  • worked on the wiki pages and added tutorials
  • started working on backwards compatibility with ROS Indigo

The next goal is to finish testing the joint trajectory execution for the Jaco arm, and integrate it with MoveIt!. Then, the grasp execution can be tested with the Jaco arm.

C++ interface ready

The C++ interface to GraspIt! is now ready to use. Over the last two weeks I have worked on eliminating outstanding issues and bugs. There are still some optional improvements that may be added over time, which are tracked as issues in my git repository.

I have started to work on the grasp execution with Gazebo and am expecting to have the first working version by mid next week.

GraspIt Eigengrasp planner now working

I have created the C++ interface for using the GraspIt EigenGrasp planner without a GUI. The source can be found in the package grasp_planning_graspit. The results of the planning process can be saved as GraspIt world files and viewed in the original GraspIt simulator.

The GraspIt source is now a separate repository which is eventually meant to fork from a original source repository (if the developer is happy to move from svn to git). It is available in my repository graspit_ros. For now, it is just a fork of my own git repository which contains a 1:1 copy of the most recent source code I pulled from the original GraspIt svn repository. The package graspit_ros is a catkin package which can be used with catkin_make to compile a library and an executable of the original GraspIt simulator.

In the next few days I will keep working on the C++ interface and provide other means to get the results, including a ROS service. The next step is then to create an environment to test the grasps in Gazebo using the Jaco hand as an example.

 

Work on urdf2graspit package and C++ API

In the last weeks I have refined the urdf2graspit package which allows users to convert from URDF to the format used in GraspIt. It is now ready to be used.

The original GraspIt code now compiles with catkin – it is not necessary any more to use qmake.

I have also added a test C++ API interfacing the GraspIt planning algorithms. The main task was to rewrite some code such that the planner can be run without the graphical interface, and to write a C++ interface to load the robot and object files and to do the planning. This required some changes in the original GraspIt source, but I tried to keep the changes as minimally invasive as possible. The C++ interface is only a test at this stage and will be further developed into a final version in the next weeks.