All NexWave products are developed using NSI (NexWave Software Infrastucture): the first component architecture totally adapted to the embedded software industry.
Here are a description and the benefits of this technology.
Components: Binary entities interacting through well-defined interfaces to form a functioning system.
NSI is a light-weight, flexible, platform- and OS-independent binary component model developed over several years of collaboration with CE manufacturers. This patented component technology offers features tailored to embedded-systems over & above generic component technology features. NSI is easy to use for developers with simple constructs to define interfaces in terms of services they provide and the ones they use.
The following figure shows the elements that compose the NSI component model:
- A, B, C, D are components
- I1, I2, I3 are interfaces
- B exports (provides) the I1 interface and imports (requests) the I2 and I3 interfaces. B's dependencies are resolved by import links with C and D, which export matching interfaces.
Components and Interfaces
NSI is defined by the following properties:
- Binary components embedding their interface definitions
- Build-time and run-time dependency resolution
- Flexible links between the components
- Direct communication between components (direct function calls whenever possible)
- Low requirements regarding resources and underlying OS
NSI (NexWave Software Infrastructure) is the first component architecture that is totally adapted to the embedded software industry.
NSI is primarily about permitting reuse of code across different product populations. For example, a component written for a DVD player can be seamlessly and easily reused in a set-top box. As reusable components are created and added to the population, greater component reuse is facilitated across different projects, and developers witness increasing returns.
|
BENEFITS
|
PC based Development and Testing |
| Dynamic BENEFITS Systems Update |
| Improved Systems Response |
|
DISTINGUISHING FEATURES
|
Legacy software reuse |
| OS/Hardware independence |
| Minimum memory and CPU overhead |
| Runtime component selection for system composition |
|
SOFTWARE ENGINEERING BENEFITS
|
Decrease of development costs |
| Shorter Time-to-Market |
| Quality |
PC based Development & Testing
Nexwave provides a well-defined OS independent Abstraction Layer implementation on multiple platforms including x86-based Windows & Linux. Nexwave also includes a set of PC-based
Development Tools. This enables NSI-based components to be developed & tested on the PC. This provides benefits like: (a) Ability to separate software development from Hardware availability (b)
Provide a low cost development environment for software developers & (c) Ability to perform complete system testing prior to deployment onto the hardware.
Dynamic Systems Update
NSI-based systems in the field can be efficiently upgraded by only replacing those components that have been modified. This greatly contains the cost to update systems as well as contains the upgrade
complexity.
Improved Systems Response
NSI provides mechanisms for the developer to determine which components are required at system start-up and which others can be dynamically loaded & unloaded on demand (based on features
invoked at runtime). As software systems increase in size & complexity, NSI provides the flexibility to balance the system in terms of application start-up time & memory requirements, improving systems
response.
Decrease of development costs
Software engineers do not come cheap, and studies have shown that even the most talented engineers are able to write only 10 lines of production-quality code per day.
Shorter time to market
For many CE organizations, time to market is much more important than the cost of development - for the same reason that reused software is cheaper, it can also be produced more quickly than rewritten
software.
Quality
Achieving the quality standards required by customers is often the most common cause of delays in software projects (i.e., many late software projects are late due to protracted bug-cleaning phases).
Reusable software that has been tested in a multitude of environments is likely to be of a higher quality than software written from scratch.
Legacy software reuse
Existing libraries, modules or source files from the last-generation software are valuable assets to integrate in a component-based infrastructure. NSI does not replace the legacy compiler, but works in
association with it, linking legacy object files with the binary encoding of the exported and imported interfaces. By limiting the refactoring to what the design of the new components and their interfaces
requires, we aim at reducing the componentization cost and effort.
OS/Hardware independence
NSI itself is hardware independent and available on various operating systems. A few NSI components provide full RTOS application program interfaces (APIs) (memory, mailbox, semaphore,
mutex, etc.). These APIs allow to write RTOS-agnostic components.
Moreover, some NSI components are provided to simulate other RTOS APIs (like TRON). This brings a powerful environment where components written for NSI can seamlessly operate with components made from TRON legacy software or other RTOS.
Hence, it is very easy to write highly portable applications across various OSes and hardware. Furthermore, NSI also provides drivers' abstraction components for framebuffer (GUI), keyboard, file
access, IP communication (sockets), etc. Finally, only few chipset-specific drivers need to be either emulated or faked to develop a CE application on a PC (Windows or Linux).
Minimum memory overhead and CPU overhead
The memory overhead introduced by NSI is limited to the NSI runtime itself (less than 150 KB). In comparison with standard software modules, components do not add any memory overhead except
the one needed to encode the component interfaces which is kept to its minimum. Nexwave also provides monitoring tools that will provide memory & CPUs measurements for individual components.
Runtime Component Selection for system composition
As NSI is a binary component technology, systems can dynamically select components as required by the runtime constraints. NSI provides the developer to specify attributes for components that specify
the systems constraints. The developer can determine that a system can include (a) either multiple or single implementation (b) required or optional implementation of an interface. For example, a product
that supports different Video region formats (NTSC, PAL etc.) can load the required region format based on the input stream but will need to have at least one of these implementations at any given
time.
If you are interested in our technology and would like to read further about our component-based solution and how it applies to the consumer electronics industry, make sure to read the following papers.
Component-Based Software Engineering for Consumer Electronics
Abstract: Component-based software engineering (CBSE) has become widely practiced in the desktop and enterprise computing arenas. Yet despite its applicability, the many benefits of CBSE have remained largely unavailable to many embedded software developers. Meanwhile, the amount of software contained in modern Consumer Electronics (CE) devices over the past decade has exploded, due largely to the market's move from analogue to digital devices (e.g., VCR to DVD). Modern CE companies have had to change almost overnight from hardware suppliers who provide small amounts of software on their devices, to software suppliers who provide generic digital computing devices (with some specialized I/O peripherals) on which their software is run. Many CE vendors are struggling to cope with this profound transformation, and stand to benefit enormously from the advances brought by CBSE...
NSI: A Component Model for Consumer Electronics Software
Abstract: NSI (Nexwave Software Infrastructure) is a software component model targeted at embedded software development, and specifically at CE software. The NSI component model is a simple binary model, with associated tools and runtime environment. The components contain native code in order to provide the power and efficiency necessary for CE software. NSI interfaces are simple yet powerful mechanisms by which the often complicated interdependencies between components can be managed. NSI has been designed to allow easy conversion of existing monolithic or modular code into components...
NSI Overview
Software component infrastructures are widely recognized as a major productivity enhancement approach, decreasing time to market, increasing quality and easing maintenance, thanks to the reuse of already developed, flexible and re-configurable components. Business, desktop and server software use asynchronous, message-passing component models such as CORBA, which allow application-level componentization and run-time upgrades at the expense of a non- real-time, resource intensive approach. Some Consumer Electronics (CE) manufacturers have pioneered internal source code based, build-time component models, which allow embedded applications to be componentized; however, commercial component systems for the embedded market have been surprisingly rare...
KOREAN- NSI Technology
Korean document explaining the fundementals of Nexwave Software Infrastructure(NSI).
KOREAN- NSI Product
Korean document describing Nexwave Software Infrastructure(NSI) with various supporting tools as a product.
KOREAN-Customer Example
Korean document outlining a leading customer (Hitachi) strategy in using and deploying Nexwave Software Infrastructure (NSI) in various Digital Consumer Electronic devices.
