Event-triggered Pulse Control with Model Learning (if Necessary)

TL;DR

This paper introduces an event-triggered pulse control strategy that adaptively learns system dynamics when needed, reducing communication in networked control systems while maintaining high performance.

Contribution

It presents a novel control approach that combines event-triggered control with model learning, enabling effective control without prior accurate models.

Findings

Reduces communication in control systems.

Adapts to changing system dynamics.

Eliminates need for pre-existing accurate models.

Abstract

In networked control systems, communication is a shared and therefore scarce resource. Event-triggered control (ETC) can achieve high performance control with a significantly reduced amount of samples compared to classical, periodic control schemes. However, ETC methods usually rely on the availability of an accurate dynamics model, which is oftentimes not readily available. In this paper, we propose a novel event-triggered pulse control strategy that learns dynamics models if necessary. In addition to adapting to changing dynamics, the method also represents a suitable replacement for the integral part typically used in periodic control.

Tables

Table 1. TABLE I: Comparison of the average inter-communication times for Example  2 before and after learning. System 1 is shown in the left column, system 2 in the right.

$a,b$	Before	After	$a,b$	Before	After
$-10$	$1\mathrm{ms}$	$21\mathrm{ms}$	$-0.25$	$1\mathrm{ms}$	$80\mathrm{ms}$
$-4/3$	$1\mathrm{ms}$	$39\mathrm{ms}$	$-0.05$	$69\mathrm{ms}$	$132\mathrm{ms}$
$-0.5$	$114\mathrm{ms}$	$215\mathrm{ms}$	$-0.02$	$85\mathrm{ms}$	$431\mathrm{ms}$
$-0.25$	$111\mathrm{ms}$	$428\mathrm{ms}$	$-0.01$	$62\mathrm{ms}$	$384\mathrm{ms}$
$-1/6$	$101\mathrm{ms}$	$321\mathrm{ms}$	$-0.005$	$115\mathrm{ms}$	$850\mathrm{ms}$

Table 2. TABLE II: Comparison of the average inter-communication times for Example  3 before and after learning.

System	Before	After	System	Before	After
1	$44\mathrm{ms}$	$239\mathrm{ms}$	6	$128\mathrm{ms}$	$271\mathrm{ms}$
2	$136\mathrm{ms}$	$349\mathrm{ms}$	7	$56\mathrm{ms}$	$240\mathrm{ms}$
3	$107\mathrm{ms}$	$283\mathrm{ms}$	8	$55\mathrm{ms}$	$219\mathrm{ms}$
4	$135\mathrm{ms}$	$256\mathrm{ms}$	9	$89\mathrm{ms}$	$279\mathrm{ms}$
5	$163\mathrm{ms}$	$363\mathrm{ms}$	10	$34\mathrm{ms}$	$273\mathrm{ms}$

Equations

$$\mathrm{d}x(t)=Ax(t)\mathrm{d}t+Bu(t)\mathrm{d}t+ϵ\mathrm{d}t+Q\mathrm{d}W(t),$$

$$\displaystyle\gamma_{\mathrm{ctrl}}=1\iff\mathopen{}\mathclose{{}\left\lVert x(t)}\right\rVert_{2}\geq\delta,$$

$$\displaystyle u(t)=\begin{cases}0&\text{if }t-t_{k}>t_{\mathrm{inp}}\lor t_{k}=0\\ \phi_{u_{\mathrm{max}}}\mathopen{}\mathclose{{}\left(\hat{A},\hat{B},\hat{\epsilon},x_{t_{k}}}\right)&\text{if }t-t_{k}\leq t_{\mathrm{inp}}\land t_{k}\neq 0,\end{cases}$$

$$u(t)=F{\delta }_{t_k}(t),$$

