RT-OS RODOS Aerospace Information Technology Aerospace Information Technology
We need an Operating system if... The Project is big (or growing fast) many (> 4) software developers developers shall work independent from each other development > 6 months It shall be hardware independent it shall have scheduling flexibility we need preemttion The result shall be reusable... Ok, but which OS? (there are >1000 Embedded OS)
Why RODOS? One from 1000's of OS http://de.wikipedia.org/wiki/echtzeitbetriebssystem ADwin ChorusOS von Chorus Systèmes S.A. / Sun Microsystems, diverse Lizenzen CMX-RTX von CMX Systems, Inc. für diverse Mikrocontroller[3] DRYOS oder DryOS ist ein Echtzeitbetriebssystem von Canon für Digitalkameras und Camcorder ecos Ein freies Echtzeitbetriebssystem für eingebettete Systeme ERIKA Enterprise ERIKA[4] ist ein RTOS OSEK OS open-source(bcc1, BCC2, ECC1, ECC2), OIL, ORTI spezifikationen, für dspic, PIC32, AVR, Nios II, ARM7, S12XS, T FreeRTOS Ein freies Echtzeitbetriebssystem für diverse Mikrocontroller LibeRTOS Ein freier Echtzeit-Linux Kernel LynxOS Ein unixoides Echtzeitbetriebssystem für vorwiegend kritische Anwendungen MicroC/OS-II Ein Echtzeitbetriebssystem, welches sich für sicherheitskritische Systeme eignet. MicroC/OS-MMU Ein Echtzeitbetriebssystem mit hardwaretechnisch unterstützten Speicherschutz und einer garantierten Laufzeit. Nut/OS Das Echtzeitbetriebssystem des Open Source Projekts Ethernut. On Time RTOS-32 Ein Echtzeitbetriebssystem mit Win32-kompatibler Programmierschnittstelle OS-9 Ein Echtzeitbetriebssystem für Steuerungssysteme Palm OS Ein Echtzeitbetriebssystem speziell für PalmOne Pocket PCs PikeOS Ein Micro-Kernel-basiertes Echtzeitbetriebssystem für sicherheitskritische Systeme. PowerPac von IAR Systems für diverse Mikrocontroller QNX Ein unixoides Echtzeitbetriebssystem primär für eingebettete Systeme Real-Time Executive Ein Echtzeitbetriebssystem für die Hewlett-Packard 1000 Serie Real VMX Ein VxWorks Clone unter LGPL Rodos Ein Echtzeitbetriebssystem, vorwiegend für Satellitenanwendungen RT-11 Ein Echtzeitbetriebssystem für die PDP-11-Familie RTAI Echtzeit-Erweiterung für Linux RTEMS Quelloffenes Echtzeitbetriebssystem für Multiprozessor-Systeme RTLinux verwendet modifizierte Kernel-Module, um Linux Echtzeiteigenschaften zu geben.[5] Carrier Grade Linux beispielsweise von WindRiver Deutschland RTOS-UH Ein Echtzeitbetriebssystem für die Automatisierungstechnik RTOSVisor Parallelbetrieb eines allgemeinnützlichen Betriebssystemen und RTOS SCIOPTA RTOS für kleine bis große und sicherheitskritische Systeme smx RTOS für ARM, Cortex, PowerPC basierte Mikrocontroller von Micro Digital Inc. [6] TTP-OS VxWorks zertifizierbares Betriebssystem Windows CE Echtzeitbetriebssystem von Microsoft für verschiedene Architekturen Xenomai Lizenzfreier Ableger von RTLinux für eingebettete Systeme
Why RODOS? One from 1000's of OS http://de.wikipedia.org/wiki/echtzeitbetriebssystem ADwin ChorusOS von Chorus Systèmes S.A. / Sun Microsystems, diverse Lizenzen CMX-RTX von CMX Systems, Inc. für diverse Mikrocontroller[3] DRYOS oder DryOS ist ein Echtzeitbetriebssystem von Canon für Digitalkameras und Camcorder ecos Ein freies Echtzeitbetriebssystem für eingebettete Systeme ERIKA Enterprise ERIKA[4] ist ein RTOS OSEK OS open-source(bcc1, BCC2, ECC1, ECC2), OIL, ORTI spezifikationen, für dspic, PIC32, AVR, Nios II, ARM7, S12XS, T FreeRTOS Ein freies Echtzeitbetriebssystem für diverse Mikrocontroller LibeRTOS Ein freier Echtzeit-Linux Kernel LynxOS Ein unixoides Echtzeitbetriebssystem für vorwiegend kritische Anwendungen MicroC/OS-II Ein Echtzeitbetriebssystem, welches sich für sicherheitskritische Systeme eignet. MicroC/OS-MMU Ein Echtzeitbetriebssystem mit hardwaretechnisch unterstützten Speicherschutz und einer garantierten Laufzeit. Nut/OS Das Echtzeitbetriebssystem des Open Source Projekts Ethernut. On Time RTOS-32 Ein Echtzeitbetriebssystem mit Win32-kompatibler Programmierschnittstelle OS-9 Ein Echtzeitbetriebssystem für Steuerungssysteme Palm OS Ein Echtzeitbetriebssystem speziell für PalmOne Pocket PCs PikeOS Ein Micro-Kernel-basiertes Echtzeitbetriebssystem für sicherheitskritische Systeme. PowerPac von IAR Systems für diverse Mikrocontroller QNX Ein unixoides Echtzeitbetriebssystem primär für eingebettete Systeme Real-Time Executive Ein Echtzeitbetriebssystem für die Hewlett-Packard 1000 Serie Real VMX Ein VxWorks Clone unter LGPL Rodos Ein Echtzeitbetriebssystem, vorwiegend für Satellitenanwendungen RT-11 Ein Echtzeitbetriebssystem für die PDP-11-Familie RTAI Echtzeit-Erweiterung für Linux RTEMS Quelloffenes Echtzeitbetriebssystem für Multiprozessor-Systeme RTLinux verwendet modifizierte Kernel-Module, um Linux Echtzeiteigenschaften zu geben.[5] Carrier Grade Linux beispielsweise von WindRiver Deutschland RTOS-UH Ein Echtzeitbetriebssystem für die Automatisierungstechnik RTOSVisor Parallelbetrieb eines allgemeinnützlichen Betriebssystemen und RTOS SCIOPTA RTOS für kleine bis große und sicherheitskritische Systeme smx RTOS für ARM, Cortex, PowerPC basierte Mikrocontroller von Micro Digital Inc. [6] TTP-OS VxWorks zertifizierbares Betriebssystem Windows CE Echtzeitbetriebssystem von Microsoft für verschiedene Architekturen Xenomai Lizenzfreier Ableger von RTLinux für eingebettete Systeme
Why RODOS? RODOS is: As simple as possible (first directive) 3K LOCS ( > safety & good to learn and teach clear understandable (a target) minimalistic, but includes all we need for an embedded RT-OS Object Oriented (Modern) Framework (more than just OO) Building Blocks Execution Platform (BBEP) (more than just OS) has integrated a middleware (more than just OS) Aims to make HW - SW boundaries transparent both HW and SW modules communicate using the Middleware executable on bare metal and on the top of other OS (more than just HW Abstraction) already in use in several satellites (proved in space) heart pump (dependable) lottery generators (playing milions per week) fault tolerant demonstrators viele Fehelrtoleranz Demonstratoren...) Targets ESA Expectations for future OS (already implemented) easy to port program per composition : no main() entry point required, each BB independent!... and... we understand/known it completely :) (no black boxes)
Dependable Computing components tuned to each other, to provide dependable computing
RODOS Core RODOS was designed as a framework offering the following features: object oriented C++ interfaces, Ultra fast booting ultra fast recovery time real time priority controlled Preemtive multithreading time management (as a central point) thread safe communication and synchronisation Event propagation Central Point: Time: Time begins at 0 (boot time) and increments continuously in nanosecond steps until END_OF_TIME which is about 150 years into the future. UTC Begins at 0 at 1.1.2000 0:00 and increments continuously in nanoseconds until 2150 Time controls almost all activities in core. Time points are always absolute time. No relative (delta) times are used (ex. No sleep(timeperiod), but suspendcalelruntil(absolute-time)) example: We meet in 15:23 minutes please tell the others, or: we meet at 10:30:00
RODOS Portabilität RODOS can be executed on embedded target hardware and on top of Linux. Applications can be moved from one host to another without modifications. The on-top-of-linux implementation helps developers to work locally on their workstation without having to use the target system. To move to the target, they have only to recompile the code. The behaviour is the same, except for timing requirements and time resolution, which on LINUX cannot be as exact as in the target systems. Bare Metal (direkt auf Hardware) On top of linux windows RTEMS Vitex-Kernel (FreeRtos)
BBEP Kompon enten Computing units (CPU) are managed by the local real-time kernel operating system (OS). On top of the kernel runs the software middleware (MW). Around this middleware the user can implement its applications (AP). To communicate with external units, including devices and other computing units, each node provides a gateway to the network. Around the network, several devices (IO Devs and computing nodes) may be attached to the System.
RODOS Components Core: support for resource management, thread synchronisation and communication, input/output and interrupts management. Middleware: carries out transparent communications between applications and computing nodes. The message exchange is asynchronous, using the publisher/subscriber protocol. No fixed communication paths are established The system can be reconfigured easily at run-time. Gateways: The middleware distributes messages only locally, but using the integrated gateways to the NetworkCentric network, messages can reach any node and application in the network. The communication in the whole system includes software applications, computing nodes and IO devices.
Application: Core Example // <-just for the application deiscovery protocoll // <---PRINTF with semaphore // <---Macro, shortcut // <--------- no main() is required
Application: Middleware example
RODOS: Dependable Computing RODOS: embedded operating system (OS) designed for dependability. for simplicity to be distributed to be extendable & adaptable as an OO Framework Building Blocks Execution Platform developed in C++, as object-oriented framework simple enough to be understood and applied in several application domains no fundamental functionality is missing
RODOS Framework Framework: Def: In object-oriented systems, a set of classes that embodies an abstract design for solutions to a number of related problems. Next step following the object-oriented technology. The functionality is provided by OO methods encapsulated in classes and other functionality by means of inheritance. A framework is composed of several classes in a structure with different relationships: inheritance, references, and contention. The whole structure has a specific functionality. The user can adapt its functionality to his needs as follows: adaptation interface (inheritance) function/method interface (ready to use functions)
RODOS Framework Framework: To adapt the functionality of the framework to your needs: inherit from adaptation interface classes (subclasses). overload virtual methods The new (user) subclasses and its objects are integrated automatically (by inheritance) into the structure and the user does not need to register them manually. This makes the integration much simpler and reduces mistake sources.
Framework: Empty Functionality RODOS Framework Thread Subscriber User: Purpose
RODOS Framework & applications A software system consists of a collection of passive and active objects. The passive objects just offer data and methods to be accessed by active objects. time request, synchronisation, IO requests, etc. (Werden von den aktiven Objekten aufgerufen) Active objects will be activated (executed) by the underlying system. They may get the CPU (time) as a reaction to timepoints, events, requests and/or communication subscribers threads, event-handlers, time-events, topic-subscribers. (will be called by OS)
RODOS Framework Aktive Obj.
RODOS Framework::Core Time is a very central point for the RODOS framework. Execution of threads is mainly controlled by time. Each thread can define periodic execution or just time points when it shall be executed. (Keine handle() Funktion, sondern breakpoints in run() ) 1. Good col. Free. Timing RODOS framework will try to satisfy all these time requirements. 2. else Priority 3. else Round-Robin In case of conflicts RODOS resolves them according to priorities. The thread/event-handler with the higher priority will be executed next. In case of same priority (and same time (do not do that!)) RODOS uses round-robin For exclusive regions IO devices shared data RODOS provides synchronisations, using Mutex (semaphores), and synchronous data FIFOS.
Try? : Timing Conficts
RODOS Implementierung Core::Thread void yiled() Many threads may run (apparently) simultaneously. Each thread may run until it is suspended for a time period by itself or by preemtion. To suspend a thread one may call explicitly the suspendcalleruntil(...) method, or access a synchronised object which may suspend its caller. Semaphore SyncFIFO WaitForMessage they call (if requires) suspendcalleruntil(...) To reactivate: When waiting time is reached Thread::resume() sets waiting time to 0
suspend / resume (Macroscopic) Event-A Event-B Time Event Eventually Periodically Event-C Resume Thread-A Resume Thread-B Thread-C Resume at Time x Thread-D Periodically resumes 0 Time ->Growing Continuously, resolution: Nanoseconds == suspendcalleruntil(...) End-Of-Time (150 Years) == External Event (Interrupt)
Preemptiv Scheduling (microscopic) Events Thread Priority 115 Resume Thread Priority 114 idle-thread Priority 0 Never suspends voluntary
Synchronisation Time: Thread::suspendCallerUntil(uint64_t time); Thread::resume(); Exclusive Sections Semaphore::enter(); Semaphore::leave(); Priority_Ceiling Atomar Data Flow: SyncFifo::put(); SyncFifo::get(); example: semaphore-io.cpp Problems: Priority-invertion Priority-Transfer Deadlocks Example: Film director and bycicle paper and pens
Semaphore PRIORITY_CEILING Atomar
suspend / resume A thread may be suspended (blocked) until a time point, then it will be resumed automatically when the corresponding time point is reached. If a thread shall be suspended without limit, we use the time point END_OF_TIME. A thread may be reactivated at any time by calling its resume() method. (sets the waiting time until 0). SuspendCallerUntil(...) and resume() may be called directly or by synchronisation objects, like semaphores and SyncFIFOs. The core may activate event handlers to react to a time points or to an interrupt (TimeEvents). Event handlers have to be very short, because they are executed in interrupt mode and while an event handler is being executed all other interrupts will be blocked. (time event handlers are not critical) Idee für enter() mitt Time-out?
Examples
//< bessert int64_t //< NOW() liefert 64 bit ns counter t0, cnt);
NOW());
Thread, Semaphore & Time Control (Synchronisation, Time-Events)
Asyncrhonous Communication To share data between event handlers and threads use async-comm objects (AsyncComBuff & AsyncComFIFO) or only elementar datatypes (int, char,..) Events have the highest priority in the system. When an event handler is executed the hardware interrupts are blocked. The next event handler may be executed only after the current one returns (terminates); event handlers cannot be interrupted. Mechanims For asyncrhonous Communication Threads (protected with Semaphores and Priorities) Interrupts Asyncrhomous
Intratask-Communikation
Synchornous Communication
RODOS Middleware Software by Composition Subscriber Publisher Subscriber Publisher Data Network Subscriber Publisher Publisher Subscriber
Publisher / Subscriber Protocol All communications in the system are based on the publisher/subscriber protocol (tasks, devices, SW-SW, SW-HW, HW-SH, HW-HW). Publishers make messages public under a given topic. Subscribers (zero, one or more) to a given topic get all messages which are published under this topic. For this communication it does not make any difference in which node (computing unit or device) the publisher and subscribers are running. They may be in the same unit, or distributed around the network. To establish a transfer path, both the publisher and the subscriber must share the same topic. A topic is a pair consisting of a data type and an integer representing a topic identifier.
Hardware Device Device Application Application Hardware Device Application Application Device Topics ~= Communication Channels
Middleware
Middleware
Middleware
RODOS Middleware The RODOS middleware distributes (and replicates) messages locally in each computing node and using gateways it may cross node boundaries to reach all units in the network. The communication protocol is based on the most simple possible implementation (we were able to design) of the publisher/subscriber protocol. + High flexibility + no difference between local/remote communication + no difference between SW-SW, SH-HW, HW-SH, HW-HW communication + communication relationships can be very dynamic. Units may disappear or appear, tasks may be migrated, activated or deactivated at any time. The position of applications can even change (migration) at runtime, without requiring any explicit reaction of the other involved applications. + There are no fixed communication paths. Each data transfer is resolved just in time using the registered communication topics.
Device Device Application Application Application Application Publisher Subscriber Protocoll Device Topics ~= Communicatio Channels Middleware
Application
Middlware & Topics
Middlware & Topics
Middlware & Topics Wieter Putters: FIFOS, ComBufs, Threads, etc etc
Software Composition Bob Message Valentine Greetings Alice Topic: Valentine
Software Composition Bob Alice Not neccesary bad, for example filter, voters, kalman Charly
Software Composition A topic is public, not a directed letter
Inter-Task communication
Inter-Task communication
More simple than normal Compare with Sokets / Procedural OS API Receive Messages Send Messages Missing: Sync
Device Device Application Application Application Application Communikation by Topics Device Topics ~= Communicatio Channels Middleware
Message distribution Message distribution cooperation core and middleware Subscriber / Putter s Thread s 0
Middleware Topics ~= Communication Channels Publish Subscriber-A Publish Subscriber-B Subscriber-C Event-A Publish Please only publishfrominterrupt Event-B Resume Thread-A Resume Thread-B Thread-C 0 End-Of-Time (150 Years)
RODOS Gateways Communication to the rest of the world (IO devices, other node, user) is performed via gateways. Gateways implement on one side the RODOS communication protocols, on the other side the protocol of the attached communication channel. for example, a wireless protocol, S3P, ethernet, SpaceWire, RS 322, MIL, radio communications, Gateways listen to all topics and may publish messages in any topic. Gateways marshal internal middleware messages in an external format in order to send them to other hardware units. When the gateway gets messages from external units, it unmarshals the data and transforms it to the internal middleware format. Then using the corresponding topic it publishes the message locally.
RODOS MW und ISO-Layers Application Not Used RODOS Middleware Externes Netzwerk
Communikation: Middleware
Middleware BOSS: Precursor of RODOS
Fault Tolerance & Middleware
Fault Tolerance & Middleware
Fault Tolerance & Middleware
Adding components Input Device Controller Output Device Middleware
Adding components Sogar Live Black-Box Input Device Controller Monitor Output Device Middleware
Adding components Input Device Controller Controller Controller Voter Output Device
External Network
External Network
Application Not Used RODOS Middleware External network 0. Menical (example Pins, holes, pin 2 & 3 by Uart)
User Application Application Data Representation and encryption Application to application (in same host) Topic / middleware network message, ids, headers, Reliability node Address and netowkr routing Gateway Link Address and local routing Voltage, Speed, bit econding, byte encoding Pyisical Link Where begins a bit? Whre begins a byte? M-Bits / Sec == Mhz? 2'er, 10'er Potenz Quad: Phase Codierung
External network
A Network-Centric Network-Switch Arbiter
A Network-Centric Network-Switch
Circuit switching Vrs. packet switching Circuit Switching Packet Switching First reserve a line (way) then begin transferring data store and forward Fifos in each Link (both sender/receiver?) +safer +simpler - inefficient - sender and receiver has to have the same speed and protocol - Packet losses by Overflow - complex Routers + efficient + send/rec. diff prot & Speed
Application Application Application Application Publisher / Subscriber Interface Topic Distribution Auto-Discovery Transport
Application Application Topic / middleware Putter / middleware Gateway Protocol Converter Protocol Converter Gateway Pyisical Link Pyisical Link Pyisical Link Pyisical Link Node Computer Middleware Switches Node Computer Data Transfers (several messages) Topics List
Application Application Topic / middleware Putter / middleware Gateway Gateway Share Memory Node Computer A Partition X Select And Copy Share Memory IO Drivers Node Computer B / Partition Y Time Space Partitioning System Data Transfers (several messages) Topics List
Real examples
RY-Demonstrator
Not so good: actuator (eg. PWM) gets 3 times the Aktuator (z.b. PWM) bekommt 3 values? and then?
Porting Hardware Abstraction Layer HAL
Hardware Variability
Layers (irealistic example) BSP = Basic Support Package
Layers and IO Driver Reality...
Driver for waht? For UART or for GPS? For I2C or for IMU? For USB or for Mouse? Abstraction: IO Port Device (z.b. Human Interface: Keyboard, Mouse, Display; Storage; ) or just where to attach the device?