Platform support

Safe DDS is designed to be highly portable, with support for a range of platforms and toolchains, including multiple RTOSes and bare metal environments. By default, Safe DDS provides out-of-the-box support for the set of platforms listed in Supported platforms, but it can be ported to other platforms with ease, provided that the requirements outlined in Minimum Requirements are satisfied.

Supported platforms

High portability is a key feature of Safe DDS, as it is designed for compatibility with a range of platforms, including multiple RTOSes and bare metal environments.

While out-of-the-box support is provided for a select set of platforms, porting the library to other platforms can be accomplished with ease, provided that the requirements outlined in Minimum Requirements are satisfied.

The table below summarizes Safe DDS’ supported platforms:

Platform	Architecture	Compiler	CMake version	Safety Level
Ubuntu 22.04	x86_64	GCC 12.1.0	3.5.0	None
QNX Neutrino 7.1	x86_64	QCC 8.3.0	3.5.0	ASIL D
FreeRTOS v11.1	ARM Cortex-M	ARM GCC 10.3.1	3.5.0	None
NuttX v12.6	RISC-V 32 bits	RISC-V GCC 13.2.0	3.5.0	None
Thread X v6.4.1	ARM Cortex-M	ARM GCC 10.3.1	3.5.0	None
Bare Metal	ARM Cortex-M	ARM GCC 10.3.1	3.5.0	None
Linux 6.9.9	ARM Cortex-A	Linux ARM GCC 11.4.0	3.5.0	None

The table below summarizes Safe DDS’ supplied transports:

Communication stack	Transport type	Safety Level
POSIX sockets	UDPv4	None
QNX Neutrino 7.1 sockets	UDPv4	ASIL D
FreeRTOS-Plus-TCP v3.1.0	UDPv4	None
LwIP v2.2 (Raw and Socket API)	UDPv4	None
NetX Duo v6.4.1	UDPv4	None

Portability

Safe DDS interfaces with three main elements during its deployment procedure: the platform, the transport, and the toolchain.

During the build procedure, Safe DDS’s C++ code will need to be built using a C++ compiler, which is a requirement for the library’s operation. During the execution of the library, Safe DDS will interact with the platform’s execution environment, which will provide the necessary services for the library’s operation, and with the transport, which will provide the necessary communication services.

Platform dependencies

As stated in Platform module section, Safe DDS operates with an abstraction on top of the underlaying execution platform. This way, Safe DDS will use the IPlatform interface to get access to:

• the system monotonic clock reference,

• underlaying memory allocators,

• and error handling for stopping the execution in case of a fatal error.

Note

For more details about how to customize the platform, please check the Platform module section.

For reference, Supported platforms use the following APIs:

• Ubuntu 22.04 uses the POSIX API: clock_gettime(), calloc(), and std::exit().

• QNX Neutrino 7.1 uses the POSIX API: clock_gettime(), calloc(), and std::exit().

• FreeRTOS v11 uses the FreeRTOS API: xTaskGetTickCount() and pvPortMalloc(), and std::exit().

• Other supported platforms will use the corresponding APIs for the underlaying execution environment.

Transport dependencies

As stated in Transport module section, Safe DDS provides a set of transports that encapsulate the dependencies with the underlaying communication stack. In general, Safe DDS will use the ITransport interface to be able to send and receive messages from and to locators.

Note

For more details about how to customize the transport, please check the Transport module section.

For reference, Supported platforms use the following transports:

• Ubuntu 22.04 uses the POSIX sockets API: socket(), bind(), sendmsg(), and recvfrom(), among others.

• QNX Neutrino 7.1 uses the QNX Neutrino sockets API: socket(), bind(), sendmsg(), and recvfrom(), among others.

• FreeRTOS v11 uses the FreeRTOS-Plus-TCP API: FreeRTOS_socket(), FreeRTOS_bind(), FreeRTOS_sendto(), and FreeRTOS_recvfrom(), among others.

• Other supported platforms will use the corresponding APIs for the underlaying communication stack.

Toolchain dependencies

During the build procedure, Safe DDS will need to be built using a C++11 compliant compiler.

As stated in Portable module section, Safe DDS provides a set of header files that encapsulate the dependencies with the C and C++ standard libraries. Those files provide default implementations assuming a standard C++11 compliant compiler but they can be overwritten to provide a custom implementation.

A complete list of the dependencies that can be overwritten or customized in Safe DDS can be found in the Portable module section.

Note

For more details about how to override the toolchain dependencies, please check the Override C++ Standard Library and Portable module section.