Computing in robotics has two important requirements: efficiency and flexibility. Algorithms for robot actions are implemented usually in procedural languages such as VAL and AL. But, since their excessive bindings create inflexible structures of computation, it is proposed that Logic Programming is a more suitable language for robot programming due to its non-determinism, declarative nature, and provision for metalevel programming. Logic Programming, however, results in inefficient computations. As a solution to this problem, researchers discuss a framework in which controls can be described to improve efficiency. They have divided controls into: (1) in-code and (2) metalevel and discussed them with reference to selection of rules and dataflow. Researchers illustrated the merit of Logic Programming by modelling the motion of a robot from one point to another avoiding obstacles

Kumarn, A.

Parameswaran, N.

English

NASA Technical Reports Server

Metalevel Programming in Robotics: 
A. Kumar N. and N. 
Indian Institute of Ttchnology 
Madras, India 
Some Issues 
to its non-determinism, declarative nature, and provision for metalevel programming. Logic 
Programming, however. results 
diacuas a framework in which controls can be described to improve efficiency. 
controls into: (i) in-code 
selecti~n of rules and dataflow. 
modelling the motion of 
1. u r o d  uction 
Computing in robotics requires both efficiency and flexibility. Large scale real t i w  
computation, both symbolic and numeric, is necessary for even apparently simple robot 
movements. Robot’s actions must be as time-efficient as possible at the end-effector and 
actuator levels[l]. At the same tiw, planning, backtracking, consulting knowledge about tbe 
world etc.. requires flexibility. 
The world of the robot is dynamizally changing, as in the case of telerobots. and tbc. 
change in the world must be :ontinuall;* noted. Accordingly, the planning of the robot at +-bc 
object and the objective levels has to be altered / readjusted. This is a strong case fa 
favour of flexible computation for robotics at the object and the objective levels. 
In robotic cornpatation. a third requirement is effective man machine communication [2].  
This requires that the programming environment be as conducive to natural input and tta 
language be as readable as possible. 
Traditionally, languages for robots aro procedural, such as VALIJ], AL [ 4 ]  and RAPT [SI. 
They provide for efficient computation, but are not flexible or easily modifiable. 
a robot 
‘ 7  - 
We propose that Logic Programming is more suitable for robot programing due to its noa- 
determinism, d-clarative nature. and provisior. far setalcvel programming. D e s c r i p t i o n  of th 
world is most conveniently aone in the declarative sernantt-s of Logic Programming. Dynamic 
change in the world can be easily incorporated by the addition / deletion of l o g i d  
assertions in the program. The fact that visual world can be best described declar8tivaly lns 
been exploited in 161 for declarative graphics. 
However. a major problem in using Logic for computation in robotics is its inefficienm. 
Typically, a Logic Programming language such as Prolog follows the depth-first strategy wi*h 
chronological backtracking and a few control features such as cut to improve efficiency 171 
However. recently, many features have been introduced in Prolog. to improve efficiency, such 
as intelligent backtracking[8.9]. annotated variables[l0]. and metalevel programing[ll.l2!. 
Of greatest relevance to robotic computation is the last feature viz.. matale-1 
programming. Here. the specification of control strategy for the object level program (OLP) is 
expressed seperately, at a differert level called metalevel. It permits one to intervene in 
the interpretation of the object level programs to define new strategies of control. It alw 
allows one to specify one’s own interpreter. 
Since wtalevel description is kept entirely separated from logic level, the basic 
procedures and world description at the object level are left entirely untouched by efficieg 
considerations. Object level programs are still as declarative and flexible as ever. & 
l b l  
I 
https://ntrs.nasa.gov/search.jsp?R=19890017103 2020-03-20T02:10:24+00:00Z
additional element of flexibility is that the controi strategy for.-- computation can ba 
changed to suit the naeda of the current goal and world. 
LIn-codearAdM&alS?wControls 
For robot proqruiry, we present control at two levels: (a) in-code, (b) metalevel; rpd 
discuss them with respect to t w  types of controls 1 (i) selection control (if) data f l w  
control. 
In-code control refers to control expressed texwally along with the OLP clauses and tlm 
syntax and the semantics are defined as part of the OIlP language. At this level we provide: 
However. at the global level, we propose largely a declarative language. 
Uetalevel control refers to control over selection of rules and is textuall separated 
from OLP. At this level, control is expressed in the form of rules (different representatiaw 
are possible) so that it is easy to modify when required. 
* efficient constructs which are procedural in nature. * liberal bindings of as much dataflow as possible. using the idea of locations. 
This strategy of splitting the controls has the following consequences on computation : 
1. Locally, the computation is expressed as efficiently as possible at the cost of 
flexibility. But, since it is only local, the resulting inflexibility may be acceptable as, in 
the worst case, it can always be replaced when modifications are required. 
the structure of computation is kept a5 flexible as possible. at the cost of 
efficiency i.e.,the programs need not be radically re-altered when the world or the inmt 
changes for a robot. Efficiency is improved by carefully choosing metalevel rules. Hence. 
readabtlity and modifiability of programs are preserved, which is very important for robotic 
computation. 
The following are the control features we have introduced to improve the efficiency: 
2. Globally, 
!mlZ!&now: 
Incode: The scope of in-code controls is restricted to individual clruses and they are 
directed to specific predicates. 
(i) a Let F(X)  be a predicate in the body of a clause C. The execution 
of this predicate results in the transfer of control to the predicate in the clause C, to 
which X is instantiated, skipping the predicates between F(X)  and X in C. F ( X )  fails when X is 
uninstantiated or when backtracking. 
(ii) Q& Let ! ( X I  be a predicate in the body of a clause C. ! (X )  succed8 
in the forward direction trivially. While backtracking, if ! ( X )  is encountered, control is 
transferred to the predicate X occuring within the clause C. 
-vel: Several control features defined in Uetalog[ll] actually fall under this: 
CEOOSECLAUSE, INHIBCLAUSE. INHIBACK. FACTOR and BACKFAIL. In addition. we proms8 a- 
parallelism as a control st.ructure on the set of modules. This makes it possible to control 
parallelism by controlling the number of processes. An important restriction w e  have placcd 
here is that these controls are expressed with respect to clauses and not individual 
predicates. Thus the comtrol her3 will tell which clause to use but not which predicate 5.n a 
clause. Controls of this type affect the top-to-bottom selection of clauses for interpretation 
within a program. The scope of all the metalevel declarations is the entire program. 
(i) QB b z a u s u m  
(PARCHOOSECLAUSE literal 1[11.1121.....11nl -) :- condition. 
interpreLat:.on in OR parallellism where tha clause hea& are unifiable with lttstal 
denotes trie J-th clause among the m clauses whose heads unify with -. 
1111 = 1, PARCHWECLAUSE reduces to CEOOSECLAUSE of Uetalog[ll]. 
The execution of this predicat8 rtsiilts in the simultaneous selection of n clausos for 
When n = 1, .nd 
l2mma: 
bcode: In Prolog, data flow within a clause occurs through side-effects in the sense Of C W .  
We introduce new predicates c m t o  and assign to let data flow both in the forward and 
backward ( on backtracking ) directions. This unlimited data flow within a clause enhances 
efficiency considerably. 
(i)  : Let C be the clause in which the predicate c m t e  OCC*M. 
182 
- - -  . -. . . .  _ _  . . . . . .  . .  .. . . . . . . . .  - ,  
Ltecution of this predicate i n  thm fornard direction results i n  the creatioa of 10c8ti0118 
i = l,...,~ . ti. These locations can be used to store values usins the u a i a  predicata described 
results in storins the value 
of the expression in L, where L is a location. It fails when L is not created, and durins 
backtrack. 
m w l :  At this level the rules define global data location8 for the p w u .  Data flow can 
occur across the clauses through paranters or S1ob.l locations when it is umvenient. 
Distributed computing for coordinated activitiea in a colony of robots can be achleved by 
appropriate wtalevel descriptions of control and data flow. 
s durins backtrack. 
Execution of this predicate 
sbkalks&iQlu 
GtoBAL L1.L2 ..... Ln. 
This declaration at #talwel defines n locations L1, .... Ln that can be wed as location8 
to store data and use them later in the program; they are visible over the entire progrm. 
In this section, we address the problem of a robot moving in a woeld, avoiding 
obstacles. For timplicity, the world is divided into a number of squares. The obhtwles are 
distributed in  he world as shown in Figure 1. The start gosition of the robot is assumed to 
be the square (l,l), denoted by p(1,l). The target is the square p(6.4). U e  restrict the 
motions of the robot to horisontal and vertical directions only. 
4 
R1 
3 
2 
1 
RS R5 , 57 
: *  * .  :TARGET : *  * :  
1 ........................... 
I I I 
............................. .................. * :  I START : * !-I * :  : *  : *  : *  * I  I ..  : . . . . . . . I  . ... ! I  : . . . . . . . I  1 
Figure 1: The robot world. 
The solution is provided at two levels: obje’ct level, and metalevel. At the object 
level, the mechanical actions and the simple heuristics the robot employ8 on encountering 
obstacles are described. At the mtalevel, knowledge about the distribution of the obstacle3 
in the world and the mechanisms for supplying information about local regions in the world ax- 
described in order to guide the robot towards its target. The knowledge encoded in the objec 
level description is complete in the sense that the knowledge is sufficient. in principle. io- 
the robot to reach any given target, by exhaustive search. tletalevel knowledgo io incornplots 
in this sense, and thus irprovi-; 
the efficiency. 
At the object level, we have the following heuristic to guide the robot: Let the current 
position of the robot bo (Cx.Cy) and the target location (Tx,Tp). where Tx >= Cx and TY >= Cy- 
If Tx = Cx and Ty = Cy. and therefore it bits; else. 
the robot moves to the square (Cx + 1, Cy) if Tx > Cx and (Cx + 1, Cy) is obstacle-free. or to 
the ?quare (Cx. Cy + 1) if T y  > Cy and (Cx, Cy + 1) is obstacle-free. Otherwise, it consults 
the expert in the current ragion. 
At the mtalevel, the squares are grouped into regions. For exa~~le, ~(1.1). ~(1.21. 
~(2.1) Each region has an expert who h a  tho knowlodge of 
the obstacles present in that dorain. The expert has the ability to saucst a out to 
each of its neighbouriw regions, whan consulted. ?or eXampbr when consulted, R l  shows th. 
w a y  out to R2 via the square ~(1.3). At the mtalevel. we also have the following control 
heuristic to avoid infinite paths: In any region Ri.tha robot ignores the advice of the erpert 
of this region, region 
Rj. In case of failure of a aolution suggested by an exwrt. the robotbacktr.cl to w 
alternative solutions that the axpert may have swested. If all the smestionr of t lm 
but it can greatly aid in reducing the exhaustive search, 
then the robot has reached its target. 
and p(2.2) form Rl.(see Pi- 1.) 
if the advice lead8 the robot back to any of the previously travelhd 
183 
- -... -. - 
curraat export f a i l  to provide 8za oxit. tbo robot w i l l  take up .nt pa t r i ed  a l te rna t ive  
suumstioas of tbo earlier expert; urd SO on. 
~(3.3). p(4.3). p(4.4). A t  thia point, the robot 18 not ab le  t o  mve further on i t a  OW. ud 
ao it consults Bs. R5 a u m a t a  the w 4  out to B2. R4 and Re. The way out  to R2 is isnored. X f  
tbe robot accepts the u8y out  to M, v i a  p(4 , l )  o r  ~(3.2). the robot finds i t ae l f  once aC8i.a 
a t  a dead d. However, on backtracking, it tries the third aolution spUeated by RS. tbpr 
enter ing R6, and the t a rge t  eventually. 
/* Robot: Object l eve l  program */ /* I n i t i a l i s e  a tack f o r  local expert and start */ 
toptravt  ~(*x.*Y). p(*Xl,*Yl) :- create ( *liit 1. 
robot ifithllr k-8 tb. f o l l ~ ~  8qu-S: p(1~1)~ p(lr2). p(1.3). ~(2.3). 
asaisn (*list, [I  1. 
t r av  ( p(*X,*Y). p(*Xl.*Yl) 1. 
t r av (  p(*X.*Y), p(*X,*Y) ) :- ! 
t rav(  p(*X,*Y). p(*Xl.*Yl) ) :- 
abrance(p(*X,*Y).p(*Xl.*Yl),p(*X2.*Y2)). 
t rav(  p(*X2.*Y2), p(*Xl,*Yl) 1. 
advance( p(*X.*Y), p(*Xl.*Yl), p(*X2,*Y2) ) :- *Xl > *X, 
8x2 is *x + 1. 
checkobst( *X2.*Y ), /* A bu i l t - i n  procedure t h a t  checks 
whether t h e  square (X2.Y) has an obstacle */ 
in,region( p(*X2.*Y), *R ), /* Finds out  t he  region t o  which (X2.Y) belongs */ 
test-append( *R. *list ), /* Checks whether *R has already been traversed */ 
move( p(*X2.*Y) 1, /* A bui l t - in  procedure t h a t  enables t h e  robot move by a square */ 
F( ! ), move( p(*X,*Y) ), ! (  move 1. /* The robot re t races  its path . 
i n  case of f a i lu re  */ 
advance[ p(*X.*Y). p(*Xl.*Yl), p(*X2,*Y2) ) :- *Y1 > *Y. 
*Y2 is *Y + 1. 
checkobst( *X,*Y2 ), 
in-regiont p(*X.*Y2). *R 1, 
test-append( *R. *list 1. 
move( p(*X.*Y2) 1, 
F( ! 1, mow( p(*X,*Y) 1, !( move 1. 
in-regionc p(*X,*Y), *R1), 
consult(  *R1. p( *X,*Y 1, p( *X2.*Y2 1) .  /* I f  m e t  with a dead end, 
advance( p(*X,*Y). p(*Xl,*Yl), p(*X2.*Y2) ) :- 
consult  local e x p e r t  */ 
/* To check whether R has been already consulted */ 
test-apptnd( *R, *list ) :- member( *R. *list 1, !. 
test,append( *R. *list ) :- append( *R. *list. *list1 1, 
assign( *list. *list1 ). 
The metalevel description defines the  local experts,  and the posi t ion of obstacles.  
Associated with each expert is its knowledge regarding the  posi t ion of squares which the  robot 
should t r y  t o  reach i n  order t o  avoid i n f i n i t e  paths. 
/* Local Experts: Hetalevel program */ 
consult(  *R1, p(*X,*Y). p(*X2,*Y2) :- out(  *Rl, +Z 1, 
member( p(*X2,*Y2), *Z 1, 
in-region( p( 8x2. *Y2 1, *R2 ), 
not( member( *R2. *list ) ), 
advance(p(*X,*Y).p(*X2,*YE).~(*X2.*Y2)). 
A. 
region( Rl. C ~ ( 1 . 1 ) .  ~(1.2). ~(2.1). ~ ( 2 . 2 )  1 1. /* Definition of region Rl */ 
region( R2. C ~(1.3). ~(2.3). ~(3.3) I 1. 
region( R4. C ~(3.1). ~(3.2). ~(4.1) I 1. 
out(  R5. R2. c P(3.31 I 1.  
out(  R5. R4. Ip(3.2). ~(4.1) I 1. 
out(  R5. R6, C ~(5.2) I 1. 
.. .. 
.. .. 
. 
184 
- .  I .  
Description of location of obst.cles a/'  
obat( 2.1 I .  obst( 2.2 I .  Ob8t(.3,4 1. 
ob&( 5.1 I .  obst( 5.3 I .  obst( 5.4 I. 
i,GQB&.&m 
In th is  paper, we have discussed the merits of Logic progr8mmina for robotic 
computations. Towards improving the efficiency of computation, while retaining the declarative 
nature of programing, we have split the control into two levels: in-code and DOtaleVel. we 
h a w  proposed several constructs at both these levels. that hprove efficiency. We have 
illustrated the elegance of mtalevel logic programming and the usage of the predic8tes we 
have introduced, on a simple robot problem. 
1. Kogan Page,Logic and Prograrping., Robot Technology series Pol 5., London 1983. 
2. Ambler A.P., 'Languages for propramming robots', in Robotics and Artificial Intelligence, 
3. 'Users guide to VAL', Unimation Inc. 
4. Goldman R.. hjtaba S.U.,'The A1 users manual', Stan-CS-79-718, Stanford Univ.,Jan 1979. 
5. Poppl4stone R.J.,Ambler A.P.,Bellos T . U . ,  'An interpreter for a Language for describing 
6. Richard Aelm and Kim Uarriott, 'Declarative Graphics'. Proc. of Third Intl. Conf. on Logic 
7. W. F. Clocksin and C. S. Hellish. 'Programming in Prolog' Springer Verlag, 2nd. edition 
8. U. Bruynooghe and L. U. Pereira. 'Deduction revision by intelligent backtracking'. in 
9. P. T. Cox. 'Finding backtrack points for intelligent backtracking' in 'Implementations of 
10. Clark IC. L.. and Uciiabe F. G.. 'IC-PROLOG : Language features' Proc. Logic Programming 
11. Hehmet Dincbas et al.. 'Uetacontrol of Logic prcgrams in Uetalog' in Proc. of the Intl. 
12. Colmerauer A . ,  'PROLOG-II:Manuel de reference et d e l e  theorique', GIA. Pacultc des 
13. Terrence W. Pratt. 'Programming Languages: Design and Implementation', Prentice Hall 
NATO AS1 series 1984. . 
assemblies , AI, vol.14. 1980. pp79-107. 
PrOgraminE. July 1986 (Lecture Notes in Comp. Science 225). 
1984. 
'Implementations of Prolog' ed. J. A. Campbell, Ellis Romood Ltd., 1984. 
Prolog' ed. J. A. Campbell, Ellis Romood Ltd., 1984. 
Workshop, Debrecen, July 1980. 
Coni. on Fifth Generation Computer Systems, ICOT. 1584. 
Sciences de Lminy, Mars 1982 . 
Inc.. 2nd edition 1984. 
185 
- 


Metalevel programming in robotics: Some issues

Abstract

Similar works

Full text

Available Versions

NASA Technical Reports Server