HOWTO Run RTI Connext DDS on Raspberry Pi

1 Introduction

RTI has recently released a community port of RTI Connext DDS for Raspberry Pi, an inexpensive credit-card-sized single-board computer with an ARM processor. RTI Connext DDS is RTI's implementation of the OMG Data Distribution Service specification. 

This HOWTO describes the steps you need to follow to set up your machine to build DDS applications able to run on a Raspberry Pi. We will use a cross-compiler that can be run on a 32- or 64-bit Linux machine, but we will also provide some links with documentation to cross-compile from different platforms.

The document is organized as follows:

• Section 2 explains how to set up your Raspberry Pi to run a supported version of Raspbian.
• Section 3 shows how to install RTI Connext DDS on your Linux host.
• Section 4 explains how to install the RTI Connext DDS libraries for Raspberry Pi on your Linux host.
• Section 5 describes the steps you need to follow to set up a cross-compiling environment for Raspberry Pi.
• Section 6 illustrates the development of DDS applications for Raspberry Pi.

2 Install Raspbian

Before installing RTI Connext DDS on your Raspberry Pi check that you have a supported image of Raspbian (hard-float ABI) installed in your SD. You can downloaded the latest version from the RaspberryPi repository or Raspian Images. We have tested our application on several versions starting with 2012-10-28-wheezy-raspbian images up to 2016-05-27-raspbian-jessie. If you find any issue running DDS applications on newer images, post a comment and we will look into it.

2.1 Install Raspbian image into the SD card

First, download and unzip the latest image (e.g., 2016-05-27-raspbian-jessie).

unzip 2016-05-27-raspbian-jessie.zip

To copy the image to the SD card, on Unix-based systems (e.g., Linux or MacOSX) you will need to use the dd command. If you are using Windows, use Win32DiskManager.

Note: This tutorial covers the process on Linux and MacOSX environments, you can find instructions on how to install the image from a Windows system here.

Before copying the image to the SD card, identify the device name comparing the results of df -h before and after inserting the SD card on your machine.

On Linux, the filesystem returned by df -h will be something like /dev/mmcblk0p1 (device name is /dev/mmcblk0 and partition number is p1) or /dev/sdd1 (device name is /dev/sdd and partition number is 1).

df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        19G  7.6G   11G  42% /
udev            494M  4.0K  494M   1% /dev
tmpfs           201M  812K  200M   1% /run
none            5.0M     0  5.0M   0% /run/lock
none            501M  124K  501M   1% /run/shm
/dev/sdd1        56M   17M   39M  30% /media/Untitled

On MacOSX, the filesystem returned by df -h will be something like /dev/disk3s1, where /dev/disk3 is the device name and s1 is the partition number.

df -h
Filesystem      Size   Used  Avail Capacity  Mounted on
/dev/disk0s2   465Gi  439Gi   26Gi    95%    /
devfs          112Ki  112Ki    0Bi   100%    /dev
map -hosts       0Bi    0Bi    0Bi   100%    /net
map auto_home    0Bi    0Bi    0Bi   100%    /home
/dev/disk3s1    56Mi   35Mi   21Mi    63%    /Volumes/Untitled

Once you have identified the device name, unmount the file system (if your SD card has more than one partition unmount all of them).

On Linux:

umount /media/Untitled

On MacOSX:

sudo umount /Volumes/Untitled

Now, copy the image to the SD card using the dd command. You should use the device name without the partition name (e.g., if the device name was /dev/sdd1 set of=/dev/sdd).

Note: You will lose all data stored on the device so be EXTREMELY CAREFUL specifying the right device.

On Linux, as indicated here, setting block size (bs) to 4M will work most of the time, try 1M if the process fails.

dd bs=4M if=/path/to/2016-05-27-raspbian-jessie.img of=/dev/sdd

