This sections explains the supported Orocos targets and the Orocos versioning scheme.

We documented this on the on-line wiki for the various flavours/options one has on the MS Windows platform: RTT on MS Windows

The RTT uses the CMake build system for configuring and building the library.

The tool you will need is cmake Most linux distros have a cmake package, and so do fink/macports in OS X. In Debian, you can use the official Debian version using

  apt-get install cmake

If this does not work for you, you can download cmake from the CMake homepage.

Next, download the orocos-rtt-1.12.1-src.tar.bz2 package from the Orocos webpage and extract it using :

  tar -xvjf orocos-rtt-1.12.1-src.tar.bz2

This section provides quick installation instructions if you want to install the RTT on a standard GNU/Linux system. Please check out Section 2, “Detailed Configuration using 'CMake'” for installation on other OSes and/or if you want to change the default configuration settings.

 
  mkdir orocos-rtt-1.12.1/build 
  cd orocos-rtt-1.12.1/build
  cmake .. -DOROCOS_TARGET=<target> [-DCMAKE_INSTALL_PREFIX=/usr/local] [-DLINUX_SOURCE_DIR=/usr/src/linux]
  make
  make install 

Where

	Note
	See Section 2, “Detailed Configuration using 'CMake'” for specifying non standard include and library paths to search for dependencies.

The make command will have created a liborocos-rtt-<target>.so library, and if CORBA is enabled a liborocos-rtt-corba-<target>.so library.

The make docapi and make docpdf dochtml (both in 'build') commands build API documentation and PDF/HTML documentation in the build/doc directory.

Orocos can optionally ( but recommended) be installed on your system with

 make install

The default directory is /usr/local, but can be changed with the CMAKE_INSTALL_PREFIX option :

	cmake .. -DCMAKE_INSTALL_PREFIX=/opt/other/

If you choose not to install Orocos, you can find the build's result in the build/src directory.

The RTT can be configured depending on your target. For embedded targets, the large scripting infrastructure and use of exceptions can be left out. When CORBA is available, an additional library is built which allows components to communicate over a network.

In order to configure the RTT in detail, you need to invoke the ccmake command:

 
  cd orocos-rtt-1.12.1/build
  ccmake .. 

from your build directory. It will offer a configuration screen. The keys to use are 'arrows'/'enter' to modify a setting, 'c' to run a configuration check (may be required multiple times), 'g' to generate the makefiles. If an additional configuration check is required, the 'g' key can not be used and you must press again 'c' and examine the output.

  cmake .. -DENABLE_CORBA=ON

2.1.2. Embedded RTT flavour

In order to run Orocos applications on embedded systems, one can turn the OS_EMBEDDED option on. Next press 'c' again and additional options will be presented which allow you to select what part of the RTT is used. By default, the OS_EMBEDDED option already disables some 'fat' features. One can also choose to build the RTT as a static library (BUILD_STATIC).

	Warning
	The Embedded flavour is not compatible with the Orocos Component Library (OCL) and should only be enabled for specific setups and only by users that understand the consequences of this flag.

Alternatively, when you can re-run cmake:

  cmake .. -DOS_EMBEDDED=ON

Move to the OROCOS_TARGET, press enter and type on of the following supported targets (all in lowercase):

The xenomai and lxrt targets require the presence of the LINUX_SOURCE_DIR option since these targets require Linux headers during the Orocos build. To use the LibC Kernel headers in /usr/include/linux, specify /usr. Inspect the output to find any errors.

	Note
	From Xenomai version 2.2.0 on, Xenomai configuration does no longer require the --with-linux option.

You can set the compiler flags using the CMAKE_BUILD_TYPE option. You may edit this field to contain:

In case you choose None, you must set the CMAKE_C_FLAGS, CMAKE_CXX_FLAGS manually. Consult the CMake manuals for all details.

Read first the 'Getting Started' section from this page if you are not familiar with RTAI installation

Orocos has been tested with RTAI 3.0, 3.1, 3.2, 3.3, 3.4, 3.5 and 3.6. The last version, RTAI 3.6, is recommended for RTAI users. You can obtain it from the RTAI home page. Read The README.* files in the rtai directory for detailed build instructions, as these depend on the RTAI version.

	Note
	For older Xenomai versions, consult the Xenomai README of that version.

Xenomai provides a real-time scheduler for Linux applications. See the Xenomai home page. Xenomai requires a patch one needs to apply upon the Linux kernel, using the scripts/prepare-kernel.sh script. See the Xenomai installation manual. When applied, one needs to enable the General Setup -> Interrupt Pipeline option during Linux kernel configuration and next the Real-Time Sub-system -> , Xenomai and Nucleus. Enable the Native skin, Semaphores, Mutexes and Memory Heap. Finally enable the Posix skin as well.

When the Linux kernel is built, do in the Xenomai directory: ./configure ; make; make install.

You'll have to specify the install directory in the XENOMAI_INSTALL_DIR option during 'ccmake'.

