Sampling-Based Path Planning Algorithm for a Plug & Produce Environment

Abstract

The purpose of this article is to investigate a suitable path planning algorithm for a multi-agent-based Plug & Produce system that can run online during manufacturing. This is needed since in such systems, resources can move around frequently, making it hard to manually create robot paths. To find a suitable algorithm and verify that it can be used online in a Plug & Produce system, a comparative study between various existing sampling-based path planning algorithms was conducted. Much research exists on path planning carried out offline; however, not so much is performed in online path planning. The specific requirements for Plug & Produce are to generate a path fast enough to eliminate manufacturing delays, to make the path energy efficient, and that it run fast enough to complete the task. The paths are generated in a simulation environment and the generated paths are tested for robot configuration errors and errors due to the target being out of reach. The error-free generated paths are then tested on an industrial test bed environment, and the energy consumed by each path was measured and validated with an energy meter. The results show that all the implemented optimal sampling-based algorithms can be used for some scenarios, but that adaptive RRT and adaptive RRT* are more suitable for online applications in multi-agent systems (MAS) due to a faster generation of paths, even though the environment has more constraints. For each generated path the computational time of the algorithm, move-along time and energy consumed are measured, evaluated, compared, and presented in the article.

1. Introduction

With the ever-increasing market demand for the mass customization of products, industries are keen to adopt smart factory technologies with digitalization strategies and following the standards of Industry 4.0 [1]. For the adaptation of Industry 4.0, one of the trends in the manufacturing sector is flexible manufacturing systems. Manufacturing facilities designed for dedicated production in various industries encounter problems when transitioning to accommodate customization. It is difficult to accommodate customized products with low-volume production based on individual customer needs [2]. These traditional dedicated manufacturing systems are time-consuming to alternate, often taking months to reconfigure the manufacturing to accommodate the customized products [3]. Again, when the product specification is changed, then industries must go through the entire reconfiguration again, meaning major investment costs are necessary for reconfiguration, which may be hard to motivate, whereas the flexibility of concepts like Plug & Produce (P & P) will reduce the cost and time of a redesign or reconfiguration, thereby allowing for quicker response to the customers and providing customized products with increased performance [2]. Flexibility can be brought into the production system in several ways, i.e., product flexibility, manufacturing flexibility, hardware flexibility, and enterprise flexibility. Product flexibility means addressing the ability of the manufacturing systems to accommodate product variants within a family of products [4]. Manufacturing flexibility plays a major role throughout the entire life cycle of manufacturing systems, and it comes into role mainly because a new product or a product variant is introduced in the manufacturing process [5]. Hardware flexibility means the reuse of a process module for various purposes and scenarios, which contributes to more sustainable manufacturing industries [6]. Enterprise flexibility is how fast the enterprise responds when the market changes, meaning introducing new products based on market fluctuations [7]. The cost of flexibility depends on two major factors, i.e., the setup cost and competence. Setup cost depends on how much time it takes to adapt all programs to the changes in manufacturing, the time taken for planning the operation, product design, and hardware and software configuration. Competence is the cost and need of in-house knowledge and external competence. In flexible manufacturing systems [8], reconfiguration of the production can be changed in a shorter time and mostly with in-house knowledge and competencies.

To become more flexible and smarter, industries are adapting reconfigurable manufacturing systems (RMS) [9], meaning that the user can customize their product with various options, the industries do not require higher investment costs for the customization, and it can be achieved by changing the configurations in modular-based systems. Modular-based systems are working based on the Plug & Produce concept [10]. In such systems, any kind of manufacturing setup can be plugged into the process as a module. The newly plugged-in module adapts to the situation automatically based on the configuration and starts to commence its work to contribute to the manufacturing process. The modules are highly flexible and sustainable, which means that they can be exchanged between the manufacturing stations and reused in another manufacturing section. RMSs can be hardware- or software-configured systems. Hardware-reconfigurable systems are the modules in the system that can be plugged in and plugged out with different configuration specifications for each module. These plugged-in modules can be integrated easily with the current ongoing production with simple instructions. In the multi agent systems, the path planner can be configured as an agent [11]. On the other hand, software-reconfigurable manufacturing systems are addressed through the configuration tool of multi-agent systems (MAS) and the details described in [12]. In MASs, the agent can communicate and negotiate with each other to complete a complex task. Figure 1 shows an overview of agent system communications with the robot (Figure 1 left) with the path planner service (Figure 1 right). Here, the parts and resources are agents which can have goals to achieve and skills to perform goals based on the software [13].

For example, if an industrial robot wants to transport a product from one place to another, the robot can be configured as a resource agent and the part to be moved can be configured as a part agent. In order to transport, path planning algorithms are implemented, modelled as a path planner agent, which takes place online [11]. Each time a robot (configured as a resource agent) wants to transport, it requests the path planner for a path between the start and the goal point. Based on the request from the resource agent, the path planner agent checks for already-generated paths. If the path exists for the same point and the environment, the path planner agent will communicate that path to the resource agent, otherwise it generates a new path and communicates it. Since the resource agent must wait for the path planner agent to generate a path each time it wants to move, the computational time of the path-planning algorithm is crucial. For repeated path enquiries the resource agent gives a request to generate a path for the same starting and goal point with the same environment, and the path planner agent retrieves the path from the local memory of the agent system. This is one of the main advantages of implementing an agent-based path planner in production. Since the agent response time is critical in many applications, the move-along path time, speed of the robot, and energy consumed by each path are investigated in this article.

