Regression-Based Self-Triggered Control of Distributed Economic Dispatch over Lossy Communication Channels

Abstract

An essential building block of today’s smart grids is the integration of various renewable power generators into the system. Renewable distributed generators (DGs) provide environment friendly energy at a low cost. In this work, a distributed economic dispatch (ED) system is considered for renewable DGs to address the scalability challenge and reduce single points of failure compared to a centralised ED system. A consensus control mechanism is devised to achieve the incremental cost (IC) consensus among the DGs and utilise a self-triggered control (STC) mechanism to reduce the communication of the distributed DG system. A lossy communication channel between local DGs is considered in this work, which can arise from power lines or congestion on noisy wireless communication channels. A regression-based estimation approach is proposed to account for lost or corrupted data. The proposed method is compared with a centralised ED system and periodic communication. The proposed STC approach achieves the same level of performance as periodic communication while using half the communication resources.

1. Introduction

Conventional power grid systems consist of a few large generators and many consumers. The system can be categorised into power generation, transmission, and distribution [1]. Electricity demand is expanding rapidly, and climate change is pushing for increased renewable energy through the integration of distributed generators (DGs) into electricity systems. Renewable DGs are intermittent generators with varying output, leading to demand-supply mismatches. The transition to a smart grid (SG) is necessary to address these mismatches, increasing the power system’s reliability by making it more controllable and automated [2]. One of the functions of the SG to address power distribution issues is economic dispatch (ED) [3]. The ED’s role is to distribute the total power demand among spatially distributed generating units while minimising operational costs and considering various performance limitations. It optimises electric energy consumption under different conditions, accommodating renewable energy generation and achieving optimal cost while reducing the need for additional traditional power generation units to meet peak-hour demands [4].

Traditional ED optimisation techniques include the gradient approach, Newton’s methods [5], the lambda iteration method [6], and linear programming. These solutions rely on global information about the power system. These ED approaches are carried out centrally in a control unit containing all the necessary details on generation capacity and total load demands. The central control unit resolves the economic dispatch problem (EDP) and transmits the control signal to all generating units [7]. This centralised strategy is impractical for large-scale distributed generation due to its complexity and creates a single point of failure with a single central control unit. Additionally, a centralised system is not scalable, as adding new generating units may involve modifying the entire system’s architecture. To address these issues, researchers have concentrated on distributed approaches to solve the ED problem [8].

Distributed or decentralised approaches have recently been adopted due to the high deployment costs and single point of failure of centralised ED systems. A DG can be integrated into the system in a distributed setup without affecting scalability. In a distributed system, each node (DG or load) is connected to other nodes (called neighbours) and exchanges state information with them. In a DG system, information exchange occurs over a communication network. Often, such networks consist of noisy links due to power line communication or wireless channels [9,10,11,12], which can result in data losses.

One of the significant challenges of a distributed ED approach is obtaining consensus among the various agents (DGs or loads). Consensus control algorithms can be used to overcome the challenges of developing consensus among agents in dynamic systems. They are broadly classified as leader–follower-based and leaderless consensus control [13]. In leader–follower consensus, one or a few agents are designated leaders, and all other agents follow the leader(s). Only a few followers are directly connected with the leader in this approach. However, other agents are expected to indirectly access the leader’s information via agents connected to the leader [14].

The communication cost of such a multi-agent system for solving the EDP has received less attention in the literature. The intercommunication frequency between agents is kept very high to accommodate power fluctuations in the grid because of renewable energy generators and varying loads. It is generally considered periodic [15,16], resulting in agents communicating even when it is not required (no load or generation power fluctuations) from a control perspective. This is the case, for example, when the generator has already assessed the load demand and functions appropriately or when the load demand has been stable for an extended period. This unnecessary communication can lead to congestion over a distributed communication network and introduce losses or delays. To address this, event-based communication strategies (event-triggered control and self-triggered control) were proposed in [17]. In the event-triggered control (ETC) approach, agents communicate only when an event occurs; for example, when an agent’s state error exceeds a threshold, the agent communicates. To measure the state error, state information has to be measured continuously by sensors, which requires smart sensors that can sense the constantly changing state. This can lead to an increase in the cost due to the sensor operations of the system. Therefore, researchers have proposed an alternative approach called self-triggered control (STC). In STC, the agent’s state is sensed only when triggering happens. Whenever a triggering event occurs, the sensor detects the system’s state, and using the error threshold, the STC predicts the next time the agent must trigger. STC is proactive, which implies that after calculating the next communication time, the agent can be inactive until the next triggering instant [18].

In multi-access communications, data packets between nodes might be lost due to limited bandwidth, channel errors, and multiple agents using the same channel. While this communication loss can be mitigated by retransmitting the lost data, it introduces communication delays that can negatively affect consensus convergence. When the connectivity between neighbours is low in a distributed EPD setup, the delays can cause system instability, and a consensus may not be reached [12]. Therefore, delays need to be mitigated. Hence, a regression-based state estimation mechanism is proposed in this work to account for any lost state data occurring during self-triggered control to avoid retransmissions and congestion over the communication channel.

