Ludwig-Erhard-Allee 10, 76131 Karlsruhe


The Distributed Object Model Environment – DOME – is an approach to connect objects, located on different computers, with each other.

Besides the concept itself, DOME includes also a portable runtime environment. DOME might be run on Unix-based operating systems, as well as on Windows. DOME has been developed for the use in automation technology plants and therefore can be run on diverse computer platforms – also with realtime constraints.

For engineering, graphic tools are available with which on the one hand the object code can be implemented in a programming language like for example C++, as well as the connection of the objects and their distribution on computers can be managed.

As an option, the application might be designed with the help of state machines.


Object oriented programming in automation is based on the concept of Function Blocks. With those, algorithms can be processed easily and encapsulated, however the exact time, the Function Block is executed, cannot directly be seen in the Function Block Diagram and varies depending on the control system which normally processes the Function Blocks in cyclical order.

However, this paradigm complicates the collaboration between equally important components, e.g. between the control systems, To solve this problem, additional engineering hours have to be planned, since these connections have to be modelled explicitly.

Control system for different tasks

Distributed systems for tomorrow’s automation

Event-oriented activation of the Function Blocks might solve this problem, however it has to be considered to plan the flow of data and the flow of events independently. Interoperability of control components of different vendors can however not be granted.

The engineering of cooperating components can be simplified by including facets of distributed systems in the automation. Integration ability of all components will be increased significantly.

The design of the application can be drawn completely independent of hardware restrictions. It can be tested in advance by simplified simulation models and can be commissioned virtually. In a second step implementation e.g. the allocation of one automation function to a hardware component can be processed.


  • Simplicity of Applicationen
  • Flexibility by means of late binding ⇒ Basis for Plug & Play
  • Type safe Data- and Information flow
  • Portability & Efficiency
  • Object-oriented Approach
  • Support of Real-time Features of Hard- and Firmware
  • Introspection / Browsing the Application / Controller
  • Reuse of Function Block Paradigm  ⇒ Modularization and Scalability of the Automation System
  • Clock Synchronisation by means of  IEEE 1588 (PTP), also for Microsoft Windows
  • Distributed Exception-Handling

DOME – Distributed Object Model Environment – describes the model of a distributed system especially designed for automation. Besides the distribution aspect, the focus lies on the object oriented design of the application, thus achieving a high reusability performance of the algorithms used on a high level of abstraction.

A DOME-application consists of a network of objects, connected by explicit interfaces via ports. Ports offering services are so-called Service-Ports, ports using services via interfaces are so-called Required-Ports.

Objekts are connected via ports

In the application design, the Link-Objects are initially set as placeholders and are only instantiated automatically during the runtime of the application, thus granting that the automation objects can be placed almost arbitrarily on the hardware-components.

Another feature of DOME is the part-application´s introspection on every hardware node. Thus the structure of all distributed applications, i.e. all objects and their connections, can be observed.

In a hardware-node, objects are handled in one or more processes, whereby they are connected among each other according to the automation´s requirements.

The following kind of connections are possible:

  • Process locally
    • synchronous (the calling port blocks; the responses can be evaluated)
    • asynchronous (the calling port does not wait)
  • Interprocess (also across nodes)
    • synchrous
    • asynchronous

To engineer a DOME application there is a difference between setting up / programming an automation object (in analogy to a function block) and the application per se. The automation object is written in the language DOME-L, based on object-oriented languages such as C++ or Java and considering only special features like the definition of the ports, the documentation for users and so on. Therefore, for the commissioning and the diagnosis of errors, basic tools can be used.

A DOME application only consists of automation objects and the connections among them.

Therefore, describing a DOME application is very easy and a configuration language called DOME-C might be used. For each process in a distributed application configuration data are created by the engineering system or might be edited manually.

The DOME manager is another important component, which is running on every hardware node. All DOME processes register and unregister at this manager. Furthermore, this DOME manager is the first point for introspection and for the establishment of the communication between processes of a distributed application.

Information exchange between local and remote objects


The commissioning and any access to a DOME application may be done based on public interfaces. There is a tool called ‘reperio’. It is able to connect with a DOME manager at any node in a network. By means of the DOME manager the ‘reperio’ requests all information about the running DOME process and offers the option to inspect the whole node. Thus all link objects and automation objects can be displayed graphically.

