Multi-Objective Edge Node Deployment Method Based on Improved Heuristic Algorithms for Smart Mines

Abstract

As the number of intelligent devices in mining environments increases, the transmission time for large datasets, including equipment status and environmental parameters, also rises. This increase leads to longer response times for service requests, making it difficult to meet the equipment’s real-time requirements. Edge computing effectively addresses the demands for low latency and high performance. However, the deployment of edge nodes can negatively affect overall service performance due to resource limitations and node heterogeneity. In this paper, we propose two node deployment strategies: an improved genetic algorithm (IBGA) for fixed device scenarios and an improved sand cat swarm optimization algorithm (ISCSO) for mobile device scenarios, both accounting for the mobility characteristics of the devices. Additionally, we developed a simulation platform based on a production line system and an intelligent patrol vehicle to evaluate the proposed method’s effectiveness. The experimental results show that the IBGA and ISCSO algorithms effectively reduce task delay and deployment cost. Both deployment methods outperform the benchmark algorithms and offer better service quality assurance.

1. Introduction

The mining environment is inherently complex, marked by high temperatures, humidity, distinct geological conditions, confined spaces, and numerous obstacles. These conditions significantly heighten the risks of hazards such as collapses, fires, and explosions, posing considerable challenges to the safety of both workers and equipment [1]. Given these factors, implementing a comprehensive monitoring system for the mining environment is essential. However, the uneven terrain in mining areas induces significant vibrations in the sensing equipment, which compromises the accuracy of the collected data. The accumulation of sand and dust also increases the risk of equipment failure. In addition, the high-temperature and humid conditions necessitate careful consideration of the temperature resistance of the devices. The mountainous topography may further weaken signal strength. Consequently, the application of multi-sensor fusion technology becomes critical, requiring the deployment of multiple sensors to achieve comprehensive, multi-attribute detection of mechanical equipment within mining environments. Mining operations inherently produce time-sensitive data that require immediate processing to ensure the safety of personnel and assets. However, the need for real-time processing demands significant computational power and storage capacity, which often surpass the capabilities of traditional computing systems [2].

To address these challenges, we utilize the vast computing and storage resources provided by cloud computing to handle large datasets. However, this approach faces challenges due to the substantial distance between the sensors and the cloud server, along with constraints in network bandwidth. The large volume of data transmitted to the cloud leads to network congestion and significant transmission delays, making it insufficient for fulfilling the real-time requirements of latency-sensitive tasks. In response to these challenges, edge computing has emerged as a complementary paradigm to cloud computing, enabling data processing closer to the source. In mining operations, edge nodes, equipped with essential computing, storage, and network communication capabilities, are strategically deployed near the equipment to ensure timely responsiveness to real-time tasks [3,4]. Despite the clear advantages of edge computing in managing large datasets, the deployment of critical edge nodes presents persistent challenges. Several factors contribute to this complexity. First, there is a significant divergence in the hardware architectures and software configurations across different sensing devices. Second, the network interactions are highly heterogeneous, involving not only device-to-device communication but also interactions between devices, edge nodes, and sensors [5,6]. Third, edge nodes from different manufacturers exhibit disparities in computing power, storage capacities, and communication capabilities [7]. Therefore, the efficient deployment of edge nodes at the network edge is essential for implementing edge computing in mining operations. This approach is also critical for ensuring service quality via the edge computing platform [8].

The mechanical equipment in the mine environment is divided into fixed equipment and mobile equipment [9]. Fixed equipment primarily includes large, immovable devices such as conveyors, stationary crushers, and vibrating screens. The operational states of these devices are complex and variable, requiring the deployment of various sensors to collect multi-faceted data. This imposes periodic computational loads on the processing nodes. Additionally, structural and layout differences among devices necessitate different sensor types to meet specific requirements. The available locations for edge node deployment also vary, and the flexibility of deployment schemes remains limited. Mobile equipment primarily comprises devices that necessitate mobility during mining operations. This category includes unmanned excavators for material extraction and transport vehicles involved in logistics. These machines typically follow fixed trajectories between material sites and handling equipment, with tasks often adhering to cyclical patterns. Prompt processing of task requests from mobile devices is crucial to maintaining the safety and efficiency of the overall operation.

In the deployment of edge nodes within mining environments, the number of nodes is closely linked to the number of operational devices and sensors. Edge computing facilitates timely real-time task responsiveness, significantly reducing task execution latency. However, it is crucial to account for the cost implications of node deployment throughout the execution process. Current research predominantly focuses on the conceptual placement of edge nodes at the network periphery or near data sources, without offering concrete, context-specific placement strategies. Additionally, the distinct characteristics of mining environments introduce unique challenges, making certain deployment solutions impractical for these applications. Variations in deployment strategies can lead to disparities in deployment costs, server resource utilization, network reliability, and access delays, highlighting the necessity of precise, context-sensitive deployment plans [10]. In the mining context, the strategic deployment of edge nodes to enhance real-time processing capabilities while simultaneously reducing latency and costs remains a critical research area. The primary contributions of this paper are outlined as follows:

• This study introduces a comprehensive system model for the deployment of edge nodes. The mining machinery is categorized into fixed and mobile equipment, and detailed edge node deployment models are provided for each scenario based on their specific operational requirements.
• In this paper, we propose two node deployment strategies: an improved genetic algorithm (IBGA) for fixed device scenarios and an improved sand cat swarm optimization algorithm (ISCSO) for mobile device scenarios, both accounting for the mobility characteristics of the devices.
• Simulation platforms were established in two distinct scenarios, utilizing a production line system and an inspection trolley. These platforms were employed to validate the proposed edge node deployment method. The results clearly demonstrate the superior effectiveness of the proposed strategy over conventional approaches.

The subsequent sections of this article are organized as follows. Section 2 reviews the related work. Section 3 introduces the system model and outlines the edge node deployment problem. In Section 4, two enhanced heuristic algorithms are presented. Section 5 provides the experimental validation of the proposed method, followed by a detailed analysis of the results. Finally, the article concludes with a comprehensive summary in Section 6.

2. Related Work

The rational and efficient deployment of edge nodes is essential for establishing a low-latency edge computing platform in mining environments. The extensive geographical distribution of end devices and the limited resources of edge nodes significantly influence the decisions regarding the number and location of node placements. In recent years, numerous scholars have explored various strategies for edge node placement.

Numerous scholars have explored methodologies for deploying edge nodes in fixed equipment scenarios. Alejandro et al. [11] proposed a static node placement framework that incorporates various node placement and optimization strategies based on network sensing capabilities. However, this study primarily focused on general suggestions for edge node deployment without providing specific solutions tailored to different application scenarios.Abdenacer et al. [12] proposed a marine predator algorithm to improve network connectivity and device coverage. Zhao et al. [13] investigated the deployment challenges of edge nodes in smart cities, focusing on scenario-specific constraints related to load balancing and delay minimization. They proposed an enhanced nondominated sorting genetic algorithm (NSGA-II) that integrates an elitist strategy to optimize the selection process in subsequent iterations. Experimental results demonstrated a significant reduction of 40.6% in system overhead, highlighting the algorithm’s effectiveness in optimizing edge node placement. However, it is important to note that while the aforementioned studies consider service type as a significant factor in node deployment, they do not account for the physical characteristics of the devices being serviced in their deployment models.

