Features and Beneficts

ERIKA Enterprise and RT-Druid Features

ERIKA Enterprise

ERIKA Enterprise is an innovative OSEK/VDX RTOS for small microcontrollers.

In addition to the OSEK/VDX standard scheduling algorithm, ERIKA Enterprise implements innovative scheduling algorithms such as Fixed Priority with preemption thresholds, Stack Resource Policy (SRP), Earliest Deadline First (EDF), and resource reservations (FRSH) which can be used to schedule tasks with real-time requirements.

ERIKA Enterprise is available with a license GPL+linking exception , and has a very small footprint: typically, a minimal installation of ERIKA Enterprise consumes from 800 to 2000 bytes of code, for the implementation of a fixed priority scheduling kernel with stack sharing and binary mutexes.

Erika Enterprise main features

  • OSEK/VDX certified.
  • Real-time kernel, priority based, with stack sharing for RAM optimization.
  • Minimal multithreading RTOS interface
  • RTOS API for: Tasks, Events, Alarms, Resources, Application modes, Semaphores, Error handling.
  • Support for conformance classes (FP, BCC1, BCC2, ECC1, ECC2, EDF, FRSH) to match different application requirements;
  • Support for preemptive and non-preemptive multitasking;
  • Support for fixed priority scheduling and Preemption Thresholds;
  • Support for Earliest Deadline First (EDF) scheduling;
  • Support for stack sharing techniques, and one-shot task model to reduce the overall stack usage;
  • Support for shared resources;
  • Support for periodic activations using Alarms;
  • Support for centralized Error Handling;
  • Support for hook functions before and after each context switch.
  • GPL with Linking Exception license


RT-Druid is the development environment for ERIKA Enterprise. Based on Eclipse, RT-Druid allows writing, compiling, and  analyzing your application in a confortable environment.

RT-Druid is composed by a set of plugin for the Eclipse Framework . The following is a list of the available plugins:

  • RT-Druid Core.
    The RT-Druid Core plugin contains all the internal metamodel representation, providing a common infrastructure for the other plugins, together with ANT scripting support.
  • RT-Druid Code Generator.
    The RT-Druid Code Generator plugin implements the OIL language compiler, together with target independent code generation routines for ERIKA Enterprise.
  • RT-Druid Code Templates manager.
    The RT-Druid Templates manager provides the possibility to easily write application templates to be used when generating a new application.

Additional plugins are also available, supporting schedulability analisys with an estimation of the response time of the application tasks.

RT-Druid main features

  • Development environment based on the Eclipse IDE;
  • Support for the OIL language for the specification of the RTOS configuration;
  • Rich text editor for OIL configuration file editing
  • Graphical configuration plugin to easily generate the OIL configuration file and to easily configure the RTOS parameters;
  • Full integration with the Cygwin development environment to provide a Unix-style scripting environment;
  • Apache ANT scripting support for code generation;
  • RT-Druid graphical editor
  • RT-Druid code generator per Erika Enterprise, including the code generator for Erika Enterprise Basic
  • Support the ORTI standard for application debugging and tracing with lauterbach debuggers



  • Portable API - The Erika API implements the same API (derived from the OSEK/VDX standard) on different microcontrollers.
  • Increased performances - Highly configurable ROM footprint, high efficiency kernel, stack sharing to limit RAM consumption.
  • Multi-core support - Multi-core issues are handled automatically, simplifying the application design and verification.
  • Code placement - Easy migration from a single core to multiple cores: no changes to the application source code, only simple modifications to configuration files.
  • Open source, with source code - Erika Enterprise is available open source, with the GNU CrossTool License (also known as GPL with Linking exception). This means the software can be used without releasing the application source code. Moreover, is distributed with source code, no royalties!



Support for Multicore architectures

ERIKA Enterprise and RT-Druid have explicit support for multicore architecture. Multiprocessor systems are being considered as an economically viable alternative to support this increasing computational demand. However, the usage of multiprocessor hardware in small embedded system poses problems to developers ranging from concurrency to load distribution.

Evidence solves these problems proposing OS-level solutions and tools for embedded multiprocessor-on-a-chip.

Erika Enterprise and RT-Druid have been designed to handle multiprocessor development and programming by hiding the use of multiprocessor synchronization primitives.

With multiprocessor hiding, it is possibile to seamlessly migrate application code from a single processor to multiprocessors without changing a single line of the source code. Hiding helps customers preserving their code base. Retargetting an application from single to multiprocessor architectures only requires different OIL configurations, but allows retaining the source code.

Partitioning code among cores

In particular, partitioning the application among the different CPUs, and implementing an efficient communication mechanism between the CPUs are the first issues to be addressed at the first stages of the development process. Unfortunately these choices are very critical for later development phases, since changes in the partitioning scheme can heavily change application design.

Erika Enterprise and RT-Druid give support to developers to solve the partitioning issues in multiprocessor applications, enabling the developer to perform code partitioning and then easily changin it at later stages in the design.

Design and programming

Design and Programming paradigms must exploit the parallelism of these architectures, but programmers are usually not trained for writing code executing in parallel on multiple processors, and designers need to find the best tradeoffs for exploiting computing capabilities without incurring in excessive blockings over shared resources or bacause of synchronization.

With Erika Enterprise, each task can be thought to run on a single processor multithreaded environment. Multiprocessor issues like data cache disabling and mutual exclusion between different CPUs accessing concurrently the same data structures are handled automatically byErika Enterprise and RT-Druid, simplifying the application design and verification.

Code placement and resource sharing

The choice of which software has to be placed on which processor is usually called code placement or software binding or partitioning.

The task of the final user is to figure out the right communication pattern(s) / architecture(s) and to implement it. Today's approach used by many development tools is non conclusive, leaving out to the designer the job of chosing the best partitioning and communication scheme for its application, with the risk of making early decisions that may impact heavily on the application code with bad application performance.

Ideally, changing the code placement must not impact on the way people design and program applications. The multicore structure must be hided to the user whenever possible, and source code compatibility between mono and multicore, with automatic mapping of application facilities to the new multiprocessor features. This is exactly what the RT-Druid code generator offers, exploiting the multiprocessor support provided by Erika Enterprise.

However, multiprocessor hiding is sometimes not sufficient alone, because the developer have to know how to partition the various jobs to obtain the maximum performance. For this reason, future versions of RT-Druid will also enable users to perform well-reasoned partitioning choices integrating the results of application timing analysis with the results of schedulability analysis. In this sense, schedulability analysis will help to give a metric that guides the developer when doing the application design choices.

Porting of legacy code to new architectures and to multiprocessors

One of the problems that typically arises when adopting multiprocessors is that application rarely start from scratch with a multicore approach. More often, new applications are upgrades to existing (working) systems that are adapted to particular new environment.

Erika Enterprise and RT-Druid helps porting existing legacy code to multiprocessors because:

  • The kernel API is the same for both single and multiprocessor systems.
  • A multicore system can be view as an "extension" of a single core. You can add functionality to a system on a separate CPU, without perturbating too much the application running on the critical part.
  • Application code does not have to be changed when changing the partitioning scheme.

Resource sharing and OS-level mechanisms

When moving from single processor systems to multiprocessor systems, standard programming paradigms used in real-time systems to access shared resources does not work anymore.

In particular, all the solutions used to avoid the Priority Inversion problem, such as the Immediate Priority Ceiling protocol implemented in the OSEK/VDX standard and in other APIs does not scale to multicores.

Erika Enterprise and RT-Druid offer an innovative way to automatically provide support for resource sharing among different processors, automatically integrating resource consistency protocols for multiprocessors when a resource is shared among different CPUs.