Real-Time
Operating System
velOSity |
|
velOSity Real-Time Operating System |
|
|
|
Rapidly
develop high performance software
for cost sensitive devices |
The velOSity™
Real-Time Operating System (RTOS) is
small, fast and royalty free, making
it a perfect fit for cost-sensitive,
high-volume and resource constrained
embedded applications. Besides being
integrated with the best-of-class
embedded software tools,
velOSity
offers developers a rich set of
kernel services, device drivers,
BSPs and middleware. The combination
of all these features make
velOSity
the choice for many of today's
embedded development applications.
Ideal for deeply embedded,
demanding embedded systems - small
and fast
The velOSity
RTOS is configured to run in flat
memory models, optimizing both its
footprint and execution speed. It
can also be configured for use
without a board support package for
your target hardware, further
reducing your memory footprint and
implementation complexity. With a
minimum RAM requirement of 3 KB,
velOSity
is perfect for even the most tightly
constrained embedded system designs.
Designed for speed, its ultra-fast
context switch time and fast kernel
service call times also make it
ideal for systems where CPU
resources are at a premium.
Proven Technology
The velOSity
RTOS is the exact kernel technology
that forms the foundation of the
ultra-reliable INTEGRITY real-time
operating system. Shipping for more
than seven years as the core kernel
of INTEGRITY,
velOSity is being deployed in
a wide variety of demanding embedded
systems, including
telecommunications, industrial
control and automation, automotive,
medical, and aerospace.
|
|
|
True Seamless Scalability |
INTEGRITY and
velOSity
employ common application
programming interfaces, including
POSIX system interfaces and
adaptation layers for VxWorks, pSOS
and other legacy RTOSes. The two
systems also share common services,
device drivers, BSPs, middleware and
network stack support with
INTEGRITY, along with a common MULTI
tools integration and debug
features.
|
Software developed for
velOSity
is 100% upwards compatible with the
INTEGRITY RTOS. If an application
requires virtual memory support (via
the memory management unit found on
certain microprocessors), INTEGRITY
can be substituted for
velOSity
with minimal to no code changes.
Should the system design call for
partitioned application and device
drivers, the existing design can be
easily reconfigured to enable
applications and device drivers to
exist in their own protected virtual
address partition.
|
Besides applications, any
middleware, device drivers, or BSPs
developed for
velOSity will run in
INTEGRITY, providing a true seamless
migration path for future designs
that would benefit from INTEGRITY’s
additional reliability, safety, and
security features. Many embedded
products are part of a family of
devices, covering a range of
capabilities and price points. At
the low end of the family where
minimal footprint, maximum execution
speed and lowest cost are paramount,
velOSity
is ideal. At the high end where
maximum reliability, safety and
security are critical, INTEGRITY is
the choice.
To support the entire family, a
common application software base can
be developed and maintained for a
family of products that can run on
low end to high end products
unmodified, enabling your
development teams to share and use a
common application source base,
common operating system API and
common development toolset across
the entire range of products. No
other operating system can provide
the same level or range of
scalability.
|
|
|
Real-time Response |
Unlike other
real-time operating systems that
disable interrupts in every kernel
service call,
velOSity's state-of the art
architecture guarantees the absolute
minimum interrupt latency by never
disabling interrupts in any service
call. Not only does
velOSity
provide the minimum response time,
but the absolute worst case response
time is extremely fast, statically
known and guaranteed.
Other operating systems, including
real-time operating systems, publish
interrupt latency figures that are
only the worst case numbers for a
particular test environment. Because
these other kernels disable
interrupts in each and every kernel
call, this puts the actual worst
case response time orders of
magnitude larger than their
published figures and not practical
or possible to compute statically.
|
|
A Complete Solution |
Many real-time
operating systems aimed at deeply
embedded applications fail to
provide a complete solution.
Essentially, the kernel is provided
as a library of services without any
drivers, board support packages,
networking software, middleware, and
other important capabilities
required to create a complete
product and get to market quickly.
Green Hills Software provides a
comprehensive suite of support and
services for
velOSity
including:
 Extensive