$$\displaystyle\begin{split}x\mathopen{}\mathclose{{}\left(t_{k}}\right)&=\int\limits_{t_{k-1}}^{t_{k}}e^{A\mathopen{}\mathclose{{}\left(t_{k}-t}\right)}Bu(t)\mathop{}\!\mathrm{d}t\\ &+\underbrace{\int\limits_{t_{k-1}}^{t_{k}}e^{A\mathopen{}\mathclose{{}\left(t_{k}-t}\right)}\epsilon\mathop{}\!\mathrm{d}t+\int\limits_{t_{k-1}}^{t_{k}}e^{A\mathopen{}\mathclose{{}\left(t_{k}-t}\right)}Q\mathop{}\!\mathrm{d}W(t)}_{\coloneqq N\mathopen{}\mathclose{{}\left(t_{k}}\right)}\\ &=e^{A\mathopen{}\mathclose{{}\left(t_{k}-t_{k}}\right)}BF+N\mathopen{}\mathclose{{}\left(t_{k}}\right)\\ &=BF+N\mathopen{}\mathclose{{}\left(t_{k}}\right),\end{split}$$

$$x(t)=\underset{0}{\overset{t}{\int }}{e}^{A(t-s)}ϵ\mathrm{d}s+\underset{0}{\overset{t}{\int }}{e}^{A(t-s)}Q\mathrm{d}W(s).$$

$$\displaystyle\tau\coloneqq\inf\mathopen{}\mathclose{{}\left\{t:\mathopen{}\mathclose{{}\left\lVert x(t)}\right\rVert_{2}\geq\delta}\right\}.$$

$$\displaystyle\gamma_{\mathrm{learn}}=1\iff\mathopen{}\mathclose{{}\left\lvert\frac{1}{N}\sum_{i=1}^{N}\tau_{i}-\operatorname*{\mathbb{E}}[\tau]}\right\rvert\geq\kappa.$$

$$\kappa ={\tau }_{\max }\sqrt{-\frac{2}{N}\ln \frac{\eta }{4}}$$

$$\displaystyle\mathbb{P}\mathopen{}\mathclose{{}\left[\mathopen{}\mathclose{{}\left|\frac{1}{N}\sum\limits_{i=1}^{N}\tau_{i}-\frac{1}{M}\sum\limits_{i=1}^{M}\tau_{i}^{\mathrm{sim}}}\right|\geq\kappa}\right]<\eta.$$

$$\begin{array}{rl}x(k+1)& =A_{\mathrm{d}}x(k)+B_{\mathrm{d}}u(k)+ϵ+v(k)\\ & =\left(\begin{array}{ccc}{A}_{\mathrm{d}}& B_{\mathrm{d}}& ϵ\end{array}\right)\left(\begin{array}{c}x(k)\\ u(k)\\ 1\end{array}\right)+v(k),\end{array}$$

$$x(k+1)$$

$$y(k)$$

$$\displaystyle\begin{split}y(k+1)&=x(k+1)+\xi\\ &=A_{\mathrm{d}}\mathopen{}\mathclose{{}\left(y(k)-\xi}\right)+B_{\mathrm{d}}u(k)+v(k)\\ &=\begin{pmatrix}A_{\mathrm{d}}&B_{\mathrm{d}}&\mathopen{}\mathclose{{}\left(I-A_{\mathrm{d}}}\right)\xi\end{pmatrix}\begin{pmatrix}y(k)\\ u(k)\\ 1\end{pmatrix}+v(k).\end{split}$$

$$x(t)$$

$$0$$

$$t_{\mathrm{inp}}$$

$$\displaystyle\begin{split}\mathop{}\!\mathrm{d}x(t)&=ax(t)\mathop{}\!\mathrm{d}t+b\mathopen{}\mathclose{{}\left(u(t)+\epsilon}\right)\mathop{}\!\mathrm{d}t+Q\mathop{}\!\mathrm{d}W(t),\end{split}$$

Full text

I Introduction

In modern engineering, control systems are often connected over communication networks. Common examples for these networked control systems (NCS) include automation industry, where multiple plants have to be controlled often by a remote controller, building automation, where sensors and actuators are deployed to regulate the indoor climate, and coordinated flight of a swarm of drones. Communication then is a shared and therefore limited resource, thus, traditional, periodic control approaches are not feasible.

In this paper, we present a new architecture for event-triggered pulse control that quantifies model accuracy and, if necessary, automatically identifies system dynamics through learning. The decision, whether learning is necessary, is taken by a learning trigger. The proposed framework can cope with changing dynamics and load disturbances, that way replacing the integrator from periodic control.

