Model-based Reactive Programming of Cooperative Vehicles for Mars Exploration

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-