betaFeedback

WorksComputer Science

Planner-Controller Interaction for Ackermann Navigation: A Matched Simulation and Hardware Benchmark

Abstract

Global planners and path-tracking controllers are often evaluated independently, although their interaction determines how a vehicle follows a planned path. Whether simulation accurately predicts the performance of specific planner-controller combinations on Ackermann-steered hardware remains uncertain. This study evaluated three geometric controllers (Regulated Pure Pursuit, Stanley, and Vector Pursuit) paired with two global planners (Hybrid A* and NavFn) on a 1/10-scale Quanser QCar and in a matched Gazebo simulation. Both environments used shared custom planning and control algorithms, matched route geometry and goals, ground-truth pose references, and a common evaluation pipeline. Five runs per configuration and environment yielded 60 benchmark runs. Controller rankings for tracking accuracy and command smoothness transferred consistently between environments, with Spearman correlations of 0.77-0.94. However, planner-dependent effects showed substantially weaker agreement. In simulation, planner selection changed the root-mean-square (RMS) angular acceleration of the commanded velocities by no more than 0.030 rad/s^2, whereas Hybrid A* increased it by 0.141-0.843 rad/s^2 on hardware, depending on the controller. These differences coincided with planner-dependent achieved speeds that the simulation's idealised longitudinal response did not reproduce. Mean controller computation times remained below 0.5 ms on the Jetson TX2. The findings demonstrate that agreement in controller rankings does not guarantee accurate prediction of planner-dependent performance for specific controller pairings on hardware, highlighting the importance of physical validation.

*Corresponding author(s). E-mail(s): [email protected];

Introduction

Autonomous navigation systems separate global planning, which determines a path to the goal, from local control, which generates commands to track that path. The Nav2 framework of the Robot Operating System 2 (ROS 2) provides a modular architecture in which planners and controllers can be selected independently [1]. However, their interaction is particularly important for Ackermann-steered vehicles, which cannot turn in place and are constrained by a minimum turning radius. Grid-based planners may generate paths containing curvature that the vehicle cannot follow [2], whereas kinematically constrained planners such as Hybrid A∗A^* account for vehicle turning limits during planning [3, 4]. Consequently, the global planner determines not only the route but also the tracking demands imposed on the controller.

Geometric path-tracking controllers, including pure pursuit and Stanley, remain widely used because of their low computational requirements and relatively simple formulations [5]. However, their responses to planned path geometry differ. Lookahead-based controllers attenuate local path variations, while controllers incorporating direct cross-track and heading-error feedback respond more closely to the local path geometry. Planner selection may therefore influence each controller differently. The Nav2 maintainers have also recognised this coupling, recommending that path smoothing and controller selection be considered together [6]. Despite this, the influence of global planner selection on geometric controller performance, particularly under physical Ackermann steering constraints, remains insufficiently characterised.

Previous evaluations have predominantly compared controllers using fixed paths [7, 8, 9] or global planners using a fixed controller [10]. Filotheou et al. [11] evaluated combinations of global and local planners on a differential-drive platform, but the physical environment was not matched to the simulated environment. Although small-scale vehicles provide a practical intermediate platform between simulation and full-scale deployment [12], simulation does not necessarily preserve controller performance rankings on hardware [9, 13]. Existing comparisons therefore leave two related questions unresolved: whether the effect of global planner selection depends on the controller and whether these planner–controller interactions transfer from simulation to hardware. Addressing both requires matched experiments that control the planning and control implementations, route geometry, localisation reference, and evaluation procedure.

This study investigates these questions through a full-factorial benchmark of three geometric controllers (Regulated Pure Pursuit, Stanley, and Vector Pursuit) paired with two global planners (Hybrid A∗A^* and NavFn). Experiments were conducted on a 1/10-scale Quanser QCar equipped with an NVIDIA Jetson TX2 [14] and in a matched Gazebo simulation. The hardware and simulation environments used ROS 2 Dashing and Jazzy, respectively, while sharing the custom planning and control algorithms, parameters, route geometry, and key performance indicator (KPI) evaluation pipeline. Both environments employed ground-truth pose references to minimise the influence of localisation uncertainty. Five runs were conducted for each planner–controller combination in both environments, yielding 60 benchmark runs. Tracking accuracy, command smoothness, mission efficiency, and embedded computational performance were evaluated.

The study addresses three research questions:

RQ1: How does global planner selection influence tracking accuracy and command smoothness, and to what extent does this influence depend on the controller?

RQ2: Which controller rankings and planner–controller effects transfer from simulation to hardware across the evaluated KPIs?

RQ3: What computational resources do the planning and control algorithms require on the embedded platform?

The principal contributions are:

  1. A matched simulation–hardware benchmark of six planner–controller configurations on an Ackermann-steered vehicle, using shared custom algorithms and evaluation procedures with documented differences between environments.

  1. A quantitative analysis of planner effects, controller effects, and their interactions, supported by bootstrap confidence intervals, demonstrating substantially larger planner-dependent command variations on hardware than in simulation.

  1. An evaluation of simulation–hardware performance transfer using controller rankings, Spearman correlations, and planner-effect directions, showing that consistent controller rankings do not guarantee reliable prediction of individual planner–controller interactions.

  1. An assessment of computational performance on the Jetson TX2, accompanied by publicly available navigation software, simulation resources, analysis scripts, and processed KPI results.

Related Work

Comparisons of path-tracking controllers

Geometric path trackers such as pure pursuit and Stanley are widely used on research vehicles due to their simplicity, limited parameterisation, and low computational cost [5]. Comparative studies have predominantly evaluated controllers against fixed reference paths. Patnaik et al. [7] compared pure pursuit, Stanley, proportional–integral–derivative (PID), linear–quadratic regulator (LQR), and model predictive control (MPC) controllers in simulation and on an instrumented passenger car at 10 km/h, using straight, circular, lane-change, and sinusoidal paths. They attributed discrepancies between simulation and hardware to steering response delays, the inability to execute small steering adjustments, and unmodelled steering and tyre dynamics, but reported neither trial counts nor quantitative cross-environment comparisons. Dominguez et al. [8] evaluated pure pursuit, Stanley, a simplified kinematic controller, and a lateral-speed controller on a physical vehicle and in simulation along a longer recorded path at speeds up to 90 km/h. Stanley achieved slightly higher accuracy on hardware but became unstable above 25 km/h in simulation with its low-speed parameters, requiring separate tuning. Passenger comfort was assessed qualitatively, with Stanley’s rapid steering movements perceived as unsafe. Rokonuzzaman et al. [5] evaluated seven controllers in simulation using a common genetic-algorithm tuning objective to ensure equal tuning effort. Stanley exhibited the highest root-mean-square (RMS) and maximum lateral errors at low speeds.

Similar evaluation approaches were adopted on scaled and indoor platforms. Kong et al. [9] compared pure pursuit, MPC, and model predictive contouring control (MPCC) along a precomputed minimum-curvature raceline in the F1TENTH Gym simulator and on a 1/10-scale F1TENTH vehicle. Simulation rankings did not transfer to hardware, where pure pursuit performed best, which the authors attributed to computational delays in the optimisation-based controllers. Within Nav2, Elbouhy et al. [15] compared the DWB (dynamic window), Model Predictive Path Integral (MPPI), and Regulated Pure Pursuit (RPP) controllers on a Clearpath Jackal across identical simulated and physical obstacle scenarios, using a single A* global planner. Sant’Anna et al. [16] evaluated the same three controllers on a TurtleBot3, exclusively in physical environments. Neither platform employed Ackermann steering. Across these studies, reference paths were predefined, recorded, precomputed, or generated by a single global planner. Consequently, the influence of planner selection on individual controller performance remained unexamined.

Global planner selection and controller coupling

Grid-based planners such as NavFn assume holonomic motion, potentially generating paths that Ackermann-steered vehicles cannot follow exactly [2, 6]. Hybrid A* [3, 4] addresses this limitation by maintaining continuous vehicle states within a discretised (x,y,θ)(x, y, \theta) search space, producing kinematically feasible paths. Accordingly, the ROS 2 navigation maintainers recommend Hybrid A* for Ackermann vehicles and advise selecting path smoothers in conjunction with path-tracking controllers [6]. However, these recommendations did not quantify the influence of planner selection on controller performance.

Experimental comparisons of global planners have generally held the controller fixed or evaluated planner–controller combinations without isolating their individual effects. Borse et al. [10] compared NavFn, Smac 2D, and Theta* with a fixed MPPI controller on an omnidirectional Robotino, conducting five runs per path in Webots and on hardware. Hardware experiments used GPS-derived poses instead of simulated odometry, comparable to the ground-truth reference employed here (Section 3.3). Hardware execution time was approximately 1.01 times that of simulation. Filotheou et al. [11] evaluated nine combinations of three global and three local ROS 1 planners on a differential-drive TurtleBot 2, conducting ten runs per combination across two simulated environments and one physical laboratory. However, the laboratory was not replicated in simulation, and results from all three environments were aggregated. into a single composite score. Consequently, the study ranked planner combinations without assessing whether their performance transferred from simulation to hardware. Neither Ackermann steering nor geometric path trackers were considered.

Simulation-to-hardware performance agreement

