easy java simulations an open source

Easy Java Simulations: an Open-SourceTool to Develop Interactive VirtualLaboratories Using MATLAB/Simulink*

J. SAÂ NCHEZ, F. ESQUEMBRE, C. MARTIÂN, S. DORMIDO, S. DORMIDO-CANTO, R. D. CANTO,R. PASTOR and A. URQUIÂADepartment of Computer Sciences and Automatic Control, UNED, C/. Juan del Rosal 16, 28040 Madrid,Spain. Email: [email protected], [email protected]

This paper describes the make-up of interactive computer simulations that implement virtuallaboratories in the field of Control Engineering education. We introduce Easy Java Simulations(EJS), a Java-based tool designed to help control educators with a low profile in programming tocreate interactive scientific simulations. This tool can be used on its own, generating stand-aloneJava applications or applets, or in conjunction with MATLAB/Simulink, using them as the internalengine that describes and solves the model. This tool allows users to develop complete, interactivesimulations in three steps: writing the mathematical model (optionally using MATLAB/Simulink),building the graphical user interface (GUI) using off-the-shelf graphical elements, and linking theGUI elements to the variables of the model. In this way, models of control engineering can bespecified either using the programming support provided by EJS or by using MATLAB/Simulink,which can then be fully controlled from EJS. In this paper we describe this particular feature indetail, and provide some examples that show the advantages that this tool offers to the world-wideengineering education community.

INTRODUCTION

RECENT DEVELOPMENTS in computer hard-ware and software now make it possible to providestudents with interactive programs that can beconsidered as midway between regular labs andlectures and that allow us to display multiple-viewrepresentations of a given dynamic system, andsome of its attributes, on the computer screen [1].Visualization thus appears naturally in the originsof automatic control, in the discovery of newrelationships among mathematical objects, and inthe transmission and communication of know-ledge. These tools, called interactive virtual labs,can be used to explain basic concepts, to providenew perspectives on and insights into a problem,and to illustrate analysis and design topics [2].

However, as a natural consequence of theenhanced performance and graphical capabilitiesof modern computers, the search for interactivitymust also take us a step forward. Nowadays, theuse of the word ``interactivity'' in the design ofautomatic control systems means, to many people,a process of repeating several times a loop wherebya user introduces some parameters in the software,runs the algorithms of design, and analyzes andcompares the results graphically in static plots. Ifthe results are not as expected, the user must enternew parameters and repeat the execution-analysisprocess until (s)he finds a configuration that is

satisfactory. Proceeding in this way, however, it isdifficult for the user to recognize the relationshipbetween the gradient of change in the results(usually, the system response in temporal andfrequency domains) and the values of the inputparameters. This perception would be considerablyimproved if the user could work with simultaneousgraphical representations of the input parametersand the model's dynamic properties, and if therewere an instantaneous translation of any modifica-tion of an input parameter to the system'sresponse. This situation could then be consideredtrue interactivity, since a change in the simulation'sparameters has an immediate effect on the differ-ent views of the system, according to the mathe-matical relationships that govern the dynamics ofthe system. Figs. 1 and 2 present two examples ofintroducing interactivity into virtual labs. Fig. 1shows a virtual lab for testing different controlstrategies for a Furuta pendulum. The next figure,Fig. 2, corresponds to an interesting applicationfor the study of the theoretical control back-ground. In such applications, the signals inside aplot can be dragged by the mouse (thus behavingas input parameters) and the new values have animmediate consequence for the other graphicalrepresentations of the system.

Let us now apply our discussion on interactivityto the real educational world, where the de factostandard software for instructional purposes isMATLAB/Simulink. If we try to apply ourconcept of interactivity to teaching with* Accepted 2 July 2005.

798

Int. J. Engng Ed. Vol. 21, No. 5, pp. 798±813, 2005 0949-149X/91 $3.00+0.00Printed in Great Britain. # 2005 TEMPUS Publications.

MATLAB/Simulink, we will encounter seriousdifficulties, because this software was not designedto develop graphical applications using this newapproach. The creation of rich graphical interfacesusing only MATLAB/Simulink is not an easy task,and high programming skills are required todevelop useful applications with even a basiclevel of interactivity. When an instructor usesMATLAB/Simulink, s/he is an expert in thesubject that is to be explained and in the use of

the mathematical facilities of the software toprogram algorithms. S/he is also capable ofpresenting the results by means of different typesof plots and numerical values. However, controlengineering instructors are not true programmersand the addition of an extra layer of interactivityto their MATLAB/Simulink applications would bevery time-consuming. This statement also applies,even more strongly, to the development of virtualand remote labs.

Fig. 1. Virtual lab for studying control problems related to the Furuta pendulum.

Fig. 2. Interactive toolbox for analyzing and designing control linear systems.

Easy Java Simulations: An Open-Source Tool 799

