This article also appears in
Subscribe now »

This diagram reflects the flow of the software build within MAHLE Powertrain's One-Click Build environment and tool chain for real time safety critical embedded systems.

Automating the software build process for an aerospace embedded system

For safety-critical real time embedded applications, quality, error-free, and flawless functioning of embedded software is paramount. This is particularly true when such embedded systems are an integral part of our lives, for example automobiles, general aviation, aerospace, other modes of public transportation, medical, etc. There are unique development challenges that surround designing and building embedded systems, because quite often software is developed independently of the hardware that it will eventually run on.

With more than 15 years of embedded systems development experience in aerospace and automotive applications, the Calibration & Controls team at MAHLE Powertrain LLC recently took on an aerospace project to design and develop embedded hardware, firmware, and the propulsion control application. In addition, it also required to meet aerospace-grade redundancy and safety aspects as well as long-term support for the product for future years. Understanding these requirements, during the concept stage of the project, the team realized that the robust- flexible-automated Embedded Software Build automation was an imperative and extremely crucial component of the final product delivery.

Automating the software build process is a fundamental step in maturing the software development process. The most important goal is to ensure build completeness and consistency to ensure the whole system is built with all the selected components. This way the build result is accurately predicted, build reproducibility is ensured, and development downtime due to build issues are reduced or eliminated.

Continuous Integration is the process of building the application on every new source code check-in and is an integral part of the Software Configuration Management, which allows small and frequent releases.

Build management incorporates the integration of all the components of a software application into an installable software product.

The most important goal of the build management is neither completeness nor consistency, which shouldn't be misunderstood as unimportant aspects—but rather, the most important goal of Build Management is repeatability. This ensures the ability to re-create any past instance of the software build and reproduce the original output with bugs that can be compared to the new output without the bug to ensure that the said bug is fixed.

Thus, automated build, continuous integration, and build management are the key aspects of a build process, when the software development teams are looking for increased efficiencies and improved quality of the software product.

For software development that involves an elaborate technical concept or requires collaborating with other people within a project team or working on different tasks in parallel, version control becomes extremely important to keep up with changes and reduce errors. It is important to work in unison while working on different tasks without getting in each other's way and to keep up-to-date with the progress of the software development.

Efficient version control would allow for a central repository that is organized and logical, facilitates file updates, notation, comparison, and merging. To choose the right version control tool could be a difficult task when considering difficulty of use, opting between server-based or peer-to-peer, ease of check-in and check-out process for the software developer and if it has a centralized repository or a decentralized network setup, where the code is frequently updated from peer sources. The goal is to force software programmers or developers to follow a standard practice within the organization and thus reduce man-hours on paperwork trails or manually scanning code or the associated notes.

MAHLE Powertrain selected Mercurial as a distributed revision control tool. It's created in Python, allowing the non-core developer to have easier access to creating new trees and undoing changes. The Mercurial documentation is more complete and facilitates learning the differences faster while its drawback is that it doesn't allow two parents to be merged and is not scriptable.

The proprietary real time operating system (RTOS) provides a simple method for scheduling individual tasks in a priority-based manner with support for pre-emptively running higher priority tasks by storing the current machine state for the current task and restoring it when the processor was available after any higher priority tasks are completed. The RTOS also provides a semaphore synchronization mechanism to protect shared system resources.

The low-level firmware or middleware has two major components, which are the VHDL code and C code. The basic functionality of the C code is to coordinate the timing of all system components, which includes itself as well as higher layers and act as a watchdog for each. In addition to its timing function it also initializes and communicates with all the hardware peripherals on behalf of the higher layers. The VHDL portion of the firmware manages safety critical tasks as well as time critical tasks.

The application layer was developed using Mathworks tools that consisted of MATLAB, Simulink, Stateflow, and various Mathwork toolboxes. While the functionality can be simulated on a PC, various toolboxes allowed a flexible configuration showing and documenting all necessary details when the model was compiled to the code. When working in embedded development, resource management is extremely important. For example it is important to keep track of processing time of the CPU, needed RAM and ROM while developing or adding new features.

The MAHLE Powertrain-developed One-Click Build Environment and Tool Chain for Real Time Safety Critical Aerospace Embedded System eliminates risk of human error while building the embedded code for the target device, ensuring repeatability and reproducibility of the build process. It is readily available in a build-able state for full-system builds offline or online with a Mercurial repository allowing for efficient version control and software management.

With progression of embedded software application development it allows continuous integration of incremental builds and protects for complete successful full-system builds with immediate success or failure feedback to the developer. The build environment ensures no unexpected build artifacts or no runtime dependencies are created by performing the software build in clean workspace. For audit and debugging purposes it generates a build-log in HTML as well as provides an audible sign of finished build.

The version control and software configuration management provides a reference back to the previous instance of the software iterations and allows rebuilding of the software code to debug the issues created in the new software or to trace back the bug being generated in the past.

With this successful implementation in next generation further enhancements will be carried out to adapt the tool chain to multiple platforms, taking the efficiency to the next level.

This article is based on SAE International technical paper 2013-01-2259 by Tejas Chhaya, Dan Evans, David Dempsey, and Jason Powers of MAHLE Powertrain LLC.

Continue reading »