Skip to content

About

No description, website, or topics provided.

Resources

Stars

49 stars

Watchers

0 watching

Forks

Repository files navigation

Odin Navigation Stack 2 (ONS2)

Manifold Tech        ASTRALL Dynamics

English | 中文

Note

This repository is under active development. Please refer to the latest code!

Odin1 is a high-performance spatial sensing module that delivers high-precision 3D mapping, robust relocalization, and rich sensory streams including RGB images, depth, IMU, odometry, and dense point clouds. ONS2 builds on Odin1 to provide an autonomous patrol navigation stack for ground platforms, enabling:

  • Multi-waypoint autonomous patrol with dynamic obstacle avoidance and remote monitoring
  • Natural-language control and Vision-Language Model (VLM) scene understanding
  • Dual runtime: the same codebase runs on ROS1 Noetic and ROS2 Jazzy

ONS2 System Architecture Overview

1. Overview

1.1 Key Features

  • High-Accuracy SLAM & Persistent Relocalization (inside Odin1, not open-sourced)
    Real-time mapping with long-term relocalization using compact binary maps.
  • Dynamic Obstacle-Aware Navigation (fully open-sourced)
    Global A* planning with a memory of blind-spot obstacles (sliding_map), combined with the NeuPAN local planner for safe motion in cluttered environments.
  • Mission Management (fully open-sourced)
    Multi-waypoint missions with pause, resume, cancel, return-home, final alignment, per-waypoint dwell, and a remote monitoring console.
  • VLM-based perception (fully open-sourced)
    Plug in your own vision-language model to run custom object checks and scene question answering. See Odin-perception.
  • Dual Runtime, Shared Core
    ros_ws/ (ROS1 Noetic) and ros2_ws/ (ROS2 Jazzy) share the planner core, the topic / service / action names, and the configuration profiles.

1.2 What's New

  • Dramatically faster planning
    Plans substantially faster even on low-compute platforms, with smoother execution and nimbler obstacle avoidance.
    See the NeuPAN optimisation notes for what was changed and the measured gains.
  • Upgraded VLM, bring your own model
    Connect a more capable vision-language model to your own workstation for richer scene understanding.
    See the Odin-perception tutorial for web links and documentation.
  • Built for industrial inspection
    Extensive optimizations tuned to real industrial inspection scenarios and long patrol routes.
    See the remote web monitor (ASTRALL SW01 + ROS 2 only) — browser-based control console with on-demand camera and intercom (requires your own 4G module, NAT traversal or a public server).
  • End-to-end, fully open source
    A complete inspection workflow — simulation to real robots, algorithms to the monitoring platform, real world to simulated world. See the Real2Sim tutorial.
  • Odin RTK fusion navigation
    Configure Odin with RTK in minutes to get full latitude/longitude-based navigation and open up further use cases.
  • Plugin architecture
    The stack is built around a plugin-based design, making it straightforward to integrate custom planners.
  • More on the way
    Further capabilities will land in upcoming releases.

1.3 Related Work

2. Supported Platforms

Robot Runtime Status
ASTRALL SW01 ROS1 Noetic / ROS2 Jazzy Supported (scripts/ons2_sw01.sh, profile robots/sw01/), extensively validated and tuned
Unitree Go2 ROS1 Noetic Supported (scripts/ons2_go2.sh, profile robots/go2/)
Dobot Lumo ROS1 Noetic Supported (scripts/ons2_dobot_lumo.sh, profile robots/dobot_lumo/, defaults to dry_run=true)
Your own robot ROS1 or ROS2 Copy robots/_template/; see 03 · Integrate Your Own Robot

Unitree Go2 is supported by the ROS1 stack only.

3. Local Planner: NeuPAN or SRU

Note

The SRU training code is already published. SRU integrated into the navigation stack will be released soon. Please stay tuned!

By default the stack uses NeuPAN on a global A* path. ONS2 can also replace NeuPAN with the SRU end-to-end policy, which maps the depth image and the goal directly to velocity commands.

NeuPAN (default) SRU (experimental)
Global planning Yes (A*, map_planner) No
Obstacle input /scan_360 from sliding_map Odin1 depth image
Output /cmd_vel /sru/cmd_vel (5 Hz, body frame), passed to /cmd_vel through a motion gate
Model Analytic: no training for a new chassis ONNX policy: must be trained for your robot
Select with Default --local-planner=sru

3.1 Running NeuPAN

