ros_client.cpp

Go to the documentation of this file.

#ifndef ROS_CLIENT_HPP
#define ROS_CLIENT_HPP

#include <ros/ros.h>
#include <pr2_controllers_msgs/JointTrajectoryAction.h>
#include <pr2_controllers_msgs/JointTrajectoryActionGoal.h>
#include <pr2_controllers_msgs/JointTrajectoryGoal.h>
#include <trajectory_msgs/JointTrajectoryPoint.h>
#include <actionlib/client/simple_action_client.h>
#include <string>
#include <vector>
#include <cmath>

class ROS_Client {
  /*
    This class:

    - holds methods that are specific to Kawada Industries' dual-arm
    robot called Hiro, via ROS.
    - As of July 2014, this class is only intended to be used through HIRONX
    class.
  */

  //TODO: Address the following concern.
  // This duplicates "Group" definition in HIRONX, which is bad.
  // Need to consider consolidating the definition either in hironx_ros_bridge
  // or somewhere in the upstream, e.g.:
  // https://github.com/fkanehiro/hrpsys-base/pull/253
public:
  typedef actionlib::SimpleActionClient< pr2_controllers_msgs::JointTrajectoryAction > TrajClient;

  pr2_controllers_msgs::JointTrajectoryGoal goal;

  ROS_Client():
    GR_TORSO("torso"),GR_HEAD("head"),
    GR_LARM("larm"),GR_RARM("rarm"),
    MSG_ASK_ISSUEREPORT("Your report to https://github.com/start-jsk/rtmros_hironx/issues about the issue you are seeing is appreciated.")
  {};

  explicit ROS_Client(std::vector<std::string> joingroups):
    MSG_ASK_ISSUEREPORT("Your report to https://github.com/start-jsk/rtmros_hironx/issues about the issue you are seeing is appreciated.")
  {
    set_groupnames(joingroups);
  };

  ROS_Client(const ROS_Client& obj)
  {
    GR_TORSO = obj.GR_TORSO;
    GR_HEAD = obj.GR_HEAD;
    GR_LARM = obj.GR_LARM;
    GR_RARM = obj.GR_RARM;
  };

  ROS_Client& operator=(const ROS_Client& obj)
  {
    GR_TORSO= obj.GR_TORSO;
    GR_HEAD = obj.GR_HEAD;
    GR_LARM = obj.GR_LARM;
    GR_RARM = obj.GR_RARM;
    return *this;
  };

  ~ROS_Client(){};

