Mastering ROS for Robotics Programming

Introduction to ROS
- Why ROS?
Installing and Setting Up ROS
Understanding ROS Concepts
ROS Programming Basics
Interfacing with Hardware
Advanced ROS Features
Integrating ROS with AI and Machine Learning
Debugging and Testing in ROS
Best Practices for ROS Development
Case Studies and Real-World Applications
Future of ROS and Robotics
Conclusion
Additional Resources

Introduction to ROS

The Robot Operating System (ROS) is not an operating system in the traditional sense but rather a flexible framework for writing robot software. Initially developed in 2007 by the Stanford Artificial Intelligence Laboratory, ROS has evolved into a robust ecosystem supported by a vast community of developers and researchers. Its modular architecture encourages the development of reusable software components, enabling rapid prototyping and innovation in robotics.

Why ROS?

Modularity: ROS promotes a modular approach, where different functionalities are encapsulated into nodes that communicate over well-defined interfaces.
Community and Ecosystem: A rich repository of packages and tools contributed by the community accelerates development.
Cross-Platform Support: While primarily associated with Linux, ROS has extended support to other platforms, including Windows and macOS.
Integration Capabilities: ROS seamlessly integrates with various programming languages, simulation tools, and hardware interfaces.

Mastering ROS is pivotal for anyone aiming to delve into robotics programming, as it lays the foundation for building scalable and efficient robotic systems.

Installing and Setting Up ROS

Before diving into ROS programming, it’s essential to install and set up the ROS environment correctly. This section outlines the system requirements, installation steps, and workspace configuration.

System Requirements

Operating System: ROS predominantly supports Ubuntu distributions. As of the latest releases, Ubuntu 20.04 (Focal) and Ubuntu 22.04 (Jammy) are widely supported.
Hardware: A modern multi-core processor, at least 8 GB of RAM, and sufficient storage (minimum 20 GB) are recommended, especially when running simulations.
Dependencies: Development tools like git, build-essential, and others are required.

Installation Steps

Configure Ubuntu Repositories

Ensure that Ubuntu repositories are set up correctly:

bash sudo apt update sudo apt install software-properties-common sudo add-apt-repository universe sudo apt update

Setup Sources

Add the ROS repository to your system:

bash sudo apt install curl curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add - sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

Install ROS

Update package lists and install ROS. For instance, to install ROS Noetic:

bash sudo apt update sudo apt install ros-noetic-desktop-full

Note: Replace noetic with the desired ROS distribution, such as melodic, foxy, or galactic, depending on compatibility with your system.

Initialize rosdep

bash sudo apt install python3-rosdep sudo rosdep init rosdep update

Environment Setup

Add ROS environment variables to your bash session:

bash echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc source ~/.bashrc

Install Dependencies for Building Packages

bash sudo apt install python3-rosinstall python3-rosinstall-generator python3-wstool build-essential

Setting Up Your Workspace

A ROS workspace is a directory where you can build and store your ROS packages.

Create the Workspace Directory

bash mkdir -p ~/catkin_ws/src cd ~/catkin_ws/ catkin_make

Source the Workspace

Add the workspace to your environment:

bash echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc source ~/.bashrc

Verify the Setup

Launch a simple ROS core to ensure everything is set up correctly:

bash roscore

If roscore starts without errors, your ROS environment is correctly installed.

Understanding ROS Concepts

ROS introduces several core concepts and abstractions that facilitate modular and distributed robotic applications. Grasping these concepts is crucial for effective ROS programming.

Nodes

Definition: Nodes are the fundamental building blocks in ROS. Each node is a separate process that performs computation. Nodes communicate with each other to achieve complex behaviors.
Functionality: A robot’s hardware abstraction, sensor processing, decision-making algorithms, and actuations are typically handled by different nodes.
Lifecycle: Nodes can be started, stopped, and restarted independently, promoting robustness and flexibility.

Topics

Definition: Topics are named buses over which nodes exchange messages. They provide a publish-subscribe communication model.
Publishers and Subscribers: Nodes can publish messages to a topic or subscribe to receive messages from a topic.
Use Cases: Sensor data streaming (e.g., camera feeds), state updates, and command signals are commonly transmitted through topics.

Services

