Discrete-Time Control System Implementation Techniques - Read Online

Book Preview

Discrete-Time Control System Implementation Techniques

You've reached the end of this preview. Sign up to read more!
Page 1 of 1

Discrete-Time Control System Implementation Techniques

First Edition

C.T. Leondes

School of Engineering and Applied Science, University of California, Los Angeles, Los Angeles, California


San Diego  New York  Boston

London  Sydney  Tokyo  Toronto

Table of Contents

Cover image

Title page

Copyright page



Workbench Techniques in the Design of Digital Control Systems








Recursive Techniques in State-Space and Matrix Fraction Realizations for Linear Systems







Bounding Techniques for Robust Stability of Time-Variant Discrete-Time Systems







Performance Prediction of Hybrid Algorithms









Decentralized Control Techniques in Periodically Time-Varying Discrete-Time Control Systems

I Introduction

II Decentralized Control of General Multi-Channel Systems

III Periodic Control of PTV Discrete-Time Systems

IV Conclusions

Appendix Proof of Theorem 1

A Finite Element Method for the Solution of Optimal Control Problems







Techniques in Cross-Coupled Digital Adaptive Feedrate Control for Multiaxis Machine Tools


II Cross-Coupled Control and Contour Error




Globally Stable Single Loop and Decentralized Adaptive Systems with Parameter Projection












Effective control concepts and applications date back over millennia. One very familiar example of this is the windmill. It was designed to derive maximum benefit from windrow, a simple but highly effective optimization technique. Harold Hazen’s 1932 paper in the Journal of the Franklin Institute was one of the earlier reference points wherein an analytical framework for modem control theory was established. There were many other notable landmarks along the way, including the MIT Radiation Laboratory series volume on servomechanisms, the Brown and Campbell book, Principles of Servomechanisms, and Bode’s book entitled Network Analysis and Synthesis Techniques, all published shortly after mid-1945. However, it remained for Kalman’s papers of the late 1950s (wherein a foundation for modem state-space techniques was established) and the tremendous evolution of digital computer technology (which was underpinned by the continuous giant advances in integrated electronics) for truly powerful control systems techniques for increasingly complex systems to be developed. Today we can look forward to a future that is rich in possibilities in many areas of major significance, including manufacturing systems, electric power systems, robotics, aerospace systems, and many other systems with significant economic, safety, cost, and reliability implications. Thus, this volume is devoted to the most timely theme of Discrete-Time Control System Implementation Techniques.

The first contribution to this volume is Workbench Techniques in the Design of Digital Control Systems by Alberto Leva, Eva Locatelli, and Riccardo Scattolini. This contribution presents a methodology for developing real-time control software and in the process focuses on problems that might arise when fitting the control code into an industrial real-time control system architecture. The related issue of developing a flexible environment for quickly developing, testing, and documenting prototypes of control modules for digital control systems (DCS) real-time control software is treated in depth and illustrated by several examples. As a result, this is a most appropriate chapter with which to begin this volume on discrete-time control system implementation techniques.

The next contribution is Recursive Techniques in State-Space Matrix Fraction Realizations for Linear Systems, by Antonio Barreiro. An essential issue in discrete-time control system implementation techniques is that of obtaining the state-space equation or the transfer function that generates a multiple-input/multiple-output (MIMO) system. This issue is known as the partial realization problem and plays a critical role in linear system theory. This contribution presents a detailed exposition of a powerful and most effective recursive method for the solution of this essential problem.

The next contribution is Bounding Techniques for Robust Stability of Time-Variant Discrete-Time Systems, by Peter H. Bauer and Eliahu I. Jury. This contribution is an in-depth treatment of robust stability for time-variant discrete-time systems with structured uncertainties, wherein the system model is known but the parameters are uncertain. The results presented include systems described by a single difference equation or by a state-space model, with extensions to 2-D and m-D systems. Significant applications of the results are also presented.

The next contribution is Performance Prediction of Hybrid Algorithms, by X. Rong Li and Yaakov Bar-Shalom. Algorithms that involve both continuous-valued and discrete-valued uncertainties are referred to as hybrid algorithms. A hybrid system with discrete-valued as well as continuous-valued variables provides a framework which is particularly powerful for solving problems characterized by structural as well as parametric changes and for decomposition of a complex system into simpler subsystems. There are many significant applications of hybrid systems, as noted in the application. The hybrid conditional averaging (HYCA) performance prediction technique is quite general and can be applied to many hybrid algorithms, including multiple-model (MM) algorithms, as described in this contribution. Numerous illustrative examples demonstrate the great effectiveness of the techniques presented.

The next contribution is Decentralized Control Techniques in Periodically Time-Varying Discrete-Time Control Systems, by Wei-Yong Yan and Robert R. Bitmead. One of the most important results about linear periodically time-varying (PTV) discrete-time systems, P, has been the establishment of a categorical equivalence between periodic systems and a class of linear time-invariant (LTI) systems. This equivalence has been used in time domain synthesis and frequency domain analysis of PTV digital filters. This contribution treats the closed-loop equivalence between a PTV system and its equivalent LTI system. This equivalence enables one to reduce the problems of controlling P by a PTV compensator to that of controlling its equivalent LTI system by an LTI compensator with structure constraints depending on the type of PTV compensator required. This contribution presents a decentralized control technique for general LTI multichannel systems. Open-loop and closed-loop equivalencies between a PTV plant and its associated LTI plant are discussed, and the solution for the problem of stabilization and pole assignment for PTV plants is presented using linear periodic output feedback by reposing it as a decentralized control problem.

The next contribution is A Finite Element Method for the Solution of Optimal Control Problems, by Robert R. Bless and Dewey H. Hodges. This contribution presents numerical methods based on finite elements in time for solving optimal control system problems. An efficient and accurate algorithm which can obtain an approximate solution for possible real-time (i.e., online) implementation is presented. This algorithm identifies the optimal switching structure for constrained problems. The algorithm also reduces initial guesses for a shooting method. Illustrative examples manifest the power of the technique presented in this contribution.

The next contribution is Techniques in Cross-Coupled Digital Adaptive Feedrate Control for Multiaxis Machine Tools, by Hua-Yi Chuang and Chang-Huan Liu. One of the most important implementation areas for discrete-time control systems is that of computer numerically controlled (CNC) machine tools, which play an essential and pervasive role in modern automated manufacturing environments. An in-depth treatment of the issues and modern techniques in CNC, some of which are original to this contribution, is presented. By taking advantage of modern microelectronics technology and advanced digital control techniques, this contribution provides design methods and demonstrates their feasibility in developing high-performance controllers for use in CNC machine tools.

The final contribution to this volume is Globally Stable Single-Loop and Decentralized Adaptive Systems with Parameter Projection, by Changyun Wen. A major area of activity involves globally stable adaptive control systems which are robust under a wide range of model uncertainties, disturbances, etc. This contribution is an in-depth and comprehensive treatment of results and techniques in this broadly complex area.

The contributors to this volume are all to be highly commended for their contributions to this comprehensive treatment of discrete-time control system implementation techniques. They have produced a modem treatment of this subject which should provide a unique reference on the international scene for many individuals working in diverse areas for years to come.

Workbench Techniques in the Design of Digital Control Systems

Alberto Leva    Dip. di Elettronica e Informazione, Politecnico di Milano Via Ponzio 34/5 - 20133 Milano (Italy)

Eva Locatelli    CEFRIEL Via Emanueli 15 - 20126 Milano (Italy)

Riccardo Scattolini    Dip. di Informatica e Sistemistica, Università di Pavia Via Abbiategrasso 209 - 27100 Pavia (Italy)


In recent years, digital control techniques have been significantly developed and improved; this is certainly due to the availability of new methods and algorithms, but also the impressing hardware and software evolution in control environments and architectures has been playing a very important role. For example, Distributed Control Systems (DCS) are now widely used in the industrial world: these systems provide both a high structural modularity, which permits to build even a very complex control equipment by simply assembling standard devices, and powerful facilities for programming this equipment, which in most cases can completely avoid writing a control strategy in terms of a classical programming language.

However, in the majority of published literature, attention is still mainly focused either on the pure algorithmic aspects or on the description of a specific, finished application, while all the problems that arise when tailoring an algorithm or a control strategy to fit on a specific target architecture are almost totally concealed. In fact it might seem that, once the control strategy has been defined and tested, and once the target architecture has been chosen, the implementation phase can be immediately carried out with no need of further analysis steps.

On the other side, as any control engineer knows, the mere program checking or algorithmic debugging cannot ensure that a control strategy will behave correctly on the target machine. When the strategy has been defined, then, the actual programming or configuration phase must be preceded by an accurate analysis of what the final program will require from the host architecture, in order to achieve the best use of the available features and resources. This is especially true when dealing with real-time systems, characterised by strict timing and performance constraints.

Moreover, only this analysis allows to see which system resources and program threads might become critical in the specific application; quite often, this has significant consequences on the program structure and/or on the implementation of some code sections. In some cases this intermediate engineering phase has lead to an almost complete rewriting of the code, or even of the control strategy. Hence, the availability of powerful control environments claims for proportionally powerful analysis and evaluation tools.

As for the available products, there is plenty of software dedicated to algorithmic analysis (e.g. Simnon™, PcMatlab™) and to the creation of a control strategy, even oriented to a DCS structure (e.g. LabView™, Genesis™, Paragon™, Cyrano™) but, still, the actual evaluation of strategy performance can only be done when the code for the target architecture has already been created and, which is worse, when the physical structure of the control system has been built.

The main goal of this work is, then, the definition of a methodology for modeling, analysing and simulating real-time control systems, which can be easily related and connected to the most common description techniques employed to design, write and document control strategies. This methodology should also allow formal analysis to be performed onto its models, and should be able to translate its models into a friendly simulation environment, in order to collect performance information to be conveyed back to the control engineer. In detail, the methodology can be thought as composed of three main steps:

1. Model the system by means of an opportune description technique. In this work, the control scheme is modeled with the Petri Net (PN) formalism [1], [2], where the single elements (transitions, places) represent the tasks composing the control strategy as well as their connections, synchronisation and exchange of data [3], [4].

In this phase, we employ Place/Transition Petri Nets with minor modifications in order to deal with timing predicates, as described in the following.

2. If necessary, perform a formal analysis on the obtained PN model, in order to ensure that the properties needed are actually verified. This further step can detect the presence of deadlocks, traps or incorrect management of time in the model; this information is fundamental in order to reduce the possibility of structural inconsistencies in the system before the subsequent simulation and implementation phases.

However, we do not concentrate on formal analysis, since plenty of techniques [5], [6], [7] and software products are already available, see e.g. [8]. Anyway, it must be noted that in non-trivial cases any formal analysis is difficult and computationally heavy: hence it is often useful, when not mandatory, to evaluate the system performance by resorting to simulation.

3. Simulate the model and evaluate the obtained results. Since for this phase, to the authors’ knowledge, almost no product exists that sufficiently keeps in mind the problems arising when programming for DCS, we show how to build an environment for debugging and testing control algorithms and strategies under MS-DOS. This environment accepts a PN model of the system, and the net behaviour is then simulated in a high-level programming language; the choice is C++, due both to the remarkable benefits that a generic object-oriented environment offers per se [9], [10] and to some peculiarities of this specific language [11].

Moreover, the testing environment is designed to provide all the user interface and I/O primitives needed for the construction of a typical control system, allowing the control engineer to focus attention on the behaviour of the specific algorithms and of the overall strategy.

Hence, the work is organised as follows: first, the requirements for the modeling methodology are outlined and the chosen descriptive formalism is briefly explained. Then, a quite complex example, namely the description of a DCS task scheduler, is reported, in order to illustrate the main features of the describing formalism. Finally, the simulation environment is illustrated together with some examples of its use.


Any real-time control system, and especially any DCS, can be thought as an event-driven structure. Its components must measure process variables, exchange data among local and global databases and output controls to actuators, which implies a lot of synchronisation and interprocess communication aspects. In addition, apart from performing the normal control strategy, any control system must respond to various process conditions and events with appropriate actions.

Figure 1 shows how a description formalism should interact with the process of writing the model of a control application, i.e. of a given control strategy implemented on a given architecture; this leads to define the main properties that such a formalism should enjoy.

Fig. 1 The role of the description formalism

To summarise, a good description formalism must:

• Provide easy, and hopefully automatic, methods for converting a common strategy description (typically a block diagram) into its semantics.

• Capture as much as possible of the target machine operation and help to understand which components and/or features are significant in the modeling phase.

• Provide consistency between the description of the strategy and of the target system, so that the complete system model can be obtained with reasonable effort.

Note that, when choosing a suitable formalism for describing such systems, the possibility of performing formal analysis on the model must not be considered the only goal, or at least not the main one: in fact, the effectiveness of a describing method for DCS comes not only from its completeness and accuracy, but also from its capability of being easily connected to a simulation environment.

Moreover, if the formalism is thoroughly conceived and consistent, writing the target system model obliges to deeply understand its operation: this knowledge, together with simulation results and performance evaluation, is the most valuable information that can be fed back from the model and its simulation to the control engineer.

In view of this, Petri Nets (IN) appear to be a very effective way of modeling such systems: their structure and connectivity can immediately show what depends on what and, when simulating their evolution, the introduction of time allows to evaluate performances and resource utilisation.

In addition, the most common formalisms traditionally employed for the functional description of a control strategy (e.g. block diagrams, flow charts, etc.) can be quite easily translated into PN models. Furthermore, modeling real-time control software with PNs allows, by even a simplified formal analysis of the PN itself, to ensure the absence of critical conditions (deadlocks, infinite loops, and so on).

Clearly, PNs are not the only suitable formalism for describing real-time control systems: among the various alternatives, for example, a great research effort is being spent in the field of object-oriented techniques [12], [13]. This approach is very effective when designing a system, since the specification, design and implementation phases can be carried out in the same environment. However, the aim of this work is slightly different: we do not intend to design a real-time system, nor a complete specification language; conversely, we would like that our environment be suitable for emulating and analysing an existing real-time control system (which in most cases has neither been conceived nor implemented in an object-oriented fashion) in order to model and study its behaviour. In view of this, the effectiveness and simplicity of PNs allow to focus attention on the proper modeling aspects, while a well-stated correspondence with object-based descriptions permits a smooth transition towards an object-oriented simulation environment.

Finally, many DCS-oriented development tools allow the designer to construct a control scheme directly in terms of block diagrams or flow charts, which are conceptually very close to a PN-based descriptive approach. Also, these systems employ the schematic description provided by the designer to actually construct the control program code, which then preserves, in some sense, a block structure: this is a further reason for assuming PN models as a very suited and natural formalism.

For an introduction to PNs, which would be lengthy and lead apart from the scope of this work, the interested reader is referred to [1], [2], [7] and [6]. Suffices here to say that, in order to properly represent time constraints and relationships and for some additional reasons to be exposed in the following, the originally chosen formalism (namely Place/Transition Petri Nets) has been enriched with time predicates according to [14], [15]. Figure 2 shows the symbol we employ for a timed transition, indicating that the transition can fire only T time instants after its preset is marked.

Fig. 2 A timed transition

However, these considerations do not conclude the choice of a suitable formalism: actually, a modeling methodology consists of a description formalism (PNs in our case) plus the rules to be used for

• interpreting the formalism basic elements (places and transition) in terms of the object being modeled (the control system) or, conversely, constructing the model given the object

• simulating the model itself (i.e. the PN evolution in time)

• relating simulation outputs to real-world quantifies.

These three aspects are very strongly connected and should be all kept into account and defined. In particular, the first and the last usually lead to similar considerations and get solved together, while the second requires more attention. Basically, since the required model is oriented to simulation and not only to formal description, the algorithm used for running the PN must be consistent with the interpretation of place marking and transition firing: this is easy to understand but practically impossible to ensure m general, i.e. for any DCS, and often presents very subtle problems even for one given system..

This can be easily understood by observing that the DCS world contains an enormous variety of devices, whose operation are at least as different as can be the possible analysis interests and the motivations to construct a model. As such, the base formalism upon which the modeling methodology is constructed must also enjoy at least some minimal generality properties.

Fortunately, as far as timed PNs are concerned, many different model construction and interpretation rules can be employed. For example:

a. A transition in the PN is associated to an action in the control system, typically an operation that cannot be interrupted, while a marked place represents the availability of data and/or the logic permission for an action to be performed.

If this approach is adopted in constructing the model, the PN evolution will substantially follow in detail the CPU(s) operation and task(s) flow; as such, the scheduling machinery is normally represented in the PN itself with high accuracy.

b. A marked place represents a running task or an occupied resource, while a firing transition indicates a change in the system state, in terms of CPU and resource allocation.

In this case a detailed representation of control code is neglected, while attention is normally focused on the control architecture behaviour when dealing with timing bounds and device contention problems.

Many other examples could be given: again, control system models can result from different strategies and architectures and also form different interests and points of view over them, and the construction of a general formalism is probably impossible.

However, the use of timed PNs coupled with the evolution algorithm proposed in [15] appears to be transparent enough to system specific features, thus allowing the model designer to employ any common point of view and still be able to give a consistent model and simulation output interpretation. In addition, timed PNs are quite a basic PN type, thus permitting technique extensions to many, more specific PN types. For example, if the model to be developed must represent in great detail the internal software behaviour and not only - or mostly - the synchronisation and concurrence aspects, more complex PN classes (e.g. ER nets [16]) can be considered.


We will now describe a quite complex example of the use of PNs to model a real-time control system: this