Model-based Programming of Cooperative Explorers Prof. Brian C. Williams Dept. of Aeronautics and Astronautics Artificial Intelligence Labs And Space Systems MIT

Classical Robotics

Deep Space Explorers and Aerial Robots Cassini Saturn Orbital Insertion Complements JPL Human-guided stunt helicopter Complements Eric Feron, MIT and Draper Labs Self Repairing Agile

Exploring Mars: Hetrogenous robotics test bed Cooperative

Model-based Autonomy and Programming How do we program explorers that reason quickly and extensively from commonsense models? How do we incorporate model-based autonomy into every day, ubiquitous computing devices through model-based programming? How do we coordinate heterogeneous teams of robots -- in space, air and land -- to perform complex exploration? How do we couple reasoning, adaptivity and learning to create robust agents?

Model-based Programming of Self Repairing Explorers

Would like to support programmers with Embedded Languages that Reason from Commonsense Models (Model-based Programming) Leading Diagnosis: Legs deployed during descent. Noise spike on leg sensors latched by software monitors. Laser altimeter registers 50ft. Begins polling leg monitors to determine touch down. Latched noise spike read as touchdown. Engine shutdown at ~50ft. Mars 98: Climate Orbiter Mars Polar Lander Must diagnose symptoms that are manifest through complex Software and Hardware Interactions

Command dispatch Fault protection Attitude control Command Sequence Mission Goal Scenario Monitors

Robustness involves controlling and sensing a complex internal network

Programmers and operators must reason through system-wide interactions to : monitor monitor track goals track goals confirm commands confirm commands isolate faults isolate faults diagnose faults diagnose faults reconfigure hardware reconfigure hardware coordinate control policies coordinate control policies repair repair avoiding failures avoiding failures Managing Interactions for Self-Repair

Robustness Requires Novel Solutions courtesy of NASA Quintuple fault occurs (three shorts, tank-line and pressure jacket burst, panel flies off). Mattingly works in ground simulator to identify new sequence handling severe power limitations. Mattingly identifies novel reconfiguration, exploiting LEM batteries for power.

Example of a Model-based Agent: Goal-directed First time correct projective reactive Commonsense models Heavily deductive Scripts component models Goals Diagnosis & Repair Mission Manager ScriptedExecutive Planner/Scheduler Remote Agent Mission-level actions & resources

courtesy JPL Started: January 1996 Launch: Fall 1998

Remote Agent Experiment May 17-18th experiment Generate plan for course correction and thrust Diagnose camera as stuck on — Power constraints violated, abort current plan and replan Perform optical navigation Perform ion propulsion thrust May 21th experiment. Diagnose faulty device and — Repair by issuing reset. Diagnose switch sensor failure. — Determine harmless, and continue plan. Diagnose thruster stuck closed and — Repair by switching to alternate method of thrusting. Back to back planning See rax.arc.nasa.gov

Model-based Autonomy and Programming How do we program explorers that reason quickly and extensively from commonsense models? How do we incorporate model-based autonomy into every day, ubiquitous computing devices through model-based programming? How do we coordinate heterogeneous teams of robots -- in space, air and land -- to perform complex exploration? How do we couple reasoning, adaptivity and learning to create robust agents?

Model-based Programs Interact Directly with State Embedded programs interact with plant sensors/actuators: Read sensors Set actuators Model-based programs interact with plant state: Read state Write state Embedded Program S Plant Obs Cntrl Model-based Embedded Program S Plant Programmer must map between state and sensors/actuators. Model-based executive maps between sensors, actuators to states.

Orbital Insertion Example EngineAEngineB Science Camera EngineAEngineB Science Camera

Model-based Programs Evolve Hidden State Model-based Executive Command goals Observations Flight System Control RT Control Layer State Reactive Control Program Reactive Control Program

