A Multi-Hop End-Edge Cooperative Computing Scheme for Power IoT

Abstract

With the continuous development of the power Internet of Things (PIoT), smart devices (SDs) have been widely used in electric power inspections. Due to the limited resources of intelligent inspection SDs and the distance of overhead transmission lines, many inspection tasks cannot be processed promptly. This paper proposes a multi-hop-based end-edge cooperative computing (MHCC) scheme to address inspection task processing in power IoT. We formulate a multi-hop task offloading problem that minimizes the energy consumption of inspection SDs with delay constraints. We develop a JDPSO algorithm to solve the multi-hop task offloading problem and evaluate the algorithm’s performance based on numerous simulation experiments. The experimental results show that JDPSO reduces the system’s energy consumption by 56.30%, 48.56%, 78.87%, 50.89%, 30.85%, and 68.31%, and also reduces delay by 50.69%, 42.78%, 58.67%, 44.84%, 10.22%, and 62.88% compared to GA, RSA, SSA, MFO, DOA, and ALC schemes.

1. Introduction

The power system is a complex industrial network carrying complex grid transmission, distribution, and massive information. Its infrastructure is distributed widely and challenging to operate and maintain [1]. Power inspection is essential to the safety of the power system and aims to understand its operation status. With the gradual expansion of the power grid’s scale, power inspection faces a series of technical challenges. Take transmission line inspection as an example. Since the power transmission infrastructure is often laid in the field, overhead transmission lines, including high-voltage towers, ancillary components, and transmission lines, must be regularly inspected as they are prone to failure or defects [2,3,4]. Affected by the harsh natural environment and complex terrain, the traditional manual inspection is characterized by high danger, low efficiency, and high investment costs [3,5,6]. Therefore, smart devices (SDs), such as unmanned aerial vehicles (UAVs) and robots, have been widely used in power grid equipment inspection [4,5,7]. With the development and progress of power Internet of Things (PIoT), more and more intellectual technologies, such as edge computing, mobile crowd sensing, advanced communication technologies, and unmanned aerial systems, are applied in inspection [8,9,10,11]. However, the intelligent inspection SDs adopted in the industry, such as UAVs and robots, face varying degrees of low range and limited computation and energy storage capacity [12]. As a direct result of the above issues, the massive inspection data of intelligent inspection still relies mainly on manual processing and is mostly offline and centralized, with poor real-time data analysis [13].

Cloud computing, an essential on-demand access pattern not limited by region or time [14], has become an essential support for power system data analysis. Power intelligent inspection can adopt a centralized cloud computing model. The inspection data from the SD are returned to the cloud computing center. Then, the rich computing resources of the cloud computing center are used to process the image data. However, the cloud computing model increases the load of the cloud computing center, which needs to occupy a large number of backhaul network bandwidth resources, and the long backhaul link makes it difficult to ensure the timeliness of data processing [13,15]. With the development of power IoT, much data are generated at the edge. Edge computing becomes an effective solution to the problems of limited-SD computing and energy storage capacity, limited return link bandwidth resources, and computational timeliness [16,17]. Edge computing and edge-end collaboration techniques can improve data processing efficiency. Some research aims to solve the computation offloading problem between SDs and edge nodes.

Deng et al. [18] offered a user-centric computational offloading model to minimize delay cost, energy consumption, and price in multiuser edge computing network setups. They formulated the problem as a mixed-integer nonlinear programming problem. To tackle this problem, the researchers proposed a branch-and-bound algorithm incorporating linear relaxation enhancements. Furthermore, a particle swarm optimization algorithm was devised, integrating 0–1 and weight improvements. Wei et al. [19] introduced an algorithm for task offloading that balances energy efficiency and delay considerations. They reframed the task offloading challenge as a two-sided matching issue, establishing a stable match between devices and servers through iterative means.

Wang et al. [7] investigated intelligent computation offloading in 5G mobile edge computing power robot inspections to address dynamic environments and different resources. They proposed an AI-assisted multidimensional collaborative optimization algorithm for route planning and task offloading to minimize inspection latency while considering queue backlog constraints. Shen et al. [16] presented a UAV edge computing offloading strategy based on deep reinforcement learning (DRL). They established a collaborative offloading architecture termed “device-edge-cloud” for the UAV edge scenario. This architecture addressed the task offloading problem as an optimization challenge for minimum delay subject to constraints on edge server communication and computing resources. Mao et al. [20] investigated a multi-antenna UAV-assisted task transmission and computation scheme with dual functions of aerial MEC and aerial relay. This study formulated an energy consumption minimization problem for UAV-assisted MEC networks, considering the channel’s uncertainty, and solved it using various convex reformulation methods and successive convex approximation (SCA) algorithms. Focusing on regions with limited or no communication infrastructure in low-latency IoT, Bai et al. [21] proposed a trust-based active notice task offloading (TANTO) scheme assisted by drones. The authors considered the task broadcasting mechanism, network trust, and priority of urgent tasks to optimize the UAV’s flight distance, task completion delay, and task completion rate. Zhang et al. [22] explore a system that employs UAVs to assist in multiaccess edge computing, with the intended outcome being the minimization of the combined expenses related to latency and energy consumption. This is achieved by adhering to certain restrictions on decision-making related to offloading and resource competition.