Definition: Services provide a synchronous remote procedure call (RPC) mechanism in ROS.
Request-Response Model: A service client sends a request message to a service server and waits for a response.
Use Cases: Actions that require confirmation, such as resetting a robot’s position or fetching configuration parameters.

Actions

Definition: Actions are similar to services but support asynchronous operations with feedback and the ability to preempt (cancel) ongoing tasks.
Structure: An action consists of a goal, result, and feedback messages.
Use Cases: Long-running tasks like navigation, path planning, or manipulation actions where periodic feedback is beneficial.

Messages

Definition: Messages are data structures used for communication between nodes. They define the format of data transmitted over topics and services.
Standard and Custom Messages: ROS provides a set of standard message types, but developers can define custom message types tailored to specific application needs.
Serialization: Messages are serialized for transmission and deserialized upon reception.

Parameters

Definition: Parameters are variables that store configuration values for nodes. They can be set at runtime or defined in configuration files.
Parameter Server: A shared database accessible to all nodes, facilitating the retrieval and modification of parameters.
Use Cases: Configuration settings like sensor calibration data, algorithm parameters, and operational modes.

Understanding and effectively utilizing these ROS concepts is fundamental to building scalable and maintainable robotics applications.

ROS Programming Basics

ROS supports multiple programming languages, with Python and C++ being the most prevalent. This section covers the basics of ROS programming in these languages and guides you through creating and managing ROS packages.

ROS in Python

Python provides ease of use and rapid development capabilities, making it suitable for high-level functionalities and scripting.

Creating a Python Node

“`python
#!/usr/bin/env python3
import rospy
from std_msgs.msg import String

def talker():
pub = rospy.Publisher(‘chatter’, String, queue_size=10)
rospy.init_node(‘talker’, anonymous=True)
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown():
hello_str = “hello world %s” % rospy.get_time()
rospy.loginfo(hello_str)
pub.publish(hello_str)
rate.sleep()

if name == ‘main‘:
try:
talker()
except rospy.ROSInterruptException:
pass
“`

Running the Node

Make the script executable and run it:

bash chmod +x talker.py rosrun your_package talker.py

ROS in C++

C++ offers performance advantages, making it suitable for real-time processing and resource-constrained environments.

Creating a C++ Node

“`cpp
#include “ros/ros.h”
#include “std_msgs/String.h”
#include

int main(int argc, char **argv)
{
ros::init(argc, argv, “talker”);
ros::NodeHandle n;
ros::Publisher chatter_pub = n.advertise(“chatter”, 1000);
ros::Rate loop_rate(10);

   int count = 0;
   while (ros::ok())
   {
       std_msgs::String msg;
       std::stringstream ss;
       ss << "hello world " << count;
       msg.data = ss.str();
       ROS_INFO("%s", msg.data.c_str());
       chatter_pub.publish(msg);
       ros::spinOnce();
       loop_rate.sleep();
       ++count;
   }

   return 0;

}
“`

Building and Running the Node

Add the source file to your package, modify the CMakeLists.txt, build the workspace, and run the node:

bash cd ~/catkin_ws catkin_make source devel/setup.bash rosrun your_package talker

Creating and Managing Packages

Packages are the primary unit of organization in ROS, encapsulating nodes, libraries, datasets, and configurations.

Creating a New Package

bash cd ~/catkin_ws/src catkin_create_pkg your_package rospy std_msgs

This command creates a new package named your_package with dependencies on rospy and std_msgs.

Directory Structure

A typical package contains directories like src/, include/, msg/, srv/, and configuration files such as CMakeLists.txt and package.xml.

Building the Package

After adding your code and dependencies, build the workspace:

bash cd ~/catkin_ws catkin_make

Managing Dependencies

Define all dependencies in the package.xml file and ensure they are installed via rosdep:

bash rosdep install --from-paths src --ignore-src -r -y

Mastering package creation and management is essential for maintaining organized and scalable ROS projects.

Interfacing with Hardware

One of ROS’s strengths is its ability to interface seamlessly with diverse hardware components, enabling the integration of sensors, actuators, and controllers into robotic systems.

Working with Sensors

Sensors provide essential data about the robot’s environment and internal states. ROS supports a wide range of sensors, including cameras, LiDARs, IMUs, and more.

Camera Integration

Use the cv_bridge package to convert ROS image messages to OpenCV formats for image processing.

