• Stars
    star
    302
  • Rank 138,030 (Top 3 %)
  • Language
    C++
  • License
    Apache License 2.0
  • Created about 9 years ago
  • Updated almost 2 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

(deprecated) ROS 1 driver for CB1 and CB2 controllers with UR5 or UR10 robots from Universal Robots

ur_modern_driver - Deprecated

Deprecation notice

note: the master branch contains a deprecated version of this driver, kept for archival purposes only.

ur_modern_driver has been deprecated completely in favour of ur_robot_driver.

Users with CB3 and e-Series controllers should use ur_robot_driver.

Refer to the announcement on ROS Discourse for more information.

Click to see original readme

Overview

A new driver for the UR3/UR5/UR10 robot arms from Universal Robots. It is designed to replace the old driver transparently, while solving some issues, improving usability as well as enabling compatibility of ros_control.

Improvements

  • A script is only running on the robot while a trajectory is actually executing. This means that the teach pendant can be used to move the robot around while the driver is connected.

  • The driver exposes the same functionality as the previous ur_driver:

    • Action interface on /follow_joint_trajectory for seamless integration with MoveIt

    • Publishes robot joint state on /joint_states

    • Publishes TCP force on /wrench

    • Publishes IO state on /ur_driver/io_states (Note that the string /ur_driver has been prepended compared to the old driver)

    • Service call to set outputs and payload - Again, the string /ur_driver has been prepended compared to the old driver (Note: I am not sure if setting the payload actually works, as the robot GUI does not update. This is also true for the old ur_driver )

  • Besides this, the driver subscribes to two new topics:

    • /ur_driver/URScript : Takes messages of type std_msgs/String and directly forwards it to the robot. Note that no control is done on the input, so use at your own risk! Inteded for sending movel/movej commands directly to the robot, conveyor tracking and the like.

    • /joint_speed : Takes messages of type trajectory_msgs/JointTrajectory. Parses the first JointTracetoryPoint and sends the specified joint speeds and accelerations to the robot. This interface is intended for doing visual servoing and other kind of control that requires speed control rather than position control of the robot. Remember to set values for all 6 joints. Ignores the field joint_names, so set the values in the correct order.

  • Added support for ros_control.

    • As ros_control wants to have control over the robot at all times, ros_control compatibility is set via a parameter at launch-time.
    • With ros_control active, the driver doesn't open the action_lib interface nor publish joint_states or wrench msgs. This is handled by ros_control instead.
    • Currently two controllers are available, both controlling the joint position of the robot, useable for trajectroy execution
      • The velocity based controller sends joint speed commands to the robot, using the speedj command
      • The position based controller sends joint position commands to the robot, using the servoj command
      • I have so far only used the velocity based controller, but which one is optimal depends on the application.
    • As ros_control continuesly controls the robot, using the teach pendant while a controller is running will cause the controller on the robot to crash, as it obviously can't handle conflicting control input from two sources. Thus be sure to stop the running controller before moving the robot via the teach pendant:
      • A list of the loaded and running controllers can be found by a call to the controller_manager rosservice call /controller_manager/list_controllers {}
      • The running position trajectory controller can be stopped with a call to rosservice call /universal_robot/controller_manager/switch_controller "start_controllers: - '' stop_controllers: - 'pos_based_pos_traj_controller' strictness: 1" (Remember you can use tab-completion for this)

Installation

As the driver communicates with the robot via ethernet and depends on reliable continous communication, it is not possible to reliably control a UR from a virtual machine.

Just clone the repository into your catkin working directory and make it with catkin_make.

Note that this package depends on ur_msgs, hardware_interface, and controller_manager so it cannot directly be used with ROS versions prior to hydro.

Usage

The driver is designed to be a drop-in replacement of the ur_driver package. It won't overwrite your current driver though, so you can use and test this package without risking to break your current setup.

If you want to test it in your current setup, just use the modified launch files included in this package instead of those in ur_bringup. Everything else should work as usual.

If you would like to run this package to connect to the hardware, you only need to run the following launch file.

roslaunch ur_modern_driver urXX_bringup.launch robot_ip:=ROBOT_IP_ADDRESS

