OpenRAVE - New pages [en]

GraspModuleIK

2011-12-19T09:39:00Z

SteveHegenbart: /* Using the grasping module for an neuronics-katana 5D arm */

The GraspModuleIK is a grasping plugin for the C++ API. The currently version uses both an IkSolver for the main path planning and an trajectory and collision detection algorithm to open and close the gripper for grabbing an object. Yet it has only implemented simple grasping positions and an 5D IkParameterization. Still, the module is designed for simple extensions to add also other robot models.

== Sourceforge Directory ==

https://sourceforge.net/projects/orgraspmoduleik/

== The GraspingModuleIK class ==

=== Attributes ===

The class keeps simple private attributes, mostly initialized when the module is created:

<source lang="cpp">
private:
OpenRAVE::RobotBasePtr _probot; ///< The active robot that will grab
OpenRAVE::ModuleBasePtr _pikmodule; ///< IkSolver module to get joint solutions
OpenRAVE::ModuleBasePtr _pbasemanip; ///< Basemanipulator to simulate the robots movement
OpenRAVE::RobotBase::ManipulatorPtr _pmanip; ///< Active manipulator to load the ikSolver
boost::shared_ptr<GraspParameters> _params; ///< Grasping parameter struct

enum handPosition {positionClose, positionOpen, positionBase};
enum handMoveMode {openHand, closeHand};
</source>

The enumerations are used inside inner methods to change the gripper position. Yet the grasping module needs to be reinitialized to change the base pointers i.g. the robot and modules specified for the robot.

=== Public Methods ===

The main functions to use are the grasping function, releasing objects and the main move function (normally used after an object is grabbed, it can also be used without any object).

<source lang="cpp">
bool GraspTarget(boost::shared_ptr<GraspParameters> params);
void ReleaseAllObjects();
bool ReleaseObject(OpenRAVE::KinBodyPtr target);
bool MoveObjectToPosition(OpenRAVE::RAY ray);
</source>

The GraspTarget will open the gripper if possible, then move to the target and grab it. The main usage of the module is as following:

* Create the module
* Call GraspTarget()
* Call MoveObjectToPosition()
* Call ReleaseObject() or ReleaseAllObjects()

=== GraspParameters ===

The GraspParameters struct is holding all informations to grab an object. It is defined as followed:

<source lang="cpp">
struct GraspParameters {
OpenRAVE::KinBodyPtr _target;
///< The target which shall be grabbed
OpenRAVE::dReal _standoff;
///< Standoff between target and robot in grab direction that will be held, in default this will be zero
OpenRAVE::dReal _offset;
///< The offset in z direction from the basic point of the target where the robot will grab the target
OpenRAVE::dReal _coarsestep;
///< Coarse step value used to approach the target while closing the gripper
OpenRAVE::dReal _finestep;
///< Fine step value used to approach the target while closing the gripper, this will be used after the coarse approximation
int _grabDirection;
///< The used grab direction to grab the target with the robot arm. Here the OpenRAVE DOF-Values DOF_X, DOF_Y and DOF_Z can be used
int _ikParameterization;
///< The ikParameterization for the robot used to initialize the ikSolver
bool _avoidTargetCollision;
///< If set, the gripper will step back a bit after there was a collision with the target while closing the gripper
};</source>

There is also an constructor defined for the struct, defining default values for all parameters except the target, the grabDirection and the ikParameterization.

<source lang="cpp">
GraspParameters(OpenRAVE::KinBodyPtr target, int grabDirection, int ikParameterization, OpenRAVE::dReal standoff = 0.0f,
OpenRAVE::dReal offset = 0.05f, OpenRAVE::dReal coarsestep = 0.1f, OpenRAVE::dReal finestep = 0.01f,
bool avoidTargetCollision = true)
</source>

== Code Examples ==
=== Using the grasping module for an neuronics-katana 5D arm ===

The following code shows how to initialize the module, define some parameters and call the main methods to grab some cups. There are two cups in the environment, standing on a table, as well as a bottle of ketchup. The first cup will be grabbed and placed down between the second cup and the bottle. Then, the second cup will be grabbed and placed to the original position of the first cup.

<source lang="cpp">
// ***** Get target KinBody
KinBodyPtr target = penv->GetKinBody("cup1");
std::string targetType;
targetType = target->GetURI().substr(target->GetURI().find_last_of('/') + 1).c_str();

// ***** Initialize grasper and graspParameters
GraspingModuleIK grasper(penv, probot);

dReal standoff = 0.0f;
dReal offset = 0.5f;

RAY first;
first.pos = target->GetTransform().trans;
first.dir = Vector(0,0,1);
first.dir.normalize3();