An incremental cost consensus (ICC) algorithm is used to demonstrate the effectiveness of our proposed distributed STC based consensus control approach. The cost of generation changes by including any distributed generator in the ICC algorithm [19]. To develop the ICC, all the neighbouring agents must be able to communicate with one another. A cascaded control mechanism is developed, where the inner loop is responsible for developing the consensus among the agents. The output of the internal loop is then fed into the outer loop to develop an STC-based communication mechanism among the agents. A regression-based estimation mechanism is proposed for handling the loss of state information, aiming to avoid delays due to retransmissions. The main contributions of this article are as follows:

• Development of an STC-based, fully distributed consensus control mechanism for the incremental cost consensus of DGs in economic dispatch.
• Proposal of a regression-based estimation method for the agent state for robust self-triggered consensus control of ED.

The remainder of this paper is organised as follows. In Section 2, we list and discuss related works. Section 3 discusses the incremental cost consensus model. This section also discusses the requirements for designing the consensus control mechanism, including algebraic graph theory. Section 4 discusses the differences between the existing and proposed approaches for self-trigger control and its benefits. The simulation results are presented in Section 5. In Section 6, we draw some conclusions and suggest future work.

2. Related Works

Using simple centralised control, the EDP was formulated in [20], where the optimal cost was obtained using a gradient descent method under the constraint of power generation. A consensus mechanism can solve the EDP by achieving optimal costs for all generators. A survey of the consensus mechanism was conducted in [7,21]. Leader–follower-based consensus for the EDP was also studied in [15,16]. As a centralised approach typically has scalability issues, distributed optimisation is more advantageous, as surveyed in [22]. A fully distributed EDP for smart grids was studied in [8], where the requirement for a central control unit was eliminated and every generator worked independently. A hierarchical-based decentralised EDP was solved in [6], where each agent solved its problem locally based on the local cost and generation capacity information. Other distributed EDPs were discussed in [23,24,25,26].

These articles mainly focused on the incremental cost consensus, and the communication between the agents was either neglected or simply periodic. Consensus-based local control was studied in [27,28], where the next communication time was calculated based on the state of the agent and its neighbours. Adaptive, event-triggered control (ETC) for the EDP was studied in [11], where the network topology was unknown, and free-weight parameters were introduced for ETC. A fixed-time EDP using event-triggered control was studied in [29], where the optimal solution was obtained at a fixed time. Therefore, combining a fixed-time EDP with an ETC mechanism can increase a controller’s computation burden to synchronise with the other controllers. A few other ETC-based EDPs were discussed in [30,31,32]. An event-triggered EDP reduces communication resources but increases the cost of continuous sensing. To avoid continuous monitoring, a self-triggered control (STC)-based EDP was solved in [33], where the connection topology was not fixed. A $\theta$-logarithmic-based formulation of the EDP was introduced in [34], where the local control used self-triggered control. Previously, we discussed self-triggered control for leader–follower-based consensus control of induction motors [35], where we considered a synchronous STC mechanism with perfect communication. Here, we extend our previous work to asynchronous STC, a more practical approach for fully distributed systems. All prior work assumes that communication between neighbours is perfect. However, to the best of our knowledge, the problem of communication losses in STC-based communication has not yet been addressed.

3. Incremental Cost Consensus

Consider multiple distributed power generators (DGs) and distributed loads connected to a smart grid. The EDP, formulated in Equation (1), aims to minimise the power generation cost while meeting the power demand with the total distributed power generation, where each generator has generation capacity constraints [20].

$$\begin{array}{cc}\hfill min& \sum _{i=1}^{N}c\left(P_i\right)\hfill \\ \hfill s.t.& \sum _{i=1}^N{P}_i=P_D\hfill \\ \hfill P_{i,min}& \le P_i\le P_{i,max}\hfill \end{array}$$

(1)

where N is the number of distributed power generators, $P_i$ is the power generated by the $i^{th}$ generator, $c\left(P_i\right)$ is the cost of power generation, and $P_D$ is the total load demand of the system. $P_{i,min}$ and $P_{i,max}$ are the minimum and maximum power generation capacities of the $i^{th}$ generator, respectively. The cost function is defined as:

$$c\left(P_i\right)=a{P_i}^2+b{P}_i$$

(2)

where $a,b$ are the fuel cost coefficients. A conventional Lagrange multiplier, given by (3), is used to solve the EDP to obtain the incremental cost (IC), ${\lambda }_i$, of each generator, where IC is the change in the cost of each generator whenever an agent enters or leaves the system. The optimal solution of the EDP is expected to have the same IC, ${\lambda }_i$, for all generators [36]. We propose a distributed approach to achieve incremental cost consensus among all generators.