Temporal planner Model-based Executive Command Goal state Observations Flight System Control RT Control Layer Inferred State Thrust Goals Attitude Point(a) Engine Off Delta_V(direction=b, magnitude=200) Power Model-based Programs Evolve Hidden State Programmer specifies abstract state evolutions OrbitInsert():: (do-watching ((EngineA = Firing) OR (EngineB = Firing)) (parallel (EngineA = Standby) (EngineB = Standby) (Camera = Off) (do-watching (EngineA = Failed) (when-donext ( (EngineA = Standby) AND (Camera = Off) ) (EngineA = Firing))) (when-donext ( (EngineA = Failed) AND (EngineB = Standby) AND (Camera = Off) ) (EngineB = Firing)))) Reactive Model-based Programming Language: State assertion State query Conditional execution Preemption Iteration Concurrent execution Programs “read” and “set” variables that are typically hidden.

Model Temporal planner Model-based Executive Command goals Observations Flight System Control RT Control Layer State Thrust Goals Attitude Point(a) Engine Off Delta_V(direction=b, magnitude=200) Power RMPL Executive Reasons from Plant Model Closed Valve Open Stuckopen Stuckclosed OpenClose inflow = outflow = 0 OrbitInsert():: (do-watching ((EngineA = Firing) OR (EngineB = Firing)) (parallel (EngineA = Standby) (EngineB = Standby) (Camera = Off) (do-watching (EngineA = Failed) (when-donext ( (EngineA = Standby) AND (Camera = Off) ) (EngineA = Firing))) (when-donext ( (EngineA = Failed) AND (EngineB = Standby) AND (Camera = Off) ) (EngineB = Firing))))

Model Temporal planner Model-based Executive Command goals Observations Flight System Control RT Control Layer State Thrust Goals Attitude Point(a) Engine Off Delta_V(direction=b, magnitude=200) Power RMPL Executive Reasons from Plant Model mode = open  high pressure = high flow; nominal pressure = nominal flow;... mode = closed  Zero flow OrbitInsert():: (do-watching ((EngineA = Firing) OR (EngineB = Firing)) (parallel (EngineA = Standby) (EngineB = Standby) (Camera = Off) (do-watching (EngineA = Failed) (when-donext ( (EngineA = Standby) AND (Camera = Off) ) (EngineA = Firing))) (when-donext ( (EngineA = Failed) AND (EngineB = Standby) AND (Camera = Off) ) (EngineB = Firing))))

Model Temporal planner Model-based Executive Command goals Observations Flight System Control RT Control Layer State Thrust Goals Attitude Point(a) Engine Off Delta_V(direction=b, magnitude=200) Power RMPL Executive Reasons from Plant Model State estimates Commanding & Repair Estimation & Diagnosis State Goals Open four valves Engine Off Achieve Thrust Valve fails stuck closed Fire backup engine

Automate programmers ability to reason from commonsense models in light of mission goals. Model-based Programming Model-based Reactive Programming Programmer guides state evolution at strategic levels. Commonsense Modeling Programmer specifies commonsense, compositional models of spacecraft behavior. Model-based Execution Kernel Reason through system interactions on the fly, performing deduction within the reactive control loop. Model-based Compilation Reduce knowledge to a vivid form, think through local contingencies.

When you have eliminated the impossible, whatever remains, however improbable, must be the truth. - Sherlock Holmes. The Sign of the Four. OPSAT: Exploring the Improbable Generate Best Options: Generalize test results to leap over infeasible options Test Against Model: Incrementally deduce how truth changes Generate BestFeasibleOptions ConflictingElements Checkedoption Test

Compare Most Likely Hypothesis to Observations It is most likely that all components are okay, and the valves are in the mode indicated.

Isolate Conflicting Information The component modes indicated in red conflict with the model and observations.

Leap to the Next Most Likely Hypothesis that Resolves the Conflict The next consistent hypothesis must differ from the conflict by at least one component mode.

New Hypothesis Exposes Additional Conflicts Next consistent hypothesis must differ from both conflicts

Final Hypothesis Resolves all Conflicts Helium tank Fuel tankOxidizer tank Main Engines Pressure 1 = nominal Flow 1 = zero Pressure 2 = nominal Flow 2 = positive Acceleration = zero Implementation: Hypotheses generated by minimal set covering, guided by A* search.

