type.h

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/>.
 *
 * @author     Jianfeng Gao ( jianfeng dot gao at kit dot edu )
 * @date       2022
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <SimoxUtility/meta/enum/EnumNames.hpp>
 
namespace armarx::control::common
{
 
    enum class ControllerType
    {
        // ----------- NjointControllers -----------
        TSAdm, // TSAdmittance,
        TSImp, // TSImpedance,
        TSVel,
        TSMixImpVel, // TSMixedImpedanceVelocity,
 
        TSImpCol, // TSCollisionAvoidanceImpedance,
        // TSImpObjCol, // TSObjectCollisionAvoidanceImpedance,
        TSAdmCol, // TSCollisionAvoidanceAdmittance,
        TSVelCol,
        TSVeloCol,
        TSMixImpVelCol, // TSCollisionAvoidanceMixedImpedanceVelocity,
 
        // ----------- NJointMPControllers -----------
        TSMPAdm, // TSAdmittanceMP,
        TSMPImp, // TSImpedanceMP,
        TSMPVel,
        TSMPMixImpVel, // TSMixedImpedanceVelocityMP,
 
        TSMPImpCol, // TSCollisionAvoidanceImpedanceMP,
        TSMPVelCol,
        TSMPVeloCol,
        TSMPMixImpVelCol, // TSCollisionAvoidanceMixedImpedanceVelocityMP,
        // TSMPImpObjCol, // TSObjectCollisionAvoidanceImpedanceMP,
 
        // ----------- NJointMPControllers for specific use-cases ------------------
        TSMPVelWiping, // adapted TSMPVel for wiping task
        TSMPImpWiping, // adapted TSMPVel for wiping task
        TSMPMixImpVelColWiping, // adapted TSMPMixImpVelCol for wiping task
 
        QPWholeBodyImpedance,
        QPWholeBodyVelocity,
        WholeBodyTrajectoryController,
 
        // ZeroMQ
        ZMQTSVel,
        ZMQTSImp,
        ZMQTSImpCol,
        ZMQTSMixImpVel,
        ZMQTSMixImpVelCol,
 
 
        // Zenoh
        ZenohTSVel,
        ZenohTSImp,
        ZenohTSImpCol,
        ZenohTSMixImpVel,
        ZenohTSMixImpVelCol,
 
 
        // Shared Memory
        SharedMemoryTSVel,
        SharedMemoryTSVelCol,
        SharedMemoryTSVeloCol,
        SharedMemoryTSImp,
        SharedMemoryTSImpCol,
        SharedMemoryTSMixImpVel,
        SharedMemoryTSMixImpVelCol
    };
 
    enum class MPType
    {
        taskspace,
        nullsapce,
        hand,
        // The following will probably be supported in the future
        //        hand_ts,
        //        head,
        //        platform
    };
 
 
    enum class MPStatus
    {
        reset,
        trained,
        running,
        paused,
        finished
    };
 
    inline const simox::meta::EnumNames<MPType> mpTypeToString = {{MPType::taskspace, "taskspace"},
                                                                  {MPType::nullsapce, "nullspace"},
                                                                  {MPType::hand, "hand"}};
 
    inline const simox::meta::EnumNames<ControllerType> ControllerTypeShort{
        {ControllerType::TSAdm, "TSAdm"},
        {ControllerType::TSImp, "TSImp"},
        {ControllerType::TSVel, "TSVel"},
        {ControllerType::TSMixImpVel, "TSMixImpVel"},
 
        {ControllerType::TSImpCol, "TSImpCol"},
        {ControllerType::TSVelCol, "TSVelCol"},
        {ControllerType::TSVeloCol, "TSVeloCol"},
        // {ControllerType::TSImpObjCol, "TSImpObjCol"},
        {ControllerType::TSMixImpVelCol, "TSMixImpVelCol"},
 
        {ControllerType::TSMPAdm, "TSMPAdm"},
        {ControllerType::TSMPImp, "TSMPImp"},
        {ControllerType::TSMPVel, "TSMPVel"},
        {ControllerType::TSMPMixImpVel, "TSMPMixImpVel"},
 
        {ControllerType::TSMPImpCol, "TSMPImpCol"},
        {ControllerType::TSMPVelCol, "TSMPVelCol"},
        {ControllerType::TSMPVeloCol, "TSMPVeloCol"},
        // {ControllerType::TSMPImpObjCol, "TSMPImpObjCol"},
        {ControllerType::TSMPMixImpVelCol, "TSMPMixImpVelCol"},
 
        {ControllerType::TSMPVelWiping, "TSMPVelWiping"},
        {ControllerType::TSMPImpWiping, "TSMPImpWiping"},
        {ControllerType::TSMPMixImpVelColWiping, "TSMPMixImpVelColWiping"},
 
        {ControllerType::QPWholeBodyImpedance, "QPWholeBodyImpedance"},
        {ControllerType::QPWholeBodyVelocity, "QPWholeBodyVelocity"},
        {ControllerType::WholeBodyTrajectoryController, "WholeBodyTrajectoryController"},
 
        // ZeroMQ
        {ControllerType::ZMQTSVel, "ZMQTSVel"},
        {ControllerType::ZMQTSImp, "ZMQTSImp"},
        {ControllerType::ZMQTSMixImpVel, "ZMQTSMixImpVel"},
        {ControllerType::ZMQTSImpCol, "ZMQTSImpCol"},
        {ControllerType::ZMQTSMixImpVelCol, "ZMQTSMixImpVelCol"},
 
        // Zenoh
        {ControllerType::ZenohTSVel, "ZenohTSVel"},
        {ControllerType::ZenohTSImp, "ZenohTSImp"},
        {ControllerType::ZenohTSMixImpVel, "ZenohTSMixImpVel"},
        {ControllerType::ZenohTSImpCol, "ZenohTSImpCol"},
        {ControllerType::ZenohTSMixImpVelCol, "ZenohTSMixImpVelCol"},
 
        // SharedMemory
        {ControllerType::SharedMemoryTSVel, "SharedMemoryTSVel"},
        {ControllerType::SharedMemoryTSVelCol, "SharedMemoryTSVelCol"},
        {ControllerType::SharedMemoryTSVeloCol, "SharedMemoryTSVeloCol"},
        {ControllerType::SharedMemoryTSImp, "SharedMemoryTSImp"},
        {ControllerType::SharedMemoryTSMixImpVel, "SharedMemoryTSMixImpVel"},
        {ControllerType::SharedMemoryTSImpCol, "SharedMemoryTSImpCol"},
        {ControllerType::SharedMemoryTSMixImpVelCol, "SharedMemoryTSMixImpVelCol"}};
 
