Embedded Systems Conference 2008
When: April 14-18, San Jose, CA
Where: McEnry Convention Center
Details: Stop by MapuSoft’s booth #2432 for free t-shirts and hats!
More info: www.cmp-egevents.com/web/esv/home
ASNE Symposium 2008 – Shipbuilding in Support of the Global War on Terrorism
When: April 14-17, Biloxi, MS
Where: Mississippi Coast Coliseum Convention Center
Details: MapuSoft’s Dan Arzonico is giving a technical presentation titled “Challenges in Application Porting and Abstraction in Ship Systems”. Agenda will be announced shortly.
More info: www.navalengineers.org
Jan. 30 & Feb. 13
Generate portable code for multiple RTOS with OS PAL
9:30am US Central Time
1:00pm US Central Time
Feb. 6 & 20
See an application ported to multiple RTOS with OS PAL
9:30am US Central Time
1:00pm US Central Time
Designing an in-house OS abstraction is akin to designing a brand new OS that will need to fit your applications now and in future. This will require a lot of thought and effort in the design. To start, you would first need to identify all of the OS features and functions that your application requires. Next, based on your required features and functions, you need to identify all of the OS candidates that would be suitable for your application during its life cycle. Once your features and functions are identified, the next step would be to focus on the design. Here are some key points to remember during the design phase:
The OS abstraction’s functions and features should satisfy all of your application’s needs, so that it does not rely on the underlying OS for any features (e.g. printf()). Also, each function should be in a separate module so that they are fully scalable. This will allow for you to scale the application’s performance by leaving out or including features. Your design should also allow for extending OS abstraction features in the future without losing the backward compatibility of your existing application code.
The OS abstraction also needs to allow for adding new OS support quickly, without having to change the existing application code. It is best to implement your OS abstraction solution on at least two operating systems to ensure that your solution will allow the application to run on a different OS without code changes. There is no use in developing an OS abstraction that requires you to change your code each and every time you move to a new OS; this would defeat the purpose of an OS abstraction design.
Your OS Abstraction should not interfere unnecessarily while debugging your application. In addition, your OS abstraction must allow for 3rd party software to co-exist with your application. Also, keep in mind that your OS abstraction should not only abstract the APIs, but the data types, header files, etc., too.
As you can see, developing an OS abstraction is a difficult task which requires a lot of forethought. It is difficult to know every OS (or OS version) that your application would ever use, as that would require predicting the future in order to plan for all changes to the application’s requirements. It is also difficult to correctly predict whether the operating systems you planned for will always be available and current, as well as to plan for new operating systems not released yet. In addition, there may be some API features and functions which are available only on some of your OS candidates, but not others. If any of these missing features and functions is critical to your application, you will need to account for their absence in your design. A complex task like developing an in-house OS abstraction takes a lot of development effort and maintenance, which distracts your focus from developing and maintaining your core product.
Luckily, MapuSoft’s OS Abstractor has taken care of all of this for you. OS Abstractor provides standard OS APIs, including common commercial APIs and POSIX APIs, for all of your development and has been designed to make it easy to add new operating systems and features. OS Abstractor also fills in missing features required by your application if the OS does not provide them. All of this is accomplished without sacrificing real-time performance and with the addition of safety critical features, which is vital for embedded applications, especially in mission critical systems. An evaluation of OS Abstractor can be downloaded here:
MapuSoft Technologies recognizes the embedded industry’s growing need to plan for the future as embedded platforms constantly evolve in order to keep up with the demands of changing markets and technologies. Embedded application developers often need to change their operating system for many reasons including OS upgrades, hardware changes and changes in their application’s technical requirements. Developers need to leverage their existing software and knowledge base rather than rewrite the code from scratch and throw away the investment made in the application; hence the need to reuse existing code and develop highly portable code. However, developing a solid software abstraction architecture that can run on multiple operating systems requires considerable planning, development and testing as well as up front costs.
*Check out the Engineering Corner for more detailed information on this subject.
MapuSoft’s OS Abstractor is an effective and economical alternative. By using OS Abstractor, your embedded application can run on many real and non-real time operating systems to negate any porting issues in the future when your platform changes. OS Abstractor enables your application to adapt to multiple operating system platforms with a standard OS interface, thereby reducing the costs associated with code maintenance and learning multiple operating systems. Also, by eliminating OS dependency, you will reduce your time to market when an OS change is required. More information about OS Abstractor and other products we offer can be found here: mapusoft.com/old/products/osabstractor/
President & CEO
Happenings in the Embedded World:
MapuSoft Technologies recently increased its market presence and profile in Australia and New Zealand by signing a distribution pact with Embedded Logic Solutions. Embedded Logic is a distributor of embedded solutions in industry sectors as diverse as defense, education, automotive and other electronic design and manufacturing areas.
The agreement makes Embedded Logic Solutions an authorized distributor of MapuSoft’s OS Changer®, OS Abstractor®, and OS PAL® solutions throughout the Australian and New Zealand markets and significantly expands MapuSoft’s reach in a region with a well established embedded market that is rapidly growing. Under the distribution pact, Embedded Logic will be engaging directly with customers to offer MapuSoft’s porting and abstraction products for embedded applications to help developers easily migrate from legacy platforms to the next generation.