A block diagram of the approach is provided in Fig. 1. We consider a plant with sensors and actuators, subject to process noise and disturbances ($v$ and $\epsilon$), and input saturations $u_{\mathrm{max}}$. Controller and actuator are connected over a communication network. Since communication is a scarce resource, periodic communication is not desirable and, therefore, we employ an event-triggered design (block ‘State Trigger’). In case of an event, we apply a pulse with length $t_{\mathrm{inp}}$ to reset the system to its equilibrium state. The pulse length naturally depends on the system dynamics. To obtain an accurate model of the system dynamics, we leverage system identification techniques to learn the model from data. As learning may be expensive, e.g., due to the involved computations, we only learn a new model if necessary, for instance, in case of a poor initial model or if the dynamics have changed. This decision process is made by the ‘Learning Trigger’. Based on a statistical analysis of the time between events, the learning trigger decides whether the model of the system dynamics is accurate enough. If not, learning of a new model is triggered. We thus have two different triggers: the state trigger ($\gamma_{\mathrm{ctrl}}$), which triggers communication of control commands if necessary, and a learning trigger ($\gamma_{\mathrm{learn}}$), which triggers learning in case of bad performance.

Contributions: We make the following contributions:

• •

A new architecture for event-triggered pulse control that automatically learns dynamics model to cope with changing dynamics;

• •

Development of a learning trigger for ETC, which allows to automatically identify system dynamics if necessary;

• •

Handling load disturbances by learning and compensating for them, thus replacing the integrator typically used in periodic control in a way suitable for ETC.

Related work: Reducing communication is one key aspect of NCS and has been addressed by introducing event-triggered methods [1, 2]. While most of these approaches are based on a dynamical model of the system, the model is typically assumed to be given and not learned from data as proposed herein.

The ‘Learning Trigger’ in Fig. 1 is based on a framework developed in recent work [3]. There, ETL was introduced to trigger learning experiments in event-triggered state estimation (ETSE). Here, we extend this framework to control. We look at a straightforward type of ETC, namely event-triggered pulse control. In contrast to [3], which considered a linear system perturbed only by Gaussian noise, we also consider load disturbances herein.

Using Dirac inputs for ETC, as we do for developing the learning trigger, has also been investigated in other works on ETC such as [4, 5, 6]. However, the approximation we propose to take into account input saturations has not been discussed therein. Moreover, none of these references considers learning approaches to cope with changing system dynamics or disturbances.

The problem of finding a replacement for continuous or periodic integral control that is suitable for ETC (e.g., to deal with load disturbances) has for instance been addressed in [7], where a disturbance observer is used. Instead of introducing a disturbance observer, we directly include the load disturbances in the learning framework. As PID-controllers are the most common controllers used in industry, event-triggered PID-control has also been investigated starting from [8]. A particular problem here is the replacement of the integral part of the PID-controller [9]. Mostly, a network between sensor and controller is considered, thus the main problem for the integral part is the non-constant sampling time of the event-triggered mechanism. In [10], this is dealt with by explicitly taking into account the actual sampling time instead of assuming a nominal, constant sampling time. A different approach is presented in [11], where the event detector is connected to the sensor. Instead of looking at the absolute value of the integrator, the difference between the current value and the value at the last triggering instant is used to trigger communication, as a constant value of the integrator indicates a control error of zero. Replacing the integrator through model learning has not been proposed yet.

Event-triggered controllers can also be learned from data without learning a model. Such approaches are proposed, for example, in [12, 13, 14, 15]. In contrast to those approaches, we use a specific control design and use learning to obtain accurate dynamic models.

Outline: In the following section, we formulate the problem setting. After that, we introduce the approach for event-triggered pulse control and discuss the concrete implementation of the learning trigger in Sec. III. In Sec. IV, we will present a numerical study and conclude with a discussion in Sec. V.

II Problem Formulation

We consider linear, time-invariant systems of the form

[TABLE]