Small-scale vehicles bridge the gap between simulation, which often lacks physical fidelity, and full-scale testing, which is constrained by time, space, and cost [12]. However, a systematic review of 38 studies found that simulation-to-hardware discrepancies were rarely examined in depth, with transferability generally reported without detailed quantitative analysis [12]. Where agreement was assessed, it was often limited to individual metrics, such as execution-time ratios [10], or qualitative observations of vehicle behaviour [7].

More detailed approaches have examined signal-level agreement and performance rankings. García Daza et al. [17] replicated a physical route in simulation and quantified the reality gap of an MPC path-tracking controller using Pearson correlation and maximum normalised cross-correlation of lateral error, steering angle, lateral acceleration, and lateral jerk. While this assessed behavioural agreement for an individual controller, it did not establish whether relative performance rankings transferred. Kadian et al. [13] addressed this distinction by defining a simulation-to-hardware correlation coefficient based on Pearson correlation across multiple methods. Evaluating nine navigation models on a LoCoBot and a scanned simulation replica of the laboratory, they reported a success-rate correlation of 0.18 and nine pairwise ranking reversals. After simulator parameter tuning, the correlation increased to 0.844. Kong et al. [9] similarly observed controller ranking reversals on a scaled vehicle (§ 2.1).

The present study adopts a ranking-based evaluation because absolute KPI values were not directly comparable between environments (§ 3.5). Agreement is assessed per KPI through rank correlation across six planner–controller combinations and further examined through the direction of each controller’s planner effect (§ 5.3).

Evaluation of command smoothness

Previous studies have assessed navigation smoothness through trajectory geometry [11, 15], actuation magnitude [16], or qualitative passenger feedback [8]. Urrea and Valencia-Aragon [18] instead employed command-based metrics, including the integrals of squared linear and angular velocity commands and the number of angular velocity sign changes. However, their comparison of DWB, RPP, and MPPI was limited to simulation on a differential-drive platform with NavFn as the sole global planner. The reviewed literature therefore does not establish how planner selection influences the rate of change of velocity commands across geometric Ackermann controllers, or whether their smoothness rankings transfer from simulation to hardware.

Research gap

Previous studies have predominantly compared controllers along fixed paths, evaluated planners with a fixed controller, or ranked planner–controller combinations without isolating their effects. Simulation–hardware agreement has been assessed through qualitative observations, individual performance metrics, signal-level correlations, or controller rankings. To the best of our knowledge, no study has systematically evaluated multiple geometric controllers and global planners on an Ackermann-steered vehicle under matched simulation and hardware conditions, while examining the transfer of planner effects, controller rankings, and their interaction. This study addresses these gaps using matched routes, goals, ground-truth pose references, shared planning and control algorithms, and a common KPI evaluation pipeline. Command smoothness and onboard computational load are also evaluated.

System and Platform

The QCar platform

The Quanser QCar is a 1/10-scale Ackermann-steered research vehicle [14] (Figure 1). The complete navigation stack operated on the onboard NVIDIA Jetson TX2, a resource-constrained embedded computer [19].

The Quanser QCar platform with its main components

Figure 1. The Quanser QCar platform with its main components

The RPLiDAR A2 light detection and ranging (LiDAR) sensor was the only onboard sensor used, providing data for map construction and costmap obstacle layers. Vehicle pose was obtained from an external motion-capture system (§ 3.3).

Table 1 summarises the platform parameters. The maximum steering angle of ±30∘\pm30^\circ corresponds to a minimum turning radius of approximately 0.44 m (L/tan⁡δmax⁡L / \tan\delta_{\max}), while the steering servo exhibits a first-order response with a time constant of 0.16 s [14]. These constraints govern path feasibility and tracking performance.

ParameterSymbolValue
WheelbaseLL0.256 m
Wheel radiusrwr_{\mathrm{w}}0.033 m
Encoder resolutionNencN_{\mathrm{enc}}28 800 counts/rev (quadrature)
Steering time constantτ\tau0.16 s
Maximum steering angleδmax⁡\delta_{\max}±0.5236\pm0.5236 rad (±30∘\pm30^\circ)

Table 1. QCar physical parameters

Software stack

The QCar operated on Ubuntu 18.04 with ROS 2 Dashing, constrained by the Jetson TX2, whereas simulation used Ubuntu 24.04, ROS 2 Jazzy, and Gazebo Harmonic. Both environments employed Nav2 [1], whose navigation pipeline is detailed in § 3.4.

The Hybrid A∗A^* planner and three controllers (RPP, Stanley, and Vector Pursuit) were developed from a common source tree compatible with both distributions. Hybrid A∗A^* operated as a standalone node implementing the ComputePathToPose action, while NavFn used the stock Nav2 planner server. Since Dashing predates the plugin-based controller server, each controller was hosted in a standalone action server exposing FollowPath, with the same servers ported to Jazzy for simulation. All controllers operated at 20 Hz with a position-only goal tolerance of 0.15 m. Cross-environment software and configuration equivalence is detailed in § 3.6.

Test track, mapping, and pose reference

Hardware experiments were conducted on a hook-shaped corridor constructed from cardboard walls within a 5.2 m ×\times 5.35 m laboratory area (Figure 2). The median free corridor width was 0.67 m. The route comprised an initial straight, a 200° left-hand bend with a centreline radius of approximately 1.9 m, and a return section terminating in a tight left turn into a dead end. Although the start and goal were separated by only 2.7 m, the planned route was approximately 10.6 m long. The final turn, with a radius of 0.5 m, approached the vehicle’s minimum turning radius of 0.44 m, making it the most kinematically demanding section.

Figure 2. The hook-shaped test track, bounded by cardboard walls (a), and the Gazebo track world rebuilt from it (b), with the occupancy grids used for navigation on hardware (c) and in simulation (d)

Vehicle pose was obtained from an OptiTrack motion-capture system comprising six cameras tracking six rigid-body markers mounted on the QCar [20]. These measurements served as the sole odometry source, without encoder or inertial measurement unit (IMU) fusion. An occupancy grid was generated using Cartographer [21] from LiDAR scans and motion-capture odometry collected during teleoperation. The resulting 0.05 m resolution map remained unchanged throughout the experiments.

Navigation architecture

Navigation followed the standard Nav2 architecture [1] (Figure 3). For each run, the behaviour-tree navigator requested a global plan through the ComputePathToPose action and passed it to the selected controller through FollowPath. Replanning and recovery behaviours were disabled, ensuring that each run evaluated one controller tracking a single global plan.

Navigation pipeline

Figure 3. Navigation pipeline, identical in both environments: one goal, one global plan, and no replanning or recovery. VP: Vector Pursuit

Both planners exposed the same planning interface, with the generated path serving as the sole handoff to the controller. The global costmaps comprised static (Cartographer), obstacle (LiDAR), and inflation layers. Hybrid A* maintained a separate costmap instance, while NavFn used the Nav2 planner server’s costmap, with identical configurations. The controllers employed rolling local costmaps with obstacle and inflation layers. All costmaps used a resolution of 0.05 m, a circular vehicle footprint of radius 0.24 m, and an inflation radius of 0.55 m.

The transformation chain comprised map →\to odom →\to base. On hardware, the odom →\to base transform was obtained directly from motion capture at 50 Hz, without filtering or latency compensation, and timestamped upon arrival. A fixed map →\to odom transform aligned the Cartographer map with the motion-capture reference frame throughout the trials.

Simulation environment

The hardware configuration was replicated in Gazebo Harmonic [22] (Figure 4), using a Unified Robot Description Format (URDF) vehicle model with the physical parameters listed in Table 1. Gazebo’s Ackermann steering system converted linear velocity and steering commands into wheel and steering-joint actuation, incorporating the physical steering lag (τ=0.16\tau= 0.16 s). However, longitudinal dynamics were idealised, with the simulated vehicle tracking commanded speeds exactly, whereas the hardware employed open-loop throttle control and exceeded commanded speeds. Consequently, absolute KPI values were not compared between environments (§ 5.3).

The simulated QCar and track in Gazebo Harmonic and the physical setup

Figure 4. The simulated QCar and track in Gazebo Harmonic (a) and the physical setup (b)

The simulated odom →\to base transform was obtained from ground-truth pose at approximately 48 Hz, comparable to the hardware motion-capture rate. Unlike simulation, hardware measurements incurred transport latency, with mean retrieval times of 8.3–8.9 ms and 95th percentiles of 13.7–17.4 ms. These measurements exclude internal motion-capture processing and therefore represent lower bounds on latency. At hardware speeds of 0.40–0.67 m/s, the corresponding positional lag was approximately 3–12 mm, small relative to the corridor width and measured cross-track errors (34–144 mm). The pose references were therefore considered sufficiently comparable for benchmarking. The simulated LiDAR matched the RPLiDAR A2 scan rate (10 Hz) and range (0.15–12 m), supplying only the costmap obstacle layer.

The Gazebo track geometry and navigation map were reconstructed from the hardware occupancy grid. Goal positions differed by less than 1 cm, while the mean hardware start position was within 0.08 m of the simulated start, with a standard deviation of 0.03 m across runs. Hybrid A* generated plans of 10.72 m in simulation and 10.61 m on hardware, a difference of 0.11 m. NavFn produced a larger discrepancy of 0.40 m, with corresponding lengths of 11.04 m and 10.64 m.

Simulation–hardware correspondence