Where ROBOT_IP_ADDRESS is your UR arm's IP and XX is '5' or '10' depending on your robot. The above launch file makes calls to both roscore and the launch file to the urXX_description so that ROS's parameter server has information on your robot arm. If you do not have your ur_description installed please do so via:

sudo apt install ros-<distro>-ur-description

Where is the ROS distribution your machine is running on. You may want to run MoveIt to plan and execute actions on the arm. You can do so by simply entering the following commands after launching ur_modern_driver:

roslaunch urXX_moveit_config ur5_moveit_planning_executing.launch
roslaunch urXX_moveit_config moveit_rviz.launch config:=true

If you would like to use the ros_control-based approach, use the launch files urXX_ros_control.launch, where XX is '5' or '10' depending on your robot.

Note: If you are using the ros_control-based approach you will need 2 packages that can be found in the ur_driver package. If you do not have the ur_driver package in your workspace simply copy these packages into your workspace /src folder:

  • urXX_moveit_config
  • ur_description

The driver currently supports two position trajectory controllers; a position based and a velocity based. They are both loaded via the launch file, but only one of them can be running at the same time. By default the velocity based controller is started. You can switch controller by calling the appropriate service:

rosservice call /universal_robot/controller_manager/switch_controller "start_controllers:
- 'vel_based_pos_traj_controller'
stop_controllers:
- 'pos_based_pos_traj_controller'
strictness: 1"

Be sure to stop the currently running controller either before or in the same call as you start a new one, otherwise it will fail.

The position based controller should stay closer to the commanded path, while the velocity based react faster (trajectory execution start within 50-70 ms, while it is in the 150-180ms range for the position_based. Usage without ros_control as well as the old driver is also in the 170ms range, as mentioned at my lightning talk @ ROSCon 2013).

Note that the PID values are not optimally tweaked as of this moment.

To use ros_control together with MoveIt, be sure to add the desired controller to the controllers.yaml in the urXX_moveit_config/config folder. Add the following

controller_list:
 - name: /vel_based_pos_traj_controller #or /pos_based_pos_traj_controller
   action_ns: follow_joint_trajectory
   type: FollowJointTrajectory
   default: true
   joints:
      - shoulder_pan_joint
      - shoulder_lift_joint
      - elbow_joint
      - wrist_1_joint
      - wrist_2_joint
      - wrist_3_joint

Using the tool0_controller frame

Each robot from UR is calibrated individually, so there is a small error (in the order of millimeters) between the end-effector reported by the URDF models in https://github.com/ros-industrial/universal_robot/tree/indigo-devel/ur_description and the end-effector as reported by the controller itself.

This driver broadcasts a transformation between the base link and the end-effector as reported by the UR. The default frame names are: base and tool0_controller.

To use the tool0_controller frame in a URDF, there needs to be a link with that name connected to base. For example:

<!-- Connect tool0_controller to base using floating joint -->
<link name="tool0_controller"/>
<joint name="base-tool0_controller_floating_joint" type="floating">
  <origin xyz="0 0 0" rpy="0 0 0"/>
  <parent link=base"/>
  <child link="tool0_controller"/>
</joint>

Now, the actual transform between base and tool0_controller will not be published by the robot_state_publisher but will be taken from this driver via /tf.

NOTE: You need an up-to-date version of robot_state_publisher that is able to deal with floating joints, see: ros/robot_state_publisher#32

Compatibility

Should be compatible with all robots and control boxes with the newest firmware.

###Tested with:

*Real UR10 with CB2 running 1.8.14035

*Real UR5 with CB2 running 1.8.14035

*Simulated UR3 running 3.1.18024

*Simulated UR5 running 3.0.16471

*Simulated UR5 running 1.8.16941

*Simulated UR5 running 1.7.10857

*Simulated UR5 running 1.6.08725

#Credits Please cite the following report if using this driver