NeuPAN is the default local planner (--local-planner=neupan) and requires no neural-network training for new robot footprints:

  • Unitree Go2 (ROS1):
    bash scripts/ons2_go2.sh --map=NAME
  • ASTRALL SW01 (ROS2 or ROS1):
    # ROS2 (default)
    bash scripts/ons2_sw01.sh --map=NAME
    
    # ROS1
    bash scripts/ons2_sw01.sh --ros1 --map=NAME
  • Dobot Lumo (ROS1):
    bash scripts/ons2_dobot_lumo.sh --map=NAME

--map=NAME (e.g., --map=parkinglot) selects your map triplet (NAME.yaml, NAME.pgm, and customer_file/NAME.bin). For how to build, convert, and place these map files (via Q9000 or Odin1), see the Map Building & Processing Guide.

For parameter tuning (speed, footprint, safety clearance, stuck escape), see 02 · Parameter Tuning.

3.2 Running SRU

SRU requires training. Obtain the locomotion controller from your robot's manufacturer — it is not provided by us. The trained ONNX models (policy and VAE encoder) are not included in this repository. Train the policy in the SRU repository, then deploy the exported models to the SRU workspace on the robot:

ManifoldTechLtd/SRU-Odin — training (Train/), deployment (Deployment/), and the porting guide.

In SRU mode the stack does not plan a global path. It sends each waypoint to SRU in the odom frame, and arrival is judged by odometry distance (sru_arrive_threshold_m in nav_params.yaml, 0.7 m by default). Route segmentation, periodic replanning, recovery, and the hot path are disabled.

Pass --local-planner=sru to any platform launcher to switch from NeuPAN to the SRU policy:

  • Unitree Go2 (ROS1):
    export SRU_WS=/path/to/sru_ros1_workspace
    bash scripts/ons2_go2.sh --local-planner=sru --map=NAME
    # Optional: select a specific policy file with --sru-policy=FILE
  • ASTRALL SW01 (ROS2 or ROS1):
    # ROS2 (default)
    export SRU_WS_ROS2=/path/to/sru_ros2_workspace
    bash scripts/ons2_sw01.sh --local-planner=sru --map=NAME
    
    # ROS1
    export SRU_WS=/path/to/sru_ros1_workspace
    bash scripts/ons2_sw01.sh --ros1 --local-planner=sru --map=NAME
  • Dobot Lumo (ROS1):
    export SRU_WS=/path/to/sru_ros1_workspace
    bash scripts/ons2_dobot_lumo.sh --local-planner=sru --map=NAME

Common notes:

  • On ROS2, the launcher starts the SRU policy node and velocity relay via ros2_ws/scripts/sru/start_sru_ros2.sh and ros2_ws/scripts/sru/sru_cmd_vel_relay.py (models default to $SRU_WS_ROS2/Deployment/models, overridable via SRU_MODELS_DIR).
  • On ROS1, the SRU helper defaults to sru_nav_go2_ros1; set SRU_PKG and SRU_LAUNCH (or configure planner.local in robots/<robot>/robot.yaml) to point to your robot's SRU package and launch file.
  • --navigation-mode has no effect in SRU mode.
  • SRU outputs a body-frame Twist, so any robot with a /cmd_vel bridge can use it. See 03 · Integrate Your Own Robot.

4. Installation and Build

Both runtimes share the same clone step and the same Odin1 USB rule. Then follow one runtime section below.

4.1 Common Steps

4.1.1 Clone the Repository

git clone --recursive https://github.com/ManifoldTechLtd/Odin-Nav-Stack2.git
cd Odin-Nav-Stack2

If you cloned without --recursive:

git submodule update --init ros_ws/src/odin_ros_driver    # ROS1 Odin1 driver (submodule)
git submodule update --init ros2_ws/src/odin_ros_driver   # ROS2 Odin1 driver (submodule)
git submodule update --init yolov5                        # optional: object detection
git submodule update --init odin_rtk_fusion               # optional: RTK input

Both ros_ws/src/odin_ros_driver and ros2_ws/src/odin_ros_driver are submodules pointing to manifoldsdk/odin_ros_driver.

4.1.2 Odin1 USB Rule

For details, see the Odin1 Ubuntu Quick Start — Create udev rules:

sudo vim /etc/udev/rules.d/99-odin-usb.rules

Add this line, then reload the rules and reinsert the device:

SUBSYSTEM=="usb", ATTR{idVendor}=="2207", ATTR{idProduct}=="0019", MODE="0666", GROUP="plugdev"
sudo udevadm control --reload && sudo udevadm trigger

