RTI Connext DDS Micro  Version 2.4.9
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
Release Notes


What's New

Improved Support for adding new Ports

Some changes were made to how RTI Connext DDS Micro includes different ports. In versions before 2.4.9 new ports would typically update osapi_config.h and add a new directory with an implementation for the required OSAPI functions. As of 2.4.9 osapi_config.h was re-factored and OS and compiler specific functions were moved to two new files:

  • osapi_os_<osname>.h This file contains OS specific information. RTI ships three files: osapi_os_posix.h, osapi_os_windows.h and osapi_os_vxworks.h. It is recommended to add a new osapi_os_<osname>.h file when a new OS is added.
  • osapi_cc_<osname>.h This file contains compiler specific informations. RTI ship osapi_cc_stds.c which works with Microsoft Visual Studio, clang and GCC.

Please refer to Porting RTI Connext DDS Micro for details.

Updated Build Environment to Build RTI Connext Micro

RTI Connext DDS Micro now includes better support for adding CMake tool-chain files and also includes a better infrastructure to manage multiple builds of RTI Connext DDS Micro. It is strongly encouraged to read Building the RTI Connext DDS Micro Source for details to get familiar with the new build environment.

Example CMake Tool-chain Files for Cross-Compilation

RTI Connext DDS Micro ships with a more cmake tool-chain files for Linux, Darwin, Windows and VxWorks. Please refer to Building the RTI Connext DDS Micro Source for details.

[RTI Issue ID MICRO-706]

Host Bundle without the Java RunTime Available

A new smaller host bundle that does not include Java Runtime Environments (JRE) is now available for download. A host bundle with JREs included is still available.

With Java being necessary for the rtiddsgen utility, rtiddsgen now picks Java based on the following order:

  • New rtiddsgen command line option -jre
  • JREHOME environment variable
  • JAVA_HOME environment variable
  • JRE shipped with the host bundle
  • PATH environment variable

[RTI Issue ID MICRO-1520]

Support for 64-bit Platforms

RTI Connext DDS Micro was written for 32 bit architectures and is for all practical purposes a 32 bit application. There is no advantage to compiling RTI Connext DDS Micro for a 64 bit architecture and the only reason to do so is if RTI Connext DDS Micro must execute in a 64 bit environment for other reasons, such as other applications being 64 bit or 64 bit libraries not being available.

RTI Connext DDS Micro is compiled and tested on various 64 bit architectures (iOS, MacOS, Windows, Linux, VxWorks). However, when doing so the following must be kept in mind:

  • RTI Connext DDS Micro does not work with any data-type larger than what the transport supports and up to a maximum of 2 GB.
  • Timestamps in RTI Connext DDS Micro are limited to seconds encoded as a signed 32 bit integer.

POSIX Compliance Improvements

RTI Connext DDS Micro supports various POSIX like operating systems. Due to small differences in the implementations not all POSIX like are equal and OS specific adaptations are necessary.

As of 2.4.9 RTI Connext DDS Micro's POSIX OSAPI implementation conforms to:

  • POSIX Std 1003.1, 2004 Edition (_POSIX_C_SOURCE 200112L)
  • X/Open 6 (_XOPEN_SOURCE 600)