On MacOSX, use /dev/rdiskX instead of /dev/diskX when specifying the output file (e.g., if the device name was /dev/disk3s1 set of=/dev/rdisk3). Set block size to 1m, as indicated here.

dd bs=1m if=/path/to/2016-05-27-raspbian-jessie.img of=/dev/rdisk3

If you get a "permission denied" error, triple-check you are specifying the right device on the of= argument and the use sudo as in:

sudo dd bs=1m if=/path/to/2016-05-27-raspbian-jessie.img of=/dev/rdisk3

Finally, remove the SD card, put into the Raspberry Pi board and boot the board. You should have a monitor and a keyboard attached to the Raspberry Pi. You will see the board boot logging the process to the screen.

On the older raspbian images after the board finished booting the display would show the Rasbpain configuration screen.

On the newer Raspbian images after the boot the window system will start directly the LXDE desktop:

2.2 Configure Raspbian

The first time you boot the Raspberry Pi you will see a configuration menu with some actions. These are the actions we recommend you to do:

• Expand root partition to fill SD card (expand_rootfs).
• Change the password for the "pi" user (by default username is "pi" and password "raspberry").
• Enable SSH server to allow remote access.

In the older Raspbian distributions this was done using the Raspbian configuration screen. In the newer ones with the LXDE desktop you need to go to the Raspberry menu and select "Preferences->Raspberry Pi Configuration" this will bring a configuration dialog (see below) where you can perform the actions listed above.

Once you are finished configuring the system, reboot the Rasbperry Pi. If you are using the older images with the special config screen you can access the configuration menu again running the command raspi-config as root. On the newer images it is available from the Raspberry menu.

2.3 Connect to the Raspberry over Ethernet

The easiest way to download the software into the Raspberry Pi is to use the ethernet connection. The older Raspberry Pis (up to model 2) did not include a wireless Ethernet adaptor so to simplify things the instrutions assume you are using the wired ethernet connector.

There are two approaches to this:

1. Use a DHCP-capable router.
2. Configure the IP address manually.

2.3.1 Option 1: Use a DHCP-capable Router

The simplest option is to plug the Raspberry to a DHCP enabled router/switch. If you have one of these routers, you can connect the Raspberry Pi to one of the ports and the router will automatically assign an IP address to the Raspberry Pi automatically.

If this process succeeds you will be able to see the IP address using the ifconfigcommand:

