An Artificial Plant Community Algorithm for Collision-Free Multi-Robot Aggregation

Abstract

Multi-robot aggregation is an important application for emergent robotic tasks, in which multiple robots are aggregated to work collaboratively. In this context, the collision-free problem poses a significant challenge, which is complicated to resolve, as aggregated robots are prone to collision. This study attempts to use robotic edge intelligence technology to solve this problem. First, a multiple objective function is built for the collision-free multi-robot aggregation problem, considering the characteristics of robotic aggregation and collision-free constraints. Second, a heuristic artificial plant community algorithm is proposed to obtain an optimal solution to the developed problem model, which is lightweight and can be deployed on edge robots to search for the optimal route in real-time. The proposed algorithm utilizes the swarm learning capability of edge robots to produce a set of collision-free aggregation assignments for all robots. Finally, a benchmark test set is developed, based on which a series of benchmark tests are conducted. The experimental results demonstrate that the proposed method is effective and its computational performance is suitable for robot edge computing.

1. Introduction

Due to their good mobility and fatigue resistance, various robots and unmanned aerial/ground vehicles—such as robotic arms, auto-guided vehicles (AGVs), unmanned aerial vehicles (UAVs), and unmanned surface vehicles (USVs)—have been widely used to replace humans in carrying out dangerous and complex tasks [1]. Collaboration and aggregation among multiple robots often provide advantages that cannot be achieved with a single robot [2]. However, collisions are also prone to occur during the aggregation of various robots. The collision-free multi-robot aggregation problem (CMAP) is a significant challenge that arises in many real-world applications. To address the CMAP, multiple robots must be assigned in an optimal manner to implement geographically distributed tasks collaboratively while avoiding collisions and ensuring a minimal makespan (i.e., the completion time of the last task) [3]. In many security and rescue applications, multiple robots are often required, and consideration of the CMAP can allow for optimized assignments, instructing the robots to aggregate to achieve important goals while simultaneously avoiding collisions. For example, when facing a fire, it is often necessary for a swarm of robots to aggregate and carry out firefighting tasks on important fire sources, as serious fires can cause huge losses of life and property [1,3].

However, finding the global optimal solution to the CMAP is not an easy task, making the CMAP a challenging issue. For example, the emergence of a task is random, chaotic, and unpredictable [1,4], and it is generally impossible to know in advance where the next emergency task will appear in large-scale firefighting and disaster rescue situations. Popular methods often divide the CMAP into two sub-problems: the multi-robot aggregation problem [5] and the collision-free multi-robot problem [6]. In each sub-problem, collaboration between multiple robots allows each task to be assigned to various robots, expanding the search space to that of non-collaborative task assignment problems [7]. In a dynamic scenario, multiple robots search for the goals to complete tasks, and more robots can dynamically aggregate to execute the emergent missions. A tiny disturbance in the solution process may produce a different makespan; therefore, the CMAP is NP-hard and requires too high of a computational cost to be effectively solved in real time.

To address this complicated problem, researchers have developed many methods to guide the activities of robots. Heuristic algorithms often achieve near-optimal results in a very short time and are considered promising for the execution of multi-robot system missions; such algorithms include grey wolf optimization (GWO) [2], the genetic algorithm (GA) [3], particle swarm optimization (PSO) [4], fuzzy logic (FL) [5,6], ant colony optimization (ACO) [7], deep learning (DL) [8], and reinforcement learning (RL) [9]. In the CMAP context, any delay in a task may result in a large aggregation of emergent tasks, making the solution space very rugged. The following emergent tasks are not yet detected by most robots, as they have not arrived at this point. Artificial intelligence-based approaches [10] can effectively help to allocate the task to a suitable robot through the analysis and synthesis of environmental information and task data.

However, most studies focused on the CMAP have separately focused on aggregation or collision, where the aggregation and collision information are not integrated [11]. If only an optimal solution for the aggregation problem or collision problem is obtained, it may be impossible to obtain an optimal solution to the global problem [12,13]. Additionally, traditional solution methods and heuristic algorithms cannot efficiently search for all solutions in uncertain environments [14,15]. When an emergent task is detected, it is difficult to modify the pre-planned solution to re-assign all tasks. Our research motivation is to solve the CMAP efficiently. For this purpose, a robotic edge intelligence (REI) architecture [10] is established, a multi-objective CMAP function is designed, a novel swarm search algorithm is proposed, and a CMAP benchmark test set is developed.

This article provides the following contributions:

First, a multi-objective CMAP function is designed that integrates the makespan, collision time, energy consumption, and total distance with battery capacity constraints for collision-free multi-robot aggregation problems. The aggregation problem and the collision-free problem are integrated while considering time-varying tasks, collaboration between robots, and dynamic environments.

Second, a novel heuristic algorithm is proposed, which can be deployed on edge robots to efficiently handle the dynamic relationships between robots and tasks. The algorithm is improved on the basis of an artificial plant community (APC) [16,17], has low hardware requirements and simple parameters, and can be run on the embedded robotic platforms.

Third, a CMAP benchmark set is developed and investigated based on references [18] and [19], which takes the characteristics of the collision-free multi-robot aggregation problem into consideration, including the number of robots and tasks, dynamic processing time, and travel time.

The remainder of this article is organized as follows. Section 2 reviews the related work. Section 3 illustrates the REI architecture. Section 4 builds a multi-objective model for solving the CMAP. Afterward, the proposed APC algorithm is introduced in Section 5. Section 6 presents the benchmark set and experimental studies. Finally, the conclusions are drawn in Section 7.

2. Related Work

This section introduces the related work on the collision-free multi-robot aggregation problem. In automated production lines for complex products, multiple robots often need to gather together to simultaneously complete collaborative processing tasks that cannot be completed by a single robot [8]. In a smart warehousing system, different logistics robots often aggregate in a certain area for simultaneous loading and unloading. In a benchmark test, we also demonstrated a scenario of multi-robot collaborative processing in a real factory [11]. The CMAP is a kind of combinational optimization problem that integrates various factors in relation to both robots and tasks. The related literature can be divided into two categories, namely, studies focused on the multi-robot aggregation problem or studies on the collision-free multi-robot problem.

2.1. Multi-Robot Aggregation Problem

Due to the fact that collaboration between multiple robots can greatly improve work efficiency and allows for the completion of tasks that a single robot cannot handle, multi-robot systems have begun to be widely applied, leading to the emergence of the multi-robot aggregation problem. An aggregation of multiple robots can form swarm intelligence that a single robot does not possess, while the failure of one or several of the robots will not affect the normal operation of the entire multi-robot system [2].

To solve the multi-robot aggregation problem, one must determine how to assign multiple robots to multiple tasks in a way that optimizes the scheduling performance of the multi-robot system. Many researchers have proposed a variety of methods to address the multi-robot aggregation problem, which can be categorized into static coordination strategies and dynamic methods.

First, static coordination strategies involve pre-arranging multiple robots to coordinate and execute each task simultaneously. A recruitment coordination strategy is a commonly used method to address the multi-robot aggregation problem through robot recruitment. If the business increment of a task is greater than the ability of the assigned robot and the robot cannot complete the task alone, more robots will be aggregated to complete the task collaboratively. In [20], a mobile federated learning approach with unreliable participants and selective aggregation was proposed. Static coordination strategies often require an integrated coordination center to provide a theoretically optimal task assignment for the small-scale static multi-robot aggregation problem, where many factors are ignored. Integrated coordination strategies allow for the pre-generation of a task assignment within a short time [21]. As these strategies do not consider the dynamic task environment during the task implementation process, they may become ineffective in many dynamic scenarios, such as fire extinguishing and earthquake rescue. Therefore, the quality of the pre-planned solutions under static coordination strategies may not meet the actual dynamic needs.

Therefore, dynamic methods employ real-time searches to obtain a good balance between makespan and the workloads of robots. The multi-man–robot problem is often modeled as a mixed-integer programming (MIP) model [22], which cannot be solved in advance. Dynamic algorithms do not require manual intervention during the task scheduling process and can obtain near-optimal solutions in a relatively limited time; such algorithms include the GA [3], FL [5,6], RL [9], and flocking-based self-organized aggregation [15]. Dynamic methods can be applied in many uncertain scenarios, where each distributed node can dynamically produce a feasible task assignment to balance the makespan of all tasks. These dynamic algorithms often employ a heuristic search mechanism to obtain good performance when solving the multi-robot aggregation problem [23]. However, the search behaviors of heuristic algorithms often lead to their premature limitation to local optimal solutions. As such, it is difficult to apply them to adjust the solution according to the dynamic task environment in real time.

2.2. Collision-Free Multi-Robot Problem

The collision-free multi-robot problem is another major challenge for multi-robot systems. When a large number of robots work together in collaboration, due to their high mobility, the avoidance of collisions and conflicts is a problem that must be considered.

One method involves installing various sensors, video surveillance devices, and radars on robots, thus enhancing their ability to perceive the environment and reduce collisions and conflicts [11,24]. With the help of various sensors, the IoT, and remote communication technologies, multiple robots can be applied to carry out tasks in unknown environments and high-risk instances.

Another method involves performing path planning and re-planning for robots, ensuring that the running routes or topologies of different robots do not collide or conflict [19]. In a dynamic environment, the obstacles or robots cannot be known until they are detected. Then, a re-planned route is generated for the robot in order to adaptively avoid obstacles, with this process being carried out in real time. In [25], a model-free visual servo swarming method for manned USVs considering visibility maintenance and collision avoidance was proposed. Heuristic algorithms—such as the artificial bee colony (ABC) algorithm [18], model–reference reinforcement learning [24], the A*-based co-evolutionary approach [26], the whale optimization algorithm (WOA) [27], and PSO [4]—can efficiently generate new routes to prevent collision and conflicts in a swarm of robots. Due to the inherent flaws of various algorithms, scholars have proposed hybrid algorithms that integrate the characteristics of different algorithms and demonstrate significant advantages, such as the fuzzy adaptive WOA [27], an ACO–ABC hybrid algorithm [28], and the WOA-AGA algorithm [29].

2.3. Collision-Free Multi-Robot Aggregation

The collision-free multi-robot aggregation problem has become a popular and interesting challenge over the past few years, with it integrating both the multi-robot aggregation problem and the collision-free multi-robot problem. The difficulty of solving this problem is higher than solving any of its sub-problems [30].

Some researchers have modeled the CMAP as a job–shop scheduling problem (JSP) with transportation [18,21]; however, there are some differences between these problem types, as shown in

Table 1. Difference between the CMAP and JSP with transportation.

Metrics	CMAP	JSP
Fixed objectives	A set of tasks	A set of machines
Moving objectives	A set of robots	A set of jobs
Assignment	Robots to tasks	Jobs to machines
Process	Robot process	Machine process
Transportation	Robots	Vehicles
Aggregation	Robot aggregation	Vehicle aggregation
Collision	Robot collision	Vehicle collision

. As the complex relationships among robots and tasks are time-varying and dynamic, coordinated aggregation execution and collision avoidance are challenging to achieve.

