Henceforth we suppose that a continuous strictly positive function $`\gamma(\cdot)`$, a $`\gamma`$-stabilizing CLF $`V(x)`$ and the corresponding feedback map $`\u:\r^d\to U`$ are fixed. All algorithms considered in this paper provide that $`u(t)\in \u(\r^d)`$; without loss of generality, we assume that $`U=\u(\r^d)`$. We are going to design an event-triggered algorithm that ensures [eq.inf-u-sigma0]. The input $`u(t)`$ switches at sampling instants $`t_0,t_1,\ldots`$, where $`t_0=0`$ and the next instants $`t_n`$ depends on the solution, remaining constant $`u(t)\equiv u_n=u(t_n)`$ on each sampling interval $`[t_n,t_{n+1})`$.

The event-triggered control algorithm design

The condition [eq.inf-u-sigma0] can be rewritten as $`W(x(t),u(t))\leq -\sigma\gamma(V(x(t))`$, where the function $`W`$ is defined by

At the initial instant $`t_0=0`$, calculate the control input $`u_0\dfb\u(x(t_0))`$. If $`V(x(t_0))=0`$, then the system starts at the equilibrium point and stays there under the control input $`u(t)\equiv u_0\quad\forall t\ge t_0`$. Otherwise, $`W(x(t_0),u(t_0))\leq -\gamma(V(x(t_0)))<-\sigma\gamma(V(x(t_0)))`$ due to [eq.inf-u-gamma], and hence for $`t`$ sufficiently close to $`t_0`$ one has $`W(x(t),u_0)<-\sigma\gamma(V(x(t))).`$ The next sampling instant $`t_1`$ is the first time when W(x(t),u_0)=-(V(x(t))), we formally define $`t_1=\infty`$ if such an instant does not exist. If $`t_1<\infty`$, we repeat the procedure, calculating the new control input $`u_1=\u(x(t_1))`$. If $`V(x(t_1))=0`$, then the system has arrived at the equilibrium, and stays there under the control input $`u(t)\equiv u_1`$. Otherwise, $`W(x(t_1),u(t_1))\overset{\eqref{eq.inf-u-gamma}}{\le} -\gamma(V(x(t_1)))<-\sigma\gamma(V(x(t_1)))`$. Hence for $`t`$ close to $`t_1`$ one has $`W(x(t),u_1)<-\sigma\gamma(V(x(t))).`$ The next sampling instant $`t_2`$ is the first time $`t>t_1`$ when $`W(x(t),u_1)=-\sigma\gamma(V(x(t)))`$, we define $`t_2=\infty`$ if such an instant does not exist. Iterating this procedure, the sequence of instants sampling $`t_0[eq.inf-u-gamma]. If $`V(x(t_n))>0`$, $`t_{n+1}`$ is the first time $`t>t_n`$ when W(x(t),u_n)=-(V(x(t))). The sequence of sampling instants terminates if $`V(x(t_n))=0`$ or [eq.inf-u-sigma-eq-n] does not hold at any $`t>t_n`$, in this case we formally define $`t_{n+1}=\infty`$ and the control is frozen $`u(t)\equiv u_n\,\forall t>t_n`$.

The procedure just described can be written as follows

(where $`\inf\emptyset=+\infty`$), or in the following “pseudocode form”.

To assure the practical applicability of the algorithm [eq.alg1], one has to prove that the solution of the closed-loop system is forward complete, addressing thus two problems. The first problem, addressed in Subsection 1-B, is the solution existence between two sampling instants: to show that the event [eq.inf-u-sigma-eq-n] is detected earlier than the solution to the following equation “explodes” (escapes from any compact) x(t)=F(x(t),u_n),u_n=(̆x(t_n)), tt_n. The second problem, addressed in Subsection 1-C, is to show the impossibility of Zeno solutions.

Although mathematically it can be possible to prolong the solution beyond the time $`t_{\infty}`$ , the practical implementation of algorithm [eq.alg1] with Zeno trajectories is problematic. Moreover, any real-time implementation of the algorithm imposes an implicit restriction on the minimal time between two consecutive events, referred to as the solution’s dwell-time. Since the control commands cannot be computed arbitrarily fast, in practice the solutions with zero dwell-time are also undesirable, even if they are forward complete.

The proof of locally uniform dwell-time positivity allows to design self-triggered and periodic event-triggered modifications of [eq.alg1] that are discussed in Subsections 1-D,E.

Remark [rem.dwell-time] may be illustrated by the simple example of the system $`\dot x=u`$ and a relay control $`\u(x)={\rm sgn}\,x`$. Choosing $`V(x)=x^2`$ and $`\gamma(v)=2\sqrt{v}`$, the event-triggered algorithm [eq.alg1] in fact coincides with the continuous time control: the first event is fired at time $`t_0`$ and $`u_0={\rm sgn}\,x_0`$; if $`x_0\ne 0`$, the second event occurs at $`t_1=|x_0|`$ and $`u_1=0`$.

The inter-sampling behavior of solutions

To examine the solutions’ behavior between two sampling instants, we introduce the auxiliary Cauchy problem (t)=F((t),u_*), (0)=_0,t, where $`u_*\in U`$. To provide the unique solvability of [eq.cauchy], henceforth the following non-restrictive assumption is adopted.

Corollary [cor.unique1] allows to show that the solution to the closed-loop system [eq.syst],[eq.alg1] exists and unique for any initial condition. One can show via induction on $`n`$ that the sequence $`\{t_n\}`$ is uniquely defined by $`x(0)`$ by noticing that $`t_0=0`$ is uniquely defined and if $`t_n<\infty`$, then the next instant $`t_{n+1}\leq\infty`$ depends only on $`t_n,x_n,u_n`$. If $`x_n=0`$, then algorithms stops and $`t_{n+1}=\infty`$. In view of Proposition [prop.tech], either event [eq.inf-u-sigma-eq-n] occurs at some time $`t>t_n`$ (the first such instant is $`t_{n+1}<\infty`$), or the solution is well defined on $`[t_n,\infty)`$ and satisfies [eq.inf-u-sigma0] (in which case $`t_{n+1}=\infty`$). In both situations, the solution is well defined on the $`n`$th sampling interval $`[t_n,t_{n+1})`$.

Notice that the solution is automatically forward complete in the case where the sequence $`t_n`$ terminates (for some $`n`$, we have $`t_{n+1}=\infty`$). This however is not guaranteed for the case where infinitely many events occur. To exclude the possibility of Zeno behavior, additional assumptions are required.

Dwell time positivity

In this subsection, we formulate our first main result, namely, the criterion of dwell time positivity in Algorithm [eq.alg1]. This criterion relies on several additional assumptions.

For any $`x_*\in\r^d`$ and $`\mathcal K\subset\r^d`$, denote B(x_*){x: V(x)V(x_*)}, B(K)_x_*KB(x_*). Algorithm [eq.alg1] implies that $`V(x(t))`$ is non-increasing due to [eq.inf-u-gamma], and hence $`x(t)\in B(x(s))`$ for $`t\ge s\ge 0`$. In particular, sets $`B(x_*)`$ are forward invariant along the solutions of [eq.syst],[eq.alg1]. For any bounded set $`\mathcal K`$, $`B(\mathcal K)`$ is also bounded since

B(\mathcal K)\subseteq\{x: V(x)\le \sup_{x_*\in \mathcal K} V(x_*)\}.

Accordingly to Assumption [ass.contin], the following supremum is finite (x_*)_ <
for any $`x_*`$ (in the case where $`x_*=0`$ and $`B(x_*)=\{0\}`$, let $`\vk(x_*)\dfb 0`$). We adopt a stronger version of Assumption [ass.contin].

Assumption [ass.F] holds, for instance, if the mapping $`\u`$ is locally bounded and $`F'_x(x,u)`$ exists and is continuous in $`x`$ and $`u`$.

