 » Examples

Examples
This section contains examples of how to use the RTDE Control Interface the RTDE Receive
Interface and the RTDE IO Interface.

 Warning

It is your own responsibility to verify that the movements performed by these examples
are collision-free and safe to execute on the robot. When in doubt, use the simulator
provided by Universal Robots.

CMake Example
Once you have installed the ur_rtde library. You can use the cmake command find_package()
to locate the library. Here is an example of how to find the library and link it against your C++
executable.

cmake_minimum_required(VERSION 3.5)
project(ur_rtde_cmake_example)

find_package(ur_rtde REQUIRED)
add_executable(ur_rtde_cmake_example main.cpp)
target_link_libraries(ur_rtde_cmake_example PRIVATE ur_rtde::rtde)

if the library is not installed or installed to a none standard system path, use one of the
following methods:

Call CMake with -Dur_rtde_DIR=/path/to/ur_rtde

Set the path in find_package() :

find_package(ur_rtde REQUIRED PATHS “/a/possible/path/to/ur_rtde”

“/another/possible/path/to/ur_rtde”)

The path to ur_rtde is the one where ur_rtdeTargets.cmake can be found. For a none install it
should be /path/to/ur_rtde/Build/ur_rtde . For an install it is /path/to/lib/cmake/ur_rtde .

Basic use
Simple example using the RTDE Control Interface to move the robot to a pose with the
moveL command.
C++:

// The constructor simply takes the IP address of the Robot

RTDEControlInterface rtde_control("127.0.0.1");
// First argument is the pose 6d vector followed by speed and acceleration
rtde_control.moveL({-0.143, -0.435, 0.20, -0.001, 3.12, 0.04}, 0.5, 0.2);

Python:

import rtde_control
rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")
rtde_c.moveL([-0.143, -0.435, 0.20, -0.001, 3.12, 0.04], 0.5, 0.3)

Simple example using the RTDE Receive Interface to get the joint positions of the robot

C++:

/* The constructor takes the IP address of the robot, by default all variables are
* transmitted. Optionally only a subset of variables, specified by a vector, are transmitted.
*/
RTDEReceiveInterface rtde_receive("127.0.0.1");
std::vector<double> joint_positions = rtde_receive.getActualQ();

Python:

import rtde_receive
rtde_r = rtde_receive.RTDEReceiveInterface("127.0.0.1")
actual_q = rtde_r.getActualQ()

Simple example using the RTDE IO Interface to set a standard digital output.

C++:

// The constructor simply takes the IP address of the Robot

RTDEIOInterface rtde_io("127.0.0.1");
rtde_io.setStandardDigitalOut(7, true);

Python:
 import rtde_io
rtde_io = rtde_io.RTDEIOInterface("127.0.0.1")
rtde_io.setStandardDigitalOut(7, True)

 Note

When using an e-Series robot data will be received at the maximum available frequency
(500Hz), for a CB3 robot the frequency will be (125Hz).

Use with ExternalControl UR Cap

ur_rtde can be used together with UR’s ExternalControl UR Cap which is also used for the
Universal Robot’s ROS driver.

You can download the UR Cap from here.

To install it on your robot, please follow the instructions:

Installing a URCap on a e-Series robot (for an e-series robot)

or

Installing a URCap on a CB3 robot (for a CB-series robot).

In order to setup ur_rtde for using the ExternalControl UR Cap, all you have to do is to
specify this in the RTDEControlInterface constructor with the flag FLAG_USE_EXT_UR_CAP.

 Tip

Remember you can combine flags in the constructor using the bitwise OR operator both
in Python (eg. RTDEControl.FLAG_VERBOSE | RTDEControl.FLAG_USE_EXT_UR_CAP)
and in C++ (eg. RTDEControlInterface::FLAG_NO_WAIT |
RTDEControlInterface::FLAG_USE_EXT_UR_CAP)

for Python:

from rtde_control import RTDEControlInterface as RTDEControl

rtde_frequency = 500.0
rtde_c = RTDEControl("127.0.0.1", rtde_frequency, RTDEControl.FLAG_USE_EXT_UR_CAP)
rtde_c.moveL([-0.143, -0.435, 0.20, -0.001, 3.12, 0.04], 0.5, 0.3)