As we can see from Table 1, the JSP is a scheduling problem for fixed machines and moving vehicles, while the CMAP is a scheduling problem involving fixed tasks and moving robots. In JSP with transportation, aggregation and collision issues exist between vehicles instead of machines; however, in CMAP, aggregation and collision issues between robots must be considered. In real applications, the movement of robots is dynamic and random, such that aggregation problems often lead to collision problems (and vice versa). Therefore, the optimal solutions to each of the sub-problems are generally not the optimal solution to the global problem, while dynamic task arrivals make aggregation and collision problems intertwined and difficult to separate. This problem is NP-hard and, so, manually solving the CMAP is very difficult.

In the existing literature on the CMAP, there are some research gaps. First, there is no suitable model that can effectively integrate the two sub-problems [31,32]. High expertise and domain knowledge are required to solve the CMAP, but different scenarios may produce different requirements. Second, there is no solution algorithm that can be efficiently run on embedded robotic platforms for edge computing; furthermore, the existing solution algorithms easily fall into local optima. Third, the performance of existing approaches often deteriorates sharply as the scale of the problem increases. In particular, a tiny delay in a task may lead to a much larger makespan for the other tasks, which may lead to serious issues in large-scale multi-robot systems [31]. Fourth, there is no appropriate benchmark set that can be used to test the performance of methods designed to assess the CMAP.

Our research work aims to help fill these gaps. To the best of our knowledge, no similar method has been developed to solve the collision-free multi-robot aggregation problem.

3. A Robotic Edge Intelligence Architecture

This section first describes the robotic edge intelligence architecture for the collision-free multi-robot aggregation problem, including the state transition diagrams of tasks and robots.

3.1. System Architecture

The proposed robotic edge intelligence architecture for collision-free multi-robot aggregation is depicted in Figure 1. There are two layers: the edge server layer (ESL) and the edge robot layer (ERL). In the edge server layer, there is a cloud center with many cloud servers that act as the edge servers; meanwhile, in the edge robot layer, there are many tasks and robots (e.g., robotic arms, AGVs, UAVs, and USVs).

The edge server layer provides top-layer optimization for the edge robot layer, with various edge servers integrated into the cloud center. Each robot entity in the ERL can be mapped to a virtual objective in the ESL, ensuring efficient task scheduling. Each edge server has a strong capability to perform edge computing, edge storage, communication, and artificial intelligence-based operations. It assigns all tasks to suitable robots when the tasks are accepted. In REI-based multi-robot systems, the ESL determines the fitness function and performs route planning, collision avoidance, robot aggregation, and performance optimization. When assigning tasks to a robot swarm, users need to specify the fitness function of the task in the ESL. Users can also interact with the robots in real-time and adjust the fitness function in a timely manner, based on the actual needs and progress during task execution. The edge servers can pre-arrange the robots’ routes to avoid collisions, balance the tasks between different robot swarms, and optimize operational performance before aggregation of the edge robots. The edge servers can communicate with edge robots and offload computing tasks between them, and the cloud center can complete more complex tasks that an edge robot cannot implement.

The edge robot layer includes many edge robots with edge computing and edge storage capabilities, including sensing, communication, motion control, and artificial intelligence. Each robot (e.g., robotic arm, unmanned aerial vehicle, auto guided vehicle, and unmanned surface vehicle) possesses an on-board processor as an embedded processing center. They can be mapped to the cloud center for task scheduling and can offload edge computing tasks to each other. Multiple robots can work in a coordinated manner to implement more complex tasks, such as collision avoidance and aggregation. Multiple robots perceive and share the external environment through a variety of sensors and communication technology and upload task and vehicle states to the ESL. Artificial intelligence on edge servers and edge robots allows for the formation of swarm intelligence, enabling the efficient processing of state information and optimized collision-free multi-robot aggregation.

Regarding engineering applications, some suggestions have been made for the robotic edge intelligence architecture in order to solve the collision-free multi-robot aggregation problem.

First, the edge servers and edge robots can be isomorphic or heterogeneous. The edge servers can be existing servers in production management systems, providing stronger edge computing capacity, operation rules, and objective functions. The edge robots utilize embedded platforms and on-board sensors to provide context awareness.

Second, the robotic edge intelligence architecture can be decentralized for the implementation of various tasks. Edge servers and edge robots have equal status and can offload computing tasks to each other. To fully utilize their powerful computing capacity, edge servers are often allocated to more complex computing tasks that an edge robot cannot complete.

Third, the distributed collaboration of edge servers and robots allows for the formation of swarm intelligence. The edge computing capacity and the artificial intelligence module are designed to ensure that the REI system can solve the collision-free multi-robot aggregation problem in real time. The computational cost and delay can be greatly reduced, and the computing power increases as the number of robots increases.

Fourth, the edge server layer serves as the virtual layer in the REI architecture, while the edge robot layer serves as the physical layer. They are connected by communication devices and protocols, such that a physical robot in the ERL can be mapped to a virtual robot in the ESL, while a virtual robot in the ESL can schedule a physical robot in the ERL. Task and robot scheduling is carried out based on the state transition diagrams described in the following subsection.

3.2. State Transition Diagram of Tasks

As mentioned above, an accurate scheduling model is important to apply an REI-based multi-robot system, where the design of the model depends on the states of the tasks and robots. The state transitions can help to instruct the REI-based multi-robot system, allowing it to assign tasks to appropriate robots. The state transition diagrams should be universal and applicable to all kinds of multi-robot systems, where each state can be effectively detected by the edge robots. Then, the REI architecture can perceive state information and optimize the scheduling schemes based on the state transition information, thus realizing collision-free multi-robot aggregation.

There are two primary state transition diagrams: the task state transition diagram and the robot state transition diagram.

A task state transition diagram for REI-based multi-robot systems is shown in Figure 2. There are five task states and five state transition processes (corresponding to the ellipses and arrows in the figure, respectively). The ellipses indicate the state of tasks, while the text on the arrows determines the action to trigger the task state transition. The five states are defined as follows, which can be detected and implemented by servers or robots:

• New—This is the initial state of a task. If a task is detected to demand robots, it will be initialized to a new state in the REI system before an assignment.
• Assignment—This is the second state of a task, which involves a new task being assigned to an idle robot. A task can be assigned and scheduled to suitable robots before task processing. The robotic edge intelligence is designed to optimize the assignment scheme in a multi-robot system.
• Processing—If a task is scheduled according to the optimized assignment and corresponding robots are allocated, then the task can be processed by the assigned robots.
• Waiting—During the task processing on a robot, an interruption (i.e., collisions resulting in collaborative robots not reaching the gathering point in time) will break off it. Then, the interrupted task will be in a waiting state. If the interruption is completed, all waiting tasks need to be returned to the assignment state, in order to further check whether the original assignment is available and whether it needs to be reassigned.
• End—If a task is completed, it will be eliminated from the REI system and, at the same time, the assigned robot is considered to be idle again.

3.3. State Transition Diagram of Robots

A robot state transition diagram for robotic edge computing is shown in Figure 3. There are five robot states and five state transition processes in total (corresponding to the ellipses and arrows in the figure, respectively). The ellipses indicate the states of the robots, while the text on the arrows determines the action to trigger the robot state transition. The five states are described as follows:

• Idle—A robot will first be initialized to the idle state, which means that it has not been assigned any tasks.. Only an idle robot can be assigned to a task in REI systems.
• Occupied—When a robot is assigned to a task, the idle robot is occupied by the task and cannot be occupied by other tasks.
• Aggregation—If an occupied robot is scheduled, then it begins to move and aggregate to the destination.
• Collision avoidance—If a collision event is predicted, the robot begins to adjust its motion control to avoid collisions, including deceleration, acceleration, stopping, and detouring. When the collision is avoided, the robot will continue aggregation.
• Processing—After the robot reaches the aggregation destination, the robot will process the assigned task. If all tasks are completed, the robot will be set to the idle state again and can be allocated to the next task.

4. The Collision-Free Multi-Robot Aggregation Problem

This section describes the collision-free multi-robot aggregation problem, which integrates the multi-robot aggregation problem and collision-free multi-robot problem. The notations and their descriptions are given first, followed by the multi-objective function of the CMAP. Then, the constraints of the proposed CMAP model are discussed.

4.1. Notation and Description

The notations used in this article are described in

Table 2. Notations and description.

Notation	Description
$G$	An undirected graph
$T$	The set of tasks
$O$	The set of operations
$O_{Ta}$	$\mathrm{The} \mathrm{set} \mathrm{of} \mathrm{operations} \mathrm{in} \mathrm{task} T_a$
$E$	The set of assignment edges
$R$	The set of robots
$T_a$	$\mathrm{Each} \mathrm{vertex} T_a\in T$ is a task
$T_{max}$	The number of tasks
$O_{Taj}$	$\mathrm{The} \mathrm{operation} \mathrm{in} \mathrm{task} T_a$
$O_{Tamax}$	$\mathrm{The} \mathrm{number} \mathrm{of} \mathrm{operations} \mathrm{in} \mathrm{task} T_a$
$E_{ab}$	Each assignment edge
$R_i$	$\mathrm{The} \mathrm{robot} \mathrm{with} \mathrm{index} R_i\in R$
$R_{max}$	The number of robots
$B_{Ri}$	$\mathrm{The} \mathrm{load} \mathrm{ability} \mathrm{of} R_i$
$C_{Ri}$	$\mathrm{The} \mathrm{battery} \mathrm{capacity} \mathrm{of} R_i$
$X$	The set of solutions
$x$	A solution
$x_{ab}^{Ri}$	The robot selection bit
$y_x$	The code value of a solution
$fit$	A set of objective values
$d_{Ta}\left(k\right)$	$\mathrm{The} \mathrm{demand} \mathrm{of} T_a$$\mathrm{accumulated} \mathrm{at} \mathrm{time} k$
$d_{Ta}\left(0\right)$	The initial demand
$c_{Ta}$	$\mathrm{The} \mathrm{inherent} \mathrm{increment} \mathrm{rate} \mathrm{of} T_a$
$D_T^{travel}$	$\mathrm{The} \mathrm{total} \mathrm{travel} \mathrm{distance} \mathrm{of} T$
$D_{Ta,Tb}^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{distance} \mathrm{from} T_a$$\mathrm{to} T_b$
$k_{Ta}\left(0\right)$	$\mathrm{The} \mathrm{detection} \mathrm{time} T_a$
$k_{Ri,Ta}^{start}$	$\mathrm{The} \mathrm{start} \mathrm{time} \mathrm{of} R_i$$\mathrm{at} T_a$
$k_{Ri,OTaj}^{start}$	$\mathrm{The} \mathrm{start} \mathrm{time} \mathrm{of} R_i$$\mathrm{at} O_{Taj}$
$k_{Ri,Ta}^{end}$	$\mathrm{The} \mathrm{completion} \mathrm{time} \mathrm{of} R_i$$\mathrm{at} T_a$
$k_{Ri,OTaj}^{end}$	$\mathrm{The} \mathrm{completion} \mathrm{time} \mathrm{of} R_i$$\mathrm{at} O_{Taj}$
$k_{Ta}^{end}\left(0\right)$	$\mathrm{The} \mathrm{completion} \mathrm{time} \mathrm{of} T_a$ at the depot
$k_{Ta}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{time} \mathrm{of} T_a$
$k_{OTaj}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{time} \mathrm{of} O_{Taj}$
$k_{Ta,Tb}^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{time} \mathrm{from} T_a$$\mathrm{to} T_b$
$k_T^{start}$	$\mathrm{The} \mathrm{earliest} \mathrm{start} \mathrm{time} \mathrm{of} T$
$k_T^{end}$	$\mathrm{The} \mathrm{latest} \mathrm{completion} \mathrm{time} \mathrm{of} T$
$k_T^{make}$	$\mathrm{The} \mathrm{maximum} \mathrm{completion} \mathrm{time} \left(\mathrm{makespan}\right) \mathrm{of} T$
$k_T^{coll}$	$\mathrm{The} \mathrm{collision} \mathrm{time} \mathrm{of} T$
$k_T^{make}\left(x,y_x\right)$	$\mathrm{The} \mathrm{completion} \mathrm{time} \mathrm{of} \mathrm{the} \mathrm{solution} y_x$
$e_T^{total}$	$\mathrm{The} \mathrm{total} \mathrm{energy} \mathrm{consumption} \mathrm{of} T$
$e_T^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{energy} \mathrm{consumption} \mathrm{of} T$
$e_{Ta}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{energy} \mathrm{consumption} \mathrm{of} T_a$
$e_{OTaj}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{energy} \mathrm{consumption} \mathrm{of} O_{Taj}$
$p_{OTaj}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{power} \mathrm{of} O_{Taj}$
$e_T^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{energy} \mathrm{consumption} \mathrm{of} T$
$e_{Ta,Tb}^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{energy} \mathrm{consumption} \mathrm{from} T_a$$\mathrm{to} T_b$
$p_{Ta,Tb}^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{power} \mathrm{from} T_a$$\mathrm{to} T_b$
$e_{Ri}^{total}$	$\mathrm{The} \mathrm{total} \mathrm{energy} \mathrm{consumption} \mathrm{of} R_i$
$e_{Ri}^{proce}$	$\mathrm{The} \mathrm{processing} \mathrm{energy} \mathrm{consumption} \mathrm{of} R_i$
$e_{Ri}^{travel}$	$\mathrm{The} \mathrm{travel} \mathrm{energy} \mathrm{consumption} \mathrm{of} R_i$