Assumption [ass.gradient] is a stronger version of CLF’s smoothness and holds e.g. when $`V\in C^2`$. Similar to [eq.kappa], we introduce the Lipschitz constant of $`V'`$ on the compact set $`B(x_*)`$: (x_*)_ ,(0).

Assumption [ass.gradient] implies that $`\nu`$ is locally bounded since for any compact $`\mathcal{K}`$ the set $`B(\mathcal K)`$ is bounded and

\sup_{x_*\in \mathcal K}\nu(x_*)\le \sup\limits_{\substack{x_1,x_2\in B(\mathcal K)\\x_1\ne x_2}} \frac{|V'(x_1)-V'(x_2)|}{|x_2-x_1|}<\infty.

Finally, we adopt an assumption that allows to establish the relation between the convergence rates of the $`\gamma`$-CLF $`V(x(t))`$ under the continuous-time control $`\u=\u(x)`$ and the solution $`x(t)`$. Notice that [eq.inf-u-gamma] gives no information about the speed of the solution’s convergence since $`\dot V(x)=V'(x)\dot x(t)`$ depends only on the velocity’s $`\dot x(t)`$ projection on the gradient vector $`V'(x)`$, whereas its transversal component can be arbitrary. These transversal dynamics can potentially lead to very slow and “non-smooth” convergence, in the sense that $`|\dot x(t)|\gg |\dot V(x(t))|`$. As discussed in Appendix 8, in such a situation the dwell-time positivity cannot be proved. Denoting

\bar F(x)\dfb F(x,\u(x)),

and introducing the angle $`\theta(x)`$ between $`\bar F(x)`$ and $`V'(x)`$ (Fig. 1), the definition of $`\gamma`$-CLF [eq.inf-u-gamma] implies that

\begin{gathered}
V'(x)=0\Longrightarrow x=0\Longrightarrow \bar F(x)=0\\
\cos\theta(x)<0\quad\forall x\ne 0.
\end{gathered}

Our final assumption requires these conditions to hold uniformly in the vicinity of $`x=0`$ in the following sense.

style="height:3cm" />

The inequalities [eq.non-degen] imply that the solution does not oscillate near the equilibrium since $`|\bar F(x)|\to 0`$ as $`|x|\to 0`$, and the angle between the vectors² $`\dot x=\bar F(x)`$ and $`V'(x)`$ remains strictly obtuse as $`x\to 0`$, i.e. the flow is not transversal to the CLF’s gradient. Assumption [ass.non-degen] can be reformulated as follows.

\begin{split}
M(x)|V'(x)\bar F(x)|=M(x)|\cos\theta(x)||V'(x)|\,|\bar F(x)|\\ \overset{\eqref{eq.non-degen}}{\geq} M(x)M_2(x)|V'(x)|\,|\bar F(x)|\overset{MM_2=1+M_1}{\geq} \\
\geq |V'(x)|\,|\bar F(x)|+M_1(x)|V'(x)|\,|\bar F(x)|\\
\overset{\eqref{eq.non-degen}}{\geq} |V'(x)|\,|\bar F(x)|+|\bar F(x)|^2,
\end{split}

\begin{gathered}
M(x)\cos\theta(x)=\frac{M(x)V'(x)\bar F(x)}{|V'(x)|\,|\bar F(x)|}\leq -1\\
|\bar F(x)|^2\leq M(x)|V'(x)\bar F(x)|\le M(x)|V'(x)|\,|\bar F(x)|,
\end{gathered}

