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
- 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) andros2_ws/(ROS2 Jazzy) share the planner core, the topic / service / action names, and the configuration profiles.
- 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.
- Odin-Nav-Stack — The ROS1-based open-source navigation stack that this project builds on.
- SRU × Odin1: Mapless Navigation with Spatially-Enhanced Recurrent Memory — Mapless navigation on Odin1 (the SRU backend).
- NeuPAN (ManifoldTech fork) — The local planner used by ONS2, with a ROS wrapper.
- ManifoldTech Real2Sim Tutorial — Transform the real world into a simulated environment in Isaac Sim using Q9000.
- odin_ros_driver and the Odin1 wiki — Odin1 driver and documentation.
- Odin RTK — Odin RTK Fusion: fuses Odin SLAM odometry with RTK/GNSS GGA data to output globally referenced poses.
- Odin Perception — the on-device inspection perception component for ONS2: feed one image to a vision model and get decidable verdicts against a structured checklist (yes/no, state, count, read-text, describe), with evidence image and latency.
| 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.
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 |
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, andcustomer_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.
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.shandros2_ws/scripts/sru/sru_cmd_vel_relay.py(models default to$SRU_WS_ROS2/Deployment/models, overridable viaSRU_MODELS_DIR). - On ROS1, the SRU helper defaults to
sru_nav_go2_ros1; setSRU_PKGandSRU_LAUNCH(or configureplanner.localinrobots/<robot>/robot.yaml) to point to your robot's SRU package and launch file. --navigation-modehas no effect in SRU mode.- SRU outputs a body-frame
Twist, so any robot with a/cmd_velbridge can use it. See 03 · Integrate Your Own Robot.
Both runtimes share the same clone step and the same Odin1 USB rule. Then follow one runtime section below.
git clone --recursive https://github.com/ManifoldTechLtd/Odin-Nav-Stack2.git
cd Odin-Nav-Stack2If 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 inputBoth ros_ws/src/odin_ros_driver and ros2_ws/src/odin_ros_driver are submodules pointing to manifoldsdk/odin_ros_driver.
For details, see the Odin1 Ubuntu Quick Start — Create udev rules:
sudo vim /etc/udev/rules.d/99-odin-usb.rulesAdd 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 triggerBoth 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.
-
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
-
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 installros-noetic-desktopinto theneupanenvironment viamambaand therobostack-noeticchannel.)
-
Robot-specific chassis SDKs:
- Unitree Go2: Install the official unitree_sdk2 first (see also the Unitree SDK Developer Guide), as
ros_ws/src/unitree_controllinks againstunitree_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_controlbuilds the raw RPC backend automatically.
- Unitree Go2: Install the official unitree_sdk2 first (see also the Unitree SDK Developer Guide), as
-
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"
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.
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.
-
System ROS2 Jazzy dependencies (required by
ros2_ws/src/*/package.xmlandons2_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
-
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
numpybelow 2.0 so it stays ABI-compatible with the system ROS2cv_bridgepackage.
-
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, skipsw01_ros_controlwith--packages-skip sw01_ros_control.
-
Build the ROS2 workspace:
source /opt/ros/jazzy/setup.bash cd ros2_ws colcon build --symlink-install --cmake-args -DBUILD_SYSTEM=ROS2 cd ..
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.
| 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 |
| 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.mdsibling (usage guides, tuning guide, NeuPAN notes, remote monitor), and the README itself has a 中文版.
| # | 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 |
| 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) | ✅ | ✅ |
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 # ROS1On 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.
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:
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_terminalabove 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.
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.
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
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.
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.
This is a NeuPAN tolerance issue. See 02 · Parameter Tuning and the tuning guide.
All nodes must use the same DDS domain, ROS_DOMAIN_ID=98. Set it in every terminal you open by hand.
Thanks to the excellent work by ROS Navigation, NeuPAN, and Ultralytics YOLO.
Special thanks to hanruihua and the Odin1 team at Manifold Tech.
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.