Shi et al. [23] investigated edge computing solutions for large-scale industrial Internet of Things (IIoT) devices in an integrated network of power line communications (PLC) and wireless communications. The researchers formulated the offloading optimization problem to maximize the total throughput and proposed a price matching-based offloading algorithm for quota tasks. Zhou et al. [24] studied a strategy to enhance computation offloading and service caching in smart grids based on edge computing. The primary objective was to reduce the overall cost of tasks within the system. The authors developed a mixed-integer nonlinear programming (MINLP) problem, which was decomposed into a master problem and a sub-problem. They utilized the gradient descent allocation algorithm and game theory to obtain the resource allocation scheme. Jiang et al. [25] studied the computational offloading problem for dense wireless sensor networks in smart grids. Considering the device-to-device (D2D) communication scenario, they established access selection and resource allocation optimization problems to minimize energy consumption under bandwidth and delay constraints and proposed a quantum-behaved particle swarm optimization (QPSO) algorithm to solve the problem. Wei et al. [19] established a delay and energy efficiency optimization problem for differentiated quality of service (QoS) demands and proposed a low-complexity task offloading algorithm with many-to-one two-sided matching.

In summary, some studies focus on UAV-assisted edge computing, such as [7,16,20,21,26,27], in which UAVs are usually required to act as edge servers or relays for collecting and processing task data. These schemes have the advantage of meeting the problem of data processing in the case of insufficient communication infrastructure and emergencies. However, the energy of UAVs is usually limited, and in the daily inspection of transmission lines, we prefer to ensure a longer inspection distance of UAVs with lower energy consumption. Additionally, some existing studies on end-to-edge computational offloading problems in power IoT, such as [19,23,24,25,28,29,30], cover a variety of PIoT application scenarios. However, PIoT involves scenarios such as power generation, transmission, and distribution, and the types of PIoT SDs, deployment methods, and network structures are different for each scenario. Therefore, the co-computing schemes for various scenarios are not generic. While some research has been dedicated to addressing power IoT edge-end collaborative computing, specialized research on transmission line inspection scenarios is still needed.

Considering the long laying distance, sparse distribution, and remote location of transmission lines, a single edge service node cannot cover the entire line area, and many densely deployed edge service nodes are unfavorable to the economy. Additionally, transmission line inspection is essential to ensure the safe operation of the power grid and the urgent need for data processing. Therefore, we design an edge computing model with multiple relay points using D2D communication and propose a multi-hop-based end-edge cooperative computing (MHCC) scheme based on the distribution characteristics of the transmission line infrastructure. The main contributions of this paper are as follows.

• To propose a multi-hop-based end-side cooperative computing (MHCC) model for transmission line inspection considering the long laying distance, sparse distribution, and remote location of transmission lines. This model has three kinds of computation methods: local computing, D2D computing, and ESC computing. ESC computing relies on multi-hop paths. In the MHCC model, the nearby resources are fully utilized to reduce transmission line inspection delays.
• To formulate a multi-hop task offloading optimization problem aiming to minimize the energy consumption of SDs while satisfying the task’s maximum delay constraint. The purpose is to improve task processing timeliness and reduce SD energy consumption. To the best of our knowledge, current research focuses on the study of UAV-assisted edge computing, which involves utilizing multiple UAVs as edge computing devices. However, this approach requires high-cost investment, particularly in scenarios such as transmission line inspections in remote areas.
• To design a joint Dijkstra and particle swarm optimization (JDPSO) algorithm to solve the proposed MHCC problem. Specifically, we utilize the Dijkstra algorithm to obtain the multi-hop path from SD to ESC and solve the D2D decision problem. The PSO algorithm obtains the computing offloading, power control, and resource allocation decisions. Finally, the performance of the proposed algorithm is evaluated through simulation experiments.

The rest of this paper is organized as follows. Section 2 presents the system model and formulates the problem. Section 3 develops the JDPSO algorithm. Simulations are carried out in Section 4, followed by the conclusion in Section 5.

2. System Model and Problem Formulation

2.1. Network Model

As shown in Figure 1, we consider an end-edge cooperative computing scenario for transmission line inspection. This scenario consists of multiple smart devices (SDs) and an edge server center (ESC) deployed in substations, new energy stations, or energy storage stations. Some inspection SDs, such as video monitoring terminals, are installed on power transmission towers. Some mobile SDs, such as UAVs, regularly patrol transmission lines. Suppose the system allows D2D communication, and the SDs can transmit data through wireless channels. When the SDs are distant from the ESC, neighboring SDs can act as relays, establishing a connection to the ESC through a multi-hop path. It is crucial to note that the inspection SDs in the system are primarily designed to complete inspections timely, efficiently, and accurately. Any self-interest among inspection SDs is negligible, underscoring the system’s cooperative nature. Whenever inspection SDs have available resources and energy and meet communication requirements, they are willing to share resources with other SDs.

Let the set of SDs be $\mathcal{M}=\{1,\dots ,m,\dots ,M\}$. Let ${\mathcal{N}}_m$ be the set of one-hop neighbor nodes of SD $m$. The SD $m$ randomly generates task $Tas{k}_m=\{s_m,c_m,d_m^{\max }\}, \forall m\in \mathcal{M}$ during the inspection, where $s_m$ denotes the size of $Tas{k}_m$ (in bits), and $c_m$ denotes the amount of computation required to one bit of data (in cycles/bit). The total amount of computation required to complete $Tas{k}_m$ is $s_m{c}_m$ (in cycles). $d_m^{\max }$ is the maximum allowable delay of $Tas{k}_m$. In this model, $Tas{k}_m$ can be executed locally or offloaded. Let ${\alpha }_m\in \{0,1,2\}, \forall m\in \mathcal{M}$ denote the decision variable of $Tas{k}_m$ for SD $m$. ${\alpha }_m=0$ denotes that SD $m$ computes its own task $Tas{k}_m$. If ${\alpha }_m=1$, $Tas{k}_m$ will be executed by the neighboring nodes of SD $m$ by one-hop D2D link. Due to the limited resources and battery capacity of SDs, this paper assumes that any neighboring node can only serve for only one SD. ${\alpha }_m=2$ represents the ESC computing where SD $m$ offloads the task to the ESC via a multi-hop path. The mathematical notations are shown in