  void init_action_clients()
  {
    static TrajClient aclient_larm("/larm_controller/joint_trajectory_action", true);
    static TrajClient aclient_rarm("/rarm_controller/joint_trajectory_action", true);
    static TrajClient aclient_head("/head_controller/joint_trajectory_action", true);
    static TrajClient aclient_torso("/torso_controller/joint_trajectory_action",true);

    aclient_larm.waitForServer();
    ROS_INFO("ros_client; 1");
    goal_larm = pr2_controllers_msgs::JointTrajectoryGoal();
    ROS_INFO("ros_client; 2");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT0");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT1");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT2");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT3");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT4");
    goal_larm.trajectory.joint_names.push_back("LARM_JOINT5");
    ROS_INFO("ros_client; 3");

    aclient_rarm.waitForServer();
    goal_rarm = pr2_controllers_msgs::JointTrajectoryGoal();
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT0");
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT1");
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT2");
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT3");
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT4");
    goal_rarm.trajectory.joint_names.push_back("RARM_JOINT5");

    aclient_head.waitForServer();
    goal_head = pr2_controllers_msgs::JointTrajectoryGoal();
    goal_head.trajectory.joint_names.push_back("HEAD_JOINT0");
    goal_head.trajectory.joint_names.push_back("HEAD_JOINT1");

    aclient_torso.waitForServer();
    goal_torso = pr2_controllers_msgs::JointTrajectoryGoal();
    goal_torso.trajectory.joint_names.push_back("CHEST_JOINT0");

    // Display Joint names
    ROS_INFO("\nJoint names;");
    std::cout << "Torso: [";
    for(std::vector<std::string>::iterator name = goal_torso.trajectory.joint_names.begin();
        name != goal_torso.trajectory.joint_names.end(); ++name)
      std::cout << *name << " ";
    std::cout << "]\nHead: [";
    for(std::vector<std::string>::iterator name = goal_head.trajectory.joint_names.begin();
        name != goal_head.trajectory.joint_names.end(); ++name)
      std::cout << *name << " ";
    std::cout << "]\nL-Arm: [";
    for(std::vector<std::string>::iterator name = goal_larm.trajectory.joint_names.begin();
        name != goal_larm.trajectory.joint_names.end(); ++name)
      std::cout << *name << " ";
    std::cout << "]\nR-Arm: [";
    for(std::vector<std::string>::iterator name = goal_rarm.trajectory.joint_names.begin();
        name != goal_rarm.trajectory.joint_names.end(); ++name)
      std::cout << *name << " "; std::cout << "]" << std::endl;
  }


  // Init positions are taken from HIRONX.
  // TODO: Need to add factory position too that's so convenient when
  // working with the manufacturer.
  void go_init(double task_duration=7.0)
  {
    ROS_INFO("*** go_init begins ***");
    std::vector<double> POSITIONS_TORSO_DEG(1,0.0);
    set_joint_angles_deg(GR_TORSO, POSITIONS_TORSO_DEG, task_duration);

    std::vector<double> POSITIONS_HEAD_DEG(2,0.0);
    set_joint_angles_deg(GR_HEAD, POSITIONS_HEAD_DEG, task_duration);

    std::vector<double> POSITIONS_LARM_DEG(6);
    POSITIONS_LARM_DEG[0] = 0.6;
    POSITIONS_LARM_DEG[1] = 0.0;
    POSITIONS_LARM_DEG[2] =-100;
    POSITIONS_LARM_DEG[3] =-15.2;
    POSITIONS_LARM_DEG[4] = 9.4;
    POSITIONS_LARM_DEG[5] =-3.2;
    set_joint_angles_deg(GR_LARM, POSITIONS_LARM_DEG, task_duration);

    std::vector<double> POSITIONS_RARM_DEG(6);
    POSITIONS_RARM_DEG[0] =-0.6;
    POSITIONS_RARM_DEG[1] =   0;
    POSITIONS_RARM_DEG[2] =-100;
    POSITIONS_RARM_DEG[3] =15.2;
    POSITIONS_RARM_DEG[4] = 9.4;
    POSITIONS_RARM_DEG[5] = 3.2;
    set_joint_angles_deg(GR_RARM, POSITIONS_RARM_DEG,task_duration, true);

    ROS_INFO("*** go_init_ends ***");
  }

  // This method takes the angles(radian) and
  // changes the angle of the joints of the robot.
  void set_joint_angles_rad(std::string groupname,
                            std::vector<double> positions_radian,
                            double duration=7.0,
                            bool wait=false)
  {
    TrajClient* action_client;

    if(groupname == GR_TORSO){
      action_client = new TrajClient("torso_controller/joint_trajectory_action", true);
      goal = goal_torso;
    }
    else if(groupname == GR_HEAD){
      action_client = new TrajClient("head_controller/joint_trajectory_action", true);
      goal = goal_head;
    }
    else if(groupname == GR_LARM){
      action_client =  new TrajClient("larm_controller/joint_trajectory_action", true);
      goal = goal_larm;
    }
    else if(groupname == GR_RARM){
      action_client =  new TrajClient("rarm_controller/joint_trajectory_action", true);
      goal = goal_rarm;
    }

    try {
      trajectory_msgs::JointTrajectoryPoint pt;
      pt.positions = positions_radian;
      pt.time_from_start = ros::Duration(duration);
      goal.trajectory.points.clear();
      goal.trajectory.points.push_back(pt);
      goal.trajectory.header.stamp = ros::Time::now() + ros::Duration(duration);
      action_client->sendGoal(goal);
      if(wait){
        ROS_INFO("waiting......");
        ROS_INFO("wait_for_result for the joint group %s = %d",
                 groupname.c_str(), action_client->waitForResult());
      }
    }
    catch(const ros::Exception& e){
      ROS_INFO("%s",e.what());
    }
    catch( ... ){
      ROS_INFO("Exception");
    }
    delete action_client;
  }


  //  groupname: This should exist in groupnames.
  void set_joint_angles_deg(std::string groupname,
                            std::vector<double> positions_deg,
                            double duration = 7.0,
                            bool wait = false)
  {
    set_joint_angles_rad(groupname,to_rad_list(positions_deg),duration,wait);
  }

private:
  std::string GR_TORSO;
  std::string GR_HEAD;
  std::string GR_LARM;
  std::string GR_RARM;

  const std::string MSG_ASK_ISSUEREPORT;

  pr2_controllers_msgs::JointTrajectoryGoal goal_larm;
  pr2_controllers_msgs::JointTrajectoryGoal goal_rarm;
  pr2_controllers_msgs::JointTrajectoryGoal goal_head;
  pr2_controllers_msgs::JointTrajectoryGoal goal_torso;

  /*
    param groupnames: List of the joint group names. Assumes to be in the
    following order:
    torso, head, right arm, left arm.
    This current setting is derived from the order of
    Groups argument in HIRONX class. If other groups
    need to be defined in the future, this method may
    need to be modified.
  */
  void set_groupnames(std::vector<std::string> groupnames)
  {
    // output group name
    ROS_INFO("set_groupnames");
    for(std::vector<std::string>::iterator name = groupnames.begin(); name != groupnames.end(); ++name)
      std::cout << *name << " "; std::cout << std::endl;

    GR_TORSO = groupnames[0];
    GR_HEAD  = groupnames[1];
    GR_RARM  = groupnames[2];
    GR_LARM  = groupnames[3];
  }

  // This method change degree to radian.
  // param list_degree: A list length of the number of joints.
  std::vector<double> to_rad_list(std::vector<double> list_degree)
  {
    std::vector<double> list_rad;
    list_rad.reserve(list_degree.size());
    for(std::vector<double>::iterator deg = list_degree.begin(); deg != list_degree.end();  ++deg){
      double rad = *deg * M_PI / 180.0;
      list_rad.push_back(rad);
      ROS_INFO("Position deg=%lf rad=%lf", *deg, rad);
    }
    return list_rad;
  }

};

#endif