Integrated Analysis of Mapping, Path Planning, and Advanced Motion Control for Autonomous Robotic Navigation

Abstract

Autonomous robotic navigation is essential in modern systems for revolutionising various industries that operate in both static and dynamic environments. To achieve this autonomous navigation, various conventional techniques that handle environment mapping, path planning, and motion control as individual modules often face challenges in addressing the complexities of autonomous navigation. Therefore, this paper presents an integrated technique that combines three essential components, such as environment mapping, path planning, and motion control, to enhance autonomous navigation performance. The first component, i.e., the mapping, utilises both binary and probabilistic occupancy maps to represent the environment. The second component is path planning, which incorporates various graph- and sampling-based algorithms such as PRM, A*, Hybrid A*, RRT, RRT*, and BiRRT, which are evaluated in terms of path length, computational time, and safety margin on various maps. The final component, i.e., motion control, utilises both conventional and advanced controller strategies such as PID, FOPID, SFC, and MPC, for better sinusoidal trajectory tracking. The four case studies for path planning and one case study on trajectory tracking on various occupancy maps demonstrated that the A* algorithm and MPC outperformed all the compared techniques in terms of optimal path length, computational time, safety margin, and trajectory tracking error. Thus, the proposed integrated approach reveals that the interplay between mapping fidelity, planning efficiency, and control robustness is vital for reliable autonomous navigation.

1. Introduction

Autonomous robotic navigation has emerged as one of the essential elements in modern systems for revolutionising various industries [1,2]. In multiple industries, for autonomous robotic navigation in static and dynamic environments, the robot’s ability to interpret the environment using occupancy maps [3,4], plan an optimal path using path planning techniques [5,6,7,8], and execute precise movements using control strategies is critical [9,10]. Thus, the need for an integrated framework utilising three fundamental components, including environment representation via occupancy maps, sampling-driven path planning, and motion control, is inevitable for enhancing performance during robotic autonomous navigation. In the literature, each of these components has been widely explored individually, and several studies also present comprehensive navigation frameworks. However, most emphasise particular aspects more strongly. For instance, the mapping algorithms have been evaluated on their fidelity [4]. On the other hand, path planning algorithms have been assessed based on their path efficiency, and motion control techniques have been evaluated based on their tracking performance [5,10]. However, for real-time robotic navigation, all these components are interconnected. An inaccurate mapping will affect the efficiency of path planning. The suboptimal path from these techniques may fail to achieve proper control action, hindering accurate follow of the optimal path.

Mapping and localisation are the first and crucial pillars for this integrated framework of autonomous navigation. Recently, in [11], a probabilistic 3D occupancy mapping framework known as OctoMap, which balances map fidelity with memory and runtime efficiency, was introduced. Each octree of the OctoMap stores the occupancy probability that supports large-scale mapping on embedded hardware. The geometry-aware 3D point cloud learning enables precise cutting-point detection in unstructured environments, supporting robust LiDAR-based navigation [12]. Similarly, the RTAB framework for large-scale SLAM, which utilises a memory-management strategy, has been proposed [13]. This type of framework has been widely adopted in ROS with inputs from LiDAR. The authors of [14,15] have introduced ORB-SLAM2 and ORB-SLAM3, respectively, which handle monocular, stereo, RGB-D, and multi-camera inputs and present an atlas of sub-maps with automatic place-recognition-based merging. However, the framework’s dependence on salient corners and challenges in textureless environments is notable. The KinectFusion framework for real-time dense surface mapping and online planning has been introduced [16]. This method fuses depth frames into a volumetric grid and simultaneously tracks using the camera.

The second pillar in autonomous robotic navigation is the use of path planning algorithms for finding an optimal path on environmental maps [17,18,19]. Dijkstra’s algorithm is the most widely used canonical single-source shortest path method for graphs with non-negative edge weights [20]. However, the major limitation of the technique is its computational cost on large maps. The A* path planning technique outperforms Dijkstra’s algorithm, which optimally searches towards the goal node with a heuristic cost function [21]. The algorithm is a standard technique for global path planning. However, the performance can degrade when heuristics are weak. The D* (or Dynamic A*) algorithm is an incremental replanning technique designed for dynamic environments that optimally replans from the start node when a new obstacle is detected [22]. However, implementing this method for continuous robot dynamics is a complex task.

Another variant of D* is the D* Lite algorithm, which plans the path by maintaining vertex keys [23]. This algorithm adapts to newly discovered obstacles in real-time. The ARA* algorithm introduces an inflation factor to the heuristic cost function [24]. The ARA* provides a suboptimal path at every iteration, making it feasible for all real-time systems. The Hybrid A* algorithm is an extension of the traditional A*, which searches in a 2D grid space, while Hybrid A* searches in a 3D continuous kinematic state space defined by the vehicle’s position $(x,y)$ and orientation $\left(\theta \right)$. This orientation $\left(\theta \right)$ in Hybrid A* helps in producing smooth and feasible paths that a real vehicle can follow [5,6,7]. The PRM algorithm, on the other hand, samples the configuration space and connects samples with a local planner, and performs graph search to find a collision-free route [25,26,27]. The significant limitations of this technique include the upfront cost of constructing the roadmap and decreased efficiency due to frequent environmental changes.

The RRT algorithm is another path planning algorithm that rapidly expands in high-dimensional spaces to find a feasible path [28,29,30]. It achieves this by randomly sampling points in the free search space and connecting them to the nearest point in the existing tree, if feasible. The RRT* algorithm is an optimized variant of the traditional RRT algorithm, which improves the path over time by incorporating a rewiring step, which reduces the path length and achieves a smoother path [31]. The BiRRT algorithm is an extended version of the traditional RRT, where two trees grow simultaneously from the start and goal, unlike the RRT algorithm, which uses only one tree from the starting node [29]. Thus, by growing trees from both ends, the search space is explored more efficiently, making it suitable for high-dimensional spaces where direct single-tree exploration is slow. The BIT algorithm combines sampling, heuristic graph search, and optimization at every iteration. The BIT* is a variant of BIT that works on graph-like edge evaluations with tree rewiring [32].