We not turn to the key problem of dwell time estimation for Algorithm [eq.alg1]. In view of [eq.aux0], to estimate of the time elapsed between consecutive events $`t_{n+1}-t_n`$, it suffices to study the behavior of the solution $`\xi(t)=\xi(t|x_*,\u(x_*))`$ to the Cauchy problem [eq.cauchy] with $`\xi_0=x_*\ne 0`$ and $`u_*=\u(x_*)`$, namely, to find the first instant $`\bar t`$ such that $`W(\xi(\bar t),u_*)=-\sigma\gamma(V(\xi(\bar t)))`$. The following lemma implies that $`\bar t\ge\tau(x_*)`$, where $`\tau(\cdot)`$ is some function, uniformly strictly positive on any compact set.

The proof of Lemma [lem.key-lemma] will be given in Appendix 7; in this proof the exact expression for $`\tau(\cdot)`$ will be found, which involves the functions $`\gamma,\vk,\nu,M`$. Note that Algorithm [eq.alg1] does not employ $`\tau(\cdot)`$, which is needed to estimate the dwell time. Notice that for a fixed $`x_*\in\r^d`$, the value $`\tau(x_*)=\tau_{\sigma}(x_*)`$ may be considered as a function of the parameter $`\sigma`$ from [eq.inf-u-sigma0]. It can be shown that $`\tau_{\sigma}(x_*)\to 0`$ as $`\sigma\to 1`$. In other words, if the event-triggered algorithm provides the same convergence rate as the continuous-time control, the dwell time between consecutive events vanishes. Lemma [lem.key-lemma] implies our main result.

\inf_{x_0\in\mathcal K}\tau_{min}(x_0)=\inf_{x\in B(\mathcal K)}\tau(x)>0

Self-triggered and time-triggered stabilizing control

As has been already mentioned, Algorithm [eq.alg1] requires neither full knowledge of the functions $`\vk,\nu,M`$, nor even upper estimates for them. If such estimates are known, $`\tau(\cdot)`$ from Lemma [lem.key-lemma] can be found explicitly (see Appendix 7), and algorithm [eq.alg1] can be replaced by the self-triggered controller:

The algorithm [eq.alg2] requires to compute the value of $`\tau(x_n)`$ at each step. Alternatively, if a lower bound $`\tau_*`$ for the value of $`\tau_{min}(x_0)`$ from [eq.tau-min] is known $`\tau_{min}(x_0)\geq\tau_*>0`$, one may consider periodic or aperiodic time-triggered sampling

Here the sequence $`\{t_n\}`$ is independent of the trajectory; often $`t_n=n\tau_0`$ with some period $`\tau_0\le\tau_*`$.

Lemma [lem.key-lemma] and [eq.aux0] yield in the following result.

The strong advantage of the self-triggered and the periodic sampling algorithms is the possibility to schedule communication and control tasks. Such algorithms are more convenient for real-time embedded systems engineering than the event-triggered controller [eq.alg1], which requires constant monitoring of the solution $`x(t)`$ and potentially can use the communication channel at any time. The downside of this is the necessity to estimate the inter-sampling time $`\tau(\cdot)`$. The conservatism of such estimates leads to more data transmissions and control switchings than the event-triggered controller [eq.alg1] needs.

Periodic event-triggered stabilization

A combination of the event-triggered and periodic sampling, inheriting the advantages of both approaches, is referred to as periodic event-triggered control . Unlike usual event-triggered control, the triggering condition is checked periodically with some fixed period $`h>0`$, i.e. the control input can be recalculated only at time $`kh`$, where $`k=0,1,\ldots`$. This automatically excludes the possibility of Zeno behavior (obviously, $`t_{n+1}-t_n\ge h>0`$) and simplifies scheduling of the computational and communication tasks.

The main difficulty in designing the periodic event-triggered controller is to find such a triggering condition that its validity at time $`kh`$ automatically implies the desired control goal [eq.inf-u-sigma0] on the interval $`[kh,(k+1)h]`$, even if the control input at time $`t=kh`$ remains unchanged. Fixing two constants $`\tilde\sigma\in (\sigma,1)`$ and $`K>1`$, we introduce the boolean function (predicate)

Here $`M(x)`$ is the function from [eq.non-degen1]. The conditions [eq.inf-u-gamma] and [eq.non-degen1] imply that $`P(x_*,\u(x_*))`$ is true for any $`x_*\ne 0`$ since W(x_*,(̆x_*))-(V(x_*))<-(V(x_*)).

Choosing the sampling period $`h>0`$ in a way specified later (Lemma [lem.key-lemma1]), the following key property can be guaranteed: if $`P(x(t_*),u_*)`$ holds for some $`t_*`$ then the static control input $`u(t)\equiv u_*`$ provides the validity of [eq.inf-u-sigma0] for $`t\in [t_*,t_*+h)`$ (notice that $`P(x(t),u_*)`$ need not be true on this interval). This suggests the following periodic event-triggered algorithm. At the initial instant $`t_0=0`$, calculate the control input $`u_0\dfb\u(x(t_0))`$. If $`x(t_0)=0`$, we may freeze the control input $`u(t)\equiv u_0\quad\forall t\ge 0`$. At any time $`t=kh`$, where $`k=1,2,\ldots,`$, the condition $`P(x(kh),u_0)`$ is checked, until one finds the first $`k_1\ge 1`$ such that $`P(x(k_1h),u_0)`$ is false. At the instant $`t_1=k_1h`$, the control input is switched to $`u_1=\u(x(t_1))`$, and the procedure is repeated again: if $`x(t_1)=0`$, one can freeze $`u(t)\equiv u_1`$, otherwise, $`u(t)=u_1`$ until the first instant $`k_2h`$ (with $`k_2>k_1`$), where $`P(x(k_2h),u_1)`$ is false, and so on. Mathematically, the algorithm is as follows