In distributed consensus control, each generating unit’s updates its own IC depending on information from its neighbours and its current IC. One of the generators is viewed as a leader, knowing the power demand and optimal cost of the system. The leader updates its IC based on the power demand, and the other generators in the group follow the leader, resulting in incremental cost consensus.

The Lagrangian of (1) is defined as:

$$\mathcal{L}(P_i,\lambda )=\sum _{i=1}^{N}c\left(P_i\right)+\lambda (P_D-\sum _{i=1}^N{P}_i)$$

(3)

3.1. Algebraic Graph Theory

An undirected graph G represents the communication topology among the power generators. We define $G=\{V,E,A\}$, where $V=\{v_1,v_2,\dots \dots ,v_n\}$ is the vertex set representing N power generators. E is the set of edges connecting the nodes. $E_{ij}$ is the edge between two nodes $(v_i,v_j),i,j\in \{1,2,3,\dots \dots ,N\},i\ne j$. If $E_{ij}\in E$, $v_i$ is a neighbour to $v_j$, and they can both communicate with each other.

The adjacency matrix is $A=\left[a_{ij}\right]\in R^{N\times N}$, where $a_{ij}=1$ when i is connected to j; otherwise, $a_{ij}=0$. The in-degree matrix is a diagonal matrix $S=diag\{s_1,s_2,\dots ,s_N\}$ with $s_i={\sum }_{j\in N_i}{a}_{ij}$, where $N_i$ is the number of agents connected to the ith agent. The graph Laplacian matrix is $L=S-A$, where all row members of L add up to zero. L is a symmetric positive semi-definite matrix. The convergence rate (time to reach IC consensus) depends on the eigenvalues of L and is given by the second-smallest eigenvalue of L. Let $L={\left[l_{ij}\right]}_{N\times N}$, where $l_{ij}=l_{ii}$ on-diagonal and $l_{ii}={\sum }_{i\ne j}{a}_{ij}$, whereas $l_{ij}$ off-diagonal is $l_{ij}=-a_{ij}$ [13].

To obtain the consensus variable ${\lambda }_i$ and power mismatch $\Delta P_i$ between the power generator and demand, we need to calculate the partial derivative of (3) with respect to $P_i$ and ${\lambda }_i$, respectively. By setting the derivative equal to zero, we obtain

$$\frac{\partial \mathcal{L}}{\partial P_i}=\frac{\partial c\left(P_i\right)}{\partial P_i}-{\lambda }_i=0$$

(4)

or, equivalently,

$$\frac{\partial c\left(P_i\right)}{\partial P_i}={\lambda }_{i}i=1,\dots \dots ,n$$

(5)

and by differentiating with respect to ${\lambda }_i$ and setting it to zero, we obtain the power mismatch $\Delta P_i$

$$\Delta P_i=P_D-\sum _{i=1}^N{P}_i$$

(6)

To obtain the IC consensus, we need to obtain ${\lambda }_i$ iteratively; therefore, ${\lambda }_i$ needs to be discretized such that the local controller has the information of all neighbouring ICs at each time interval as:

$${\lambda }_i(k+1)=-\sum _{j=1}^n{d}_{ij}{\lambda }_j\left(k\right),i=1,\dots \dots ,n$$

(7)

where $d_{ij}=\frac{|l_{ij}|}{{\sum }_{j=1}^n\left|l_{ij}\right|}$ is the $(i,j)$th entry of a row-stochastic matrix L, and ${\lambda }_j$ is the IC of the jth neighbour generator. k is the time index where the generator updates its IC. By using (7), the system is expected to converge to a common IC asymptotically [16].

3.2. Consensus Control Updates

The consensus controller is responsible for developing the consensus of the IC of each generator based on the ICs of all the connected neighbours. Each generator calculates the control input for its own controller using the IC received from its neighbours. The control inputs for the leader and follower are given by (8) and (9), respectively.

$$u_{0l}\left(t\right)=-\sum _{j\in N^f}\left({\lambda }_i-{\lambda }_j\right)-\sum _{j\in N^l}\left[\left({\lambda }_i-{\lambda }_j\right)+\left({\lambda }_0-{\lambda }_i\right)\right]$$

(8)

$$u_i\left(t\right)=-\sum _{j\in N^f}\left({\lambda }_i-{\lambda }_j\right)-\sum _{j\in N^l}\left({\lambda }_i-{\lambda }_j\right)$$

(9)

where $N^f$ represents the follower set, $N^l$ represents the leader set, and $\left(t\right)$ is the continuous time index when $u_i$ is given to the controller.

The objective of the consensus control algorithm is to achieve the same incremental cost for all generators. The state error of the incremental cost for any agent i is given by (10) [37].

$$Z_i\left(t\right)=\sum _{j\in N_i}({\lambda }_i\left(t\right)-{\lambda }_j\left(t\right))=d\lambda ,i=1,\dots \dots .,N$$

(10)

Once the consensus is achieved, each generator’s $Z_i\left(t\right)$ is expected to be zero.

4. Self-Triggered Control

To achieve consensus, each generator requires the IC information from its neighbours and hence the generators must frequently communicate to exchange this information. Centralised EDP approaches use periodic communication strategies, leading to potentially significant communication overhead. With increasing generators and load demand, SGs are moving towards a distributed scenario to reduce system complexity. In several scenarios, the frequent information exchanges due to periodic communication approaches are unnecessary; hence, the move towards event-based, aperiodic communication. In our case of distributed STC, the generator updates its control input and broadcasts its state information to its neighbours [27] whenever an event occurs, i.e., the state error goes beyond a certain limit. The state error is defined by (11)

$$e_i\left(t\right)={\lambda }_i\left(t_k^i\right)-{\lambda }_i\left(t\right)$$

(11)

where $t\in [t_k^i,t_{k+1}^i$) and $t_k^i$ is the last triggering time instance at which agent i communicated its information to its neighbours. ${\lambda }_i\left(t_k^i\right)$ is the incremental cost at this time. The consensus controller of agent i is updated at the next triggering time instance using the recent information updates it received from its neighbours, and this is given by (12)

$${\lambda }_i\left(t_{k+1}\right)=-\sum _{j\in N_i}({\lambda }_i\left(t_k^i\right)-{\lambda }_j\left(t_{k\left(t\right)}^j\right))$$

(12)

where $N_i$ is the set of neighbouring agents. ${\lambda }_j$ is the latest information received by agent i from its neighbour j at its last triggering instance $t_{k\left(t\right)}^j$. In the case of multiple updates from a neighbour, $k\left(t\right)=mi{n}_{\{s\in \mathbb{N}:t_s^j\le t\}}(t-t_s^j)$, where $\mathbb{N}$ is the set of natural numbers. The control law of agent i, given by (12), is updated at its own event time and on receipt of any information update from any of its neighbours.

Equation (11) implies that

$${\lambda }_j\left(t_{k\left(t\right)}^j\right)={\lambda }_j\left(t\right)+e_j\left(t\right)$$

(13)

Therefore,

$${\dot{\lambda }}_i\left(t\right)=-\sum _{j\in N_i}({\lambda }_i\left(t\right)-{\lambda }_j\left(t\right))-\sum _{j\in N_i}(e_i\left(t\right)-e_j\left(t\right))$$

(14)

which leads to

$$\dot{\lambda }\left(t\right)=-d(\lambda \left(t\right)+e\left(t\right))$$

(15)

This distributed model can be validated by analysing the stability of the system. Hence, we need to define an input-to-state-stable (ISS) Lyapunov function.

$$V=(1/2){\lambda }^{T}d\lambda$$

(16)

Differentiating, we obtain

$$\begin{array}{cc}\dot{V}& ={\lambda }^{T}d\dot{\lambda }=-{\lambda }^{T}d(d\lambda +de)=-Z^{T}Z-Z^{T}de\\ & =-\sum _i{Z_i}^2-\sum _i\sum _{j\in N_i}(e_i-e_j)Z_i\\ & =-\sum _i{Z_i}^2-\sum _i\left|N_i\right|Z_i{e}_i+\sum _i\sum _{j\in N_i}{Z}_i{e}_j\end{array}$$

(17)

Now, using the following Young’s inequality [38]

$$\left|ab\right|\le (x/2)a^2+(1/2x)b^2,forx>0$$

(18)

we obtain

$$\dot{V}\le -\sum _i{Z_i}^2+\sum _{i}x|N_i|{Z_i}^2+\sum _i\frac{1}{2x}\left|N_i\right|{e_i}^2+\sum _i\sum _{j\in N_i}\frac{1}{2x}{e_j}^2$$

(19)

and assume that x is bounded by $0<x<(1/|N_i\left|\right)$ for all $i\in \mathbb{N}$. From algebraic graph theory, we know that the graph is symmetric, which allows us to interchange the last term of (19), i.e., ${\sum }_i{\sum }_{j\in N_i}\frac{1}{2x}{e_j}^2={\sum }_i\frac{1}{2x}\left|N_i\right|{e_i}^2$, where ${\sum }_{j\in N_i}|.|=|N_i|$ such that $\dot{V}\le -{\sum }_i(1-x){Z_i}^2+{\sum }_i(1/x)\left|N_i\right|{e_i}^2$. Therefore, it results in an error-enforcing condition as follows:

$${e_i}^2<\frac{{\zeta }_{i}x(1-x|N_i\left|\right)}{|N_i|}{Z_i}^2$$

(20)

which yields $\dot{V}$ negative definite when ${\zeta }_i\in (0,1]$, where $Z_i={\sum }_{j\in N_i}({\lambda }_i-{\lambda }_j)$ and if $Z_i=0$ for some agent i at any updating instance $t_k^i$ means the agent state has not changed and hence the error is equal to zero. Hence, there is no need to send additional updates, and no events should be triggered [39]. This is the fundamental difference between our triggering rule and [27]. Thus, for each i, an event is triggered at

$${e_i}^2>\frac{{\zeta }_{i}x(1-x|N_i\left|\right)}{|N_i|}{Z_i}^2$$

(21)

Let us define

$${\alpha }_i=\frac{{\zeta }_{i}x(1-x|N_i\left|\right)}{|N_i|}$$

(22)

Therefore, (20) can be rewritten as

$${|{\lambda }_i\left(t_k^i\right)-{\lambda }_i\left(t\right)|}^2<{\alpha }_i{Z_i}^2$$

(23)

From [27], we know that

$${\dot{\lambda }}_i\left(t\right)=u_i\left(t\right)$$

(24)

and from (9), we obtain,

$$u_i\left(t\right)=-\sum _{j\in N_i}\left({\lambda }_i-{\lambda }_j\right)$$

(25)

and here, $N_i\in \{N^f\cup N^l\}$; therefore,

$${\lambda }_i\left(t\right)=-\sum _{j\in N_i}({\lambda }_i\left(t_k^i\right)-{\lambda }_j\left(t_{k\left(t\right)}^j\right))(t-{t_k}^i)+{\lambda }_i\left({t_k}^i\right)$$

(26)

where $k\left(t\right):=argma{x}_{n\in \mathbf{N}}\{{t_n}^j-{t_k}^i\}$. The next control update is expected to happen at

$$min\{t_{k+1}^i,{min}_{j\in N_i}{t}_{k\left(t\right)}^j\}.$$

Now, defining ${\phi }_i={\sum }_{j\in N_i}({\lambda }_i\left(t_k^i\right)-{\lambda }_j\left(t_{k\left(t\right)}^j\right))$ and ${\phi }_j={\sum }_{n\in N_j}({\lambda }_j\left(t_k^j\right)-{\lambda }_n\left(t_{k\left(t\right)}^n\right))$. Also, let $t-{t_k}^i={\delta }_i$. Recalling the proposition $Z_i={\sum }_{j\in N_i}({\lambda }_i-{\lambda }_j)$ and using ${\phi }_i,{\phi }_j,{\delta }_i$, we obtain

