Source-linked AI summary
An ISS self-triggered implementation of linear controller
Manuel Mazo, Adolfo Anta, Paulo Tabuada
TL;DR
Digital and networked control systems motivate reducing controller updates without sacrificing closed-loop stability, especially under additive disturbances. The paper develops a state-based self-triggered implementation for linear controllers and shows EISS, tunable performance, and a computation–actuation trade-off.
Problem
The paper asks how to construct a self-triggered implementation for a linear stabilizing controller that enlarges inter-execution times while rendering the closed loop EISS.
Method
The method selects state-dependent update times using continuous- and discrete-time Lyapunov-based output maps, with design parameters controlling sampling and execution bounds.
Results
The proposed implementation guarantees exponential input-to-state stability under additive disturbances, with explicit gains affected by τmin, τmax, ∆, and λ.
Takeaways & Limitations
Increasing computational complexity can improve performance guarantees and enlarge inter-execution times, trading computation for actuation savings.
Takeaways & Limitations
The analysis assumes a linear plant with a linear stabilizing controller whose closed-loop matrix A + BK is Hurwitz.
Abstract
from arXiv · showhide
Nowadays control systems are mostly implemented on digital platforms and, increasingly, over shared communication networks. Reducing resources (processor utilization, network bandwidth, etc.) in such implementations increases the potential to run more applications on the same hardware. We present a self-triggered implementation of linear controllers that reduces the amount of controller updates necessary to retain stability of the closed-loop system. Furthermore, we show that the proposed self-triggered implementation is robust against additive disturbances and provide explicit guarantees of performance. The proposed technique exhibits an inherent trade-off between computation and potential savings on actuation.
1 Introduction
Self-triggered control adapts controller-update intervals to the plant state, reducing executions and resource use while raising robustness concerns during unattended intervals. The paper proposes a resource–actuation trade-off for linear systems with explicit stability and performance guarantees.
- Digital and networked control systems can share processor and communication resources with other applications, motivating resource-efficient implementations.
- Self-triggered control makes the interval between controller updates state-dependent, unlike periodic control, which executes every T units of time.
- Self-triggered implementations reduce controller executions but introduce robustness concerns during intervals when the plant receives no attention.
- The proposed linear-system implementation chooses large update intervals subject to computational limits while enforcing desired performance levels.
- Increasing computational resources improves performance guarantees and reduces controller executions, trading computation for actuation and communication savings.
2 Notation
This section establishes notation for linear control systems, Lyapunov functions, exponential input-to-state stability, norms, and matrix properties used in the analysis.
- The paper denotes the positive real numbers by R+ and uses R+_0 for the nonnegative real numbers.
- A control system is modeled as a linear differential equation with controlled input χ and essentially bounded, piecewise continuous disturbance δ.
- A linear feedback controller is the map u = Kx, and the associated closed-loop matrix A + BK is assumed Hurwitz when stability is required.
- A quadratic function V(x) = x^T P x is a Lyapunov function for ξ̇ = Aξ when P > 0 and A^T P + PA ≤ −2λI for some positive decay rate λ.
- EISS provides exponential state decay with a disturbance gain, and reduces to global exponential stability when δ = 0.
3 A self-triggered implementation for stabilizing linear controllers.
The paper constructs a state-based self-triggering map for a sampled linear controller, selecting update times that preserve EISS while imposing computational and inter-execution constraints.
- Problem and setup: The implementation computes the next update time from the current state through tk+1 = tk + Γ(ξ(tk)).
- Problem and setup: The target is a map Γ that enlarges inter-execution times while rendering the sampled-data closed-loop system exponentially input-to-state stable.
- Trigger construction: Continuous-time and discrete-time output maps, hc and hd, support a sampled-time approximation of the desired Lyapunov condition.
- Trigger construction: The discrete trigger searches admissible sample counts up to Nmax while enforcing hd(x, s) ≤ 0 for s = 0, . . . , n.
- Design constraints: τmin and τmax impose lower and upper bounds on inter-execution times; the upper bound supports robustness and limits computational complexity.
- Design constraints: Linearity makes hd quadratic in the sampled state, while a Veronese embedding enables implementation of the policy with stated space and time complexity.
4 Main results
The paper establishes stability and performance guarantees for the proposed self-triggered implementation while characterizing how design parameters affect execution timing, robustness, and computational cost. The results formalize the trade-off between longer inter-execution times and increased computation.
- Construction and timing: The discrete-time implementation Γd is a computable version of the ideal map Γc, whose generated inter-execution times are no smaller than τ∗.The ideal maximum time is τ∗(x) := min{Γc(x), τmax}, with τmax limiting the interval to obtain robustness against disturbances.
- Comparison with periodic implementation: The self-triggered approach provides inter-execution times no smaller than the periodic implementation, whose period must guarantee performance across all operating points.The same analysis also gives a formal procedure for selecting a periodic sampling period, or MATI, instead of relying on ad-hoc rules.
- Stability and performance: The proposed implementation renders the closed-loop system EISS with gains determined by the construction and its design parameters.The main result specifies how τmin, τmax, ∆, and λ affect the EISS gains.
- Stability and performance: Increasing τmax permits longer inter-execution times but degrades EISS gains unless ∆ is decreased, which requires more computation.Thus, performance can be traded against execution frequency through the design parameters.
- Digital implementation: The implementation requires accounting for measurement, computation, and actuation delays, with computation delays dominating in the described setting.The computation of Γd is divided into preprocessing and online steps, and processing-speed and ∆ constraints are identified.
5 Conclusions
The paper presents a self-triggered implementation for stabilizing linear feedback systems that guarantees exponential input-to-state stability under additive disturbances. Performance and complexity are tunable through design parameters, with greater computational complexity enabling stronger guarantees and longer inter-execution times.
- The implementation guarantees exponential input-to-state stability of the closed-loop linear system with respect to additive disturbances.
- Selecting ∆, λ, τmin and τmax tunes the resulting performance and implementation complexity.
- Increasing computational complexity improves performance guarantees and enlarges the inter-execution times between controller updates.
6 Appendix: Proofs
The appendix proves bounds used to establish the self-triggered stability result. It constructs bounds on a Lyapunov-like function, identifies the critical intersection time, and extends the argument to disturbances and implementation timing.
- The transformed proof introduces η(t) as the state difference from the last update and ζ as an augmented state satisfying linear dynamics.
- The minimum allowable continuous-trigger time is characterized through the Implicit Function Theorem and extrema of Γc.
- The proof introduces a lemma that bounds the evolution of a positive definite function along system trajectories over any finite interval.
- The disturbance-free proof uses W(x) = xT Px and derives trajectory bounds on each inter-update interval.
- The bound on W(rn + s) is maximized where its increasing and decreasing branches meet, at s = s∗.
- The resulting bound is independent of the controller-update index, completing the proof of the stated result.