At Ekumen, we thrive on turning “what if” into “what is”. Our latest breakthrough takes one of our favorite educational platforms—the Andino robot—and elevates it from a single-robot navigator to a member of a perfectly synchronized, multi-robot fleet.
In this post, we’re pulling back the curtain on how we bridged the gap between Nav2 (the standard navigation stack for ROS 2) and Open-RMF (the gold standard for global orchestration) to build a robust, production-ready fleet management system.
The Challenge: When One Robot Isn’t Enough
Nav2 is great at getting a single robot from A to B while dodging obstacles. But as soon as you add a second or tenth robot to the same floor, “local navigation” quickly turns into “gridlock”. Without a central brain, robots become their own biggest obstacles, causing deadlocks at narrow doorways and traffic jams in busy corridors.
To solve this, we integrated Open-RMF (Robotics Middleware Framework). By choosing ROS 2 over traditional Web APIs, we ensured a high-performance, native connection that acts as the “air traffic controller” for the warehouse. Our mission? Create a reusable, scalable template that allows any Nav2-powered fleet to be managed by Open-RMF with ease.
Our Approach: The Architectural “Bridge”
Scaling a fleet isn’t just about adding more robots; it’s about creating a language they all understand. We developed a multi-layered architecture that keeps high-level strategy separate from low-level execution:
- Open-RMF Core: The central strategist, handling task dispatching and global traffic.
- Fleet Adapter: The translator. It takes Open-RMF’s high-level plans and converts them into actionable robot commands.
- Fleet Manager: The command center. This unified ROS 2 interface abstracts away the complexity of individual robots, making the entire fleet look like one cohesive system.
- Robot Handler: The field agent. Dedicated to each robot, it communicates directly with the Nav2 stack to execute precise movements.
This “Bridge” architecture is the secret sauce: Open-RMF doesn’t need to know the physics of an Andino, and the Andino doesn’t need to know it’s part of a global orchestration. It just works.
Overcoming the “Real World” Hurdles
Bridging these systems required more than just connecting pipes; it required solving the classic “gotchas” of robotics:
1. The Geometry Problem: Synchronizing Coordinate Frames
RMF lives in a building-wide coordinate system, while robots live in their local maps. Even a slight mismatch can lead to a robot trying to drive through a wall. We utilized the nudged Python library to calculate precise transformations between these worlds, ensuring that an RMF waypoint translates perfectly to a Nav2 goal every single time.
2. The Communication Problem: Bridging Paths and Actions
Open-RMF provides a full, timed path, but Nav2 typically expects a single destination. Our RobotCommandHandle implements a sophisticated state machine that “trickle-feeds” waypoints to the Fleet Manager. This allows RMF to maintain strict schedule control while letting Nav2 handle the heavy lifting of local path planning and obstacle avoidance.
3. The Scalability Problem: Unified Management
By introducing the Andino Fleet Manager, we’ve made scaling effortless. Adding a new robot to your fleet no longer requires manual code changes—it’s as simple as updating a configuration file. The system grows with your needs.
The Result: Harmony in Motion
The result is more than just “robots moving”. It’s a fleet of Andinos working in total harmony. They negotiate tight spaces, wait patiently for their turn at intersections, and report their health (like battery levels) back to a central dashboard.
See it in Action: The Andino Fleet Demo
To truly appreciate the coordination Open-RMF brings to the fleet, we’ve prepared a demo that showcases a real-world scenario in a simulated office environment.
In this video, you can observe several key coordination behaviors:
- Strategic Task Allocation: Open-RMF receives a command to move a robot from room 2 to room 6. It intelligently selects andino3 for the task.
- Concurrent Operations: Shortly after, a second command is issued to move from room 5 to room 1, and andino1 is assigned. Both robots begin their journeys simultaneously.
- Dynamic Conflict Resolution: Watch as andino3 approaches andino4. To avoid a potential collision and clear the path, andino4 is proactively moved to a nearby waypoint further from andino3’s path. Once the way is clear, it returns to its original position.
This synchronization ensures that the fleet operates as a single, cohesive unit rather than a group of independent agents.
Because we built this on standard ROS 2 and Nav2 interfaces, this isn’t just an “Andino solution”—it’s a universal template for any Nav2-powered robot.
Build the Future of Your Fleet
We’re committed to open-source excellence, which is why the entire project is available for you to explore. Whether you’re an engineer looking for a reference implementation or a company ready to deploy a fleet, our repository is the perfect starting point.
- Explore the Code: andino_rmf on GitHub
- Dive Deeper: Learn about OpenRMF on this blogpost: Deep Dive into Open-RMF
Ready to take your fleet to the next level?
Coordination doesn’t have to be complicated. At Ekumen, we specialize in building the bridges that make complex robotics simple. From custom Fleet Adapters to full-scale RMF deployments, we’re here to help you build the future.
Interested in Open-RMF or Nav2 for your next project? Connect with the experts at Ekumen. Let’s get your fleet moving.