From: AAAI Technical Report WS-98-02. Compilation copyright © 1998, AAAI (www.aaai.org). All rights reserved.
Planning, Scheduling, and Plan Execution
for Autonomous Robot Office Couriers
Michael Beetz and MarenBennewitz
University of Bonn, Dept. of ComputerScience III,
Roemerstr. 164, D-53117 Bonn, Germany,
email: beetz, bennewit@cs.uni-bonn.de
a letter and thereby miss a deadline. Suchpreparation actions makethe performanceof individual jobs slower but
they can be expected to improvethe overall performance
significantly.
¯ Flexibility and Robustness. Schedules are to be generated based on partial information about the environment
and the tasks. For instance, incomplete task specifications like "pick up the letter from Wolframand deliver
it," lack proper descriptions of envelope as well as the
destination of the letter. Acting appropriately based on
partial information requires the robot courier to watch
out for opportunities and exploit them as well as detect
and avoid problems while executing scheduled activity.
¯ Experience. Information acquired through extended experience is exploited to computemore appropriate schedules. For instance, the time it takes for different people
to load or unload at different places.
It is important that the scheduler of an autonomousrobot
office courier is able to interleave delivery jobs, reschedule whenproblems are detected, and exploit opportunities.
The scheduler also has to be able to predict whetherexploiting an opportunity that has just been detected might cause
failures in other activity threads such as missing deadlines
(BG98). What seems less important is the computation
schedules that guarantee minimalpath length because loading and unloading takes significant amountof time.
Our research on scheduling
everyday activity is carded out
in the context of FAXBOT,
a structured reactive controller
(SRC)(Bee98) that is designed
for robust and efficient execution of delivery plans on
the autonomous mobile robot
RHINO(see Fig. 1), an RWi
B21 robot. RHINOis equipped
Fig. 1: Themobilerobot
with three PCs connected to the
RHINO
university-wide computer networkvia a tether-less radio link. Its sensor systemcontains
24 ultra-sonic proximity sensors, two laser range finders,
Abstract
Thispaperinvestigates issues in the integrationof planning,
scheduling, and plan execution in the context of control
systems for autonomousrobot office couriers. Suchcontrol systems have to meet challenging requirements. They
mustavoid late deliveries and achieve long-termefficiency
instead of restricting themselvesto the optimizationof problem solving episodes. Becauserobotsacting in humanworking environments
are often forced to scheduletheir activities
without having completeinformation their control systems
mustreliably and efficiently execute scheduledactivity in
changingand partly unknown
situations. In particular, the
control systemsmustbe able to exploit opportunities, flexibly avoid problems,and integrate command
revisions for
currentlyactive tasks.
Wepropose to implementsuch control systems for scheduled activity by employingconcurrent reactive plans that,
whileperformingtheir actions, reschedulethe course of action whenevernecessary. The plans have a modular and
transparent representation whichpermits easy transformations by transformationrules. It is these rules that implement
the controller’s schedulingandschedulerepair methods.
Introduction
To carry out their jobs reliably and efficiently manyautonomous mobile service robots acting in human working
environments have to view their jobs as everyday activity.
Weconsider a particular instance of everyday activity: performing office courier service. Scheduling everyday activity differs in important aspects from manyother scheduling tasks such as job shob scheduling (FS84), space shuttle scheduling (DSB94),or transportation scheduling in the
following aspects:
¯ Amortized cost and utility ofplans. The goal of scheduling everydayactivity is the optimization of long-term efficiency rather than problem-solving episodes. Therefore, a competent office courier distributes for instance
empty envelopes according to an expected consumption
profile while performing its delivery jobs. Distributing
the envelopes beforehand decreases the chances that the
robot must search for empty envelopes before delivering
67
and a CCDstereo color camerasystem.
FAXBOT
operates in a part of an office building containing a large hallway,several offices, a library, and a classroom(see Figure 2). FAXBOT
uses a symbolically annotated 3Dworldmodelof its environment
that contains floor
plan informationfor walls, doorways,and roomsand static
pieces of furniture. Theworld modelprovides all the information required by the RHINO
navigation systemto exhibit fast and collision free navigationand accurate robot
localization (TBB+98).It also contains detailed geometric modelsof the furniture items that can be used for their
recognition. Finally, the worldmodelstores symbolicinformationthat is used to interpret natural languagecommands
and as domainknowledgefor mission planning.
FAXBOT
operates over extendedperiods of time and carries out a scheduleof multiple jobs, whichcan be changed
at any time. Jobs are issued via electronic mail using
stronglyrestricted natural language.
An Extended
Example
Considerthe followingexperimentthat is carried out by
RHINO
using FAXBOT’s
scheduling capabilities. RHINO
receives two commands:
"put the red letter on the meeting table in roomA-111on the desk in roomA-120"and
"deliver the green bookfromthe librarian’s desk in room
A-110to the desk in roomA-114."
Wheneverthe jobs change FAXBOT
computesan appropriate schedulevery fast. FAXBOT’s
initial scheduleis to
pick upthe red letter first, then pickup the greenbook,then
deliver the red letter, andthe greenbookafterwards.If the
secondjob involvedalso a red letter to be delivered, then
the schedulerwouldfirst carry out the first job completely
and then carry out the secondjob. This is done to avoid
carrying twored letters at the sametimeand therebyyield
possible confusions.
Fig. 3. Default
schedule,
Fig. 2: Environment
of the office courier
To accomplish its commands
FAXBOT
uses a library of
routine plans. Theroutine plan for deliveries specifies that
RHINO
is to navigateto the pickupplace, wait until letter is
loaded,navigateto the destinationof the delivery, and wait
for the letter to be unloaded.
The maincontributions of this paper are that we show
(1) the installation of modularandtransparent schedules
complexconcurrent and reactive robot control programs;
(2) explain the designof schedulesand controllers that allowfor the opportunisticand robust executionof scheduled
activity; and (3) describe novel plan transformationtechniques for schedulingand reschedulingeverydayactivity.
The remainderof this paper is organizedas follows. The
section 2 presents an examplein whichFAXBOT
schedules
its delivery jobs basedon partial informationand reschedules its activities to avoidtask failures andexploit opportunities. The section 3 gives a glimpseof the plan representation used by FAXBOT
and presents the control structures used for the implementationand revision of activity
schedules. Section4 presents technical details of FAXBOT’s
activity scheduler and showshowscheduling methodsare
implemented
as declarative plan transformationrules. Section 5 describes howthe FAXBOT
controller accomplishes
the behaviorof the robotthat is describedin Section2.
68
Fig. 4. Schedulethat
avoids carrying twored
letters.
Proposing a schedule also implies makingassumptions
about whether and whendoors are open or closed. Thus
when adopting the schedule FAXBOT
assumes that the
doors of the rooms A-110, A-Ill, A-114, and A-120
are open. To performthe necessary adaptations flexibly,
FAXBOT
monitors the assumptionsunderlying its schedule
while performingits deliveries: wheneverit passes a door
it estimates the openingangle of that door and revises the
scheduleif necessary.
Fig. 5: Complete
trajectory for the twodeliveries
Figure 5 pictures RHINO’s
trajectory during the accomplishmentof the twodelivery jobs. Initially, all doors in
the environmentare open. FAXBOT
starts with the delivery
of the red letter and headsto the meetingtable in A-111
wherethe letter is loaded(step 2). At this moment
the door
of A-120is closed. Thus, whenFAXBOT
enters the hallway
to deliver the red letter at Michael’sdesk, it estimatesthe
opening angle of the door of roomA-120. At this moment
FAXBOT
detects that the door has been closed and that it
cannotcompletethe delivery(step 3). A failure is signalled.
Since FAXBOT
does not knowwhen room A-120 will
be openagain, it revises the schedulesuch that it delivers
the greenbookfirst and accomplishes
the failed delivery as
an opportunity. ThusFAXBOT
navigates to the librarian’s
desk in A-110to pick up the green book to roomA-114
(step 4). At this momentroomA-120is openedagain.
FAXBOT
heads towards A-114to deliver the green bookit
passes roomA-120(step 5). At this point the door estimation processsignals an opportunity: A-120is open!Therefore, FAXBOT
interrupts its current deliveryto completethe
deliveryof the red letter. Afterthe deliveryof the red letter
is completed(step 6), FAXB
OTcontinuesthe delivery of the
green book(step 7). The behavior generated by FAXBOT
all doorsstay openis shownin Fig. 6 and the one if A-120
is closed but not openedagain in Fig. 7.
declares its subtasks as user commands
and causes the generation of failure and success reports upontheir termination.
WITH-POLICY
v B, anothercontrol structure, means"execute
the primaryactivity B suchthat the executionsatisfies the
policy v" Policies are concurrentprocessesthat run while
the primaryactivity is active and interrupt the primaryif
necessary.
Events that require RHINO
to perform actions such as
"passinga door"are handledthroughfluents, programvariables that signal changesof their values and therebyenable
control threads to react to asynchronousevents. The RPL
statement WHeNEVeR
F B is an endless loop that executes B
wheneverthe fluent p gets the value "true" WAIT-FOR
F, another controlabstraction,blocksa threadof controluntil the
fluent F becomestrue.
PrimaryActivities and Policies
The FAXBOT
controller carries out two kinds of subplans:
primaryactivities, actions taken to accomplishthe robot’s
missionand policies, whichmonitorand maintainthe conditions necessaryfor the successfuland efficient execution
of the primaryactivities.
Primaryactivities include for examplethe navigationto
places whereobjects are to be picked up and delivered. A
policy might, for instance, monitorthe doors the robot is
Fig. 6. Trajectoryif
Fig. 7. Trajectoryif
passing to detect whetherthey are openor closed. Another
A-120stays open.
A-120is closed again.
policy mightmonitorhowwell the robot knowsits position
The behaviorexhibited by FAXB
OTdemonstratesthe foland invokeactive localization whenevernecessary. Primary
lowingcapabilities of FAXBOT’s
scheduler and its integraactivities musthandle interrupts and, due to the possible
tion into the overall controller: interleavingdeliverytasks,
side-effects of policies, these activities haveto makesuitrevising scheduleswhile they are executed, and exploiting
able preparationsfor their successfulcontinuationafter reopportunities.
activation.
Policies are best viewedas constraints on the execution
The FAXBOTController
of primaryactivities. Constraints such as "wheneveryou
FAXBOT’s
delivery routines are implementedin RPL(Repass a door estimate the openingangle of the door using
active Plan Language)(McD91).RPLprovides conditionits laser rangefinders" and opportunitiessuchas "complete
als, loops, programvariables, processes, and subroutines.
the delivery to roomA-120as soon as you learn the ofRPLalso places high-level constructs (interrupts, monitors)
fice is open"whichare both necessaryfor carrying out the
to synchronizeparallel physical actions and makeplans rejobs opportunistically,are specified using the aPEconstruct
active and robust by incorporating sensing and monitoring
WITH-POUCY.
Events like "passing a door" are detected by
actions, and reactions triggered by observedevents at the
fluents that trigger actions like estimatingthe doorangle.
programmer’s
disposal. The RPLconstructs used to specify
Whena delivery gets interrupted because FAXBOT
has descheduledactivity are the PLAN-,
WITH-POLICY-,
WHENEVER-, tected that the door to A-120is open, that opportunityhas
and WAIT-FOR-Statements;
but see(McD91)
for a complete
the side effect of movingthe robot into the office A-120.
description.
Theinterrupted delivery plan has therefore to be replanned
ThePLAN-Statement
has the form(PLAN
STEPSCONSTRAINTS). before it canbe continued.
STEPshave the form (:TAGNAME
SUBPLAN)
and tag SUBPLAN
The Structure of the FAXBOT
Controller
with the nameNAME.constraints have the form (:ORDER
S~ S2) whereSis are nametags of the plan steps. Steps
TheFAXBOT
controller is structured in a modularand transare executedin parallel except whenthey are constrained
parent waysuch that automatic plan transformationtechotherwise. The :ORDER
constraints makesure that a subseniques can retrieve parts of the plan easily and modifythe
quent step is started only if all steps computing
the inputs
plan without makingit opaquefor subsequentplan revision
have been completed. The TOP-LEVEL
command
indicates
processes.
69
Thealgorithmfor orderingthe navigation tasks is also
simple.Essentially,it sorts the destinationnorthof the hallwayin ascendingand south of the hallway in descending
order (the environment
is picturedin Figure2). After this
initial sort the scheduleriteratively resolvesproblemssuch
as misseddeadlines or confusionscaused by carrying objects that lookidentical.
WITH-POLICY :TAG OPPORTUNISTIC-PRIMARIES
TOP-LEVEL
:TAG ACTIVE.PRIMARIES
PLAN
SCHEDULE-DELIVERIES
( delivs)
1 for each Loc in Delivs
2
do ifNorth-of?(Loc, Hallway)
3
then North ~-- North O {Loc}
4
else South ~ South U {Loc}
5 North +-- Sort(North, >)
6 South +-- Sort(South,<)
7 for each Loc in North
8
do ifEast-of?(Loc, Robot)
9
then East ~ East U {Loc}
10
else West <--- West U {Loc}
11 Schedule ~ Append(West, South, East)
12 while-~Conflict-free(Schedule
13
do Schedule ~-- Remove-a-Conflict(Schedule)
14 return Schedule
TOP-LEVEL
:ORDER
Theoverall plan of the FAXBOT
controller consists of the
plan bodytagged PRIMARY-ACTMTIES
that contains the plans
for accomplishingthe user commands
and the surrounding
policies that specifythe constraints on the executionof the
primaryactivities. Theprimaryactivities are separatedinto
the opportunistic primaries and the active primaries. The
active primariesare the ones that the robot is able to accomplish without help. The order in which the subplans
of the active primariesare executedis given by the order
constraints that specify a (partial) order on the navigation
tasks containedin the active primarytasks. Theopportunistic primariesare the ones that robot cannot accomplishautonomously.To completethemit has to wait for enabling
conditions. For example, because FAXBOT
has no action
for openingdoors it mighthaveto wait for doors to openin
order to completeits deliveries. Theopendoor mightbe an
opportunity to completea user command.
Becauseof the hierarchical structure of office environmentsthis simple heuristic algorithmfor computingschedules workssurprisingly well. Theoptimalscheduleasks the
robotto visit everyoffice withthe orderof the offices being
clockwise(or anti-clockwise)starting at the office closest
to the robot. The Voronoidiagramsof offices have often
almosttree structure (with fewcycles) so that the deskscan
be easily reachedfromthe doorand the center of the room.
There are various cases for whichthis algorithm produces suboptimal schedules. For instance, you can place
n destinationson a circle (equallyspaced).In this setting,
the algorithmasks the robot to go backandforth on the circle andtake a route that is longerthan necessary.Thealgorithm can be extendedeasily so that it computes
with a high
probability nearly optimal schedulesfast. The questionis
whetherhavingnearly optimal schedulescauses the robot to
accomplishits tasks moreefficiently. Oftentighter schedules fail moreoften. In our opinion it is morepromising
to learn scheduling heuristics from experience. Information relevant for schedulingthat can be learned fromexperience include the expectedduration of loadingand unloading, whenpeople are usually in their offices, whendoors
are openor closed, and so on.
The schedulingroutine is implementedas a plan transformationrule that can be applied to FAXBOT’S
overall plan
while the plan is executed (BM97;BM94).Wewill diagram
plan-transformationrules
The FAXBOT Scheduler
The scheduling methodtakes constraints, resources, and
deadlines into accountand tries to minimizethe numberof
interruptions for people. Themethodcarries out a sequence
of steps: (1) the schedulerextracts all navigationtasks from
the structuredreactive plan; (2) it computes
an efficient total order on the navigationtasks that (if possible)meetsall
givendeadlinesavoidsoverloadingthe robot; (3) it installs
the scheduleinto the structured reactive plan; and (4) installs a monitoringprocess that monitorsall the assumptions madeby the schedulerand triggers a reschedulingprocess wheneveran assumptionis detected to be violated.
The extraction step is simple because all navigation
tasksare requiredto havetheform(ACHIEVE
(LOC
RHINO
Ioc))
(BM92).In the extraction step every navigation task
tagged witha uniquenamethat can be later used to specify
the order on the navigationtasks. A moredifficult issue in
the extraction step is guessingthe destinations of navigation tasks that are not completelyspecified. (McD92)
describes a techniquefor guessingdestinations of navigation
tasks basedon MonteCarlo simulationsof the plan.
(pl ATcp ==pat) F
--’~--I curia
pt’
L
0
1.) ?PRIM-ACTIVITIES
AT PRIMARY-ACTIVITIES
2.) ?ACTIVE-PRIMARIES
AT ACTIVE-PRIMARIES
(PLAN ?CMDS?CONSTRAINTS)
/
(a)
UNSCHEDULED-PLAN-BUG
(?ROOT-TASK?ACTIVE-PRIMARIES)
A NAVIGATION-TASKS
(b)
(?ACTIVE-PRIMARIES?NAV-TASKS)
^SCHEDULE?NAV-TASKS(?SCHED-CONSTRAINTS)
(c)
1.) WITH-POLICY
WHENEVER
(NO.__.~(AND I?SCHED-ASSMTS))
(d)
^ SCHEDULING-ASSUMPTIONS
SIGNAL(UNSCHEDULED-PLAN-BUG
(?NAV-TASKS?SCHED-ASSMTS))
(?ROOT-TASK?ACTIVE-PRIMARIES))
?PRIM-ACTIVITIES
2.) PLAN ?CMDS!?CONSTRAINTSI?SCHED-CONSTRAINTS
Figure8: Planrevisionrule for the the installation of task schedules.
wherecondis the applicabilitycondition,(pt ATcp =-- pat) the
input plan schemaand pl’ the output plan schemaof the
rule. Theapplicability conditionis a conjunctionof literals. Theinput plan schemaconsists of a pattern variable
to which the subplan with code path cp is boundand an
optionalpattern pat that is matchedagainst the subplanpl.
Therule is applicableif the applicationconditionholds and
the plan pl with code path cp matchesthe pattern pat. The
resulting plan fragmentpl’ replaces the input fragmentin
the revisedplan.
Figure 8 showsthe formalization of the transformation
rule that schedulesoffice delivery tasks. The transformation rule revises the primaryactivities by addinganother
global policy that generates an unscheduledplan bugwhenever an assumptionunderlyingthe current scheduleis detected as violated. Therule also revises the active primaries by adding the ordering contraints of the schedule
to the constraints of the primaryactivities. Thescheduling
rule is applicableundera set of conditionsspecifyingthat
(a) Thereis a bug of the category"unscheduledplan;" (b)
Thenavigationtasks containedin the active primaries are
?NAV-TASKS;(C) ?SCHED-CONSTRAINTS
ale orderingconstraints
on ?NAV-TASKS
such that any order whichsatisfies ?SCHEDCONSTRAINTS
will accomplishthe active primary tasks fast
and avoid deadline violations and overloadingproblems;
(d) ?NAV-TASKS
can be accomplished
if ?SCHED-ASSTS
are satisfied. The rule is applied wheneverthe set of user commandschanges.
Robust and Efficient
Schedules
To accomplish robust and efficient execution of schedules we (1) explicitly record and monitor scheduling assumptions;(2) install opportunisticdeliverytasks; and (3)
reschedulethe primaryactivities while they are executed
whenevera brokenschedulingassumptionis detected.
Currently, we only consider one kind of schedulingassumptionsand opportunities: the state of doors. To monitor these assumptions, the FAXBOT
controller employsa
global policy: wheneverthe robot passes a door it estimates
the openingangle of this door. The openingangles of each
door are stored in an fluent that has twodependentfluents:
one signalling that the dooris closed and one that the door
is open.
The schedulingassumptionsof the active primaries are
that all roomsthat are destinationsof navigationtasks are
open. Schedulingassumptionsare handled by a policy of
the followingform:
WITH-POLICYSEQWAIT-FOR.(CLOSED(ROOMt)
V...
V CLOSED(ROOM,i))
SIGNAL(CLOSED-DOOR-BUG
...)
Plan Body
Thuseach violated scheduling assumptiontriggers the
application of the schedulingtransformationrule shownin
Figure 9. In order to apply schedulingtransformationsto
the primaryactivities while the primaryactivities are executed, the primaryactivities haveto be restartable (BM96).
Restartability meansthat the robot controller canrepeatedly
start executinga plan, interrupt the execution,and start it
anew,andthe resulting behaviorof the robot is verysimilar
to the behaviorof executingthe plan onlyonce. Restartability facilitates the smoothintegration of plan revisions into
ongoingactivities: a partially executedrestartable plan can
be revised by terminatingthe plan and starting the newplan
that containsthe revisions.
In practice, however,restartable plans workdifferently.
Consider,for example,a plan for the deliveryof an object.
Todeterminewhichparts of the plan can be skipped, it is
sufficient to knowthe object’s location and someaspects
of the robot’s state (like its location andwhatit carries).
Becausethe FAXBOT
controller updates the object descriptions wheneverit perceives and "manipulates"the object,
FAXBOT
can determinethe state of execution based on the
descriptionof the object to be delivered.
Toact efficiently, FAXBOT
has to exploit opportunities.
A necessarypreconditionof exploiting opportunitiesis that
FAXBOT
is able to specify whatopportunities are. Onekind
of opportunity that FAXBOT
Canexploit is the opportunistic completionof delivery tasks. Supposea user command
cannot be completedbecause the roomwherethe object is
to be deliveredis closed. In this case, the executionof the
active primaryplan for accomplishing
the delivery fails and
the plan is installed as an opportunisticprimary.
The revision of the FAXBOT
controller that is triggered
71
1 .) ?ACT-PRIMARIES
AT ACTIVE-PRIMARIES
2.) ?OPP-PRIMARIES
AT OPPORTUNISTIC-PRIMARIES
CLOSED-DOOR-BUG
(?CMD-FAILURE ?DOOR-FCT?ROOM
(?TLC) ?FAILED-TASK)
^TLC-NAME(?TLC ?TLC-NAME)
^ ROOT-TASK(?ROOT
?FAILED-TASK)
1.) ?REM-ACT-PRIMAR~IES
A DELETE-ACTIVE-PRIMARY-TLC-PLAN
2.) TOP-LEVEL
(?ROOT ?TLC-NAME?REMAINING-TLC-PLANS)
:TAG ?TLC-NAME
^TAGGED-SUBTASK(?ROOT
?TLC-NAME?TLC-TASK)
SEQ WAIT-FOR(OPEN(?ROOM)) A RPL-EXP(?TLC-TASK
?TLC-PLAN)
?TLC-PLAN
I?OPP-PRIMARIES
Figure9: Planrevision rule for deliverytasks that cannotbe completedbecauseof closed doors.
by closed doors is accomplishedby the plan transformation
rule listed in Figure9. Theplan revision rule is triggered
by a "closed door" bug that causes a user command
to fail.
Therule deletes the failed plan for the user command
from
the active primaryactivities and addsthe plan to the opportunistic primaryactivities.
has been closed in the meantime.BecauseFAXBOT
cannot
completethe delivery of the red letter the corresponding
command
fails. This failure triggers the replanningpolicy
P-3. Because FAXBOT
cannot foresee when room A-120
will be openagain it transformsthe completionof the delivery into an opportunity. Thus as soon as FAXBOT
notices roomA-120to be openit interrupts its current misFAXBOT’s
Scheduling Methodsat Work
sion, completesthe deliveryof the red letter, andcontinues
with the remainingmissionsafter the red letter has been
This section describes how FAXBOT
accomplishes the
courier jobs described earlier. In the beginning, FAXBOT successfullydelivered.
carries out no primaryactivities. Its outermostpolicy enrevisions ]
(P’l)
WITH-POLICY[ integratecommand
sures that newcommands
are received and processed.
i
(P-l)
WITH-POLICY
[ replan/reschedule when necessary J
WITH-POLICy[
integrate
......
d revisions[
(P-l)
WITH-POLICY[
replan/reschedule when necessary I
[ PR,MARY
ACT,V,T,ES
(P-2)
i
I
PRIMARYACTIVITIES
Uponreceiving the two commands
the policy P-1 puts
plans for the commands
into the active primaryactivities of
the SRC.The insertion of the commands
triggers the scheduler of the policyP-2 that ordersthe navigationtasks in the
primaryactivities. Theschedulingpolicy also addsan additional policy I)-3 that monitorsthe assumptionsunderlying
the schedule, that is that the roomsA-110,A-111,A-114,
and A-120are open.
WITH-POLICY
integratecommandrevisions
WITH-POLICY
WITH-POLICY
(p3)
WITH-POLICY
[ ~ach~duMwh~n~ HO,~, I I L
(P-l)
(P-Z)
(P-3)
NAV-4
After FAXBOT
has picked up the red letter fromthe meeting table and left roomA-Ill, it notices that roomA-120
’
2oi I
I
:rAa~;ii
: ; I
:! ii’:~’,,’
rXo
II
Discussion
Ourresearch on schedulingthe activities of an autonomous
robotoffice courierare still in an earlystage. Sofar wehave
only performedsomesimple experimentsto validate that
the FAXBOT
controller and its scheduler work;that is that
it can reliably monitorscheduling assumptionsand schedule delivery jobs duringtheir execution(see our examplein
the secondsection). In the future weplan to comparethe
behavior generated by the FAXBOT
controller with alternative controllersthat applydifferent (re)schedulingstrategies. Wealso needto examinemorecarefully the literature
on robust scheduling,in particular (ZF94).
In this paper we have mainly focussed on the application of schedulingtechniquesto plans that control an autonomousmobileservice robot. As such the contributions
of this paper lie mainlyin the representation of complex
concurrentand reactive plans that facilitate schedulingoperations, the specification of plan revision methodsin the
form of plan transformationrules, and the application of
these scheduling methods while the robot carries out the
scheduled activity.
FAXBOT
accomplishes its jobs successfully because its
subplans are madeinterruptable and restartable using highlevel control structures that specify synchronized concurrent reactive behavior. FAXBOT
achieves adaptivity through
plan revision and scheduling processes, implemented as
policies, that detect opportunities, contingent situations,
and invalid assumptions. Plan revision techniques are able
to perform the required adaptations because of the modular and transparent specification of concurrent and reactive
behavior. In particular the distinction of policies and primaryactivities increases the modularity significantly. Policies enable FAXBOT
to specify opportunistic behavior and
to achieve reliable operation while makingsimplifying assumptions.
There are manyopen issues that we would like to investigate more carefully in the near future. These issues
include the development of more sophisticated scheduling methods(ZF94), the application of learning techniques
to acquire useful information that can be exploited by
heuristic
scheduling methods (HC92b; HV98a; HV98b;
ZDD+92),and a thorough experimental investigation on
the effects of different scheduling techniques on the behavior exhibited by autonomousservice robots (HC92a).
References
M.Beetz. Structured reactive controllers for service robots in
humanworkingenvironments. In G. Kraetzschmarand G. Palm,
editors, HybridInformationProcessingin Adaptive Autonomous
Vehicles.Springer,1998.to appear.
D. Hart andP. Cohen.Predicting andexplainingsuccessand task
duration in the phoenixplanner. In J. Hendler,editor, AIPS-92:
Proc.of the First InternationalConference
on Artificial Intelligence PlanningSystems, pages 106-115. Kaufmann,San Mateo,
CA, 1992.
A. Howeand P. Cohen.Isolating dependencies on failure by
analyzingexecutiontraces. In J. Hendler,editor, AIPS-92:Proc.
of the First InternationalConferenceon Artificial Intelligence
Planning Systems, pages 277-278. Kaufmann,San Mateo, CA,
1992.
K. Haighand M. Veloso. Learning situation-dependent costs:
Improvingplanning from probabilistic robot execution. In To
appear in Autonomous
Agents 98, 1998.
K. Haighand M. Veloso.Planning, execution and learning in a
robotic agent. In to appearin FourthInternational Conference
on AI PlanningSystems, 1998.
D. McDermott.A reactive plan language. Research Report
YALEU/DCS/RR-864,
Yale University, 1991.
D. McDermott.
Transformationalplanning of reactive behavior.
Research Report YALEU/DCS/RR-941,
Yale University, 1992.
S. Thrun, A. BUcken,W.Burgard, D. Fox, T. Frrhlinghaus,
D. Hennig,T. Hofmann,M. Krell, and T. Schimdt.Maplearning
and high-speed navigation in RHINO.
In D. Kortenkamp,R.P.
Bonasso,and R. Murphy,editors, Al-basedMobileRobots: Case
studies of successful robot systems. MITPress, Cambridge,MA,
1998.to appear.
M. Zweben,E. Davis, B. Daun, E. Drascher, M. Deale, and
M. Eskey. Learningto improveconstraint-basedscheduling. Artificial Intelligence, 58:271-296,1992.
M. Zwebenand M. S. Fox. Intelligent Scheduling. MorganKaufmann, 1994.
M. Beetz and H. Grosskreutz. Causal modelsof mobile service
robot behavior. In R. Simmons,
M.Veloso,and S. Smith,editors,
to appear in Fourth International Conferenceon AI Planning
Systems, MorganKaufmann,1998.
M.Beetz and D. McDermott.
Declarative goals in reactive plans.
In J. Hendler,editor, First InternationalConferenceon AI Planning Systems, pages 3-12, MorganKaufmann,1992.
M. Beetz and D. McDermott.
Improvingrobot plans during their
execution. In Kris Hammond,
editor, SecondlnternationalConference on AI PlanningSystems, pages 3-12, MorganKaufmann,
1994.
M. Beetz and D. McDermott.Local planning of ongoing behavior. In Brian Drabble,editor, ThirdlnternationalConferenceon
AI Planning Systems, pages 3-12, MorganKaufmann,1996.
M. Beetz and D. McDermott.Expressing transformations of
structured reactive plans. In Recent Advancesin AI Planning.
Proceedings of the 1997 EuropeanConference on Planning,
pages 64-76. SpringerPublishers, 1997.
M. Drummond,
K. Swanson,and J. Bresina. Scheduling and execution for automatic telescopes. In M.Zwebenand M. Fox, editors, Intelligent Scheduling, pages 341-369.MorganKaufmann
Publishers, 1994.
M. S. Fox and S. Smith. Isis - a knowledge-basedsystem for
factory scheduling.Expertsystems, 1(I):25--49, 1984.
73