Renamed the driver to ur_robot_driver

ur_robot_driver/doc/ROS_INTERFACE.md

@@ -0,0 +1,675 @@
+# ur_robot_driver
+
+The new driver for Universal Robots UR3, UR5 and UR10 robots with CB3 controllers and the e-series.
+
+## Launchfiles
+### ur3e_bringup.launch
+
+Standalone launchfile to startup a ur3e. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur3e_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_e_description)/config/ur3e_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_e_description)/launch/ur3e_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+ * "**tool_baud_rate**" (default: "115200")
+
+    Baud rate used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_device_name**" (default: "/tmp/ttyUR")
+
+    Local device name used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_parity**" (default: "0")
+
+    Parity configuration used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_rx_idle_chars**" (default: "1.5")
+
+    Number of idle chars in RX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_stop_bits**" (default: "1")
+
+    Number of stop bits used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tcp_port**" (default: "54321")
+
+    Port on which the robot controller publishes the tool comm interface. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tx_idle_chars**" (default: "3.5")
+
+    Number of idle chars in TX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_voltage**" (default: "0")
+
+    Tool voltage set at the beginning of the UR program. Only used, when `use_tool_communication` is set to true.
+
+ * "**use_tool_communication**" (default: "false")
+
+    On e-Series robots tool communication can be enabled with this argument
+
+### ur10_bringup.launch
+
+Standalone launchfile to startup a ur10 robot. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur10_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_description)/config/ur10_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_description)/launch/ur10_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+### ur_control.launch
+
+Robot bringup launchfile without the robot description. Include this, if you want to include robot control into a larger launchfile structure.
+
+#### Arguments
+ * "**controller_config_file**" (Required)
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    If set to true, will start the driver inside gdb
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (Required)
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description. Pass the same config file that is passed to the robot_description.
+
+ * "**launch_prefix**" (Required)
+
+    Please add description. See file "launch/ur_control.launch".
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**rtde_input_recipe_file**" (default: "$(find ur_robot_driver)/resources/rtde_input_recipe.txt")
+
+    Recipe file used for the RTDE-inputs. Only change this if you know what you're doing.
+
+ * "**rtde_output_recipe_file**" (default: "$(find ur_robot_driver)/resources/rtde_output_recipe.txt")
+
+    Recipe file used for the RTDE-outputs. Only change this if you know what you're doing.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+ * "**tool_baud_rate**" (default: "115200")
+
+    Baud rate used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_device_name**" (default: "/tmp/ttyUR")
+
+    Local device name used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_parity**" (default: "0")
+
+    Parity configuration used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_rx_idle_chars**" (default: "1.5")
+
+    Number of idle chars in RX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_stop_bits**" (default: "1")
+
+    Number of stop bits used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tcp_port**" (default: "54321")
+
+    Port on which the robot controller publishes the tool comm interface. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tx_idle_chars**" (default: "3.5")
+
+    Number of idle chars in TX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_voltage**" (default: "0")
+
+    Tool voltage set at the beginning of the UR program. Only used, when `use_tool_communication` is set to true.
+
+ * "**urscript_file**" (default: "$(find ur_robot_driver)/resources/servoj.urscript")
+
+    Path to URScript that will be sent to the robot and that forms the main control program.
+
+ * "**use_tool_communication**" (Required)
+
+    On e-Series robots tool communication can be enabled with this argument
+
+### ur_common.launch
+
+Launchfile that starts a robot description with robot_state publisher and the driver for a given robot. It is recommended to use the individual launch files instead such as `ur10_bringup.launch`. Additionally, this launchfile can be used as a template to include this driver into a larger launch file structure.
+
+#### Arguments
+ * "**controller_config_file**" (Required)
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_control.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (Required)
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (Required)
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+ * "**tool_baud_rate**" (default: "115200")
+
+    Baud rate used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_device_name**" (default: "/tmp/ttyUR")
+
+    Local device name used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_parity**" (default: "0")
+
+    Parity configuration used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_rx_idle_chars**" (default: "1.5")
+
+    Number of idle chars in RX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_stop_bits**" (default: "1")
+
+    Number of stop bits used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tcp_port**" (default: "54321")
+
+    Port on which the robot controller publishes the tool comm interface. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tx_idle_chars**" (default: "3.5")
+
+    Number of idle chars in TX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_voltage**" (default: "0")
+
+    Tool voltage set at the beginning of the UR program. Only used, when `use_tool_communication` is set to true.
+
+ * "**use_tool_communication**" (Required)
+
+    On e-Series robots tool communication can be enabled with this argument
+
+### ur5_bringup.launch
+
+Standalone launchfile to startup a ur5 robot. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur5_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_description)/config/ur5_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_description)/launch/ur5_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+### ur5e_bringup.launch
+
+Standalone launchfile to startup a ur5e robot. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur5e_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_e_description)/config/ur5e_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_e_description)/launch/ur5e_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+ * "**tool_baud_rate**" (default: "115200")
+
+    Baud rate used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_device_name**" (default: "/tmp/ttyUR")
+
+    Local device name used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_parity**" (default: "0")
+
+    Parity configuration used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_rx_idle_chars**" (default: "1.5")
+
+    Number of idle chars in RX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_stop_bits**" (default: "1")
+
+    Number of stop bits used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tcp_port**" (default: "54321")
+
+    Port on which the robot controller publishes the tool comm interface. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tx_idle_chars**" (default: "3.5")
+
+    Number of idle chars in TX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_voltage**" (default: "0")
+
+    Tool voltage set at the beginning of the UR program. Only used, when `use_tool_communication` is set to true.
+
+ * "**use_tool_communication**" (default: "false")
+
+    On e-Series robots tool communication can be enabled with this argument
+
+### ur3_bringup.launch
+
+Standalone launchfile to startup a ur5 robot. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur3_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_description)/config/ur3_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_description)/launch/ur3_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+### ur10e_bringup.launch
+
+Standalone launchfile to startup a ur10e robot. This requires a robot reachable via a network connection.
+
+#### Arguments
+ * "**controller_config_file**" (default: "$(find ur_robot_driver)/config/ur10e_controllers.yaml")
+
+    Config file used for defining the ROS-Control controllers.
+
+ * "**controllers**" (default: "joint_state_controller scaled_pos_traj_controller speed_scaling_state_controller force_torque_sensor_controller")
+
+    Controllers that are activated by default.
+
+ * "**debug**" (default: "false")
+
+    Debug flag that will get passed on to ur_common.launch
+
+ * "**headless_mode**" (default: "false")
+
+    Automatically send URScript to robot to execute. On e-Series this does require the robot to be in 'remote-control' mode. With this, the URCap is not needed on the robot.
+
+ * "**kinematics_config**" (default: "$(find ur_e_description)/config/ur10e_default.yaml")
+
+    Kinematics config file used for calibration correction. This will be used to verify the robot's calibration is matching the robot_description.
+
+ * "**limited**" (default: "false")
+
+    Use the description in limited mode (Every axis rotates from -PI to PI)
+
+ * "**robot_description_file**" (default: "$(find ur_e_description)/launch/ur10e_upload.launch")
+
+    Robot description launch file.
+
+ * "**robot_ip**" (Required)
+
+    IP address by which the robot can be reached.
+
+ * "**stopped_controllers**" (default: "pos_traj_controller")
+
+    Controllers that are initally loaded, but not started.
+
+ * "**tf_prefix**" (default: "")
+
+    tf_prefix used for the robot.
+
+ * "**tool_baud_rate**" (default: "115200")
+
+    Baud rate used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_device_name**" (default: "/tmp/ttyUR")
+
+    Local device name used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_parity**" (default: "0")
+
+    Parity configuration used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_rx_idle_chars**" (default: "1.5")
+
+    Number of idle chars in RX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_stop_bits**" (default: "1")
+
+    Number of stop bits used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tcp_port**" (default: "54321")
+
+    Port on which the robot controller publishes the tool comm interface. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_tx_idle_chars**" (default: "3.5")
+
+    Number of idle chars in TX channel used for tool communication. Only used, when `use_tool_communication` is set to true.
+
+ * "**tool_voltage**" (default: "0")
+
+    Tool voltage set at the beginning of the UR program. Only used, when `use_tool_communication` is set to true.
+
+ * "**use_tool_communication**" (default: "false")
+
+    On e-Series robots tool communication can be enabled with this argument
+
+## Nodes
+### ur_robot_driver_node
+
+This is the actual driver node containing the ROS-Control stack. Interfaces documented here refer to the robot's hardware interface. Controller-specific API elements might be present for the individual controllers outside of this package.
+
+#### Advertised Services
+ * "**hand_back_control**" ([std_srvs/Trigger](http://docs.ros.org/api/std_srvs/html/srv/Trigger.html))
+
+    Calling this service will make the "External Control" program node on the UR-Program return.
+
+ * "**resend_robot_program**" ([std_srvs/Trigger](http://docs.ros.org/api/std_srvs/html/srv/Trigger.html))
+
+    When in headless mode, this sends the URScript program to the robot for execution. Use this after the program has been interrupted, e.g. by a protective- or EM-stop.
+
+ * "**set_io**" (ur_msgs/SetIO)
+
+    Service to set any of the robot's IOs
+
+ * "**set_speed_slider**" (ur_msgs/SetSpeedSliderFraction)
+
+    Set the speed slider fraction used by the robot's execution. Values should be between 0 and 1. Only set this smaller than 1 if you are using the scaled controllers (as by default) or you know what you're doing. Using this with other controllers might lead to unexpected behaviors.
+
+#### Parameters
+ * "**hardware_interface/joints**" (Required)
+
+    Names of the joints. Usually, this is given in the controller config file.
+
+ * "**headless_mode**" (Required)
+
+    Start robot in headless mode. This does not require the 'External Control' URCap to be running on the robot, but this will send the URScript to the robot directly. On e-Series robots this requires the robot to run in 'remote-control' mode.
+
+ * "**input_recipe_file**" (Required)
+
+    Path to the file containing the recipe used for requesting RTDE inputs.
+
+ * "**kinematics/hash**" (Required)
+
+    Hash of the calibration reported by the robot. This is used for validating the robot description is using the correct calibration. If the robot's calibration doesn't match this hash, an error will be printed. You can use the robot as usual, however Cartesian poses of the endeffector might be inaccurate. See the "ur_calibration" package on help how to generate your own hash matching your actual robot.
+
+ * "**output_recipe_file**" (Required)
+
+    Path to the file containing the recipe used for requesting RTDE outputs.
+
+ * "**robot_ip**" (Required)
+
+    The robot's IP address.
+
+ * "**script_file**" (Required)
+
+    Path to the urscript code that will be sent to the robot.
+
+ * "**tf_prefix**" (default: "")
+
+    Please add description. See hardware_interface.cpp line number: 67
+
+
+
+    	robot_hw_nh.param<std::string>("tf_prefix", tf_prefix_, "");
+
+ * "Symbol: **this_thread**" (default: "&params")
+
+    Please add description. See hardware_interface_node.cpp line number: 98
+
+
+
+    	int ret = pthread_setschedparam(this_thread, SCHED_FIFO, &params);
+
+ * "**tool_baud_rate**" (Required)
+
+    Baud rate used for tool communication. Will be set as soon as the UR-Program on the robot is started. See UR documentation for valid baud rates.  Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE.  Then, this parameter is required.
+
+ * "**tool_parity**" (Required)
+
+    Parity used for tool communication. Will be set as soon as the UR-Program on the robot is started. Can be 0 (None), 1 (odd) and 2 (even).  Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE.  Then, this parameter is required.
+
+ * "**tool_rx_idle_chars**" (Required)
+
+    Number of idle chars for the RX unit used for tool communication. Will be set as soon as the UR-Program on the robot is started. Valid values: min=1.0, max=40.0  Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE.  Then, this parameter is required.
+
+ * "**tool_stop_bits**" (Required)
+
+    Number of stop bits used for tool communication. Will be set as soon as the UR-Program on the robot is started. Can be 1 or 2.  Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE.  Then, this parameter is required.
+
+ * "**tool_tx_idle_chars**" (Required)
+
+    Number of idle chars for the TX unit used for tool communication. Will be set as soon as the UR-Program on the robot is started. Valid values: min=0.0, max=40.0  Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE.  Then, this parameter is required.
+
+ * "**tool_voltage**" (Required)
+
+    Tool voltage that will be set as soon as the UR-Program on the robot is started. Note: This parameter is only evaluated, when the parameter "use_tool_communication" is set to TRUE. Then, this parameter is required.
+
+ * "**use_tool_communication**" (Required)
+
+    Should the tool's RS485 interface be forwarded to the ROS machine? This is only available on e-Series models. Setting this parameter to TRUE requires multiple other parameters to be set,as well.
+
+#### Published topics
+ * "**robot_program_running**" ([std_msgs/Bool](http://docs.ros.org/api/std_msgs/html/msg/Bool.html))
+
+    Whenever the runtime state of the "External Control" program node in the UR-program changes, a message gets published here. So this is equivalent to the information whether the robot accepts commands from ROS side.
+
+#### Subscribed topics
+ * "**script_command**" ([std_msgs/String](http://docs.ros.org/api/std_msgs/html/msg/String.html))
+
+    Send arbitrary script commands to this topic. Note: On e-Series the robot has to be in remote-control mode.  Sending scripts to this will stop program execution unless wrapped in a secondary program:  sec myProgram(): set_digital_out(0, True) end
+
+### tool_communication
+
+This node is used to start the RS485 tunneling interface on the ROS machine. This requires that the RS485 daemon is running on the robot controller and tool communication is enabled on the robot.
+
+#### Parameters
+ * "**~device_name**" (Required)
+
+    By default, socat will create a pty in /dev/pts/N with n being an increasing number. Additionally, a symlink at the given location will be created. Use an absolute path here.
+
+ * "**~robot_ip**" (Required)
+
+    IP address of the robot
+
+ * "**~tcp_port**" (default: "54321")
+
+    Port on which the remote pc (robot) publishes the interface
+

ur_robot_driver/doc/features.md

@@ -0,0 +1,34 @@
+# Feature comparison and roadmap
+
+| Feature                                               | ur_modern_driver | this_driver           |
+| ---                                                   | ---              | ---                   |
+| position-based control                                | yes              | yes                   |
+| scaled position-based control                         | -                | yes                   |
+| velocity-based control                                | yes              | planned               |
+| reporting of tcp wrench                               | yes              | yes                   |
+| reporting of tcp wrench in tcp link                   | -                | yes                   |
+| pausing of programs                                   | -                | yes                   |
+| continue trajectories after EM-Stop resume            | -                | yes                   |
+| continue trajectories after protective stop           | -                | yes                   |
+| panel interaction in between possible                 | no<sup>1</sup>   | yes                   |
+| get and set IO states                                 | yes              | yes               |
+| use tool communication on e-series                    | -                | yes                   |
+| use the driver without a teach pendant necessary      | -                | planned               |
+| support of CB2 robots                                 | yes              | -                     |
+| trajectory extrapolation on robot on missing packages | no<sup>2</sup>   | yes                   |
+| use ROS as drop-in for TP-programs                    | -                | yes   |
+| extract calibration from robot                        | -                | yes                   |
+| send custom script commands to robot                  | yes              | yes               |
+| ROS 2 support                                         | ?                | (planned)<sup>3</sup> |
+| Reconnect on a disconnected robot                     | yes              | yes           |
+
+<sup>1</sup> Depending on the mode the driver is running the panel won't react or using the panel
+will stop the program without notifying the ROS user.
+
+<sup>2</sup> In velocity mode this is implicitly given.
+
+<sup>3</sup> There is no specific plan to do this inside of the first driver development. However,
+it is structured in a way so that a ROS2 driver should be developed as easy as possible by keeping
+as much as possible in a ros-independent library.
+
+

ur_robot_driver/doc/install_urcap_cb3.md

@@ -0,0 +1,44 @@
+# Installing a URCap on a CB3 robot
+
+For using the *ur_robot_driver* with a real robot you need to install the
+**externalcontrol-1.0.urcap** which can be found inside the **resources** folder of this driver.
+
+**Note**: For installing this URCap a minimal PolyScope version of 3.7 is necessary.
+
+To install it you first have to copy it to the robot's **programs** folder which can be done either
+via scp or using a USB stick.
+
+On the welcome screen select *Setup Robot* and then *URCaps* to enter the URCaps installation
+screen.
+
+ ![Welcome screen of a CB3 robot](initial_setup_images/cb3_01_welcome.png)
+
+There, click the little plus sign at the bottom to open the file selector. There you should see
+all urcap files stored inside the robot's programs folder or a plugged USB drive.  Select and open
+the **externalcontrol-1.0.urcap** file and click *open*. Your URCaps view should now show the
+**External Control** in the list of active URCaps and a notification to restart the robot. Do that
+now.
+
+ ![URCaps screen with installed urcaps](initial_setup_images/cb3_05_urcaps_installed.png)
+
+After the reboot you should find the **External Control** URCaps inside the *Installation* section.
+For this select *Program Robot* on the welcome screen, select the *Installation* tab and select
+**External Control** from the list.
+
+ ![Installation screen of URCaps](initial_setup_images/cb3_07_installation_excontrol.png)
+
+Here you'll have to setup the IP address of the external PC which will be running the ROS driver.
+Note that the robot and the external PC have to be in the same network, ideally in a direct
+connection with each other to minimize network disturbances. The custom port should be left
+untouched for now.
+
+ ![Insert the external control node](initial_setup_images/cb3_10_prog_structure_urcaps.png)
+
+To use the new URCaps, create a new program and insert the **External Control** program node into
+the program tree
+
+ ![Program view of external control](initial_setup_images/cb3_11_program_view_excontrol.png)
+
+If you click on the *command* tab again, you'll see the settings entered inside the *Installation*.
+Check that they are correct, then save the program. Your robot is now ready to be used together with
+this driver.

ur_robot_driver/doc/install_urcap_e_series.md

@@ -0,0 +1,43 @@
+# Installing a URCap on a s-Series robot
+
+For using the *ur_robot_driver* with a real robot you need to install the
+**externalcontrol-1.0.urcap** which can be found inside the **resources** folder of this driver.
+
+**Note**: For installing this URCap a minimal PolyScope version of 5.1 is necessary.
+
+To install it you first have to copy it to the robot's **programs** folder which can be done either
+via scp or using a USB stick.
+
+On the welcome screen click on the hamburger menu in the top-right corner and select *Settings* to enter the robot's setup.  There select *System* and then *URCaps* to enter the URCaps installation screen.
+
+ ![Welcome screen of an e-Series robot](initial_setup_images/es_01_welcome.png)
+
+There, click the little plus sign at the bottom to open the file selector. There you should see
+all urcap files stored inside the robot's programs folder or a plugged USB drive.  Select and open
+the **externalcontrol-1.0.urcap** file and click *open*. Your URCaps view should now show the
+**External Control** in the list of active URCaps and a notification to restart the robot. Do that
+now.
+
+ ![URCaps screen with installed urcaps](initial_setup_images/es_05_urcaps_installed.png)
+
+After the reboot you should find the **External Control** URCaps inside the *Installation* section.
+For this select *Program Robot* on the welcome screen, select the *Installation* tab and select
+**External Control** from the list.
+
+ ![Installation screen of URCaps](initial_setup_images/es_07_installation_excontrol.png)
+
+Here you'll have to setup the IP address of the external PC which will be running the ROS driver.
+Note that the robot and the external PC have to be in the same network, ideally in a direct
+connection with each other to minimize network disturbances. The custom port should be left
+untouched for now.
+
+ ![Insert the external control node](initial_setup_images/es_10_prog_structure_urcaps.png)
+
+To use the new URCaps, create a new program and insert the **External Control** program node into
+the program tree
+
+ ![Program view of external control](initial_setup_images/es_11_program_view_excontrol.png)
+
+If you click on the *command* tab again, you'll see the settings entered inside the *Installation*.
+Check that they are correct, then save the program. Your robot is now ready to be used together with
+this driver.

ur_robot_driver/doc/real_time.md

@@ -0,0 +1,282 @@
+# Setting up Ubuntu with a PREEMPT_RT kernel
+In order to run the `universal_robot_driver`, we highly recommend to setup a ubuntu system with
+real-time capabilities. Especially with a robot from the e-Series the higher control frequency
+might lead to non-smooth trajectory execution if not run using a real-time-enabled system.
+
+You might still be able to control the robot using a non-real-time system. This is, however, not recommended.
+
+To get real-time support into a ubuntu system, the following steps have to be performed:
+ 1. Get the sources of a real-time kernel
+ 2. Compile the real-time kernel
+ 3. Setup user privileges to execute real-time tasks
+
+This guide will help you setup your system with a real-time kernel.
+
+## Preparing
+To build the kernel, you will need a couple of tools available on your system. You can install them
+using
+
+``` bash
+$ sudo apt-get install build-essential bc ca-certificates gnupg2 libssl-dev wget gawk
+```
+
+Before you download the sources of a real-time-enabled kernel, check the kernel version that is currently installed:
+
+```bash
+$ uname -r
+4.15.0-62-generic 
+```
+
+To continue with this tutorial, please create a temporary folder and navigate into it. You should
+have sufficient space (around 25GB) there, as the extracted kernel sources take much space. After
+the new kernel is installed, you can delete this folder again.
+
+In this example we will use a temporary folder inside our home folder:
+
+```bash
+$ mkdir -p ${HOME}/rt_kernel_build
+$ cd ${HOME}/rt_kernel_build
+```
+
+All future commands are expected to be run inside this folder. If the folder is different, the `$`
+sign will be prefixed with a path relative to the above folder.
+
+## Getting the sources for a real-time kernel
+To build a real-time kernel, we first need to get the kernel sources and the real-time patch.
+
+First, we must decide on the kernel version that we want to use. Above, we
+determined that our system has a 4.15 kernel installed. However, real-time
+patches exist only for selected kernel versions. Those can be found on the
+[linuxfoundation wiki](https://wiki.linuxfoundation.org/realtime/preempt_rt_versions).
+
+In this example, we will select a 4.14 kernel. Select a kernel version close  to the
+one installed on your system.
+
+Go ahead and download the kernel sources, patch sources and their signature files:
+
+```bash
+$ wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/4.14/patch-4.14.139-rt66.patch.xz
+$ wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/4.14/patch-4.14.139-rt66.patch.sign
+$ wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.14.139.tar.xz
+$ wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.14.139.tar.sign
+```
+
+To unzip the downloaded files do
+```bash
+$ xz -d patch-4.14.139-rt66.patch.xz
+$ xz -d linux-4.14.139.tar.xz
+```
+
+### Verification
+Technically, you can skip this section, it is however highly recommended to verify the file
+integrity of such a core component of your system!
+
+To verify file integrity, you must first import public keys by the kernel developers and the patch
+author. For the kernel sources use (as suggested on
+[kernel.org](https://www.kernel.org/signature.html))
+
+```bash
+$ gpg2 --locate-keys torvalds@kernel.org gregkh@kernel.org
+```
+
+and for the patch search for a key of the author listed on 
+[linuxfoundation wiki](https://wiki.linuxfoundation.org/realtime/preempt_rt_versions).
+
+```bash
+$ gpg2 --keyserver hkp://keys.gnupg.net --search-keys zanussi
+gpg: data source: http://51.38.91.189:11371
+(1)     German Daniel Zanussi <german.zanussi@globant.com>
+          4096 bit RSA key 0x537F98A9D92CEAC8, created: 2019-07-24, expires: 2023-07-24
+(2)     Michael Zanussi <mzanussi@gmail.com>
+          4096 bit RSA key 0x7C7F76A2C1E3D9EB, created: 2019-05-08
+(3)     Tom Zanussi <tzanussi@gmail.com>
+        Tom Zanussi <zanussi@kernel.org>
+        Tom Zanussi <tom.zanussi@linux.intel.com>
+          4096 bit RSA key 0xDE09826778A38521, created: 2017-12-15
+(4)     Riccardo Zanussi <riccardo.zanussi@gmail.com>
+          2048 bit RSA key 0xD299A06261D919C3, created: 2014-08-27, expires: 2018-08-27 (expired)
+(5)     Zanussi Gianni <g.zanussi@virgilio.it>
+          1024 bit DSA key 0x78B89CB020D1836C, created: 2004-04-06
+(6)     Michael Zanussi <zanussi@unm.edu>
+        Michael Zanussi <mzanussi@gmail.com>
+        Michael Zanussi <michael_zanussi@yahoo.com>
+        Michael Zanussi <michael@michaelzanussi.com>
+          1024 bit DSA key 0xB3E952DCAC653064, created: 2000-09-05
+(7)     Michael Zanussi <surfpnk@yahoo.com>
+          1024 bit DSA key 0xEB10BBD9BA749318, created: 1999-05-31
+(8)     Michael B. Zanussi <surfpnk@yahoo.com>
+          1024 bit DSA key 0x39EE4EAD7BBB1E43, created: 1998-07-16
+Keys 1-8 of 8 for "zanussi".  Enter number(s), N)ext, or Q)uit > 3
+```
+
+Now we can verify the downloaded sources:
+```bash
+$ gpg2 --verify linux-4.14.139.tar.sign
+gpg: assuming signed data in 'linux-4.14.139.tar'
+gpg: Signature made Fr 16 Aug 2019 10:15:17 CEST
+gpg:                using RSA key 647F28654894E3BD457199BE38DBBDC86092693E
+gpg: Good signature from "Greg Kroah-Hartman <gregkh@kernel.org>" [unknown]
+gpg: WARNING: This key is not certified with a trusted signature!
+gpg:          There is no indication that the signature belongs to the owner.
+Primary key fingerprint: 647F 2865 4894 E3BD 4571  99BE 38DB BDC8 6092 693E
+
+$ gpg2 --verify patch-4.14.139-rt66.patch.sign
+gpg: assuming signed data in 'patch-4.14.139-rt66.patch'
+gpg: Signature made Fr 23 Aug 2019 21:09:20 CEST
+gpg:                using RSA key 0x0129F38552C38DF1
+gpg: Good signature from "Tom Zanussi <tom.zanussi@linux.intel.com>" [unknown]
+gpg:                 aka "Tom Zanussi <zanussi@kernel.org>" [unknown]
+gpg:                 aka "Tom Zanussi <tzanussi@gmail.com>" [unknown]
+gpg: WARNING: This key is not certified with a trusted signature!
+gpg:          There is no indication that the signature belongs to the owner.
+Primary key fingerprint: 5BDF C45C 2ECC 5387 D50C  E5EF DE09 8267 78A3 8521
+     Subkey fingerprint: ACF8 5F98 16A8 D5F0 96AE  1FD2 0129 F385 52C3 8DF1
+```
+
+## Compilation
+Before we can compile the sources, we have to extract the tar archive and apply the patch
+
+```bash
+$ tar xf linux-4.14.139.tar
+$ cd linux-4.14.139
+linux-4.14.139$ xzcat ../patch-4.14.139-rt66.patch.xz | patch -p1 
+```
+
+Now to configure your kernel, just type
+```bash
+linux-4.14.139$ make oldconfig
+```
+
+This will ask for kernel options. For everything else then the `Preemption Model` use the default
+value (just press Enter) or adapt to your preferences. For the preemption model select `Fully Preemptible Kernel`:
+
+```bash
+Preemption Model
+  1. No Forced Preemption (Server) (PREEMPT_NONE)
+> 2. Voluntary Kernel Preemption (Desktop) (PREEMPT_VOLUNTARY)
+  3. Preemptible Kernel (Low-Latency Desktop) (PREEMPT__LL) (NEW)
+  4. Preemptible Kernel (Basic RT) (PREEMPT_RTB) (NEW)
+  5. Fully Preemptible Kernel (RT) (PREEMPT_RT_FULL) (NEW)
+choice[1-5]: 5
+```
+
+Now you can build the kernel. This will take some time...
+
+```bash
+linux-4.14.139$ make -j `getconf _NPROCESSORS_ONLN` deb-pkg
+```
+
+After building, install the `linux-headers` and `linux-image` packages in the parent folder (only
+the ones without the `-dbg` in the name)
+
+```bash
+linux-4.14.139$ sudo apt install ../linux-headers-4.14.139-rt66_*.deb ../linux-image-4.14.139-rt66_*.deb
+```
+
+## Setup user privileges to use real-time scheduling
+To be able to schedule threads with user privileges (what the driver will do) you'll have to change
+the user's limits by changing `/etc/security/limits.conf` (See [the manpage](https://manpages.ubuntu.com/manpages/bionic/man5/limits.conf.5.html) for details)
+
+We recommend to setup a group for real-time users instead of writing a fixed username into the config
+file:
+
+```bash
+$ sudo groupadd realtime
+$ sudo usermod -aG realtime $(whoami)
+```
+
+Then, make sure `/etc/security/limits.conf` contains
+```
+@realtime soft rtprio 99
+@realtime soft priority 99
+@realtime soft memlock 102400
+@realtime hard rtprio 99
+@realtime hard priority 99
+@realtime hard memlock 102400
+```
+
+Note: You will have to log out and log back in (Not only close your terminal window) for these
+changes to take effect. No need to do this now, as we will reboot later on, anyway.
+
+## Setup GRUB to always boot the real-time kernel
+To make the new kernel the default kernel that the system will boot into every time, you'll have to
+change the grub config file inside `/etc/default/grub`.
+
+Note: This works for ubuntu, but might not be working for other linux systems. It might be necessary
+to use another menuentry name there.
+
+But first, let's find out the name of the entry that we will want to make the default. You can list
+all available kernels using
+
+```bash
+$ awk -F\' '/menuentry |submenu / {print $1 $2}' /boot/grub/grub.cfg
+
+menuentry Ubuntu
+submenu Advanced options for Ubuntu
+    menuentry Ubuntu, with Linux 4.15.0-62-generic
+    menuentry Ubuntu, with Linux 4.15.0-62-generic (recovery mode)
+    menuentry Ubuntu, with Linux 4.15.0-60-generic
+    menuentry Ubuntu, with Linux 4.15.0-60-generic (recovery mode)
+    menuentry Ubuntu, with Linux 4.15.0-58-generic
+    menuentry Ubuntu, with Linux 4.15.0-58-generic (recovery mode)
+    menuentry Ubuntu, with Linux 4.14.139-rt66
+    menuentry Ubuntu, with Linux 4.14.139-rt66 (recovery mode)
+menuentry Memory test (memtest86+)
+menuentry Memory test (memtest86+, serial console 115200)
+menuentry Windows 7 (on /dev/sdc2)
+menuentry Windows 7 (on /dev/sdc3)
+```
+
+From the output above, we'll need to generate a string with the pattern `"submenu_name>entry_name"`. In our case this would be
+
+```
+"Advanced options for Ubuntu>Ubuntu, with Linux 4.14.139-rt66"
+```
+**The double quotes and no spaces around the `>` are important!**
+
+With this, we can setup the default grub entry and then update the grub menu entries. Don't forget this last step!
+
+```bash
+$ sudo sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT="Advanced options for Ubuntu>Ubuntu, with Linux 4.14.139-rt66"/' /etc/default/grub
+$ sudo update-grub
+```
+
+## Reboot the PC
+After having performed the above mentioned steps, reboot the PC. It should boot into the correct
+kernel automatically.
+
+## Check for preemption capabilities
+Make sure that the kernel does indeed support real-time scheduling:
+
+```bash
+$ uname -v | cut -d" " -f1-4 
+#1 SMP PREEMPT RT
+```
+
+## Optional: Disable CPU speed scaling
+Many modern CPUs support changing their clock frequency dynamically depending on the currently
+requested computation resources. In some cases this can lead to small interruptions in execution.
+While the real-time scheduled controller thread should be unaffected by this, any external
+components such as a visual servoing system might be interrupted for a short period on scaling
+changes.
+
+To check and modify the power saving mode, install cpufrequtils:
+```bash
+$ sudo apt install cpufrequtils
+```
+
+Run `cpufreq-info` to check available "governors" and the current CPU Frequency (`current CPU
+frequency is XXX MHZ`). In the following we will set the governor to "performance".
+
+```bash
+$ sudo systemctl disable ondemand
+$ sudo systemctl enable cpufrequtils
+$ sudo sh -c 'echo "GOVERNOR=performance" > /etc/default/cpufrequtils'
+$ sudo systemctl daemon-reload && sudo systemctl restart cpufrequtils
+```
+
+This disables the `ondemand` CPU scaling daemon, creates a `cpufrequtils` config file and restarts
+the `cpufrequtils` service. Check with `cpufreq-info`.
+
+For further information about governors, please see the [kernel
+documentation](https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt).

ur_robot_driver/doc/rosdoc.yaml

@@ -0,0 +1,4 @@
+- builder: doxygen
+  name: C++ API
+  output_dir: c++
+  file_patterns: '*.c *.cpp *.h *.cc *.hh *.dox'

ur_robot_driver/doc/setup_tool_communication.md

@@ -0,0 +1,48 @@
+# Setting up the tool communication on an e-Series robot
+The Universal Robots e-Series provides an rs485 based interface at the tool flange that can be used
+to attach an rs485-based device to the robot's tcp without the need to wire a separate cable along
+the robot.
+
+This driver enables forwarding this tool communication interface to an external machine for example
+to start a device's ROS driver on a remote PC.
+
+This document will guide you through installing the URCap needed for this and setting up your ROS
+launch files to utilize the robot's tool communication.
+
+## Robot setup
+For setting up the robot, please install the **rs485-1.0.urcap** found in the **resources** folder.
+Installing a URCap is explained in the [setup guide](install_urcap_e_series.md) for the **external-control** URCap.
+
+After installing the URCap the robot will expose its tool communication device to the network.
+
+## Setup the ROS side
+In order to use the tool communication in ROS, simply pass the correct parameters to the bringup
+launch files:
+
+```bash
+$ roslaunch ur_robot_driver ur<3|5|10>e_bringup.launch \
+  use_tool_communication:=true \
+  tool_voltage:=24 \ # can be 0, 12 or 24
+  tool_parity:=0 \ # 0: none, 1: odd, 2: even
+  tool_baud_rate:=115200 \
+  tool_stop_bits:=1 \
+  tool_rx_idle_chars:=1.5 \
+  tool_tx_idle_chars:=3.5 \
+  tool_device_name:=/tmp/ttyUR  # remember that your user needs to have the rights to write that file handle
+```
+
+The `tool_device_name` is an arbitrary name for the device file at which the device will be
+accessible in the local file system. Most ROS drivers for rs485 devices accept an argument to
+specify the device file path. With the example above you could run the `rs485_node` from the package
+`imaginary_drivers` using the following command:
+
+```bash
+$ rosrun imaginary_drivers rs485_node device:=/tmp/ttyUR
+
+```
+
+You can basically choose any device name, but your user has to have the correct rights to actually
+create a new file handle inside this directory. Therefore, we didn't use the `/dev` folder in the
+example, as users usually don't have the access rights to create new files there.
+
+For all the other tool parameters seen above, please refer to the Universal Robots user manual.