Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |
Launch files
Messages
Services
Plugins
Recent questions tagged nav2_simple_navigator at Robotics Stack Exchange
Package Summary
| Version | 0.1.7 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-planning/navigation2.git |
| VCS Type | git |
| VCS Version | crystal-devel |
| Last Updated | 2019-03-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Michael Jeronimo
Authors
Simple Navigator
The Simple Navigator module implements a nav2_tasks::NavigateToPose task server. As such, its responsibility is to navigate the robot to the specified pose.
Overview
The Simple Navigator implements NavigateToPose using two sub-tasks, ComputePathToPose and FollowPath, which are, in turn, task servers that implement the nav2_tasks::ComputePathToPose and nav2_tasks::FollowPath interfaces. It is conceptually similar to the MoveBase in the ROS 1 Navigation stack in that it coordinates the global planner (ComputePathToPose) and the local planner (FollowPath).
The Simple Navigator sits in the task hierarchy, as follows:
The Simple Navigator module is meant to show how one can utilize (sub-)task clients in a direct way to implement a task. The BtNavigator module, an alternative implementation of NavigateToPose, is a drop-in replacement for the Simple Navigator and uses behavior trees to implement more complex behavior, including recovery.
Implementation
In its execute method, which directs the task server to begin its operation, the Simple Navigator invokes ComputePathToPose and FollowPath in sequence, managing the task clients for each directly.
Package Dependencies
| Deps | Name |
|---|---|
| nav2_common | |
| rclcpp | |
| nav2_tasks | |
| nav2_msgs | |
| ament_cmake | |
| ament_lint_common | |
| ament_lint_auto | |
| ament_cmake_gtest | |
| ament_cmake_pytest | |
| launch | |
| launch_testing |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| navigation2 |