Nav2

https://docs.nav2.org/latest/
Admin
Nav2 is a production-grade navigation framework for mobile and surface robotics that provides...
Tokens:17,475
Snippets:231
Trust Score:7.4
Update:7 months ago
Show doc for...
Tokens:
Raw
### Launch Navigation2 Stack

Source: https://docs.nav2.org

This snippet demonstrates how to launch the core Navigation2 stack, typically used for basic robot navigation tasks. It assumes necessary ROS 2 and Navigation2 packages are installed.

```python
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='nav2_bringup',
            executable='nav2_bringup_launch.py',
            name='nav2_bringup',
            output='screen',
            parameters=[{'use_sim_time': True}]
        )
    ])
```

--------------------------------

### Nav2 Planner Server Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML snippet shows parameters for the Nav2 Planner Server. It includes the `planner_plugins` list, specifying the global planner to use, and parameters for the default `SmacPlanner2D`, such as `analytic_expansion`, `motion_model`, and `smooth_path`. This allows customization of the global path planning algorithm.

```yaml
planner_server:
  ros__parameters:
    planner_plugins: ["SmacPlanner2D"]
    SmacPlanner2D:
      analytic_expansion: true
      motion_model: "# Use "" for default
      smooth_path: true
      # ... other SmacPlanner2D parameters
    # ... other planner server parameters

```

--------------------------------

### Nav2 Smoother Server Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML snippet shows parameters for the Nav2 Smoother Server. It includes settings for the `smoother_server_parameters`, such as `frequency` and `max_smoothing_iterations`. This allows for fine-tuning the path smoothing algorithm to improve navigation efficiency and comfort.

```yaml
smoother_server:
  ros__parameters:
    smoother_server_parameters:
      frequency: 10.0
      max_smoothing_iterations: 10
      # ... other smoother parameters

```

--------------------------------

### Nav2 Behavior Server Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML snippet illustrates common parameters for the Nav2 Behavior Server. It includes settings for the behavior tree navigator, default plugins, and specific parameters for behaviors like `Spin` and `BackUp`. This configuration allows customization of the robot's autonomous navigation behaviors.

```yaml
behavior_server:
  ros__parameters:
    bt_navigator:
      behavior_tree_xml_file_name: "navigate_w_replanning_and_recovery.xml"
      plugins: "['FollowPath', 'ComputePathToPose', 'ComputePathThroughPoses', 'RateController', 'VoxelGrid', 'SpeedSmoother', 'PathReviser', 'BackUp', 'Spin', 'Wait', 'ClearCostmapService', 'LoadMap', 'SaveMap', 'SendPoseService', 'SendPathService', 'GetMapROI', 'GetPathArea', 'GetPathCells', 'GetPathCellsInRadius', 'GetPathCellsInPolygon', 'GetPathCellsInGrid', 'GetPathCellsInGridArea', 'GetPathCellsInGridPolygon', 'GetPathCellsInGridRadius', 'GetPathCellsInGridPolygonRadius', 'GetPathCellsInGridPolygonRadiusArea', 'GetPathCellsInGridPolygonRadiusAreaGrid', 'GetPathCellsInGridPolygonRadiusAreaGridCells', 'GetPathCellsInGridPolygonRadiusAreaGridCellsCells', 'GetPathCellsInGridPolygonRadiusAreaGridCellsCellsCells', 'GetPathCellsInGridPolygonRadiusAreaGridCellsCellsCellsCells', 'GetPathCellsInGridPolygonRadiusAreaGridCellsCellsCellsCellsCells', 'GetPathCellsInGridPolygonRadiusAreaGridCellsCellsCellsCellsCellsCells']"
      # ... other bt_navigator parameters
    spin_behavior:
      # Parameters for the Spin behavior
      spin_duration: 2.0
      # ...
    backup_behavior:
      # Parameters for the BackUp behavior
      backup_dist: 0.3
      # ...

```

--------------------------------

### Nav2 Controller Server Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML snippet details parameters for the Nav2 Controller Server. It includes the `controller_plugins` list, specifying which controller to use, and parameters for the default `FollowPath` controller, such as `xy_goal_tolerance` and `state_transition_wait_time`. This allows customization of the robot's local motion control.

```yaml
controller_server:
  ros__parameters:
    controller_plugins: ["FollowPath"]
    FollowPath:
      xy_goal_tolerance: 0.2
      yaw_goal_tolerance: 0.2
      state_transition_wait_time: 2.0
      # ... other FollowPath parameters
    # ... other controller server parameters

```