Table 2 summarises the correspondence between the hardware and simulation configurations. The custom Hybrid A* planner and controller algorithms used byte-identical source files and parameters, with only their ROS 2 server wrappers adapted between Dashing and Jazzy. NavFn used the stock implementation from each distribution with matched parameters. Although the LiDAR scan resolutions differed, neither environment’s obstacle layer introduced occupied cells beyond the static map. Consequently, this difference did not alter the obstacle information available to the planners and controllers.

ComponentHardwareSimulationStatus
OS / ROS 2Ubuntu 18.04 / DashingUbuntu 24.04 / JazzyDiffers
ComputeJetson TX2Desktop PCDiffers
Hybrid A* plannerStandalone nodeSame algorithm and parametersIdentical
NavFn plannerDashing stock implementationJazzy stock implementation; same parametersMatched parameters
Controllers (RPP, Stanley, Vector Pursuit)Standalone action serversSame algorithms and parameters; wrappers ported to JazzyIdentical algorithms
Navigation settings20 Hz; single plan; no replanning or recovery; 0.15 m position-only goal toleranceSameIdentical
Global costmapStatic, obstacle and inflation layers; 0.05 m resolution; r=0.24r = 0.24 m; 0.55 m inflationSameIdentical
Pose source (odom → base)Motion capture, 50 Hz, timestamped on arrivalSimulator ground truth, ≈48\approx48 HzComparable
map → odomConstant offsetIdentityFrame-aligned
Navigation mapCartographer occupancy gridGenerated from the same gridMatched
LiDAR384 samples, ≈10\approx10 Hz, 0.15–12 m720 samples, 10 Hz, 0.15–12 mComparable
Start and goalHand-placed start; goal (0.570, 2.643)Start (0, 0); goal (0.56, 2.64)Matched geometry
Steering conversion, limit and lagδ=arctan⁡(Lω/v)\delta= \arctan(L\omega/v); ±0.5\pm0.5 rad; τ=0.16\tau= 0.16 sSameIdentical
Longitudinal responseOpen-loop throttleExact commanded speedDiffers

Table 2. Simulation–hardware software and configuration correspondence

Planning and Control Methods

Hybrid A* and NavFn global planners

NavFn and Hybrid A* were selected to compare global planning with and without explicit vehicle kinematic constraints. NavFn generates grid-based paths without enforcing curvature limits, leaving the controller to accommodate potentially infeasible turns. In contrast, Hybrid A* incorporates the vehicle’s minimum turning radius during planning, reducing the burden on the controller.

NavFn constructs a navigation function through wavefront expansion from the goal and extracts a path using gradient descent [23]. It was configured with Dijkstra expansion, a goal tolerance of 0.15 m, and planning through unknown space enabled. The planner represents the vehicle as a circle without imposing curvature or heading constraints.

Hybrid A*, based on [3, 4], searches over continuous states (x,y,θ)(x, y, \theta) using fixed-length bicycle-model motion primitives:

θj+1=θj+sRmin⁡σ,xj+1=xj+scos⁡θj+1,yj+1=yj+ssin⁡θj+1(1)\begin{aligned} \theta_{j+1} &= \theta_j + \frac{s}{R_{\min}}\sigma,\\ x_{j+1} &= x_j + s\cos\theta_{j+1},\\ y_{j+1} &= y_j + s\sin\theta_{j+1} \tag*{(1)} \end{aligned}

where jj is the primitive step index, σ∈{−1,−0.5,0,0.5,1}\sigma\in\{-1,-0.5,0,0.5,1\} represents steering input as a fraction of full lock, s=0.15s = 0.15 m is the step length, and Rmin⁡=0.5R_{\min} = 0.5 m is the minimum turning radius. The resulting maximum heading change was 0.30.3 rad per step. Setting Rmin⁡R_{\min} above the QCar’s geometric minimum of 0.440.44 m (§ 3.1) ensured that the motion primitives respected its curvature limit. Expanded states were stored in a closed set discretised by costmap cell and 72 heading bins of 5∘5^\circ each.

The accumulated cost gg combined path length, a turning penalty (weight 1.2), and normalised costmap cost (weight 2.0), favouring paths away from obstacles and towards the corridor centreline. The heuristic hh used an 8-connected Dijkstra cost-to-go from the goal, incorporating the same costmap term to account for corridor geometry. Each motion primitive was collision-checked along its length at intervals of half the costmap resolution, with unknown and inscribed cells treated as occupied. Search terminated within 0.20.2 m of the goal position or after 2000 expansions, without enforcing goal heading.

The resulting path was smoothed iteratively while preserving its endpoints. Each interior point xi\mathbf{x}_i was adjusted towards its original position xi0\mathbf{x}_i^0 and the midpoint of its neighbours:

xi←xi+wd(xi0−xi)+ws(xi−1+xi+1−2xi)(2)\mathbf{x}_i \leftarrow\mathbf{x}_i + w_d(\mathbf{x}_i^0-\mathbf{x}_i) + w_s(\mathbf{x}_{i-1}+\mathbf{x}_{i+1}-2\mathbf{x}_i) \tag*{(2)}

where wd=0.5w_d = 0.5 and ws=0.3w_s = 0.3. Smoothing continued for up to 50 iterations or until the total displacement per iteration fell below 0.050.05 m. Updates were accepted only when the new point and its connecting segment to the preceding point were collision-free. The complete smoothed path was not subsequently revalidated, and path headings were recomputed from its final geometry.

Regulated Pure Pursuit

Figure 5 illustrates the geometry of the three implemented controllers.

Geometry of the three controllers as implemented

Figure 5. Geometry of the three controllers as implemented

The first controller was based on pure pursuit [24], incorporating curvature-dependent speed regulation adapted from RPP [25]. At each control cycle, the path was pruned to the closest pose while preserving forward progress, preventing the lookahead point from returning to previously traversed sections. This was particularly relevant to the hook-shaped track, where separate route segments passed close together. The lookahead point was selected as the first remaining path pose at least Ld=0.6 mL_d = 0.6\,\mathrm{m} from the vehicle. Its coordinates (x,y)(x,y) in the vehicle frame determined the commanded curvature:

κ=2yx2+y2(3)\kappa= \frac{2y}{x^2+y^2} \tag*{(3)}

The commanded speed vv was scaled by 0.75 for ∣κ∣>0.3/m|\kappa| > 0.3/\mathrm{m} and by 0.5 for ∣κ∣>0.5/m|\kappa| > 0.5/\mathrm{m}. Angular velocity ω=vκ\omega= v\kappa was limited to 1.0 rad/s and converted to a steering angle using the bicycle model:

δ=arctan⁡(Lωv),(4)\delta= \arctan\left(\frac{L\omega}{v}\right), \tag*{(4)}

with steering constrained to the vehicle’s configured limits. The controller used neither cross-track nor heading-error feedback, relying instead on lookahead geometry, which attenuated path variations shorter than the lookahead distance. Unlike the full RPP formulation, proximity-based speed reduction, approach-velocity scaling, and collision checking were not implemented.

Stanley

The second controller implemented the kinematic Stanley steering law [26, 27], combining heading alignment with cross-track error correction. The reference point was positioned 0.256 m ahead of the vehicle centre, approximately 0.13 m ahead of the front axle. At each cycle, the path was pruned as in RPP, and the pose nearest to this reference point was selected. Cross-track error ee was defined as the lateral offset of the selected pose in the vehicle frame, while heading error ψ\psi was calculated from the orientation of the outgoing path segment. The steering command was

δ=ψ+arctan⁡(kemax⁡(∣v∣,v0)),v0=0.1 m/s(5)\delta= \psi+ \arctan\left(\frac{ke}{\max\left(|v|,v_0\right)}\right), \qquad v_0 = 0.1\,\mathrm{m/s} \tag*{(5)}

with k=0.80k = 0.80. Although the denominator includes a minimum-speed threshold v0v_0, the controller server supplied zero as the current velocity in every cycle. Consequently, the denominator remained fixed at v0v_0, yielding an effective cross-track gain of k/v0=8/mk/v_0 = 8/\mathrm{m} independent of actual vehicle speed. The steering command was limited to ±0.5\pm0.5 rad.

For consistency with RPP, the same curvature-dependent speed regulation was applied, using the curvature implied by the steering command, κ=∣tan⁡δ∣/L\kappa= |\tan\delta|/L. Unlike RPP, Stanley corrected errors at the nearest path pose rather than using a lookahead point, making its response more sensitive to local path variations. The yaw-rate and steering-delay damping terms of the full Stanley formulation were not implemented.

Vector Pursuit

The third controller was a geometric path tracker inspired by Vector Pursuit [28], combining position and orientation errors without implementing the original screw-theoretic formulation. Its steering command was a weighted sum of geometric and orientation terms:

δ=ktδgeom+krδorient,\delta= k_t \delta_{\mathrm{geom}} + k_r \delta_{\mathrm{orient}},
δgeom=arctan⁡(2Lsin⁡αld)(6)\delta_{\mathrm{geom}} = \arctan\left(\frac{2L\sin\alpha}{l_d}\right) \tag*{(6)}

where δgeom\delta_{\mathrm{geom}} was the pure pursuit steering angle towards the first path pose at least 0.6 m from the vehicle centre, with bearing α\alpha and distance ldl_d (ld≥0.6l_d \ge0.6 m) expressed in the vehicle frame. The orientation term δorient\delta_{\mathrm{orient}} was the heading of the chord connecting the nearest path pose to a pose at least 0.25 m further along the path, expressed in the vehicle frame. Path pruning and lookahead selection followed RPP. The weights were kt=1.5k_t = 1.5 and kr=2.0k_r = 2.0, with the resulting steering command limited to ±0.5\pm0.5 rad.

