Coordination of multi-agent systems via asynchronous cloud communication

TL;DR

This paper introduces a self-triggered multi-agent coordination algorithm that minimizes cloud communication by using promises about future control inputs, ensuring asymptotic convergence without continuous listening.

Contribution

It presents a novel self-triggered control method for multi-agent systems that reduces communication by leveraging promises, without requiring agents to listen continuously.

Findings

The algorithm guarantees asymptotic convergence to desired states.

Agents can communicate less frequently while maintaining coordination.

Simulations validate the effectiveness of the proposed approach.

Abstract

In this work we study a multi-agent coordination problem in which agents are only able to communicate with each other intermittently through a cloud server. To reduce the amount of required communication, we develop a self-triggered algorithm that allows agents to communicate with the cloud only when necessary rather than at some fixed period. Unlike the vast majority of similar works that propose distributed event- and/or self-triggered control laws, this work doesn't assume agents can be "listening" continuously. In other words, when an event is triggered by one agent, neighboring agents will not be aware of this until the next time they establish communication with the cloud themselves. Using a notion of "promises" about future control inputs, agents are able to keep track of higher quality estimates about their neighbors allowing them to stay disconnected from the cloud for longer periods of time while still guaranteeing a positive contribution to the global task. We prove that our self-triggered coordination algorithm guarantees that the system asymptotically reaches the set of desired states. Simulations illustrate our results.

Tables

Table 1. Table 1: Data stored on the cloud for all agents  i 𝑖 i at any time  t 𝑡 t .

$t_i^{\text{last}}$	Last time agent $i$ surfaced
$t_i^{\text{expire}}$	Control expiration time of agent $i$
$t_i^{\text{next}}$	Next time agent $i$ will surface
$x_i\left(t_i^{\text{last}}\right)$	Last updated position of agent $i$
$u_i\left(t_i^{\text{last}}\right)$	Last trajectory of agent $i$
$M_i\left(t_i^{\text{last}}\right)$	Most recent control promise from agent $i$

Equations

$${\dot{x}}_i(t)=u_i(t),$$

$$u_i(t)$$

$$\dot{x}=-Lx,$$

$$u_i^{\star }(t)=-\sum _{j\in {\mathcal{N}}_i}(x_i(t_i^{\ell })-x_j(t_i^{\ell })),t\in [t_i^{\ell },t_i^{\ell +1}).$$

$$|x_j(t)-x_i(t)|\to 0$$

$$V(x(t))$$

$$\dot{V}$$

$${\dot{V}}_i\triangleq -{\dot{x}}_i\sum _{j\in {\mathcal{N}}_i}(x_j-x_i).$$

$$V(x(t))$$

$$x_j(t)=x_j(t_j^{\text{last}})+u_j(t_j^{\text{last}})(t-t_j^{\text{last}}).$$

$$\displaystyle R^{i}_{j}(t)=\left\{\begin{array}[]{cc}\{x_{j}(t^{\textrm{last}}_{j})+u_{j}(t^{\textrm{last}}_{j})(t-t^{\textrm{last}}_{j})\}&t\leq t^{\textrm{next}}_{j},\\ B(x_{j}(t^{\textrm{next}}_{j}),M_{j}(t)(t-t^{\textrm{next}}_{j}))&\textrm{otherwise,}\end{array}\right.$$

$$R_i^i(t)=\{x_i(t_i^{\text{last}})+u_i(t_i^{\text{last}})(t-t_i^{\text{last}})\}.$$

$$\underset{t\ge t_i^{\ell }}{\mathrm{infimum}}$$

$$\underset{x(t)\in R^i(t)}{\max }{\dot{V}}_i(x(t))>0,$$

$$\underset{t}{\mathrm{infimum}}$$

$$t_{\pi (k)}^{\text{next}}\le t\le t_{\pi (k+1)}^{\text{next}},$$

$$\sum _{m^{\prime }=1}^k{\alpha }_{i\pi (m^{\prime })}(t_{\pi (m^{\prime })}^{\text{next}})+\sum _{m=k+1}^{|{\mathcal{N}}_i|}{\alpha }_{i\pi (m)}(t_i^{\text{last}})$$

$$+\sum _{m^{\prime }=1}^k(t-t_{\pi (m)}^{\text{next}}){\gamma }_{i\pi (m^{\prime })}(t_i^{\text{last}})$$

$$+\sum _{m=k+1}^{|{\mathcal{N}}_i|}(t-t_{\pi (m)}^{\text{next}}){\beta }_{i\pi (m)}(t_i^{\text{last}})>0,$$

$${\alpha }_{ij}(t)\triangleq -u_i(t)(x_j(t)-x_i(t)),$$

$${\beta }_{ij}(t)\triangleq -u_i(t)(u_j(t)-u_i(t)),$$

$${\gamma }_{ij}(t)\triangleq |u_i(t)|M_j(t)+u_i(t{)}^2.$$

$$T_i^{\star }=\min \{{\tau }_i^{\star ,(k)}|k\in \{0,\dots ,|{\mathcal{N}}_i|\}\}.$$

$$\Delta V_i^{\ell }\triangleq {\int }_{t_i^{\ell }}^{t_i^{\ell +1}}{\dot{V}}_i(\tau )d\tau ,$$

$$\underset{t\ge t_i^{\ell }}{\mathrm{infimum}}$$

$$\underset{x(t)\in R^i(t)}{\max }{\int }_{t_i^{\text{last}}}^t{\dot{V}}_i(\tau )d\tau >0,$$

$$\underset{t}{\mathrm{infimum}}$$

$$t_{\pi (k)}^{\text{next}}\le t\le t_{\pi (k+1)}^{\text{next}},$$

$$\displaystyle\sum_{m^{\prime}=1}^{k}\Big{[}\alpha_{i\pi(m^{\prime})}(t^{\textrm{last}}_{i})(t^{\textrm{next}}_{\pi(m^{\prime})}-t^{\textrm{last}}_{i})+\frac{1}{2}\beta_{i{\pi(m^{\prime})}}(t^{\textrm{last}}_{i})(t^{\textrm{next}}_{\pi(m^{\prime})}-t^{\textrm{last}}_{i})^{2}$$

$$\displaystyle\ +\alpha_{i{\pi(m^{\prime})}}(t^{\textrm{next}}_{\pi(m^{\prime})})(t-t^{\textrm{next}}_{\pi(m^{\prime})})+\frac{1}{2}\gamma_{i{\pi(m^{\prime})}}(t^{\textrm{last}}_{i})(t-t^{\textrm{next}}_{\pi(m^{\prime})})^{2}\Big{]}$$

$$\displaystyle+\sum_{m=k+1}^{|{\mathcal{N}}_{i}|}\Big{[}\alpha_{i{\pi(m)}}(t^{\textrm{last}}_{i})(t-t^{\textrm{last}}_{i})+\frac{1}{2}\beta_{i{\pi(m)}}(t^{\textrm{last}}_{i})(t-t^{\textrm{last}}_{i})^{2}\Big{]}>0.$$

$$T_i^{\text{total}}=\min \{{\tau }_i^{tot,(k)}|k\in \{0,\dots ,|{\mathcal{N}}_i|\}\}$$

$$\underset{t}{\mathrm{infimum}}$$

$$g(t)>0,$$

$$t_1\le t\le t_2,$$

$$t_i^{\ell +1}=(1-{\sigma }_i)T_i^{\star }+{\sigma }_i{T}_i^{\text{total}}.$$

$$M_i^{\ell }$$

Full text

1 Introduction

This paper considers a multi-agent coordination problem where agents can only communicate with one another indirectly through the use of a central base station or “cloud.” Small connected household devices that require communication and coordination with each other are become increasingly prevalent (the “Internet of Things”). To reduce both power consumption and bandwidth requirements for these small, low-power devices, it is ideal that they communicate as infrequently as possible with the cloud server. For instance, one can imagine a number of devices trying to coordinate through asynchronous communication with a dedicated cloud (e.g., email) server. In this setting, a device can only receive and send messages while connected to the server; however, being connected to the server at all times is a waste of energy and wireless resources. In this paper we present a method to facilitate the coordination of a number of agents through a cloud server that guarantees the completion of a global task while reducing the number of communications required and without the need for a device to continuously be in communication with the cloud server.

Specifically, we consider the more concrete related problem of coordinating a number of submarines that only can communicate with a base station while at the surface of the water. While a majority of related works allow for an agent to push information to its neighbors at any desired time, communicating with the outside world when underwater is extremely expensive, if not impossible [1, 2], and so a submarine must perform all communication while surfaced.

Each time a submarine surfaces, it must determine the next time to surface as well as the control law to use while underwater in order to adequately achieve some desired global task based only on information available on the server at that moment. In this paper we are interested in designing a self-triggered coordination algorithm in which agents can autonomously schedule the next time to communicate with the cloud based on currently available information. While we motivate our problem via an underwater coordination problem in which communication while submerged is impossible, it is directly applicable to any scenario where wireless-capable agents cannot be listening to communication channels continuously.

Literature review: In the context of the multi-agent coordination problem in general, the literature is extensive [3, 4, 5]. In our specific problem of multi-agent consensus, Olfati-Saber and Murray [6] introduce a continuous-time law that guarantees consensus convergence on undirected as well as weight-balanced digraphs. However, the majority of these works assume agents can continuously, or at least periodically, obtain information about their neighbors. Instead, when communication is expensive as in our case, we wish to minimize the number of times communication is necessary.

A useful tool for determining discrete communication times in this manner is event-triggered control, where an algorithm is designed to tune controller executions to the state evolution of a given system, see e.g., [7, 8]. In particular, event-triggered control has been successfully applied to multi-agent systems with the goal of limiting computation and decision making to reduce overall communication, sensing, and/or actuation effort of the agents. In [9], the authors formulate a threshold on system error to determine when control signals need to be updated. In [10], the authors expand on this and determine a distributed threshold for a wireless control network, further taking into account network errors such as communication delays and packet drops. Event-triggered ideas have also been applied to the acquisition of information rather than control. Several approaches [11, 12, 13] utilize periodically sampled data to reevaluate the controller trigger. Zhong and Cassandras [14] additionally drop the need for periodic sampling, creating a distributed trigger to decide when to share data based only on local information.

Event-triggered approaches generally require the persistent monitoring of some triggering function as new information is being obtained. Unfortunately, this is not directly applicable to our setup because the submarines only get new information when they are at the surface of the water. Instead, self-triggered control [15, 16, 17] removes the need to continuously monitor the triggering function, instead requiring each agent to compute its next trigger time based solely on the information available at the previously triggered sample time.

The first to apply these ideas to consensus, Dimarogonas et al. [18], remove the need for continuous control by introducing an event-triggered rule to determine when an agent should update its control signal, however still requiring continuous information about their neighbors. In [19], the authors further remove the need for continuous neighbor state information, creating a time-dependent triggering function to determine when to broadcast information. The authors in [20] similarly broadcast based on a state-dependent triggering function. Recently, these ideas have been extended from undirected graphs to arbitrary directed ones [13, 21, 22].

A major drawback of all aforementioned works is that they require all agents to be “listening,” or available to receive information, at all times. Specifically, when any agent decides to broadcast information to its neighbors, it is assumed that all neighboring agents in the communication graph are able to instantaneously receive that information. Instead, we are interested in a situation where when an agent is disconnected from the cloud, it is incapable of communicating with other agents.

In [23], the authors study a very similar problem to the one we consider here but develop an event-triggered solution in which all Autonomous Underwater Vehicles (AUVs) must surface together at the same time. Instead, we are interested in a strategy in which AUVs can autonomously surface asynchronously while still guaranteeing a desired stability property. This problem has very recently been looked at in [24, 25, 26] where the authors utilize event- and self-triggered coordination strategies to determine when the AUVs should resurface. In [24], a time-dependent triggering rule $\beta(\sigma_{0},\sigma_{1},\lambda_{0},t)$ is developed that ensures practical convergence (in the presence of noise) of the whole system to the desired configuration. In [26] the authors present a similarly time-dependent triggering rule that allows agents to track a reference trajectory in the presence of noise. Instead, the authors in [25] develop a state-dependent triggering rule with no explicit dependence on time; however, the self-triggered algorithm developed there is not guaranteed to avoid Zeno behaviors which makes it an incomplete solution to the problem. In this work we incorporate ideas of promises from team-triggered control [27, 28] to develop a state-dependent triggering rule that guarantees asymptotic convergence to consensus while ensuring that Zeno behavior is avoided.

Statement of contributions: Our main contribution is the development of a novel distributed team-triggered algorithm that combines ideas from self-triggered control with a notion of “promises.” These promises allow agents to make better decisions since they have higher quality information about their neighbors in general. Our algorithm incorporates these promises into the state-dependent trigger to determine when they should communicate with the cloud. In contrast to [24, 25], our algorithm uses a state-dependent triggering rule with no explicit dependence on time, no global parameters, and no possibility of Zeno behavior. The main drawback of the time-dependent triggering rule $\beta(\sigma_{0},\sigma_{1},\lambda_{0},t)$ is that the choice of the constants $\sigma_{0},\sigma_{1},\lambda_{0}$ greatly affect the performance (number of events and convergence speed) of the system and there is no good way to choose these a priori; i.e., depending on the initial condition, different values of $\sigma_{0},\sigma_{1},\lambda_{0}$ will perform better. Instead, the state-dependent triggering rule developed here is more naturally coupled with the current state of the system. In general, distributed event- and self-triggered algorithms are designed so that agents are never contributing negatively to the global task, generally defined by the evolution of a Lyapunov function $V$. Instead, our algorithm does not rely on this guarantee. More specifically, we actually allow an agent to be contributing negatively to the global task temporarily as long as it is accounted for by its net contribution over time. Our algorithm guarantees the system converges asymptotically to consensus while ensuring that Zeno executions cannot occur. Finally, we illustrate our results through simulations.

2 Problem Statement

We consider system of $N$ submarine agents with single-integrator dynamics

[TABLE]

for all $i\in\{1,\dots,N\}$, where we are interested in reaching a consensus configuration, i.e. where $\|x_{i}(t)-x_{j}(t)\|\rightarrow 0$ as $t\rightarrow\infty$ for all $i,j\in\{1,\dots,N\}$. For simplicity, we consider scalar states $x_{i}\in\mathbb{R}$, but these ideas are extendable to arbitrary dimensions.

Given a connected communication graph $\mathcal{G}$, it is well known [6] that the distributed continuous control law

[TABLE]

drives each agent of the system to asymptotically converge to the average of the agents’ initial conditions. In compact form, this can be expressed by

[TABLE]

where $x=[x_{1}\ \dots\ x_{N}]^{T}$ is the vector of all agent states and $L$ is the Laplacian of ${\mathcal{G}}$. However, in order to be implemented, this control law requires each agent to continuously have information about its neighbors and continuously update its control law.

Several recent works have been aimed at relaxing these requirements [13, 21, 22, 19]. However, they all require agents to be “listening” continuously to their neighbors, i.e. when an event is triggered by one agent, its neighbors are immediately aware and can take action accordingly.

Unfortunately, as we assume here that agents are unable to perform any communication while submerged, we cannot continuously detect neighboring events that occur. Instead, we assume that agents are only able to update their control signals when their own events are triggered (i.e., when they are surfaced). Let $\{t_{i}^{\ell}\}_{\ell\in\mathbb{Z}_{\geq 0}}$ be the sequence of times at which agent $i$ surfaces. Then, our algorithm is based on a piecewise constant implementation of the controller (2) given by

[TABLE]

Remark 2.1**.**

Later we will allow the control input $u_{i}(t)$ to change in a limited way while agent $i$ is submerged, but for now we assume that the control is piecewise constant on the intervals $[t^{\ell}_{i},t^{\ell+1}_{i})$. Motivation for and details behind changing the control while submerged are discussed later in section 3.3. $\bullet$**

The purpose of this paper is to develop a self-triggered algorithm that determines how the the sequence of times $\{t_{i}^{\ell}\}$ and control inputs $u_{i}(t)$ can be chosen such that the system converges to the desired consensus statement. More specifically, each agent $i$ at each surfacing time $t_{i}^{\ell}$ must determine the next surfacing time $t_{i}^{\ell+1}$ and control $u_{i}(t)$ only using information available on the cloud at that instant. The closed loop system should then have trajectories such that $|x_{i}(t)-x_{j}(t)|\rightarrow 0$ as $t\rightarrow\infty$ for all $i,j\in\{1,\dots,N\}$. We describe the cloud communication model next.

2.1 Cloud communication model

We assume that there exists a base station or “cloud” that agents are able to upload data to and download data from when they are surfaced. This cloud can store any finite amount of data, but can perform no computation. At any given time $t\in[t_{i}^{\ell},t_{i}^{\ell+1})$, the cloud stores the following information about agent $i$: the last time $t^{\textrm{last}}_{i}(t)=t^{\ell}_{i}$ that agent $i$ surfaced, the next time $t^{\textrm{next}}_{i}(t)=t_{i}^{\ell+1}$ that agent $i$ is scheduled to surface, the state $x_{i}(t^{\textrm{last}}_{i})$ of agent $i$ when it last surfaced, and the last control signal $u_{i}(t^{\textrm{last}}_{i})$ used by agent $i$. The server also contains a control expiration time $t^{\textrm{expire}}_{i}\leq t^{\textrm{next}}_{i}$ and a promise $M_{i}$ for each agent $i$ which will be explained later in Section 3. This information is summarized in Table 1.

For simplicity, we assume that agents can download/upload information to/from the cloud instantaneously. Let $t^{\ell}_{i}$ be a time at which agent $i$ surfaces to communicate with the cloud. The communication link is established at time $t^{\ell}_{i}$, and we immediately update $t^{\textrm{last}}_{i}=t^{\ell}_{i}$ and $x_{i}(t_{i}^{\ell})$ based on agent $i$’s current position.

While the link is open, agent $i$ downloads all the information in Table 1 for each neighbor $j\in\mathcal{N}_{i}$. Using this information, agent $i$ (instantaneously) computes its control signal $u_{i}(t^{\ell}_{i})$ and next surfacing time $t^{\ell+1}_{i}$ such that it knows it will make a net positive contribution to the consensus over the interval $[t^{\ell}_{i},t^{\ell+1}_{i})$. Finally, before closing the communication link and diving, agent $i$ calculates a promise $M_{i}$ bounding its future control inputs and uploads all data to the server.

Remark 2.2**.**

Because of the existence of a centralized cloud server, it may be tempting to ask why the communication graph $\mathcal{G}$ is not always the complete graph $K_{N}$. Note that the amount of computation an agent does under our algorithm is quadratic in the number of neighbors $|{\mathcal{N}}_{i}|$ (see Remark 3.2). To ensure scalability for agents with limited computational capabilites as the number of agents in the network grows extremely large, then, it may be necessary to force a more limited communication topology. Furthermore, especially with the increasing popularity of software defined networking, it is true that while any agent $i$ may be able to communicate with any other agent $j$, it should be avoided whenever possible. $\bullet$**

Problem 1**.**

Given $N$ agents with dynamics (1) and the communication model described in Section 2.1, for each agent $i$, find an algorithm that prescribes when to communicate with the cloud based on currently available information and a control input $u_{i}(t)$ used in between communications $t\in[t_{i}^{\ell},t_{i}^{\ell+1})$, such that

[TABLE]

as $t\rightarrow\infty$ for all agents $i,j\in\{1,\dots,N\}$.

In the next section we describe this algorithm in detail.

3 Distributed Trigger Design

Consider the objective function

[TABLE]

where $L$ is the Laplacian of the connected communication graph $\mathcal{G}$. Note that $V(x)\geq 0$ for all $x\in^{N}$ and $V(x)=0$ if and only if $x_{i}=x_{j}$ for all $i,j\in\{1,\dots,N\}$. Thus, the function $V(x)$ encodes the objective of the problem and we are interested in driving $V(x)\rightarrow 0$. For simplicity, we drop the explicit dependence on time when referring to time $t$.

Taking the derivative of $V$ with respect to time, we have

[TABLE]

Let us split up $\dot{V}=\sum_{i=1}^{N}\dot{V}_{i}$, where

[TABLE]

Note that we have essentially distributed $\dot{V}$ in a way that clearly shows how each agent’s motion directly contributes to the global objective, allowing us to write

[TABLE]

Ideally, we now wish to design a self triggered algorithm such that $\dot{V}_{i}(x(t))\leq 0$ for all agents $i$ at all times $t$. Thus at surfacing time $t^{\ell}_{i}$, agent $i$ must determine $t^{\ell+1}_{i}$ and $u_{i}(t)$ such that $\dot{V}_{i}(t)\leq 0$ for all $t\in[t_{i}^{\ell},t^{\ell+1}_{i})$.

While in the fully developed algorithm we will allow an agent to modify its control while still submerged, for now we assume that the control input is constant on the entire submerged interval and defer the discussion of the control “expiration time” $t^{\textrm{expire}}_{i}$; its motivation and (minor) modifications to the algorithm to section 3.3.

Note that given the information agent $i$ downloaded from the server at time $t^{\ell}_{i}$, it is able to exactly compute the state of a neighboring agent $j\in\mathcal{N}_{i}$ up to the time it resurfaces $t^{\textrm{next}}_{j}$. For any $t\in[t^{\ell}_{i},t^{\textrm{next}}_{j}]$,

[TABLE]

At time $t^{\textrm{next}}_{j}$, however, agent $j$ autonomously updates its control signal in a way unknown to agent $i$, making it difficult to determine how agent $i$ should move without surfacing. To remedy this, we borrow an idea of promises from team-triggered control [28]. Suppose that although we don’t know $\dot{x}_{j}(t)$ exactly for $t>T_{i}$, we have access to some bound $M_{j}(t)>0$ such that $|\dot{x}_{j}(t)|\leq M_{j}(t)$.

Using this information, we introduce the notion of agent $j$’s reachable set as determinable by agent $i$. For any $j\in{\mathcal{N}}_{i}$, let $R^{i}_{j}(t)$ be the set of states at time $t$ within which agent $i$ can determine that agent $j$ must be in. For $t\leq t^{\textrm{next}}_{j}$, agent $i$ is able to determine $x_{j}(t)$ exactly and so $R^{i}_{j}(t)=\{x_{j}(t)\}$ is a singleton containing agent j’s exact position. For $t>t^{\textrm{next}}_{j}$, as all agent $i$ knows is a bound on agent $j$’s control law, $R^{i}_{j}$ is a ball that grows at a rate determined by agent $j$’s promise $M_{j}$:

[TABLE]

where $B(x,r)$ is a closed ball of radius $r$ centered at $x$. $R^{i}_{i}$ is simply the singleton

[TABLE]

We can now express the latest time that agent $i$ can still be sure it is contributing positively to the objective.

Definition 1**.**

$T^{\star}_{i}$* is the first time $T^{\star}_{i}\geq t^{\ell}_{i}$ after which agent $i$ can no longer guarantee it is positively contributing to the objective, the solution to the following:*

[TABLE]

where $R^{i}(t)$ is defined as the set of all states $x_{j}(t)$ for $j\in{\mathcal{N}}_{i}\cup\{i\}$ such that each $x_{j}(t)$ satisfies $x_{j}(t)\in R^{i}_{j}(t)$.

It is easy to compute the solution to (14) exactly given the structure of $R^{i}_{j}(t)$ given above. Let $\pi_{t}$ be a sorted ordering on the next surfacing times of all of agent $i$’s neighbors, i.e. let $\pi_{t}:[|{\mathcal{N}}_{i}|]\rightarrow{\mathcal{N}}_{i}$ be a one-to-one function such that $t^{\textrm{next}}_{\pi_{t}(1)}\leq t^{\textrm{next}}_{\pi_{t}(2)}\leq\ldots\leq t^{\textrm{next}}_{\pi_{t}(|{\mathcal{N}}_{i}|)}$. We abuse notation slightly by additionally setting $t^{\textrm{next}}_{\pi(0)}=t^{\textrm{last}}_{i}$ and $t^{\textrm{next}}_{\pi(|{\mathcal{N}}_{i}|+1)}=\infty$ so the union of the intervals $[t^{\textrm{next}}_{\pi(k)},t^{\textrm{next}}_{\pi(k+1)})$ for $k\in\{0,1,\ldots,|{\mathcal{N}}_{i}|\}$ covers all $t\geq t^{\textrm{last}}_{i}$.

Proposition 1**.**

Let $\tau^{\star,(k)}_{i}$ be the solution to the following optimization:

[TABLE]

where

[TABLE]

Then, the solution $T^{\star}_{i}$ to (14) can be computed exactly as

[TABLE]

Proof.

See Appendix A. ∎

It is additionally possible to allow agent $i$ to remain submerged for longer by allowing $\dot{V}_{i}$ to temporarily become positive, as long as we select $t^{\ell+1}_{i}$ such that the total contribution to the objective $V$ on the interval $[t^{\ell}_{i},t^{\ell+1}_{i})$,

[TABLE]

is nonpositive.

Definition 2**.**

$T^{\textrm{total}}_{i}$* is the first time $T^{\textrm{total}}_{i}\geq t^{\ell}_{i}$ after which agent $i$ can no longer guarantee its total contribution over the submerged interval is positive, the solution to the following:*

[TABLE]

To compute $T^{\textrm{total}}_{i}$, we follow a similar approach.

Proposition 2**.**

Let $\tau^{tot,(k)}_{i}$ be the solution to the following optimization:

[TABLE]

Then, the solution $T^{\textrm{total}}_{i}$ to (21) can be computed as

[TABLE]

Proof.

See Appendix B. ∎

Remark 3.1**.**

Although the optimization constraints in Propositions 1 and 2 appear complex, note that they are linear or quadratic in $t$ and so the infimums can be solved for easily. Consider a problem of the form

[TABLE]

where $g(t)$ is a polynomial in $t$.

Let $r_{1}\leq r_{2}\leq\dots\leq r_{K}$ be the roots of $g$ that lie in the interval $(t_{1},t_{2})$, and let $r_{0}=t_{1}$ and $r_{K+1}=t_{2}$. The solution $t^{\star}$ to (24) is the smallest $r_{i}$, $i=0,\dots,K$, such that $g(r_{i})\geq 0$ and $g(\frac{1}{2}(r_{i}+r_{i+1}))>0$. If no such $r_{i}$ exists, $t^{\star}=\infty$.

• $\bullet$*

Remark 3.2**.**

The computation of the constraint coefficients in (22) and (15) takes $O(|{\mathcal{N}}_{i}|)$ time, and in both cases $|{\mathcal{N}}_{i}|+1$ such problems must be solved. Thus, computation of $T^{\star}$ and $T^{\textrm{total}}$ both takes $O(|{\mathcal{N}}_{i}|^{2})$ time.

• $\bullet$*

Selecting $t^{\ell+1}=T^{\star}_{i}$ ensures that $\dot{V_{i}}<0$ over the submerged interval, ensuring that agent $i$ is making progress towards the global objective at all $t$. Selecting $t^{\ell+1}=T^{\textrm{total}}_{i}$ introduces a trade-off; while this time allows the agent to remain submerged for longer, as it allows some positive contribution to the objective function, overall progress is slower. Thus, we propose a tuning parameter $\sigma_{i}\in[0,1]$, selecting a time $t^{\ell+1}_{i}$ such that $T^{\star}_{i}\leq t^{\ell+1}\leq T^{\textrm{total}}_{i}$:

[TABLE]

By continuity of $\dot{V}_{i}$ and the definitions of $T^{\star}_{i}$ and $T^{\textrm{total}}_{i}$, it is guaranteed for $t_{i}^{\ell+1}\in[T^{\star}_{i},T^{\textrm{total}}_{i}]$ that we still have $\Delta V_{i}^{\ell}\leq 0$ (as defined in (20)) with this definition. Setting all $\sigma_{i}$ near 0 allows faster convergence with more frequent surfacing, while $\sigma_{i}$ near 1 results in slower convergence but less frequent surfacing.

3.1 Selecting promises $M_{j}$

As it isn’t possible in general for agent $i$ to bound a neighbor agent $j$’s future control inputs from past state and control information, instead each agent makes a promise $M_{i}$ about its future control inputs each time it connects to the server. In the preceding section, we assumed that the bound $|\dot{x}_{j}(t)|\leq M_{j}(t)$ was satisfied at all times without describing how to make it so. Here, we describe how to co-design the control laws $u_{i}(t)$ and promises $M_{i}(t)$ to ensure that this actually holds at all times.

Let $M_{i}^{\ell}$ be the promise made by agent $i$ at time $t^{\ell}_{i}$. From the constraints in Propositions 1, 2, it is clear that the smaller $M_{j}$ is for any $j\in{\mathcal{N}}_{i}$, the longer agent $i$ is able to stay submerged. However, limiting the control too much below the ideal control (3) will slow convergence.

We consider a promise rule in which at time $t_{i}^{\ell}$ agent $i$ sets its promise to be a function of $|u^{\star}_{i}(t^{\ell}_{i})|$:

[TABLE]

For example, $f(x)=cx$ provides a parameter $c$ that effectively allows another trade-off between convergence speed and communication frequency. Note however that this does not mean agent $i$ can use its ideal control law at all times; if the new desired input is greater in magnitude than a previous promise, to remain truthful to previous promises agent $i$ must wait until the new promise has been received by all of its neighbors when they surface before it can use its desired control input.

Let $\tau_{ij}^{\ell}$ be the time that agent $j$ sees agent $i$’s $\ell$th promise, i.e. $\tau_{ij}^{\ell}=t^{\textrm{next}}_{j}(t^{\ell}_{i})$. When submerging for an interval $[t^{\ell}_{i},t^{\ell+1}_{i})$, agent $i$ needs to guarantee that all promises $M_{i}$ currently believed by $j\in{\mathcal{N}}_{i}$ are abided by.

Let $p^{\textrm{last}}_{ij}(t)$ be the most recent promise by agent $i$ that agent $j$ is aware of at time $t$, i.e.

[TABLE]

and let $\mathcal{P}_{i}^{\ell}$ be the set of promise indices that agent $i$ must abide by when submerging on $[t^{\ell}_{i},t^{\ell+1}_{i})$, i.e.

[TABLE]

To abide by all promises that agent $i$’s neighbors believe about its controls, then, it simply needs to bound its control input magnitude by

[TABLE]

With this bound, the actual control law used and uploaded by agent $i$ on the interval $[t^{\ell}_{i},t^{\ell+1}_{i})$ is given by bounding the ideal control magnitude by $u^{\textrm{max}}_{i}(t^{\ell}_{i})$, or

[TABLE]

3.2 Maximum submerged time

The method presented thus far is almost complete; however, consider the case in which a subset of the communication graph has locally reached “consensus” while the system as a whole has not. If there is some agent $i$ such that at agent $i$’s next surfacing time $t^{\ell}_{i}$ we have $x_{i}(t^{\ell}_{i})=x_{j}(t^{\ell}_{i})$ for all $j\in{\mathcal{N}}_{i}$, and furthermore that $u_{j}(t^{\ell}_{i})=0$ for all $j\in{\mathcal{N}}_{i}$, then it would set its next triggering time to infinity. An examination of the constraints in (15) and (22) then reveals that the feasible set in both cases is equal to the empty set $\emptyset$. The times $T^{\star}_{i}$ and $T^{\textrm{total}}_{i}$ will thus be chosen as $\inf\emptyset=\infty$.

In order to guarantee consensus in all situations, and as it is impossible for agent $i$ to obtain information outside of its immediate neighbors, it is necessary to introduce a maximum submerged time $t_{\textrm{max}}$. If an agent $i$ computes a $t^{\textrm{ideal}}_{i}$ such that $t^{\textrm{ideal}}_{i}-t^{\textrm{last}}_{i}>t_{\textrm{max}}$, the agent instead chooses $t^{\textrm{next}}_{i}=t^{\textrm{last}}_{i}+t_{\textrm{max}}$. This ensures that despite a region of the communication network being at local “consensus,” no agent will effectively remove itself from the system and information will continue to propagate.

3.3 Avoiding Zeno behavior

While the presented method of selecting surfacing times guarantees convergence, it is susceptible to Zeno behavior, i.e. requiring some agent $i$ to surface an infinite number of times in a finite time period. To avoid this behavior, we introduce a fixed dwell time $T^{\textrm{dwell}}_{i}>0$, and force each agent to remain submerged for at least a duration of $T^{\textrm{dwell}}_{i}$. Unfortunately, this means that in general, there may be times at which an agent $i$ is forced to remain submerged even when it does not know how to move to contribute positively to the global task (or it may not even be possible if it is at a local minimum). Remarkably, from the way have have distributed $\dot{V}$ using (7), if agent $i$ sets $u_{i}(t)=0$, its instantaneous contribution to the global objective is exactly 0.

Thus, we allow an agent’s control to change while it is submerged and modify the control law described in the previous section as follows. If the chosen ideal surfacing time $t^{\textrm{ideal}}_{i}=(1-\sigma_{i})T^{\star}_{i}+\sigma_{i}T_{i}^{\textrm{total}}$ is greater than or equal to $t^{\ell}_{i}+T^{\textrm{dwell}}_{i}$, then nothing changes; agent $i$ sets its next surfacing time $t^{\ell+1}_{i}=t^{\textrm{ideal}}_{i}$ and uses the control law (32) on the entire submerged interval.

If, on the other hand, $t^{\textrm{ideal}}_{i}<t^{\ell}_{i}+T^{\textrm{dwell}}_{i}$, we let agent $i$ use the usual control law until $t^{\textrm{ideal}}_{i}$, until which it knows it can make a positive contribution. After $t^{\textrm{ideal}}_{i}$, agent $i$ no longer is certain it can make a positive contribution to the global objective. Thus, we force agent $i$ to remain still until it has been submerged for a dwell time duration. In other words, we set $t^{\textrm{next}}=t^{\ell}_{i}+T^{\textrm{dwell}}_{i}$, $t^{\textrm{expire}}=t^{\textrm{ideal}}_{i}$ and use control law (32) on the interval $[t^{\ell}_{i},t^{\textrm{expire}}_{i})$.

For $t\in[t^{\textrm{expire}}_{i},t^{\ell+1}_{i})$, we then set $u_{i}(t)=0$, and note that because $\dot{V}_{i}(t)=0$ on this interval we still have the desired contribution to the global objective

[TABLE]

Agent $i$ is then still able to calculate the position of any neighbor $j$ exactly for any $t<t^{\textrm{next}}_{j}$ using information available on the cloud by

[TABLE]

An overview of the fully synthesized self-triggered coordination algorithm is presented in Algorithm 1. Next, we present the main convergence result of this algorithm.

Theorem 3.3**.**

Given the dynamics (1) and $\mathcal{G}$ connected, if the sequence of times $\{t_{i}^{\ell}\}$ and control laws $u_{i}(t^{\ell}_{i})$ are determined by Algorithm 1 for all $i\in\{1,\dots,N\}$, then

[TABLE]

for all $i,j\in\{1,\dots,N\}$ as $t\rightarrow\infty$.

Proof.

First, because $t^{\ell+1}-t^{\ell}\geq T^{\textrm{dwell}}_{i}>0$, Zeno behavior is impossible, and so $x(t)$ exists for all $t\geq 0$.

Now, consider the objective function $V=\frac{1}{2}x^{T}Lx$. Then, recall we can decompose it as

[TABLE]

Letting $\ell^{\textrm{max}}_{i}(t)=\operatorname{argmax}_{\ell\in\mathbb{Z}_{\geq 0}}t^{\ell}_{i}\leq t$ be the index such that $t^{\textrm{last}}_{i}(t)=t^{\ell^{\textrm{max}}_{i}(t)}_{i}$, we can further expand this as

[TABLE]

Consider $\Delta V_{i}^{\ell}$ (as defined in (20)), which is the net contribution of agent $i$ over the time interval $[t_{i}^{\ell},t_{i}^{\ell+1})$. Note that we have explicitly designed algorithm 1 to ensure that each $\Delta V_{i}^{\ell}\leq 0$. $T^{\textrm{total}}_{i}$ is exactly the earliest time at which we can no longer guarantee $\Delta V_{i}^{\ell}\leq 0$ in the worst case, and we always have $t^{\textrm{ideal}}<T^{\textrm{total}}_{i}$. Furthermore, if the dwell time forces an agent to stay submerged past $t^{\textrm{ideal}}_{i}$, by setting the control to 0 we ensure that the total contribution on the submerged interval is equal to the contribution from $t^{\ell}_{i}$ to $t^{\textrm{ideal}}_{i}$. Thus, we know that $\Delta V_{i}^{\ell}\leq 0$ for all $i\in\{1,\dots,N\}$ and for all $\ell\in\{1,\dots,\ell^{\textrm{max}}_{i}-1\}$.

Thus, we have

[TABLE]

It is clear that $V(x(t))$ is a nonincreasing function along the system trajectories and bounded below by 0. Furthermore, by the introduction of the dwell time it is clear that each sequence of times $\{t_{i}^{\ell}\}_{\ell\in\mathbb{Z}_{\geq 0}}$ goes to infinity as $\ell\rightarrow\infty$. Thus, $\lim_{t\rightarrow\infty}V(x(t))=C\geq 0$ exists.

Because $\Delta V_{i}^{\ell}\leq 0$ for all $\ell$ and $V(x)$ is bounded from below, it is guaranteed that $\Delta V_{i}^{\ell}\rightarrow 0$ as $t\rightarrow\infty$. Thus, by LaSalle’s Invariance Principle [29], the trajectories of the system converge to the largest invariant set contained in

[TABLE]

From examination of the local objective contribution (7), we see that $\dot{V}_{i}(x)=0$ if and only if either $u_{i}(t)=0$ or $\sum_{j\in{\mathcal{N}}_{i}}x_{j}-x_{i}=0$. First, note that $\sum_{j\in{\mathcal{N}}_{i}}x_{j}-x_{i}=0$ for all $i$ if and only if the system is at consensus. This condition is equivalent to $Lx=0$, and as we assume $\mathcal{G}$ is connected, $\ker(L)=\{\mathbf{1}_{N}\}$.

Now, assume the system is not at consensus, so there is at least one agent $i$ with $\sum_{j\in{\mathcal{N}}_{i}}x_{j}-x_{i}\neq 0$. From the control law (3) it is clear that this implies the next time agent $i$ surfaces, $t^{\ell}_{i}$, we will have $u^{\star}_{i}(t^{\ell}_{i})\neq 0$ as well. Thus, we simply have to prove that the next time $t^{\ell}_{i}$ that agent $i$ surfaces, it computes a $t^{\textrm{ideal}}_{i}>t^{\ell}_{i}$ so the real control $u_{i}(t)\neq 0$ for a nonzero period of time. As $t^{\textrm{ideal}}_{i}>T^{\star}_{i}$, the last time at which we can guarantee $\dot{V}_{i}(t)\leq 0$, it suffices to show $T^{\star}_{i}>t^{\ell}_{i}$.

$T^{\star}_{i}$ is computed as the earliest time after which our bound on $\dot{V}_{i}(t)$ is positive. From (50) we can write this bound at time $t^{\ell}_{i}$ as

[TABLE]

which is strictly negative. As the bound is a continuous function of time, this implies that the smallest $t$ such that we can no longer guarantee $\dot{V}_{i}(t)\leq 0$ is strictly greater than $t^{\ell}_{i}$. Thus, the next time agent $i$ surfaces, it will apply a nonzero control for a positive duration.

Finally, due to the existence of the maximum submerged time $t_{\textrm{max}}$, we know that there exists a finite future time at which agent $i$ will surface, which completes the proof.

∎

4 Simulation

In this section we simulate a system of 5 agents with initial condition $x=[9\ -2\ 0.5\ 8.5\ 4]^{T}$ for a total time of 10 seconds, and with all $\sigma_{i}=\sigma$ the same value. In all simulations we set $T^{\textrm{dwell}}=10^{-8}$ seconds, but the dwell time condition was never used. Similarly, we set $t_{\textrm{max}}=5$ seconds, but it never affected the simulation. The topology of the communication network is shown in Figure 1. We compare our algorithm presented here with the algorithm proposed in [30], as well as with a simple periodic triggering rule where each agent surfaces every $T$ seconds and uses the constant control law $u^{\star}_{i}(t^{\ell}_{i})$ on each submerged interval. Note that for the undirected graph in Figure 1 the system will converge as long as $T<T^{*}=2/\lambda_{\text{max}}(L)=0.4331$ [31].

We first compare our algorithm with $\sigma=0.75$ and the promise function (26) as $f(x)=x$, the algorithm presented in [30] with $\sigma=0.5$, and a periodic time-triggering rule with $T=0.35$. The total number of surfacings by any agent up to time $t$, denoted $N_{S}(t)$, is shown in Figure 2.

The evolution of the objective function $V(x(t))$ for the same three configurations described above is displayed in Figure 2. Note that although all three algorithms have a similar convergence rate, the algorithm presented here requires significantly fewer communications amongst the agents to achieve that result. For our algorithm under these parameters, the evolution of the robot states over time is shown in Figure 3, and each individual agent’s surfacing times are shown in Figure 3.

We also ran the same simulation but with our algorithm having $\sigma=0.75$ and the promise function as $f(x)=4x$. The resulting surfacing counts and objective function evolution can be seen in Figures 4 and 4. In this situation, note that although all algorithms resulted in a similar number of communications required, the algorithm presented here converged more quickly.

As mentioned above, the periodic triggering rule for this specific network topology is guaranteed to converge for any period $T\leq 0.4331$. We further compared our algorithm with $f(x)=x$ and $\sigma=0.75$ against the periodic triggering rule with a period very near this threshold, $T=0.43$. The resulting $N_{S}(t)$ and evolution of the global objective $V(t)$ is seen in Figures 5 and 5 respectively. Here our algorithm both converges significantly more quickly and requires far fewer surfacings by the agents than even the most infrequent possible communication under a periodic triggering rule. Furthermore, to determine the threshold under which a periodic triggering rule will converge, each agent required global information about the communication graph. On the contrary, our algorithm is guaranteed to converge using only local information and no shared parameters.

We additionally investigated the effect of choosing various promise functions $f(x)$. We ran three simulations with $\sigma=0.5$ and $f(x)=0.25x$, $f(x)=x$, and $f(x)=4x$. The results can be seen in Figures 6 and 6. For a promise of the form $f(x)=cx$, we see that a smaller value of $c$ results in more infrequent communication while also slowing convergence; it forces agents to move more slowly, slowing their movement towards consensus, while also slowing the growth of the bound their neighbors can make on their state, reducing the rate at which those neighbors need to communicate.

A single agent’s control law (agent 5) from a run of our algorithm with $\sigma=0.5$ is shown in Figure 7, along with its “promise” currently on the cloud server. There exists a lag between when the promised control max $M_{5}(t)$ increases and when the actual control increases likewise. While $M_{5}(t)$ represents the ideal control that the agent would use, it is still bound to a previous promise until the newer one propagates to all neighbor agents.

5 Conclusion

We have presented a novel self-triggering algorithm that, given only the ability to communicate asynchronously at discrete intervals through a cloud server, provably drives a set of agents to consensus without Zeno behavior. Unlike most previous work, we do not require an agent to be able to listen continuously, instead only being able to receive information at its discrete surfacing times. Through the use of control promises, we are able to bound the states of neighboring agents, allowing an agent to remain submerged until its total contribution to the consensus would become detrimental. The given algorithm requires no global parameters, and is fully distributed, requiring no computation to be done off of each local platform. Simulation results show the effectiveness of the proposed algorithm.

In the future, we are interested in investigating control laws different from (32) and forms of $f(x)$ other than $f(x)=cx$ that may be able to provide more infrequent surfacings or faster convergence. We are additionally interested in methods to reach approximate consensus rather than true asymptotic consensus, and guaranteeing no Zeno behavior without a dwell time.

Acknowledgments

This work was supported in part by the TerraSwarm Research Center, one of six centers supported by the STARnet phase of the Focus Center Research Program (FCRP) a Semiconductor Research Corporation program sponsored by MARCO and DARPA.

Appendix A Proof of Proposition 1

We begin by further splitting up the local objective contribution $\dot{V}_{i}$ as a sum of individual neighbor pair contributions: $\dot{V}_{i}(t)=\sum_{j\in{\mathcal{N}}_{i}}\dot{V}_{ij}(t),$ where

[TABLE]

For $t\leq t^{\textrm{next}}_{j}$, we can write $\dot{V}_{ij}(t)$ exactly as

[TABLE]

For $t>t^{\textrm{next}}_{j}$, since agent $i$ no longer has access to $u_{j}(t)$, we write it as follows:

[TABLE]

We can then use the promise $M_{j}(t)$ to bound

[TABLE]

allowing us to upper bound $\dot{V}_{ij}(t)$ for $t>t^{\textrm{next}}_{j}$ with

[TABLE]

Letting $\alpha_{ij}$, $\beta_{ij}$, and $\gamma_{ij}$ be as defined in Proposition 1, we can write these as

[TABLE]

Assume that the solution to (14) lies in the interval $T_{i}^{*}\in[t^{\textrm{next}}_{\pi(k)},t^{\textrm{next}}_{\pi(k+1)})$ for some $k\in\{0,\dots,|\mathcal{N}_{i}|\}$. On this interval, the states of neighbors $\pi(m)$ for $m>k$ are known exactly, while those $\pi(m^{\prime})$ with $m^{\prime}\leq k$ are only known to lie in a ball since they are scheduled to surface and change their control by this time interval. Using (44) and (47), we can write the local objective contribution $\dot{V}_{i}(t)$ for $t$ in this interval as

[TABLE]

Let $\tau^{\star,(k)}_{i}$ be the solution to (14) with the additional constraint that $t$ be within the interval $[t^{\textrm{next}}_{\pi(k)},t^{\textrm{next}}_{\pi(k+1)}]$:

[TABLE]

The objective derivative constraint in (53) can be rewritten using (52) in the form seen in Proposition 1. The solution to the original optimization (14) can then be written as

[TABLE]

Appendix B Proof of Proposition 2

First, note that the separation amongst neighbor pairs is still valid:

[TABLE]

For an agent $j\in{\mathcal{N}}_{i}$ and $t\leq t^{\textrm{next}}_{j}$, we can exactly compute the pair contribution over its submerged interval as

[TABLE]

where $\alpha_{ij}$ and $\beta_{ij}$ are as given in (16) and (17).

For agent $j$ and $t>t^{\textrm{next}}_{j}$, we first split the integral into a part that we can compute exactly and a part that we can only bound:

[TABLE]

and using the bound (52), can write

[TABLE]

The total pair contribution $\int\dot{V}_{ij}(t)$ is then given by (56) for $t\leq t^{\textrm{next}}_{j}$, and bounded by

[TABLE]

for $t>t^{\textrm{next}}_{j}$.

As before, consider times $t$ that lie in the interval $[t^{\textrm{next}}_{\pi(k)},t^{\textrm{next}}_{\pi(k+1)})$ for some $k\in\{0,\dots,|{\mathcal{N}}_{i}|\}$. We can bound the full objective contribution for times $t$ in this interval as (from (56), (57), and (59))

[TABLE]

Let $\tau^{tot,(k)}_{i}$ be the optimal solution to (21) with the additional constraint that $t$ be within the interval $[t^{\textrm{next}}_{\pi(k)},t^{\textrm{next}}_{\pi(k+1)})$. Using (60), we can rewrite the objective bound in (21) on this interval, resulting in the optimization seen in (22). The solution $T^{\textrm{total}}_{i}$ to (21) can then be written as

[TABLE]