--------------------------------

### Nav2 Behavior Tree Navigator Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML configuration shows parameters for the Nav2 Behavior Tree Navigator. It includes settings for `NavigateToPose` and `NavigateThroughPoses` actions, defining parameters like `goal_x`, `goal_y`, and `goal_yaw`. This allows for precise control over navigation goals.

```yaml
behavior_server:
  ros__parameters:
    bt_navigator:
      # ... other parameters
      navigate_to_pose:
        # Parameters for NavigateToPose action
        goal_x: 1.0
        goal_y: 2.0
        goal_yaw: 0.0
        # ...
      navigate_through_poses:
        # Parameters for NavigateThroughPoses action
        poses: [] # List of poses
        # ...

```

--------------------------------

### Nav2 Route Server Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML configuration details parameters for the Nav2 Route Server. It includes settings for `server_parameters`, `edge_scorer_parameters`, and `route_operations_parameters`. This allows customization of how routes are generated, scored, and managed for navigation.

```yaml
route_server:
  ros__parameters:
    server_parameters:
      # Parameters for the route server itself
      # ...
    edge_scorer_parameters:
      # Parameters for scoring edges in the route graph
      # ...
    route_operations_parameters:
      # Parameters for route operations like finding and optimizing routes
      # ...

```

--------------------------------

### Initialize Turtlebot 3 Location (ROS)

Source: https://docs.nav2.org

Initializes the starting pose of the Turtlebot 3 robot in the navigation environment. This is a critical step before sending navigation goals.

```shell
ros2 topic pub --once /initialpose geometry_msgs/msg/PoseWithCovarianceStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {pose: {position: {x: 0.0, y: 0.0, z: 0.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}, covariance: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}}"
```

--------------------------------

### Nav2 Costmap2D ROS Parameters Example (YAML)

Source: https://docs.nav2.org

This YAML configuration outlines ROS parameters for the Nav2 Costmap2D node. It includes settings for the global and local costmaps, such as `resolution`, `map_update_frequency`, and `publish_frequency`. It also lists plugins for inflation, obstacle, and static layers, allowing customization of the robot's environment representation.

```yaml
costmap_2d:
  ros__parameters:
    global_frame: "map"
    robot_base_frame: "base_link"
    update_frequency: 5.0
    publish_frequency: 10.0
    resolution: 0.05
    plugins:
      - name: "obstacle_layer"
        type: "nav2_costmap_2d::ObstacleLayer"
      - name: "inflation_layer"
        type: "nav2_costmap_2d::InflationLayer"
    # ... other costmap2d parameters

```

--------------------------------

### Launch Nav2 (ROS)

Source: https://docs.nav2.org

Launches the Nav2 navigation stack for ROS 2. This command typically starts the necessary nodes for localization, planning, and control.

```shell
ros2 launch nav2_bringup navigation_launch.py
```

--------------------------------

### Get Backtrace from Nav2 Bringup

Source: https://docs.nav2.org

This snippet shows how to obtain a backtrace from the Nav2 bringup process, which is useful for debugging crashes. This typically involves specific launch file configurations or command-line arguments.

```python
from launch import LaunchDescription
from launch.actions import ExecuteProcess

def generate_launch_description():
    return LaunchDescription([
        ExecuteProcess(
            cmd=['gdb', '--args', 'ros2', 'launch', 'nav2_bringup', 'nav2_bringup_launch.py'],
            output='screen'
        )
    ])
```

--------------------------------

### Pass Behavior Plugin Name via Params File (YAML)

Source: https://docs.nav2.org

This example demonstrates how to configure Nav2 to use a custom behavior plugin by specifying its name in a ROS 2 parameter file (YAML format). This allows the behavior tree to load and execute the 'MyBehaviorPlugin' when needed, without modifying the core Nav2 launch files.

```yaml
behavior_server:
  ros__parameters:
    # ... other parameters
    bt_navigator:
      plugins: "['MyBehaviorPlugin']"
      # ... other bt_navigator parameters

```

--------------------------------

### Static Transform Publisher Demo (ROS)

Source: https://docs.nav2.org

Demonstrates how to use the static transform publisher in ROS to broadcast a fixed transformation between two coordinate frames. This is crucial for setting up robot kinematics and sensor data.

```shell
ros2 run tf2_ros static_transform_publisher 0 0 0 0 0 0 frame_id child_frame_id
```

--------------------------------

### Modify Navigation2 Parameter for STVL