Model-based Autonomy and Programming How do we program explorers that reason quickly and extensively from commonsense models? How do we incorporate model-based autonomy into every day, ubiquitous computing devices through model-based programming? How do we coordinate heterogeneous teams of robots -- in space, air and land -- to perform complex exploration? How do we couple reasoning, adaptivity and learning to create robust agents?

Model-based Programming of Cooperative Systems How do we model behaviors of cooperative robotic networks? How do we command cooperative networks? How do we monitor cooperative networks?

Programmers and operators must reason through system-wide interactions to : select deadlinesselect deadlines select timing constraintsselect timing constraints allocate resourcesallocate resources Managing Interactions for Cooperation select among redundant proceduresselect among redundant procedures Evaluate outcomesEvaluate outcomes Plan contingenciesPlan contingencies

Model-based Cooperative Programming c If c next A Unless c next A A, B Always A Choose reward A in time [t -,t + ] Decision-theoretic Temporal Planner Model-based Programs Specify team behaviors as concurrent programs. Specify alternatives using decision theoretic choice. Specify timing constraints between activities. Model-based Execution Looks before it leaps  Pre-plans threads of execution that are optimal and temporally consistent. Responds at reactive timescales  Perform planning as graph search  Navigates globally

Enroute Mission Scenario HOME RENDEZVOUS RESCUE AREA Diverge RESCUE LOCATION MEETING POINT Station: ABC Station: XYZ ONETWO

Enroute Activity: Rendezvous Rescue Area Corridor 2 Corridor 1 Corridor 3 Enroute

RMPL for Group-Enroute Group-Enroute()[l,u] = { choose { do { Group-Traverse-Path(PATH1_1,PATH1_2,PATH1_3,RE_POS)[l*90%,u*90%]; } maintaining PATH1_OK, do { Group-Traverse-Path(PATH2_1,PATH2_2,PATH2_3,RE_POS)[l*90%,u*90%]; } maintaining PATH2_OK }; { Group-Transmit(OPS,ARRIVED)[0,2], do { Group-Wait(HOLD1,HOLD2)[0,u*10%] } watching PROCEED } Non-deterministic choice:

RMPL Interpreter KirkKirk IdeaIdea TitanTitan Dynamically selects among alternate executions, satisfies open conditions and checks schedulability, Selects execution times, monitors outcomes and plans contingencies. Reactive Temporal Planner Plan Executive (Hidden) States RMPL Program Commands Observables Mode EstimationReactive Planning Model of Networked Embedded Vehicles monitor activitiesmonitor activities diagnose plan failuresdiagnose plan failures

[450,540] price = 425 price = 440 price = 0 price = 30price = 0 price = 1price = 0 0 price = 425 Path P = 1  3  4  5  8   9   12   13  2 Extend Path Enroute Activity: Least cost threads of execution generated by extended auction algorithm Start Node : 1 End Node: 2

Temporal planning is combined with randomized path planning to find a collision free corridor 45 x init Path 1 x goal X obs

Robotic Vehicles ATRV Rovers Monster Trucks Blimps Spheres Simulated Air/Space Vehicles

Scenario Cooperative Target Site Exploration: Heterogeneous rover team and blimps explore science sites determined by remote sensing exploration feature path planned/taken way point exploration region identified feature goal position Tasks: small scout rovers (ATRV Jr) explore terrain as described in earlier scenarios blimps provide additional fine grain air surveillance scout rovers identify features for further investigation by sample rover (ATRV) scout rovers provide refined terrain mapping for path planning of the larger sample rover Scenario Research Objective Extend coordination to heterogeneous team …

Summary: Model-based Autonomy To survive decades autonomous systems must orchestrate complex networks of devices. In model-based autonomy, programming involves specifying strategies as abstract state evolutions, and specifying commonsense models. Runtime kernels are agile, deducing and planning from these models within the reactive loop. Model-based programming languages and kernels are broadening out to cooperative and hybrid systems.