ESF RTOS™ is a real-time executive that provides an unusually efficient and elegant suite of functions for creating and coordinating multiple, asynchronous threads of code execution. A unique object-oriented architecture contributes to code compactness, interface simplicity, ease of customization, and powerful functionality. It is a “light weight” real-time kernel, where threads share the same address space, and where operations, such as context switching and memory allocation, are fast and deterministic.

The ESF RTOS is also an operating system abstraction layer, where the real-time kernel interface provides the same multi-threaded service model for standard platforms and other real-time kernels. Supported environments currently include WIN32 and POSIX systems and several real-time kernels such as UCOS, VDK, ThreadX, or Integrity. Kernel base classes and modularity provide easy portability to new environments.

Kernel Services
ESF OS service calls are exceptionally easy to learn, use, and remember. The services are methods contained in real-time kernel classes, such as Thread, Semaphore, or Mailbox, that provide a natural organization for these functions. These kernel classes completely define the kernel interface, and they use common interface style conventions.
For example, most kernel resource objects share a common “Pend(OS::TIMEOUT Timeout, …), Post(…), and Liberate()” style interface. The general pattern is that a thread checks for the availability of a resource, such as a block of memory or a semaphore, by calling a Pend(…) method. If the resource is available, the thread obtains it, else blocks with a specified time-out. When a thread is finished with a resource it obtained earlier, it frees it by calling the resource’s Post(…) method. All threads blocked on a resource can be freed by calling the Liberate() method.
This manual documents all kernel services. The services and functions of the kernel classes are summarized as follows:
1. OS (Operating System) class - system initialization, system error codes, system time-out codes, periodic operating system time tick service.

2. Thread class - thread creation, deletion, prioritizing, and scheduling; creation of “no context switch” critical regions; synchronization via (“and” and “or”) events; voluntary delay and relinquishing of CPU.

3. Semaphore class - resource access control, mutual exclusion, thread execution precedence.

4. Mailbox and PriorityMailbox classes - support for thread to thread or interrupt service routine to thread data communication.

5. Message and PriorityMessage classes - base data objects to post to mailboxes.

6. Timer class - software timing services.

7. Region class - deterministic, real-time, fixed block size, memory allocation/de-allocation management.

8. Cpu and Context (Hardware Abstraction Layer component) classes - processor hardware abstractions supporting portability.

9. Irq (Hardware Abstraction Layer component) class - standard interrupt control hardware abstraction interface.

10. Device class - standard base class for all device drivers.

Determinism
An important requirement for many applications is deterministic behavior and the ability to guarantee that “hard” real-time deadlines are met. If a hard deadline is missed, the operation is incorrect and serious problems could occur - e.g. the boiler explodes, the plane loses control, etc. This is in contrast to a missed “soft” deadline that creates a relatively minor recovery annoyance or inefficiency.
All ESF RTOS service calls have deterministic worst case execution times, and all internal functions, such as scheduling and context switching, are deterministic. This deterministic behavior supports hard real-time applications, and is a must for scheduling theories such as the Rate Monotonic Algorithm (RMA).

Features

• Small footprint
• No external library dependencies
• No heap based allocation
• ROMable
• Fast speed and reliability
• Over 8 years of design wins
• Royalty free
• Simple, easy, and consistent RTOS API
• Open API - runs on WIN32 and POSIX
• Easy porting features – CPU and Interrupt control hardware abstractions.
• Deterministic behavior – time associated with context switch, scheduling, or message reception, etc. is the same regardless of the number of these objects used by the application.
• Compatible with 16, 32, and 64 bit processors