Generally, in production, the algorithm that offers the lowest computational time is preferred, and the reason is that during the online application, if a path agent needs a long time to create a path, the other agents in the process must wait. On the other hand, if the process module has more obstacles or constraints, sometimes, the traditional Rapidly-Exploring Random Tree (RRT) algorithm fails to generate the path. It means that in certain cases, predefined sampling values in the algorithms may be higher than the configuration-free space (gap) between the obstacles. In these circumstances, the path planner must generate a path if it exists subjected to when the tool can travel between the gap of the obstacles. To address this issue, the research presented in this paper has focused on implementing different types of sampling-based path planning algorithms that are implemented and evaluated in real time with agent-based scenarios together with a standard industrial IRB 6700 robot, from the Zürich, Swedish manufacturer ABB The robot is configured as one of the agents (as a resource agent) in a multi-agent system to achieve higher flexibilities in Configurable Multiagent Systems (C-MAS). Here, the sampling-based algorithms are chosen because they provide probabilistic completeness, can be implemented in complex environments, are best suited for high-dimensional spaces, can handle kinematic constraints, and explore the search space until they find a solution to give the optimal result. Although it provides only probabilistic completeness, the efficiency and ease of implementation make these algorithms more common in applications like automobile and manufacturing industries, etc. [14]. The five algorithms evaluated in a P and P environment are RRT, adaptive RRT, PRM in combination with Dijkstra, RRT*, and adaptive RRT* algorithms. The adaptive RRT and adaptive RRT* algorithms are developed by the authors; these are novel versions of RRT and RRT* algorithms that automatically adapt their sampling value depending on the constraints present in the environment. In these algorithms, a new collision check function is responsible for adjusting the sampling value when an obstacle exists between the $q_{near}$ and $q_{mid}$ sampling points. For evaluation and comparison, the research presented includes sampling-based algorithms in different ways to test in a Plug & Produce environment, i.e., considering non-optimal and optimal path planning with active and passive algorithm classification.

In this research it was purposed to:

• Investigate suitable online path planning algorithms for a multi-agent-based manufacturing system;
• Validate if the developed novel algorithm (adaptive RRT*) has the same characteristics as existing sampling-based algorithms;
• Prove that it is the best-suited algorithm for online path planning, even though more constraints are present in the environment.

The move-along time of the path generated and energy consumed by each path are measured and validated for optimal path planning in real time.

There is importance in employing this research as an automated online path planner in the manufacturing industries, particularly in cases requiring extensive customization, as follows:

• Cutting tool change applications in the production industries [15];
• Optimized online path planner for the kitting application in assembly lines [16];
• Used as an online path planner in wood manufacturing industries to construct unique walls [17];
• Use of all the above-mentioned path planners [15,16,17] as a path agent in the MAS to generate online paths, depending on the required application in the manufacturing industries [11].

1.1. Short Literature Review

Automation industries perform movement and transportation with a robot that requires a collision-free path from the starting position with orientation, to the goal position with orientation. A variety of path planning algorithms exist for achieving the motions of the robots by creating collision-free paths. One of the most common and powerful algorithm types chosen to create collision-free paths is sampling-based algorithms. Even though the completeness guarantees are weaker in these algorithms [18], they provide probabilistic completeness, have collision detection methods in the configuration space and apply a discrete search that utilizes the samples. There exist other combinatorial algorithms [19] for creating collision-free paths, but these algorithms exhibit a high computational time, resulting in real-time implementation difficulties within industries. If the right settings are chosen for the sampling-based algorithms, they are easy to implement and they overcome the challenges of combinatorial algorithms [14]. Sampling-based algorithms are classified into two categories: active and passive [20]. Any algorithm which gets its best feasible path on its own without any extra search algorithms is active. For example, the RRT algorithm constructs the tree and finds the path between the start and goal points on its own, independently of any graph search algorithms. The algorithms which create the mesh or graph and add a combination of the search algorithm to pick the best feasible path are called passive. For example, PRM creates the roadmap and can fetch a path from the start to the goal based on any graph search algorithms implemented. For example, the article by A*, Dijkstra evaluates both passive and active sampling-based algorithms.

1.1.1. Non-Optimal Algorithms

Active sampling-based algorithms such as RRT expand randomly in the configuration space and rapidly construct tree-like structures over the entire search space; due to this nature, they can fetch a non-optimal random path in a short time compared to other algorithms [15,20,21,22,23,24,25]. Lately, many researchers have investigated a variety of sampling-based RRT path planning algorithms for industrial robot applications and their improved versions [26,27,28,29,30,31] in terms of various parameters like computational time of an algorithm, path length, energy consumed by the path, length of the path, obstacle avoidance capacity, etc. RRT is one of the most influential algorithms in the sampling-based path planning algorithm family. It has an incremental search approach without any parameter tuning, and without reducing the resolution, it brings the randomly generated path without collision. This means that it constructs the search tree incrementally throughout the configuration space, without setting any resolution parameters. It randomly explores the search space and creates the number of nodes by checking for the obstacle in the configuration space between the nodes. It efficiently searches non-convex, high-dimensional spaces by randomly building a space-filling tree by creating the random nodes and making the edges between the nodes if no collision is detected between the two nodes.

1.1.2. Optimal Algorithms

Passive Algorithms

PRM is another sampling-based planning algorithm, and it works on incremental sampling-based node search algorithms, which could not bring a path on their own, but could generate a practical graph for the entire configuration space. Once the road map is constructed, any type of graph search algorithm can be implemented to find the optimal path between the start and goal points. This process repeats the entire workspace and creates a dense graph among all configurations in the free space [32]. PRM samples the random configuration and checks that the configuration is in the free space. If it is in the free space, PRM uses the local planner to make the edges between the configurations. There are many ways to make the connection between the nodes. One among them is Delaunay Triangulation, which makes the connection based on the node connection [33], but this is not used due to the intractable complexity of computing and also local path planning using artificial potential field supported by augmented reality, which bypasses the local minima issue [34]. In this article, the K-nearest neighborhood connection is used in PRM to make the connections between the randomly generated configurations due to its high accuracy [35]. There are improved PRM algorithms implemented by reducing the sampling space generated by random nodes, yet maintaining the same number of nodes generated, thereby improving the space utilization. The results are compared with traditional PRM and improved genetic algorithms, and were found to have significant advantages in terms of energy consumption and adaptability [36]. A* is considered one of the best heuristic graph search algorithms, it can calculate the solution quickly, but it is not adapted for complex scenarios and the optimal value depends on the heuristic value [37]. The algorithm named Bellman–Ford can handle negative weights, but it does not scale well, meaning changes in the network topology are not reflected quickly because the updates are spread node by node only, indicating it is slower compared to other graph search algorithms [38]. Dijkstra’s algorithm can recalculate if any problem arises from the starting node to the ending node, and due to its simplicity and flexibility, it can be implemented in complex situations and the optimal value is not dependent on the heuristic value. Dijkstra always fetches close to linear paths, with less computational time even in high-dimensional spaces [39].

Active Algorithms

