Rodos (operating system)

from Wikipedia, the free encyclopedia
Rodos
Logo of the Rodos operating system
developer University of Würzburg - Computer Science 8
License (s) Apache license version 2.0
Others Programmed in C , C ++ , assembly language
Information & Download (Gitlab)

Rodos ( R ealtime O nboard D ependable O perating S ystem) is a real-time operating system for embedded systems and is designed for applications that have high demands on the reliability.

history

Rodos was developed at the German Aerospace Center (DLR) and emerged from the BOSS operating system . Among other things, it is used in the current DLR micro-satellite program . The system runs on the orbiting satellites TET-1 and BIROS , it was also used for BeeSat 1 and 2.

Rodos is currently being further developed by both the DLR and the Department of Information Technology for Aerospace at the Julius Maximilians University of Würzburg .

This article or section needs to be revised. Details should be given on the talk page. Please help to improve it , and then remove this flag.

features

Rodos is implemented as a framework with a multilayer structure. The lowest layer forms the direct control of the hardware , on which the middleware is based as the second layer . The task of the middleware is to enable communication between different applications and components of the highest layer. Rodos was written object-oriented in C ++ , supplemented by hardware- specific C and assembler code.

Rodos makes it possible to easily write real-time applications for different, variable platforms . During development, special attention was paid to the simplest possible implementation of the components of the operating system. Unnecessary complexity should be avoided and the user should be provided with an uncomplicated, clear system. Rodos supports features typical of real-time operating systems, such as threads and semaphores .

The special features include:

Examples

Hello World

The standard sample program Hello World in Rodos looks like this: 

#include "rodos.h"

class HelloWorld : public StaticThread<> {
  void run(){
    PRINTF("Hello World!\n");
  }
} helloworld;

As you can see, the implementation is very straightforward. The Thread class is extended by a special run method, which in turn uses the string "Hello World!" using the PRINTF function. All components that the user needs to develop Rodos software are included in the rodos.h header file .

Threads

Rodos uses fair priority controlled preemptive scheduling . The thread with the highest priority is executed; any threads that are already running are paused ( preemptive multitasking ). If several threads have the same priority and are to be executed, they are given a fixed computing time interval alternately.

Example: 

#include <rodos.h>

class HighPriorityThread: public StaticThread<> {
public:
  HighPriorityThread() : StaticThread("HiPriority", 25) { 
  }
  void run() {
    while(1) {
      PRINTF("*");
      suspendCallerUntil(NOW() + 1*SECONDS);
    }
  }
} highprio;

class LowPriorityThread: public StaticThread<> {
public:
  LowPriorityThread() : StaticThread("LowPriority", 10) { 
  }

  void run() {
    while(1) {
         PRINTF("."); 
    }
  }
} lowprio;

Here the thread LowPriorityThread constantly gives the character "." off and is interrupted every second by the thread HighPriorityThread and the output of "*".

Topics

Rodos uses topics for communication between different threads, but also via gateways between different systems . A topic represents a message of a certain type, for whose type a thread can register as a recipient ( subscriber ). A thread can also act as the sender ( publisher ) of such a message. The message system is thus implemented according to the publisher-subscriber structure . Here is a simple example with a publisher and a subscriber , both of which use the topic counter1 , which only contains a long integer .

Example: 

#include <rodos.h>

Topic<long>    counter1(-1, "counter1");

class MyPublisher : public StaticThread<> {
public:
	MyPublisher() : StaticThread("SenderSimple") { }

	void run () {
		long cnt = 0;
		TIME_LOOP(3*SECONDS, 3*SECONDS) {
			PRINTF("Publish: %ld\n", ++cnt);
			counter1.publish(cnt);
		}
	}
} publisher;

class MySubscriber : public SubscriberReceiver<long> {
public:
    MySubscriber() : SubscriberReceiver<long>(counter1) { }
    void put(long &data) {
        PRINTF("Received: %ld\n", data);
    }       
}subscriber;

The publisher thread sends an increasing counter reading at 3-second intervals, while the subscriber simply outputs the integer received in this way.

Supported Architectures

Supported processor architectures :

Furthermore, Rodos can use other operating systems as a guest system:

Web links

Individual evidence

  1. ↑ Partner: University of Wuerzburg Planetary Transportation Systems GmbH