Kernel Services

Classes

class  ApparatusFramework::Kernel
class  ApparatusFramework::Mutex
class  ApparatusFramework::Semaphore
class  ApparatusFramework::Task
struct  ApparatusFramework::ErrorStatus
class  ApparatusFramework::ErrorHandler
class  ApparatusFramework::Factory
class  ApparatusFramework::Future< Item >
class  ApparatusFramework::Guard
class  ApparatusFramework::Monitor
class  ApparatusFramework::Msg
class  ApparatusFramework::MsgHandler
class  ApparatusFramework::MsgMgr

Enumerations

enum  ApparatusFramework::ErrorTypeEnum { ApparatusFramework::ERROR_HANDLER_NO_ERROR = 0, ApparatusFramework::ERROR_HANDLER_WARNING = 1, ApparatusFramework::ERROR_HANDLER_ERROR = 2, ApparatusFramework::ERROR_HANDLER_ASSERT = 3 }

Variables

const unsigned char ApparatusFramework::NrOfBytes_C = BBVINT_KERNELSERVICES_MSG_MESSAGE_SIZE
const int ApparatusFramework::MaxNrOfMsgs_C = BBVINT_KERNELSERVICES_MSGMGR_QUEUE_SIZE

Detailed Description

The real-time category defines a middleware layer, which shields the application programmers from the subtleties of the used commercial real-time kernel. We provide a set of classes to implement multi-threaded embedded applications. Our interface translates the method calls of the abstraction layer into the methods of the used kernel. All basic mechanisms provided by commercial kernels are mapped in our system services. The application programmers do not need to learn the subtleties of the underlying commercial kernels. They always use our standard interface regardless of the chosen commercial product.

Currently we support the following real-time kernel: RTK68 from Abatron AG, pSOS+ from Integrated Systems Inc., OSE Classic and OSE Delta from ENEA SE and VRTX32 and VRTXsa from Microtec. We provide a complete implementation of our kernel services running under Windows NT 4.x. This implementation does not use any commercial product and can be used free of charge for the initial development in the simulation environment.

The goal of this category is to suppress any dependencies with commercial kernels and be able to switch to another kernel with just a recompilation of the application. We provide the following abstractions in our kernel services: tasks, messages, kernel, semaphore, mutex, future, message manager.

The following abbreviations are used when defining methods or identifiers belonging to the subsystem:

Preprocessor macro definitions

This short section describes the macros implemented into the Services. Define them while compiling your project to include the specific functionality.

Error Handler

Interface for the implementation of a asynchronous error handling. The idea is that a component that wants to get error events from another one installs itself as an error handler of this class. As soon as the observed class detects an error it calls the handleError()method of the error handler. Each component that wants itself to install as an error handler of another component has to inherit from the class presented here.

Factory

The Factory class creates the instances of all objects, initializes them and starts them up. The factory itself has to be instantiated in the main and is a singleton.


Enumeration Type Documentation

Possible types of errors

Enumerator:
ERROR_HANDLER_NO_ERROR 

Classification no error

ERROR_HANDLER_WARNING 

Classification warning

ERROR_HANDLER_ERROR 

Classification error

ERROR_HANDLER_ASSERT 

Classification assertion

Attention:
For this error type, the errorStatus.errorNr points to a string representing the validated statement. The errorStatus.param points to a string representing the file and errorStatus.senderId contains the line where the assertion occurred.

Definition at line 68 of file ErrorHandler.h.


Variable Documentation

const int ApparatusFramework::MaxNrOfMsgs_C = BBVINT_KERNELSERVICES_MSGMGR_QUEUE_SIZE

MaxNrOfMsgs_C holds the maximum number of messages that can to be handled in the message queue. This size is needed to statically allocate memory for the queue.

Definition at line 59 of file MsgMgr.h.

const unsigned char ApparatusFramework::NrOfBytes_C = BBVINT_KERNELSERVICES_MSG_MESSAGE_SIZE

Constants The number of bytes, m_data can store. m_data defines a constant maximum size of data that a from Msg derived class can contain (in Bytes). There is a free memory area which makes up a pool of a fixed number of messages. This memory is statically allocated and has the size of (NrOfBytes_C + other space that the base class of Msg needs)*MaxNrOfMsgs_C defined in MsgMgr.

Definition at line 72 of file Msg.h.

© 2004-2010 bbv Software Services AG / Apparatus Services