HMR language
The HMR language has been designed to textual human and machine redable representation of XTT2 models.
The syntax of the HMR is a subset of Prolog syntax where a number of operators have been defined.
Each HMR file consists of the following parts:
[requied] Types definitions (predicate xtype),
[optional] Types groups definitions (predicate xtpgr),
[requied] Attributes definitions (predicate xattr),
[optional] Attributes groups definitions (predicate xatgr),
[requied]Definicje schematów (tabel) (predicate xschm),
[requied] Rules definitions (predicate xrule),
[optional] States definitions (predicate xstat).
[optional] Callbacks definitions (predicate xcall)
Each of predicates (besides xschm and xrule) is a Prolog list, which defines the properities of a XTT object.
In example, the definitions of type weekdays and an attribute day is as follows:
xtype [name: weekdays,
base: symbolic,
desc: 'A set of days of the week',
domain: ['Monday'/1,'Tuesday'/2,'Wednesday'/3,'Thursday'/4,'Friday'/5,'Saturday'/6,'Sunday'/7],
ordered: yes
].
xattr [name: day,
abbrev: day,
class: simple,
type: weekdays,
comm: in,
callback: [ask_symbolic_GUI,[day]],
desc: 'The current day'
].
xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T),
alsv_domain(AttName,Domain,symbolic),
Params = [AttName|Domain],
term_to_atom(Params, AtomParams),
jpl_call(T,request,['callbacks.input.ComboBoxFetcher',AtomParams],Answer),
atom_to_term(Answer,Answer2,_),
alsv_new_val(AttName,Answer2)).
Exercise
Callbacks in HMR
Callbacks are the functions that are executed during the XTT tables evaluation in order to get a value or to present a value.
The example of the callbacks execution results are showed in the picture below.
In the cashpoint system, the callbacks are used for calling a enter PIN dialog as well as for displaying messages to the user.
There are two types of callbacks:
in - are executed before (or during) inference process in order to get attributes value.
out - are executed for values of attributes presentation, when the inference process is finished.
The type of a callback is determined by value of the attribute comm property.
HMR syntax provides a callback property of the XTT attribute that indicates which callback function should be called.
The property has a list structure, where the first element is the name of the callback function and the second is a list of parameters.
xattr [name: day,
abbrev: day,
class: simple,
type: day,
comm: in,
callback: [ask_console,[day]]
].
The above example defines an attribute day.
The value of the property comm of this attribute is in what defines the type of the callback to be in.
For this attribute the ask_console callback function will be called, which will get the value of the attribute day.
Callbacks and attributes
In HMR, callbacks are related to attributes. For each attribute two properties must be defined in order to use callbacks:
HMR provides xcall predicate that allows for callback definition.
The following example shows the JPL mechnism, which is used to create a callback written in Java.
xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T),
alsv_domain(AttName,Domain,symbolic),
Params = [AttName|Domain],
term_to_atom(Params, AtomParams),
jpl_call(T,request,['callbacks.input.ComboBoxFetcher',AtomParams],Answer),
atom_to_term(Answer,Answer2,_),
alsv_new_val(AttName,Answer2)).
Programming languages
HeaRT supports the callbacks written in:
Prolog
Prolog-based callbacks are an ordinary Prolog predicates.
xcall ask_console : [AttName] >>> (write('Type value for attribute: '),
write(AttName),nl,
read(Answer),
alsv_new_val(AttName,Answer)).
Exercise
In order to run inference process directly from HeaRT interpreter you must:
Run the inference for the following model: thermostat-clb-pl.pl
XPCE
The XPCE-based callbacks consist of the ordinary Prolog predicates that are enriched by XPCE functions.
In order to assure the correct integration with HaeRT, the following schema must be used:
xcall xpce_ask_numeric: [AttName] >>> (
dynamic(end),
% The body of the callback, which prepares a dialog to appear.
repeat,
% Waiting for OK button
send(@display,dispatch),
end,!,
retractall(end)).
The example of the callback that reads a value from the range [Min; Max] is presented below:
xcall xpce_ask_numeric: [AttName] >>> (alsv_domain(AttName,[Min to Max],numeric),
dynamic(end),
new(@dialog,dialog('Select a value')),
send_list(@dialog,append,
[new(I,int_item(AttName,low := Min, high := Max)),
new(_,button('Select',and(message(@prolog,assert,end),and(message(@prolog,alsv_new_val,AttName,I?selection),message(@dialog,destroy)))))]),
send(@dialog,open),
repeat,
send(@display,dispatch),
end,!,
retractall(end)).
Exercise
Run the inference mechanism for the ATM example and trace the callback mechanism:
Java
The Java-based callbacks are the Java programs that are executed by prolog with the help of JPL.
To exploit this mechanism, the following classes mysu be used:
DataFetcher.java - an abstract class that must be inherited by all the callbacks
RequestInterface.java - controller
Response.java - class that stores a data retrieved from a user.
The set of basic components, which can be used to the retrieval data from a user, is prepared to facilitate the callbacks implementation.
ComboBoxFetcher.java - creates a list of selectable values. It returns one (selected) value.
SliderFetcher.java - allowf for selecting a value from a given range of values. It returns one (selected) value.
TwoListsFetcher.java - creates a list of selectable values. It returns list of all selected values.
ComboGUI.java -
GUI for ComboBoxFetcher
SliderGUI.java -
GUI for SliderFetcher
TwoListsGUI.java -
GUI for TwoListsFetcher
Download a source code here.
Example
In order to use some of the above components to create callback, you must go through the following steps:
Compile the source code
javac callbacks/input/*.java skeleton/*.java
and move it to the HMR file directory.
Modify the HMR file by adding the callback filed to the appropriate attributes.
Define the value of this filed by entering the name of the callback as well as a list of parameters i.e.
callback: [ask_symbolic_GUI,[day]]
Add the
xcall predicates to the HMR file, which execute a given callback:
xcall ask_symbolic_GUI : [AttName] >>> (
% Creating controller
jpl_new('skeleton.RequestInterface',[],T),
% Creating a list of params
alsv_domain(AttName,Domain,symbolic),
Params = [AttName|Domain],
term_to_atom(Params, AtomParams),
% Execute the callback with the params contained by AtomPArams term.
% The result will be stored in Answer term.
jpl_call(T,request,['callbacks.input.ComboBoxFetcher',AtomParams],Answer),
% Map the returned value into term and add it the the factbase
atom_to_term(Answer,Answer2,_),
alsv_new_val(AttName,Answer2)).
Go to HMR file directory.
Run HeaRT tool.
Compile HMR file.
Run the inference mechanism.
The callback should be executed.
Exercise 1
Download the file kardio.zip and run the inference for the HMR file.
Exercise 2
Run HeaRT and load HMR
file.
Then run the infenrence mechnism using predicate (gox/3).
Add a new XPCE-based callback, which would present the results of the inference.
-
Add (modify an existing Prolog-based) a new JAVA-based callbacks in the same way as in the previous section.
Komentarze
Z braku lepszego miejsca tutaj studenci wpisują komentarze natury ogólnej do tego lab.