Synthesizing communication plans for reachability and safety specifications
Kazumune Hashimoto, Dimos V. Dimarogonas

TL;DR
This paper develops control and communication strategies for nonlinear networked control systems to ensure reachability of a target set and safety constraints, using Lyapunov functions and abstraction methods.
Contribution
It introduces a novel approach combining $elta$-ISS control Lyapunov functions with abstraction schemes for efficient communication scheduling.
Findings
Effective control and communication strategies validated by simulations.
Guarantees of reachability and safety under the proposed schemes.
Reduced computational complexity through abstraction and graph search.
Abstract
We propose control and communication strategies for nonlinear networked control systems subject to state and input constraints. The objective is to steer the state of the system towards a prescribed target set in finite time (\textit{reachability}), while at the same time remaining inside a safety set for all time (\textit{safety}). By leveraging the notion of -ISS control Lyapunov function, we derive a sufficient condition to generate a communication scheduling, such that the resulting state trajectory guarantees reachability and safety. Moreover, in order to alleviate computational burden we present a way to find a suitable communication scheduling by implementing abstraction schemes and standard graph search methodologies. Simulation examples validate the effectiveness of the proposed approach.
Click any figure to enlarge with its caption.
Figure 1
Figure 2
Figure 3
Figure 4
Figure 5
Figure 6
Figure 7
Figure 8
Figure 9
Figure 10
Figure 11
Figure 12
Figure 13
Figure 14
Figure 15
Figure 16
Figure 17
Figure 18
Figure 19
Figure 20
Figure 21
Figure 22
Figure 23
Figure 24
Figure 25
Figure 26
Figure 27
Figure 28
Figure 29
Figure 30
Figure 31
Figure 32
Figure 33
Figure 34
Figure 35
Figure 36
Figure 37
Figure 38
Figure 39
Figure 40| Num. of communication | 430 | 484 | 530 | — |
| Computation time (s) | 32 | 5.4 | 0.62 | — |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsFormal Methods in Verification · Petri Nets in System Modeling · Advanced Control Systems Optimization
Synthesizing communication plans for reachability and safety specifications
Kazumune Hashimoto, Dimos V. Dimarogonas, Kazumune Hashimoto is with the School of Electrical Engineering and Computer Science, KTH Royal Institute of Technology, 10044 Stockholm, Sweden (e-mail: [email protected]). His work is supported by the Knut and Alice Wallenberg Foundation.Dimos V. Dimarogonas is with the ACCESS Linnaeus Center, School of Electrical Engineering and Computer Science, KTH Royal Institute of Technology, 10044 Stockholm, Sweden (e-mail : [email protected]). His work was supported by the Swedish Research council (VR) and the Knut and Alice Wallenberg Foundation.
Abstract
We propose control and communication strategies for nonlinear networked control systems subject to state and input constraints. The objective is to steer the state of the system towards a prescribed target set in finite time (reachability), while at the same time remaining inside a safety set for all time (safety). By leveraging the notion of -ISS control Lyapunov function, we derive a sufficient condition to generate a communication scheduling, such that the resulting state trajectory guarantees reachability and safety. Moreover, in order to alleviate computational burden we present a way to find a suitable communication scheduling by implementing abstraction schemes and standard graph search methodologies. Simulation examples validate the effectiveness of the proposed approach.
Index Terms:
Event and self-triggered control, constrained control, reachability and safety.
I Introduction
With the advent of communication technologies, there has been a growing trend of introducing communication networks in many control applications, such as manufacturing plants, autonomous robots, traffic systems, and so on [1]. Typically, a control system whose sensors, actuators, and controllers are spatially distributed and connected over communication channels is referred to as a Networked Control System (NCS). On one hand, the introduction of NCSs has many advantages, such as the elimination of redundant wirings, the availability to control a plant remotely in distant areas, and so on [2]. On the other hand, the introduction of NCSs has raised new technological challenges that remain to be solved. In particular, one of the crucial challenges lies in the fact that NCSs are subject to limited resources, such as limited life-time of battery powered devices and a limited communication bandwidth. For example, sensors and relay nodes are typically battery driven and are equipped with a frugal battery capacity. Thus, designing appropriate feedback controllers to save energy consumption is a crucial problem to be solved. In order to reduce redundant utilizations of such limited resources, two relevant control schemes have been proposed, namely, event-triggered control and self-triggered control [3]. In both strategies, the objective is to reduce the communication frequency between the plant and the controller. Specifically, sensor data and control signals are exchanged over a communication network only when they are needed, so that communication is given aperiodically. Such aperiodic scheme can potentially lead to energy savings of battery powered devices, since the communication over the network is known to be one of the crucial energy consumers.
So far, event and self-triggered control strategies have been analyzed for many different types of systems, including linear systems [4, 5, 6, 7, 8], nonlinear systems [9, 10], and distributed control systems [11]. In addition, more sophisticated approaches to reduce sensing and communication costs have been provided, such as periodic event-triggered control [12, 13] and dynamic event-triggered control[14]. Some experimental validations of applying the event-triggered and self-trigered control schemes have also been provided, see e.g., in [15, 16]. For more different formulations and approaches, see [17] for a recent survey paper.
In this paper, we consider the following problem: “design control and communication strategies, such that the state of the system is steered towards a given target region (reachability), while at the same time remaining inside a given safety set for all times (safety)”. In other words, we present aperiodic control strategies for achieving reachability and safety, in contrast to the afore-cited approaches in which the control objective is mostly stabilization (of the origin) or output regulation. Reachability and safety controller synthesis have been active areas of research in various control applications, such as flight control systems[18], motion planning of dynamic robots[19], safe platooning or control of maneuvers [20], to name a few, and many different theoretical foundations and problem formulations have been already proposed, see e.g., [21, 22, 23, 24, 25]. For example, in [21], reachability analysis is given for continuous-time linear systems on a set of full-dimensional polytopes (or simplices) that are partitioned in a state-space. A piece-wise affine control law is designed as a set of vector fields to steer the state to exit a prescribed facet in finite time to enter an adjacent polytope. Another approach to controller synthesis problem is based on approximately bisimilar abstractions[24, 25]. In this approach, a symbolic model that approximately simulates the behavior of the original control system is constructed through the notion of approximate bisimilar relations, and a safety controller is synthesized based on finding appropriate paths by solving symbolic optimal control problems.
While many control strategies to achieve reachability and safety have been proposed as illustrated above, only a few works have been provided to accommodate communication strategies, aiming at reducing the communication load for NCSs, see e.g., [7, 26]. For example, in [7] an aperiodic control scheme was proposed by using the notion of control invariant set, which guarantees the existence of a controller such that the state remains inside the safety set for all time. However, a fundamental assumption required in that paper is that the safety set is convex; essentially, this assumption is required to obtain the invariant set as well as to make the optimal control problem convex. Thus, designing suitable control and communication strategies for a non-convex safety set may still be a challenging problem, which is the case considered in this paper.
The approach presented here differs from the existing event and self-triggered control strategies in the following way. We start by defining the notion of -ISS control Lyapunov function, which is a variant of -ISS Lyapunov functions[27, 28] that are defined for systems without controls. This function is a useful tool to analyze contractive behaviors between any pair of the state trajectories, and has been attracted much attention in various analysis and control design applications, see, e.g., [25, 29]. Based on this function, we next introduce the notion of an error propagation model, which quantifies how a closed loop state trajectory can track a given reference according to the occurrence or non-occurrence of communication. The error propagation model is a key ingredient to derive a sufficient condition to generate a communication scheduling that guarantees reachability and safety. Moreover, in order to alleviate the computational burden to find a suitable communication scheduling, we next translate the error propagation model into a symbolic error system, which is a variant of transition systems. By this translation, a suitable communication scheduling to achieve reachability and safety can be efficiently found by implementing standard graph search algorithms.
The proposed approach builds upon our previous work [26]. In [26], we construct a collection of polyhedral contractive sets with different inter-event times and control updates. Then, these sets are translated into the corresponding symbolic system, and the communication scheduling is generated by graph search algorithms. However, the previous approach is only applicable to linear discrete-time systems with a convex safety set, and, moreover, the control objective is the stabilization to the origin. In the approach presented in this paper, we deal with nonlinear discrete-time systems and a non-convex safety set and the control objective is to achieve reachability and safety. Thus the proposed approach establishes the novelty with respect to the previous approach in [26]. As we will see later, the key ideas to achieve this novelty is the utilization of several trajectory generation tools, such as RRT[30], RRT*[31], which allows to generate a nominal state trajectory towards a target region in a non-convex safety set (see Section III-A), and the utilization of -ISS control Lyapunov functions, which allows to analyze how the actual state trajectory differs from the nominal one according to the occurrence of communication (see Section IV-A).
The rest of the paper is organized as follows. We provide some premilinaries and the problem formulation in Section II. The control and communication strategies are proposed in Section III and IV, respectively. In Section V, simulation results are given to validate the effectiveness of the proposal including linear and nonlinear systems. Finally, conclusions and future works are provided in Section VI.
Notations. Let , , , be the non-negative real, positive real, non-negative integers, and positive integers, respectively. We denote as the set of integers in the interval . A function is called a class -function if it is continuous, strictly increasing, and . It is called a class -function if it is a class -function and as . We denote by the identity function, i.e., , . The notation is used to denote the composition of the two functions and . The notation is used to denote the maximum singular value of the matrix . We denote by the Euclidean norm of vector .
II Problem formulation
II-A Plant dynamics, free-space
Let us consider a networked control system depicted in Fig. 1, where the plant and the controller are connected over a communication network. We assume that the dynamics of the plant is given by the following nonlinear system:
[TABLE]
where is the state at time step , is the control input, and is the disturbance. The control and the disturbance variables are constrained as , , , where
[TABLE]
for given positive constants , . In addition, the state is constrained as , , where is a bounded polygonal set that can be either a convex or non-convex region. The set represents the free-space, in which the state is allowed to move. Inside , there exists an initial region in which the state is initiated at , i.e., , and a target region to which the state aims to move. For simplicity, we assume that the regions are disjoint and are both represented by polytopes. Moreover, let denote the Chebyshev center [32] of the polytope . The Chebyshev center is the center of the maximum ball that is included in the polytope and is obtained by solving a linear program (for details, see Section 5.4.5 in [32]).
For the function , we assume the following:
Assumption 1**.**
The function is Lipschitz continuous in and , i.e., there exist positive constants and , such that for all , , and ,
[TABLE]
II-B -ISS control Lyapunov function
With respect to the control system (1), we introduce the following function as the key ingredient to design appropriate control and communication strategies.
Definition 1**.**
A smooth function is said to be a -ISS control Lyapunov function, if for all , and , there exist a smooth function , class -functions , , , and a class -function , such that:
[TABLE]
[TABLE]
where , .
The closest notion to Definition 1 is a -ISS Lyapunov function [27, 28] that is defined for systems without controls. As stated in [27, 28], a -ISS Lyapunov function is a useful tool to analyze incremental input-to-state stability, which captures the contractive behaviors between any pair of the state trajectories. Moreover, the function has been also utilized to obtain finite abstractions for nonlinear control systems in (1), see, e.g., [25, 29]. In contrast to the afore-cited analysis, in this paper we make use of Definition 1 in order to design not only a control strategy such that the resulting state trajectory achieves reachability and safety, but also a communication strategy such that the communication reduction is achieved for the NCSs. Note that as shown in (1), the state-feedback controller is applied to only one of the two states (i.e., ). The intuition behind here is that we will analyze contractive behaviors between a closed-loop state trajectory with the control law and an open-loop state trajectory that will be generated offline, as we will see in later sections.
Throughout the paper, we assume the existence of the -ISS control Lyapunov function:
Assumption 2**.**
For system (1), there exist smooth functions and , such that is a -ISS control Lyapunov function with respect to satisfying (5), (1). Moreover, for any and , there exist a class -function and a class -function , such that
[TABLE]
For example, consider the linear system: , where the pair is assumed to be stabilizable. Let be a candidate -ISS control Lyapunov function and be the corresponding control law, where is given such that is Hurwitz. Indeed, the condition (5) trivially holds and we also have
[TABLE]
so that we have with . Thus, the function is a -ISS control Lyapunov function with respect to . Moreover, (7) holds with and .
II-C Overview of the communication strategy
During the implementation, the plant interacts with the controller over the communication network to update the control inputs in real time. To indicate the communication times, let , be given by
[TABLE]
That is, if the plant transmits the state information to the controller, based on which the control input is updated and transmitted back to the plant. On the other hand, if no communication occurs at . Instead, as we will see later, the plant makes use of a control input that is obtained before the online implementation.
In this paper, we will present two ways to generate a suitable communication scheduling. The first one is an offline approach, in which we preliminary define the communication scheduling before the online implementation. In other words, the communication times are fixed for all state trajectories from to . The offline approach is beneficial in the sense that it does not require any computational effort to generate communication scheduling during online execution. On the other hand, the offline communication strategy tends to be conservative, which means that it yields more communication times than the one that is actually (minimally) required to guarantee reachability and safety. In view of this, we further provide an online approach as the second communication strategy, in which the controller assigns suitable communication schedulings during online execution. The online communication strategy is given in a self-triggered manner, meaning that for each communication time the controller determines the next communication time based on the state information that is received from the plant.
II-D Problem formulation
To formulate the problem, we define the validity of a state trajectory as follows:
Definition 2**.**
For given , , and disturbance sequence , the trajectory is called valid if the following conditions hold:
(Dynamics): there exist , , such that , ; 2. 2.
(Safety): , ; 3. 3.
(Reachability): .
That is, the trajectory is valid if there exists a controller such that the state can reach in finite time, while at the same time always remaining inside for guaranteeing safety. Based on the above, the goal of this paper is to design suitable control and communication strategies, such that the corresponding trajectory becomes valid:
Problem 1**.**
For a given , design both control and communication strategies, such that the resulting trajectory is valid for all , .
III Control Strategy
In this section, we provide a control strategy as a solution to Problem 1. First, we provide an offline procedure to design the control strategy (Section III-A). Then, we describe how the control strategy is implemented online (Section III-B).
III-A Offline procedure
In the offline step, we generate a nominal state trajectory from to . Specifically, we aim to produce a state trajectory and the corresponding control for some , such that ,
[TABLE]
and . Recall that represents the Chebyshev center of . Roughly speaking, the trajectory represents a reference that the actual state should follow to move from to .
So far, numerous techniques have been proposed to generate the reference trajectory as described above. Popular ones are the well-known sampling-based algorithms, such as RRT[30], RRT*[31] and their variants such as g-RRT [33]. Sampling-based algorithms are powerful techniques to find feasible state trajectories even in a complex (non-convex) state-space , and have been demonstrated successfully in many control applications, especially in robotics. An alternative method is the cell-decomposition approach [22, 21]. For example, in [22] the state-space is decomposed into a set of polytopes, and a piece-wise affine control law is designed for each polytope to steer the state towards the neighboring polytopes. Moreover, we can also utilize optimization-based approaches, such as those solving constrained optimal control problems [34, 35]. In view of the many different techniques as illustrated above, the way that the trajectory is derived is beyond the scope of this paper; we can utilize any of the above techniques to obtain the reference state and control trajectories.
III-B Control strategy
Suppose that we have found reference state and control trajectories , in an offline manner according to the procedure presented in the previous subsection. Then, starting from any , the following control strategy is provided during online implementation: for all ,
[TABLE]
That is, if the communication is taking place at , the controller applies the state-feedback control law defined in Assumption 2 by using the actual state that is received from the plant. Intuitively, from Definition 1 the occurrence of the communication () implies that the error between the actual state and the reference potentially becomes smaller. Thus, the occurrence of communication allows the actual state trajectory to track the given reference, which increases the possibility to achieve reachability and safety. On the other hand, if the communication is not given the plant applies the reference . Although the error may propagate in this case, we can instead reduce the communication frequency by not providing the communication. In the next section, we provide a more quantitative analysis for the above intuition and propose a detailed communication strategy.
IV Communication strategy
Based on the control strategy provided in the previous subsection, we now provide a detailed procedure to generate a communication scheduling , as well as an implementation algorithm of the communication strategy.
IV-A Deriving error propagation model
Let , be given by an error between the actual state and the reference with respect to at time step , i.e., , where is given in Assumption 2. In the following, we describe how this error behaves according to whether communication is given () or not given (). For a given , suppose that and the control law in (12) is applied. Let . From (1), we obtain
[TABLE]
where , and . Thus, we obtain
[TABLE]
where denotes the identity function. Without loss of generality, we assume that the function is a class -function1)1)1)This is due to the fact that for any -function , there exists a class -function such that: (i) , ; (ii) is a class -function, see [36]. . In addition to the error propagation of the states, it is required that the control input satisfies the constraint, i.e., . To derive the condition for this, observe that from (7) we obtain
[TABLE]
where we have used from (5). Thus, if .
Suppose now that and the control law in (13) is applied. Let . From the Lipschitz continuity in Assumption 1, it follows that
[TABLE]
where and (with ). Moreover, from (5) we obtain and . Thus, we obtain
[TABLE]
Note that the input constraint is satisfied for this case, i.e., . Consequently, for both and [math], we obtain
[TABLE]
where the function is defined by
[TABLE]
The inequality (15) indicates that if the communication is given at (i.e., ), the error between the actual state and the reference potentially becomes smaller. Indeed, if is large enough to satisfy , it holds that and the error gets strictly smaller at the next time. On the other hand, the error may grow according to (15) (with ) if the communication is not given. Thus, we can quantitatively evaluate the propagation of the error according to the relation given in (15). Note that since , , , and are class (or )-functions, the function is monotone[37] with respect to and , i.e., for any , with , and with , it holds that
[TABLE]
As will be shown below, the monotonicity property plays an important role to derive suitable conditions to guarantee the validity of the state trajectory.
For given , and , let , be recursively given by
[TABLE]
That is, represents the upper bound of by setting the disturbance sequence as the maximal (worst case) one and considering the equality in (15) for all . In addition, let , be given by
[TABLE]
where . The set indicates the set of all states around such that the error value is less than . From (19) it follows that
[TABLE]
Thus, represents the maximum value of the error at such that the actual value of the state at guarantees safety. Finally, let be given by
[TABLE]
[TABLE]
Based on the above notations, we obtain the following result:
Lemma 1**.**
Suppose that the communication scheduling , is designed such that:
- (C.1)
; 2. (C.2)
, ; 3. (C.3)
; 4. (C.4)
,
,
where are computed according to (18). Then, for any and , the state trajectory becomes valid by applying the control strategy in (12) and (13).
Proof.
Suppose that , is designed such that the conditions (C.1)–(C.4) are fulfilled. For any , let and be the (actual) state and the corresponding control trajectories according to (12) and (13). From (21), it holds that and so we have . Thus, for any we obtain
[TABLE]
where we have used the monotonicity property in (17). Since , we obtain
[TABLE]
for any . Using the same procedure, we recursively obtain , for any . From (C.2), it then holds that , , which means from (20) that
[TABLE]
. Thus, the state trajectory guarantees safety. Moreover, it follows from (C.3) and (22) that , which means that the state trajectory guarantees reachability. In addition, from (C.4) and (14), implies that
[TABLE]
and implies . Thus, it holds that , . Therefore, it is shown that the trajectory becomes valid. Since this holds for any and the proof is complete. ∎
Lemma 1 indicates that if the communication scheduling , is given such that the sequence of errors with becomes small enough to satisfy (C.2) and (C.3), as well as that the condition (C.4) holds in order to satisfy the input constraint, then every state trajectory starting from becomes valid.
Remark 1** (On the computation of ).**
Note that in order to check (C.1)–(C.3) one is required to compute , (as well as ). For the linear case, a -ISS control Lyapunov function can be chosen as the error norm (see Section II-B) and thus the set is defined as a ball with center and radius . Let be a polytope with . The set can be of any shape (e.g., square, hexagon) but is selected to include the ball . Since any polygonal set can be cell-decomposed as ( denotes the number of polytopes obtained by the decomposition), it holds that if
[TABLE]
where . Since and are both polytopes, is a polytope that can be computed by vertex operations. Thus, can be obtained (under-approximated) by searching the maximum value of with the property that the union of all , is equal to . For general nonlinear systems, however, it may be difficult to compute since the function is in general not given by the error norm. In this case, we can make use of property in (5) in the following way. For a given , let be the ball set characterized as , where the function is defined in (5). Since for any , it holds that for any . Therefore, can be under-approximated by searching the maximum value of with , which can be done by employing the same procedure as for the linear case described above.
IV-B A naive approach to generate communication scheduling
From Lemma 1, if we assign , such that the conditions (C.1)–(C.4) are satisfied, the resulting state trajectory guarantees both safety and reachability. At the same time, we can achieve the communication reduction as much as possible by finding the minimum number of communication instants (i.e., ). In what follows, we present ideas to achieve such communication scheduling. As a starting point, this subsection provides a naive approach as a motivation to derive our proposed solution in the next subsections.
Suppose that we obtain and as, respectively, the reference state and control trajectories as described in Section III-A, as well as , as described in Section IV-A (see in particular Remark 1). The most straightforward approach to obtain the desired communication scheduling , may be to consider all possible (feasible) communication schedulings satisfying all conditions (C.1)–(C.4), and then find the optimal one providing the minimum number of communication instants. The overview of this approach is illustrated in Fig. 2. As shown in the figure, the problem is translated into the construction of a binary tree with the depth . That is, starting from we first compute the next error for the two cases, according to whether the communication is given () or not given (). For each case, we check if the corresponding error value is below the safety (or reachability if ) bounds, i.e., check if and (or and if ), as well as check if it satisfies the input constraint according to (C.4). If the conditions are satisfied, we add the node and the corresponding edge to the tree. If the condition does not hold, no further nodes and edges are added. The above procedure is iterated until the terminal time step is reached. Once the tree has been constructed, we seek the optimal path from the initial node to the ones at , which provides the minimum number of communication instants.
By using the above procedure, we can find a communication scheduling such that the conditions (C.1)–(C.4) are rigorously satisfied, and thus the resulting state trajectory achieves reachability and safety. However, the main drawback of the above procedure is its computational complexity; the number of total nodes for the constructed binary tree (as well as the number of feasible paths) for the worst case is . Thus, the number of total nodes grows exponentially with respect to the total time steps, which makes the construction of a binary tree intractable.
Motivated by the above issue, in the following subsections we provide an alternative approach that makes the problem of finding the communication scheduling scale well with respect to the time step . In particular, we propose to construct a symbolic error system, which represents an abstracted behavior of the upper bound of the error propagation model in (18). The symbolic system is abstracted in the sense that it deals with only a finite number of non-negative reals that are selected from the domain of , in contrast to the original model in (18) that is defined over all non-negative reals in . The symbolic system is constructed by making use of the monotonicity property in (17), and it allows us to generate desired communication schedulings with the computational complexity being much more tractable than the naive approach.
IV-C Abstracting the behavior of the error propagation model
In this subsection we provide an approach to construct a symbolic model representing an abstracted behavior of (18). To this end, we first partition the domain of into a finite number of segments. That is, for given with and , define a set of scalars given by
[TABLE]
and . Here, represents the maximum finite value among the set of scalars , and represents the number of cells in the partition of the domain . How these parameters should be given is described later in this section. The sequence , , represents the upper bound of the errors that will be treated to generate the communication schedulings. Namely, instead of using the original model (18) that is defined over all non-negative reals in , we use here an abstracted model that consists of only a finite number of positive reals . We refer to this abstracted model as the symbolic error system, which is formally defined below:
Definition 3**.**
A symbolic error system is a tuple
[TABLE]
where
- •
is a set of symbols;
- •
is a labeling function given by , ;
- •
is a transition relation defined as follows: for given and , let be given by
[TABLE]
Then, .
The system mainly consists of a finite set of symbols and their transitions defined in . Each symbol is related to the scalar through the mapping . In other words, the symbol indicates that the upper bound of the error is . The transition relation is defined by solving (27). Here, represents the upper bound of the error at the next time from the one associated with with (or without) the occurrence of communication indicated by . Thus, the next symbol to be transitioned is determined by taking the closest upper bound to . Roughly speaking, the transition indicates that the upper bound of the error becomes smaller (or larger) by providing (or not providing) the communication. For example, with indicates that the upper bound of the error decreases from to by the occurrence of communication. On the other hand, with indicates that the upper bound of the error grows from to by not providing the communication. Note that the transition system is deterministic and non-blocking (see, e.g., [38]), which means that for every and there exists one transition from .
(Example 1): Consider the linear system , where the pair is assumed to be stabilizable. As described in Section II-B, define as the -ISS control Lyapunov function with respect to , where is given such that is Hurwitz. The corresponding upper bound of the error model is given by (18) with
[TABLE]
Suppose that we have , , and , and the parameters for the partition of the domain are , (i.e., , and ). The symbolic error system is illustrated as a graph in Fig. 3. For example, we have and so . Also, we have and so . Note that we have since . This means that the rate of decrease of the error is not large enough to transition to . Thus, the state that the upper bound of the error is (i.e., ) can never be reached in . In the original system (18), on the other hand, it holds that for all , which means that there exists some that can become smaller than at the next time. Thus, the symbolic system provides a somewhat conservative behavior in the sense that the error cannot be further reduced in comparison to the original system in (18).
Remark 2** (On the selection of ).**
When constructing , one needs to define the parameters and in order to characterize the partition of . In this remark, we provide a way to determine the parameter ; regarding , please refer to Section IV-E for details as well as the illustrative analysis in the simulation section (Section V-B). Let us recall that we compute , in (19). Here, each represents the maximum allowable error that can be taken at , which means that the error does not take values more than . Since determines the maximum finite error value associated with the symbol in , one way to select is to take the maximum value among , , i.e.,
[TABLE]
Note that since is a bounded polygonal set, , as well as are finite.
IV-D Generating the communication plan: an offline approach
Based on the symbolic system provided in the previous subsection, we now provide a framework to generate the desired communication scheduling. As described in Section II-C, we present both an offline and an online framework to generate the communication scheduling; in this subsection we derive the former approach. In order to assign a suitable communication scheduling in an offline manner, we further construct the following symbolic system:
Definition 4**.**
A timed symbolic error system is a tuple
[TABLE]
where
- •
is a set of symbols;
- •
is a transition relation, and for all if the following conditions hold:
- (D.1)
; 2. (D.2)
; 3. (D.3)
; 4. (D.4)
;
- •
is an initial state, where is given by
[TABLE]
- •
is a set of terminal states given by
[TABLE]
A timed symbolic system is provided as an extension to the original one , in the sense that the time step domain in the symbolic states as well as an initial state and a set of terminal states are additionally defined in the symbolic system. As shown in the definition, a transition is allowed from to only if the conditions (D.1)–(D.4) are satisfied. Condition (D.1) indicates that the transition from to is allowed in the original transition system . Conditions (D.2), (D.3) indicate that the upper bounds of the error associated with and are respectively below the safety bounds and that are defined in (19). Condition (D.4) is essentially required in order for the control input to satisfy the input constraint. Overall, the procedure to derive is presented in Algorithm 1. As shown in the algorithm, for each time step and for each transition in , we check if the conditions (D.2) – (D.4) are satisfied. Only if the conditions are satisfied, we add the corresponding transition in . As we will see in the next subsection, the complexity for implementing Algorithm 1 is shown to be linear with respect to , which is thus much more tractable than the construction of a binary tree for the naive approach described in Section IV-B.
We proceed to define the accepting run for by recalling the standard definitions from automata theory (see, e.g., [38]):
Definition 5**.**
For given , , the sequence is called an accepting run for , in , if , , , and . Moreover, , is called accepted by , if there exists an accepting run for , .
Based on the above definitions, we obtain the following result:
Theorem 1**.**
Suppose that the communication scheduling , is designed such that it is accepted by . Then, for any and , the resulting state trajectory is valid by applying the control strategy in (12) and (13).
Proof.
Suppose that , is accepted by , and let be the accepting run for , . Based on , and for a given , let , , be the sequence computed according to (18). In addition, let , . From (21), we obtain
[TABLE]
and thus . Since , it holds from the definition of the transition relation in Definition 3 that . Thus, we obtain
[TABLE]
where we have used the monotonicity property of the function in (17). Using the same procedure, we recursively obtain , . Moreover, from conditions (D.2), (D.3) in Definition 4 it holds that , , and thus , . Also, from and (22), it holds that
[TABLE]
Thus, we obtain . From condition (D.4), implies that
[TABLE]
for all . As a consequence, the sequence , , , fulfills conditions (C.1)–(C.4) in Lemma 1. Therefore, from Lemma 1, by implementing the control strategy in (12) and (13) according to , , the resulting state trajectory becomes valid for any and . The proof is complete. ∎
Theorem 1 states that the existence of an accepting run of implies that any state trajectory starting from achieves reachability and safety. In order to provide online execution, we generate the communication scheduling in the following way. First, we assume (i.e., communication occurs at the initial time), which is required since the plant does not know any information about the control inputs to be applied at the initial time . Second, in order to reduce the number of communication times as much as possible, we find the accepting run that leads to the smallest number of communication instants. That is, we find (with ) by solving the following problem:
[TABLE]
subject to , , and , . The above optimal run can be obtained as follows. First, for each we look for an accepting run from to by implementing standard graph search methodologies (e.g., Dijkstra algorithm [39]). Then, among all the accepting runs we further select the one with the minimum number of communication instants.
In summary, the implementation algorithm based on the offline communication scheduling obtained above is illustrated in Algorithm 2. In the algorithm, the function (line 2) is defined by
[TABLE]
i.e., the function outputs the number of zero-elements appearing at the beginning of the sequence . As shown in the algorithm, for each communication time the controller updates the current control input (line 2) by utilizing and a set of control inputs for the non-communication time steps (i.e., ). Then, the control inputs are transmitted to the plant and no communication is given until the next communication time. This procedure is iterated until the terminal step is reached. From Theorem 1, it is shown that any state trajectory starting from becomes valid by applying Algorithm 2.
IV-E Discussion on the computational complexity
Recall that in the naive approach presented in Section IV-A, the number of total nodes and edges of a binary tree for the worst case are exponential with respect to the time step . Thus, the binary tree construction can be intractable especially for a large value of . In the proposed approach, on the other hand, we aim at constructing the timed symbolic error system , in which the complexity heavily depends on the implementation of Algorithm 1 (i.e., the derivation of ). In the algorithm, it is required to check the conditions (D.2)–(D.4) for each and each transition in . Since the total number of transitions in is (since there exist two transitions from each ), the total number of iterations in Algorithm 1 is . Since the parameter is determined independently from , the construction of is linear with respect to and is thus much more tractable than the naive approach. Once is constructed, it is required to find an offline communication scheduling by finding the accepting run with the minimum number of communication instants. The complexity to find an accepting run from to each is , if we apply the Dijkstra algorithm [39]. Thus, the complexity of finding the optimal communication scheduling is , where denotes the total number of symbols in .
Note that the total number of iterations in Algorithm 1 as well as complexity to find the communication scheduling also depend on the tuning parameter , which represents the number of partitions of the domain . Here, if is selected smaller, we can reduce the complexity to obtain both and the offline communication scheduling. However, if is selected smaller and the partition of becomes sparser, the corresponding transition system may not approximate precisely enough the error propagation model in (18). More specifically, it is possible that the symbol can transition to another one associated with a much larger value than the original behavior in (18) (i.e., for some , we may have ). Due to such mismatch, the offline communication scheduling tends to be more conservative as is chosen smaller, i.e., the communication frequency tends to be higher as the partition becomes sparser. Therefore, the parameter should be carefully chosen by taking into account the trade-off between the computational complexity and the conservativeness of the communication scheduling.
IV-F Generating communication plan: an online approach
In the previous subsection we provided an offline framework to generate the communication strategy. This approach is beneficial in terms of the computational load, since communication scheduling does not need to be generated during the online implementation. However, the drawback of this approach may be that the communication scheduling is conservative; the generated scheduling may require a higher number of communications than the one that is actually (minimally) required to guarantee reachability and safety. This conservativeness is due to the fact that the error between the actual state and the reference during the online implementation may be much smaller than the one assumed by the optimal run generated offline. For example, suppose that the accepting run includes the symbol for some . This implies, from the proof of Theorem 1, that the error between the actual state and the reference is below , i.e., . However, since the accepting run is obtained offline, can be much smaller than the upper bound . This means that there may exist another such that , i.e., there can exist a symbol that provides a more rigorous upper bound for . In this case, there may exist another run from providing a smaller number of communication instants than the one from .
Motivated by the above, this subsection provides an online communication scheduling algorithm that has the potential to provide a less conservative result than the offline communication case. The proposed strategy is illustrated in Algorithm 3. In the algorithm, the function (line 3) is defined by
[TABLE]
That is, the function outputs the symbol associated with the closest upper bound to . Moreover, the function outputs the optimal communication scheduling by finding an appropriate sequence from to the symbol in with the minimum number of communication instants, i.e.,
[TABLE]
subject to , , with and .
As shown in the algorithm, for each communication time the controller identifies the current symbol associated with the closest upper bound to , aiming at reducing the conservativeness with respect to the offline approach. Then, based on the current symbol it updates the optimal communication scheduling by finding the smallest number of communication instants (line 3). Then, the controller computes a current control input (line 3) as well as a set of control inputs for the non-communication time steps (line 3) and transmits them to the plant. Note that as shown in the algorithm, the communication is given in a self-triggered manner [3], in which for each communication time the controller determines the next communication time (if it exists) based on the state information .
In addition to the communication reduction, another advantage of employing the online approach (rather than the offline approach) is that it can potentially handle larger size of disturbances. This is due to the fact that Algorithm 3 looks for an accepting run at for a given initial state , while the offline approach looks for an accepting run, before implementing Algorithm 2, such that every initial state should lead to a valid trajectory. Mathematically, we have with , meaning that the initial error is over-estimated when the offline approach is employed. Thus, an accepting run from is more likely to be found instead of under the same values of , or, in other words, a larger size of disturbance is allowed by applying the online approach. The above observation will be also illustrated in the simulation section: see Section V for the linear case.
With a slight abuse of Definition 5, we define the accepting run as follows. For given , , and , , the sequence is called an accepting run for , , if , , , and . Moreover, , is called accepted by , if there exists an accepting run for , . For the online communication approach, we obtain the following result:
Theorem 2**.**
For a given , suppose that Algorithm 3 is implemented. Moreover, suppose that at the initial time there exists , with , such that it is accepted by . Then, for any , the following holds:
- (E.1)
(Feasibility): for any with , there exists , , such that it is accepted by . 2. (E.2)
(Validity): the resulting state trajectory is valid.
The first result (E.1) means that the existence of an accepting run at implies the existence of an accepting run for all the communication time steps afterwards. This property is important, since if no accepting runs were present for some , the controller would not find a suitable communication scheduling according to (35). The second result (E.2) shows the validity of the state trajectory by applying Algorithm 3.
Proof.
Here we provide a proof only for (E.1). The proof for (E.2) is similar to the one of Theorem 1 and is provided in Appendix. The proof for (E.1) is given by induction. From the assumption, at there exists a communication scheduling such that it is accepted by . Thus, the controller can find the optimal communication scheduling according to (35). Let , with be the optimal communication scheduling obtained at and
[TABLE]
be the corresponding (accepting) run for , with . Note that since (38) is accepting, we have . Since is given by solving (36), it holds that . Thus, we obtain
[TABLE]
where and the last inequality follows from the fact that and is given according to Definition 3. Thus, we obtain . By using the same procedure, we recursively obtain
[TABLE]
where denotes the next communication time from the initial time (i.e., , ). Now, consider the next communication time , and let . In what follows, we show that there exists a communication scheduling for , such that it is accepted by . Let , be the communication scheduling given by
[TABLE]
Here, , represents a candidate communication scheduling for , such that it is accepted by , or in other words, there exists an accepting run for , . Let , be such that , with . Note that since is deterministic and nonblocking (see Section IV-C), the sequence , is uniquely determined by , . We now show that is an accepting run for , . Let us first show (with ). Condition (D.1) in Definition 4 trivially holds since . Moreover, since and (see (39)), we obtain
[TABLE]
Since , we obtain and thus condition (D.2) in Definition 4 holds. Moreover, due to the monotonicity property of and , we obtain
[TABLE]
Since , it follows from (27) in Definition 3 that , so that we have . Thus, we obtain
[TABLE]
where the last inequality follows from the fact that . Thus, condition (D.3) holds. Finally, noting that and
[TABLE]
it is shown that condition (D.4) in Definition 4 holds. Therefore, we have . By using the same procedure as above, we recursively obtain
[TABLE]
for all , and it is shown that , . Since and , we then obtain . Thus, it holds that . Therefore, it is shown that is an accepting run for , .
Since there exists an accepting run for , the controller can find the optimal communication scheduling at according to (35). Let , be the optimal communication scheduling obtained at , and let be the next communication time from (i.e., and ). Let and
[TABLE]
be a candidate communication scheduling for . With a slight abuse of notation, let , be such that , with . By using exactly the same procedure as for the case described above, it follows that
[TABLE]
is an accepting run for , with . Since there exists an accepting run at , the controller can find the optimal communication scheduling according to (35). Then, it is again shown that there exists an accepting run at the next communication time . Therefore, it is inductively shown that for any communication time step , there exists a communication scheduling such that it is accepted by . The proof of (E.1) is complete. ∎
V Illustrative examples
In this section we provide two illustrative examples to validate our control schemes. All simulations were conducted by Matlab 2016a on a Windows 10, Intel(R) Core(TM), 2.40GHz, 8GB RAM computer.
V-A Linear case
One of the well-known examples of Problem 1 is a motion planning problem of a vehicle, in which we aim to steer a vehicle to a desired goal set in finite time while avoiding obstacles. Let and be the position and velocity of the vehicle, respectively. Defining the state as , the dynamics is assumed to be given by
[TABLE]
where , is the control input and is the disturbance. We discretize (48) under a sample-and-hold controller with sampling time interval to obtain the corresponding discrete-time system: . The input and the disturbance sets are assumed to be given by , , and the position of the vehicle is constrained by the set , where the set is illustrated in Fig. 4(a). In the figure, the white regions represent the free-space in which the vehicle can move freely, and the black regions represent obstacles to be avoided. Assuming that the velocity is constrained by the set , the state-space is given by . The initial set is given by , where and . The target set is given by , where and . The sets and are also illustrated in Fig. 4(a).
To generate reference state and control trajectories in an offline manner according to Section III-A, we have implemented a standard RRT algorithm[30]. While implementing the algorithm, we generate a collision-free trajectory with a safety margin , i.e., all states are at least away from the obstacles (i.e., boundaries of ), see e.g., [40]. Such safety margin is imposed here to obtain large values of , so as to increase the possibility of finding an accepting run of . The algorithm is successfully terminated and finds the reference state and control trajectories , with . Based on the trajectories, we compute , . Although the naive approach described in Section IV-B was implemented, the algorithm did not terminate due to a lack of memory; indeed, the total number of nodes to construct a binary tree for the worst case is , which is clearly intractable for the algorithm to be terminated. Thus, it is worth applying our proposed approach to alleviate the computational burden.
Since it follows that for all , we set (see Remark 2). In this subsection, we fix the parameter as , although we will consider different values in the next subsection (nonlinear case). Following Section IV-C, we choose as the -ISS control Lyapunov function with the control law given by , where is designed so that . Based on this, we have constructed as well as by implementing Algorithm 1. The algorithm took only less than 2 seconds, which is thus shown to be much tractable than the naive approach.
Fig. 4(b) illustrates a sample state trajectory of by applying the offline communication approach (Algorithm 2), where . In the figure, each red star mark represents a state when communication is given (i.e., , with ). It is shown from the figure that the trajectory enters the target region while avoiding all obstacles. Moreover, the number of communication instants required to achieve reachability is given by out of the total time steps , which is thus shown to achieve the communication reduction. It can be seen from the figure that the transmission frequency tends to be high when the state is close to the obstables, especially when moving in a narrowed space. Intuitively, this is because the safety margins , tend to be small especially when the reference trajectory is close to the obstacles, and so the communication is more likely to be given such that the actual state can track to the reference to guarantee safety. Fig. 5 illustrates the corresponding control inputs applied to the plant. It is shown from the result that the control inputs satisfy the constraints, i.e., , .
To validate Theorem 1, Algorithm 2 has been implemented 100 times with the initial state randomly chosen from . Fig. 4(c) illustrates the resulting state trajectories of . From the figure, all trajectories are indeed shown to achieve reachability while avoiding obstacles, regardless of disturbance influence and initial states.
Fig. 4(d) illustrates a sample state trajectory of by applying the online communication approach (Algorithm 3). Moreover, Table I illustrates the number of communication instants by applying Algorithm 2 and Algorithm 3, as well as the average computation time required for each communication time instant during the online execution (i.e., the average computation time to execute from line 2 to line 2 for Algorithm 2 and from line 3 to line 3 for Algorithm 3). From Fig. 4(d) and the table, the online approach is shown to achieve a smaller number of communication instants than the offline approach. On the other hand, it is shown that the computation time for the online approach is longer than the offline approach. This is due to the fact that the online approach is required to update the communication scheduling for each communication time step.
To analyze how much the disturbance size can be tolerated for both the online and offline approaches, we further computed the maximum allowable , such that the offline communication scheduling (an accepting run from ) is found, as well as that the online communication scheduling at (an accepting run from with ) is found. The results are given by for the offline approach, and for the online approach. Thus, the results show that a larger size of disturbance is allowed by applying the online approach. As described in Section IV-F, this is due to the fact that the initial state error is over-estimated when the offline approach is employed (i.e., ).
V-B Nonlinear case
As an example of a nonlinear system, we consider a control problem of an inverted pendulum, whose continuous-time model is discretized with the sampling time interval :
[TABLE]
where and are the states representing the angular position and the velocity of the mass, is the control input, is the additive disturbance, and are the parameters characterized by the physical quantities such as the gravity constant. Assume that , and the control and the disturbance sets are given by , . Regarding the state constraint, we consider the following two sets:
[TABLE]
and . The set is given so as to steer the pendulum with sufficiently large position and velocity, see e.g., [20] for a similar constraint. The set is illustrated as the white regions in Fig. 6(a).
Let us obtain the upper bound of the error model in (18) in order to implement the proposed strategies. For and , it follows that
[TABLE]
where , , and . Since we have
[TABLE]
the system is Lipschitz continuous satisfying the property in (4) with and (see, e.g., [25] for a related analysis for the continuous case). Moreover, let be given by , where and with . Then, it can verified that
[TABLE]
where and . Therefore, it is shown that the function is -ISS control Lyapunov function with respect to , and we can obtain the corresponding error model in (18).
Let and . We assume . Instead of achieving stabilization of the origin, we aim here at designing control and communication strategies such that the state can periodically traverse between and . To this aim, we construct for both , and , , and switch the designed strategies between the two sets during the online implementation. That is, starting from we first implement control and communication strategies by setting , . Then, once the state enters we set , and implement the corresponding strategies. This procedure is iterated for all times so that the state trajectory traverses between and .
As with the linear case, we implement the RRT algorithm to generate the reference trajectories for both , and , . For both cases, we set , and and construct by implementing Algorithm 1. Fig. 6(b) illustrates the resulting state trajectories by implementing the offline communication strategy (Algorithm 2). The figure shows that the state trajectory actually traverses between and while remaining inside . Moreover, the number of communication instants for the time interval is , which is thus shown to achieve the communication reduction. Fig. 7 illustrates the corresponding control inputs applied to the plant. From the result, it is shown that the control inputs satisfy the constraints, i.e., , .
In Section IV-E, we have discussed the trade-off between the computation time to obtain and the number of communication instants according to the selection of . To analyze such trade-off, we construct for both , and , with different selection of the parameter as , and generate the corresponding offline communication schdulings. For each selection of , we measure the total computation time to terminate Algorithm 1. Then, we implement the control and communication strategies such that the state trajectory traverses between and according to the procedure described above, and count the number of communication instants during the time interval . The results are shown in Table II. The table illustrates that the number of communication instants increases as is selected smaller, and the feasible communication scheduling was not found when (with the symbol “—”); as described in Section IV-E, this is because the mismatch between the symbolic model and the original error model in (18) becomes larger as the partition of the domain becomes sparser. On the other hand, the computation time to generate the communication scheduling decreases as is selected smaller, which is due to a decrease of the number of iterations in Algorithm 1. Therefore, it is shown that there exists a trade-off between the computation time to generate the communication scheduling and the communication load, and the trade-off can be regulated by the tuning parameter .
VI Conclusion and Future work
In this paper, we propose control and communication strategies for reachability and safety specifications in a networked control system. The key idea of the proposed approach is to utilize the notion of -ISS control Lyapunov function, which captures contractive behaviors between any pair of the state trajectories under a certain state feedback control law. The function is given to introduce the error propagation model, which represents how the upper bound of the error between the actual and the reference trajectories behaves according to the occurrence or non-occurrence of communication. Based on the error propagation model, we derive a sufficient condition for the communication scheduling to guarantee reachability and safety. Moreover, in order to reduce computational complexity, we introduce the notion of symbolic error system, which represents an abstracted behavior of the error propagation model. The communication scheduling is then given by implementing standard graph search methodologies, and is provided in both offline and online fashion. Finally, we illustrate the benefits of the proposed approach through numerical simulations for both linear and nonlinear cases.
It should be noted that, incremental stability analysis has been provided recently for complex dynamical systems that have not been considered in this paper, including hybrid systems[41], switched systems[29], and mechanical systems[42]. Thus, future work will involve investigating the applicability of the proposed approach to those types of systems. Moreover, our future work involves investigating the applicability of the proposed approach to mobile communication networks, where the network consists of multiple nodes communicating with each other under the randomness of connectivity. The problem may be treated by incorporating the idea of energy-aware packet forwarding protocols, such as those presented in [43, 44]. Finally, extending the proposed approach to more complex specifications, such as those expressed by Linear Temporal Logic (LTL) formulas, will be taken into account in future investigations.
(Proof for (E.2) in Theorem 2): The proof for (E.2) is also given by induction. Let us go back again to the initial time , and let , with be the optimal communication scheduling obtained at . In addition, let (38) denote the accepting run for , and be the next communication time from the initial time . As described in the proof of (E.1), we obtain , . Moreover, since , , it follows from (D.2) and (D.3) in Definition 4 that
[TABLE]
which implies from (20) that , . Thus, the state trajectory guarantees safety for all the time until the next communication time . Moreover, from (D.4) in Definition 4, it follows that , and the constraint for the control inputs are satisfied.
Consider now the next communication time , and let , be the optimal communication scheduling obtained at according to (35). Note that the optimal communication scheduling can be found due to the feasibility property described in (E.1). With a slight abuse of notation, let
[TABLE]
with be the accepting run for , . Moreover, let be the next communication time from . Again, it follows from (D.2) and (D.3) in Definition 4 that
[TABLE]
From this and (D.4) in Definition 4, we obtain , , and the safety is guaranteed until the next communication time . By following the same procedure as illustrated above, we obtain , and , .
Let be the last communication time step, where represents the total number of communication instants. Let , be the optimal communication scheduling obtained at , and
[TABLE]
with be the accepting run for , . Since is the last communication time step, we either have (i) (), or (ii) . For case (i), it follows that , since . Thus, we obtain . For case (ii), it follows that
[TABLE]
and . Thus, , and . Therefore, the state trajectory achieves reachability and safety for both case (i) and (ii). Moreover, it follows from (D.4) in Definition 4 that , for both case (i) and (ii). Based on the above, it is shown that the state trajectory becomes valid. The proof is complete.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] R. A. Gupta and M.-Y. Chow, “Networked Control System: Overview and Research Trends,” IEEE Transactions on Industrial Electronics , vol. 57, no. 7, pp. 2527–2535, 2010.
- 2[2] W. Zhang, M. S. Branicky, and S. M. Phillips, “Stability of networked control systems,” IEEE Control Systems , vol. 21, no. 1, pp. 84–99, 2001.
- 3[3] W. P. M. H. Heemels, K. H. Johansson, and P. Tabuada, “An introduction to event-triggered and self-triggered control,” in Proceedings of the 51st IEEE Conference on Decision and Control (IEEE CDC) , 2012, pp. 3270–3285.
- 4[4] P. Tabuada, “Event-triggered real-time scheduling of stabilizing control tasks,” IEEE Transactions on Automatic Control , vol. 52, pp. 1680–1685, 2007.
- 5[5] M. C. F. Donkers and W. P. M. H. Heemels, “Output-based event-triggered control with guaranteed ℒ ∞ subscript ℒ {\mathcal{L}}_{\infty} gain and decentralized event-triggering,” IEEE Transactions on Automatic Control , vol. 57, no. 6, pp. 1362–1376, 2011.
- 6[6] V. S. Dolk, D. P. Borgers, and W. P. M. H. Heemels, “Output-based and decentralized dynamic event-triggered control with guaranteed ℒ p subscript ℒ 𝑝 {\mathcal{L}}_{p} -gain performance and zeno-freeness,” IEEE Transactions on Automatic Control , vol. 62, no. 1, pp. 34–49, 2016.
- 7[7] K. Hashimoto, S. Adachi, and D. V. Dimarogonas, “Aperiodic sampled-data control via explicit transmission mapping: a set-invariance approach,” IEEE Transactions on Automatic Control , vol. 63, no. 10, pp. 3523–3530, 2018.
- 8[8] M. Kishida, “Event-triggered control with self-triggered sampling for discrete-time uncertain systems,” IEEE Transactions on Automatic Control , 2018 (to appear).
