Joint.hh

Go to the documentation of this file.

/*
 * Copyright 2012 Open Source Robotics Foundation
 *
 * 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.
 *
*/
/* Desc: The base joint class
 * Author: Nate Koenig, Andrew Howard
 * Date: 21 May 2003
 */

#ifndef _JOINT_HH_
#define _JOINT_HH_

#include <string>
#include <vector>

#include <boost/any.hpp>

#include "gazebo/common/Event.hh"
#include "gazebo/common/Events.hh"
#include "gazebo/math/Angle.hh"
#include "gazebo/math/Vector3.hh"
#include "gazebo/msgs/MessageTypes.hh"

#include "gazebo/physics/JointState.hh"
#include "gazebo/physics/Base.hh"
#include "gazebo/physics/JointWrench.hh"

#define MAX_JOINT_AXIS 2

namespace gazebo
{
  namespace physics
  {

    class Joint : public Base
    {
      public: enum Attribute
              {
                FUDGE_FACTOR,

                SUSPENSION_ERP,

                SUSPENSION_CFM,

                STOP_ERP,

                STOP_CFM,

                ERP,

                CFM,

                FMAX,

                VEL,

                HI_STOP,

                LO_STOP
              };

      public: explicit Joint(BasePtr _parent);

      public: virtual ~Joint();

      public: void Load(LinkPtr _parent, LinkPtr _child,
                        const math::Pose &_pose);

      public: virtual void Load(sdf::ElementPtr _sdf);

      public: virtual void Init();

      public: void Update();

      public: virtual void UpdateParameters(sdf::ElementPtr _sdf);

      public: virtual void Reset();

      public: void SetState(const JointState &_state);

      public: void SetModel(ModelPtr _model);

      public: virtual LinkPtr GetJointLink(int _index) const = 0;

      public: virtual bool AreConnected(LinkPtr _one, LinkPtr _two) const = 0;

      public: virtual void Attach(LinkPtr _parent, LinkPtr _child);

      public: virtual void Detach();

      public: virtual void SetAxis(int _index, const math::Vector3 &_axis) = 0;

      public: virtual void SetDamping(int _index, double _damping) = 0;

      public: double GetDamping(int _index);

      public: virtual void ApplyDamping();

      public: template<typename T>
              event::ConnectionPtr ConnectJointUpdate(T _subscriber)
              {return jointUpdate.Connect(_subscriber);}

      public: void DisconnectJointUpdate(event::ConnectionPtr &_conn)
              {jointUpdate.Disconnect(_conn);}

      public: math::Vector3 GetLocalAxis(int _index) const;

      public: virtual math::Vector3 GetGlobalAxis(int _index) const = 0;

      public: virtual void SetAnchor(int _index,
                                     const math::Vector3 &_anchor) = 0;

      public: virtual math::Vector3 GetAnchor(int _index) const = 0;

      public: virtual void SetHighStop(int _index,
                                       const math::Angle &_angle);

      public: virtual void SetLowStop(int _index,
                                      const math::Angle &_angle);

      public: virtual math::Angle GetHighStop(int _index) = 0;

      public: virtual math::Angle GetLowStop(int _index) = 0;

      public: virtual double GetEffortLimit(int _index);

      public: virtual double GetVelocityLimit(int _index);

      public: virtual void SetVelocity(int _index, double _vel) = 0;

      public: virtual double GetVelocity(int _index) const = 0;

      public: virtual void SetForce(int _index, double _effort) = 0;

      public: double CheckAndTruncateForce(int _index, double _effort);

      public: virtual double GetForce(unsigned int _index);

      public: virtual JointWrench GetForceTorque(unsigned int _index) = 0;

      public: virtual void SetMaxForce(int _index, double _force) = 0;

      public: virtual double GetMaxForce(int _index) = 0;

      public: math::Angle GetAngle(int _index) const;

      public: virtual unsigned int GetAngleCount() const = 0;

      public: void SetAngle(int _index, math::Angle _angle);

      public: virtual math::Vector3 GetLinkForce(unsigned int _index) const = 0;

      public: virtual math::Vector3 GetLinkTorque(
                  unsigned int _index) const = 0;

      public: virtual void SetAttribute(const std::string &_key, int _index,
                                        const boost::any &_value) = 0;

      public: virtual double GetAttribute(const std::string &_key,
                                                unsigned int _index) = 0;

      public: LinkPtr GetChild() const;

      public: LinkPtr GetParent() const;

      public: void FillMsg(msgs::Joint &_msg);

      public: double GetInertiaRatio(unsigned int _index) const;

      public: math::Angle GetLowerLimit(unsigned int _index) const;

      public: math::Angle GetUpperLimit(unsigned int _index) const;

      public: virtual void SetProvideFeedback(bool _enable);

      public: virtual void CacheForceTorque() { }

      public: double GetDampingCoefficient() const;

      protected: virtual math::Angle GetAngleImpl(int _index) const = 0;

      private: void LoadImpl(const math::Pose &_pose);

      private: void ComputeInertiaRatio();

      protected: LinkPtr childLink;

      protected: LinkPtr parentLink;

      protected: ModelPtr model;

      protected: math::Vector3 anchorPos;

      protected: math::Pose anchorPose;

      protected: LinkPtr anchorLink;

      protected: double dampingCoefficient;

      protected: gazebo::event::ConnectionPtr applyDamping;

      protected: double effortLimit[MAX_JOINT_AXIS];

      protected: double velocityLimit[MAX_JOINT_AXIS];

      protected: double inertiaRatio[MAX_JOINT_AXIS];

      protected: math::Angle lowerLimit[MAX_JOINT_AXIS];

      protected: math::Angle upperLimit[MAX_JOINT_AXIS];

      protected: JointWrench wrench;

      protected: bool useCFMDamping;

      private: static sdf::ElementPtr sdfJoint;

      protected: bool provideFeedback;

      private: std::vector<std::string> sensors;

      private: event::EventT<void ()> jointUpdate;

      private: math::Angle staticAngle;
    };
  }
}
#endif