+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

me_joint.h

Go to the documentation of this file.

// -*-c++-*-
//---------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file me_joint.h
 *
 * The ME_Joint object corresponds to the joint in a mechanism.
 * ME_Joint attaches a ME_Body to its parent.
 * 
 * <br>@b Designer(s):   Antonio Diaz-Calderon,
 *                       Won S. Kim,
 *                       Hari Das Nayar,
 *                       Issa Nesnas
 * <br>@b Author(s):     Hari Das Nayar
 * <br>@b Date:          March 24, 2004 
 *
 * <b>Software License:</b><br>
 * <code> http://claraty.jpl.nasa.gov/license/open_src/  or 
 *        file: license/open_src.txt </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 *
 * $Revision: 1.7 $
 */
//---------------------------------------------------------------------------

#ifndef ME_JOINT_H
#define ME_JOINT_H

#include "claraty/share.h"
#include "claraty/frame.h"


namespace claraty {

//----------------------------------------------------------------------
//-----------------------<< Joint_Limits class >>-----------------------
//----------------------------------------------------------------------
/**
 * Joint_Limits class
 * This class maintains joint limit attributes.
 *
 * @ingroup mech_model_pkg
 */
class Joint_Limits {
public:
  Joint_Limits()
    : _min (0.0), _max(0.0), _vmax(0.0), _torque_min(0.0), _torque_max(0.0) {}
  Joint_Limits(const Joint_Limits & jm)
  {
    _min = jm._min; _max = jm._max; _vmax = jm._vmax;
    _torque_min = jm._torque_min; _torque_max = jm._torque_max;
  }
  void set_parameters(double joint_min, double joint_max,
                      double joint_vmax,
                      double joint_tmin, double joint_tmax)
  {
    _min = joint_min;
    _max = joint_max;
    _vmax = joint_vmax;
    _torque_min = joint_tmin;
    _torque_max = joint_tmax;
  }
  void get_parameters(double & joint_min, double & joint_max,
                                  double & joint_vmax,
                                  double & joint_tmin, double & joint_tmax)
  {
    joint_min  = _min;
    joint_max  = _max;
    joint_vmax = _vmax;
    joint_tmin = _torque_min;
    joint_tmax = _torque_max;
  }
  
  double _min;
  double _max;
  double _vmax;
  double _torque_min;
  double _torque_max;
};

//-------------------------------------------------------------------------
//---------------------<< Joint_Stiffness Struct >>------------------------
//-------------------------------------------------------------------------
/**
 * Joint_Stiffness class
 * This class maintains joint stiffness attributes.
 *
 * @ingroup mech_model_pkg
 */
class Joint_Stiffness {
public:
  Joint_Stiffness() : _kx(0.0), _ky(0.0), _kz(0.0) {}
  Joint_Stiffness(const Joint_Stiffness & js)
  { _kx = js._kx; _ky = js._ky; _kz = js._kz; }
  void set_parameters(double joint_kx, double joint_ky, double joint_kz)
  {
    _kx = joint_kx;
    _ky = joint_ky;
    _kz = joint_kz;
  }
  void get_parameters(double & joint_kx, double & joint_ky, double & joint_kz)
  {
    joint_kx = _kx;
    joint_ky = _ky;
    joint_kz = _kz;
  }
private:
  double _kx;
  double _ky;
  double _kz;
};

//-------------------------------------------------------------------------
//---------------------<< Joint_Constraint Struct >>-----------------------
//-------------------------------------------------------------------------
/**
 * Joint_Constraint class
 * This class maintains joint constraint attributes.
 *
 * @ingroup mech_model_pkg
 */
class Joint_Constraint {
public:
  Joint_Constraint(): _offset(0), _slope(0), s_expr_attribute("") {}
  Joint_Constraint(const Joint_Constraint & jc)
    : _offset(0), _slope(0), s_expr_attribute(jc.s_expr_attribute){}
  void set_parameters(std::string joint_constr_expr)
  {
    s_expr_attribute = joint_constr_expr;
  }
  std::string get_parameters()
  {
    return s_expr_attribute;
  }
  bool evaluate_constraint_expression();
  double get_slope() { return _slope;};
  double get_offset() { return _offset;};
  int get_dependent_joint_index() { return _dependent_body_joint_value_index;};
  std::string get_dependent_body_name() { return _dependent_body_name;}

private:
  double _offset;
  double _slope;
  std::string s_expr_attribute;
  std::string _dependent_body_name;
  long _dependent_body_joint_value_index;
  
};


//-------------------------------------------------------------------------
//---------------------------<< ME_Joint Class >>--------------------------
//-------------------------------------------------------------------------
/**
 * ME_Joint class
 * The ME_Joint class implements a generic model of joints in a kinematic
 * system.
 *
 * @ingroup mech_model_pkg
 */

class ME_Body;

class ME_Joint {
  friend std::ostream& operator<< (std::ostream& os,
                                   ME_Joint & me_joint);
  