Source: https://docs.nav2.org

This snippet illustrates modifying a Navigation2 parameter, likely related to costmap configuration or plugin loading, when integrating the STVL (Spatial-Temporal Vision Library) for external costmap plugins. Ensure STVL is correctly installed and accessible.

```yaml
local_costmap:
  plugins:
    - name: "obstacle_layer"
      type: "costmap_2d::ObstacleLayer"
    - name: "voxel_layer"
      type: "costmap_2d::VoxelLayer"
    - name: "stvl_layer"
      type: "stvl_costmap_plugin::STVLPlugin"
      enabled: true
      # STVL specific parameters here...
```

--------------------------------

### Create a New Planner Plugin in C++

Source: https://docs.nav2.org

This snippet provides the basic structure for creating a custom planner plugin for Nav2 using C++. It involves inheriting from `nav2_smac_planner::SmacPlanner2D` or a similar base class and implementing the `createPlan` method. This allows for custom global path planning algorithms.

```cpp
#include "nav2_smac_planner/smac_planner_2d.hpp"

namespace my_nav2_plugins {

class MyPlannerPlugin : public nav2_smac_planner::SmacPlanner2D
{
public:
  MyPlannerPlugin() = default;
  virtual ~MyPlannerPlugin() = default;

  bool createPlan(const geometry_msgs::msg::PoseStamped& start, const geometry_msgs::msg::PoseStamped& goal, std::vector<geometry_msgs::msg::PoseStamped>& plan) override;

private:
  // Plugin specific members
};

bool MyPlannerPlugin::createPlan(const geometry_msgs::msg::PoseStamped& start, const geometry_msgs::msg::PoseStamped& goal, std::vector<geometry_msgs::msg::PoseStamped>& plan)
{
  // Implementation of the custom planner logic
  // Call parent class methods or implement custom logic
  return SmacPlanner2D::createPlan(start, goal, plan);
}

}  // namespace my_nav2_plugins

```

--------------------------------

### Create a New Behavior Tree Plugin in C++

Source: https://docs.nav2.org

This snippet outlines the creation of a custom behavior tree plugin for Nav2. It includes the necessary headers, class definition inheriting from `BT::SyncActionNode`, and placeholder methods for initialization and execution. This enables the development of custom nodes that can be integrated into Nav2's behavior trees.

```cpp
#include "behaviortree_cpp_v3/action_node.h"

namespace my_nav2_plugins {

class MyBehaviorTreePlugin : public BT::SyncActionNode
{
public:
  MyBehaviorTreePlugin(
    const std::string& name,
    const BT::NodeConfiguration& config) : BT::SyncActionNode(name, config)
  {}

  static BT::PortsList providedPorts()
  {
    return {
      BT::Input("target_point", "geometry_msgs::msg::Point")
    };
  }

  BT::NodeStatus tick() override
  {
    // Implementation of the behavior tree node logic
    // Access input ports like: auto target_point = getInput<geometry_msgs::msg::Point>("target_point");
    return BT::NodeStatus::SUCCESS;
  }
};

}  // namespace my_nav2_plugins

```

--------------------------------

### Profile Nav2 Bringup

Source: https://docs.nav2.org

This snippet outlines how to profile the Nav2 bringup process to identify performance bottlenecks. This often involves using profiling tools integrated with ROS 2 or the underlying system.

```shell
ros2 launch nav2_bringup nav2_bringup_launch.py --ros-args -p profiling:=true
```

--------------------------------

### Export a Planner Plugin for Nav2

Source: https://docs.nav2.org

This code demonstrates how to export a custom planner plugin as a shared library (`.so` file). This allows the Nav2 planner server to load and use the custom planner for generating global paths.

```cpp
#include "my_nav2_plugins/my_planner_plugin.hpp"
#include "pluginlib/class_list_macros.hpp"

// Export the plugin
PLUGINLIB_EXPORT_CLASS(my_nav2_plugins::MyPlannerPlugin, nav2_core::GlobalPlanner)

```

--------------------------------

### Create a New Controller Plugin in C++

Source: https://docs.nav2.org

This snippet provides the basic structure for creating a custom controller plugin for Nav2 using C++. It includes inheriting from `nav2_controller::Controller`, defining necessary methods like `setPlan`, `computeVelocityCommands`, and `isGoalReached`. This allows for the implementation of custom motion control algorithms.

