trajectory_execution_manager.h

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2012, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  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 Willow Garage 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.
 *********************************************************************/
 
/* Author: Ioan Sucan */
 
#pragma once
 
#include <moveit/macros/class_forward.h>
#include <moveit/robot_model/robot_model.h>
#include <moveit/planning_scene_monitor/current_state_monitor.h>
#include <moveit_msgs/RobotTrajectory.h>
#include <sensor_msgs/JointState.h>
#include <std_msgs/String.h>
#include <ros/ros.h>
#include <moveit/controller_manager/controller_manager.h>
#include <boost/thread.hpp>
#include <pluginlib/class_loader.hpp>
 
#include <memory>
 
namespace trajectory_execution_manager
{
MOVEIT_CLASS_FORWARD(TrajectoryExecutionManager);  // Defines TrajectoryExecutionManagerPtr, ConstPtr, WeakPtr... etc
 
// Two modes:
// Managed controllers
// Unmanaged controllers: given the trajectory,
class TrajectoryExecutionManager
{
public:
  static const std::string EXECUTION_EVENT_TOPIC;
 
  typedef boost::function<void(const moveit_controller_manager::ExecutionStatus&)> ExecutionCompleteCallback;
 
  using PathSegmentCompleteCallback = boost::function<void(std::size_t)>;
 
  struct TrajectoryExecutionContext
  {
    std::vector<std::string> controllers_;
 
    // The trajectory to execute, split in different parts (by joints), each set of joints corresponding to one
    // controller
    std::vector<moveit_msgs::RobotTrajectory> trajectory_parts_;
  };
 
  TrajectoryExecutionManager(const moveit::core::RobotModelConstPtr& robot_model,
                             const planning_scene_monitor::CurrentStateMonitorPtr& csm);
 
  TrajectoryExecutionManager(const moveit::core::RobotModelConstPtr& robot_model,
                             const planning_scene_monitor::CurrentStateMonitorPtr& csm, bool manage_controllers);
 
  ~TrajectoryExecutionManager();
 
  bool isManagingControllers() const;
 
  const moveit_controller_manager::MoveItControllerManagerPtr& getControllerManager() const;
 
  void processEvent(const std::string& event);
 
  bool ensureActiveControllersForGroup(const std::string& group);
 
  bool ensureActiveControllersForJoints(const std::vector<std::string>& joints);
 
  bool ensureActiveController(const std::string& controller);
 
  bool ensureActiveControllers(const std::vector<std::string>& controllers);
 
  bool isControllerActive(const std::string& controller);
 
  bool areControllersActive(const std::vector<std::string>& controllers);
 
  bool push(const moveit_msgs::RobotTrajectory& trajectory, const std::string& controller = "");
 
  bool push(const trajectory_msgs::JointTrajectory& trajectory, const std::string& controller = "");
 
  bool push(const trajectory_msgs::JointTrajectory& trajectory, const std::vector<std::string>& controllers);
 
  bool push(const moveit_msgs::RobotTrajectory& trajectory, const std::vector<std::string>& controllers);
 
  const std::vector<TrajectoryExecutionContext*>& getTrajectories() const;
 
  void execute(const ExecutionCompleteCallback& callback = ExecutionCompleteCallback(), bool auto_clear = true);
 
  void execute(const ExecutionCompleteCallback& callback, const PathSegmentCompleteCallback& part_callback,
               bool auto_clear = true);
 
  moveit_controller_manager::ExecutionStatus executeAndWait(bool auto_clear = true);
 
  moveit_controller_manager::ExecutionStatus waitForExecution();
 
  std::pair<int, int> getCurrentExpectedTrajectoryIndex() const;
 
  moveit_controller_manager::ExecutionStatus getLastExecutionStatus() const;
 
  void stopExecution(bool auto_clear = true);
 
  void clear();
 
  void enableExecutionDurationMonitoring(bool flag);
 
  void setAllowedExecutionDurationScaling(double scaling);
 
  void setAllowedGoalDurationMargin(double margin);
 
  void setExecutionVelocityScaling(double scaling);
 
  void setAllowedStartTolerance(double tolerance);
 
  void setWaitForTrajectoryCompletion(bool flag);
 
private:
  struct ControllerInformation
  {
    std::string name_;
    std::set<std::string> joints_;
    std::set<std::string> overlapping_controllers_;
    moveit_controller_manager::MoveItControllerManager::ControllerState state_;
    ros::Time last_update_;
 
