The current flight software approach is monolithic in nature. Every module has tentacles that reach deep within dozens of other software modules. Because of these interdependencies between modules, functionality is difficult to extract and reuse for other missions.
A component software approach was deployed via a SysML model to a partitioned operating system that provides mechanisms to enforce strict time and memory space isolation between components. The component design enforces concrete interfaces that restrict communication across well-defined channels and ports to encapsulate functionality. The component modeling approach provides a plug-and-play mechanism for generation and configuration of implementation code. The objective is to demonstrate that a single modeling artifact can be used for both analysis and rapid deployment of software components on a partitioned or multicore real-time system.
The software application component model becomes the basis for analyzing the software architecture and auto-generating flight code to be run on a variety of different platforms in various partitioned configurations. Casting the software application into a formal model enabled explicit representation of a software architecture composed of components that only communicated to other components through interfaces represented as SysML ports. Ports are strongly typed and can only connect to other ports of the same type. SysML stereotypes indicate different types of components as active or passive. In addition, the component port interfaces are stereotyped as synchronous versus asynchronous, indicating methods of communication.
The model lent itself to analysis and was the source from which all components, ports, and communication lines were automatically generated. Once the model was constructed, the software developer manually developed functional code snippets to flesh-in the details within a component.
This work was done by Garth J. Watney, Timothy K. Canham, and Leonard J. Reder of Caltech for NASA’s Jet Propulsion Laboratory.
The software used in this innovation is available for commercial licensing. Please contact Dan Broderick at
This Brief includes a Technical Support Package (TSP).
Modeling for Partitioned and Multicore Flight Software Systems
(reference NPO49403) is currently available for download from the TSP library.
Don't have an account?
Overview
The document titled "Modeling for Partitioned and Multi-core Flight Software Systems" discusses a significant shift in the development of flight software at NASA's Jet Propulsion Laboratory. Traditionally, flight software has been monolithic, with tightly interdependent modules that complicate reuse and configurability for different missions. To address these challenges, the authors propose a component-based software architecture that leverages modeling techniques, specifically using the Systems Modeling Language (SysML).
The primary objective of this new approach is to create a flexible software development environment that allows for predictable performance in partitioned and multi-core systems. The authors emphasize the need for a component software framework, which they developed and refined under the Instrument Software Framework (ISF). This framework encapsulates behavior within components that communicate solely through well-defined, typed ports, promoting isolation and ease of testing.
Key advantages of the ISF include the ability to test components in isolation, reconfigure them with minimal effort, and deploy them across different platforms without altering the underlying code. The document details the creation of a custom ISF Profile that extends SysML to include specific constructs for active and passive components, as well as synchronous and asynchronous ports. This modeling approach allows for a clear representation of software architecture, facilitating analysis and rapid deployment.
The authors also introduce a Component XML Specification, a text-based format for capturing the software component architecture, which serves as the foundation for auto-generating flight code. This process is supported by two main tools: the MagicDraw Component Plugin, which parses the SysML model, and the ISF Autocoder, which generates C++ flight code based on the specifications.
The results of this work were validated using an ARINC653 emulation, demonstrating the flexibility of the approach. Changes to the system, such as reconfiguring component connections or reallocating components to different targets, could be made without modifying the component code itself. This modularity allows for the reuse of components across different applications, significantly enhancing the development process.
In conclusion, the document outlines a transformative approach to flight software development that prioritizes modularity, reusability, and ease of configuration, setting the stage for more efficient and effective software solutions for future space missions.