“`python
import rospy
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import cv2

def image_callback(msg):
bridge = CvBridge()
cv_image = bridge.imgmsg_to_cv2(msg, desired_encoding=’bgr8′)
cv2.imshow(“Camera Feed”, cv_image)
cv2.waitKey(1)

rospy.init_node(‘camera_listener’)
rospy.Subscriber(“/camera/image_raw”, Image, image_callback)
rospy.spin()
“`

LiDAR Integration

Tools like hector_slam and velodyne drivers facilitate LiDAR data processing and mapping.

bash sudo apt install ros-noetic-velodyne

Configure and launch the LiDAR driver as per your hardware specifications.

Actuators and Controllers

Actuators, such as motors and servos, enable the robot to interact with its environment. ROS leverages controllers for precise actuator management.

Joint Control with ros_control

The ros_control framework provides standardized interfaces for hardware abstraction.

xml <transmission name="transmission1"> <type>transmission_interface/SimpleTransmission</type> <joint name="joint1"> <hardwareInterface>PositionJointInterface</hardwareInterface> </joint> <actuator name="actuator1"> <hardwareInterface>PositionJointInterface</hardwareInterface> </actuator> </transmission>

Motor Drivers

Integrate motor drivers by publishing velocity commands to the appropriate topics.

“`python
import rospy
from geometry_msgs.msg import Twist

rospy.init_node(‘motor_controller’)
pub = rospy.Publisher(‘/cmd_vel’, Twist, queue_size=10)
rate = rospy.Rate(10)
while not rospy.is_shutdown():
twist = Twist()
twist.linear.x = 0.5
twist.angular.z = 0.1
pub.publish(twist)
rate.sleep()
“`

Custom Hardware Integration

For robots with proprietary or specialized hardware, developers often need to create custom ROS drivers.

Creating a Custom Driver

Develop a ROS node that interfaces with the hardware’s communication protocol (e.g., serial, CAN bus).

“`cpp
#include “ros/ros.h”
#include “std_msgs/String.h”
#include

int main(int argc, char **argv)
{
ros::init(argc, argv, “custom_driver”);
ros::NodeHandle nh;
serial::Serial ser;
ser.setPort(“/dev/ttyUSB0”);
ser.setBaudrate(115200);
serial::Timeout to = serial::Timeout::simpleTimeout(1000);
ser.setTimeout(to);
ser.open();

   ros::Publisher pub = nh.advertise<std_msgs::String>("sensor_data", 1000);
   ros::Rate loop_rate(10);

   while (ros::ok())
   {
       std::string data = ser.read(ser.available());
       std_msgs::String msg;
       msg.data = data;
       pub.publish(msg);
       ros::spinOnce();
       loop_rate.sleep();
   }
   return 0;

}
“`

Handling Communication

Ensure robust error handling and synchronization when interfacing with hardware to maintain system stability.

Interfacing with hardware is a critical aspect of robotics programming. ROS provides the flexibility and tools necessary to integrate a wide array of hardware components effectively.

Advanced ROS Features

Beyond the basics, ROS offers a suite of advanced features and tools that facilitate complex robotic behaviors, including navigation, manipulation, simulation, and visualization.

The ROS Navigation Stack provides algorithms and tools for autonomous navigation, enabling robots to move safely and efficiently in their environments.

Core Components
Localization: Determining the robot’s position using techniques like AMCL (Adaptive Monte Carlo Localization).
Mapping: Creating occupancy grids or other map representations using SLAM (Simultaneous Localization and Mapping).
Path Planning: Generating feasible paths from the current position to a goal.
Obstacle Avoidance: Dynamically avoiding obstacles while following paths.
Setting Up Navigation

Configure the move_base node with appropriate parameters, including global and local planners, costmaps, and sensor integrations.

bash roslaunch turtlebot3_navigation turtlebot3_navigation.launch map_file:=/path/to/map.yaml

Using RViz for Navigation

Use RViz to visualize the robot’s position, path, and sensor data, facilitating debugging and monitoring.

MoveIt! for Manipulation

MoveIt! is a powerful framework for robot manipulation, providing capabilities for motion planning, kinematics, and control.

Features of MoveIt!
Motion Planning: Generate collision-free paths for robot arms.
Inverse Kinematics: Calculate joint configurations for desired end-effector positions.
Grasping: Plan grasps for object manipulation.
Collision Detection: Ensure planned motions do not result in collisions.
Integrating MoveIt!