Speed was scaled by 0.75 for ∣δ∣>0.30|\delta| > 0.30 rad and by 0.5 for ∣δ∣>0.425|\delta| > 0.425 rad. Unlike RPP and Stanley, this regulation used steering-angle rather than curvature thresholds.

The non-normalised weights and chord-based heading term prevent exact curvature tracking. For a vehicle on a circular path of radius RR, the steering command is approximately δ≈(ktL+krc/2)/R\delta\approx(k_tL + k_rc/2)/R, where cc is the chord length. This is approximately 2.5 times the steady-state requirement L/RL/R, requiring an inward lateral offset to maintain the curve. The controller therefore combines RPP’s lookahead-based steering with a local heading correction similar to Stanley.

Controller tuning protocol

Controller parameters were tuned before benchmarking using a separate track containing a sharp U-turn, rather than the evaluation route. Tuning was conducted in simulation and on hardware, prioritising collision-free route completion, command smoothness, and speed. The principal adjusted parameters were commanded linear velocity and Stanley’s cross-track gain kk. Adjustments were made iteratively until further changes increased cross-track error.

Structural parameters were shared where applicable, including the 0.6 m lookahead distance for RPP and Vector Pursuit, the ±0.5\pm0.5 rad steering limit, and the two-stage speed-regulation approach. Controller-specific parameters were then fixed across both planners and environments.

During benchmarking, all planner–controller combinations used the same nominal speed within each environment: 0.35 m/s on hardware and 0.30 m/s in simulation. These common setpoints avoided introducing commanded-speed differences between configurations within each environment. Parameters were not retuned for individual planners, preserving the planner–controller interactions under investigation. Table 3 summarises the final settings. Stanley’s sensitivity to its cross-track gain was evaluated separately in simulation (§ 6.4).

ParameterValue
Hybrid A*
Step length0.15 m
Minimum turning radius Rmin⁡R_{\min}0.5 m
Steering inputs{−1,−0.5,0,0.5,1}\{-1, -0.5, 0, 0.5, 1\} (fraction of full lock)
Heading bins72
Cost weightsTurning: 1.2; costmap: 2.0
Search limitsGoal tolerance: 0.2 m; maximum expansions: 2000
Smootherwd=0.5w_d = 0.5, ws=0.3w_s = 0.3; maximum 50 iterations; displacement threshold 0.05 m
NavFn
Search methodDijkstra expansion
Goal tolerance0.15 m
Unknown-space planningEnabled
Regulated Pure Pursuit
Lookahead distance0.6 m (fixed)
Speed regulation×0.75\times0.75 for ∣κ∣>0.3/m\lvert\kappa\rvert> 0.3/\mathrm{m}; ×0.5\times0.5 for ∣κ∣>0.5/m\lvert\kappa\rvert> 0.5/\mathrm{m}
Angular-rate limit1.0 rad/s
Stanley
Cross-track gain kk0.80
Minimum speed v0v_00.1 m/s
Reference-point offset0.256 m ahead of vehicle centre
Speed regulationRPP thresholds applied to κ=∣tan⁡δ∣/L\kappa= \lvert\tan\delta\rvert/L
Vector Pursuit
Lookahead distance0.6 m
Weights ktk_t, krk_r1.5, 2.0
Heading chordAt least 0.25 m
Speed regulation×0.75\times0.75 for ∣δ∣>0.30\lvert\delta\rvert> 0.30 rad; ×0.5\times0.5 for ∣δ∣>0.425\lvert\delta\rvert> 0.425 rad
Shared settings
Steering limit±0.5\pm0.5 rad
Controller frequency20 Hz
Commanded speedHardware: 0.35 m/s; simulation: 0.30 m/s
Goal checkPosition within 0.15 m of final plan pose; heading not checked
Costmaps (Hybrid A*, NavFn, and controllers)
Resolution0.05 m
Robot radius0.24 m
Inflation radius0.55 m

Table 3. Planner and controller parameters used in the benchmark. Environment-specific values are indicated

Experimental Design

Experimental design and run protocol

The experiment followed a full factorial design comprising three controllers, two planners, and two environments (simulation and hardware), with five valid runs per combination, yielding 60 benchmark runs. Each run followed the hook-shaped route described in § 3.3, using the single-plan navigation procedure established in § 3.4.

For hardware trials, the vehicle was manually positioned at the start before each run, with standard deviations of 0.03 m in position and 1.7° in heading across runs. Runs lasted 15–27 s from first motion to goal arrival, with all hardware trials conducted within a fixed battery operating range. In simulation, the vehicle was reset to an identical start pose before each run. Benchmark speeds were held constant across configurations within each environment (§ 4.5). Runs with non-benchmark speed settings, degraded motion-capture data, or incomplete recordings were repeated.

Each run recorded vehicle pose, the global plan, and velocity commands. Controller execution timing and system load were additionally recorded on hardware. All performance metrics were calculated offline from these recordings (§ 5.2).

Stanley’s cross-track gain sensitivity was evaluated separately in simulation. Both planners were tested at k∈{0.40,0.54,0.60,0.70}k \in\{0.40, 0.54, 0.60, 0.70\}, with three runs per value and all other parameters unchanged. The benchmark gain of k=0.80k = 0.80 was represented by the main simulation runs.

Performance and computational metrics

All KPIs were calculated offline using a common script across both environments. Each run was evaluated against its recorded global plan, using ground-truth pose expressed in the map frame: motion capture on hardware and simulator pose in simulation. The evaluation window extended from the first to the last velocity command with linear speed exceeding 0.01 m/s. Simulation timestamps followed the simulation clock.

Tracking accuracy.

Cross-track error (CTE) eie_i was defined as the shortest distance from each measured pose to the nearest plan segment, with the projection constrained to that segment. Tracking accuracy was summarised by the root-mean-square error (RMSE) and maximum deviation:

CTERMSE=1N∑i=1Nei2,CTEmax⁡=max⁡iei(7)\mathrm{CTE}_{\mathrm{RMSE}} = \sqrt{\frac{1}{N}\sum_{i=1}^{N} e_i^2}, \qquad\mathrm{CTE}_{\max} = \max_i e_i \tag*{(7)}

Heading error was calculated as the difference between vehicle yaw and the orientation of the nearest plan segment, wrapped to ±π\pm\pi and reported as an RMS value in degrees.

Command smoothness.

Commanded linear and angular velocities were resampled at 20 Hz using a zero-order hold. Their rates of change were approximated by finite differences and summarised as RMS linear and angular accelerations:

aRMS=1M−1∑i=1M−1(ui+1−uiΔt)2,Δt=0.05 s(8)a_{\mathrm{RMS}} = \sqrt{\frac{1}{M-1}\sum_{i=1}^{M-1}\left(\frac{u_{i+1}-u_i}{\Delta t}\right)^2}, \qquad\Delta t = 0.05\ \mathrm{s} \tag*{(8)}

where uiu_i denotes the corresponding linear or angular velocity command and MM the number of resampled commands. The evaluation window excluded the initial transition from rest and the final command to stop. These metrics quantify variations in controller commands rather than measured vehicle accelerations, avoiding direct dependence on the physical actuation response.

Efficiency.

Mission time was defined as the duration of the evaluation window. Driven distance was calculated by interpolating the pose trajectory to 10 Hz and summing successive displacements. Average speed was the driven distance divided by mission time. Path efficiency was defined as the ratio of driven to planned distance, with values above unity indicating additional travel. Planned distance was calculated after thinning successive plan points to a minimum spacing of 0.1 m, preventing grid-scale variations in NavFn paths from inflating their lengths. Final goal error was the distance between the last recorded pose and the plan endpoint.

Computational performance.

On hardware, controller execution time and control-loop period were recorded for each cycle. Execution time was summarised by its mean, 95th percentile, and maximum; loop period by its mean, standard deviation, and 95th percentile. Planning time was recorded for each global plan. Total CPU utilisation across all cores, per-process CPU utilisation, and memory usage were sampled at 2 Hz. Computational metrics covered the interval from the first planning request to the final motion command.

Statistical analysis

Individual runs were the unit of analysis, with five counted runs per environment–controller–planner combination (§ 5.1). Computational performance metrics were unavailable for some hardware runs because the corresponding topics were not logged in the recorded rosbags; these metrics were therefore summarised from the remaining valid recordings, with the corresponding sample size nn reported. Each combination was summarised by its mean and standard deviation (SD).

Simulation and hardware were analysed separately because their longitudinal responses differed (§ 3.5); data were neither pooled nor compared using absolute KPI values. Within each environment, three effects were estimated: the planner effect, defined as the Hybrid A∗^*–NavFn difference for each controller; controller effects, defined as pairwise controller differences within each planner; and planner–controller interactions, defined as differences in planner effects between controllers. The interaction therefore indicates whether planner influence depends on controller selection.

Effects were expressed as mean differences in the original KPI units, with 95% confidence intervals obtained through bootstrap resampling [29]. Runs were resampled with replacement within each combination for 10 000 iterations, and interval bounds were taken from the 2.5th and 97.5th percentiles of the resulting differences. An effect was considered resolved when its interval excluded zero. Significance tests and standardised effect sizes were not used because near-deterministic simulation produced Note: Simulation mission times use the simulation clock. Absolute KPI values are not compared between environments (§ 5.3).

