ROS Bag

ROS Bags do not record the entire system state but instead capture data from specific ROS Topics. This allows engineers to log only the necessary sensor data (e.g., /camera/image_raw, /scan) and command streams, minimizing file size and focusing analysis.

• Selective Capture: Use the ros2 bag record -t <topic_name> command to record specific topics.
• Efficiency: Avoids logging internal debug topics, conserving storage.
• Use Case: Essential for isolating data from a malfunctioning perception node without capturing irrelevant actuator commands.

During playback, a ROS Bag publishes messages onto the live ROS graph with the same timestamps and inter-message delays as during the original recording. This creates a deterministic, repeatable simulation of past system behavior.

• Deterministic Replay: Enables exact reproduction of sensor streams for debugging intermittent faults.
• Simulation Input: A recorded bag file can serve as a high-fidelity sensor input for testing new perception algorithms offline.
• Tool: The ros2 bag play command handles this synchronization, optionally accelerating or looping the playback.

ROS Bags are a first-class citizen within the ROS 2 tooling ecosystem, enabling a seamless workflow from recording to visualization and analysis.

• CLI Tools: ros2 bag is the primary command-line interface for recording, playing, and inspecting bags.
• RViz Visualization: Played-back topics can be visualized in RViz just like live data, for replaying sensor feeds and robot trajectories.
• rqt_bag GUI: Provides a graphical interface for inspecting message timelines, contents, and plotting data.
• Python API (rosbag2_py): Allows programmatic bag creation, reading, and data extraction for custom analysis pipelines.

Recording high-frequency sensor data (e.g., images, point clouds) presents significant I/O and storage challenges. ROS Bag configuration is critical for managing system load.

• Compression: MCAP format supports per-topic compression to reduce file size (critical for video streams).
• Buffer Management: The recorder uses a configurable cache to buffer messages before writing to disk, preventing drops during I/O spikes.
• Storage Options: Can write to fast SSDs for high-bandwidth logging or network storage for long-term archiving.
• Split Files: Bags can be automatically split by size or duration to manage file handles and facilitate processing.

ROS Bags are indispensable throughout the robotic software lifecycle, serving specific roles in development, testing, and deployment.

• Offline Debugging: Record a problematic run, then repeatedly analyze sensor data and internal state to isolate bugs.
• Algorithm Regression Testing: Use a standard set of "golden" bag files as test fixtures to validate that perception or planning changes do not degrade performance.
• Documentation & Sharing: Bags provide a reproducible dataset for sharing with team members or for publication, ensuring everyone analyzes the exact same sensor inputs.
• Simulation Bridging: Record data from a physical robot to create a realistic simulation scenario, or play simulated data into a real robot's software stack for Hardware-in-the-Loop (HIL) testing.

This is the most fundamental use case. Engineers record sensor data and internal system state during field tests or lab experiments. The bag file acts as a deterministic log of the system's execution, allowing them to:

• Replay the exact sensor inputs and messages to reproduce bugs.
• Inspect the timing and content of every message on every topic using tools like rqt_bag or ros2 bag info.
• Isolate failures by correlating anomalous robot behavior with specific sensor readings or internal state changes that occurred seconds or minutes prior.

ROS Bags provide the raw, time-synchronized multimodal data required to develop and train perception and planning algorithms.

• Perception Models: Record synchronized streams from cameras, LiDAR, and IMUs to train object detection, semantic segmentation, or SLAM models without needing the physical robot present.
• Imitation Learning: Capture topic data (e.g., /cmd_vel, /joint_states) during expert demonstrations to create datasets for behavioral cloning.
• Benchmarking: Create standard bag files with challenging scenarios (e.g., dynamic obstacles, poor lighting) to serve as a consistent benchmark for evaluating different algorithm versions.

Bags enable continuous integration (CI) pipelines for robotic software by providing reproducible, hardware-independent test scenarios.

• CI/CD Pipelines: A test node subscribes to a bag's playback and validates that new code produces the expected outputs (e.g., correct object detections, planned paths).
• Regression Detection: By comparing the outputs of a new system version against a golden master bag recorded from a known-good version, engineers can detect subtle behavioral regressions.
• Hardware-in-the-Loop (HIL): Bags can feed simulated sensor data to a system partially running on real control hardware, testing the integration of physical actuators with new perception software.

Recorded real-world data is crucial for creating and validating high-fidelity simulations.

• Simulation Ground Truth: A bag from a physical robot provides the ground truth sensor readings and robot states needed to calibrate and validate physics simulators (e.g., Gazebo, Isaac Sim), ensuring the sim's outputs match reality.
• Digital Twin Synchronization: Play back a bag into a simulation to create a synchronized digital twin of a past real-world operation, enabling detailed forensic analysis in a risk-free virtual environment.
• Sim-to-Real Gap Analysis: By running the same algorithm on both a bag (real data) and a simulated replica, engineers can quantify the reality gap and refine their sim-to-Real transfer techniques.

A well-annotated ROS Bag serves as a canonical artifact that captures a specific robotic capability or test scenario.

• Reproducible Research: In academia and industrial R&D, publishing the bag file alongside a paper allows peers to exactly reproduce experimental results and verify claims.
• Team Handoff: A new engineer can understand system behavior by replaying key scenario bags, seeing the exact data flows that experienced developers debugged.
• Demonstration Archives: Bags record successful complex maneuvers (e.g., a door opening, a dynamic obstacle avoidance sequence) for stakeholder reviews, without needing to stage a live demo.

Bags allow engineers to analyze the temporal behavior and resource usage of their ROS graph under realistic load.

• Latency Analysis: Tools can process bags to measure end-to-end latency from a sensor message (e.g., /camera/image_raw) to a resulting command (e.g., /cmd_vel).
• Network Load Assessment: By analyzing message rates and sizes across topics in a bag, engineers can characterize network bandwidth usage and identify potential bottlenecks before deployment.
• Deterministic Replay for Profiling: Code profilers (e.g., ros2_tracing) can be run during a bag replay to isolate CPU-intensive callbacks under a consistent, repeatable data load, unlike variable live tests.

A ROS Topic is a named, many-to-many communication channel for asynchronous data streaming. Nodes publish messages to a topic, and any number of subscriber nodes can receive them. This is the primary data source recorded by a ROS Bag.

• Publish-Subscribe Model: Decouples data producers from consumers.
• Message Type: Every topic has a strictly defined .msg type (e.g., sensor_msgs/Image, geometry_msgs/Twist).
• Bag Contents: A ROS Bag is essentially a serialized log of messages published on one or more topics, along with their precise timestamps.

A ROS Message is a strictly typed data structure that defines the format of information exchanged between nodes. Defined in .msg files, they are the atomic unit of data serialized within a ROS Bag.

• Type Safety: Ensures publishers and subscribers agree on data structure.
• Composition: Messages can contain primitive types (integers, strings) or other nested messages.
• Serialization: When a message is published, it is converted (serialized) into a binary format for transmission and storage in the bag file. Tools like rosbag deserialize this data for playback and analysis.

ROS 2 Quality of Service (QoS) policies govern the reliability, durability, and timeliness of communication between nodes. These policies critically affect what data is available to be recorded in a ROS 2 Bag.

• Reliability: RELIABLE vs BEST_EFFORT. A bag recording with BEST_EFFORT subscribers may miss messages under system load.
• Durability: VOLATILE vs TRANSIENT_LOCAL. A TRANSIENT_LOCAL publisher retains messages for late-joining subscribers, ensuring a recording node doesn't miss initial data.
• History Depth: Determines how many messages are queued before being dropped, impacting recording completeness during processing spikes.

The ROS Graph is the runtime network of all ROS nodes, topics, services, and actions in a system. A ROS Bag provides a temporal snapshot of the data flowing through a subset of this graph.

• Dynamic Topology: The graph can change as nodes start and stop.
• Visualization: Tools like rqt_graph visualize the live graph.
• Bag as a Record: Playing back a bag recreates a segment of the graph's data flow in time, allowing developers to analyze the system's state and interactions offline. It is a recorded slice of the graph's activity.

rosbag2 is the ROS 2 suite of tools for bag recording and playback, and rviz2 is the 3D visualization tool. They are the primary applications for interacting with bag data.

• rosbag2 CLI: Commands like ros2 bag record -o my_bag /camera/image /lidar/scan start recording. ros2 bag play my_bag replays data.
• SQLite Storage: ROS 2 bags default to an SQLite database format (.db3), enabling efficient querying and indexing by time and topic.
• Visualization: During bag playback, rviz2 can subscribe to re-published topics (e.g., images, point clouds, TF transforms) to visually debug and analyze the recorded sensor data and robot state.

High-fidelity physics simulators like Gazebo are used to generate synthetic ROS Bag data in a controlled, repeatable virtual environment before testing on physical hardware.

• Data Generation: Simulated sensors (cameras, IMUs, LiDAR) publish data to ROS topics just like real hardware, which can be recorded into bags.
• Ground Truth: Simulation provides perfect ground truth data (e.g., exact robot pose, object locations) that can be recorded alongside sensor topics for algorithm training and validation.
• Regression Testing: Bags recorded from simulation provide deterministic datasets for continuous integration (CI) testing of perception and planning stacks.