boost::shared_ptr<GraspParameters> params(new GraspParameters(target, (int)DOF_Z, (int)IkParameterization::Type_TranslationDirection5D, standoff, offset));
params->_coarsestep = 0.1f;
params->_finestep = 0.01f;
params->_avoidTargetCollision = false;
params->_target = penv->GetKinBody("cup1");

// ***** Grasp target object
grasper.GraspTarget(params);

// ***** Move object to new position and release it
RAY ray;
ray.pos = penv->GetKinBody("cup2")->GetTransform().trans;
ray.pos.y = (ray.pos.y + penv->GetKinBody("ketchup")->GetTransform().trans.y) / 2.0;
ray.pos.z += params->_offset;
ray.dir = Vector(0,0,1);
ray.dir.normalize3();
grasper.MoveObjectToPosition(ray);
grasper.ReleaseAllObjects();

// ***** Grab new target and move it
params->_target = penv->GetKinBody("cup2");
grasper.GraspTarget(params);

first.pos.z += params->_offset;
grasper.MoveObjectToPosition(first);
grasper.ReleaseAllObjects();
</source>

BaseManipulation

2011-11-29T22:14:54Z

Rdiankov:

== Code Examples ==
=== Setting A Robots Manipulators To Default ===
<source lang="cpp">
baseManip = RaveCreateModule(penv, "BaseManipulation");
if(baseManip == NULL)
{
ROS_FATAL("Was unable to create module BaseManipulation. Check your $OPENRAVE_PLUGINS\n");
return false;
}
penv->AddModule(baseManip, myRobot->GetName());
//Move our manipulators to default positions so they don't fall with physics...
stringstream sinput, soutput;
for(vector<RobotBase::ManipulatorPtr>::const_iterator myIt = myRobot->GetManipulators().begin();
myIt != myRobot->GetManipulators().end(); myIt++)
{
sinput.clear();
sinput.str("");
sinput << "MoveManipulator goal";
for(unsigned int i = 0; i < (*myIt)->GetArmIndices().size(); i++)
sinput << " 0";

myRobot->SetActiveManipulator((*myIt)->GetName());
baseManip->SendCommand(soutput, sinput);
}
</source>

FAQ

2011-11-21T16:08:55Z

Rdiankov:

== Installation Questions ==
# '''How do I use OpenRAVE with ROS?'''
#* Install the '''rospackages''' ''openrave'', ''collada_robots'', and ''soqt'' found on the ROS website. Also make sure you have ''python-sympy'' from your OS repo. Now, whenever you want to use openrave, just update your manifest.xml with a
<source lang="xml">
<depend package="openrave" />
</source>
#* You also have another option, download openrave from source. Compile and install it. To add it to your ROS_PATH, you need a manifest.xml in an "openrave" folder inside your '''ROS_PACKAGE_PATH'''. I need to update this and add a manifest.xml you can use. (just the same one from the ros repo install)

== Physics and OpenRAVE ==
# '''When I turned physics on, my robot fell apart.'''
#: This is because the time step of your simulation is too large. Try setting a smaller timestep (<= 0.001).
#: In python:
<source lang="python">
env.StopSimulation()
env.StartSimularion(0.001)
</source>
#: In C++:
<source lang="cpp">
EnvironmentBasePtr env = RaveCreateEnvironment;
env->StopSimulation();
env->StartSimularion(0.001);
</source>
# '''Is there a parallel/modified ODE plugin? What about setting contact joints?'''
#* The ode engine from ROS (''opende'') employs a few patches, as well as a parallelization patch. You can rosmake the opende package. HOWEVER, then you must recompile the odeplugin (OpenRAVE plugin) and force OpenRAVE to use the sources and shared libraries from the modified ODE engine. Lucky for you, the opende package has an odeconfig tool which spits out the correct flags for you.
#* There is also a plugin developed by CSIRO ASL. Among the things they changed is allowing the individual parameter setting of contact joints in the xml. [https://code.launchpad.net/csiro-asl-ros-pkg Here] is the repo. You need openrave in your '''ROS_PACKAGE_PATH''' to use its CMake. It may be possible to modify the CMake file using openrave-config to get all the flags.
# '''My physics is unstable what can I do?'''
#* The first most important thing you should do, is lower the timestep as stated above.
#* The second most important thing to do, is set your erp and cfm. The OpenRAVE ODE plugin by default sets them extremely low. An explanation can be found [http://opende.sourceforge.net/wiki/index.php/Manual_(Concepts)#Soft_constraint_and_constraint_force_mixing_.28CFM.29 here].
#** Just setting the <erp>0.4</erp> drastically stabilized my simulations.

== OpenRAVE Planners ==