limiter.h

Go to the documentation of this file.

/*
 * Copyright 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef COB_TWIST_CONTROLLER_LIMITERS_LIMITER_H
#define COB_TWIST_CONTROLLER_LIMITERS_LIMITER_H
 
#include <vector>
 
#include "cob_twist_controller/limiters/limiter_base.h"
 
#define LIMIT_SAFETY_THRESHOLD 0.1/180.0*M_PI
 
/* BEGIN LimiterJointContainer *******************************************************************************/
class LimiterContainer
{
    public:
        virtual KDL::Twist enforceLimits(const KDL::Twist& v_in) const;
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        void init();
 
        virtual ~LimiterContainer();
 
        explicit LimiterContainer(const LimiterParams& limiter_params) :
            limiter_params_(limiter_params)
        {}
 
    protected:
        const LimiterParams& limiter_params_;
 
        std::vector<const LimiterCartesianBase*> input_limiters_;
        std::vector<const LimiterJointBase*> output_limiters_;
        typedef std::vector<const LimiterCartesianBase*>::const_iterator input_LimIter_t;
        typedef std::vector<const LimiterJointBase*>::const_iterator output_LimIter_t;
 
        void add(const LimiterCartesianBase* lb);
        void add(const LimiterJointBase* lb);
 
        void eraseAll();
};
/* END LimiterJointContainer *****************************************************************************************/
 
/* BEGIN LimiterAllJointPositions *******************************************************************************/
class LimiterAllJointPositions : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterAllJointPositions(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterAllJointPositions **********************************************************************************/
 
/* BEGIN LimiterAllJointVelocities *******************************************************************************/
class LimiterAllJointVelocities : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterAllJointVelocities(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterAllJointVelocities *********************************************************************************/
 
/* BEGIN LimiterAllJointAccelerations ****************************************************************************/
class LimiterAllJointAccelerations : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterAllJointAccelerations(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterAllJointAccelerations ******************************************************************************/
 
/* BEGIN LimiterAllCartesianVelocities ***********************************************************************/
class LimiterAllCartesianVelocities : public LimiterCartesianBase
{
    public:
        virtual KDL::Twist enforceLimits(const KDL::Twist& v_in) const;
 
        explicit LimiterAllCartesianVelocities(const LimiterParams& limiter_params) :
            LimiterCartesianBase(limiter_params)
        {}
};
/* END LimiterAllCartesianVelocities *************************************************************************/
 
/* BEGIN LimiterIndividualJointPositions *************************************************************************/
class LimiterIndividualJointPositions : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterIndividualJointPositions(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterIndividualJointPositions **************************************************************************/
 
/* BEGIN LimiterIndividualJointVelocities ***********************************************************************/
class LimiterIndividualJointVelocities : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterIndividualJointVelocities(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterIndividualJointVelocities *************************************************************************/
 
/* BEGIN LimiterIndividualJointAccelerations ***********************************************************************/
class LimiterIndividualJointAccelerations : public LimiterJointBase
{
    public:
        virtual KDL::JntArray enforceLimits(const KDL::JntArray& q_dot_ik, const KDL::JntArray& q) const;
 
        explicit LimiterIndividualJointAccelerations(const LimiterParams& limiter_params) :
            LimiterJointBase(limiter_params)
        {}
};
/* END LimiterIndividualJointAccelerations *************************************************************************/
 
/* BEGIN LimiterIndividualCartesianVelocities ***********************************************************************/
class LimiterIndividualCartesianVelocities : public LimiterCartesianBase
{
    public:
        virtual KDL::Twist enforceLimits(const KDL::Twist& v_in) const;
 
        explicit LimiterIndividualCartesianVelocities(const LimiterParams& limiter_params) :
            LimiterCartesianBase(limiter_params)
        {}
};
/* END LimiterIndividualCartesianVelocities *************************************************************************/
 
#endif  // COB_TWIST_CONTROLLER_LIMITERS_LIMITER_H