Set up MoveIt! for your robot using the MoveIt! Setup Assistant, which guides you through robot description, planning groups, and end-effectors.

bash roslaunch moveit_setup_assistant setup_assistant.launch

Executing Manipulation Tasks

Use MoveIt!’s APIs to execute pick-and-place tasks, orchestrating multiple manipulation actions seamlessly.

Simulation with Gazebo

Gazebo is a high-fidelity physics simulator that integrates tightly with ROS, allowing for realistic testing and development without physical hardware.

Features of Gazebo
Physics Engine: Simulate dynamics, collisions, and sensors accurately.
3D Visualization: Render robots and environments in three dimensions.
Extensibility: Add custom models, plugins, and sensors.
Running a Simulation

Launch a Gazebo simulation with your robot model:

bash roslaunch your_robot_gazebo your_robot_world.launch

Interacting with the Simulation

Control the simulated robot using ROS topics, visualize sensor data in RViz, and debug using ROS tools.

ROS Visualization with RViz

RViz is a 3D visualization tool for ROS, enabling developers to visualize sensor data, robot states, and planning outcomes.

Using RViz

Launch RViz and add desired display elements like laserscans, maps, robot models, and trajectories.

bash rosrun rviz rviz

Customization

Tailor RViz interfaces to display specific data relevant to your application, enhancing monitoring and debugging capabilities.

Advanced ROS features like navigation, manipulation, simulation, and visualization are indispensable for building sophisticated and autonomous robotic systems.

Integrating ROS with AI and Machine Learning

The convergence of ROS with artificial intelligence (AI) and machine learning (ML) unlocks new potentials in robotics, enabling intelligent perception, decision-making, and adaptability.

Perception and Computer Vision

Integrating AI-driven perception allows robots to understand and interpret their environment.

Object Detection and Recognition

Utilize deep learning models within ROS nodes to detect and classify objects.

“`python
import rospy
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import cv2
import tensorflow as tf

def image_callback(msg):
bridge = CvBridge()
cv_image = bridge.imgmsg_to_cv2(msg, desired_encoding=’bgr8′)
# Preprocess and run the model
predictions = model.predict(processed_image)
# Publish or act on predictions

rospy.init_node(‘object_detector’)
rospy.Subscriber(“/camera/image_raw”, Image, image_callback)
rospy.spin()
“`

Semantic Segmentation

Implement segmentation algorithms to differentiate various objects and regions within sensor data.

Path Planning and Decision Making

Machine learning enhances path planning by enabling robots to adapt to dynamic environments and optimize their routes.

Reinforcement Learning for Navigation

Train agents using reinforcement learning to navigate complex environments with minimal supervision.

“`python
import gym
import rospy
from std_msgs.msg import String

# Define the environment and agent
“`

Behavior Trees

Employ behavior trees for modular and scalable decision-making processes in robotics tasks.

Reinforcement Learning in ROS

Reinforcement learning (RL) equips robots with the ability to learn optimal actions through trial and error.

Integrating RL Frameworks

Use frameworks like TensorFlow or PyTorch alongside ROS to develop RL-based controllers.

“`python
import rospy
import tensorflow as tf

# Define the RL agent and connect to ROS topics for state and action
“`

Simulation for Training

Leverage Gazebo simulations to train RL agents in safe and controlled environments before deployment on physical robots.

Integrating ROS with AI and machine learning paves the way for intelligent and autonomous robots capable of learning and adapting to their surroundings.

Debugging and Testing in ROS

Developing reliable robotic systems necessitates robust debugging and testing strategies to identify and rectify issues promptly.

ROS Logging

ROS provides a comprehensive logging system to monitor node activities and system states.

Logging Levels

Utilize different logging levels (DEBUG, INFO, WARN, ERROR, FATAL) to categorize messages based on severity.

python rospy.loginfo("This is an info message") rospy.logwarn("This is a warning") rospy.logerr("This is an error message")

Viewing Logs

Access logs using the rqt_console tool or by inspecting log files located in ~/.ros/log/.

bash rosrun rqt_console rqt_console

Unit Testing with rostest

Automate testing of ROS nodes and packages using rostest, which integrates with the gtest framework.

Creating a Test File

xml <launch> <test test-name="test_node" pkg="your_package" type="test_node"/> </launch>

Writing Test Cases

Implement test cases in C++ using gtest to verify node functionality.

“`cpp
#include
#include “ros/ros.h”

TEST(NodeTest, ExampleTest)
{
ASSERT_TRUE(ros::ok());
}

int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
ros::init(argc, argv, “test_node”);
return RUN_ALL_TESTS();
}
“`

Running Tests

Execute tests using the rostest command:

bash rostest your_package test_node.test

Simulation Testing

Utilize Gazebo simulations to test robotic behaviors in diverse scenarios without risking physical hardware.

Scenario Creation

Design various simulation scenarios that mimic real-world conditions, including obstacles, dynamic elements, and sensor noise.

Automated Testing

Develop scripts to automate testing sequences in simulations, ensuring consistency and repeatability.

Robust debugging and testing practices are essential for developing reliable and efficient robotic systems, enabling developers to identify issues early and maintain high-quality software standards.

Best Practices for ROS Development

Adhering to best practices ensures that ROS projects are maintainable, scalable, and collaborative. This section outlines essential guidelines for effective ROS development.

Code Organization

Modular Design

Structure your code into reusable and independent nodes, facilitating easier maintenance and testing.

Package Structuring

Follow ROS conventions for package structures, segregating scripts, launch files, configurations, and resources appropriately.

plaintext your_package/ ├── CMakeLists.txt ├── package.xml ├── src/ ├── scripts/ ├── launch/ ├── config/ └── launch/

Documentation

Code Comments

Include meaningful comments and docstrings in your code to explain functionality and logic.

ROS Wiki and README

Provide comprehensive documentation in the README.md and consider contributing to the ROS Wiki for broader visibility.

Usage Instructions

Detail installation steps, dependencies, configuration parameters, and usage examples to assist other developers and users.

Version Control and Collaboration

Git Integration

Use Git for version control, enabling tracking of changes, branching, and collaborative development.

bash git init git add . git commit -m "Initial commit"

Repository Hosting

Host your ROS packages on platforms like GitHub or GitLab, facilitating collaboration through pull requests and issue tracking.

Continuous Integration (CI)

Implement CI pipelines using tools like Travis CI or GitHub Actions to automate building, testing, and deploying ROS packages upon code changes.

Implementing these best practices fosters a productive development environment, enhances code quality, and streamlines collaborative efforts in ROS-based projects.

Case Studies and Real-World Applications

Understanding how ROS is applied in real-world scenarios provides valuable insights into its versatility and capabilities. This section explores several case studies across diverse industries.

Autonomous Vehicles

ROS is instrumental in developing autonomous vehicle systems, handling perception, localization, mapping, path planning, and control.

Perception Modules

Integrate sensor data from cameras, LiDARs, and radars to interpret the vehicle’s surroundings using ROS-based perception nodes.

Localization and Mapping

Implement SLAM algorithms with ROS to create and utilize maps for navigation and obstacle avoidance.

Control Systems

Develop ROS nodes that interface with vehicle actuators to execute steering, acceleration, and braking commands based on planned trajectories.

Industrial Automation

In industrial settings, ROS facilitates automation through robotic arms, conveyors, and assembly systems, enhancing efficiency and precision.

Robotic Manipulation

Utilize MoveIt! for motion planning and control of robotic arms employed in tasks like welding, assembly, and packaging.

Human-Robot Collaboration

Develop ROS nodes that enable safe and efficient collaboration between humans and robots on factory floors through sensor integration and intuitive interfaces.

Predictive Maintenance

Leverage ROS data streams and analytics to predict equipment failures and schedule maintenance proactively.

Service Robots

Service robots in healthcare, hospitality, and domestic environments benefit from ROS’s flexibility in handling diverse tasks and interactions.

Healthcare Robotics

Deploy ROS-based robots for tasks such as patient monitoring, assistance in physical therapy, and medication delivery, ensuring reliability and safety.

Hospitality Robots

Implement ROS-driven robots to serve guests, manage inventory, and navigate dynamic environments in hotels and restaurants.

Domestic Robots

Develop home robots for cleaning, security, and personalized assistance, utilizing ROS for integrating sensors, user interfaces, and autonomous behaviors.

These case studies exemplify ROS’s adaptability and robustness in addressing complex challenges across various robotics applications, underscoring its pivotal role in advancing the field.

Future of ROS and Robotics