The third and final pillar in autonomous robotic navigation is the use of motion control techniques for following the optimal path by controlling the robot’s drive components, such as motors and actuators. The PID controller is the most widely used to achieve this objective. An extension to PID, which is a kinematic fuzzy logic–based PID controller for following circular and point-to-point trajectories, has been introduced [33]. The controllers help to balance responsiveness and overshoot when curvature and speed vary along the path. However, the controller still oscillates near the sharp corners. Similarly, an intelligent PID with PD in the feedforward direction is proposed to achieve the robust trajectory tracking performance under disturbances and model uncertainty [34]. The authors of [35] have proposed the FOPID controller, and the authors of [36] have proposed the hybrid sliding mode with FOPID controllers for trajectory-tracking and maintaining stability. The two additional degrees of freedom in FOPID, namely, integral and derivative orders, facilitate achieving more robust performance. On the other hand, various researchers also proposed different control strategies for trajectory tracking. For instance, Wang et al. proposed a state feedback controller for achieving better real-time performance and robustness to speed and curvature changes [37]. Similarly, Villalba-Aguilera et al. implemented an MPC controller for tracking with online obstacle-aware shaping [38].

From the above literature, it is worth highlighting that conventional techniques, which handle environment mapping, path planning, and motion control as individual modules, often face challenges in addressing the complexities of autonomous navigation. This creates a clear motivation for developing an integrated framework that can manage these interdependent tasks of mapping, path planning, and motion control, thereby improving reliability and adaptability in real-world scenarios. Thus, this research proposes an integrated framework that combines all these components to achieve better autonomous navigation. The key contributions of this research are as follows: First, environmental representation through the use of multiple occupancy mapping techniques. Second, a comprehensive analysis of path planning algorithms, including PRM, A*, Hybrid A*, RRT, RRT*, and BiRRT. Third, an investigation of multiple motion control strategies, including PID, FOPID, SFC, and MPC, is conducted to assess their effectiveness during trajectory tracking.

The remaining sections of the paper are organised as follows: Section 2 presents the representation of the environment using occupancy-based maps such as binary and probabilistic mapping. Section 3 presents various path planning algorithms such as PRM, A*, and Hybrid A* algorithms, and the RRT family, which includes RRT, RRT*, and BiRRT for finding optimal paths on the occupancy maps. Section 4 presents motion control techniques, including PID, fractional-order PID, state feedback controller, and model predictive controller, for the robot to move along the desired path and achieve the desired speed at each moment. Section 5 presents the performance of various path planning algorithms on different occupancy maps and compares them in terms of path length, computational time, and safety margin. This section also presents the performance compression of various motion control techniques on following a sinusoidal path and compares them in terms of different performance metrics. Section 6 concludes the paper.

2. Environment Representation Using Occupancy-Based Mapping

Representing the environment is the first step in autonomous robotic navigation, which helps determine where a robot can and cannot go, as well as its ability to move safely and efficiently within the environment [39,40]. The environmental map will abstract the physical world into computable forms for better representation. The occupancy map is one such type of approach that represents the robot’s environment by dividing it into a grid of cells. As given in

Table 1. Key characteristics and types of occupancy maps.

Aspect	Description
Structure	Grid (2D or 3D) of discrete cells.
Cell Values	0: free space; 1: occupied (obstacle); $0<p<1$: probability of occupancy.
Binary Occupancy Map	Each cell is either free (0) or occupied (1).
Probabilistic Occupancy Map	Each cell stores a probability value for occupancy.
3D Occupancy Map (Octomap)	Extends to 3D using voxel-based representation.

, the grid can be either 2D or 3D, with cells representing whether they are occupied by an obstacle or free.

As described in Table 1, there are mainly two types of occupancy maps, which are the binary occupancy map and the probabilistic occupancy map. In a binary occupancy map, as the name suggests, each cell is assigned a binary value of either 1 or 0, indicating whether it is occupied or free, respectively. Similarly, the probabilistic occupancy map assigns a value to each cell, ranging from 0 to 1, that represents the occupancy status. A detailed description of both maps will be provided in the subsequent sections.

2.1. Binary Occupancy Maps

As mentioned earlier, a binary occupancy map represents the environment as a grid-based structure, which is typically a two-dimensional array. In which each cell is represented as either occupied (1) or free (0). The binary occupancy maps are often created using various techniques. The first and simplest method is manual creation, in which a plan is made by an operator utilising known environmental characteristics. This is especially helpful in simulated or controlled settings where the precise placement of obstacles is known in advance. An example of a manually defined binary occupancy map is shown in Figure 1a.

Secondly, using thresholding algorithms to transform 2D photos into occupancy grids is a more dynamic and automated approach. In these situations, RGB or grayscale data are examined and converted to binary values using a cutoff point that separates the light (free) from the dark (occupied) areas (see Figure 1b). Finally, the creation of random binary maps is another popular technique that is useful for evaluating path planning algorithms in various uncertain situations, as shown in Figure 1c. Figure 1a illustrates a controlled environment with predetermined obstacles, whereas Figure 1c highlights uncertain scenarios where obstacles are randomly distributed, emulating unpredictable real-world conditions for robustness testing. It is worth highlighting that despite their ease of use and computational effectiveness, binary occupancy maps are not very effective at handling real-world complexity, including sensor noise, dynamic impediments, and partial observability.

2.2. Probabilistic Occupancy Maps

Similarly, the probabilistic occupancy map represents the environment as a discrete grid of cells, with cell values of approximately 1 indicating a high probability of occupancy or the presence of an obstacle, and values of approximately 0 indicating a high confidence level that the cell is free or empty space. The intermediate values, i.e., between 0 and 1, represent uncertain or partially observed regions. This enables the path planner to avoid potentially hazardous areas without relying on strict thresholds, select safer, lower-risk routes, and reason under uncertainty.

These maps are often created using sensor fusion methods that integrate data across time. LiDAR-based SLAM is one of the most popular methods for creating this type of probabilistic occupancy map, as it enables real-time updates to both the map and the robot’s current position. An example of such a probabilistic occupancy map created from LiDAR scans and poses is shown in Figure 2.

3. Sampling-Driven Path Planning Algorithms

