ICartesianControl.h

Go to the documentation of this file.

// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
 
#ifndef __I_CARTESIAN_CONTROL__
#define __I_CARTESIAN_CONTROL__
 
#include <map>
#include <vector>
 
#include <yarp/os/Vocab.h>
 
#include <ICartesianSolver.h>
 
//---------------------------------------------------------------------------------------------------------------
// KEEP VOCAB LIST AND DOCUMENTATION IN SYNC WITH roboticslab::RpcResponder::makeUsage AT CartesianControlServer/
//-----------------------------------------------------------------------------------------------------------------------------------
// USING `int` INSTEAD OF `yarp::conf::vocab32_t` BECAUSE OF SWIG: https://github.com/roboticslab-uc3m/kinematics-dynamics/issues/180
//-----------------------------------------------------------------------------------------------------------------------------------
 
// General-purpose vocabs
constexpr int VOCAB_CC_OK = yarp::os::createVocab32('o','k');              
constexpr int VOCAB_CC_FAILED = yarp::os::createVocab32('f','a','i','l');  
constexpr int VOCAB_CC_SET = yarp::os::createVocab32('s','e','t');         
constexpr int VOCAB_CC_GET = yarp::os::createVocab32('g','e','t');         
constexpr int VOCAB_CC_NOT_SET = yarp::os::createVocab32('n','s','e','t'); 
 
// RPC commands
constexpr int VOCAB_CC_STAT = yarp::os::createVocab32('s','t','a','t'); 
constexpr int VOCAB_CC_INV = yarp::os::createVocab32('i','n','v');      
constexpr int VOCAB_CC_MOVJ = yarp::os::createVocab32('m','o','v','j'); 
constexpr int VOCAB_CC_RELJ = yarp::os::createVocab32('r','e','l','j'); 
constexpr int VOCAB_CC_MOVL = yarp::os::createVocab32('m','o','v','l'); 
constexpr int VOCAB_CC_MOVV = yarp::os::createVocab32('m','o','v','v'); 
constexpr int VOCAB_CC_GCMP = yarp::os::createVocab32('g','c','m','p'); 
constexpr int VOCAB_CC_FORC = yarp::os::createVocab32('f','o','r','c'); 
constexpr int VOCAB_CC_STOP = yarp::os::createVocab32('s','t','o','p'); 
constexpr int VOCAB_CC_WAIT = yarp::os::createVocab32('w','a','i','t'); 
constexpr int VOCAB_CC_TOOL = yarp::os::createVocab32('t','o','o','l'); 
constexpr int VOCAB_CC_ACT = yarp::os::createVocab32('a','c','t');      
 
// Streaming commands
constexpr int VOCAB_CC_POSE = yarp::os::createVocab32('p','o','s','e');   
#ifndef SWIG_PREPROCESSOR_SHOULD_SKIP_THIS
[[deprecated("use `VOCAB_CC_POSE` instead")]]
constexpr int VOCAB_CC_MOVI = yarp::os::createVocab32('m','o','v','i');
#endif
constexpr int VOCAB_CC_TWIST = yarp::os::createVocab32('t','w','s','t');  
constexpr int VOCAB_CC_WRENCH = yarp::os::createVocab32('w','r','n','c'); 
 
// Control state
constexpr int VOCAB_CC_NOT_CONTROLLING = yarp::os::createVocab32('c','c','n','c');  
constexpr int VOCAB_CC_MOVJ_CONTROLLING = yarp::os::createVocab32('c','c','j','c'); 
constexpr int VOCAB_CC_MOVL_CONTROLLING = yarp::os::createVocab32('c','c','l','c'); 
constexpr int VOCAB_CC_MOVV_CONTROLLING = yarp::os::createVocab32('c','c','v','c'); 
constexpr int VOCAB_CC_GCMP_CONTROLLING = yarp::os::createVocab32('c','c','g','c'); 
constexpr int VOCAB_CC_FORC_CONTROLLING = yarp::os::createVocab32('c','c','f','c'); 
 
// Actuator control
constexpr int VOCAB_CC_ACTUATOR_NONE = yarp::os::createVocab32('a','c','n');              
constexpr int VOCAB_CC_ACTUATOR_CLOSE_GRIPPER = yarp::os::createVocab32('a','c','c','g'); 
constexpr int VOCAB_CC_ACTUATOR_OPEN_GRIPPER = yarp::os::createVocab32('a','c','o','g');  
constexpr int VOCAB_CC_ACTUATOR_STOP_GRIPPER = yarp::os::createVocab32('a','c','s','g');  
constexpr int VOCAB_CC_ACTUATOR_GENERIC = yarp::os::createVocab32('a','c','g');           
 
// Controller configuration (parameter keys)
constexpr int VOCAB_CC_CONFIG_PARAMS = yarp::os::createVocab32('p','r','m','s');        
constexpr int VOCAB_CC_CONFIG_GAIN = yarp::os::createVocab32('c','p','c','g');          
constexpr int VOCAB_CC_CONFIG_TRAJ_DURATION = yarp::os::createVocab32('c','p','t','d'); 
constexpr int VOCAB_CC_CONFIG_CMC_PERIOD = yarp::os::createVocab32('c','p','c','p');    
constexpr int VOCAB_CC_CONFIG_WAIT_PERIOD = yarp::os::createVocab32('c','p','w','p');   
constexpr int VOCAB_CC_CONFIG_FRAME = yarp::os::createVocab32('c','p','f');             
constexpr int VOCAB_CC_CONFIG_STREAMING_CMD = yarp::os::createVocab32('c','p','s','c'); 
 
namespace roboticslab
{
 
class ICartesianControl
{
public:
    virtual ~ICartesianControl() = default;
 
    //--------------------- RPC commands ---------------------
 
    virtual bool stat(std::vector<double> &x, int * state = nullptr, double * timestamp = nullptr) = 0;
 
    virtual bool inv(const std::vector<double> &xd, std::vector<double> &q) = 0;
 
    virtual bool movj(const std::vector<double> &xd) = 0;
 
    virtual bool relj(const std::vector<double> &xd) = 0;
 
    virtual bool movl(const std::vector<double> &xd) = 0;
 
    virtual bool movv(const std::vector<double> &xdotd) = 0;
 
    virtual bool gcmp() = 0;
 
    virtual bool forc(const std::vector<double> &fd) = 0;
 
    virtual bool stopControl() = 0;
 
    virtual bool wait(double timeout = 0.0) = 0;
 
    virtual bool tool(const std::vector<double> &x) = 0;
 
    virtual bool act(int command) = 0;
 
    //--------------------- Streaming commands ---------------------
 
    virtual void pose(const std::vector<double> &x) = 0;
 
#ifndef SWIG_PREPROCESSOR_SHOULD_SKIP_THIS
    [[deprecated("use `pose` instead")]]
    virtual void movi(const std::vector<double> &x)
    {
        pose(x);
    }
#endif
 
    virtual void twist(const std::vector<double> &xdot) = 0;
 
    virtual void wrench(const std::vector<double> &w) = 0;
 
    //--------------------- Configuration accessors ---------------------
 
    virtual bool setParameter(int vocab, double value) = 0;
 
    virtual bool getParameter(int vocab, double * value) = 0;
 
    virtual bool setParameters(const std::map<int, double> & params) = 0;
 
    virtual bool getParameters(std::map<int, double> & params) = 0;
 
};
 
} // namespace roboticslab
 
#endif // __I_CARTESIAN_CONTROL__