WO2004059400A1 - Self-tuning controller for non-linear processes described by set of local linear models - Google Patents

Abstract

The self-tuning non-linear controller is intended for control of a class of non-linear processes that may be represented by a fuzzy set of low-order local linear models that are selected using a scheduling variable. The model is obtained by means of experimental modelling using a special on-line learning procedure combining model identification with pre- and post-identification steps that provide reliable operation. There is a choice of several novel control algorithms suitable for different processes that may be used for control and whose parameters are automatically tuned from the model. The controller monitors the resulting control performance and may react to detected irregularities. The controller is suitable for implementation on hardware platforms such as programmable logic or open controllers.

Description

SELF-TUNING CONTROLLER FOR NON-LTNEAR PROCESSES DESCRIBED BY SET OF LOCAL LINEAR MODELS

FIELD OF THE INVENTION

The invention relates to controllers used in process control engineering, more specifically to self-tuning (adaptive) non-linear control and more particularly to self-tuning controller for nonlinear processes described by set of local linear models.

BACKGROUND ART

There is a number of known non-linear control methods that were designed with the aim of achieving more efficient control of non-linear processes than the conventional linear methods such as the well-known and industrially proven PID controller (Bequette 1997, Henson & Seborg 1997, Qin & Badgwell 1998). All of those methods are based on some form of modelling of the process non-linearity and using this knowledge for improving the control strategy by applying non-linear controller action. Some of them are based on detailed theoretical (first-principles) modelling, while other use experimental modelling based on general non-linear models such as artificial neural networks, fiizzy models, wavelets, multiple models etc. (Sjδberg & al. 1995, Murray-Smith & Johansen 1997) where model parameters are extracted from measurement data using a form of model identification (Ljung 1987), or controller parameters are calculated from measurements directly.

Self-tuning or adaptive control methods (Astrδm & Wittenmark 1995) assume time-varying process dynamics and therefore calculate model parameters, or update the controller directly, during controller operation. With adaptive controllers this usually occurs continuously while With self-tuning controllers it is triggered on demand. In both cases, injection of perturbation signals may be used. While most adaptive methods assume that the process is linear, this concept is also applicable to non-linear processes.

An overview of existing patents in related fields includes:

WO 01/79945 to Hess et al. describes a non-linear controller-based on an adaptive linear model predictive controller for which the model is obtained from a first-principles non-linear_: process model. US5335164 to Gough, Jr. et al. describes a method and apparatus for non-linear adaptive control based on Laguerre series network model and predictive control.

US6055524 to Chen describes a direct adaptive non-linear controller based on an artificial neural network.

US5740033 to McCroskey et al. describes a control system based on a non-linear model predictive controller and an interactive modeller.

US5682309 to Fontaine et al. describes a non-linear controller based on a non-linear state-space model, state estimation and on-line optimisation using sequential quadratic programming.

WO 01/92974 to Calise et al. describes an adaptive non-linear controller based on a linear controller and model inversion of an adaptive artificial neural network.

US5394322 to Hansen describes a model-based method for self-tuning of a linear PID controller.

EP0571080 to Molnar describes a method for self-tuning of a linear PID controller.

EP0360206 to Yokokawa et al. describes a method of linear PID controller self-tuning based on three performance indexes.

US4407013 to Arcara et al. describes a method of linear PID controller self-tuning from a discrete-time model.

While advanced in theory, there are several drawbacks to known methods and controllers in practice. Due to the complexity of implementation and computational demand, the hardware requirements are high. The complexity of tuning makes .them unattractive to non-specialised engineers. This is particularly the case with methods based on detailed theoretical modelling, while reliability of experimental modelling is often questioned. In any case, control is subject to imperfect modelling.

The presented controller attempts to overcome these problems and provide an efficient and user- friendly tool for control of a certain practically very important class of non-linear processes that may be represented by a fuzzy set of low-order local linear models that are selected using a scheduling variable. The model is obtained by means of experimental modelling using a special on-line learning procedure combining model identification with pre- and post-identification steps that provide reliable operation. There is a choice of several control algorithms suitable for different processes that may be used tor control and whose parameters are automatically tuned from the model. The controller monitors the resulting control performance and may react to detected irregularities. All the algorithms are adapted for implementation on standard low-cost industrial hardware platforms such as programmable logic or open controllers, accompanied by software that simplifies the initial configuration from a personal computer.

SUMMARY OF THE INVENTION

The self-tuning non-linear controller according to the present invention is intended for control of a class of non-linear processes that may be represented by a fuzzy set of low-order local linear models that are selected using a scheduling variable. The model is obtained by means of experimental modelling using a special on-line learning procedure combining model identification with pre- and post-identification steps that provide reliable operation. There is a choice of several control algorithms suitable for different processes that may be used for control and whose parameters are automatically tuned from the model. The controller monitors the resulting control performance and may react to detected irregularities. The controller is suitable for implementation on hardware platforms such as programmable logic or open controllers.

The self-tuning non-linear controller is based on a multi-faceted model comprising a set of first- order discrete-time linear local models with.time delay and offset and second-order discrete-time linear local models with time delay and offset which are placed at different positions of a scheduling variable _., that can be as a whole interpreted as the said Takagi-Sugeno fuzzy model.

_^ The self-tuning non-linear controller consists of a Signal Preprocessing Agent, an Online Learning Agent, a Model Information Agent, a Control Algorithm Agent, a Control Performance Monitor, and an Operation Supervisor, where

• the Signal Preprocessing Agent prepares the process signals for real-time control and stores them to a buffer fori batch- wise post-processing,

• the Control Algorithm Agent performs non-linear control based on the multi-faceted model in real time and automatically retunes the controller from the multi-faceted model,

^'• the Online Learning Agent periodically inspects the buffer of recent real-time signals and extracts new model information when appropriate,

• the Model Information Agent maintains the active multi-faceted model,

• the Control Performance Monitor periodically inspects the buffer of recent real-time signals and extracts features of closed-loop performance of detected events, that may be used to trigger modification of Operation Supervisor configuration,

• the Operation Supervisor coordinates controller operation. DISCLOSURE OF THE INVENTION

The invention will be described with reference to the accompanying drawings, illustrating:

Fig. 1 : Self-tuning non-linear controller overview

Fig. 2: Fuzzy membership functions of local models in the Multi-Faceted Model

Fig. 3 : Online learning procedure

Fig. 4: Fuzzy Gain-Scheduling Controller Control Algorithm Agent overview

Fig. 5: Dead-Time Compensation Controller Control Algorithm Agent overview

Fig. 6: Rule-Based Neural Controller Control Algorithm Agent overview

Fig. 7: Control Performance Monitor

Fig. 8: Fuzzy logic membership functions for Performance Index calculation in CPM

Fig. 9: Fuzzy logic rule table for Performance Index calculation in CPM

Fig. 10: The sample neutralisation process

Fig. 11 : pH control performance comparison between FGSC and linear PI controller

1. Overview

The proposed controller is built in the form of a multi-agent system where several independent agents (modules) interact with each other. The system includes the following agents, as shown in Fig. 1:

• Signal Preprocessing Agent (SPA) (1),

• Online Learning Agent (OLA) (2),

• Model Information Agent (MIA) (3),

• Control Algorithm Agent (CAA) (4),

• Control Performance Monitor (CPM) (5),

• Operation Supervisor (OS) (6).

2. Multi-faceted Model

