LUND UNIVERSITY

PO Box 117
221 00 Lund
+46 46-222 00 00

An Architecture for Expert System Based Feedback Control

Årzén, Karl-Erik

1988

Document Version:
Publisher's PDF, also known as Version of record

Link to publication

Citation for published version (APA):
Årzén, K-E. (1988). An Architecture for Expert System Based Feedback Control. (Technical Reports TFRT-
7399). Department of Automatic Control, Lund Institute of Technology (LTH).

Total number of authors:
1

General rights
Unless other specific re-use rights are stated the following general rights apply:
Copyright and moral rights for the publications made accessible in the public portal are retained by the authors
and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the
legal requirements associated with these rights.
 • Users may download and print one copy of any publication from the public portal for the purpose of private study
or research.
 • You may not further distribute the material or use it for any profit-making activity or commercial gain
 • You may freely distribute the URL identifying the publication in the public portal

Read more about Creative commons licenses: https://creativecommons.org/licenses/
Take down policy
If you believe that this document breaches copyright please contact us providing details, and we will remove
access to the work immediately and investigate your claim.

https://portal.research.lu.se/portal/en/publications/an-architecture-for-expert-system-based-feedback-control(f7b7cc68-31fb-4e83-b338-d48dffd9cf01).html


CODEN: IUTFD2/(TFRr-73 ee) I L-07 I (1es8)

An Architecture for Expert System
Based Feedback Control

Karl-Erik Årzén

Department of Automatic Control
Lund Institute of Technology

September 1988



Department of Automatic Control
Lund fnstitute of Technology
P.O. Box 118
5-221 00 Lund Sweden

Documcnt na¡rc¡c
Report

Datc of itøuc
September L988

Documcnt ÀIumbc¡

CoDEN: tUTFD2/(TFRT-73ee)/1-07l( 1e88)
Author(s)
Karl-Erik Årzén

Supcrviso¡

Sponcoring org¡anísation
STU

Titlc dnd subtìtle
An architecture for expert system based feedback control.

Absttæt

It is a recognized problem that many industrial control loops are badly tuned or run in manual mode.
Two expert system approaches have been suggested for this problem. Fuzzy, rule-based control replace
control algorithms by linguistic rules which model the operators manual control strategy. Knowledge-based
control extends the range of conventional controllers by encoding general control knowledge and heuristics
concerning tuning and adaptation in a supervisory expert system. An architecture for knowledge-based control
is described where two concurrent processes are used for the knowledge-based system and the numerical
algorithms. A modular, blackboard-based approach is used. This allows the decomposition of the problem
into subtasks which are implemented as separate knowledge sourcee that can be rule-based with different
inference strategies or procedural. The framework can be compared with a real-time operating system and
has similar real-time primitives. The system has been implemented on a VAX tL/780 and used with good
experiences.

Key words
Real-time expert systems, Feedback control

Classífic¿tíon systcrm and./or indcx tcrms (íf any)

S up plc ment ary b iblio graphic al ínfo tmat io n

ISSN and kcy title ISBN

Languagc

English
Numbc¡ oÍ pages

7
R.ccípìcnt's notes

S ccuríty classìfrcat íon

The report may bc o¡de¡ed from thc Department of Automatíc Cont¡ol or bortowcd úårough thc llnivercíty Librury 2, Box 7010,
3-227 O3 Lund, Swcdcn, Tclcx: 33248 lubbís lund.



Paper to be presented at
AI in real-time control,

the IFAC Vüorkshop on
21-23 September, Wales.

An architecture for expert systern based
feedback control

Kart-Erik Ä.rzén
Department of Automatic Control

Lund Institute of Technology
Box 118

5-221 00 Lund, Swcden

