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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange

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

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description 🏎️ Formula Student FEUP Autonomous Systems Department Repository
Checkout URI https://github.com/fs-feup/autonomous-systems.git
VCS Type git
VCS Version main
Last Updated 2025-06-19
Dev Status UNKNOWN
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Planning Node

Additional Links

No additional links.

Maintainers

  • André

Authors

No additional authors.

Planning Module

Package Information

Description

The planning module is the third main module in the autonomous system. It comes after the Localization and Mapping processing and precedes the Control module. It is responsible for processing the cones information(position and color) and to calculate the best path for the car to follow considering the received track. It then sends the desired path to the control in the form of a ordered position sequence.

Folder Structure

  • adapter_planning: Adapters to change ros2 interfaces according to simulator or environment
  • config: Configuration structures for the planning module
  • utils: Utility functions for the planning module, including spline fitting
  • planning: Main classes and functions for the planning module

Launch Configurations

  • eufs.launch.py: Launches the planning node with the necessary parameters for the EUFS simulator.
  • vehicle.launch.py: Launches the planning node with the necessary parameters for the 01 vehicle.
  • pacsim.launch.py: Launches the planning node with the necessary parameters for the PacSim simulator.

Important Dependencies

  • CGAL: Computational Geometry Algorithms Library. Used for Delaunay Triangulations.
  • GSL: GNU Scientific Library. Used for splines.

How to Run

Install Dependencies

You will need CGAL library for the Delaunay Triangulations. GSL library for the splines.

  ./dependencies_install.sh

Compiling

	colcon build --packages-up-to planning

Testing

colcon test --packages-select planning # use event-handler=console_direct+ for imediate output

To check test results:

colcon test-result --all --verbose

Running

Choose one of the launch files available at the “launch” directory. Each file’s name indicates the context in which it should be used. If the name of the file is run the following command (replace with the actual name of the launch file):

  source ./install/setup.bash # If in a new terminal
	ros2 run planning <file_name>

At each launch file, you can find the arguments which will be passed to the planning node. Those arguments control whether the node publishes visualization messages (which can be used to foxglove), where the node gets its input from, and parameters intrinsic to the algorithms (which were tuned to some extent). At the declaration of each launch argument, you will find the description of the argument and the value which will be used if you launch the node with that launch file. If you want to change the value which will be used, edit the launch file and compile the package again.

Design

The architecture of the module may be described according to the following diagrams.

Class Diagram

This diagram will focus on the main classes and instances inside the planning module, mentioning only the core units and most important functions.

  • ROS Node: Serves as the fundamental structure and operational backbone of the system.

  • Planning: It is the main orchestrator behind all the processes. It is responsible for the communication with other nodes. It contains an Adapter instance to manage information from the car/simulator and the main intervenients in the pipeline, as the LocalPathPlanner, responsible for the path calculation, the ConeColoring, responsible for attributing a color to unlabeled cones, the PathSmoothing, responsible for smoothing the point array to be published and the Track, which assembles the cones information after coloring and averages them using splines.

  • LocalPathPlanner: This component is responsible for calculation the desired path. It takes the information from the track and using that it creates a sequence of points within the track boundaries for the control module to use as a reference later on.

  • Track: This component assembles the information received by the track map, splitting and organizing the different cones in side and colors. It can also deals with any outliers by averaging out all cones using splines, and thus transforming the outliers into the main distribution sequence.

  • ConeColoring: This component responsible for attributing a color to unlabeled ones. It starts from a certain pair, and searches for the next cone for each using a cost function, achieving a fully colored track map in the end.

  • PathSmoothing: This component is responsible for fitting a spline through all the calculated points, smoothing the path the vehicle will follow and augmenting the number of references if necessary.

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged planning at Robotics Stack Exchange