NAMOROS

NAMOROS is a ROS 2 package addressing the problem of Navigation Among Movable Obstacles (NAMO). It enables mobile robots to plan and execute navigation tasks in environments where certain obstacles can be grasped and relocated. NAMOROS encapsulates the NAMOSIM motion planner within a ROS 2 framework, providing services, actions, and message types to facilite the execution of NAMO plans on real and simulated robots. The package allow users to compute and update NAMO plans, and dynamically synchronize the planner with the changing environment state. It also supports multi-robot environments and provides the ability to dynamically manage conflicts via NAMOSIM’s communication-free coordination strategy. NAMOROS integrates seamlessly with Gazebo Sim or any ROS 2-compatible mobile robot platform. It supports holonomic and differential-drive motion models. NAMOROS is designed for R&D in multi-robot navigation, particularly in interactive environments.

System Requirements

• Ubuntu 22.04
• ROS2 Humble

Setup

First, clone the repo and cd into it.

git clone git@github.com:Chroma-CITI/namoros.git
cd namoros

Next, use rosdep to install the dependencies listed in the package.xml files:

rosdep install --from-paths . -r -y

Some python dependencies must be installed with pip:

pip install -r namoros/requirements.txt

Finally, build and source the project.

colcon build
source install/setup.bash

Demostrations

In order to launch a simulation demonstration a robot that makes use of namoros nodes, run the following script.

./launch_demo.sh

Architecture

The system is organized as ROS2 packages:

• namoros: ROS2 nodes to control the robot and interacting with the namosim planner within a behavior tree framework
• namoros_msgs: Custom ROS2 message definitions
• namoros_gz: Custom Gazebo plugin for simulating grab and release actions.

Here is a block diagram showing the main components of NAMOROS:

The NAMO Planner block is a custom ROS2 node that manages the namosim planner and exposes services and actions for interacting with it.

The NAMO Behavior Tree block is another custom node that executes that main behavior tree which controls the robot execution and interaction with the planner node.

The other blocks, nav2 and aruco_markers are third-party packages used for simple navigation and detection of visual markers placed on movable obstacles.

If running in a Gazebo simulation, a plugin from the namoros_gz package is provided to simulate grab and release actions. It works by dynamically creating a fixed joint between a user-chosen link on the robot and a link on the obstacle.

Main Behavior Tree

The main behavior tree is illustrated in the following diagram. It ticks at a frequency of 2Hz. The robot starts by waiting to receive a start pose and goal pose. These may come from the scenario file or be published to the corresponding topics. The behavior tree continuously motors its sensor data for the positions of other robots and movable obstacles. It uses this data during specific periods to synchronize the planner node’s state with the estimated state of the environment which is necessary for conflict detection. The New Movable node encapsulates a subtree that handles dynamic detection of movable obstacles but is only used when that feature is activated and not shown for brevity.

Execute Plan Subtree

Because a NAMO plan consists of multiple behaviors such as path following, and grabbing and releasing obstacles, and because the plan is initially unknown and subject to change, the Execute Plan bevavior dynamically creates and executes a subtree corresponding to the current plan. The following diagram shows an example subtree which consists of a transit path followed by a transfer path to move an obstacle, and lastly another transit path to reach the goal. Immediately before and after each transfer path there are also grab and release sequences. Each of these behaviors are themselves small subtrees which are illustrated below. The Execute Plan subtree always starts with a release behavior just in case the robot was already holding an obstacle at the time the plan was computed.

Transit Path

The transit path uses nav2 to follow the corresponding path segment within the NAMO plan.

Grab Sequence

The grab sequence consists of first turning towards the obstacle, approaching it within close range as determined by the lidar sensor, and finally performing the grab action. An important point is that synchronizing the planner with the observed obstacle state is disabled because the planner treats robot and the obstacle as a single object during transfer paths. Otherwise, the planner will detect conflicts with the obstacle the robot is already carrying.

Release Sequence

The release sequence first performs the release action, and the backs the robot up at a constant slow speed for a fixed time period. Then the robot re-estimates the obstacle position, synchronizes the planner, and re-computes the plan.

Conflict Handling

During path following, the behavior tree periodically synchronizes the planner node with the current estimated state of the environment and checks for conflicts. When a conflict is detected, the robot is interrupted, the plan is updated, and then plan execution is restarted.

File truncated at 100 lines see the full file