Carlos et al. [14] proposed a deployment strategy utilizing a distributed genetic algorithm to optimize system performance and network costs, addressing the challenges posed by resource constraints and the wide geographical distribution of devices. Huang et al. [15] focused on the task offloading aspect in edge server deployment, using a simulated annealing algorithm to determine optimal node locations. Their approach aimed to balance the load among edge nodes and improve user experience. However, it is important to note that previous studies did not fully consider the comprehensive cost implications related to the number of deployed edge nodes.

Jiang et al. [16] introduced an enhanced clustering algorithm that accounts for variations in device functionality and layout, as well as disparities in computational and storage capacities across different edge nodes. The optimization of edge node deployment aims to balance network latency with the costs associated with computational resource deployment. The results demonstrate the algorithm’s superiority over traditional methods. Wang et al. [17] examined the issue of fault-tolerant node deployment, considering real-world scenarios with node failures. They framed the problem as a multi-objective challenge focused on achieving load balance and minimizing deployment costs. To solve this, they employed a genetic algorithm with heuristic enhancements. The results demonstrate the method’s effectiveness in reducing both latency and deployment costs compared to other algorithms. Nevertheless, prior research has not thoroughly explored the specific requirements of edge node deployment within mining environments, making the proposed techniques less suitable for smart mining applications.

In edge computing, certain devices are in constant motion, resulting in frequent changes to their location. This mobility increases service latency and creates challenges for efficient task execution. Therefore, it is crucial to consider the effects of device mobility when determining the optimal placement of edge nodes. Yuan et al. [18] developed virtual nodes within a pay-per-use framework and utilized deep learning techniques to predict service requests and placement cost parameters. They proposed a dynamic virtual edge node placement scheme based on the predicted parameters, with the primary aim of simultaneously minimizing placement costs and network delays. Empirical results confirm the algorithm’s superiority compared to traditional clustering-based node placement schemes. Kasi et al. [19] formulated the edge node deployment problem as a multi-objective optimization problem aimed at minimizing workload imbalance and access delay. They employed a genetic algorithm framework, further enhanced by the integration of a local search algorithm to facilitate node assignment. Mazloomi et al. [20] proposed a reinforcement learning framework to solve the edge node placement problem, which models real-world scenarios by constructing state and action spaces. Shen et al. [21] proposed a dynamic node placement scheme, beginning with system initialization using a clustering algorithm. Following this, a graph-matching algorithm is employed to calculate the fitness function, and a nondominated sorting genetic algorithm is used to identify the optimal placement of nodes. Empirical results demonstrate that this approach significantly reduces task latency compared to conventional clustering-based methods.

As previously noted, the study standardized the computational capabilities of edge nodes. However, in real-world scenarios, it is crucial to deploy nodes with varying computational capacities to meet the specific requirements of different tasks. Zhang et al. [22] explored the edge node deployment problem, addressing both node placement and service layout. They proposed a two-stage approach, incorporating clustering and nonlinear programming. This method accounts for multiple factors, such as the number of nodes, interactions between edge nodes and base stations, and the impact of the nodes’ computational and storage capacities on the deployment process. Empirical results confirm that the algorithm significantly outperforms the baseline approach. It is noteworthy that this research primarily focuses on smart city environments, without addressing the unique characteristics of mining applications. This limitation hinders its capacity to meet the stringent real-time requirements and to manage the spatial constraints inherent in mining operations. As a result, a significant research gap remains in the development of effective edge node placement strategies specifically tailored to mining environments.

Therefore, this study is framed within the context of the complex mining environment. Recognizing the distinctive characteristics of this setting, the research introduces two specific edge node deployment algorithms designed for fixed and mobile device scenarios. These algorithms focus on optimizing latency and cost efficiency, aiming to ensure rapid task responses during mining and transportation operations. The study also offers a valuable framework for the strategic deployment of edge computing nodes across various production environments in mining operations.

3. System Model and Problem Description

3.1. System Model

Mining operations encompass the critical production stages of “drilling, blasting, extraction, loading, transportation, and dumping”. Drilling and blasting predominantly occur at the surface, requiring substantial computational resources for training sophisticated mining algorithms. Conversely, extraction, loading, and transportation activities are typically conducted in underground mining areas. The spatial limitations and power supply constraints inherent in such underground environments necessitate the use of smaller, low-power devices. Consequently, deploying complex computational models on these resource-constrained devices is often impractical, posing significant challenges to efficient task execution in these scenarios. Moreover, large volumes of data are typically transmitted to surface-level facilities for processing before being returned to the underground operations, resulting in significant latency and reduced overall system reliability. Thus, the strategic deployment of edge nodes directly at the mining site emerges as a crucial approach, enabling task offloading to local edge processing. This approach not only mitigates latency but also enhances the system’s robustness. This section focuses on addressing the complex problem of identifying optimal deployment locations for edge nodes, specifically tailored to both fixed and mobile devices. For clarity,

Table 1. Notations.

Symbol	Description
SN	Number of fixed equipment
SD	Fixed equipment collection
SX	Number of potential candidate locations for fixed equipment
SP	A collection of potential candidate locations for fixed equipment
SM	Number of edge nodes for fixed equipment
SE	Fixed device edge node collection
MN	Number of mobile devices
MD	Mobile device collection
MM	Number of edge nodes for mobile devices
ME	Collection of edge nodes for mobile devices
$C^{all}$	Edge node deployment cost
${\beta }_1$	Delay weight coefficient
${\beta }_2$	Placement cost weight coefficient
$T_{i,j}^{trans}$	The transmission time of a task
$T_{i,j}^{exe}$	The execution time of a task
$T_{i,j}^{queue}$	The queuing time of a task
$T_{max}$	Maximum task delay

defines the symbols and notations used throughout this section.

3.1.1. Fixed Device Model

We use the loading device as a case study and simulate the loading task on the production line platform in the subsequent experimental section. The loading task requires that, when the bucket is transported around the loading device via the hoist, the loading device must receive information about the bucket (e.g., position, load status, etc.) and transmit its own position and orientation to the bucket to ensure coordinated operation between the two. In the event that the bucket becomes stuck, an immediate warning signal must be sent to surrounding equipment to prevent hazardous operations. This task is subject to strict time constraints to minimize the risk of disaster. Ideally, edge nodes for fixed devices should be deployed during the construction phase of smart mines. However, the current shift towards intelligent mining is predominantly realized by upgrading traditional mining operations to facilitate intelligent control systems. A significant portion of the mining and transportation equipment has already been installed, and both power lines and network cables have been fully deployed. This pre-existing infrastructure limits the flexibility of potential edge node placement locations, thereby introducing challenges in the deployment process. To reduce the complexity of this problem, the following assumptions are proposed:

• Large-scale fixed equipment and intelligent terminals have already been deployed.
• Communication delays between edge nodes and intelligent terminals are consistent.
• Task requests from intelligent terminals vary periodically.

Considering the aforementioned constraints, the system model for edge node placement in the mining production line is illustrated in Figure 1.

In an already constructed mining line, this paper selects several potential locations for deploying edge nodes, based on the traditional expertise of scholars. In this paper, we denote the set of edge nodes as $SE$, $SE=\{s{e}_1,s{e}_2,\dots ,s{e}_{SM}\}$, where $SM$ represents the number of edge nodes. The CPU frequency of each node is denoted by $SFR=\{sfr{e}_1,sfr{e}_2,\dots ,sfr{e}_{SM}\}$. The set of potential candidate locations is represented by $SP=\{s{p}_1,s{p}_2,\dots ,s{p}_{SX}\}$, where $SX$ is the number of potential candidate locations and satisfies $SX<SN$. Each candidate location $s{p}_i$ is characterized by its coordinates $s{p}_i=(x_i,y_i)$. The communication between the edge nodes and the fixed devices is carried out by wired or wireless means [23]. Fixed devices send real-time task requests to the edge nodes during operation, with the requests changing periodically. In this paper, $SD=\{s{d}_1,s{d}_2,\dots ,s{d}_{SN}\}$ represents the set of fixed devices, where $SN$ corresponds to the total number of devices, and $(x_i,y_i)$ encapsulates the location status information for each fixed device, $s{d}_i$. The task requests of the devices are represented by the set $ST=\{s{t}_1,s{t}_2,\dots ,s{t}_{SN}\}$, where each request is described as $s{t}_i=\{sdi{n}_i,s{y}_i,sdou{t}_i\}$. In this context, $sdi{n}_i$ represents the input data volume for the task, $s{y}_i$ quantifies the task load, and $sdou{t}_i$ specifies the output data volume.

Referencing Figure 1 and the preceding description, it becomes clear that various potential candidate locations within the mining production line have been selected based on expert insights. These edge nodes are strategically deployed according to a scenario-specific node deployment plan. The selected locations must satisfy the dual objectives of minimizing the task response time for the equipment and optimizing the deployment costs associated with the nodes.

3.1.2. Mobile Device Model

In the case of the mine cart, the inspection trolley was used to simulate the transport task in the subsequent experimental section. The transport task involves the unmanned movement of mine vehicles along designated routes on mine roads, using sensory information collected from the environment. Throughout the process, these trucks interact with the platform, other vehicles, and surrounding equipment to perform tasks such as fault detection and warnings. However, the mobility of these vehicles introduces several challenges, including potential task transmission failures, disruption of service continuity, increased response delays, and compromised operational safety. To address these issues, edge nodes are strategically deployed in proximity to the equipment for task processing, ensuring both the safety and efficiency of transportation operations. As illustrated in Figure 2, the mining transportation scenario presents the critical challenge of rapidly responding to uncrewed transport vehicles, making it a focal point of research. This section, thus, examines the placement of mobile vehicle edge nodes within the context of edge computing systems specific to this scenario.

To streamline the complexity of this problem, we make the following assumptions. (1) Each edge node can establish communication with the cloud center regardless of its location. (2) Edge nodes maintain a consistent communication latency when interacting with mobile devices. (3) Mobile devices operate in periodic cycles. (4) Mobile devices do not need to be co-located. The edge node placement model for mobile equipment within the mining production line shares several fundamental components with the model designed for fixed equipment. These common elements include mobile equipment, potential candidate locations for node placement, edge nodes, tasks, and other relevant factors critical to optimizing node deployment and ensuring efficient operation.

When addressing the placement of edge nodes on mobile devices, this section no longer takes position constraints into account, as these devices are in motion with a broad range of movement. Consequently, any position along the trajectory can be deemed a potential candidate for node placement. In this scenario, the exact quantity of edge nodes remains uncertain, necessitating the selection of suitable algorithms to optimize the number of node deployments. The rest of the characteristics are similar to those in the fixed scene. This paper focuses on mobile devices with trajectories that remain nearly constant or exhibit minimal changes. In this paper, the group of mobile devices is represented as $MD=\{m{d}_1,m{d}_2,...,m{d}_{MN}\}$, where MN signifies the total number of mobile devices in the set. Furthermore, for each mobile device $m{d}_i$, its positional coordinates at time t are denoted as $m{d}_i^t=\{x_i^t,y_i^t\}$. We use ME to denote the set of edge nodes, where $ME=\{m{e}_1,m{e}_2,...,m{e}_{MM}\}$, with MM representing the number of edge nodes. $MFRE=\{mfr{e}_1,mfr{e}_2,...,mfr{e}_{MM}\}$ signifies the CPU frequency of each edge node. The set of tasks is denoted as $MT=\{m{t}_1,m{t}_2,...,m{t}_{MN}\}$. Each individual task request is specified as $m{t}_i=\{mdi{n}_i,m{y}_i,mdou{t}_i\}$, where $mdi{n}_i$ signifies the quantity of input data required by the task, $m{y}_i$ represents the task’s load, and $mdou{t}_i$ denotes the amount of output data.

In contrast to edge node deployments for fixed devices, the dynamic nature of mobile devices introduces additional challenges related to maintaining stable communication connectivity between multiple nodes and devices. Therefore, selecting the optimal location for edge node placement in such scenarios requires careful consideration, as any potential location within the environment may influence performance. This focus on appropriate placement enhances service responsiveness to task requests from mobile devices but also increases the complexity of identifying the optimal solution. The model proposed in this paper demonstrates versatility, making it suitable for a variety of mobile scenarios.

3.2. Problem Description

In this study, the edge node deployment problem is formulated as an optimization task, where the objective is to identify the optimal locations from a set of candidate sites, subject to specific constraints. [24]. Given that node deployment is a well-known NP-hard problem, heuristic algorithms are commonly employed to address it. In practical scenarios, edge nodes generally have access to a stable power supply network, ensuring sufficient energy availability [25]. Furthermore, the distinctive nature of the mining environment magnifies its vulnerability to latency. Consequently, this study omits the consideration of energy consumption by edge nodes and focuses on the aspects of cost and delay.

In this section, uniform mathematical notation is employed to enhance the clarity of problem formulations in various scenarios. The set of edge nodes is represented by E, while the set of tasks is denoted as T. To distinguish between fixed and mobile equipment, the prefixes ‘S’ and ‘M’ are used, respectively. For example, in the context of the fixed equipment scenario, E corresponds to SE, whereas in the mobile equipment scenario, E corresponds to ME.