```cpp
#include "nav2_controller/controller_plugin.hpp"
#include "nav2_util/robot_utils.hpp"

namespace my_nav2_plugins {

class MyControllerPlugin : public nav2_controller::Controller
{
public:
  void setPlan(const nav2_msgs::msg::Path::SharedPtr path) override;
  geometry_msgs::msg::TwistStamped computeVelocityCommands(geometry_msgs::msg::PoseStamped pose, geometry_msgs::msg::TwistStamped twist) override;
  bool isGoalReached() override;

private:
  // Plugin specific members
};

void MyControllerPlugin::setPlan(const nav2_msgs::msg::Path::SharedPtr path)
{
  // Implementation to set the global plan
}

geometry_msgs::msg::TwistStamped MyControllerPlugin::computeVelocityCommands(geometry_msgs::msg::PoseStamped pose, geometry_msgs::msg::TwistStamped twist)
{
  // Implementation to compute velocity commands based on the current pose and twist
  geometry_msgs::msg::TwistStamped cmd;
  return cmd;
}

bool MyControllerPlugin::isGoalReached()
{
  // Implementation to check if the goal has been reached
  return false;
}

}  // namespace my_nav2_plugins

```

--------------------------------

### Create a New Navigator Plugin in C++

Source: https://docs.nav2.org

This snippet outlines the structure for creating a custom navigator plugin for Nav2. It involves inheriting from `nav2_navfn_planner::NavFnPlanner` or a similar base class and implementing the necessary navigation logic. This allows for custom path planning algorithms to be integrated.

```cpp
#include "nav2_navfn_planner/navfn_planner.hpp"

namespace my_nav2_plugins {

class MyNavigatorPlugin : public nav2_navfn_planner::NavFnPlanner
{
public:
  MyNavigatorPlugin() = default;
  virtual ~MyNavigatorPlugin() = default;

  bool createPlan(const geometry_msgs::msg::PoseStamped& start, const geometry_msgs::msg::PoseStamped& goal, std::vector<geometry_msgs::msg::PoseStamped>& plan) override;

private:
  // Plugin specific members
};

bool MyNavigatorPlugin::createPlan(const geometry_msgs::msg::PoseStamped& start, const geometry_msgs::msg::PoseStamped& goal, std::vector<geometry_msgs::msg::PoseStamped>& plan)
{
  // Implementation of the custom path planning algorithm
  // Call parent class methods or implement custom logic
  return NavFnPlanner::createPlan(start, goal, plan);
}

}  // namespace my_nav2_plugins

```

--------------------------------

### Create a New Behavior Plugin in C++

Source: https://docs.nav2.org

This snippet demonstrates the basic structure for creating a new behavior plugin for Nav2 using C++. It includes the necessary includes, class definition inheriting from `nav2_behavior_tree::BehaviorTreeNodes`, and placeholder methods for initialization and execution. This allows for custom navigation behaviors to be integrated into the Nav2 stack.

```cpp
#include "nav2_behavior_tree/bt_action.hpp"
#include "behaviortree_cpp_v3/behavior_tree.h"

namespace my_nav2_plugins {

class MyBehaviorPlugin : public nav2_behavior_tree::BehaviorTreeNodes
{
public:
  MyBehaviorPlugin(
    const std::string& name,
    const BT::NodeConfiguration& config) : BehaviorTreeNodes(name, config)
  {}

  static BT::PortsList providedPorts()
  {
    return {
      BT::Input("target_pose", "geometry_msgs::msg::PoseStamped")
    };
  }

  BT::NodeStatus tick() override
  {
    // Implementation of the behavior logic
    // Access input ports like: auto target_pose = getInput<geometry_msgs::msg::PoseStamped>("target_pose");
    return BT::NodeStatus::SUCCESS;
  }
};

}  // namespace my_nav2_plugins

```

--------------------------------

### Launch RViz (ROS)

Source: https://docs.nav2.org

Launches RViz, a 3D visualization tool for ROS. It's commonly used to visualize robot models, sensor data, and navigation paths.

```shell
ros2 launch rviz2 rviz2.launch.py
```

--------------------------------

### Export a Navigator Plugin for Nav2

Source: https://docs.nav2.org

This code demonstrates how to export a custom navigator plugin as a shared library (`.so` file). This allows the Nav2 navigation server to load and utilize the custom planner, enabling custom path planning strategies.

```cpp
#include "my_nav2_plugins/my_navigator_plugin.hpp"
#include "pluginlib/class_list_macros.hpp"

// Export the plugin
PLUGINLIB_EXPORT_CLASS(my_nav2_plugins::MyNavigatorPlugin, nav2_core::GlobalPlanner)

```

