Search

Power resources on board autonomous systems are limited but power requirements on these systems are increasing due to rapid technology growth. Today's methods for controlling these resources either use expensive and conservative strategies (e.g. reactive control), or employ pre-defined power schedules that heighten the risk of operation failure in a dynamic environment. An intelligent Power Management System (PMS) is required to improve, or maintain, system capability. The strategies proposed in this paper aim to contribute towards an intelligent PMS. Using optimization methods, an adaptive and flexible PMS, capable of constructing the best executable power schedules while satisfying real-time requirements, is presented. A three-level optimization strategy is introduced. Due to the feasibility requirement of the solutions produced, the first level uses a constraint satisfaction approach. Then, the solution is quickly improved using a local search algorithm and, next, a global search algorithm is used in the remaining execution time to explore the possibility of further improvement in the solution. The efficiency of the last two levels is enhanced by use of convex programming techniques. Using a case study, we demonstrate that the proposed PMS is capable of rapidly producing a feasible solution, and subsequently optimizing this solution to provide an improved solution. The proposed PMS is capable of adapting to a dynamic environment, by coping with any change in problem description and problem constraints, and constructing a new best executable solution, while satisfying realtime requirements.

Dealing with practical applications of digital control, the assumption of regular and uniform sampling pattern is questionable. Sometimes a non-uniform sampling scheme leads to beneficial results as better performance or energy saving among others. However in these cases the theoretical analysis of the controlled system performances is much more computationally involved. In this contribution an interactive simulation tool to deal with multirate systems (MR) is presented. It allows an easy understanding of the performance degrading or improvement when changing the sampling pattern parameters. The tool was developed using Sysquake, a Matlab-like language with fast execution and powerful graphic facilities. It can be delivered as an executable.

Interactive tools have been established as an excellent complement to control education, helping students in learning complex concepts. A wide variety of different interactive tools have been created using environments as Easy Java Simulations and Sysquake. These tool are very powerful but they are limited to be used in any type of devices, since they require executable files or virtual machines. This paper presents a new framework to develop interactive tools for control education. The interactive tools are developed only with ECMA and W3C standards, what allows them to be used in any device containing a web browser that meets these standards. Implementation issues and some examples are shown.

In this paper we present our work and results in the framework of obstacle avoiding for marine vehicle teams by means of trajectory planning. Based on a team of maritime systems, such as Autonomous Underwater Vehicles (AUVs) or Autonomous Surface Vehicles (ASVs), which are intended to perform a preplanned mission in a given formation topology, methods for trajectory planning are investigated which guarantee for both obstacle-free paths and formation preservation. The proposed solution contains advanced graph search and trajectory smoothing to generate executable path for the vehicles.

Model Driven Engineering (MDE) is now becoming the new paradigm for application development. The objective of this approach is to create applications from a set of conceptual models, and especially from a collection of models. In this context, a method of semi-automatic generation of interactive personalized multiplatform applications, based on MDE, has been developed. This transport-oriented method is called PERCOMOM (PERsonalisation and COnceptual MOdeling Method) and it relies on models that use all particular formalisms which lean in most cases on graphical design. This paper present the conception and the development of the graphical tools that allows creating and manipulating two types of PERCOMOM's models: the models of business process based on BPMN and the interaction static models. Finally, through this tool, we should be able to migrate from BPMN to BPEL in order to produce an executable code.

Many large-scale multi-agent missions consist of a sequence of subtasks, each of which can be accomplished separately by having agents execute appropriate decentralized controllers. However, many decentralized controllers have network topological prerequisites that must be satisfied in order to achieve the desired effect on a system. Therefore, one cannot always hope to accomplish the original mission by having agents naively switch through executing the controllers for each subtask. This paper extends the Graph Process Specification (GPS) framework, which was presented in previous work as a way to script decentralized control sequences for agents, while ensuring that network topological requirements are satisfied when each controller in the sequence is executed. Atoms, the fundamental building blocks in GPS, each explicitly state a network topological transition. Moreover, they specify the means to make that transition occur by providing a multi-agent controller, as well as a way to locally detect the transition. Scripting a control sequence in GPS therefore reduces to selecting a sequence of atoms from a library to satisfy network topological requirements, and specifying interrupt conditions for switching. As an example of how to construct an atom library, the optimal decentralization algorithm is used to generate atoms for agents to track desired multi-agent motions with when the network topology is static. The paper concludes with a simulation of agents performing a drumline-inspired dance using decentralized controllers generated by optimal decentralization and scripted using GPS.

The paper describes the conceptual basis and functionality of ITSIE , an Interactive Tool for System Identification Education. The tool is developed using Sysquake, a Matlab-like language with fast execution and excellent facilities for interactive graphics, and is delivered as a stand-alone executable that is readily accessible to students and users. The tool focuses on the open-loop identification of a SISO fifth-order system subject to multiple noise sources using classical prediction-error methods. The various stages of system identification, ranging from input signal design using PRBS and multisine signals through model validation are evaluated simultaneously and interactively in one screen. The highly visual and strongly coupled nature of system identification is very amenable to interactive tools, and the tool presented in this paper enables students to discover a myriad of important identification topics with a much lower learning curve than existing methods. Plans for additional tools in the series are discussed.

The model-driven approach to software development has been increasingly applied to manage the growing complexity in modern manufacturing systems. With this approach, a model of a system is first created at a high-level of abstraction. The model is then converted into an executable program by means of automatic code generation tools. Models can be simulated and visualized throughout the entire design flow of the system, thereby increasing confidence of the design's correctness and its adherence to user requirements. Moreover, since the design is specified at a higher level of abstraction, the description itself is easier to understand, and consequently, less prone to errors. However, automated code generation from high-level models have typically been inefficient compared to hand-crafted code. In this paper, we demonstrate an approach for generating efficient code for systems modelled using IEC 61499 function blocks. We have also developed a tool chain that allows complex material handling systems to be modelled, visualized, and synthesized in a seamless fashion. Experimental evaluations show that our approach produces significantly faster and smaller code compared to an existing tool.

This paper presents a new approach for the implementation of task-based supervisory controllers. Based on a general framework allowing the reduction of controller models, the presented methodology provides an efficient implementation of discrete-event controllers on Programmable Logic Controllers. Considering the bottlenecks of the platform, propositions are made for the reduction of resource need of the generated code by modularity and hierarchy as well as for ensuring determinism. Presented methods can be directly used for automated generation of executable code for controller devices. Results are illustrated on a simple example.

This paper describes a novel simple model based predictive controller with manipulated value constraints. This controller is suitable for substitution of the classical PID controller used in industrial practice. It is assumed that the controlled system is stable, linear and t-invariant FIR system. The discrete step response sequence is used as the process model. Alternatively it is possible to use three-parameter model. To make the open-loop optimization easier the set of admissible control sequences is restricted to stepwise pulse-step sequences. The optimization procedure is then executable in reasonable time. A single tuning parameter is available for manual fine-tuning of the controller - the control moves penalty coefficient.

An implementation of the disjunctive datafiow execution model for distributed control applications is presented. In this model, a control application is divided into independently executable function blocks. To achieve shorter response times, each function block is only executed when there is a significant change in any of its input data valum. To this end, an implementation hased on a field programmahle gate array (FPGA) was designed. Based on the requirements of a specific control application, VHDL code expressing the necessary firmware support is generated, compiled, and loaded into the FPGA before execution.

This paper deals with multi-criterion planning problem. Beside traditional constraints, we assume that tasks can migrate between resources and they are executable by many methods with different results. The random start & forward search algorithm is proposed to solve the mentioned problem, in condition, the time for solving is limited.

Virtual-laboratories (virtual-labs, in short) provide a flexible and user-friendly method useful for defining the experiments to be performed on a mathematical model. Virtual-lab users are allowed to design and perform their own simulation experiments. As a result, they become active players in their own learning process, which motivates them to further learning. Virtual-labs can be used to explain basic concepts, to provide new perspectives of a problem, and to illustrate analysis and design topics.

We demonstrate the utility of discrete controller synthesis to formally assess the fault-tolerance capabilities of a dependable system from the early design stages. We start with an executable specification in order to yield a new fault-tolerant executable specification. Then, we obtain manually the final distributed implementation and we formally verify its conformity to the initial fault-tolerant specification.

This paper presents an object-oriented software framework created with the aim of modeling and simulating distributed applications based on the CAN protocol. The created infrastructure consists of a modular simulator that allows describing all the system components, namely the interconnection bus and the distributed nodes. The object-oriented programming paradigm is used to simplify the modular implementation of the several protocol layers. The simulator was written in C++ and can be used as an executable specification to assist in the hardware implementation of a CAN controller.

This paper presents a validation approach for real-time applications using simulation techniques. Simulation concerns the operational architecture and takes into account the executable code of real-time tasks and the execution support model: set of processors, network and basic software (real-time executive and communication system). We show in this paper the performances that can be reached for the analysis of the temporal behaviour of real-time programs in a distributed system.

This paper presents a Rapid Controller Prototyping System based on Matlab, Simulink and the Real-Time-Workshop toolbox. Executable code is automatically generated for Linux RTAI, a hard real-time extension of the Linux Operating System. The generated code runs as a normal user space hard real-time application on a standard personal computer with the RTAI extension of the Linux Operating System. This environment can be used to quickly implement real-time controllers. Moreover, standard hardware allows the use of rapid prototyping techniques not only during development activities but also during system operation. A didactic and an industrial application are presented which demonstrate the capabilities and the performance of the environment.

This paper presents a systems-theoretic approach to profile, model, and control malicious executables in computer software. By treating the structural profile of malicious codes as a generator of formal languages, the language recognizer serves as a supervisory controller in the sense that the spread of malicious executables is arrested with the goal of making the virus ineffective. The theoretical foundation and the approach presented in this paper are applicable to a wide class of malicious executables. The controller can be designed as a separate program or as a background process to run on individual machines to monitor other processes. Simulation experiments on supervisory control of a file virus are presented as examples.

This contribution deals with an embedded distributed systems rapid prototyping method that employs hardware prototyping components and an executable specification language. Statements of such a language cover process management, timing and communication commands that are interpreted using the services of a real-time executive and a communication task located in each node prototype. The language is made executable by a technique that employs attribute grammars and either macroprocessor or Prolog-supported generation of software prototypes. Execution or interpretation of the expanded code embedded in reusable system components of the trial architecture provides final step ofthe method.

In the hierarchical control of discrete event systems (DES), the hierarchical consistency expresses the requirement that a control task is solvable within the model at a given level if it is in fact executable by the infrastructure one level down. In this paper we present a method for construction of a two level hierarchy of DES with hierarchical consistency. By application of a generalized model for controlled DES for the high level system, hierarchical consistency is obtained directly with no refinement of the hierarchy. This approach makes itself distinct from other approaches for hierarchical control for that they all add complexity by refining the the hierarchy to ensure hierarchical consistency.

The process of showing that a program satisfies some particular properties with respect to its specification is called program verification. Axiomatic semantics is a verification method that makes assertions describing properties about the states of a program. There exists a transformation from the assertions of a program's verification proof to executable assertions. The latter may be embedded in the program to make it fault tolerant. An axiomatic proof system for concurrent programs is applied to generate executable assertions in a real time distributed environment. A train set example is used as model problem.

The authors motivate and illustrate an approach for domain-specific specification languages in the field of small local railway or tramway control systems. Adopting terms and concepts from the application domain, such languages are the ideal means of communication between users, system engineers and control computer specialists. Semantic rigour is provided by a transformation of the domain-specific representation into wide-spectrum formal specification languages. These transformations offer the possibilities of formal verification and testing against formal specifications, as well as automatic generation of executable programs from specifications. The construction of the transformation can be substantially simplified if the class of control systems is formalised in a generic way using design patterns and frameworks.

This paper presents a prototyping methodology for the development in Ada 95 of distributed applications with hard real-time requirements. Based upon an architecture-independent description of the system's elementary actions and their exchange of events, and given the system's configuration, real-time analysis of the distributed application can be performed. In addition, using the same system description an executable prototype of the application is created, which enables testing its timing behavior, and, if the actual code for the elementary actions is provided, automatically generating the final code of the application.

A MATLAB-based rapid controller prototyping and development system for on-line tuning is presented. This is capable of automatically generating executable code for a digital signal processor from a Simulink specification of a controller and also has a real-time parameter adjustment and data logging facility. An optimisation problem can therefore be formulated in MATLAB with the controller parameters as decision variables and direct measures of the controller's performance as optimisation objectives. A multiobjective genetic algorithm is used as an optimisation engine to perform on-line tuning for the controller of an active magnetic bearing system. The optimisation objective function is based on on-line H∞ and H2, measures of controller performance.

In this paper a new method for the development of distributed safety-critical real-time systems is presented. The method is based on the synchronous approach for designing reactive systems and a time-triggered communication architecture. Synchronous software components consisting of a reactive and a transformational part are used to specify the behavior of the system. The reactive part of a synchronous component is specified in the synchronous language ESTEREL. In the design model, hardware and software components are composed graphically on a high level of abstraction. From the graphical design specification executable code can be generated automatically. Due to the synchronous execution model, the code is deterministic and can also be simulated and verified.

The OBSERV methodology for software development is based on rapid construction of an executable specification, or prototype, of a system. The specification may be examined and modified repeatedly to achieve the desired functionality. The objectives of OBSERV also include facilitating a smooth transition to a target system, and providing means for reusing specification, design, and coding of systems and subsystems. This article describes OBSERV, and demonstrates how the methods used in our approach can be used to develop provably correct real-time reactive systems. Correctness is checked by means of simulation and formally proved with a model checker.

The Unified Modeling Language (UML) has been proposed as an extensible general-purpose standard for modeling of object-oriented applications. In this paper, we describe a specialization of UML for the domain of highly-dependable distributed realtime systems. This specialization, which is defined using the built-in extensibility mechanisms of UML, is based on a combination of the ISO/ITU Reference Model for Open Distributed Processing and the architectural modeling capabilities of the ROOM language. A notable feature of this extension is that it has formal semantics allowing the construction of executable models as well as complete code generation from the models.

A possibility of use of the Estelle language for computer executable SME related enterprise models is considered. An example of such a model, developed for creamery, with main focus on water and sewage management is presented. The model can be used for support of the factory supervisor for operational decisions, and for rationalisation of water and sewage management - it means adjusting it to occurring water shortage by choice of some„investment option”.

This paper describes an implementation procedure of distributed control software for robot-based manufacturing systems. Robots and other devices such as conveyors and manufacturing machines are defined as object-oriented communicating sequential processes. A modular and hierarchical approach is adopted to define a set of Petri net type diagrams, which represent concurrent control processes for such devices, and asynchronous and synchronous interactions in global process interaction nets. Operational specifications are directly transformed to executable codes in a parallel programming language, such as occam. Implementations of control software on a multiprocessing environment and transputer networks are comparatively evaluated.

The paper presents a framework for modelbased synthesis of discrete controllers and automatic generation of control code. We use a special representation of Condition/Event systems for design of models of the uncontrolled behaviour of the plant. Formal controller synthesis is performed for specification in terms of forbidden states and desired sequences. The synthesized controller is automatically transformed into a language following the IEC 1131 and is executable.

Structured analysis and object oriented approaches to information system requirements analysis and design are discussed. It is argued that the design of an information architecture is an essential step in an uncertain environment, when the rates of external and internal change and the rate of technological change are high. Executable models based on Colored Petri Nets enhance the object oriented approach for use in systems engineering.

This paper presents recent results from an on-going research programme which is considering the use of parallel processing platforms as the basis for real time simulation and control problems. The emphasis is on the development of generic tools whose natural domain of operation is complex systems, i.e. cases where the performance limitations imposed by sequential computing platforms mean that existing tools cannot be effectively employed. Here the major development reported is a backend accelerator which takes output from standard sequential processing based environments and automatically generates executable parallel code without user intervention.

A motion control development system (MCDS) has been developed at the University of Natal to allow control algorithms to be entered in block diagram form, which are then transformed to executable code. The intention is to allow the design engineer to produce real-time software that will run on the controller hardware with minimal use of programming. This paper briefly describes the software components of the MCDS. Test code for a current source inverter (CSI) fed squirrel cage induction motor (SCIM) was implemented using the software tools of the MCDS. This paper demonstrates the correct operation of the MCDS by comparing simulated and measured results for the SCIM under field oriented control (FOC) coded by hand, and the results obtained by the code automatically generated using the MCDS.

In most cases, Digital Signal Processing (DSP) algorithms are nowadays implemented using the classical way, that can be denoted as a low-level implementation. With this technique, mathematical equations are directly rewritten into a source code and then compiled into an executable. This approach however requires good knowledge of the signal processor and programming itself. This disadvantages can be overcome using another method called the high-level implementation, which uses for executable generation the Matlab and its capability of executable generation from Simulink models. A simulink model is converted by Real-Time Workshop into an executable file for a signal processor.

The software part of embedded real-time systems is constantly increasing in size and complexity. Therefore, for a company to stay competitive in a strong market, techniques for management of such risks as misunderstanding of customer needs, schedule or budget overrun, quality pitfalls, or in the worst case cancelled projects, are required. The spiral model guides a developer to postpone detailed elaboration of low-risk software elements until the essential high-risk elements of the design are stabilised. The spiral model incorporates prototyping as a risk reduction option at any stage of development. This means supporting executable system models where different parts are represented at different levels of abstractions called (distributed) heterogeneous prototypes. Source code is integrated into the system models through a run-time adaptation technology which is explained in this paper.

A technique to achieve real-time computing throughput from rule-based expert systems is discussed. Using compilation, compaction, and parallelization techniques, this research synthesizes a set of concurrently executable Ada tasks from a knowledge’ base of rules. A prototype compilation system based on this approach has demonstrated speedups in excess of 100X along with increased embeddability of the knowledge base. The work is being extended into a software engineering development environment for expert systems whereby programming constructs from both the procedural and rule-based language domains are made available to the user. The approach strives to present the engineer with programming templates that protect him from the intricate control mechanisms of the inference engine and to enable him to concentrate on problem solving at higher levels of abstraction.

We document the application of formal methods to the specification and verification of the type of process control typically used in safety critical systems. We discuss the use of an executable subset of the formal specification language OBJ to model and verify systems utilising Programmable Logic Controllers (PLCs) prior to hardware implementation. We specify a stand alone PLC. a common instruction sub-set, and a complete “test engine” combining all the main elements of a PLC, ie. I/O/program scan-I-Program + IO-History. The method integrates with existing techniques for the development of PLC programs which we specify by an abstract data type which models ladder logic. Examples are presented to demonstrate the practicality of the approach and the benefits to be gained from testing such systems in software. The role of such techniques in an industrial safety critical context are discussed, both from the point of view of systems implementation and maintenance. In conclusion we outline current work focusing on hand held tool support, additional formal verification methods, and the application of the technique to systems development within safety standards.

An architecture for incremental prototyping of real-time distributed systems is described in the paper. The final goal is to support incremental development of embedded, distributed systems using the spiral model of software development. The architecture consists of a set of layers with well defined interfaces between them. The three main layers provide support for a specification language based on SA/RT, an internal representation of prototypes based on high-level timed Petri nets, and for distributed execution of prototypes. Executable code can be gradually substituted for parts of the SA/RT model during the development process.

Surface inspection technology for flat steel products is considered in this paper. Rautaruukki New Technology has developed its own machine vision inspection technology which is based on line scan imaging, very fast image processing facilities and sophisticated knowledge-based classification algorithms for surface defects. Automated tools which utilize expert systems and graphical user-interfaces, are added to the system to assist the development of new machine vision applications. Expert systems are applied in the knowledge extraction and in the implementation of defect classifiers. The domain-specific classification rules can be modified by an expert system which is capable of providing a complete decision tree classifier with executable source code. Graphical visualisation of the classification scheme is made possible. Real defect images are used as the input data for this system. The resulting classifier software can be transferred into the real surface inspection system for application testing. Experience of these tools, as well as of the first implementation of the inspection system in the pickling line of Rautaruukki's Hameenlinna thin sheet mills, is discussed. This system, called Smartvis , is now being commercialized. At the end, an optional classification method utilizing neural networks, is considered in the case of detecting periodical defects like roll marks. The expert system (ES) tools including neural nets have been tested in laboratory environment.

A heterogeneous prototype is an executable system model whose different parts may present different levels of abstraction (modeling levels), and yet they can be executed together as a total system. We present the basic ideas how heterogeneous prototypes along with concurrent engineering can be used to address the future requirements of the software engineering process: overcoming increasing complexity and development risks and supporting flexible just-on-time product development. A prototyping environment that supports the execution of heterogeneous prototypes of real-time embedded systems is also discussed.

It is widely accepted that prototyping is a powerful technique to carry out early fault detection. Main features of prototyping are: feasibility check against project constraints; check of the designer’s interpretation against user requirements; verification of the user requirements against his/her real needs. In spite of these advantages prototyping is not widely used because of some weakness of the current prototyping tools: weak connections with the system high level model; lack of connections with the target system code generator. This paper describes a software development environment, called DEEnv (Design Enhanced Environment), giving a partial answer to these two problems and carrying prototyping approach towards fault avoidance. DEEnv is an environment which automatically produce the prototype as a consequence of the high level design. This prototype can be used to refine, using an iterative and incremental method, the high level design minimizing in such a way possible design faults. The designer interacts with DEEnv using graphic tools whereas the code which describe the system model is generated; the system model is wholly described by an executable modelling language (GALILEO).The paper presents the main advantages and problems of the prototyping techniques. Then it analyzes the architecture of DEEnv and its impact on global quality of the software project.

An approach to efficient implementation of real time control systems is presented. A compiler for translation of control algorithms is used in combination with a general program for real time control. The compiler translates control algorithms, written in a design language, to an implementation language, and generates code for connecting the control algorithms to the user interface. The translated algorithms are then automatically incorporated in the real time control program. The resulting executable program have a number of interactive facilities such as interconnection of controllers, plotting and textual display of all variables, and data logging. The design language is chosen as Simnon, a language for simulation of nonlinear systems, and the implementation language is chosen as Modula-2. The system has been used in research and education, and has reduced the implementation time considerably, e.g. when developing new laboratory exercises, or when a control algorithm is tested in a laboratory experiment

In this paper we formulate the problem of determining constraints in the parameter space used for planning reference trajectories for tracking systems. The objective is to obtain parameter constraints which allow a maximal amount of maneuverability while assuring that operatmg limits will not be violated and that the system can execute the prescribed reference trajectory within a given error tolerance. We present a numerical algorithm for generating the parameter constrants based on previously computed constraints in the space of the continuous-time trajectory and its derivatives. A simplicial approximation method is used to generate a polyhedral approximation to a maximal set of parameters corresponding to executable trajectories. Supervisory planning and control can then be carried out in the reference trajectory parameter space without detailed simulation of the underlying system dynamics. We illustrate the computational algorithm and its application to trajectory planning for a two-axis CNC cutting tool.

In recent years the functional possibilities and in this way, the range of information processing of process control systems have increased by ten folds due to the use of distributed microprocessor systems. But the information processing capacity of the operator has remained the same as before. To avoid information owerflow of the operator we must carefully plan his work. This concept should be designed in the early stages of an automation project as it concerns the narrowest functional potential. To be able to do this methods have to be at hand for requirement specification of man-machine tasks and symbols to illustrate these functions in technological schemes and so on. Both of them are needed as a basis for calculating the total information load of the operator (sum of all control channels of the whole plant) and for ensuring the performance capability of each single task (channel). To prove the requirements of human operation a CAD module is described. It considers the capability of an operator to carry out the specified tasks. This module compares the required time constants of each function to be carried out with those of a trained operator. If this calculation leads to the result that the time constant relations required are beyond human possibilities an alarm signal will be given. The next step is to sum up all parameters of required human activity to ensure that the balance is within the executable range. If this condition is not true another alarm signal will occur. Thus all functions concentrated on the operator's desk are to be controlled. Main items of human operation are to act as a redundancy in case of instrument failure. For this problem the CAD module uses probability information about the reliability of instruments and the consideration of degradation of a system by partial failure.

In this paper, we describe a software system which generates synthetic workloads for use in the performance evaluation of distributed real-time computer systems. The software system consists of a high-level description language and its compiler. The language provides a flexible, easy-to-use description of the structure and behavior of the real-time workload. The compiler, called a synthetic workload generator (SWG), uses this description to produce an executable synthetic workload (SW). The SW may then be used to drive the system under evaluation while measurements are being made.

Extended Abstract This contribution presents the internet based control engineering educational system used in Czech Technical University in Prague. The system consists of three basic parts. The first one is the internet textbook that makes it possible to explain new knowledge to the user in very friendly and comprehensive manner. Many figures, hyperlinks and both theoretical and practical examples from different areas (mechanics, electrical engineering, hydraulics, thermodynamics) improve readability of the textbook. Especially the hyperlinks enable understanding the subject in more general and wide context. The aim of the textbook is to introduce the backgrounds of modeling and control of dynamic systems for students in bachelor program. Since in control engineering there are many associations and mutual relations the system of hyperlinks is very suitable to explain them. Many files can be downloaded including executable in Matlab to demonstrate the theoretical knowledge by experimental simulations. The students can change parameters or other conditions of the simulated system and thereby take a part in the learning process in an active manner. The second part of the system is represented by the Matlab web server (MWS) which allows running all the examples and applications in the textbook from any point in the internet network. Program package Matlab contains a lot of procedures and routines used in control engineering. Moreover a simple program language included in this environment enables compiling and running new algorithms and applications created by the user. In internet network configuration the user sends his data to the server in HTML form and the server runs the application and returns results as HTML page (including figures). Thanks to the connection of the textbook with MWS anybody can validate the theoretical results on a practical application. The main advantage of MWS is the possibility of executing control experiments on models of real plants located in laboratory for automatic control. At present highly nonlinear and unstable model of levitation of a pot in air stream is available for remote control. The input to the model is voltage of a ventilator which is placed at the bottom of the tube which top end is opened. The air stream produced by the ventilator elevates a cup. The vertical position of the cup measured by a laser sensor represents the output variable. The model is controlled by Allen-Bradley PLC-5 which can use both PID and logical controller. A PC is also connected to store data from the automata and to visualize data using web pages. This computer is also equipped by Matlab environment and Real Time toolbox to be able to implement more sophisticated control algorithms. The data are transferred to MySQL database which is used by PHP program for Apache web server. All the data and the current status of the model are refreshed and displayed every 500ms. Whole model is scanned by a web camera. The reservation system is available to make it possible to access the model by more students. The students can create their own procedures or they can download the applications prepared by the teacher. The third main part of the system is an e-learning module that makes it possible to create, execute and check the results of an electronic test. This is very important for the students and all who want to check understanding of the knowledge acquired from the textbook. Different kinds of answers are possible: a number (the tolerance interval can be specified), a lis of terms, yes/no answer and arbitrary string of characters. Every answer is recorded so that the user can stop and continue the test after. Student identification data is loaded from the information system. All three parts connected each other create a complete educational tool for knowledge gaining, its validation on both theoretical and practical examples and applications and testing its understanding. Very important part of the presented system is a user friendly environment for those who want to add new pages or chapters into internet textbook or make some corrections there. This tool is again available via web interface. The most used component of the publishing tool is a WYSIWYG (what you see is what you get) editor of HTML pages. Apart from writing a text it allows text and heading highlighting, creating a numbered or unnumbered list or inserting figures or hyperlinks using a simple menu system. The created HTML pages are thereafter checked and corrected according to the HTML standard. Any internet based educational tool has to be equipped by an administration system that ensures distributing the access rights to different parts of the textbook according to a type of the user. The system uses the modern program tools as the PHP language for generating the textbook code, MySQL for user administration and all database operations (e.g. electronic test evaluation and its result storing) or system CSS2 for graphical appearance arrangement. The whole system is created as a support for basic education in control engineering but its principles can be used in any other educational area. The whole textbook has been originally made in Czech language ( http://dce.felk.cvut.cz/sari ) and it has been translated into English.

This paper describes a development system for embedded real-time control, Descartes, which allows control algorithms to be entered in block diagram form which are then transformed to Ada95 executable code. The intention is to allow the design engineer to produce real-time software that will run on the controller hardware with minimal use of programming, which will be portable over the platforms on which Ada95 is supported, which has predictable real-time behaviour and which permits configuration on distributed platforms.

This paper describes the development of an inexpensive interactive load flow system utilizing an existing load flow program. The system was Installed on a computer network which supports a time sharing option (TSO). Minor modifications were made to the Philadelphia Electric Company Power flow program to enable interactive operation Including a convergence record display On a cathode ray tube (CRT) screen during program execution. Routines composed of executable sequences of TSO commands were developed to enable a user to exercise control over program Initiations, executions, cancellations, modifications, and the editing of results. The user can then create, modify, and delete data sets by easy interaction with the CRT. These capabilities, combined with the ease of operation, and the economical implementation make this system quite attractive and practicable for many existing computer systems with remote terminal capability. This system can quickly provide electric utility system planning engineers with load flow solutions with significant cost savings due to more efficient utilization of engineering time.

The π-paradigm of system development is described. Central to this paradigm is the notation of a Concurrently Executable Module, or CEM. A runnable system developed within the π-paradigm consists of a number of CEMs, each of which has an underlying abstract data type and each of which is potentially a unit of concurrency within the runnable system. The paradigm is illustrated by an example, the development of a distributed implementation of a simple text processing system.

This work presents concepts and techniques developed for real-time control of an industrial manufacturing system. One of the main industrial requirements was to acheive a high degree of safeness at low cost. The overall architecture of the system is developed to provide reasonable protection against failures. It is centered around a triple schema: 1) Use of off-line testing techniques of the computer support (as a background task); 2) Use of an abstract copy of the application software acting as a generalized watch-dog, the spy ; and 3) Use of special error detecting/correcting codes for essential information concerning the state of the system, plus executable assertions concerning the critical procedures. In this paper we introduce the ideas and techniques that define the spy. Because the kind of system to be controlled is highly concurrent, Petri nets were adopted as the formal tool to describe concurrency. Their graphical representation plus their extensive validation theory will help the designer in the phases previous to software implementation.