RRT* is another variation of RRT algorithms, but it has an inbuilt optimization function to improve the path quality. It differs from RRT in several ways: the high-density tree is generated randomly toward the nodes with a lower distance; the path is optimized by rewiring; and it brings asymptotic optimal paths, meaning it can fetch a path in large spaces. Another improved RRT path planning algorithm is outlined in [26]; it can fetch the efficient path in shorter time, but it cannot guarantee the results when there are more constraints in the environment, so it is obvious that it takes more computational time. To generate the path planning with less computational time, the improved RRT algorithm, i.e., RRT expansion, is one example with target gravity and the result is tested in humanoid robots [28]. During map generation, the node will be expanded under joint and gravity action based on random probability. When the path generation is complete, the breadth-first search is used to smoothen the generated path [23]. The RRT-biased with regression [40] algorithms are tested in complex environments. This algorithm adds the regression mechanism to avoid the over-searching of nodes in the configuration space, and it continuously improves the reachable spatial information, as well as refines the boundary nodes in joint space. This algorithm avoids the time taken in collision detection function and increases the success rate and efficiency. Even though the results are comparable, it is tested only within the simulation environment. Transition-based RRT (T-RRT) [30] is another improved version using the stochastic optimization method. It means that after rapidly growing the random trees, it uses the transition test to accept or reject a new potential state and also combines with the self-tuning parameter to control the RRT’s exploration. This algorithm is simulated to create maps in rough terrain applications. Another path planning algorithm [21] was tested in a 2D environment with the use of distance maps using wave expansion and the depth-first search method. The collision points were indicated and collected in the database, and the goal was to avoid collision to save the manipulation steps. Even though there are large variants of RRT* algorithms available, sometimes it fails to generate the path in more constrained environments where the sampling value is higher than the gap between the obstacles. We propose a novel variant of RRT*, the adaptive RRT*, which is modified by adjusting the sampling value to accommodate the constraint environments [17]. Previous research has shown that when RRT* fails to generate a path in more constraint environments the novel adaptive RRT* algorithm changes the sampling value based on the constraints present in the environment, and thus fetches a collision-free path if one exists. Robots working with humans are required to be aware of their surroundings and they are actively involved in collision checking using the MoveIt Library integrated with the Robot Operating System (ROS) [41]. ROSs are used to set up motion planning queries and check for the configuration errors and target being outside of reach in a 3D environment, but they are not directly involved with online path planners [41].

Much research has investigated the comparison between different path planning algorithms tested for industrial robots [42,43,44,45]. Some of the tested algorithms are the sequential algorithm (SEQ), the simultaneous algorithm (A*), the simultaneous algorithm with uniform cost (UC), the simultaneous algorithm with greedy cost (G), and the genetic algorithm (GA). The environment is created with different numbers of obstacles like 1, 2, and 3, and the path length and computational time are measured and compared across all the algorithms [44]. The adapted RRT algorithm is a modified version of RRT by adding the heuristic algorithms. This is tested with autonomous robots. Due to the heuristics algorithm addition, this overcomes the shortcoming of probabilistic completeness, but has the limitation that it needs the predetermined knowledge of intermediate stations for the autonomous robots [46]. Many researchers are exploring metaheuristic algorithms for mobile robot path planning, as they have demonstrated their effectiveness in addressing complex optimization problems [47]. An improved lazy PRM algorithm was implemented online for welding applications [48], but here, the online version is used to detect the obstacles and the environment. Another study showed the comparison between the PRM or RRT and genetic algorithm methods, and the result showed that in terms of computational time, sampling-based algorithms are finding the path in a shorter time compared to computational intelligence methods, such as GAs, but in terms of the path length, computational intelligence algorithms are superior to sampling-based algorithms [49].

2. Implementation of Path Planning Algorithms

To obtain collision-free paths, a Plug & Produce environment is modeled in the Robotstudio simulation environment, and a path is generated from all the algorithms mentioned. Given that the path planner is integrated into an agent-based platform, the computational time of the algorithms is also measured and evaluated during path generation. The generated path is tested to make sure that there are no robot configuration errors or other type of errors due to the target being outside of reach. While the path is generated in the Robotstudio environment, the size of the generated corner path can be varied using the zone. The position accuracy of the robot Tool Center Point (TCP) can be directly changed by the zone value in the argument of a move instruction in Robotstudio. The length of the path will be substituted for the corresponding zone specified within the zone data. The TCP of the robot can be operated with different zone values like fine, z50, z100, and z200. While choosing the zone size, the zone data cannot be larger than half the distance of the preceding or succeeding target in the path. If a larger zone is specified, the robot automatically reduces it. Here, “fine” specifies that the TCP of the robot will go directly to the specified position, and it will not cut any corners on its way to the next position. On the other hand, z50, z100, and z200 are the different zone values. If z50 is chosen, there will be a 50 mm distance between the target position and the TCP. Similarly, for z100, it is a 100 mm distance and for z200, it is a 200 mm distance between the TCP and the target, but choosing these values makes the path smoother when values increase [50].

Later, the generated path is tested using an ABB IRB 6700 robot and the energy is measured across the move-along time in a real manufacturing scenario. Move-along time has been calculated to find the optimum speed of the robots, and the relation between the speed and the energy consumed by each collision-free path is measured and evaluated.

Table 1. Algorithms evaluated and their respective characteristics.

Algorithm Implemented	Characteristics of Each Algorithm Evaluated
RRT	RRT efficiently searches nonconvex, high-dimensional spaces, and builds the tree randomly by creating $q_{rand}$ nodes. This is a non-optimal active sampling-based algorithm.
Adaptive RRT	Adaptive RRT efficiently searches nonconvex, high-dimensional spaces, and builds the tree randomly by creating $q_{rand}$ nodes, and has an extra collision check module which adapts the sampling value according to the constraints present in the environment. This is also a non-optimal active sampling-based algorithm.
PRM + Dijkstra	PRM works in two phases: the construction phase and the query phase. During the construction phase, the road map is built for the entire environment, and during the query phase, the start and goal configurations relate to the build road map and are later implemented with the Dijkstra algorithm to find the shortest path from the map for the start and goal point in the configuration space.
RRT*	The RRT* algorithm efficiently builds the tree in the entire search space of nonconvex and high-dimensional space. After building the tree, it finds the asymptotically optimal path from the starting position of the configuration to the goal position of the configuration by a best parent search in the optimal step.
Adaptive RRT*	Adaptive RRT* algorithms create the path like RRT*, but have an extra collision check module during more constraints present in the environment. Due to this extra collision the module should be checked. An adaptive RRT* algorithm changes its sampling value and finds the $q_{mid}$ when the obstacle presents between $q_{near}$ and ${ q}_{nearest}$. Then, it should be checked for the collision between $q_{near}$ and $q_{mid}$. Therefore, this creates a path efficiently, even if the narrow path exists and can accommodate the tool size in the gap.

