Showing papers by "Brian C. Williams published in 2001"

Executing reactive, model-based programs through graph-based temporal planning

Abstract: In the future, webs of unmanned air and space vehicles will act together to robustly perform elaborate missions in uncertain environments. We coordinate these systems by introducing a reactive model-based programming language (RMPL) that combines within a single unified representation the flexibility of embedded programming and reactive execution languages, and the deliberative reasoning power of temporal planners. The KIRK planning system takes as input a problem expressed as a RMPL program, and compiles it into a temporal plan network (TPN), similar to those used by temporal planners, but extended for symbolic constraints and decisions. This intermediate representation clarifies the relation between temporal planning and causal-link planning, and permits a single task model to be used for planning and execution. Such a unified model has been described as a holy grail for autonomous agents by the designers of the Remote Agent[Muscettola et al., 1998b].

Mode estimation of model-based programs: monitoring systems with complex behavior

Abstract: Deductive mode-estimation has become an essential component of robotic space systems, like NASA's deep space probes. Future robots will serve as components of large robotic networks. Monitoring these networks will require modeling languages and estimators that handle the sophisticated behaviors of robotic components. This paper introduces RMPL, a rich modeling language that combines reactive programming constructs with probabilistic, constraint-based modeling, and that offers a simple semantics in terms of hidden Markov models (HMMs). To support efficient realtime deduction, we translate RMPL models into a compact encoding of HMMs called probabilistic hierarchical constraint automata (PHCA). Finally, we use these models to track a system's most likely states by extending traditional HMM belief update.

A Reactive Model-based Programming Language for Robotic Space Explorers

Abstract: Model-based autonomous agents have emerged recently as vital technologies in the development of highly autonomous reactive systems, particularly in the aerospace domain. These agents utilize many automated reasoning capabilities, but are complicated to use because of the variety of languages employed for each capability. To address this problem, we introduce model-based programming, a novel approach to designing embedded software systems. In particular, we introduce the Reactive Model-based Programming Language (RMPL), which provides a framework for constraint-based modeling, as well as a suite of reactive programming constructs. To convey the expressiveness of RMPL, we show how it captures the main features of synchronous programming languages and advanced robotic execution languages. This paper focuses on using the rich behavior modeling of RMPL to provide sequencing and robotic execution capabilities for spacecraft.

Model-based Reactive Programming of Cooperative Vehicles for Mars Exploration

