Critical airborne and ground-based aerospace software appli-cations commonly require access to avionics data buses for communications with remote computing nodes, sensors, and actuators. In a typical avionics system, this interface is achieved by mounting an embedded interface module, for example a MIL-STD-1553 or ARINC 429 PMC module onto an embedded single board computer as shown in Figure 1.
The embedded single board computer typically hosts an embedded RTOS and the application software. The applications software typically accesses the aircraft data bus through the low-level C style Applications Programming Interface (API) libraries supplied with the PMC interface modules. These low-level APIs are commonly focused on the hardware implementation of the data bus interface module and therefore require the avionics application programmer to become very familiar with and focused on the hardware implementation of the particular interface module being used. Additionally, because these low-level APIs are composed of C language functions, they do not inherently support Object Oriented (OO) programming and design methods, which are commonly used to efficiently build high quality, fault tolerant, and reusable applications software modules using C++. These APIs also do not provide inherent support for multiprocess, distributed applications, which are becoming more common as aerospace and avionics applications become increasingly complex.
To support modern avionics applications designed using the latest OO design methodologies and programming languages, a new generation of high-level C++ APIs has been developed. This new API is designed to provide inherent support for multiprocess applications and distributed computing paradigms and to be easily portable to multiple operating systems and the latest programming languages such as C# and Python. Most importantly, it has been designed to provide an intuitive programming interface that allows the applications developer to focus on the avionics application instead of the specifics of the interface hardware or the details of managing multiple distributed processes.
Supporting state-of-the-art designs
The new high-level API architecture’s primary software module is the API Core, which is based on a core Object Wrapper Layer (OWL) software module (see Figure 2). Additionally, the API Core provides an object-oriented encapsulation of the MIL-STD-1553 and ARINC 429 functions and features of the hardware interface module. The API Core is implemented in C++ and utilizes only standard external libraries, such as the Standard Template Library (STL). Usage of any operating system specific external libraries is strictly prohibited in order to allow the API Core to be easily ported to almost any operating system and Integrated Development Environment (IDE). When coupled with the newly added support for C++ compilation within many commonly used embedded operating systems (such as VxWorks, INTEGRITY, QNX, LynxOS, Linux, and Windows XP Embedded), this design requirement allows applications programmers to take advantage of the latest OO design methods to speed application development and ultimately reduce development and maintenance costs when compared to the usage of legacy C based procedural languages and methodologies.
The new API Core technology also focuses the API on the data bus protocol for which it provides an interface (MIL-STD-1553 and ARINC 429) and shields the user from any details of the underlying hardware interface module. This results in a very intuitive programming interface that frees the applications programmer from the requirement to learn the low-level details of the interface hardware. Additionally, it promotes the development of applications that are independent of the underlying hardware, which increases flexibility and the potential future cost savings should newer and less expensive hardware become available.
The sample code snippet below shows how a Bus Controller command sequence is built and executed using the new MIL-STD-1553 C++ API, demonstrating the hardware independence and intuitive nature of the new library. The implementation of similar functionality using existing low-level APIs could easily take double the lines of source code.
Due to the recently increasing popularity of new object-oriented programming languages such as C# (C Sharp) and Python, the API Core also addresses the need to provide inherent support for multiple languages. Because the new high-level API Core provides a C++ API that is simple and utilizes uniform method prototyping constructs, API designers are able to use the Simplified Wrapper and Interface Generator (SWIG) interface compiler to automatically generate extremely simple and thin software wrappers for the purpose of exporting APIs for other OO languages. In the past, when using existing low-level C based APIs, the task of creating an interface for another language was typically a time consuming and manual process that fell to the applications programmer and added to the overall cost of development.
Distributed multiprocess applications
Another common theme for modern MIL-STD-1553 and ARINC 429 applications and simulations is the use of multi-process and distributed software architectures. When developing these types of applications using old-style APIs, the tedious tasks of managing shared object lifetimes, access to shared data, and the low-level communications between remote processes were left to the applications programmer and therefore added to project costs and impeded the developer’s focus on the avionics application. Thus, to provide more intuitive support for multiprocess (and possibly distributed) applications, new API Core technology includes a Remotable API Server consisting of a Server process and additional features and functions within the API Core to support Client operations. The purpose of the Remotable API service is to free the application developer from the tedious details of interprocess communications and to therefore reduce the cost of implementation while at the same time improving overall quality and performance characteristics of the application software.
The Remotable API Server provides the functionality needed to make the avionics interface hardware APIs available simultaneously to multiple Client processes residing on the local host computer and on remote hosts available via a TCP/IP network. The details of the communications between the server and client processes are completely hidden from applications programmers, freeing them to focus on the avionics applications and not the synchronization and communications details of the host-to-host interactions.
Additionally, platform-independent standard communications protocols (such as IIOP) are used to implement the internal communications interface between the Remotable API Server and remote clients. This allows new API architecture technology to seamlessly support distributed applications residing on multiple hosts using different operating systems. For example, a single distributed application could be spread across three hosts ‚Äì two running Linux and one running Windows XP.
Supporting legacy applications
Due to the abundance of existing applications in service that are heavily based on legacy architectures that cannot support C++ and OO methodologies, the API Core was also designed to provide a complementing ANSI C Application Binary Interface (ABI). The C ABI allows the new API to also be effectively used in more traditional MIL-STD-1553 and ARINC 429 applications while at the same time providing some of the intuitive and hardware independent advantages of the C++ API. The C ABI is designed for binary compatibility, which allows subsequent versions of the C ABI to be used by avionics applications without the requirement for the application to be rebuilt and redistributed. The C ABI is also modeled as a complement to the C++ API to allow applications programmers to easily move from one interface to the other. The code snippet shown below demonstrates how the object-oriented and intuitive nature of the C++ API has been reflected in the C ABI.
Taking avionics APIs into the future
MIL-STD-1553 and ARINC 429 are widely used avionics data buses that can be found in many military and commercial aerospace applications where lifetimes can span decades. These data bus technologies have been proven to withstand the test of time and are still found to be central to many new aircraft and vehicle designs, ensuring their existence well into the future. As a result, there is a need for MIL-STD-1553 and ARINC 429 interface module programming interfaces to effectively and efficiently support both legacy and new system software design techniques that focus on object-oriented methods and multiprocess and distributed architectures. As a result, the systems programmer is freed from focusing on the specific hardware module and can concentrate on more efficient applications development. These were the primary design goals of AIM-USA’s software design team during the development of this new high-level software library architecture, designed to support multiple existing and new avionics applications on multiple hardware and operating systems platforms. CS