for C++:
 RTDEControlInterface rtde_control("127.0.0.1", 500.0,
RTDEControlInterface::FLAG_USE_EXT_UR_CAP);
rtde_control.moveL({-0.143, -0.435, 0.20, -0.001, 3.12, 0.04}, 0.5, 0.2);

When you execute your ur_rtde application it will simply wait for you to press play on the
controller in order to start, unless you use the FLAG_NO_WAIT, in which case the interface
will be initialized, but cannot be used before the program is running on the controller. The
port used for communicating with the UR Cap defaults to 50002 if this does not suit your
application it can be changed in the constructor of the RTDEControlInterface right after the
flags. eg. RTDEControl(“127.0.0.1”, RTDEControl.FLAG_USE_EXT_UR_CAP, <SOME PORT>).

 Note

You must have the ExternalControl node as a part of the program and it must be setup
with the correct IP of the computer that you want to control the robot from. This can be
changed under: (Installation tab -> URCaps -> ExternalControl).

Use with custom script

The rtde control script is uploaded to the robot by default. However if you want to modify
the script and execute it as a part of a program on the controller, you have the option of not
uploading the default rtde control script. This means that ur_rtde expects a script to be
running on the controller that you have set up manually eg. copied to the controller from USB
or scp over the network.

What you can do, is to split the rtde_control script into two separate scripts: rtde_init.script
and rtde_control.script. where rtde_init.script contains the header and rtde_control.script
contains the control loop. You then create a new program in Polyscope and add a BeforeStart
sequence to this new program. Simply add the rtde_init.script to the BeforeStart sequence
and the rtde_control.script to the Robot Program. See picture below:
Remember! that if you copy the rtde_control.script, please remove the $MAJOR.MINOR tags,
that is used for removing lines that are not compatible with specific controller versions. Also
set the appropriate offset for reg_offset_float and reg_offset_int either 0 or 24.

The benefit of the approach is that you have access to any functionality installed on the robot
such as functions from a gripper UR cap etc. (the same is true, when using the
ExternalControl UR Cap). You must simply specify that you want to use a custom script in the
RTDEControlInterface constructor with the FLAG_CUSTOM_SCRIPT:

for Python:

from rtde_control import RTDEControlInterface as RTDEControl

rtde_c = RTDEControl("127.0.0.1", RTDEControl.FLAG_CUSTOM_SCRIPT)
rtde_c.moveL([-0.143, -0.435, 0.20, -0.001, 3.12, 0.04], 0.5, 0.3)

for C++:

RTDEControlInterface rtde_control("127.0.0.1", RTDEControlInterface::FLAG_CUSTOM_SCRIPT);

rtde_control.moveL({-0.143, -0.435, 0.20, -0.001, 3.12, 0.04}, 0.5, 0.2);

When you execute your ur_rtde application it will simply wait for you to press play on the
controller in order to start, unless you use the FLAG_NO_WAIT, in which case the interface
will be initialized, but cannot be used before the program is running on the controller. Finally
make sure the robot is in remote control.
Record Data Example
This example shows how to record the robot data to a (.csv) file of your choice. You can set
the frequency at which the data is recorded. Optionally, you can decide to only record a
subset of the available robot data. You do this by passing a std::vector<std::string> to
startFileRecording() that contains the names of the variables that you want to record. eg.

...
std::vector<std::string> record_variables = {"timestamp", "actual_q", "actual_TCP_pose"};
rtde_receive.startFileRecording("robot_data.csv", record_variables);
...

by default all variables are recorded, and you are not required to pass the variables argument.

C++:
#include <ur_rtde/rtde_receive_interface.h>
#include <boost/program_options.hpp>
#include <thread>
#include <chrono>
#include <csignal>
#include <string>
#include <iostream>

using namespace ur_rtde;

using namespace std::chrono;
namespace po = boost::program_options;

// Interrupt flag
bool flag_loop = true;
void raiseFlag(int param)
{
flag_loop = false;
}

int main(int argc, char* argv[])

{
try {
po::options_description desc("Allowed options");
desc.add_options()
("help", "Record robot data to a (.csv) file")
("robot_ip", po::value<std::string>()->default_value("localhost"),
"the IP address of the robot")
("frequency", po::value<double>()->default_value(500.0),
"the frequency at which the data is recorded (default is 500Hz)")
("output", po::value<std::string>()->default_value("robot_data.csv"),
"data output (.csv) file to write to (default is \"robot_data.csv\"")
;

po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);

if (vm.count("help")) {
std::cout << desc << "\n";
return 0;
}

signal(SIGINT, raiseFlag);
double frequency = vm["frequency"].as<double>();
double dt = 1.0 / frequency;
RTDEReceiveInterface rtde_receive(vm["robot_ip"].as<std::string>(), frequency);

rtde_receive.startFileRecording(vm["output"].as<std::string>());
std::cout << "Data recording started. press [Ctrl-C] to end recording." << std::endl;
int i=0;
while (flag_loop)
{
auto t_start = steady_clock::now();
if (i % 10 == 0)
{
std::cout << '\r';
printf("%.3d samples.", i);
std::cout << std::flush;
}
auto t_stop = steady_clock::now();
auto t_duration = std::chrono::duration<double>(t_stop - t_start);
if (t_duration.count() < dt)
{
 std::this_thread::sleep_for(std::chrono::duration<double>(dt - t_duration.count()));
}
i++;
}

// Stop data recording.

rtde_receive.stopFileRecording();
std::cout << "\nData recording stopped." << std::endl;
}
catch(std::exception& e) {
std::cerr << "error: " << e.what() << "\n";
return 1;
}
catch(...) {
std::cerr << "Exception of unknown type!\n";
}
return 0;
}

Python:
from rtde_receive import RTDEReceiveInterface as RTDEReceive
import time
import argparse
import sys

def parse_args(args):
"""Parse command line parameters

Args:
args ([str]): command line parameters as list of strings

Returns:
:obj:`argparse.Namespace`: command line parameters namespace
"""
parser = argparse.ArgumentParser(
description="Record data example")
parser.add_argument(
"-ip",
"--robot_ip",
dest="ip",
help="IP address of the UR robot",
type=str,
default='localhost',
metavar="<IP address of the UR robot>")
parser.add_argument(
"-o",
"--output",
dest="output",
help="data output (.csv) file to write to (default is \"robot_data.csv\"",
type=str,
default="robot_data.csv",
metavar="<data output file>")
parser.add_argument(
"-f",
"--frequency",
dest="frequency",
help="the frequency at which the data is recorded (default is 500Hz)",
type=float,
default=500.0,
metavar="<frequency>")

return parser.parse_args(args)

def main(args):
"""Main entry point allowing external calls

Args:
args ([str]): command line parameter list
"""
args = parse_args(args)
dt = 1 / args.frequency
rtde_r = RTDEReceive(args.ip, args.frequency)
rtde_r.startFileRecording(args.output)
print("Data recording started, press [Ctrl-C] to end recording.")
i = 0
try:
while True:
start = time.time()
if i % 10 == 0:
sys.stdout.write("\r")
sys.stdout.write("{:3d} samples.".format(i))
 sys.stdout.flush()
end = time.time()
duration = end - start

if duration < dt:

time.sleep(dt - duration)
i += 1

except KeyboardInterrupt:
rtde_r.stopFileRecording()
print("\nData recording stopped.")

if __name__ == "__main__":
main(sys.argv[1:])

You can find the source code of this example under examples/cpp/record_data_example.cpp , if
you compiled ur_rtde with examples you can run this example from the bin folder. If you want
to run the python example navigate to examples/py/ and run python3 record_data_example.py .

Move Asynchronous Example

This example will perform two asynchronous movements, first one by moveJ, followed by a
movement with moveL. Both movements are stopped before reaching the targets with stopJ
and stopL respectively.

C++:
 #include <ur_rtde/rtde_control_interface.h>
#include <ur_rtde/rtde_receive_interface.h>

#include <thread>
#include <chrono>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");
RTDEReceiveInterface rtde_receive("127.0.0.1");
std::vector<double> init_q = rtde_receive.getActualQ();

// Target in the robot base

std::vector<double> new_q = init_q;
new_q[0] += 0.2;

/**
* Move asynchronously in joint space to new_q, we specify asynchronous behavior by setting
the async parameter to
* 'true'. Try to set the async parameter to 'false' to observe a default synchronous
movement, which cannot be
* stopped by the stopJ function due to the blocking behaviour.
*/
rtde_control.moveJ(new_q, 1.05, 1.4, true);
std::this_thread::sleep_for(std::chrono::milliseconds(200));
// Stop the movement before it reaches new_q
rtde_control.stopJ(0.5);

// Target 10 cm up in the Z-Axis of the TCP

std::vector<double> target = rtde_receive.getActualTCPPose();
target[2] += 0.10;

/**
* Move asynchronously in cartesian space to target, we specify asynchronous behavior by
setting the async parameter
* to 'true'. Try to set the async parameter to 'false' to observe a default synchronous
movement, which cannot be
* stopped by the stopL function due to the blocking behaviour.
*/
rtde_control.moveL(target, 0.25, 0.5, true);
std::this_thread::sleep_for(std::chrono::milliseconds(200));
// Stop the movement before it reaches target
rtde_control.stopL(0.5);

// Move to initial joint position with a regular moveJ

rtde_control.moveJ(init_q);

// Stop the RTDE control script

rtde_control.stopScript();
return 0;
}

Python:
 import rtde_control
import rtde_receive
import time

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")
rtde_r = rtde_receive.RTDEReceiveInterface("127.0.0.1")
init_q = rtde_r.getActualQ()

# Target in the robot base

new_q = init_q[:]
new_q[0] += 0.20

# Move asynchronously in joint space to new_q, we specify asynchronous behavior by setting the
async parameter to
# 'True'. Try to set the async parameter to 'False' to observe a default synchronous movement,
which cannot be stopped
# by the stopJ function due to the blocking behaviour.
rtde_c.moveJ(new_q, 1.05, 1.4, True)
time.sleep(0.2)
# Stop the movement before it reaches new_q
rtde_c.stopJ(0.5)

# Target in the Z-Axis of the TCP

target = rtde_r.getActualTCPPose()
target[2] += 0.10

# Move asynchronously in cartesian space to target, we specify asynchronous behavior by setting

the async parameter to
# 'True'. Try to set the async parameter to 'False' to observe a default synchronous movement,
which cannot be stopped
# by the stopL function due to the blocking behaviour.
rtde_c.moveL(target, 0.25, 0.5, True)
time.sleep(0.2)
# Stop the movement before it reaches target
rtde_c.stopL(0.5)

# Move back to initial joint configuration

rtde_c.moveJ(init_q)

# Stop the RTDE control script

rtde_c.stopScript()

You can find the source code of this example under examples/cpp/move_async_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 move_async_example.py .

Move Until Contact 

This example will move the robot down in the Z-axis with a speed of 100mm/s until contact
is detected. The robot is automatically moved back to the initial point of contact. You can
specify the speed vector as well as a direction to check for contacts in, see the API for further
details.

You can find the source code of this example under examples/cpp/move_until_contact.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 move_until_contact.py .
C++:

#include <ur_rtde/rtde_control_interface.h>
#include <thread>
#include <chrono>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

// Parameters
std::vector<double> speed = {0, 0, -0.100, 0, 0, 0};
rtde_control.moveUntilContact
moveUnti (speed);
rtde_control.stopScript();
return 0;
}

Python:

import rtde_control

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")
speed = [0, 0, -0.100, 0, 0, 0]
rtde_c.moveUntilContact
moveUnti (speed)

rtde_c.stopScript()

Forcemode Example
This example will start moving the robot downwards with -10N in the z-axis for 2 seconds,
followed by a move upwards with 10N in the z-axis for 2 seconds.

You can find the source code of this example under examples/cpp/forcemode_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 forcemode_example.py .

C++:
 #include <ur_rtde/rtde_control_interface.h>
#include <thread>
#include <chrono>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

// Parameters
std::vector<double> task_frame = {0, 0, 0, 0, 0, 0};
std::vector<int> selection_vector = {0, 0, 1, 0, 0, 0};
std::vector<double> wrench_down = {0, 0, -10, 0, 0, 0};
std::vector<double> wrench_up = {0, 0, 10, 0, 0, 0};
int force_type = 2;
double dt = 1.0/500; // 2ms
std::vector<double> limits = {2, 2, 1.5, 1, 1, 1};
std::vector<double> joint_q = {-1.54, -1.83, -2.28, -0.59, 1.60, 0.023};

// Move to initial joint position with a regular moveJ

rtde_control.moveJ(joint_q);

// Execute 500Hz control loop for a total of 4 seconds, each cycle is ~2ms
for (unsigned int i=0; i<2000; i++)
{
steady_clock::time_point t_start = rtde_control.initPeriod();
// First we move the robot down for 2 seconds, then up for 2 seconds
if (i > 1000)
rtde_control.forceMode(task_frame, selection_vector, wrench_up, force_type, limits);
else
rtde_control.forceMode(task_frame, selection_vector, wrench_down, force_type, limits);
rtde_control.waitPeriod(t_start);
}

rtde_control.forceModeStop();
rtde_control.stopScript();

return 0;
}

Python:
 import rtde_control

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")

task_frame = [0, 0, 0, 0, 0, 0]
selection_vector = [0, 0, 1, 0, 0, 0]
wrench_down = [0, 0, -10, 0, 0, 0]
wrench_up = [0, 0, 10, 0, 0, 0]
force_type = 2
limits = [2, 2, 1.5, 1, 1, 1]
dt = 1.0/500 # 2ms
joint_q = [-1.54, -1.83, -2.28, -0.59, 1.60, 0.023]

# Move to initial joint position with a regular moveJ

rtde_c.moveJ(joint_q)

# Execute 500Hz control loop for 4 seconds, each cycle is 2ms

for i in range(2000):
t_start = rtde_c.initPeriod()
# First move the robot down for 2 seconds, then up for 2 seconds
if i > 1000:
rtde_c.forceMode(task_frame, selection_vector, wrench_up, force_type, limits)
else:
rtde_c.forceMode(task_frame, selection_vector, wrench_down, force_type, limits)
rtde_c.waitPeriod(t_start)

rtde_c.forceModeStop()
rtde_c.stopScript()

Intended movement:

ServoJ Example
This example will use the servoJ command to move the robot, where incremental changes are
made to the base and shoulder joint continuously in a 500Hz control loop for 2 seconds.
You can find the source code of this example under examples/cpp/servoj_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 servoj_example.py .

C++:

#include <ur_rtde/rtde_control_interface.h>
#include <thread>
#include <chrono>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

// Parameters
double velocity = 0.5;
double acceleration = 0.5;
double dt = 1.0/500; // 2ms
double lookahead_time = 0.1;
double gain = 300;
std::vector<double> joint_q = {-1.54, -1.83, -2.28, -0.59, 1.60, 0.023};

// Move to initial joint position with a regular moveJ

rtde_control.moveJ(joint_q);

// Execute 500Hz control loop for 2 seconds, each cycle is ~2ms

for (unsigned int i=0; i<1000; i++)
{
steady_clock::time_point t_start = rtde_control.initPeriod();
rtde_control.servoJ(joint_q, velocity, acceleration, dt, lookahead_time, gain);
joint_q[0] += 0.001;
joint_q[1] += 0.001;
rtde_control.waitPeriod(t_start);
}

rtde_control.servoStop();
rtde_control.stopScript();

return 0;
}

Python:
 import rtde_control

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")

# Parameters
velocity = 0.5
acceleration = 0.5
dt = 1.0/500 # 2ms
lookahead_time = 0.1
gain = 300
joint_q = [-1.54, -1.83, -2.28, -0.59, 1.60, 0.023]

# Move to initial joint position with a regular moveJ

rtde_c.moveJ(joint_q)

# Execute 500Hz control loop for 2 seconds, each cycle is 2ms

for i in range(1000):
t_start = rtde_c.initPeriod()
rtde_c.servoJ(joint_q, velocity, acceleration, dt, lookahead_time, gain)
joint_q[0] += 0.001
joint_q[1] += 0.001
rtde_c.waitPeriod(t_start)

rtde_c.servoStop()
rtde_c.stopScript()

 Note

Remember that to allow for a fast control rate when servoing, the joint positions must be
close to each other e.g. (dense trajectory). If the robot is not reaching the target fast
enough try to increase the acceleration or the gain parameter.

Intended movement:
SpeedJ Example
This example will use the speedJ command to move the robot, where the first 2 joints are
speeding continuously in a 500Hz control loop for 2 seconds.

You can find the source code of this example under examples/cpp/speedj_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 speedj_example.py .

C++:

#include <ur_rtde/rtde_control_interface.h>
#include <thread>
#include <chrono>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

// Parameters
double acceleration = 0.5;
double dt = 1.0/500; // 2ms
std::vector<double> joint_q = {-1.54, -1.83, -2.28, -0.59, 1.60, 0.023};
std::vector<double> joint_speed = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

// Move to initial joint position with a regular moveJ

rtde_control.moveJ(joint_q);

// Execute 500Hz control loop for 2 seconds, each cycle is ~2ms

for (unsigned int i=0; i<1000; i++)
{
steady_clock::time_point t_start = rtde_control.initPeriod();
rtde_control.speedJ(joint_speed, acceleration, dt);
joint_speed[0] += 0.0005;
joint_speed[1] += 0.0005;
rtde_control.waitPeriod(t_start);
}

rtde_control.speedStop();
rtde_control.stopScript();

return 0;
}

Python:
 import rtde_control

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")

# Parameters
acceleration = 0.5
dt = 1.0/500 # 2ms
joint_q = [-1.54, -1.83, -2.28, -0.59, 1.60, 0.023]
joint_speed = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

# Move to initial joint position with a regular moveJ

rtde_c.moveJ(joint_q)

# Execute 500Hz control loop for 2 seconds, each cycle is 2ms

for i in range(1000):
t_start = rtde_c.initPeriod()
rtde_c.speedJ(joint_speed, acceleration, dt)
joint_speed[0] += 0.0005
joint_speed[1] += 0.0005
rtde_c.waitPeriod(t_start)

rtde_c.speedStop()
rtde_c.stopScript()

Intended movement:

MoveL Path With Blending Example

This example will use the moveL command with a path, where each joint pose in the path has
a defined velocity, acceleration and blend. The joint poses in the path are defined by a 9-
dimensional vector, where the first six values constitutes the joint pose, followed by the last
three values velocity, acceleration and blend.

You can find the source code of this example under

examples/cpp/movel_path_with_blend_example.cpp , if you compiled ur_rtde with examples you can

run this example from the bin folder. If you want to run the python example navigate to
examples/py/ and run python3 movel_path_with_blend_example.py .

C++:

#include <ur_rtde/rtde_control_interface.h>

using namespace ur_rtde;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

double velocity = 0.5;

double acceleration = 0.5;
double blend_1 = 0.0;
double blend_2 = 0.02;
double blend_3 = 0.0;
std::vector<double> path_pose1 = {-0.143, -0.435, 0.20, -0.001, 3.12, 0.04, velocity,
acceleration, blend_1};
std::vector<double> path_pose2 = {-0.143, -0.51, 0.21, -0.001, 3.12, 0.04, velocity,
acceleration, blend_2};
std::vector<double> path_pose3 = {-0.32, -0.61, 0.31, -0.001, 3.12, 0.04, velocity,
acceleration, blend_3};

std::vector<std::vector<double>> path;
path.push_back(path_pose1);
path.push_back(path_pose2);
path.push_back(path_pose3);

// Send a linear path with blending in between - (currently uses separate script)
rtde_control.moveL(path);
rtde_control.stopScript();

return 0;
}

Python:

import rtde_control

rtde_c = rtde_control.RTDEControlInterface("127.0.0.1")

velocity = 0.5
acceleration = 0.5
blend_1 = 0.0
blend_2 = 0.02
blend_3 = 0.0
path_pose1 = [-0.143, -0.435, 0.20, -0.001, 3.12, 0.04, velocity, acceleration, blend_1]
path_pose2 = [-0.143, -0.51, 0.21, -0.001, 3.12, 0.04, velocity, acceleration, blend_2]
path_pose3 = [-0.32, -0.61, 0.31, -0.001, 3.12, 0.04, velocity, acceleration, blend_3]
path = [path_pose1, path_pose2, path_pose3]

# Send a linear path with blending in between - (currently uses separate script)
rtde_c.moveL(path)
rtde_c.stopScript()
Intended movement:

IO Example
This example will print out the state of a standard digital output, change the state of that
output and print the state again. Furthermore it will set the current ratio of an analog output.

You can find the source code of this example under examples/cpp/io_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder. If you want to
run the python example navigate to examples/py/ and run python3 io_example.py .

C++:
 #include <ur_rtde/rtde_io_interface.h>
#include <ur_rtde/rtde_receive_interface.h>
#include <iostream>
#include <thread>

using namespace ur_rtde;

int main(int argc, char* argv[])

{
RTDEIOInterface rtde_io("127.0.0.1");
RTDEReceiveInterface rtde_receive("127.0.0.1");

/** How-to set and get standard and tool digital outputs. Notice that we need the
* RTDEIOInterface for setting an output and RTDEReceiveInterface for getting the state
* of an output.
*/

if (rtde_receive.getDigitalOutState(7))
std::cout << "Standard digital out (7) is HIGH" << std::endl;
else
std::cout << "Standard digital out (7) is LOW" << std::endl;

if (rtde_receive.getDigitalOutState(16))
std::cout << "Tool digital out (16) is HIGH" << std::endl;
else
std::cout << "Tool digital out (16) is LOW" << std::endl;

rtde_io.setStandardDigitalOut(7, true);
rtde_io.setToolDigitalOut(0, true);
std::this_thread::sleep_for(std::chrono::milliseconds(10));

if (rtde_receive.getDigitalOutState(7))
std::cout << "Standard digital out (7) is HIGH" << std::endl;
else
std::cout << "Standard digital out (7) is LOW" << std::endl;

if (rtde_receive.getDigitalOutState(16))
std::cout << "Tool digital out (16) is HIGH" << std::endl;
else
std::cout << "Tool digital out (16) is LOW" << std::endl;

// How to set a analog output with a specified current ratio

rtde_io.setAnalogOutputCurrent(1, 0.25);

return 0;
}

Python:
 import rtde_io
import rtde_receive
import time

rtde_io_ = rtde_io.RTDEIOInterface("127.0.0.1")
rtde_receive_ = rtde_receive.RTDEReceiveInterface("127.0.0.1")

# How-to set and get standard and tool digital outputs. Notice that we need the
# RTDEIOInterface for setting an output and RTDEReceiveInterface for getting the state
# of an output.

if rtde_receive_.getDigitalOutState(7):
print("Standard digital out (7) is HIGH")
else:
print("Standard digital out (7) is LOW")

if rtde_receive_.getDigitalOutState(16):
print("Tool digital out (16) is HIGH")
else:
print("Tool digital out (16) is LOW")

rtde_io_.setStandardDigitalOut(7, True)
rtde_io_.setToolDigitalOut(0, True)
time.sleep(0.01)

if rtde_receive_.getDigitalOutState(7):
print("Standard digital out (7) is HIGH")
else:
print("Standard digital out (7) is LOW")

if rtde_receive_.getDigitalOutState(16):
print("Tool digital out (16) is HIGH")
else:
print("Tool digital out (16) is LOW")

# How to set a analog output with a specified current ratio

rtde_io_.setAnalogOutputCurrent(1, 0.25)

Robotiq Gripper Example

This example demonstrates the use of the RobotiqGripper interface. See the API here:
Robotiq Gripper API

You can find the source code of this example under examples/cpp/robotiq_gripper_example.cpp ,
if you compiled ur_rtde with examples you can run this example from the bin folder.

C++:
#include <ur_rtde/robotiq_gripper.h>
#include <chrono>
#include <iostream>
#include <thread>

using namespace std;

using namespace ur_rtde;

/**
* Print object detection status of gripper
*/
void printStatus(int Status)
{
switch (Status)
{
case RobotiqGripper::MOVING:
std::cout << "moving";
break;
case RobotiqGripper::STOPPED_OUTER_OBJECT:
std::cout << "outer object detected";
break;
case RobotiqGripper::STOPPED_INNER_OBJECT:
std::cout << "inner object detected";
break;
case RobotiqGripper::AT_DEST:
std::cout << "at destination";
break;
}

std::cout << std::endl;

}

int main(int argc, char* argv[])

{
std::cout << "Gripper test" << std::endl;
ur_rtde::RobotiqGripper gripper("127.0.0.1", 63352, true);
gripper.connect();

// Test emergency release functionality

if (!gripper.isActive())
{
gripper.emergencyRelease(RobotiqGripper::OPEN);
}
std::cout << "Fault status: 0x" << std::hex << gripper.faultStatus() << std::dec <<
std::endl;
std::cout << "activating gripper" << std::endl;
gripper.activate();

// Test setting of position units and conversion of position values

gripper.setUnit(RobotiqGripper::POSITION, RobotiqGripper::UNIT_DEVICE);
std::cout << "OpenPosition: " << gripper.getOpenPosition() << " ClosedPosition: " <<
gripper.getClosedPosition()
<< std::endl;
gripper.setUnit(RobotiqGripper::POSITION, RobotiqGripper::UNIT_NORMALIZED);
std::cout << "OpenPosition: " << gripper.getOpenPosition() << " ClosedPosition: " <<
gripper.getClosedPosition()
<< std::endl;

// Test of move functionality with normalized values (0.0 - 1.0)

int status = gripper.move(1, 1, 0, RobotiqGripper::WAIT_FINISHED);
printStatus(status);
status = gripper.move(0, 1, 0, RobotiqGripper::WAIT_FINISHED);
printStatus(status);
 // We preset force and and speed so we don't need to pass it to the following move functions
gripper.setForce(0.0);
gripper.setSpeed(0.5);

// We switch the position unit the mm and define the position range of our gripper
gripper.setUnit(RobotiqGripper::POSITION, RobotiqGripper::UNIT_MM);
gripper.setPositionRange_mm(10, 50);
std::cout << "OpenPosition: " << gripper.getOpenPosition() << " ClosedPosition: " <<
gripper.getClosedPosition()
<< std::endl;
gripper.move(50);
status = gripper.waitForMotionComplete();
printStatus(status);

gripper.move(10);
status = gripper.waitForMotionComplete();
printStatus(status);

std::cout << "moving to open position" << std::endl;

status = gripper.open();
status = gripper.waitForMotionComplete();
printStatus(status);

// Test async move - start move and then wait for completion
gripper.close(0.02, 0, RobotiqGripper::START_MOVE);
status = gripper.waitForMotionComplete();
printStatus(status);

status = gripper.open(1.0, 0.0, RobotiqGripper::WAIT_FINISHED);

printStatus(status);

gripper.setUnit(RobotiqGripper::POSITION, RobotiqGripper::UNIT_DEVICE);
gripper.setUnit(RobotiqGripper::SPEED, RobotiqGripper::UNIT_DEVICE);
gripper.setUnit(RobotiqGripper::FORCE, RobotiqGripper::UNIT_DEVICE);

std::cout << "OpenPosition: " << gripper.getOpenPosition() << " ClosedPosition: " <<
gripper.getClosedPosition()
<< std::endl;

gripper.move(255, 5, 0);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
while (RobotiqGripper::MOVING == gripper.objectDetectionStatus())
{
std::cout << "waiting..." << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
printStatus(gripper.objectDetectionStatus());

std::cout << "disconnecting" << std::endl;

gripper.disconnect();
}

Jog Example
This example shows how you can use the jogStart() function of the RTDEControlInterface to
jog the robot in the tool frame, using the arrows on your keyboard.
You can find the source code of this example under examples/cpp/jog_example.cpp , if you
compiled ur_rtde with examples you can run this example from the bin folder.

C++:
#include <ur_rtde/rtde_control_interface.h>
#include <ncurses.h>
#include <chrono>
#include <iostream>
#include <thread>

using namespace ur_rtde;

using namespace std::chrono;

int main(int argc, char* argv[])

{
RTDEControlInterface rtde_control("127.0.0.1");

// Curses Initialisations
initscr();
raw();
keypad(stdscr, TRUE);
noecho();
timeout(10);

// Parameters
double speed_magnitude = 0.15;
std::vector<double> speed_vector = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);

std::string instructions("[ Use arrow keys to control the robot, to exit press 'q' ]");
int c, row, col;
getmaxyx(stdscr, row, col);
mvprintw(row / 2, (col-strlen(instructions.c_str())) / 2, "%s", instructions.c_str());

while ((c = getch()) != 'q')

{
steady_clock::time_point t_start = rtde_control.initPeriod();
c = getch();
switch (c)
{
case KEY_UP:
speed_vector = {0.0, 0.0, -speed_magnitude, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);
break;
case KEY_DOWN:
speed_vector = {0.0, 0.0, speed_magnitude, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);
break;
case KEY_LEFT:
speed_vector = {speed_magnitude, 0.0, 0.0, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);
break;
case KEY_RIGHT:
speed_vector = {-speed_magnitude, 0.0, 0.0, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);
break;
default:
speed_vector = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
rtde_control.jogStart(speed_vector, RTDEControlInterface::FEATURE_TOOL);
break;
}
rtde_control.waitPeriod(t_start);
}

endwin();
rtde_control.jogStop();
rtde_control.stopScript();
 return 0;
}

 Note

This example only works on Linux / UNIX at the moment, since it requires ncurses for
registering key presses. It can fairly easy be adjusted to work for Windows, just use the
conio.h header instead of ncurses.