Abstract. It is a recognized problem that many industrial control loops are badly tuned
or ru¡l in manual modc. Two cxpcrt systcm approachcs havc bccn suggcstccl ftrr tlris
problem. Fuzzy, rule-based control replace control algorithms by linguistic rules rv¡ic[
model the operators m¿nual control strategy. Knowledge-based control extends the rangc of
conventional controllers by encoding general control knowledge and heuristics concerning
tuning and adaptation in a supervisory expert system. An architecture for knorvledge-
based control is described where two concurrent processes are used for the knowledge-basecl
system and the numerical algorithms. A modular, blackboard-based approach is used. Tiris
allows the decomposition of the problem into subtasks which are implemented as separate
knowledge sources that can be rule-based with different inference strategies or procedural.
The framework can be compared with a real-time operating system and has similar real-
time primitives. The system has beer- implemented on a VAX I1/780 and used rvith goocl
experiences.

Keyuords: Real-time expert systems, Feedback control

1. Introduction
There is currently a significant interest in expert sys-
tem techniques in the process control community,
Applications of many different types have been pro-
posed, implemented and a few also fielded. This pa-
per considers the use ofexpert system, or knowledge-
based system, techniques in the closed control loop.
It is a recognized problem that many industrial con-
trol loops are badly tuned or run in rnanual ¡node.
This decreases the quality of the end product ancl
thus increases cost. The manual control task also
adds to thc already high cognitivc burclc¡r that pro-
cess operators are exposed to in modern control sys-
tems.

The reasons for the poor control arc many. Onc
could be that the control loop is badly tuned from
the beginning. Another could be that the operating
conditions have changed since the initialization of the
controller. This could, c.g. bc duc to operation at
dillerent operating points or time-varying dynamics.

The conventional solution to the problern of poorly
tuned control loops is to use adaptive controllcrs.
Adaptive controllers, e.g., (,4.ström and Wittenmarrk,
1989), are currently beginning to be used in i¡rdustrial
practice. There are, however, problems. Even though
an explicit self-tuning regulator periodically updates
the coefñcie¡rts of a process model thcre still a¡e rrÌany

parameters that must be set explicitly. Examples are
model orders and time scales. Such information can
be diflìcult to provide and process operators typicall¡'
lack the intuitive understanding that they have with
conventional PID controllers-

Two expert system approaches have been suggested
for the described problem. Both i¡volve using the
expert system as a part ol the feedback loop. In the
u'ell-known fuzzy or rule-based approach, e.g., (Tong,
1984), the attempt is to model the manuai control
strategy of the process operator. It is exprcssed as
qualitative, Iinguistic rules lor horv to choose the con-
trol signal in different situations, The rules replace
conventional control algorithms. The intended appli-
cations are control ofcomplcx proccsscs such as, c.g.,
cement kilns, for which either appropriate models do
not exist or are inadequate.

The sccond approach, from now on rcfcrrc<l f,o as
knowledge-based control (Åström and Anton, 1g84;
Ãström et al, 1986i Ârzén, 1987), instead uses ex-
pert system techniques to extend the range of con-
vcntional control ir.lgorithrns by crrcoding gcrrcral
control knowlcdgc and heuristics rcgirrding tuning
and adaptation in a supcrvisory expert system. Tlie
kno*'ledge-based control approach is closer in spirit
to co¡n'entional aclap[ivc control than fuzz¡' conlrol
is. The approach is also motivaied by shortconrings
of adaptive cont¡ollers.

'Ihe recursive identification algorithrns and the co¡r-
trol algorithms of adaptive controlle¡s c¿r¡r l¡e sr:cn



Supervlslon
algorlthmsKnowledge

Bas€d
System

algorlthme

Conlrol
algorllhms Process

A prlorl
informatlon

Figure 1. A knowledge-based controller

as the final algorithmic representation of an large
amount of undcrlying thcoretical as v/ell as practi-
cal control knowledgc. This reprcsent,ation is howevcr
not enough. It has to be combined with heuristic
logic that assures the controller performance under
non-standard conditions. These conditions include
switching between different operating modes, insuf-
ficient process excitation, control signal saüuration
etc, The concept safety jacket or saÍety nef (Isermann
and Lachmann, 1985; Warvick, 1g88) has been estab-
lished for this logic. The safety net part of a controller
is often much larger than the actual algorithms and
is designed mai¡ly from intuition, experience, ancl
simulation. Safety nets tend to be very complex. Ex-
perience has shown that design and testing is quite
time consu:rring.