pi@raspberrypi ~ $ ifconfig
eth0      Link encap:Ethernet  HWaddr b8:27:eb:03:24:b0  
          inet addr:192.168.33.10  Bcast:192.168.33.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:227 errors:0 dropped:0 overruns:0 frame:0
          TX packets:88 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:21872 (21.3 KiB)  TX bytes:17740 (17.3 KiB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

Here we see that the router assigned the IP address 192.168.33.10 to the eth0 interface on the Raspberry Pi.

2.3.2 Option 2: Configure the IP Address Manually

If you do not have a DHCP enabled router available you can connect the Raspberry Pi directly to the Ethernet port of another computer. You can use a regular Ethernet cable (no need for a so-called crossover cable) as the Raspberry Pi is smart enough to detect the direct connection.

If you connect your laptop or PC directly to the Raspberry Pi with an ethernet cable you also need to set the IP addresses manually as there is no DHCP server to assign them to the Raspberry Pi.

It is possible that when you connect the ethernet cable from the host to the Raspberry Pi, the host's network interface has already an auto-assigned IP address (e.g., 169.254.x.x). You can check that by typing ifconfigon Linux or MacOSX (or ipconfig on Windows). For instance, on MacOSX you will see something like:

ifconfig
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
	inet6 ::1 prefixlen 128 
	inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 
	inet 127.0.0.1 netmask 0xff000000 
gif0: flags=8010<POINTOPOINT,MULTICAST> mtu 1280
stf0: flags=0<> mtu 1280
en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500
	ether 58:b0:35:fe:09:22 
	inet6 fe80::5ab0:35ff:fefe:922%en0 prefixlen 64 scopeid 0x4 
	inet 169.254.71.49 netmask 0xffff0000 broadcast 169.254.255.255
	media: autoselect (100baseTX <full-duplex,flow-control>)
	status: active
en1: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500
	ether 90:27:e4:e8:f1:e8 
	inet6 fe80::9227:e4ff:fee8:f1e8%en1 prefixlen 64 scopeid 0x5 
	inet 10.30.1.124 netmask 0xffffff00 broadcast 10.30.1.255
	media: autoselect
	status: active

In this case, en0 (the name MacOSX uses for the wired ethernet interface) was assigned the address 169.254.71.49 with the mask 0xffff0000 (i.e., 255.255.0.0).

If the host has an IP address, you only need to configure manually the address on the Raspberry Pi. If the host does not, you need to configure manually the IP address on both the host and the Raspberry Pi.

In our situation we only needed to configure manually the Raspberry Pi. To do this we need to choose an IP address that is on the same network as the host, for instance 169.254.71.1 as it is on the same 169.254.x.x network. You can set this IP address on the Raspberry Pi is done using the ifconfig command:

sudo ifconfig eth0 169.254.71.1 netmask 255.255.0.0 up

Once you have set the IP address you can use SSH to log in from your host using the username "pi" and the password you set on section 2.2. If you did not change the password, use "raspberry", which is the one configured by default. The messages below will vary depending on your host and raaspbian image.

ssh pi@169.254.71.1
The authenticity of host '169.254.71.1 (169.254.71.1)' can't be established.
RSA key fingerprint is ba:8a:bf:90:a0:42:fb:ba:34:74:03:b3:2d:55:50:f4.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '169.254.71.1' (RSA) to the list of known hosts.
pi@169.254.71.1's password: 
Linux raspberrypi 3.2.27+ #250 PREEMPT Thu Oct 18 19:03:02 BST 2012 armv6l

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Sun Dec 16 21:32:50 2012 from 169.254.71.49
pi@raspberrypi ~ 

Note: If you want to set manually the IP address on both host and the Raspberry Pi you will need to pick two IP addresses. We recommend you to use addresses that fall in the private IP range. For instance, two in the 192.168.x.x range: 192.168.1.1 and 192.168.1.2. These addresses use a 255.255.255.0 mask. On the Raspberry Pi run:

sudo ifconfig eth0 192.168.1.1 netmask 255.255.255.0 up

If you are using a Linux host (assuming you are using the eth0 interface) run:

sudo ifconfig eth0 192.168.1.2 netmask 255.255.255.0 up

On MacOSX host (assuming you are ussing the en0 interface run the following command (you can also use the GUI under system utilities):

sudo ifconfig en0 192.168.1.2 netmask 255.255.255.0 up

2.3.3 Configure the Raspberry Pi get the same assigned IP each time it boots

If you want to setup the Raspberry Pi as a headless device—and you anticipate you will not be able to connect it to a DHCP-enabled router—you need to configure it so that it gets a manual IP address each time it boots. The effect of the ifconfig command only lasts until the next reboot, so you boot the Raspberry Pi headless (i.e., operating without a monitor, keyboard, and mouse) you will not be able to connect to it.

To configure the Rasberry Pi to get a specific IP address each time it boots, edit /etc/network/interfaces as root:

# Comment out the following line:
# iface eth0 inet dhcp

# And add the following lines instead:
iface eth0 inet static
address 169.254.71.1
netmask 255.255.0.0

The next time you reboot and connect the ethernet cable to the Rasberry Pi, it will have the assigned IP address and you will be able to SSH directly to it.

Note: Remember to revert these changes if you ever want to connect to a router and get an address automatically assigned via DHCP.

3 Install RTI Connext DDS on your Linux Host

The next thing you need is to do is to set up a Linux computer with the RTI Connext DDS Host development bundles. There are two ways in which you can do this:

1. Downloading a bundle/installer from the RTI Support Portal.
2. Downloading the RTI Open Community Source, free Evaluation, or University bundles.

3.1 Option 1: Install RTI Connext DDS from the RTI Support portal

If you have purchased a support contract, and you have an account on the RTI Support Portal you can download the Linux Host bundles from it.

You can use any of the options bellow, as RTI Connext Professional includes RTI Connext Messaging, which itself includes RTI Connext DDS.

• RTI Connext DDS Core bundles:
• On 32-bit Linux: rti_connext_dds-5.2.3-core-host-i86Linux.run
• On 64-bit Linux: rti_connext_dds-5.2.3-core-host-x64Linux.run
• RTI Connext DDS Basic bundles:
• On 32-bit Linux: rti_connext_dds-5.2.3-basic-host-i86Linux.run
• On 64-bit Linux: rti_connext_dds-5.2.3-basic-host-x64Linux.run
• RTI Connext DDS Professional bundles:
• On 32-bit Linux: rti_connext_dds-5.2.3-pro-host-i86Linux.run
• On 64-bit Linux: rti_connext_dds-5.2.3-pro-host-x64Linux.run

3.2 Option 2: Download the RTI Connext free evaluation, the Open Community Source, or the University & IR&D bundles

If you do not want to use the RTI Live CD and you cannot access the RTI support portal, you can download RTI Connext from here. This link gives you access to the free RTI DDS Open Community Source, the free University and IR&D bundles, and also the full Connext DDS Product and Tools under an evaluation license.

4 Install RTI Connext DDS 5.2.3 libraries for Raspberry Pi on your Linux host

For this step we assume that you have completed the previous step and you have installed RTI Connext DDS under some directory on your Linux host. In the following we assume your installation directory is /home/rticonnext/rti_connext_dds-5.2.3.

The first step is to download and install the RTI Connext DDS 5.2.3 target libraries for Raspberry Pi. These libraries are distributed as an rtipkg file that needs to be installed using the rtipkginstall utility distributed along with RTI Connext DDS. You have the following options to download the Connext DDS libraries for Raspberry Pi:

• RTI customers can download the appropriate rtipkg target package from the RTI Support Portal:
• rti_connext_dds-5.2.3-core-target-armv6vfphLinux3.xgcc4.7.2.rtipkg
• rti_connext_dds-5.2.3-basic-target-armv6vfphLinux3.xgcc4.7.2.rtipkg
• rti_connext_dds-5.2.3-pro-target-armv6vfphLinux3.xgcc4.7.2.rtipkg
• Evaluation, Open Community Source, or University & IR&D users can download it from the RTI Community Portal:
• rti_connext_dds-5.2.3-core-target-armv6vfphLinux3.xgcc4.7.2.rtipkg

Once you have download the appropriate rtipkg, you can install it as follows:

cd /home/rticonnext/rti_connext_dds-5.2.3
./bin/rtipkginstall ~/Downloads/rti_connext_dds-5.2.3-core-target-armv6vfphLinux3.xgcc4.7.2.rtipkg

You will see all the library files installed under the rti_connext_dds-5.2.3/lib directory:

ls ./lib/armv6vfphLinux3.xgcc4.7.2
libnddscd.so     libnddscorezd.a  libnddscppzd.a
libnddscored.so  libnddscppd.so   libnddsc.so
libnddscore.so   libnddscpp.so    libnddscz.a
libnddscorez.a   libnddscppz.a    libnddsczd.a

Note that in addition to the libraries, the utility programs rtiddsping, rtiddsspy, and rtiddsprototyper are all available to run on the Raspberry Pi.

Now, you can start building DDS applications for the Raspberry Pi.

Note: If you compile your application statically against the RTI Connext DDS libraries, you will not need to install these libraries on your Raspberry Pi. However, if you link RTI Connext DDS libraries dynamically, you will need follow the instructions above to also install RTI Connext onto the Raspberry Pi itself. If you do this, remember also to set the LD_LIBRARY_PATH environment variable on the Raspberry Pi to include the directory rti_connext_dds-5.2.3/lib/armv6vfphLinux3.xgcc4.7.2. For example, if you copied the RTI Connext DDS installation into your Raspberry under /home/pi/rti_connext_dds-5.2.3 you will need to set LD_LIBRARY_PATHas follows:

export LD_LIBRARY_PATH=/home/pi/rti_connext_dds-5.2.3/lib/armv6vfphLinux3.xgcc4.7.2:$LD_LIBRARY_PATH

5 Set up linux Cross-compiling Environment for Raspberry Pi

The Raspberry Pi has limited resources compared to a regular desktop PC. Development and compilation on the Raspberry Pi tends to be quite slow. For this reason, we normally cross-compile most applications. That is, we compile the application in a different machine (e.g., a regular x86 Linux desktop) using a cross-compiler able to create binaries for the ARM 6 processor used by the Raspberry Pi.

There are two ways to do this:

1. Use an existing toolchain for cross-compilation to the Raspberry Pi.
2. Create your own toolchain for cross-compilation to the Raspberry Pi.

5.1 Option 1 [Recommended]: Use an existing toolchain for cross-compilation

You can find many toolchains including cross-compilers capable of creating code that can be run on the Raspberry Pi. In this section, we show you how to use toolchains built by RTI for 32- and 64-bit Linux environments. If you want to build your own toolchain, see instructions on Section 5.2. If you want to build applications on Windows, take a look at this tutorial.

Download the Raspberry Pi toolchain for your platform into a suitable directory (e.g., under /home/rticonnext/toolchains).

mkdir -p /home/rticonnext/toolchains
cd /home/rticonnext/toolchains

On 32-bit Linux:

wget https://s3.amazonaws.com/RTI/Community/ports/toolchains/raspbian-toolchain-gcc-4.7.2-linux32.tar.gz
tar xvzf raspbian-toolchain-gcc-4.7.2-linux32.tar.gz

On 64-bit Linux:

wget https://s3.amazonaws.com/RTI/Community/ports/toolchains/raspbian-toolchain-gcc-4.7.2-linux64.tar.gz
tar xvzf raspbian-toolchain-gcc-4.7.2-linux64.tar.gz

Now that you have the toolchain, add its bin directory to the path. Assuming you are using BASH in a 32-bit environment, run:

export PATH=/home/rticonnext/toolchains/raspbian-toolchain-gcc-4.7.2-linux32/bin:$PATH

If you want these changes to be permanent on your system, assuming again you are using BASH, add the line above to ~/.bashrc.

5.2 Option 2: Build your own toolchain for cross-compilation to Raspberry Pi

Building a custom toolchain gives you great flexibility, as it allows you to tune the compiler for a specific target. In this tutorial we show you how to use Crosstool-ng—a toolchain generator for more than 40 platforms—to generate a toolchain to compile for your Raspberry Pi.

5.2.1 Install Crosstool-ng

To configure and compile Crosstool-ng you need to install some dependencies in your system. Assuming you are using Ubuntu (in other distributions package names will be quite similar) run:

sudo apt-get install bison flex texinfo gperf gawk libtool automake libncurses5-dev subversion

Now download, extract, compile, and install crosstool-ng. Assuming you want to install Crosstool-ng under /home/rticonnext/build_tools/crosstool-ng-1.17 run:

wget http://crosstool-ng.org/download/crosstool-ng/crosstool-ng-1.17.0.tar.bz2
tar xvjf crosstool-ng-1.17.0.tar.bz2
cd crosstool-ng-1.17.0
mkdir -p /home/rticonnext/build_tools/crosstool-ng-1.17
./configure --prefix=/home/rticonnext/build_tools/crosstool-ng-1.17
make
make install

5.2.2 Configure and build the toolchain

Once you have compiled Crostool-ng, you can configure and build a toolchain for the Raspberry Pi:

/home/rticonnext/build_tools/crosstool-ng-1.17/bin/ct-ng menuconfig

Note: This will create a .config file under the working directory with your configuration (and a .build directory with all the binaries that will be copied later to the directory you want to install the toolchain on). We recommend you to run these commands from a place you can remove the files from once you are done building your toolchain.

In the configuration menu, edit the following options:

• Paths and misc options
  • Try features marked as EXPERIMENTAL
  • In prefix directory indicate the directory where you want your toolchain. In this case: ${HOME}/toolchains/raspbian-toolchain-gcc-4.7.2-linux32
• Target options
  • Target architecture: arm
  • Endianness: Little endian
  • Bitness: 32-bit
  • Floating point: hardware (FPU)
• Toolchain options
  • Build static toolchain (Experimental)
  • Toolchain bug url: http://community.rti.com
  • Tuple's vendor string: raspbian
  • Tuple's alias: arm-linux-gnueabihf
• Operating system
  • Target OS: Linux
  • You can also select the kernel version you run in your target. In this case, use 2.6.32.60.
• C compiler
  • C compiler: gcc
  • gcc version: 4.7.2
  • In additional supported languages add C++

Once you are done with your configuration, run:

/home/rticonnext/build_tools/crosstool-ng-1.17/bin/ct-ng build

This toolchain building process takes quite long. Once the toolchain is ready, you should find it under /home/rticonnext/toolchains/raspbian-toolchain-gcc-4.7.2-linux32 (or the directory you selected when you run ct-ng menuconfig).

Now that you have the toolchain, add its bin directory to the path. Assuming you are using BASH in a 32-bit environment, run:

export PATH=/home/rticonnext/toolchains/raspbian-toolchain-gcc-4.7.2-linux32/bin:$PATH

6 Compile and Run a Hello World Example

To validate your installation you can build a "hello world" application in C++ and Java using rtiddsgen in your own machine. You will generate and and edit the source files in your machine, cross-compile the code, and copy the executables to your Raspberry Pi.

6.1 C++ Example

First, create a file called hello.idl with the following content:

struct hello_message {
   string name; //@key
   long count;
};

Use rtiddsgen to generate a C++ example for the Raspberry Pi platform:

./bin/rtiddsgen -example armv6vfphLinux3.xgcc4.7.2 -language C++ hello.idl

Note: Remember to export the NDDSHOME environment variable and include the toolchain bin/ directory in the PATH and as we explained in Sections 4 and 5.1.

The rtiddsgen utility generates several files, including a makefile and two source files with the publisher and subscriber applications. Now, edit hello_publisher.cxx and add some data to be sent. To do this, look for the comment "/* Modify the data to be sent here */" in the C++ source file and add the code highlighted here:

       printf("Writing hello_message, count %d\n", count);

       /* Modify the data to be sent here */
       strcpy(instance->name, "Fernando");
       instance->count = count;

       retcode = hello_message_writer->write(*instance, instance_handle);
       if (retcode != DDS_RETCODE_OK) {
           printf("write error %d\n", retcode);
       }

       NDDSUtility::sleep(send_period);

To build the examples, use the makefile generated by rtiddsgen.

make -f makefile_hello_armv6vfphLinux3.xgcc4.7.2

Finally, copy the executables and the XML file with the default QoS settings for the example to the Raspberry Pi (e.g., to /home/pi/examples), and run the publisher and subscriber applications.

scp objs/armv6vfphLinux3.xgcc4.7.2/hello_publisher \
pi@<raspberrypi_ip>:/home/pi/example/
scp objs/armv6vfphLinux3.xgcc4.7.2/hello_subscriber \
pi@<raspberrypi_ip>:/home/pi/example/
scp USER_QOS_PROFILES.xml pi@<raspberrypi_ip>:/home/pi/example/
ssh pi@
cd /home/pi/example
./hello_publisher
Writing hello_message, count 0
Writing hello_message, count 1
Writing hello_message, count 2
Writing hello_message, count 3
./hello_subscriber 
hello_message subscriber sleeping for 4 sec...

  name: "Fernando"
  count: 1
hello_message subscriber sleeping for 4 sec...

  name: "Fernando"
  count: 2
hello_message subscriber sleeping for 4 sec...

  name: "Fernando"
  count: 3

6.2 Java Example

In this example we will show you how to generate code for Java and how to run it on your Raspberry Pi. We assume that you already have JDK installed on your device.

6.2.1 Create RTI Connext Java Example

Just like in the C++ example, create a file called hello.idl with the following content in your computer:

struct hello_message {
   string name; //@key
   long count;
};

Use rtiddsgen to generate a Java example for the Raspberry Pi platform (armv6vfphLinux3.xgcc4.7.2 in this case). Remember to set NDDSHOME to the right path before running the rtiddsgen.

./bin/rtiddsgen -example armv6vfphLinux3.xgcc4.7.2 -language java hello.idl

Edit hello_messagePublisher.java and add some data to be sent. To do this, look for the comment "/* Modify the data to be sent here */" in the Java source file and add the code highlighted here:

                System.out.println("Writing hello_message, count " + count);

                /* Modify the instance to be written here */
                instance.name = "Fernando";
                instance.count = count;

                /* Write data */
                writer.write(instance, instance_handle);
                try {
                    Thread.sleep(sendPeriodMillis);
                } catch (InterruptedException ix) {
                    System.err.println("INTERRUPTED");
                    break;
                }

Although you can generate the Java .class files in your Raspberry Pi, "cross-compiling" the .class files from your computer will be much faster. 

make -f makefile_hello_armv6vfphLinux3.xgcc4.7.2

Now, copy the example to the Raspberry Pi (e.g., to /home/pi/examples).

scp -r /path/to/example_dir pi@<raspberrypi_ip>:/home/pi/example

6.2.3 Run RTI Connext Java Example

Finally, using the makefile we ship with the example, run the publisher and subscriber applications. Remember to set NDDSHOME to the right path before running the applications.

Note: At runtime, the example Java example needs to load the runtime libraries under lib/armv6vfphLinux3.xgcc4.7.2 and the JAR files under lib/java. That implies that you must copy either the RTI Connext DDS installation or the corresponding lib folder into your Raspberry Pi. Once you have those libraries, setting the NDDSHOME environment variable to point to the parent folder of lib, should suffice.

ssh pi@<raspberrypi_ip>
cd /home/pi/example
 
make -f makefile_hello_armv6vfphLinux3.xgcc4.7.2 hello_messagePublisher
javac -classpath .:/home/pi/rti_connext_dds-5.2.3/lib/java/nddsjava.jar hello_messagePublisher.java
java -classpath ".:/home/pi/rti_connext_dds-5.2.3/lib/java/nddsjava.jar" hello_messagePublisher
Writing hello_message, count 0
Writing hello_message, count 1
Writing hello_message, count 2
Writing hello_message, count 3
Writing hello_message, count 4

make -f makefile_hello_armv6vfphLinux3.xgcc4.7.2 hello_messageSubscriber
java -classpath ".:/home/pi/rti_connext_dds-5.2.3/lib/java/nddsjava.jar" hello_messageSubscriber
hello_message subscriber sleeping for 4 sec...
hello_message subscriber sleeping for 4 sec...
Received:
 name: Fernando
count: 0

hello_message subscriber sleeping for 4 sec...
Received:
    name: Fernando
    count: 1

hello_message subscriber sleeping for 4 sec...
Received:
    name: Fernando
    count: 2

hello_message subscriber sleeping for 4 sec...
Received:
    name: Fernando
    count: 3