with the state $x(t)\in\operatorname*{\mathbb{R}}^{n}$, the control input $u(t)\in\operatorname*{\mathbb{R}}^{m}$, the constant load disturbance $\epsilon\in\operatorname*{\mathbb{R}}^{n}$, and $W(t)\in\operatorname*{\mathbb{R}}^{n}$ a multidimensional Wiener process representing process noise. We assume that we can measure the full state, thus, $y=x$ in Fig. 1.

As depicted in Fig. 1, control commands have to be transmitted over a communication network. We thus employ an event-triggered design, with the block ‘State Trigger’ implemented by

[TABLE]

where $\delta$ is a user-defined threshold and is essentially the deviation from the equilibrium that we are willing to tolerate. In case of an event, i.e., $\gamma_{\mathrm{ctrl}}=1$, we apply a pulse to reset the system to its equilibrium,

[TABLE]

where $\phi_{u_{\mathrm{max}}}$ is the pulse generating policy, $(\hat{A},\hat{B},\hat{\epsilon})$ captures the model of the system dynamics, $x_{t_{k}}$ is the state of the system at the triggering instant $t_{k}$, $t_{\mathrm{inp}}$ is the pulse length (see Fig. 1), and $u_{\mathrm{max}}$ the maximum input the actuator can apply. By applying a pulse with appropriate length, we can reset the system to its equilibrium state. This, however, requires that we have a model that accurately describes the true system dynamics. We obtain this model, and adapt it in case the dynamics change, via model learning techniques. Model learning may be expensive due to the involved computations or required exploration, therefore, we only want to learn in case the estimated dynamics $(\hat{A},\hat{B},\hat{\epsilon})$ deviate too much from the true dynamics $(A,B,\epsilon)$. Since the true dynamics are unknown, the decision needs to be based on some implicit feature, which will be the communication signal. Developing such a learning scheme for ETC is the main objective of this paper.

III Event-triggered Pulse Control with Model Learning

In this section, we present the event-triggered control and learning framework. We start with a derivation of the learning trigger assuming Dirac impulse control, then show how we learn the system dynamics, and finally detail practical pulse control (with bounded pulses) for first-order systems.

III-A Event-triggered Learning for Control

The learning trigger is based on the framework presented in [3] for ETSE. Here, we extend this framework to ETC. For the theoretical analysis, we assume a control strategy based on Dirac impulses, i.e., here, we will ignore the assumption of having an input saturation at the actuator. Using Dirac impulses, we can, similarly as in ETSE [3], reset the error to zero at communication times. We then have a control law of the form

[TABLE]

where $F$ is the control gain and $\delta_{t_{k}}$ the Dirac impulse. In particular, the control input is zero apart from the triggering times $t_{k}$, where $t_{k}$ corresponds to $\gamma_{\mathrm{ctrl}}=1$ in (2). To further analyze this scheme, we write (1) in integrated form,

[TABLE]

where we assume that the process starts in $x(t_{k-1})=0$ and $N(t_{k})$ is the measurement we get before applying the impulse. By setting (5) to zero we can (assuming $B$ invertible) show that $F=-B^{-1}N(t_{k})$ resets the system to zero. Implementing such a control law then also fulfills the prior assumption of $x(t_{k-1})=0$, as the system starts in zero after every triggering instant. In Sec. III-C, we will drop the assumption of being able to apply Dirac impulses as inputs and instead apply pulses with the maximum input $u_{\mathrm{max}}$ for a given time.

Considering a control law as proposed in (4), we thus have a random process that always starts in zero. This is only true, if the input matrix $B$ is known exactly. In that case, the sole cause of an error would be propagated noise and the load disturbance $\epsilon$. Therefore, in case of no communication, we obtain

[TABLE]

We can now define a stopping time $\tau$ as the first moment the state crosses the threshold $\delta$, which resets the error to zero,

[TABLE]

The stopping times defined in (7) coincide with the time between communication, hence, ‘stopping times’ and ‘inter-communication times’ will be used synonymously hereafter. We can now further define the expected value of these stopping times, $\operatorname*{\mathbb{E}}[\tau|x(0)=0]$, which is the average inter-communication time of the system. This expected value can be obtained via Monte Carlo simulations (for a more detailed discussion, see [3]).