  /** Enumeration to indicate joint type. */
  enum JOINT_TYPE {      // All other types can be modeled using types below 
    UNDEFINED = -1,
    PIN = 1,        // Models a 1-dof revolute joint
    SLIDER = 2,     // Models a 1-dof prismatic joint
    FULL6DOF = 3,       // Models a vehicle body relative to a
    // base reference frame
    STATIC = 10     // Models a rigid joint
  };
  
  /** @{ @name ME_Joint constructor/destructor */
public:
  ME_Joint();
  ME_Joint(ME_Joint & me_joint);
  virtual ~ME_Joint(){}
  /** @} */
  
  /** @{ @name ME_Joint model querying */
private:
  int _resolve_type(std::string joint_type_str);
  std::string _unresolve_type(int joint_type);
  /** @} */
  
  /** @{ @name ME_Joint model setting */
public:
  void set_name(std::string name);
  std::string get_name();
  void set_body(ME_Body * me_body) {_me_body = me_body;};
  ME_Body * get_body() { return _me_body;};
  void set_type(std::string type);
  void set_type(short type);
  std::string get_type();
  void set_actuated(bool actuated);
  bool is_actuated();
  bool has_limits() {return _limited;}
  void set_offset(double offset);
  double & get_offset();
  void set_home(double home);
  double & get_home();
  void set_value(double value, int dof_index=0);
  double get_value(int dof_index=0);
  void set_limits(double joint_min, double joint_max,
                        double joint_vmax,
                        double joint_tmin, double joint_tmax);
  void get_limits(double & joint_min, double & joint_max,
                        double & joint_vmax,
                        double & joint_tmin, double & joint_tmax);
  void set_stiffness(double kx, double ky, double kz);
  void get_stiffness(double & kx, double & ky, double & kz);
  void set_constraint_expression(std::string expr);
  std::vector<double> & get_values_vector();
  std::string get_constraint_expression();
   bool is_constrained() {return _constrained;};
  int get_number_dofs();
  void rotate_joint_axes(const Quaternion<double> & rotation);
  void rotate_joint_axes(const RMatrix<double> & rotation);
  void set_joint_axes(Vector<double> joint_axis);
  void get_joint_axes(Vector<double> & joint_axis);
  Vector<double> & get_joint_axis();

  /** @} */
  
  /** @{ @name ME_Joint joint algorithms */
public:
  Transform get_transform();
  /** @} */
  
 private:
  unsigned int _index;         /**< Index in Mechanism_Model.*/
  bool _limited;               /**< To indicate if joint has limits in
                                          range of motion */
  bool _actuated;              /**< True if actuated, false if
                                          passive */
  short _type;                 /**< Joint type. Only PIN or SLIDER are
                                          allowed for DH and Homogenous
                                          transform input format types */
  double _offset;              /**< Joint offset */
  double _home;                /**< Joint home position */
  unsigned int _number_of_dofs;/**< Number of joint degrees of freedom. */
  Frame * _parent_frame;       /**< Frame on the parent body associated
                                          with this joint. */
  std::vector<double> _values;
  bool _constrained;
  
  std::string        _name;          /**< Joint name */
  Joint_Limits       _limits;        /**< Joint limits parameters */
  Joint_Stiffness  * _stiffness;     /**< Joint stiffness parameters */
  Joint_Constraint * _constraint;    /**< Joint constraint description */
  ME_Body          * _me_body;       /**< Body that this joint is on */ 
  Vector<double>     _joint_axis;    /**< Joint axes components */
};


//-------------------------------------------------------------------------

} // namespace claraty

#endif // ME_JOINT_H

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635