.

The CMAP can be defined as an undirected assignment graph $G (T, E)$. In the undirected graph, the set of vertices is a task set $T=\{T_0, T_1,\cdots ,T_{Tmax}\}$, while the set of edges is an assignment set $E=\{E_{01}, E_{02},\cdots ,E_{n-1,n}\}$. $T_0$ indicates the task depot, and each edge $E_{ab}=\left(T_a,T_b\right)\in E$ is associated with a travel time $k_{Ta,Tb}^{travel}$ from $T_a$ to $T_b$. In the aggregation process, different robots gather on the same task to perform different operations, where these different operations occur at different times or locations to avoid collisions when robots aggregate. The set of operations is $O=\{O_{T1}, O_{T2},\cdots ,O_{Tmax}\}$, and each task $T_a$ has a set of operations $O_{Ta}=\{O_{Ta1}, O_{Ta2},\cdots ,O_{Tamax}\}$. Hence, each task can be divided into several operations and assigned to a set of robots $R=\{R_0, R_1,\cdots ,R_{Rmax}\}$ for aggregation and implementation. The robots are initially located at task $T_0$, and each robot $R_i$ has a load ability $B_{Ri}$, which denotes the amount of demand that the robot can reduce per time unit. Additionally, each robot $R_i$ has a battery capacity $C_{Ri}$ for energy consumption in processing and travel.

A collision-free multi-robot aggregation problem contains four elements $\mathrm{C}\mathrm{M}\mathrm{A}\mathrm{P}=[T,O,R,E]$. For a set of solutions $X=\{x_0, x_1,\cdots ,x_{xmax}\}$, there is a set of candidate solution $x^{*}=\left\{x_{ab}^{Ri}\right\}$, where the robot selection bit $x_{ab}^{Ri}=$1 if $R_i$ goes from $T_a$ to $T_b$ and 0 otherwise. In CMAP, the position of each task is fixed, and a swarm of robots can aggregate on a task to complete different operations separately. Different robots do not repeat the same operation. During the aggregation process, collisions between robots also need to be prevented.

4.2. Problem Definition

To address the collision-free multi-robot aggregation problem, robots need to be arranged to complete all tasks as soon as possible while, at the same time, ensuring that there is no collision. Therefore, the main objectives include the maximum completion time (makespan) $k_T^{make}$ and the collision time $k_T^{coll}$ of $T$.

The first objective is the maximum completion time (makespan) $k_T^{make}$ of $T$, which is determined by the difference between the earliest start time $k_T^{start}$ and the latest completion time $k_T^{end}$ of $T$, where

$$k_T^{start}=\mathrm{m}\mathrm{i}\mathrm{n}\left\{k_{Ri,Ta}^{start}\right|T_a\in T,R_i\in R\}$$

(1)

$$k_T^{end}=\mathrm{m}\mathrm{a}\mathrm{x}\left\{k_{Ri,Ta}^{end}\right|T_a\in T,R_i\in R\}$$

(2)

According to Equations (1) and (2), the maximum completion time (makespan) $k_T^{make}$ of $T$ can be obtained as follows:

$$k_T^{make}=k_T^{end}-k_T^{start}$$

(3)

The second objective is the collision time $k_T^{coll}$ of $T$, where collision is defined as different robots arriving at the same position at the same time. During the aggregation process, different robots gather on the same task to perform different operations. In order to avoid collisions, different robots handle the same task at different positions or different times. Therefore, the collision time can be calculated based on the time it takes for different aggregation robots to reach and leave the same position when processing the same task, and we have

$$k_T^{coll}=\sum _{T_0}^{T_{Tmax}}|k_{Ri+1,OTaj}^{start}-k_{Ri,OTaj}^{end}|$$

(4)

The third objective is the total energy consumption $e_T^{total}$ of $T$, including the processing energy consumption $e_T^{proce}$ of $T$ and the travel energy consumption $e_T^{travel}$. Considering the processing power $p_{OTaj}^{proce}$ of $O_{Taj}$, the processing energy consumption $e_{OTaj}^{proce}$ of $O_{Taj}$ can be calculated as follows:

$$\begin{array}{l}{e}_{OTaj}^{proce}=p_{OTaj}^{proce}(k_{Ri,OTaj}^{end}-k_{Ri,OTaj}^{start});\\ \forall T_a\in [1,T_{max}];\forall R_i\in [1,R_{max}];\end{array}$$

(5)

Thus, the processing energy consumption $e_{Ta}^{proce}$ of $T_a$ can be obtained as follows:

$$e_{Ta}^{proce}={\sum }_{OTaj=1}^{OTamax}{e}_{OTaj}^{proce}; \forall T_a\in [1,T_{max}]$$

(6)

Then, the processing energy consumption $e_T^{proce}$ of $T$ can be described as follows:

$$e_T^{proce}={\sum }_{Ta}^{Tmax}{e}_{Ta}^{proce}; \forall T_a\in [1,T_{max}]$$

(7)

Considering the travel power $p_{Ta,Tb}^{travel}$ from $T_a$ to $T_b$, the travel energy consumption $e_{Ta,Tb}^{travel}$ can be calculated as follows:

$$\begin{gathered} e_{Ta,Tb}^{travel}=p_{Ta,Tb}^{travel}(k_{Ri,Tb}^{start}-k_{Ri,Ta}^{end}); \\ \forall T_a\in [1,T_{max}];\forall R_i\in [1,R_{max}]; \end{gathered}$$

(8)

Then, the travel energy consumption $e_T^{travel}$ of $T$ is

$$e_T^{travel}={\sum }_{T0}^{Tmax}{e}_{Ta,Tb}^{travel}; \forall T_a,T_b\in [1,T_{max}]$$

(9)

According to the processing energy consumption $e_T^{proce}$ of $T$ in Equation (7) and the travel energy consumption $e_T^{travel}$ of $T$ in Equation (9), the total energy consumption $e_T^{total}$ of $T$ can be calculated as follows:

$$e_T^{total}=e_T^{proce}+e_T^{travel}$$

(10)

The fourth objective is the total travel distance $D_T^{travel}$ of $T$, which can be calculated using the travel distance $D_{Ta,Tb}^{travel}$ from $T_a$ to $T_b$; that is,

$$D_T^{travel}={\sum }_{T0}^{Tmax}{D}_{Ta,Tb}^{travel}; \forall T_a,T_b\in [1,T_{max}]$$

(11)

Then, the collision-free multi-robot aggregation problem can be described as a four-objective function, considering the maximum completion time (makespan) $k_T^{make}$ in Equation (3), the collision time $k_T^{coll}$ in Equation (4), the total energy consumption $e_T^{total}$ in Equation (10), and the total travel distance $D_T^{travel}$ in Equation (11):

$$\begin{gathered} Obj=\left\{{\min (k}_T^{make}\right),\min \left(k_T^{coll}\right), \\ \min \left(e_T^{total}\right), \min \left(D_T^{travel}\right)\} \end{gathered}$$

(12)

To address the collision-free multi-robot aggregation problem, we need to arrange the aggregation plan of robots to complete all tasks subject to a series of constraints. Whenever a new task is assigned, the robots executing the assigned task form an undirected graph $G (T, E)$. A complex task can be divided into a series of sub-tasks $T=\{T_0, T_1,\cdots ,T_{Tmax}\}$, enabling each idle robot to aggregate without collision.

As each vertex $T_a\in T$ is a task, it is associated with three factors: the detection/arrival time $k_{Ta}\left(0\right)$, the inherent increment rate $c_{Ta}$, and the initial demand $d_{Ta}\left(0\right)$. Then, a set of constraints can be obtained.

The first constraint is that a task is unknown by the REI system until it is detected. The emergent demand $d_{Ta}\left(k\right)$ of the candidate tasks can be detected by the robotic edge intelligence architecture. The detected demand $d_{Ta}\left(k\right)$ of $T_a$ accumulated at time $k$ can be obtained as follows:

$$d_{Ta}\left(k\right)=d_{Ta}\left(0\right)+c_{Ta}\times (k-k_{Ta}\left(0\right))\ge d_{Ta}\left(0\right)$$

(13)

Each edge $E_{ab}=\left(T_a,T_b\right)\in E$ is associated with a travel time $k_{Ta,Tb}^{travel}$ from $T_a$ to $T_b$. We have

$$k_{Ta,Tb}^{travel}\left(k\right)=k_{Ri,Tb}^{end}-k_{Ri,Ta}^{start}$$

(14)

where $k_{Ri,Tb}^{end}$ represents the completion time of $T_b$.

The second constraint is that a task cannot be executed before it is detected. Therefore,

$$\begin{gathered} k_{Ri,Tb}^{start}\ge k_{Tb}\left(0\right); \\ \forall T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(15)

where $k_{Ri,Tb}^{start}$ is the start time of $R_i$ at $T_b$.