Two software products now exist that can helpsolve this problem: SysQuake [3] and Easy JavaSimulations [4]. The first is a commercial tooloriented to the development of interactive applica-tions using a language fully compatible withMATLAB. Consequently, MATLAB legacy code(i.e. M-files) can be reused and benefit fromSysQuake's high graphical capabilities to producevaluable, interactive instructional control applica-tions. Additional information on this software canbe found at http://www.calerga.com, and examplesof advanced control applications developed with itare described in [5±9].

Easy Java Simulations (EJS) is an open source(free of charge) software tool that helps createdynamic, interactive scientific simulations in theJava language. The tool is targeted for both sciencestudents and teachers with basic programmingskills and is therefore very much suited to thesituation one finds in most university classrooms.Within EJS, simulations are created by specifying amodel for the simulated system and by building aview that continuously visualizes the state of thismodel and that readily responds to user inter-action. Models can be described in EJS applica-tions either using its self-contained facilities (ODEsolvers and Java code editors) or Simulink blockdiagrams. If using the latter, EJS can wrap theSimulink model with a Java-made layer of inter-activity. The final product is a Java applicationthat efficiently interchanges data (input para-meters and states variables) with the Simulinkmodel through MATLAB's workspace (Fig. 3).

The tool can be used as a timely first step forcontrol educators as a way of adopting an inter-active-based approach in order to be at the cuttingedge of innovative initiatives in education, such asthe different world-wide open-source initiatives

that physics instructors are currently encountering[10]. Because of its interest, this paper describesEJS in more detail and presents two case studies ofthe development of control virtual labs.

The paper is organized as follows. First, EasyJava Simulations are briefly described, with parti-cular emphasis on the development of controlvirtual labs that use MATLAB/Simulink as thesimulation and mathematical engine. The nextsection shows an example of this collaborationbetween tools to develop a virtual lab on amagnetic levitator. Then a more advanced virtuallab is described, the quadruple-tank process, whichalso uses Simulink to develop the model. Thepaper ends with some conclusions on the combineduse of EJS and MATLAB/Simulink as a way tofoster the use of interactivity in control education,and, more precisely, the construction of instruc-tional control virtual labs.

A brief survey of Easy Java SimulationsA quick description of Easy Java Simulations