    inline const simox::meta::EnumNames<ControllerType> ControllerTypeNames{
        {ControllerType::TSAdm, "TSAdm"},
        {ControllerType::TSImp, "TSImp"},
        {ControllerType::TSVel, "TSVel"},
        {ControllerType::TSMixImpVel, "TSMixImpVel"},
 
        {ControllerType::TSImpCol, "TSImpCol"},
        {ControllerType::TSVelCol, "TSVelCol"},
        {ControllerType::TSVeloCol, "TSVeloCol"},
        {ControllerType::TSMixImpVelCol, "TSMixImpVelCol"},
        // {ControllerType::TSImpObjCol, "NJointTaskspaceObjectCollisionAvoidanceImpedanceController"},
 
        {ControllerType::TSMPAdm, "TSMPAdm"},
        {ControllerType::TSMPImp, "TSMPImp"},
        {ControllerType::TSMPVel, "TSMPVel"},
        {ControllerType::TSMPMixImpVel, "TSMPMixImpVel"},
 
        {ControllerType::TSMPImpCol, "NJointTSCollisionAvoidanceImpedanceMPController"},
        {ControllerType::TSMPVelCol, "TSMPVelCol"},
        {ControllerType::TSMPVeloCol, "TSMPVeloCol"},
        {ControllerType::TSMPMixImpVelCol, "NJointTSCollisionAvoidanceMixedImpedanceVelocityMP"},
        // {ControllerType::TSMPImpObjCol, "NJointTSObjectCollisionAvoidanceImpedanceMPController"},
 
        {ControllerType::TSMPVelWiping, "NJointWipingVelMPController"},
        {ControllerType::TSMPImpWiping, "NJointWipingImpedanceMPController"},
        {ControllerType::TSMPMixImpVelColWiping, "NJointWipingMixImpVelColMPController"},
 
        {ControllerType::WholeBodyTrajectoryController, "NJointWholeBodyTrajectoryController"},
 
        {ControllerType::ZMQTSVel, "NJointZeroMQTaskspaceVelocityController"},
        {ControllerType::ZMQTSImp, "NJointZeroMQTaskspaceImpedanceController"},
        {ControllerType::ZMQTSMixImpVel, "NJointZeroMQTaskspaceMixedImpedanceVelocityController"},
        {ControllerType::ZMQTSImpCol, "NJointZeroMQTaskspaceCollisionAvoidanceImpedanceController"},
        {ControllerType::ZMQTSMixImpVelCol,
         "NJointZeroMQTaskspaceCollisionAvoidanceMixedImpedanceVelocityController"},
 
        // Zenoh
        {ControllerType::ZenohTSVel, "NJointZenohTaskspaceVelocityController"},
        {ControllerType::ZenohTSImp, "NJointZenohTaskspaceImpedanceController"},
        {ControllerType::ZenohTSMixImpVel, "NJointZenohTaskspaceMixedImpedanceVelocityController"},
        {ControllerType::ZenohTSImpCol,
         "NJointZenohTaskspaceCollisionAvoidanceImpedanceController"},
        {ControllerType::ZenohTSMixImpVelCol,
         "NJointZenohTaskspaceCollisionAvoidanceMixedImpedanceVelocityController"},
 
        // Shared Memory
        {ControllerType::SharedMemoryTSVel, "NJointSharedMemoryTaskspaceVelocityController"},
        {ControllerType::SharedMemoryTSVelCol, "NJointSharedMemoryTaskspaceVelColController"},
        {ControllerType::SharedMemoryTSVeloCol, "NJointSharedMemoryTaskspaceVeloColController"},
        {ControllerType::SharedMemoryTSImp, "NJointSharedMemoryTaskspaceImpedanceController"},
        {ControllerType::SharedMemoryTSMixImpVel,
         "NJointSharedMemoryTaskspaceMixedImpedanceVelocityController"},
        {ControllerType::SharedMemoryTSImpCol,
         "NJointSharedMemoryTaskspaceCollisionAvoidanceImpedanceController"},
        {ControllerType::SharedMemoryTSMixImpVelCol,
         "NJointSharedMemoryTaskspaceCollisionAvoidanceMixedImpedanceVelocityController"}};
 
} // namespace armarx::control::common