On Time RTOS-32 Components
On Time RTOS-32 applications always use RTTarget-32.
Components RTKernel-32, RTFiles-32, RTIP-32, RTPEG-32, and
RTUSB-32 are optional.
RTTarget-32 - Core Operating System and Development
RTTarget-32 includes all development tools required to run
32-bit applications on an embedded system. RTTarget-32 can
process an application built with a regular Win32 compiler to
run on the embedded target. It provides boot code to initialise
the target's hardware, a run-time library, a locator, and cross
debugging support. RTTarget-32's run-time environment emulates a
subset of the Win32 API.
RTKernel-32 - Real-Time Scheduler
RTKernel-32 is a library with functions to create threads,
semaphores, critical sections, etc. It adds most Win32 thread
API functions to On Time RTOS-32's Win32 emulation.
RTFiles-32 - Embedded File System
RTFiles-32 is a portable royalty-free FAT-12/16/32, exFAT, and
ISO 9660 file system for embedded systems. RTFiles-32 is a
library containing the core file handling functions as well as
the required device drivers. Several different APIs are provided
for compatibility with other systems. No source code
modifications of existing programs are required to use
RTIP-32 - Embedded TCP/IP Stack
RTIP-32 is a TCP/IP stack for embedded systems. It provides
deterministic, configurable memory usage, a table driven device
driver interface and an easy-to-use Berkeley socket compatible
API. The network configuration can be set statically or obtained
dynamically at runtime using RARP, BOOTP, and optionally DHCP
RTIP-32 supports simultaneous communications over multiple
Ethernet and serial port interfaces. It supports the protocols
UDP, TCP, ARP, RARP, BOOTP, IGMP, ICMP, NAT, and NATP. Numerous
add-ons are available to extend RTIP-32's range of supported
RTPEG-32 - Portable Embedded GUI
RTPEG-32 is an event-driven, object-oriented C++ GUI library for
embedded systems. It supports professional Windows look-and-feel
or custom user interfaces. Device drivers for VGA and SVGA/VESA
graphics hardware are included.
RTUSB-32 - Real-Time Host USB Stack
RTUSB-32 contains the core USB host protocol stack, the required
host controller device drivers, a low-level communication API
and high-level class drivers. Full source code is available.
RTUSB-32 is suitable for implementing USB hosts, not USB
RTTarget-32 - Core Operating System and Development Tools
RTTarget-32 is a Win32 subset operating system for 32- and
64-bit x86 embedded systems. Programs are developed under
Microsoft Windows using standard 32-bit compilers (Borland
C/C++, Microsoft Visual C/C++, Borland Delphi). Executable files
built with these compilers are processed by RTTarget-32 to run
on the target system.
- Target Booting
RTTarget-32's boot code can boot applications directly from
floppy disk, hard disk, EPROM disk, flash disk, ROM, a BIOS
extension, or DOS. At power-on or reset, the boot code
initialises the target computer's hardware, sets up system
data structures such as the GDT, IDT, and the page table,
and starts the application. A PC compatible BIOS can be used
for booting, but is optional. RTTarget-32's boot code can
control the complete boot sequence starting at the boot
- Cross Debugging Over Serial Ports, Parallel
Ports, and Ethernet
Source-level debugging is supported using Borland's free
Turbo Debugger or the debugger integrated in Microsoft
Visual Studio 6.0/.NET/2005/2008/Express. Host and target
computers are connected using a serial link at up to 921600
baud, a parallel port, or over Ethernet. With RTIP-32, the
application can use the same Ethernet interface as the cross
debugger if only one Ethernet interface is available.
- Run-Time Library
RTTarget-32 includes functions for physical memory access,
port I/O, hardware interrupt handling, serial I/O, real-time
clock access, PCI and PnP BIOS calls, PCMCIA card
management, 387 FPU emulation, and more.
- Win32 Emulation Library
RTTarget-32 provides about 270 Win32 API functions, allowing
it to run many Win32 programs unmodified. The Win32 API
emulation covers memory management, file I/O (RAM files,
console files, printer ports), console I/O (screen and
keyboard), time-of-day and system tick, DLL management
(LoadLibrary/GetProcAddress), exception handling, access to
Win32 resources, memory mapped files, etc.
- Supports C/C++ and Pascal Run-Time Systems
The compiler's run-time system functions such as printf,
malloc, fopen, etc., are fully supported. Even advanced C++
and Pascal features such as exception handling, run-time
type identification, etc., are available. Alternatively,
programs can run without run-time system for even less
- Low Resource Requirements
32-bit programs developed with RTTarget-32 can run in as
little as 16k of memory. A typical "Hello World" program
with RTTarget-32's Win32 emulation library, keyboard and
screen driver, and a full C++ run-time system can boot and
run on a system with about 64k of total memory.
- Supports Privilege Levels
Programs can run at CPU privilege level 0 or 3 to optimise
either for maximum protection or best performance.
- Supports Page-Level Protection
The CPU's memory protection features are used to guarantee
that programs cannot overwrite protected data, code, or
critical system tables.
- 387 FPU Software Emulator
Even on CPUs without a hardware floating point unit,
applications can use floating point calculations and types
such as float, double, and long double. The 387 math
emulator is fully reentrant and interruptible.
- Multiprocessor Support
RTTarget-32 has functions to start and stop additional CPUs.
Spinlocks and inter-processor interrupts are available to
synchronise execution among CPUs. While RTTarget-32 does not
contain a multitasking scheduler,
can use the multiprocessor support to schedule threads on up
to 32 CPUs.
- APIC Support
If the target has at least one IOAPIC (Input Output Advanced
Interrupt Controller), RTTarget-32 applications can use it
to replace the legacy i8259 interrupt controllers. APIC mode
supports a higher interrupt load and up to 32 (instead of
15) interrupt signals, requiring less IRQ sharing.
- Supports DLLs
Applications consist of one main program (the .exe file) and
up to 31 DLLs, which can be statically linked into a program
image or loaded dynamically through a file system.
- Data Compression
Program code and data can be compressed to save EPROM or
boot disk space and accelerate downloads.
- RAM Files
RTFiles-32 is not used, file I/O can be simulated with
file images located in reserved RAM or ROM on the target.
With On Time's embedded file system RTFiles-32, files on
disk can also be accessed.
RTTarget-32 has built in drivers for keyboard, text-mode
screen, serial ports, parallel ports, PS/2 and serial mice,
and PCMCIA controllers. Since RTTarget-32 allows direct
access to physical memory, I/O ports, and hardware
interrupts, developing additional drivers is very easy.
- Supports Platform RTOS32Win from acontis
With the add-on component RTVmf-32, On Time RTOS-32 programs
can be executed under
RTOS32Win from acontis
technologies. RTOS32Win is a virtual machine framework
which can execute On Time RTOS-32 programs parallel to
Window under real-time conditions.
- Supports the Real-Time Hypervisor from Real-Time
With the new add-on component RTRth-32, On Time RTOS-32
programs can be executed under the
Real-Time Hypervisor from
Systems. The Real-Time Hypervisor can execute several
operating systems or several instances of the same system on
separate cores of multi-core or multi-CPU systems.
RTKernel-32 - Real-Time Scheduler for On Time RTOS-32
RTKernel-32 is a preemtive real-time multitasking scheduler for
On Time RTOS-32. RTKernel-32 is compact (about 16k code, 6k
data), fast, and offers excellent real-time response times. All
RTKernel-32 threads run within a single program (single process,
multi-threaded). The multiprocessor version of RTKernel-32
supports up to 32 CPU cores.
An RTKernel-32 thread is implemented as a C/C++ function. A
program can dynamically create threads using the appropriate
kernel API calls. Each thread has its own stack, a priority
between 1 and 64, and a task state. Several threads can be
started executing the same code; however, each is allocated its
own stack and thus its own local variables. All threads have
access to the program's global data. Thus, shared code and
shared data are inherently implemented by RTKernel-32.
RTKernel-32 offers three different mechanisms for inter-task
- Semaphores allow
the exchange of signals for activating and suspending
threads. RTKernel-32 supports counting, binary, event,
resource, mutex semaphores, and critical sections. Resource
and mutex semaphores implement priority inheritance.
- Mailboxes (queues
or FIFO buffers) allow threads to exchange messages
asynchronously. The maximum number and size of messages can
be configured for each mailbox. High priority messages can
be sent to a mailbox ahead of all others. Mailboxes can also
be used to send data from hardware interrupt handlers to
used for synchronous (rendezvous style) exchange of
messages. No data is buffered, data is sent directly from
one thread to another.
RTKernel-32 offers excellent performance. Its benchmark program
RTBench (also included in the free On
Time RTOS-32 Evaluation Kit) may be used to measure its
performance on any target computer. The table below lists some
results for three different targets. RTKernel-32's scheduler is
about 5 times faster than the scheduler of Windows.
|For more information please contact
the MicroWay sales team:
MicroWay Pty Ltd
PO Box 84,
Braeside, Victoria, 3195, Australia
Ph: 1300 553 313
Fax: 1300 132 709
ABN: 56 129 024 825
|Sydney Sales Office
MicroWay Pty Ltd
PO Box 1733,
Crows Nest, NSW 1585, Australia
Tel: 1300 553 313
Fax: 1300 132 709
ABN: 56 129 024 825
|New Zealand Sales Office
MicroWay Pty Ltd (NZ)
PO Box 912026
Victoria Street West
Auckland 1142, New Zealand
Tel: 0800 450 168
+61 3 9580 1333, fax +61 3 9580 8995