The RTI Connext DDS Micro UDP transport uses ioctl calls to enable certain socket features. The required flags are in non-standard header-files on some operating system. In addition, not all POSIX-like operating systems support all the features. RTI Connext DDS Micro checks which OS it is compiled for by testing the presence of preprocessor flags. As of 2.4.9 RTI Connext DDS Micro has been built and tested on the following operating systems that supports a POSIX API (osapi_os.h):

  • Linux (linux)
  • Mac OS X (10.6 and later) ((APPLE) && defined(MACH))
  • QNX 6.x (QNXNTO)
  • VOS (VOS)
  • iOS (((APPLE) && defined(MACH))
  • Android (linux && ANDROID)

NOTE: An additional compile option to enable certain non-POSIX features can be enabled to unchecking the RTIME_OSAPI_ENABLE_STRICT_POSIX option in the cmake-gui or by defining the C preprocessor flag -DOSAPI_ENABLE_STRICT_POSIX=1

[RTI Issue ID MICRO-1548]

C++ Support for find_topic()

The operation DDS_DomainParticipant_find_topic() is now natively supported by the C++ API as DDSDomainParticipant::find_topic().

[RTI Issue ID MICRO-1551]

Types Are Automatically Unregistered Upon Deleting Contained Entities

In previous releases, types must be unregistered manually from a DomainParticipant before the participant can be deleted. Now in this release, all registered types are automatically unregistered when calling DDS_DomainParticipant_delete_contained_entitites().

NOTE: It is legal to register the same type multiple times as long as it is registered with the same type-plugin. If manually unregistering a type, the type must be unregistered the same number of times as it was registered. DDS_DomainParticipant_delete_contained_entitites() ignores the number of times a type has been registered since all entities using a type are deleted first.

[RTI Issue ID MICRO-1569]

What's Fixed

Improved Documentation

The RTI Connext DDS Micro documentation has been improved for the following topics:

[RTI Issue ID MICRO-711, MICRO-1521, MICRO-1538, MICRO-1555]

Losing Participant Liveliness Stops Communication

Previously, given a DomainParticipant "P1" whose endpoints are communicating with other endpoints belonging to other DomainParticipants, when P1 detected liveliness lost with one other DomainParticipant, communication incorrectly stopped with endpoints belonging to other DomainParticipants as well.

[RTI Issue ID MICRO-1543]

DDSTopic::narrow() Returned Incorrect Value in C++

The function lookup_topicdescription() returned a DDSTopicDescription that caused DDSTopic::narrow() to segmentation fault when this DDSTopicDescription was passed to other functions.

DDSTopic::narrow() now correctly returns a DDSTopic when passed a DDSTopicDescription found with lookup_topicdescription().

[RTI Issue ID MICRO-1544]

PRECONDITION_NOT_MET Returned by deleted_topic() When Topic Is Not Use

delete_topic() incorrectly returned PRECONDITION_NOT_MET if there where multiple references to it (for example via find_topic()). This has been corrected and delete_topic() now returns DDS_RETCODE_OK if there are multiple references, but the reference count can be decremented.

[RTI Issue ID MICRO-1545]

Instance Resources Not Reclaimed When Unregistered

When an instance is unregistered on the data writer that is best-effort with infinite deadline or using TRANSIENT_LOCAL durability, the data writer fails to free the resources being used. As a result, new instances cannot be written. This has been fixed and when an instance is unregistered all resources associated with the key is released.

[RTI Issue ID MICRO-1546]

Invalid Memory Read Reported in Log.c

Some memory profile tools reported an invalid read in Log.c. This was caused by an invalid pointer access when the log buffer was full and has been corrected.

[RTI Issue ID MICRO-1550]

Unsupported Functions When Compiling With RTI_CERT Has Been Removed From Generated Code

Code generated by rtiddsgen to support user data types has been updated to properly support compilation with the flag RTI_CERT. All unsupported operations (e.g. FooTypeSupport_delete_data) are now excluded when RTI_CERT is specified.

[RTI Issue ID MICRO-1558]

The HelloWorld_cert Example Now Compiles When Linked Against a Library Built With RTI_CERT

The HelloWorld_cert called functions that were not supported by libraries built with RTI_CERT. This has been corrected.

[RTI Issue ID MICRO-1561]

Hostnames Are No Longer Validated

Previously in RTI Connext DDS Micro 2.4.6, a function to validate IP hostnames as defined by RFC-952 was added and called before passing them to the OS. However, this function was too restrictive and excluded valid service names. Hostname validation is now only done directly by the OS.

[RTI Issue ID MICRO-1563]

A Participant May Not Be Rediscovered In Case Of Asymmetric Liveliness Loss

This problem was only present when using dynamic discovery.

Consider two participants A and B. In the previous release, if A lost liveliness with B, but B did not lose liveliness with A, then A did not completely rediscover B when their connection was reestablished. The problem was that since B had not lost liveliness with A, when a connection was reestablished, B thought A was already up to date on endpoint discovery. Hence, A did not rediscover the endpoints in B. This release has fixed this issue.

[RTI Issue ID MICRO-1571]

A Non-keyed Endpoint Matches a Keyed Endpoint

When performing matching between A DataReader and DataWriter the entity kind was not checked. This means a keyed DataReader would match a non-keyed DataWriter and a non-keyed DataReader would match an keyed DataWriter.

This issue would can happen if two different IDLs files are used to create DataReaders and DataWriters of the same topic and type.

Note that RTI Connext DDS Micro does not support type validation. If two (or more) IDLs are used to describe the same keyed type there is no check that the key-fields are the same. Thus, even with this issue resolved there are still potential pitfalls with multiple IDLs for the same type.

[RTI Issue ID MICRO-1574]

Known Issues

Static Endpoint Discovery Requires Unique Object IDs Across All Remote Endpoints

When using static endpoint discovery (DPSE), RTI Connext Micro requires that the object_id for statically asserted remote endpoints must be unique across all remote endpoints, as opposed to just between remote endpoints within the same participant. Note, this restriction was incorrectly documented as removed in version 2.4.1.

[RTI Issue ID MICRO-211, MICRO-1553]

Deprecated Windows APIs Used by RTI Connext Micro

Between VS2010 and VS2015 some APIs used by the RTI Connext DDS Micro OSAPI and UDP transport on Windows have been deprecated. The applicable APIs are:

  • GetVersionExA
  • gethostbyname
  • inet_addr

Note that although these warnings can be removed by defining _WINSOCK_DEPRECATED_NO_WARNINGS, RTI Connext DDS Micro does not do so to make it clear these APIs are being used.

[RTI Issue ID MICRO-1575]

Compiler warnings on VxWorks

When compiling for VxWorks 6.9 with the -Wconversion flag there are compiler warnings of the type:

warning: conversion to 'DDS_Boolean' from 'int' may alter its value

These compiler warnings seem to be an issue with GCC for VxWorks and can be ignored. The problem is that returning a value from a expression seems to always be treated as an unbounded int as opposed to an int with a value of 0 or 1 as the C standard dictates.

OSAPI Does Not Always Detect Endianess

osapi_cc_stdc.h detects the CPU endianness by checking GCC predefined macros, such as BYTE_ORDER. However, some versions of GCC does not set these macros, for example GCC for VxWorks. If osapi_cc_stdc.h does not find any of the flags, it incorrectly sets the CPU to little endian.

In this case it is important that one of the following preprocessor macros are defined:

  • RTI_ENDIAN_BIG The CPU is big-endian
  • RTI_ENDIAN_LITTLE The CPU is little-endian

NOTE: The VxWorks cmake toolchain file from RTI set these based on CPU type in the target name (–name option).


What's New

2.4.8 is a maintenance release with no new features.

What's Fixed

Consistent support for assignment operator in C++

The assignment operator for the DDS Qos, Qos policy and Status structures were not consistently supported. This has been fixed in this release as follows:

  • All QoS structures support the default generated C++ assignment operator.
  • All QoS policy structures support the default generated C++ assignment operator.
  • All Status structures support the default generated C++ assignment operator.

In addition, all QoS structures support the == and != operators.

[RTI Issue ID MICRO-1541]

DPSE API renamed to avoid conflict with assert()

The DPSE C++ API had methods called assert. However, this conflicts with the C assert() macro. This has been fixed in this release by updating the DPSE C++ API to be inline with the C API. The new API is:

class DDSCPPDllExport DPSEDiscoveryPlugin
RemoteParticipant_assert(DDSDomainParticipant *const participant,
const char *rem_participant_name);
RemotePublication_assert(DDSDomainParticipant * const participant,
const char *const rem_participant_name,
const struct DDS_PublicationBuiltinTopicData *const data,
RemoteSubscription_assert(DDSDomainParticipant * const participant,
const char *const rem_participant_name,
const struct DDS_SubscriptionBuiltinTopicData *const data,

[RTI Issue ID MICRO-1539]


What's New

2.4.7 is a maintenance release with no new features.

What's Fixed

Statuses are passed as pointers instead of references to DDSDomainParticipantListeners

The statuses in the DDSDomainParticipantListener methods are now passed by reference instead of by pointer.

[RTI Issue ID MICRO-1524]

Missing assignment operator = in RT_ComponentFactoryId

The C++ API did not include the assignment operator for the RT_ComponentFactoryId type. The following assignment operators have been added:

RT_ComponentFactoryId& operator=(const char *const name);
RT_ComponentFactoryId& operator=(const RT_ComponentFactoryId& from);
const RT_ComponentFactoryId& operator=(const RT_ComponentFactoryId& from) const;

[RTI Issue ID MICRO-1525]

CMAKE_C_FLAGS_ORIGINAL in CMakeLists.txt misspelled

The CMAKE_C_FLAGS_ORIGINAL variable in the CMakeLists.txt file was misspelled causing the original C_FLAGS to be ignored. This has been corrected in this release.

[RTI Issue ID MICRO-1526]

Missing const qualifier for the sequence [] operator

The C++ API was missing the const qualifier for the sequence [] operator. This has been corrected in this release with these operators:

T& operator[] (RTI_INT32 index);
const T& operator[] (RTI_INT32 index) const;

[RTI Issue ID MICRO-1527]

Missing primitive IDL sequences in C++

The C++ API did not include sequence of the primitive IDL types. This has been corrected in this release. Please refer to Working with Sequences for more information about the sequence API.

[RTI Issue ID MICRO-1529]


What's New

Important API Changes

This version of RTI Connext DDS Micro includes a number of API changes to improve compatibility with RTI Connext DDS Core and make the API more robust to input argument errors such as string length violations. Please note that some of the changes are incompatible with earlier version of RTI Connext DDS Micro.

Changed and Incompatible APIs
  • DDS_SEQUENCE_INITIALIZER(t) has changed to DDS_SEQUENCE_INITIALIZER. That is, the sequence element type is no longer passed in.
  • Foo_seq_get_contiguous_buffer replaces Foo_seq_get_buffer.
  • DDSTopic now uses multiple inheritance. Thus, it is no longer necessary to explicitly convert a topic to a topic description with the as_topicdescription() method when creating calling create_datareader() in C++.
  • The DDS_DiscoveryComponent::name value has changed type from a char pointer to a RT_ComponentFactoryId_T type. Use RT_ComponentFactoryId_set_name to set the name of the discovery plugin name.
  • All C++ statuses are passed as a const reference instead of a const pointer to the listeners.
New APIs
  • By default the full sequence API has been enabled. In previous versions only a limited subset was enabled. NOTE: For RTI_CERT the default sequence API is still the limited API.
  • The following new sequence methods have been added to the full sequence API (excluding the DDSConditionSeq):
    • ensure_length
    • to_array
    • from_array
    • operator[] in C++ is equivalent to get_reference()
    • operator= is equivalent to _copy()
    • operator== is equivalent to _is_equal()
    • operator!= is equivalent to !_is_equal()
  • The following new sequence methods have been added to the DDSConditionSeq:
    • ensure_length
    • operator[] in C++ is equivalent to get_reference()
    • operator= is equivalent to _copy()
    • operator== is equivalent to _is_equal()
    • operator!= is equivalent to !_is_equal()
  • RTIBool has been added (it is used by RTI Connext DDS Core) and is equivalent to RTI_BOOL in RTI Connext DDS Micro.
  • A new method DDS_EntityNameQosPolicy_set_name has been added to set the DDS_EntityNameQosPolicy::name field.
  • Please refer to All public C API now natively available to C++ users for new C++ APIs.

Run-time Memory Footprint Has Been Significantly Reduced

The internal representation of state information has been refactored, significantly reducing run-time memory usage.

Please refer to the Configuring Resource Limits guide for details.

New FooTypeSupport operations

The FooTypeSupport code generated for a user-defined Foo data type now includes three additional operations:

  • FooTypeSupport::get_type_name
  • FooTypeSupport::create_data
  • FooTypeSupport::delete_data

These operations are available to users of both the C and C++ APIs.

All public C API now natively available to C++ users

The missing parts of RTI Connext Micro's public C API have now been added to the public C++ API, so that C++ users don't have to rely on C operations to implement their applications.

C++ developers are also not required to include any C header file anymore, but they must instead rely on newly available C++ header files.

Please refer to DDS C++ API for a list of APIs.

Status data passed by reference to C++ listeners

All callbacks exposed by the DDS listeners of the C++ API (DDSDataReaderListener, DDSDataWriterListener, DDSTopicListener, and other derived classes) now accept the status data passed in by the middleware as a C++ reference, rather than a pointer.

TheParticipantFactory now available to C++ users

The variable TheParticipantFactory is now available to users of the C++ API to reference the singleton instance of DDSDomainParticipantFactory.

Status types now available in DDS:: C++ namespace

All the status types (e.g. DDS_SubscriptionMatchedStatus) have been exposed to C++ users as part of the DDS:: namespace (e.g. DDS::SubscriptionMatchedStatus).

Foo::copy_data() takes const argument

The pointer specifying the source sample passed to the generated operation Foo::copy_data() (C++ API) is now of "const" type.

ConditionSeq added to C++ DDS namespace

C++ developers can now refer to data type DDS_ConditionSeq as DDS::ConditionSeq.

First 2-Bytes Of GUID Assigned to Vendor ID

In order to be interoperable with the Real-Time Publish-Subscribe Wire Protocol DDS Interoperability Wire Protocol (DDSI-RTPS), version 2.2, the first 2-bytes of every GUID are now automatically assigned to the OMG-specified Vendor ID.

What's Fixed

POSIX Threads Were Created Without Names

Previous releases on POSIX platforms created threads with no names. In this release, if thread naming is supported, a POSIX thread created with the RTI Connext DDS Micro OSAPI_Thread_new() function will have its thread name set.

[RTI Issue ID MICRO-638]

Prerequisite for HelloWorld_android updated in README.txt

The README.txt file for Android did not clarify that is it necessary to install the NDK tool-chain as a standalone toolchain. This has been fixed.

[RTI Issue ID MICRO-807]

CPP/HelloWorld_dpde example does not overwrite RTIMEHOME

In previous releases of RTI Connext DDS Micro, the CPP/HelloWorld_dpde example overwrote the RTIMEHOME environment variable, making it impossible for developers to point it to any custom value.

This error was fixed and the example can now be compiled with any valid value of RTIMEHOME.

[RTI Issue ID MICRO-834]

Transport Not Supporting Multicast Did Not Ignore Multicast

Previously, if a multicast address was specified as a discovery or user_traffic address, it was not correctly ignored by transports that did not support multicast. Consequently, an application may have failed to create a DomainParticipant. This has been fixed in this release.

[RTI Issue ID MICRO-1153]

Discovery Messages Incorrectly Dropped When Containing Non-Standard Locators

When a discovery message was received with a non-standard locator, such as for an unsupported transport, rather than just ignore the locator, the entire discovery message was discarded. This incorrect behavior prevented discovery of the entity that sent the discovery message. This issue has been fixed in this release.

[RTI Issue ID MICRO-1270]

HEARTBEAT Not Sent in Response To Initial ACKNACK

In RTI Connext DDS Micro, a newly matched reliable DataReader will send an initial ACKNACK submessage to the matching DataWriter in order to expedite reliable communication. The initial ACKNACK is zero-valued, and a DataWriter receiving it will not resend any samples but instead will send a HEARTBEAT that the DataReader will respond with a proper ACKNACK.

In the previous release, however, a DataWriter receiving this initial ACKNACK did not respond with a HEARTBEAT. Consequently, reliable resend of historical samples did not start as soon as it should have, and instead would start with the next HEARTBEAT sent by the DataWriter, either a periodic HEARTBEAT or a piggyback HEARTBEAT sent with newly written samples. This issue has been fixed in this release.

[RTI Issue ID MICRO-1443]

Incorrect Return Code From DataReader's Read or Take APIs When Max_Outstanding_Reads Exceeded

When a DataReader's read or take APIs are called, depending on the input parameters of the sample sequence and sample-info sequence, the DataReader may loan to the caller its memory containing sample and sample-info entries. A resource limit, DATA_READER_RESOURCE_LIMITS max_outstanding_reads, sets the maximum number of samples (and corresponding sample-info entries) that may be loaned.

In previous releases, when max_oustanding_reads was exceeded, the read/take APIs incorrectly returned DDS_RETCODE_NO_DATA instead of DDS_RETCODE_OUT_OF_RESOURCES. This bug has been fixed in this release.

[RTI Issue ID MICRO-1460]

DataReader Did Not Replace Historical Samples When max_samples_per_instance Equaled History Depth

Previously, given a DataReader with RESOURCE_LIMITS max_samples_per_instance equal to HISTORY depth, when the DataReader exceeded its depth (or max_samples_per_instance), it incorrectly did not replace the oldest historical sample with the newest sample. Instead, the oldest historical sample was kept in the queue, and subsequent calls to read() could return it. Note, calls to take() would remove all taken sample from the queue.

This issue has been fixed in this release.

[RTI Issue ID MICRO-1463]

A Disposed Instance Could Be Updated By A DataWriter That Is Not Its Exclusive Owner

When EXCLUSIVE_OWNERSHIP was used, a disposed instance could incorrectly be updated by a DataWriter with a lower strength than the DataWriter that disposed the instance, even if that DataWriter had not unregistered the instance. This has been corrected: when an instance is disposed, a lower strength DataWriter is not allowed to update the instance as long as the DataWriter that disposed the instance is still registered as an updater for the instance. Only when the DataWriter unregisters from the instance can a lower strength DataWriter update the instance again.

[RTI Issue ID MICRO-1464]

Fixed code generation for user-defined enum constants.

The previous version of rtiddsgen shipped with RTI Connext DDS Micro contained a bug which prevented the numerical constants assigned to an enum's values to be correctly handled in the generated code.

This error has been fixed and IDL enum types are now correctly translated into C/C++ data types with the correct constants.

[RTI Issue ID MICRO-1483]

Hostname is verified as specified in RFC-952 and RFC-1123

RTI Connext DDS Micro relied on gethostbyname() to resolve hostnames. However, if a name resolver was not available it was possible to specify illegal names.

This has been corrected and only legal names, as defined by RFC-952 and RFC-1123, are resolved.

[RTI Issue ID MICRO-1489]

DDS_<Foo>Seq APIs Were Missing

The DDS sequence APIs for the built-in DDS types, such as DDS_LongSeq etc, were missing. The workaround was to use CDR_<Foo>Seq instead.

This issue has been corrected in this release, with the missing sequence APIs now included.

[RTI Issue ID MICRO-1493]

DataReader Could Reject All Subsequent Samples From a DataWriter

In the previous release, given a DataReader receiving samples from a DataWriter, after the DataWriter had written approximately (2^32) - max_samples_per_remote_writer number of samples, no more samples from that DataWriter would be received by the DataReader. Instead, every subsequent sample from the DataWriter would be rejected. This was caused by an incorrect update of an internal counter of the DataReader.

[RTI Issue ID MICRO-1500]

POSIX Thread Priorities Not Changeable

It was not possible to change the priority of POSIX threads created in previous releases of RTI Connext DDS Micro. Instead, a POSIX thread inherited the priority of its parent. This has been fixed in this release.

[RTI Issue ID MICRO-1502]

RTPS DATA Submessages with K-flag Set Were Dropped

Previously, RTPS DATA submessages with the K-flag set (indicating a serialized key payload) were not processed and instead dropped by a DataReader. This has been fixed and such DATA submessages are now processed and accepted.

[RTI Issue ID MICRO-1511]


RTI Connext DDS Micro 2.4.5 is the baseline for the DO-178C Level A certifiable version of RTI Connext DDS Micro. Please note that while RTI Connext DDS Micro features a subset of RTI Connext DDS Micro the documentation is shared between the two products. In particular, note that APIs supported by RTI Connext DDS Micro is clearly marked.

Supported Architecture

A Certification Package for RTI Connext DDS Micro 2.4.5 is only available on the following platform:

  • Wind River, VxWorks Cert
  • Extreme Engineering Solutions (X-ES) XCalibur1700 board and BSP
  • Wind River GCC 4.2.1 compiler

For other platforms, please contant RTI Support (suppo[email protected][email protected][email protected]ti.co[email protected]m)

What's New

Updated Signatures for OSAPI Functions

The OS API functions OSAPI_System_generate_uuid and OSAPI_Timer_update_timeout have had their signatures changed. These must be taken into account when porting your platform to this version.

Updated Generated Code from rtiddsgen

Generated code from rtiddsgen has been updated. Consequently, users using this version of RTI Connext DDS Micro must use the new rtiddsgen to regenerate files for existing types.

What's Fixed

Deadline Missed Status Not Triggered

Samples written with a period between one and two deadline periods may have incorrectly not triggered the deadline missed status on the DataWriter and/or DataReader.

[RTI Issue ID MICRO-1426]

Failure in DataWriter Operations May Have Blocked Application

Failures within the functions DDS_DataWriter_register_instance and DDS_DataWriter_assert_liveliness may have resulted in a blocked application, where no further communication occurred. This problem has been fixed in this release.

[RTI Issue ID MICRO-1283, MICRO-1284]

Instance Handle Could Not Be Retrieved For a Topic

In the previous release, it was not possible to get the instance handle for a topic. This has been fixed.

[RTI Issue ID MICRO-1215]

Reliable DataWriter Sent Redundant Repair Samples

In the previous release, a reliable DataWriter may have responded to a reliable DataReader's negative acknowledgement by sending samples the DataReader already received. This resending of redundant samples has been fixed in this release.

[RTI Issue ID MICRO-1197]

Duration Based Qos Policies Where Limited to 24 Days

Previously, Qos policies that are based on DDS_Duration, such as deadline and liveliness, had a limit of 24 days. This has been changed to a limit of 24855 days.

[RTI Issue ID MICRO-1176]


What's New

Updated Generated Code from rtiddsgen

Generated code from rtiddsgen has been updated. Consequently, users using this version of RTI Connext DDS Micro must use the new rtiddsgen to regenerate files for existing types.

What's Fixed

Missing Parameter in Sample Filtering Callback of HelloWorld Example Resulted in Incorrectly Unfiltered Samples

A DataReaderListener on_before_sample_commit callback function is provided in each HelloWorld example to show how to drop or accept a received sample. This release fixes a problem where the sample_info parameter was not provided for each example on_before_sample_commit callback. Previously, without the parameter, a received sample was incorrectly accepted when it should have been dropped.

[RTI Issue ID MICRO-1177]

Communication With Endpoint Incorrectly Stopped After Shutdown of Other Endpoint

Given a DataWriter or DataReader communicating with multiple remote endpoints, when there are two remote endpoints remaining and one of them is removed, communication with the last remaining endpoint will stop due to a bug that caused the last endpoint to be undiscovered.

[RTI Issue ID MICRO-1114]

Double Free by C++ Foo Sequence Functions

The FooSeq.max and FooSeq.copy functions in C++ lead to a double free on sequence elements. This was most notable when using the read/take APIs and copying data. This has been fixed.

[RTI Issue ID MICRO-1133]

Entity Name's Maximum Length Was Not 255 Bytes

The max entity name is 255 bytes. However, the internal array used to reprint the entity name did not take into account the NUL termination, limiting the max entity name to 254 bytes.

[RTI Issue ID MICRO-1129]

Re-discovery of Participants May Fail

When a discovered participant is disposed or its lease duration expires it is removed from a participant. However, not all resources where freed and if the remote_participant resource limit where exhausted and a new participant was created it would not be discovered. This has been fixed in this release.

[RTI Issue ID MICRO-1134]

Accessing Samples with read() Resulted in New Samples Being Rejected

An error in the resource handling of the read() function caused resources to no be reusable upon calling return_loan(). Thus new samples was rejected. This error has been corrected. The take() API is not affected by this API.

[RTI Issue ID MICRO-1089]

Default Value of DDS_LivelinessQosPolicy Kind Was DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS

Previously, the default liveliness kind was DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS. To comply with the DDS standard, in this release the default liveliness kind has been changed to DDS_AUTOMATIC_LIVELINESS_QOS.

[RTI Issue ID MICRO-1061]


What's New

FACE Conformance

RTI Connext DDS Micro has been verified for FACE conformance. See this user guide to learn how to build RTI Connext DDS Micro using the FACE conformance test tools.


New Features

Configurable Discovery of Unknown Peers

A DomainParticipant can receive a discovery message from another DomainParticipant that is either reachable or unreachable from its initial peers list. Previously, these messages were always received. However, an application may want to restrict the list of discoverable DomainParticipants to ones reachable from its peers list.

To enable that capability, accept_unknown_peers has been added as a configurable boolean field of DDS_DiscoveryQosPolicy. When set DDS_BOOLEAN_FALSE, only DomainParticipants reachable from the peers list can be discovered, and when set DDS_BOOLEAN_TRUE, all DomainParticipants can be discovered.

[RTI Issue ID MICRO-971]


New Features

New -micro option for rtiddsgen

The rtiddsgen version shipped with this release of RTI Connext Micro introduces a new command line argument, "-micro", which enables users to explicitly target RTI Connext Micro when using the code generation tool.

Previously this was implicitly implied by the use of values "microC" or "microC++" for command line argument "-language". This prevented rtiddsgen to be able to produce an help output specific for RTI Connext Micro. This functionality is now available to users, who may use arguments "-micro - help" to visualize a list of all command line arguments supported by rtiddsgen when tar- geting RTI Connext Micro.

[RTI Issue ID MICRO-779]

New language options for generating code for RTI Connext DDS Micro using rtiddsgen

The new version of rtiddsgen that is shipped with RTI Connext DDS Micro introduces new values for the "-language" command line argument, which should be adopted by users instead of the previously supported "microC" and "microC++".

In order to generated custom data-types support code that can be used with RTI Connext DDS Micro, user shall specify the following command line options.

  • Target language C
    • -micro -language C
  • Target language C++
    • -micro -language C++

[RTI Issue ID MICRO-79]

CMake Configuration for Buildable Source

The provided CMake configuration for building RTI Connext DDS Micro from source code has been updated:

  • Configuration options have been simplified, including selecting a target operating system, and for including C++ API support
  • Output libraries are now identical to pre-built shipped libraries of RTI Connext DDS Micro The previous configuration instead produced a single library.

[RTI Issue ID MICRO-112, MICRO-770, MICRO-805]

DDS_WaitSet and DDS_Condition APIs For C++

This release officially introduces full support of DDS_WaitSet and DDS_Condition APIs also for C++ users of RTI Connext DDS Micro.

The following operations are officially supported:

  • DDSWaitSet::DDSWaitSet()
  • DDSWaitSet::wait()
  • DDSWaitSet::attach_condition()
  • DDSWaitSet::detach_condition()
  • DDSWaitSet::get_conditions()
  • DDSCondition::get_trigger_value()
  • DDSGuardCondition::DDSGuardCondition()
  • DDSGuardCondition::set_trigger_value()
  • DDSStatusCondition::set_enabled_statuses()
  • DDSStatusCondition::get_enabled_statuses()
  • DDSStatusCondition::get_entity()

[RTI Issue ID MICRO-685]

New HelloWorld_dpde_waitset Example

A new code example, HelloWorld_dpde_waitset, has been added to the set of examples shipped with RTI Connext DDS Micro.

This example is based on the preexisting HelloWorld_dpde example and it exemplifies the use of the recently introduced DDS_WaitSet and DDS_Condition APIs.

By leveraging a few pre-processor macros, the example also provides an equivalent implementation of its behavior using traditional listeners on DDS entities. Users may switch between one implementation and the other by modifying values of these macro and by recompiling the example's source code.

[RTI Issue ID MICRO-708]

Access to Status of DDS Entities by C++ APIs

Operations of the DDS API which grant users access to data structures describing the current internal information about a particular entity status have now been fully implemented and they are officially supported by RTI Connext Micro's C++ API.

The following methods have been introduced:

  • DDSDataReader::get_sample_rejected_status
  • DDSDataReader::get_sample_lost_status
  • DDSDataReader::get_subscription_matched_status
  • DDSDataReader::get_requested_incompatible_qos_status
  • DDSDataReader::get_requested_deadline_missed_status -
  • DDSDataReader::get_instance_replaced_status
  • DDSDataReader::get_liveliness_changed_status
  • DDSDataWriter::get_publication_matched_status
  • DDSDataWriter::get_offered_incompatible_qos_status
  • DDSDataWriter::get_offered_deadline_missed_status
  • DDSDataWriter::get_liveliness_lost_status
  • DDSTopic::get_inconsistent_topic_status

[RTI Issue ID MICRO-784]

Improved support for listeners of DDS entities in C++ API

Support for operations allowing the setting and retrieval of listener objects from DDS entities has been extended and it is now fully available to users of RTI Connext Micro's C++ API.

The following methods have been implemented and they are now fully supported as part of the C++ API:

  • DDSDomainParticipant::set_listener
  • DDSDomainParticipant::get_listener
  • DDSSubscriber::set_listener
  • DDSSubscriber::get_listener
  • DDSPublisher::set_listener
  • DDSPublisher::get_listener
  • DDSTopic::set_listener
  • DDSTopic::get_listener
  • DDSDataWriter::set_listener
  • DDSDataReader::set_listener

New Operations FooTypeSupport_register/unregister_type for User Data-Types

The new version of rtiddsgen that is shipped with RTI Connext DDS Micro now generates two new additional operation which can be used by users to more easily register a data-type on a DDS_DomainParticipant. In particular, these operation allow the specification of an empty (null) type name at registration time. The default name associated with the type will be used in this case.

The new operations are generated only for top-level data-types which are the only ones usable for the creation of a DDS_Topic.

[RTI Issue ID MICRO-796]

Sample Info Provided With DataReaderListener's Sample Filter Callback

DataReaderListener.on_before_sample_commit() now provides sample info of the sample being filtered in a new parameter, sample_info.

[RTI Issue ID MICRO-809]

More Information Provided in DDS_SampleLostStatus Type

The DDS_SampleLostStatus type has two new fields:

  • kind
  • sample_info

The kind (of type DDS_SampleLostStatusKind) indicates why a sample was lost. For samples lost for any reason other than DDS_SAMPLE_LOST_BY_DATAWRITER, sample_info gives additional information about the sample.

[RTI Issue ID MICRO-919]

What's Fixed

Full Support of -namespace Option for rtiddsgen

The new version of rtiddsgen shipped with RTI Connext DDS Micro introduces official support for the "-namespace" command line argument when the tool is used for the genera- tion of C++ type support code. If the option is specified on the command line, IDL modules will be translated into C++ namespaces instead of being used as prefixes to the name of data-types defined within them.

[RTI Issue ID MICRO-153]

Redundant Code Not Generated for Non Top-Level Types

Previous version of rtiddsgen that were shipped with RTI Connext DDS Micro included, in the generated code for user-specified data-types, several support operations which were not required by data-types which cannot be used as top-level types for a DDS_Topic.

These redundant operation have now been removed from the generation outcome and they are only produced for top-level types.

[RTI Issue ID MICRO-678]

Setting Real-Time Clock for VxWorks Platform

For VxWorks platforms, when initializing an application, RTI Connext DDS Micro set the real-time clock (i.e. clock_settime) to a predefined value. This could have interfered with user configured time, thus this release no longer sets the real-time clock.

[RTI Issue ID MICRO-692]

IDL Copy Directives Now Supported by rtiddsgen

Support for IDL copy directives (such as "//@copy", "//@copy-c", ...) has been improved and the following copy directives are now fully supported in user-provided IDL files:

  • "//@copy"
  • "//@copy-declaration" or "//@copy-c"
  • "//@copy-c-declaration"

[RTI Issue ID MICRO-740]

Incompatible Encoding of DDS_Duration_t with RTI Connext DDS

The DDS_Duration_t datatype was not correctly encoded by RTI Connext DDS Micro when sent over the wire. Specifically, the nanoseconds field of Duration_t was not correctly encoded. This was not a problem between RTI Connext DDS Micro applications, but when inter-operating with RTI Connext DDS applications, the durations of Liveliness lease_duration and Deadline period were misinterpreted and resulted in incorrect timing. A workaround was to multiply the nanoseconds field of the RTI Connext Micro application's durations by 4 when communication with RTI Connext DDS.

[RTI Issue ID MICRO-768]

Premature Wakeup from Semaphore Take for POSIX Platforms

A problem existed on platforms using POSIX threads (e.g. Linux) where taking a semaphore with a timeout may have woken up prematurely. This could have resulted premature wake-up for Waitsets.

[RTI Issue ID MICRO-772]

Failed Compilation of C++ Generated Code from rtiddsgen

A bug has been fixed in the code generation templates, used by rtiddsgen to produce support code used by the C++ API for user-defined custom data-types. This bug caused erroneous code to be generated for non top-level data-types in the resulting source files. This code prevented the generated source code from being successfully compiled.

These additional and unnecessary parts have now been removed.

[RTI Issue ID MICRO-777, MICRO-778]

DDS_Topic_get_inconsistent_topic_status in C API

The operation DDS_Topic_get_inconsistent_topic_status has been added to RTI Connext Micro's C API and it is now fully supported.

[RTI Issue ID MICRO-783]

DDS_StatusCondition's Trigger Value Not Updated When DDS_DATA_AVAILABLE_STATUS Is Reset

A bug has been fixed which prevented a DDS_StatusCondition instance, associated with a DDS_DataReader, DDS_Subscriber, or DDS_DomainParticipant, from correctly transitioning its trigger value from true to false when state DDS_DATA_AVAILABLE_STATUS was consumed and deactivated in the associated DDS entity.

This behavior caused the wait() operation of any DDS_WaitSet, that had the DDS_StatusCondition instance attached to it, to always immediately return successfully, after the DDS_StatusCondition's trigger value had been transitioned to active. Note that it was still possible for the condition's trigger value to transition to false state if another of the enabled statuses transitioned to false in the associated DDS entity, causing the DDS_StatusCondition to properly update its state according to the DDS entity's one.

[RTI Issue ID MICRO-786]

DDS_WaitSet_get_conditions Supported by C API

The operation DDS_WaitSet_get_conditions has now been fully implemented and it can be now used to access the list of DDS_Conditions attached to a DDS_WaitSet instance.

[RTI Issue ID MICRO-788]

Reliable, Keep-Last DataReader May Stop Receiving Samples

A reliable DataReader with KEEP_LAST history may have stopped receiving new samples, after previous samples were received out of order. This was due to a bug where there were no available resources of the DataReader to receive samples that would allow the out of order samples to be presented in order to the application.

[RTI Issue ID MICRO-790]

Memory Dynamically Allocated By DPSE After Initialization

RTI Connext Micro is designed not to allocate memory dynamically after an entity has been created and enabled. However, a bug in the implementation for Dynamic Partici- pant, Static Endpoint (DPSE) discovery resulted in the dynamic allocation of memory during participant discovery. The memory allocated was to increase the maximum size of sequences for storing received participant discovery data. This release has been fixed to do this allocation during initialization.

[RTI Issue ID MICRO-803]

Application Crashed When Looking Up DomainParticipant

Previously, an application would crash when DDS_DomainParticipantFactory_lookup_participant() was called before the first invo- cation of DDS_DomainParticipantFactory_get_instance(). This was caused by improper initialization of the DomainParticipantFactory and has been fixed in this release.

[RTI Issue ID MICRO-819]

Setting Log Verbosity May Have Been Ineffective

Logging verbosity is configured by calling OSAPI_Log_set_verbosity(). It should be configurable at any time. However, a bug existed where the first call to DDS_DomainParticipantFactory_get_instance() reset the log verbosity to OSAPI_LOGKIND_ERROR. This caused calls to OSAPI_Log_set_verbosity() for verbos- ity not equal OSAPI_LOGKIND_ERROR to be ineffective when called before the first DDS_DomainParticipantFactory_get_instance().

[RTI Issue ID MICRO-820]

Waitset’s Wait may have Incorrectly Timed Out when Listener also Installed

Given a DataReader and a DDS status handled by both the DataReaderListener and a Waitset, the Waitset's wait operation may not have correctly woken up, resulting in a timeout. For example, having DDS_DATA_AVAILABLE_STATUS handled by both the listener's on_data_available callback and as an enabled status of a StatusCondition attached to a Waitset could have resulted in the Waitset waiting to timeout even though data was actually available. As a workaround, you may have disabled the listener and instead relied only on the Waitset. This workaround is no longer needed.

[RTI Issue ID MICRO-969]

Data not Received due to Samples not being Sent by all Transports

RTI Connext Micro supports two built-in transports: UDP and Intra, where Intra only transports data between endpoints belonging to the same DomainParticipant. With both transports enabled (which is the default setting), a bug introduced in Connext Micro 2.3.1 caused written samples to be sent over only one transport. This could result in samples not being received by a remote DomainParticipant, where samples are sent over Intra but not over UDP.

[RTI Issue ID MICRO-866]

Static Endpoint Discovery Restrictively Required Unique Object IDs Across All Remote Endpoints

When using static endpoint discovery (DPSE), RTI Connext Micro incorrectly enforced a requirement that the object_id for statically asserted remote endpoints must be unique across all remote endpoints, as opposed to just between remote endpoints within the same participant. This restriction has been removed.

[RTI Issue ID MICRO-211]

Possible Non-Discovery or Non-Communication between Connext Micro using DPSE and a Non-Micro Application

The participant discovery messages sent by a Connext Micro application using the Dynamic-Participant Static-Endpoint (DPSE) discovery plugin contained an incorrect value for the Built-in Endpoint Mask parameter. The bits of the mask indicate which built-in discovery endpoints are enabled, and for DPSE the bits corresponding to the participant built-in writer and reader were not set. This could cause other DDS implementations not to discover, communicate, or correctly update statuses with Connext Micro using DPSE. This problem has been fixed in this release.

[RTI Issue ID MICRO-974]

Known Issues

Incomplete Documentation for non-DDS APIs

RTI Connext Micro does not yet provide documentation for all non-DDS modules. The internal modules missing documentation include the run-time (RT), the writer and reader history queues (wh_sm, rh_sm), RTPS, and NETIO.

C++ APIs Not Supported for Android Platform

The Android platform (armv7leAndroidR8Dgcc4.7) does not support C++ APIs in this release.

Waitset Delete Not Safe For Concurrent Use

A Waitset’s delete() operation is not safe for concurrent use when other threads may be calling any operations of the Waitset. In general, access to a WaitSet should be guaranteed to have ceased before its delete() operation is called.

Partial support of DDS_InstanceHandle_t in C++ API

Type DDS_InstanceHandle_t is the only data type of Connext Micro's public API whose operations have not yet been exposed as C++ methods. For this reasons, users must rely on its C API, which is already available when including the C++ API header.

RTI Connext DDS Micro Version 2.4.9 Copyright © Thu Dec 15 2016 Real-Time Innovations, Inc