A complete engineering development environment (IDE) is also available. The IDE is dedicated to develop algorithms of the automation objects and to configure the nodes, executing the distributed application. This IDE is called ‘DOME Engineering’ and is avalibale for Microsoft operating systems only. It includes cross compilers for the target nodes. In addition the application development may be done by using State Machines and to distribute them to the dedicated nodes.


Distributed application by means of DOME. Following pages describe the concept more in detail.

The figure alongside illustrates a distributed application consisting of 5 objects running on 3 nodes or devices.

What is DOME?

At first DOME is a concept to create distributed automation applications based on objects. These objects may be executed on the node with best fitting characteristics. Secondly, DOME is a high efficient runtime available for several platforms.


This means, DOME is portable to different operation systems and also portable on different hardware architectures. Besides the distribution and portability, object orientation and re-usability of the application is one important design objective.

A DOME application consists of a network of objects connected by means of dedicated connection points, so called ports. By means of such ports, objects offer services or use services from other objects.

In addition there are link-objects connecting the ports. Link-objects are defined during engineering. The runtime is responsible to establish the connections. This is done dynamically, thus applications may be redesigned at runtime.

Furthermore DOME offers introspection. Each node running DOME may be inspected in detail. This means, running applications, objects, their links, object properties etc. can be seen at runtime. No special debugging tools are required for this.


DOME is a ideal platform to implement Industrial Cyber Physical Systems (CPS). It allows to load these parts of the overall application on a dedicated node needing access to the physical process to control. Also for small IoT application DOME can be used, because the footprint is so small.


DOME runtime is performant, because it is developed in C++. Thus no interpreter or just in time compiler influence the performance. Also the objects building the application will be executed in the machine code of the dedicated hardware architecture. Also the footprint for scheduling the port invocation is very small.

DOME uses an optimized communication protocol. This can be mapped e.g. on different Ethernet based protocols like UDP or TCP and does not imply an protocol overhead like HTML or Web Services.


As mentioned above DOME runtime is portable. There is a operation system and hardware abstraction, but this abstraction layer is less as possible. DOME is running from small platforms like Raspberry PI up to powerful Industrial PCs (IPC).

DOME requires an operating system (32 or 64 bits), offering basic services. At the moment, DOME is running on different Linux distributions, NetBSD, FreeBSD or Windows systems.


DOME is designed to run on shop floor. Vertical data integration is supported by means of provided client functionality e.g. implemented in .Net or also natively in C++.

Clock synchronization

Basis requirement in distributed systems is a synchronized time base on all involved nodes. DOME runtime has integrated a clock synchronization functionality based on Precision Time Protocol (PTP), defined in IEEE 1588 and IEC 61588. Depending on available hardware and network topology this concept allows a synchronization lower than 1ms between the nodes.

Realizable control concepts

Different control concepts can be realized with DOME. Main classification may be open- or closed-loop control. In automation especially closed-loop control is of special interest. Feedback can given to the controller object(s) in two principle ways:

  • synchronous, blocked invocation of a port –> feedback can be the return value or output parameters (this represents in principle the client-server paradigm of method invocations or remote function invocations)
  • asynchronous, non-blocked invocation of a port –> the caller does not wait for the result, feedback is provided by means of a second non-blocking port

This page is explaining who to get and setup DOME onto your computer or embedded hardware .

Install the runtime


Download the setup for the DOME runtime for Windows and execute the setup program.


The DOME runtime for Windows is installed implicitly during installation of the DOME Studio engineering tool. Thus, if you want to use the PC also as engineering platform, separate runtime installation is not necessary.


Debian based distributions

The Debian package will be provided on demand. After receiving the package install it:

   sudo apt-get install dome_runtime.deb

Raspberry Pi

For this platform we provide a specific boot image. Download this image and copy it in documented way on a SDRAM-Card for the Raspberry Pi. To do this, you have to prepare the Raspberry Pi at first. Independent of the following instructions please have a look into the HowTo provided in each zip archive for newest updates:

  1. Download the image from the download tab
  2. Extract image(as .img) from the .zip archive
  3. Install the image onto a SD or MicroSD card (min 4GB)
  4. Please refer to and use the image formerly extracted!
  5. Insert sd card into your Raspberry Pi (1 or 2 or 3)
  6. Power on the Raspberry Pi
  7. The static IP is preconfigured in the image.
