ControllerInterface.ice

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    RobotControllers::RobotNJointControllersInterface
 * @author     Jianfeng Gao ( jianfeng dot gao at kit dot edu )
 * @date       2021
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <ArmarXCore/interface/core/BasicTypes.ice>
#include <ArmarXCore/interface/serialization/Eigen.ice>
#include <RobotAPI/interface/units/RobotUnit/NJointController.ice>
#include <RobotAPI/interface/core/Trajectory.ice>
#include <armarx/control/common/mp/MPPoolInterface.ice>
#include <armarx/control/njoint_controller/task_space/ControllerInterface.ice>
#include <armarx/control/interface/ConfigurableNJointControllerInterface.ice>
 
 
module armarx{ module control {
    //    /**
    //    * This is used by the NJointTaskspaceMPControllers like the impedance and admittance controller
    //    */
    //    class ConfigurableNJointMPControllerConfig extends ConfigurableNJointControllerConfig
    //    {
    //        armarx::aron::data::dto::Dict mpConfig;
    //    };
    //    module NJointMultiMPControllerMode
    //    {
    //        enum CartesianSelection
    //        {
    //            ePosition = 7,
    //            eOrientation = 8,
    //            eAll = 15
    //        };
    //    };
 
 
    //    class NJointMultiMPControllerConfig extends NJointControllerConfig
    //    {
    //
    //        // dmp configuration
    //        float DMPKd = 20;
    //        int kernelSize = 100;
    //        double tau = 1;
    //        string dmpMode = "MinimumJerk";
    //        string dmpStyle = "Discrete";
    //        double dmpAmplitude = 1;
    //
    //        double phaseL = 10;
    //        double phaseK = 10;
    //        double phaseDist0 = 50;
    //        double phaseDist1 = 10;
    //        double phaseKpPos = 1;
    //        double phaseKpOri = 0.1;
    //        double timeDuration = 10;
    //        double posToOriRatio = 100;
    //
    //        // velocity controller configuration
    //        string nodeSetName = "";
    //        string tcpName = "";
    //        NJointMultiMPControllerMode::CartesianSelection mode = NJointMultiMPControllerMode::CartesianSelection::eAll;
    //
    //        double maxLinearVel;
    //        double maxAngularVel;
    //        double maxJointVelocity;
    //        string debugName;
    //
    //        float Kp_LinearVel;
    //        float Kd_LinearVel;
    //        float Kp_AngularVel;
    //        float Kd_AngularVel;
    //
    //        float vel_filter;
    //
    //        int jsDMPKernelSize = 100;
    //        int jsDMPBaseMode = 1;
    //        double jsDMPPhaseL = 10;
    //        double jsDMPPhaseK = 10;
    //        double jsDMPPhaseDist0 = 0.3;
    //        double jsDMPPhaseDist1 = 0.1;
    //        double jsDMPPhaseKp = 1;
    //        bool isPhaseStop = false;
    //        Ice::StringSeq jointNamesJSDMP;
    //    };
 
 
    //    interface NJointMultiMPControllerInterface extends NJointControllerInterface
    //    {
    //        void learnTSDMPFromFiles(Ice::StringSeq trajfiles);
    //        void learnJSDMPFromFiles(Ice::StringSeq trajfiles);
    //        bool isFinished();
    //        void runDMP(Ice::DoubleSeq goalsTS, Ice::DoubleSeq goalsJS, double times);
    //        void runDMPWithTime(Ice::DoubleSeq goals, double time);
    //
    //        void setSpeed(double times);
    //        void setViaPoints(double canVal, Ice::DoubleSeq point);
    //        void setViaPointsJS(double canVal, double point);
    //        void removeAllViaPoints();
    //        void setGoalsTS(Ice::DoubleSeq goals);
    //        void setGoalsJS(Ice::DoubleSeq goals);
    //
    //        double getCanVal();
    //        void resetDMP();
    //        void stopDMP();
    //        void pauseDMP();
    //        void resumeDMP();
    //
    //        void setControllerTarget(float avoidJointLimitsKp, NJointMultiMPControllerMode::CartesianSelection mode);
    //        void setTorqueKp(StringFloatDictionary torqueKp);
    //        void setNullspaceJointVelocities(StringFloatDictionary nullspaceJointVelocities);
    //        string getTSDMPAsString();
    //        Ice::DoubleSeq createTSDMPFromString(string dmpString);
    //        string getJSDMPAsString();
    //        Ice::DoubleSeq createJSDMPFromString(string dmpString);
    //
    //    };
 
 
    //    class KeypointMPControllerConfig extends NJointTaskspaceAdmittanceControllerConfig
    //    {
    //        // dmp configuration
    //        int numKeypoints;
    //        string controlParamJsonFile = "";
    //
    //        float keypointKp;
    //        float keypointKi;
    //        float keypointKd;
    //        float maxControlValue;
    //        float maxDerivation;
    //        float filterCoeff;
    //        bool isRigid;
    //        Eigen::VectorXf pointCtrlMask;
    //        Eigen::VectorXf initialKeypointPosition;
    //    };
 
 
    //    interface KeypointMPControllerInterface extends NJointTaskspaceAdmittanceControllerInterface, MPPoolInterface
    //    {
    //        void setKeypoints(Eigen::VectorXf xyz);
    //        void resetKeypoints(int n_points, float keypoint_stiffness, bool is_rigid, Eigen::VectorXf ctrl_mask, Eigen::VectorXf init_keypoints_position);
    //        void toggleMP(bool enableMP);
    //    };
 
    interface NJointTSAdmittanceMPControllerInterface extends NJointTaskspaceAdmittanceControllerInterface, MPPoolInterface
    {};
 
    interface NJointTSImpedanceMPControllerInterface extends NJointTaskspaceImpedanceControllerInterface, MPPoolInterface
    {};
 
    //    interface NJointKeypointsAdmittanceMPControllerInterface extends NJointKeypointsAdmittanceControllerInterface, MPPoolInterface
    //    {};
 
    //    interface NJointKeypointsImpedanceMPControllerInterface extends NJointKeypointsImpedanceControllerInterface, MPPoolInterface
    //    {};
 
    interface NJointKVILImpedanceMPControllerInterface extends NJointKeypointsImpedanceControllerInterface, MPPoolInterface
    {
        void setCurveProjection(Eigen::Vector3f curve_proj_point, float proj_value, Eigen::Vector3f curve_vec);
        Eigen::Vector3f getCurveKeypointPosition();
    };
};  /// control
};  /// armarx