dynus

KO | EN

gitlite — search

#react #typescript #llm #android #machine-learning #rust #docker #macos #nodejs #windows #cli #awesome-list #pytorch #open-source

(★ 73)

No description available.

File Explorer

Download Latest Version (.zip)

- cave_pointcloud_viz.ipynb
- collision_checker.py
- convert_actual_traj_id.ipynb
- debug.ipynb
- dynamic_obstacle_benchmark_node.py
- dynamic_obstacle_collision_checker.py
- global_planner_benchmark_data_analysis.ipynb
- global_planner_benchmark_node.py
- ground_robot_and_quadruped_pointcloud_viz.ipynb
- hardware_experiment_data_analysis.ipynb
- hardware_groud_robot_pointcloud_viz.ipynb
- hardware_uav_pointcloud_viz.ipynb
- high_res_forest_pointcloud_viz.ipynb
- make_video_from_bag.ipynb
- office_pointcloud_viz.ipynb
- offline_tf_visualization_bag_writer.py
- p_n_benchmark_data_analysis.ipynb
- p_n_benchmarking_node.py
- run_bags_one_by_one.py
- single_agent_performance_data_analysis.ipynb
- single_agent_performance_node.py
- sota_benchmarking_pointcloud_viz.ipynb
- test_bezier.ipynb
- test_bspline.ipynb
- test_linear.ipynb
- test_optimize_yaw_multiple_obsts.ipynb
- test_uncertainty_propagation_static.ipynb
- time_allocation_benchmark_data_analysis.ipynb
- time_allocation_benchmark_node.py
- time_allocation_graph_generation.ipynb
- uav_hardware_dyn_sta.ipynb
- uav_hardware_dynamic.ipynb
- uav_hw_static.ipynb
- yaw_fov_visualization.ipynb
- yaw_optimization_benchmark_data_analysis.ipynb
- yaw_optimization_benchmark_node.py
- yaw_optimization_vis.ipynb
- cave_param.yaml
- dynamic_obstacle_empty_param.yaml
- dynus.yaml
- dynus_hw_quadrotor.yaml
- dynus_sim_ground_robot.yaml
- dynus_sim_quadruped.yaml
- easy_forest_param.yaml
- high_res_forest_param.yaml
- office_param.yaml
- data.txt
- Dockerfile
- dynus.sh
- Makefile
- __init__.py
- module_to_import.py
- cave.gif
- dyn_sta_hw.gif
- ground_robots.gif
- ground_robots_hw.gif
- multiagent_cross.gif
- multiagent_straight.gif
- office.gif
- single_agent_cave.gif
- single_agent_dynamic_obstacles.gif
- single_agent_office.gif
- single_agent_realistic_forest.gif
- single_agent_static_forest.gif
- test31_ground_view.gif
- - data_type.hpp
  - data_utils.hpp
  - dgp_manager.hpp
  - dgp_planner.hpp
  - graph_search.hpp
  - map_util.hpp
  - octomap_server_dynus.hpp
  - read_map.hpp
  - termcolor.hpp
  - TimedOcTree.h
  - TimedOcTreeNode.h
  - utils.hpp
- - convert_goal_to_cmd_vel.hpp
  - convert_odom_to_state.hpp
  - convert_vicon_to_state.hpp
  - dynus.hpp
  - dynus_node.hpp
  - dynus_type.hpp
  - gurobi_solver.hpp
  - gurobi_solver_utils.hpp
  - initial_guess.hpp
  - obstacle_tracker_node.hpp
  - quadruped_convert_goal_to_cmd_vel.hpp
  - quadruped_convert_odom_to_state.hpp
  - utils.hpp
  - yaw_solver.hpp
- - exprtk.hpp
  - gazebo_ros_imu_sensor.hpp
  - ImuSensorPlugin.hh