The approach in knowledgc-based control is to use
an expert system to represent the heuristic safety
net. The controller consists of the combination of
the expert system and a set of control algorithms,
identification algorithms and supervision algorithms,
as shown in Fig. 1.

The topic of this paper is the organization and arch!
tecture of a knowledge-based controller. I{nowledge-
based control is a real-time expert system applica-
lion and, as suclì, contains several difEcult problems
such as non-monotoning reasoning, representation of
time and temporal reasoning, reasoning under time
constraints, responsiveness to asynchronous events
etc. For an overview of these issues see Laífey et al
(1988) or Chantler (198S). Some of these issues are
still unsolved and will be probably never be com-
pletely solved. In several cases, however, practical
approaches exist that to some degree solve the prob-
lems.

There exist a widely spread mis-unclerstanding that,
adding intelligent behaviour to a controller is simply
a matter of generating a few rules and implementing
them in an off-the-shelf expert system shell. This is
far from the case. There is a strong interplay bctween
the architecture of the expert system and the type
of knowledge that ca¡r be naturally expressed in it.
The majority of the expert system softrvare is st,ill
intended for stand alone, off-line applications. Real-
time capacities a¡e only available in ferv cases such
as, e.9., G2 (Gensym, 1987), PICON (Moore el aI,
1985), and Muse (CCL, 1987).

Section 2 describes the overall organization of an ex-
pcrt system framework that has been developed and

,-/-\

Figure 2. Ove¡all implementation structure.

implemented on a VAX lI1780. The frame-*'ork rvas
developed for knowledge-based controi applications
but is not restricted to it. The system has been uscd
for design of intelligent tuning controllers (,4.r2én,
1987). In Section 3, the architecture of the expert
system part of the controller is described t,ogether.
Implementational issues are described in Section 4.
Finally, Section 5 contains a discussio:r .rbout the sys-
tem and a comparison *'ith other systems.

2. Overall architecture
The knowledge-based controller consists of two major
parts: the numerical algorithms and the knowledgc-
based system. To assure that the execution of the nu-
merical algorithms are not delayed by the knowledge-
based system the parts are implemented as two com-
municating concurrent VMS processes wlìere the nu-
merical algorithms have the highest priority.

The man-machine interface is implemented as a sepa-
rate process. From tiris process, the user can interact
directly with the knorvledge-based system and incli-
rectly with the algorithms. The timer process is used
t,o implement certain real-time interrupts described
in the next section. The overall structure is shown in
Fig 2.

The knorvledge-baseci syste¡n and thc rnan-nrachi¡re
interface are both writtcn in Lisp. Thc Lisp uscd is
the UnLx dialect Franz Lisp, (Foderaro et aI, I?BB).
The software package EUNICE, (Kashtan, 1g82),
is used to create a Unix environment under Vi',{S.
The reason for using Lisp is mainly its powerful
syrnbolic processing capabilities. A drawback rvith
Lisp in a real-time system is the garbage collection.
The probiem can be avoided in t.rvo rvays. By using
a Lisp system with i¡rcremental garbage coliection
the garbage collection activily is spread uniformly in
time and performed in the background. Thc seconcì
approaclÌ is to write Lisp code that does not generate
any garbage. This is rvhat is done in G2.

Tlm.
bo

Process

R.. u lt
bor

Timer

System
Basod

Numerical
algorithm

Man-mach¡n€
communlcatio



The nurnerical algorithms

The numerical algorithm process is written in Pas-
cal. It consists of a library of different algorithms
such as PID algorithms, pole-placement algorithms,
discrete filters, relays, recursive least-squares algo-
ritlrrns, lcvcl crossing dctccl,ors, ctc. Thc algorilluns
are uniformly coded and have well-defined interfaces.
It is relatively straight forward to add new types of
algorithms to the system. The process is connected
to A/D and D/A converters.
The algorithms can principally be divided into three
groups: control algorithms, identification algorithms
and monitoring algorithms. The cont,rol algorithms
all compute a control signal based on command and
measurement signals. Only one control algorithm can
be running at a time. The identification and moni-
toring algorithms all in some sense extract informa-
tion from the numerical signal ff.ow. This informa-
tion is sent to the knowledge-based system. The al-
gorithms in these two groups can be viewed as filt,ers
or feature extractors that send information to the
knowledge-based system only when something signif-
icant has happened. During steady-state operation,
the knowledge-bascd system is not i¡volved and t,he
system resembles a conventional controller. The sep-
aration between the numerical algorithms and the
knowledge-based system is favourable from the point
of information flow. If a knowledge-based system was
interfaced directly to a physical process or to an exist-
ing control system, numerical information would have
to be senú forth and back again at a high rate. The
knowledge-based system also had to itself extract all
useful symbolic i¡formation from the signals. This is
a task that often is expressed in the form of numer-
ical algorithms. Using expert system techniques for
such tasks is often inefficient.

Inter-pro cess cornnlunication

The processes communicate by sending messages
through mailboxes shown as rectangles in Fig. 2. The
messages that are sent to the algorithms via Outbox
are confìguration commands, parameter changes, and
information requests from the knowledge-based sys-
tem. The messages t,hat go to the knowledge-based
system contains results obtained by an algorithm,
alarrns that have been detected, answers to infor-
mation requests, user cornmands, and timer inter-
rupts. Messages to the knowledge-based system are
normally sent to Inbox which is a standard first-in,
first-out VMS ¡nailbox. Messagcs wilh prioritics in-
dicating their importance are allowed, This is made
possible by having an inte¡nal maill¡ox inside ùhe
knowledge-based system process into which the mcs-
sages in Inbox are inserted according to their pri-
ority. Important messages such as alarms and timer
interrupts have a high priority and are thus taken
care of as fast as possible. Answerbox is used for re-
sponses to information requests that, has been made
by ihe knowledge-based system. Resultbox is used
by the knowledge-based system to rcturn results to
Lltc man-machine intcrfacc.

The use of Lisp has interesting consequences for the

communication between the knowledge-based system
and thc ¡nan-¡n¿rchinc intcrfocc. Muilboxcs can bc
seen as text files whcre a text line corrcsponcls to
a message. In Lisp there is no syntactical difierence
between dat,a objects and program code, i.e., Lisp
functions. Lists are r¡sc<l to rcprcscnt both. This
makes it possible to implement remote evaluation
of Lisp functions. An arbitrary Lisp function can l¡e
sent to the knowlcdgc-based systern from thc rna¡r-
machine interface wherc it is cvaluatcd and the rcsull
is returned in Resultbox, erronous

Knowledge-based system
architecture

A standard ofÏ-the-shelf expert system framework,
OPS 4, was used to implement the knorvledge-based
part of the system in a first prototype (.Â.rzén, 1g86a,
1980b). OPS 4 (Forgy, 1979) is a simple rule-based,
forward-chaining expert system framework. The rea-
son for this choice was the data-driven nature of
knowledge-based control. Data in the form of signif-
icant events detected by the algorithms are sent to
the knowledge-based system which should react and
generate some response. The framework OPS 4 uses
the incremental pattern-matching algorithm RETE
(Forg¡ 1982) and is therefore also reasr¡nably fast.
Another reason for the choice was simply that the
system was alrailable to us and that rve rvanted to
test the basic ideas rapidl¡'.

Experiences of a prototype

The first prototype was used to implement a relay-
based PID auto-tuner (Åström and Hägglund, 1984).
Ðxperiments with the prototype gave many results
concerning both the feasibility of the approach and
the demands on a expert system framex'ork for
knowledge-based control. We were reassured in that
the approach is feasible. The response times for the
knowledge-based system were acceptable. The sam-
pling rate for the numerical aigorithm process was
1 sccond. It took approximatively 2-3 sampling pe-
riods from that a message tvas sent to the until a
responding message was returned. A second positive
result was a clean implementation of a relay auto-
tuner that clearly benefited from the separation of
logic and algorithms. The tin.re and ellort to make
extensions to the controller were significantly smaller
tha¡r for comparablc irnplcrncntaLions i¡r co¡rvc¡r{,i<.¡¡r¿rl
languages.

The negative experiences all concerncd OPS4. It be-
camc clear that a sirnple forward-chaining rule sys-
tem is not sufficient. An expert system framework
must allow for a modular decomposition of both the
rulebase and the database. For the database, this
could be achieved by a frame system. The rulebase
must be decomposable into rulc groups for the dilTer-
ent subtasks. Furthcr it was found thaü one knowl-
edgc represcntation technique is not enorrgh. Somc
subtasks contai¡rs large sequential elements. 'Ihcse
are mo¡e naturally represented procedurally tlran

3



Global
Database

(Blackboard) Schedu ler

Knowledge sources

TJ
Figure 3. Knowledge based control st¡ucture

with rules. It was also clear that backward chaining
inferencing would be useful for some problems. Thc
most, important drawback with OPS 4 was, however,
that it is not designed for real-time operation. It has,
e.9., no possibilities to havc timc-outs associatcd with
database elements, no means for halting the rule exe-
cution for a certain time, and no possibilities to check
rules at given time intervals.

A blackboard system
Based on the experiences of the prototype, a real-
time expert system framework has been developed.
The reasoning model chosen as the basis for frame-
work is the blackboard model, (Nii, 1986). A globat
database, the blackboard, is available to dilïerent, co-
operating knowledge sources. The database allows for
frame structures for storing associated information.
The knowledge sources can be thought ofas different
actors, each ofwhich solves some subtask ofthe prob-
lem. The knowledge sources also have thei¡ own local
databases. Knowledge sources can be rule-based with
either forward or backwa¡d chaining and procedural,
The structure of the framework is shown in Fig. B.
A knowledge source implements the domain knowl-
edge for a certain task. It is ofien associated with one
or more numerical algorithms. It could for example
contain the hcrrristic logic surrounding an algorithm.

The knowledge sources have primitives for adding,
modifying, and deleting frames both gtobally and lo-
cally. They also have primitives to halt their execu-
tion for a certain time or until a certain dat¿base
element is added to the blackboard. It is possible to
have forward chaining rules that are tested with spe-
cific time i¡terv¿ls and to associate validiiy intervals
with database elements.

The operation of the knowledge-based controller in-
volves the actiyation of different knowledge sources
both in sequence and in parailel. A typical case when
knowledge sources are active in parallel is during
the steady state control of the process. One knowl-
edge source takes care of the actual control algorithm
while other knowledge sources implernent diferent
monitoring aspects.

A separate rule-based module schedules the selcc-
tion of knowledge sourccs at two different levels. The
first level involves the sequential activation of dif-
ferent knowledge sources. The second level involves

the scheduling between different knowledge sources
that are active simultaneously. This resembles the
scheduling in an ordinary real-time, multi-tasking
operating system where the knowledge sources are
thc equivalents of concurrcnt proccsscs, Â knos,lcclgc
source runs until it explicitly rcturns control to thc
scheduler, e.g,, if it has to wait for some information
or if it is finished. A simple extension rvhich allo.*,s
interrupts among the knowledge sources is described
in Årzén (i987). With this extension, priorities can
be associated with knowledge sources. The scheduìer
contains frames with inlormation of the state of the
different knowledge sourccs and fra¡ncs rvhich co¡r_
tains information about the conditions on *,hich a
knowledge source is waiting.

Thc prinritivcs that involvcs waLil,ing ¿ ccrt¿¡in l,i¡nc
are implemenied with the help of the timer process.
A primitive that causes a knowledge source to .rvait
a certain time gives rise to a mcssagc to thc timcr
process. The message contains the desired wakeup
time and a unique identifier for the rvaittime request.
A high-priority message is returned to the scheduler
when the waiting time has elapsed. This message
causes the state of the waiting knowledge source to
be changed to ready.

Knowledge source combination

The operation ofthe knowledge-based controller typ-
ically consists of a sequence, with parallel parts, of
knowledge source activations. Three diffe¡ent meth-
ods for combiniag knowledge sources into scquences
have been implemented.

The most straightforward way is to use primitives
that let knowledge sources acti'r'ate and deactivate
each other. A knorvledge source has the possibility
to wait until another knowledge source is finished.
Procedural knowledge sources also have t,he possibil-
ity to call other procedural knorvledge sources, and
await and use their returned result.

Anothcr alLcrnativc is to havc ¿l nunrL¡c¡ of ¡-rrc-sl,orcd
sequc¡rces. One example of a sequence could be the
i¡ritial tuning sequence. Othcr sequences could be
used to ¡eturn to steady-state control when different
alarm conditions have been de tected. Combination of
knowledge sou¡ces into sequences is b¿sically a pro-
cedural operation. It is therefore natural to express it
with procedural knowledge sources. In order for this
to be possible, rvait primitivcs that allows *'aiting for
conjunctions and disjunctions of multiple events have
been implemented.

Tire last, and most complex mcthod is to dynanri-
cally generate sequences. This is accom¡rlished by as-
sociating goal states, i.e., post-conditions, and ini-
tial states, i.e., pre-conditions, with each knowledge
source. Each knowledge source can be vierved as an
opcrator that transforms tìrc staie of the system front
its initial statc to its goal statc. A sequence is recu¡-
sivcly generated b¡. comparing the desircd goal and
the current state u'ith the pre- and post-conditions
of the operators. This formulation turns the problem
into a planning problem. The scheduler generates a



plan which then is executed.

The possibility for diferent knowledge representa-
tion techniques allows the user to choose the tech-
nique most natural for each sub-problem. The v¿rious
methods of combining knowledge sources give a rich
and flexible structure. For instance, it is possible to
have one knorvledge source that contains monitoring
rulcs which are checked periodically. If something er-
roneous is detected the rules can invoke other knorvl-
edge sources that focuses on the problem. These
knowledge sources could, e.g. be backward chainers
that tries t,o verify some hypothesis concerning the
error or proceclural knowledge sources that performs
some procedural tests. Meta-knowledge sourccs with
knowledge about, the applicability of othcr knowlcdge
sources are also easy to implement.

A knowledge source in a knowledge-based control
application could be, e.g., contain knowledge about
design of different controllers. Another knowledge
source could contain knowledge about modelling
¿¡rcl ¡noclcl vnlidation. Othcr cxam¡rlcs cor¡lrl co¡rlni¡r
knowledge of dillerent monitoring aspects of the con-
troller. The possibility to refer to past signal values
is important in a real-time environment. This is pos-
sible through statistics knowledge sources that com-
putes signal statistics over different time horizons.
These knowledge sources are associated witîr numer-
ical algorithms that collect the signal values.

The described framework has been used for the de-
sign of elaborate extensions of relay auto-tuning.
This is described in ,A,rzén (1987).

4, Implementation
The implementation of the expert system framework
is built on the object-oriented system Flavors (Can-
non, 1982) and the forward-chaining production sys-
tem YAPS (Allen, 1983). The YAPS system is a
pattern-matching system i¡ the same spirit as the
OPS family with a similar optimized, incremental
matching algorithm. The important difference is that
YAPS is v¡ritten in Flavors and allows Flavor in-
stances in its database. These Flavor instances can
be instances of other YAPS systems.

The YAPS system originally only allows arbitrarily
nested list structures of containing numbers, atoms,
and Flavor instances as database elements. The sys-
tem has been modified to allow frame structures. The
system has also been extended to allow for auto-
matic explanations of how database elements have
l¡een added to the system.

The Scheduler is implement,ed as a flavor which in-
herits a YAPS flavor. The scheduling strategy is rep-
resented with rules. The different types of knowledge
sources are implemented as diflerent flavors. Each in-
dividual knowledge source is an instance of the cor-
responding flavor. Each knorvledge source is repre-
sented as a frame in the scheduler database. The
frarne contains slots for the type of knorvledge source,

Scheduler - YAPS system

Figure 4. Implementation stnrcture

e.g., forward or procedural, for the state of the knorvl-
edge source, and for the actual flavor instance that
implements the knowledge source.

The implementation structure is illustrated in Fig, 4.
The actual interface between the knorvledge sources
and the schedrrler consists of a relat.ively small sct
of messages for which the knowledge sou¡ce flavors
should supply methods. This makes it easy t,o add
new types of knowledge sources to the system.

A slightly simplified example of a rule in the sched-
uler is given below.

(p schsdul€l
'rIf a knorledgo sourco is ready
a¡d no othor knoçledge sourco is
runaing thsn ru¡ this knosl_edge sourcs"
(f ra¡e k¡o¡ledgo-source

status activo
6tato t6ady
instance -x)

(' (fra¡oe krrorledge-source
stato running))

(nodify 1 stat€ running)
(<- -¡ 'run))

The forward chailing knowiedge sources are imple-
mented as instances of a flavor that inherits a YAPS
flavor. This givcs a st¡ucture where several YAPS sys-
tcms residc as datab¿rsc clements insidc tirc Schcdulcr
YAPS system.

The backward chaining knowledge sources are based
on an small expert systcm example in Winston and
Horn, (1981), which has bcen extended and embed-
ded in Flavors. Currently they can only ask qucs-
tions to the operator when an answer cannot be au-
tomatically deduced. A possible extension rvould be
to, in that case, allow a backward chaining knowÌedge
source to invoke a lorward or procedural knowledge
source that returns the needed atìswer.

The procedural knowledge sources cor.rsists of Lisp
functions. In order to allow interrupts of these func-
tions at arbitrary places the entire state of the Lisp
computation must be saved. This is not possiblc rvith
the Franz Lisp of the basic system. Inste¿Ld Lisp has
been used to write a register nìacllirìe basecl intcr-
preter for a procedural Lisp-like language that allorvs
the computation to be suspended.

,._ìì
I Knowledge

ü:Þ

Global
Database

Rules

Scheduling rules



5. Summary
Àrr gcrrcrul cx¡rcrL systcrrr frur¡rcwork fcrr rcul-tirrrc u¡_l-
plications has becn prescntcd. It has becn dcvelopcd
for knowledge-based control applications but is not
restricted to it.

The framework has real-time facilities. It is modu-
larized into knowledge sources that can be compared
with concurrent processes. This is similar to thc Muse
system. In the current version, however, the knorvl-
edge sources cannot interrupt each other. With a sim-
ple extension this is possible. The knowledge sources
have primitives to wait a certain time or for a cer-
tain database element. These primitives are used to
implement periodic rule testing in a way similar to
G2 and Picon.

Validity intervals can be used to indicate how long
database elements remain valid. In contrast v¡ith G2
and Picon the validity interv¿ls are not propagated
to inferred facts. History values of important signal
values are maintained. It is not possible to store
history va.lues of arbitrary frame attributes.
The system allows for both rule-based and procedural
representation which is very important, The flexible
means of combining knowledge sources gives a rich
structure.

1ìrere are many similarities between real-time op-
erating systems and real-time knowledge-based sys-
tems. Real-time operating systems for process control
have evolved over a long period of time. This paper
indicatcs a new system architccturc where real-time
operating systems, databases, object-oriente(i pro-
gramrning, and knowledge-based systems are com-
bined.

The exccution speed of the system is of the orcler of
one forward chaining rule per second, The system is
currently being ported to a Symbolics - IBM PC en-
vironment where the knowledge-based system resides
on the Symbolics and the numerical algorithms reside
on the IBM PC. Preliminary results indicate a factor
of 10 in increased speed. Other possible candidates
for migration are systerns where powerful symbolic
processing capacity is combined with conventional
cornputing. One example of this is the ¿z-Explorer.

,4. cknorvle dge rncnts

The author rvould like to thank Professor I{arl Johan
Âström and Sven Erik Mattsson for many useful
discussions. This work has been supported by the
National Swedish Board for Technical Development
(STU) under contract 85-3084.

Refe¡ences

ALLnu, E.M. (1983): ,,yApS: yet another production
system," TR-1146, Department of Computer Science,
University of Maryland.

ÂnzÉN, K-8. (19S'6a): ,,Expert systems for process
control,' in D. Sri¡am and R. Adey (trds.): proc.
of Fj¡st Intetnational Conference on Applications of
Artifrcial lntclligence in Engineering Practice, Springer
Verlag, Berlin, pp. 1127-1138.

.ÅnzÉx, K-8. (1986b): "Usc of expert svstems in closed
loop feedback control," Proc. of American Control
Conference, Seattle, Wr\.

ÅnzÉx, K-8. (19S7): "Realization of cxpert system bascd
feedback control," Ph.D. thesis CODEN: LUTFD2/
TFRT-1029, Department of Automatic Control, Lund
Llul,iùutc of 'l'cchnology, Lund, Swcdcr¡.

ÂsrRölt, K.J. and J..J. ANro¡ (1984): ,,Experr control,,,
Proc. 9'th IFAC World Congress, Budapest, IIungar5,.

Ås'rRöu, K.J. and 'I'. IIÃccLUND (1984): ,,Autorrratic
tuning of simple regulators," Proc. IFAC g'th l!¡orld
Co ngress, B udapest, Ilungary.

Åsrnö¡'¡ K.J. and B. W¡TTnu¡¿lnx (fOSO): Adaptit,e
Control, To appear, Addison-lVesley, Reading, lr,fA.

ÅsrRölr, K.J., J.J. Ar.row and K.-E. ÅnzÉN (1986):
"Expert control," Automatica, 22, 3, 277-286.

CaNuoll, H.I. (1982); "Flavors: A non-hierarchical ap-
proach to object-oriented programming,," unpublished
paper.

CCL (1987): "Muse product description,', Cambridge
Consultants Liroited, 4 pages.

Cu.lxrr,er, M.J. (1988): ,'Real-time aspects of experr
systems in process control," Colloquium on Expert
Systems jn P¡ocess Control, IEE, Savoy Place, Lonclon
UK.

FoouR,o.Ro, J.K., K.L. Sxr,ownR and K. Lay¡R (19g3):
"The Franz Lisp Manual," ',JC Berkeley, California.

FoRcY, C.L. (1979): "OPS4 IJser's manual," Technical
report CMU-CS-79-132, Department of Computer Sci-
ence, Carnegie-Melion University,

FoRcY, C.L. (1982): "Rete: À fast algorithm for the
many pattern/many object pattern match problem,"
Artifr.cial Intelligence, 75, l, 17-37.

GnNsyl,t (1987): G2 User's manual, Gens¡.m Corp..
Cambridge, MA.

IsERlaaNN, R. and K.H. Llcuuaun (1985): ,,pa¡ame-
ter-adaptive control with configuration aids and sr.rper-
vision functions," Äuf,omalica, 2L, 6, 625-638.

K.a,snT,nN, D.L. (1982): "EUNICE: A system for porring
UNIX programs to VAX/VMS," Artificial Intelligence
Center, SRI Inte¡national, \,Ienlo Park, California.

L,rrrnv, 1'.J., P.A. Cox, J.L. Scurvrrot, S.tr,I. K¡o.
and J. Y READ (1988): "Real-time knowledge-based
systems," AI Magazine, I, I, 27-45,

MooRrì, R.L., L.R. IIrrwxrwsor,r, M.lì. i.¡;vtN;r¡rrì
C.G. I(xrcxnRBocKÐR (1gS5): ,,Expert control,', proc.
American Conttol Conf., Boston, \,f Ä, pp. ES5-887.

Ntt, lI.P. (i986): "Blackboa¡d sy6tems: t he Ì¡lackl¡oarrl
model of probiem solving and the evolution of black-
board a¡chitectures," AI Magazine, 7, 2, 38-53.

ToNc, R.M. (198a): "A retrospective vicw of ftzzy con-
trol systems," Fuzzy Sets and ,Sysúerns, 14, lgg-210.

WaRvtcr, K. (1988): Implementation of self-tuning
controllers, Peter Peregrinus, London.

'Wnts,oN, P.H. and B.K.P. HoRN (1981): Iisp, Ad<ìi-
son-\\Iesley, Reading, MA,