(by definition, $`\min\emptyset=+\infty`$).

Notice that the algorithm [eq.alg3] implicitly depends on three parameters: $`\sigma\in (0,1)`$, $`\tilde\sigma\in(\sigma,1)`$ and $`K>1`$. The role of the first parameter is the same as in Algorithm [eq.alg1] (it regulates the converges rate). The parameters $`\tilde\sigma`$ and $`K`$ determine the maximal sampling period $`h`$: the less restrictive condition $`P(x(kh),u_n)`$ is, the more often it has to be checked in order to guarantee the desired inter-sampling behavior, as will be explained in more detail in Remark [rem.sigma-K-remark].

The choice of $`h>0`$ is based on the following lemma, similar to Lemma [lem.key-lemma] and dealing with the solution $`\xi(t)=\xi(t|\bar x,u_*)`$ to the Cauchy problem [eq.cauchy]. Unlike Lemma [lem.key-lemma], $`u_*\ne\u(\bar x)`$.

Lemma [lem.key-lemma1] is proved in Appendix 7, where an explicit formula for $`\tau^0(\cdot)`$ is found. This lemma entails the following result.

Self-triggered and periodic event-triggered stabilization

One may notice that the dwell-time estimates, obtained in Section 1, employ the functions $`\vk(\cdot)`$ and $`\nu(\cdot)`$ from Assumptions [ass.F] and [ass.gradient] and $`M(\cdot)`$ from [eq.non-degen1]. Essentially, we need only

Numerical Examples

In this section, two examples illustrating the applications of algorithm [eq.alg1] are considered.

Event-triggered backstepping for cruise control

Our first example illustrates the procedure of event-triggered backstepping with guaranteed dwell-time positivity in the following problem, regarding the design of full-range, or stop and go, adaptive cruise control (ACC) systems . The main purpose of ACC systems is to adjust automatically the vehicle speed to maintain a safe distance from vehicles ahead (the distance to the predecessor vehicle, as well as its velocity, is measured by onboard radars, laser sensors or cameras). We consider, however, a more general problem that can be solved by ACC, namely, keeping the predefined distance to the predecessor vehicle. Such a problem is natural e.g. when the vehicle has to safely merge a platoon of vehicles (Fig. 2), move in a platoon or leave it . In the simplest situation the platoon travels at constant speed $`v_0>0`$. Denoting and the the desired distance from the vehicle to the platoon by $`d_0`$, the control goal is formulated as follows d(t)-d_0 0,v(t)-v_0 0.

We consider the standard third-order model of a vehicle’s longitudinal dynamics  (v)a(t)+a(t)=u(t),a(t)=v(t). Here $`a(t)`$ is the controller vehicle’s actual acceleration, whereas $`u(t)`$ can be treated as the commanded (desired) acceleration. The function $`\tau(v)`$ depends on the dynamics of the servo-loop and characterizes the driveline constant, or time lag between the commanded and actual accelerations. We suppose the function $`\tau(v)`$ to be known, the vehicle being able to measure $`d(t),v(t),a(t)`$ and aware of the platoon’s speed $`v_0`$.

/>

To design an exponentially stabilizing CLF in this problem, we use the well-known backstepping procedure . We introduce the functions $`x_1,x_2,x_3`$ as follows

/>

/>

/>

/>

/>

/>

/>

/>

By noticing that $`v_0-v(t)=x_2-kx_1`$ and $`a(t)=2kx_2(t)-k^2x_1(t)-\xi_3(t)`$, the equations [eq.vehi] are rewritten as follows

It can be easily shown now that $`V(x)=\frac{1}{2}(x_1^2+x_2^2+x_3^2)`$ is the CLF for the system [eq.vehi1] whenever $`k>1`$, corresponding to the feedback controller $`\u(x)`$ as follows

\begin{aligned}
\u(x)&\dfb\tau(v)k^2[x_2-kx_1]+\\&+[1-2k\tau(v)](2kx_2-k^2x_1-x_3)-\tau(v)(x_1-kx_3).
\end{aligned}

Indeed, a straightforward computation shows that

\begin{aligned}
F(x,\u(x))&=(x_2-kx_1,x_3-kx_2,x_1-kx_3)^{\top},\\
V'(x)F(x,\u(x))&=-2(k-1)V(x)-\\&-\frac{1}{2}[(x_1-x_2)^2+(x_1-x_3)^2+(x_2-x_3)^2],
\end{aligned}

entailing [eq.es-clf] with $`\ae=2(k-1)`$. It can be easily shown that all assumptions of Theorem [thm.dwell] hold. The algorithm [eq.alg1] gives an event-triggered ACC algorithm.

In Fig. 3, we simulate the behavior of the algorithm [eq.alg1] with $`\sigma=0.9`$, choosing $`k=1.01`$ and $`\tau=0.3s`$ for two situations. In the first situation (plots on top) the vehicle initially travels with the same speed as the platoon ($`v(0)-v_0=0`$), but needs to decrease the distance by $`10`$m, i.e. $`x_1(0)=d(0)-d_0=10`$, $`x_2(0)=kx_1(0)`$, $`x_3(0)=k^2x_1(0)`$. In the second case (plots at the bottom), the vehicle needs to decrease its speed by $`2`$m/s, keeping the initial distance to the platoon: $`d_0=d(0)`$, $`v(0)-v_0=2`$, and thus $`x_1(0)=0,x_2(0)=v_0-v(0)=-2,x_3(0)=-4k`$. One may notice that the vehicle’s trajectories periods of “harsh” braking, which cause discomfort of the human occupants (as well as large values of the jerk, caused by rapid switch of the control input). In this simple example, intended for demonstration of the design procedure, we do not consider these constraints.