extremely small within-cell variation, occasionally below a millimetre, while the five hardware runs per combination provided limited statistical power.

Simulation–hardware agreement was evaluated separately for each KPI using the Spearman rank correlation across the six configuration means [30], agreement in controller rankings within each planner, and agreement in the sign of each controller’s planner effect. These measures assessed the transfer of relative performance patterns rather than absolute KPI values.

Computational metrics were summarised descriptively from hardware runs using Hybrid A*, the more computationally demanding planner. Available sample sizes were n=3n = 3, 4, and 5 for RPP, Stanley, and Vector Pursuit, respectively. Planning times were pooled across controllers because planner execution preceded and was independent of controller operation.

Results

Overall performance

All 60 counted runs reached the goal. Table 4 reports the five headline KPIs for each planner–controller combination, while Figure 6 shows the recorded trajectories. Supplementary KPI results are provided in Table A1 in the Appendix.

ControllerPlannerCTE RMSE (m)Max. CTE (m)Linear accel. RMS (m/s2^{2})Angular accel. RMS (rad/s2^{2})Mission time (s)
Simulation
RPPHybrid A*0.0476 ± 0.0001730.109 ± 0.0001790.213 ± 0.007750.121 ± 0.0021955.4 ± 0.472
RPPNavFn0.0546 ± 0.00005480.156 ± 00.293 ± 0.007270.137 ± 0.0012153.7 ± 0.0821
StanleyHybrid A*0.0484 ± 0.0002950.0962 ± 0.001740.718 ± 0.01860.867 ± 0.022856.4 ± 0.685
StanleyNavFn0.0472 ± 0.0004970.145 ± 00.538 ± 0.02100.890 ± 0.019065.2 ± 0.129
Vector PursuitHybrid A*0.184 ± 0.001600.328 ± 0.01020.542 ± 0.03501.09 ± 0.034444.2 ± 0.932
Vector PursuitNavFn0.124 ± 0.001290.189 ± 0.0008580.441 ± 0.01291.06 ± 0.027947.4 ± 0.288
Hardware
RPPHybrid A*0.0565 ± 0.004430.121 ± 0.01080.530 ± 0.01670.377 ± 0.011215.8 ± 0.357
RPPNavFn0.0698 ± 0.03300.136 ± 0.06420.397 ± 0.01690.236 ± 0.020921.8 ± 2.88
StanleyHybrid A*0.0454 ± 0.01410.0909 ± 0.03010.986 ± 0.07101.41 ± 0.092223.9 ± 1.28
StanleyNavFn0.0343 ± 0.008920.0935 ± 0.03560.787 ± 0.03000.882 ± 0.080226.5 ± 0.595
Vector PursuitHybrid A*0.0939 ± 0.02330.191 ± 0.04440.878 ± 0.05542.13 ± 0.20617.4 ± 1.08
Vector PursuitNavFn0.144 ± 0.06730.327 ± 0.1660.603 ± 0.08081.29 ± 0.23722.8 ± 3.36

Table 4. Headline performance metrics for each planner–controller combination (mean ± SD, n=5n = 5)

Figure 6. Driven trajectories of all counted runs, by environment (rows) and planner (columns). Controllers are distinguished by colour and line style. Dashed black lines: plans. ◦: start; ×: goal. Grey: navigation map

ControllerPlannerPath efficiencyAverage speed (m/s)Final goal error (m)Heading error RMS (°)
Simulation
RPPHybrid A*0.9621 ± 0.0005130.186 ± 0.001830.1413 ± 0.001737.81 ± 0.0124
RPPNavFn0.9514 ± 0.0003740.193 ± 0.0002590.1400 ± 0.0019118.3 ± 0.0390
StanleyHybrid A*0.9642 ± 0.0005550.183 ± 0.002080.1377 ± 0.005156.87 ± 0.0802
StanleyNavFn0.9650 ± 0.001090.161 ± 0.0003580.1365 ± 0.0095316.8 ± 0.0616
Vector PursuitHybrid A*0.9160 ± 0.002610.222 ± 0.004330.1404 ± 0.004317.75 ± 0.0386
Vector PursuitNavFn0.9290 ± 0.001150.213 ± 0.001300.1407 ± 0.0014220.7 ± 0.0932
Hardware
RPPHybrid A*0.9984 ± 0.002910.674 ± 0.02370.07667 ± 0.06447.36 ± 0.356
RPPNavFn0.9978 ± 0.01260.509 ± 0.03720.05500 ± 0.027610.1 ± 1.35
StanleyHybrid A*1.006 ± 0.006490.445 ± 0.02500.07285 ± 0.01009.32 ± 0.957
StanleyNavFn0.9901 ± 0.009020.398 ± 0.008830.08353 ± 0.009967.48 ± 1.21
Vector PursuitHybrid A*1.032 ± 0.009930.631 ± 0.03400.09026 ± 0.056010.2 ± 0.600
Vector PursuitNavFn1.045 ± 0.03640.493 ± 0.06250.08126 ± 0.028215.0 ± 4.13

Table A1. Supplementary performance metrics for each planner–controller combination (mean ± SD)

Vector Pursuit recorded the highest cross-track error in every configuration. Its CTE RMSE ranged from 0.124–0.184 m in simulation and from 0.0939–0.144 m on hardware, whereas all RPP and Stanley configurations remained below 0.070 m. With Hybrid A* in simulation, Vector Pursuit maintained an inward offset along the main bend. On hardware with NavFn, it exhibited substantial lateral excursions along the initial straight, producing a mean maximum CTE of 0.327 m, with a maximum of 0.55 m in one run.

RPP and Stanley achieved CTE RMSE values below 0.055 m in simulation. With Hybrid A*, their errors were 0.0476 m and 0.0484 m, respectively; with NavFn, they were 0.0546 m and 0.0472 m. On hardware, Stanley achieved lower CTE RMSE than RPP with both planners: 0.0454 m versus 0.0565 m with Hybrid A*, and 0.0343 m versus 0.0698 m with NavFn.

Angular acceleration RMS consistently ranked the controllers RPP < Stanley < Vector Pursuit across both planners and environments. In simulation, the respective ranges were 0.121–0.137 rad/s², 0.867–0.890 rad/s², and 1.06–1.09 rad/s². On hardware, they were 0.236–0.377 rad/s², 0.882–1.41 rad/s², and 1.29–2.13 rad/s², respectively. Linear acceleration RMS followed the ordering RPP < Vector Pursuit < Stanley in every configuration.

Stanley recorded the longest mission time in all four environment–planner combinations, exceeding the other controllers by 1.0–17.8 s. Mission times were evaluated within each environment, as specified in § 5.3.

Planner–controller interaction

Figure 7 shows angular acceleration RMS for each controller with each planner, and Table 5 gives the planner effect (Hybrid A* minus NavFn) on linear acceleration RMS and CTE RMSE, both with 95% bootstrap confidence intervals (§ 5.3).

Figure 7. Angular acceleration RMS of each controller with each global planner, in simulation and on hardware. Points: cell means (n=5n = 5); error bars: 95% bootstrap confidence intervals of the cell mean. The controllers are offset horizontally for legibility

ControllerLinear accel. RMS (m/s2^{2}) — SimulationLinear accel. RMS (m/s2^{2}) — HardwareCTE RMSE (mm) — SimulationCTE RMSE (mm) — Hardware
RPP−0.080 [−0.088, −0.071]+0.133 [0.114, 0.151]−7.0 [−7.2, −6.9]−13.3 [−41.1, 10.5]
Stanley+0.179 [0.157, 0.201]+0.200 [0.136, 0.257]+1.2 [0.8, 1.7]+11.1 [−1.4, 24.3]
Vector Pursuit+0.101 [0.068, 0.126]+0.276 [0.201, 0.353]+60.4 [58.9, 62.1]−49.6 [−107.4, 3.1]

Table 5. Planner effect (Hybrid A* − NavFn) on linear acceleration RMS and CTE RMSE: mean difference and 95% bootstrap confidence interval per controller and environment

In simulation, planner selection had a limited effect on angular acceleration RMS. Hybrid A* reduced the metric by 0.016 rad/s2^{2} for RPP and 0.023 rad/s2^{2} for Stanley, while increasing it by 0.030 rad/s2^{2} for Vector Pursuit. The corresponding effects on linear acceleration RMS were −0.080, +0.179, and +0.101 m/s2^{2}, respectively.

On hardware, Hybrid A* increased both command-acceleration RMS metrics for all three controllers. Angular acceleration RMS increased by 0.141 rad/s2^{2} for RPP, 0.524 rad/s2^{2} for Stanley, and 0.843 rad/s2^{2} for Vector Pursuit. Linear acceleration RMS increased by 0.133 m/s2^{2}, 0.200 m/s2^{2}, and 0.276 m/s2^{2}, respectively, with every confidence interval excluding zero (Table 5). The differences between the controllers’ angular-acceleration planner effects were 0.38 rad/s2^{2} (Stanley–RPP), 0.70 rad/s2^{2} (Vector Pursuit–RPP), and 0.32 rad/s2^{2} (Vector Pursuit–Stanley) on hardware, compared with no more than 0.053 rad/s2^{2} in simulation.

Planner effects on tracking accuracy were less consistent. In simulation, Hybrid A* changed CTE RMSE by −7 mm for RPP, +1 mm for Stanley, and +60 mm for Vector Pursuit. No planner effect on CTE RMSE was resolved on hardware. For Vector Pursuit, the effect reversed to −50 mm, but its confidence interval included zero.

Note: nn = 5 runs per cell. Bootstrap: 10 000 resamples of runs within each cell (§ 5.3).

On hardware, all three controllers completed the route faster with Hybrid A*, despite identical commanded speeds across planners. Mission times decreased by 2.6–6.0 s, while average speeds increased by 0.05–0.17 m/s. In simulation, planner-dependent differences in average speed remained below 0.03 m/s.

Simulation-to-hardware transfer

Table 6 summarises simulation–hardware agreement in controller rankings and planner effects for each KPI.

KPISpearman ρ\rhoController order agrees: Hybrid A*NavFnPlanner-effect sign agrees: RPPStanleyVP
CTE RMSE0.886✗✓✓✓✗
Maximum CTE0.886✓✓✓✓✗
Linear accel. RMS0.943✓✓✗✓✓
Angular accel. RMS0.771✓✓✗✗✓
Mission time0.600✗✗✗✓✓
Path efficiency−0.714✗✗✓✗✓
Average speed0.600✗✗✗✓✓
Final goal error0.029✗✗✓✗✗
Heading error RMS0.371✗✓✓✗✓

Table 6. Simulation–hardware agreement in KPI rankings and planner-effect directions

Controller rankings for tracking accuracy and command smoothness showed the strongest agreement between environments. Spearman correlations were ρ=0.89\rho= 0.89 for both CTE RMSE and maximum CTE, 0.94 for linear acceleration RMS, and 0.77 for angular acceleration RMS. Within each planner, controller rankings were identical across environments for maximum CTE and both acceleration metrics. CTE RMSE Note: ✓ indicates agreement and ✗ disagreement. VP: Vector Pursuit. Spearman correlations use the six planner–controller cell means. Controller order is based on ascending cell means within each planner. Planner-effect signs are based on mean(Hybrid A*) − mean(NavFn) for each controller; sign agreement does not imply a statistically resolved effect.

rankings were also identical under NavFn; under Hybrid A*, only RPP and Stanley exchanged positions, having differed by 0.8 mm in simulation.

In contrast, planner effects showed limited transfer. For angular acceleration RMS, the effect direction agreed between environments only for Vector Pursuit; for linear acceleration RMS, agreement was observed for Stanley and Vector Pursuit. Planner-dependent changes in angular acceleration RMS did not exceed 0.030 rad/s2^{2} in simulation, whereas Hybrid A* increased the metric by 0.141–0.843 rad/s2^{2} on hardware (§ 6.2). Vector Pursuit’s CTE RMSE planner effect also reversed, from +60 mm in simulation to −50 mm on hardware, although the hardware confidence interval included zero.

Agreement was weaker for the remaining KPIs. Mission time and average speed each yielded ρ=0.60\rho= 0.60, with Vector Pursuit completing the route fastest in simulation and RPP on hardware. Stanley was the slowest controller in both environments. Heading error RMS (ρ=0.37\rho= 0.37) and final goal error (ρ=0.03\rho= 0.03) showed weak rank agreement, while path efficiency exhibited a negative correlation (ρ=−0.71\rho= -0.71), indicating substantially different configuration rankings.

Overall, simulation reproduced the relative controller performance in tracking accuracy and command smoothness, but not the magnitude or direction of planner-dependent effects consistently. Agreement in mission time, achieved speed, and secondary KPIs was also weaker.

Sensitivity of Stanley to its gain

Stanley’s response to its cross-track gain depended on the global planner (Figure 8). Reducing kk from 0.80 to 0.40 with Hybrid A* increased CTE RMSE from 48.4 mm to 61.7 mm, while reducing angular acceleration RMS from 0.867 rad/s2^{2} to 0.622 rad/s2^{2}. With NavFn, the same gain reduction increased both CTE RMSE (47.2 mm to 51.2 mm) and angular acceleration RMS (0.890 rad/s2^{2} to 1.08 rad/s2^{2}). The angular acceleration ranking RPP < Stanley < Vector Pursuit remained unchanged across all tested gains with Hybrid A*. With NavFn, Stanley matched or exceeded Vector Pursuit at k=0.40k = 0.40 and k=0.54k = 0.54, demonstrating that controller smoothness rankings were sensitive to gain selection under this planner.

Figure 8. Sensitivity of Stanley to its cross-track gain kk in simulation. (a) Angular acceleration RMS against kk; (b) CTE RMSE against kk. Stanley is shown in orange, with Hybrid A* as circles on a solid line and NavFn as squares on a dotted line. The horizontal lines in (a) are the benchmark values of RPP (blue) and Vector Pursuit (VP, green), solid for Hybrid A* and dotted for NavFn. Error bars: ±1 SD; n=3n = 3 runs per point for k<0.80k < 0.80 and n=5n = 5 at k=0.80k = 0.80 (the benchmark runs)

Computational load on the TX2

Table 7 reports the computational load measured on the Jetson TX2 during Hybrid A* hardware runs (n=3n = 3, 4, and 5 for RPP, Stanley, and Vector Pursuit, respectively). Measurements included the navigation stack, sensor drivers, motion-capture client, and data recording.

RPP<br>(n=3n = 3)Stanley<br>(n=4n = 4)Vector Pursuit<br>(n=5n = 5)
Controller computation time (ms)
Mean0.420 ± 0.05560.399 ± 0.01540.434 ± 0.0490
95th percentile0.968 ± 0.1890.923 ± 0.1601.11 ± 0.249
Per-run maximum8.26 ± 3.607.40 ± 4.565.40 ± 1.58
Control-loop period (ms)
Mean50.0 ± 0.00057750.0 ± 050.0 ± 0.000894
SD0.924 ± 0.4080.824 ± 0.1051.16 ± 0.865
95th percentile51.0 ± 0.26251.0 ± 0.23751.0 ± 0.263
System resource utilisation
Total CPU mean (%)63.8 ± 0.10263.9 ± 0.46263.9 ± 0.0644
Total CPU maximum (%)65.2 ± 0.40465.7 ± 0.62965.7 ± 0.444
Controller CPU (% of one core)6.07 ± 0.2235.96 ± 0.05666.11 ± 0.159
Planner CPU (% of one core)4.31 ± 0.1153.97 ± 0.08664.16 ± 0.130
Peak system RAM (GiB)4.32 ± 0.01274.33 ± 0.01264.41 ± 0.0282
Planning time per plan (ms)Mean: 59.8; range: 27.2–123 (n=12n = 12)

Table 7. Computational performance on the Jetson TX2 during Hybrid A* hardware runs

Mean controller computation times ranged from 0.399 ms to 0.434 ms, with 95th-percentile values of 0.923–1.11 ms. The mean computation times differed by less than 0.04 ms across controllers. Mean control-loop periods remained at 50.0 ms, with standard deviations of 0.824–1.16 ms and 95th-percentile periods of 51.0 ms.

Hybrid A* planning required 27.2–123 ms per run, with a mean of 59.8 ms across 12 runs. Mean total CPU utilisation ranged from 63.8 % to 63.9 %, while the controller and planner processes consumed 5.96–6.11 % and 3.97–4.31 % of one CPU core, respectively. Mean peak system memory usage ranged from 4.32 GiB to 4.41 GiB of the available 8 GiB. These measurements indicate that controller computation imposed a limited processing burden on the TX2 under the tested workload.

Note: Values are mean ± SD across runs of the per-run statistic specified in each row. Total CPU utilisation is measured across all online cores; process CPU is expressed as a percentage of one core. RAM represents system memory in use (MemTotal − MemAvailable). Planning time was pooled across all 12 Hybrid A* runs. Measurements include the navigation stack, sensor drivers, motion-capture client, and recording processes.

Discussion

Transfer of controller rankings

Simulation reproduced the relative performance of the three controllers in tracking accuracy and command smoothness, with Spearman correlations ranging from 0.77 to 0.94 (Table 6). Controller rankings were identical across environments for maximum CTE and both command-acceleration metrics. The only discrepancy in CTE RMSE rankings occurred between RPP and Stanley under Hybrid A*, whose simulated errors differed by just 0.8 mm. These results demonstrate that simulation provided reliable controller rankings for lateral tracking accuracy and command smoothness under the tested configurations, despite differences in vehicle dynamics.

This agreement contrasts with the ranking reversals reported in previous studies. Kadian et al. [13] observed poor simulation–hardware ranking agreement until simulator parameters were tuned, while Kong et al. [9] attributed controller-ranking reversals to computational delays in optimisation-based methods. In the present study, the geometric controllers required less than 0.5 ms per command on average, representing less than 1% of the control period (§ 6.5). Their low computational demands reduce the relevance of optimisation-related delays observed in earlier comparisons. The rankings transferred despite the simulation’s idealised longitudinal response.

In contrast, metrics influenced by longitudinal dynamics showed weaker agreement. Mission time and average speed each yielded ρ=0.60\rho= 0.60, while path efficiency exhibited a negative correlation (ρ=−0.71\rho= -0.71). These discrepancies are consistent with the difference between ideal commanded-speed tracking in simulation and open-loop throttle control on hardware (§ 3.5). Final goal error showed negligible ranking agreement (ρ=0.03\rho= 0.03), with the hardware results reflecting residual vehicle motion after goal acceptance. Heading error RMS also showed limited agreement (ρ=0.37\rho= 0.37). Thus, simulation reliably ranked the tested controllers for lateral tracking accuracy and command smoothness but did not reproduce their relative performance in mission efficiency or final goal positioning.