device driver support, including: |
|
|
Ethernet |
|
I2C |
| |
serial |
|
CAN |
| |
flash |
|
IDE |
| |
PCI |
|
|
|
|
Over
100 board support packages
File
system support
USB
host stack and class drivers
IPv4/IPv6
TCP/IP stacks
Network
applications
Advanced
communications protocols
2D
and 3D graphics
CORBA
ORBs
and
more…
|
In addition, Green
Hills Software provides consulting
and engineering services to aid in
porting, tuning, and integration
with your custom requirements.
|
|
Integrated Development Environment |
| With over 20 years
of experience providing tools for
the development and debugging of
embedded systems, Green Hills
Software provides the most
comprehensive suite of development
tools tailored to providing complete
control and visibility for
velOSity-based
applications. In addition to
run-control debugging when utilizing
the Green Hills Software
hardware-assist debugging devices,
run-mode debugging via a BSP's
ethernet or serial drivers is also
available to the end user. |
|
Microprocessors controlling
some types of embedded
systems, such as printers,
often can not be completely
halted in order to debug
problems due to the
mechanical or other critical
parts under control of the
operating system and
applications. MULTI’s
run-mode debugging support
solves these problems by
using I/O interfaces for
debugging without any need
to stop the microprocessor.
When a board support package
is not used or not yet
developed, Green Hills
Software hardware-assist
debug devices, Green Hills
probe, Slingshot, and
SuperTrace Probe, can be
used to get the kernel and
application code downloaded
to your target with kernel
aware debugging out of the
box. |
|
The MULTI suite of
development tools for
velOSity
optionally include the Resource
Analyzer for monitoring application
and system CPU and memory usage, the
EventAnalyzer for understanding the
complex behavior of the system, and
the TimeMachine 4-D debugger which
helps users find outrageously
difficult bugs in minutes. Also
available is the ISIM Target
Environment simulator, providing an
instruction accurate host-based
simulation environment for
velOSity
when hardware is not yet available
or in limited supply. Optimizing
compilers for C, C++ Embedded C++
and MISRA C are available and
support the
velOSity operating system.
These compilers generate the
smallest footprint and fastest
executing code in the industry.
|
|
Field Debugging |
Traditional
debugging techniques are
often unsuitable for fielded
embedded systems where
halting the processor or
delaying even a single
thread can interrupt service
or bring down a system. With
Green Hills Software’s field
debugging capabilities—tracepoints,
passive mode, and
hardware-assisted
trace—developers and field
technicians
can safely interact with
in-use embedded systems with
minimal intrusions.
Tracepoints are essentially
breakpoints managed on the
target. Tracepoint logic
records the values of
register or memory contents
into a buffer, allowing the
thread to immediately
continue. Tracepoint
implementation requires
close integration between
the debugger and the
operating system. Ideally,
the debugger sets the
tracepoints so developers
can take advantage of the
debugger’s knowledge and ask
for tracepoints on named
variables at specific
locations. Once a tracepoint
has been set, the debugger
can be detached, and
velOSity can manage
the insertion, deletion, and
data gathering of
tracepoints autonomously. |
|
|
The debugger can be reattached to
the system hours, days, or even
months later to upload the data
velOSity
collects. In passive mode, the
debugger only permits read
operations. Any operations which
could alter the state of the system
(e.g. write to memory or halting a
thread) are denied. Developers can
only use the debugger to examine the
state of any thread in the system
while it continues to run. Write
access can be configured via a
password in
velOSity itself to toggle
into and out of passive mode.
Using the Green Hills SuperTrace
Probe, execution trace data can be
gathered from many types of
microprocessors and uploaded from
the fielded system. Collected data
can be sent back to the device
manufacturer for analysis with the
TimeMachine debugger. TimeMachine
can find a memory corruption in
seconds by setting a watchpoint and
running the debugger backwards in
time to pinpoint when the critical
memory location was last written.
TimeMachine is
velOSity kernel-aware, mining
the trace data to present a
historical view of all the
kernel-level events such as
interrupts, context-switches, and
service calls.
Hardware-assisted trace, when used
in conjunction with TimeMachine, is
an ideal field debugging tool
because the trace data is gathered
without any instrumentation of the
target code and without ever halting
or slowing the microprocessor.
|
Back to GH Home Page
Back to Testech Home Page
Compiler
RTOS
Emulator/Debugging
|
)
)
)
)
)