← Back to Home

OOMWOO — Build Your Own Open-Source Robot Vacuum Cleaner with ROS2 and LiDAR

2026-07-17

OOMWOO — Build Your Own Open-Source Robot Vacuum Cleaner with ROS2 and LiDAR

What is OOMWOO?

OOMWOO is an open-source, DIY robot vacuum cleaner you build yourself using off-the-shelf parts, a 3D-printed chassis, and the Robot Operating System 2 (ROS2). With 4372 GitHub stars in just over a month, it has captured the maker community's imagination by promising a truly local, cloud-free, vendor-independent vacuum that you own from the PCB up.

The name "OOMWOO" is a rotational ambigram — it reads the same when flipped 180°, just like the robot roaming your floor in every direction. Sponsored by makerspet.com and remake.ai, the project is built entirely in public with a modular, community-driven design.

OOMWOO Architecture

Why is it Trending?

Robot vacuums have become a commodity, but they come with strict vendor lock-in. Your Roomba sends maps to the cloud. Your Dreame phone-home for features. OOMWOO flips this: every line of code, every PCB trace, every 3D-printed part is open. You can repair it, upgrade the LiDAR, replace the motors, or add a robotic arm — all without asking permission.

The timing is perfect: affordable 2D LiDAR sensors, powerful single-board computers, and mature ROS2 tooling have converged to make a DIY vacuum genuinely competitive with consumer models.

Architecture Overview

OOMWOO uses a dual-processor split architecture that mirrors how commercial vacuums are built, with a critical design principle: safety never depends on Linux or ROS2.

CPU (Compute Module)

  • Raspberry Pi CM4 or CM5 (or any pin-compatible module: Radxa CM3, Pine64 SOQuartz)
  • Runs ROS2, SLAM Toolbox for LiDAR-based mapping, and Nav2 for autonomous navigation
  • Handles LiDAR data (UART, ~5 Hz), camera feeds (MIPI), and IMU processing
  • Minimum target: 4 GB RAM (2 GB stretch goal via ROS2 node composition)
  • Cooling via the suction fan's airflow — no dedicated fan needed

MCU (Real-Time / Safety Controller)

  • STM32G070RBT6 running FreeRTOS with static memory allocation
  • Owns all motors, encoders, bumper/cliff/wheel-drop sensors, and battery charging control
  • Communicates with the CPU via a custom high-speed serial protocol (not micro-ROS)
  • Hard safety lives here: independently stops motors on bumper hit, cliff detection, or wheel-drop; current-limits a stuck brush; watchdogs the CPU

Sensors and Actuators

  • 2D LiDAR (UART, ~5 Hz, 360°) for SLAM mapping
  • MIPI camera(s) for future object detection and obstacle avoidance
  • IMU for odometry and orientation
  • Drive motors (left/right wheels), suction fan, and roller brush
  • Bumper, cliff detector, wheel-drop sensors, IR sensors

Power

  • 4S2P Li-ion battery pack with built-in BMS (~14.4 V, ~5200 mAh / ~75 Wh)
  • Charged via 16.8 V CC/CV with NTC temperature sensing

Smart Home Integration

  • Native Home Assistant support (Phase 2)
  • Optional educational profile: swap the CM4/5 for an ESP32-S3 running micro-ROS, with SLAM processed offboard on a dev PC over Wi-Fi

Prerequisites

Before diving in, you'll need:

Component Details
Compute Raspberry Pi CM4/5 (4 GB+) or pin-compatible module
MCU STM32G070RBT6 or similar (on the I/O carrier board)
LiDAR Affordable 2D LiDAR (supported by kaiaai/LDS libraries)
Chassis 3D printer (FDM, ~349 mm round body)
Motors Sourced wheel motors, suction fan, roller brush
Battery 4S2P Li-ion pack with built-in BMS
Software ROS2 Humble or later, Ubuntu 22.04+/Debian 12
Skills Basic electronics, 3D printing, ROS2 fundamentals

Note: The hardware BoM is still being finalized. For now, you can start with the simulation environment described below.

Setting Up the Simulation Environment

Even without physical hardware, you can run the OOMWOO robot in a Gazebo simulation. This lets you test SLAM mapping, navigation, and cleaning behavior entirely in software.

1. Install ROS2 and Gazebo

Follow the official ROS2 installation guide for your platform:

# Ubuntu 24.04 example
sudo apt install software-properties-common
sudo add-apt-repository universe
sudo apt update && sudo apt install ros-jazzy-desktop python3-rosdep
sudo rosdep init && rosdep update
echo "source /opt/ros/jazzy/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Clone the OOMWOO Simulation

git clone https://github.com/makerspet/oomwoo-one.git
cd oomwoo-one
rosdep install --from-paths src --ignore-src -r -y
colcon build
source install/setup.bash

3. Launch the Gazebo Simulation

ros2 launch oomwoo_one gazebo.launch.py

This launches the robot in a residential-layout world with:

  • Full URDF model (~349 mm round chassis)
  • LiDAR sensor publishing scan data
  • Differential drive controller
  • Odometry and TF frames

4. Teleoperate the Robot

In another terminal:

ros2 run teleop_twist_keyboard teleop_twist_keyboard

Use the keyboard arrows to drive the simulated vacuum around.

5. Run SLAM for Mapping

ros2 launch slam_toolbox online_async.launch.py

Watch the LiDAR scan lines build a map of the simulation environment in real time.

6. Install the Full Development Environment

For the complete OOMWOO development setup:

git clone https://github.com/makerspet/oomwoo-install.git
cd oomwoo-install
./install.sh

This installs all dependencies including ROS2 packages, SLAM Toolbox, Nav2, and the URDF model.

How to Contribute

OOMWOO is built entirely by the community. The project is organized into modules that can be worked on independently:

Module Status Description
URDF + Gazebo Sim ✅ In progress Robot model, simulation world, sensor plugins
Clean and Map 🟢 Ready Coverage cleaning while SLAM-mapping
Dock Cycle 🟢 Ready Undock, return-to-dock, precise docking
Recovery Behaviors 🟢 Ready Safety ladder, pause-and-alert, stuck detection
Floor Handling 🟢 Ready Edge cleaning, carpet detection, mop control
I/O PCB ✅ In progress KiCad carrier board with CM4 socket + STM32
Compute Benchmark ✅ In progress Memory reduction, ROS2 composable nodes

To contribute: pick a module, announce it in GitHub Discussions, build it in your own repo, and send a short PR linking it. The best solution for each module surfaces over time.

Architecture Diagram

The architecture diagram above illustrates the complete system design:

  • Top row: 2D LiDAR, Camera/IMU/Audio, and optional Wi-Fi (educational ESP32-S3 mode)
  • Upper middle: CPU running ROS2 Core, SLAM Toolbox, Nav2, and Gazebo Sim
  • Lower middle: MCU handling motor control, safety monitoring, and battery/charging
  • Bottom row: Drive motors, safety sensors, and battery pack
  • Right side: Home Assistant integration (Phase 2)

Data flows from sensors → CPU (via UART, MIPI, I²C) → MCU (via custom serial protocol) → motors and actuators. A bus distribution pattern ensures clean routing without crossing arrows.

OOMWOO vs Commercial Alternatives

Feature OOMWOO Roomba j7+ Dreame X40 Ultra
Open source ✅ Full ❌ Proprietary ❌ Proprietary
Cloud dependency ❌ None ✅ Required ✅ Partially
LiDAR SLAM ✅ 2D LiDAR ❌ Camera-based ✅ Yes
Home Assistant ✅ Native ❌ Via hack ❌ Via hack
Repairable ✅ 3D-printable ❌ Disposable ❌ Difficult
Cost (DIY) ~$200-400 ~$600 ~$1000
ROS2 ✅ Native ❌ ❌

Resources

OOMWOO is at the design/RFC stage. The simulation environment is ready today — jump in, contribute a module, and be part of building the world's first truly open robot vacuum.

← Retour à l'Accueil

OOMWOO — Construisez Votre Propre Aspirateur Robot Open-Source avec ROS2 et LiDAR

2026-07-17

OOMWOO — Construisez Votre Propre Aspirateur Robot Open-Source avec ROS2 et LiDAR

Qu'est-ce que OOMWOO ?

OOMWOO est un aspirateur robot open-source DIY que vous construisez vous-même avec des pièces standard, un châssis imprimé en 3D et le Robot Operating System 2 (ROS2). Avec 4372 étoiles GitHub en un peu plus d'un mois, il a captivé l'imagination de la communauté maker en promettant un aspirateur vraiment local, sans cloud et sans dépendance envers un fournisseur — que vous possédez de la carte PCB aux roues.

Le nom « OOMWOO » est un ambigramme rotationnel — il se lit de la même façon retourné à 180°, comme le robot qui parcourt votre sol dans toutes les directions. Sponsorisé par makerspet.com et remake.ai, le projet est entièrement construit en public avec une conception modulaire et communautaire.

Architecture OOMWOO

Pourquoi cet engouement ?

Les aspirateurs robots sont devenus des produits de grande consommation, mais ils imposent un verrouillage propriétaire. Votre Roomba envoie ses cartes vers le cloud. Votre Dreame téléphone à la maison pour certaines fonctionnalités. OOMWOO inverse cette tendance : chaque ligne de code, chaque piste de PCB, chaque pièce imprimée en 3D est ouverte. Vous pouvez le réparer, améliorer le LiDAR, remplacer les moteurs ou ajouter un bras robotique — sans demander la permission.

Le moment est idéal : les capteurs LiDAR 2D abordables, les ordinateurs monocarte puissants et les outils ROS2 matures convergent pour rendre un aspirateur DIY véritablement compétitif avec les modèles commerciaux.

Architecture

OOMWOO utilise une architecture à double processeur qui reflète la conception des aspirateurs commerciaux, avec un principe de conception critique : la sécurité ne dépend jamais de Linux ou ROS2.

CPU (Module de calcul)

  • Raspberry Pi CM4 ou CM5 (ou tout module compatible : Radxa CM3, Pine64 SOQuartz)
  • Exécute ROS2, SLAM Toolbox pour la cartographie LiDAR et Nav2 pour la navigation autonome
  • Gère les données LiDAR (UART, ~5 Hz), les flux caméra (MIPI) et le traitement IMU
  • Cible minimale : 4 Go de RAM (objectif extensible de 2 Go via composition de nœuds ROS2)
  • Refroidissement par le flux d'air du ventilateur d'aspiration — aucun ventilateur dédié nécessaire

MCU (Contrôleur temps réel / Sécurité)

  • STM32G070RBT6 exécutant FreeRTOS avec allocation mémoire statique
  • Possède tous les moteurs, codeurs, capteurs de pare-chocs/précipice/roue et le contrôle de charge de la batterie
  • Communique avec le CPU via un protocole série personnalisé à haute vitesse (pas micro-ROS)
  • La sécurité matérielle réside ici : arrête indépendamment les moteurs en cas de choc, détection de précipice ou chute de roue ; limite le courant d'une brosse bloquée ; surveille le CPU

Capteurs et actionneurs

  • LiDAR 2D (UART, ~5 Hz, 360°) pour la cartographie SLAM
  • Caméra(s) MIPI pour la détection d'objets et l'évitement d'obstacles
  • IMU pour l'odométrie et l'orientation
  • Moteurs de roue (gauche/droite), ventilateur d'aspiration et brosse rotative
  • Capteurs de pare-chocs, de précipice, de chute de roue et infrarouges

Alimentation

  • Batterie Li-ion 4S2P avec BMS intégré (~14,4 V, ~5200 mAh / ~75 Wh)
  • Charge via CC/CV 16,8 V avec sonde de température NTC

Intégration domotique

  • Support natif Home Assistant (Phase 2)
  • Profil éducatif optionnel : remplacez le CM4/5 par un ESP32-S3 exécutant micro-ROS, avec SLAM traitée sur un PC de développement via Wi-Fi

Prérequis

Composant Détails
Calcul Raspberry Pi CM4/5 (4 Go+) ou module compatible
MCU STM32G070RBT6 ou similaire (sur la carte porteuse I/O)
LiDAR LiDAR 2D abordable (supporté par les bibliothèques kaiaai/LDS)
Châssis Imprimante 3D (FDM, corps rond ~349 mm)
Moteurs Moteurs de roue, ventilateur d'aspiration, brosse rotative
Batterie Batterie Li-ion 4S2P avec BMS intégré
Logiciel ROS2 Humble ou ultérieur, Ubuntu 22.04+/Debian 12
Compétences Électronique de base, impression 3D, notions ROS2

Note : La nomenclature matérielle (BoM) est encore en cours de finalisation. Pour l'instant, vous pouvez commencer avec l'environnement de simulation décrit ci-dessous.

Configuration de l'environnement de simulation

Même sans matériel physique, vous pouvez exécuter le robot OOMWOO dans une simulation Gazebo. Cela vous permet de tester la cartographie SLAM, la navigation et le comportement de nettoyage entièrement dans un environnement logiciel.

1. Installer ROS2 et Gazebo

Suivez le guide d'installation officiel ROS2 pour votre plateforme :

# Exemple Ubuntu 24.04
sudo apt install software-properties-common
sudo add-apt-repository universe
sudo apt update && sudo apt install ros-jazzy-desktop python3-rosdep
sudo rosdep init && rosdep update
echo "source /opt/ros/jazzy/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Cloner la simulation OOMWOO

git clone https://github.com/makerspet/oomwoo-one.git
cd oomwoo-one
rosdep install --from-paths src --ignore-src -r -y
colcon build
source install/setup.bash

3. Lancer la simulation Gazebo

ros2 launch oomwoo_one gazebo.launch.py

Ceci lance le robot dans un monde résidentiel avec :

  • Modèle URDF complet (châssis rond ~349 mm)
  • Capteur LiDAR publiant les données de scan
  • Contrôleur de transmission différentielle
  • Odométrie et trames TF

4. Téléopérer le robot

Dans un autre terminal :

ros2 run teleop_twist_keyboard teleop_twist_keyboard

Utilisez les flèches du clavier pour déplacer l'aspirateur simulé.

5. Exécuter SLAM pour la cartographie

ros2 launch slam_toolbox online_async.launch.py

Regardez les lignes de scan LiDAR construire une carte de l'environnement de simulation en temps réel.

6. Installer l'environnement de développement complet

git clone https://github.com/makerspet/oomwoo-install.git
cd oomwoo-install
./install.sh

Ceci installe toutes les dépendances, y compris les paquets ROS2, SLAM Toolbox, Nav2 et le modèle URDF.

Comment contribuer

OOMWOO est entièrement construit par la communauté. Le projet est organisé en modules qui peuvent être développés indépendamment :

Module Statut Description
URDF + Simulation Gazebo ✅ En cours Modèle robot, monde de simulation, plugins capteurs
Nettoyage et cartographie 🟢 Prêt Nettoyage de couverture avec cartographie SLAM
Cycle de station 🟢 Prêt Désamarrage, retour à la station, amarrage précis
Comportements de sécurité 🟢 Prêt Procédure de sécurité, pause-alerte, détection de blocage
Gestion des sols 🟢 Prêt Nettoyage des bords, détection de moquette, contrôle de la serpillière
PCB E/S ✅ En cours Carte porteuse KiCad avec socket CM4 + STM32
Benchmark de calcul ✅ En cours Réduction mémoire, nœuds ROS2 composables

Pour contribuer : choisissez un module, annoncez-le dans GitHub Discussions, construisez-le dans votre propre dépôt et envoyez une courte PR qui le lie. La meilleure solution pour chaque module émerge avec le temps.

OOMWOO vs Alternatives Commerciales

Fonctionnalité OOMWOO Roomba j7+ Dreame X40 Ultra
Open source ✅ Complet ❌ Propriétaire ❌ Propriétaire
Dépendance cloud ❌ Aucune ✅ Requise ✅ Partielle
SLAM LiDAR ✅ LiDAR 2D ❌ Caméra ✅ Oui
Home Assistant ✅ Natif ❌ Via bidouille ❌ Via bidouille
Réparable ✅ Imprimable 3D ❌ Jetable ❌ Difficile
Coût (DIY) ~200-400$ ~600$ ~1000$
ROS2 ✅ Natif ❌ ❌

Ressources

OOMWOO est au stade de conception/RFC. L'environnement de simulation est disponible dès aujourd'hui — plongez, contribuez à un module et faites partie de la construction du premier aspirateur robot vraiment ouvert au monde.