One may notice that in both situations the algorithm produces “packs” of 15-30 close events. In the first case, events are fired starting from $`t_1=14.1`$s, the maximal time elapsed between consecutive events is $`6.38`$s and the minimal time is $`0.05`$s. The average frequency of events is 3.2Hz. In the second case, the first event occurs at $`t_1=1.5s`$, the maximal time between events is $`8.6`$s, the minimal time is $`0.04`$s. The average frequency of events is $`3.6`$Hz.

An example of non-exponential stabilization

/>

/>

/>

Our second example is borrowed from  and deals with a two-dimensional homogeneous system

The quadratic form $`V(x)=\frac{1}{2}[x_1^2+x_2^2]`$ satisfies [eq.inf-u-gamma] with $`\gamma(v)=v^2`$ and $`\u(x)=-x_2^3-x_1x_2^2`$ since

V'(x)F(x,\u(x))=-x_1^4-x_2^4\le -V^2/2.

Therefore, the event-triggered algorithm [eq.alg1] provides stabilization with convergence rate

V(x(t))\le \left[V(x(0))+\sigma t/2\right]^{-1}.

To compare our algorithm with the one reported in  and based on the Sontag controller, we simulate the behavior of the system for $`x_1(0)=0.1, x_2(0)=0.4`$, choosing $`\sigma=0.9`$. The results of numerical simulation (Fig. 4) are similar to those presented in . Although the convergence of the solution is slow ($`V(x(t))=O(t^{-1})`$ and $`|x(t)|=O(t^{-1/2})`$), its second component and the control input converge very fast. During the first $`200`$s, only two events are detected at times $`t_0=0`$ and $`t_1\approx 5.26`$, after which the control is fixed at $`u(t)\approx -6\cdot 10^{-7}`$.

Conclusion

In this paper, we address the following fundamental question: let a nonlinear system admit a control Lyapunov function (CLF), corresponding to a continuous-time stabilizing controller with a certain (e.g. exponential or polynomial) convergence rate. Does this imply the existence of an event-triggered controller, providing the same convergence rate? Under certain natural assumptions, we give an affirmative answer and show that such a controller in fact also provides the positive dwell time between consecutive events. Moreover, we show that if the initial condition is confined to a known compact set, this problem can be also solved by self-triggered and periodic event-triggered controllers. Our results can also be extended to robust control Lyapunov functions (RCLF), extending the concept of CLF to systems with disturbances.

Analysis of the proofs reveals that the main results of the paper retain their validity in the case where the CLF is proper yet not positive definite, and its compact zero set $`X_0=\{x\in\r^d: V(x)=0\}`$ consists of the equilibria of the system [eq.closed-loop]. If our standing assumptions hold, then algorithms [eq.alg1],[eq.alg2],[eq.alg2+],[eq.alg3] provide that $`V(x(t))\xrightarrow[t\to\infty]{}0`$ (with a known convergence rate) and any solution converges to $`X_0`$ in the sense that $`{\rm dist}(x(t),X_0)\xrightarrow[t\to\infty]{} 0`$. At the same time, Lyapunov stabilization of unbounded sets (e.g. hyperplanes ) requires additional assumptions on CLFs; the relevant extensions are beyond the scope of this paper.

Although the existence of CLFs can be derived from the inverse Lyapunov theorems, to find a CLF satisfying Assumptions [ass.F]-[ass.non-degen] can in general be non-trivial; computational approaches to cope with it are subject of ongoing research. Especially challenging are problems of safety-critical control, requiring to design a control Lyapunov-barier function (CLBF). Other important problems are event-triggered and self-triggered redesign of dynamic continuous-time controllers (needed e.g. when the state vector cannot be fully measured) and stabilization with non-smooth CLFs .

Introduction

The seminal idea to use the second Lyapunov method as a tool of control design  has naturally lead to the idea of control Lyapunov Function (CLF). A CLF is a function that becomes a Lyapunov function of the closed-loop system under an appropriate (usually, non-unique) choice of the controller. The fundamental Artstein theorem  states that the existence of a CLF is necessary and sufficient for stabilization of a general nonlinear system by a “relaxed” controller, mapping the system’s state into a probability measure. For an affine unconstrained system, a usual static stabilizing controller can always be found, as shown in the seminal work .

In general, to find a CLF for a given control system is a non-trivial problem since the set of CLFs may have a very sophisticated structure, e.g. be disconnected . However, in some important situations a CLF can be explicitly found. Examples include some homogeneous systems , feedback-linearizable, passive or feedback-passive systems  and cascaded systems , for which both CLFs and stabilizing controllers can be delivered by the backstepping and forwarding procedures . The CLF method has recently been empowered by the development of algorithms and software for convex optimization  and genetic programming .

Nowadays the method of CLF is recognized as a powerful tool in nonlinear control systems design . A CLF gives a solution to the Hamilton-Jacobi-Bellman equation for an appropriate performance index, giving a solution to the inverse optimality problem . Another numerical method to compute CLFs  employs the so-called Zubov equation. The method of CLF has been extended to uncertain , discrete-time , time-delay  and hybrid systems . Combining CLFs and Control Barrier Functions (CBFs), correct-by-design controllers for stabilization of constrained (“safety-critical”) systems have been proposed .

