Families (of products) in space

NASA is developing plans for innovative and novel approaches to future (unmanned) space exploration missions. Future missions involve sending spacecraft and robots to harsh environments, where resilience is necessary for the survival of the mission. In addition, distances and communication lead times between the spacecraft and Earth necessitate much of the mission operation being autonomous. We have been conducting research on the development of autonomous space exploration missions based on principles from Autonomic Computing (AC), whereby the mission is imbued with self-management capabilities. Such missions will involve several, rather than single, spacecraft, robots or other devices, operating in collaboration. We describe one such concept mission, ANTS (Autonomous Nano-Technology Swarm), which involves a number of sub-missions that are self-similar. Our work in this, and other future missions, has involved the use of techniques from AC for building in self-management, and ultimately self-governance. We have also explored the use of formal methods to gain confidence in the correct behavior of the mission. Since both the physical devices which will be used for exploration, and the software that is essential for their successful deployment, lend themselves to a productline approach, we have been exploiting techniques from software product-line engineering, in particular Multi-Agent System Product Lines (MAS-PL) and Dynamic Software Product Lines (DSPL)

Autonomy requirements engineering: a case study on the Bepicolombo mission

The development of unmanned space exploration missions is closely related to integration and promotion of autonomy in robotic spacecraft. Elicitation and expression of autonomy requirements is one of the most significant challenges the autonomous spacecraft engineers need to overcome. Nowadays, requirements engineering for autonomous systems appears to be a wide open research area with no definitive solution yet. This paper presents an approach to Autonomy Requirements Engineering where Goal-Oriented Requirements Engineering is merged with special Generic Autonomy Requirements. To provide a solution to the domain of space missions, the Generic Autonomy Requirements are put in the context of space missions. Further, the approach is applied to a case study based on the ESA’s BepiColombo Mission where mission’s autonomy requirements are elicited

Multi-agent systems – Theory, approaches and NASA applications

This chapter introduces the multi-agent paradigm and presents concepts and approaches related to multi-agent systems and paradigm-inspired popular research topics such as grid computing, intelligent swarms, sensor networks, service-oriented computing, cloud computing and autonomic computing. Additionally, the chapter reflects the authors’ experience and presents a review of the NASA multi-agent applications of ground control and space-exploration systems. The Multi-Agent Systems approach helps NASA systems deal efficiently with huge amounts of data and to perform unmanned tasks in deep space where single monolith spacecraft are impractical

Knowledge representation and reasoning for intelligent software systems

Knowledge representation and reasoning for intelligent software system

Knowledge representation with KnowLang: the marXbot Case Study

Intelligent systems are capable of AI exhibited via knowledge representation and reasoning, which helps to connect abstract knowledge symbols to real-world meanings. This paper presents a formal language for knowledge representation called KnowLang. The language implies a multi-tier specification model emphasizing knowledge corpuses, knowledge base operators and inference primitives. The approach allows for efficient and comprehensive knowledge structuring where ontologies are integrated with rules and Bayesian networks. The paper presents the KnowLang specification constructs formally along with a case study based on a mobile robotics platform

ASSL: a software engineering approach to autonomic computing

ASSL provides a framework for formal specification, validation, and code generation of autonomic systems

Modeling the image-processing behavior of the NASA voyager mission with ASSL

NASA exploration missions increasingly rely on the concepts of autonomic computing, exploiting these to increase the survivability of remote missions, particularly when human tending is not feasible. This paper presents initial results of long-term research targeted at the design and implementation of prototype models for future Voyager-like missions that rely on principles of autonomic computing. Here, we employ the Autonomic System Specification Language (ASSL) to build a formal model and to generate a prototype for the image-processing behavior of the NASA Voyager Mission. This helps to validate existing features and perform experiments through simulation. Moreover, this prototype lays the basis for future experiments whereby autonomic features are added in a stepwise manner

Developing self-managing embedded systems with ASSL

We present a new formal approach to the implementation of embedded systems, arrived at by introducing self-management capabilities to the same. We use the ASSL (Autonomic System Specification Language) framework to approach the problem of formal specification and automatic code generation of embedded systems. Some features of ASSL help to specify event-driven embedded systems where hardware is sensed via special metrics intended to drive events and self-management policies. The latter can be specified to handle critical situations in an autonomous reactive manner. Moreover, we present a case study where we use ASSL to specify control software for the wide-angle camera carried on board by NASA’s Voyager II spacecraf

On the autonomy requirements for space missions

In new space exploration initiatives of NASA and ESA, there is emphasis on both human and robotic exploration. Risk and feasibility are major factors supporting the use of unmanned craft and the use of automation and robotic technologies where possible. In that context, an autonomous system is able to monitor its behavior and eventually modify the same according to changes in the operational environment, thus being considered as self-adaption. Requirements engineering for autonomous systems, therefore, must address what adaptations are possible and under what constrains, and how those adaptations are realized. Requirements engineering for autonomous systems appears to be a wide open research area with only a limited number of approaches yet considered. In this paper, we present initial results of our research and study on autonomy requirements for space system

Capturing autonomy features for unmanned spacecraft with ARE, the Autonomy Requirements Engineering approach

Along with the traditional requirements, requirements engineering for autonomous and self-adaptive systems needs to address requirements related to adaptation issues, in particular: 1) what adaptations are possible; 2) under what constrains; and 3) how those adaptations are realized. Note that adaptations arise when a system needs to cope with changes to ensure realization of the system’s objectives. To handle these and other issues, Lero - the Irish Software Engineering Research Center has developed the Autonomy Requirements Engineering (ARE). Basically, ARE converts adaptation issues into autonomy features where Goal-Oriented Requirements Engineering (GORE) is used along with a model for Generic Autonomy Requirements (GAR). The approach is intended to help engineers develop missions for unmanned exploration, often with limited or no human control. Such robotics space missions rely on the most recent advances in automation and robotic technologies where autonomy and autonomic computing principles drive the design and implementation of unmanned spacecraft