outlines the algorithms evaluated in the research presented and each algorithm is explained further down. The industrial testbed environment is shown in Figure 2, which was created in Robotstudio simulation, and the algorithms are implemented. In the testbed industrial environment, there are ten process modules (number 1–10), and each module has the same configurations, thus it can be reused in another location of the testbed. These process modules can be easily plugged into the robot cell and its configuration. Initially, all the five algorithms evaluated were executed in the simulation, without any obstacles to ensure the successful execution of the algorithms to create a path. Later, the algorithms are implemented within the real environment with all the process modules, fencing, components, and the robot to create a collision-free path. The created path was tested and validated throughout to make sure that no errors were introduced due to the robot configurations and the target being outside of reach. The robot configuration error occurs when at least one of the axes of the robot cannot move from the current position to the programmed position with its configuration. This can be addressed with the $CalcJointT$ function with the error handler in Robotstudio. Once the path validation is successful, it is saved as $RapidLoadMode$ module in RAPID programming in Robotstudio.

2.1. RRT

RRT grows a tree from the initial node by sampling the sequence of the random node and tries to make an edge between the nodes. For each iteration, one random sample node will be created from the closest vertex in the tree and this tree grows in the large unsearched areas randomly. The inputs to generate a tree based on RRT are initial configuration ($q_{start}$), number of vertices $\left(K\right)$, the incremental distance ($\delta$), configuration space ($C$), and the output to reach $q_{goal}$ and construct a tree ($T)$ based on RRT. For RRT, $q_{start}$ represents the starting position of the random tree. Initially, a random node $q_{rand}$ is created using $RAND\_CONF$ in the obstacle-free configuration space. Then, the nearest node, $q_{near}$, is obtained in the tree near $q_{rand}.$ From $q_{near}$ to $q_{rand}$ based on the sampling value ($\delta$), the sampled configurations are created, which are called $q_{new}.$ Now, the new configuration, i.e., $q_{new}$, is placed in the line in-between $q_{near}$ and $q_{rand}$ with a sampling value of $\delta .$ Here, the value of $\delta$ is fixed. After placing the $q_{new}$ node, collision detection will be enabled between $q_{near}$ and $q_{new}$. If there is no collision between the $q_{near}$ and $q_{new}$ nodes, an edge will be created. This edge will be added to the tree, $T$. If there is a collision found, the created $q_{new}$ the node will be discarded and another $q_{new}$ will be sampled in the obstacle-free space, and again, a collision check will be enabled. The above process will be iterated continuously until $q_{new}$ reaches $q_{goal}.$ When $q_{new}$ reaches $q_{goal}$, the random tree ($T)$ based on RRT for the entire configuration space is constructed. The collision-free random path from $q_{start}$ to $q_{goal}$ is created. Algorithm 1 shows captures of the implemented RRT algorithm.

Algorithm 1. Captures of the RRT algorithm

Algorithm to Build RRT tree T: $\mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n} RRT (q_{start},q_{goal}, K, \delta , C) :T$    $T.init \left(q_{start}\right)$    $\mathit{f}\mathit{o}\mathit{r} k=1 to K \mathit{d}\mathit{o}$      $q_{rand} \leftarrow RAND\_CONF \left( \right) \mathrm{i}\mathrm{n}{C}_{free}$      $q_{near} \leftarrow NEAREST\_CONFIG (q_{rand}, T)$      $q_{new} \leftarrow EXTEND (q_{near}, q_{rand}, \delta )$      $\mathit{i}\mathit{f} obstacleFree$ ($q_{near}, q_{new}) \mathit{t}\mathit{h}\mathit{e}\mathit{n}$       $T \leftarrow T \cup \left\{q_{new}\right\}$       $E\leftarrow E \cup \left\{{(q}_{near},q_{new}) \right\}$      $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$    $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$   $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n} T=(V,E)$ $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n}$

2.2. Adaptive RRT

An adaptive RRT algorithm is a modified version of the RRT algorithm and its sampling value, which is adapted based on the constraints present in the environment. An adaptive RRT works exactly like RRT, up to the collision check module. During the collision check, if there is no collision between $q_{near}$ and $q_{new}$, it connects the edge like in RRT. If there is a collision, the RRT discards the $q_{new}$ point and samples another $q_{new}$, but in adaptive RRT, it divides the $\delta$ value by 2 (that point is marked as $q_{mid}$) and checks for the collision. If there is no collision between the $q_{near}$ and $q_{mid}$, it discards the $q_{new}$ point and creates an edge between $q_{near}$ and $q_{mid}$, then adds it to the tree, $T$. By dividing the $\delta$ value by 2, it discards the obstacle between $q_{mid}$ and $q_{new}$. Here, each time the obstacle is between $q_{near}$ and $q_{new}$, it is creating an extra node called $q_{nearest}$. Due to this, the number of nodes created by adaptive RRT will be higher than RRT. Because of this, the energy consumed by the path generated by adaptive RRT and the computational time of adaptive RRT will be higher compared to RRT. But this adaptive RRT algorithm is useful when we have more obstacles/constraints in the environment. Algorithm 2 shows captures of the adaptive RRT algorithm.

Algorithm 2. Captures of the adaptive RRT algorithm

Algorithm to build Adaptive RRT tree (T): $\mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n} RRT\left( q_{start},q_{goal},K, \delta , C\right) :T$     $T.init \left(q_{start}\right)$      $\mathit{f}\mathit{o}\mathit{r} k=1 to K \mathit{d}\mathit{o}$         $q_{rand} \leftarrow RAN{D}_{CONF} \left( \right) \mathrm{i}\mathrm{n} C_{free}$;         $q_{near} \leftarrow NEAREST\_CONFIG \left(q_{rand}, \delta \right);$         $\mathit{i}\mathit{f} Collisionfree$ ($q_{near}$, $q_{rand}) \mathit{t}\mathit{h}\mathit{e}\mathit{n}$           $T \leftarrow T \cup \left\{q_{new}\right\}$;           $E\leftarrow E \cup \left\{{(q}_{near},q_{new}) \right\}$;         end if         else        Find $q_{mid} point between q_{near} and q_{random}$        $\mathit{i}\mathit{f} Collisionfree$ ($q_{near}$, $q_{mid}) \mathit{t}\mathit{h}\mathit{e}\mathit{n}$         generate a $q_{new} between q_{near} and q_{mid}$         find $q_{nearest}$ the nearest point to $q_{new}$ in the tree!         choose $q_{min}$ the best parent out of $q_{nearest}$ and $q_{near}$ for $q_{new}$         insert $dis{t}_{min}$ and $q_{new}$ in the T.         rewire T for $q_{new}$        $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$       $\mathit{e}\mathit{n}\mathit{d} \mathit{e}\mathit{l}\mathit{s}\mathit{e}$     $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$     $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n} \mathit{T}$ $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n}$

2.3. PRM with the Dijkstra Algorithm

PRM works in two phases, i.e., the construction phase and a query phase. During the construction phase, it constructs the roadmap in the form of an undirected graph $G=\left(V,E\right)$ in the configuration-free space ($C_{free})$. It randomly generates uniform sample configurations ($q_{start}, q_{rand}, q_{near} and q_{goal}$) in $C_{free}$. The $edge in E$ corresponds to the collision-free, connecting the random samples $q_{start} \mathrm{a}\mathrm{n}\mathrm{d} q_{goal}.$ $E$ is a straight line which is referred to as a local path, computed by a local planner. Sampling is performed based on uniform random distribution in $C_{free}$ space. The sample configurations that lie in the configuration obstacles space are discarded using a simple collision check algorithm. The next step is connecting the pair of randomly generated sample configurations.

Depending on the PRM parameter $\left(k\right)$, the value and the number of connections established between each sample created, four distance functions can be used to find the nearest neighbor. For example, 2-norm in C—space, $\infty$—norm in C—space, 2—norm in workspace, and $\infty$—norm in workspace. Here, 2—norm in C—space is used due to its simplicity. One pair of neighboring configurations is identified, and using a simple local planner, the connections are established between these two configurations. To establish the connection, an incremental collision detection function is enabled and it checks for the collision between the configurations. If there is no collision found, the edge will be created between the configurations. Each configuration can have a maximum number of possible connections, and it can be fixed with the value $k$, which is called $k$-nearest neighbor value. During the construction phase, the user can fix the number of samples $\left(n_{samples}\right)$ to be created, which can increase or decrease the complexity of the created map. Algorithm 3 shows captures of the PRM algorithm. When the connections are established between all the random configurations, the formation of the road map in the entire $C-space$ is finished, i.e., the learning phase of PRM is finished. The purpose of the learning phase is to construct a roadmap in the form of an undirected graph. The time it takes to create the graph mainly depends on two values: $k$ and $n_{samples}$. If these two values are increased, the density of the graph increases. Thus, the learning phase is always slow. In the query phase, the start ($q_{start}$) and goal ($q_{goal}$) points are assigned within the $C_{free} space$ in the created dense graph.

Algorithm 3. Captures of the PRM algorithm

Algorithm to build roadmap with PRM: $\mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n} PRM (n_{samples}, k$) : $G$    $V\leftarrow \varnothing and E\leftarrow \varnothing$    $\mathit{w}\mathit{h}\mathit{i}\mathit{l}\mathit{e} \left|V\right|<n \mathit{d}\mathit{o}$     $\mathit{r}\mathit{e}\mathit{p}\mathit{e}\mathit{a}\mathit{t}$     $q_{rand}\leftarrow$ a random configuration in $C_{free}$     $\mathit{u}\mathit{n}\mathit{t}\mathit{i}\mathit{l} q_{rand}$ is collision free     $V\leftarrow V \cup \left\{q\right\}$    $\mathit{e}\mathit{n}\mathit{d} \mathit{w}\mathit{h}\mathit{i}\mathit{l}\mathit{e}$    $\mathit{f}\mathit{o}\mathit{r} \mathit{a}\mathit{l}\mathit{l} q\in V \mathit{d}\mathit{o}$      $N_q\leftarrow k$ nearest neighbors of $q$ chosen from $V$      $\mathit{f}\mathit{o}\mathit{r} \mathit{a}\mathit{l}\mathit{l} q_{near}\in N_q\mathit{d}\mathit{o}$       $\mathit{i}\mathit{f} \left(q_{rand},q_{near}\right)\notin E \mathit{a}\mathit{n}\mathit{d} ∆\left(q_{rand},q_{near}\right)\ne NIL \mathit{t}\mathit{h}\mathit{e}\mathit{n}$         $E\leftarrow E\cup \left\{(q_{rand},q_{near})\right\}$       $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$      $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$    $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$ $G=(V,E)$ $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n} \mathit{G}$ $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n}$

The purpose of this phase is to plan the path from the initial configuration ($q_{start}$) to the goal configuration ($q_{goal}$) in the roadmap. Initially, the graph $G=(V,E)$ is empty. The local planner ($∆$) connects from one random configuration ($q_{rand}$) to the next nearest random configuration ($q_{near}$) via a straight line in $C_{free}.$ If there is no collision, between $q_{rand}$ and $q_{near}$ else $NIL$. $∆$ is assumed as symmetric and deterministic. This $q_{near}$ is chosen based on the Euclidean distance from $q_{rand}$. This iteration continues until it connects all the randomly generated $n_{samples}$ configurations with a minimum $k$-number of connections for all the configurations. This is the end of generating the $road map (V,E)$ as a dense graph.

Dijkstra finds the optimal path in terms of distance, meaning the cost function is chosen as the distance. It marks the distance as zero from the current vertex to the next vertex, then finds all vertices leading to the current vertex and calculates the distance for all the vertices. It finds the smallest value vertex, saves it and marks that vertex as current. It then finds all the vertices which lead to the current vertex and calculates the distance value. This process repeats until marking all the vertices as visited, meaning that the algorithm iterates the entire $roadmap (V,E).$ Algorithm 4 shows the captures of Dijkstra optimization algorithm.

Algorithm 4. Captures of the Dijkstra Optimization algorithm

Algorithm of Dijkstra Optimization algorithm: 1. Initialize the starting node as the source. – set source_node. distance = 0 – set source_node. parent = None 2. Initialize a priority queue Q with all nodes in G – $set Q=\{v: v in V\}$ 3. $\mathrm{While} Q$ is not empty: $\mathrm{a}.\mathrm{Extract} \mathrm{the} \mathrm{node} \mathrm{u} \mathrm{with} \mathrm{the} \mathrm{smallest} \mathrm{distance} \mathrm{from} Q$ $\mathrm{b}.\mathrm{F}\mathrm{o}\mathrm{r} \mathrm{e}\mathrm{a}\mathrm{c}\mathrm{h} \mathrm{n}\mathrm{e}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{b}\mathrm{o}\mathrm{r} \mathrm{v} \mathrm{o}\mathrm{f} \mathrm{u}:$ – $If v is in Q:$     # Compute the Euclidean distance from u to v, d(u,v), via the roadmap G.     $i. d(u, v)=sqrt({\left(u.x-v.x\right)}^2+{\left(u.y-v.y\right)}^2)$     $ii. If d(u,v)+u.distance<v.distance:$       $1. Update v.distance=d(u,v)+u.distance$       $2. Update v.parent=u$ $\mathrm{c}. \mathrm{Remove} \mathrm{u} \mathrm{from} Q$ 4. If the target node is reachable from the source node:   a. Construct the shortest path from the target node to the source node with the best parent search based on distance.   b. Return to the shortest path. 5. Otherwise, return to the target node that is unreachable from the source node.

2.4. RRT*

RRT* is an incremental sampling-based planning algorithm which brings an initial solution based on the principle of RRT and optimizes the path using two planning stages, i.e., the best parent search and rewiring. RRT* also considers both the incoming and outgoing edges of each new vertex, which helps improve the cost function in terms of the distance of existing vertices. Thereby, it locally minimizes the cost function and creates a complete tree ($T$).

RRT* constructs the tree ($T$) initially by adding $q_{start}$ as the starting point. It randomly generates the $q_{rand}$ point in the configuration-free ($C_{free}$) space. $C_{free}$ is derived from configuration spaces $\left(C\right)$ without obstacles ($C_{obs}$), so $C_{free}$ is created using $C \cap C_{obs}.$ From $q_{rand}$, it finds the nearest node $q_{nearst}$. Then, it interpolates between $q_{rand}$ and $q_{nearst}$. The new interpolated node is called $q_{new}$. It checks for the obstacles between $q_{new}$ and $q_{nearest}$ by enabling the collision check function. Collision check is performed in three stages. The first one is checking the collision between $q_{new}$ and $q_{nearest}$, then between the robot tool and the environment, and finally it checks the collision between the robot and the environment. If there is no collision, $q_{new}$ will be added to the trajectory and update the cost of reaching $q_{new}$ from the $q_{nearest}.$ Then, $q_{nearest}$ will act as a parent node of $q_{new}$, find the next nearest neighbor from $q_{new}$, and mark it as $q_{near}$. From all the neighbors of $q_{near}$, it checks if $q_{new}$ can be reached shortly with the distance value ($dis{t}_{min})$ for the node $q_{min}$ from any other parent node, without any collision with the obstacles. The node which gives the least $dis{t}_{min}$ value is selected and updated as $q_{new}$. $q_{new}$ will then be added to the tree as one of the nodes. This is the first optimal step, and it is called the best parent search of RRT* algorithms. The second optimal step is rewiring; it finds the new lower-cost path to reach among the nodes that are already existing in the tree ($T).$ Rewiring is carried out by searching the node $q_{near}$ and checking it by changing its parent to $q_{new}$ to see will there be a chance to lower the cost of the path. If so, the tree is rewired, added as the child of $q_{new}$, and the shortest nodes of the path updated.

Iteration continues until $q_{goal}$ or the maximum number of nodes is reached. Until the maximum number of nodes is reached, it is not finding the $q_{goal}$; it terminates the loop and comes out as no available collision-free path found. Algorithm 5 shows captures of the RRT* algorithm.

Algorithm 5. Captures of the RRT* algorithm

Algorithm to build RRT* tree: $\mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n} RR{T}^{*} \left(q_{start}, q_{goal}, n\left(samples\right), C\right) :T$  $create empty \mathit{T} with q_{start}$   $\mathit{f}\mathit{o}\mathit{r} n do$    generate a random node $q_{rand}$ in $C_{free}$    find the nearest node in the tree $q_{nearest}$ from $q_{rand}$    $\mathit{i}\mathit{f}$ collision free $\left(q_{nearest}, q_{rand}\right)$ then      generate $q_{new}$ between $q_{nearest }$ and $q_{rand}$      add the $q_{new}$ to $T$      find $q_{near}$ in the vicinity of the $q_{new}$      calculate the cost in terms of distance.      $q_{min}\leftarrow dis{t}_{min}=d(nearest, new)+d(new, near)$      $\mathit{i}\mathit{f} d_{new}<d\left(nearest, near\right)$ then update the parent of $q_{near}$ to $q_{new}$       rewire $T$ for $q_{new}$      $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$     $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$   $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$   $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n} \mathit{T}$ $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{u}\mathit{n}\mathit{c}\mathit{t}\mathit{i}\mathit{o}\mathit{n}$

2.5. Adaptive RRT*

This is a modified version of RRT*. The main purpose of this algorithm is that it can be used in a constraint environment when RRT* cannot fetch a collision-free path after the number of iterations. This adaptive RRT* dynamically changes its sampling value in the collision check module and tries to create a collision-free path in the more constraint environment. While the collision check function happens between $q_{new}$ and $q_{nearest}$, if there is no collision, it follows RRT*, but if a collision exists, an adaptive RRT* finds the mid-point $q_{mid}$ between $q_{new}$ and $q_{nearest}.$ Then, the collision check function performs a collision check between $q_{mid}$ and $q_{nearest}.$ If there is no collision, it connects the edge from $q_{nearest}$ to $q_{mid}$ and ignores the portion of $q_{mid}$ to $q_{new}$. If there is a collision between $q_{nearest}$ to $q_{mid}$, it rejects the entire portion of $q_{nearest}$ to $q_{new}$ and continues searching for the next $q_{rand}$ point. This process continues until it finds another collision between $q_{new}$ and $q_{nearest}$. If no collision occurs, it works as RRT*, but when there is a collision occurring between $q_{mid}$ and $q_{nearest},$ this algorithm functions as an adaptive RRT* by having the extra collision check module. This iteration continues until it constructs the entire $T$ of $C_{free}$ space or until it reaches the $q_{goal}$ point. In this adaptive RRT*, best parent search and rewiring take place to bring the asymptotically optimal probabilistic collision-free path for the environment, as it is in the RRT* algorithm. Algorithm 6 shows the captures of the adaptive RRT*. This Adaptive RRT* is mainly used where a lot of constraints are present in the process module. This algorithm creates a greater number of nodes if the obstacle is present compared to RRT* because of the extra collision check function.

Algorithm 6. Captures from the adaptive RRT* algorithm

Algorithm to build Adaptive RRT* tree:   function Adaptive RRT* $(q_{start}, q_{goal}, n(samples), C)$ : T     create $T$ with $q_{start}$     $\mathit{f}\mathit{o}\mathit{r} n \mathit{d}\mathit{o}$       generate a random node $q_{rand}$ in $C_{free}$       find the nearest node in the tree $q_{nearest}$ from $q_{rand}$       $\mathit{i}\mathit{f} Collisionfree$ ($q_{nearest}$, $q_{rand}) \mathit{t}\mathit{h}\mathit{e}\mathit{n}$         generate $q_{new}$ between $q_{nearest}$ and $q_{rand}$         add $q_{new}$ to the tree!         find $q_{near}$ in the vicinity of the $q_{new}$           calculate the cost in terms of distance          $q_{min}\leftarrow dis{t}_{min}$= $d(nearest, new)+d(new, near)$          if $d_{new}<d\left(nearest, near\right)\mathit{t}\mathit{h}\mathit{e}\mathit{n}$          $update parent of q_{near} to q_{new}$          $rewire T for$ $q_{new}$          end if        end if          else          find $q_{mid}$ point between $q_{nearest}$ and $q_{random}$          $\mathit{i}\mathit{f}$ collision free ($q_{nearest}$, $q_{mid})$ then             generate $q_{new}$ between $q_{nearest}$ and $q_{mid}$            find $q_{near}$ in the vicinity of the $q_{new}$             calculate the cost in terms of distance.            $q_{min}\leftarrow dis{t}_{min}$= $d(nearest, new)+d(new, near)$            if $d_{new}<d\left(nearest, near\right)\mathit{t}\mathit{h}\mathit{e}\mathit{n}$             $update parent of q_{near} to q_{new}$            rewire $T$ for $q_{new}$            end if           $\mathit{e}\mathit{n}\mathit{d} \mathit{i}\mathit{f}$          end else     $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$

3. Results

All the tested algorithms were implemented in a Robotstudio simulation environment to generate a collision-free path. The generated paths were tested in real time with ABB IRB6700, which is configured with the industrial test bed applying the Plug & Produce concept shown in Figure 3. The created paths were tested for the feasibility of online implementation of path planning in MAS within a Plug & Produce environment. During the runtime when the path planner agent is generating a path, the other agents (e.g., resource agent) must wait online for the path planner agent to respond with the generated path, so the computational time of the algorithm is important to evaluate while running online applications in this environment.

For the calculation of computational time, all the algorithms are simulated in DELL Intel(R) Core(TM) i7-8650U, CPU @ 1.90GHz–2.11GHz, Installed RAM 16.0 GB (15.9 GB usable), System type: 64-bit operating system, x64-based processor computer. Computational time varies depending on the number of obstacles present in the environment. Initially, all the algorithms were tested without any obstacles; then they were tested with two obstacles to make sure that the algorithms generated a successful path. Thereafter, the simulated algorithms were tested with the real Plug & Produce environment shown in Figure 3, and the energy consumed by each path was measured. As seen in

Table 2. Average values of computational time are centralized.

Algorithm	Environment	RRT	RRT*	Adaptive RRT	Adaptive RRT*	PRM
Average computational time (Secs)	Fewer constraints	4.4	4.9	5.2	7.2	11.3
Average computational time (Secs)	More constraints	-	-	11.6	11.7	25.6

, even though the environment is the same, the computational time differed largely between RRT to adaptive RRT, and from RRT* to adaptive RRT*. The reason is that the adaptive RRT and adaptive RRT* algorithms are generating a greater number of nodes due to the additional collision module.

If the environment has more constraints when the predefined sampling values in the algorithms may be higher than the configuration-free space (gap) between the obstacles, RRT and RRT* fail to generate the path, but in these circumstances, an adaptive RRT and adaptive RRT* are generating the path successfully. One kind of such scenario is simulated and tested, which is shown in Figure 4.

The move-along time of each path is measured, the test repeated number of times, and the average values are centralized in

Table 3. Average values of the move-along time of the generated path are centralized.

Speed in mm/s	Move-Along Time of the Generated Path (Secs)
	RRT	Adaptive RRT	PRM	RRT*	Adaptive RRT*
400	9.9	12.8	6.2	5.8	5.8
500	7.7	10.3	4.9	4.7	4.7
600	6.9	8.6	4.2	3.9	3.9
700	5.8	7.6	3.3	3.4	3.5
800	4.7	6.5	3	3	3

. The time taken to move from the starting point to the goal point is also higher compared to the RRT algorithm due to the higher generation of the number of nodes. However, in the cases of RRT* and adaptive RRT*, one additional optimal step is incorporated to find the optimal path. Hence, the time taken to compute differs, but the time taken to move along the path is almost the same for all speeds for the optimal algorithms. The RRT and adaptive RRT algorithms are random path generators; even though they take less time to generate the path, they take longer time to complete the path. Computational time can be compensated in an online path planner by saving the generated paths for reuse. Thus, more focus is needed toward the move-along time of the path, which was generated by optimal algorithms, meaning that with different speeds, the move-along time will vary. The purpose is to find the trade between the speed and the move-along time for online applications. Optimal algorithms are tested with the various zone values, such as FINE, Z100, Z150, and Z200. These zone values determine the position accuracy of the robot’s TCP with a generated node in the path. Fine positioning is used when very high accuracy is required. This setting is preferred for a task that requires high precision, for example, assembling small components or handling delicate objects. To set up fine positioning, the zone data values should be reduced, i.e., $X=2 \mathrm{m}\mathrm{m}$, $Y=2 \mathrm{m}\mathrm{m}$, and $Z=2 \mathrm{m}\mathrm{m}$. Z100 positioning is a standard accuracy level suitable for most general tasks. It balances accuracy with speed and is commonly used in manufacturing applications. To set up Z100 positioning, the zone data values should be configured as $X=100 \mathrm{m}\mathrm{m}$, $Y=100 \mathrm{m}\mathrm{m}$, and $Z=100 \mathrm{m}\mathrm{m}$. Z150 positioning offers a slightly larger accuracy zone, allows for a bit more tolerance, and maintains reasonable precision. This is mainly preferred where the speed is more critical than accuracy. To configure Z150 zone data, the values should be set as $X=150 \mathrm{m}\mathrm{m}$, $Y=150 \mathrm{m}\mathrm{m}$, and $Z=150 \mathrm{m}\mathrm{m}$. A Z200 position provides a larger accuracy zone, and it is best suited for tasks where precision is less, and the speed of the robot is a primary concern. To configure Z200 zone data, the values are $X=200 \mathrm{m}\mathrm{m}$, $Y=200 \mathrm{m}\mathrm{m}$, and $Z=200 \mathrm{m}\mathrm{m}$. These zone values can be changed by accessing the robot’s controller. The higher zone values are smoothening the corners of the paths more. Due to that, the energy consumption of the path will be considerably lower, whereas the lesser values are reaching the corner of each node generated so that the robot encounters a greater number of accelerations and decelerations, thereby consuming more energy. Even though PRM requires longer computational time, it creates nodes and edges for the entire workspace of the environment and applies the Dijkstra optimization iteration. If the environment is not changed, it does not need to create nodes and edges every time; thus, it will generate the path quickly after some iterations, meaning that it counts only Dijkstra’s optimal path finding time. For different speeds, the energy is measured to be at least five times higher, and the average values are calculated and centralized in

Table 4. Measured energy values for different speeds for all optimal sampling-based algorithms.

Zone Value	PRM [J]				Adaptive RRT* [J]				RRT* [J]
Speed (mm/s)	FINE	Z100	Z150	Z200	FINE	Z100	Z150	Z200	FINE	Z100	Z150	Z200
10	1190	993	968	925	877	871	865	851	845	825	790	753
50	945	912	895	815	610	604	590	585	420	400	375	321
100	1220	1201	1190	1099	899	897	894	891	522	502	444	411
200	1424	1398	1356	1208	1053	1050	1045	1039	674	654	586	563
300	1478	1421	1396	1349	1104	1101	1098	1091	723	681	645	608
400	1539	1457	1433	1386	1147	1145	1140	1139	762	705	689	640
500	1625	1482	1451	1429	1196	1182	1175	1167	803	786	710	672
600	1722	1532	1498	1479	1257	1245	1212	1207	852	802	745	706
700	1833	1591	1560	1537	1319	1299	1275	1261	901	875	789	741
800	1961	1655	1620	1598	1392	1378	1346	1323	957	902	830	776
900	2091	1733	1688	1669	1470	1428	1397	1375	1011	998	846	820
1000	2246	1820	1758	1730	1559	1514	1489	1447	1082	985	872	866
1500	3149	2408	2288	2237	2062	1995	1867	1794	1428	1398	1285	1127
2000	4206	3330	2969	2880	2735	2675	2544	2311	1804	1756	1645	1434
2500	4933	4032	3683	3417	3396	3296	3126	2977	2123	2010	1924	1818
3000	5213	4310	3910	3714	3569	3415	3365	3197	2478	2389	2247	2175

. From the measured data, it is evident that less energy is consumed at a lower speed, i.e., 50 mm/s. When the speed increases, the energy consumption also increases linearly. Energy consumption depends on many factors, e.g., the number of nodes generated for each path, payload, robot configuration, speed of the robot, zone values, and the temperature of the gearbox in the robot.

The energy consumed by each path was measured through API available in RobotStudio called the signal analyzer online, and the measured data validated with an energy measuring instrument C. A 8335 Power Quality Analyzer. It is apparent from the response given in Figure 5 that when the speed increases more than 1000 mm/s, the energy consumption also increases rapidly. Generally, PRM consumes more energy and takes more computation time and move-along time. Even though an adaptive RRT* consumes more energy than RRT* due to the additional node it generates when it encounters obstacles. Thus, it is preferred in the Plug & Produce environment for online path planners when there are more constraints in the process modules.

4. Conclusions and Discussion

This article investigated the suitable online path planning algorithm for a multi-agent-based manufacturing system. For this investigation, five different sampling-based path planning algorithms are considered and implemented successfully within the Plug & Produce environment. Here, the robot agent communicated with the path planner agent to generate a collision-free path. The path planner agent generated the collision-free optimal path using the adaptive RRT* algorithm even though there are several constraints present in the environment when the tool dimension can be accommodated between the obstacles. Two aspects of saving time during path generation could be identified: (1) the adaptive RRT and adaptive RRT* are faster than the other compared algorithms when a high number of nodes is required to avoid collisions due to narrow spaces between obstacles. However, the path generated from all the optimal algorithms are taking almost equal time to move along the path. (2) The optimal algorithms take more computational time to generate a path than non-optimal algorithms due to optimizing the path after generating the nodes. This higher computational time can be compensated for by reusing the already-generated paths from the saved path database in the agent system. The adaptive RRT* algorithm is preferred and best suited for online path generators in the agent-based platform in C-MAS-based applications for flexible manufacturing. The energy consumed by each path is measured for all the optimal algorithms via the Robotstudio add-in called signal analyzer online, and the measured energy is validated using the C.A 8335 Power Quality Analyzer. The energy consumption is considerably lower for the RRT* algorithm, with up to 1000 mm/sec of the robot. It is preferred to use the speed of the robot less in auto mode compared to the manual mode. All the generated paths are tested in the industrial test bed configured with the ABB IRB6700 robot within a Plug & Produce environment and validated whether the newly developed algorithms follow the characteristics of the existing traditional sampling-based algorithms and at the same time offered a path with constraints in the environment if a path exists.

For further research based on path planning, to save the computational time of optimal path planning algorithms, we aim to split the generated path into different numbers of waypoints. Each time the robot agent requests for a path to be generated, the path planner agent looks for the existing paths for each waypoint and the matching environments. Then, it tries to reuse the already-generated points for some of the waypoints. Only the new waypoint path will be generated and added along with the already-existing generated waypoints. From this approach, we can considerably reduce the computational time of the algorithm, which will facilitate the use of a faster online path planning agent service system. In addition to that, the authors are interested in testing other algorithms in the RRT family like RRT*-smart, potential-guided RRT*, real-time RRT*, and informed RRT* within the Plug & Produce environment.