The planner–controller interaction

The principal simulation–hardware discrepancy concerned planner-dependent command smoothness. In simulation, planner effects on angular acceleration RMS did not exceed 0.030 rad/s20.030\ \mathrm{rad}/\mathrm{s}^{2}, and interaction contrasts did not exceed 0.053 rad/s20.053\ \mathrm{rad}/\mathrm{s}^{2}. On hardware, Hybrid A* increased angular acceleration RMS by 0.1410.141–0.843 rad/s20.843\ \mathrm{rad}/\mathrm{s}^{2}, with interaction contrasts of 0.320.32–0.70 rad/s20.70\ \mathrm{rad}/\mathrm{s}^{2} (§ 6.2). Simulation therefore substantially underestimated the influence of planner selection on command smoothness.

On hardware, these effects coincided with differences in achieved vehicle speed. Despite a common nominal speed of 0.35 m/s0.35\ \mathrm{m}/\mathrm{s} and a fixed battery operating range, Hybrid A* configurations achieved average speeds 0.050.05–0.17 m/s0.17\ \mathrm{m}/\mathrm{s} higher than their NavFn counterparts. The corresponding differences in simulation remained below 0.03 m/s0.03\ \mathrm{m}/\mathrm{s}. The idealised longitudinal response in simulation (§ 3.5) did not reproduce the speed differences observed with the physical vehicle.

For a fixed curvature profile traversed at constant speed, angular acceleration scales with the square of vehicle speed. Applying this relationship to the measured mean hardware speeds gives predicted Hybrid A*–NavFn angular acceleration ratios of 1.75 for RPP, 1.25 for Stanley, and 1.64 for Vector Pursuit. The observed ratios were 1.60, 1.60, and 1.65, respectively. The agreement for RPP and Vector Pursuit is consistent with achieved speed contributing to their planner-dependent command variations. For Stanley, the observed increase exceeded the speed-based estimate, indicating that speed scaling alone does not account for the difference under these assumptions. Because the planners also generated different paths and vehicle speed varied during execution, these comparisons do not isolate speed as the causal mechanism.

Planner effects on tracking accuracy were less consistent, with no resolved CTE RMSE effects on hardware and a reversal in the observed effect for Vector Pursuit. Taken together, the findings show that simulation reproduced relative controller performance more consistently than planner-dependent effects. For the tested platform, planner selection based on command smoothness therefore required hardware validation.

Controller-specific behaviour

RPP consistently generated the smoothest commands. Its fixed 0.6 m lookahead and absence of direct cross-track feedback attenuated local path variations (§ 4.2), favouring smooth command generation while maintaining competitive tracking accuracy. Stanley’s fixed effective cross-track gain of 8/m8/\mathrm{m} made its steering response sensitive to small lateral deviations (§ 4.3). At zero heading error, cross-track errors of 1.0 cm and 1.6 cm reached the thresholds at which speed was scaled to 75% and 50%, respectively, while 6.8 cm brought steering to its limit. This sensitivity provides an explanation for Stanley’s consistently longer mission times despite its tracking accuracy.

The gain-sensitivity experiment further demonstrated the dependence of Stanley’s behaviour on planner selection (§ 6.4). Reducing the cross-track gain improved command smoothness with Hybrid A* but degraded it with NavFn. One possible explanation is the heading-error term’s sensitivity to local variations in NavFn’s grid-based path, which become relatively more influential as cross-track correction weakens. Consequently, the observed smoothness ranking was stable across the tested gains with Hybrid A*, but not with NavFn.

Vector Pursuit’s consistently higher tracking error was consistent with the curvature-tracking bias of the implemented control law (§ 4.4). Its non-normalised weights and chord-based orientation term required an inward lateral offset during steady turning, consistent with the trajectory observed under Hybrid A* in simulation. The large lateral excursions recorded with NavFn on hardware were not explained by this steady-turn behaviour alone. These findings characterise the geometric implementation evaluated here rather than the original screw-theoretic Vector Pursuit formulation [28].

Computational load

The geometric controllers imposed a limited computational burden on the Jetson TX2, with mean execution times below 0.5 ms and differences below 0.04 ms between controllers (§ 6.5). Their execution times were small relative to the 50 ms control period, indicating that controller computation was not a limiting factor under the tested workload. Although computational constraints have been identified as a concern for navigation on legacy NVIDIA Jetson platforms [31], the planning and control algorithms evaluated here required a small fraction of the available processing resources. This contrasts with the optimisation-based controllers examined by Kong et al. [9], for which computational delays contributed to differences between simulation and hardware performance.

The complete system nevertheless operated under a substantially greater workload, including sensor drivers, motion capture, and data recording. Total CPU utilisation reached 65.7% in the reported per-run statistics, while battery capacity constrained the duration of experimental sessions. The computational measurements were limited to Hybrid A* hardware runs, with three to five runs per controller. They therefore establish the feasibility of the tested implementations under the measured conditions, rather than their capacity to accommodate additional computational demands.

Scope and limitations

The benchmark comprised five runs per configuration, limiting the precision of hardware estimates, and computational measurements were limited to Hybrid A* hardware runs (n=3n = 3–5 per controller). Experiments were restricted to one vehicle, one track, and one commanded speed per environment. Consequently, the findings do not establish how planner–controller interactions vary with vehicle speed, route geometry, or operating conditions.

Simulation and hardware differed in longitudinal dynamics, with idealised speed tracking in simulation and open-loop throttle control on the QCar. The mechanism underlying the planner-dependent differences in achieved hardware speed was not independently isolated. Although the custom planning and control algorithms were shared, these differences limit the interpretation of simulation–hardware agreement.

Both environments used external ground-truth pose references, excluding the influence of online state-estimation errors. Hardware motion-capture measurements nevertheless incurred uncompensated latency, with the measured retrieval delay corresponding to a positional lag of 3–12 mm (§ 3.5).

Conclusion

This study evaluated three geometric path-tracking controllers (Regulated Pure Pursuit, Stanley, and Vector Pursuit) paired with two global planners (Hybrid A* and NavFn) on a 1/10-scale Ackermann vehicle and in a matched Gazebo simulation. The benchmark comprised 60 runs, with all configurations sharing the custom planning and control algorithms, route geometry, goals, and evaluation pipeline.

Controller rankings for tracking accuracy and command smoothness transferred consistently between environments, with Spearman correlations of 0.77–0.94. However, planner-dependent effects showed substantially weaker agreement. In simulation, planner selection changed angular acceleration RMS by no more than 0.030 rad/s20.030\ \mathrm{rad}/\mathrm{s}^{2}, whereas Hybrid A* increased it by 0.141–0.843 rad/s2^{2} on hardware, depending on the controller. These differences coincided with higher achieved speeds under Hybrid A*, which the simulation’s idealised longitudinal response did not reproduce. Mission time, average speed, path efficiency, and final goal positioning also showed weaker agreement.

The findings demonstrate that agreement in controller rankings does not guarantee agreement in planner–controller behaviour. Although simulation reproduced the relative tracking accuracy and command smoothness of the tested controllers, it did not consistently predict how individual planner–controller pairings would respond on hardware. Consequently, selecting a controller based on simulation performance alone is insufficient to establish the performance of a specific navigation configuration. Hardware validation remains necessary to assess planner–controller interactions under the intended operating conditions.

All three controllers operated within the Jetson TX2’s measured computational budget, with mean command computation times below 0.5 ms. Future work will incorporate an optimisation-based controller and extend the benchmark to additional routes, commanded speeds, and experimental repetitions. The navigation stack, simulation environment, and processed KPI results are openly available (see Data availability and Code availability).

Declarations

Data availability

