---

robot/SerialManipulator

Go to the documentation of this file.

/****************************************************************************
  Copyright (C)2002 David Jung <opensim@pobox.com>

  This program/file is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
        
  This program 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. (http://www.gnu.org)
        
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  $Id: SerialManipulator,v 1.14 2002/09/18 17:08:44 jungd Exp $
  $Revision: 1.14 $
  $Date: 2002/09/18 17:08:44 $
  $Author: jungd $
 
****************************************************************************/

#ifndef _ROBOT_SERIALMANIPULATOR_
#define _ROBOT_SERIALMANIPULATOR_

#include <robot/robot>

#include <base/array>
#include <base/Serializer>
#include <robot/Manipulator>


namespace robot {


/// Abstract interface for serial manipulator description classes.
/**
 *  Describables serial manipulator via Denavit-Hartenberg parameters.
 */
class SerialManipulator : public Manipulator
{
public:

  virtual Type type() const { return Serial; }

  /// Parameters for a single joint
  class JointParameters : public base::Serializable
  {
  public:
    enum JointType { Prismatic, Revolute };

    JointParameters() {}
    JointParameters(JointType type, Real alpha, Real a, Real d, Real theta,
                    Real minLimit, Real MaxLimit, Real minAccel=0, Real maxAccel=0,
                    bool active=true)
      : type(type), alpha(alpha), a(a), d(d), theta(theta),
        minLimit(minLimit), maxLimit(maxLimit), minAccel(minAccel), maxAccel(maxAccel),
        active(active)
      {}
    ~JointParameters() {}

    virtual String className() const { return String("JointParameters"); }


    JointType type;

    // Denavit-Hartenberg 
    Real alpha;  ///< twist angle (const) (radians)
    Real a;      ///< link length (const)
    Real d;      ///< distance between links (home pos)
    Real theta;  ///< angle between links (home pos) (radians)

    Real minLimit, maxLimit; ///< joint limits
    Real minAccel, maxAccel; ///< joint acceleration limits
    
    bool active; 
    
    bool operator==(const JointParameters& p)
    { return (type==p.type)
        && Math::equals(alpha,p.alpha) && Math::equals(theta,p.theta)
        && Math::equals(d,p.d) && Math::equals(a,p.a)
        && (active==p.active); 
    }

    bool operator!=(const JointParameters& p) { return !(*this == p); }

    virtual void serialize(base::Serializer& s)
    {
      s(type,"type");
      s(alpha,"alpha")(a,"a")(d,"d")(theta,"theta");
      s(minLimit,"minLimit")(maxLimit,"maxLimit"); 
      s(minAccel,"minAccel")(maxAccel,"maxAccel");
      s(active,"active");
    }
  };

  /// Parameters describing complete manipulator
  typedef base::array<JointParameters> Parameters;

  virtual const Parameters& getParameters() const = 0; ///< returns all of manipulator's joint parameters
  virtual Parameters& getParameters() = 0; ///< returns all of manipulator's joint parameters

  virtual void serialize(base::Serializer& s)
  {
    s(getName(),"name");
    s(getParameters(),"serialManipulatorParameters");
  }

protected:
  SerialManipulator() {}
  SerialManipulator(const SerialManipulator& sm) : Manipulator(sm) {}
  SerialManipulator(String name) : Manipulator(name) {}

};


/// \todo consolidate the output operators
inline std::ostream& operator<<(std::ostream& out, const robot::SerialManipulator& m) // Output
{
  out << "D-H parameters for each joint: (* marks variable)\n";
  const robot::SerialManipulator::Parameters& p = m.getParameters();

  for(Int i=0; i<p.size(); i++) {
    const robot::SerialManipulator::JointParameters& j(p[i]);
    out << i << " - ";

    switch(j.type){
    case SerialManipulator::JointParameters::Revolute:  
      out << "Revolute :" << " alpha:" << Math::radToDeg(j.alpha) << ",  a:" << j.a << ",  d:" << j.d << ",  theta:"  << Math::radToDeg(j.theta) << "*\n"; 
      break;
    case SerialManipulator::JointParameters::Prismatic:  
      out << "Prismatic:" << " alpha:" << Math::radToDeg(j.alpha) << ",  a:" << j.a << ",  d:" << j.d << "*,  theta:"  << Math::radToDeg(j.theta) << "\n";
      break;
    }
  }
  return out;
}


inline std::ostream& operator<<(std::ostream& out, const robot::SerialManipulator::Parameters& p) // Output
{
  out << "D-H parameters for each joint: (* marks variable)\n";

  for(Int i=0; i<p.size(); i++) {
    out << i << " - ";

    switch(p[i].type){
    case SerialManipulator::JointParameters::Revolute:  
      out << "Revolute :" << " alpha:" << Math::radToDeg(p[i].alpha) << ",  a:" << p[i].a << ",  d:" << p[i].d << ",  theta:"  << " * " << "\n"; 
      break;
    case SerialManipulator::JointParameters::Prismatic:  
      out << "Prismatic:" << " alpha:" << Math::radToDeg(p[i].alpha) << ",  a:" << p[i].a << ",  d:" << " * " << ",  theta:"  << Math::radToDeg(p[i].theta) << "\n";
      break;
    }
  }
  return out;
}



inline std::ostream& operator<<(std::ostream& out, const robot::SerialManipulator::JointParameters& j) // Output
{

  out << "D-H parameters for joint: (* marks variable)\n";

  switch(j.type){
    case SerialManipulator::JointParameters::Revolute:  
      out << "Revolute :" << " alpha:" << Math::radToDeg(j.alpha) << ",  a:" << j.a << ",  d:" << j.d << ",  theta:"  << " * " << "\n"; 
      break;
    case SerialManipulator::JointParameters::Prismatic:  
      out << "Prismatic:" << " alpha:" << Math::radToDeg(j.alpha) << ",  a:" << j.a << ",  d:" << " * " << ",  theta:"  << Math::radToDeg(j.theta) << "\n";
      break;
  }
  return out;
}

} // robot

#endif

---