An ISS self-triggered implementation of linear controllers

Manuel Mazo Jr., Adolfo Anta Martinez, Paulo Tabuada

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

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. Keyword: Self-triggered control, cyber-physical systems, robustness. 1
BibTeX
@article{jr2010iss,
  author = {Manuel Mazo Jr. and Adolfo Anta Martinez and Paulo Tabuada},
  title = {{An ISS self-triggered implementation of linear controllers}},
  journal = {Automatica},
  year = {2010},
  url = {https://openreview.net/forum?id=qWDM-aqCbcQ},
}
Figure