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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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
CONTRIBUTING
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.
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