--------------------------------

### Pass Planner Plugin Name via Params File (YAML)

Source: https://docs.nav2.org

This YAML configuration shows how to specify a custom planner plugin for the Nav2 planner server. By listing the plugin's class ID, Nav2 can load and use the custom planner for generating global navigation paths.

```yaml
planner_server:
  ros__parameters:
    planner_plugins: ["my_nav2_plugins/MyPlannerPlugin"]
    # ... other planner server parameters

```

--------------------------------

### Export a Controller Plugin for Nav2

Source: https://docs.nav2.org

This code demonstrates how to export a custom controller plugin as a shared library (`.so` file) for Nav2. This involves creating a plugin library that can be loaded by the controller server, allowing Nav2 to use the custom controller for motion planning.

```cpp
#include "my_nav2_plugins/my_controller_plugin.hpp"
#include "pluginlib/class_list_macros.hpp"

// Export the plugin
PLUGINLIB_EXPORT_CLASS(my_nav2_plugins::MyControllerPlugin, nav2_controller::Controller)

```

--------------------------------

### Important Docker Commands for Development

Source: https://docs.nav2.org

This snippet lists essential Docker commands for development workflows, particularly relevant for ROS 2 and Navigation2 development. These commands cover building images, running containers, and managing Docker resources.

```shell
# Build a Docker image
docker build -t my-ros-image .

# Run a Docker container
docker run -it --rm -v /path/to/your/code:/ros2_ws/src my-ros-image bash

# List running containers
docker ps

# Stop a container
docker stop <container_id>
```

--------------------------------

### Pass Navigator Plugin Name via Params File (YAML)

Source: https://docs.nav2.org

This YAML configuration shows how to specify a custom navigator plugin for the Nav2 planner server. By listing the plugin's class ID, Nav2 can load and use the custom planner for generating navigation paths.

```yaml
planner_server:
  ros__parameters:
    planner_plugins: ["my_nav2_plugins/MyNavigatorPlugin"]
    # ... other planner server parameters

```

--------------------------------

### Write a New Costmap2D Plugin in C++

Source: https://docs.nav2.org

This snippet shows the basic structure for creating a custom Costmap2D plugin in C++. It involves inheriting from `nav2_costmap_2d::Layer` and implementing methods like `onInitialize`, `updateBounds`, and `updateCosts`. This allows for custom costmap layers, such as gradient-based layers, to be added.

```cpp
#include "nav2_costmap_2d/layer.hpp"
#include "nav2_costmap_2d/costmap_layer.hpp"

namespace my_nav2_plugins {

class MyCostmapPlugin : public nav2_costmap_2d::CostmapLayer
{
public:
  virtual ~MyCostmapPlugin() = default;

  virtual void onInitialize() override;
  virtual void updateBounds(double robot_x, double robot_y, double robot_yaw, double* min_x, double* min_y, double* max_x, double* max_y) override;
  virtual void updateCosts(nav2_costmap_2d::Costmap2D& master_grid, double robot_x, double robot_y, double robot_yaw) override;

private:
  // Plugin specific members
};

void MyCostmapPlugin::onInitialize()
{
  // Initialize plugin parameters and resources
  CostmapLayer::onInitialize();
}

void MyCostmapPlugin::updateBounds(double robot_x, double robot_y, double robot_yaw, double* min_x, double* min_y, double* max_x, double* max_y)
{
  // Update the bounds of the costmap layer
  // Use matchSize(); to ensure the layer matches the master_grid size
  matchSize();
  // ... update bounds logic ...
}

void MyCostmapPlugin::updateCosts(nav2_costmap_2d::Costmap2D& master_grid, double robot_x, double robot_y, double robot_yaw)
{
  // Update the costmap with new cost values
  // ... update costs logic ...
}

}  // namespace my_nav2_plugins

```

--------------------------------

### Enable Costmap2D Plugin in Costmap2D Configuration (YAML)

Source: https://docs.nav2.org

This YAML configuration shows how to enable a custom Costmap2D plugin. By listing the plugin's class ID in the `plugins` list of the costmap2D node's parameters, Nav2 will load and use the custom layer for generating costmaps.

```yaml
costmap_2d:
  ros__parameters:
    plugins:
      - name: "my_costmap_plugin"
        type: "my_nav2_plugins::MyCostmapPlugin"
    # ... other costmap2d parameters

```

--------------------------------

### Launch Turtlebot 3 (ROS)

Source: https://docs.nav2.org

Launches the Turtlebot 3 robot simulation or hardware interface using ROS. This typically involves setting up robot-specific launch files and configurations.

```shell
ros2 launch turtlebot3_bringup minimal.launch.py
```

--------------------------------

### Export a Behavior Tree Plugin Library for Nav2

Source: https://docs.nav2.org

This code demonstrates how to export a custom behavior tree plugin, making it available for Nav2 to load. It involves creating a shared library (`.so` file) and registering the plugin class with the Behavior Tree factory. This allows the custom node to be used within Nav2's behavior trees.

```cpp
#include "my_nav2_plugins/my_behavior_tree_plugin.hpp"
#include "behaviortree_cpp_v3/bt_factory.h"

// Register the plugin with the Behavior Tree factory
BT_REGISTER_NODES(factory)
{
  factory.registerNodeType<my_nav2_plugins::MyBehaviorTreePlugin>("MyBehaviorTreePlugin");
}

```

--------------------------------

### Export a Behavior Plugin for Nav2

Source: https://docs.nav2.org

This snippet shows how to export a custom behavior plugin so that Nav2 can discover and load it. It involves creating a shared library (`.so` file) and ensuring the plugin class is registered. This allows the behavior tree to instantiate and use the custom plugin during navigation.

```cpp
#include "my_nav2_plugins/my_behavior_plugin.hpp"
#include "behaviortree_cpp_v3/bt_factory.h"

// Register the plugin with the Behavior Tree factory
BT_REGISTER_NODES(factory)
{
  factory.registerNodeType<my_nav2_plugins::MyBehaviorPlugin>("MyBehaviorPlugin");
}

```

--------------------------------

### Enable Denoise Layer for Obstacle Filtering

Source: https://docs.nav2.org

This snippet demonstrates enabling the Denoise Layer in Navigation2 to filter out noise-induced obstacles from sensor data. This helps in creating a cleaner costmap for more reliable navigation.

```yaml
local_costmap:
  plugins:
    - name: "obstacle_layer"
      type: "costmap_2d::ObstacleLayer"
    - name: "denoise_layer"
      type: "costmap_2d::DenoiseLayer"
      enabled: true
      noise_threshold: 0.1
      min_obstacle_height: 0.05
```

--------------------------------

### Export and Make GradientLayer Plugin

Source: https://docs.nav2.org

This snippet shows how to export a custom Costmap2D plugin, such as a 'GradientLayer', as a shared library (`.so` file). This makes the plugin discoverable by the costmap2D node, allowing it to be loaded and integrated into the navigation stack.

```cpp
#include "my_nav2_plugins/my_costmap_plugin.hpp"
#include "pluginlib/class_list_macros.hpp"

// Export the plugin
PLUGINLIB_EXPORT_CLASS(my_nav2_plugins::MyCostmapPlugin, nav2_costmap_2d::Layer)

```

--------------------------------

### Pass Controller Plugin Name via Params File (YAML)

Source: https://docs.nav2.org

This YAML snippet illustrates how to configure Nav2 to use a custom controller plugin. By specifying the plugin name in the controller server's parameters, Nav2 can load and utilize the custom controller for generating velocity commands.

```yaml
controller_server:
  ros__parameters:
    controller_plugins: ["my_nav2_plugins/MyControllerPlugin"]
    # ... other parameters

```

--------------------------------

### Send a Goal Pose (ROS)

Source: https://docs.nav2.org

Sends a navigation goal pose to the Nav2 stack. This command instructs the robot to navigate to the specified position and orientation.

```shell
ros2 topic pub --once /goal_pose geometry_msgs/msg/PoseStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {position: {x: 1.0, y: 1.0, z: 0.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}"
```

--------------------------------

### Configure Navigation2 with Semantic Segmentation Layer

Source: https://docs.nav2.org

This snippet shows how to configure the Navigation2 costmap to include a semantic segmentation layer. This allows the robot to navigate based on semantic understanding of the environment, requiring a semantic segmentation inference node and specific Nav2 parameters.

```yaml
plugins:
  - name: semantic_segmentation
    type: semantic_segmentation_layer::SemanticSegmentationLayer
    enabled: true
    cost_scaling_factor: 10.0
    semantic_classes:
      - "car"
      - "person"
    obstacle_layer:
      enabled: true
      max_obstacle_height: 2.0
      track_unknown_space: true
```
Tokens:
Raw