4.2 ROS1 Noetic (Ubuntu 20.04)

Both ROS1 and ROS2 use the NeuPAN local planner by default (NeuPAN/ requires Python ≥ 3.10). Because Ubuntu 20.04 ships with system Python 3.8, create a Python 3.10 conda environment for NeuPAN while building the ROS1 C++ packages against your system ROS Noetic installation.

4.2.1 Install

  1. System ROS1 dependencies:

    sudo apt update
    sudo apt install -y \
      ros-noetic-tf2-ros ros-noetic-tf2-geometry-msgs ros-noetic-tf2-eigen \
      ros-noetic-cv-bridge ros-noetic-image-transport ros-noetic-pcl-ros \
      ros-noetic-pointcloud-to-laserscan ros-noetic-map-server \
      ros-noetic-rosbridge-suite ros-noetic-foxglove-bridge
  2. Python ≥ 3.10 environment for the NeuPAN local planner:

    conda create -n neupan python=3.10 -y
    conda activate neupan
    pip install rospkg catkin_pkg
    pip install torch --index-url https://download.pytorch.org/whl/cpu   # on Jetson, use the NVIDIA JetPack wheel
    pip install -e NeuPAN
    export NEUPAN_PYTHON="$(which python)"

    (Alternative: if you prefer a self-contained RoboStack environment without system /opt/ros/noetic, you can install ros-noetic-desktop into the neupan environment via mamba and the robostack-noetic channel.)

4.2.2 Build

  1. Robot-specific chassis SDKs:

    • Unitree Go2: Install the official unitree_sdk2 first (see also the Unitree SDK Developer Guide), as ros_ws/src/unitree_control links against unitree_sdk2.
    • ASTRALL SW01: The SW01 chassis SDK and driver support are provided by ASTRALL Dynamics. Contact them through their official website: https://www.astralldynamics.com/index.html.
    • Dobot Lumo: Optional; without the Lumo SDK, dobot_ros_control builds the raw RPC backend automatically.
  2. Build the ROS1 workspace:

    # Full build (when unitree_sdk2 is installed):
    bash ros_ws/src/odin_ros_driver/script/build_ros.sh
    # Equivalent to: cd ros_ws && catkin_make -DCMAKE_BUILD_TYPE=Release
    
    # Or build without unitree_control (for SW01, Dobot Lumo, or custom robots):
    cd ros_ws && catkin_make -DCMAKE_BUILD_TYPE=Release \
      -DCATKIN_WHITELIST_PACKAGES="nav_interfaces;odin_ros_driver;map_planner;sliding_map;neupan_ros;mission_manager;atomic_move;sw01_ros_control;dobot_ros_control"

4.2.3 Launch

bash scripts/ons2_go2.sh --map=NAME  # Unitree Go2 (ROS1)
bash scripts/ons2_dobot_lumo.sh --map=NAME  # Dobot Lumo (ROS1)
bash scripts/ons2_sw01.sh --ros1 --map=NAME  # ASTRALL SW01 (ROS1)

Stop: bash scripts/ons2_go2_stop.sh, bash scripts/ons2_dobot_lumo_stop.sh, or bash scripts/ons2_sw01_stop.sh.

4.3 ROS2 Jazzy (Ubuntu 24.04)