In particular, the start time $k_{Ri,Tb}^{start}$ of $R_i$ at $T_b$ is determined by the completion time $k_{Ri,Ta}^{end}$ of $R_i$ at $T_a$ and the travel time $k_{Ta,Tb}^{travel}$ from $T_a$ to $T_b$; that is,

$$\begin{gathered} k_{Ri,Tb}^{start}=\sum _{a=0}^{T_{max} }\left(k_{Ta}^{end}+k_{Ta,Tb}^{travel}\right)x_{ab}^{Ri}; \\ \forall T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(16)

where $x_{ab}^{Ri}$ is a robot selection bit ($x_{ab}^{Ri}=$1 if $R_i$ goes from $T_a$ to $T_b$ and $x_{ab}^{Ri}=$ 0 otherwise). Equation (16) indicates that a robot immediately aggregates to the next task after the completion of the current task.

The third constraint is that a task cannot be executed before the former task is completed; that is,

$$\begin{gathered} k_{Ri,Ta+1}^{start}\ge k_{Ri,Ta}^{start}+k_{Ri,Ta}^{proce}; \\ \forall T_a\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(17)

The fourth constraint is that a task cannot be completed before processing is completed; that is,

$$\begin{gathered} k_{Ri,Ta}^{end}\ge k_{Ri,Ta}^{start}+k_{Ri,Ta}^{proce}; \\ \forall T_a\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(18)

Then, the fifth constraint for the robot selection bit can be described as follows:

$$\begin{gathered} x_{ab}^{Ri}\in \left\{\mathrm{0,1}\right\};a\ne b; \\ \forall T_a{,T}_b\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(19)

The sixth constraint is that the number of incoming paths should equal the number of outgoing paths for each robot at each task; that is,

$$\begin{gathered} {\sum }_{b=0}^{T_{max}}{x}_{ab}^{Ri}={\sum }_{a=0}^{T_{max}}{x}_{ba}^{Ri}; \\ \forall T_a,T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}]; \end{gathered}$$

(20)

where the binary decision variable $x_{ba}^{Ri}$ takes a value of 1 if there is a path for $R_i$ to go from $T_b$ to $T_a$, and 0 otherwise.

The seventh constraint is that each task can be assigned to each robot at most once; that is,

$$\begin{gathered} {\sum }_{a=0}^{T_{max}}{x}_{ab}^{Ri}\le 1; \\ \forall T_a,T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}] \end{gathered}$$

(21)

The eighth constraint is that the start time and completion time of all the robots at the depot are 0:

$$k_{Ri,Ta}^{start}\left(0\right)=k_{Ta}^{end}\left(0\right)=0;\forall R_i\in [1,R_{max}]$$

(22)

At the final time $k_{Ri,Tb}^{end}$, all tasks are completed and exit the REI system, and the aggregated robots return to the depot to be reset to an idle state for the next task assignment. It should be noted that all completed tasks should be cleared and all robots should be set as idle again.

The ninth constraint is that the demand for each task must decrease to 0 if it is completed:

$$\begin{gathered} d_{Tb}(0)+c_{Tb}\left(k_{Tb}^{end}-k_{Tb}\left(0\right)\right)={\sum }_1^{T_{max}}{\sum }_{i=1}^{R_{max}}{x}_{ab}^{Ri}{B}_{Ri}(k_{Tb}^{end}-k_{Ri,Tb}^{start}) \\ \forall {T_a,T}_b\in [1,T_{max}] \end{gathered}$$

(23)

Equation (23) indicates the constraint of load ability $B_{Ri}$. When the task is completed, the accumulated demand at $k_{Tb}^{end}$ equals the total demand fulfilled by the robots executing until $k_{Tb}^{end}$.

The tenth constraint is that the inherent increment rate $c_{Tb}$ of $T_b$ should be limited in the ability $B_{Ri}$ of $R_i$; that is,

$$c_{Tb}<{\sum }_{i=1}^{R_{max}}{\sum }_{a=0}^{T_{max}}{(x}_{ab}^{Ri}{B}_{Ri});\forall T_b\in [1,T_{max}]$$

(24)

Equation (24) indicates that, for every task, the inherent increment rate of a task must be lower than the total ability of the available robots executing the task, thus ensuring the completion of the task.

The 11th constraint is that the total energy consumption $e_{Ri}^{total}$ of a robot $R_i$ should not surpass its battery capacity $C_{Ri}$; that is,

$$e_{Ri}^{total}\le C_{Ri},\forall R_i\in [1,R_{max}]$$

(25)

The total energy consumption $e_{Ri}^{total}$ of $R_i$ includes the processing energy consumption $e_{Ri}^{proce}$ of $R_i$ and the travel energy consumption $e_{Ri}^{travel}$ of $R_i$. According to the robot selection bit $x_{ab}^{Ri}$, which is 1 if $R_i$ goes from $T_a$ to $T_b$, and 0 otherwise, we have

$$e_{Ri}^{total}=e_{Ri}^{proce}+e_{Ri}^{travel}$$

(26)

$$e_{Ri}^{proce}={\sum }_{OTaj=1}^{OTamax}{x_{ab}^{Ri}p}_{OTaj}^{proce}(k_{Ri,OTaj}^{end}-k_{Ri,OTaj}^{start}); \forall T_a,T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}]$$

(27)

$$e_{Ri}^{travel}={\sum }_{Ta}^{Tmax}{x}_{ab}^{Ri}{p}_{Ta,Tb}^{travel}(k_{Ri,Tb}^{start}-k_{Ri,Ta}^{end}); \forall T_a,T_b\in [1,T_{max}];\forall R_i\in [1,R_{max}]$$

(28)

The objective of the proposed CMAP model is to search for the optimal solution to minimize the objective function in Equation (12) on a set of solutions satisfying Equations (13)–(28).

It is challenging to search for all solutions to the CMAP. Given a solution $x=\{x_0, x_1,\cdots ,x_{xmax}\}$ and its solution $y_x$ for all of the $x_{ab}^{Ri}$ values, the makespan can be calculated as follows:

$$k_T^{make}\left(x,y_x\right)=\underset{T_b\in [1,T_{max}]}{\mathrm{m}\mathrm{a}\mathrm{x}}{k}_{Ri,Tb}^{end}-\underset{T_a\in [1,T_{max}]}{\mathrm{m}\mathrm{i}\mathrm{n}}{k}_{Ri,Ta}^{start}$$

(29)

where $k_{Ri,Ta}^{start}$ and $k_{Ri,Tb}^{end}$ are calculated from $x$ and $y_x$. In the proposed CMAP model, each code $y_x$ is represented as a binary string of robot selection bits for a solution $x$.

In the aggregation process, the maximum completion time (makespan) $k_T^{make}$ and the collision time $k_T^{coll}$ are evaluated as a value $Obj$. A task with a shorter processing time, a smaller travel time, and a smaller demand tends to be completed earlier. As the maximum completion time (makespan) $k_T^{make}$ and the collision time $k_T^{coll}$ are often conflicting, and as there are a lot of constraints, it is very difficult to solve the CMAP. In the following section, a novel artificial plant community algorithm is explored in order to help us address the CMAP.

5. An Artificial Plant Community Algorithm

To solve the collision-free multi-robot aggregation problem, this section exploits an artificial plant community algorithm running on a swarm of edge robots. The APC algorithm, proposed in [16,17], is lightweight and has few parameters. It is improved here to enable it to effectively run on the embedded platforms of edge robots and to be suitable under a variable population size. With the edge computing capability of a large number of robots, the improved APC algorithm can help us to search for the optimal solution to the collision-free multi-robot aggregation problem.

5.1. APC-Based REI

The APC algorithm is based on the growth process of a real plant community, which searches for optimal solutions through the heuristic learning of a swarm of plant individuals. For engineering applications, some suggestions for APC-based REI have been proposed, as detailed below.

First, the APC algorithm can be deployed as a local computing method. This refers to running the APC algorithm directly on edge robots or other terminal devices, which enables the data processing and convergence computation of the APC algorithm to be completed locally on the edge robots without the need for network transmission of data. The advantage of this approach is its high efficiency and real-time performance, making it suitable for scenarios with extremely high real-time requirements, such as fire monitoring.

Second, the APC algorithm can also be deployed as an edge computing method. This involves deploying the APC algorithm on edge computing devices in the user’s local area network environment, such as edge boxes or edge routers. The advantages of this approach include fast data processing speed, reduced transmission time of data in the network, and reduced network burden and bandwidth pressure. The APC algorithm uses simple and/or/not operators and is thus suitable for the embedded platforms on edge computing devices.

Third, the APC algorithm can also be deployed as a cloud computing method. In this approach, the APC algorithm is run on the cloud servers for remote access through the Internet, where the cloud servers run the APC algorithm for scheduling and convergence. The associated advantages are strong computing power and ensuring the security and privacy of data. Hence, the APC algorithm may perform better in dynamic aggregation and collision environments, and each edge robot can join or leave the REI system at any time. However, the APC calculation process may result in certain delays and higher costs. If the network is interrupted, the system may not function properly.

Finally, the APC algorithm can also be deployed in a hybrid manner, using a combination of the three methods described above. The advantages of this approach include easy management and expansion, as well as the ability to dynamically adjust the computing resources according to needs; however, it increases the complexity of the APC system. The artificial plant community is randomly distributed on all edge robots or edge servers, and searches for feasible solutions to the collision-free multi-robot aggregation problem.

5.2. Solution Steps of the APC

According to the APC-based REI architecture, the solution steps of the APC algorithm are illustrated in this section in detail. The solution process is composed of five primary steps: initialization, seeding, growing, fruiting, and checking for the end condition. An artificial plant individual can be present in three forms in different solution steps: a seed, an individual, or a fruit. Each artificial plant form can be changed into each other, and the continuous transformation of APC individuals can help us to solve the CMAP.

5.2.1. Initialization

The initialization step includes three sets of parameters: The parameters of the collision-free multi-robot aggregation problem, the APC parameters, and the parameters of the solution system.

The parameters of the collision-free multi-robot aggregation problem include four elements $\mathrm{C}\mathrm{M}\mathrm{A}\mathrm{P}=[T,O,R,E]$, including a task set $T=\{T_0,T_1,\cdots ,T_{Tmax}\}$, the operation set $O=\{O_{T1},O_{T2},\cdots ,O_{Tmax}\}$, a set of robots $R=\{R_0,R_1,\cdots ,R_{Rmax}\}$, and the assignment edge set $E=\{E_{01},E_{02},\cdots ,E_{n-1,n}\}$. Each task $T_a$ has a set of operations $O_{Ta}=\{O_{Ta1},O_{Ta2},\cdots ,O_{Tamax}\}$. The robots are initially located at task $T_0$, and each robot $R_i$ has a load ability $B_{Ri}$ and a battery capacity $C_{Ri}$.

The APC parameters include the population size $S$, the selection bits of a robot set {$x_{ab}^{Ri}\}$, the seeding probability $p_{seed}$, the growing probability $p_{grow}$, and the fruiting probability $p_{fruit}$. Hence, as a candidate solution set, $X=\{x_1,x_2,\dots ,x_s,\dots ,x_S\}$ represents an artificial plant community, where $x_s$={$x_{ab}^{Ri}\}$. The objective function $Obj$ in Equation (12) can be introduced as a fitness function for the APC algorithm:

$$fit=Const-Obj$$

(30)

where $Const$ is a sufficiently large positive constant. Here, the higher the fitness $fit$ is, the better the artificial plant individuals. The fitness function $fit$ in Equation (30) can help the APC algorithm to choose the best individuals.

The parameters of the solution system are composed of the error threshold $e_{th}$ and the maximum number of iterations ${Ite}_{max}$, where the iteration counter $Ite$ is initially set to be zero.

5.2.2. Seeding of the APC

The seeding process endows the APC with a global search capability, where all APC individuals are in the form of seeds randomly generated in the whole candidate solution space. The random search capability can help to search for more candidate solutions to the collision-free multi-robot aggregation problem, which is defined by a seeding probability $p_{seed}$. There are two scenarios to produce the seeds in the seeding stages.

The first seeding scenario is in the first iteration after initialization. There are no individuals or fruits generated in previous iterations, and initial seeds with a population size $S$ will be randomly generated in the edge robots.

The second seeding scenario occurs in the following iterations. Therefore, fruits generated in the previous fruiting steps with a population size of $S$ can be selected as a part of the seeds, and another part of random seeds with a population size of $p_{seed}\times S$ is also produced. These two types of seeds contain elites and random solutions and have a greater population size of $(1+p_{seed})\times S$.

An artificial plant seed $x_s$ can be encoded as a binary string for robot assignment, as shown in Equation (31):

$$x_s=\left\{x_{ab}^{Ri}\right\}$$

(31)

A binary bit $x_s$ = 1 indicates that a task edge $E_{ab}=\left(T_a,T_b\right)\in E$ from tasks $T_a$ to $T_b$ is selected as the candidate solution of robot $R_i$, while $x_s$ = 0 represents that a task edge $E_{ab}=\left(T_a,T_b\right)\in E$ is not chosen as the candidate solution.

Therefore, the lower the seeding probability $p_{seed}$, the weaker the global search ability, but the faster the convergence rate, possibly even resulting in premature convergence to a local optimum, and vice versa.

5.2.3. Growth of the APC

The survived seeds are determined by the growing probability $p_{grow}$ and a fitness function. The artificial plant seeds with high fitness can grow to generate more fruits, while the other seeds with low fitness do not survive and are removed. Hence, the population size of the APC in the growing stage is reduced to a small value of $p_{grow}\times S$, with the size of the removed population being (1 − $p_{grow})\times S$. On some edge robots with population size (1 − $p_{grow})\times S$, there may be no artificial plant individual; however, other edge robots with a population size $p_{grow}\times S$ may contain elite individuals. Based on the fitness function $fit$ in Equation (30), the growing individuals $x_s^{*}$ can be calculated as follows:

$$x_s^{*}=\left\{x_s^{*}\right|fit\left({x_s^{*}\in Sp}_{grow}\right)\ge fit\left({x_s\in S(1-p}_{grow}\right)\left)\right\}$$

(32)