- timer.hpp
- base_dynus.launch.py
- convert_goal_cmd_vel.launch.py
- convert_odom_to_state.launch.py
- convert_vicon_to_state.launch.py
- default_multiagent_sim.yaml
- default_sim.yaml
- default_sim_ground_robot.yaml
- docker_multiagent_sim.yaml
- docker_sim.yaml
- dyn_obstacles.launch.py
- dynus_hw_ground_robot.yaml
- goal_monitor.launch.py
- goal_sender.launch.py
- hardware_big_drone.yaml
- hardware_ground_robot.yaml
- initial_guess_benchmarking.launch.py
- object_detection.launch.py
- onboard_dynus.launch.py
- quadruped_sim.yaml
- run_bags.yaml
- run_single_sim.py
- sim_env.launch.py
- spawn_quadrotor.launch.xml
- spawn_quadrotor_with_asus.launch.xml
- - asus_camera_simple.dae
  - asus_camera_simple.stl
- - hokuyo_utm_30lx.dae
  - hokuyo_utm_30lx.stl
  - hokuyo_utm_30lxTEST_SELF_FILTER.dae
- - kinect_camera_simple.dae
  - kinect_camera_simple.stl
- - model2.dae
  - model4.dae
- - axle.stl
  - back_sonar.stl
  - chassis.stl
  - front_sonar.stl
  - left_hubcap.stl
  - right_hubcap.stl
  - top.stl
  - wheel.stl
- - back_rim.stl
  - back_sonar.stl
  - caster_hubcap.stl
  - caster_swivel.stl
  - caster_wheel.stl
  - chassis.stl
  - front_rim.stl
  - front_sonar.stl
  - left_hubcap.stl
  - left_wheel.stl
  - right_hubcap.stl
  - right_wheel.stl
  - top.stl
- - pioneer-lx-plinth.stl
  - pioneer-lx_hull.stl
  - pioneer-lx_visual.stl
- - quadrotor.dae
  - quadrotor_base.dae
  - quadrotor_base.stl
  - quadrotor_base_2.dae
  - quadrotor_base_2.stl
- - d435.dae
- - max_sonar_ez4.dae
- - thermaleye_camera_hector_v1.dae
  - thermaleye_camera_hector_v1.stl
  - thermaleye_camera_hector_v2.dae
  - thermaleye_camera_hector_v2.stl
- dynus.rviz
- dynus_hw_ground_robot.rviz
- dynus_px01_hardware.rviz
- dynus_sim_ground_robot.rviz
- dynus_uav_hardware.rviz
- multiagent.rviz
- multiagent_wo_cameras.rviz
- bag_record.py
- bezier_closed_form.ipynb
- convert_goal_to_cmd_vel.py
- convert_normalized_coefficients_to_time_parameterized_coefficients.ipynb
- convert_odom_to_state.py
- convert_vicon_to_state.py
- download_collection.py
- dummy_traj_publisher.py
- dynus_commands.py
- generate_random_forest.py
- goal_monitor_node.py
- goal_sender.py
- hw_bag_record.py
- initial_guess_benchmarking.py
- kill_ros_processes.py
- object_detection_node.py
- reduce_control_dimensions.ipynb
- reduce_control_dimensions_with_time.ipynb
- rename_folders.py
- unpack_model_zip.py
- v_max_adjustment_text.ipynb
- - dgp_manager.cpp
  - dgp_planner.cpp
  - graph_search.cpp
  - octomap_server_dynus.cpp
  - utils.cpp
- - convert_goal_to_cmd_vel.cpp
  - convert_odom_to_state.cpp
  - convert_velodyne_to_ros_time.cpp
  - convert_vicon_to_state.cpp
  - dynus.cpp
  - dynus_node.cpp
  - fake_dynamic_obstacles.cpp
  - fake_sim.cpp
  - gurobi_solver.cpp
  - initial_guess.cpp
  - obstacle_tracker_node.cpp
  - quadruped_convert_goal_to_cmd_vel.cpp
  - quadruped_convert_odom_to_state.cpp
  - utils.cpp
  - yaw_solver.cpp
- - gazebo_ros_imu_sensor.cpp
  - move_model.cpp
- - test_yaw_solver.cpp
  - visualize_test_yaw_solver_cpp.ipynb
- - model.config
  - model.sdf
- - model.config
  - model.sdf
- - model.config
  - model.sdf
- - model.config
  - model.sdf
- _d435.gazebo.xacro
- _d435.urdf.xacro
- _d435i.gazebo.xacro
- _d435i.urdf.xacro
- _t265.gazebo.xacro
- _t265.urdf.xacro
- dyn_obstacle1.urdf.xacro
- generic_camera.urdf.xacro
- p3at.urdf.xacro
- p3at_manual.urdf
- pioneer3at_body.urdf.xacro
- quadrotor.urdf.xacro
- quadrotor_base.urdf.xacro
- sonar_sensor.urdf.xacro
- - forest.world
  - forest_tagged.world
  - hill.world
  - hill_tagged.world
  - lake.world
  - lake_tagged.world
  - park.world
  - park_tagged.world
- ACL_office.world
- ACL_office_with_backpack.world
- big_forest.world
- big_forest_high_res.world
- easy_forest.world
- empty.world
- empty_wo_ground.world
- finals_systems_prelim2.world
- flight_space.world
- flight_test_env.world
- forest.world
- forest0.world
- forest2.world
- forest3.world
- forest3_with_walls.world
- hard_forest.world
- hospital.world
- medium_forest.world
- office.world
- quadruped_easy_forest.world
- quadruped_forest3.world
- roi_map_test.world
- simple_tunnel.world
- static_uncertainty_test.world
- static_uncertainty_test2.world
- static_uncertainty_test3.world
- static_uncertainty_test4.world
- tunnel.world
CMakeLists.txt
FindGUROBI.cmake
LICENSE
package.xml
README.md
setup.sh

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# DYNUS: Uncertainty-aware Trajectory Planner in Dynamic Unknown Environment #

### **Submitted to the IEEE Transactions on Robotics (T-RO)**

| **Static Forest** | **Dynamic Obstacles** |
| ------------------------- | ------------------------- |
<a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/single_agent_static_forest.gif" width="350" height="193" alt="Static Forest"></a> | <a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/single_agent_dynamic_obstacles.gif" width="350" height="193" alt="Static Forest"></a> |

| **Office** | **Cave** |
| ------------------------- | ------------------------- |
<a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/office.gif" width="350" height="193" alt="Static Forest"></a> | <a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/cave.gif" width="350" height="193" alt="Static Forest"></a>

| **Realistic Forest** | **Static Hardware** |
| ------------------------- | ------------------------- |
<a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/single_agent_realistic_forest.gif" width="350" height="193" alt="Static Forest"></a> | <a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/test31_ground_view.gif" width="350" height="193" alt="Static Forest"></a>

| **Dynamic Hardware** | **Ground Robots Hardware** |
| ------------------------- | ------------------------- |
<a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/dyn_sta_hw.gif" width="350" height="193" alt="Static Forest"></a> | <a target="_blank" href="https://youtu.be/SI8YbMS-wyw"><img src="./imgs/ground_robots_hw.gif" width="350" height="193" alt="Static Forest"></a>

## Paper

The paper is available on [arXiv](https://arxiv.org/abs/2504.16734).

## Citation

If you use this code in your research, please cite the following paper:

```
@article{kondo2025dynus,
  title={DYNUS: Uncertainty-aware Trajectory Planner in Dynamic Unknown Environments},
  author={Kondo, Kota and Peterson, Mason and Rober, Nicholas and Viso, Juan Rached and Jia, Lucas and Chen, Jialin and Merton, Harvey and How, Jonathan P},
  journal={arXiv preprint arXiv:2504.16734},
  year={2025}
}
```

## Video

YouTube video: [DYNUS: Uncertainty-aware Trajectory Planner in Dynamic Unknown Environment](https://youtu.be/SI8YbMS-wyw)

## For Multiagent Planners

[Robust MADER: Decentralized and Asynchronous Multiagent Trajectory Planner Robust to Communication Delay](https://github.com/mit-acl/rmader)

## General Setup

DYNUS has been tested on both Docker and native installations on Ubuntu 22.04 with ROS 2 Humble.

### Use Docker (Recommended)

DYNUS’s backend optimizer is powered by Gurobi, which requires a valid license. To obtain a license, please visit [Gurobi Licensing](https://www.gurobi.com/solutions/licensing/) and generate a Web License Service (WLS) license. **Note:** The regular license is not compatible with Docker.

1. **Install Docker:**  
   Follow the [official Docker installation guide for Ubuntu](https://docs.docker.com/engine/install/ubuntu/).

2. **Clone the Repository and Navigate to the Docker Folder:**
   ```bash
   mkdir -p ~/code/ws
   cd ~/code/ws
   git clone https://github.com/mit-acl/dynus.git
   cd dynus/docker
   ```

3. **Place Your Gurobi License:**  
   Copy your `gurobi.lic` file into the `docker` folder.

4. **Build the Docker Image:**
   ```bash
   make build
   ```

<details>
 <summary>Useful Docker Commands</summary>

- **Remove all caches:**  
    ```bash
    docker builder prune
    ```

- **Remove all containers:**  
    ```bash
    docker rm $(docker ps -a -q)
    ```

- **Remove all images:**  
    ```bash
    docker rmi $(docker images -q)
    ```

</details>

### Native Installation

1. **Clone the Repository and Navigate to the Workspace Folder:**
   ```bash
   mkdir -p ~/code/ws
   cd ~/code/ws
   git clone https://github.com/mit-acl/dynus.git
   cd dynus
   ```

2. **Run the Setup Script:**
   ```bash
   ./setup.sh
   ```
   This script will first install ROS 2 Humble, then DYNUS and its dependencies. Please note that this script modifies your `~/.bashrc` file.

<details>
 <summary>Error Handling</summary>

- **Error 1: When running `colcon build`**
    ```
    By not providing "Finddecomp_util.cmake" in CMAKE_MODULE_PATH, this project
    has asked CMake to find a package configuration file provided by
    "decomp_util", but CMake did not find one.
    ```
    - **Solution:**  
      Source `install/setup.bash` and build again.

- **Error 2: When running Python script**  
    ```
    No module named 'rclpy._rclpy_pybind11'
    ```
    - **Solution:**  
      Deactivate the Conda environment if you are using Conda.

- **Runtime Error 3:**  
    ```
    "Spawn status: Entity pushed to spawn queue, but spawn service timed out
    waiting for entity to appear in simulation under the name [quadrotor]"
    ```
    - **Solution:**  
      Go to the world file you are using and make sure `sim_time` is set to `0`.

- **Error 4: When building dlio package**  
    ```
    fatal error: numpy/ndarrayobject.h: No such file or directory
    ```
    - **Solution:**  
      Just cleaned up the workspace and rebuilt it.

- **Error 5: Gazebo runtime error**
 ```
 [gzserver-1] gzserver: /usr/include/boost/smart_ptr/shared_ptr.hpp:728: 
 typename boost::detail::sp_member_access<T>::type boost::shared_ptr<T>::operator->() const 
 [with T = gazebo::rendering::Scene; typename boost::detail::sp_member_access<T>::type = gazebo::rendering::Scene*]: 
 Assertion `px != 0' failed.
 ```
 - **Solution:** 
 Source Gazebo's setup file: 
 ```
 source /usr/share/gazebo/setup.bash
 ```

- **Error 6: Missing package configuration file** 
 ```
 Could not find a package configuration file provided by "diagnostic_updater" 
 with any of the following names: when building realsense-ros.
 ```
 - **Solution:** 
 Install the missing package: 
 ```
 sudo apt-get install ros-humble-diagnostic-updater
 ```
 - **Error 7: When running `colcon build`**
 ```
 /lib/libgurobi_c++.a, needed by test_yaw_solver
 ```
 - **Solution:** 
 Set the Gurobi path: (even if you put this in bashrc - just to make sure it's set)
 ```
 export GUROBI_HOME=/opt/gurobi1103/linux64
 colcon build --cmake-args "-DCMAKE_BUILD_TYPE=Release"
 ```
 ```
</details>

## Run the Simulation

### Use Docker (Recommended)

The `dynus.sh` script in the `docker/` folder is copied into the DYNUS container and acts as the entrypoint.  
You can modify this script to set environment variables and choose the simulation environment.

#### Currently Supported Environments:
1. **`high_res_forest`** – High-resolution forest with 3D obstacles (note: Gazebo may run slowly)
2. **`easy_forest`** – Benchmarking environment used in the paper
3. **`office`** – Confined indoor office space
4. **`empty`** – Open space with dynamic obstacles

#### Coming Soon:
- **`cave`** – Cave-like environment with YOLO-based person detection  
- **`wheeled_robot`** – 2D ground robot simulation  
- **`quadruped`** – 2D quadruped robot simulation

#### How to Run
1. Modify the last line of `dynus.sh` to set the desired environment:
   ```bash
   python3 src/dynus/launch/run_single_sim.py --env easy_forest
   ```
2. Then build and run the container:
   ```bash
   make run-sim
   ```
3. Set a goal in Rviz by clicking the "2D Goal Pose" button (or pressing `G`), then clicking on the map.  
4. Alternatively, publish a goal from the command line:
   ```bash
   ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped \
   "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, \
     pose: {position: {x: 105.0, y: 0.0, z: 3.0}, \
     orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
   ```
   Feel free to change the `x`, `y`, and `z` values to set a custom goal position.

---

### Use Native Installation

If you prefer not to use Docker, you can run DYNUS directly on your machine.

#### How to Run
1. Make sure you have all dependencies installed (e.g., ROS 2, Gazebo, required Python packages).
2. Source your ROS 2 and workspace setup:
   ```bash
   source /opt/ros/humble/setup.bash
   source ~/dynus_ws/install/setup.bash
   ```
3. Run the simulation script with your desired environment:
   ```bash
   python3 src/dynus/launch/run_single_sim.py --env easy_forest
   ```
4. You can change `--env` to any supported environment:
   ```bash
   --env high_res_forest
   --env office
   --env empty
   ```
5. Set a goal in Rviz by clicking the "2D Goal Pose" button (or pressing `G`), then clicking on the map.  
6. Or publish a goal manually:
   ```bash
   ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped \
   "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, \
     pose: {position: {x: 105.0, y: 0.0, z: 3.0}, \
     orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
   ```
   Adjust `x`, `y`, and `z` to define your desired goal position.

If you encounter any issues, please refer to the [Error Handling](#error-handling) section.

### Notes

<details>
 <summary>ROS2 Multiagent Hardware Setup</summary>

**Debugging Useful Commands:**
  - `ros2 multicast send`
  - `ros2 multicast receive`
  - `ros2 run demo_nodes_cpp talker`
  - `ros2 run demo_nodes_cpp listener`

**Commands to Run:**
  - `sudo ufw disable`
  - `sudo ufw allow in proto udp to 224.0.0.0/4`  
    *(if you disable ufw, you don't need this)*
  - `sudo ufw allow in proto udp from 224.0.0.0/4`  
    *(if you disable ufw, you don't need this)*
  - `sudo ufw allow in proto udp from 192.168.1.0/24`  
    *(if you disable ufw, you don't need this)*

**Things to Check:**
 - `export RMW_IMPLEMENTATION=rmw_fastrtps_cpp`
 - `export ROS_LOCALHOST_ONLY=0`
 - Ensure `ROS_DOMAIN_ID` is set to the same value for all agents.
 - *(For ground station)* You may need to unplug other network interfaces to encourage the computer to use the correct network.
</details>

<details>
 <summary>How to Monitor Compute</summary>

- **Record Performance Data:**
 ```bash
 perf record -g -- tmuxp load src/dynus/launch/default_sim.yaml
 ```
 - **Generate Performance Script:**
 ```bash
 perf script >> script.txt
 ```
 - **Generate Flame Graph:**
 ```bash
 cat /home/kkondo/code/dynus_ws/script.txt | ./stackcollapse-perf.pl | ./flamegraph.pl > flame.html
 ```
 - **View Flame Graph:** 
 Open `flame.html` in your browser (e.g., type the path in your browser).
</details>

<details>
 <summary>Gazebo</summary>

- **Hospital Models & World Files:**
 - [OpenRobotics Hospital Models](https://app.gazebosim.org/OpenRobotics/fuel/collections/Hospital)
 - [Useful World Files for Gazebo and ROS 2 Simulations](https://automaticaddison.com/useful-world-files-for-gazebo-and-ros-2-simulations/)
</details>

<details>
 <summary>For Octomap</summary>

- **Installation Commands:**
 ```bash
 sudo apt-get install ros-humble-octomap
 sudo apt-get install ros-humble-octomap-msgs
 sudo apt-get install ros-humble-octomap-ros
 sudo apt-get install ros-humble-octomap-rviz-plugins
 sudo apt install ros-humble-rviz-common
 ```
</details>

<details>
 <summary>If You Use Conda for Dynus</summary>

- Use **Python 3.10 or below** *(to avoid pybind errors)*.
 - Install GCC 12.1.0 to prevent gcc errors:
 ```bash
 conda install -c conda-forge gcc=12.1.0
 ```
 - Install required Python packages:
 ```bash
 pip install numpy lxml pyyaml empy==3.3.4 catkin_pkg lark
 ```
</details>

<details>
 <summary>How to Build Docker Using Private Repo with PAT</summary>

- **Generate a Personal Access Token (PAT):**
 - Follow [this guide](https://www.geeksforgeeks.org/how-to-generate-personal-access-token-in-github/) to generate your PAT.
 - When generating your PAT, ensure:
 - **Repository access:** Set to **All repositories**
 - In the **Repository permissions** menu, find the **Contents** row and select **Access > Read and Write**
 - **Copy your PAT.**
 - **Modify the Docker Makefile:**
 - Navigate to the docker folder in the dynus repo.
 - Open the `Makefile` with your favorite text editor.
 - Replace `"YOUR_PAT"` with your actual PAT.
 - **Run in Terminal:**
 ```bash
 xhost +
 ```
</details>

<details>
 <summary>Object Detection Module</summary>

- **Install Dependencies:**
 ```bash
 pip install opencv-python
 pip install ultralytics
 ```
 - **Download YOLO Model:**
 - Use `yolo11n.pt` (for example):
 ```bash
 wget https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt
 ```
 - **Install Specific Numpy Version:**
 ```bash
 pip install numpy==1.26.4
 ```
</details>

<details>
 <summary>New Conda Environment for YOLO</summary>

- **Create and Configure Environment:**
 ```bash
 conda install -n yolo -c conda-forge libstdcxx-ng
 ```
</details>

<details>
 <summary>Goal Commands</summary>

- **Office Space:**
 ```bash
 ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {position: {x: 36.0, y: 42.0, z: 2.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
 ```
 - **Forest3:**
 ```bash
 ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {position: {x: 50.0, y: 0.0, z: 3.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
 ```
 - **Path Push Visualization:**
 ```bash
 ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {position: {x: 8.0, y: 0.0, z: 3.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
 ```
 - **Ground Robot:**
 ```bash
 ros2 topic pub /NX01/term_goal geometry_msgs/msg/PoseStamped "{header: {stamp: {sec: 0, nanosec: 0}, frame_id: 'map'}, pose: {position: {x: 50.0, y: 0.0, z: 0.5}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}}" --once
 ```
</details>

<details>
 <summary>Bag Record Commands</summary>

- **Path Push Visualization Bag:**
 ```bash
 ros2 bag record /NX01/dgp_path_marker /tf /tf_static /rosout /NX01/point_G /NX01/cluster_bounding_boxes /NX01/tracked_obstacles /NX01/fov /NX01/uncertainty_spheres -o test7
 ```
 - **Ground Robot Visualization Bag:**
 ```bash
 ros2 bag record /NX01/d435/color/image_raw /NX01/fov /NX01/point_G /NX01/actual_traj /NX01/mid360_PointCloud2 /tf /tf_static -o test0
 ```
</details>

<details>
 <summary>(ACL Specific) Running a Large Scale Simulation on Lambda Machines</summary>

**Setup:**
  - Connect a monitor to the machine.
  - Set the display:
    ```bash
    export DISPLAY=:1
    ```
  - Run:
    ```bash
    xhost +
    ```
  - *If you see "Depth Camera not found" in `base_dynus.launch..py`, try rebuilding the docker image.*

**Error Troubleshooting:**
 - **Error:**
 ```
 docker: Error response from daemon: could not select device driver "" with capabilities: [[gpu]].
 make: *** [Makefile:11: run-sim] Error 125
 ```
 - **Solution:**
 - Follow [this StackOverflow thread](https://stackoverflow.com/questions/75118992/docker-error-response-from-daemon-could-not-select-device-driver-with-capab).
 - Use `run-sim-no-gpu` in `dynus/docker/Makefile` *(currently Lambda machines' GPU is not working—should be fixed soon)*.
 - Note: Realsense won’t work without a display. (SSH with `-X` may not work; a physical monitor is required.)
 - Once the simulation is running, the bag file is saved inside Docker. To copy it to your local machine:
 ```bash
 docker cp <container_id>:/path/to/bag/file /path/to/local/machine
 ```
 *(Find `<container_id>` by running `docker ps`.)*

**Goal Sender Examples:**
 - **Forest3 Goal Sender (Straight Path):**
 ```bash
 ros2 launch dynus goal_sender.launch.py list_agents:="['NX01', 'NX02', 'NX03', 'NX04', 'NX05']" list_goals:="['[50.0, 20.0, 0.0]', '[50.0, 10.0, 0.0]', '[50.0, 0.0, 0.0]', '[50.0, -10.0, 0.0]', '[50.0, -20.0, 0.0]']" default_goal_z:=2.0
 ```
 - **Forest3 Goal Sender (Cross Path):**
 ```bash
 ros2 launch dynus goal_sender.launch.py list_agents:="['NX01', 'NX02', 'NX03', 'NX04', 'NX05']" list_goals:="['[50.0, -20.0, 0.0]', '[50.0, -10.0, 0.0]', '[50.0, 0.0, 0.0]', '[50.0, 10.0, 0.0]', '[50.0, 20.0, 0.0]']" default_goal_z:=2.0
 ```
 - **Big Forest High Res Goal Sender (Straight Path):**
 ```bash
 ros2 launch dynus goal_sender.launch.py list_agents:="['NX01', 'NX02', 'NX03', 'NX04', 'NX05']" list_goals:="['[35.0, 20.0, 0.0]', '[35.0, 10.0, 0.0]', '[35.0, 0.0, 0.0]', '[35.0, -10.0, 0.0]', '[35.0, -20.0, 0.0]']" default_goal_z:=3.0
 ```
 - **Big Forest High Res Goal Sender (Cross Path):**
 ```bash
 ros2 launch dynus goal_sender.launch.py list_agents:="['NX01', 'NX02', 'NX03', 'NX04', 'NX05']" list_goals:="['[35.0, -20.0, 0.0]', '[35.0, -10.0, 0.0]', '[35.0, 0.0, 0.0]', '[35.0, 10.0, 0.0]', '[35.0, 20.0, 0.0]']" default_goal_z:=3.0
 ```
 - **Quadruped Forest3 Goal Sender:**
 ```bash
 ros2 launch dynus goal_sender.launch.py list_agents:="['NX01']" list_goals:="['[45.0, 0.0, 0.0]']" default_goal_z:=1.0
 ```
</details>

dynus

File Explorer

Today's picks

Was this content helpful?

Recent Feedback

dynus

File Explorer

Today's picks

Was this content helpful?

Recent Feedback

Download README