How to use Sample Project
  1. Install Compiler Toolchain for CrossCompiling on Windows (for link see below, eg. raspberry-gcc4.9.2-r2.exe)
  2. Install DOME Studio
  3. Make sure one of the engineering computer’s network interfaces is in the same subnet as the Raspberry Pi (for the preconfigured Raspberry Pi: e.g. [192.168.239.x subnet])
    a) Remember the IP address of the engineering computer’s network interface (in same subnet as the Raspberry Pi) as aaa.bbb.ccc.ddd
    b) Append the following lines onto this file: C:\ProgramData\ifak\DOME\dome.ini (change aaa.bbb.ccc.ddd accordingly):


    c) Change this line every time your engineering machines IP is changed; delete those two lines, if the used network interface gets it IP-address from a DHCP-Server with DNS (needed)

  4. Reboot Windows to enable the update of the PATH variable for all programs
  5. Open DOME Studio
  6. Goto File→Help→Help to open the short documentation of the DOME Studio
  7. Be aware some questions could be answered here.
  8. Open ExemplatoryRaspberryPiProject from the zip file by
    File→Open Project→Browse→$unzippath\ExemplaryRaspberryPiProject\ExemplaryRaspberryPiProject.eep
  9. Click on Node Management
    a) Make sure the ip configured for TestNode as Node Address is the same as the Raspberry Pi’s; click save after changes.
  10. Press Build and Run and accept the changes for the firewall configuration
  11. The Raspberry Pi DOME processes should also send logging data to the DOME Studio ⇒ check the info tab in the bottom half for several “struct{….” fields
  12. Connect with putty.exe onto the Raspberry Pi (please maximise putty.exe)
    User: root
    Password: raspberry
    and check if the current time is appended onto the /opt/ifak/tmp/domedate file:

    # cat /opt/ifak/tmp/domedate

    It should show several timestamps, confirming that the DOME processes are running.

Changing the IP Address of the DOME-node (if needed, eg for more than one Raspberry Pi)
  1. Make sure one of the  engineering computer’s network interfaces is in the same subnet as the Raspberry Pi (for the preconfigured Raspberry Pi: e.g. [192.168.239.x subnet])
  2. Connect via ssh to your Raspberry Pi; use putty.exe on Windows (please maximise putty.exe after connect); IP/Hostname:
    User: root
    Password: raspberry
  3. a) Change IPin /etc/network/interfaces with the nano editor:
    # nano /etc/network/interfaces

    ⇒ change line address to your prefered IP address
    ⇒ press ctrl+x to exit and after this  press Y to save
    b) Change Nodename in /etc/dome.ini with the nano editor:
    ⇒ change line Nodename to your prefered IP address(same as above)
    ⇒ press ctrl+x to exit and after this press Y to save

  4. reboot
    # reboot
  5. Close putty.exe and reopen a connection with a new putty.exe session and the new IP (see step 2)
  6. Make sure your computer is in the same subnet as configured, to get a connection.
  7. Change or insert the device in DOME Studio ⇒ Node Management
Useful links

putty.exe for getting a console connection to the raspberrypi

Compiler Toolchain for crosscompiling on Windows, please take at least version 4.9 on jessie

Install DOME Studio Engineering Tool

In order to install the engineering tool follow the instructions below and notice all of its prerequisites:


  • Windows 7 – 10 with latest updates
  • Install Visual C++ 2015 Build Tools (
    visual-cpp-build-tools) or Visual Studio 2015 with C++ support
  • (State charts add-on / optional) Rhapsody 7.5 System Designer


  • Start “DOME Studio Setup.exe”

If not installed, a recent version of DOME runtime will be automatically installed when DOME Studio starts.


The DOME Studio may be used in order to create Automation Objects and DOME application in a comfortable way. For instance the instantiation of Automation Objects, setting of node address etc. is very convenient. After the design of the application, the code can be downloaded to the involved nodes.

A more detailed information how to use the development environment can be found in provided user guide, installed during setup.







DOME reperio

The commissioning, maintenance and supervision of DOME applications may be done completely by means of the provided interfaces. Nevertheless there is a small tool called reperio for the introspection of DOME nodes.

You can connect with one of the detected DOME nodes in the network and browse all running DOME processes on this node. Furthermore it is possible to create, start, stop, or destroy DOME processes by means with this tool.

Inside a DOME process, instantiated objects, their ports and their connections can be observed in graphic way. In addition to this relatively static information reperio allows also to log transmitted data for selected ports.


Recently, DOME Debugger is available for Linux based operation systems only. The description will be reworked, when the tool is also ported to Windows.