places it in the category of `̀ code generators''. Thismeans that users need to provide only the mostrelevant core of the simulation's algorithm and thetool automatically generates all the Java codeneeded to create a complete interactive simulation,including a wide range of sophisticated softwaretechniques (such as handling computer graphicroutines, communication protocols, multithread-ing and others). What makes EJS very specialwithin this category of software is that it hasbeen conceived by teachers and for teachers, andfor students who are more interested in under-standing the simulated phenomena than in theunderlying computer-specific aspects.

The tool uses an original simplification of thesuccessful Model-View-Control software paradigm

Fig. 3. Building a simulation using EJS and MATLAB/Simulink.

J. SaÂnchez et al.800

(MVC), and structures simulations in two mainparts: model and view. The MVC paradigm statesthat a simulation is composed of three parts.

1. The model, which describes the phenomenonunder study in terms of:

. variables, which hold the different possiblestates of the phenomenon, and

. relationships among these variables (corres-ponding to the laws that govern the phenom-enon), expressed by computer algorithms.

2. The control, which defines certain actions that auser can perform on the simulation.

3. The view, which shows a graphical representa-tion (either realistic or schematic) of the differ-ent states that the phenomenon can have.

These three parts are deeply interconnected. Themodel obviously affects the view, since a change inthe state of the model must be made graphicallyevident to the user. The control affects the model,because control actions can (and usually do)modify the value of variables of the model. Finally,the view affects the model and the control, becausethe graphical interface can contain componentsthat allow the user to modify variables or performthe predefined actions. As mentioned above, EJSfurther simplifies the construction of a simulationby merging the control, half into the view, half intothe model.

The model is what conveys the scientific part ofthe simulation and is thus the responsibility andthe main interest of the user. Control teachers areused to describing their algorithms in terms ofmathematical equations and to expressing theseusing a given computer language, or by means ofhigh-level tools such as MATLAB/Simulink. Themain target when creating the model of a simula-tion is to concentrate on the analytical descriptionof the phenomena, the content, and the accuracyof the simulation. However, the creation of thenecessary graphical user interface (that is, the view)

is the part of the simulation that demands moreknowledge of advanced programming techniques.And, to make the situation even worse, the addi-tion of interactivity to this interface involvesmastering sophisticated software techniqueswhich demand a big investment of time and effort.

EJS helps its users through both tasks. The toolprovides extensive scaffolding to define the model,while still retaining the flexibility of a generalprogramming language, so that it is possible tospecify almost any type of algorithm. This ispedagogically important, since the process oflearning good control fundamentals consists, to agreat extent, in understanding the basic principlesrequired to build models.

In order to define the model in EJS, the userfollows a prescribed sequence:

. declare the variables that describe the system;

. initialize these variables to a correct initial state;

. describe how the value of these variableschanges over time; and

. establish how they affect each other when theuser interacts with the system and modifies oneor more of their values.

The last two steps consist in translating the math-ematical equations or physical laws that rule thephenomenon under study into computer algo-rithms. Sometimes, though, the actual implemen-tation of these algorithms can be a difficult task.For this reason, EJS provides two extra facilities.The first is a built-in editor and solver for systemsof ordinary differential equations (ODE). The userwrites the equations in a way that is similar to hows/he would write on a blackboard, and the systemautomatically generates the code that numericallysolves the equations using one of several of thestandard algorithms provided (Fig. 4). The editoralso includes support to handle simple state eventsof the ODE. The second facility is a connection toMATLAB/Simulink that lets users design andsolve their models with the help of these tools. In

Fig. 4. Edition panel to write the ODE and select the solver.


this second case, the model is fully defined by aSimulink block diagram, and all that is needed isan M-file that informs EJS about the names of theMATLAB/Simulink variables so that it can create,once the final application is generated, a bi-direc-tional link between the Java-coded interactiveinterface (the view) and the Simulink diagram forthe model. Two examples on the use of this optionare further described in the following sections.

In order to help create the view, EJS provides aset of advanced graphical elements (Fig. 5) thatbuild on top of both standard Java Swing compo-nents (containers, buttons, text fields, sliders,combo boxes, etc.) and on specific scientific two-and three-dimensional visualization classes fromthe Open Source Physics project [10] (particles,vectors, images, vector and scalar fields, etc.).These elements can be used in a simple drag-and-drop way to build the interface. The user just needsto design the view so that it will offer a visual-ization of the phenomenon appropriate to thedesired pedagogical goals. In particular, the viewshould encourage students to explore the phenom-enon from different engineering perspectives inorder to gain a better insight into the system.

To complete the view, its different elements haveto be instructed to display on the screen accordingto the values of the variables of the model. Everygraphic element of EJS has certain internal values,called `̀ properties'', that can be customized tomake the element look and behave in a particularway (change its displayed value, position, size,etc.). The user can very easily connect the proper-ties of the graphical elements of the view to thevalue of the different variables of the model. Someof these properties can also be instructed to triggeruser-defined actions (typical routines defined in themodel) when the user interactively changes them.This procedure, which is called `̀ linking'' the

model and the view, is what turns the simulationinto a dynamic, interactive application. Thismechanism configures a simple, though very effec-tive, way of designing and building advancedinteractive user interfaces (Fig. 6).

The reason for this is that linking is a two-wayconnection. When the variables of the modelchange, the view is informed, so that it immedi-ately displays the new state of the model. In return,since the view elements have built-in interactivecapabilities, any interaction between the studentand the interface immediately affects the modelvariables that have a connection to it. For ex-ample, let us imagine an EJS simulation of thecontrol level of a tank. The tank and the waterinside it are represented in the view by means oftwo coloured rectangles. If the dimensions of thetank are modified by dragging with the mouse thecorners of the outer rectangle, the variables repre-senting the tank width and height in the analyticalmodel will reflect this change (thus affecting thedynamics of the system). Similarly, if the waterlevel changes as a consequence of the model'sevolution, the visible height of the rectangle willchange to display the current water level.

With all the high-level information, which onlythe user can provide, EJS takes care of all the low-level procedures needed to create the final simula-tion. It will generate the Java code that handles allthe internal tasks, compile it into Java classes, packthe classes in a compressed file, and end up with aready-to-use simulation. Simulations created usingEJS can either be used as stand-alone applicationsunder different operating systems (for instance, a.BAT file is provided when running underWindows) or can be distributed via the Internetand run as applets within HTML pages (alsogenerated by EJS) by using any Java-enabledweb browser. The tool also includes a simple

Fig. 5. Library of the graphical elements of EJS.


HTML editor to help the teacher enhance thegenerated web pages with pedagogical informationand/or instructions for the simulation. At present,the use of MATLAB/Simulink is not supportedwhen running simulations as applets, although weare working on a future model that will allow EJSto generate distributed applications with Javainterfaces and Simulink models running in differ-ent computers using the Internet to interchangeinformation.

A virtual lab for the magnetic levitator systemThe system modeled in this section is the ECP

magnetic levitation system (model 730) [11]. Fig. 7shows the free-body diagram of two suspendedmagnets. Each magnet is acted on by forces fromeither driver coil, from the other magnet, fromgravity and from friction (modeled as viscous).The differential equations for both magnets are:

m1�y1 � c1 _y1 � Fm12 � Fu11 ÿ Fu21 ÿmg �1�m2�y2 � c2 _y2 � Fm12 � Fu22 ÿ Fu12 ÿmg �2�

The magnetic force terms are modeled by [11]:

Fu11 � i1

a�y1 � b�N �3�

Fu12 � i1

a�yc � y2 � b�N �4�

Fu21 � i2

a�yc ÿ y1 � b�N �5�

Fu22 � i2

a�ÿy2 � b�N �6�

Fm12 � c

�y12 � d�N �7�

y12 � yc � y2 ÿ y1 �8�where a, b, c, d and N are constants which may bedetermined by numerical modeling of the magneticconfiguration. In this case, N = 4 and a, b, c and dhave been determined by empirical methods inorder to adjust the simulation and experimentalresults. The identification of the parameters of themodel was done by measuring the specific input/output characteristics of the magnet/coil actuatorsand the magnet/magnet interactions as they varywith relative position. The strong magnetic fieldnonlinearity, however, is inherent to this class ofmagnetic systems. For most control designpurposes, the upper and lower actuators' charac-teristics may be assumed to be identical.

The interaction of the two magnets has anonlinear force characteristic. When two magnetsare used in the configuration, they are usuallyplaced with like poles facing each other so thatthey repel. When the lower magnet is stationary,the upper magnet comes to rest in equilibriumbetween the upward repulsive magnet force anddownward gravitational force. The magnetic force

Fig. 6. View of an interactive application developed using EJS.

Fig. 7. Free-body diagram of the magnetic levitator.


characteristic may be measured by adding andsubtracting weight from the upper magnet andmeasuring the equilibrium height. Using thisprocedure, we obtained the following values forthe parameters: a � 1:65 N, b � 6:2 cm, c � 2:69Ncm3 y d � 4:2 cm.

Implementation of the magnetic levitator with EJSand MATLAB/Simulink

When developing this type of simulation, one ofthe most important things that the teacher needs tobear in mind is utilising the correct configurationof windows and operating controls of the simula-tion in order to facilitate the student's understand-ing of the virtual lab. In our case, this view (usingEJS terminology) is divided into several elements,as displayed in Fig. 8. Because the simulation is tobe used for didactical purposes, it was very impor-tant for us to provide a visualization that displaysthe physical system as realistically as possible, butthat also provides support for graphic toolscommonly used in control (plots, diagrams, inputdevices, controllers, etc.). A second requirementwas to provide a set of interactive elements thatcould be manipulated by the students to makechanges in a dynamic way during an experiment.The view is therefore structured in one mainwindow and three secondary dialog windows.The main window is located at the left-hand sideof Fig. 8. The big central part of the main windowschematically displays the magnetic levitator andallows the user to change interactively the setpoints by dragging the arrows up and down. The

lower part of the main window is filled withbuttons and check boxes that allow the user tochoose the operating conditions of the system.With these elements the user can select to:

. Play, pause and reset the simulation.

. Choose the control system mode: manual orautomatic.

. Change the mass of the magnets' (change m).

. Change the magnets' polarity (polarity m#1 andpolarity m#2).

. Select the magnets that will operate the levitator(upper magnet and/or lower magnet).

The last two options can be used to configure thevirtual lab as a variety of single-input single-output(SISO) and multi-input multi-output (MIMO)systems. By using a repulsive force from thelower coil to levitate a single magnet, an open-loop stable SISO system is created. Attractivelevitation via the upper coil configures an open-loop unstable system. Two magnets may be raisedby a single coil to produce a SIMO plant. If twocoils are used, a MIMO plant is produced. Thesemay be locally stable or unstable, depending on theselection of the magnets' polarities and thenominal magnet positions. The plant has inher-ently strong nonlinearities, due to the naturalproperties of magnetic fields. Thus, this virtuallab provides a dynamically rich test bed for imple-mentation of introductory and advanced controlmethods.

However, the most relevant feature of thisdidactical application is that MATLAB/Simulink

Fig. 8. Magnetic levitation virtual lab.


is running in the background. Fig. 9 shows theSimulink block diagram of the magnetic levitatordescribed in equations 1 to 8 with the modifica-tions needed for it to be used by EJS.

There are three main steps to using a standardSimulink block diagram within EJS. The firstconsists in making some changes to the originalSimulink model. These changes are necessarybecause Simulink models are, obviously, createdto be run within Simulink. But, since the commun-ication between Simulink and EJS goes throughMATLAB's workspace, we first need to changethe Simulink model so that it sends/receives thevalue of some of its variables and parameters to/from MATLAB's workspace. Fig. 9 shows howsome system parameters of the block diagram havebeen adapted to be read from MATLAB's work-space: magnets' masses, polarities, and parametersof the magnetic configuration. The block diagramhas also been slightly modified so that it writes thesimulation state in MATLAB's workspace (timeand positions of the two magnets) after everyintegration step.

The reading of the values from MATLAB'sworkspace variables is done by including`̀ MATLAB function'' blocks in the diagram toevaluate variables and/or expressions. Fig. 10ashows a Simulink block in which an expression

using MATLAB variables is evaluated to generateone of the magnetic forces. To write the modelstate back into MATLAB's workspace after eachintegration step, it is necessary to include a `̀ Toworkspace'' block in the diagram for each of thevariables in the state vector of the model. As anexample, Fig. 10b shows the block used to send theposition of magnet 1 (variable y1) back to theworkspace.

A second difference to a standard bock diagramcomes from the fact that Simulink models areusually played and paused by the user throughSimulink's user interface. Hence, the model mustbe changed so that it stops after every integrationstep. For this, it is necessary to include in themodel diagram one ``MATLAB function'' blockwith the MATLAB command `̀ set_param (gcs,`SimulationCommand', `Pause')``. In this way,EJS can control exactly when the model needs toplay.

The second step needed to connect the Simulinkmodel with EJS is the creation of a simple M-file.This file provides EJS with basic informationabout the model and about the variables andparameters that can be accessed throughMATLAB's workspace. Fig. 11 shows an extractfrom the file that we created for this example.

The syntax for this text file is rather simple.

Fig. 9. Modified Simulink block diagrams.


What enables EJS to read and access these vari-ables is the special comment at the end of each line.This comment always starts with the keyword`̀ EJS'' immediately after the comment character`̀ %''. The keyword must be followed by one of thefollowing words: Model, Variable, or Para-meter.

. Model is used to tell EJS the name of theSimulink file that describes the model.

. Variable provides EJS with a description of avariable of the Simulink model. A variable canbe declared to be accessible for reading, writingor both. If no modifier is indicated, the variablecan be freely accessed and EJS will synchronizeits value with the associated EJS variable beforeand after every integration step of Simulink, as,for example, happens with the positions of themagnets (variables y1 and y2). If declared asInputOnly, however, EJS will understand thatthe variable is not to be changed by the Simulinkmodel and will always force its value to what-ever it is within EJS. In our example, the masses(variables m1 and m2) and the control actions(u1 and u2) are input-only variables that will beset by the user through the simulation interface.Finally, if declared as OutputOnly, EJS willread the variable after every integration step of

the Simulink model is run, but it will not try tochange its value in the Simulink model. Forinstance, the time variable of the model is readonly since it is the result of Simulink executionafter each integration step.

. Parameter declares variables that are definedinside Simulink blocks. Ejs makes no distinctionbetween variables and parameters for computa-tional use. However, for technical reasons, thecomment for a parameter must include informa-tion about the Simulink block or menu in whichthe parameter is defined and the function of thisparameter within the block. In our example, theintegration step dt is declared to be the general(that is, not defined within any block) parametermaxstep, since it is located in a dialog panel ofthe menu Parameters located in the Simulinkmenu Simulation.

The third and final step in this process consists ofconnecting the variables of the EJS model withMATLAB's workspace variables (which are inturn associated with variables of the Simulinkmodel). Fig. 12 shows the variables in EJS forour example and how they are connected toMATLAB's variables. Notice that we havechosen similar (if not identical) names for bothsets of variables.

(a)

(b)

Fig. 10. Source and sink blocks to communicate MATLAB's workspace and Simulink.

Fig. 11. Extract from the file levitator.m, used to connect Simulink and EJS.


To make the connection between EJS andMATLAB/Simulink it is necessary to open apage of external variables in the EJS application(Fig. 12a). In this page it is necessary to introduceinto the External File text field the path to theinformation M-file previously created for the levi-tator. Now, whenever you create an EJS variableand right-click on it, you will be given a windowwith a list of the MATLAB variables to which youcan connect your EJS variable (Fig. 12b). Byclicking on any of these variables, the connectionbetween the EJS variable and the MATLAB vari-able will be automatically established. Establishinga connection means exactly that: a) the value of theEJS variable will be pushed to the variable of themodel before running Simulink, and b) the EJS

variable will be given back whatever value theSimulink variable has after the model has runone integration step.Our Simulink model is now ready to be used. EJSwill run the Simulink model whenever we insert theJava sentence

external.step (1);

in a page of the evolution section (the main loop)of EJS (Fig. 13). A call to this method has thefollowing effects:

1. The value of every EJS variable that is con-nected to a MATLAB variable (except thosedeclared as OutputOnly) is pushed to theSimulink model.

(b)

(a)

Fig. 12. EJS page of variables showing the connection to MATLAB's variables.

Fig. 13. Evolution page of the EJS to control an external model running in MATLAB/Simulink.


2. The Simulink model is run exactly one integra-tion step.

3. The value of all MATLAB variables that areconnected to EJS variables (except thosedeclared as InputOnly) are retrieved fromthe Simulink model.

We can now operate EJS in the standard way inorder to build our desired view and to link it to thevariables of the model in a form that suits ourpedagogical needs. Fig. 14a shows the tree repre-sentation of the view elements that we chose forour view (see also Fig. 8). As an example, Fig. 14bdisplays the table of properties for the graphicalelement mass2, which allows users to resizemagnet 2 and change its mass. Fig. 14c showshow a Java method called ChangeMass2 islinked to the `̀ On Drag'' action of this graphicalobject. In this way, when the user drags the objectthe magnet will be resized and the Java method willbe invoked to compute the new value of themagnet mass according to its current dimensions.

Finally, it is worth noting that EJS is capable ofrunning more than one Simulink model fromwithin one single simulation. This is simply doneby creating two or more separate pages of vari-ables, each with a different M-file, and connectingEJS variables to the corresponding MATLABvariables. When the system runs, EJS will takecare of opening as many MATLAB sessions as areneeded and of managing all connections.

An advanced virtual lab: the quadruple-tankprocess

Our second example of an EJS/MATLAB appli-cation is the quadruple-tank process. Originallyintroduced by Johansson [12], it has receivedgreat attention because it presents interestingproperties in both control education and research.The quadruple-tank exhibits complex dynamics inan elegant way. Such dynamic characteristics

include interactions and a transmission zero loca-tion that can be tuned in operation. With adequatetuning, this system presents non-minimum-phasebehavior that arises due to the multivariablenature of the problem. For this reason, the quad-ruple-tank has been used to show the results ofdifferent control strategies and as an educationaltool in teaching advanced multivariable controltechniques. Although the setup is simple, theprocess can still illustrate interesting multivariablephenomena. The process flowsheet is displayed inFig. 15. The target is to control the levels h1 and h2in the lower two tanks with two pumps. Theprocess inputs are the voltages, v1 and v2, appliedto the pumps.

The differential equations representing the massbalances in this quadruple-tank process are:

dh1

dt�ÿ a1

s1�h1��2gjh1j

p� a3

s1�h1��2gjh3j

p� 1k1v1

s1�h1�dh2

dt�ÿ a2

s2�h2��2gjh2j

p� a4

s2�h2��2gjh4j

p� 2k2v2

s2�h2�dh3

dt�ÿ a3

s3�h3��2gjh3j

p� �1ÿ 2�k2v2

s3�h3� ÿ kd1d1

s3�h3�dh4

dt�ÿ a4

s4�h4��2gjh4j

p� �1ÿ 1�k1v1

s4�h4� ÿ kd2d2

s4�h4� �9�

Fig. 14. Elements for the view of the magnetic levitator.


where hi is the liquid level in tank i; ai is the outletcross-sectional area of tank i; si(hi) is the cross-sectional area of tank i; vj is the speed setting ofpump j, with the corresponding gain kj; j is theportion of the flow that goes into the upper tankfrom pump j; and d1 and d2 are flow disturbancesfrom tank 3 and tank 4 respectively, with corres-ponding gains kd1 and kd2. The process manipu-lated inputs are v1 and v2 (speed settings to thepumps) and the measured outputs are y1 and y2

(voltages from level measurement devices). Themeasured level signals are assumed to be propor-

tional to the true level; i.e., y1 � km1h1 and y2 �km2h2. The level sensors are calibrated so that km1�km2 � 1.

This process exhibits interacting multivariabledynamics, because each of the pumps affects bothof the outputs. The linearized model of the quad-ruple-tank process has a multivariable zero, whichcan be located in either the left or the right half-plane by simply adjusting the throttle valves 1 and 2. Johansson showed that the inverse response(non-minimum phase) occurs when 0 < 1+ 2 < 1and minimum phase for 1 < 1 + 2 � 2. The valve

Fig. 15. Schematic view of the quadruple-tank process.

Fig. 16. View of the quadruple-tank virtual lab.


settings will give the overall system entirely differ-ent behavior from a multivariable control view-point. Unmeasured disturbances can be applied bypumping water out of the top tanks and into thelower reservoir. This exposes students to distur-bances rejection as well as reference tracking.

Implementation of the quadruple-tank with EJSand MATLAB/Simulink

The main window of the EJS application for thisexample can be seen at the left-hand side of Fig.16. Schematically displayed in its upper part arethe four tanks and the set of dripping holes, pipes,pumps and valves that configure the system. Wetried to make this first image as self-explanatory aspossible. The black arrows indicate the set pointsof the lower tanks, those under control. These setpoints can be changed interactively by draggingthe arrows up and down. The lower part of themain window is occupied by primary controls thatlet the user specify how the system should run.With the left-hand column of buttons, the user canperform the following actions:

. Play, pause and reset the simulation.

. Select to run the nonlinear or linear models (orboth) for the system.

. Choose whether to control the system manually(M) or automatically (A).