For continuous-time systems, CLF-based controllers are also continuous-time. Their implementation on digital platforms requires to introduce time sampling. The simplest approach is based on emulation of the continuous-time feedback by a discrete-time control, sampled at a high rate. Rigorous stability analysis of the resulting sampled-time systems is highly non-trivial; we refer the reader to  for a detailed survey of the existing methods. A more general framework to sample-time control design, based on a direct discretization of the nonlinear control system and approximating it by a nonlinear discrete-time inclusion, has been developed in . This method allows to design controllers that cannot be directly redesigned from continuous-time algorithms, but the relevant design procedures and stability analysis are sophisticated.

The necessity to use communication, computational and power resources parsimoniously has motivated to study digital controllers that are based on event-triggered sampling, which has a number of advantages over classical time-triggered control . Event-triggered control strategies can be efficiently analyzed by using the theories of hybrid systems , switching systems , delayed systems  and impulsive systems . It should be noticed that the event-triggered sampling is aperiodic and, unlike the classical time-triggered designs, the inter-sampling interval need not necessarily be sufficiently small: the control can be frozen for a long time, provided that the behavior of the system is satisfactory and requires no intervention. On the other hand, with event-triggered sampling one has to prove the existence of positive dwell time between consecutive events: even though mathematically any non-Zeno trajectory is admissible, in real-time control systems the sampling rate is always limited.

A natural question arises whether the existence of a CLF makes it possible to design an event-triggered controller. In a few situations, the answer is known to be affirmative. The most studied is the case where the CLF appears to be a so called ISS Lyapunov function  and allows to prove the input-to-state stability (ISS) of the closed-loop system with respect to measurement errors. A more recent result from  relaxes the ISS condition to a stronger version of usual asymptotic stability, however the control algorithm from , in general, does not ensure the absence of Zeno solutions. Another approach, based on Sontag’s universal formula  has been proposed in . All of these results impose limitations, discussed in detail in Section 6. In particular, the estimation of the convergence rate for the methods proposed in  is a non-trivial problem. In many situations a CLF can be designed that provides some known convergence rate (e.g. exponentially stabilizing CLFs ) in continuous time. A natural question arises whether event-based controllers can provide the same (or an arbitrarily close) convergence rate. In this paper, we give an affirmative answer to this fundamental question. Under natural assumptions, we design an event-triggered controller, providing a known convergence rate and a positive dwell time between consecutive events. Furthermore, we design self-triggered and periodic event-triggered controllers that simplify real-time task scheduling.

The paper is organized as follows. Section 6 gives the definition of CLF and related concepts and sets up the problem of event-triggered stabilization with a predefined convergence rate. The solution to this problem, being the main result of the paper, is offered in Section 1, where event-triggered, self-triggered and periodic event-triggered stabilizing controllers are designed. In Section 3, the main results are illustrated by numerical examples. Section 4 concludes the paper. Appendix contains some technical proofs and discussion on the key assumption in the main result.

Preliminaries and problem setup

Henceforth $`\r^{m\times n}`$ stands for the set of $`m\times n`$ real matrices, $`\r^n=\r^{n\times 1}`$. Given a function $`G:\r^n\to\r^m`$ that maps $`x\in\r^n`$ into $`G(x)=(G_1(x),\ldots,G_m(x))^{\top}\in\r^m`$, we use $`G'(x)=\big(\frac{\partial G_i(x)}{\partial x_j}\big)\in\r^{m\times n}`$ to denote its Jacobian matrix.

Control Lyapunov functions in stabilization problems

To simplify matters, henceforth we deal with the problem of global asymptotic stabilization. Consider the following control system x(t)=F(x(t),u(t)),t, where $`x(t)\in\r^{d}`$ stands for the state vector and $`u(t)\in U\subseteq\r^{m}`$ is the control input (the case $`U=\r^m`$ corresponds to the absence of input constraints). Our goal is to find a controller $`u(\cdot)=\mathcal U(x(\cdot))`$, where $`\mathcal U:x(\cdot)\mapsto u(\cdot)`$ is some causal (non-anticipating) operator, such that for any $`x(0)\in\r^{d}`$ the solution to the closed-loop system is forward complete (exists up to $`t=+\infty`$) and converges to the unique equilibrium $`x=0`$ x(t) 0x(0)̊^d,F(0,U(0))=0.

We now give the definition of CLF. Following , we henceforth assume CLFs to be smooth, radially unbounded (or proper) and positive definite.

\begin{gather}
V(0)=0,\quad V(x)>0\,\forall x\ne 0,\quad \lim_{|x|\to\infty}V(x)=\infty;\label{eq.pos-def}\\
\inf_{u\in U} V'(x)F(x,u)<0\quad\forall x\ne 0.\label{eq.inf-u}
\end{gather}

The condition [eq.inf-u], obviously, can be reformulated as follows x u(x)U If $`F(x,u)`$ is Lebesgue measurable (e.g., continuous), then the set $`\{x\ne 0,u\in U:V'(x)F(x,u)<0\}`$ is also measurable and the Aumann measurable selector theorem  implies that the function $`u(x)`$ can be chosen measurable; however, it can be discontinuous and infeasible (the closed-loop system has no solution for some initial condition). Some systems [eq.syst] with continuous right-hand sides cannot be stabilized by usual controllers in spite of the existence of a CLF, however, they can be stabilized by a “relaxed” control  $`x\mapsto v(x)`$, where $`v(x)`$ is a probability distribution on $`U`$.

The situation becomes much simpler in the case of affine system [eq.syst] with $`F(x,u)=f(x)+g(x)u`$. Assuming that $`f:\r^d\to\r^d`$ and $`g:\r^d\to\r^{d\times m}`$ are continuous and $`U`$ is convex, the existence of a CLF ensures the possibility to design a controller $`u=u(x)`$, where $`u:\r^d\to U`$ is continuous everywhere except for, possibly, $`x=0`$ . While the original proof from  was not fully constructive, Sontag  has proposed an explicit universal formula, giving a broad class of stabilizing controllers. Assuming that $`U=\r^m`$, let a(x)V’(x)f(x),b(x)V’(x)g(x). Then [eq.inf-u] means that $`a(x)<0`$ whenever $`b(x)=0`$ and $`x\ne 0`$. In the scalar case ($`m=1`$), Sontag’s controller is u(x)=