After defining the occupancy map as explained in Section 2, the next essential part of autonomous robotic navigation is path planning. The path planning algorithms help the robot find the optimal path from the starting point to the destination point, avoiding all obstacles. The robot’s navigation capabilities mainly depend on the efficiency and robustness of the path planning algorithm employed.

Path planning algorithms can be broadly categorised into three main approaches: graph-based, sampling-based, and hybrid approaches. The graph-based algorithms will discretise the space into a grid or graph for finding the optimal path. However, the sampling-based techniques generate explicit graphs that are more suitable for continuous or high-dimensional domains. The hybrid approaches integrate motion feasibility and system dynamics into the design process.

As shown in Figure 3, the PRM, A*, and Hybrid A* algorithms and the RRT family, which includes RRT, RRT*, and BiRRT, are among the most well-known path planning techniques in autonomous robot navigation. The PRM builds a graph of collision-free configurations using random sampling and connects them to form a roadmap for path planning in static environments [25,26,27]. Moreover, the A* algorithm uses heuristics to find the shortest path on a grid. At the same time, the Hybrid A* algorithm extends it with continuous motion and vehicle kinematics to produce smoother, feasible paths [5,6,7]. The RRT algorithm explores the space rapidly by growing random trees. RRT* improves path optimality over time, and BiRRT grows trees from both start and goal for faster convergence [28,29,30]. These methods differ not only in their search strategy but also in their underlying representation: PRM relies on roadmaps, A* and Hybrid A* on grids/graphs, and RRT variants on random tree structures. A detailed description of these path planning techniques will be presented in the subsequent sections.

3.1. Probabilistic Roadmap (PRM)

As mentioned earlier, the PRM is a sampling-based path planning technique that creates a roadmap, a network of paths that avoid collisions, by randomly selecting viable configurations from the environment and connecting them using basic local planners [25,26,27]. The flowchart of the PRM algorithm illustrating its implementation phases is shown in Figure 4. As shown in the figure, the algorithm consists of two distinct phases: the construction phase and the query phase.

During the construction phase, first, random samples will be drawn from the robot’s configuration space. Then, each sample will be checked for collision. All free samples that are collision-free will be retained as nodes. Secondly, the algorithm attempts to connect these nodes to the neighbouring nodes using a basic local planner. The connections will only be added if there is an available, direct, and collision-free path between them. Finally, this process repeats to build a roadmap that represents the feasible connectivity in the environment. Further, during the query phase, the start and goal will be connected to the existing roadmap using the same collision-free criteria. Then, the standard graph search algorithms will be applied to the map to find the feasible path from the start to the goal.

3.2. A* and Hybrid A* Algorithms

Similarly, the A* algorithm is a graph-based path planning technique that finds the optimal path from the starting and the destination nodes in a weighted graph [5,6,7]. Using the following formula, the A* algorithm combines the actual cost $g\left(n\right)$ from the start node to the given node n and the heuristic estimated cost $h\left(n\right)$ to reach the destination or goal node from the node n.

$$f\left(n\right)=g\left(n\right)+h\left(n\right).$$

(1)

The four most commonly used heuristic cost functions by the A* algorithm are Manhattan, Euclidean, Euclidean Squared, and Chebyshev, which are computed as follows:

$$h\left(n\right)=|x_2-x_1|+|y_2-y_1|,$$

(2)

$$h\left(n\right)=\sqrt{{(x_2-x_1)}^2+{(y_2-y_1)}^2},$$

(3)

$$h\left(n\right)={(x_2-x_1)}^2+{(y_2-y_1)}^2,$$

(4)

$$h\left(n\right)=max\left(\right|x_2-x_1|,|y_2-y_1\left|\right).$$

(5)

The implementation flowchart of the A* algorithm is shown in Figure 5. As illustrated in the figure, the algorithm comprises four phases. Firstly, the initialisation phase involves creating two lists. The open list collects nodes that are candidates for exploration, and the closed list contains nodes that have already been examined. The start node $n_{start}$ is added to the open list, and the cost from the starting point is set to zero. The total estimated cost for reaching the goal from the start node is computed using the cost function $f\left(n\right)$ in (1). The second phase is the exploration phase, in which the algorithm repeatedly examines the node n in the Open list that has the lowest estimated total cost value $f\left(n\right)$. During this phase, the A* algorithm efficiently narrows its search towards the goal by always choosing the most promising successor node. During this process, if the currently selected node happens to be the goal node, then the algorithm stops and proceeds to reconstruct the path; else, it moves on to further exploration and the successor generation phase.

The next phase is the successor generation phase, during which, if the goal node has not yet been reached, the algorithm generates all possible successors from the current node. Each successor is checked for validity by comparing it with both the open and closed lists. For all the valid successors, the associated costs such as $g\left(n\right)$, $h\left(n\right)$, and $f\left(n\right)$ are calculated using the heuristic cost functions given in (2) to (5). The final phase is the node expansion and path reconstruction phase. In this phase, the algorithm progresses by moving the current node n from the open to the closed lists. For each valid successor, the algorithm determines whether it should be added to the open list, updated with better cost or parent information, or ignored if it has already been processed under better conditions. When the goal node $n_{goal}$ is reached, the algorithm makes use of parent pointers that were stored during exploration to trace back from the goal to the start node $n_{start}$. By following these parent relationships, it efficiently builds the sequence of steps that constitute the optimal path found. This ensures that the result is both minimal in cost and valid concerning the constraints and heuristics used in the search.

The Hybrid A* algorithm is an extension of the traditional A*, which searches in a 2D grid space, while Hybrid A* searches in a 3D continuous kinematic state space defined by the vehicle’s position $(x,y)$ and orientation $\left(\theta \right)$. This orientation $\left(\theta \right)$ in Hybrid A* helps in producing smooth and feasible paths that a real vehicle can follow. The key features of this algorithm include path planning in a 3D continuous state space, encompassing orientation, as well as handling both forward and reverse motions. The algorithm further checks for collisions using state validators on occupancy maps and uses the cost function combining actual cost and heuristic, defined as follows:

$$f(x,y,\theta )=g(x,y,\theta )+h(x,y,\theta ),$$