Table 1. Mathematical notation.

Notation	Description
$M$	Number of SDs
$\mathcal{M}$	Set of SDs
$m$	Index of SDs
${\mathcal{N}}_m$	Set of one-hop neighbor nodes of SD $m$
$k$, $i$, $l$	The SDs in $\mathcal{M}$
$m^{\prime }$, $k^{\prime }$, $i^{\prime }$, $l^{\prime }$	The one-hop neighbor node of SD $m$, SD $k$, SD $i$, and SD $l$
$Tas{k}_m$	Task to be processed generated by SD $m$
$s_m$	The size of $Tas{k}_m$
$c_m$	The amount of computation required to one bit of data for $Tas{k}_m$
$d_m^{\max }$	The maximum allowable delay of $Tas{k}_m$
${\alpha }_m$	The decision variable of $Tas{k}_m$
$f_m$, $f_{m^{\prime }}$, $f_e$	The computing capacity of SD $m$, SD $m^{\prime }$, and the ESC
$\epsilon$	The energy coefficient
$E_m^0$, $E_{m^{\prime }}^0$	The operating energy consumption of SD $m$ and SD $m^{\prime }$ per unit of time.
$D_{Tas{k}_m}^{local}$, $E_{Tas{k}_m}^{local}$	The delay and energy consumption of $Tas{k}_m$ for local computing
${\gamma }_{m,m^{\prime }}$, ${\gamma }_{k,k^{\prime }}$	The decision variable for direct device-to-device communication
$D_{m,m^{\prime }}^{tr}$, $D_{k,k^{\prime }}^{tr}$	The transmission delay between two adjacent SDs
$D_{m,m^{\prime }}^c$	The computation delay of $m^{\prime }$ to process $Tas{k}_m$
$D_{Tas{k}_m}^{d2d}$, $E_{Tas{k}_m}^{d2d}$	The delay and energy consumption of $Tas{k}_m$ for D2D computing
$r_{m,m^{\prime }}$	The wireless communication rate between SD $m$ and SD $m^{\prime }$
$B$	The channel bandwidth
$p_m^{tr}$, $p_{m,\max }^{tr}$	The transmission power and maximum transmission power of SD $m$
$h_{m,m^{\prime }}$	The channel gain between SD $m$ and SD $m^{\prime }$
${\sigma }^2$	The noise power
$L_m$, $L_i$	The multi-hop path of SD $m$ and SD $i$
$D_{Tas{k}_m}^{etr}$	The multi-hop transmission delay of $Tas{k}_m$ in ESC computing
$D_{Tas{k}_m}^{ec}$	The computation delay of the ESC to process $Tas{k}_m$
$D_{Tas{k}_m}^{esc}$, $E_{Tas{k}_m}^{esc}$	The delay and energy consumption of $Tas{k}_m$ for ESC computing
$\left(k,k^{\prime }\right)$	A segment between two neighboring nodes in the multi-hop path $L_m$
$\phi \left({\alpha }_m,\alpha \right)$	An auxiliary function
$D_{Tas{k}_m}$, $E_{Tas{k}_m}$	The delay and energy consumption corresponding to $Tas{k}_m$
${\lambda }_m$	The penalty factor
$Fitness$, $Penalty$	The fitness and penalty function of system
${\mathcal{P}}_1$, ${\mathcal{P}}_2$	The denotes of the multi-hop cooperative computing problem

.

2.2. Computingl Model

As mentioned earlier, there are three computation modes for tasks: local computing, D2D computing, and ESC computing. D2D computation means that the SDs can offload the task to the neighboring nodes through one-hop D2D communication, and ESC computation means that the SDs can offload the task to the ESCs through one-hop or multi-hop communication.

2.2.1. Local Computing

When an SD chooses local computing, ${\alpha }_m=0$. Let the computing capacity of SD $m\in \mathcal{M}$ be $f_m$. Then, the local computing delay of $Tas{k}_m$ is

$$D_{Tas{k}_m}^{local}=\frac{s_m{c}_m}{f_m}.$$

(1)

The energy consumption corresponding to $Tas{k}_m$ is

$$E_{Tas{k}_m}^{local}=\epsilon {f_m}^2{s}_m{c}_m+E_m^0{D}_{Tas{k}_m}^{local},$$

(2)

where $\epsilon$ is the energy coefficient, which is related to the chip structure [31]. $E_m^0$ indicates the operating energy consumption of SD $m$ per unit of time, which may vary among SDs. The video monitoring terminals on transmission towers usually have a relatively fixed working mode, and their energy consumption per unit of time is approximated as a constant. According to [32], the energy consumption of mobile SDs, such as UAVs, is related to parameters such as moving speed and mass, assuming that the SD $m$ moves at a constant speed with rate and the SD’s mass remains unchanged during the inspection process, so the energy consumption of the mobile SD per unit of time can also be approximated as a constant.

2.2.2. D2D Computing