. Select, in the case of automatic control, whetherto use a P or PI controller (this can easily beextended to other types of controllers).

A detailed explanation about the possibilities ofthis control application can be found at [13].However, in that work, the application was fullydeveloped using EJS. In this paper, the four-tankapplication presented simulates the nonlinear partof the model using a Simulink block diagram, andthe linear model and the view have beenprogrammed under EJS.

The process required to create such a hybridapplication is similar to the one used for themagnetic levitator example. For the first step ofthis process, we first had to implement thenonlinear differential equations corresponding tothe tanks (Equations 9) in a Simulink file (Fig. 17a

Fig. 17. Simulink subsystems of tank 1 and the PID controllers.

Fig. 18. Extract of the M-file fourtanks.m to connect Simulink and EJS.


shows the Simulink subsystem of tank 1). We alsocreated an M-function for the PID controller usedto control the tank levels and included this M-function in two Simulink blocks connected to thenonlinear models of tanks 1 and 2. Fig. 17b showsthe diagram of the Simulink subsystem used toimplement the manual and automatic controlsystem; the PID M-function is included in thePID1 and PID2 blocks, which are used to computethe control signals v1 and v2 (the voltages of thetwo pumps); two switch blocks, named Switch1and Switch2, allow us to select automatic ormanual control, depending on the value of aMATLAB variable, auto, that can be interac-tively changed using EJS view. In this way, whenthe user selects automatic control in the graphicalview, the values of the control signals v1 and v2are computed and the two PID blocks are selectedto drive the Simulink subsystems for tanks 1 and 2respectively; however, when the control is manual,the values of the variables v1 and v2 are setdirectly by the user and sent to the MATLABworkspace, from which the Simulink blocks, v1and v2, read and pass them to the subsystems fortanks 1 and 2 .

We also needed to adapt the block diagram forinteraction with EJS. The mechanism for this issimilar to that used for the magnetic levitatorexample and requires the introduction of enoughsource and sink blocks as needed to exchangeinformation between Simulink and MATLAB'sworkspace.

The second step of the process was to create theM-file to inform EJS about accessible MATLABvariables. Fig. 18 shows an extract of the text fileused for this example.

The third and final step was to open this filefrom EJS and to connect MATLAB variables withEJS variables. Fig. 19a shows how EJS variablesare connected to the MATLAB variables definedin this M-file.

Once all this was done, we could introduce asimple sentence in the form ``_external.-step(1);'' in one of EJS's evolution pages toinstruct Simulink to run the block diagram once.This way, at every evolution step of EJS, the two

models (the linear and the nonlinear) advance in asynchronized way, generating the state of thesystem. Note that both models share the sameuser interface: the nonlinear model developed inSimulink, and the linear model written using thefeatures of EJS to define and solve differentialequations. The use of different models within thesame application is completely transparent to theuser. EJS generates the necessary Java code toexchange the information between MATLABand EJS variables.

CONCLUSION

Using computer simulations in an instructionalcontext usually implies using computers to buildmodels of real-world phenomena in order to helpstudents grasp the fundamentals of the behavior ofcomplex systems. Interacting with an instructionalsimulation can enable learners to gain better en-gineering understanding of a real system, processor phenomenon through exploring, testing hypoth-eses, and discovering explanations for the mechan-isms and processes. Furthermore, students have anexcellent opportunity to `̀ experiment'' with theirown ideas in terms of engineering design by simpleinteraction with the tool. Not only can interactivevirtual labs be effective in presenting engineeringconcepts in the classroom, they also can be bene-ficial in extending students' experience in analysisand design assignments. This invitation to creativ-ity can be most useful when it comes to specializedcontrol engineering student projects.

In this context, many control educators wouldbe more willing to use interactive simulations intheir lectures and labs if they had a set of tools thatwould facilitate their development. An obviousway to achieve this is to select one of the well-known software packages in the control engineer-ing field, such as MATLAB/Simulink, and toprovide a tool that would wrap models with thenecessary layers of interactivity without demand-ing a deep knowledge of computer programming.From the point of view of MATLAB's users, thebenefits of this approximation is twofold: it lets

Fig. 19 (a). Variable page illustrating the link between some EJS and MATLAB variables. (b) Evolution page showing the EJSinstruction to order Simulink runs one step of simulation.


them reuse all the MATLAB legacy code and alsotakes advantage of their experience in the use ofthis de facto standard.

This paper shows two examples of the type ofcontrol applications that have been created usingEasy Java Simulations, a software tool that helpscreate, in a very easy way, dynamic and interactivescientific simulations in the Java language. In theview of the two final developments, it is clear thatEJS takes a step forward in the use of interactivityand MATLAB in an instructional environment. Amore detailed explanation of the development ofEJS applications using MATLAB/Simulink can be

found in the EJS documentation. The softwarepackage and the examples shown in this paperare available for free at http://fem.um.es/EJS.

Finally, we would like to emphasize that underno circumstances should instructors forget thattheir ultimate goal is to arouse students' curiosityto discover, question, and wonder. Interactivity isone of the inherent ways for human beings toperform this.

AcknowledgementsÐThis work has been supported by theSpanish CICYT under grant DPI2001-1012 and DPI2004-01804.

REFERENCES

1. S. Dormido, The role of interactivity in control learning (Plenary Lecture), IFAC Symposium onAdvances Control Education ACE'03, Oulu, Finland, June 2003.

2. S. Dormido, Control learning: Present and future, Annual Reviews in Control, 28 (2004), pp. 115±136.

3. Y. Piguet, SysQuake: User Manual, Calerga (1999).4. E. Esquembre, Easy Java Simulations: A software tool to create scientific simulations in Java,

Comp. Phys. Comm. (2002). See also http://fem.um.es/Ejs.5. S. Dormido, J. Aranda, J. M. DõÂaz and S. Dormido-Canto, Interactive educational environment

for design by QFT methodology, Proceedings of 5th International Symposium on QuantitativeFeedback Theory and Robust Frequency Domain Methods, pp. 223±230, Pamplona (August 2001).

6. S. Dormido, F. Gordillo, S. Dormido-Canto and J. Aracil, An interactive tool for introductorynonlinear control systems education, IFAC World Congress b `02, Barcelona, July 2002.