The ROS2 stack (ros2_ws/) has been validated on ASTRALL SW01 and supports any ROS2 robot configured through robots/<robot>/robot.yaml (see 03 · Integrate Your Own Robot). Because Ubuntu 24.04 ships with system Python 3.12 (which already satisfies NeuPAN's Python ≥ 3.10 requirement), both the ROS2 nodes and the NeuPAN local planner run directly on the system Python without needing conda.

4.3.1 Install

  1. System ROS2 Jazzy dependencies (required by ros2_ws/src/*/package.xml and ons2_bringup):

    sudo apt update
    sudo apt install -y \
      ros-jazzy-ros-base ros-jazzy-tf2-ros ros-jazzy-tf2-geometry-msgs \
      ros-jazzy-pcl-ros ros-jazzy-pcl-conversions ros-jazzy-cv-bridge ros-jazzy-image-transport \
      ros-jazzy-pointcloud-to-laserscan ros-jazzy-rosbridge-suite ros-jazzy-nav-msgs \
      ros-jazzy-sensor-msgs ros-jazzy-std-srvs ros-jazzy-message-filters \
      ros-jazzy-rosidl-default-generators ros-jazzy-rosidl-default-runtime \
      ros-jazzy-nav2-map-server ros-jazzy-foxglove-bridge
  2. Python dependencies for the NeuPAN local planner (defined in NeuPAN/pyproject.toml):

    python3 -m pip install --break-system-packages "numpy<2" \
      torch --index-url https://download.pytorch.org/whl/cpu --extra-index-url https://pypi.org/simple
    python3 -m pip install --break-system-packages -e NeuPAN

Keep numpy below 2.0 so it stays ABI-compatible with the system ROS2 cv_bridge package.

4.3.2 Build

  1. Robot-specific chassis SDKs:

    • ASTRALL SW01: The SW01 chassis SDK and driver support are provided by ASTRALL Dynamics. Contact them through their official website: https://www.astralldynamics.com/index.html.
    • Custom robots: Implement your own chassis bridge and register it in robots/<robot>/robot.yaml; see 03 · Integrate Your Own Robot. If you are not building for SW01, skip sw01_ros_control with --packages-skip sw01_ros_control.
  2. Build the ROS2 workspace:

    source /opt/ros/jazzy/setup.bash
    cd ros2_ws
    colcon build --symlink-install --cmake-args -DBUILD_SYSTEM=ROS2
    cd ..

4.3.3 Launch

bash scripts/ons2_sw01.sh --map=NAME  # ASTRALL SW01 (ROS2, or your own robot launcher)

Stop: bash scripts/ons2_sw01_stop.sh. Use ROS_DOMAIN_ID=98 in every terminal you open by hand; the launch script sets it by default.

4.4 Differences between ROS1 and ROS2

Item ROS1 (Noetic) ROS2 (Jazzy)
OS Ubuntu 20.04 Ubuntu 24.04
Python for NeuPAN System python3 or NEUPAN_PYTHON (Python ≥ 3.10) System Python 3.12 (pip --break-system-packages)
Build catkin_make / build_ros.sh colcon build --symlink-install --cmake-args -DBUILD_SYSTEM=ROS2
Discovery roscore (started by the launcher) DDS, ROS_DOMAIN_ID=98, no roscore
Launcher scripts/ons2_go2.sh, scripts/ons2_dobot_lumo.sh scripts/ons2_sw01.sh
--navigation-mode Optional (defaults to replan_periodic) Optional (defaults to replan_periodic)
Stop scripts/ons2_go2_stop.sh, scripts/ons2_dobot_lumo_stop.sh scripts/ons2_sw01_stop.sh
tmux session ons2_go2, ons2_dobot_lumo ons2_sw01
Mission CLI / TUI ros_ws/scripts/test_nav_control_rospy.py or scripts/tools/mission_cli.sh ros2_ws/scripts/test_nav_control_ros2.py or ros2 service call
Robots Go2, Dobot Lumo, SW01 SW01
Odin driver Submodule ros_ws/src/odin_ros_driver Submodule ros2_ws/src/odin_ros_driver

5. Documentation

5.1 Feature Index — Start from What You Want to Do

I want to… Read
Run a patrol mission on an existing robot 01 · Quick Start
Drive it from a browser (Foxglove, or the optional 3DGS console) Quick Start § 5 · Web Control Frontend
Operate it remotely over 4G / NAT — ROS 2 (SW01) only; ROS 1 not supported yet Remote Web Monitor
Understand or retune the local planner — what was optimised and why NeuPAN Optimisation Notes
Look up the default values for my platform — measured per-robot values plus a recommended tuning order 02 · Parameter Tuning
Look up what a specific parameter does, or debug a symptom Advanced Tuning & Troubleshooting — full parameter dictionary (MPC/DUNE, scan pre-processing, adaptive safety band, global planner) plus a symptom→parameter table
Pick or write a platform profile Robot Profiles
Add automated inspection — checklist verdicts, annotated frames Perception guide → Odin-perception
Connect a new robot — interface contract, chassis bridge, TF, launch 03 · Integrate Your Own Robot
Ask a VLM questions about the scene VLM Scene Understanding
Understand the architecture / module dataflow Architecture · Module Dataflow
Scan a site and build a navigation map (Q9000 / Odin1) Map Tutorial · pcd_to_pgm.py
Reproduce a scenario in simulation (Real2Sim) MT-Real2Sim-Tutorial
Deploy with Docker (Jetson, ROS1) docker/docker-compose.yml

Chinese docs: every guide in this repository has a *.zh-CN.md sibling (usage guides, tuning guide, NeuPAN notes, remote monitor), and the README itself has a 中文版.

5.2 Core Guides

# Guide Use it to
1 Quick Start for Existing Robots Start the stack on Go2, SW01, or Dobot Lumo, and send missions
2 Parameter Tuning Change speed, footprint, clearance, and tracking for each platform
3 Integrate Your Own Robot Connect a new robot: interface contract, chassis bridge, TF, launch

5.3 Feature Status at a Glance

Capability ROS 1 (Noetic) ROS 2 (Jazzy)
Patrol navigation, local/global planning ✅ ✅
Web control console (Foxglove) ✅ ✅
Inspection perception (Florence-2, separate repo) ✅ ✅
Remote web monitor (camera / intercom / e-stop) ❌ not yet ✅ SW01
3DGS navigation console (optional, contact us) ✅ ✅

5.4 VLM Scene Understanding

Start a VLM server (llama.cpp, OpenAI-compatible API), then the terminal client:

llama-server -m SmolVLM-500M-Instruct-Q8_0.gguf --mmproj mmproj-SmolVLM-500M-Instruct-Q8_0.gguf
ros2 launch odin_vlm_terminal odin_vlm_terminal.launch.py     # ROS2
roslaunch odin_vlm_terminal odin_vlm_terminal.launch          # ROS1

On an onboard computer with limited resources, run the VLM server on a companion machine. Note that we no longer recommend this path — Florence-2 (see below) fully supersedes it.

5.5 Inspection Perception (Florence-2)

Optional module — ONS2 runs fully without it. Adding perception is a two-process side-car, not a rebuild: you do not have to recompile this stack, touch its launch files, or change any navigation parameter. You can add it or drop it at any time.

Do you need it?

You need Odin-perception if… You do not need it if…
Patrols must produce pass/fail verdicts (valve state, gauge readings, indicator colors, nameplate OCR) You only need the robot to navigate between waypoints
You want annotated images (boxes + verdict text) on the camera feed A human watches the video stream and decides
Your Odin1 camera can publish RGB (sendrgb: 1) Your platform has no RGB stream

For structured inspection — valve closed? gauge reading? indicator color? — the perception component lives in a separate open-source repository, so the model environment never has to be merged into this ROS workspace:

➡️ Odin-perception

It takes an image, returns decidable verdicts against a YAML/JSON checklist, and can publish an annotated image (detection boxes + verdict text). It attaches to this stack in two processes communicating over HTTP:

odin driver ──► /odin1/image/undistorted
                      │
        ros1/ros2 capture node (:8730) ──HTTP──► perception-run (Florence-2)
                      ▲                                   │
                      └───────── POST /annotate ◄─────────┘
                      │
        /inspection/annotated/compressed ──► Foxglove / RViz / rosbridge

Installation and integration are documented in that repository's README — see its Integrating with Odin-Nav-Stack2 section for the step-by-step procedure, the topic contract, and the ROS 1 / Jetson pitfalls.

Prerequisite on this side: the Odin driver must actually publish images, i.e. sendrgb: 1 and sendrgbundistort: 1 in the driver's control_command.yaml; verify with rostopic hz /odin1/image/undistorted before wiring perception in.

odin_vlm_terminal above is a different, lightweight path: it forwards frames to an OpenAI-compatible VLM server for free-form Q&A. Use Odin-perception when you need repeatable, checklist-driven inspection verdicts.

6. Architecture

The stack is layered: Odin1 sensing and TF → pointcloud_to_laserscan → sliding_map obstacle memory → A* global planning (map_planner) → NeuPAN local control (neupan_ros) → chassis bridge, coordinated by mission_manager. Only one node may publish /cmd_vel at a time. Control passes from NeuPAN to atomic_move through /neupan/stop.

7. Repository Structure

Odin-Nav-Stack2/
├── robots/                        # Single source of truth for per-robot profiles
│   ├── _template/                 # Template for new robots (robot.yaml + neupan/{config,planner}.yaml)
│   ├── go2/                       # Unitree Go2 profile & NeuPAN configs (ROS 1)
│   ├── sw01/                      # ASTRALL SW01 profile & NeuPAN configs (ROS 2)
│   └── dobot_lumo/                # Dobot Lumo profile & NeuPAN configs (ROS 1)
├── scripts/                       # Unified entry scripts & operational tools
│   ├── ons2_go2.sh / ons2_go2_stop.sh
│   ├── ons2_sw01.sh / ons2_sw01_stop.sh
│   ├── ons2_dobot_lumo.sh / ons2_dobot_lumo_stop.sh
│   └── lib/ | tools/ | systemd/ | map_processing/
├── ros_ws/                        # ROS 1 Noetic workspace
│   ├── scripts/                   # ROS 1 runtime scripts (test_nav_control_rospy.py, waypoint_goal_bridge.py, sru/, ...)
│   └── src/
│       ├── odin_ros_driver/       # Submodule -> manifoldsdk/odin_ros_driver (Odin1 sensor driver)
│       ├── ons2_bringup/          # Profile-driven ROS 1 launch files (go2, dobot, map_planner, neupan)
│       ├── nav_interfaces/        # Shared messages, services, and actions
│       ├── sliding_map/           # 360° ego-centric virtual scan & obstacle memory
│       ├── map_planner/           # Global 2D A* planner & scan temporal filter
│       ├── neupan_ros/            # ROS 1 action server wrapper for NeuPAN
│       ├── mission_manager/       # Multi-waypoint mission state machine
│       ├── atomic_move/           # Closed-loop move / turn / align services
│       ├── unitree_control/       # Unitree Go2 SDK2 velocity bridge
│       ├── dobot_ros_control/     # Dobot Lumo RPC velocity bridge & O1L launch
│       └── odin_vlm_terminal/     # VLM scene question-answering node
├── ros2_ws/                       # ROS 2 Jazzy workspace (1:1 core parity with ros_ws)
│   ├── scripts/                   # ROS 2 runtime scripts (test_nav_control_ros2.py, waypoint_goal_bridge.py, sru/, ...)
│   └── src/
│       ├── odin_ros_driver/       # Submodule -> manifoldsdk/odin_ros_driver (Odin1 sensor driver)
│       ├── ons2_bringup/          # Generic profile-driven bringup.launch.py
│       ├── nav_interfaces/        # ROS 2 IDL messages, services, and actions
│       ├── sliding_map/           # ROS 2 360° virtual scan & obstacle memory
│       ├── map_planner/           # ROS 2 global A* planner & cloud/scan filters
│       ├── neupan_ros/            # ROS 2 action server + ros2_shim.py
│       ├── mission_manager/       # ROS 2 mission state machine & path safety validator
│       ├── atomic_move/           # ROS 2 closed-loop alignment node
│       ├── sw01_ros_control/      # ASTRALL SW01 SDK velocity bridge
│       └── odin_vlm_terminal/     # ROS 2 VLM scene question-answering node
├── NeuPAN/                        # Shared MPC + analytic DUNE local planner core (Python)
├── perception/                    # Guide & clone instructions for ManifoldTechLtd/Odin-perception
├── docker/                        # Docker setup for Jetson (ROS 1)
└── docs/                          # Documentation
    ├── usage/                     # 01_quick_start, 02_parameter_tuning, 03_integrate_your_robot
    ├── architecture/              # ROBOT_PROFILE.md, ONS2_ARCHITECTURE.md, MODULE_DATAFLOW.md
    └── TUNING_GUIDE.md            # Detailed parameter dictionary & troubleshooting reference

8. FAQ

8.1 How do I check relocalization?

Open RViz (rviz on ROS1, rviz2 on ROS2), set the fixed frame to map, and add the TF display. Relocalization succeeded when map → odom → odin1_base_link is connected.

8.2 The start or goal is occupied after I publish a goal

Check the inflated map (/inflated_map) in RViz. The start and goal must lie outside the inflation area. Adjust navigation.inflation_radius in robots/<robot>/robot.yaml.

8.3 The robot does not stop near the target

This is a NeuPAN tolerance issue. See 02 · Parameter Tuning and the tuning guide.

8.4 ROS2 nodes run but cannot see each other

All nodes must use the same DDS domain, ROS_DOMAIN_ID=98. Set it in every terminal you open by hand.

9. Acknowledgements

Thanks to the excellent work by ROS Navigation, NeuPAN, and Ultralytics YOLO.

Special thanks to hanruihua and the Odin1 team at Manifold Tech.

10. License

ONS2 is released under the GNU General Public License v3.0. Third-party components keep their own licenses; the full list includes NeuPAN (GPL-3.0), the Odin1 driver (Apache-2.0), yolov5 (AGPL-3.0, optional submodule), and the ASTRALL SDK (proprietary, not distributed with this repository). Check the license of each component before redistributing it.

About

No description, website, or topics provided.

Resources

Stars

49 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages