# Fast-RTPS
**Repository Path**: px4/fast-rtps
## Basic Information
- **Project Name**: Fast-RTPS
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-12-01
- **Last Updated**: 2021-06-25
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# eProsima Fast DDS
[](https://www.fiware.org/developers/catalogue/)
[](https://opensource.org/licenses/Apache-2.0)
[](https://github.com/eProsima/Fast-RTPS/releases)
[](https://github.com/eProsima/Fast-RTPS/issues)
[](https://github.com/eProsima/Fast-RTPS/network/members)
[](https://github.com/eProsima/Fast-RTPS/stargazers)
[](https://eprosima-fast-rtps.readthedocs.io)
[](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_linux)
[](http://jenkins.eprosima.com:8080/view/Nightly/job/nightly_fastdds_sec_master_linux_aarch64/)
[](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_windows/label=windows-secure,platform=x64,toolset=v141)
[](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_mac)
[](http://jenkins.eprosima.com:8080/job/nightly_fastdds_coverage_linux)
*eprosima Fast DDS* (formerly Fast RTPS) is a C++ implementation of the DDS (Data Distribution Service) standard of the OMG (Object Management Group). eProsima Fast DDS implements the RTPS (Real Time Publish Subscribe) protocol, which provides publisher-subscriber communications over unreliable transports such as UDP,
as defined and maintained by the Object Management Group (OMG) consortium. RTPS is also the wire interoperability protocol defined for the Data Distribution
Service (DDS) standard. *eProsima Fast DDS* expose an API to access directly the RTPS protocol, giving the user full access to the protocol internals.
Some of the main features of this library are:
* Configurable best-effort and reliable publish-subscribe communication policies for real-time
applications.
* Plug and play connectivity so that any new applications are automatically discovered by any other
members of the network.
* Modularity and scalability to allow continuous growth with complex and simple devices in the
network.
* Configurable network behavior and interchangeable transport layer: Choose the best protocol and
system input/output channel combination for each deployment.
* Two API Layers: a high-level Publisher-Subscriber one focused on usability (DDS) and a lower-level Writer-Reader one that provides finer access to the inner workings of the RTPS protocol.
*eProsima Fast DDS* has been adopted by multiple organizations in many sectors including these important cases:
* Robotics: ROS (Robotic Operating System) as their default middleware for ROS2 until and including the
latest long term release Foxy Fitzroy.
* EU R&D: FIWARE Incubated GE.
This project is part of [FIWARE](https://www.fiware.org/). For more information check the FIWARE Catalogue entry for
[Robotics](https://github.com/Fiware/catalogue/tree/master/robotics).
## Want us to share your project with the community?
Write to evaluation.support@eprosima.com or mention @EProsima on Twitter.
We are curious to get to know your use case!
## Supported platforms
* Linux [](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_linux)
* Linux-aarch64 [](http://jenkins.eprosima.com:8080/view/Nightly/job/nightly_fastdds_sec_master_linux_aarch64/)
* Windows [](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_windows/label=windows-secure,platform=x64,toolset=v141)
* Mac [](http://jenkins.eprosima.com:8080/job/nightly_fastdds_sec_master_mac)
## Installation Guide
You can get either a binary distribution of *eprosima Fast DDS* or compile the library yourself from source.
### Installation from binaries
The latest, up to date binary release of *eprosima Fast DDS* can be obtained from the company website.
### Installation from Source
#### Dependencies
##### Asio and TinyXML2 libraries
On Linux, you can install these libraries using the package manager of your Linux distribution.
For example, on Ubuntu you can install them by using its package manager with the next command.
```bash
sudo apt install libasio-dev libtinyxml2-dev
```
On Windows, you can install these libraries using [Chocolatey](https://chocolatey.org).
First, download the following chocolatey packages from this
[ROS2 Github repository](https://github.com/ros2/choco-packages/releases/latest).
* asio.1.12.1.nupkg
* tinyxml2.6.0.0.nupkg
Once these packages are downloaded, open an administrative shell and execute the following command:
```batch
choco install -y -s asio tinyxml2
```
Please replace `` with the folder you downloaded the packages to.
#### Colcon installation
[colcon](https://colcon.readthedocs.io) is a command line tool to build sets of software packages.
This section explains to use it to compile easily Fast-RTPS and its dependencies.
First install ROS2 development tools (colcon and vcstool):
```bash
pip install -U colcon-common-extensions vcstool
```
Download the repos file that will be used to download Fast RTPS and its dependencies:
```bash
$ mkdir fastdds_ws
$ cd fastdds_ws
$ wget https://raw.githubusercontent.com/eProsima/Fast-DDS/master/fastrtps.repos
$ mkdir src
$ vcs import src < fastrtps.repos
```
Finally, use colcon to compile all software:
```bash
$ colcon build
```
#### Manual installation
Before compiling manually Fast DDS you need to clone the following dependencies and compile them using
[CMake](https://cmake.org).
* [Fast CDR](https://github.com/eProsima/Fast-CDR.git)
```bash
$ git clone https://github.com/eProsima/Fast-CDR.git
$ mkdir Fast-CDR/build && cd Fast-CDR/build
$ cmake ..
$ cmake --build . --target install
```
* [Foonathan memory](https://github.com/foonathan/memory)
```bash
$ git clone https://github.com/eProsima/foonathan_memory_vendor.git
$ cd foonathan_memory_vendor
$ mkdir build && cd build
$ cmake ..
$ cmake --build . --target install
```
Once all dependencies are installed, you will be able to compile and install Fast DDS.
```bash
$ git clone https://github.com/eProsima/Fast-DDS.git
$ mkdir Fast-DDS/build && cd Fast-DDS/build
$ cmake ..
$ cmake --build . --target install
```
## Documentation
You can access the documentation online, which is hosted on [Read the Docs](https://fast-dds.docs.eprosima.com).
* [Start Page](https://fast-dds.docs.eprosima.com)
* [Installation manual](https://fast-dds.docs.eprosima.com/en/latest/installation/binaries/binaries_linux.html)
* [User manual](https://fast-dds.docs.eprosima.com/en/latest/fastdds/getting_started/getting_started.html)
* [Fast DDS-Gen manual](https://fast-dds.docs.eprosima.com/en/latest/fastddsgen/introduction/introduction.html)
* [Release notes](https://fast-dds.docs.eprosima.com/en/latest/notes/notes.html)
## Quality Declaration
*eprosima Fast DDS* claims to be in the **Quality Level 1** category based on the guidelines provided by
[ROS 2](https://ros.org/reps/rep-2004.html).
See the [Quality Declaration](https://github.com/eProsima/Fast-DDS/blob/master/QUALITY.md) for more details.
## Quick Demo
For those who want to try a quick demonstration of *Fast DDS* libraries on Ubuntu, here is a way to launch an example
application.
First, download and install **docker** application.
Open a terminal and type the following command:
$ sudo apt-get install docker.io
Then, download the docker image files from the
[eProsima downloads website](https://eprosima.com/index.php/downloads-all).
Load the docker images:
$ docker load -i ubuntu-fast-dds:.tar
$ docker tag ubuntu-fast-rtps: ubuntu-fast-rtps:latest
$ docker load -i ubuntu-fast-dds-helloworld:.tar
$ docker load -i ubuntu-fast-dds-shapesdemo:.tar
Run the Docker container with the *eProsima Shapes Demo* application. Please refer to
[Shapes Demo documentation](https://eprosima-shapes-demo.readthedocs.io)
for further details on how to use this application.
$ xhost local:root
$ docker run -it --privileged -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix \
ubuntu-fast-dds-shapesdemo:
It is also possible to run the *Fast DDS* HelloWorld example by executing the following command:
$ docker run -it ubuntu-fast-dds-helloworld:
Run as many images as wanted and check the communication between them.
For instance, to run `Benchmark` example, run the following commands in the separate terminal sessions:
$ docker run -i ubuntu-fast-rtps /usr/local/examples/C++/Benchmark/bin/Benchmark subscriber udp
$ docker run -i ubuntu-fast-rtps /usr/local/examples/C++/Benchmark/bin/Benchmark publisher udp
## Getting Help
If you need support you can reach us by mail at `support@eProsima.com` or by phone at `+34 91 804 34 48`.
---
Supported by ROSIN - ROS-Industrial Quality-Assured Robot Software Components.
More information: rosin-project.eu
This project has received funding from the European Union’s Horizon 2020
research and innovation programme under grant agreement no. 732287.