7. P. Albertos, J. Salt, S. Dormido and A. Cuenca, An interactive simulation tool for the study ofmultirate sampled data systems, IFAC Symposium on Advances Control Education ACE `03,Oulu, Finland, June 2003.

8. S. Dormido, M. Berenguel, S. Dormido-Canto and F. RodrõÂguez, Interactive learning ofintroductory constrained generalized predictive control, IFAC Symposium on Advances ControlEducation ACE `03, Oulu, Finland, June 2003.

9. N. Tan, D. Atherton and S. Dormido, Systems with variable parameters: Classical controlextensions for undergraduates, IFAC Symposium on Advances Control Education ACE `03,Oulu, Finland, June 2003.

10. W. Christian, The open source physics project (http://www.opensourcephysics.org).11. ECP Educational Control Products, Magnetic Levitation System, manual for model 730 (1999).12. K. H. Johansson, The quadruple-tank process: A multivariable laboratory process with an

adjustable zero, IEEE Trans. on Control Systems Technology, 8(3) (2000), pp. 456±465.13. S. Dormido and F. Esquembre, The Quadruple-Tank Process: An Interactive Tool for Control

Education, Proceedings of the European Control Conference, Cambridge, UK (2003).

JoseÂ SaÂnchez received his Computer Sciences degree from Madrid Polytechnic University in1994 and his Ph.D. from UNED in 2001. Since 1993, he has been working at UNED'sDepartment of Computer Sciences and Automatic Control as an Associate Professor.

Francisco Esquembre was born in Alicante (1963) and received a Ph.D. in Mathematics inJune 1991 from the University of Murcia, Spain, where he has worked since 1986, holding apermanent job as an Associate Professor from 1994.

SebastiaÂn Dormido received his Physics degree from Madrid Complutense University (1968)and his Ph.D. from Country Vasque University (1971). In 1981, he was appointed Professorof Control Engineering at UNED. He has supervised 25 Ph.D. theses and co-authoredmore than 150 conference papers and 100 journal papers. Since 2002 he has been Presidentof the Spanish Association of Automatic Control, CEA-IFAC. His scientific activityincludes various subjects in the control engineering field: computer control of industrialprocesses, model-based predictive control, robust control, modeling and simulation ofhybrid systems and control education with special emphasis on remotes and virtual labs.


Carla Martin received her M.Sc. in Electrical Engineering in 2001 from UniversityComplutense of Madrid. She is currently completing her doctorate studies at UNED,Spain.

S. Dormido-Canto received his M.Sc. in Electronic Engineering in 1994 from the ICAI andhis Ph.D. in 2001 from UNED. Since 1994, he has been working at UNED's Department ofComputer Sciences and Automatic Control as an Assistant Professor.

R. D. Dormido received her M.Sc. in Physics in 1994 from University Complutense ofMadrid and her Ph.D. in 2001 from UNED. Since 1994, she has been working at UNED'sDepartment of Computer Sciences and Automatic Control as an Assistant Professor.

R. Pastor received his M.Sc. in Physics in 1994 from University Complutense of Madrid. Heis currently completing his doctorate studies at UNED, Spain.

A. UrquõÂa received his M.Sc. in Physics in 1992 from University Complutense of Madridand his Ph.D. in 2000 from UNED. Currently he is working as an associate professor atUNED, Spain.


easy java simulations an open source

Documents