Open-RMF: Open-Source Robot Fleet Management System

What is Open-RMF?

Open-RMF (Open Robotics Middleware Framework) is open-source framework for managing multi-vendor robot fleets in single facility. Developed by Open Source Robotics Alliance (OSRA), Open-RMF solves hardest problem in robot fleet management: how can robots from different manufacturers -- each with proprietary protocol and navigation stack -- coordinate and operate together without collision or resource conflict?

In practice, typical electronics factory might use MiR AMR for part transport, Locus robot for warehouse picking, and custom AGV for assembly line. Without Open-RMF, each fleet runs separate management system -- leading to path conflicts, deadlock at elevators, and wasted resources.

Open-RMF creates abstraction layer above each fleet.

Open-RMF Architecture

Open-RMF uses modular design where each component handles specific function:

┌─────────────────────────────────────────────────┐
│              Open-RMF Core                       │
│  ┌─────────────┐  ┌──────────────┐              │
│  │ Task        │  │ Traffic      │              │
│  │ Dispatcher  │  │ Manager      │              │
│  └──────┬──────┘  └──────┬───────┘              │
│         │                │                       │
│  ┌──────┴────────────────┴───────┐              │
│  │        Schedule Database       │              │
│  └──────┬────────────────┬───────┘              │
│         │                │                       │
│  ┌──────┴──────┐  ┌─────┴───────┐              │
│  │Fleet Adapter│  │Fleet Adapter│  ...          │
│  │  (MiR)      │  │  (Custom)   │              │
│  └──────┬──────┘  └──────┬──────┘              │
└─────────┼────────────────┼──────────────────────┘
          │                │
     ┌────┴────┐     ┌────┴────┐
     │ MiR AMR │     │ Custom  │
     │ Fleet   │     │ AGV     │
     └─────────┘     └─────────┘

Fleet Adapter — Bridge Between Robot and System

Fleet Adapter is most critical component, acting as "translator" between each manufacturer's proprietary protocol and Open-RMF standard API. Each robot type needs dedicated adapter. Open-RMF provides fleet_adapter_template in Python for quick adapter development.

Adapter responsibilities:

• Receive commands from Open-RMF (move to waypoint X, dock at station Y)
• Convert to robot language (REST API, MQTT, DDS, or ROS 2 Action)
• Report status back: current position, battery level, task progress

Traffic Manager — Resolve Path Conflicts

Traffic Manager handles path conflicts between robots (even different manufacturers). Uses schedule-based conflict resolution: each robot "books" road segments, and Traffic Manager ensures no 2 robots occupy same lane simultaneously.

Task Dispatcher — Assign Tasks to Robots

Task Dispatcher receives task requests from operator (dashboard or API) and assigns to best robot based on:

• Distance to pickup point
• Remaining battery
• Robot type (not all robots can do all tasks)
• Current schedule

Why Multi-Vendor Fleet is Difficult

Each manufacturer uses different protocol. MiR uses REST API, Fetch uses MQTT, many Chinese AGVs use custom Modbus TCP. Even ROS 2-based robots often use different topic/action names per manufacturer.

Core problems:

• Path conflicts: Robot A unaware of robot B's location
• Shared resources: Elevator, automatic doors, narrow corridors -- who goes first?
• Task allocation: Which fleet manager assigns task when multiple fleet managers exist?
• Monitoring: Each manufacturer's dashboard -- operator must watch 3-4 screens

Open-RMF solves by creating abstraction layer above each fleet.

Installing Open-RMF with ROS 2

System Requirements

• Ubuntu 22.04 or 24.04
• ROS 2 Humble or Jazzy
• Python 3.10+

Install from Binary Packages

# Install ROS 2 Humble (if not present)
sudo apt update && sudo apt install -y ros-humble-desktop

# Install Open-RMF packages
sudo apt install -y \
  ros-humble-rmf-fleet-adapter \
  ros-humble-rmf-task-ros2 \
  ros-humble-rmf-traffic-ros2 \
  ros-humble-rmf-visualization

# Source environment
source /opt/ros/humble/setup.bash

Build from Source (for Development)

mkdir -p ~/rmf_ws/src
cd ~/rmf_ws/src

# Clone core repos
git clone https://github.com/open-rmf/rmf.git
git clone https://github.com/open-rmf/rmf_demos.git
git clone https://github.com/open-rmf/free_fleet.git

# Install dependencies
cd ~/rmf_ws
rosdep install --from-paths src --ignore-src -r -y

# Build
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release
source install/setup.bash

Run Demo Simulation

Open-RMF includes Gazebo simulation scenarios:

# Demo factory with 2 different robot fleets
ros2 launch rmf_demos_gz office.launch.xml

# Open web dashboard (default port 3000)
# Visit http://localhost:3000 for real-time map

Demo office includes:

• 2 robot fleets: tinyRobot (delivery) and deliveryRobot (heavy payload)
• Pre-defined traffic lanes
• Interactive doors and lifts
• API endpoint for task dispatch

Write Fleet Adapter for Custom Robot

import rclpy
from rclpy.node import Node
from rmf_fleet_adapter import adpt
import rmf_adapter.vehicletraits as traits
import rmf_adapter.geometry as geometry

class MyFleetAdapter(Node):
    def __init__(self):
        super().__init__('my_fleet_adapter')

        # Define robot characteristics
        profile = traits.Profile(
            footprint=geometry.make_final_convex_circle(0.3),
            vicinity=geometry.make_final_convex_circle(0.5)
        )
        vehicle_traits = traits.VehicleTraits(
            linear=traits.Limits(0.7, 0.5),   # max vel, max accel
            angular=traits.Limits(0.6, 0.8),
            profile=profile
        )

        # Register fleet with Open-RMF
        self.adapter = adpt.Adapter.make('my_fleet_adapter')
        self.fleet_handle = self.adapter.add_fleet(
            'my_custom_fleet',
            vehicle_traits,
            self.navigation_graph
        )

        self.get_logger().info('Fleet adapter initialized!')

    def navigate(self, robot_name, destination):
        """Send movement command to actual robot"""
        # Replace with API call to robot controller
        self.get_logger().info(
            f'Navigating {robot_name} to {destination}'
        )

def main():
    rclpy.init()
    adapter = MyFleetAdapter()
    rclpy.spin(adapter)

if __name__ == '__main__':
    main()

Comparison with Proprietary Solutions

VDA5050 -- European Communication Standard

VDA5050 is communication standard between AGV/AMR and master controller, developed by German Auto Association (VDA) and German Machine Builders (VDMA). Defines MQTT protocol standard for robots from different manufacturers to communicate with single master controller. However, VDA5050 is just protocol -- you still build traffic manager and task dispatcher yourself, while Open-RMF provides complete system.

MiR Fleet -- Only for MiR Ecosystem

MiR Fleet Manager is commercial solution from Mobile Industrial Robots (owned by Teradyne). Powerful and easy to install, but manages only MiR robots. If warehouse adds AGV from another manufacturer, MiR Fleet cannot help.

Learning Resources

Open-RMF has extensive documentation and active community:

• Main GitHub: github.com/open-rmf/rmf -- root repo with installation guides
• Free Fleet: github.com/open-rmf/free_fleet -- Python fleet adapter using zenoh
• Demos: github.com/open-rmf/rmf_demos -- pre-built simulation scenarios
• Online Book: osrf.github.io/ros2multirobotbook -- detailed A-Z guide

When to Use Open-RMF?

Should use when:

• Factory has robots from 2+ different manufacturers
• Need automatic traffic management at intersections
• Team has ROS 2 experience and wants full control

Consider alternatives when:

• Only robots from single manufacturer -- use their fleet manager
• No ROS 2 expertise -- learning curve is steep
• Need 24/7 support -- commercial solutions have SLA

VnRobo is integrating Open-RMF into fleet management solution, combined with real-time monitoring dashboard, creating product suitable for Vietnamese factories -- where multi-vendor fleet is becoming standard.

Related Posts

• Robot Fleet Management Overview -- Fleet management concepts
• Kubernetes for Robot Fleet: Orchestration at Scale -- Deploy and manage fleet software with K3s
• Multi-robot Coordination: Task Allocation Algorithms -- Task allocation algorithms from Hungarian to RL