$$Z_i\left(t\right)=\sum _{j\in N_i}(-{\phi }_i{\delta }_i+{\lambda }_i\left({t_k}^i\right))-\sum _{j\in N_i}(-{\phi }_j(t-t_{k\left(t\right)}^j)+{\lambda }_j\left(t_{k\left(t\right)}^j\right)$$

$$Z_i\left(t\right)=-|N_i|{\phi }_i{\delta }_i+\left|N_i\right|{\lambda }_i\left({t_k}^i\right)+\sum _{j\in N_i}({\phi }_j(t-t_k^i+t_k^i-t_{k\left(t\right)}^j)-{\lambda }_j\left(t_{k\left(t\right)}^j\right))$$

(27)

Rearranging $Z_i\left(t\right)$, we obtain

$$Z_i\left(t\right)=(-|N_i|{\phi }_i+\sum _{j\in N_i}{\phi }_j){\delta }_i+\left|N_i\right|{\phi }_i+\sum _{j\in N_i}\left({\phi }_j(t_k^i-t_{k\left(t\right)}^j)\right)$$

(28)

Defining ${\rho }_i=-\left|N_i\right|{\phi }_i+{\sum }_{j\in N_i}{\phi }_j$ and ${\mathsf{\Phi }}_i=\left|N_i\right|{\phi }_i+{\sum }_{j\in N_i}\left({\phi }_j(t_k^i-t_{k\left(t\right)}^j)\right)$ and using (23) and (26), (20) can be rewritten as

$${\left(\right|{\phi }_i\left|{\delta }_i\right)}^2<{\alpha }_i{\left(\right|{\rho }_i{\delta }_i+{\mathsf{\Phi }}_i\left|\right)}^2$$

(29)

The self-triggered control law for agent i is defined as follows: if there is a ${\delta }_i\ge 0$ such that ${\left(\right|{\phi }_i\left|{\delta }_i\right)}^2={\alpha }_i{\left(\right|{\rho }_i{\delta }_i+{\mathsf{\Phi }}_i\left|\right)}^2$, the next triggering instance $t_{k+1}^i$ occurs for agent i at most ${\delta }_i$ times after $t_k^i$, i.e., $t_{k+1}^i\le t_k^i+{\delta }_i$. If any agents are triggered, the control laws of all the connected neighbours are expected to be updated.

To calculate the intercommunication time interval of each agent, we need to solve (29) for ${\delta }_i$. Since we already know that $Z_i\left(t_k^i\right)\ne 0$, the solution for ${\delta }_i$ is

$${\delta }_i=min\left\{0,\frac{-\sqrt{{\alpha }_i}{\mathsf{\Phi }}_i}{\left(\right|{\phi }_i|+\sqrt{{\alpha }_i}{\rho }_i)},\frac{\sqrt{{\alpha }_i}{\mathsf{\Phi }}_i}{\left(\right|{\phi }_i|-\sqrt{{\alpha }_i}{\rho }_i)}\right\}$$

(30)

Both the terms for ${\delta }_i$ may be negative, resulting in ${\delta }_i=0$ in reality. This scenario is not practical and can cause the system to reach Zeno local behaviour. Therefore, a minimum intercommunication time is required so that the system does not reach Zeno local behaviour. This minimum time interval can be obtained by taking the time derivative of $\left(\right|\left|e\right||/|\left|d{\lambda }_i\right|\left|\right)$ [27]. Thus,

$$\frac{d}{dt}\left(\right|\left|e\right||/\left|\right|d{\lambda }_i\left|\right|)\le (1+{\left(\right|\left|d\right|\left|\right|\left|e\right||/|\left|d{\lambda }_i\right|\left|\right))}^2$$

(31)

Let $q=\left(\right|\left|e\right||/|\left|d{\lambda }_i\right|\left|\right)$; hence, (31) becomes,

$$\dot{q}\le {(1+|\left|d\right|\left|q\right)}^2$$

(32)

q satisfies the bound $q\left(t\right)\le {\varphi }_i(t,{\varphi }_0)$, where $\varphi (t,{\varphi }_0)$ is obtained by:

$$\dot{{\varphi }_i}={(1+|\left|d\right|\left|{\varphi }_i\right)}^2$$

(33)

with ${\varphi }_i(0,{\varphi }_0)={\varphi }_0$. Therefore, the minimum intercommunication time is bounded by ${\tau }_i$, which satisfies ${\varphi }_i({\tau }_i,0)=({\alpha }_i/\left|\right|d\left|\right|)$. The solution to (31) is ${\varphi }_i({\tau }_i,0)=(\tau /1-\tau |\left|d\right|\left|\right)$, resulting in ${\tau }_i=({\alpha }_i/\left|\right|d\left|\right|(1+{\alpha }_i))$ [27].

Hence, the next communication time for agent i is expected to be

$$t_{k+1}^i=t_k+min\left\{{\tau }_i,\frac{-\sqrt{{\alpha }_i}{\mathsf{\Phi }}_i}{|{\phi }_i|+\sqrt{{\alpha }_i}{\rho }_i},\frac{\sqrt{{\alpha }_i}{\mathsf{\Phi }}_i}{|{\phi }_i|-\sqrt{{\alpha }_i}{\rho }_i}\right\}$$

(34)

Consensus over Lossy Communication Channels

To develop the incremental cost (IC) consensus among different distributed generators (DGs), all the generators need to broadcast their state information at their communication time, and the neighbour receives that information. This work considers that the communication between the generators is over a lossy, multi-access communication channel. Losses occur due to the limited bandwidth resources that create multi-access congestion and due to noise and interference in the channel, e.g., a wireless channel, which causes delays. These delays are mitigated due to the use of self-triggered control, in which all the agents are not trying to broadcast their IC states at the same periodic interval but rather communicate over their STC times. Noise and interference in the channel can also corrupt or cause the broadcast data to be lost.

There are multiple ways to tackle data loss due to noise in the channel. The most common one is to use the previously received value of a DG if a data packet is lost, but due to the rapidly changing nature of DGs from renewable sources, this can slow down the convergence, and increase the cost. The other approach is to retransmit a lost packet, which can also cause delays and slow down the convergence process.

Therefore, to avoid these issues, this work proposes estimating the information contained in the lost data. Since in incremental cost consensus (ICC), all followers have to develop a consensus with the leader, and the leader has a linear cost curve, here, linear regression-based state estimation serves the purpose of estimating the lost state data. An agent updates its control input using the estimated state of its neighbours rather than the previously received and stored state information. To accommodate this approach, the local controller definition is updated in (12)

$${\lambda }_i\left(t_{k+1}\right)=-\sum _{j\in N_i}({\lambda }_i\left(t_k^i\right)-{\widehat{\lambda }}_j\left(t_k^i\right))$$

(35)

where ${\widehat{\lambda }}_j$ is the estimated cost of neighbour agent j at the communication time of agent i, $t_k^i$. ${\widehat{\lambda }}_j$ is defined as

$${\widehat{\lambda }}_j={\overline{\lambda }}_j+m_{\lambda t}(t_k^i-{\overline{t}}_j)$$

(36)

where ${\overline{\lambda }}_j$ is the average of the last r ($r=5$ is used for simulations) received values of the cost of agent j at agent i, and ${\overline{t}}_j$ is the average of the last r communication times of agent j. The slope, $m_{\lambda t}$, is defined as

$$m_{\lambda t}=\frac{r\sum \left[{\lambda }_j{t}_k^i\right]-\sum \left[t_k^i\right]\sum \left[{\lambda }_j\right]}{r\sum {\left[t_k^i\right]}^2-{(\sum t_k^i)}^2}$$

(37)

The error Equation (20) is also updated as

$${e_i}^2<\frac{{\zeta }_{i}x(1-x|N_i\left|\right)}{|N_i|}{\widehat{Z}}_i^2$$

(38)

where ${\widehat{Z}}_i={\sum }_{j\in N_i}({\lambda }_i-{\widehat{\lambda }}_j)$.

Hence, the STC proposed in this work becomes:

$$t_{k+1}^i=t_k+min\left\{{\tau }_i,\frac{-\sqrt{{\alpha }_i}{\widehat{\mathsf{\Phi }}}_i}{|{\widehat{\phi }}_i|+\sqrt{{\alpha }_i}{\widehat{\rho }}_i},\frac{\sqrt{{\alpha }_i}{\widehat{\mathsf{\Phi }}}_i}{|{\widehat{\phi }}_i|-\sqrt{{\alpha }_i}{\widehat{\rho }}_i}\right\}$$

(39)

The communication mode between DGs considered in much of the literature is based on an event-triggered approach [11,29,32,34], in which continuous monitoring of the IC is required. There has been much less work reported using an STC approach for the EDP [28,33,40]. Furthermore, where STC-based communication between the DGs has been considered, perfect communication between the generators is assumed, which is not always the case. Therefore, a regression-based STC (39) is designed to compensate for data loss due to communication errors or outages. The proposed regression-based STC for the EDP is shown in Figure 1.

5. Simulation Results

This section presents and discusses a performance analysis of the proposed self-triggered control method for the economic dispatch problem (EDP) through simulation studies. Various power generation scenarios and network topologies are considered in the analysis of our method and compared with existing work. The impact of STC on the system is observed and compared with a periodic communication scenario. The performance of regression-based STC over lossy channels is compared with that of simple STC in the literature.

5.1. Case I

Here, we consider a scenario in which three power-generating units are trying to meet the system’s power demand $\left(P_D\right)$, as shown in Figure 2. One of the units is designated as the leader, and it is expected to achieve the optimal cost. The other two agents act as followers, trying to reach a consensus with the leader. The parameters used to calculate the incremental cost for the simulation were taken from [20] and are given in

Table 1. Parameters for the three-agent system [16].

Unit	a (USD/MW2h)	b (USD/MWh)	${\mathit{P}}_{\mathit{Gi}}$ (MW)	${\mathit{P}}_{\mathit{min}}$ (MW)	${\mathit{P}}_{\mathit{max}}$ (MW)
1	0.001562	7.92	450	200	450
2	0.001940	7.85	300	150	370
3	0.004820	7.80	100	100	225

.

When the total power demand was $P_D=850$ MW, the optimal incremental cost, ${\lambda }^{\ast }$, obtained using the Lagrange multiplier, was USD 9.12/MWh. The incremental cost of the leader was determined using (5), and the power mismatch for the system was handled using (6). The incremental cost consensus using periodic communication with an inter-sampling time of $0.02$ (seconds) [25] is shown in Figure 3a. Although the initial incremental costs of all the agents are different, the leader obtained the optimal cost, and the followers reached a consensus with the leader. Let us assume that the load changed to $P_D=950$ MW after 50 iterations, as shown in Figure 3c [16]. As there was an increase in the power demand, the optimal incremental cost of the system increased, leading to an increase in the power generation from each DG to match the power demand, as shown in Figure 3b. The mismatch between the total power generation and the demand is shown in Figure 3c. As shown in Figure 3a, the simulation was carried out for a period of 100 iterations (as the system reached its steady state in 50 iterations, the new change in the system state could be incorporated in 100 iterations), and the neighbouring agents communicated periodically. Thus, the message exchange of each agent with its neighbouring agent was 100 data packets carrying state information for the complete simulation run. The inter-sampling time calculated using STC (34) is shown for each agent in Figure 4. This inter-sampling communication time was significantly higher than the conventional periodic sampling time, leading to a significantly reduced number of message exchanges in the system.

Our STC approach, given by (39), reduced the number of message exchanges of each agent with its neighbours to 50 data packets. The inter-sampling time of the proposed technique was higher, as shown in Figure 4; however, this communication frequency reduction might impact the system’s performance. The trade-off between less communication and system performance was computed and is shown in Figure 5a. Figure 5a shows the deviation in the ICC state when using STC (34) with the conventional periodic inter-sampling time, where the communication between the DGs was assumed to be perfect. Figure 5b shows the deviation in the ICC state when using our proposed regression-based STC compared to periodic communication. The difference in the state was less than 1%, and we observed a significantly reduced amount of communication when using the proposed STC. The difference in the ICC state is due to the unavailability of the latest neighbour’s information (ICC state). Each agent possesses only the information received from its neighbour during the neighbour’s last communication time [34]. The system’s performance can be further improved by considering the latest information from the neighbour, which can be estimated from the previously stored values. A linear regression-based state estimation mechanism is used in this work to estimate the neighbour’s state, and the resulting improvement in the ICC can be observed in Figure 5b.

With a lossy, multi-access communication medium between the agents, e.g., a wide-area wireless network, data packet loss can occur in the communication system. The proposed linear regression methodology also helps mitigate the effects of data losses, and the agents can still obtain a consensus by estimating the neighbour’s latest state information from the previously stored values. Here, we considered two scenarios of data losses (30% and 50%), and the cost deviation from the ideal communication scenario is depicted in Figure 6a,b, respectively. The results show that the percentage deviation of the incremental cost was less than $1\%$, although there was a 50% data loss.

5.2. Case II

In this section, we consider a more complex distributed power generation network scenario comprising five units in three different network topologies, as shown in Figure 7. Figure 7a (‘topology 1’) depicts a random network topology in which some agents can access the leader directly, while others are not directly connected to the leader but reach a consensus with their neighbours. Thus, all agents in the system achieve incremental cost consensus. In the considered random architecture, $G1$ acts as the leader; hence, it can access the difference between the current and generated power demand. $G1$ is not directly connected to all followers. For example, $G3$ does not obtain any information directly from the leader but obtains it through its neighbours, $G2$ and $G4$ (see Figure 7a). Figure 7b depicts a scenario with a network topology (‘topology 2’) with fewer edges. In this architecture, agent $G1$ is directly connected to only two neighbours, and agent $G5$ is three hops away from the leader. Figure 7c (‘topology 3’) shows a scenario with a linear topology, where each agent has the minimum number of network connections. In this architecture, agent $G1$ is directly connected to only one neighbour, and agent $G5$ is four hops away from the leader. The parameters used to calculate the incremental cost consensus for the five-agent system were obtained from [16] and are shown in

Table 2. Parameters for five-agent system [16].

Unit	a (USD/MW2h)	b (USD/MWh)	${\mathit{P}}_{\mathit{Gi}}$ (MW)	${\mathit{P}}_{\mathit{min}}$ (MW)	${\mathit{P}}_{\mathit{max}}$ (MW)
1	0.001562	7.92	200	200	450
2	0.001940	7.85	250	150	350
3	0.004820	7.80	100	75	225
4	0.001562	7.92	200	200	450
5	0.004820	7.80	100	75	225

.

In these three scenarios, the initial power demand was 850 MW, and the corresponding optimal cost was ${\lambda }^{\ast }=USD8.65/$MWh. As shown in Figure 8, it is assumed that the power demand changed to 950 MW after 50 iterations. The incremental costs of the system for the considered network topologies 1, 2, and 3 are shown in Figure 8a–c, respectively. For topology 1, shown in Figure 8a, where most followers could directly access the leader G1, convergence was expected to be very fast, and all DGs were expected to develop consensus quickly. The simulation was run using the exact periodic sampling of $0.02$ s used in [15], and the results in Figure 8a validate that the consensus convergence of the topology was smooth and fast due to multiple followers accessing the leader state. The convergence time increased in Figure 8b since the number of followers accessing the leader was reduced. This convergence further slowed, as shown in Figure 8c, where only one follower could access the leader DG. Moreover, the incremental cost consensus was directly related to communication between the leader and the followers. The results using a periodic inter-sampling time were compared with simple STC (34) and our proposed regression-based STC (39). The percentage deviation in the ICC for the leader and a follower is shown in Figure 9 and Figure 10, respectively. The results show that the proposed regression-based STC performed better than the simple STC. The proposed STC was also validated over a lossy channel with a 30% packet loss, where the regression-based STC was used to estimate the loss in state information. The results demonstrate that the ICC was impacted by less than 0.5% when using the proposed STC, even with a high loss in state information of 30%. The inter-sampling time calculated using STC (34) for each DG is shown in Figure 11. The results show that the inter-sampling time increased significantly using the proposed STC for all agents compared to periodic communication while not significantly impacting the convergence of the ICC.

6. Conclusions

A distributed EDP is solved in this work, in which each DG agent communicates over a potentially lossy communication channel with its neighbours to develop a consensus on their incremental cost. The inter-sampling time for communication is obtained using self-triggered control (STC). In the proposed STC, a regression-based estimation mechanism is used to estimate the latest state information to increase the intercommunication time. The proposed regression-based STC is also validated over a lossy communication channel, where the ICC state information is lost due to data packet loss and hence the state is estimated using the linear regression model. The Zeno behaviour in conventional STC is avoided in this work by providing a minimum inter-sampling time. The simulated results validate that the proposed regression-based STC works better than simple STC, and the performance of the ICC is not affected by packet loss over the lossy channel. The proposed STC increases the inter-sampling time and reduces the communication frequency, reducing communication costs. Improved performance is achieved over a lossy channel with regression-based loss estimations.

The proposed regression-based STC is proactive, which means once the next communication time is calculated, the communication is only expected to happen at that time. This means that any state change would not be addressed between planned communications. In future work, we will address this issue. Further, linear regression estimates the state so that computational complexity is avoided. However, if the reference value for consensus is not linear, the linear regression-based estimation can degrade the system’s performance; hence, other estimation mechanisms must be studied.