Abstract
Event-triggered and self-triggered control have recently been proposed as alternatives to the well established periodic implementation of control loops on digital platforms. In a self-triggered implementation, the control task is responsible for computing the new actuator values as well as the next instant of time at which the state should be sampled, the control law recomputed, and the actuator values updated. In between these time instants, the system under control requires no attention and can operate in open loop. Self-triggered implementations can be seen as double edged swords: on the one hand, by using the state of the plant to determine when the control law needs to be recomputed, desired levels of control performance are enforced while drastically reducing the resources (processor time, communication bandwidth, etc) used for control; on the other hand, by operating the plant in open loop for extended periods of time, robustness of self-triggered implementations becomes an honest concern. In this paper we propose a self-triggered implementation for linear systems achieving exponential input-to-state stability, hence addressing the robustness concerns. Moreover, the proposed implementation computes the largest possible times during which the plant can operate in open loop while meeting desired performance levels and subject to the computational capabilities of the digital platform.
Introduction
In the realm of cyber-physical systems, the traditional approach to digital control relies on periodic sampling. While straightforward to implement, periodic control often results in an inefficient use of resources—processor cycles, network bandwidth, and battery power—by updating actuators even when the system state is stable. Event-triggered control (ETC) emerged as an alternative, triggering updates only when a performance threshold is breached. However, ETC necessitates continuous sensor monitoring to detect these events.
This paper explores Self-Triggered Control (STC), a paradigm where the controller proactively determines the next time it needs to sample the state and update the control law. By allowing the system to operate in "open loop" for calculated intervals, STC offers a significant reduction in communication and actuation frequency. The authors specifically address the robustness of such systems, proposing a framework for linear systems that ensures Exponential Input-to-State Stability (EISS).
The Mechanics of Self-Triggered Control
The core innovation of STC lies in its ability to predict future behavior. Instead of reacting to an error (as in ETC), the controller uses the current state $\xi$ to solve for the largest possible time interval $\tau$ during which the system can remain unattended without violating stability constraints.
Lyapunov-Based Scheduling
The authors utilize a Lyapunov function—a mathematical representation of the system's "energy"—to derive these intervals. Traditionally, stability requires this energy to decrease monotonically at every instant. This paper relaxes that constraint, defining an Output Map ($h_c$) that tracks whether the system stays within a predefined "decay envelope." As long as the system is guaranteed to return to a stable trajectory by the next update, it is permitted to "wander" within safe bounds in the interim.
Computational Efficiency: Veronese Embedding
To make the calculation of the next update time ($\tau$) feasible for embedded microcontrollers, the authors employ a Veronese embedding. This mathematical technique transforms a potentially complex optimization problem into a simpler quadratic function of the current state. This allows the controller to determine the next sampling instant with a computational complexity of $O(m^2)$, where $m$ is the state dimension.
Robustness and Input-to-State Stability (ISS)
A primary concern with open-loop operation is the impact of external disturbances ($\delta$) and modeling inaccuracies. If a system "sleeps" for too long, an unforeseen disturbance could push it into instability.
The authors address this by proving that their implementation achieves Exponential Input-to-State Stability (EISS). This guarantee ensures that the state remains bounded relative to the magnitude of the disturbances. Even in the presence of noise, the system's "sleep timer" is calculated to maintain a safety margin, ensuring that the system remains robust under real-world conditions.
Key Results
The paper’s theoretical contributions are summarized in several key findings:
- Stability Guarantees (Theorem 4.2): The authors provide the explicit mathematical proof that the self-triggered implementation maintains EISS, provided the minimum execution time ($\tau_{min}$) is appropriately bounded.
- Near-Optimality: The authors demonstrate that their discrete-time implementation ($\Gamma_d$) generates inter-execution times that are within one sampling step ($\Delta$) of the theoretical maximum. This means the system stays in a low-power state for as long as is mathematically safe.
- Resource Trade-off: The framework explicitly trades a small increase in onboard computation (to calculate $\tau$) for a significant decrease in actuation and communication. In many hardware contexts, the energy cost of a few CPU instructions is orders of magnitude lower than the cost of toggling a radio or driving a motor.
Conclusion and Limitations
This research provides a robust foundation for self-triggered control in linear systems. By moving away from rigid periodic schedules, engineers can design more efficient cyber-physical systems that preserve battery life and bandwidth without sacrificing stability.
However, some limitations remain. The current proofs are tailored for linear plants ($\dot{\xi} = A\xi + B\chi + \delta$). While the concepts of ISS are applicable to non-linear systems, the specific computational shortcuts (like the Veronese embedding) may not translate directly. Additionally, the model assumes that the time taken to compute the next update is negligible—an assumption that holds for most modern microcontrollers but may require re-evaluation for extremely high-frequency control loops.
Summary updated