How To Implement Redundant Tasks?

[Woolfrey]

The current method of RMRC is through this function:

Eigen::VectorXf SerialKinCtrl::get_cartesian_control(const float &time)

I've programmed in the foundations for redundancy resolution inside. At the moment it uses singularity avoidance as default. I was thinking of some sort of switch case to select redundant tasks when solving the control:

switch(redundantTask)
{
     case: manipulability
     {
          // Do calcs
          break;
     }
     case: force
     {
          // Do calcs
          break;
     }
     etc...
}

Alternatively, we could write a function like:

Eigen::VectorXf SerialKinCtrl::get_cartesian_control(const float &time, const Eigen::VectorXf &redundantTask)

where the redundant task is specified by the user, in case it is something unique they want to apply.

Something to think about...

[Woolfrey]

@ssutjipto.

I've changed this to a discussion since it's not urgent/critical for RobotLibrary.

At the moment I'm leaning towards two functions for RMRC. One basic one that will compute the joint velocities and use singularity avoidance by default:

Eigen::VectorXf SerialKinCtrl::get_cartesian_control(const Eigen::Isometry3f &pose, const Eigen::VectorXf &vel)
{
          // Do calcs
         return qdot;
}

and another that accepts the redundant task as an input:

Eigen::VectorXf SerialKinCtrl::get_cartesian_control(const Eigen::Isometry3f &pose, const Eigen::VectorXf &vel, const Eigen::VectorXf &redundantTask)
{
          // Do calcs
          return qdot;
}

I had originally thought to have several different redundant tasks built in that we could put in an enum list or something. Then the user could select which one to activate when doing RMRC. But then if you want to optimize for external forces, for example, you need to specify a direction, so that's another argument to be specified and it starts getting complicated...

So I think it's best just to have singularity avoidance as default, which is easy to do, and an option for a redundant task that the user can compute themselves, elsewhere.