The model-based controller is founded on a multi-faceted model (MFM) (7) that includes several model forms required by the online-learning mechanism and control algorithm agents. Specifically, it includes, a set of first- and second-order discrete-time linear local models with time delay and offset, which are placed at different positions of a^' scheduling variable s. The model equation for second order models is y(k) - -a_{l J}y(k - 1) - a_{2 j}y(k - 2) + b_X u(k - 1 - du_j ) +

+ b_{2 j}u(k - 2 - du_j ) + c_{X j}v(k -l - dv_j) + c_{2 j}v(k - 2 - dV_j) r_j and for first order models simplified to y(k) = -a_l y(k - 1) + b_{X J}u(k - 1 - du_j ) x c_X v(k - 1 - dV_j ) + r_y- where

£ is the discrete time index, - J is the number of the local model, y(k) is the process output signal (controlled variable, CN), u(k) is the process input signal (manipulated variable, MN), v(k) is the (optional) measured disturbance signal (MD), du is the delay in the MV-CV path, dv is the delay in the MD-CN path, a_h b_h C_t and r are parameters of local models. The MFM can be interpreted as a Takagi-Sugeno fuzzy model, for the second order written as m m m y k) = -∑ _ja_{l y}(k - 1) - ∑ _ja_2Jy(k - 2) X ∑ β_jb^-u -l - d_Uj) x

7=1 7=1 7=1 x

where β_j - β s) is the degree of fulfilment of they-th membership function (it is a function of the scheduling variable s). Normalised triangular membership functions are used as illustrated in m

Fig. 2, so that _j = 1 at any value of s.

.7=1

The scheduling variable is calculated in each time instant as follows s(k) = k_rr(k) + k_yy(k) X k_uu(k) X k_vv(k) where the coefficients k_r, k_y, A:„,and k_v are predefined constants.

3. Online Learning Agent

OLA (2) analyses the buffer of recent real-time signals (8), prepared by SPA, and generates new local models (9) when conditions are appropriate. It is invoked periodically or upon demand by OS. Since it js..a computationally intensive task, it-runs as a low-priority- task in a multitasking operating system.

The following procedure is carried out whenever OLA is invoked, as illustrated in Fig. 3: Excitation check (10), Copying of the current MFM from MIA (11), Selection of local models (12), Identification of selected local models (13), Verification/validation of selected local models (14). Submission of modified local models to MIA (15).

Excitation check: if the variance of the signals r(k), y(k), u(k), and v(k) in the active buffer is below their specified thresholds, the execution is cancelled (16).

Selection of local models: the local models for which the sum of their corresponding membership functions β_j(s) over the active buffer normalised by the active buffer length exceeds 0.2 are selected. Further processing does not include other local models.

Identification of local models: the parameters of the selected local models are identified using the Fuzzy Instrumental Variables (FIV) identification method, an extension of linear instrumental variables identification procedure (Ljung 1987) for the specified MFM. The identification is performed for each local model (and its corresponding fuzzy set, denoted by the index j) separately (17). The most general form of the procedure where all parameters of a second-order model are estimated is described below.

Firstly, the vector of the estimates of the plant parameters θ_y = ty_\ , a₂ , b_i , b_2J, c_X , c₂ ,r_j] is initialised (18) from the active MFM in MIA, and the covariance matrix P₇ is initialised to' 10⁵ • I (identity matrix).

Then, an approximation of P, and θ . is obtained using weighted least-squares (LS) identification (19) in the recursive form (to avoid matrix inversion) with a dead-zone preventing result degradation by noise: for k= (buffer _start ra& (du_j, dv_j) +2) to buffer _end ψ_y (A + l) = [-βyjrø, -βy fc-1). _j k-du_j), P_ju(k-l-du_j), _jv(k-dv_j), _jv(k-l-ώ/_j), β_; if abs ψ_jy(k + 1) - ψ. (k + l)θ_y- (k)J > noise Jhreshold

- Q_j (k 1) = θ_y (*) XT_j (k + l)ψ_y. (fc + _jy(k'+ 1) - ψ/ (k X l)θ (k))

P , (*)ψ , (k x l)ψ / (k x 1)P , (k)

¥_i(kxϊ) = Ε,(k)- i '- - - — -^ ÷-

^{1 J} l + ψ/(λ + l)P /r)ψ (A: + l) endif endfor where ψ ^τ is the vector of measurements.

Finally, improved estimates of P, and θ_y are calculated using weighted instrumental variables

(IV) identification method (20) for k = (buffer jstart + max(-t«„ dvy) +2) to buffer_end ψ_J(k+l) = [-p_jy(k),-fl_Jy(k-l),P_Ju(k-du_J),1i^

y(kxl) = ∑ψ_J ^τ(kxϊ) _J(k) =1 χ, (^/+1) = [-β £), -β, *-l), β₇"(*-^^ if abs ψ_j y (k 1) - ψ_y ^T (k X l)θ_y (k) J > noise Jhreshold θ__/(A: + l) = ^β t)

endif endfor where χ (k+V₎ ^T is the vector of instrumental variables and y(k) is the simulated output.

For identification of first order models a very similar procedure is used where the following vectors are modified:

Ψ,(* + l) = [-β,X*), β,«(*-ώι,). β,v(A-rfv,), β ^r

In case of lack of excitation in the model branch from v (MD) to y (CN), or when MD is not present at all, variants of the method with the following vectors are used for second order models θ,= [α_{lj3 2jy},b ,b_2s7,r.]

Ψ,(*+l) =

-β_j λ-1), β,tt(*-Λ-.), ik-l-du_j), βj

%_j(k+i) =

βj and for first order models, respectively, ^Θ,= ₇ ^, \₇, ] ψ, (/t + l) = [-β, y(/c), ^_]U(k-du₃ β ^r

In case of lack of excitation in the model branch from u (MN) to y (CV), variants of the method with the following vectors are used for second order models θ, = [ _> c_2j7 ,r. ] ψ,(/t + l) = [^(k-dV_j), _jV(k-l-d_Vj), β,f χ,(fc + l) = [^(k-dV_j , β,v(*-_-rfv_y), β f and for first order models, respectively,

ψ, (/t+l) = [β,v(/c--t^'v . ), β ]^r

Verification/validation of local models:

This step is performed by comparing the output of a selected local model, denoted by the index j, with actual process output in the proximity of the local model position, specified by the corresponding membership functions β , and calculating the normalised sum of mean square errors (MSE) vaf. When performed on the same data that was used for parameter identification it is called verification, while with model parameters obtained on another data set it is referred to as validation.

The local model is described as θ_y = [^Ω_,_y. ^a ₂,_j > bι , b2,₇ > ^cι,₇ ' ^c2,j >^r _jY> i*^{1 case} °^ ^a ^^ιrst~ order model or when measured disturbance v is not present, the coefficients a_2j, b _j, c_2j are set to 0. The following procedure is used: sim_start = m& (du_j X dvj) + model_order; ym_dd = y(sim_start — 2); ym_d = y(sim_start — 1 ); vaf = 0; sumbetO_j = 0; for k = buffe jstart X sim_start to buffer _end calculate membership function β, = β, ( s(k) ) sumbeta_} = sumbeta_j + β,; ym = [-ym_d —ym_dd u(k-du—l) u(k-du_j-2) z(k~dv_j-l) z(k-dV_j—2) l]^r - θ ,- ; ym_dd=ym_d; ym_d^~ym; vaf = vaf X (y(k) -yr f * β_y; end vaf — vaf I (sumbeta_j X 10^~10);

For each of the selected local models, this step is carried out with three sets of model parameters θ ■ : the initial model from MIA (21), the model estimate of the LS method (22) and the model estimate of the IV method (23). The model with the lowest vaf of the three is sent to MIA (15) as the result of online learning, along with its vaf that serves as a confidence index (cij) and a flag chg_j indicating whether the model is new or not.

4. Model Information Agent (MIA)

MIA maintains the active MFM (model-in-use) and its status information.

MIA accepts online learning results from OLA. If the model confidence index is below the specified threshold, the automatic mode may be disabled. When a new local model is received, it is accepted if it passes the stability test (and possibly other tests) and its confidence index is sufficient. If the local model is accepted, its ag_j flag is set, which means that it is ready for controller tuning by the CAA's tuning layer and not used yet. Each local model also has a c_j flag indicating whethei the local model had been tuned since start-up or not.

MIA contains a mechanism for inserting additional local models.

MIA may also store the model-in-use to a local database (24) or recall a previously stored one from there.

At initial configuration, MIA is filled with local model that are not accurate but provide a reliable (although sluggish) performance of the controller, similar to the Safe mode. With online learning through experiments or even normal operation (when the conditions are appropriate), an accurate model of the plant is built by receiving identified local models from OLA.

5. Control Algorithm Agent

The CAA (4) includes functionality of an advanced non-linear control algorithm and automatic tuning of its parameters from the MFM. Several CAAs with different operating principle and properties may be used in the controller and may be interchanged in the initial configuration phase.

The CAA supports several modes of operation:

• Manual mode: open-loop operation • Safe mode: a fixed linear controller, tuned conservatively

• Auto mode (or several auto modes with different tuning parameters): non-linear controller The CAAs share a common interface of interaction with other agents of the controller and a common modular internal structure, consisting of three layers:

• The control layer (25) includes the functionality of a local linear controller (or several local linear controllers at once), including all functionality required for industrial controllers, such as anti-windup protection, reasonable switching between open-loop and closed-loop operation, etc.

• The scheduling layer (26) performs switching or scheduling (blending) of tuned local linear controllers, so that in conjunction with the control layer a fixed-parameter non-linear controller is realised.

• The tuning layer (27) performs automatic tuning of controller parameters from the MFM whenever new models are generated (indicated by the ag flags) and auto-tuning is enabled. When tuning is completed, the ag flags are cleared and the tuned flags are set. The tuning layer maintains the controller parameters, that are derived from the MFM in general but CAA-specific, and the controller parameters also include a copy of the MFM from which they were tuned. It replaces the parameters of the control and scheduling layer in such manner that their real-time operation is not disturbed.

Fuzzy Gain-scheduling Controller (FGSC) CAA

An overview of FGSC is shown in Fig. 4.

The control layer of FGSC (28) consists of a single PID controller in the velocity form (in order to use velocity-based linearisation when blending local controllers), equipped with anti-windup protection, and is defined by the following procedure carried, out in each discrete time step k:

% INPUTS:

% Tsamp - sampling time of the PI control algorithm

% r(k) - reference signal

% y(k) - process output signal

% limit miax, μmin, _duup, _dudown - actuator limitation ^s

% controller _mode - The controller mode -

% ujnanual - controller output for the manual mode

% Kp, Ti, Td- Current PID controller parameters

% beta - 0: disturbance rejection, 1: reference following) . % KTd - The filter time constant ratio, KTd = Td/ TJ)

% OUTPUTS:

% u(k) - controller output

% INTERNAL SIGNALS (previous values stored for the next sample):

% uP_\, uD_2, uD_l, ucu_ , r_l, uu_l, u_l

% Re-calculation of all filter and gain parameters if2ϊ~=0

Kpi - Tsamp I Ti; else

Kpi = ; endif

Kpd= Td/ Tsamp; Tf=Td/KTd; Kf= 1 - exp( -Tsamp I Tf); % Calculation of anti-windup parameters if(Z>etα=l)

Tmp = 1 + Kpi X Kpd; else

Tmp = Kpi; endif

Tmpl = 1 / (Tmp X le-10); Daw = Tmpl I (Kp * KfX le-10); if (beta== 1)

Kaw 1 = Kpi* Tmpl ,' Kf;

Kaw2 = 1 - Kf- Kpd * Tmpl; else

Kawl^llKfi

Kaw2 = \-Kf; endif

% Calculation of PID terms e(k) = r(k)-y(k); uP = Kp*e(k); ul= Kpi * Kp* e(k); uD = Kp* Kpd * (e(k) X (beta-l) * r(k));

% Calculate unlimited unfiltered controller output uu(k) ucu - ucu_l uI uD- 2*uD_l + uD_2 uP- uP_l + Kawl * (u_\ - uu_l)

-Kp* (l-beta) * (r(k) - rj ; uu(k) - Kf* ucu X Kaw2 * (u_l - uu_l) + (1 - Kf) * uu_\; % Calculate the new value of u(k) (limited controller output)

u(k) — ujnanual; else % Automatic control u(k) = uu(k); endif

% Controller output limitation u(k) = max(min(-.(/t), limit _umax), limitμmin); duout = u(k) -u_l; if duout> Tsamp * limit _duup u(k) = u_l X Tsamp * limit_duup; elseif duout < —Tsamp * limit _dudown u(k) = u_\ — Tsamp* limit_dudown; endif

% Update internal signals for next sample uP_i-uP; uD_2 — uD_l; ύD_\—uD; ucu_l—ucu; r_l=r(k); u_l = u(k); uu_\-uu(k);

The scheduling layer of FGSC (29) is implemented as fuzzy blending of the controller parameters (in case of Ti, its inverse value) according to the scheduling variable s and the triangular membership functions β, (30) of the local models in the MFM. The following procedure is used:

% INPUTS:

% CPM -controller parameters matrix CPM =[CPι CP₂... CP„,]

% where m is the number of local controllers, sorted by scheduling variable

% _{. .} CP_/.are local_.Pφ controller parameters, CP_j=[Kp_j Ti_j Td_j_ S_jf _.

% s - the current scheduling variable

% OUTPUTS:

% CP = [ Kp Ti Td s ]^τ- scheduled controller parameters at the current scheduling variable s % Find two neighbouring controllers

_

while (s > sjήgher) & (j <= m)

J =j + if/ <= m sj igher — sf, endif endwhile

% Determine scheduled parameters if/ = 1 % s is lower than ^

elseif == m X 1 % 5 is higher than s_m

CP = CP_ffl; else % s is between Si and s_m , actual fuzzy scheduling tmp = (s - 5_/_ι) / (,-)^• - 5;_ι) ;

^ = ^κPj-ι + tmp * (Kpj - Kp );

Td = Td_j-ι X tmp * (Td_j - Td ); if(2ϊ = 0) | (7 ^ = 0) Ti = 0; % PI controller else 7Ϊ = l/( l/ri _ι + tmp* (\ITi_j- VIϊ )); endif endif

The tuning layer of FGSC (31) is based on the magnitude optimum (MO) criterion implemented using the multiple integration (MI) method (Vrancic & al. 2001). Discrete-time process parameters that are extracted from the MFM are converted it into continuous-time parameters. Then the so-called areas are calculated which are used for the calculation of the controller parameters, first the PI and then PID controller parameters. The following procedure is used for tuning of a single local PI controller from its corresponding local model (32): . .

% INPUT PARAMETERS: % Tsamp - sampling time % beta - 1: reference following, 0: disturbance rejection (boolean)

% KTd - The ratio between Td and Tf

% Kid - The ratio between Ti and Td in the serial PID structure

% mαx - maximum allowed open-loop gain (controller gain * steady-state process gain)

% LM,- = [ay, ay, by, by, du_j, S_j ]- local model parameters, delay and scheduling variable

% position, extracted from the MFM (second order models: ₂y = by = 0)

% OUTPUT PARAMETERS:

% CPy - controller parameters, CPy = [ Kp_j Ti, Td_} sf

% Flag_PI_gain - The PI gain was modified from Kmax; boolean

% Transformation from discrete to continuous model by using bilinear transformation

Kpr = (by X b_2J) I (1 + a_y X a_2J); e = - by * Tsamp I ( by X by); b_2c = 0.25 * (Z>₂y - by) * Tsamp²1 ( b_υ X by); — (1 - ) * Tsamp / (1 + a X a_2j); a_2c = 0.25 * (1 + ay - ay) * Tsamp²1 (I ay X ay);

Td— du_j * Tsamp;

% Calculation of areas from continuous model for magnitude optimum calculation

A0 = Kpr;

Al = Kpr *( a_lc - b_lc Td);

A2 = Kpr *( b_2c - a_2c- Td* b_lc 0.5*Td²) XAl* a_lc;

A3 = Kpr*(Td* b^ - O^Tf* b_Xc + 0.166666* TcT) XA2* a_lc -Al* a_2c;

A4 = Kpr*(Td²* b_2c *0.5 - 0.166666*7tf³* b_lc + 0.04166666*7. ) + A3* a_lc -A2* a_2c;

A = K r*(TS* b_2c *0.166666 - 0.04166666*7tf** b_lc X 0.008333333 *Td⁵) XA4* a_lc

-A3* a_2c; % Calculation of PI parameters for magnitude optimum Flag_PI_gain = 0; Tmpl =Al*A2 -A3*A0;

Tmp3 = A0²*A3 + A l³ - 2*A0*A 1 *A2; if beta === 1 % Optimum controller_gain for reference-following if (Tmpl -= 0)

Kpj = A3 * 0.5 I Tmpl; else Kp_j = Kmax /A0; % Use maximum gain

Flag_PI gain = 1; endif else % Optimum controller gain for disturbance rejection

SI = Tmpl² -A3 * Tmpl * Tmp3; if Tmp3 ~= 0

Kp_j = (Tmpl - sqtt(Sl)*sga(Tmpl)) I (Tmp3*Tmpl); else Kp_j = Kmax /A0; % Use maximum gain

Flag_PI_gain = 1; endif endif if (Kp_j*A0 <= 0) I (abs(Kp_j*A ) > Kmαx) Kp_j = Kmαx I A0; % Gain correction

Flαg_PI_gαin = 1; endif

Ti_j = Al *Kp / (A0*Kp + 0.5 + 0.5 *Kp²*A ²*Tmp2); Td_j = Q;

Dead-time Compensation Controller (DTCC) CAA

An overview of DTCC is shown in Fig. 5.

The control layer of DTCC (37) consists of a single PID controller in the velocity form and up to 10 local predictive functional controllers (PFCs) equipped with anti-windup protection and

MN constrains restriction. The control layer is implemented by using the following procedure that is carried out at each time instant (k):

% INPUTS:

% Tsamp - sampling time of the PI control algorithm

% r(k) - reference signal

% y(k) - process output signal

% limit μmax, _μmin, _duup, _dudown - actuator limitation

% controller._mode - The controller mode

% u nanual - controller output for the manual mode

% Kp, Ti, Td - Current PID controller parameters

% Wiit i... Whtjo - weight coefficients for the local controllers' outputs % dsti ... dstio, hi...h_]0 - tuning parameters for the local predictive functional controllers

% klm₁...klm₁₀, k2mι...k2m₁₀, kldι...kld₁₀, k2dι...k2d}o, amlm...amlmιo,

% am2niι...am2mιo, dmj...dmιo, ddj...ddιo - local model parameters

% delt - dead zone

%pfc_enable

%ff- is feed-forward enabled

% OUTPUTS:

% uct(k) - controller output

% INTERNAL SIGNALS (previous values stored for the next sample): e_l, uD_l, u_ l

% upfc =0;

% Calculation of PID controller outputs

% Calculation of control error e(k) = r(k) -y(k);

% dead zone restriction if(e(k) >== - delt& en <= delt) e(k) = 0; endif;

% Derivative block calculation uD = uDJ X Td/ (alfa*Td X Tsamp) * (e(k) - e_l) + Tsamp /(alfa*Td X Tsamp) * (e(k) - uD);

% gain block calculation uP = Kp *(uD - uDJ); % integral block calculation ul =Kp*Tsampl/Ti*uD; % output calculation , upid (k) = u_lX uD X ul; % antiwindup reset if(upid(k) >= limit μmax \ upid(k) <- limit xmin) upid(k)- u_lXuP; endif

% past values updating ej = e(k); uDJ = uD; u_l = upid(k);

% Calculation of PFC local controllers' outputs for/ =1 to numjocal nodels

% Model update routine for i — DTCC yectorJength to 2 ylm_memo,_j = ylm_meπιo,.i_j; y2m_memo,_j =y2m_memo_l_ι_J; yld_memo,_j =yld_memo_l.ι_J; y2d_memo,_j =y2djnemo_l_ι_J; end ylmjnemoi_j—amlm_j *ylm_memθ]_jXklni_j *(l-amlm *vector_μ(l); y2m_memoi_j =am2m_j *y2m_memoj_j+k2?n_j *(l-am2m *vector μ(l); yld nemoi_j—amld_j *yld_memoi_jXkld_j *(l-amldj *vector_y(l);

if (controller ^ι_ modc >= 2)&(pfc_enable ==1) lambda_j = exp(-3*Tsamp /dstj; % Reference trajectory coefficient

dif_j = dm_j-dd_j,- key_j = 1; else dif_j ^dd_j-dni_j; key_}-0; endif if == 0 dd_j=0; ee_j-(l-lambdafh *(ylm_memo(dm+l, i)Xy2m_ιnemo(dm+l, i)); aa_j=vector_rf(lXdm_j+hyiambda h_j*vector f(l+dm)-(l-lambda h_j)*y(k); bb_j=0; cC_j=(lambda_J ^Ah_l)*(ylm_memθ]_J+y2m_memojJ; fij= ; gg_j=-(amlmf"h_j) *ylm nemoi_jX(am2mfh *y2m_mempιj; hhf (klni_j *(l-amlmfh)Xk2m_j *(l-am2m h)); else dd_j ^:=(l-lambda_j ^A hJ *(yld_memo(l+dd_j, i) y2djnemo(lXdd_j, i)); ee= (l-lambda_J hj *(ylm_memθd_mj +_,y+ y2m_memθd_mj +., ),' if key _j ==1 aa_j

X hj-lambdaf h * vector rf(lXdm)-(l-lambda^A h_j)*y(k); bb_j =(lambda_j h_j)*((amld_j ^Adif)* yldjnemoi_jXkld_j *(l-amld_j dif) *v(k)X(am2d_j dif) * ^' y2d_memoi_jXk2d_j *(l-am2d_j dif) *v); cC_j =(lambda_j hj *(ylm_memoj_jX y2jn_memoιJ; ffj =-(amld_j ^A(h_j+dif)*yld_memoi_jXkld_j *(l-amld_j (h_]Xdif_J))*v(k)Xam2d_j ( h_jXdif)* y2d_memθ]_jXk2d*_j (l-am2d_j ^A(h_jXdif))*v(k)); gg_j =-((amlm_j h_j)*ylm_memθ]_jX(am2m_j ^Λ h_j)*y2m_memθ]J; hh_j =(klm_j *(l-amlm_j. ^A h)Xk2m_} *(l-am2ni_j ^A hJ); elseif key_} =—0 aa_} =vector_rf(dd_j + h_j l)-lambda_j ^A _j*vector_rf(dd_j + l)-(l-lambda hj*y(k) ; bb_j =(lambda h *((amlm_j ^Adif)* lm_memθ]_jX(am2m_j ^Adif)* y2m_memoιJ; cC_j - (lambda ^, h) *(yldjnemoi_j y2d_memojJ; ff_j —-(amlm_j ( h_jXdif)* ylm_memθ]_j+am2m_j ^A( h_jXdif)* y2m_memθ]_j); gg_j =-((amld_j ^A hj* yldjnemoi_jXkld_j *(l-amld_j ^A h)*v(k)X(am2d_j h)* y2d_memθ]_j X k2d₃ *(l-am2d_j ^Λ h) *v(k)); hh_j =-(lambda_j ^A h_j)*(klm_j *(l-amlm_j dif)Xk2m_j *(l-am2m_j ^Adif))Xklm_j. *(1- amlm_j ( h_jXdif))Xk2m_j *(l-am2m_j ^A(h_j+dif)); endif endif

% Manipulated variable computation upfcl_j=(aa_jXbb_j+cC_jXdd_j+ee_jXff_jXgg_j)/hh_j; % Controller dead zone if abs(vector_rf(l)-y(k))< delt upfcl_j = upfcj_j; endif upfc = upfc X Wht_j*upfcl % Blending of the local PF controllers outputs endif endfor

% Controller mode switch & final output if (controller node

uact(k) — upfc; elseif controller node >= 1 uact(k) = upid; elseif controller node == 0 uact(k) = ujnanual; endif if uact(k) > limjμmax uact(k)= limjμmax; endif if uact(k) < limjμmin uact(k) — limjμmin; endif

% Constrains checking routine if lim imax < (vector _uj X lim_duup*Tsamp) umx = limjμmax; else umx = (vector jU lim_duup*Tsamp); endif if limjμmin > (vector jμy- lim)dudown*Tsamp) umn — limjμmin; else umn=(vectorjμι— lim iudown *Tsamp); endif if uact(k) > umx uact(k) = umx; endif if uact < umn uact(k) = umn; endif

% Controller dead zone if (abs (vector f-y(k)) < delt) &(controller node ~= 0) uact(k) . = vector 'j (l); . endif

% Update of MN and disturbance vectors forj = DTCC iectorJength to 2 vector jd_j = vector jU_j.j; vector jV_j = vector j\>_j.,; endfor vector _ uχ— uact(k); vector jy,= v(k);

The scheduling layer (36) of DTCC is implemented as fuzzy blending of the PID controller parameters or local PFC controller outputs according to the scheduling variable s and the membership functions of the local models. The following algorithm is implemented:

% INPUTS:

% CPM controller parameters matrices CPM = [ CP_! CP₂ ... CP_m ]

% where m is the number of local controllers, sorted by scheduling variable

% CPy are local PID controller parameters, CPy = [ Kp_j Ti, Td, Wht_v..M\A_vai

% s - the current scheduling variable

% OUTPUTS:

% CP - [Kp Ti Td Wht,_j...Wht_10j]^T - scheduled controller parameters at the current scheduling variable s

% Find two neighbouring controllers j = l; s_higher = s,; while (s > sjiigher) & (j <= m)

7 =7 + 1; if <= m sjiigher = s/, endif endwhile

% Determine scheduled parameters if/ == 1 % s is lower than S_\

CP = CP,; elseif/ = m X 1 % s is higher than s_m

CP = CP_m; . else % s is between S\ and..s„, ., actual fuzzy scheduling tmp = (_. - s_j-ι) I (s_j - s_j-i) ;

Kp = K _j_ + tmp * (Kp_j - Kpj-ι );

Td = Td_j_, + tmp * (Td_j - Td ); Ti = Ti_j_ιXtmp*(Ti _j - Ti,.j); Whtι= Whi]_j.ι+tmp*(Wht_u- Whti_j.,);

Wht₁₀= Whiιo_j.ι+tmp*(Wht_10J- Wht_10J.ι); endif

The tuning layer of DTCC (33) is based on tuning tables for parameters of the predictive controller and the PID controller and classical approaches for PID controller tuning. There are two manners of obtaining PID settings. The first one is based on formulas approximating the results of a number of simulations with various stable plant models performed in advance. The second manner comprises the approach based on the internal model scheme. PFC tuning parameters are calculated based on formulas obtained with simulations (in the way as the first

PID tuning manner). The following procedure is used for tuning of a single local PID and PFC controller (35) from th ir corresponding local model (34):

% INPUT PARAMETERS:

% Tsamp - sampling time

% LMy = [ay, ay, by, by, du_j, _j ]- local model parameters, delay and scheduling variable

% position, extracted from the MFM (second order models: ₂y = by = 0)

% speedjactor - correction coefficient for PID controller tuning parameters

% no_del_gain - PID controller gain when no delayed model is available

% .tunejnanner -two different formulas for calculation of PID tuning parameters are provided

% model_orders - order of local models

% OUTPUT PARAMETERS:

% CP_j - PID controller parameters, CP_j = [Kp, Ti_j Td, Wht,... Wht_l0]

% CP y - PFC controller parameters, CPOJ = [dst_j h_j klm_j k2m_j kld_j k2d_j amlni_j am2mj dm, ddβ

% if (model jorders == 2) & (realjoots), i = (a,, X sqrtfa² i_j-.4*a_2j))/(-2); g= a,_j- i; f= (b2j-g*blj)/(i-g); h= (blj*i- b2j)/(i-g); ff- (c2j-g*clj)/(i-g); h_h= (clj*i-c2j)/(i-g);. dml= dm*Tsamp; ddl= ddXTsamp; amlm._j—-i; am2m_j—-g; klm_j=h/(l-amlm); k2m₁=f/(l-am2m);

k2d_j—f /(l-am2m_j); Tlm_j—-Tsamp/log(amlm); T2m_j=-TsampΛog(am2m_j); K_j—klm_j k2m_j; T_j=Tlm_j+T2m_j; elseif model yrders == 1 % first order model i = (a,_j X sqrt i_j - 4*a_2j))/(-2); g= ^au - ϊ; f=(b2j-g*blj)/(i-g); h=(blj*i-b2j)/(i-g); fj=(c2j-g*clj)/(i-g); h_h= (clj*i-c2j)/(i-g); dml_j= drn_j*Tsamp; ddl_j= dd_j*Tsamp; amlm_j=-i;

klm_j=h/(l-amlm_j); k2m_j=f/(l-am2m_j); kld_j=h_h/(l-amlm_j) ; k2d_j=ff/(l-am2m_j);

Tlm_j—-Tsamp/log(amlm);

T2m_j--Tsamp/log(am2m ;

K_j=klm_j k2m_j;

T_j=Tlm_j T2m_j; endif if dml_j-—0 tunejmanner=l; endif kappa= dml/T,; if kappa <= 0.4 esp=0.9*dml_j; else esp=dml_j; endif if dml_j==0,

Kp_j= speed _factor*no_ del_gain/K_j; if tune nanner =— 0

SO_j l.0/(K_j*dml_j) *(0.287X0.21 *T dml_jX0.385*exp(-1.57*T dml)); Sl_j=l/K_j*(-0.186X0.784*T_j/dml_jX0.435*exp(-1.4*T/dml_j)); S2_j=dml_j/K_j*(0.076x0.207*T/dml_jX0.024*exp(-1.25*T/dmlJ); Ti_j=Sl/SO_j; Td_j=S2_j/Sl_j; else tune jnanner == 1 Ti_j=T_jXdml_j/2; Td_j—Ti/6; endif else if tune jnanner == 0

S0_j=l.0/(K_j *dml_j) *(0.287X0.21 *T/dml_jX 0.385 *exp(-l.57*T/dml ); Sl_j=l/K_j*(-0.186X0.784*T/dml_jX0.435*exp(-1.4*T/dml_j)); S2_j=d7nl_j/K_j*(0.076+0.207*T/dml_j+0.024*exp(-1.25*T_j/ώnl_j));

Td_j=S2_j/Sl_j;

Kp_j =0.43 *speedJactor *Sl_j; elseif tune jnanner —=1

Kp_j=0.43 *speedJactor *(T_jXdml 2)/K/(espXdml/2); Ti_j=T_j+dml/2; Td_j=(T_j *dml/2)/(T_jXdml/2); endif endif dst_j=0.5*(1.2463*dml_jX0.18822*T_j); h_j=ceil(5*0.2231 *T/Tsamp); for i=l:10, if /==/ Whirl; else

Whtι=0; endif endfor for i=l to DTCC_vector_length ylmjnemoi_j=klm_j*vectorjμ; y2mjnemθi_j=k2m_j *vectorjμ; yldjnemoy=kld_j*vectorjv; y2djnemθy=k2d_j *vectorjy; endfor

Rule-based Neural Conti-oller (RBNC) CAA

An overview of RBNC is shown in Fig. 6.

The control layer of the RBNC (38) consists of a single PID controller in the velocity form equipped with anti-windup protection, and is specified by the following procedure that is executed at each discrete time step k:

% INPUTS:

% Ts - sampling time of the PI confrol algorithm

% r(k) - reference signal

% y(k) - process output signal

% limit jamax, umin, sleM max, min - actuator limitation

% controller jnode - The controller mode

% ujnanual - controller output for the manual mode

% Kp, Ti, Td - Current PID controller parameters

% alfa- tracking constant

% beta - jump constant

% OUTPUTS:

% u(k) - confroller output without constraints

% uout(k) - confroller output with constraints

% INTERNAL SIGNALS (previous values stored for the next sample):

% y_l, y_2, u_l, ej., eu_l, r_l % RBNC CONTROLLER ALGORITHM

% Calculation of PID terms e(k) = r(k) - y(k);

Tt = alfa*Ti; % tracking time constant cO = Kp*(lXTs/Ti); % e(k) mμltiplier cl - -Kp; % e(k-l) multiplier β = -Kp *Td/(Ts 2); % y(k) multiplier fl = -2*f0; % y(k- 1) multiplier f2 = f0; % y(k-2) multiplier jump = Kp *(beta-l); % jump factor enters only when set point changed dPIe = c0*e X cl *e_l; % dP + dl terms using process error dDy =f0*y Xfl *y_l β*y_2; % dD term using process output du = dPIe X dDy jump*(r-r_l); % total incremental control signal including jump term

%Calculate unlimited controller output deltau du (Ts/Tt) *eu_l; % basic dP+dl+dD algorithm with anti-windup u(k)= u_l + deltau; % controller output without constraints

% Calculate the new value of u(k) (limited controller output) if controller jnode == Manual u(k) = ujnanual; deltau = u(k) - u_ l; endif

% Controller output limitation if deltau >= slewjnax, % Controller slew rate limit du - slewjnax; % upper bound else if deltau <= slewjnin du = slewjnin; % lower bound else du = deltau; % in linear regime endif

% Calculate the Total Controller output with constraints uin = u_l X du; . % Total controller output ifuin >= limit jμmax % Controller output limit uout(k) = limit jimax; % upper bound else if in <= limit jμmin uou(k)t = limit μmin; % lower bound else uou(k)t = uin; end

% Update internal signals for next sample eu = uout - uin; eu_l = eu; u_l — uout; e_l — e; r_l = r; y_2 —y_l; y_l = y;

The scheduling layer of the RBNC (39) (i.e. the RBNC Supervisor) performs switching of controller parameters in accordance with linguistic rules and the values of the process output and target set-point. The kernel of the RBNC Supervisor involves two 2-4-1 artificial neural networks (ANN) (44). The neurons of all but the output neuron possess sigmoidal compression. Each ANN is trained using a set of 11 coded linguistic rules. The object of the zone verification block (43) is to establish the indices of the current and target operating zones. An operating zone is defined as a region about each point where a local process model has been identified. The boundaries of each zone are taken as the mid-points between contiguous points at which a local process model has been identified. These two indices form the inputs to the ANNs in the RBNC Supervisor. The RBNC Supervisor decides which candidate controller to use while the process output is in transition from one operating point to another. % INPUTS:

% Ts - sampling time of the PI control algorithm % controller jnode - The controller mode % y(k) — process output signal % sp — target set point

% ZLM- is a matrix of zone limits ZLM- [ZL,, ZL₂, ...ZL„J for each operating zone % where ZL; contains values that are pertinent to each operating zone

% CPM- controller parameters matrix CPM= [CP, CP₂ ... CP_m] % where m is the number of local controllers, sorted by scheduling variable

% CPy are local PID controller parameters, CPy = [Kp_j Ti_j Td_j S_jJ^T

% s - the current scheduling variable

% LMj = [ay, a_2j, by, by, du_j, s,J- local model parameters, delay and scheduling variable position, .extracted from the- MFM _ (second order models: ay ==-ό₂y-= 0)

% model jDrder - model order of the MFMs % OUTPUTS: % zone - zone index uniquely specifying the current operating zone and corresponding optimum ^' % controller parameters

% RBNC NEURAL RULE-BASED SUPERVISOR ALGORITHM Step 1: determine zone index of y Step 2: determine zone index of sp

Step 3: determine whether to use increscent or decrescent switching logic that guarantees asymptotic stability between contiguous operating Zones. The procedure makes use of the Jury stability test. The increscent switching logic has the following steps:

1) if the target set-point is in the same Zone as the current operating Zone then do not alter the Controller parameters

2) if the target set-point is in a Zone higher than the present operating Zone then increment the Zone index successively (and apply the corresponding Controller parameters) until the target Zone is reached.

3) if the target set-point is in a Zone lower than the present operating Zone then starting from the current Zone parameters decrement the Zone index successively (and apply the corresponding Controller parameters) until the target Zone is reached. while the decrescent switching logic has the following steps:

1) if the target set-point is in the same Zone as the current operating Zone then do not alter the Confroller parameters

2) if the target set-point is in a Zone higher than the present operating Zone then starting from the current Zone parameters, increment the Zone index successively (and apply the corresponding Controller parameters) until the target Zone is reached.

3) if the target set-point is in a Zone lower than the present operating Zone then, decrement the Zone index successively (and apply the corresponding Controller parameters) until the target Zone is reached.

The tuning layer of the RBNC (40) uses a stochastic procedure, and. in particular Simulated

Annealing based on. the Metropolis Algorithm with an embedded Jury stability test (45), to compute the globally, optimum parameters of the PID controller corresponding -to each operating zone.

% INPUTS:

% Ts - sampling time of the PI control algorithm % controller jnode - The controller mode

% LM_j = [ay, ay, by, b_2j, du_Jt S_jJ- local model parameters, delay and scheduling variable

% position, extracted from the MFM (second order models: a_2j = b₂ = 0)

% OUTPUTS:

% CP* = [Kp Ti Td s ]^τ - optimum controller parameters at the current scheduling variable s

% beta - - jump constant

% RBNC TUNING ALGORITHM

Step 1: determine the time to reach 63% of final value of step response

Step 2: using the Persson and Astrom technique compute estimate of the parameters of the sub-optimum PID or PI controller Step 3: test stability of the closed system with the corresponding LMj using the Jury test Step 4: use the Simulated Annealing search algorithm with embedded Jury test to compute the globally optimum controller parameters

6. Control Performance. Monitor (CPM)

CPM analyses the buffer of recent real-time signals, prepared by SPA, and estimates features of closed-loop control response when conditions are appropriate. It is invoked periodically. Since it is a computationally intensive task, it runs as a low-priority task in a multitasking operating system. It consists of three submodules: the Buffer Founder (BF), the Situation. Classifier (SC)

(57), and the Performance Estimator (PE) (58).

When CPM is invoked, BF forms new dynamic buffers from the current buffers according to the process conditions so that only the correct data are sent to SC. SC scans- the buffer for the last recognisable event,; such as a step change of the reference, a step change of the measured disturbance, an unmeasured disturbance, a steady state, or oscillation. If such an event is detected, the corresponding section of the buffer . is . sent to PE, otherwise the execution is terminated.

For the detected events, PE may extract the following features: overshoot, settling time, rise time, oscillation, tracking error, regulation error.

The following procedure is carried out whenever CPM is invoked, as illustrated in Fig. 7:

Copy of real data buffer (47)

Steady State check (48)

Data Filtration (49)

Reference and Measured Disturbance analysis (50)

Oscillation check (51) Noise/Signal Estimation (52)

Transient process settlement check (53)

Steady State check (54)

Features Estimation (55)

Performance Index calculation (55)

Send Results to Operator Supervisor and Human Machine Interface (56)

Copy of real data buffer:

This module calls functions, which copy a part of the real-time data buffer for background processing. The so-formed arrays r, y, u, and v are the main CPM input parameters.

Steady state check:

By using peak-to-peak and linear fit criteria, this module checks whether all signals r, y, u, and v in the active buffer have reached steady state (SS). If so, there is nothing to evaluate and the processing is terminated; if not, the algorithm continues with the main part of CPM.,

Filtration:

This module performs filtering of the input y and v buffers (if requested). Three filtering methods may be used: moving average, exponential, or fourth differences.

Reference and Measured Disturbance analysis:

The main task of this module is checking the input r and v buffers for a change. If a step-wise change of either signal is recognized, the CPM continues, with oscillation checking routine. If there is an unrecognised event, the CPM sends "UNRECOGNIZED EVENT" message to the operator panel and terminates any further computations.

Oscillation Check:

This module checks the CV buffer for oscillation by comparing the deqay ratio to its. threshold. The main task of this checking routine is to detect oscillation as .soon as possible. This procedure is intended for avoiding accidents or undesired CV behaviour. If oscillation is detected, the_CPM terminates and sends a flag to the Operation Supervisor for switching to the safe mode.

Noise/Signal Estimation: The main task of this module is calculating the Noise/Signal ratio of the controlled variable. An estimate of the noise variance is calculated on the base of a segment of the CV buffer before the registered change. The requested minimum data can be specified. The amplitude of the signal is calculated as an absolute value of the difference between the past and the new steady state value of MD (if there is a MD change) or as the absolute value of the reference change (if there is a SP change). The calculated ratio is compared to a configured threshold.

If the threshold is not exceeded, the CPM processing of the buffer continues, otherwise it is terminated.

Transient process settlement check:

Check if the transient process has settled to a new steady state. If not, the processing is terminated.

Steady State check:

Check if the process was in steady state before the recognized event. If not, the processing is terminated.

Send Results to Operator Supervisor and Human Machine Interface (HMI):

This module comprises functions that send messages to HMI; and the flag to that indicates a request for switching to the safe mode to the Operation Supervisor.

Features Estimation:

This procedure computes the transient process features like overshoot, settling time, rise time, oscillation, tracking error, and regulation error when the conditions are appropriate.

appropriat _conditions = -oscillation ietected AND noisejsigiτal < noise_signal hreshold

AND fransient jprocessjinish AND steady tatejbej ^co ^•e_xchange; if (reference _ orjneasured_disturbance :hange AND appropriat _ conditions)

Calculate overshoot, settling time, rise time, oscillation, tracking error, and regulation error;

Performance Index calculation; endif Performance Index calculation

Based on the computed process features (overshoot (59), settling time (60), decay (61) ) a generalized criterion for the quality of the transient process is computed by using fuzzy rules in Fig. 8. This criterion is called Performance Index (PI) (62). For each process feature a set of linguistic variables is introduced — poor, good, and excellent. A rule table based on expert knowledge is created (Fig. 9) which maps the PI values and all combinations of feature values. PI has five linguistic variables - poor, satisfactory, good, very good, excellent, corresponding to the following values; 0.0, 0.25, 0.5, 0.75, 1.0. From the received value of PI using the defuzzyfϊcation procedure the transient response quality is evaluated. PI lower than 0.25 triggers a request for switching to the Safe mode, while PI between 0.25 and 0.5 results in a sending warning message to the HMI.

BEST MODES FOR CARRYING OUT THE INVENTION

The run-time module (RTM) of the proposed controller, including all described agents, is intended for implementation on a capable programmable logic controller (PLC) or an embedded controller. One of the test platforms consists of a Mitsubishi A1S series PLC with an INEA IDR SPAC20 coprocessor, based on the TMS320C32 digital signal processor of Texas Instruments, running at a clock frequency of 40 MHz and with 2MB of RAM. The initial configuration of the RTM is performed using a Configuration Tool (CT), running on a personal computer, that is used for transferring the RTM parameters to the PLC and includes a "wizard" that guides the engineer through the configuration of initial parameters.

The operation of the controller is illustrated with an application for pH control of a simulated neutralisation process in Fig. 10, described in detail in (Henson & Seborg 1994, Kavsek- Biasizzo & al. 1997, Gerksic & al. 2000). An acid stream (63), a buffer stream (64) and a base stream (65) are mixed in a tank. The acid and base streams are equipped with flow control valves. The pH of the mixture is measured with a sensor located downstream (66). The effluent pH is the controlled variable y, and the manipulated variable u is the flow of the base stream Q3. The static characteristic of the process is highly non-linear and its open-loop gain changes by the factor 8, so it is very difficult for control with a conventional PID controller. The non-linear model simulated on a personal computer using Matlab/Simulink of The MathWorks, Inc., was used in the role of the real process, while the controller on the PLC was using a model obtained by online learning. The operating range between pH values 6 and 8 was covered with five local models placed, at positions 6, 7, 7.15, 7.4, and 8, with respect to the known ti ration curve. s(k) = 0.3 y(k) + 0.7 r(k) was used as the scheduling variable. Each local model was trained with online learning through an open-loop experiment consisting of three step-changes of u of small amplitude about the operating point, and the local controllers were tuned automatically from the local models. In the upper part of Fig. 11, the process output (67) follows the reference signal (68) reasonably well under FGSC control, while the performance of a fixed PI confroller in the lower part (69, 70) is much worse. The PI controller, which is also used as the Safe mode, is tuned for stable performance in the high-gain operating area around pH 8, however its operation in the low-gain region below pH 7 is sluggish.

REFERENCES:

Astrδm, K. J., Wittenmark, B., 1995, Adaptive control. Addison- Wesley Publishing Company,

Inc., Reading, Massachusetts. Bequette, B.W., 1991, Non-linear Confrol of Chemical Processes: A Review. Ind. Eng. Chem.

Res, Vol. 30, pp. 1391-1413. Gerksic, S, Juricic, D, Strmcnik, S, Matko, D, 2000, Wiener model based non-linear predictive control. International Journal of Systems Science, Vol. 31, No. 2, pp. 189-202. Henson, M. A, Seborg, D. E, 1994, Adaptive. non-linear control of a pH neutralisation process:

IEEE Transactions on Control Systems Technology, Vol. 2, pp. 169-182. Henson, M. A, Seborg, D. E, 1997, Non-linear Process Control. Prentice-Hall PTR, Upper

Saddle River, NJ. , Kavsek-Biasizzo, K, Skrjanc, I, Matko, D, 1997, Fuzzy predictive control of highly non-linear pH process. Computers & Chemical Engineering, Vol. 21, pp. S613-S618. Ljung, L, 1987, System Identification. Prentice Hall, Englewood Cliffs, NJ. Murray-Smith, R., Johansen, T. A, 1997, Multiple Model Approaches to Modelling and

Control. Taylor & Francis, London. Qin, S. J, Badgwell, T. J, 1998, An Overview of Non-linear Model Predictive Control

Applications. Proc. Non-linear Model Predictive Control Workshop Ancona '98, Ancona,

Birkhauser Verlag AG, Basel (2000). Sjδberg, J, Zhang, Q, Ljung, L., Benveniste, A, .Deylon, B, Glorennec, P.-Y, Hjalmarsson,

H, Juditsky, A._; 1995, Non-linear Black-Box Modeling in System Identification: a

Unified Overview. Automatica 31(12), pp..1691.-1724. Vrancic, D, Strmcnik, S, Juricic, D, 2001, A magnitude optimum multiple integration tuning method for filtered PID controller. Automatica, vol. 37, pp. 1473-1479.

Claims

1. A self-tuning non-linear controller that is based on a multi-faceted model comprising a set of first-order discrete-time linear local models with time delay and offset and second-order discrete-time linear local models with time delay and offset which are placed at different positions of a scheduling variable s, that can be as a whole interpreted as the Takagi-Sugeno fuzzy model.

2. The self-tuning non-linear controller of Claim 1 including an online learning procedure for the said Takagi-Sugeno fuzzy model that processes a batch of recent process signals and comprises the said steps of excitation check, selection of local models, identification of selected local models, and verification/validation of selected local models.

3. The self-tuning non-linear controller of Claim 1 using a model identification procedure for the said Takagi-Sugeno fuzzy model based on the linear instrumental variables identification procedure where each of sufficiently excited local models passes the said procedure of the said initialisation of the vector of parameters θy and the covariance matrix Py, the further approximation of Py and θ using weighted least-squares identification with a dead-zone, and obtaining the final estimate of them through weighted instrumental-variables identification, or several iterations of instrumental-variables identification.

4. The self-tuning non- linear controller using a model identification procedure of Claim 4 with the said reduced vectors of model parameters when excitation from either the manipulated variable u or the measured disturbance v is not present, and/or a lower_, order model is used.

5. The self-tuning non-linear controller of Claim 1 including an interchangeable Control Algorithm Agent that is organised in the said three-layer structure, where ,

• the control layer alone includes the functionality of an industrial controller and, may act as a linear controller individually,

• the scheduling layer performs switching . or scheduling (blending) of tuned local linear controllers, so that in conjunction with the control layer a fixed-parameter non-linear confroller is realised, • the tuning layer performs automatic tuning of controller parameters from the multi-faceted model whenever new local models are generated and automatic tuning is enabled.

6. The self-tuning non-linear controller of Claim 1, comprising a control algorithm that uses fuzzy parameter-scheduling of a PID controller in which

• the PID controller is implemented in the velocity form with anti-windup protection, that enables blending of the local controllers in the manner of velocity-based linearisation based control design

• the scheduling layer schedules the values of the continuous-time PID controller parameters Kp and Td and the inverse value of Ti, so that actually the poles and zeros of the controller's continuous-time transfer function are being scheduled.

7. The self-tuning non-linear controller of Claim 1 comprising a control algorithm that uses a Rule-Based Neural Supervisor that enforces the optimum parameters of a PID controller in which

• the PID controller is implemented in the velocity form with anti-windup protection, permitting selection of the optimum local controller candidate for every, operating zone for which a process model has been identified.

• the Rule-Based Neural Supervisor determines the optimum values of the continuous-time PID controller parameters Kp and Td and the inverse value of Ti and enforces them in a step-wise manner, ensuring that the PID controller always yields optimum control performance about the operating points for which process models have been identified, while guaranteeing absolute stability of the controlled process When it is in transition between adjacent zones.

8. The self-tuning non-linear controller of Claim 1 comprising a control algorithm that uses a non-linear Predictive Functional Controller, which is characterized by blending of the outputs of a finite number of basic time invariant predictive functional confrollers, working in parallel, where the changeable weights of the basic controllers depend on the state of the plant in the resident plant models space.

9. The self-tuning non-linear controller of Claim 1 comprising a confrol performance monitoring agent, characterised by • periodically performing batch-wise analysis of the buffer of recent real-time signals with the purpose of extracting features of recognised events when possible

• the structure consisting of the Buffer Founder, the Situation Classifier, and the Performance Estimator submodules

• the buffer processing procedure comprising the steps of steady state check, data filtration, reference and measured disturbance analysis, oscillation check, noise/signal estimation, transient process settlement check, steady state check, features estimation, and performance index calculation.

10. A self-tuning non-linear controller consisting of a Signal Preprocessing Agent, an Online Learning Agent, a Model Information Agent, a Confrol Algorithm Agent, a Control Performance Monitor, and an Operation Supervisor, where

• the Signal Preprocessing Agent prepares the said process signals r, u, y, v and s for real-time confrol and stores them to a buffer for batch-wise post-processing,

• the Confrol Algorithm Agent performs non-linear confrol based on the said multi-faceted model in real time and automatically retunes the controller from the multi-faceted model,

• the Online Learning Agent periodically inspects the buffer of recent real-time signals and extracts new model information when appropriate,

• the Model Information Agent maintains the active multi-faceted model,

• the Control Performance Monitor periodically inspects the buffer of recent real-time signals and extracts features of closed-loop performance of detected events, that may be used to trigger modification of Operation Supervisor configuration,

• the Operation Supervisor coordinates confroller operation.