Abstract: In the future webs of unmanned vehicles will act together to robustly achieve elaborate missions within uncertain environments. This web may be a distributed satellite system forming an interferometer, or may be a heterogenous set of rovers and blimps exploring Mars. We coordinate these systems by introducing a reactive model-based programming language (RMPL) that combines within a single unified representation the flexibility of embedded programming and reactive execution languages, and the deliberative reasoning power of temporal planners. To support fast mission planning as graph search, the KIRK planner compiles an RMPL program into a temporal plan network (TPN), similar to those used by temporal planners, but extended for symbolic constraints and decisions. To robustly coordinate air vehicle or rover maneuvers we combine the Kirk planning algorithm with randomized algorithms for kinodynamic path planning. Finally, we describe our Mars exploration testbed, including four RWI ATRV vehicles. 1 Model-based Programming The recent spread of advanced processing to embedded systems has created vehicles that execute complex missions with increasing levels of autonomy, in space, on land and in the air. These vehicles must respond to uncertain and often unforgiving environments, both with a fast response time and with a high assurance of first time success. The future looks to the creation of cooperative robotic networks. For example, giant space telescopes are being deployed that are composed of satellites carrying the telescope’s different optical components. These satellites act in concert to image planets around other stars, or unusual weather events on earth. In addition, the 2000 Mars Program Independent Assessment Team recommended an exploration architecture that adopts a more global view. For example, a heterogenous set of vehicles, such as orbiters, rovers and blimps might work in concert to identify and evaluate sites of greatest scientific interest. The creation of robotic networks cannot be supported by the current programming practice alone. Recent mission failures, such as the Mars Climate Orbiter and Polar Landers, highlight the challenge of creating highly capable vehicles within realistic budget limits. Due to cost constraints, spacecraft flight software teams often do not have time to think through all the plausible situations that might arise, encode the appropriate responses within their software and then validate that software with high assurance. To break through this barrier we need to invent a new programming paradigm. In this paper we advocate the creation of embedded, model-based programming languages that support the ability to specify global strategies for multivehicle coordination. First, we argue that the programmer should retain control for the overall success of a mission, by programming game plans and contingencies that in the programmer’s experience will ensure a high degree of success. The programmer should be able to program these game plans using features of the best embedded programming languages available. For example, reactive synchronous languages[5], like Esterel, Lustre and Signal, offer a rich set of constructs for interacting with sensors and actuators, for creating complex behaviors involving concurrency and preemption, and for modularizing these behaviors using all the standard encapsulation mechanisms. Model-based programming extends this style of reactive language with a minimal set of constructs neccessary to perform flexible mission coordination, while hiding its reasoning capabilities under the hood of the language’s interpreter or compiler. Second, we argue that model-based programming languages should focus on elevating the programmer’s thinking, by automating the process of reasoning about low-level system interactions. Many recent space mission failures, such as Mars Climate Orbiter and Mars Polar Lander, can be isolated to difficulties in reasoning through low-level system interactions. On the other hand, this limited form of reasoning and book keeping is the hallmark of computational methods. The interpreter or compiler of a model-based program reasons through these interactions using composable models of the system being controlled. We are developing a language, called the Reactive Model-Based Programming Language (RMPL), that supports four types of reasoning about system interactions: reasoning about contingencies, scheduling, inferring a system’s hidden state and controlling that state. This paper develops RMPL in the context of contingencies and scheduling, while [15], shows how RMPL is used to infer hidden state. Third, execution of these programs is a form of mission-level planning that searches through the options for the optimal strategy that operates within the time constraints. Vehicle movement is central to these missions, hence to achieve global optimality we unify mission-level planning with global path planning algorithms. In particular we build upon the rapidly exploring random tree (RRT) algorithm of La Valle[8]. In addition, these vehicles may operate in highly dynamic situations or situations where maneuvering is extremely tight. RMPL offers a middle ground between execution languages, like RAPS [4], and highly flexible, operator-based temporal planners,like HSTS [10]. RAPS offers the exception handling and concurrency mechanisms of embedded languages, while adding goal monitoring, nondeterministic choice and metric constraints. However, RAPS makes its decisions reactively, without addressing concerns of schedulability and threat resolution, and hence can fall into a failure state. RMPL incorporates the forward looking planning and scheduling abilities of modern temporal planners, but can substantially restrict the space of plans considered to possible threads of execution through the RMPL program. This speeds response and mitigates risk. To develop the model-based programming paradigm in the context of Mars exploration, we have developed a combination of simulation and ground-based testbeds, including a collection of four RWI ATRV rovers and a set of formation flying spacecraft, called Spheres, to be flown on space station. The paper begins by introducing a subset of RMPL that includes constructs from traditional reactive programming plus constructs for specifying contingencies and scheduling constraints. Second, we describe how Kirk, an RMPL-based planner/executive, compiles RMPL programs into temporal plan networks (TPN), which compactly represent all possible threads of execution of an RMPL program, and all resource constraints and conflicts between concurrent activities. Third, we present Kirk’s online planning algorithm for RMPL that “looks” by using network search algorithms to find threads of execution through the TPN that are temporally consistent. The result is a partially ordered temporal plan. Kirk then “leaps” by executing the plan using plan execution methods[12] developed for Remote Agent[11]. Fourth, we develop the unification of Kirk with randomized, kino-dynamic path planning algorithms. We present Kirk in the context of a simple Mars exploration mission segment. 2 Example: Cooperative Ex-

Improving Model-based Mode Estimation through Offline Compilation

Abstract: Many recent and future space missions point to the need for increased autonomy in spacecraft with an emphasis on more capable fault diagnostic systems. The most widely used fault diagnostic systems are rule-based. Rule-based systems have quick response to events and clearly present to engineers the predefined reactions to events. These systems, however, require engineers to manually generate all necessary rules and these do not convey the assumed model the engineers used to generate the rules. Contrarily, model-based systems eliminate the need to manually generate the rules. Most model-based system such as GDE [3], Sherlock [4], and Livingstone [6], however, may not provide quick response and do not specify the rules for engineers to review and verify. Mini-ME addresses the issues of both rule-based and model-based approaches and provides an alternative solution to fault diagnosis. Mini-ME provides quick response by shifting computationally expensive tasks of model-based diagnosis offline. Additionally, it offers the capability to inspect and verify the rules.

Autonomous sequencing and model-based fault protection for space interferometry

Abstract: This paper documents the application of RA technologies in the field of interferometer instrument control.

The Techsat-21 Autonomous Sciencecraft Constellation Demonstration

Abstract: The Autonomous Sciencecraft Constellation flight demonstration (ASC) will fly onboard the Air Forces's TechSat-21 constellation. Demonstration of its capabilities in a flight environment will open up tremendous new opportunities in planetary science, space physics, and earth science that would be unreadable without this technology.

A demonstration of robust planning, scheduling, and execution for the Techsat-21 autonomous sciencecraft constellation

Abstract: The paper talks about the planning, scheduling, and execution framework used in ASC (Autonomous Sciencecraft Constellation).