If we had a perfect model of the system dynamics, the average inter-communication times that we observe in the system should approach the expected value of the stopping time. If both values deviate by too much, we have evidence that the model is inaccurate and can trigger learning of a new model. Precisely, we define the learning trigger in Fig. 1 as

[TABLE]

In this equation, $\gamma_{\mathrm{learn}}\!=\!1$ indicates that a new model shall be learned, $\operatorname*{\mathbb{E}}[\tau]$ is approximated using Monte Carlo simulations, i.e., $\operatorname*{\mathbb{E}}[\tau]\!\approx\!\frac{1}{M}\sum_{i=1}^{M}\tau_{i}^{\mathrm{sim}}$, and $\tau_{1},\tau_{2},\ldots,\tau_{N}$ define the last $N$ empirically observed inter-communication times. Due to the randomness of the process, it can still happen that we trigger learning despite the model being perfect. Assuming that the stopping times are bounded by $\tau_{\mathrm{max}}$, the confidence level can be quantified using Hoeffding’s inequality [16] and influenced through the design parameter $\eta$.

Theorem 1

Let the parameters $\eta$, $N$, $M>N$, and $\tau_{\mathrm{max}}$ be given, $\tau_{1},\ldots,\tau_{N}$ and $\tau_{1}^{\mathrm{sim}},\ldots,\tau_{M}^{\mathrm{sim}}$ independent and identically distributed, and assume a perfect model. For

[TABLE]

we obtain

[TABLE]

Proof:

We compare stopping times obtained via Monte Carlo simulations with stopping times observed from the real process. In both cases, we have a random process that always starts in zero. This is the same setting as investigated in [3], thus, the theorem can be proven as shown therein. ∎

Boundedness of the stopping times can easily be ensured in practice by applying a control input the latest when $\tau_{\mathrm{max}}$ is reached. The confidence parameter $\eta$ then basically defines the tradeoff between accepting an inaccurate model or triggering learning despite the model being perfect. Intuitively, $\eta$ defines the probability that the error $\kappa$ is observed, while empirical and expected stopping times are drawn from the same distribution (i.e., we have a perfect model). If this probability is below a predefined threshold, we trigger learning of a new model.

III-B Model Learning

For the derivation of the stopping times as well as for the final controller design, we need knowledge of the full system dynamics (matrices $A$ and $B$) and the load disturbance $\epsilon$. To calculate the stopping times, e.g., via Monte Carlo simulations, we additionally need knowledge of the process noise variance $Q$. To estimate the model, we rewrite system (1) in discrete time,

[TABLE]

with $A_{\mathrm{d}}$, $B_{\mathrm{d}}$ the discrete-time system and input matrix, respectively, and $v(k)$ the discrete-time process noise. That way, we can learn the system dynamics with standard least-squares techniques, as we will demonstrate in Sec. IV.

Having knowledge of the load disturbances, we can incorporate them in the control design in Sec. III-C. This represents a suitable solution to replace the integral part of standard, periodic controllers.

Remark 1

Another problem that may be considered with this approach is the knowledge of the zero-level of the system. We are considering an equilibrium at $x(t)=0$, but the measurements are actually voltage signals from a sensor and what zero means for that system is not clear from the beginning. We can model this as a sensor bias, i.e., we would have the following system dynamics

[TABLE]

where $\xi$ is the sensor bias. Rewriting this yields

[TABLE]

Thus, we can identify the system dynamics and the sensor bias via least-squares techniques. Estimating both, a sensor bias and a load disturbance, is, however, not possible, as they are not distinguishable given the output data.

III-C Implementation of Event-triggered Pulse Control with Input Saturation

If the state of the system exceeds the threshold $\delta$, we want to quickly reset it to zero. Application of Dirac impulses is not compatible with our assumption of an input saturation at the actuator.

Instead of applying Dirac impulses, we propose to apply the maximum input and vary the duration of the pulse. This has two main benefits: 1) The input cannot exceed the saturation and, thus, will drive the system state to its desired value, as it will not be limited by the saturation; 2) The system will be driven to zero as fast as possible, that way coming as close to the idealized Dirac input as possible. This represents a straightforward approach to lift the idea of ETL to the ETC setting. For the derivation of the length of the pulse, we will restrict ourselves to first-order systems (i.e., $n=1$ in (1) with scalar variables $a$ and $b$) and later comment on extensions to higher-order systems.

To derive the length of an impulse, we look at the system equation in integrated form. If no event is triggered, i.e., if the system is close to its desired state, we have $u(t)=0$. At triggering times $t_{k}$ we apply the maximum input,

[TABLE]

The input shall be applied for long enough such that the state becomes zero. We thus set (14) to zero and solve for $t$ (setting $t_{k}=0$),

[TABLE]

which leads to

[TABLE]

In (14) and (15), we assumed the noise to be zero during the application of the pulse. For the Dirac impulse, this holds, as the time of the application tends to zero. Here, we explicitly derive how long the input will be applied, hence, the system will during this time also be excited by noise and we will not be able to exactly drive it to zero. We take this into account when computing the stopping times. Instead of starting at zero, we consider a process that starts in $x(0)\sim\mathcal{N}(0,\Sigma_{0})$, with variance $\Sigma_{0}$.

Remark 2

For a system (1) with state dimension $n>1$, a single pulse will generally not be sufficient to drive the state to zero. Instead, we would have to change between maximum and minimum input, which leads to a bang-bang controller [17]. Then, $t_{\mathrm{inp}}$ in Fig. 1 would be a vector containing the switching points. Different algorithms have been proposed in literature to find these switching points [18, 19]. This paper is a first approach towards combining the ideas of ETL with ETC and the extension to bang-bang type of controllers is beyond the scope of this work. Generalizations to such or other control structures are, however, certainly important questions for future work.

IV Numerical Study