@techreport{andersen2015optimizing, title = {Optimizing the Universal Robots ROS driver.}, institution = {Technical University of Denmark, Department of Electrical Engineering}, author = {Andersen, Thomas Timm}, year = {2015}, url = {http://orbit.dtu.dk/en/publications/optimizing-the-universal-robots-ros-driver(20dde139-7e87-4552-8658-dbf2cdaab24b).html} }

The report can be downloaded from http://orbit.dtu.dk/en/publications/optimizing-the-universal-robots-ros-driver(20dde139-7e87-4552-8658-dbf2cdaab24b).html

More Repositories

1

universal_robot

ROS-Industrial Universal Robots support (https://wiki.ros.org/universal_robot)
C++
1,082
star
2

industrial_training

ROS-Industrial Training Material
C++
422
star
3

ros_qtc_plugin

ROS Qt Creator Plug-in (https://ros-qtc-plugin.readthedocs.io)
C++
397
star
4

ros_canopen

CANopen driver framework for ROS (http://wiki.ros.org/ros_canopen)
C++
339
star
5

kuka_experimental

Experimental packages for KUKA manipulators within ROS-Industrial (http://wiki.ros.org/kuka_experimental)
C++
268
star
6

industrial_ci

Easy continuous integration repository for ROS repositories
Shell
246
star
7

robotiq

Robotiq packages (http://wiki.ros.org/robotiq)
C++
227
star
8

ros2_i_training

HTML
169
star
9

industrial_core

ROS-Industrial core communication packages (http://wiki.ros.org/industrial_core)
C++
154
star
10

fanuc

ROS-Industrial Fanuc support (http://wiki.ros.org/fanuc)
C++
153
star
11

motoman

ROS-Industrial Motoman support (http://wiki.ros.org/motoman)
C++
146
star
12

abb

ROS-Industrial ABB support (http://wiki.ros.org/abb)
C++
145
star
13

ros2_canopen

CANopen driver framework for ROS2
C++
143
star
14

yak

A library for integrating depth images into Truncated Signed Distance Fields.
C++
132
star
15

abb_experimental

Experimental packages for ABB manipulators within ROS-Industrial (http://wiki.ros.org/abb_experimental)
CMake
131
star
16

noether

Tool path planning and surface segmenter
C++
121
star
17

industrial_calibration

Contains libraries/algorithms for calibrating industrial systems
C++
120
star
18

abb_robot_driver

The new ROS driver for ABB robots
C++
100
star
19

reach

A tool that allows users to visualize and quantitatively evaluate the reach capability of a robot system for a given workpiece.
C++
94
star
20

industrial_moveit

ROS-Industrial movit meta-package (http://wiki.ros.org/industrial_moveit)
C++
93
star
21

abb_libegm

A C++ library for interfacing with ABB robot controllers supporting Externally Guided Motion (689-1)
C++
93
star
22

abb_librws

A C++ library for interfacing with ABB robot controllers supporting Robot Web Services
C++
69
star
23

robodk_postprocessors

Open-source vendor-specific post-processors/code generators from RoboDK (http://robodk.com)
Python
64
star
24

easy_perception_deployment

A ROS2 package that accelerates the training and deployment of CV models for industries.
Python
54
star
25

industrial_reconstruction

Tools for surface reconstruction from 2D depth images
Python
50
star
26

easy_manipulation_deployment

A ROS2 package that allows rapid digitization of robotic work cells and ease of efficient path-planning of manipulators.
C++
49
star
27

yak_ros

Example ROS frontend node for the Yak TSDF package
C++
48
star
28

cros

A single thread pure C implementation of the ROS framework
C
47
star
29

fanuc_experimental

Experimental packages for Fanuc manipulators within ROS-Industrial (http://wiki.ros.org/fanuc_experimental)
CMake
45
star
30

stomp_ros

ROS packages for the STOMP planner (split out of industrial_moveit)
C++
37
star
31

robot_movement_interface

Drivers implementing the Robot Movement Interface, which allows access to robot specific capabilities in a standardized common format while maintaining compatibility with the ROS-Industrial Joint interface.
C++
36
star
32

human_tracker

Library for detecting and tracking humans using 3D sensing systems (stereo and kinect-like)
36
star
33

flexgui_industrial

Moved to: https://github.com/PPM-Robotics-AS/flexgui4.0
JavaScript
31
star
34

kuka

ROS-Industrial KUKA support (http://wiki.ros.org/kuka)
CMake
30
star
35

abb_driver

(old) ROS driver for ABB IRC5 / RW5 or RW6 controllers (Simple Message & RAPID)
AMPL
29
star
36

staubli_experimental

Experimental packages for Staubli manipulators within ROS-Industrial (http://wiki.ros.org/staubli_experimental)
CMake
27
star
37

staubli_val3_driver

ROS-Industrial (simple message) driver for StΓ€ubli CS8 and CS9 robot controllers (VAL 3 application)
TeX
26
star
38

docker

ROS-Industrial docker and cloud tools
Dockerfile
23
star
39

stomp

Stochastic Trajectory Optimization for Motion Planning (STOMP)
C++
22
star
40

reach_ros2

ROS2 packages for REACH
C++
17
star
41

staubli

ROS-Industrial Staubli support (http://wiki.ros.org/staubli)
C++
17
star
42

ros_industrial_cmake_boilerplate

CMake
16
star
43

packml_ros2

State machine based system programming, monitoring and control in ROS 2
C++
16
star
44

motoman_experimental

Experimental packages for Motoman manipulators within ROS-Industrial
C++
15
star
45

abb_robot_driver_interfaces

ROS message and service definitions for a ROS driver for ABB robots
CMake
13
star
46

rep

ROS-Industrial REPs
12
star
47

crcl

11
star
48

workcell_explorer

Repository for GSoC 2018 focusing on creation of a ROS package for Robotic Workcell exploration
CMake
11
star
49

ur_msgs

ROS messages and services for Universal Robots robot controllers.
CMake
11
star
50

industrial_calibration_tutorials

Tutorials for industrial calibration package.
CMake
11
star
51

keyence_experimental

C++
10
star
52

siemens_tutorials

C++
10
star
53

ros_industrial_meetings

Repository for tracking ROS-Industrial developers meeting minutes
9
star
54

packet-simplemessage

Wireshark Lua dissector for the ROS-Industrial SimpleMessage protocol
Lua
8
star
55

reach_ros

ROS1 Packages for REACH
C++
8
star
56

siemens_experimental

C++
8
star
57

intelligent_actuator

ROS package for serial communication with the Robo Cylinder
Python
8
star
58

swri-ros-pkg

Automatically exported from code.google.com/p/swri-ros-pkg
C++
7
star
59

abb_egm_rws_managers

A C++ library for encapsulating ROS agnostic components for a ROS driver for ABB robots
C++
6
star
60

ros2_quality_assurance_guidelines

A collection of documentation which contains detailed instructions and tutorials for improving ROS 2 package quality, following REP-2004 quality level and integrating CI into one's development workflow.
Python
6
star
61

industrial_pcl_experimental

ROS Industrial addons, utilities, and other libraries that extend or are useful with the Point Cloud Library (PCL)
C++
5
star
62

jenkins_config

Contains jenkins CI configuration scripts.
Python
4
star
63

socketcan_interface

DO NOT USE YET
C++
4
star
64

industrial_experimental

Contains experimental packages for industrial_core.
C++
3
star
65

yak_ros2

Example ROS 2 frontend node for the Yak TSDF package
C++
3
star
66

ros_industrial_issues

Repository for tracking common ROS-Industrial issuses.
3
star
67

tolomatic

C++
2
star
68

industrial_pcl

ROS-Industrial PCL Extension meta-package. http://wiki.ros.org/industrial_pcl
C++
2
star
69

rvip

A ROS package for easy integration of a hybrid 2D-3D robotic vision technique for industrial tasks.
1
star
70

robotiq_experimental

Experimental robotiq packages within ROS-Industrial
C++
1
star
71

siemens_drivers

Open source drivers for Siemens devices
1
star
72

fake_ar_publisher

C++
1
star
73

ros_profinet_experimental

1
star
74

acuity

Support for acuity laser products
Python
1
star
75

error_resolution_diagnoser

C++
1
star
76

fanuc_demos

Demos of ROS(-Industrial) functionality specifically for (simulated) Fanuc robots
1
star
77

industrial_calibration_ros2

ROS Utilities for Industrial Calibration
Python
1
star
78

epd_onnxruntime_vendor

CMake
1
star
79

error_classification_server

Python
1
star