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/msg/robot_trajectory.hpp>
#include <sensor_msgs/msg/joint_state.hpp>
#include <std_msgs/msg/string.hpp>
#include <rclcpp/rclcpp.hpp>
#include <moveit/controller_manager/controller_manager.h>
#include <pluginlib/class_loader.hpp>
 
#include <memory>
#include <deque>
#include <thread>
 
#include <moveit_trajectory_execution_manager_export.h>
 
namespace trajectory_execution_manager
{
MOVEIT_CLASS_FORWARD(TrajectoryExecutionManager);  // Defines TrajectoryExecutionManagerPtr, ConstPtr, WeakPtr... etc
 
// Two modes:
// Managed controllers
// Unmanaged controllers: given the trajectory,
class MOVEIT_TRAJECTORY_EXECUTION_MANAGER_EXPORT TrajectoryExecutionManager
{
public:
  static const std::string EXECUTION_EVENT_TOPIC;
 
  typedef std::function<void(const moveit_controller_manager::ExecutionStatus&)> ExecutionCompleteCallback;
 
  using PathSegmentCompleteCallback = std::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::msg::RobotTrajectory> trajectory_parts_;
  };
 
  TrajectoryExecutionManager(const rclcpp::Node::SharedPtr& node, const moveit::core::RobotModelConstPtr& robot_model,
                             const planning_scene_monitor::CurrentStateMonitorPtr& csm);
 
  TrajectoryExecutionManager(const rclcpp::Node::SharedPtr& node, 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::msg::RobotTrajectory& trajectory, const std::string& controller = "");
 
  bool push(const trajectory_msgs::msg::JointTrajectory& trajectory, const std::string& controller = "");
 
  bool push(const trajectory_msgs::msg::JointTrajectory& trajectory, const std::vector<std::string>& controllers);
 
  bool push(const moveit_msgs::msg::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);
 
  bool executionDurationMonitoring() const;
 
  void setAllowedExecutionDurationScaling(double scaling);
 
  double allowedExecutionDurationScaling() const;
 
  void setAllowedGoalDurationMargin(double margin);
 
  double allowedGoalDurationMargin() const;
 
  void setExecutionVelocityScaling(double scaling);
 
  double executionVelocityScaling() const;
 
  void setAllowedStartTolerance(double tolerance);
 
  double allowedStartTolerance() const;
 
  void setWaitForTrajectoryCompletion(bool flag);
 
  bool waitForTrajectoryCompletion() const;
 
  rclcpp::Node::SharedPtr getControllerManagerNode()
  {
    return controller_mgr_node_;
  }
 
private:
  struct ControllerInformation
  {
    std::string name_;
    std::set<std::string> joints_;
    std::set<std::string> overlapping_controllers_;
    moveit_controller_manager::MoveItControllerManager::ControllerState state_;
    rclcpp::Time last_update_{ 0, 0, RCL_ROS_TIME };
 
    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::msg::RobotTrajectory& trajectory,
                 const std::vector<std::string>& controllers);
 
  void updateControllersState(const rclcpp::Duration& age);
  void updateControllerState(const std::string& controller, const rclcpp::Duration& age);
  void updateControllerState(ControllerInformation& ci, const rclcpp::Duration& age);
 
  bool distributeTrajectory(const moveit_msgs::msg::RobotTrajectory& trajectory,
                            const std::vector<std::string>& controllers,
                            std::vector<moveit_msgs::msg::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::msg::String::ConstSharedPtr& event);
 
  void loadControllerParams();
 
  // Name of this class for logging
  const std::string name_ = "trajectory_execution_manager";
 
  rclcpp::Node::SharedPtr node_;
  rclcpp::Logger logger_;
  rclcpp::Node::SharedPtr controller_mgr_node_;
  std::shared_ptr<rclcpp::executors::SingleThreadedExecutor> private_executor_;
  std::thread private_executor_thread_;
  moveit::core::RobotModelConstPtr robot_model_;
  planning_scene_monitor::CurrentStateMonitorPtr csm_;
  rclcpp::Subscription<std_msgs::msg::String>::SharedPtr 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<std::thread> execution_thread_;
 
  std::mutex execution_state_mutex_;
  std::mutex execution_thread_mutex_;
 
  // this condition is used to notify the completion of execution for given trajectories
  std::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<rclcpp::Time> time_index_;  // used to find current expected trajectory location
  mutable std::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_;
 
  bool execution_duration_monitoring_;
  // 'global' values
  double allowed_execution_duration_scaling_;
  double allowed_goal_duration_margin_;
  bool control_multi_dof_joint_variables_;
  // 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
  double execution_velocity_scaling_;
  bool wait_for_trajectory_completion_;
 
  rclcpp::node_interfaces::OnSetParametersCallbackHandle::SharedPtr callback_handler_;
};
}  // namespace trajectory_execution_manager