No version for distro humble showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro jazzy showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro kilted showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro lyrical showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro rolling showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro galactic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro iron showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro melodic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file

No version for distro noetic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

wayp_plan_tools repository

wayp_plan_tools

ROS Distro
github

Repository Summary

Description
Checkout URI https://github.com/jkk-research/wayp_plan_tools.git
VCS Type git
VCS Version ros2
Last Updated 2026-11-16
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
wayp_plan_tools 0.0.0

README

wayp_plan_tools ROS 2 package

Waypoint and planner tools for ROS 2 with minimal dependencies. Static Badge

Tutorial (simulation + controllers): jkk-research.github.io/latest/workshops/control_sim

Planner / control nodes:

  • single_goal_pursuit: Pure pursuit (for vehicles / robots), a simple cross-track error method
  • multiple_goal_pursuit: Multiple goal pursuit for vehicles / robots an implementation of our paper
  • stanley_control: Stanley controller, a heading error + cross-track error method
  • follow_the_carrot: Follow-the-carrot, the simplest controller

Waypoint nodes:

  • waypoint_saver: saves the waypoints to a csv
  • waypoint_loader: loads the waypoints from a csv to a ROS 2 topic
  • waypoint_to_target: translates the global waypoint array to local target waypoint(s), thus it makes possible to use the controller nodes in a standalone way

Build

It is assumed that the workspace is ~/ros2_ws/.

Terminal 1 🔴 clone

cd ~/ros2_ws/src

git clone https://github.com/jkk-research/wayp_plan_tools

Terminal 1 🔴 build

cd ~/ros2_ws

colcon build --packages-select wayp_plan_tools --symlink-install

Terminal 2 🔵 run

source ~/ros2_ws/install/setup.bash

ros2 launch wayp_plan_tools waypoint_saver.launch.py

Control nodes

In this project the single_goal_pursuit, the multiple_goal_pursuit, stanley_control and the follow_the_carrot controllers are implemented. A high level overview about the algorithms is visible on the following figure:

single_goal_pursuit node

The “classic” pure pursuit implementation

multiple_goal_pursuit node

Multiple goal pursuit for vehicles / robots, an implementation of our paper

It extends pure pursuit from one goal point to several. The node reads the goal points from waypoint_topic (PoseArray in the vehicle frame, base_link = center of the rear axle). For each goal point $i$ it computes the pure pursuit steering angle $\delta_i = \arctan\frac{2 L \sin\alpha_i}{l_{d,i}}$. Here $L$ is the wheelbase, $\alpha_i$ is the angle of the goal point and $l_{d,i}$ is its distance. The steering command is the average of these angles, $\delta = \frac{1}{n}\sum_{i=1}^{n}\delta_i$. Several goal points at different distances smooth the steering: the near points correct the lateral error and the far points anticipate the curves. With one goal point the node is the same as single_goal_pursuit. The speed comes from pursuitspeedtarget. The output is published on cmd_vel (linear.x = speed, angular.z = steering angle [rad]).

stanley_control node

Stanley lateral controller, implemented according to the original paper: S. Thrun et al., Stanley: The Robot that Won the DARPA Grand Challenge, Journal of Field Robotics 23(9), 2006, Section 9.2 (pdf).

The steering law (Eq. 7 in the paper):

\[\delta(t) = \psi(t) + \arctan\frac{k\,x(t)}{u(t)}\]
  • $\psi(t)$: heading error, the orientation of the nearest path segment relative to the vehicle’s orientation
  • $x(t)$: cross-track error, the lateral distance of the center of the front axle from the nearest point of the path (signed, positive if the path is on the left)
  • $u(t)$: vehicle speed
  • $k$: gain, for small errors $x(t) \approx x(0)\,e^{-kt}$ (Eq. 9), so $k$ sets the convergence rate

With zero cross-track error the front wheels are steered parallel to the path; with a large error the $\arctan$ term turns the wheels toward the path (at most $\pm 90°$).

ros2 launch wayp_plan_tools stanley_control.launch.py

follow_the_carrot node

Follow-the-carrot, the simplest controller

waypoint_to_target node

Reads the waypoint array and speeds, from that it creates single or multiple goal points.

It also provides a /metrics_wayp array topic with the following elements:

Array element Meaning Const
[0] current lateral distance to the waypoint (signed, cross-track error) CUR_LAT_DIST_SIGNED
[1] current lateral distance to the waypoint (absolute value) CUR_LAT_DIST_ABS
[2] average lateral distance over time AVG_LAT_DISTANCE
[3] maximum lateral distance over time MAX_LAT_DISTANCE
[4] current waypoint ID CUR_WAYPOINT_ID
[5] target waypoint ID TRG_WAYPOINT_ID
[6] target waypoint longitudinal distance (similar to lookahed distance, but at a waypoint) TRG_WAY_LON_DIST
[7] actual lookahead distance ACT_LOOK_DIST
[8] heading difference between the closest waypoint and the vehicle [rad] (despite its name, not a distance) CUR_CROSS_TRACK

File truncated at 100 lines see the full file