RMLTask.hpp

Go to the documentation of this file.

/* Generated from orogen/lib/orogen/templates/tasks/Task.hpp */

#ifndef TRAJECTORY_GENERATION_RMLTASK_TASK_HPP
#define TRAJECTORY_GENERATION_RMLTASK_TASK_HPP

#include "trajectory_generation/RMLTaskBase.hpp"
#include "trajectory_generationTypes.hpp"
#include <ReflexxesAPI.h>

/* TODOs (D.M, 2016/06/28):
 *
 * - Introduce a "stop" functionality, which leads to a controlled stop of the robot (while repecting the motion constraints). This can be useful
 *   if, e.g. the robot shall be stopped by some external sensor event, without performing a 'hard' stop
 * - Introduce a "reset" functionality, which sets the current interpolator state to the actual state. This can be used after the robot has stopped
 *   to bring the system to a safe initial state
 * - Add the possibility to control compliant joints. Here the problem is that the interpolator state is quite often not the same as the actual
 *   robot state (because of a position deviation due to an external force applied to the robot). This could be handles by adding a "maximum allowed
 *   deviation" between actual and interpolator state. However, the continuity of the output signal has to be ensured at all times!
 */

namespace trajectory_generation{

class RMLTask : public RMLTaskBase
{
    friend class RMLTaskBase;
protected:
    MotionConstraints motion_constraints;        
    ReflexxesAPI* rml_api;                       
    RMLInputParameters *rml_input_parameters;    
    RMLOutputParameters *rml_output_parameters;  
    RMLFlags* rml_flags;                         
    ReflexxesResultValue rml_result_value;       
    ReflexxesInputParameters input_parameters;   
    ReflexxesOutputParameters output_parameters; 
    base::Time timestamp;                        
    double cycle_time;                           
    virtual void updateMotionConstraints(const MotionConstraint& constraint,
                                         const size_t idx,
                                         RMLInputParameters* new_input_parameters) = 0;

    virtual RTT::FlowStatus updateCurrentState(RMLInputParameters* new_input_parameters) = 0;

    virtual RTT::FlowStatus updateTarget(RMLInputParameters* new_input_parameters) = 0;

    virtual ReflexxesResultValue performOTG(RMLInputParameters* new_input_parameters,
                                            RMLOutputParameters* new_output_parameters,
                                            RMLFlags *rml_flags) = 0;

    virtual void writeCommand(const RMLOutputParameters& new_output_parameters) = 0;

    virtual void printParams(const RMLInputParameters& in, const RMLOutputParameters& out) = 0;

    virtual const ReflexxesInputParameters& convertRMLInputParams(const RMLInputParameters &in, ReflexxesInputParameters& out) = 0;

    virtual const ReflexxesOutputParameters& convertRMLOutputParams(const RMLOutputParameters &in, ReflexxesOutputParameters& out) = 0;

    void handleResultValue(ReflexxesResultValue result_value);

public:
    RMLTask(std::string const& name = "trajectory_generation::RMLTask");
    RMLTask(std::string const& name, RTT::ExecutionEngine* engine);
    ~RMLTask();
    bool configureHook();
    bool startHook();
    void updateHook();
    void errorHook();
    void stopHook();
    void cleanupHook();
};
}

#endif