Commercial real-time kernels are designed to perform unrelated functions in a pseudo-parallel way. They provide a set of basic multi-tasking mechanisms available through a programmatic interface. Such commercial libraries are quite expensive to acquire and are cumbersome to simulate under modern operating systems, e.g. Windows, Linux or UNIX. The cost of a developer license allowing a programmer to develop software for a selected commercial kernel is quite high.
Our kernel services provide an object-oriented abstraction layer above these commercial real-time kernels. All our embedded applications use the same interface to access the various underlying commercial real-time kernels. The application programmers do not need to learn the subtleties of the underlying RTOS (Real-Time Operating System) library. They always use our standard interface regardless of the chosen commercial kernel.
Each software application has a set of basic routines called system services. This set of services implements all elementary functions needed to realize a powerful yet easy to maintain product. These methods pervade the whole product architecture and simplify greatly the implementation of powerful programming patterns. A good designed set of system services is one of the common characteristics of all efficient and successful industrial systems. They are the victory flag showing how elegantly recurring problems have been solved. Powerful system services simplify the understanding of the software for newcomers. They should also make the product more portable to new hardware or software platforms. We hope we have crafted a useful set of classes allowing easy implementation of application functionality on the different targets used by our devices.
This section describes the concepts and patterns we use to implement our kernel services. By using a small set of powerful constructs, our apparatus services cover all our application domains without being too complex or requiring too many resources in the target.
The basic concept provided is an abstract run-time machine. This virtual machine isolates the application programmer from the details of the underlying hardware or the used kernel. This machine can be ported to other processors or other real-time kernels. The programs running on top of the kernel run without knowledge of the underlying layers. Therefore they can easily be ported to all systems on which the virtual machine is running. One main goal was to implement this virtual machine as efficiently as possible.
Being based on similar concepts as the ones used in the ROOM method, our virtual machine can also be distributed on multiple processors without breaking the chosen semantics. The implemented patterns are used through all our applications. After you have learned them once, you are able to understand all the tasking aspects of any other subsystem.
A small set of rules defines the semantics of our virtual machine:
Encapsulates the underlying operating system and provides a well defined interface to its basic functions (Tasks, Semaphores, Messages, etc).
The real-time STL package provides a lightweight static replacement for the standard template library. It does not use any dynamic memory allocation.
Provides a collection of design patterns widely used within the Apparatus Framework.
Provides classes to log events and interactively execute commands.
Provides generic interfaces to character devices and files. They are an object oriented equivalent to the abstractions used by POSIX.
Provides communication protocols and related classes. Together with the Device Services they provide a uniform way for communicating with peripheral devices.
Manual testing requires a lot of effort and concentration. The Unit-Test Services package provides classes for automated unit tests.
Some utilities for simulating the system on a personal computer under Windows XP, 2000 and NT.
© 2004-2010 bbv Software Services AG / Apparatus Services