When SD $m$ selects D2D computing, ${\alpha }_m=1$. As mentioned above, SD $m$ offloads $Tas{k}_m$ to its neighbor node $m^{\prime }\in {\mathcal{N}}_m$ by a one-hop D2D link. Let ${\gamma }_{m,m^{\prime }}\in \left\{0,1\right\}$ be the decision variable for direct device-to-device (D2D) communication. If ${\gamma }_{m,m^{\prime }}=1$, an SD establishes a D2D connection with SD $m^{\prime }$. If ${\gamma }_{m,m^{\prime }}=0$, no D2D connection is established. When an SD acts as a D2D computing node, it can only provide computing services to one of its neighbor nodes. It needs to satisfy ${\displaystyle {\sum }_{m^{\prime }\in {\mathcal{N}}_m}{\gamma }_{m,m^{\prime }}=1}$. Regarding D2D computing, the delay of $Tas{k}_m$ includes the transmission delay between SD $m$ and SD $m^{\prime }$ (i.e., $D_{m,m^{\prime }}^{tr}$) and the computation delay of $m^{\prime }$ (i.e., $D_{m,m^{\prime }}^c$).

$$D_{Tas{k}_m}^{d2d}={\gamma }_{m,m^{\prime }}\left(D_{m,m^{\prime }}^{tr}+D_{m,m^{\prime }}^c\right)=\frac{{\gamma }_{m,m^{\prime }}{s}_m}{r_{m,m^{\prime }}}+\frac{{\gamma }_{m,m^{\prime }}{s}_m{c}_m}{f_{m^{\prime }}}$$

(3)

where $r_{m,m^{\prime }}$ is the wireless communication rate between SD $m$ and SD $m^{\prime }$, and $f_{m^{\prime }}$ is the computing capacity of SD $m^{\prime }$.

$$r_{m,m^{\prime }}=B{\log }_2\left(1+\frac{p_m^{tr}{h}_{m,m^{\prime }}}{{\sigma }^2}\right)$$

(4)

where $B$ is the channel bandwidth, $p_m^{tr}\le p_{m,\max }^{tr}$ denotes the transmission power of SD $m$, $p_{m,\max }^{tr}$ is the maximum transmission power, $h_{m,m^{\prime }}$ represents the channel gain between SD $m$ and SD $m^{\prime }$, and ${\sigma }^2$ is the noise power.

The energy consumption associated with $Tas{k}_m$ includes SD $m$’s D2D transmission energy consumption, SD $m$’s operation energy consumption during transmission, the computation energy consumption of SD $m^{\prime }$, and the operation energy consumption of SD $m^{\prime }$ during executing $Tas{k}_m$. Since the receiver can operate in a small-signal state and the reception energy consumption is usually smaller than the transmission and computation energy consumption, this paper does not consider the reception energy consumption of SD $m^{\prime }$.

$$E_{Tas{k}_m}^{d2d}={\gamma }_{m,m^{\prime }}\left(D_{m,m^{\prime }}^{tr}{p}_m^{tr}+E_m^0{D}_{m,m^{\prime }}^{tr}\right)+{\gamma }_{m,m^{\prime }}\left(\epsilon {f_{m^{\prime }}}^2{s}_m{c}_m+E_{m^{\prime }}^0{D}_{m,m^{\prime }}^c\right)$$

(5)

where $p_m^{tr}$ is the transmission power of SD $m$ and $E_{m^{\prime }}^0$ indicates the operating energy consumption of SD $m^{\prime }$ per unit of time.

2.2.3. ESC Computing

${\alpha }_m=2$ when the SD $m$ uses ESC computing. SD $m$ offloads $Tas{k}_m$ to the ESC via the multi-hop path $L_m$. The multi-hop transmission path diagram is shown in Figure 2. The delay of $Tas{k}_m$ in ESC computing includes multi-hop transmission delay $D_{Tas{k}_m}^{etr}$ and the ESC’s computation delay $D_{Tas{k}_m}^{ec}$.

$$D_{Tas{k}_m}^{esc}=D_{Tas{k}_m}^{etr}+D_{Tas{k}_m}^{ec}={\displaystyle \sum _{\left(k,k^{\prime }\right)\in L_m}{\gamma }_{k,k^{\prime }}{D}_{k,k^{\prime }}^{tr}}+\frac{s_m{c}_m}{f_e}={\displaystyle \sum _{\left(k,k^{\prime }\right)\in L_m}\frac{{\gamma }_{k,k^{\prime }}{s}_m}{r_{k,k^{\prime }}}}+\frac{s_m{c}_m}{f_e}$$

(6)

where $\left(k,k^{\prime }\right)$ denotes a segment between two neighboring nodes in the multi-hop path $L_m$. $f_e$ is the ESC’s computing capacity. The ESC can serve multiple SDs at the same time and its computing capacity is sufficient; i.e., each SD obtains resources for $f_e\gg f_m$.

For the ESC computing, each relay node $k^{\prime }$ in multi-hop path $L_m$ consumes energy due to its participation in the transmission of $Tas{k}_m$, including D2D transmission energy consumption and operation energy consumption during transmission. Similarly, we do not consider the relay nodes’ reception energy consumption. As we are more concerned with the energy consumption of SD, this model does not account for the energy consumption of the ESC.

$$E_{Tas{k}_m}^{esc}={\displaystyle \sum _{\left(k,k^{\prime }\right)\in L_m}{\gamma }_{k,k^{\prime }}{D}_{k,k^{\prime }}^{tr}{p}_k^{tr}}+{\displaystyle \sum _{\left(k,k^{\prime }\right)\in L_m}{\gamma }_{k,k^{\prime }}{D}_{k,k^{\prime }}^{tr}{E}_k^0}$$

(7)

where ${\gamma }_{k,k^{\prime }}$ is the decision variable, $p_k^{tr}$ is the transmission power of SD $k$, and $E_k^0$ indicates the operating energy consumption of SD $k$ per unit of time.