For the numerical study, we will consider a collection of first-order processes. For each system, we assume a remote controller that is colocated with the sensor, but needs to transmit its actuation commands over a communication network, where all controllers share the same network. For all examples, we assume a threshold of $\delta=0.02$. As parameters of the learning trigger, we choose a confidence level $\eta=0.05$, $N=$2000, $M=$10\,000, and $\tau_{\mathrm{max}}=$1\text{,}\mathrm{s}. According to Theorem [1](#Thmtheo1), we then obtain $\kappa\approx$0.066.

In [20, p. 227], a batch of process models that are common in process industry is collected. Among others, typical parameters for first-order systems with time delay are provided. We will start the numerical investigation of the proposed framework in Sec. IV-A by looking at these models, but we neglect the time delay. The models have stable dynamics as is a common property in process industry. To showcase the capability of the framework to also deal with unstable systems, we will consider such examples in Sec. IV-B. For all investigated systems, we will consider additional process noise and load disturbances. We model the load disturbance to enter with the input, similar as for instance done in [21, p. 54].

As in (1), we assume continuous-time systems

[TABLE]

which we discretize with a sample time of $1\text{\,}\mathrm{ms}$. The sample time is not equal to the update interval of the communication system and is only limited by the maximum frequency of the timers in the processors used for controller and actuator. A fine discretization is necessary, as we will derive a continuous pulse length. The finer the discretization is, the more accurate is the application of the pulse (and the earlier we notice if the system is outside the tolerable range).

IV-A Stable Dynamics

As a proof of concept, we first consider one specific from [20] (note that the first-order systems provided therein always lead to $a=b$):

Example 1

System (16) with $a=b=-0.01$, process noise $Q=10^{-4}$, load disturbance $\epsilon=5$, and maximum input $u_{\mathrm{max}}=100$. In case learning is triggered, we always collect data for $200\text{\,}\mathrm{s}$ and then use these data points to identify the system dynamics.

In Fig. 2, the average and expected inter-communication times are shown. The average inter-communication times are computed with a moving average over $2000$ stopping times, which we reset in case learning is triggered and after deriving new system matrices. In the beginning, we assume that we have an accurate model, hence, the observed inter-communication times approach the expected ones. After $2000$ stopping times, we set the load disturbance to $\epsilon\!=\!10$. As expected, the inter-communication times decrease and learning is triggered. After learning (first vertical line in Fig. 2), the empirical inter-communication times again approach the expected ones and we reduce communication. In a second change, after $7000$ stopping times, we have $\epsilon\!=\!20$ and $a=b=-0.05$. Similar as before, this leads to a decrease of the average inter-communication time and learning is triggered. Having learned new dynamics (second vertical line in Fig. 2), the empirical inter-communication times again approach the expected ones, i.e., average communication is reduced through learning.

We now consider the case where the initial matrices that we have of the process are wrong. Both, nominal and true dynamics of the systems are again taken from [20]:

Example 2

Two systems of the form (16) with nominal dynamics $a=b\in\{-0.1,-1\}$, load disturbances $\epsilon\in\{0.1,1\}$, $Q=10^{-4}$, and $u_{\mathrm{max}}\in\{1,100\}$. For the true dynamics, $a$ and $b$ are given in Table I, the noise variance and load disturbance are sampled from uniform distributions over the intervals $Q\in[10^{-4},10^{-3}]$, $\epsilon\in[0.1,0.2]$ (for system 1), and $\epsilon\in[1,5]$ (for system 2). In case learning is triggered, we use all data collected so far to identify the system dynamics.

The inter-communication times before and after learning the dynamics are given in Table I. It can clearly be seen that learning helps in lowering communication.

IV-B Unstable Dynamics

For the investigation of systems with unstable dynamics, we look at the following system:

Example 3

System (16) with nominal dynamics $a=5$, $b=3$, $\epsilon=0.01$, $Q=10^{-4}$, and maximum input $u_{\mathrm{max}}=1$. The true dynamics are sampled from random distributions over the intervals $a\in[1,10]$, $b\in[1,2]$, $\epsilon\in[0.01,0.02]$, and $Q\in[10^{-4},10^{-3}]$. As in Example 2, we use all data we have collected so far to identify a new model in case learning is triggered.

In Table II, we compare the average inter-communication times of all systems before and after deriving new system matrices. For all of them, we observe a significant increase in the inter-communication times after learning, i.e., communication is reduced. This demonstrates that the approach is also suitable for unstable systems.

In Fig. 3, one specific system from Example 3 is shown before (Fig. 3a) and after (Fig. 3b) learning new system matrices. Due to the error in the initial matrices, the system is not reset to zero with the pulses before learning and, thus, new control inputs have to be generated very frequently. After learning, the pulse length is such that the system is successfully reset, which also results in increased inter-communication times, and, therefore, less communication. This is especially emphasized as in Fig. 3a, before learning, we show only $1\text{\,}\mathrm{s}$, while in Fig. 3b we show $2\text{\,}\mathrm{s}$ and still observe far less pulses.

The study reveals that the proposed architecture enables us to increase inter-communication times through learning. We are able to learn system dynamics and subsequently reset the state of the system to zero in case it leaves its tolerable range. Through learning load disturbances, the architecture is a suitable replacement for integral control in event-triggered settings.

V Conclusion

In NCS, communication is a scarce and limited resource. In this work, we presented a framework for event-triggered pulse control for NCS. Most common event-triggered control approaches rely on the availability of an accurate dynamics model. Contrary to that, the proposed framework does not rely on this assumption, but uses model learning instead. As learning is expensive (e.g., due to the involved computations), we only learn if necessary using the ETL framework. By observing the communication behavior, we quantify the accuracy of the model and trigger learning of a new model only in case the accuracy is not sufficient. The presented control design respects input saturations and can also handle load disturbances, thus essentially replacing the integral part of common periodic controllers.

A numerical study demonstrates the applicability of the approach and the benefit of learning the system dynamics. After learning, we observe a significant increase in the inter-communication time. However, the presented examples are first-order systems. While we have outlined how higher-order systems could be treated (Remark 2), the actual extension to such systems is an interesting topic for future work. Moreover, we assumed that we are able to perfectly measure the full state of the system. Incorporating Gaussian measurement noise is already possible with the presented approach. How to extend the ETL framework to partial state measurements is subject to ongoing research.

In this work, we proposed for the first time to trigger model learning experiments in ETC to adapt to changes in the dynamics. The learning trigger compares the expected and the observed time between communication. While this is an intuitive approach, in some cases this trigger does not detect disturbed models. A more robust behavior can be achieved by triggering on the full distribution, e.g., via a Kolmogorov-Smirnoff test, which is subject of current research [22].