关 键 词：

同步 发电机 系统 触发 控制 研究 吕媛

资源描述：

同步发电机励磁系统自触发控制研究_吕媛,同步,发电机,系统,触发,控制,研究,吕媛

内容简介：

On Self-Triggered Control for Linear Systems: Guarantees and ComplexityManuel Mazo Jr., Adolfo Anta and Paulo TabuadaAbstractTypical digital implementations of feedback con-trollers periodically measure the state, compute the controllaw, and update the actuators. Although periodicity simplifiesthe analysis and implementation, it results in a conservativeusage of resources. In this paper we drop the periodicityassumption in favor of self-triggered strategies that decidewhen to measure the state, execute the controller, and updatethe actuators according to the current state of the system.In particular, we develop a general procedure leading to self-triggered implementations of feedback controllers, that highlyreduces the number of controller executions while guaranteeinga desired level of performance. We also analyze the inherenttrade-off between the computational resources required for theself-triggered implementation and the resulting performance.The theoretical results are applied to a physical example toshow the benefits of the approach.I. INTRODUCTIONFeedback control laws are traditionally implemented ina periodic fashion due to the ease of design and analysis.However, this approach represents a conservative solutionsince the controller is updated at the same rate regardless ofthe current state of the plant. A system could be on a stablemanifold of the state space and therefore require little or noattention, while if the system lies on an unstable manifold,it might demand faster updates. Periodic implementationscannot take advantage of this fact because they disregardthe information contained in the state. Moreover, the periodis usually selected to guarantee a desired performance underworst case conditions even though these might rarely occur.Although there is a vast literature on periodic implementa-tions of feedback control laws, ad hoc rules are still appliedto determine stabilizing periods (for instance, 20 times thebandwidth of the system).With the advent of embedded and networked controlsystems, greater functionality is expected and control loopsno longer have at its disposal dedicated computational andcommunication resources. While traditionally the implemen-tation aspects were ignored at the design stage, this can nolonger be done. Hence, intensive research is being currentlyconducted to ascertain the real-time requirements of con-trol systems. Several researchers proposed resource-awareimplementations of control laws, such as event-triggeredcontrol (1, 2, 3, 4). Under this paradigm, the controllerexecution is triggered according to the state of the plant.M. Mazo Jr, A. Anta, and P. Tabuada are with the Department ofElectrical Engineering, Henry Samueli School of Engineering and Ap-plied Sciences, University of California, Los Angeles, CA 90095-1594,mmazo,adolfo,This work has been partially funded by the NSF CSR-EHS 0712502grant, a Spanish Ministry of Science and Education/UCLA LA20040003fellowship and a Mutua Madrile na Automovil stica scholarship.This approach calls for resources whenever they are indeednecessary, and it provides a high degree of robustness, sincethe system is being permanently monitored. However, theseimplementations require, in general, dedicated hardware tocontinuously monitor the state of the plant. Moreover, event-triggered control systems lack a systems theory that facili-tates the analysis of such systems.To overcome these drawbacks of event-triggered systems,in this paper we advocate the use of self-triggered imple-mentations. The underlying idea is to emulate the event-triggered implementation without resorting to extra hard-ware. In most control systems, the state of the plant hasto be measured or estimated. Thus, this information can beused by the controller to decide its next execution time. Theself-triggered approach was previously studied in 5, wherethe next execution time is treated as a new state variable.Although it represents an important step towards resource-aware implementation, no guarantees of correct operation orperformance were provided. Self-triggered control was alsoanalysed in 6, for the particular class of full-informationHcontrollers. It was also explored in 7 for distributedsystems and in 8 for a class of nonlinear systems.In this paper, we show how to obtain a self-triggeredimplementation of any linear state-feedback controller sta-bilizing a linear control system. Moreover, the resultingself-triggered implementation preserves exponential stabilitywhile reducing the number of executions of the controller.We also study the trade-off between the complexity of theimplementation and the resulting control performance.The rest of the paper is organized as follows: Section IIintroduces some preliminary notation and definitions, Sec-tion III defines event-triggered control and self-triggeredcontrol and introduces the problem we tackle in this paper.Sections IV and V describe the proposed self-triggeredimplementation. The performance guarantees and complexityof the implementation are provided in Section VI. Someexamples illustrating the proposed techniques are presentedin Section VII. Related topics such as robustness of theself-triggered approach and non-zero computation delays arebriefly discussed in Section VIII. The proof of the maintheorem in the paper is included in Appendix IX.II. NOTATIONWe denote by N+the positive natural numbers, and R+to the positive real numbers. We also use N+0= N+ 0and R+0= R+ 0. The usual Euclidean vector norm isrepresented by |. The set of eigenvalues of the matrix A isindicated with i(A). A function : 0,a R+0, a 0is of class K if it is continuous, zero at zero and strictlyincreasing. A continuous function : R+00,a R+0is ofclass KL if (,) is of class K for each 0 and (,s) ismonotonically decreasing to zero for each s 0. A class KLfunction (,s) is called exponential if (,s) ksec,k 0, c 0.III. PROBLEMSTATEMENTThe problem we aim to solve is that of finding an efficientsample-and-hold implementation of a linear controller. Inthis context an implementation will be more efficient thananother when it requires fewer executions to achieve thesame stability performance. Before formally introducing theproblem we tackle in this paper, we need to introducethe notions of Event-Triggered Control and Self-TriggeredControl.A. Event-triggered control.Assume a linear control system: x = Ax + Bu,x Rn,u Rm(1)and a linear feedback controller:u = Kx(2)rendering the closed loop asymptotically stable. For a con-tinuous implementation we have xc= (A + BK)xc, hencethere exists a Lyapunov function Vc(t) := xTc(t)Pxc(t) suchthat:Vc=xTc!(A + BK)TP + P(A + BK)xc(3)=xTcQxc(4)with P satisfying the Lyapunov equation:Q = (A + BK)TP + P(A + BK)(5)for some positive definite matrix Q.Now let the control signal be obtained from sample andhold measurements:u(t) = Kx(tk),t tk,tk+1where tkand tk+1are two consecutive sampling instants.We will call to any implementation in which the controlsignal is held constant between executions, not necessarilyperiodic, a sampled-data system. The closed loop dynamicsunder a sample and hold implementation of the controller isdescribed by: x=Ax + BKx(tk)=(A + BK)x + BKe(6)where e represents a measurement error defined by:e(t) := x(tk) x(t),t tk,tk+1(7)Treating e(t) as a new state variable we can rewrite the statespace representation of the system as:# x e$=#A + BKBKA BKBK$#xe$(8)The selection of the sequence of update times tk atwhich the controller is updated will determine the behaviorof the sampled-data system. In a periodic implementation,we have tk+1= tk+T, k N+0, for some specified periodT 0. In contrast with a periodic implementation, an event-triggered strategy defines the sequence tk implicitly as thetimes at which some triggering condition is violated. We startthis paper by proposing one such triggering condition.Define the function V (t,x0) := x(t)TPx(t), where x(t)is a solution of (1), x(0) = x0, and P is a positive definitematrix. The specification is defined by a function S : R+0Rn R+0upper-bounding the evolution of V . Hence, theupdate times tkare determined by the time instants at which:V (t,x0) S(t,x0), t t0(9)is violated. An event-triggered implementation will recom-pute the controller whenever V (tk,x0) = S(tk,x0), in orderto prevent the violation of its triggering condition (9). Werefer to S(t,x0) as the performance function from here on.We will drop the explicit dependence on x0of V and Swhenever it is clear from the context.B. Self-triggered control.The self-triggered control paradigm aims at obtaining amap relating the current state x(tk) with the next samplingtime: h : Rn R+, h(x(tk) = tk+1. This map shallprovide with an emulation of the events generated by sometriggering condition, e.g. condition (9). If constructing suchh() is possible, a self-triggered implementation provideswith the same inter-execution times as an event-triggeredimplementation. Furthermore, the self-triggered implemen-tation does not require continuous monitoring of the state.Now we can introduce the problem we tackle in the presentpaper.Problem 3.1 (Self-Triggered Control Design): Givenalinearcontrolsystem(1),alinearstatefeedbackcontroller(2),anoutputfunctionV (t,x0),andaperformancefunctionS(t,x0),findaself-triggeredimplementationachievingapredefinedperformancespecified as a bound on the evolution of Vby S, i.e.V (t,x0) S(t,x0).IV. PERFORMANCESPECIFICATIONThe first step in the design of our self-triggered implemen-tation is to specify the desired performance. It is straight-forward to conclude that an event-triggered implementationbased on (9) with S(t,x0) (t,|x0|),x0 Rn,where (t,|x0|) KL, renders the system (1) uniformlyglobally asymptotically stable 9. Furthermore, if (t,|x0|)is an exponential KL function, the system is uniformlyglobally exponentially stable 9. We are only interested inspecifications implying at least asymptotic stability of thesystem, but we do not restrict ourselves to the case whenS(t,x0) := (t,|x0|), for (t,|x0|) KL.Moreover, in order for an event-triggered or self-triggeredimplementation to be of any use, the inter-execution timestk+1tkshould be lower bounded by some positive quantity,i.e. tk+1 tk tmin 0. To enforce inter-executiontimes greater than zero it is sufficient to design S satisfyingV (tk) 0 is the discretization step. Analogously, zs=Gszsand Ts:= eGs. As a consequence, now we cancompute the value of V (t) and S(t) at t = tk+ r:V (tk+ r) = LTrz(tk)S(tk+ r) = LTrsz(tk)only from the initial condition x(tk).Let us define rmin:= )tmin* and rmax:= )tmax*, wheretmaxis the maximum time the system is allowed to run inopen loop (a design parameter), and tminas defined in (19).The discretized model just provides with values of z at timestr= tk+r, r N+o. The next execution time satisfying (9)could be computed as:tk+1=tk+(rmin+min(j : j 0,j+1 0)1) (20)where j= S(tk+(rmin+j1)V (tk+(rmin+j1)is the jthentry of the vector defined as: =Lz(tk),L =L(Trmins Trmin)L(Trmin+1s Trmin+1).L(Trmaxs Trmax)(21)The vector represents the discretized evolution of thetriggering condition (9). The fact that eT(tk) = 0 will letus have a more efficient implementation in terms of memoryusage. We will address these issues in the next section. Alsonotice that the matrixL is computed only once at designtime, and the only terms to be computed online are z(tk)and the productLz(tk).The proposed policy ensures that V (r) S(r),r N+0, but does not establish any bound on V (t) at thosepoints t += r. At those points V (t) might be greater thanS(t) and we could not detect it. To overcome this drawback,we develop in the following section a bound for V (t) in thespirit of those in 11, in order to provide with a performanceguarantee under the self-triggered policy (20).VI. MAINRESULTSWe establish the performance guarantees achieved by theself-triggered protocol (20) in the following theorem:Theorem 6.1 (Guaranteed performance): The linear sys-tem (1), with control law (2) under the implementationdefined by (20), with S(t) defined as in (10) and asdiscretization step satisfies:V (t,x(tk) g(,rmax)S(t,x(tk), t tk,tk+1 (22)where:g(,rmax):=e(+)+ e(rmax1)e(+) e :=maxi“i(FTpI +IFp)” :=mini“i(FTpI +IFp)”:=maxi“i(R)”,R := P12RP12Fp:=P12AP12P12BKP1200,I :=Inn000Corollary 6.2 (Exponential Stability): Theimplementa-tion is uniformly globally exponentially stable with:V (t)(t,|xs(t0)|) := g(,rmax)|xs(t0)|et, t R+0:=mini“i(R)”The proof to the theorem is included in the appendix.Tighter, but more convoluted, bounds than the ones pre-sented in the theorem can be obtained through equa-tions (33) and (34) in the appendix. The proof of the corollaryis trivial. The value g(,rmax) can be regarded as a measureof the degradation of the performance as a function of andrmax. One can also see this measure of degradation in theform of a delay, i.e. V (t) |xs(t0)|e(t), with the delaygiven by: =1log(g(,rmax)(23)When discussing the space and time complexity of theproposed self-triggered strategy, we shall use Msto denotespace complexity and Mtto denote time complexity. Notethat Msand Mtonly describe the space and time complexitythat are needed to go from a periodic implementation toa self-triggered implementation. Regarding time complex-ity, we assume a unitary cost for products, additions andcomparison operations. We summarize the complexity of im-plementing the self-triggered protocol (20) in the followingTheorem:Theorem 6.3 (Implementation Complexity): Then-dimensional linear system (1), with control law (2)under the implementation defined by (20), with S(t) definedas in (10) and as discretization step requires Msunits ofmemory and Mtcomputations, for:Ms:=N()n(n + 1)2(24)Mt:=2Ms+ N() +n(n + 1)2(25)with N() := )tmax* )tmin*.Proof:Spacecomplexity:N()vectorsareneededtocheck the condition (9) at the different times tk+ r,r = )tmin*.)tmax*. Since e(tk) = 0, instead of stor-ing the matrixLRN()2n(2n+1)2that multiplied2(xTeTT), we can select the subset of its entries cor-responding to only 2(x). Thus the matrix of vectors to bestoredLxhas size N()n(n+1)2.01020406080100120t s S(t)V(t)Fig. 1.Lyapunov function decay and performance function S(t)for =1 ms.Time Complexity: The operation =Lxzx(tk), withzx= 2(x) requires N()n(n+1)2products and the sameamount of additions, besides then(n+1)2products necessaryto compute the embedding 2(x). Moreover, we need to findthe first change of sign in the vector which requires N()comparisons. Adding all those terms proves the expressionprovided.Theorem 6.3 describes the main trade-offs in this self-triggered implementation: decreasing the discretization step increases the complexity linearly, but improves the per-formance guarantee exponentially through g(,rmax).VII. EXAMPLETo illustrate the performance of the proposed self-triggered implementation we borrow the Batch Reactormodel from 12 with state space description: x=2641.380.206.715.670.584.2900.671.064.276.655.890.044.271.342.10375x+264005.67030375uA state feedback controller placing the poles of the closedloop system at 3 + 1.2i,3 1.2i,3.6,3.9 is givenby:K =#0.10060.24690.09520.24471.40990.19660.01390.0823$The matrix Q is set to the identity Q = I, R = 0.5Q, andP is obtained from solving the Lyapunov equation (3).We can already compute the minimum time, tmin= 20msusing (19). We first select tmax= 300ms and = 1ms.With this design the complexity becomes Ms= 2810 andMt= 5911. The worst-case required computational speed(Mtcomputations in tmin) does not represent an impedimentfor current microprocessors. Figure 1 depicts the evolution ofthe Lyapunov function V (t) against the performance functionemployed in the design: S(t). We zoomed in the first secondto better appreciate the triggering condition and the effect ofsetting a maximum inter-sample time. We have also markedwith vertical dashed lines the instants at which a new updatehappens; see also Figure 2 which depicts the evolution ofthe inter-execution times.We use the delay as the measure of the performanceguarantees. Tables I and II, present the different values of as and tmaxvary. Although the performance guaranteesdegrade with , simulation results show only a modestdegradation with of the achieved performance. This is!#$%&()*!+!&!+!+&!+#!+#&!+$!+$&,-./0,1!,1!-./0Fig. 2.Inter-execution times for =1 ms.012345678910020406080100120ts !=1ms!=2ms!=3ms!=10ms(t,|xo|)Periodic 20msFig. 3.Evolution of V (t) for different values of .illustrated in Figure 3 and in Table I by looking at thenumber of controller updates in 10s. On the other hand wecan see how increasing the time tmaxhas a negative effecton the guarantees, but does provide improvements in termsof number of updates (see Table II).The implementationcomplexity (Msand Mt) for those different values of andtmax, are summarized in Tables I and II.Finally, to illustrate the effect of the discretization step, we raised tmaxto 900ms, and simulated the systemwith initial conditions x() = 6sin() 6cos() 1 9T. InFigure 4 we present the inter-execution times produced by theself-triggered protocol with different values of for initialconditions with ranging from 0 to 0.5 radians. We canclearly appreciate the quantizing effect of on the inter-TABLE IIMPLEMENTATION COMPLEXITY AND PERFORMANCEAS A FUNCTION OFFORtmax= 0.3s,IN10s.Periodic (T=20ms)1ms2ms5ms10msMs028101410570290Mt0591129711207619s051.01Updates50062626263TABLE IIIMPLEMENTATION COMPLEXITY AND PERFORMANCEAS A FUNCTION OFtmaxFOR =5 ms,IN10s.Periodic (T=20ms)0.1s0.3s0.5s0.9sMs01705709701770Mt0367120720473727s00.240.551.425.75Updates500102624732!#!$!$#!%!%#!&!&#!#!#!&!&#!&(!&)!&*!&+!,-./0123!234$,-51,6$756%756#756$!75Fig. 4.Inter-execution times as a function of .execution times.VIII. DISCUSSIONThe self-triggered implementation, described in Section V,can be used for any state-feedback linear controller stabiliz-ing a linear plant. The case of dynamic controllers, althoughnot described in this paper, can be handled using similar tech-niques. Moreover, the performance degradation, described bythe term g(,rmax), can be suitably modified to accommo-date the influence of a non-zero delay between sensing andupdating the actuators, by following the methods describedin 4. Self-triggered and event-triggered implementationsare known to have some degree of robustness with respectto disturbances 13. The authors are currently investigatingthe trade-offs between the computational complexity of theimplementation and its robustness.Of independent interest is the method described in Sec-tion V to compute the minimum inter-execution time. Thismethod offers an alternative approach to the choice ofsampling periods for periodic implementations of linearcontrollers.REFERENCES1 K.Arz en, “A simple event based PID controller,” Proceedings of 14thIFAC World Congress, vol. 18, pp. 423428, 1999.2 K.Astr om and B. Bernhardsson, “Comparison of Riemann andLebesgue sampling for first order stochastic systems,” Proceedingsof the 41st IEEE Conference on Decision and Control, vol. 2, 2002.3 W. Heemels, J. Sandee, and P. van den Bosch, “Analysis of event-driven controllers for linear systems,” Int. J. of Control, pp. 81(4),571590, 2008.4 P. Tabuada, “Event-triggered real-time scheduling of stabilizing controltasks,” IEEE Transactions on Automatic Control, vol. 52(9), pp. 16801685, 2007.5 M. Velasco, J. Fuertes, and P. Marti, “The self triggered task modelfor real-time control systems,” Work in Progress Proceedings of the24th IEEE Real-Time Systems Symposium, pp. 6770, 2003.6 X. Wang and M. Lemmon, “State based Self-triggered feedbackcontrol systems with L2 stability,” 17th IFAC world congress, 2008.7 M. Mazo Jr and P. Tabuada, “On Event-