(6)

where $g(x,y,\theta )$ is the actual cost from the start node to the current node, and $h(x,y,\theta )$ is the heuristic estimated cost to reach the goal node with orientation $\theta$, which is computed as

$$h(x,y,\theta )=\sqrt{{(x-x_g)}^2+{(y-y_g)}^2}+w_{\theta }·|\theta -{\theta }_g|,$$

(7)

where $(x_g,y_g,{\theta }_g)$ is the goal state, and $w_{\theta }$ is a weight factor.

3.3. Rapidly Exploring Random Tree (RRT)

The RRT algorithm is another path planning algorithm that rapidly expands in high-dimensional spaces to find a feasible path [28,29,30]. It achieves this by randomly sampling points in the free search space and connecting them to the nearest point in the existing tree, if feasible. This approach biases growth towards unexplored areas, enabling efficient coverage of large and complex environments. The RRT-based algorithm is divided into five phases, as illustrated in Figure 6. During the initialisation phase, the algorithm initialises the tree from the start or root node. Next, during the random sampling phase, the samples will be generated randomly from the free search space. Then, the algorithm identifies the node in the existing tree that is nearest to the random sample during the nearest node selection process. Then, during the extension phase, the tree attempts to extend from the nearest node towards the random sample, up to a specified step size. If the new position is obstacle-free, it becomes a new node with an edge connecting it to the nearest node. Otherwise, it will discard both the new node and the tree extension. Finally, during the termination phase, this process repeats until a node reaches sufficiently close to the goal or a maximum number of iterations is completed.

The RRT* algorithm is an optimized variant of the traditional RRT algorithm, which improves the path over time by incorporating a rewiring step, which reduces the path length and achieves a smoother path [31]. The flowchart of the RRT* algorithm, illustrating its phases including the rewiring step, is shown in Figure 7. As shown in the figure, during the initialisation phase, the algorithm initialises the tree with the starting node. During the sampling phase, the algorithm generates a random sample in the configuration space and selects the goal state directly to guide the search, a method known as goal-direct sampling. During the nearest node selection, the algorithm finds the nearest nodes in the existing tree to the sampled point. The extension and rewiring phase is the crucial phase in this algorithm. During this phase, the algorithm extends the tree in the same way as the RRT algorithm from the nearest node towards the sampled point. If the new edge is collision-free, then it will add the new node and the edge to the tree. If a collision occurs, the new node will be discarded. Further, the RRT* algorithm adds a rewiring step, which identifies the nearby nodes within the search radius. Then select the parent node for the new node that results in the lowest total cost. Further rewiring of nearby nodes occurs if connecting through the new node yields a shorter path. Finally, during the termination phase, the algorithm checks if the new node is within the goal region. Then, it will record the path and update the best shortest path. Finally, the algorithm reconstructs the optimal path from start to goal using the final tree structure.

The BiRRT is an extended version of the traditional RRT, where two trees grow simultaneously from the start and goal, unlike the RRT algorithm, which uses only one tree from the starting node [29]. Thus, by growing trees from both ends, the search space is explored more efficiently, making it suitable for high-dimensional spaces where direct single-tree exploration is slow. Similarly, the implementation flowchart of the BiRRT algorithm illustrating its six phases is shown in Figure 8. As illustrated in the figure, the algorithm proceeds through five phases. Firstly, during the initialisation phase, the algorithm initialises both trees, Tree A from the starting node and Tree B from the goal node. Similar to RRT*, during the sampling phase, the BiRRT algorithm also generates a random sample in the configuration space. It selects the goal state directly to guide the search, a method known as goal-direct sampling. During the expansion phase, both trees will find and expand towards the nearest node. For both trees, if the new edge is collision-free, then it will add the new node and the edge to the tree. If a collision occurs, the new node will be discarded. As both the trees expand simultaneously in this phase, the search space is explored more efficiently. The next phase is the connection and path reconstruction phase. During this phase, the algorithm checks if Tree B or the goal tree successfully connects to the new node in Tree A or the start tree, and then constructs the path. Otherwise, the algorithm proceeds to its final phase, known as the alternation or swapping phase. In this phase, the algorithm swaps the roles of both trees and continues from the samples phase by regenerating the random samples.

4. Advanced Motion Control Techniques

After obtaining the optimal path using the path planning techniques as explained in the previous section, the next essential part of autonomous robotic navigation is motion control. The motion control techniques will help the robot move along this path by controlling its drive components, such as motors and actuators, to achieve the desired speed at each moment. The path planning algorithms in Section 3 help decide where the robot should go in the occupancy maps defined in Section 2. The motion control techniques help determine how the robot, driven by DC motors, gets there. The motors in the robot require a precise control signal to achieve the target motion. To achieve this, this research employs four control strategies, including PID, fractional-order PID, state feedback control, and modern predictive controllers. These controllers help in accurately regulating speed and ensure the robot tracks the planned path reliably.

4.1. PID and Fractional-Order PID Controllers (FOPIDs)

The PID controller is one of the most commonly used feedback control systems, which maintains a desired output, namely the speed of the robot, by adjusting its inputs [41]. The controller combines three actions: the proportional part with gain $K_p$ to respond to present error, the integral part with gain $K_i$ to eliminate past error, and the derivative part with gain $K_d$ to anticipate future error. The controller equation in the time domain is defined as

$$u\left(t\right)=K_{p}e\left(t\right)+K_i{\int }_0^{t}e\left(\tau \right)d\tau +K_d{\displaystyle \frac{de\left(t\right)}{dt}},$$

(8)

where $e\left(t\right)=r\left(t\right)-y\left(t\right)$ is the tracking error. Further, the transfer function of the PID controller $C\left(s\right)$ in Laplace domain s is given as

$$C\left(s\right)=K_p+{\displaystyle \frac{K_i}{s}}+K_{d}s.$$

(9)

From the above PID controllers time domain and transfer function, the FOPID controllers equations can be achieved by replacing the integral and derivative actions with fractional orders of $\lambda$ and $\mu$, respectively, [41,42,43], as

$$u\left(t\right)=K_{p}e\left(t\right)+K_i{D}_t^{-\lambda }e\left(t\right)+K_d{D}_t^{\mu }e\left(t\right),$$

(10)

$$C\left(s\right)=K_p+{\displaystyle \frac{K_i}{s^{\lambda }}}+K_d{s}^{\mu }.$$

(11)

The block diagrams of PID and FOPID controllers for the speed control of the simplified vehicle model $G\left(s\right)$ are shown in Figure 9a and Figure 9b, respectively.

4.2. State Feedback Controller (SFC)

Unlike the PID controller that uses the transfer function model of the robot, the SFC uses state variables $x\left(t\right)$ of the system to compute the control input $u\left(t\right)$ using a constant gain matrix K defined as [44]

$$u\left(t\right)=-Kx\left(t\right).$$

(12)

The block diagram of SFC controllers for the speed control of the simplified vehicle model defined in state-space form is shown in Figure 10. As shown in the figure, the system is represented in state-space as

$$\begin{array}{cc}\hfill \dot{x}\left(t\right)& =Ax\left(t\right)+Bu\left(t\right),\hfill \\ \hfill y\left(t\right)& =Cx\left(t\right),\hfill \end{array}$$

(13)

where A, B, and C are the system, input, and output matrices. $x\left(t\right)$, $u\left(t\right)$, and $y\left(t\right)$ are the state, input and output vectors.

4.3. Model Predictive Controller (MPC)

MPC is an advanced control strategy that uses a model to predict the future behaviour of a system and optimizes control actions over a finite prediction horizon p, subject to constraints [45]. Unlike the SFC, the MPC controller is designed for a system represented in discrete-time state-space form, as follows:

$$\begin{array}{cc}\hfill x_{k+1}& =A{x}_k+B{u}_k,\hfill \\ \hfill y_k& =C{x}_k,\hfill \end{array}$$

(14)

where A, B, and C are the system, input, and output matrices. $x_k$, $u_k$, and $y_k$ are the state, input, and output vectors at time step k.

The block diagram of the MPC controller is shown in Figure 11. As shown in the figure, the above discrete-time state-space model is used to predict the system’s future state and output over a prediction horizon p. At each step, the MPC controller computes the optimal sequence of control inputs by minimising the cost function J, defined as

$$J=\sum _{i=k}^{k+p-1}{(y_i-r_i)}^{T}Q(y_i-r_i)+u_i^{T}R{u}_i,$$

(15)

where $r_i$ is the reference trajectory, Q and R are the tuned weighting matrices to find the future control inputs $(u_k,u_{k+1},\dots ,u_{k+p-1})$.

5. Results and Discussions

5.1. Performance Analysis of Path Planning Algorithms

This section presents the performance analysis of path planning algorithms given in Section 3 on the occupancy maps created in Section 2.

5.1.1. Case 1: Manually Defined Map

In this case study, the performance of all path planning algorithms given in Section 3 is evaluated on a manually generated occupancy map given in Figure 1a. The detailed performance comparison of various path planning algorithms, highlighting both qualitative behaviours and quantitative path length, computation time, and safety margin (i.e., the average distance maintained from the planned path and the nearest obstacle) results on a manually defined occupancy map, is shown in Figure 12 and

Table 2. Numerical performance comparison of various path planning algorithms on different occupancy maps.

Technique/Metrics	Case 1			Case 2			Case 3			Case 4
	PL	CT	SM	PL	CT	SM	PL	CT	SM	PL	CT	SM
PRM	136.89	0.082	0.75	738.37	64.731	3.50	38.39	0.721	0.18	480.72	64.40	0.20
A* with Euclidean	129.30	0.008	1.26	735.46	0.131	0.51	39.59	0.143	1.03	421.00	0.142	0.00
A* with Chebyshev	129.30	0.008	1.24	737.22	0.125	0.51	39.59	0.165	1.02	422.29	0.139	0.00
A* with Euclidean Squared	166.08	0.006	1.52	860.98	0.061	0.51	40.58	0.112	1.06	463.73	0.101	0.00
A* with Manhattan	129.30	0.007	1.26	756.17	0.114	0.51	39.83	0.115	1.06	429.90	0.144	0.00
Hybrid A*	131.86	0.325	1.29	726.05	22.58	3.28	40.29	20.766	1.59	700.82	136.39	0.18
RRT	169.82	3.227	1.07	973.55	7.198	3.73	55.36	0.054	3.11	–	–	–
RRT*	170.07	3.150	1.54	953.04	6.589	4.06	43.10	0.065	1.27	–	–	–
BiRRT	160.12	5.008	1.58	922.11	5.884	3.97	49.05	0.031	1.53	–	–	–

Note: PL = Path Length in meters, CT = Computation Time in seconds, SM = Safety Margin in meters.

. As shown in the figure and the table, the PRM method has achieved a path length of 136.89 m by constructing a collision-free network of sampled nodes (see Figure 12a). However, the PRM’s path will heavily depend on node density and also require significant preprocessing for reliability. On the other hand, the A* algorithm with both Euclidean and Chebyshev cost functions has achieved a path length of 129.30 m, which is the shortest path among all the compared methods. This is because the algorithm’s efficient heuristics allow the algorithm to perform optimal search in direct and diagonal movements (see Figure 12b,c). Moreover, the A* algorithm with the Manhattan cost function has also achieved the shortest path of 129.30 m in length, but restricted movements to orthogonal steps and produces a more angular trajectory (see Figure 12d). The A* algorithm with Euclidean Squared cost function has produced a longer path of length 166.08 m due to the higher penalties on longer moves and altering the route geometry (see Figure 12e). The Hybrid A* algorithm, which incorporates vehicle kinematics to generate smooth and drivable curves, has achieved a slightly longer path length of 131.86 m compared to the traditional A* algorithm but achieved a feasible path (see Figure 12f).

The conventional RRT quickly found a viable path with 169.82 m, but without optimal guarantees. The RRT* improved path smoothness and connectivity, but achieved a long 170.07 m path due to map constraints and sampling bias. The BiRRT achieved a 160.12 m path by simultaneously growing two trees from the start and goal, with faster convergence than the RRT algorithm. It is worth highlighting that all the sampling-based algorithms have produced longer paths due to their exploratory nature (see Figure 12g–i). Overall, the grid-based A* algorithm with Euclidean and Chebyshev metrics delivers the best optimal path, demonstrating superior path efficiency for this occupancy map.

The computational times shown in Table 2 indicate that the PRM technique completed in 0.082 s, whereas the A* algorithm with all four cost functions achieved the shortest times, ranging from around 0.006 to 0.008 s. In contrast, the Hybrid A* algorithm has a higher computational time of 0.325 s. On the other hand, the RRT family, including RRT, RRT*, and BiRRT, has the largest computational times, ranging from 3 to 5 s. This reflects the trade-off between exploration and efficiency. Further, the safety margins given in Table 2 show that the PRM maintained a moderate clearance, whereas the A* algorithm with all four cost functions achieved the paths with safety margins of 1.24 to 1.52 m. Moreover, the Hybrid A* algorithm provided a slightly better safety margin of 1.29 m, while RRT, RRT*, and BiRRT offered the highest safety margin up to 1.58 m. This indicates that the A* algorithm provides the shortest path in less computational time. At the same time, RRT techniques offer paths with the highest safety margins, albeit at the expense of longer paths and higher computational times.

5.1.2. Case 2: Map Created from Image

Similarly, in this case study, the performance of all path planning algorithms given in Section 3 is evaluated on an occupancy map generated from an image as presented in Figure 1b. Figure 13 presents the detailed performance evaluation of various path planning algorithms on a large, maze-like occupancy map generated from an image. Also, Table 2 presents the quantitative path length, computation time, and safety margin results for all the compared techniques. As shown in Figure 13a, the PRM technique has produced a feasible path with a length of 738.37 m by creating a dense network with 2000 node samples to capture narrow corridors and complex turns. On the other hand, among the grid-based techniques, as shown in Figure 13b,c, A* with Euclidean and Chebyshev cost functions has achieved the shortest path lengths of 735.46 m and 737.22 m, respectively. This is because the algorithm benefited from an optimal search that allows diagonal movements. The A* algorithm with the Manhattan function shown in Figure 13d has achieved a longer path of 756.17 m due to its restriction to orthogonal moves, which results in less direct routes in maze-like environments. Moreover, the A* algorithm with Euclidean Squared (see Figure 13e) has produced a significantly longer path of 860.98 m due to longer steps and additional detours. Hybrid A* has performed better among all the compared techniques and produced a shortest path of 726.05 m while maintaining kinematic feasibility, demonstrating its ability to generate smooth curves that reduce unnecessary detours (see Figure 13f).

Similar to Case 1, the sampling-based algorithms shown in Figure 13g–i have achieved longer paths due to their stochastic exploration. The RRT generated a longest path of 973.55 m due to its tendency to prioritise feasibility over optimality. The performance of RRT* has improved upon RRT by incremental path refinement and reducing the path length to 953.04 m. In comparison, the BiRRT achieved further improvement with a reduced path length of 922.11 m by simultaneously growing trees from the start and goal nodes. However, all RRT-based algorithms produced paths substantially longer than the grid-based techniques, indicating reduced efficiency in tightly constrained, corridor-dense maps. Overall, for this large and intricate map, Hybrid A* provided the most competitive balance between path efficiency and motion feasibility, outperforming all other compared techniques.

Similarly, the computational times in Table 2 highlight that the PRM technique required a significantly higher computational time of around 64.731 s, compared to the A* algorithm with all four cost functions, which had computation times ranging from 0.061 to 0.131 s. The Hybrid A* algorithm, however, showed a considerably larger computation time of 22.58 s due to its additional consideration of vehicle kinematics. In comparison, the RRT family (RRT, RRT*, and BiRRT) demonstrated moderate computational costs ranging between 5.884 and 7.198 s. Regarding safety margins, the PRM achieved a relatively high clearance of 3.50 m, while the A* variants delivered lower but consistent safety margins of around 0.51 m. The Hybrid A* algorithm achieved a safety margin of 3.28 m, showing a good trade-off between feasibility and clearance. On the other hand, the RRT, RRT*, and BiRRT algorithms produced the highest safety margins, ranging from 3.73 to 4.06 m, but at the expense of longer path lengths and higher computational requirements. Similar to Case 1, these results also indicate that while A* algorithms remain computationally efficient and deliver shorter paths, sampling-based RRT methods provide safer solutions but at a higher computational cost.

5.1.3. Case 3: Map Created from LiDAR Scans and Poses

Similarly, the performance of all path planning algorithms presented in Section 3 is evaluated on an occupancy map created from LiDAR scans and poses, as shown in Figure 2. Figure 14 presents a comparative assessment of various path planning algorithms applied to this probabilistic occupancy map, highlighting their exploration characteristics and the resulting paths. Table 2 also presents the quantitative path length, computation time and safety margin results for all the compared techniques for this map. The constructed path by the PRM technique in Figure 14a shows a graph of randomly sampled nodes connected by collision-free edges that produces a feasible path length of 38.39 m. As explained earlier, the technique’s performance depends solely on the sampling density.

The performance of the A* family of algorithms shown in Figure 14b–e demonstrates deterministic grid-based searches, with slight differences based on the cost functions. The A* with Euclidean heuristic produces a more direct route of path length 39.59 m. In comparison, A* with the Chebyshev function produced the same path length of 39.59 m using its efficient diagonal movements and potentially reducing path turns. Moreover, the A* with Euclidean-squared generated a longer path length of 40.58 m by moving more heavily and altering path geometry. In contrast, the A* with Manhattan function produced a path length of 39.83 m by restricting its motion to cardinal directions and creating more angular trajectories. On the other hand, Hybrid A*, shown in Figure 14f, produced a smooth path with a length of 40.29 m via drivable curves at the expense of higher computational demand.

Similar to cases 1 and 2, the sampling-based planners in this case also exhibit distinct trade-offs. The path by RRT shown in Figure 14f rapidly found the feasible solution with a path length of 55.36 m, though with less optimal and more irregular paths. The RRT* produced a shorter path, 43.10 m, than the RRT by incrementally rewiring its search tree for shorter, smoother routes, though at a higher computational cost. The BiRRT also outperformed the RRT by producing a feasible path of 49.05 m by growing two trees from the start and goal until they meet. Overall, the A* algorithm excels in generating a short and predictable path on a probabilistic occupancy map.

For Case 3, Table 2 shows that the PRM required 0.721 s of computation, which is higher than the A* algorithm variants, whose computational times ranged from 0.112 to 0.165 s. In contrast, the Hybrid A* algorithm had a significantly longer computational time of 20.766 s, due to the additional complexity of generating smooth kinematic paths. Interestingly, the RRT family was very efficient in this case, producing computational times ranging from 0.031 to 0.065 s, which is lower than both PRM and A*. Regarding safety margins, the PRM achieved a relatively low clearance of 0.18 m, while the A* variants achieved safety margins in the range of 1.02 to 1.06 m. Hybrid A* produced the highest margin of 1.59 m, showing an effective balance of feasibility and safety. Meanwhile, RRT, RRT*, and BiRRT offered higher safety margins, ranging from 1.27 to 3.11 m, indicating safer navigation, but often at the expense of longer paths. Unlike cases 1 and 2, this case demonstrates that RRT-based methods can achieve fast convergence and large safety margins, while A* remains more efficient in path optimality.

5.1.4. Case 4: Randomly Generated Map

Similarly, the performance of all path planning algorithms given in Section 3 is evaluated on a randomly generated complex occupancy map as presented in Figure 1c. Figure 15 and Table 2 present a comparative evaluation of all these path planning algorithms on a randomly generated complex occupancy map, highlighting both deterministic and sampling-based strategies and their respective adaptation to intricate environments. The PRM’s response, shown in Figure 15a, depicts a network of randomly distributed nodes and through collision-free connections, which achieved a feasible path of 480.72 m in length. However, as shown in the figure, the technique’s performance in this complex map is strongly dependent on higher sampling node density and connectivity. A lower sampling rate will result in a suboptimal path and exhibit excessive detours.

The A* algorithm with its four cost function variants shown in Figure 15b–e demonstrates strong deterministic performance on grid-based representations of this on a randomly generated complex occupancy map. First, the A* with Euclidean cost function identifies the most direct route of 421.00 m that efficiently navigates the intricate corridors. Second, the A* with Chebyshev of 422.29 m further supports diagonal transitions, maintaining its optimality and smoothness in open regions. Thirdly, the A* with Euclidean Squared cost of 463.73 m has a slightly increased path length due to its quadratic weighting. Finally, the A* with Manhattan cost function limits movements to grid-aligned directions and produced more angular trajectories of 429.90 m path length. The Hybrid A*, which extended the traditional A* by including vehicle kinematic constraints, resulted in smooth, feasible trajectories of 700.82 m in length. Although the path length exceeds that of A*, the algorithm ensures that physical motion constraints are maintained.

It is worth highlighting that for this highly cluttered and randomly generated complex map, all the sampling-based planners, RRT, RRT*, and BiRRT, did not succeed in completing a collision-free path. This is because the intrinsic randomness and reliance on open passages often lead to failed paths with constrained connectivity and narrow corridors. Overall, the results illustrate that A* and Hybrid A* excel in finding efficient, predictable paths in this randomly generated complex map.

In Case 4, the results in Table 2 indicate that PRM required 64.40 s of computation, similar to Case 2, whereas the A* algorithm variants have the fastest computational times between 0.101 and 0.144 s. The Hybrid A* method was computationally expensive, requiring 136.39 s, reflecting the increased complexity in larger maps. In terms of safety margins, PRM achieved only 0.20 m, while all A* variants yielded zero clearance, indicating that their optimal paths cut very close to obstacles. Hybrid A* maintained a slightly better margin of 0.18 m, though still quite small. Similar to earlier cases, A* algorithms guarantee the optimal paths with low computation time, though at the expense of safety clearance.

5.2. Performance Analysis of Motion Control Techniques

In this section, the performance of all motion control techniques given in Section 4 is evaluated on the following vehicle longitudinal dynamics model. This section also represents the integration between path planning and motion control through the use of a sinusoidal reference trajectory under ideal conditions and in the presence of dynamic disturbances, to simulate real-world uncertainties. The nonlinear continuous-time vehicle model is given by

$$\begin{array}{cc}\hfill {\dot{V}}_x\left(t\right)& ={\displaystyle \frac{1}{m}}\left[u\left(t\right)-{\displaystyle \frac{1}{2}}\rho C_{d}A{V}_x{\left(t\right)}^2-mgsin\theta \left(t\right)-C_{r}mgcos\theta \left(t\right)\right],\hfill \\ \hfill y\left(t\right)& =V_x\left(t\right),\hfill \end{array}$$

(16)

where

• $x\left(t\right)$—longitudinal position of the vehicle [m];
• $V_x\left(t\right)$—longitudinal velocity of the vehicle [m/s];
• ${\dot{V}}_x\left(t\right)$—longitudinal acceleration of the vehicle [m/s²];
• m—mass of the vehicle [kg];
• $u\left(t\right)$—net tractive/braking force applied at the wheels [N];
• $\rho$—air density [kg/m³];
• $C_d$—aerodynamic drag coefficient;
• A—frontal cross-sectional area of the vehicle [m²];
• g—gravitational acceleration ($\approx 9.81$ m/s²);
• $\theta \left(t\right)$—road slope angle [rad];
• $C_r$—rolling resistance coefficient;
• $y\left(t\right)$—measured output, taken as the vehicle longitudinal velocity [m/s].

The coefficient values used in this work are $\rho =1.225$ kg/m³, $C_d=0.3$, $A=2.2$ m², $C_r=0.015$ and $m=1400$ kg. The tuned parameters of PID and FOPID controllers using a trial-and-error approach for the control of a vehicle in (16) for following a sinusoidal path are $K_p=1100$, $K_i=100$, $K_d=60$, $\lambda =0.98$ and $\mu =0.02$. Similarly, during the design of SFC for obtaining K, the desired settling time and maximum overshoot are chosen as 2 and 0.05, respectively. On the other hand, the prediction and control horizons used during the design of MPC are 60 and 10, respectively. The performance comparison of all these motion control techniques, such as PID, FOPID, SFC, and MPC, for following a sinusoidal path defined by $V_{ref}=10+5sin\left(0.2t\right)$ is shown in Figure 16.

The numerical performance of these controllers is evaluated based on the tracking error $e\left(t\right)$, which is computed as follows:

$$e\left(t\right)=V_{\mathrm{ref}}\left(t\right)-V_x\left(t\right),$$

(17)

where $V_{\mathrm{ref}}\left(t\right)$ is the reference speed and $V_x\left(t\right)$ is the actual speed. From the above error $e\left(t\right)$, the performance metrics used in this work, such as MAE, RMSE, and IAE, are computed as

$$\begin{array}{c}\hfill \mathrm{MAE}={\displaystyle \frac{1}{N}}\sum _{i=1}^N\left|e_i\right|,\mathrm{RMSE}=\sqrt{{\displaystyle \frac{1}{N}}\sum _{i=1}^N{e}_i^2},\mathrm{IAE}={\int }_0^T\left|e\left(t\right)\right|dt,\end{array}$$

(18)

where N is the number of samples and T is the total simulation time. The numerical performance comparison of these controllers in terms of MAE, RMSE, and IAE is given in

Table 3. Numerical performance comparison of motion control techniques on a sinusoidal path without and with dynamic disturbances.

Controller	Sinusoidal Path Without Disturbances			Sinusoidal Path with Dynamic Disturbances
	MAE	RMSE	IAE	MAE	RMSE	IAE
PID	1.40	2.26	140.19	1.98	2.89	198.03
FOPID	1.19	1.68	119.65	1.21	1.69	121.72
SFC	0.37	0.64	37.01	0.38	0.80	38.81
MPC	0.09	0.59	9.89	0.19	0.65	19.46

.

From Figure 16 and Table 3, it is evident that the PID controller exhibits noticeable overshoot and steady-state deviations, with the highest tracking errors, MAE, RMSE, and IAE of 1.40, 2.26, and 140.19, respectively. Whereas the FOPID controller improved the performance of PID by providing smoother control actions and reducing overshoot, achieving an MAE of 1.19, an RMSE of 1.68, and an IAE of 119.65. The SFC method significantly enhances performance, with lower error values (i.e., MAE, RMSE, and IAE of 0.37, 0.64, and 37.01), demonstrating a faster transient response and improved steady-state accuracy. Finally, the MPC outperforms all other approaches, achieving the lowest tracking errors, with an MAE of 0.09, an RMSE of 0.59, and an IAE of 9.89, reflecting its ability to anticipate future reference changes and optimize control inputs accordingly. It is worth highlighting that the MPC achieved minimal overshoot, rapid settling, and excellent robustness to dynamic variations in the sinusoidal trajectory. Overall, while SFC delivers a significant improvement over PID and FOPID, MPC offers the most accurate and robust solution for tracking sinusoidal paths.

To further evaluate the robustness of the proposed motion controller strategies, a sinusoidal path with dynamic disturbances consisting of Gaussian noise and step-like variations has been incorporated. The performance comparison of all compared motion control techniques for following a sinusoidal path with dynamic disturbances is shown in Figure 17. From Figure 17 and Table 3, it is evident that all the compared controllers have experienced degraded performance. Firstly, the PID controller, with MAE, RMSE, and IAE of 1.98, 2.89, and 198.03, respectively, indicates that the controller is highly sensitive to disturbances. Secondly, the FOPID controller, with MAE = 1.21, RMSE = 1.69, and IAE = 121.72, demonstrates that it is less sensitive to disturbances than the PID controller. The SFC controller exhibited stable behaviour with MAE = 0.38, RMSE = 0.80, and IAE = 38.81. The MPC continued to outperform all the compared controllers, with MAE = 0.19, RMSE = 0.65, and IAE = 19.46. Thus, MPC provides superior robustness and accuracy under realistic disturbance conditions.

6. Conclusions

This paper presents an integrated framework for autonomous robotic navigation that combines three key components: environment mapping, path planning, and motion control. The performance of the proposed framework is evaluated on four distinct occupancy maps, including binary and probabilistic maps. Based on the performance evaluation of path planning algorithms on four occupancy map scenarios, Hybrid A* has achieved the optimal path with the shortest length from start to node of 131.86 m for Case 1, 726.05 m for Case 2, 40.29 m for Case 3, and 700.82 m for Case 4. The A* with Euclidean and Chebyshev heuristics also achieved the shortest paths in Case 1 with 129.30 m, Case 2 with 735.46 m and 737.22 m, and Case 3 with 39.59 m. However, all other compared techniques, such as PRM and RRT-based algorithms, have achieved longer paths. Furthermore, based on the performance evaluation of motion control techniques on the tracking sinusoidal path, MPC has outperformed all other compared controllers, such as PID, FOPID, and SFC, with the lowest tracking errors in terms of MAE, RMSE, and IAE of 0.09, 0.59, and 9.89, respectively. In addition, the numerical analysis, in terms of computational time and safety margin, also revealed that the A* algorithm with various cost functions achieved the shortest computational times, ranging from 0.006 to 0.165 s, with safety margins between 1.24 and 1.52 m. In contrast, the RRT, RRT*, and BiRRT algorithms have a longer computation time, ranging from 3 to 7 s, but offer the highest safety margins, up to 1.58 m. The Hybrid A* algorithm has yielded moderate computational times, ranging from 0.325 to 136.39 s, and a safety margin of 1.29 to 3.28 m, maintaining a competitive trade-off between computational effort and path safety.

These results demonstrate that the integrated framework offers an adaptable solution for robotic navigation, with the Hybrid A* and MPC being the optimal choices for path planning and motion control. However, a limitation of the present work is that the integration between path planning and motion control is represented using a predefined sinusoidal path under ideal conditions and in the presence of dynamic disturbances, rather than through direct closed-loop interaction. Therefore, future work will focus on integrating path planners and motion controllers in real-world environments that account for sensing noise, dynamic objects, and SLAM drift, aiming to achieve fully autonomous, adaptive navigation.