  * [ base_local_planner ](/base_local_planner?distro=melodic)
  * [ catkin ](/catkin?distro=melodic)
  * [ cmake_modules ](/cmake_modules?distro=melodic)
  * [ costmap_2d ](/costmap_2d?distro=melodic)
  * [ costmap_converter ](/costmap_converter?distro=melodic)
  * [ dynamic_reconfigure ](/dynamic_reconfigure?distro=melodic)
  * [ geometry_msgs ](/geometry_msgs?distro=melodic)
  * [ interactive_markers ](/interactive_markers?distro=melodic)
  * [ libg2o ](/libg2o?distro=melodic)
  * [ mbf_costmap_core ](/mbf_costmap_core?distro=melodic)
  * [ mbf_msgs ](/mbf_msgs?distro=melodic)
  * [ message_generation ](/message_generation?distro=melodic)
  * [ message_runtime ](/message_runtime?distro=melodic)
  * [ nav_core ](/nav_core?distro=melodic)
  * [ nav_msgs ](/nav_msgs?distro=melodic)
  * [ pluginlib ](/pluginlib?distro=melodic)
  * [ roscpp ](/roscpp?distro=melodic)
  * [ std_msgs ](/std_msgs?distro=melodic)
  * [ tf2 ](/tf2?distro=melodic)
  * [ tf2_eigen ](/tf2_eigen?distro=melodic)
  * [ tf2_geometry_msgs ](/tf2_geometry_msgs?distro=melodic)
  * [ tf2_ros ](/tf2_ros?distro=melodic)
  * [ visualization_msgs ](/visualization_msgs?distro=melodic)


Drive on heading behavior with configurable distance to drive

[ Assisted Teleop ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behaviors/plugins)


* Provide custom obstacles as point-, line- or polygon-shaped ones (additionally to or instead of the costmap obstacles).


* Optimization weight for satisfying the maximum allowed angular velocity


Steve Macenski


` ~<name>/yaw_goal_tolerance ` ( ` double ` , default: 0.2)


