Green Hills, GHS, MULTI, 2000, C, C++, ADA, Compiler, SImulator, Debugger, RTOS, u-Velocity, Small, footprint, Velocity, JTAG, BDM, Debug, Probe, Embedded,DO-170B Aerospace, Fortan, GMART, GSTART, G-CoverTimeMachine, RunTime, Analyzer, ETM, Slingshot, Supertrace, Probe, ARM, ARM7, ARM9, ARM920, ARM922, ARM926, MMU, MIPS, EMMA2, PowerPC, XScale, StrongARM,. OMAP, TI, MIPS, ColdFire, 68K, CPU32, V800, BlackFin, ARC, StarCore, FR, ZSP, Tricore, ST100, i960, MCORE, Alpha, Intrinsity, Lexra, RAD6000, RH32, Renesas, Hitech, SH, SparcLite

Real-Time Operating System µ-velOSity

µ-velOSity™ Real-Time Microkernel

Small, fast, intuitive

The µ-velOSity real-time microkernel is the smallest of Green Hills Software’s family of royalty-free operating systems. It is implemented as a C library so it can be easily ported to a number of target architectures. Its simple design as well as integration with the best-in-class MULTI tools make µ-velOSity both easy to learn and simple to use.

With 20% faster instruction execution, 50% smaller memory footprint, and 80% fewer CPU cycles required to boot, µ-velOSity is the best choice for any cost-sensitive and resource-constrained embedded development application.

Speed & size measurements
Boot time	<1500 cycles
Minimum RAM requirement	1KB
Minimum ROM requirement	1.6KB
*Measurements performed using a standard target configuration. Results may vary based on configuration.

Reduce development time

Designed to be simple to use, µ-velOSity offers a clear, concise API that reduces development time and improves product maintainability. For developers moving from standalone or no-OS configurations, µ-velOSity provides essential kernel features, including:

multi-tasking functionality
hardware abstraction
resource allocation and management
real-time response
integrated middleware support for TCP/IP, MS/DOS and flash file system, USB device/mass storage class, and embedded graphics. With µ-velOSity you will reduce both development costs and time-to-market.

Built with quality


	By combining a small footprint, intuitive interface, and maximum performance, µ-velOSity enables developers to produce reliable device software and get it to market faster and at lower cost.

By delivering µ-velOSity in source code, developers can configure and build the microkernel to meet their specific, unique system design requirements while only including what services are absolutely needed. As a result, developers have ultimate flexibility.

Written in ANSI/ISO compliant C, µ-velOSity employs an rigorous coding style that includes MISRA-C safety subset enforcement. By using these strict coding rules, no function within µ-velOSity exceeds a McCabe Cyclomatic code complexity metric of 8. Based on the SEI risk evaluation assessment using Cyclomatic code complexity numbers, µ-velOSity is a simple program with low risk. In contrast, numbers >8 indicate a complex, high-risk program and up to an un-testable program with very high risk. By using the MULTI debugger to develop, debug, and test µ-velOSity, Green Hills achieves 100% coverage of the µ-velOSity source code during test and validation.

Small size, high speed

With its efficient design and minimal 1.6KB ROM footprint, µ-velOSity fits better in on-chip memory than competing products. This eliminates the need to access off-chip memory, increases execution speed, and reduces the footprint. µ-velOSity was designed to use the smallest number of CPU clock cycles when booting. This is critical for manufacturers developing battery-powered products that measure power consumption in nano joules, so they can assure continuous operation for >10 years on one AA battery. This is also important for embedded devices that require an extremely rapid boot time.

Other operating systems require additional space in each task’s stack for interrupt handling. This method can waste critical memory resources since each task’s stack must be increased to account for the stack use of interrupt service routines. This waste can be extreme if the design allows nested interrupts. µ-velOSity reduces the amount of RAM each task requires by using a separate run-time stack for interrupt handling. In addition, the Green Hills compiler can automatically insert stack overflow checking so that developers can uncover and fix these tough-to-find bugs faster and before product deployment.

µ-velOSity takes full advantage of Green Hills Compiler optimizations by reducing code size and increasing execution speed. Additionally, µ-velOSity’s ultra-fast context switch time and fast kernel service call times also make it ideal for systems where CPU resources are at a premium.

Unmatched scalability


	In µ-velOSity, detailed task status and object information is tightly integrated with source-level debugging to extend system visibility and reduce development time.

Software developed for µ-velOSity is 100% upwards compatible with both the velOSity kernel and INTEGRITY RTOS. Manufacturers that develop a family of embedded devices covering a range of capabilities and price points can standardize on Green Hills Software operating systems and be assured that code written for one device can easily be ported to another, delivering optimal code re-use. With the Green Hills family of operating systems, you can develop a software base that can be shared by low- to high-end products with little modification:

µ-velOSity is ideal at the low end where minimal footprint, maximum speed, and lowest cost are paramount
velOSity is a great fit where middleware and comprehensive board support packages are essential
INTEGRITY is the optimal choice for advanced systems where maximum reliability, safety, and security are critical

This family of operating systems provides developers with a seamless migration path for future designs that grow in complexity and requirements. For example, if an application evolves to require virtual memory support (via the MMU on certain microprocessors), INTEGRITY can be substituted for velOSity or µ-velOSity with only minimal code changes.

Comprehensive development tools

For over 20 years, Green Hills Software has been providing tools for developing and debugging embedded systems. With µ-velOSity, developers can use the most comprehensive suite of development tools available and realize complete application control and visibility:

Hardware debug devices, including the Green Hills Probe, Slingshot, and SuperTrace Probe let you download code to your target for kernel-aware debugging and run-control right out of the box.
Target simulators provide instruction accurate hostbased simulation environments for µ-velOSity when hardware is not yet available or in limited supply.
Optimizing compilers for C, C++, Embedded C++ and MISRA C support the µ-velOSity microkernel. These compilers generate the smallest footprint and fastest executing code in the industry.
The New Project Wizard for µ-velOSity provides project templates and application examples to help users get up and running with µ-velOSity in minutes.
The MULTI suite of development tools for µ-velOSity includes simultaneous multiple task debugging integrated with profiling and code coverage visibility for advanced source-level debugging.
The optional TimeMachine debugger helps you find bugs faster and optimize system performance. TimeMachine can greatly enhance system visibility, significantly reducing development time and helping developers to create higher performance, more reliable device software.
Kernel-aware debugging allows developers to easily view detailed information about µ-velOSity kernel objects, such as tasks and semaphores. Summaries of all objects of a certain type and extensive information about specific kernel objects are made possible by µ-velOSity's tight integration with the MULTI debugger.