In case your application benefits from remote access over a network, the RTT can be used with 'The Ace Orb' ( TAO) or OMNIORB-4. The RTT was tested with TAO 1.3.x, 1.4.x, 1.5x and 1.6.x and OMNIORB 4.1.x. There are two major TAO development lines. One line is prepared by OCI (Object Computing Inc.) and the other by the DOC group. You can find the latest OCI TAO version on OCI's TAO website. The DOC group's TAO version can be found on the Real-time CORBA with TAO (The ACE ORB) website. Debian and Ubuntu users use the latter version when they install from .deb packages.

If you need commercial support for any TAO release or seek expert advice on which TAO version or development line to use, consult the commercial support website.

2.6.1. TAO installation (Optional)

	Important
	Debian or Ubuntu users can skip this step and just do sudo aptitude install libtao-orbsvcs-dev tao-idl gperf-ace tao-naming . Orocos software will automatically detect the installed TAO software.

Note

If your distribution does not provide the TAO libraries, or you want to use the OCI version, you need to build manually. These instructions are for building on Linux. See the ACE and TAO installation manuals for building on your platform. Orocos requires the ACE, TAO and TAO-orbsvcs libraries and header files to be installed on your workstation. If you used manual installation, the ACE_ROOT and TAO_ROOT variables must be set.

You need to make an ACE/TAO build on your workstation. Download the package here: OCI Download. Unpack the tar-ball, and enter ACE_wrappers. Then do: export ACE_ROOT=$(pwd) export TAO_ROOT=$(pwd)/TAO Configure ACE for Linux by doing: ln -s ace/config-linux.h ace/config.h ln -s include/makeinclude/platform_linux.GNU include/makeinclude/platform_macros.GNU Finally, type: make cd TAO make cd orbsvcs make This finishes your TAO build.

  cmake .. -DENABLE_CORBA=ON -DCORBA_IMPLEMENTATION=OMNIORB 

  cmake .. -DENABLE_CORBA=ON -DCORBA_IMPLEMENTATION=TAO 

To quickly test an Orocos application, you can download the examples from the webpage on Component template, which contains a suitable CMake environment for building components or RTT Examples which contains a variety of demo programs.

If you built the RTT yourself, you can issue a

 cmake .. -DENABLE_TESTS=ON
 make check

in the build directory, which will test the RTT against your current target.

The first question asked by many users is : How do I write a test program to see how it works?

Some care must be taken in initialising the realtime environment. First of all, you need to provide a function int ORO_main(int argc, char** argv) {...}, defined in <rtt/os/main.h> which contains your program :

  #include <rtt/os/main.h>
	      
  int ORO_main(int argc, char** argv)
  {
     // Your code, do not use 'exit()', use 'return' to 
     // allow Orocos to cleanup system resources.
  } 

If you do not use this function, it is possible that some (OS dependent) Orocos functionality will not work.

You can quick-start build components using the Orocos Component Template package which you can download from the OCL download page, which uses CMake. If you do not wish to use CMake, you can use the example below to write your own Makefiles.

Example 1. A Makefile for an Orocos Application or Component

You can compile your program with a Makefile resembling this one :

  OROPATH=/usr/local

  all: myprogram mycomponent.so

  # Build a purely RTT application for gnulinux.
  # Use the 'OCL' settings below if you use the TaskBrowser or other OCL functionality.
  #
  CXXFLAGS=`PKG_CONFIG_PATH=${OROPATH}/lib/pkgconfig pkg-config orocos-rtt-gnulinux --cflags`
  LDFLAGS=`PKG_CONFIG_PATH=${OROPATH}/lib/pkgconfig pkg-config orocos-rtt-gnulinux --libs`

  myprogram: myprogram.cpp
        g++ myprogram.cpp ${CXXFLAGS} ${LDFLAGS} -o myprogram


  # Building dynamic loadable components requires the OCL to be installed as well:
  #
  CXXFLAGS=`PKG_CONFIG_PATH=${OROPATH}/lib/pkgconfig pkg-config orocos-ocl-gnulinux --cflags`
  LDFLAGS=`PKG_CONFIG_PATH=${OROPATH}/lib/pkgconfig pkg-config orocos-ocl-gnulinux --libs`

  mycomonent.so: mycomponent.cpp
        g++ mycomponent.cpp ${CXXFLAGS} ${LDFLAGS} -fPIC -shared -DOCL_DLL_EXPORT  -o mycomponent.so

Where your replace gnulinux with the target for which you wish to compile. If you use parts of the OCL, use the flags from orocos-ocl-gnulinux.

We strongly recommend reading the Deployment Component manual for building and loading Orocos components into an application.

These flags must be extended with compile and link options for your particular application.

	Important
	The LDFLAGS option must be placed after the .cpp or .o files in the gcc command.

	Note
	Make sure you have read Section 2, “Detailed Configuration using 'CMake'” for your target if you application has compilation or link errors ( for example when using LXRT ).