A predictive MPC controller with modular & custom cost functions that can
accomplish many tasks.


  * Build history (last 4 of 7 builds):
  * [ #13  06-Jan-2024 12:01  3 / 3  ](https://build.ros.org//job/Ndev__teb_local_planner__ubuntu_focal_amd64/13/)
  * [ #11  21-Jun-2023 08:49  3 / 3  ](https://build.ros.org//job/Ndev__teb_local_planner__ubuntu_focal_amd64/11/)
  * [ #10  21-Feb-2023 03:49  3 / 3  ](https://build.ros.org//job/Ndev__teb_local_planner__ubuntu_focal_amd64/10/)
  * [ #9  05-Oct-2022 23:49  3 / 3  ](https://build.ros.org//job/Ndev__teb_local_planner__ubuntu_focal_amd64/9/)


####  Parallel Planning in distinctive Topologies


      * [ Sensor Introduction ](../../setup_guides/sensors/setup_sensors.html#sensor-introduction)
        * [ Common Sensor Messages ](../../setup_guides/sensors/setup_sensors.html#common-sensor-messages)
      * [ Simulating Sensors using Gazebo ](../../setup_guides/sensors/setup_sensors.html#simulating-sensors-using-gazebo)
        * [ Adding Gazebo Plugins to a URDF ](../../setup_guides/sensors/setup_sensors.html#adding-gazebo-plugins-to-a-urdf)
        * [ Launch and Build Files ](../../setup_guides/sensors/setup_sensors.html#launch-and-build-files)
        * [ Build, Run and Verification ](../../setup_guides/sensors/setup_sensors.html#build-run-and-verification)
      * [ Mapping and Localization ](../../setup_guides/sensors/setup_sensors.html#mapping-and-localization)
      * [ Costmap 2D ](../../setup_guides/sensors/setup_sensors.html#costmap-2d)
        * [ Configuring nav2_costmap_2d ](../../setup_guides/sensors/setup_sensors.html#configuring-nav2-costmap-2d)
        * [ Build, Run and Verification ](../../setup_guides/sensors/setup_sensors.html#id2)
      * [ Conclusion ](../../setup_guides/sensors/setup_sensors.html#conclusion)
    * [ Setting Up the Robot’s Footprint ](../../setup_guides/footprint/setup_footprint.html)
      * [ Footprint Introduction ](../../setup_guides/footprint/setup_footprint.html#footprint-introduction)
      * [ Configuring the Robot’s Footprint ](../../setup_guides/footprint/setup_footprint.html#configuring-the-robot-s-footprint)
      * [ Build, Run and Verification ](../../setup_guides/footprint/setup_footprint.html#build-run-and-verification)
      * [ Visualizing Footprint in RViz ](../../setup_guides/footprint/setup_footprint.html#visualizing-footprint-in-rviz)
      * [ Conclusion ](../../setup_guides/footprint/setup_footprint.html#conclusion)
    * [ Setting Up Navigation Plugins ](../../setup_guides/algorithm/select_algorithm.html)
      * [ Planner and Controller Servers ](../../setup_guides/algorithm/select_algorithm.html#planner-and-controller-servers)
      * [ Selecting the Algorithm Plugins ](../../setup_guides/algorithm/select_algorithm.html#selecting-the-algorithm-plugins)
        * [ Planner Server ](../../setup_guides/algorithm/select_algorithm.html#planner-server)
        * [ Controller Server ](../../setup_guides/algorithm/select_algorithm.html#controller-server)
      * [ Conclusion ](../../setup_guides/algorithm/select_algorithm.html#conclusion)
  * [ Robots Using ](../../about/robots.html)
  * [ General Tutorials ](../../tutorials/index.html)
    * [ Navigating with a Physical Turtlebot 3 ](../../tutorials/docs/navigation2_on_real_turtlebot3.html)
      * [ Overview ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#overview)
      * [ Requirements ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#tutorial-steps)
        * [ 0- Setup Your Enviroment Variables ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#setup-your-enviroment-variables)
        * [ 1- Launch Turtlebot 3 ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#launch-turtlebot-3)
        * [ 2- Launch Nav2 ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#launch-nav2)
        * [ 3- Launch RVIZ ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#launch-rviz)
        * [ 4- Initialize the Location of Turtlebot 3 ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#initialize-the-location-of-turtlebot-3)
        * [ 5- Send a Goal Pose ](../../tutorials/docs/navigation2_on_real_turtlebot3.html#send-a-goal-pose)
    * [ (SLAM) Navigating While Mapping ](../../tutorials/docs/navigation2_with_slam.html)
      * [ Overview ](../../tutorials/docs/navigation2_with_slam.html#overview)
      * [ Requirements ](../../tutorials/docs/navigation2_with_slam.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/navigation2_with_slam.html#tutorial-steps)
        * [ 0- Launch Robot Interfaces ](../../tutorials/docs/navigation2_with_slam.html#launch-robot-interfaces)


* Number of actual solver iterations called in each _outerloop_ iteration. See param ` no_outer_iterations ` .


Carl Delsey


Whether to use A*. If false, uses Dijkstra’s expansion.


Back up behavior of configurable distance to back out of a situation where the
robot is stuck

[ Wait ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behaviors/plugins)


Checks if battery percentage is below a specified value.

[ Is Path Valid Condition
](https://github.com/navigation2/blob/replanning/nav2_behavior_tree/plugins/condition/is_path_valid_condition.cpp)


        * [ 1- Setup Rviz clicked point ](../../tutorials/docs/navigation2_dynamic_point_following.html#setup-rviz-clicked-point)
        * [ 2- Run Dynamic Object Following in Nav2 Simulation ](../../tutorials/docs/navigation2_dynamic_point_following.html#run-dynamic-object-following-in-nav2-simulation)
    * [ Navigating with Keepout Zones ](../../tutorials/docs/navigation2_with_keepout_filter.html)
      * [ Overview ](../../tutorials/docs/navigation2_with_keepout_filter.html#overview)
      * [ Requirements ](../../tutorials/docs/navigation2_with_keepout_filter.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/navigation2_with_keepout_filter.html#tutorial-steps)
        * [ 1\. Prepare filter mask ](../../tutorials/docs/navigation2_with_keepout_filter.html#prepare-filter-mask)
        * [ 2\. Configure Costmap Filter Info Publisher Server ](../../tutorials/docs/navigation2_with_keepout_filter.html#configure-costmap-filter-info-publisher-server)
        * [ 3\. Enable Keepout Filter ](../../tutorials/docs/navigation2_with_keepout_filter.html#enable-keepout-filter)
        * [ 4\. Run Nav2 stack ](../../tutorials/docs/navigation2_with_keepout_filter.html#run-nav2-stack)
    * [ Navigating with Speed Limits ](../../tutorials/docs/navigation2_with_speed_filter.html)
      * [ Overview ](../../tutorials/docs/navigation2_with_speed_filter.html#overview)
      * [ Requirements ](../../tutorials/docs/navigation2_with_speed_filter.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/navigation2_with_speed_filter.html#tutorial-steps)
        * [ 1\. Prepare filter mask ](../../tutorials/docs/navigation2_with_speed_filter.html#prepare-filter-mask)
        * [ 2\. Configure Costmap Filter Info Publisher Server ](../../tutorials/docs/navigation2_with_speed_filter.html#configure-costmap-filter-info-publisher-server)
        * [ 3\. Enable Speed Filter ](../../tutorials/docs/navigation2_with_speed_filter.html#enable-speed-filter)
        * [ 4\. Run Nav2 stack ](../../tutorials/docs/navigation2_with_speed_filter.html#run-nav2-stack)
    * [ Using Rotation Shim Controller ](../../tutorials/docs/using_shim_controller.html)
      * [ Overview ](../../tutorials/docs/using_shim_controller.html#overview)
      * [ What is the Rotation Shim Controller? ](../../tutorials/docs/using_shim_controller.html#what-is-the-rotation-shim-controller)
      * [ Configuring Rotation Shim Controller ](../../tutorials/docs/using_shim_controller.html#configuring-rotation-shim-controller)
      * [ Configuring Primary Controller ](../../tutorials/docs/using_shim_controller.html#configuring-primary-controller)
      * [ Demo Execution ](../../tutorials/docs/using_shim_controller.html#demo-execution)
    * [ Adding a Smoother to a BT ](../../tutorials/docs/adding_smoother.html)
      * [ Overview ](../../tutorials/docs/adding_smoother.html#overview)
      * [ Requirements ](../../tutorials/docs/adding_smoother.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/adding_smoother.html#tutorial-steps)
        * [ 0- Familiarization with the Smoother BT Node ](../../tutorials/docs/adding_smoother.html#familiarization-with-the-smoother-bt-node)
        * [ 1- Specifying a Smoother Plugin ](../../tutorials/docs/adding_smoother.html#specifying-a-smoother-plugin)
        * [ 2- Modifying your BT XML ](../../tutorials/docs/adding_smoother.html#modifying-your-bt-xml)
    * [ Using Collision Monitor ](../../tutorials/docs/using_collision_monitor.html)
      * [ Overview ](../../tutorials/docs/using_collision_monitor.html#overview)
      * [ Requirements ](../../tutorials/docs/using_collision_monitor.html#requirements)
      * [ Configuring Collision Monitor ](../../tutorials/docs/using_collision_monitor.html#configuring-collision-monitor)
      * [ Configuring Collision Monitor with VelocityPolygon ](../../tutorials/docs/using_collision_monitor.html#configuring-collision-monitor-with-velocitypolygon)
      * [ Preparing Nav2 stack ](../../tutorials/docs/using_collision_monitor.html#preparing-nav2-stack)
      * [ Demo Execution ](../../tutorials/docs/using_collision_monitor.html#demo-execution)
    * [ Adding a New Nav2 Task Server ](../../tutorials/docs/adding_a_nav2_task_server.html)
      * [ Lifecycle Nodes ](../../tutorials/docs/adding_a_nav2_task_server.html#lifecycle-nodes)


A path smoother using a constraints problem solver to optimize various
criteria such as smoothness or distance from obstacles, maintaining minimum
turning radius

[ Savitzky-Golay Smoother ](https://github.com/ros-
planning/navigation2/tree/main/nav2_smoother)


Calls Nav2 smoother server

[ Follow Path Action ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/follow_path_action.cpp)


following pre-planned routes through approved corridors in
industrial settings where safety is paramount. Thus, it is
an important type of behavior to support in a complete
navigation framework.
These controllers do attempt to prevent collisions utilizing the cost map information given. However, rather than
adaptively avoiding collisions, these controllers will simply
stop without going around an obstacle in its way. They will
wait for a new global route to be selected or the obstacle
moves from its path. Due to their simplicity in evaluating
geometric, kinematic, and/or control-law derived functions,
these controllers can run well in-excess of 1 kHz.
Regulated Pure Pursuit is a variation on the traditional
Pure Pursuit algorithm. Pure Pursuit finds a point on the
reference path a fixed-distance away from the robot to track,
known as the lookahead point [26]. This fixed-distance from
the robot can be interpreted as the chord of a circle with
points on it (x, y)vehicle and (x, y)lookahead belonging to
the positions of interest. When the path is represented in
the vehicle coordinate frame, the curvature of the route,
κ, to follow the lookahead point can be represented as
κ =
2y
L2 , where y is the lateral coordinate of the lookahead
point and L is the distance away from the robot. With an
arbitrary choice of translational velocity vt, we can compute
an angular velocity, va, required to drive the robot towards
the lookahead point via va = vtκ. This process is conducted
iteratively resulting in the robot tracking a given reference
path.
Adaptive Pure Pursuit builds on this by dynamically
adjusting the lookahead distance based on the robot’s current
velocity, typically in the form L = vtlt, where lt is the
lookahead time gain [27]. This process has been shown
to improve tracking stability of reference paths and reduce
tracking errors in high curvature turns.
The Regulated Pure Pursuit controller builds on these
foundations and expands the behavior one step further with
heuristic penalty functions on the desired translational velocity vt to regulate the speed of the robot in confined or
precarious situations [28]. Rather than naively assuming a
fixed speed, which can be dangerous in practical applications,


  * [ base_local_planner ](/base_local_planner?distro=lunar)
  * [ catkin ](/catkin?distro=lunar)
  * [ cmake_modules ](/cmake_modules?distro=lunar)
  * [ costmap_2d ](/costmap_2d?distro=lunar)
  * [ costmap_converter ](/costmap_converter?distro=lunar)
  * [ dynamic_reconfigure ](/dynamic_reconfigure?distro=lunar)
  * [ geometry_msgs ](/geometry_msgs?distro=lunar)
  * [ interactive_markers ](/interactive_markers?distro=lunar)
  * [ libg2o ](/libg2o?distro=lunar)
  * [ message_generation ](/message_generation?distro=lunar)
  * [ message_runtime ](/message_runtime?distro=lunar)
  * [ nav_core ](/nav_core?distro=lunar)
  * [ nav_msgs ](/nav_msgs?distro=lunar)
  * [ pluginlib ](/pluginlib?distro=lunar)
  * [ roscpp ](/roscpp?distro=lunar)
  * [ std_msgs ](/std_msgs?distro=lunar)
  * [ tf ](/tf?distro=lunar)
  * [ tf_conversions ](/tf_conversions?distro=lunar)
  * [ visualization_msgs ](/visualization_msgs?distro=lunar)


Continuous Integration


Differential, Omnidirectional

##  Smoothers  ¶


Description

---|---|---

[ WaitAtWaypoint ](https://github.com/ros-
planning/navigation2/tree/main/nav2_waypoint_follower/plugins/wait_at_waypoint.cpp)


* Maximum angular velocity of the robot in radians/sec


Eitan Marder-Eppstein


Cancels spin behavior action

[ Cancel Wait Action ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/wait_cancel_node.cpp)


Steve Macenski


  * **[ Code API ](http://docs.ros.org/en/noetic/api/teb_local_planner/html) **
  * **[ Msg API ](http://docs.ros.org/en/noetic/api/teb_local_planner/html/index-msg.html) **
  * [ Tutorials ](/teb_local_planner/Tutorials)
  * [ FAQ ](http://answers.ros.org/questions/scope:all/sort:activity-desc/tags:teb_local_planner/page:1/)
  * [ Changelog ](http://docs.ros.org/en/noetic/changelogs/teb_local_planner/changelog.html)
  * [ Change List ](/teb_local_planner/ChangeList)
  * [ Reviews ](/teb_local_planner/Reviews)


` ~<name>/max_vel_x_backwards ` ( ` double ` , default: 0.2)


fuse 20 542.46 2.81 0.52 5.19 ± 1.37
Fig. 16. Three state estimates of the same circuitous path. Black path:
amcl-generated ground truth path; dotted red path: estimate of the path
fusing only wheel encoder and IMU data for r l; dashed blue path: estimate
of the path using the same data, but fused via the fuse package.
rate and provides corrections to odometric drift. A localization system attempts to match its sensor data to a known
model of the environment or build the model simultaneously,
e.g., Simultaneous Localization and Mapping (SLAM). Commonly, localization is preformed using 2D laser scanners, 3D
lidars, or cameras - though techniques exist using more exotic
and/or mixtures of sensors. Localization’s output is a pose
and confidence relative to a world model. This pose solves
the REP 105 portion of the tf transformation tree from map
to odom.
In ROS 2, the standard localization and SLAM implementations continue to be 2D laser scanner techniques due
to their robustness in dynamic and changing environments
over long durations. While strides have been made in visual
techniques, the field is still rapidly evolving and even relatively mature methods like ORB-SLAM3 are insufficiently
robust for large classes of practical robotics tasks [51]. They
are generally sufficient for a number of small-scale or shortduration applications, but official ROS 2 support requires
further substantive improvements.
A. Localization
AMCL One popular approach for solving the localization
problem is through the use of particle filters [52], which
enable robust state estimation in dynamic environments and
in the presence of noisy sensor data. Particle filters represent non-Gaussian statistical distributions using a discrete
set of hypotheses (particles). In the case of mobile robot
localization, the distribution represents the probable pose of
the robot.
If an initial pose is not set, a particle filter may initialize
the particle cloud by uniformly distributing it throughout the
space. Otherwise, the particles are distributed around the
provided start pose of the robot. At each update step, the
particles are projected using a kinematic model of the robot
with noise perturbations. The particles are then weighted
based on the likelihood of their sensor observations at that
pose. The filter may then resample the particles, that is,
generate a new particle distribution by selecting particles
from the existing distribution.
The amcl (Adaptive Monte Carlo Localization) package
contains a pure and fully-parameterized implementation of


      * [ Subtrees Obtain Shared Resources ](../migration/Iron.html#subtrees-obtain-shared-resources)
      * [ Collision Monitor: added watchdog mechanism based on ` source_timeout  ` parameter with default blocking behavior ](../migration/Iron.html#collision-monitor-added-watchdog-mechanism-based-on-source-timeout-parameter-with-default-blocking-behavior)
      * [ BtActionServer: use native library haltTree() ](../migration/Iron.html#btactionserver-use-native-library-halttree)
      * [ Global Frame Removed from 2 BT Nodes ](../migration/Iron.html#global-frame-removed-from-2-bt-nodes)
      * [ Introduction of ` CostmapUpdate.msg  ` ](../migration/Iron.html#introduction-of-costmapupdate-msg)
      * [ Full Stack Uses Node Clocks ](../migration/Iron.html#full-stack-uses-node-clocks)
      * [ New Graceful Motion Controller ](../migration/Iron.html#new-graceful-motion-controller)
      * [ Plugin Libraries in BT Navigator Only Includes Custom Nodes ](../migration/Iron.html#plugin-libraries-in-bt-navigator-only-includes-custom-nodes)
      * [ New RViz Plugin for selecting Planners, Controllers, Goal Checkers, Progress Checkers and Smoothers ](../migration/Iron.html#new-rviz-plugin-for-selecting-planners-controllers-goal-checkers-progress-checkers-and-smoothers)
      * [ RPP new optional ` interpolate_curvature_after_goal  ` behavior and fix conflict between ` use_rotate_to_heading  ` and ` allow_reversing  ` ](../migration/Iron.html#rpp-new-optional-interpolate-curvature-after-goal-behavior-and-fix-conflict-between-use-rotate-to-heading-and-allow-reversing)
      * [ Cancel Checker Interface For GlobalPlanner ](../migration/Iron.html#cancel-checker-interface-for-globalplanner)
      * [ New BtActionServer/BtNavigator parameter ](../migration/Iron.html#new-btactionserver-btnavigator-parameter)
      * [ New collision monitor parameter ](../migration/Iron.html#new-collision-monitor-parameter)
      * [ New graceful cancellation API for Controllers ](../migration/Iron.html#new-graceful-cancellation-api-for-controllers)
      * [ Standardization of Plugin Naming with Double Colons (::) ](../migration/Iron.html#standardization-of-plugin-naming-with-double-colons)
      * [ Collision monitor: dynamic radius for circle type polygons ](../migration/Iron.html#collision-monitor-dynamic-radius-for-circle-type-polygons)
  * [ Simple Commander API ](../commander_api/index.html)
    * [ Overview ](../commander_api/index.html#overview)
    * [ Commander API ](../commander_api/index.html#id1)
    * [ Costmap API ](../commander_api/index.html#costmap-api)
    * [ Footprint Collision Checker API ](../commander_api/index.html#footprint-collision-checker-api)
    * [ Examples and Demos ](../commander_api/index.html#examples-and-demos)
  * [ Roadmaps ](../roadmap/roadmap.html)
    * [ Jazzy Roadmap ](../roadmap/roadmap.html#jazzy-roadmap)
    * [ Iron Roadmap ](../roadmap/roadmap.html#iron-roadmap)
    * [ Humble Roadmap ](../roadmap/roadmap.html#humble-roadmap)
  * [ About and Contact ](../about/index.html)
    * [ Related Projects ](../about/related_projects.html)
    * [ About ](../about/index.html#id1)
    * [ Contact ](../about/index.html#contact)


    * [ Constrained smoother ](../configuration/packages/configuring-constrained-smoother.html)
      * [ Smoother Server Parameters ](../configuration/packages/configuring-constrained-smoother.html#smoother-server-parameters)
      * [ Example ](../configuration/packages/configuring-constrained-smoother.html#example)
    * [ Velocity Smoother ](../configuration/packages/configuring-velocity-smoother.html)
      * [ Velocity Smoother Parameters ](../configuration/packages/configuring-velocity-smoother.html#velocity-smoother-parameters)
      * [ Example ](../configuration/packages/configuring-velocity-smoother.html#example)
    * [ Collision Monitor ](../configuration/packages/configuring-collision-monitor.html)
      * [ Provided Nodes ](../configuration/packages/configuring-collision-monitor.html#provided-nodes)
        * [ Collision Monitor Node ](../configuration/packages/collision_monitor/configuring-collision-monitor-node.html)
        * [ Collision Detector Node ](../configuration/packages/collision_monitor/configuring-collision-detector-node.html)
    * [ Waypoint Follower ](../configuration/packages/configuring-waypoint-follower.html)
      * [ Parameters ](../configuration/packages/configuring-waypoint-follower.html#parameters)
      * [ Provided Plugins ](../configuration/packages/configuring-waypoint-follower.html#provided-plugins)
        * [ WaitAtWaypoint ](../configuration/packages/nav2_waypoint_follower-plugins/wait_at_waypoint.html)
        * [ PhotoAtWaypoint ](../configuration/packages/nav2_waypoint_follower-plugins/photo_at_waypoint.html)
        * [ InputAtWaypoint ](../configuration/packages/nav2_waypoint_follower-plugins/input_at_waypoint.html)
      * [ Default Plugin ](../configuration/packages/configuring-waypoint-follower.html#default-plugin)
      * [ Example ](../configuration/packages/configuring-waypoint-follower.html#example)
  * [ Tuning Guide ](../tuning/index.html)
    * [ Inflation Potential Fields ](../tuning/index.html#inflation-potential-fields)
    * [ Robot Footprint vs Radius ](../tuning/index.html#robot-footprint-vs-radius)
    * [ Rotate in Place Behavior ](../tuning/index.html#rotate-in-place-behavior)
    * [ Planner Plugin Selection ](../tuning/index.html#planner-plugin-selection)
    * [ Controller Plugin Selection ](../tuning/index.html#controller-plugin-selection)
    * [ Caching Obstacle Heuristic in Smac Planners ](../tuning/index.html#caching-obstacle-heuristic-in-smac-planners)
    * [ Costmap2D Plugins ](../tuning/index.html#costmap2d-plugins)
    * [ Nav2 Launch Options ](../tuning/index.html#nav2-launch-options)
    * [ Other Pages We’d Love To Offer ](../tuning/index.html#other-pages-we-d-love-to-offer)
  * [ Nav2 Behavior Trees ](../behavior_trees/index.html)
    * [ Introduction To Nav2 Specific Nodes ](../behavior_trees/overview/nav2_specific_nodes.html)
      * [ Action Nodes ](../behavior_trees/overview/nav2_specific_nodes.html#action-nodes)
      * [ Condition Nodes ](../behavior_trees/overview/nav2_specific_nodes.html#condition-nodes)
      * [ Decorator Nodes ](../behavior_trees/overview/nav2_specific_nodes.html#decorator-nodes)
      * [ Control: PipelineSequence ](../behavior_trees/overview/nav2_specific_nodes.html#control-pipelinesequence)
      * [ Control: Recovery ](../behavior_trees/overview/nav2_specific_nodes.html#control-recovery)
      * [ Control: RoundRobin ](../behavior_trees/overview/nav2_specific_nodes.html#control-roundrobin)
    * [ Detailed Behavior Tree Walkthrough ](../behavior_trees/overview/detailed_behavior_tree_walkthrough.html)
      * [ Overview ](../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#overview)
      * [ Prerequisites ](../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#prerequisites)
      * [ Navigate To Pose With Replanning and Recovery ](../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#navigate-to-pose-with-replanning-and-recovery)


* Optimization weight for the inflation penalty (should be small).


* Optimization weight for enforcing a minimum turning radius (only for carlike robots).


* Maximum absolute translational velocity of the robot while driving backwards in meters/sec. See optimization parameter ` weight_kinematics_forward_drive `


Creator


Description

---|---|---

[ Rate Controller ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/decorator/rate_controller.cpp)


Alexey Merzlyakov


` ~<name>/enable_homotopy_class_planning ` ( ` bool ` , default: true)


        * [ CancelCoverage ](bt-plugins/actions/CancelCoverage.html)
        * [ RemovePassedGoals ](bt-plugins/actions/RemovePassedGoals.html)
        * [ CancelControl ](bt-plugins/actions/CancelControl.html)
        * [ CancelBackUp ](bt-plugins/actions/CancelBackUp.html)
        * [ CancelSpin ](bt-plugins/actions/CancelSpin.html)
        * [ CancelWait ](bt-plugins/actions/CancelWait.html)
        * [ CancelDriveOnHeading ](bt-plugins/actions/CancelDriveOnHeading.html)
        * [ CancelAssistedTeleop ](bt-plugins/actions/CancelAssistedTeleop.html)
        * [ SmoothPath ](bt-plugins/actions/Smooth.html)
      * [ Condition Plugins ](configuring-bt-xml.html#condition-plugins)
        * [ GoalReached ](bt-plugins/conditions/GoalReached.html)
        * [ TransformAvailable ](bt-plugins/conditions/TransformAvailable.html)
        * [ DistanceTraveled ](bt-plugins/conditions/DistanceTraveled.html)
        * [ GoalUpdated ](bt-plugins/conditions/GoalUpdated.html)
        * [ GloballyUpdatedGoal ](bt-plugins/conditions/GloballyUpdatedGoal.html)
        * [ InitialPoseReceived ](bt-plugins/conditions/InitialPoseReceived.html)
        * [ IsStuck ](bt-plugins/conditions/IsStuck.html)
        * [ TimeExpired ](bt-plugins/conditions/TimeExpired.html)
        * [ IsBatteryLow ](bt-plugins/conditions/IsBatteryLow.html)
        * [ IsPathValid ](bt-plugins/conditions/IsPathValid.html)
        * [ PathExpiringTimer ](bt-plugins/conditions/PathExpiringTimer.html)
        * [ AreErrorCodesPresent ](bt-plugins/conditions/AreErrorCodesPresent.html)
        * [ WouldAControllerRecoveryHelp ](bt-plugins/conditions/WouldAControllerRecoveryHelp.html)
        * [ WouldAPlannerRecoveryHelp ](bt-plugins/conditions/WouldAPlannerRecoveryHelp.html)
        * [ WouldASmootherRecoveryHelp ](bt-plugins/conditions/WouldASmootherRecoveryHelp.html)
        * [ IsBatteryCharging ](bt-plugins/conditions/IsBatteryCharging.html)
      * [ Control Plugins ](configuring-bt-xml.html#control-plugins)
        * [ PipelineSequence ](bt-plugins/controls/PipelineSequence.html)
        * [ RoundRobin ](bt-plugins/controls/RoundRobin.html)
        * [ RecoveryNode ](bt-plugins/controls/RecoveryNode.html)
      * [ Decorator Plugins ](configuring-bt-xml.html#decorator-plugins)
        * [ RateController ](bt-plugins/decorators/RateController.html)
        * [ DistanceController ](bt-plugins/decorators/DistanceController.html)
        * [ SpeedController ](bt-plugins/decorators/SpeedController.html)
        * [ GoalUpdater ](bt-plugins/decorators/GoalUpdater.html)
        * [ PathLongerOnApproach ](bt-plugins/decorators/PathLongerOnApproach.html)
        * [ SingleTrigger ](bt-plugins/decorators/SingleTrigger.html)
      * [ Example ](configuring-bt-xml.html#example)
    * [ Costmap 2D ](configuring-costmaps.html)
      * [ Costmap2D ROS Parameters ](configuring-costmaps.html#costmap2d-ros-parameters)


Plugin Name


* Provide custom via-points (you need to set ` ~<name>/global_plan_viapoint_sep ` to zero or negative)


####  Obstacle Parameters


Point-through-points navigation via a behavior tree action server

[ CoverageNavigator ](https://github.com/open-
navigation/opennav_coverage/tree/main/opennav_coverage_navigator)


Fig. 15. Example factor graph for a system with asynchronous measurements. A sensor measurement from a wheel encoder creates a constraint
between state x1 and x3. A measurement from an IMU creates a constraint
between state x2 and x4. The disjoint graphs are then connected via unicycle
model kinematic constraints.
The ROS 2 fuse package provides a factor graph framework that can be used in state estimation, mapping, calibration, and more [48], [49]. Within fuse, each factor node can
represent a measurement constraint or a kinematic constraint.
Measurement constraints represent the error term in Eq. 9 as
R
− 1
2 (zi − h(x)), where h, the sensor model, is a function
that transforms the variables in the constraint into the space
of the measurement. The covariance matrix R controls how
much weight the error term in question carries during the
optimization process. A small covariance would result in the
measurement being heavily weighted.
Kinematic constraints represent cost in the form
P
− 1
2 (xi − f(xt−1)), where xi
is the current value of the
variables connected to the constraint and the function f is
a state transition function that projects the variable values in
xt−1 forward in time.
fuse makes extensive use of dynamically loaded plugins to
manage the highly configurable graph construction and optimization process. A number of plugins are already provided
for common mobile robotics needs, but users may create and
utilize their own plugins for custom requirements. Each type
of plugin are detailed below.
Variables: Definitions of the quantities to be optimized.
A variable may represent a single value, e.g., x position, or it may represent more complex data, such as
a timestamped two-dimensional pose. For example, the
Orentation3DStamped variable comprises a 3D orientation (represented as a quaternion) with an associated time
stamp.
Constraints: Connections for variables in the factor graph. Each constraint is responsible for generating
some cost given the connected variables. These costs
are then minimized during optimization. For example,
the RelativePose2DStampedConstraint produces a
cost for two poses in the graph that is proportional to the
difference between those poses and the measured difference
as provided by a sensor measurement.


      * [ DWB Forward vs Reverse Pruning ](../../migration/Humble.html#dwb-forward-vs-reverse-pruning)
      * [ More stable regulation on curves for long lookahead distances ](../../migration/Humble.html#more-stable-regulation-on-curves-for-long-lookahead-distances)
      * [ Publish Collision Monitor State ](../../migration/Humble.html#publish-collision-monitor-state)
      * [ Renamed ROS-parameter in Collision Monitor ](../../migration/Humble.html#renamed-ros-parameter-in-collision-monitor)
      * [ New safety behavior model “limit” in Collision Monitor ](../../migration/Humble.html#new-safety-behavior-model-limit-in-collision-monitor)
      * [ Velocity smoother applies deceleration when timeout ](../../migration/Humble.html#velocity-smoother-applies-deceleration-when-timeout)
      * [ PoseProgressChecker plugin ](../../migration/Humble.html#poseprogresschecker-plugin)
      * [ Allow multiple goal checkers and change parameter progress_checker_plugin(s) name and type ](../../migration/Humble.html#allow-multiple-goal-checkers-and-change-parameter-progress-checker-plugin-s-name-and-type)
      * [ IsBatteryChargingCondition BT Node ](../../migration/Humble.html#isbatterychargingcondition-bt-node)
      * [ Behavior Server Error Codes ](../../migration/Humble.html#behavior-server-error-codes)
      * [ New Denoise Costmap Layer Plugin ](../../migration/Humble.html#new-denoise-costmap-layer-plugin)
      * [ SmacPlannerHybrid viz_expansions parameter ](../../migration/Humble.html#smacplannerhybrid-viz-expansions-parameter)
    * [ Iron to Jazzy ](../../migration/Iron.html)
      * [ Added TwistStamped Option for Commands ](../../migration/Iron.html#added-twiststamped-option-for-commands)
      * [ Add VelocityPolygon in Collision Monitor ](../../migration/Iron.html#add-velocitypolygon-in-collision-monitor)
      * [ Change polygon points parameter format in Collision Monitor ](../../migration/Iron.html#change-polygon-points-parameter-format-in-collision-monitor)
      * [ Introduction of Soft-Real Time Action Servers ](../../migration/Iron.html#introduction-of-soft-real-time-action-servers)
      * [ ` opennav_coverage  ` Project ](../../migration/Iron.html#opennav-coverage-project)
      * [ Introduce a new Multi-Robot Bringup Launch ](../../migration/Iron.html#introduce-a-new-multi-robot-bringup-launch)
      * [ New option for the Voxel and Obstacle Layers ](../../migration/Iron.html#new-option-for-the-voxel-and-obstacle-layers)
      * [ use_interpolation RPP Parameter Depreciated ](../../migration/Iron.html#use-interpolation-rpp-parameter-depreciated)
      * [ Changes to MPPI Goal Critic ](../../migration/Iron.html#changes-to-mppi-goal-critic)
      * [ Changes to MPPI Path Angle Critic ](../../migration/Iron.html#changes-to-mppi-path-angle-critic)
      * [ Changes to MPPI Path Handling For Directionality ](../../migration/Iron.html#changes-to-mppi-path-handling-for-directionality)
      * [ Addition of new MPPI Cost Critic ](../../migration/Iron.html#addition-of-new-mppi-cost-critic)
      * [ MPPI Acceleration ](../../migration/Iron.html#mppi-acceleration)
      * [ Move Error Code Enumerations ](../../migration/Iron.html#move-error-code-enumerations)
      * [ Substitution in parameter file ](../../migration/Iron.html#substitution-in-parameter-file)
      * [ Allow Behavior Server Plugins to Access The Action Result ](../../migration/Iron.html#allow-behavior-server-plugins-to-access-the-action-result)
      * [ Smac Planner Debug Param Name Change ](../../migration/Iron.html#smac-planner-debug-param-name-change)
      * [ Smac Planner On Approach to Goal Shortcutting Solutions ](../../migration/Iron.html#smac-planner-on-approach-to-goal-shortcutting-solutions)
      * [ Added GPS Waypoint Follower Server ](../../migration/Iron.html#added-gps-waypoint-follower-server)
      * [ Smac Planner Hybrid-A* New Features ](../../migration/Iron.html#smac-planner-hybrid-a-new-features)
      * [ New node in nav2_collision_monitor: Collision Detector ](../../migration/Iron.html#new-node-in-nav2-collision-monitor-collision-detector)
      * [ Dynamic enabling/disabling of sources/polygons in Collision Monitor/Detector ](../../migration/Iron.html#dynamic-enabling-disabling-of-sources-polygons-in-collision-monitor-detector)
      * [ Expose action server’s result timeout ](../../migration/Iron.html#expose-action-server-s-result-timeout)
      * [ RewrittenYaml could add new parameters to YAMLs ](../../migration/Iron.html#rewrittenyaml-could-add-new-parameters-to-yamls)
      * [ Simple Commander API Allows Multi-Robot Namespacing ](../../migration/Iron.html#simple-commander-api-allows-multi-robot-namespacing)
      * [ Change duration type in wait_action node ](../../migration/Iron.html#change-duration-type-in-wait-action-node)
      * [ The costmap activation fails when required transforms are not available ](../../migration/Iron.html#the-costmap-activation-fails-when-required-transforms-are-not-available)


Selects the progress checker based on a topic input, otherwises uses a default
progress checker id

[ Navigate Through Poses ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/navigate_through_poses_action.cpp)


creation. A design has been proposed to create a localization framework for building both 2D and 3D localization
systems atop of modular components. In the future, this
will allow developers to swap out individual components of
standard implementations to build use case-specific or novel
localization systems without being required to recreate all
other components. Its initial release will contain an analog
to AMCL, but also recent algorithms such as DT-NDL-MCL
and pose-graph based solutions [66].
XI. CONCLUSION
This paper surveys the state-of-the-art in ROS 2 navigation, as of November 2022, with key metrics and expert
insights from principal ROS developers and maintainers. The
redesign of Nav2 has triggered a renewed interest in mobile
robotics technology in the ROS ecosystem. Since 2018, Nav2
and related projects have continued to develop modern algorithms to augment historically capable methods in continual
use since Willow Garage. New global path planning, local
trajectory planning, cost map, and state estimation algorithms
have been introduced to enhance navigation capabilities
to support a broader set of vehicles, environments, and
applications. Moreover, entirely new classes of algorithms
and systems have been added to hone performance: such as
path smoothers, behavior trees, and numerous utilities. This
innovation has not terminated - new developments come on
a quarterly basis and continues to thrive amongst an ever
increasing number of commercial, academic, and individual
contributors.
REFERENCES
[1] S. Macenski, T. Foote, B. Gerkey, C. Lalancette, and W. Woodall,
“Robot operating system 2: Design, architecture, and uses in the wild,”
Science Robotics, vol. 7, no. 66, p. eabm6074, 2022.
[2] S. Macenski, F. Mart´ın, R. White, and J. G. Clavero, “The marathon 2:
A navigation system,” in 2020 IEEE/RSJ International Conference on
Intelligent Robots and Systems (IROS). IEEE, 2020, pp. 2718–2725.
[3] E. Marder-Eppstein, E. Berger, T. Foote, B. Gerkey, and K. Konolige, “The office marathon: Robust navigation in an indoor office
environment,” in 2010 IEEE international conference on robotics and
automation. IEEE, 2010, pp. 300–307.
[4] M. Jaimez, J.-L. Blanco, and J. Gonzalez-Jimenez, “Efficient reactive
navigation with exact collision determination for 3d robot shapes,”
International Journal of Advanced Robotic Systems, vol. 12, no. 5,
p. 63, 2015.
[5] L. C. Wang, L. S. Yong, and M. Ang, “Hybrid of global path


The teb_local_planner package implements a plugin to the base_local_planner of
the 2D navigation stack. The underlying method called Timed Elastic Band
locally optimizes the robot's trajectory with respect to trajectory execution
time, separation from obstacles and compliance with kinodynamic constraints at
runtime.


Released


  * [ Getting Started ](../../getting_started/index.html)
    * [ Installation ](../../getting_started/index.html#installation)
    * [ Running the Example ](../../getting_started/index.html#running-the-example)
    * [ Navigating ](../../getting_started/index.html#navigating)
  * [ Development Guides ](../../development_guides/index.html)
    * [ Build and Install ](../../development_guides/build_docs/index.html)
      * [ Install ](../../development_guides/build_docs/index.html#install)
      * [ Build ](../../development_guides/build_docs/index.html#build)
        * [ Released Distribution Binaries ](../../development_guides/build_docs/index.html#released-distribution-binaries)
        * [ Rolling Development Source ](../../development_guides/build_docs/index.html#rolling-development-source)
        * [ Docker Container Images ](../../development_guides/build_docs/index.html#docker-container-images)
      * [ Generate Doxygen ](../../development_guides/build_docs/index.html#generate-doxygen)
      * [ Help ](../../development_guides/build_docs/index.html#help)
        * [ Build Troubleshooting Guide ](../../development_guides/build_docs/build_troubleshooting_guide.html)
    * [ Dev Containers ](../../development_guides/devcontainer_docs/index.html)
      * [ Dev Container Guide ](../../development_guides/devcontainer_docs/devcontainer_guide.html)
        * [ Creating Dev Containers ](../../development_guides/devcontainer_docs/devcontainer_guide.html#creating-dev-containers)
        * [ Using Dev Containers ](../../development_guides/devcontainer_docs/devcontainer_guide.html#using-dev-containers)
      * [ What, Why, How? ](../../development_guides/devcontainer_docs/index.html#what-why-how)
        * [ What is a Dev Container? ](../../development_guides/devcontainer_docs/index.html#what-is-a-dev-container)
        * [ Why use a Dev Container? ](../../development_guides/devcontainer_docs/index.html#why-use-a-dev-container)
        * [ How do Dev Containers work? ](../../development_guides/devcontainer_docs/index.html#how-do-dev-containers-work)
      * [ Prerequisites ](../../development_guides/devcontainer_docs/index.html#prerequisites)
      * [ Getting started ](../../development_guides/devcontainer_docs/index.html#getting-started)
      * [ Security ](../../development_guides/devcontainer_docs/index.html#security)
    * [ Getting Involved ](../../development_guides/involvement_docs/index.html)
      * [ Getting Involved ](../../development_guides/involvement_docs/index.html#id1)
      * [ Process ](../../development_guides/involvement_docs/index.html#process)
      * [ Licensing ](../../development_guides/involvement_docs/index.html#licensing)
      * [ Developer Certification of Origin (DCO) ](../../development_guides/involvement_docs/index.html#developer-certification-of-origin-dco)
  * [ Navigation Concepts ](../../concepts/index.html)
    * [ ROS 2 ](../../concepts/index.html#ros-2)
      * [ Action Server ](../../concepts/index.html#action-server)
      * [ Lifecycle Nodes and Bond ](../../concepts/index.html#lifecycle-nodes-and-bond)
    * [ Behavior Trees ](../../concepts/index.html#behavior-trees)
    * [ Navigation Servers ](../../concepts/index.html#navigation-servers)
      * [ Planner, Controller, Smoother and Recovery Servers ](../../concepts/index.html#planner-controller-smoother-and-recovery-servers)
      * [ Planners ](../../concepts/index.html#planners)
      * [ Controllers ](../../concepts/index.html#controllers)
      * [ Behaviors ](../../concepts/index.html#behaviors)


* State Lattice computed the path in 113ms


` ~<name>/weight_obstacle ` ( ` double ` , default: 50.0)


  * Immutable Page
  * Comments
  * [ Info ](/action/info/teb_local_planner?action=info)
  * [ Attachments ](/action/AttachFile/teb_local_planner?action=AttachFile)
  * More Actions:  Raw Text  Print View  Render as Docbook  Delete Cache  \------------------------  Check Spelling  Like Pages  Local Site Map  \------------------------  Rename Page  Copy Page  Delete Page  \------------------------  My Pages  Subscribe User  \------------------------  Remove Spam  Revert to this revision  Package Pages  Sync Pages  \------------------------  CreatePdfDocument  Load  RawFile  Save  SlideShow


Calls Nav2 controller server

[ Navigate to Pose Action ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/navigate_to_pose_action.cpp)


Pradheep Padmanabhan


#  Package Summary


Joshua Wallace


Cancels wait behavior action

[ Cancel Drive on Heading Action ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/drive_on_heading_cancel_node.cpp)


Differential, Omnidirectional, Legged

[ TEB Controller ](https://github.com/rst-tu-dortmund/teb_local_planner)


* Reinitialize the trajectory if a previous goal is updated with a separation of more than the specified value in meters (skip hot-starting)


(formerly  SmacPlanner  )


* Optimization weight for minimzing the distance to via-points (resp. reference path). **New in version 0.4**


This package implements an online optimal local trajectory planner for
navigation and control of mobile robots as a plugin for the ROS [ navigation
](/navigation) package.  The initial trajectory generated by a global planner
is optimized during runtime w.r.t. minimizing the trajectory execution time
(time-optimal objective),  separation from obstacles and compliance with
kinodynamic constraints such as satisfying maximum velocities and
accelerations.


Source code and ` README  ` with design, explanations, and metrics can be
found on [ Github ](https://github.com/ros-
planning/navigation2/tree/main/nav2_smac_planner) . A brief explanation can be
found below, but the ` README  ` contains the most detailed overview of the
framework and planner implementations.


Calls clear costmap around robot service

[ Compute Path to Pose Action ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/compute_path_to_pose_action.cpp)


window polynomial function to remove noise from the
signal. This may be applied to path plans from search-based
planners due to their regular search intervals. This smoother
is unique from the others in that it will not generally modify
the character of the input path. Rather, it will only smooth
out irregularities that can be modeled as noise within a 7-
point window. This is most useful for gradient-descent path
creation, as found in the NavFn Planner or potential field
methods, which can generate irregularities due to performing
gradient-descent on a discrete grid. This method will smooth
”noisy” outlier path points while retaining the intent from the
planner. Fig. 10 shows a case in which NavFn generated a
path with an unusually large numbers of jagged points, which
the Savitzky-Golay Smoother refines into a smooth global
path. Since the character of the path remains the same, the
changes in key metrics are often negligible. This smoother,
like the others, will also update the orientation vectors of
each path point to be tangent to the final smoothed path.
Fig. 10. NavFn path (yellow) smoothed by Savitzky-Golay Smoother (red).
V. OVERVIEW OF PERCEPTION
A. Overview
The key to achieving reactive behavior - where a robot
intelligently navigates in a dynamic environment - is using
the robot’s sensors and semantic information to maintain a
representation of the environment. ROS 2 employs cost or
risk maps as the environmental model to consolidate the
results of potentially many algorithms. A balance must be
achieved to create a sufficiently high-fidelity representation
of the environment and be able to maintain that representation efficiently. Perception algorithms, sensor data, or
semantic information about the environment are populated
into this world model for use in global path and local
trajectory planning.
Cost maps reduce the world model into a two-dimensional
grid, with each grid cell having a cost associated with it. Cost
maps evolved from the probability-based occupancy grids
developed at Carnegie Mellon in the 1980s [34], [35]. The
modern cost map was first described by Marder-Eppstein et
al [3], where the cost associated with each cell was an integer
in the range [0, 255]. In general, planning algorithms will
prefer paths with lower costs and avoid those with higher


* Visualize the graph that is created for exploring distinctive trajectories (check marker message in rviz)


Michael Jeronimo


* Global planning frame (in case of a static map, this parameter must be usually changed to "/map".


` ~<name>/odom_topic ` ( ` string ` , default: "odom")


A plugin check whether robot is within translational distance , rotational
distance of goal, and velocity threshold.

##  Progress Checkers  ¶


####  Trajectory Configuration Parameters


Steve Macenski


Extracts a path section around robot

[ Planner Selector ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/planner_selector_node.cpp)


` ~<name>/min_obstacle_dist ` ( ` double ` , default: 0.5)


Sarthak Mittal


* This parameter is only relevant for type "line". It contains the end coordinates of the line segment.


**Package Links**


The teb_local_planner package implements a plugin to the base_local_planner of
the 2D navigation stack. The underlying method called Timed Elastic Band
locally optimizes the robot's trajectory with respect to trajectory execution
time, separation from obstacles and compliance with kinodynamic constraints at
runtime.


A highly configurable DWA implementation with plugin interfaces


* Specify the number of samples generated for creating the roadmap graph


Alberto Tudela


Documented


Continuous Integration:  3 / 3


© Copyright 2023.


The following parameters are relevant only for holonomic robots:  New in ROS
kinetic


      * [ Added Smoother Task Server ](../../migration/Galactic.html#added-smoother-task-server)
      * [ Removed Use Approach Velocity Scaling Param in RPP ](../../migration/Galactic.html#removed-use-approach-velocity-scaling-param-in-rpp)
      * [ Refactored AMCL motion models as plugins ](../../migration/Galactic.html#refactored-amcl-motion-models-as-plugins)
      * [ Dropping Support for Live Groot Monitoring of Nav2 ](../../migration/Galactic.html#dropping-support-for-live-groot-monitoring-of-nav2)
      * [ Replanning Only if Path is Invalid ](../../migration/Galactic.html#replanning-only-if-path-is-invalid)
      * [ Fix CostmapLayer clearArea invert param logic ](../../migration/Galactic.html#fix-costmaplayer-cleararea-invert-param-logic)
      * [ Dynamic Composition ](../../migration/Galactic.html#dynamic-composition)
      * [ BT Cancel Node ](../../migration/Galactic.html#bt-cancel-node)
      * [ BT PathLongerOnApproach Node ](../../migration/Galactic.html#bt-pathlongeronapproach-node)
      * [ BT TruncatePathLocal Node ](../../migration/Galactic.html#bt-truncatepathlocal-node)
      * [ Constrained Smoother ](../../migration/Galactic.html#constrained-smoother)
      * [ Replanning at a Constant Rate and if the Path is Invalid ](../../migration/Galactic.html#replanning-at-a-constant-rate-and-if-the-path-is-invalid)
      * [ Euclidean Distance 2D ](../../migration/Galactic.html#euclidean-distance-2d)
      * [ Recovery To Behavior ](../../migration/Galactic.html#recovery-to-behavior)
      * [ Respawn Support in Launch and Lifecycle Manager ](../../migration/Galactic.html#respawn-support-in-launch-and-lifecycle-manager)
      * [ New Nav2 Velocity Smoother ](../../migration/Galactic.html#new-nav2-velocity-smoother)
      * [ Goal Checker API Changed ](../../migration/Galactic.html#goal-checker-api-changed)
      * [ Added Assisted Teleop ](../../migration/Galactic.html#added-assisted-teleop)
    * [ Humble to Iron ](../../migration/Humble.html)
      * [ New Behavior-Tree Navigator Plugins ](../../migration/Humble.html#new-behavior-tree-navigator-plugins)
      * [ Added Collision Monitor ](../../migration/Humble.html#added-collision-monitor)
      * [ Removed use_sim_time from yaml ](../../migration/Humble.html#removed-use-sim-time-from-yaml)
      * [ Run-time Speed up of Smac Planner ](../../migration/Humble.html#run-time-speed-up-of-smac-planner)
      * [ Recursive Refinement of Smac and Simple Smoothers ](../../migration/Humble.html#recursive-refinement-of-smac-and-simple-smoothers)
      * [ Simple Commander Python API ](../../migration/Humble.html#simple-commander-python-api)
      * [ Smac Planner Start Pose Included in Path ](../../migration/Humble.html#smac-planner-start-pose-included-in-path)
      * [ Parameterizable Collision Checking in RPP ](../../migration/Humble.html#parameterizable-collision-checking-in-rpp)
      * [ Expanded Planner Benchmark Tests ](../../migration/Humble.html#expanded-planner-benchmark-tests)
      * [ Smac Planner Path Tolerances ](../../migration/Humble.html#smac-planner-path-tolerances)
      * [ costmap_2d_node default constructor ](../../migration/Humble.html#costmap-2d-node-default-constructor)
      * [ Feedback for Navigation Failures ](../../migration/Humble.html#feedback-for-navigation-failures)
      * [ Costmap Filters ](../../migration/Humble.html#costmap-filters)
      * [ Savitzky-Golay Smoother ](../../migration/Humble.html#savitzky-golay-smoother)
      * [ Changes to Map yaml file path for map_server node in Launch ](../../migration/Humble.html#changes-to-map-yaml-file-path-for-map-server-node-in-launch)
      * [ SmootherSelector BT Node ](../../migration/Humble.html#smootherselector-bt-node)
      * [ Publish Costmap Layers ](../../migration/Humble.html#publish-costmap-layers)
      * [ Give Behavior Server Access to Both Costmaps ](../../migration/Humble.html#give-behavior-server-access-to-both-costmaps)
      * [ New Model Predictive Path Integral Controller ](../../migration/Humble.html#new-model-predictive-path-integral-controller)
      * [ Behavior Tree Uses Error Codes ](../../migration/Humble.html#behavior-tree-uses-error-codes)
      * [ Load, Save and Loop Waypoints from the Nav2 Panel in RViz ](../../migration/Humble.html#load-save-and-loop-waypoints-from-the-nav2-panel-in-rviz)


    * [ Constrained smoother ](configuring-constrained-smoother.html)
      * [ Smoother Server Parameters ](configuring-constrained-smoother.html#smoother-server-parameters)
      * [ Example ](configuring-constrained-smoother.html#example)
    * [ Velocity Smoother ](configuring-velocity-smoother.html)
      * [ Velocity Smoother Parameters ](configuring-velocity-smoother.html#velocity-smoother-parameters)
      * [ Example ](configuring-velocity-smoother.html#example)
    * [ Collision Monitor ](configuring-collision-monitor.html)
      * [ Provided Nodes ](configuring-collision-monitor.html#provided-nodes)
        * [ Collision Monitor Node ](collision_monitor/configuring-collision-monitor-node.html)
        * [ Collision Detector Node ](collision_monitor/configuring-collision-detector-node.html)
    * [ Waypoint Follower ](configuring-waypoint-follower.html)
      * [ Parameters ](configuring-waypoint-follower.html#parameters)
      * [ Provided Plugins ](configuring-waypoint-follower.html#provided-plugins)
        * [ WaitAtWaypoint ](nav2_waypoint_follower-plugins/wait_at_waypoint.html)
        * [ PhotoAtWaypoint ](nav2_waypoint_follower-plugins/photo_at_waypoint.html)
        * [ InputAtWaypoint ](nav2_waypoint_follower-plugins/input_at_waypoint.html)
      * [ Default Plugin ](configuring-waypoint-follower.html#default-plugin)
      * [ Example ](configuring-waypoint-follower.html#example)
  * [ Tuning Guide ](../../tuning/index.html)
    * [ Inflation Potential Fields ](../../tuning/index.html#inflation-potential-fields)
    * [ Robot Footprint vs Radius ](../../tuning/index.html#robot-footprint-vs-radius)
    * [ Rotate in Place Behavior ](../../tuning/index.html#rotate-in-place-behavior)
    * [ Planner Plugin Selection ](../../tuning/index.html#planner-plugin-selection)
    * [ Controller Plugin Selection ](../../tuning/index.html#controller-plugin-selection)
    * [ Caching Obstacle Heuristic in Smac Planners ](../../tuning/index.html#caching-obstacle-heuristic-in-smac-planners)
    * [ Costmap2D Plugins ](../../tuning/index.html#costmap2d-plugins)
    * [ Nav2 Launch Options ](../../tuning/index.html#nav2-launch-options)
    * [ Other Pages We’d Love To Offer ](../../tuning/index.html#other-pages-we-d-love-to-offer)
  * [ Nav2 Behavior Trees ](../../behavior_trees/index.html)
    * [ Introduction To Nav2 Specific Nodes ](../../behavior_trees/overview/nav2_specific_nodes.html)
      * [ Action Nodes ](../../behavior_trees/overview/nav2_specific_nodes.html#action-nodes)
      * [ Condition Nodes ](../../behavior_trees/overview/nav2_specific_nodes.html#condition-nodes)
      * [ Decorator Nodes ](../../behavior_trees/overview/nav2_specific_nodes.html#decorator-nodes)
      * [ Control: PipelineSequence ](../../behavior_trees/overview/nav2_specific_nodes.html#control-pipelinesequence)
      * [ Control: Recovery ](../../behavior_trees/overview/nav2_specific_nodes.html#control-recovery)
      * [ Control: RoundRobin ](../../behavior_trees/overview/nav2_specific_nodes.html#control-roundrobin)
    * [ Detailed Behavior Tree Walkthrough ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html)
      * [ Overview ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#overview)
      * [ Prerequisites ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#prerequisites)
      * [ Navigate To Pose With Replanning and Recovery ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#navigate-to-pose-with-replanning-and-recovery)


Point-to-point navigation via a behavior tree action server

[ NavigateThroughPosesNavigator ](https://github.com/ros-
planning/navigation2/tree/main/nav2_bt_navigator/src/navigators)


Throttles child node to a given rate

[ Distance Controller ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/decorator/distance_controller.cpp)


#  NavFn Planner  ¶


and the scan is inserted into the submap at its best estimated
pose. When a submap is completed, it takes part in a loop
closure process which compares submaps and local scans to
refine the global occupancy grid model.
While Cartographer is a good option for some users, it is
worth noting that out-of-the-box results with Cartographer
are typically poor. It is possible to achieve 3-5 cm accuracy using Cartographer, but requires extensive professional
tuning using hardware platforms with high-quality odometry. Further, the original author’s organization has halted
development and support. ROS 2 support is managed by a
community effort but has not received significant attention
due to the complexity of the codebase. Thus, it is difficult
to recommend the use of Cartographer.
Fig. 18. Map generated by SLAM Toolbox [61].
SLAM Toolbox is a set of tools and capabilities for 2D
SLAM built upon the OpenKarto SLAM library [62]. SLAM
Toolbox is also a pose-graph optimization method. It matches
incoming sensor readings with a recent rolling buffer of scans
to provide a corrected pose. This uses a correlation grid
constructed from the buffer of local measurements to match
the incoming scan at a coarse half-resolution, followed up
by full resolution for fine tuning the results.
The incoming scan with the initially corrected pose is then
evaluated for loop closure. Candidate scans are found which
are near the incoming measurement but not connected locally
in the graph. The candidates are matched against the scan at
a coarse resolution. If the match is strong enough, a full
resolution match is performed on the fine correlation grid. If
again the match is sufficiently strong, a constraint is added;
then the pose-graph optimization process is performed.
Changes were made to the OpenKarto library to increase
speed of scan matching using multi-threading and replace
the Sparse Bundle Adjustment with Google Ceres to provide
more flexible optimization settings. It can reliably map
spaces greater than 100,000 sq ft in real-time (fig. 18),
enables serialization of maps for continued mapping, allows
for manual manipulation of the pose-graph, and comes with
several operating modes.
IX. OVERVIEW OF KEY UTILITIES
This section provides overviews of new and unique utilities in ROS 2. They contribute intuitive user interactions and
create safer robotic systems by commanding, regulating, and


* Specify a time duration in seconds that needs to be expired before a switch to a new equivalence class is allowed.


large-scale environments.
Thus, Nav2 provides primarily search-based global planning methods. The furnished algorithms cover the full
spanning set of both circular and arbitrarily-shaped robot
models, including differential-drive, holonomic, Ackermann,
and legged robot platforms. Namely, these are Navigation
Function, 2D-A*, Theta*, Hybrid-A*, and State Lattice
planners. All of the planners are cost-aware, meaning they
consider the range of cost map risk values populated from
sensor data, perception pipelines, or semantic information
such as maps - not solely binary obstacles.
For comparison, a AMD Ryzen 5 5600X CPU with
Ubuntu 20.04 was utilized to benchmark each planning algorithm. The experiment contained 1,000 randomly generated
start and goal poses through a 20% randomly occupied
10,000m2 map. Each start and goal pairing was made to
be at least 3 meters apart and known to be reachable. All of
the algorithms are analyzed with the same 1,000 paths and
uses the provided default settings. The results are shown in
Table I.
A. Holonomic Planners
Nav2 provides a variety of holonomic path planners.
This class of planner is most useful for omni-directional
or differential-drive robots, particularly those that may be
approximated as circular. Non-circular robots that are small
relative to their environment may be treated as circular for
global planning purposes if there is no navigable corridor
too narrow to accommodate an in-place rotation. While
differential-drive robots cannot move at any angle, they may
perform in-place rotations to a given requested heading if
required. Thus, many forms of differential-drive platforms
may effectively use holonomic planners.
These planners generally create paths via traditional gridbased algorithms. Since they do not track robot orientation
during grid-search, these algorithms collision check using
point-costs of the visited cells in an inflated or convolved cost
grid, which are discussed further in Sec. V. Those included in
Nav2 are Navigation Function (commonly known as NavFn),
Theta*, and smoothed 2D-A* [8], [9], [10].
Fig. 1. Example plans from the holonomic planners. NavFn in red, Theta*
in green, 2D-A* in blue.
Navigation Function planner is a modified Global Dynamic Window Approach planner based on the NF1 function
[8]. It uses Dijkstra’s Algorithm to expand a potential field


* Random keypoints/waypoints are sampled in a rectangular region between start and goal. Specify the width of that region in meters.


Checks if the battery is charging.

Decorator Plugin Name


(pose, velocity, etc). Such estimates are typically obtained
through sensor fusion, or the process of determining a
robot’s state relative to a reference frame given many noisy
sensor measurements, such as IMUs, wheel encoders, pose
measurements, GPS, and more. The output of this fusion is
an approximation of a robot’s state variables and typically a
measure of confidence regarding the estimate.
ROS Enhancement Proposal (REP) 105 establishes the
coordinate frames for common types of robotic systems to
ensure interoperability of components [43]. The transformation tree containing these coordinate frames is populated by
the algorithms of this and the next sections and managed by
the tf library [44]. tf is utilized by a litany of applications
to transform sensor data or relative vectors through timevarying reference frames - not simply for robot state tracking.
Within this formulation, the odom to base link transform can be generated by integrating a robot’s wheel encoder
data to provide a pose estimate that can be used for local
control of the robot. That pose will drift over time, however,
so REP 105 also specifies a map to base link transform15
that represents a drift-free estimate of the robot’s pose. This
pose is useful for carrying out operations such as global
planning. However, it is subject to discontinuities, making it a
poor choice for control algorithms. The map to base link
transform can be provided through a localization package,
described in more detail in section VIII.
Alternatively, both transforms can be provided through
the use of state estimators. In the case of the odom to
base link transform, this would typically mean fusing
wheel encoder data with other continuous sources like angular velocity data from an IMU. For the map to base link
transform, the pose estimate from the localization package
might be fused with other global pose estimates or with
the same sources fused in the odom to base link state
estimator. This is useful if the localization package produces
infrequent or irregularly-timed pose measurements, as it
enables the global pose estimate to be generated at a fixed
frequency.
While there are a myriad of algorithms for performing sensor fusion, two well-known and robust classes of approaches
are Kalman filtering and factor graphs, both of which have
implementations within the ROS 2 ecosystem.
A. State Estimators
Robot Localization In the 60 years since its introduction,
Kalman filtering has become one of the best-known and


Mohammad Haghighipanah


* Allowed final euclidean distance to the goal position in meters


      * [ Composition ](../../tutorials/docs/adding_a_nav2_task_server.html#composition)
      * [ Error codes ](../../tutorials/docs/adding_a_nav2_task_server.html#error-codes)
      * [ Conclusion ](../../tutorials/docs/adding_a_nav2_task_server.html#conclusion)
    * [ Filtering of Noise-Induced Obstacles ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html)
      * [ Overview ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#overview)
      * [ Requirements ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#tutorial-steps)
        * [ 1\. Enable Denoise Layer ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#enable-denoise-layer)
        * [ 2\. Run Nav2 stack ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#run-nav2-stack)
      * [ How it works ](../../tutorials/docs/filtering_of_noise-induced_obstacles.html#how-it-works)
    * [ Camera Calibration ](../../tutorials/docs/camera_calibration.html)
      * [ Overview ](../../tutorials/docs/camera_calibration.html#overview)
      * [ Requirements ](../../tutorials/docs/camera_calibration.html#requirements)
      * [ Tutorial Steps ](../../tutorials/docs/camera_calibration.html#tutorial-steps)
    * [ Get Backtrace in ROS 2 / Nav2 ](../../tutorials/docs/get_backtrace.html)
      * [ Overview ](../../tutorials/docs/get_backtrace.html#overview)
      * [ Preliminaries ](../../tutorials/docs/get_backtrace.html#preliminaries)
      * [ From a Node ](../../tutorials/docs/get_backtrace.html#from-a-node)
      * [ From a Launch File ](../../tutorials/docs/get_backtrace.html#from-a-launch-file)
      * [ From Large Project ](../../tutorials/docs/get_backtrace.html#from-large-project)
      * [ From Nav2 Bringup ](../../tutorials/docs/get_backtrace.html#from-nav2-bringup)
      * [ Automatic backtrace on crash ](../../tutorials/docs/get_backtrace.html#automatic-backtrace-on-crash)
    * [ Profiling in ROS 2 / Nav2 ](../../tutorials/docs/get_profile.html)
      * [ Overview ](../../tutorials/docs/get_profile.html#overview)
      * [ Preliminaries ](../../tutorials/docs/get_profile.html#preliminaries)
      * [ Profile from a Node ](../../tutorials/docs/get_profile.html#profile-from-a-node)
      * [ Profile from a Launch File ](../../tutorials/docs/get_profile.html#profile-from-a-launch-file)
      * [ From Nav2 Bringup ](../../tutorials/docs/get_profile.html#from-nav2-bringup)
      * [ Interpreting Results ](../../tutorials/docs/get_profile.html#interpreting-results)
    * [ Docker for Development: Zero to Hero ](../../tutorials/docs/docker_dev.html)
      * [ Overview ](../../tutorials/docs/docker_dev.html#overview)
      * [ Preliminaries ](../../tutorials/docs/docker_dev.html#preliminaries)
      * [ Important Docker Commands ](../../tutorials/docs/docker_dev.html#important-docker-commands)
      * [ Exploring Your First Container ](../../tutorials/docs/docker_dev.html#exploring-your-first-container)
      * [ Understanding ROS Docker Images ](../../tutorials/docs/docker_dev.html#understanding-ros-docker-images)
      * [ For Docker-Based Development ](../../tutorials/docs/docker_dev.html#for-docker-based-development)
        * [ Building a Development Image ](../../tutorials/docs/docker_dev.html#building-a-development-image)
        * [ Visualizations from Docker ](../../tutorials/docs/docker_dev.html#visualizations-from-docker)
      * [ For Docker-Based Deployment ](../../tutorials/docs/docker_dev.html#for-docker-based-deployment)
      * [ Conclusion ](../../tutorials/docs/docker_dev.html#conclusion)


The teb_local_planner package allows the user to set [ Parameters
](/Parameters) in order to customize the behavior. These parameters are
grouped into several categories: robot configuration, goal tolerance,
trajectory configuration, obstacles, optimization, planning in distinctive
topologies and miscellaneous parameters. Some of them are chosen to be
compliant with the [ base_local_planner ](/base_local_planner) . Many (but not
all) parameters can be modified at runtime using [ rqt_reconfigure
](/rqt_reconfigure) .


Michael Jeronimo


Default

---|---

bool


` ~<name>/cmd_angle_instead_rotvel ` ( ` bool ` , default: false)


* Specify minimum duration for the reduced horizon in case an infeasible trajectory is detected (refer to parameter ` shrink_horizon_backup ` in order to activate the reduced horizon mode).


  * [ source ubuntu focal ](https://build.ros.org/view/Nsrc_uF/job/Nsrc_uF__teb_local_planner__ubuntu_focal__source)
  * [ binary ubuntu focal amd64 ](https://build.ros.org/view/Nbin_uF64/job/Nbin_uF64__teb_local_planner__ubuntu_focal_amd64__binary)
  * [ binary ubuntu focal armhf ](https://build.ros.org/view/Nbin_ufhf_uFhf/job/Nbin_ufhf_uFhf__teb_local_planner__ubuntu_focal_armhf__binary)
  * [ binary ubuntu focal arm64 ](https://build.ros.org/view/Nbin_ufv8_uFv8/job/Nbin_ufv8_uFv8__teb_local_planner__ubuntu_focal_arm64__binary)
  * [ devel ubuntu focal amd64 ](https://build.ros.org/view/Ndev/job/Ndev__teb_local_planner__ubuntu_focal_amd64)
  * [ doc ](https://build.ros.org/view/Ndoc/job/Ndoc__teb_local_planner__ubuntu_focal_amd64)


0.5

Description


Use GitHub to [ report bugs or submit feature requests
](https://github.com/rst-tu-dortmund/teb_local_planner/issues/new) . [ [ View
active issues ](https://github.com/rst-tu-
dortmund/teb_local_planner/issues?page=1&state=open) ]


* Minimum turning radius of a carlike robot (set to zero for a diff-drive robot).


      * [ Navigation Subtree ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#navigation-subtree)
      * [ Recovery Subtree ](../../behavior_trees/overview/detailed_behavior_tree_walkthrough.html#recovery-subtree)
    * [ Navigate To Pose ](../../behavior_trees/trees/nav_to_pose_recovery.html)
    * [ Navigate Through Poses ](../../behavior_trees/trees/nav_through_poses_recovery.html)
    * [ Navigate To Pose and Pause Near Goal-Obstacle ](../../behavior_trees/trees/nav_to_pose_and_pause_near_goal_obstacle.html)
    * [ Navigate To Pose With Consistent Replanning And If Path Becomes Invalid ](../../behavior_trees/trees/nav_to_pose_with_consistent_replanning_and_if_path_becomes_invalid.html)
    * [ Follow Dynamic Point ](../../behavior_trees/trees/follow_point.html)
    * [ Odometry Calibration ](../../behavior_trees/trees/odometry_calibration.html)
  * [ Navigation Plugins ](../../plugins/index.html)
    * [ Behavior-Tree Navigators ](../../plugins/index.html#behavior-tree-navigators)
    * [ Costmap Layers ](../../plugins/index.html#costmap-layers)
    * [ Costmap Filters ](../../plugins/index.html#costmap-filters)
    * [ Controllers ](../../plugins/index.html#controllers)
    * [ Planners ](../../plugins/index.html#planners)
    * [ Smoothers ](../../plugins/index.html#smoothers)
    * [ Behaviors ](../../plugins/index.html#behaviors)
    * [ Waypoint Task Executors ](../../plugins/index.html#waypoint-task-executors)
    * [ Goal Checkers ](../../plugins/index.html#goal-checkers)
    * [ Progress Checkers ](../../plugins/index.html#progress-checkers)
    * [ Behavior Tree Nodes ](../../plugins/index.html#behavior-tree-nodes)
  * [ Migration Guides ](../../migration/index.html)
    * [ Dashing to Eloquent ](../../migration/Dashing.html)
      * [ New Packages ](../../migration/Dashing.html#new-packages)
      * [ New Plugins ](../../migration/Dashing.html#new-plugins)
      * [ Navigation2 Architectural Changes ](../../migration/Dashing.html#navigation2-architectural-changes)
    * [ Eloquent to Foxy ](../../migration/Eloquent.html)
      * [ General ](../../migration/Eloquent.html#general)
      * [ Server Updates ](../../migration/Eloquent.html#server-updates)
      * [ New Plugins ](../../migration/Eloquent.html#new-plugins)
      * [ Map Server Re-Work ](../../migration/Eloquent.html#map-server-re-work)
      * [ New Particle Filter Messages ](../../migration/Eloquent.html#new-particle-filter-messages)
      * [ Selection of Behavior Tree in each navigation action ](../../migration/Eloquent.html#selection-of-behavior-tree-in-each-navigation-action)
      * [ FollowPoint Capability ](../../migration/Eloquent.html#followpoint-capability)
      * [ New Costmap Layer ](../../migration/Eloquent.html#new-costmap-layer)
    * [ Foxy to Galactic ](../../migration/Foxy.html)
      * [ NavigateToPose Action Feedback updates ](../../migration/Foxy.html#navigatetopose-action-feedback-updates)
      * [ NavigateToPose BT-node Interface Changes ](../../migration/Foxy.html#navigatetopose-bt-node-interface-changes)
      * [ NavigateThroughPoses and ComputePathThroughPoses Actions Added ](../../migration/Foxy.html#navigatethroughposes-and-computepaththroughposes-actions-added)
      * [ ComputePathToPose BT-node Interface Changes ](../../migration/Foxy.html#computepathtopose-bt-node-interface-changes)
      * [ ComputePathToPose Action Interface Changes ](../../migration/Foxy.html#computepathtopose-action-interface-changes)


** Jenkins jobs  (6) **


Features introduced in **version 0.2** are presented in the following video
(supporting car-like robots and costmap conversion).


Plugin Name


* If this parameter is set to true, the motion of obstacles with non-zero velocity (provided via user-supplied obstacles on topic ` ~/obstacles ` or obtained from the [ costmap_converter ](/costmap_converter) ) is predicted and considered during optimization via a constant velocity model. **New**


Gets static ` map  ` and loads occupancy information into costmap

[ Inflation Layer ](https://github.com/ros-
planning/navigation2/tree/main/nav2_costmap_2d/plugins/inflation_layer.cpp)


is a popular approach for outdoor robot platforms. While
subject to drift in some environments, GPS data provides
a globally unambiguous positional reference and reduces
the need for techniques that rely on expensive sensors. The
key to integrating GPS data in a robot’s state estimate is
the computation of the transform between the robot’s world
frame (e.g., the map frame as specified in REP-105) and the
GPS frame, most commonly the WGS-84 geodetic datum
[57].
Generating this transform requires knowledge of the
robot’s pose in a world frame, the robot’s latitude and
longitude as provided from a GPS sensor, and the robot’s
heading in an earth-referenced frame, as might be obtained
via an IMU with a magnetometer.
The robot localization package described in Section VIIA provides the NavSat Transform Node, whose purpose is to
calculate this transformation. It does this by converting the
GPS position and earth-referenced heading into a position in
the Universal Transverse Mercator (UTM) coordinate frame
[58]. From there, the transform to the robot’s world frame is
trivial. The output of NavSat Transform Node is a pose that
can be fused into the robot’s state estimate or directly used
for localization with respect to the robot’s world frame. The
accuracy of GPS localization is limited by the environment,
quality of the GPS receiver, and whether RTK (Real-time
kinematic) GPS corrections are available in the area. When
RTK is available, accuracies can reach 2 cm or better [59].
B. Mapping
Mapping solves the fundamental problem of how a robot
understands its environment. It uses sensor data and potentially robot state estimates to generate a globally accurate
model of the world. This world representation is used for
many tasks, including global planning and localization, when
not using GPS or other global positioning systems. Succinctly, mapping is the process of learning a world’s contents
from sensor data. For mapping techniques in ROS 2, the map
is represented as an occupancy grid, or a grid map of cells
representing the probability of occupancy. They also perform
mapping and localization simultaneously, e.g. SLAM.
Cartographer provides real-time simultaneous localization and mapping in both 2D and 3D for multiple platforms
and sensor configurations using pose-graph optimization
[60]. Laser scans are added into submaps over short periods
of time to create locally accurate maps with current measurements. Scan matching is performed on these local submaps


Wiki: teb_local_planner (last edited 2020-03-11 14:29:59 by  [
ChristophRoesmann ](/ChristophRoesmann "ChristophRoesmann @
2a02:908:1580:1020:592c:9468:838b:60df\[2a02:908:1580:1020:592c:9468:838b:60df\]")
)


* Specify the maximum length (cumulative Euclidean distances) of the subset of the global plan taken into account for optimization. The actual length is than determined by the logical conjunction of the local costmap size and this maximum bound. Set to zero or negative in order to deactivate this limitation.


* Specify up to which pose on the predicted plan the feasibility should be checked each sampling interval.


  * Maintainer status: developed
  * Maintainer: Christoph Rösmann <christoph.roesmann AT tu-dortmund DOT de>
  * Author: Christoph Rösmann <christoph.roesmann AT tu-dortmund DOT de>
  * License: BSD
  * Source: git [ https://github.com/rst-tu-dortmund/teb_local_planner.git ](https://github.com/rst-tu-dortmund/teb_local_planner) (branch: kinetic-devel)


Sarthak Mittal


Steve Macenski


Removes goal poses passed or within a tolerance for culling old viapoints from
path re-planning

[ Compute Path Through Poses ](https://github.com/ros-
planning/navigation2/tree/main/nav2_behavior_tree/plugins/action/compute_path_through_poses_action.cpp)


> The plugins listed below are inside the ` nav2_smac_planner  ` package. See
> the pages for individual configuration information.


pp. 1627–1639, 1964.
[34] L. Matthies and A. Elfes, “Integration of sonar and stereo range
data using a grid-based representation,” in Proceedings of the IEEE
International Conference on Robotics and Automation (ICRA), 1988,
pp. 727–733.
[35] H. P. Moravec, “Sensor fusion in certainty grids for mobile robots,”
AI magazine, vol. 9, no. 2, pp. 61–74, 1988.
[36] T. Lozano-Perez, “Spatial planning: A configuration space approach,”
Computers, IEEE Transactions on, vol. 100, no. 2, pp. 108–120, 1983.
[37] G. K. Kraetzschmar, G. Pages Gassull, and K. Uhl, “Probabilistic `
quadtrees for variable-resolution mapping of large environments,”
IFAC Proceedings Volumes, vol. 37, no. 8, pp. 675–680, 2004.
[38] D. V. Lu, D. Hershberger, and W. D. Smart, “Layered costmaps
for context-sensitive navigation,” in 2014 IEEE/RSJ International
Conference on Intelligent Robots and Systems. IEEE, 2014, pp. 709–
715.
[39] K. Museth, J. Lait, J. Johanson, J. Budsberg, R. Henderson, M. Alden,
P. Cucka, D. Hill, and A. Pearce, “Openvdb: An open-source data
structure and toolkit for high-resolution volumes,” in ACM SIGGRAPH
2013 Courses, ser. SIGGRAPH ’13. Association for Computing
Machinery, 2013.
[40] S. Macenski, D. Tsai, and M. Feinberg, “Spatio-temporal voxel layer:
A view on robot perception for the dynamic world,” International
Journal of Advanced Robotic Systems, vol. 17, no. 2, 2020.
[41] G. Oriolo, G. Ulivi, and M. Vendittelli, “Fuzzy maps: a new tool for
mobile robot perception and planning,” Journal of Robotic Systems,
vol. 14, no. 3, pp. 179–197, 1997.
[42] M. Colledanchise and P. Ogren, ¨ ”Behavior trees in robotics and AI:
An introduction”. CRC Press, 2018.
[43] W. Meeussen. (2010) Rep-105: Coordinate frames for mobile
platforms. [Online]. Available: https://www.ros.org/reps/rep-0105.html
[44] T. Foote, “tf: The transform library,” in 2013 IEEE Conference on
Technologies for Practical Robot Applications (TePRA), 2013, pp. 1–
6.
[45] R. E. Kalman, “A new approach to linear filtering and prediction
problems,” Transactions of the ASME–Journal of Basic Engineering,
vol. 82, no. Series D, pp. 35–45, 1960.
[46] E. Wan and R. Van Der Merwe, “The unscented kalman filter for nonlinear estimation,” in Proceedings of the IEEE 2000 Adaptive Systems
for Signal Processing, Communications, and Control Symposium (Cat.
No.00EX373), 2000, pp. 153–158.


` ~<name>/acc_lim_theta ` ( ` double ` , default: 0.5)


#  Package Summary


` ~<name>/h_signature_prescaler ` ( ` double ` , default: 1.0)


Creator


A plugin check whether robot is within translational distance and rotational
distance of goal.

[ StoppedGoalChecker ](https://github.com/ros-
planning/navigation2/blob/main/nav2_controller/plugins/stopped_goal_checker.cpp)


      * [ BackUp BT-node Interface Changes ](../migration/Foxy.html#backup-bt-node-interface-changes)
      * [ BackUp Recovery Interface Changes ](../migration/Foxy.html#backup-recovery-interface-changes)
      * [ Nav2 Controllers and Goal Checker Plugin Interface Changes ](../migration/Foxy.html#nav2-controllers-and-goal-checker-plugin-interface-changes)
      * [ FollowPath goal_checker_id attribute ](../migration/Foxy.html#followpath-goal-checker-id-attribute)
      * [ Groot Support ](../migration/Foxy.html#groot-support)
      * [ New Plugins ](../migration/Foxy.html#new-plugins)
      * [ Costmap Filters ](../migration/Foxy.html#costmap-filters)
      * [ SmacPlanner ](../migration/Foxy.html#smacplanner)
      * [ ThetaStarPlanner ](../migration/Foxy.html#thetastarplanner)
      * [ RegulatedPurePursuitController ](../migration/Foxy.html#regulatedpurepursuitcontroller)
      * [ Costmap2D ` current_  ` Usage ](../migration/Foxy.html#costmap2d-current-usage)
      * [ Standard time units in parameters ](../migration/Foxy.html#standard-time-units-in-parameters)
      * [ Ray Tracing Parameters ](../migration/Foxy.html#ray-tracing-parameters)
      * [ Obstacle Marking Parameters ](../migration/Foxy.html#obstacle-marking-parameters)
      * [ Recovery Action Changes ](../migration/Foxy.html#recovery-action-changes)
      * [ Default Behavior Tree Changes ](../migration/Foxy.html#default-behavior-tree-changes)
      * [ NavFn Planner Parameters ](../migration/Foxy.html#navfn-planner-parameters)
      * [ New ClearCostmapExceptRegion and ClearCostmapAroundRobot BT-nodes ](../migration/Foxy.html#new-clearcostmapexceptregion-and-clearcostmaparoundrobot-bt-nodes)
      * [ New Behavior Tree Nodes ](../migration/Foxy.html#new-behavior-tree-nodes)
      * [ sensor_msgs/PointCloud to sensor_msgs/PointCloud2 Change ](../migration/Foxy.html#sensor-msgs-pointcloud-to-sensor-msgs-pointcloud2-change)
      * [ ControllerServer New Parameter failure_tolerance ](../migration/Foxy.html#controllerserver-new-parameter-failure-tolerance)
      * [ Removed BT XML Launch Configurations ](../migration/Foxy.html#removed-bt-xml-launch-configurations)
      * [ Nav2 RViz Panel Action Feedback Information ](../migration/Foxy.html#nav2-rviz-panel-action-feedback-information)
    * [ Galactic to Humble ](../migration/Galactic.html)
      * [ Major improvements to Smac Planners ](../migration/Galactic.html#major-improvements-to-smac-planners)
      * [ Simple (Python) Commander ](../migration/Galactic.html#simple-python-commander)
      * [ Reduce Nodes and Executors ](../migration/Galactic.html#reduce-nodes-and-executors)
      * [ API Change for nav2_core ](../migration/Galactic.html#api-change-for-nav2-core)
      * [ Extending the BtServiceNode to process Service-Results ](../migration/Galactic.html#extending-the-btservicenode-to-process-service-results)
      * [ Including new Rotation Shim Controller Plugin ](../migration/Galactic.html#including-new-rotation-shim-controller-plugin)
      * [ Spawning the robot in Gazebo ](../migration/Galactic.html#spawning-the-robot-in-gazebo)
      * [ Recovery Behavior Timeout ](../migration/Galactic.html#recovery-behavior-timeout)
      * [ New parameter ` use_final_approach_orientation  ` for the 3 2D planners ](../migration/Galactic.html#new-parameter-use-final-approach-orientation-for-the-3-2d-planners)
      * [ SmacPlanner2D and Theta*: fix goal orientation being ignored ](../migration/Galactic.html#smacplanner2d-and-theta-fix-goal-orientation-being-ignored)
      * [ SmacPlanner2D, NavFn and Theta*: fix small path corner cases ](../migration/Galactic.html#smacplanner2d-navfn-and-theta-fix-small-path-corner-cases)
      * [ Change and fix behavior of dynamic parameter change detection ](../migration/Galactic.html#change-and-fix-behavior-of-dynamic-parameter-change-detection)
      * [ Dynamic Parameters ](../migration/Galactic.html#dynamic-parameters)
      * [ BT Action Nodes Exception Changes ](../migration/Galactic.html#bt-action-nodes-exception-changes)
      * [ BT Navigator Groot Multiple Navigators ](../migration/Galactic.html#bt-navigator-groot-multiple-navigators)
      * [ Removed Kinematic Limiting in RPP ](../migration/Galactic.html#removed-kinematic-limiting-in-rpp)


Released


© Copyright 2023.


  * [ mpc_local_planner ](/mpc_local_planner?distro=melodic)
  * [ seed_r7_navigation ](/seed_r7_navigation?distro=melodic)
  * [ teb_local_planner_tu... ](/teb_local_planner_tutorials?distro=melodic)


Triggers child nodes if the new global path is significantly larger than the
old global path on approach to the goal

Control Plugin Name


` ~<name>/footprint_model/line_start ` ( ` double[2] ` , default: [-0.3, 0.0])


relative to others. We end by providing a glimpse into the future
of the ROS 2 mobile robotics ecosystem.
I. INTRODUCTION
The Robot Operating System 2 (ROS 2) was redesigned
from the ground up to meet the requirements of modern robotics research and commercial products in warehouses, urban settings, agriculture, aerospace, autonomous
driving, and more. It also provides previously missing capabilities such as security, multi-robot communications, and
embedded/real-time support. Philosophically, ROS 2 was
created as a production-grade robotics framework to serve
the growing and maturing robotics industry [1].
The transition to ROS 2 has sparked a renaissance of new
development in long-dormant project ecosystems. This new
development is holistic, comprising algorithmic refreshes,
new features, documentation, and increased maturity inspired by ROS 2’s philosophical and procedural changes.
The mobile robotics ecosystem in ROS 2 has seized this
opportunity to rethink and redesign based on the needs of
modern systems.
Nav2 is the major project within the mobile robotics
ecosystem and provides a next-generation autonomous mobile robotics navigation framework and system [2]. The
original Navigation Stack was developed at Willow Garage
for the PR2 robot and based around an unconfigurable
state machine, move base [3]. It largely supported circular
differential-drive and omnidirectional research platforms.
Nav2 was built from the ground up to leverage innovations
in behavior trees and contains refreshed algorithms. It supports all common forms of classical robots (e.g. differential,
omnidirectional) as well as newer robot platforms such as
Ackermann, large, non-circular, and quadruped robots. It
maintains production-grade quality standards with 90% unit
test coverage and seeks to re-centralize development across
academia and industry.
The Nav2 project and ROS 2’s mobile robotics ecosystem
have been developing new capabilities at a pace not seen
since the days of Willow Garage. New algorithms, features,
and behavior trees are being added on a quarterly basis
as the result of open collaborations between companies,
individuals, and academia. Over the past two years, a compelling set of new algorithms and behaviors have been made
available - some of which have no comparable capability in
other similar frameworks (ROS 1, MRPT, etc) - and have
yet to be compared in literature [4]. The introduction of
Nav2 ([2]) showcases many of these new algorithms and
behaviors working on commercial robots in highly dynamic


David Lu!!


###  Topics


* Hybrid-A* computed the path in 144ms


However, these features come at an increased compute
cost. The experiments in section VII-B suggest that fuse
could require as much as 4x the CPU of r l. As r l is fairly
lightweight, this increase is generally acceptable for the vast
majority of applications.
For those particularly resource-constrained applications,
there are a number of parameters that may be tuned to
improve compute time. Reducing the length of the smoothing
window of the fixed-lag smoother and the frequency of update can improve the performance. Further, fuse uses Google
Ceres’ automatic differentiation in many of the plugins to
compute Jacobians [50]. While this is convenient, it is not
as efficient as analytically derived Jacobians, which Ceres
also supports.
B. Comparison
To compare the two state estimation systems in ROS 2,
an experiment was designed and run on a 3.8 GHz AMD
Ryzen 5800x CPU. A mobile robot equipped with wheel
encoders, an IMU, and a laser scanner was driven along a
541-meter long route through a commercial environment to
collect a dataset, ending within 10 cm of the starting pose.
The odometry and IMU data was collected at 25 Hz. r l’s
EKF node and fuse’s fixed-lag smoother node each fused
linear and angular velocities from the wheel encoders and
angular velocities from the IMU. ROS 2’s amcl package
provides the ground-truth information (Sec. VIII-A). The
fixed lag smoothing window in fuse was set to 0.5 seconds
and the covariance was extracted from the graph at 1 Hz.
The results can be seen in Fig. 16 and Table V. At the
end of the path, the fuse estimate was 1.44 meters closer to
the ground truth position than the r l estimate, though both
estimates were well below 5.4 meters, or 1%, of the groundtruth pose. The CPU usage for fuse was approximately 3.7x
that of r l, with a slightly larger standard deviation.
VIII. OVERVIEW OF LOCALIZATION AND MAPPING
Localization is the process by which the robot determines
where it is with respect to a global frame of reference. As
opposed to state estimation, this typically occurs at a reduced
TABLE V
STATE ESTIMATORS COMPARISON
State Estimator Update Frequency (Hz) Total Distance (m) Total Error (m) Error (% Distance Traveled) CPU %
robot localization 30 542.16 4.25 0.78 1.38 ± 1.17


* Publish planner feedback containing the full trajectory and a list of active obstacles (should be enabled only for evaluation or debugging). See list of publishers above.


melodic  noetic  _Show EOL distros:_


void moveit::planning_interface::MoveGroupInterface::setWorkspace  |  (  |
double  |  _minx_ ,
---|---|---|---
|  |  double  |  _miny_ ,
|  |  double  |  _minz_ ,
|  |  double  |  _maxx_ ,
|  |  double  |  _maxy_ ,
|  |  double  |  _maxz_
|  )  |  |

Specify the workspace bounding box. The box is specified in the planning frame
(i.e. relative to the robot root link start position). This is useful when the
planning group contains the root joint of the robot – i.e. when planning
motion for the robot relative to the world.


Definition at line [ 1869 ](move__group__interface_8cpp_source.html#l01869) of
file [ move_group_interface.cpp ](move__group__interface_8cpp_source.html) .


![animation showing the arm moving relatively straight toward the
goal](../../_images/move_group_interface_tutorial_clear_path.gif)


209  const  std::vector<std::string>& getJoints()  const  ;


moveit_msgs::RobotState start_state_


Definition at line [ 1639 ](move__group__interface_8cpp_source.html#l01639) of
file [ move_group_interface.cpp ](move__group__interface_8cpp_source.html) .


_values_ MUST have one value for each variable in joint _joint_name_ .
_values_ are set as the target for this joint. Other joint targets remain
unchanged.


            default:
              RCLCPP_INFO(logger_, "Planning request unknown result code");
              return;
          }
        };
    auto goal_handle_future = move_action_client_->async_send_goal(goal, send_goal_opts);
    // wait until send_goal_opts.result_callback is called
    while (!done)
    {
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    if (code != rclcpp_action::ResultCode::SUCCEEDED)
    {
      RCLCPP_ERROR_STREAM(logger_, "MoveGroupInterface::plan() failed or timeout reached");
      return res->error_code;
    }
    plan.trajectory = res->planned_trajectory;
    plan.start_state = res->trajectory_start;
    plan.planning_time = res->planning_time;
    RCLCPP_INFO(logger_, "time taken to generate plan: %g seconds", plan.planning_time);
    return res->error_code;
  }
  moveit::core::MoveItErrorCode move(bool wait)
  {
    if (!move_action_client_ || !move_action_client_->action_server_is_ready())
    {
      RCLCPP_INFO_STREAM(logger_, "MoveGroup action client/server not ready");
      return moveit::core::MoveItErrorCode::FAILURE;
    }
    moveit_msgs::action::MoveGroup::Goal goal;
    constructGoal(goal);
    goal.planning_options.plan_only = false;
    goal.planning_options.look_around = can_look_;
    goal.planning_options.replan = can_replan_;
    goal.planning_options.replan_delay = replan_delay_;
    goal.planning_options.planning_scene_diff.is_diff = true;
    goal.planning_options.planning_scene_diff.robot_state.is_diff = true;
    bool done = false;
    rclcpp_action::ResultCode code = rclcpp_action::ResultCode::UNKNOWN;
    std::shared_ptr<moveit_msgs::action::MoveGroup_Result> res;


635  bool  setEndEffector(  const  std::string& eef_name);


(const std::string &name)
|  Remember the current joint values (of the robot being monitored) under
_name_ . These can be used by [ setNamedTarget()
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#a5262ff42a454b499d3608b384957a5e4
"Set the current joint values to be ones previously remembered by
rememberJointValues\(\) or...") . These values are remembered locally in the
client. Other clients will not have access to them.  More...

void  |  [ rememberJointValues
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#add21f181b93fab2a50b52014dc3551e7)
(const std::string &name, const std::vector< double > & [ values
](../../../api/tf2/html/cache__unittest_8cpp.html#a2ad192c64ff93c02f9f41c320e7aa1bc)
)
|  Remember the specified joint values under _name_ . These can be used by [
setNamedTarget()
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#a5262ff42a454b499d3608b384957a5e4
"Set the current joint values to be ones previously remembered by
rememberJointValues\(\) or...") . These values are remembered locally in the
client. Other clients will not have access to them.  More...

const std::map< std::string, std::vector< double > > & |  [
getRememberedJointValues
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#a7da7361401c0810970a6b69105c5ee01)
() const
|  Get the currently remembered map of names to joint values.  More...

void  |  [ forgetJointValues
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#ad0e6c9229684e8f172dc40c3df038d17)
(const std::string &name)
|  Forget the joint values remebered under _name_ .  More...

Manage planning constraints

void  |  [ setConstraintsDatabase
](classmoveit_1_1planning__interface_1_1MoveGroupInterface.html#acf351f6c3bb8730c76bdc4f624fc3ea2)
(const std::string &host, unsigned int port)
|  Specify where the database server that holds known constraints resides.
More...


Definition at line [ 128 ](move__group__interface_8h_source.html#l00128) of
file [ move_group_interface.h ](move__group__interface_8h_source.html) .


This is the latest (and last) version of MoveIt 1 for ROS Noetic, which is
still actively developed. See also [ MoveIt 2 tutorials
](https://moveit.picknik.ai/) and other available versions in drop down box on
left.


Options(const std::string &group_name, const std::string
&desc=ROBOT_DESCRIPTION, const ros::NodeHandle &node_handle=ros::NodeHandle())


After this call, the JointValueTarget is used **instead** of any previously
set Position, Orientation, or Pose targets.


Definition at line [ 2195 ](move__group__interface_8cpp_source.html#l02195) of
file [ move_group_interface.cpp ](move__group__interface_8cpp_source.html) .


Definition at line [ 1719 ](move__group__interface_8cpp_source.html#l01719) of
file [ move_group_interface.cpp ](move__group__interface_8cpp_source.html) .


robot_model::RobotModelConstPtr
moveit::planning_interface::MoveGroupInterface::getRobotModel  |  (  |  |  )
|  const
---|---|---|---|---

Get the RobotModel object.


125  [ MOVEIT_STRUCT_FORWARD
](../../../api/moveit_core/html/namespacecollision__detection.html#a1cb8da8467ea8e22af94de00c401e975)
( [ Plan
](structmoveit_1_1planning__interface_1_1MoveGroupInterface_1_1Plan.html) );


[ 120
](structmoveit_1_1planning__interface_1_1MoveGroupInterface_1_1Options.html#a2e72f8b0daa9a9f7067648c9eca24b15)
robot_model::RobotModelConstPtr [ robot_model_
](structmoveit_1_1planning__interface_1_1MoveGroupInterface_1_1Options.html#a2e72f8b0daa9a9f7067648c9eca24b15)
;


Parameters


    object_to_attach.primitives.push_back(cylinder_primitive);
    object_to_attach.primitive_poses.push_back(grab_pose);
    object_to_attach.operation = object_to_attach.ADD;
    planning_scene_interface.applyCollisionObject(object_to_attach);


Definition at line [ 2246 ](move__group__interface_8cpp_source.html#l02246) of
file [ move_group_interface.cpp ](move__group__interface_8cpp_source.html) .