For ease of presentation, we introduce the function $\phi \left({\alpha }_m,\alpha \right)$, where $\alpha \in \{0,1,2\}$.

$$\phi \left({\alpha }_m,\alpha \right)=\{\begin{array}{ll}0,& {\alpha }_m\ne \alpha \\ 1,& {\alpha }_m=\alpha \end{array}$$

(8)

To summarize, the delay and energy consumption corresponding to $Tas{k}_m$ can be expressed by the following equations:

$$D_{Tas{k}_m}=\phi \left({\alpha }_m,0\right)D_{Tas{k}_m}^{local}+\phi \left({\alpha }_m,1\right)D_{Tas{k}_m}^{d2d}+\phi \left({\alpha }_m,2\right)D_{Tas{k}_m}^{esc},$$

(9)

$$E_{Tas{k}_m}=\phi \left({\alpha }_m,0\right)E_{Tas{k}_m}^{local}+\phi \left({\alpha }_m,1\right)E_{Tas{k}_m}^{d2d}+\phi \left({\alpha }_m,2\right)E_{Tas{k}_m}^{esc}.$$

(10)

2.3. The Impact of Assumptions in the Model

Allowing D2D communication is essential for establishing the multi-hop model in this paper. In scenarios such as transmission line inspection, some SDs may be situated in areas with no or weak base station coverage and may require relay nodes to facilitate communication. D2D links can facilitate information exchange and data transmission between SDs.

The concept of self-interest in a device is one of the critical points in cooperative computing. Considering user preferences, connection security, and payment, the user equipment may not be willing to share its resources with others in mobile networks and the internet of vehicles. However, in transmission line inspection, both the video monitoring terminal on the transmission tower and the UAVs share the common goal of completing the line inspection effectively. The SDs in the PIoT must undergo strict licensing and certification processes before being installed and used. As a result, we can ignore the self-interest of these devices.

For D2D computing, if an SD acts as a service node, it can only provide computational services to one neighbor node. This assumption aims to avoid multiple neighbor nodes selecting the same SD simultaneously, which may overload that SD. If this assumption is not considered, ${\displaystyle {\sum }_{m^{\prime }\in {\mathcal{N}}_m}{\gamma }_{m,m^{\prime }}=1}$ is not necessary.

We suppose that the UAVs move at a constant speed, which aims to simplify the model. This assumption allows us to focus our goal on the offloading decision process rather than mobility analysis for mobile devices, since the UAVs usually fly at low speeds.

2.4. Problem Formulation

Inspection SDs are commonly used in the field and usually operate using solar energy and batteries. The amount of energy consumed directly affects the working hours of SDs. SDs prioritize energy consumption over delay to ensure the device can work continuously and stably. Thus, we formulate a multi-hop cooperative computing (MHCC) problem, ${\mathcal{P}}_1$, to optimize energy consumption while ensuring processing delays of inspection tasks. ${\mathcal{P}}_1$ aims to minimize the system’s energy consumption while meeting the delay constraints.

$$\begin{array}{ll}{\mathcal{P}}_1:& \underset{{\alpha }_m,{\gamma }_{m,m^{\prime }},f_m,p_m^{tr}}{\min }{\displaystyle \sum _{m\in \mathcal{M}}{E}_{Tas{k}_m}}\\ s.t.& C1: D_{Tas{k}_m}\le d_m^{\max }, \forall m\in \mathcal{M}\\ & C2: {\alpha }_m\in \{0,1,2\}, \forall m\in \mathcal{M}\\ & C3: {\gamma }_{m,m^{\prime }}\in \{0,1\}, \forall m\in \mathcal{M}, m^{\prime }\in {\mathcal{N}}_m\\ & C4: {\displaystyle {\sum }_{m^{\prime }\in {\mathcal{N}}_m}{\gamma }_{m,m^{\prime }}}=1, \forall m\in \mathcal{M}\\ & C5: p_m^{tr}\le p_{m,\max }^{tr}, \forall m\in \mathcal{M}\end{array}$$

(11)

where $C1$ shows the delay of $Tas{k}_m$ cannot exceed the maximum delay. $C2$, $C3$, and $C5$ are the variable range constraints, and $C4$ indicates the SDs can serve one and only one of its neighbor nodes when SDs act as a computing node. The constrained optimization problem ${\mathcal{P}}_1$ is a mixed-integer nonlinear programming (MINLP) problem that is NP-hard. To solve ${\mathcal{P}}_1$, we utilize the penalty function method to formulate the fitness function similar to the literature [33]:

$$Fitness={\displaystyle \sum _{m\in \mathcal{M}}{E}_{Tas{k}_m}}+Pennalty$$

(12)

$$Penalty={\displaystyle \sum _{m\in \mathcal{M}}{\lambda }_m\left[\max \left(0,D_{Tas{k}_m}-d_m^{\max }\right)\right]}$$

(13)

${\lambda }_m$ is the penalty factor. The constraints $C2$ to $C5$ involve the range of values of the variables, which can be guaranteed during the programming process and do not need to be added to the penalty function. Therefore, the constrained optimization problem ${\mathcal{P}}_1$ can be transformed into ${\mathcal{P}}_2$.

$$\begin{array}{ll}{\mathcal{P}}_2:& \underset{{\alpha }_m,{\gamma }_{m,m^{\prime }},f_m,p_m^{tr}}{\min }Fitness\\ s.t.& C2: {\alpha }_m\in \{0,1,2\}, \forall m\in \mathcal{M}\\ & C3: {\gamma }_{m,m^{\prime }}\in \{0,1\}, \forall m\in \mathcal{M}, m^{\prime }\in {\mathcal{N}}_m\\ & C4: {\displaystyle {\sum }_{m^{\prime }\in {\mathcal{N}}_m}{\gamma }_{m,m^{\prime }}}=1, \forall m\in \mathcal{M}\\ & C5: p_m^{tr}\le p_{m,\max }^{tr}, \forall m\in \mathcal{M}\end{array}$$

(14)

3. Algorithm Design

It has been shown that ${\mathcal{P}}_2$ is a mixed-integer nonlinear programming problem. This type of problem is generally challenging to solve. However, a swarm intelligence algorithm is a common approach that can provide an approximate solution within a limited number of iterations. Particle swarm optimization is an intelligent optimization algorithm that mimics the feeding behavior of bird flocks. The primary goal is to find the best possible solution by promoting collaboration and sharing of information among individuals in the group. Each particle has speed and position characteristics in PSO [33,34]. PSO is a stable and low-complexity algorithm widely used in various application areas, such as combinatorial optimization, function optimization, neural network training, fuzzy system control, and nonlinear integer programming problems. Thus, we propose a joint Dijkstra and particle swarm optimization (JDPSO) algorithm to solve ${\mathcal{P}}_2$.

Solving ${\mathcal{P}}_2$ requires solving computing offloading decisions, D2D decisions, power control, and computational resource allocation simultaneously. We decompose the problem into two sub-problems: the D2D decision sub-problem and the offloading decision sub-problem.

3.1. D2D Decision

The purpose of the D2D decision problem is to obtain the transmission paths for the ESC computing. We use the Dijkstra algorithm to obtain the shortest path from SD to ESC, i.e., a table of potential multi-hop paths.

The Dijkstra algorithm can determine the shortest path between a source node and a target node in a single-source mapping environment by constructing a shortest path tree step by step. It is assumed that the weight between two nodes represents the distance between them. The Dijkstra algorithm begins by marking the source node as visited and then selects the node closest to the source as the current node. Then, the current node is marked as visited, and the distances of its neighboring nodes are updated. This process continues until all nodes have been visited. The pseudo-code of the Dijkstra algorithm is shown in Algorithm 1. The Dijkstra algorithm generates the potential multi-hop paths table, allowing SD to find the next hop D2D node quickly.

Algorithm 1. Dijkstra algorithm
1:	Input: The distribution of SDs.
2:	Output: The shortest path from SD to ESC.
3:	Initialize system parameters: adjacent matrix with weights $W$, numbering of the source node and numbering of the target nodes.
4:	Set the label of the source node $q_0$ to zero, i.e., $L_D(q_0)=0$, and the labels of all other nodes are set to infinity $L_D(-q_0)=\infty$, where $-q_0$ denotes the nodes except $q_0$.
5:	Store the visited nodes in the array $Q$, which only contains $q_0$ initially.
6:	Find an unvisited node $x$ such that $L_D(x)$ is minimum.
7:	Add $x$ to $Q$, i.e., $x$ has now been visited.
8:	Update $L_D(y)=\min \left\{L_D(y),L_D(x)+W(x,y)\right\}$ for all $y$ adjacent to $x$ such that $y$ is not visited, where $W(x,y)$ is the weights between $x$ and $y$.
9:	Repeat lines 5 to 8 until all the nodes are visited.
10:	Retrieve the array $Q$, having shortest path from $q_0$ to all other nodes.
11:	Store the shortest path from each SD to the ESC, i.e., the potential multi-hop paths table, until the next update.

3.2. Offloading Decision

For the offloading decision problem, we use the PSO algorithm to obtain the computational offloading decision, the power control, and the computational resource allocation decision, i.e., solve for the variables ${\alpha }_m$, ${\gamma }_{m,m^{\prime }}$, $f_m$, and $p_m^{tr}$.

The potential decision for SD $m$ is represented as $X_m=[{\alpha }_m, {\gamma }_{m,m^{\prime }}, f_m, p_m^{tr}]$, which denotes the position of particle $m$ in PSO. Each particle moves through the search space with a specific direction and velocity, adjusting its position and velocity based on individual and global experience. The equations for updating the particle velocity and position are as follows.

$$V_m^{t+1}=\varpi V_m^t+{\mu }_1{\zeta }_1\left(p_{{best}_m}-X_m^t\right)+{\mu }_2{\zeta }_2\left(g_{best}-X_m^t\right)$$

(15)

$$X_m^{t+1}=X_m^t+V_m^{t+1}$$

(16)

where $V_m^t$ and $X_m^t$ are the velocity and the position of particle $m$ at the $t$-th iteration. $V_m^{t+1}$ and $X_m^{t+1}$ denote the velocity and the position of particle $m$ at the $(t+1)$-th iteration. $\varpi$ represents the inertia factor. ${\mu }_1$ and ${\mu }_2$ are random values in the interval [0,1]. ${\zeta }_1$ and ${\zeta }_2$ are the acceleration constants. $p_{{best}_m}$ is the best position of the previous iteration of particle $m$. $g_{best}$ is the global best position.

During the initialization of particle positions, it is essential to initialize the offloading decision, denoted as ${\alpha }_m$, and then proceed to initialize ${\gamma }_{m,m^{\prime }}$, $f_m$, and $p_m^{tr}$ based on the offloading decision. When SD $m$ selects ESC computing, it is necessary to load the potential multi-hop paths table obtained from Algorithm 1 to determine ${\gamma }_{m,m^{\prime }}$.

The pseudo-code of JDPSO is shown in Algorithm 2.

Algorithm 2. JDPSO
1:	Input: System parameters: the number and location of SDs, the transmission parameters, and the task parameters (size, the amount of computation, and maximum delay of tasks),
2:	Output: ${\alpha }_m$, ${\gamma }_{m,m^{\prime }}$, $f_m$, and $p_m^{tr}$
3:	Initialize the iteration parameters, particle parameters, ${\alpha }_m$, ${\gamma }_{m,m^{\prime }}$, $f_m$, $p_m^{tr}$
4:		if ${\alpha }_m=2$
5:			Load the potential multi-hop paths table obtained by Algorithm 1 to determine ${\gamma }_{m,m^{\prime }}$.
6:		end if
7:	Calculate the fitness value of each particle, and record the optimal particle.
8:	for iteration < maximum number of iterations
9:		for each search particle
10:			Update the position of the current particle.
11:			if ${\alpha }_m=2$
12:				Load the potential multi-hop paths table obtained by Algorithm 1 to determine ${\gamma }_{m,m^{\prime }}$.
13:			end if
14:			Check if any particle goes beyond the search space and amend it. Ensure that conditions C2–C5 in ${\mathcal{P}}_2$ are met.
15:			Calculate the fitness of each particle.
16:			Update the optimal particle if there is a better solution.
17:		end
18:	end
19:	Return the optimal particle and MHCC scheme (i.e., ${\alpha }_m$, ${\gamma }_{m,m^{\prime }}$, $f_m$, and $p_m^{tr}$).

4. Numerical Results and Analysis

4.1. Simulation Setup

With a substation in Jilin Province as the center, the area within a radius of 2 km selects four transmission lines in four different directions. Each line contains fifteen transmission towers, each with an intelligent inspection device. Each transmission line is meticulously inspected by a UAV. The simulation scene diagram is shown in Figure 3. The numbers in the figure indicate the serial number of the SDs. $(sit{e}_x,sit{e}_y)$ represents the coordinates of SDs and ESC. Since the ESC is located at the origin, $sit{e}_x$ and $sit{e}_y$ imply the horizontal and vertical distances (in meters) between the SD and the ESC. The path loss model is $140.7+36.7lo{g}_{10}(d) \mathrm{dB}$, where $d$ is the distance between SDs. We run the simulations on a laptop equipped with an Intel Core i5-8250U 1.8GHz processor and 16GB of RAM. The simulation software we use is Matlab R2023b.

Table 2. Simulation parameters.

Parameters	Value
Number of SDs	64, (4 UAVs and 60 video monitors)
Number of ESCs	1
The computing capacity of SDs $f_m$	$\left\{1,1.2,1.5\right\}\mathrm{GHz}$
The computing capacity of ESC $f_e$	25 GHz
The maximum transmission power of SDs $p_{m,\max }^{tr}$	23 dBm
The wireless channel bandwidth	180 kHz
The number of channels occupied by each SD	[3,12]
The noise power ${\sigma }^2$	$3.98\times {10}^{-21}$
The energy coefficient $\epsilon$	${10}^{-26}$
The operating energy consumption of SDs $E_m^0$	${10}^4$ J
The transmission rate between SD and ESC	50 Mbps
The size of task data $s_m$	$\left\{0.2,0.5,0.8,1\right\} \mathrm{Mb}$
The computation amount required to one bit of data $c_m$	1000 cycles
The inertia factor $\varpi$	1
The acceleration constants ${\zeta }_1$, ${\zeta }_2$	2
The particle population size	200
The maximum number of iterations	1000

summarizes the main simulation parameters.

4.2. System Performance Analysis

To evaluate the performance of the proposed JDPSO algorithm, we compared it with five other baseline methods, including genetic algorithms (GAs), random search algorithm (RSA), the salp swarm algorithm (SSA) [35], the moth–flame optimization algorithm (MFO) [36], the dingo optimization algorithm (DOA) [37], and all local computing (ALC). GA is a widely used swarm intelligence optimization algorithm and serves as a common baseline algorithm. GA is applied in computational offloading optimization, as mentioned in [38,39]. SSA, MFO, and DOA have gained popularity as swarm intelligence optimization algorithms in recent years. Some literature has introduced novel computational offloading schemes based on these algorithms [40,41,42,43]. Random search algorithm (RSA) is a simple stochastic selection algorithm known for its fast optimization search speed. In the RSA algorithm, the decision-making process of the SDs is random, and the optimal solution is saved based on the fitness value. Afterward, all the SDs update their decisions randomly. The algorithm iterates several times until a stable optimal solution is found by comparing the current and historical optimal solutions. On the other hand, in the ALC algorithm, all SDs complete their task by the local computing unit.

Figure 4 depicts the JDPSO algorithm’s convergence performance. The convergence curves of various algorithms are compared under identical initial population, population size, and number of iterations. Figure 4 illustrates that JDPSO achieves faster convergence and has a better optimum than GA, RSA, SSA, MFO, and DOA. JDPSO weighs individual optimality and global optimality in the position updating process. Notably, the fitness value of the optimal solution of JDPSO declines by 61.24%, 53.55%, 59.32%, 53.89%, and 28.26% compared to GA, RSA, SSA, MFO, and DOA, respectively. GA converges prematurely at about the 300th iteration, which indicates that the similarity of individuals increases with the number of iterations, and the diversity of the population decreases. RSA randomly updates the SD’s decision at each iteration and does not rely on the best solution obtained, which limits RSA’s local search capability. For ${\mathcal{P}}_2$, SSA lacks effective strategies to escape local optima, which leads to less stable results in its optimization search. The MFO’s utilization of spiral search enhances its local search capabilities. However, this limits the MFO’s ability to perform effective global searches, especially in complex problems. DOA converges slower after the 100th iteration and gradually falls into local optimality. Figure 5 compares the energy consumption of the optimal solution obtained by each algorithm. The results show that the JDPSO’s optimal solution has 54.49%, 47.83%, 54.47%, 49.10%, and 25.85% less energy consumption than the GA, RSA, SSA, MFO, and DOA, respectively. Therefore, the JDPSO provides a more energy-efficient solution. Figure 4 and Figure 5 demonstrate the strong convergence of JDPSO and the ability to obtain superior solutions through the iterative process.

Figure 6 compares various algorithms based on the number of SDs that choose local computing, D2D computing, and ESC computing. According to the results, in the JDPSO, 7 SDs chose local computing, 8 SDs (12.50%) chose D2D computing, and 49 SDs (76.56%) chose ESC computing. In JDPSO and DOA, there are significantly more SDs for ESC computing compared to D2D computing and local computing. The number of ESC computing SDs is similar in GA, RSA, SSA, and MFO. The number of local computing and ESC computing SDs are similar in GA, RSA, and SSA. In contrast, the number of local computing and D2D computing SDs are similar in MFO. In addition, Figure 4 and Figure 5 show that the energy consumption of JDPSO and DOA are significantly lower than that of other algorithms. This suggests that energy savings can be achieved by offloading more tasks to the ESC when the ESC has ample computational capacity (in this paper, ESC’s computational capacity is 25 GHz, much higher than that of SDs). A detailed comparison of the data is provided in

Table 3. Number of SDs obtained by different algorithms for local computation, D2D computation and ESC computation.

	JDPSO	GA	RSA	SSA	MFO	DOA
Local Computing	7	23	24	22	19	13
D2D Computing	8	13	16	21	19	16
ESC Computing	49	28	24	21	26	35

. The JDPSO algorithm has the highest percentage of cooperative computation, around 90%. In contrast, the GA, RSA, SSA, MFO, and DOA have offloading percentages of 64.06%, 62.50%, 65.63%, 70.31%, and 79.69%, respectively.

In Figure 7, we compared the average fitness and average energy consumption of the JDPSO with varying computation capacities of the ESC. The results indicate that as the computation capacity of the ESC increases, the fitness value and energy consumption decrease. When the computational capacity of the ESC is 5 GHz, the energy consumption of SDs is higher than that of others. This is because ESC computing leads to additional latency, and as a result, SDs prefer local computing or D2D computing when the computational power of ESC is low. In local computing and D2D computing, SDs consume a lot of computational energy. However, when the computation capacity of the ESC exceeds 20 GHz, the fitness value and energy consumption tend to stabilize, which implies that continuously increasing the computational capacity of the ESC has a limited effect on the system’s performance.

To evaluate the algorithm’s long-term performance, we experimented 100 times. The fitness and average fitness values of each algorithm are depicted in Figure 8. The average fitness values of 100 repeated experiments for the JDPSO, GA, RSA, SSA, MFO, and DOA are as follows: 107.6173, 283.3368, 230.905, 275.6819, 247.4765, and 155.6651, respectively. The JDPSO’s performance is superior to that of the GA, RSA, SSA, MFO, and DOA, with fitness reductions of 62.02%, 53.39%, 60.96%, 56.51%, and 30.87%, respectively. The results show that JDPSO can achieve a long-term stable optimization performance. We now compare the system’s energy consumption and delay among different algorithms, as illustrated in Figure 9 and Figure 10. JDPSO decreases the system’s energy consumption by 68.31% and delay by 62.88% compared to the all-local computing scheme. In practice, some inspection SDs currently use all-local computing. The comparison results show that the JDPSO scheme outperforms the all-local computing scheme regarding energy consumption and delay. For the GA, RSA, SSA, MFO, and DOA, the system’s energy consumption in the JDPSO decreases by 56.30%, 48.56%, 78.87%, 50.89%, 30.85%, and the delay decreases by 50.69%, 42.78%, 58.67%, 44.84%, and 10.22%. This suggests that JDPSO is capable of significantly reducing the system’s energy consumption and delay. Inspection SDs for transmission lines are generally powered by solar energy and batteries, which often fail to obtain stable functions due to sunlight, weather changes, etc. Low power consumption has become a necessary attribute of inspection SDs. The proposed MHCC scheme and JDPSO algorithm can further reduce the system’s energy consumption, which is crucial for transmission line inspection. Figure 11 shows the shortest path topology for each SD to the ESC. The node numbered 1 in the figure is the ESC, and the other nodes are numbered corresponding to Figure 3. The numbers in the Figure 11 indicate the serial number of the SDs.

5. Conclusions

In this paper, we investigate multi-hop end-edge cooperative computation in transmission line inspection scenarios with the aim of solving the current problem of inefficient manual processing of inspection data and disadvantages of cloud computing. We formulate an MHCC problem to minimize the energy consumption of system SDs with delay constraints. We decompose the MHCC problem into the D2D decision sub-problem and the offloading decision sub-problem, and develop a joint Dijkstra and particle swarm optimization algorithm. Simulation results show that the proposed scheme can significantly reduce the system’s energy consumption and delay. Lower energy consumption leads to longer inspection distances, thereby improving the efficiency of intelligent daily inspections of transmission lines. Additionally, for future work, it is worth studying the offloading of tasks from a smart device to multiple auxiliary computing devices simultaneously. This may require a decomposition and prioritization of tasks.