    bool operator<(ControllerInformation& other) const
    {
      if (joints_.size() != other.joints_.size())
        return joints_.size() < other.joints_.size();
      return name_ < other.name_;
    }
  };
 
  void initialize();
 
  void reloadControllerInformation();
 
  bool validate(const TrajectoryExecutionContext& context) const;
  bool configure(TrajectoryExecutionContext& context, const moveit_msgs::RobotTrajectory& trajectory,
                 const std::vector<std::string>& controllers);
 
  void updateControllersState(const ros::Duration& age);
  void updateControllerState(const std::string& controller, const ros::Duration& age);
  void updateControllerState(ControllerInformation& ci, const ros::Duration& age);
 
  bool distributeTrajectory(const moveit_msgs::RobotTrajectory& trajectory, const std::vector<std::string>& controllers,
                            std::vector<moveit_msgs::RobotTrajectory>& parts);
 
  bool findControllers(const std::set<std::string>& actuated_joints, std::size_t controller_count,
                       const std::vector<std::string>& available_controllers,
                       std::vector<std::string>& selected_controllers);
  bool checkControllerCombination(std::vector<std::string>& controllers, const std::set<std::string>& actuated_joints);
  void generateControllerCombination(std::size_t start_index, std::size_t controller_count,
                                     const std::vector<std::string>& available_controllers,
                                     std::vector<std::string>& selected_controllers,
                                     std::vector<std::vector<std::string> >& selected_options,
                                     const std::set<std::string>& actuated_joints);
  bool selectControllers(const std::set<std::string>& actuated_joints,
                         const std::vector<std::string>& available_controllers,
                         std::vector<std::string>& selected_controllers);
 
  void executeThread(const ExecutionCompleteCallback& callback, const PathSegmentCompleteCallback& part_callback,
                     bool auto_clear);
  bool executePart(std::size_t part_index);
  bool waitForRobotToStop(const TrajectoryExecutionContext& context, double wait_time = 1.0);
 
  void stopExecutionInternal();
 
  void receiveEvent(const std_msgs::StringConstPtr& event);
 
  void loadControllerParams();
 
  double getJointAllowedStartTolerance(std::string const& jointName) const;
  void updateJointsAllowedStartTolerance();
 
  moveit::core::RobotModelConstPtr robot_model_;
  planning_scene_monitor::CurrentStateMonitorPtr csm_;
  ros::NodeHandle node_handle_;
  ros::NodeHandle root_node_handle_;
  ros::Subscriber event_topic_subscriber_;
 
  std::map<std::string, ControllerInformation> known_controllers_;
  bool manage_controllers_;
 
  // thread used to execute trajectories using the execute() command
  std::unique_ptr<boost::thread> execution_thread_;
 
  boost::mutex execution_state_mutex_;
  boost::mutex execution_thread_mutex_;
 
  // this condition is used to notify the completion of execution for given trajectories
  boost::condition_variable execution_complete_condition_;
 
  moveit_controller_manager::ExecutionStatus last_execution_status_;
  std::vector<moveit_controller_manager::MoveItControllerHandlePtr> active_handles_;
  int current_context_;
  std::vector<ros::Time> time_index_;  // used to find current expected trajectory location
  mutable boost::mutex time_index_mutex_;
  bool execution_complete_;
 
  std::vector<TrajectoryExecutionContext*> trajectories_;
 
  std::unique_ptr<pluginlib::ClassLoader<moveit_controller_manager::MoveItControllerManager> > controller_manager_loader_;
  moveit_controller_manager::MoveItControllerManagerPtr controller_manager_;
 
  bool verbose_;
 
  class DynamicReconfigureImpl;
  DynamicReconfigureImpl* reconfigure_impl_;
 
  bool execution_duration_monitoring_;
  // 'global' values
  double allowed_execution_duration_scaling_;
  double allowed_goal_duration_margin_;
  // controller-specific values
  // override the 'global' values
  std::map<std::string, double> controller_allowed_execution_duration_scaling_;
  std::map<std::string, double> controller_allowed_goal_duration_margin_;
 
  double allowed_start_tolerance_;  // joint tolerance for validate(): radians for revolute joints
  // tolerance per joint, overrides global allowed_start_tolerance_.
  std::map<std::string, double> joints_allowed_start_tolerance_;
  double execution_velocity_scaling_;
  bool wait_for_trajectory_completion_;
};
}  // namespace trajectory_execution_manager