Abstract
Traditional digital control systems rely on periodic sampling, which often leads to an over-utilization of computational and communication resources. This paper presents a self-triggered control strategy for linear systems that dynamically determines the next sampling instant based on the current state. By leveraging Lyapunov-based triggering conditions and discrete-time approximations, the proposed method ensures Exponential Input-to-State Stability (EISS) even in the presence of external disturbances. The approach effectively trades off local computation for reduced network traffic, making it ideal for resource-constrained Networked Control Systems (NCS).
Introduction
In modern embedded and networked control environments, managing shared resources like CPU cycles and network bandwidth is a primary engineering challenge. Most digital controllers operate on a rigid periodic schedule, where the sampling period $T$ is chosen to satisfy the worst-case stability requirements. While simple, this approach is inherently inefficient: when a system is near its equilibrium, it does not require the same high-frequency updates as it does during large transients.
To address this, "event-triggered" control was developed to initiate updates only when a specific error threshold is reached. However, event-triggering typically requires continuous monitoring of the system state to detect threshold crossings, which can consume significant power and hardware resources. This paper explores a self-triggered alternative, where the controller predicts the next required update time at the moment of the current execution, allowing the system to "sleep" in the interim.
Problem Formulation
The authors consider a linear time-invariant system subject to additive disturbances, represented by the state equation: $$\dot{\xi} = A\xi + B\chi + \delta$$ where $\xi$ is the state, $\chi$ is the control input, and $\delta$ represents external noise or disturbances. The goal is to design a triggering policy that minimizes the frequency of updates to the control signal $\chi$ while maintaining a desired level of performance and robustness.
The Self-Triggered Framework
Lyapunov-Based Triggering
The core of the proposed method is a Lyapunov function $V(x)$, which serves as a measure of the system's "energy." The triggering logic is designed to ensure that this energy decays at a specified rate $\lambda$. Rather than requiring the energy to decrease monotonically at every single instant, the authors allow for temporary fluctuations between updates, provided the overall trend follows the desired decay.
The $h_c$ and $h_d$ Maps
To implement this, the authors introduce a continuous-time output map, $h_c$, which monitors the deviation of the system's actual energy from the target decay path. The next update is theoretically triggered just before $h_c$ indicates a violation of the stability bounds.
Because digital processors cannot solve the transcendental equations involved in the continuous $h_c$ map exactly, the paper introduces a discrete-time approximation, $h_d$. This approximation is based on a small internal sampling time $\Delta$. The controller evaluates the condition at intervals of $\Delta$ to determine the largest possible integer $k$ such that the system remains stable until $k\Delta$.
Computational Efficiency via Veronese Embedding
To ensure the triggering condition can be computed quickly on embedded hardware, the authors utilize a Veronese embedding. This mathematical technique allows the quadratic triggering conditions to be evaluated with predictable space and time complexity, ensuring that the "cost" of calculating the next update time does not outweigh the communication savings.
Stability and Robustness
A significant contribution of this work is the rigorous proof of Exponential Input-to-State Stability (EISS). Unlike previous self-triggered methods that assumed a noise-free environment, this framework explicitly accounts for the disturbance term $\delta$. Theorem 4.2 in the paper provides explicit formulas for EISS gains, giving designers a mathematical guarantee that the system state will remain bounded proportional to the magnitude of the external noise.
Furthermore, the authors provide a method (Lemma 4.1) to calculate $\tau_{min}^*$, the absolute minimum time between updates. This lower bound is essential for real-time scheduling, as it prevents "Zeno behavior"—a theoretical loop where the controller attempts to trigger infinitely fast.
Key Insights and Results
- Resource Optimization: The framework demonstrates that as the internal computation frequency ($1/\Delta$) increases, the inter-execution times approach the theoretical maximum allowable limit, maximizing resource savings.
- Performance Tuning: Designers can tune the balance between system performance (settling time) and resource usage (CPU/network load) by adjusting the decay rate $\lambda$ and the approximation parameter $\Delta$.
- Hardware Considerations: The paper acknowledges the trade-off between computation and communication. For extremely high-speed plants, the overhead of the self-triggered calculation might be prohibitive, but for most networked systems, the reduction in communication frequency provides a net benefit.
Conclusion
This self-triggered implementation provides a robust and computationally feasible alternative to periodic control for linear systems. By shifting the burden from continuous monitoring to predictive computation, the method ensures stability and disturbance rejection while significantly reducing the load on shared communication and processing infrastructure. Future work may involve extending these efficient computational techniques to non-linear system dynamics.
Summary updated