The processed KPI results supporting the findings of this study are available in the hardware repository (https://github.com/HWUD-AIMBeyonD/qcar) and the simulation repository (https://github.com/HWUD-AIMBeyonD/QCarSim). The raw rosbag recordings are not publicly available due to their size but are available from the corresponding author on reasonable request.

Code availability

The planner, controller, simulation, and KPI-evaluation source code is available at https://github.com/HWUD-AIMBeyonD/qcar and https://github.com/HWUD-AIMBeyonD/QCarSim.

Acknowledgements

The authors acknowledge the AIMBeyonD Lab, in collaboration with which this research was conducted, and Heriot-Watt University Dubai for providing laboratory facilities and support.

Funding

No funding was received for this study.

Competing interests

The authors declare no competing interests.

Not applicable. This study did not involve human participants or animals.

Not applicable.

Author contributions

M. Saeed: Conceptualization, Methodology, Software, Investigation, Formal analysis, Data curation, Visualization, Writing – original draft, Writing – review & editing. M. Saleh: Supervision, Writing – review & editing. M. Shawgi: Supervision, Project administration, Writing – review & editing. M. Al Musleh: Resources, Writing – review & editing. All authors read and approved the final manuscript.

Thesis reuse disclosure

This article builds upon the first author’s undergraduate final-year project, “Design and Evaluation of a Scalable Autonomous Vehicle Navigation Stack”, submitted to Heriot-Watt University Dubai in 2026.

Supplementary KPIs

Note: Simulation average speeds were calculated using simulation-clock time. They are below the 0.30 m/s simulation setpoint because the curvature- and steering-based speed regulation (§ 4) reduced the commanded speed along the curved sections of the route.

References

  1. [1]Macenski, S., Martín, F., White, R., Ginés Clavero, J.: The Marathon 2: A navigation system. In: 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 2718–2725 (2020). https://doi.org/10.1109/IROS45743.2020.9341207
  2. [2]Macenski, S., Booker, M., Wallace, J., Fischer, T.: Cost-aware kinematically feasible planning for mobile and surface robotics. IEEE Robotics and Automation Practice 1, 81–85 (2026) https://doi.org/10.1109/RAP.2026.3684018
  3. [3]Dolgov, D., Thrun, S., Montemerlo, M., Diebel, J.: Practical search techniques in path planning for autonomous driving. In: Proceedings of the First International Symposium on Search Techniques in Artificial Intelligence and Robotics (STAIR-08). AAAI, Chicago, USA (2008)
  4. [4]Dolgov, D., Thrun, S., Montemerlo, M., Diebel, J.: Path planning for autonomous vehicles in unknown semi-structured environments. The International Journal of Robotics Research 29(5), 485–501 (2010) https://doi.org/10.1177/0278364909359210
  5. [5]Rokonuzzaman, M., Mohajer, N., Nahavandi, S., Mohamed, S.: Review and performance evaluation of path tracking controllers of autonomous vehicles. IET Intelligent Transport Systems 15(5), 646–670 (2021) https://doi.org/10.1049/itr2.12051
  6. [6]Macenski, S., Moore, T., Lu, D.V., Merzlyakov, A., Ferguson, M.: From the desks of ROS maintainers: A survey of modern & capable mobile robotics algorithms in the Robot Operating System 2. Robotics and Autonomous Systems 168, 104493 (2023) https://doi.org/10.1016/j.robot.2023.104493
  7. [7]Patnaik, A., Patel, M., Mohta, V., Shah, H., Agrawal, S., Rathore, A., Malik, R., Chakravarty, D., Bhattacharya, R.: Design and implementation of path trackers for Ackermann drive based vehicles. arXiv preprint arXiv:2012.02978 (2020) https://doi.org/10.48550/arXiv.2012.02978
  8. [8]Dominguez, S., Ali, A., Garcia, G., Martinet, P.: Comparison of lateral controllers for autonomous vehicle: Experimental results. In: 2016 IEEE 19th International Conference on Intelligent Transportation Systems (ITSC), pp. 1418–1423 (2016). https://doi.org/10.1109/ITSC.2016.7795743
  9. [9]Kong, X., Fisher, C., Evans, B.: A critical evaluation of pure pursuit, MPC and MPCC: Balancing simplicity, performance and constraints. MATEC Web of Conferences 406, 04013 (2024) https://doi.org/10.1051/matecconf/202440604013
  10. [10]Borse, S., Viehmann, T., Ferrein, A., Lakemeyer, G.: A ROS 2-based navigation and simulation stack for the Robotino. In: RoboCup 2024: Robot World Cup XXVII. Lecture Notes in Computer Science, vol. 15570, pp. 19–31. Springer, Cham (2025). https://doi.org/10.1007/978-3-031-85859-8_2
  11. [11]Filotheou, A., Tsardoulias, E.G., Dimitriou, A.G., Symeonidis, A.L., Petrou, L.: Quantitative and qualitative evaluation of ROS-enabled local and global planners in 2D static environments. Journal of Intelligent & Robotic Systems 98(3), 567–601 (2020) https://doi.org/10.1007/s10846-019-01086-y
  12. [12]Caleffi, F., Rodrigues, L.d.S., Stamborosi, J.d.S., Pereira, B.M.: Small-scale self-driving cars: A systematic literature review. Journal of Traffic and Transportation Engineering (English Edition) 11(2), 271–292 (2024) https://doi.org/10.1016/j.jtte.2023.09.005
  13. [13]Kadian, A., Truong, J., Gokaslan, A., Clegg, A., Wijmans, E., Lee, S., Savva, M., Chernova, S., Batra, D.: Sim2Real predictivity: Does evaluation in simulation predict real-world performance? IEEE Robotics and Automation Letters 5(4), 6670–6677 (2020) https://doi.org/10.1109/LRA.2020.3013848
  14. [14]De La Trinidad-Rendon, J.S., Reyes-Avendaño, J.A., Gonzalez-Hernandez, H.G.: A comparative study of scaled autonomous vehicle platforms for research and education. In: 2025 IEEE Mexican Humanitarian Technology Conference (MHTC), pp. 123–129 (2025). https://doi.org/10.1109/MHTC65808.2025.11086476
  15. [15]Elbouhy, S.M., Adamanov, A., Braun, P.M., Rose, H.W.: Comparative analysis of local trajectory planning algorithms in ROS2. In: 2025 IEEE International Conference on Simulation, Modeling, and Programming for Autonomous Robots (SIMPAR), pp. 1–6 (2025). https://doi.org/10.1109/SIMPAR62925.2025.10979015
  16. [16]Sant’Anna, T.B., Argolo, M.B., Lima, R.T.: Comparative analysis in real environment of trajectory controllers on ROS2. In: 2023 Latin American Robotics Symposium (LARS), 2023 Brazilian Symposium on Robotics (SBR), and 2023 Workshop on Robotics in Education (WRE), pp. 308–312 (2023). https://doi.org/10.1109/LARS/SBR/WRE59448.2023.10332973
  17. [17]García Daza, J., Izquierdo, R., Martínez, L.M., Benderius, O., Fernández Llorca, D.: Sim-to-real transfer and reality gap modeling in model predictive control for autonomous driving. Applied Intelligence 53(10), 12719–12735 (2023) https://doi.org/10.1007/s10489-022-04148-1
  18. [18]Urrea, C., Valencia-Aragon, K.: Theoretical analysis and systematic comparison of local navigation control strategies in semi-structured environments: A systems approach. Systems 14(3), 228 (2026) https://doi.org/10.3390/systems14030228
  19. [19]NVIDIA: Jetson TX2 Module. https://developer.nvidia.com/embedded/jetson-tx2. Accessed 12 November 2026 (2017)
  20. [20]NaturalPoint: OptiTrack Motion Capture Systems. https://optitrack.com. Accessed 12 November 2026 (2026)
  21. [21]Hess, W., Kohler, D., Rapp, H., Andor, D.: Real-time loop closure in 2D LIDAR SLAM. In: 2016 IEEE International Conference on Robotics and Automation (ICRA), pp. 1271–1278 (2016). https://doi.org/10.1109/ICRA.2016.7487258
  22. [22]Koenig, N., Howard, A.: Design and use paradigms for Gazebo, an open-source multi-robot simulator. In: Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), vol. 3, pp. 2149–2154 (2004). https://doi.org/10.1109/IROS.2004.1389727
  23. [23]Konolige, K.: A gradient method for realtime robot control. In: Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), vol. 1, pp. 639–646 (2000). https://doi.org/10.1109/IROS.2000.894676
  24. [24]Coulter, R.C.: Implementation of the pure pursuit path tracking algorithm. Technical Report CMU-RI-TR-92-01, Carnegie Mellon University, Pittsburgh, PA (January 1992)
  25. [25]Macenski, S., Singh, S., Martín, F., Ginés, J.: Regulated pure pursuit for robot path tracking. Autonomous Robots 47(6), 685–694 (2023) https://doi.org/10.1007/s10514-023-10097-6
  26. [26]Thrun, S., Montemerlo, M., Dahlkamp, H., Stavens, D., Aron, A., Diebel, J., Fong, P., Gale, J., Hennaply, M., Hoffmann, G., Lau, K., Oakley, C., Palatucci, M., Pratt, V., Stang, P., Strohband, S., Dupont, C., Jendrossek, L.-E., Koelen, C., Markey, C., Rummel, C., van Niekerk, J., Jensen, E., Alessandrini, P., Bradski, G., Davies, B., Ettinger, S., Kaehler, A., Nefian, A., Mahoney, P.: Stanley: The robot that won the DARPA Grand Challenge. Journal of Field Robotics 23(9), 661–692 (2006) https://doi.org/10.1002/rob.20147
  27. [27]Hoffmann, G.M., Tomlin, C.J., Montermello, M., Thrun, S.: Autonomous automobile trajectory tracking for off-road driving: Controller design, experimental validation and racing. In: Proceedings of the 2007 American Control Conference, pp. 2296–2301 (2007). https://doi.org/10.1109/ACC.2007.4282788
  28. [28]Wit, J.S.: Vector pursuit path tracking for autonomous ground vehicles. PhD thesis, University of Florida (2000)
  29. [29]Efron, B., Tibshirani, R.J.: An Introduction to the Bootstrap. Chapman & Hall, New York (1993). https://doi.org/10.1007/978-1-4899-4541-9
  30. [30]Spearman, C.: The proof and measurement of association between two things. The American Journal of Psychology 15(1), 72–101 (1904) https://doi.org/10.2307/1412159
  31. [31]Hammami, H., Abban, M., Aga, A.M., Mohamed, L., Alsaad, S., Abdulaziz, N.: SUSHI: A vision system for reactive, uninformed ASV navigation via multi-field path planning and visual exploration. Journal of Intelligent & Robotic Systems 112(2), 38 (2026) https://doi.org/10.1007/s10846-026-02379-9

Paper details

vlnc:W_kzep9k7g
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents