ROS Index
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | boost |
| Last Updated | 2022-10-10 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 0.4.0 |
README
Universal Robots Client Library
- Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
Requirements
- Polyscope (The software running on the robot controller) version 3.12.0 (for CB3-Series), or 5.5.1 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
-
The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library. For the C++17 features, please use those minimum compiler versions:
Compiler min. version GCC 7 Clang 7
Build instructions
Plain cmake
To build this library standalone so that you can build you own applications using this library, follow the usual cmake procedure:
cd <clone of this repository>
mkdir build && cd build
cmake ..
make
sudo make install
This will install the library into your system so that it can be used by other cmake projects directly.
Inside a ROS workspace
If you want to build this library inside a ROS workspace, e.g. because you want to build the
Universal Robots ROS driver from
source, you cannot use catkin_make directly, as this library is not a catkin package. Instead, you
will have to use
catkin_make_isolated or catkin
build to build your
workspace.
Use this library in other projects
When you want to use this library in other cmake projects, make sure to
- Add
find_package(ur_client_library REQUIRED)to yourCMakeLists.txt - add
ur_client_library::urclto the list oftarget_link_libraries(...)commands inside your CMakeLists.txt file
As a minimal example, take the following “project”:
```c++ /main.cpp/
#include
int main(int argc, char* argv[]) { urcl::DashboardClient my_client(“192.168.56.101”); bool connected = my_client.connect(); if (connected) { std::string answer = my_client.sendAndReceive(“PolyscopeVersion\n”); std::cout « answer « std::endl;
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/UniversalRobots/Universal_Robots_Client_Library.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-13 |
| Dev Status | DEVELOPED |
| CI status | No Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
| Name | Version |
|---|---|
| ur_client_library | 2.0.0 |
README
Universal Robots Client Library
A C++ library for accessing Universal Robots interfaces. With this library C++-based drivers can be implemented in order to create external applications leveraging the versatility of Universal Robots robotic manipulators.
The library has no external dependencies besides the standard C++ libraries such as ROS, or boost to make it easy to integrate and maintain. It also serves as the foundation for the ROS and ROS 2 drivers.
Requirements
- Polyscope (The software running on the robot controller) version 3.14.3 (for CB3-Series), or 5.9.4 (for e-Series) or higher. If you use an older Polyscope version it is suggested to update your robot. If for some reason (please tell us in the issues why) you cannot upgrade your robot, please see the version compatibility table for a compatible tag.
- The library requires an implementation of POSIX threads such as the
pthreadlibrary - Socket communication is currently based on Linux sockets. Thus, this library will require Linux for building and using.
- The master branch of this repository requires a C++17-compatible compiler. For building this library without a C++17-requirement, please use the boost branch instead that requires the boost library.
Build instructions
License
The majority of this library is licensed under the Apache-2.0 licensed. However, certain parts are licensed under different licenses:
- The queue used inside the communication structures is originally written by Cameron Desrochers and is released under the BSD-2-Clause license.
- The semaphore implementation used inside the queue implementation is written by Jeff Preshing and licensed under the zlib license
While the main LICENSE file in this repository contains the Apache-2.0 license used for the
majority of the work, the respective libraries of third-party components reside together with the
code imported from those third parties.
Library contents
Currently, this library contains the following components:
- Basic primary interface: The primary interface isn’t fully implemented at the current state and provides only basic functionality. See A word on the primary / secondary interface for further information about the primary interface.
- RTDE interface: The RTDE interface is fully supported by this library. See RTDEClient for further information on how to use this library as an RTDE client.
- Dashboard interface: The Dashboard server can be accessed directly from C++ through helper functions using this library.
- Custom motion streaming: This library was initially developed as part of the Universal Robots ROS driver. Therefore, it also contains a mechanism to do data streaming through a custom socket, e.g. to perform motion command streaming.
Example driver
In the examples subfolder you will find a minimal example of a running driver. It starts an
instance of the UrDriver class and prints the RTDE values read from the controller. To run it make
sure to
- have an instance of a robot controller / URSim running at the configured IP address (or adapt the address to your needs)
- run it from the package’s main folder (the one where this README.md file is stored), as for simplicity reasons it doesn’t use any sophisticated method to locate the required files.
Architecture
See Architecture documentation
A word on the primary / secondary interface
Currently, this library doesn’t support the primary interface very well, as the Universal Robots
ROS driver was built mainly upon
the RTDE interface. The PrimaryClient for directly accessing the primary
interface doesn’t support all features of the primary interface.
The comm::URStream class can be used to open a connection to the primary / secondary interface
and send data to it. The producer/consumer pipeline structure
can also be used together with the primary / secondary interface. However, package parsing isn’t
implemented for most packages currently. See the primary_pipeline
example on details how to set this up. Note that when running this
example, most packages will just be printed as their raw byte streams in a hex notation, as they
aren’t implemented in the library, yet.
File truncated at 100 lines see the full file