tree.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011, PAL Robotics S.L.
 * All rights reserved.
 *
 * Copyright (c) 2008, Willow Garage, Inc.
 * All rights reserved.
 *
 * Author: Marcus Liebhardt
 *
 * This class has been derived from the chain class in the
 * pr2_mechanism_model package in the pr2_mechanism stack for ROS
 * written by Stuart Glaser and Wim Meeussen.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef PR2_MECHANISM_MODEL_TREE_H
#define PR2_MECHANISM_MODEL_TREE_H
 
#include <ros/ros.h>
#include <kdl/chain.hpp>
#include <kdl/tree.hpp>
#include <kdl/jntarray.hpp>
#include <kdl/jntarrayvel.hpp>
#include "pr2_mechanism_model/robot.h"
 
namespace pr2_mechanism_model
{
 
class Tree
{
public:
  Tree() : kdl_tree_() {};
  ~Tree() {};
 
  bool init(RobotState *robot_state);
 
  void getPositions(KDL::JntArray&) const;
 
  template <class Vec>
  void getPositions(Vec&) const;
 
  void getVelocities(KDL::JntArrayVel&) const;
 
  template <class Vec>
  void getVelocities(Vec&) const;
 
  void getEfforts(KDL::JntArray&) const;
 
  template <class Vec>
  void getEfforts(Vec&) const;
 
  void setEfforts(const KDL::JntArray&);
 
  template <class Vec>
  void setEfforts(const Vec&);
 
  void addEfforts(const KDL::JntArray&);
 
  template <class Vec>
  void addEfforts(const Vec&);
 
  bool allCalibrated() const;
 
  void toKdl(KDL::Tree&) const;
 
  JointState* getJoint(unsigned int) const;
 
  int size() const;
 
private:
  KDL::Tree kdl_tree_;
  std::vector<JointState*> joints_;
};
 
inline void Tree::getPositions(KDL::JntArray& positions) const
{
  assert(positions.rows() == joints_.size());
  for (unsigned int i = 0; i < joints_.size(); ++i)
    positions(i) = joints_[i]->position_;
}
 
template <class Vec>
inline void Tree::getPositions(Vec &v) const
{
  assert((int)v.size() == (int)joints_.size());
  for (size_t i = 0; i < joints_.size(); ++i)
    v[i] = joints_[i]->position_;
}
 
inline void Tree::getVelocities(KDL::JntArrayVel& velocities) const
{
  assert(velocities.q.rows() == joints_.size());
  assert(velocities.qdot.rows() == joints_.size());
  for (unsigned int i = 0; i < joints_.size(); ++i)
  {
    velocities.q(i) = joints_[i]->position_;
    velocities.qdot(i) = joints_[i]->velocity_;
  }
}
 
template <class Vec>
inline void Tree::getVelocities(Vec &v) const
{
  assert((int)v.size() == (int)joints_.size());
  for (size_t i = 0; i < joints_.size(); ++i)
    v[i] = joints_[i]->velocity_;
}
 
inline void Tree::getEfforts(KDL::JntArray& efforts) const
{
  assert(efforts.rows() == joints_.size());
  for (unsigned int i = 0; i < joints_.size(); ++i)
    efforts(i) = joints_[i]->measured_effort_;
}
 
template <class Vec>
inline void Tree::getEfforts(Vec &v) const
{
  assert((int)v.size() == (int)joints_.size());
  for (size_t i = 0; i < joints_.size(); ++i)
    v[i] = joints_[i]->measured_effort_;
}
 
inline void Tree::setEfforts(const KDL::JntArray& efforts)
{
  assert(efforts.rows() == joints_.size());
  for (unsigned int i = 0; i < joints_.size(); ++i)
    joints_[i]->commanded_effort_ = efforts(i);
}
 
template <class Vec>
inline void Tree::setEfforts(const Vec& v)
{
  assert((int)v.size() == (int)joints_.size());
  for (size_t i = 0; i < joints_.size(); ++i)
    joints_[i]->commanded_effort_ = v[i];
}
 
inline void Tree::addEfforts(const KDL::JntArray& efforts)
{
  assert(efforts.rows() == joints_.size());
  for (unsigned int i = 0; i < joints_.size(); ++i)
    joints_[i]->commanded_effort_ += efforts(i);
}
 
template <class Vec>
inline void Tree::addEfforts(const Vec& v)
{
  assert((int)v.size() == (int)joints_.size());
  for (size_t i = 0; i < joints_.size(); ++i)
    joints_[i]->commanded_effort_ += v[i];
}
 
inline bool Tree::allCalibrated() const
{
  for (unsigned int i = 0; i < joints_.size(); ++i)
  {
    if (!joints_[i]->calibrated_)
      return false;
  }
  return true;
}
 
inline void Tree::toKdl(KDL::Tree &tree) const
{
  tree = kdl_tree_;
}
 
inline JointState* Tree::getJoint(unsigned int actuated_joint_i) const
{
  if (actuated_joint_i >= joints_.size())
    return NULL;
  else
    return joints_[actuated_joint_i];
}
 
inline int Tree::size() const
{
  return joints_.size();
}
 
} // namespace
 
#endif /* PR2_MECHANISM_MODEL_TREE_H */