To choose the best candidate solution in the growing operation, various sorting methods can be employed, such as the direct sort, bubble sort, merge sort, select sort, quick sort, and so on. Different sorting algorithms may have different advantages in terms of temporal and spatial performance. Now, the plant individual with the highest fitness can be selected as the optimal solution. Based on the growing individuals $x_s^{*}$ selected using Equation (32), the best candidate solution can be defined as $x_s^{\#}$ in Equation (33):

$$x_s^{\#}\left(t\right)=\left\{x_s^{\#}\right|fit\left(x_s^{\#}\right)=\mathrm{m}\mathrm{a}\mathrm{x}\left[fit\left(x_s^{*}\right)\right]\}$$

(33)

The local search ability of the APC is determined by the growing probability $p_{grow}$. The lower the growing probability $p_{grow}$, the higher the convergence rate, but the lower the global search ability; as such, a low growing probability $p_{grow}$ may result in a premature convergence to local optima and vice versa.

5.2.4. Fruiting of the APC

The fruiting operation endows the APC with a social learning capability, where the elite plant individuals with high fitness can learn from each other to generate more offspring fruits. This social learning process allows the swarm intelligence of edge robots to search for more candidate solutions, such that the population size increases to its original value $S$.

For the best individual $x_s^{\#}$ with the highest fitness, the fruiting operation will generate identical offspring to preserve the elite information, as shown in Equation (34):

$$x_s^{\prime }(k+1)=x_s^{\#}\left(k\right)$$

(34)

For all individuals, social learning occurs between different individuals to generate more feasible solutions, with a population size of $S-1$.

A cross-factor $C_{fruit}$ can help us decide how many parents exchange information each time to produce offspring. If $C_{fruit}=1$, parthenogenesis is considered and it is suitable to preserve the best candidate solution (i.e., there is no social learning, only self-learning).

If $C_{fruit}=2$, two individuals are employed to generate an offspring each time, and each offspring is composed of social learning information from two parents. If it is assumed that there are two parents $x_s(k-1)=\left\{x_{s1}\right(k-1),\dots ,x_{sl}(k-1),x_{s\left(l+1\right)}(k-1),\dots \}$ and ${x\prime }_s(k-1)=\left\{{x\prime }_{s1}\right(k-1),\dots ,{x\prime }_{sl}(k-1),{x\prime }_{s\left(l+1\right)}(k-1),\dots \}$, a fruit with $C_{fruit}=2$ is shown in Equation (35):

$$\begin{gathered} x_s^{\prime }\left(k\right)=\left\{x_{s1}\right(k-1),x_{s2}(k-1),\dots ,x_{sl}(k-1\left){,x\prime }_{s\left(l+1\right)}\right(k-1),k \\ \mathrm{Or} x_s^{\prime }\left(k\right)=\left\{{x\prime }_{s1}\right(k-1),{x\prime }_{s2}(k-1),\dots ,{x\prime }_{sl}(k-1\left){,x}_{s\left(l+1\right)}\right(k-1),\dots \} \end{gathered}$$

(35)

If $C_{fruit}\ge 3$, three or more individuals are employed to learn from each other, but it also makes the calculation process more complex. Assuming the three parents $x_s(k-1)=\{\dots ,x_{sl}\left(k-1\right),\dots \}$, ${x^{\prime }}_s(k-1)=\{\dots ,{x^{\prime }}_{sl}\left(k-1\right),\dots \}$, and ${x”}_s(k-1)=\{\dots ,{x”}_{sl}\left(k-1\right),\dots \}$, a possible offspring is shown in Equation (36).

$$x_s^{\prime }\left(k\right)=\{x_{s1}\left(k-1\right),\dots ,{x^{\prime }}_{sl}\left(k-1\right),\dots ,{x”}_{s(l+1)}(k-1),\dots \}$$

(36)

In particular, the social learning process helps the APC to recover the population size to the initial value $S$.

In summary, a higher $p_{fruit}$ can retain more information about elites and accelerate the convergence performance. On the contrary, a lower $p_{fruit}$ makes it easier to destroy the information obtained from elites, making it less likely to converge to local optima early.

5.2.5. Checking for the End Condition

The robotic edge devices search for the optimal candidate solutions to the collision-free multi-robot aggregation problem through iterative edge computing of the artificial plant community algorithm. Therefore, a series of end conditions should be preset to instruct the edge robots to justify whether the iteration will be stopped before the optimal candidate solution is output to assign the robots to various tasks and avoid collisions.

The best candidate solution $x_s^{\#}\left(t\right)$ at time $t$ has the fitness $fit\left[x_s^{\#}\left(t\right)\right]$ according to Equation (33), and the best candidate solution $x_s^{\#}(k-1)$ at the previous time step $(k-1)$ has fitness $fit\left[x_s^{\#}\left(k-1\right)\right]$. Hence, the error between two adjacent moments $k$ and $(k-1)$ can be calculated as follows:

$$error\left(k\right)=|fit\left[x_s^{\#}\left(k\right)\right]-fit[x_s^{\#}\left(k-1\right)\left]\right|$$

(37)

Then, an error threshold $e_{th}$ can be introduced to determine whether the iterative calculation process can be completed.

$$\left\{\begin{array}{c}if error\left(k\right)\le e_{th},then go to end.\\ else, then return to the seeding step.\end{array}\right.$$

(38)

If the edge robots determine that the $error\left(k\right)$ in Equation (36) is not higher than the predefined threshold $e_{th}$, then the iteration can be completed, and the optimal candidate solution $x_s^{\#}\left(t\right)$ can be output for assignment. Otherwise, the fruits obtained from this calculation will serve as the seeds for the next iteration, starting a new round of iteration until the end conditions are met.

5.3. Algorithm Flow

As shown the APC algorithm flow shown in Figure 4, based on the iterative execution of the seeding, growing, and fruiting operations, the edge robots can search for the optimal candidate solution to the collision-free multi-robot aggregation problem through the swarm intelligence of multi-robot systems.

The algorithm flow in Figure 4 is composed of five primary steps and a big loop, including initialization, seeding operation, growing operation, the fruiting operation, and checking for the end condition. During initialization, the parameters of CMAP, the APC parameters, and the solution system parameters—that is, the fitness function in Equation (30)—are defined. In the seeding operation, random seeds are generated according to the seeding probability p_seed, and seeds are produced from the previous fruits. In the growing operation, fitness calculation and comparison are conducted in order to determine the optimal seeds to grow according to the growing probability p_grow, selecting the seeds with the highest fitness. In the fruiting operation, fruits are generated according to the fruiting probability p_fruit, and optimal fruits are generated via parthenogenesis. After checking for the end condition, the APC will decide to continue the calculation loop or output the optimal candidate solution to the CMAP.

According to the APC algorithm flowchart shown in Figure 4, the pseudo-code for robotic edge implementation is shown in Algorithm 1. This algorithm describes the solution process of the APC algorithm with respect to the collision-free multi-robot aggregation problem, where the candidate solution is encoded using Equation (31), the fitness function is that given in Equation (30), and the constraints are Equations (13)–(28). The task state transition process is shown in Figure 2, and the robot state transition process is shown in Figure 3.

Algorithm 1: The APC to solve the CMAP

Then, the best candidate solution to the CMAP will be output for robot assignment. Algorithm 1 depicts the solution process for a collision-free multi-robot aggregation problem, where the APC individuals are encoded as a feasible solution via Equation (31). The fitness function in Equation (30) and constraints in Equations (13)–(28) are employed to instruct the APC to search for the optimal candidate solutions. When implementing the optimal candidate solution, the robots will be assigned to a suitable task, and the state transitions of tasks and robots will change during assignment. In Algorithm 1, after a task is completed, the completed task disappears from the REI system and will no longer be reused, while the robot that completed the task can be reused for the next task. Overall, when the number of robots is N, the computational complexity of this algorithm is $O\left(N^2\right)$.

6. Benchmark Data and Experiments

This section describes the design of a series of benchmark data used to test the proposed REI-based method in order to solve the collision-free multi-robot aggregation problem, including the benchmark data set, experimental results, and performance comparison.

6.1. Benchmark Test Set

To test the collision-free multi-robot aggregation problem solution process, the benchmark data used in [18,19] are introduced and modified herein, which were collected in a production workshop scenario. Based on the proposed REI model, the benchmark data were modified to reflect a scenario with 15 fixed tasks, 15 operations, and 15 robots, which is more complex than the benchmark tests detailed in [18,19]. In [18], 15 flowing jobs and 15 fixed machines were considered but not transportation; meanwhile, in [19], 15 flowing jobs, 8 fixed machines, and 15 AGVs were considered. Due to the more complex obstacle placements and higher robot densities, we designed a unidirectional loop consisting of 15 fixed tasks with a total length of 140 m and an equal distance between consecutive tasks of 10 m, as shown in Figure 5. Based on the layout of the actual production systems used in [18,19], Figure 5 provides the benchmark test roadmap of the 15 fixed tasks to simplify the calculations and as a benchmark comparison for international peers.

In Figure 5, there is a 10 m interval between adjacent pairs of the 15 fixed tasks $T=\{T_1,T_2,\dots ,T_{15}$}, where the considered distance is the Manhattan distance between tasks. For example, the travel distance $D_{\mathrm{1,8}}$ between $T_1 \mathrm{a}\mathrm{n}\mathrm{d} T_8$ can be obtained as 30 m. Hence, the travel distances ${[D}_{ij}]$ between consecutive tasks can be represented as follows (in m):

$${[D}_{ij}]=\left[\begin{array}{ccc}\begin{array}{ccc}-& 10& 20\\ 10& -& 10\\ 20& 10& -\end{array}& \begin{array}{ccc}30& 40& 10\\ 20& 30& 20\\ 10& 20& 30\end{array}& \begin{array}{ccc}\begin{array}{ccc}20& 30& 40\\ 10& 20& 30\\ 20& 10& 20\end{array}& \begin{array}{ccc}50& 20& 30\\ 40& 30& 20\\ 30& 40& 30\end{array}& \begin{array}{ccc}40& 50& 60\\ 30& 40& 50\\ 20& 30& 40\end{array}\end{array}\\ \begin{array}{ccc}30& 20& 10\\ 40& 30& 20\\ 10& 20& 30\end{array}& \begin{array}{ccc}-& 10& 40\\ 10& -& 50\\ 40& 50& -\end{array}& \begin{array}{ccc}\begin{array}{ccc}30& 20& 10\\ 40& 30& 20\\ 10& 20& 30\end{array}& \begin{array}{ccc}20& 50& 40\\ 10& 60& 50\\ 40& 10& 20\end{array}& \begin{array}{ccc}30& 20& 30\\ 40& 30& 20\\ 30& 40& 50\end{array}\end{array}\\ \begin{array}{c}\begin{array}{ccc}20& 10& 20\\ 30& 20& 10\\ 40& 30& 20\end{array}\\ \begin{array}{ccc}50& 40& 30\\ 20& 30& 40\\ 30& 20& 30\end{array}\\ \begin{array}{ccc}40& 30& 40\\ 50& 40& 30\\ 60& 50& 40\end{array}\end{array}& \begin{array}{c}\begin{array}{ccc}30& 40& 10\\ 20& 30& 20\\ 10& 20& 30\end{array}\\ \begin{array}{ccc}20& 10& 40\\ 50& 60& 10\\ 40& 50& 20\end{array}\\ \begin{array}{ccc}60& 80& 60\\ 20& 30& 40\\ 30& 20& 50\end{array}\end{array}& \begin{array}{ccc}\begin{array}{c}\begin{array}{ccc}-& 10& 20\\ 10& -& 10\\ 20& 10& -\end{array}\\ \begin{array}{ccc}30& 20& 10\\ 20& 30& 40\\ 10& 20& 30\end{array}\\ \begin{array}{ccc}40& 20& 40\\ 30& 20& 10\\ 40& 30& 20\end{array}\end{array}& \begin{array}{c}\begin{array}{ccc}30& 20& 10\\ 20& 30& 20\\ 10& 40& 30\end{array}\\ \begin{array}{ccc}-& 50& 40\\ 50& -& 10\\ 40& 10& -\end{array}\\ \begin{array}{ccc}60& 40& 20\\ 20& 30& 20\\ 10& 40& 30\end{array}\end{array}& \begin{array}{c}\begin{array}{ccc}20& 30& 40\\ 10& 20& 30\\ 20& 10& 20\end{array}\\ \begin{array}{ccc}30& 20& 10\\ 20& 30& 40\\ 10& 20& 30\end{array}\\ \begin{array}{ccc}-& 10& 20\\ 10& -& 10\\ 20& 10& -\end{array}\end{array}\end{array}\end{array}\right]$$

Our modified benchmark test has an entrance at task 1, where 15 robots are allowed to be in task 1 initially and can enter or exit the task at any time. The robot speed is limited to between 0.2 m/s and 2 m/s, divided into five different speed levels.

Table 3. The processing times (h) of the tasks.

Operation	${\mathit{T}}_1$	${\mathit{T}}_2$	${\mathit{T}}_3$	${\mathit{T}}_4$	${\mathit{T}}_5$	${\mathit{T}}_6$	${\mathit{T}}_7$	${\mathit{T}}_8$	${\mathit{T}}_9$	${\mathit{T}}_{10}$	${\mathit{T}}_{11}$	${\mathit{T}}_{12}$	${\mathit{T}}_{13}$	${\mathit{T}}_{14}$	${\mathit{T}}_{15}$
$O_1$	0.7	0.8	0.8	0.4	0.4	0.8	0.5	0.6	0.3	0.5	0.5	0.1	0.5	0.2	0.7
$O_2$	0.9	0.5	0.8	0.6	0.5	0.2	0.7	0.7	0.7	0.8	0.8	0.4	0.4	0.1	0.5
$O_3$	0.6	0.2	0.5	0.9	0.6	0.9	0.4	0.8	0.6	0.3	0.5	0.5	0.7	0.5	0.6
$O_4$	0.6	0.3	0.5	0.5	0.7	0.5	0.6	0.7	0.2	0.2	0.8	0.9	0.6	0.4	0.4
$O_5$	0.2	0.7	0.2	0.3	0.4	0.6	0.9	0.9	0.6	0.4	0.3	0.1	0.7	0.4	0.2
$O_6$	0.7	0.4	0.3	0.7	0.7	0.4	0.2	0.2	0.7	0.7	0.3	0.3	0.4	0.6	0.9
$O_7$	0.4	0.5	0.4	0.3	0.5	0.6	0.5	0.3	0.5	0.4	0.3	0.7	0.6	0.7	0.1
$O_8$	0.5	0.4	0.3	0.7	0.6	0.7	0.9	0.2	0.4	0.5	0.4	0.3	0.5	0.6	0.5
$O_9$	0.6	0.6	0.7	0.3	0.7	0.2	0.1	0.8	0.3	0.7	0.3	0.5	0.6	0.9	0.8
$O_{10}$	0.3	0.7	0.3	0.3	0.6	0.9	0.8	0.1	0.6	0.3	0.7	0.5	0.7	0.2	0.1
$O_{11}$	0.4	0.4	0.5	0.5	0.6	0.5	0.8	0.3	0.6	0.6	0.3	0.3	0.1	0.6	0.2
$O_{12}$	0.6	0.6	0.8	0.8	0.1	0.6	0.2	0.5	0.4	0.4	0.5	0.8	0.6	0.5	0.8
$O_{13}$	0.3	0.4	0.7	0.9	0.2	0.4	0.5	0.8	0.1	0.1	0.6	0.2	0.7	0.1	0.2
$O_{14}$	0.2	0.1	0.5	0.6	0.7	0.6	0.1	0.1	0.3	0.4	0.7	0.7	0.2	0.4	0.1
$O_{15}$	0.1	0.4	0.7	0.7	0.8	0.7	0.2	0.3	0.2	0.4	0.2	0.6	0.4	0.6	0.5

shows the processing times $k_{OTaj}^{proce}$ for the 15 tasks $T=\left\{T_1,T_2,\dots ,T_{15}\right\}$, about twice the number of machines in [19]. This modification is more suitable for our complex multi-robot system and the benchmark data are consistent with real-world cases [18]. Comparing with the travel distances in ${[D}_{ij}]$ and the average speed of the robots of about 0.5 m/s, the processing times in Table 3 are greater. As adjusted data referring to the existing literature [18,19] were developed to meet the requirements of multi-robot systems and serve as a proxy to a real-world multi-robot aggregation problem, this adjustment was considered more suitable for our benchmark tests with robot travel.

Table 4. The processing power (kw) for each task.

${\mathit{T}}_1$	${\mathit{T}}_2$	${\mathit{T}}_3$	${\mathit{T}}_4$	${\mathit{T}}_5$	${\mathit{T}}_6$	${\mathit{T}}_7$	${\mathit{T}}_8$	${\mathit{T}}_9$	${\mathit{T}}_{10}$	${\mathit{T}}_{11}$	${\mathit{T}}_{12}$	${\mathit{T}}_{13}$	${\mathit{T}}_{14}$	${\mathit{T}}_{15}$
0.9	1.01	1.14	1.21	1.32	0.91	1.03	1.16	1.22	1.31	0.92	1.02	1.12	1.2	1.33

lists the processing power $p_{OTaj}^{proce}$ for each task, which was modified from the setup power in [19]. Hence, the processing energy consumption $e_{Ta}^{proce}$ and $e_{OTaj}^{proce}$ can be obtained by the product of the processing power values and the processing times in Equations (6) and (7).

The travel power $p_{Ta,Tb}^{travel}$ of the robots with different speed rates is shown in

Table 5. The travel power (W) for each robot.

Rate	1	2	3	4	5
Speed (m/s)	0.4	0.5	0.67	1.0	2.0
Power consumption (W)	60.4	82.8	119.2	191.2	405.8

after modifying the travel power in the benchmark test data [19]. The energy consumption can be obtained by multiplying the travel power values by the travel times using Equations (8) and (9). Compared with the benchmark data [19], there was no apparent modification in the average robot power, as robots only need to walk during the aggregation process, without the need to move goods or transport. Therefore, a robot was considered to consume 0.90–1.22 kW of energy for each operation of a task and 82.8 W to travel at a speed of 0.5 m/s.

Some assumptions were made to simplify the experimental analysis, as follows:

Assumption 1.

It is assumed that the battery carried by the robot has sufficient capacity; there is no need to consider the charging caused by insufficient battery capacity. As the battery of a robot is sufficient to finish multiple tasks after being fully charged, it is reasonable not to consider additional charging during the execution of each task.

Assumption 2.

It is assumed that there is no difference between robots, machines, tasks, or cargo, and human interference, environmental disturbances, malfunctions, and accidents are not considered.

Assumption 3.

It is assumed that different tasks are independent, and different robots are also independent. The intrinsic connections between different tasks are not considered, nor the connections between different robots.

Assumption 4.

It is assumed that different robots perform the same operation without considering any differences in operational details, including different robot walking methods, different manipulating arms, and different levels of power consumption caused by various operations.

6.2. Benchmark Test Results

This section provides the benchmark test results for the proposed APC algorithm. The multi-objective function in Equation (30) is employed for natural selection, which includes the maximum completion time (makespan) $k_T^{make}$ in Equation (3), the collision time $k_T^{coll}$ in Equation (4), the total energy consumption $e_T^{total}$ in Equation (10), and the total travel distance $D_T^{travel}$ in Equation (11). The fitness function is Equation (30). The APC simulation parameters include the population size = 80, the seeding probability $p_{seed}=0.2$, the growing probability $p_{grow}=0.7$, the fruiting possibility $p_{fruit}=0.1$, and the cross-factor $C_{fruit}=2$.

The end conditions included the maximum number of iterations ${Ite}_{max}=200$ and the maximum computation time = 1.0 h. The simulation system was characterized by an AMD Ryzen 3 4300U with Radeon Graphics 2.70 GHz CPU, 8.00 GB RAM, 64-bit Windows 10 operating system, and the MATLAB R2018a simulation software.

Figure 6 presents the processing time for the collision-free multi-robot aggregation problem. The horizontal axis gives the processing time, the vertical axis shows the number of tasks, and the right side presents the travel time, processing time, and makespan of each robot (in fractional form). Each progress bar in Figure 6 is labeled with three numbers enclosed in parentheses, denoting the task number $T_a$, operation number $O_{Taj}$, and processing time $k_{OTaj}^{proce}$. The Gantt chart shows the robot aggregation results and processing time under the minimum makespan, with different tasks marked with different colors. The makespan value in Figure 6 is $k_T^{make}=$ 14.0280 h, and the processing power consumption can be calculated to be $e_T^{proce}=$123.404 kWh, according to the corresponding processing time. Although the travel time value is given on the right, it is not visible in the graph.

Figure 7 shows the travel time for collision-free multi-robot aggregation. The horizontal axis shows the travel time, the vertical axis lists the number of robots, and the right side indicates the travel time and makespan of each robot (in fractional form). All progress bars in Figure 7 are labeled with three numbers enclosed in parentheses, including the task number, operation number, and travel time. Figure 7 verifies the robot aggregation results and travel Gantt chart in accordance with the makespan shown in Figure 6. The total collision time was $k_T^{coll}$ = 0.0 h and, so, the proposed scheduling method realized the collision-free objective. The makespan of the travel time in Figure 7 is $k_{Ta,Tb}^{travel}=$ 13.9280 h, and the corresponding travel energy consumption of $T$ can be obtained as $e_T^{travel}=$ 0.2670 kWh. Therefore, the total energy consumption of all tasks was calculated as $e_T^{total}=$123.6710 kWh. The maximum travel distance in Figure 7 is $\mathrm{m}\mathrm{a}\mathrm{x}\left\{D_{Ta,Tb}^{travel}\right\}=$ 440 m, and the minimum travel distance is $\mathrm{m}\mathrm{i}\mathrm{n}\left\{D_{Ta,Tb}^{travel}\right\}=$300 m, while the total travel distance $D_T^{travel}$ is 5800 m.

After 300 tests, the statistics of the benchmark test are summarized in

Table 6. General statistics of the benchmark data.

Indicator	Solutions
	Minimum	Average	Maximum
The makespan $k_T^{make}$ of all tasks (h)	14.0280	14.9405	16.4168
Total collision time $k_T^{coll}$ (h)	0	0	0
Total energy consumption $e_T^{total}$ (kWh)	123.6710	123.6788	123.6801
Total travel distance $D_T^{travel}$ (m)	5800	5970	6230
Total processing energy consumption (kWh)	123.404	123.404	123.404
Total travel energy consumption (kWh)	0.2670	0.2748	0.2868
The maximum travel distance of robot $R_i$ (m)	440	473	510
The minimum travel distance of robot $R_i$ (m)	270	303	340
The lowest robot speed (m/s)	0.5	0.5	0.5

, where the results demonstrate that the proposed APC algorithm can help us to search for the optimal solution to the collision-free multi-robot aggregation problem. It can be seen that the minimum value of makespan $k_T^{make}$ presented an increase of about 14.55% compared to the maximum value, the total travel distance $D_T^{travel}$ (m) had an increase of about 6.90% compared to the maximum value, and the minimum value of travel energy consumption $e_T^{travel}$ had an increase of 6.90% compared to the maximum value. There is a positive correlation between the total robot energy consumption (kWh) and the maximum travel distance (m) and the travel speed (m/s) in Table 5, where the total processing energy (kWh) of robots was 430.33–462.24 times greater than the travel energy consumption (kWh). The statistical data indicate the total collision time $k_T^{coll}$ = 0.0 h, verifying that the collision-free objective was satisfied in the multi-robot aggregation problem.

Figure 8 shows the convergence curves of the proposed APC algorithm, including the average fitness of the APC population and the best fitness of the optimal solution. The benchmark test results in Figure 6 and Figure 7 were calculated with a maximum number of iterations equal to 200. It can be observed, from Figure 8, that the optimal solution can be obtained by the proposed APC algorithm after about 140 iterations, showing the good convergence performance of the proposed APC algorithm in solving the collision-free multi-robot aggregation problem.

To delve deeper into the entangled factors affecting the collision-free multi-robot aggregation problem, the benchmark results under changing parameters are shown in Figure 9a,b, describing how variations in the parameters affected the main metrics (i.e., the makespan $k_T^{make}$, total collision time $k_T^{coll}$, total travel distance $D_T^{travel}$, and total energy consumption $e_T^{total}$). To present the different variation curves in the same graph, all data were normalized.

The trends of the four main metrics with different distances between tasks are shown in Figure 9a. It can be observed that the the collision-free goal of $k_T^{coll}$ = 0.0 h is reached, where a greater distance between tasks increased the makespan $k_T^{make}$, total travel distance $D_T^{travel}$, and the total energy consumption $e_T^{total}$. When the distance between tasks was in the range of 90–150 m, the makespan $k_T^{make}$ rapidly increased. Maintaining the distance between tasks in the range of 50–90 m is helpful to balance the makespan $k_T^{make}$ and the energy consumption $e_T^{total}$, as the total travel distance $D_T^{travel}$ will decrease and less time will be consumed for aggregation.

The trends of the four main metrics under different robot velocities are shown in Figure 9b. It can be seen that a greater robot velocity is helpful to decreasing the makespan $k_T^{make}$ when the collision-free goal of $k_T^{coll}$ = 0.0 h is achieved. However, a greater robot velocity will increase the total energy consumption $e_T^{total}$, while the total travel distance $D_T^{travel}$ remains stable. When the robot velocity is in the range of 1.0–2.0 m/s, the total energy consumption $e_T^{total}$ will rapidly increase. Therefore, maintaining the robot velocity in the range of 0.5–1.0 m/s helps to balance the makespan $k_T^{make}$ and the energy consumption $e_T^{total}$, as less time will be consumed for robot aggregation and collision avoidance.

Considering Figure 6, Figure 7, Figure 8 and Figure 9, the travel energy consumption is less than the processing energy consumption, and more robots are helpful to improving task efficiency while maintaining a low makespan $k_T^{make}$. To the contrary, fewer robots will tend to increase the makespan $k_T^{make}$ and reduce task efficiency. Additionally, the energy conservation effect caused by fewer robots is less than the increase in the makespan value $k_T^{make}$. For engineering applications, performing tasks at an economical speed helps to conserve energy, and more robots and more energy consumption at faster aggregation velocity can help to improve task efficiency.

6.3. Performance Comparison

Some state-of-the-art algorithms were employed for comparison, including the proposed APC algorithm, grey wolf optimization (GWO) [2], the genetic algorithm (GA) [3], particle swarm optimization (PSO) [4], ant colony optimization (ACO) [7], and deep learning (DL) [8].

All of these SOTA algorithms adopted the same benchmark data described in Section 6.1 and the multi-objective function in Equation (12). Each technique uses a basic version and the same population size. The APC algorithm used the same parameters as detailed above. For GWO, the population size of the gray wolves was set to S = 80, the upper bound of the variables was set as ub = [10, 10], the lower bound of variables was set as lb = [−10, −10], and the dimension of the problem was set as dim = 2. For the GA, the population size was S = 80, the chromosome length was Lind = 20, the crossover probability was px = 0.7, and the mutation probability was pm = 0.01. For the PSO, the population size was set as S = 80, the location limitation was 0.5, the speed limitation was [−0.5, 0.5], the self-learning factor was c1 = 1.5, and the social learning factor was c2 = 1.5. The ACO parameters were set as follows: pheromone importance = 1.0, importance of heuristic factors = 5.0, pheromone volatilization factor = 0.1, and S = 80 ants. For the DL models, a convolutional neural network with six convolution cores, six input channels (cin = 6), and six output channels (cout = 6) was used. The learning rate of the offset item was twice that of the weight. The extension edge was set to 0, the weight was initialized to Gaussian, and the value of the constant offset item was 0.

Two scenarios were employed for comparison, i.e., different task numbers and different robot numbers, as detailed in

Table 7. Comparison of algorithms under varying numbers of tasks.

Method		Number of Tasks								Mean
		${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=1$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=3$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=5$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=7$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=9$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=11$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=13$	${\mathit{T}}_{\mathit{m}\mathit{a}\mathit{x}}=15$
APC	Makespan $k_T^{make}$	0.144	0.276	0.357	0.391	0.413	0.425	0.432	0.443	0.360
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.286	0.294	0.302	0.317	0.324	0.329	0.336	0.355	0.318
	Total travel distance $D_T^{travel}$	0.158	0.169	0.179	0.188	0.197	0.205	0.211	0.219	0.191
	Solution time (s)	518	519	523	532	546	543	556	565	537.8
GWO	Makespan $k_T^{make}$	0.144	0.289	0.363	0.400	0.426	0.432	0.447	0.448	0.369
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.291	0.295	0.313	0.325	0.327	0.336	0.335	0.359	0.323
	Total travel distance $D_T^{travel}$	0.161	0.173	0.182	0.191	0.204	0.217	0.219	0.224	0.196
	Solution time (s)	505	508	512	536	533	540	548	564	530.8
GA	Makespan $k_T^{make}$	0.149	0.283	0.368	0.404	0.422	0.431	0.440	0.444	0.368
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.286	0.305	0.310	0.334	0.340	0.341	0.349	0.367	0.329
	Total travel distance $D_T^{travel}$	0.162	0.171	0.178	0.187	0.197	0.206	0.214	0.225	0.193
	Solution time (s)	517	509	510	525	534	551	544	557	530.9
PSO	Makespan $k_T^{make}$	0.146	0.282	0.365	0.408	0.423	0.434	0.439	0.452	0.369
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.293	0.293	0.318	0.320	0.329	0.327	0.348	0.361	0.324
	Total travel distance $D_T^{travel}$	0.157	0.174	0.177	0.193	0.206	0.210	0.217	0.228	0.195
	Solution time (s)	506	517	521	523	537	552	555	563	534.3
ACO	Makespan $k_T^{make}$	0.150	0.287	0.371	0.418	0.412	0.436	0.445	0.454	0.372
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.294	0.308	0.311	0.326	0.335	0.339	0.341	0.372	0.328
	Total travel distance $D_T^{travel}$	0.159	0.170	0.188	0.192	0.205	0.216	0.221	0.229	0.198
	Solution time (s)	504	512	513	521	536	539	552	558	529.4
DL	Makespan $k_T^{make}$	0.148	0.287	0.355	0.396	0.419	0.438	0.431	0.443	0.365
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.292	0.306	0.299	0.314	0.325	0.333	0.342	0.357	0.321
	Total travel distance $D_T^{travel}$	0.157	0.173	0.186	0.195	0.203	0.211	0.210	0.230	0.196
	Solution time (s)	1952	2078	2191	2114	2227	2239	2383	2476	2207.5

and

Table 8. Comparison of algorithms under varying numbers of robots.

Method		Number of Robots								Mean
		${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=1$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=3$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=5$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=7$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=9$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=11$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=13$	${\mathit{R}}_{\mathit{m}\mathit{a}\mathit{x}}=15$
APC	Makespan $k_T^{make}$	0.887	0.685	0.576	0.515	0.478	0.463	0.452	0.443	0.562
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.268	0.285	0.294	0.303	0.323	0.328	0.332	0.355	0.311
	Total travel distance $D_T^{travel}$	0.218	0.222	0.230	0.219	0.228	0.221	0.225	0.219	0.223
	Solution time (s)	509	521	524	533	537	544	556	565	536.1
GWO	Makespan $k_T^{make}$	0.938	0.693	0.587	0.529	0.501	0.478	0.467	0.448	0.580
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.274	0.287	0.306	0.312	0.326	0.334	0.346	0.359	0.318
	Total travel distance $D_T^{travel}$	0.231	0.228	0.229	0.234	0.226	0.232	0.227	0.224	0.229
	Solution time (s)	504	506	519	520	541	538	543	564	529.4
GA	Makespan $k_T^{make}$	0.936	0.694	0.582	0.513	0.482	0.466	0.451	0.444	0.571
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.267	0.295	0.308	0.319	0.324	0.339	0.350	0.367	0.321
	Total travel distance $D_T^{travel}$	0.218	0.226	0.228	0.231	0.229	0.220	0.219	0.225	0.225
	Solution time (s)	508	520	523	532	535	542	547	557	533.0
PSO	Makespan $k_T^{make}$	0.931	0.682	0.587	0.523	0.484	0.471	0.468	0.452	0.575
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.283	0.301	0.302	0.308	0.319	0.332	0.343	0.361	0.319
	Total travel distance $D_T^{travel}$	0.217	0.227	0.218	0.228	0.223	0.225	0.231	0.228	0.225
	Solution time (s)	517	509	517	521	538	553	549	563	533.4
ACO	Makespan $k_T^{make}$	0.922	0.695	0.581	0.527	0.489	0.462	0.467	0.454	0.575
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.287	0.294	0.312	0.313	0.325	0.329	0.335	0.372	0.321
	Total travel distance $D_T^{travel}$	0.222	0.229	0.231	0.225	0.221	0.226	0.228	0.229	0.226
	Solution time (s)	503	514	512	526	539	548	551	558	531.4
DL	Makespan $k_T^{make}$	0.892	0.689	0.582	0.513	0.481	0.464	0.453	0.443	0.565
	Total collision time $k_T^{coll}$	0	0	0	0	0	0	0	0	0.000
	Total energy consumption $e_T^{total}$	0.278	0.281	0.299	0.314	0.320	0.325	0.339	0.357	0.314
	Total travel distance $D_T^{travel}$	0.223	0.218	0.218	0.224	0.227	0.224	0.222	0.230	0.223
	Solution time (s)	1955	2083	2196	2221	2231	2238	2396	2476	2224.5

. The number of tasks was increased from $T_{max}=\mathrm{1,3},5,\dots$ to $T_{max}=15$, and the number of robots was increased from $R_{max}=\mathrm{1,3},5,\dots$ to $R_{max}=15$. All algorithms run with the same number of iterations and the same computation time. For all algorithms, the maximum number of iterations was set to ${Ite}_{max}=200$, and the maximum computation time was 1.0 h. Five main metrics were used for the benchmark comparison: the makespan $k_T^{make}$, total collision time $k_T^{coll}$, total energy consumption $e_T^{total}$, total travel distance $D_T^{travel}$, and the solution time. As these metrics are differently scaled, the results of all metrics were normalized into the range from 0 to 1. The solution time is provided in seconds. Note that the optimal results in Table 7 and Table 8 are highlighted in bold.

Table 7 shows the comparison results of benchmark tests using the six heuristic algorithms with different numbers of tasks. The first line of Table 7 presents the total number of tasks, with nine scenarios in total, including the mean value. The first column lists the APC, GWO, GA, PSO, ACO, and DL. It can be observed that more tasks tended to increase the makespan for all algorithms, as well as the energy consumption. Table 7 indicates that the makespan $k_T^{make}$, total energy consumption $e_T^{total}$, and total travel distance $D_T^{travel}$ improved differently with the algorithms used. In summary, the proposed APC algorithm could more easily obtain better mean values for makespan and energy consumption, as highlighted in bold in the table. Compared with the other SOTA algorithms, the proposed APC algorithm improved the makespan $k_T^{make}$ by up to 3.09%, total energy consumption $e_T^{total}$ by up to 3.38%, and total travel distance $D_T^{travel}$ by up to 3.42% while maintaining no collisions ($k_T^{coll}$ = 0).

Table 8 presents a comparison of the results obtained using the six heuristic algorithms with different numbers of robots, where the first line of Table 8 lists the considered number of robots. The first column lists the APC, GWO, GA, PSO, ACO, and DL algorithms, where each adopted the same parameters as above. The comparative results in Table 8 indicate that the metrics were optimized by the different algorithms to various degrees, whereby the proposed APC algorithm obtained the best mean values for each metric (highlighted in bold). For the main metrics, the proposed APC algorithm improved the makespan $k_T^{make}$ by up to 3.06%, total energy consumption $e_T^{total}$ by up to 3.15%, and total travel distance $D_T^{travel}$ by up to 2.68% while maintaining no collisions ($k_T^{coll}$ = 0). Regarding solution speed, the APC had a great advantage over the DL model, as the latter required more computational time to search for comparable solutions. In summary, under a varying number of robots, the APC algorithm can search for the optimal solutions with fast convergence while effectively avoiding local optima.

According to the performance comparison in Table 7 and Table 8, the most efficient algorithm was the APCbefore DL and GA. To achieve an optimal makespan without collision, robots must be assigned to aggregate on different tasks and complete operations as soon as possible. Considering the collision-free multi-robot aggregation problem, the proposed APC algorithm demonstrated clear advantages in searching for optimal solutions over the other SOTA algorithms.

6.4. Discussion

First, in our benchmark experiment, 15 robots were employed to implement the edge computing architecture detailed in Section 3. The success of the experiment also proved the feasibility of the proposed edge intelligence approach. When the number of robots increases, the APC algorithm can even improve edge computing capabilities.

Second, our benchmark experiment used the objective function and constraints established in Section 4, including the maximum completion time (makespan) $k_T^{make}$, the collision time $k_T^{coll}$, the total energy consumption $e_T^{total}$, and the total travel distance $D_T^{travel}$. The experimental results indicate that the established problem model effectively describes the CMAP.

Third, from Figure 6, Figure 7, Figure 8 and Figure 9 and Table 6 in Section 6.2, as well as Table 7 and Table 8 in Section 6.3, it can be seen that simple parameters and fast calculation ability make the APC algorithm very suitable for deployment on robotic edge computing platforms. Compared with other heuristic optimization methods, including ACO, GA, PSO, or standard APC, the improved APC algorithm uses random seeding in each iteration to increase its global search capability and enhance its local convergence ability through an increased probability of crossing growing individuals. When the number of robots is N, the computational complexity of this algorithm is $O\left(N^2\right)$. The same parameters were used to develop the SOTA methods used for comparison; however, this does not mean that the algorithms will perform similarly under the same conditions, as each has specific functioning characteristics.

Fourth, our benchmark test data took into account the collision problem during multi-robot aggregation, and all data have been accurately presented in the manuscript (i.e., Figure 5, Table 3, Table 4 and Table 5 in Section 6.1). Therefore, international peers can reproduce the data themselves and conduct further research.

Fifth, the experimental results presented in this section also demonstrated that the combination of robotic edge computing platforms and artificial intelligence in engineering applications is feasible and promising. The developed robotic edge intelligence approach can be expected to help in solving many engineering problems in the context of industrial automation, autonomous transportation, and search-and-rescue operations without the need to upgrade expensive hardware and software.

Finally, there are some differences between running algorithm on systems with edge computing and without edge computing. In an edge computing system, the response time of algorithms is significantly reduced, making such a system especially suitable for latency-sensitive applications, such as real-time autonomous driving, industrial automation, and so on. In a system without edge computing, algorithms are easily affected by single points of failure and may have difficulty in performing large-scale data processing.

7. Conclusions

This study first attempted to survey the collision-free multi-robot aggregation problem and, consequently, developed a novel robotic edge intelligence model to address the CMAP. Our work includes four main contributions, as follows: First, four metrics of the collision-free multi-robot aggregation problem were considered, including the minimum makespan, collision avoidance, energy consumption, and total travel distance. Second, a novel heuristic algorithm is designed to search for the optimal solution, namely, the artificial plant community algorithm. Third, a newly developed benchmark test set based on the existing literature was explored. The experimental results demonstrated that the proposed APC algorithm presents improved global and local search capabilities, and is superior to some state-of-the-art methods in solving the CMAP. Regarding the efficiency of task execution, the proposed APC algorithm improved makespan $k_T^{make}$ by up to 3.06%, the total energy consumption $e_T^{total}$ by up to 3.15%, and the total travel distance $D_T^{travel}$ by up to 2.68%, while maintaining no collisions ($k_T^{coll}$ = 0). At the same time, the proposed APC method is lightweight; as such, it can be easily deployed on the embedded platforms of edge robots. The performance comparison demonstrated that the APC algorithm can efficiently instruct the edge robots to aggregate and handle tasks without collision.

However, there are still some shortcomings that need to be further resolved. First, while this work built a multi-objective function for the CMAP, it was based on a certain environment and assumptions. For engineering applications, it is required to consider more factors and uncertain environments to ensure collision avoidance. Second, our edge intelligence approach was not deployed in real-world scenarios and, in future research, how to deploy and validate edge intelligence in real-world scenarios is an important direction. This work investigated some main metrics, but other metrics were not considered—such as the collision rate, path efficiency, convergence time, and resource utilization—which should be further surveyed in the future. Third, there may be differences between running the proposed algorithm in systems characterized by edge computing and those without edge computing, potentially leading to hardware limitations, communication delays, sensor inaccuracies, and environmental uncertainties, which are not considered in this manuscript. In the future, it will be necessary to further study the developed mathematical model and working processes, as well as conducting further comparative experiments. Finally, even though the proposed APC can efficiently handle the collision-free multi-robot aggregation problem, it will be important to test and analyze the impacts of environment size, obstacle density, and computational resources on performance in the future, using more real-world benchmark data and statistical tools.