3.2.1. Task Delay

The service time in an edge computing system comprises multiple components, including the task transmission time from the terminal device to the edge node, the task processing time at the edge node, and the waiting time for task execution. A critical factor influencing this service time is the data transmission rate within the communication channel, which significantly impacts overall system performance:

$$R_i=Wlo{g}_2(1+P_{i}H/{\sigma }^2),i\in T$$

(1)

In the presented model, we utilize several parameters for the communication channel and task allocation. Specifically, W represents the communication bandwidth, ${\sigma }^2$ denotes the channel noise power, $P_i$ indicates the transmit power of the node, and H represents the channel gain. To indicate whether task i is executed on edge node j, we adopt the notation ${\alpha }_{i,j}$:

$${\alpha }_{i,j}=\left\{\begin{array}{cc}\hfill 1& ,Iftaskicanbeexecutedinedgenodej\\ \hfill 0& ,others\end{array}\right.$$

(2)

All the tasks are carried out by at least one node, and each node caters to at least a solitary device:

$$\sum _{j\in E}{\alpha }_{i,j}\ge 1,\forall i\in Tand\sum _{i\in T}{\alpha }_{i,j}\ge 1,\forall j\in E$$

(3)

The transmission time of a service is denoted as $T_{i,j}^{trans}$. The size of this transmission time is influenced by the number of inputs and outputs of a task and can be expressed as follows:

$$T_{i,j}^{trans}={\alpha }_{i,j}(d_{in}\left(j\right)+d_{out}\left(j\right)/R_i),i\in T,j\in E$$

(4)

The task processing time of the edge node is contingent on the processing capability of the node itself and the load of the task, which can be expressed as follows:

$$T_{i,j}^{exe}={\alpha }_{i,j}(y\left(j\right)/f\left(i\right)),i\in T,j\in E$$

(5)

Upon reaching the edge node, the task is queued, awaiting processing by the node. The queuing time can be calculated using the following formula:

$$T_{i,j}^{queue}={\alpha }_{i,j}(lea{v}_j-arr{i}_j),i\in T,j\in E$$

(6)

where $lea{v}_i$ represents the departure time of the $ith$ task, while $arr{i}_i$ signifies the arrival time of the $ith$ task. Consequently, the service time of each task can be expressed as:

$$T_{i,j}=T_{i,j}^{trans}+T_{i,j}^{exe}+T_{i,j}^{queue}$$

(7)

The maximum task latency $T_{max}$ is used to describe the computational performance of edge nodes in this study:

$$T_{max}=argma{x}_{i\in T,j\in E}\left(T_{i,j}\right)$$

(8)

3.2.2. Deployment Cost

The objective of deploying edge nodes in a mining environment is to uphold service quality while concurrently minimizing costs. The cost can be expressed by Equation (9):

$$C_{all}=\sum _{i=1}^M{n}_{i}pr{i}_i$$

(9)

$$pr{i}_i=a{x}_i+A,x_i>0,i=1,2,...,M$$

(10)

where $n_i$ signifies the quantity of edge nodes i, a and A are constants, and the variable $x_i$ corresponds to the computational capacity of the node, where the cost of the node is directly proportional to its computational capacity.

3.2.3. Problem Formulation

This paper addresses the challenge of deploying edge nodes with the objective of optimizing response time and cost. In the scenario involving fixed devices, the aim is to minimize both response time and cost. In the mobile scenario, the goal is to optimize and minimize response time. The objective function can be expressed as follows:

$$min{T}_{max}$$

(11)

$$min{C}_{all}$$

(12)

• s.t. (c1): ${\sum }_{j\in E}{\alpha }_{i,j}\ge 1,\forall i\in T$
• (c2): ${\sum }_{i\in T}{\alpha }_{i,j}\ge 1,\forall j\in E$
• (c3): $T_{max}\le MAXT$
• (c4): $0<C_{all}\le MAXC$

c1: All tasks are handled by at least one edge node. c2: Each edge node serves at least one device; otherwise, the placement of the node is meaningless. c3: The maximum response time in edge computing cannot exceed the maximum service time defined by the edge node. c4: The cost of placing edge nodes should be a nonnegative number and not exceed the expected cost.

4. Edge Node Deployment Algorithm Design

Building on the proposed edge node deployment models for the two distinct scenarios, we have developed specific placement algorithms aimed at achieving optimal deployment objectives [26]. For stationary equipment, we propose an enhanced dual-population genetic algorithm, while for mobile equipment scenarios, we introduce an improved sand cat swarm optimization algorithm. These algorithms are designed to address the unique challenges posed by each scenario, ensuring efficient and effective edge node placement.

4.1. Improved Dual Population Genetic Algorithm

Deploying edge nodes in a fixed scenario constitutes a complex discrete multi-objective optimization problem. Notably, the solution space expands exponentially as the number of terminal devices increases [27]. To address the challenges outlined, this study utilizes a Improved Bi-population Genetic Algorithm (IBGA), which simulates biological inheritance and evolution through a stochastic search optimization method, as described in previous research [28]. This method provides robust global search capabilities, coupled with fast optimization, high accuracy, and flexibility, making it a highly effective tool for addressing multi-objective optimization problems [29]. To address the problem of concentrated distribution and limited diversity within the algorithm, cubic mapping chaos is utilized for population initialization. Additionally, the concept of concurrent evolution across multiple swarms is integrated to further enhance algorithmic performance. This approach is intended to improve the algorithm’s performance and effectiveness. To mitigate the issue of chromosome disruption caused by crossover and mutation operations, a roulette selection mechanism with an elite retention strategy is applied. Algorithm 1 presents the detailed implementation process of the Improved Bi-population Genetic Algorithm (IBGA). Figure 3 shows the flowchart of the IBGA algorithm.

Algorithm 1 Improved Bi-population Genetic Algorithm (IBGA)

Input: $SM$,$P_b$,$MP$,$MAXGEN$,$P_{mut}$,$P_{cro}$

Output: Optimal edge node deployment solution.   1: Initialization: Number of binary digits of the variable $P_b$, Population number $MP$, Number of iterations $MAXGEN$, $SM$,$P_{mut}$,$P_{cro}$   2: Chromosomal coding.   3: Generated The chaotic sequence according to Equation (13).   4: Population initialization.   5: Calculated the crossover probability according to the Equation (18).   6: Calculate the adaptive function value according to Equation (17).   7: Sort based on adaptive value.   8: for all $gen=1$ to $MAXGEN$ do   9:  for all $i=1$ to $MP$ do 10:   Select action. 11:   Crossover operation. 12:   Mutations operation. 13:   Calculate the offspring adaptive function value. 14:   Update population. 15:  end for 16:  Immigration operations. 17:  Select elite individuals to form a new elite population. 18: end for

4.1.1. Gray Coding Chromosome Structure

Given that genetic algorithms cannot directly handle the parameters of the problem space, it is essential to encode these problem space parameters as chromosomes in the genetic space. In this scenario, each chromosome represents a node deployment location. Due to the substantial Hamming distance that can arise from binary encoding of neighboring integers, potentially reducing the search efficiency of genetic operators, this study adopts Gray encoding for the chromosome structure. As shown in Figure 4, each chromosome uses Gray coding to represent a solution. The candidate position is represented by a continuous four-digit code, with the edge node number corresponding to the decimal value of this four-digit Gray code.

4.1.2. Population Initialization Based on the Cubic Chaos Map

The traditional approach relies on random initialization of the search population, often leading to limited diversity and increasing the chances of the algorithm becoming trapped in a local maximum. Cubic mapping chaos can lead to a more uniform population, expand the search space, and improve the convergence speed and accuracy of the algorithm. The formula for the cubic mapping chaotic sequence is as follows:

$$z(i+1)=4z{\left(i\right)}^3-3z\left(i\right),-1\le z\left(i\right)\le 1,i=0,1,2,...$$

(13)

$$u_i=l_{min}+(l_{max}-l_{min})(z\left(i\right)+1)/2$$

(14)

where $z\left(i\right)$ represents the chaotic variable, $l_{max}$ and $l_{min}$ indicate the upper and lower bounds of the mapping interval, respectively, and the mapped variable value is denoted as $u_i$.

4.1.3. Fitness Function

In this scenario, the objective function aims to minimize both delay and cost, denoted as the combined objective function W:

$$W={\beta }_1{T}_{max}+{\beta }_2{C}^{all}$$

(15)

$${\beta }_1+{\beta }_2=1$$

(16)

where the weight coefficients ${\beta }_1$ and ${\beta }_2$ are used to balance the considerations of delay and cost. In order to maximize the fitness function, an adjustment of the objective function is necessary to ensure that the function value becomes more prominent as the total overhead decreases. The fitness function can be expressed as:

$$fitness=1/(W+1)$$

(17)

To avoid the situation where the denominator is 0, add 1 to the denominator.

4.1.4. Parallel Evolution of Two Populations

Parallel evolution of multiple populations entails evolving distinct populations concurrently, each governed by different parameters. These populations evolve independently and periodically exchange their best individuals. This process helps preserve population diversity, improves solution quality, accelerates convergence, and reduces the risk of the algorithm becoming trapped in local optima.

• Selection operation
  We use roulette and modified elite strategy for operator selection. First, the top 10% of the best individuals in the population are retained according to their fitness values and passed directly to the next generation as elite individuals. The roulette method is used to select the remaining 90% of the population. This can prevent the optimal individual from being eliminated, ensure the quality of the offspring population, and improve the global convergence ability of the algorithm.
• Crossover operation
  The population was divided into two sub-populations, one with a fixed crossover probability $P_{cro}$ and the other with an adaptive crossover probability. The adaptive crossover probability is calculated as follows:

  $$P=\vartheta P_1+(1-\vartheta )P_2$$

  (18)

  $$\vartheta =1-K/K_{max}$$

  (19)

  where $P_1$ and $P_2$ denote the larger and smaller crossover probabilities, K represents the current iteration number, and $K_{max}$ represents the maximum number of iterations. The crossover mechanism employed here is a two-point crossover method, which randomly sets the starting point and end point of the crossover in the chromosome string, exchanges the structure between the parents’ exchange points, and generates two new individuals, as illustrated in Figure 5.
• Mutation operation
  Mutation in genetic algorithms alters specific gene values on the chromosome string through different techniques to generate new individuals. These mutation operators are essential for maintaining population diversity and avoiding premature convergence. However, traditional mutation operators are prone to local optima issues. To overcome this, enhancements to the standard random mutation method have been introduced, incorporating Gaussian mutation for chromosome alterations. The mutation probability $P_{mut}$ determines whether a mutation occurs. If a mutation takes place, the original gene value in the chromosome is replaced by a random number generated from a normal distribution with a mean $\mu$ and variance ${\sigma }^2$.

Through multiple iterations, the algorithm identifies the optimal edge node placement that satisfies the criteria of minimum delay and cost.

4.1.5. Algorithm Performance Analysis

The complexity of the IBGA algorithm is influenced by factors such as population size, the number of iterations, and the complexity of genetic operations.This study focuses on the analysis of time complexity related to the computation of fitness functions, the sorting of fitness values, and the selection, crossover, and mutation operations carried out during the algorithm’s execution. The population size is MP, chromosome length is N, the number of iterations is represented by MAXGEN, m is the number of chromosomes outside the elite chromosome, the crossover probability is $P_{cro}$, and the mutation probability is $P_{mut}$. Therefore, the time complexity of the algorithm is $O(MAXGEN\ast (O\left(MP\right)+O\left(MP\right)logMP)+O(N\ast m\ast P_{cro})+O(m\ast P_{mut}))$.

The IBGA algorithm does not rely on a specific mathematical formulation of the problem or gradient information. It allows users to design coding schemes, crossover mechanisms, and mutation operations flexibly based on the problem’s characteristics, providing both robustness and adaptability.

4.2. Improved Sand Cat Swarm Optimization Algorithm

The Sand Cat Swarm Optimization (SCSO) algorithm mimics two primary survival behaviors observed in natural sand cat populations: foraging and hunting prey [30,31]. Compared to other population-based intelligence algorithms, the Sand Cat Swarm Optimization (SCSO) algorithm demonstrates robust optimization capabilities, making it well-suited for addressing complex multi-objective optimization problems. However, its convergence speed and search accuracy are moderate, which increases its susceptibility to becoming trapped in local optima. Thus, this paper introduces three enhancement techniques to strengthen the global search capabilities of the Sand Cat Swarm Optimization algorithm. The Improved Sand Cat Swarm Optimization (ISCSO) algorithm is subsequently applied to solve the edge node deployment problem in mobile device scenarios. The detailed steps of the ISCSO algorithm are presented in Algorithm 2. Figure 6 shows the flowchart of the ISCSO.

Algorithm 2 Improved sand cat group optimization algorithm

Input: $MD$,$ME$,$MN$,$MF$

Output:  Optimal edge node deployment solution.   1: Initialization: $MAXGEN$,$ME$,R,r,$r_G$   2: The chaotic sequence is generated in accordance with the Equation (19).   3: for all $me=1$ to $ME$ do   4:  Set an initial value for each sand cat.   5: end for   6: for all $t=1$ to $MAXGEN$ do   7:  Update r,$r_G$,R   8:  Check if any sandcats exceed the search space and modify.   9:  Calculate the fitness value of each sand cat according to Equation (15) and find the best sand cat. 10:  for all $me=1$ to $ME$ do 11:   Obtain random angles using roulette algorithm. 12:   if $R\le 1$ then 13:    Update the position of the sand cat according to Equation (26). 14:    Execute the strategy to obtain a new position according to Equation (27). 15:   else 16:    Update the position of the sand cat according to Equation (22). 17:    Execute the search strategy according to Equation (23) to obtain the new position. 18:   end if 19:  end for 20: end for

4.2.1. Logistic Chaotic Sequence

Chaotic sequences possess the attributes of randomness, nonlinearity, and ergodicity. They are instrumental in sustaining population diversity, subsequently enhancing the algorithm’s convergence speed and accuracy. In this study, logistic chaos mapping is employed to initialize the population, with the improved formula provided as follows:

$$X_{i+1}=\gamma x_{i+1}+(1-x_i)$$

(20)

$$Y_{i+1}=l_{min}+x_{id}(l_{max}-l+min)$$

(21)

where $\gamma$ serves as the control parameter, with $\gamma >1$, the value range of $x_i$ falls within $0<x_i<1$, $x_{id}$ signifies the chaotic sequence generated by Equation (19), $Y_i$ represents the position of the ith individual, and $l_{max}$ and $l_{min}$ denote the search range of the population.

4.2.2. Spiral Exploration Strategy

During the exploration phase, the sand cat identifies prey by considering the optimal location, current position, and sensitivity range. This phenomenon is mathematically described by Equation (22):

$$pos(i+1)=r(po{s}_{bc}\left(i\right)-rand(0,1)po{s}_c\left(i\right))$$

(22)

where $po{s}_{bc}\left(i\right)$ is the optimal solution, $po{s}_c\left(i\right)$ is the current position, and r is the sensitivity range.

Spiral exploration within the algorithm facilitates the discovery of multiple search paths and assists individuals in making more effective adjustments to their positions. Following the integration of spiral exploration, individuals perform search operations within the search space in a spiral pattern. Expanding their exploratory capabilities enhances the algorithm’s potential to escape local optima and improves its overall global search performance. The update formula is represented by Equation (23):

$$pos(i+1)=o\ast r(po{s}_{bc}\left(i\right)-rand(0,1)po{s}_c\left(i\right))$$

(23)

Equation (24) signifies the computation of the spiral exploration factor, denoted as o:

$$o=exp\left(bg\right)cos\left(2\pi g\right)$$

(24)

where b represents the spiral shape constant and g represents the path coefficient, where $g\in [-1,1]$.

4.2.3. Levy Flight Strategy

In the prey attack phase, a random position, denoted as $po{s}_{rand}\left(i\right)$, is generated using the best and current positions. Subsequently, a random angle $\alpha$ is selected through the roulette algorithm, and the attack operation is executed using the Equation (26):

$$po{s}_{rand}\left(i\right)=|rand(0,1)\ast po{s}_{bc}\left(i\right)-po{s}_c\left(i\right)|$$

(25)

$$pos(i+1)=po{s}_{bc}\left(i\right)-po{s}_{rand}\left(i\right)\ast r\ast cos\left(\alpha \right)$$

(26)

The prey attack in the standard algorithm is executed through random angles, which may lead to the algorithm overlooking some optimal solutions. We introduce the levy flight strategy to mitigate the influence of locally optimal solutions, as described in Equation (27):

$$pos(i+1)=po{s}_{bc}\left(i\right)+(po{s}_{bc}\left(i\right)-po{s}_c\left(i\right))\ast C\ast levy$$

(27)

$$levy={\displaystyle \frac{u}{{|vs.|}^{-\beta }}}$$

(28)

where variables u and v follow a normal distribution, $u\sim N(0,{\sigma }_u^2),v\sim N(0,{\sigma }_v^2)$, and C is a constant representing the step adjustment coefficient.

5. Experimental Setup

5.1. Fixed Equipment Scene Experimental Setup

As depicted in Figure 1, the mine’s grab crane unloads ore from the cargo hold into the loading basket and subsequently transfers it to the storage yard or loading platform via the conveyor belt. This operation is analogous to manipulating a robotic arm to grasp materials and deposit them into the material box on the production line. In the loading task, failure of the robotic arm to securely grasp the material and accurately place it into the material box can result in scattered materials, disrupting the production line and hindering its regular operation. In such instances, immediate intervention is crucial to prevent more severe risks. To ensure the smooth operation of the production line, it is imperative to deploy equipment with sufficient computing and storage resources to process real-time data. This reflects the edge node deployment challenges encountered in mining scenarios. Hence, this study focuses on validating the algorithm’s efficacy in tasks related to material grabbing and loading within a laboratory production line platform.

The small production line test bench is shown in Figure 7. The comprehensive system consists of modules such as conveyor belts, loading, unloading, packaging, robotic arms, and other components. Upon receiving a remote order, the production line system undergoes the process of order confirmation, independent execution of product customization and assembly, and visual display of operational status to facilitate intelligent production. Simulation parameters for the experiments are specified in

Table 2. Notations used in fixed device edge node placement.

Symbol	Description	Value
SN	Number of fixed equipment	[10, 100]
SX	Number of potential candidate locations	[5, 15]
$s{d}_{in}$	Amount of data input per task	[800, 1500] kb
$s{d}_{out}$	Amount of data output per task	[1, 50] kb
$sy$	Load per task	[10, 50] MHz
$sfre$	The main frequency of the edge node	[1.5, 4.5] GHz
C	Edge node cost	[800, 3000]
${\beta }_1$	Delay weight coefficient	0.6
${\beta }_2$	Placement cost weight coefficient	0.4

.

5.2. Mobile Device Scene Parameter Settings

In the experiments related to mobile device edge node placement, we employed a laboratory-developed inspection car as a mobile device to simulate the movement trajectory and task requests encountered by mobile devices within the mining environment. The structure of the trolley is depicted in Figure 8. The car consists of several key components, including a server, motor vision module, navigation module, power supply, and controller power supply module, among other parts.

A laboratory site measuring 60 by 60 m was designated for the experiments. Multiple inspection vehicles were deployed, with task data being recorded and subsequently used for experimental evaluations. The maximum coverage range of the edge node was set at 20 m, and the movement speed of the inspection vehicles was maintained at 5 m per second. Additional details and parameters are provided in

Table 3. Notations used in mobile device edge node placement.

Symbol	Description	Value
MN	Number of mobile devices	[5, 10, 20]
MX	Number of potential candidate locations	[5, 10, 20]
$m{d}_{in}$	Amount of data input per task	[80, 150] Kb
$m{d}_{out}$	Amount of data output per task	[1, 50] Kb
$my$	Load per task	[80, 1000] MHz
$mfre$	The main frequency of the edge node	3.6 GHz

.

We conducted simulations on a computer equipped with a 3.60 GHz AMD CPU and 16 GB RAM (Advanced Micro Devices, Inc., Santa Clara, CA, USA), utilizing the parameters outlined in

Table 4. Parameters set in the algorithms.

Symbol	Description	Value
T	Maximum number of iterations of IBGA	500
M	Number of populations of IBGA	200
$P_{cro}$	Crossover rate of IBGA	0.6
$P_{alt}$	Variation rate of IBGA	0.05
T	Maximum number of iterations of ISCSO	500
MF	Number of populations of ISCSO	200
b	Spiral shape constant	1

for the algorithms.

6. Results and Discussion

6.1. Analysis of the Results of the Fixed Equipment Edge Node Placement Algorithm

We have selected the randomized algorithm [32] and the k-means algorithm [33,34] as benchmark algorithms for comparison. A comparison of IBGA with benchmark algorithms and GA [35,36] is performed based on completion time and deployment cost. On the production line platform, a sequence of operations is executed. This includes monitoring the position of the materials box, tracking the status of materials, assembling the cylinder to move the materials box to the processing position upon detection, performing the loading operation, updating the product status, and activating the cylinder to push the materials box along the conveyor belt in a series of five tasks. Based on expert input, a minimum of five strategically placed nodes were required to ensure the smooth execution of each task. Each node was assumed to have sufficient resources to handle any task assigned to it successfully. Multiple experiments were conducted on the production line platform with different edge node placements in each scenario. Device coverage and objective function values were obtained through the algorithm, and the results are presented in

Table 5. Experimental results.

Number of Edge Nodes	Average Device Coverage	Objective Function Value
5	0.5895	0.6228
6	0.7074	0.6220
7	0.7800	0.6140
8	0.8571	0.6020
9	0.9614	0.5916
10	0.9773	0.6080
11	0.9841	0.6400

. To reduce the impact of random errors, the results of 50 experiments were averaged.

The optimal number of nodes to be deployed in this scenario can be obtained by analyzing the experimental results in Table 5. As the number of edge nodes increases, the system’s device coverage expands accordingly. In each time slot, the number of tasks processed by the system rises, leading to a reduction in task response time. This reduction outweighs the increase in cost, resulting in a gradual decrease in the objective function value. However, when the number of nodes exceeds 9, the reduction in task response time becomes less significant compared to the increase in cost, leading to a subsequent rise in the value of the objective function. Figure 10 illustrates the detailed delay and cost outcomes. Hence, with nine nodes, the achieved solution attains the optimal objective, boasting a high coverage rate and representing the optimal deployment solution at that juncture, as illustrated in Figure 9. Figure 9a depicts the initial node positions generated by the IBGA algorithm and Figure 9b shows the optimal node deployment scheme generated by IBGA after a certain number of iterations. Figure 9c further illustrates the algorithm’s stability, achieved after 200 iterations.

Figure 10 illustrates the impact of the four deployment strategies on the service time as the number of edge nodes increases while keeping the number of endpoints constant. As shown in Figure 10a, the service time of all four methods steadily decreases with the increasing number of $S{E}_s$. The underlying reason is that, as the number of edge nodes increases, the available resources per node also increase, leading to a reduction in the average number of device requests allocated to each node, which in turn results in a decrease in latency.Among these strategies, the IBGA achieves a reduction in service time of 20.5–31.2% compared to the other algorithms, demonstrating a significantly lower service time. The results show that the IBGA algorithm performs best as the number of edge nodes increases.

In Figure 10b, it is evident that the deployment cost increases for all four methods as the number of SEs increases. This is primarily due to the fact that deploying additional nodes incurs higher overall costs. The figure illustrates that the IBGA method consistently demonstrates a lower deployment cost compared to other algorithms, making it particularly well-suited for this scenario. The reason is that as the number of SEs increases, more nodes are deployed, leading to an increase in cost. However, the IBGA algorithm manages this growth more efficiently than the other approaches.

Figure 10c shows the objective function value obtained for different deployment strategies. Our objective is to minimize this function value, and as the figure illustrates, the IBGA method achieves the lowest overall objective value compared to the other algorithms, with IBGA performing the best and GA ranking second. This is due to the ability of the GA algorithm to search multiple regions of the solution space and to search faster for the optimal deployment location. The improved IBGA algorithm demonstrates superior convergence due to its approach of replacing random searches with targeted searches for candidate positions, thus avoiding redundant searches for the same node pairs. Additionally, by employing two populations that evolve simultaneously, the algorithm reduces the time required to find the optimal solution.

To simulate real-world conditions more accurately, we increased the number of devices to better reflect the complexity of a natural mining area. This increase allowed us to replicate the actual workload encountered in such environments. We then evaluated the algorithm’s performance under different task density conditions, assessing how it adapts to the increased workload and varying demands.

Figure 11 illustrates the impact of four node deployment solutions as the number of terminal devices increases, with a fixed count of nine edge nodes. As shown in Figure 11a, the response time for each strategy increases parallel with the increase in terminal devices. Notably, it is evident that IBGA exhibits the shortest service time, while the randomized algorithm yields the longest service time across varying numbers of end devices. When compared with the randomized and k-means algorithms, the IBGA algorithm demonstrates notable reductions in service delays, with savings of 1012.5 ms and 539.8 ms, respectively. This improvement is due to the increase in task generation as more terminals are introduced, leading to higher computational demands on the edge nodes. Consequently, these nodes must provide enhanced computing services, resulting in a general increase in response times for all strategies.

Figure 11b illustrates the deployment costs of various methods as the number of terminal devices increases. The figure reveals an upward trend in deployment costs for all four methods as the number of devices increases. Among the four algorithms, IBGA consistently demonstrates superior performance and lower costs. The randomized algorithm displays significant cost fluctuations due to its unrestricted nature. This is attributed to the growing number of devices, resulting in increased task volume and higher demand for computing resources. Consequently, more expensive nodes are selected to meet the higher resource requirements, resulting in escalated deployment costs.

6.2. Analysis of the Results of the Mobile Device Edge Node Placement Algorithm

In mobile device scenarios, it is important to note that the determination of candidate location points for nodes becomes a challenging task. As a result, the range of potential edge node deployments remains uncertain. In our laboratory environment, all inspection vehicles are equipped with identical functions and generate similar task requests. Therefore, a single type of edge node is deployed, and the primary factor influencing overall deployment cost is the number of nodes. In this section, we specifically examine the impact of varying the number of edge nodes on the overall task delay. To evaluate the performance of ISCSO, we use random distribution and mean distribution algorithms [37] as benchmark methods. Additionally, we compare ISCSO with other algorithms, such as SCSO and PSO [38], in terms of task completion time and deployment cost.

Currently, the laboratory has a total of 20 mobile carts. To simulate small-scale, medium-scale, and large-scale mining environments, we conducted three sets of experiments, with 5, 10, and 20 trolleys placed in each set, respectively. Considering the limited coverage of edge nodes, a minimum of three nodes must be deployed to ensure task completion. As the number of mobile devices increases, the number of nodes deployed remains fewer than the number of devices. Consequently, we deployed [3, 5], [3, 9], and [3, 18] nodes across the three experimental sets. Observing Figure 12, Figure 13 and Figure 14, it becomes evident that the total delay of all algorithms increases with the growing number of mobile devices. This is due to the increased task volume generated by the higher number of devices, leading to a corresponding rise in total task completion delay.

Figure 12 illustrates the relationship between task completion delay and the number of nodes, with the number of cars set at 5. As shown in Figure 12a, the overall task delay decreases as the number of nodes increases. As the number of edge nodes increases, additional computational resources are provided, leading to a higher number of tasks being processed. Consequently, the overall delay decreases with the increase in the number of nodes. After analysis and comparison, the ISCSO algorithm demonstrates a delay reduction of up to 45%, outperforming the other four algorithms in minimizing delay. This improvement is attributed to the proposed algorithm’s consideration of device mobility and the correlation between tasks and locations, which leads to a more effective node matching model. Furthermore, the enhanced spiral search and Lévy flight strategies in the ISCSO algorithm expand the exploration space, enhance the algorithm’s global search capability, and facilitate the identification of the optimal solution in a shorter time. Figure 12b represents the deployment positions and coverage ranges of the nodes. Figure 12c shows that as the number of iterations increases, the device coverage stabilizes at 67%, and the algorithm converges after 200 iterations.

Figure 13 depicts the relationship between task completion delay and the number of nodes with a fleet size of 10 cars. As shown in Figure 13a, the total task delay decreases as the number of nodes increases. After analysis and comparison, the ISCSO algorithm demonstrates a reduction in total delay by up to 13%, outperforming the other four algorithms in minimizing delay. In Figure 13b, the deployment location and coverage of the nodes are illustrated. In contrast, Figure 13c demonstrates thatas the number of iterations increases, the device coverage stabilizes at 90%, and the algorithm converges after 300 iterations.

Figure 14 illustrates the relationship between task completion delay and the number of nodes when the number of cars is set to 20. Figure 14a demonstrates that the total task delay decreases as the number of nodes increases. After analysis and comparison, the ISCSO algorithm demonstrates a reduction in total delay by up to 23%, outperforming the other four algorithms in minimizing delay. Figure 14b illustrates the deployment location and coverage of the nodes. In contrast, Figure 14c reveals that as the number of iterations increases, the device coverage stabilizes at 99%, and the algorithm converges after 150 iterations.

The time complexity of the ISCSO algorithm is influenced by factors such as population size, dimensionality, and the computational complexity of the fitness function. In this study, we analyze the time complexity of fitness evaluations and location update operations. Assuming that the number of sand cats is ME and the dimension D, the complexity of the fitness function is f(D). The time complexity of the whole iterative process is $O(MAXGEN\ast ME\ast (D+f\left(D\right)\left)\right)$. Even in environments with significant changes or the presence of obstacles, the ISCSO algorithm demonstrates strong robustness and consistently identifies optimized paths.

The proposed scheme demonstrates that the rational deployment of edge nodes can enhance the real-time monitoring capabilities of devices, optimize data processing, and improve decision-making processes. Firstly, by reducing task response times and optimizing data flow, the system can detect equipment failures or abnormal conditions more rapidly, thereby providing early warnings and reducing both downtime and maintenance costs. Secondly, it reduces the dependence on central servers, enhances the speed and accuracy of data processing, enables real-time decision-making at the edge nodes, and minimizes the demand for network bandwidth. Finally, by deploying IBGA and ISCSO algorithms to optimize the deployment location of the edge nodes, it not only improves the efficiency of task processing, but also makes more accurate decisions based on real-time data, and the intelligent decision-making process effectively improves the flexibility and responsiveness of mine management.

The approach presented in this paper has demonstrated promising results. However, the limitations of the experimental simulation conditions, coupled with the variability across different mining environments, may lead to deviations in the algorithm’s performance. For Assumption 1, it is important to note that not all tasks necessarily require service by edge nodes. Mandating that every task be handled by at least one edge node could result in resource over-allocation or inefficiency. For Assumption 2, some edge nodes may serve purposes such as data aggregation or collaboration with other nodes, rather than directly providing computational resources. Requiring each edge node to directly serve devices could lead to unnecessary node deployment, overlooking the potential roles these nodes may play in network orchestration or data processing. For Assumption 3, in real-world scenarios, the response time of an edge node can be influenced by factors such as network latency, device load, and other external conditions. Enforcing a strict requirement that the response time always remains within a predefined maximum value may lead to overly conservative node selection, potentially hindering the optimal allocation of tasks. For Assumption 4, the cost of deploying an edge node encompasses not only the initial hardware purchase but also long-term expenses, such as operation and maintenance, energy consumption, and bandwidth usage. Strictly limiting the deployment cost of edge nodes may result in excessive resource optimization, potentially compromising system performance or scalability. These assumptions may make the model over-idealized and ignore the complexities of practical applications.

Meanwhile, in underground mines or remote areas with limited network connectivity and device availability, the deployment methodology must account for factors such as energy consumption, communication latency, and redundancy design to ensure system stability and efficiency. The types of equipment and tasks in different mining environments vary significantly, necessitating deployment methods that dynamically adjust node placement and load distribution based on the processing capacity of the equipment, the computational intensity of the tasks, and the data transmission requirements. Therefore, future research should focus on relaxing these assumptions, customizing them according to the environmental characteristics, equipment requirements, and economic considerations of different mining operations. This would enable the development of a more realistic edge node deployment model, thereby enhancing the system’s flexibility and adaptability.

7. Conclusions

This paper investigates the challenge of edge node deployment in mining environments, categorizing the problem into two primary scenarios: edge node deployment for fixed devices and for mobile devices. These categorizations are based on the specific characteristics of application scenarios and production environments. For the fixed equipment scenarios, we conducted a thorough analysis that took into account response delays and deployment costs. A weighted multi-objective optimization model was developed for node deployment, and the IBGA method was introduced to achieve near-optimal solutions. A testing platform integrated with the existing production line system was established to comprehensively evaluate the performance of the algorithm. The experimental results enabled a detailed analysis of the relationship between latency, deployment costs, and the number of devices and edge nodes. Ultimately, the findings demonstrate that the proposed method consistently outperforms alternative approaches in both efficiency and cost-effectiveness. In the mobile device scenario, we formulated an edge node deployment model focused on minimizing task completion delay and applied the ISCSO algorithm to derive the optimal solution. This study represents the first application of the SCSO algorithm to address node placement challenges, particularly in a mobile device simulation environment using a laboratory-developed inspection vehicle. The performance of the proposed algorithm was rigorously evaluated within this context. Empirical findings demonstrate that ISCSO consistently outperforms other algorithms in minimizing total delay. Therefore, the method proposed in this paper can ensure the minimal delay and deployment cost in the mining environment. In the future, we will further optimize the node deployment plan based on the service distribution of edge nodes.