The future of ROS and robotics is intertwined with advancements in artificial intelligence, machine learning, and hardware innovations. Several trends are shaping the trajectory of both ROS and the broader robotics landscape:

ROS 2 Evolution

With the ongoing development of ROS 2, which emphasizes real-time capabilities, security, and cross-platform support, ROS is poised to address the growing demands of modern robotic systems.

Integration with AI and ML

Enhanced integration with AI and machine learning frameworks is enabling more intelligent and adaptive robotic behaviors, pushing the boundaries of automation and autonomy.

Edge Computing and Distributed Systems

Leveraging edge computing will allow robots to process data locally, reducing latency and dependency on centralized systems, thereby enhancing performance and reliability.

Collaborative Robotics (Cobots)

The rise of collaborative robots capable of working alongside humans safely and efficiently is driving the development of ROS features focused on human-robot interaction and safety.

Standardization and Interoperability

Efforts towards standardizing interfaces and protocols within ROS are facilitating interoperability between different robotic systems and components, fostering a more cohesive ecosystem.

As robotics continues to evolve, ROS remains at the forefront, adapting and expanding to meet the emerging needs of researchers, developers, and industries worldwide.

Conclusion

Mastering ROS is a gateway to harnessing the full potential of robotics programming. Its comprehensive framework, supported by a vibrant community and an extensive array of tools and packages, empowers developers to build sophisticated and capable robotic systems. This guide has traversed the essentials of installing and setting up ROS, understanding its core concepts, programming in Python and C++, interfacing with hardware, leveraging advanced features, integrating AI and machine learning, and adhering to best practices. Whether you’re embarking on your robotics journey or looking to deepen your expertise, mastering ROS will equip you with the skills and knowledge to innovate and excel in the dynamic field of robotics.

Additional Resources

To further enhance your journey in mastering ROS for robotics programming, consider exploring the following resources:

Official ROS Documentation: https://docs.ros.org
ROS Tutorials: http://wiki.ros.org/ROS/Tutorials
ROS Answers (Q&A Community): https://answers.ros.org
MoveIt! Documentation: https://moveit.ros.org/documentation/
Gazebo Simulator: https://gazebosim.org
ROS Books:
Programming Robots with ROS by Morgan Quigley, Brian Gerkey, and William D. Smart
ROS Robotics By Example by Carol Fairchild and Dr. Thomas L. Harman
Online Courses:
Coursera’s ROS Specialization
Udemy’s ROS for Beginners
Community Forums and Groups:
ROS Discourse: https://discourse.ros.org
ROS Subreddit: https://www.reddit.com/r/ROS

Engage with these resources to stay updated, seek assistance, and continue expanding your ROS and robotics knowledge.

Kilgone Robot Vacuum and Mop Combo, WiFi/Alexa/App, Smart Robotic Vacuum Cleaner, Ultra-Slim & Quiet, Tangle-Free, Auto Recharge, Robot Vacuum Cleaner for Pet Hair/Carpet/Hard Floor

(110)

$149.99 (as of March 19, 2025 14:41 GMT +00:00 - )

Smart Robot Vacuum and Mop Combo, App Control, 3 Cleaning Modes, Anti-Fall Sensors, Multi-Surface Cleaning, Self-Charging, 700Pa Suction Ideal for Pet Hair, Soft and Hard Floors, Black

(57)

$102.07 (as of March 19, 2025 14:41 GMT +00:00 - )

Laresar Evol 3 Robot Vacuum with Replacement Parts, 1 Roller Brush, 2 Washable Mop Cloth, 2 Filters, 2 Side Brushes

$155.99 (as of March 19, 2025 14:41 GMT +00:00 - )

Fit For Loorow AT800 Robot Vacuum, 13pcs 4 Side Brushes 3 Filters & Mop Pads, Vacuum Parts & Accessories Fit For Loorow AT800 Accessories 3-In-1 Robot Vacuum

(1)

$22.58 (as of March 19, 2025 14:41 GMT +00:00 - )

iRobot Roomba Vac Robot Vacuum (Q0120) - Easy to use, Power-Lifting Suction, Multi-Surface Cleaning, Smart Navigation Cleans in Neat Rows, Self-Charging, Alexa

(50482)

$119.00 (as of March 19, 2025 14:41 GMT +00:00 - )

Table of Contents