Here $`q(b)`$ is a continuous function, $`q(0)=0`$. It is shown  that the control [eq.sontag-scal] is continuous at any $`x\ne 0`$, moreover, if $`a(\cdot)`$, $`b(\cdot)`$ and $`q(\cdot)`$ are $`C^k`$-smooth (respectively, real analytic), the same holds for $`u(\cdot)`$ in the domain $`\r^d\setminus\{0\}`$. The global continuity requires an addition “small control” property . Similar controllers have been found for a more general case, where $`m>1`$ and $`U`$ is a closed ball in $`\r^m`$ .

CLF and event-triggered control

Dealing with continuous-time systems [eq.syst], the CLF-based controller $`u=\u(x)`$ is also continuous-time, and its implementation on digital platforms requires time-sampling. Formally, the control command is computed and sent to the plant at time instants $`t_0=0

As an alternative to periodic sampling, methods of non-uniform event-based sampling have been proposed . With these methods, the next sampling instant instant $`t_{n+1}`$ is triggered by some event, depending on the previous instant $`t_n`$ and the system’s trajectory for $`t>t_n`$. Special cases are self-triggered controllers , where $`t_{n+1}`$ is determined by $`t_n`$ and $`x(t_n)`$, and there is no need to check triggering conditions, and periodic even-triggered control , which requires to check the triggering condition only periodically at times $`n\tau`$. The advantages of event-triggered control over traditional periodic control, in particular the economy of communication and energy resources, have been discussed in the recent papers . Event-triggered control algorithms are widespread in biology, e.g. oscillator networks .

A natural question arises whether a continuous-time CLF can be employed to design an event-triggered stabilizing controller. Up to now, only a few results of this type have been reported in the literature. In , an event-triggered controller requires the existence of a so-called ISS Lyapunov function $`V(x)`$ and a controller $`u=k(x)`$, satisfying the conditions

\begin{gather}
%\begin{gathered}
\alpha_1(|x|)\le V(x)\le \alpha_2(|x|)\quad\forall x\in\r^d\label{eq.isss}\\
V'(x)F(x,k(x+e))\le -\alpha_3(|x|)+\gamma(|e|)\quad\forall x,e\in\r^d.\label{eq.iss}
%\end{gathered}
\end{gather}

Here $`\alpha_i(\cdot)`$ ($`i=1,2,3`$) are $`\mathcal K_{\infty}`$-functions⁴ and the mappings $`k(\cdot):\r^d\to\r^m`$, $`F(\cdot,\cdot):\r^d\times\r^m\to\r^d`$, $`\alpha_3^{-1}(\cdot)`$ and $`\gamma(\cdot):\r_+\to\r_+`$ are assumed to be locally Lipschitz. Subsituting $`e=0`$ into [eq.iss], one easily shows that the ISS Lyapunov function satisfies [eq.inf-u], being thus a special case of CLF; the corresponding feedback $`\u(x)\dfb k(x)`$ not only stabilizes the system, but in fact also provides its input to state stability (ISS) with respect to the measurement error $`e`$. The event-triggered controller, offered in , is as follows

The controller [eq.tabuada] guarantees a positive dwell time between consecutive events $`\tau=\inf_{n\ge 0}(t_{n+1}-t_n)>0`$, which is uniformly positive for the solutions, starting in a compact set.

Whereas the condition [eq.iss] holds for linear systems  and some polynomial systems , in general it is restrictive and not easy to verify. Another approach to CLF-based design of event-triggered controllers has been proposed in . Discarding the ISS condition [eq.iss], this approach is based on Sontag’s theory  and inherits its basic assumptions: first, the system has to be affine $`F(x,u)=f(x)+g(x)u`$, where $`f,g\in C^1`$, second, Sontag’s controller is admissible ($`u(x)\in U`$ for any $`x`$). The controllers from  also provide positivity of the dwell time (“minimal inter-sampling interval”).

An alternative event-triggered control algorithm, substantially relaxing the ISS condition [eq.iss] and applicable to non-affine systems, has been proposed in  and requires the existence of a CLF, satisfying [eq.isss] and [eq.iss] with $`e=0`$

The events are triggered in a way providing that $`V`$ strictly decreases along any non-equilibrium trajectory t_n+1={tt_n: V’(x(t))F(x(t),u_n)=-(|x(t)|)}. Here $`0<\mu(r)<\alpha_3(r)`$ for any $`r>0`$ and $`\mu`$ is $`\mathcal K_{\infty}`$-function. As noticed in , this algorithm in general does not provide dwell time positivity, and may even lead to Zeno solutions.

As will be discussed below, the conditions [eq.isss] and [eq.iss1] entail an estimate for the CLF’s convergence rate. In this paper, we assume that the CLF satisfies a more general convergence rate condition, and design an event-triggered controller that preserves the convergence rate and provides positive dwell time between consecutive switchings. Also, we show that for each bounded region of the state space, self-triggered and periodic event-triggered controllers exist that provide stability for any initial condition from this region. Our approach substantially differs from the previous works . Unlike , we do not assume that CLF satisfies the ISS condition [eq.iss]. Unlike , the affinity of the system is not needed, and the solution’s convergence rate can be explicitly estimated. Unlike , the dwell time positivity is established.

CLF with known convergence rate

Whereas the existence of CLF typically allows to find a stabilizing controller, it can potentially be unsatisfactory due to very slow convergence. Throughout the paper, we assume that a CLF gives a controller with known convergence rate.

To examine the behavior of solutions of the closed-loop system, we introduce the following function $`\Gamma:(0,\infty)\to\r`$ (s)_1^s,s>0. The definition [eq.Gamma] implies that $`\Gamma(s)`$ is positive when $`s>1`$ and negative for $`s<1`$. Since, $`\Gamma'(s)=1/\gamma(s)>0`$, $`\Gamma`$ is increasing and hence the limits (possibly, infinite) exist

\underline\Gamma\dfb\lim_{s\to 0}\Gamma(s)<0,\quad \overline\Gamma\dfb\lim_{s\to \infty}\Gamma(s)>0.

The inverse $`\Gamma^{-1}:(\underline\Gamma,\overline\Gamma)\to (0,\infty)`$ is increasing and $`C^1`$-smooth. If $`\underline\Gamma>-\infty`$, we define $`\Gamma^{-1}(r)\dfb 0`$ for $`r\le\underline\Gamma`$.

To understand the meaning of the function $`\Gamma(s)`$, consider now a special situation, where the equality in [eq.inf-u-gamma] is achieved V’(x)F(x,(̆x))= -(V(x))x̊^d. The CLF $`V(x(t))`$ can be treated as some “energy”, stored in the system at time $`t`$, whereas $`\gamma(V(x(t)))=-\dot V(x(t))`$ can be treated as the energy dissipation rate or “power” consumed by the closed-loop system (“work” done by the system per unit of time) with feedback $`u=\u(x)`$. By noticing that $`\frac{d}{dt}\Gamma(V(x(t))=\dot V(x(t))/\gamma(V(x(t))=-1`$, the function $`\Gamma`$ may be considered as the “energy-time characteristics” of the system: it takes the system time $`t_1=\Gamma(V_0)-\Gamma(V_1)`$ to move from the energy level $`V_0=V(x(0))`$ to the energy level $`V_1`$.

In general, [eq.inf-u-gamma] implies an upper bound for a solution.

Depending on the finiteness of $`\underline\Gamma`$, Proposition [prop.converge] explicitly estimates either time or rate of the CLF’s convergence to $`0`$.

Example 1. Let $`\gamma(v)=\ae v`$, where $`\ae>0`$ is a constant. In this case $`\Gamma(s)=\ae^{-1}\ln s`$, $`\underline\Gamma=-\infty`$, $`\overline\Gamma=\infty`$, $`\Gamma^{-1}(r)=e^{\ae r}`$. The $`\gamma`$-stabilizing CLF provides exponential stabilization (being an ES-CLF ). The inequality [eq.conv-rate] reduces to 0V(t)(æ(æ^-1V(0)-t))=V(0)e^-æt.

Example 2. Let $`\gamma(v)=\ae v^{a}`$ with $`\ae>0,a>1`$. We have $`\Gamma(s)=[\ae(a-1)]^{-1}(1-s^{1-a})`$, $`\underline\Gamma=-\infty`$, $`\overline\Gamma=[\ae(a-1)]^{-1}`$, $`\Gamma^{-1}(r)=\left(1-\ae(a-1)r\right)^{1/(1-a)}`$, and [eq.conv-rate] boils down to

Example 3. Let $`\gamma(v)=\ae v^{a}`$ with $`\ae>0,a<1`$. Similar to the case $`a>1`$, one has $`\Gamma(s)=[\ae(a-1)]^{-1}(1-s^{1-a})`$ and $`\Gamma^{-1}(r)=\left(1-\ae(a-1)r\right)^{1/(1-a)}`$, however, $`\underline\Gamma=[\ae(a-1)]^{-1}>-\infty`$. The condition [eq.conv-rate] again leads to [eq.aux2], however, the right-hand side vanishes for $`t\ge t_0\dfb \vk(1-a)^{-1}V(0)^{1-a}`$, e.g. the solution converges in finite time $`t_0`$.

Example 3 shows that a CLF can give a controller, solving the problem of finite-time stabilization. An event-triggered counterpart of such a controller can be designed, using the procedure discussed in the next section. However, the property of local positivity of dwell time does not hold for such a controller (see Remark [rem.dwell-time]), and thus the absence of Zeno trajectories does not follow from our main results. Finite-time event-triggered stabilization is thus beyond the scope of this paper, being a subject of ongoing research.

Problem setup

In this paper, we address the following fundamental question: does the existence of a continuous-time $`\gamma`$-stabilizing CLF allow to design an event-triggered mechanism, providing the same convergence rate as the continuous-time control $`u=\u(x)`$? Relaxing the latter requirement, we seek for event-triggered controllers whose convergence rates are arbitrarily close to the convergence rate of the continuous-time controller.

Problem. Assume that $`V`$ is a $`\gamma`$-stabilizing CLF, where $`\gamma(v)`$ is a known function, and $`\sigma\in (0,1)`$ is a fixed constant. Design an event-triggered controller, providing the following condition (x(t))-(V(x(t)))t.

Applying Proposition [prop.converge] to $`\tilde \gamma(s)=\sigma\gamma(s)`$ (which corresponds to $`\tilde\Gamma(s)=\sigma^{-1}\Gamma(s)`$), it is shown that [eq.inf-u-sigma0] entails that 0V(x(t))^-1((V(x(0)))-t). For instance, in the Example 1 considered above [eq.conv-rate1] implies exponential convergence with exponent $`\sigma\ae`$ (that is, $`V(t)\le V(0)e^{-\sigma\ae t}`$) (versus the rate $`\ae`$ in continuous time).