Recording Modes
Cerulion Core supports three different recording modes for MCAP logging. Choose the mode that best fits your use case.
Recording Mode Comparison
| Mode | Use Case | When Messages are Logged | Best For |
|---|
| Publisher Logging | Record all messages sent by a publisher | When send() is called | Recording your own node’s output |
| Subscriber Logging | Record all messages received by a subscriber | When receive() gets a message | Recording external sources (ROS2, other nodes) |
| Standalone Recorder | Record for a specific duration | Continuously for a time period | Time-limited recording sessions |
Publisher Logging
Enable logging on a publisher to record all sent messages.
When to Use
- Recording messages from your own nodes
- Logging sensor data your application produces
- Capturing control commands your system sends
Example
use cerulion_core::prelude::*;
use std::sync::Arc;
#[derive(Copy, Clone, Debug)]
#[repr(C)]
struct SensorData {
temperature: f32,
timestamp: u64,
}
// Create MCAP recorder
let recorder = Arc::new(
McapRecorder::create("publisher_log.mcap", None, None)?
);
// Create publisher
let mut publisher = Publisher::<SensorData>::create("sensors/data")?;
// Enable MCAP logging
publisher.enable_mcap_logging(recorder.clone());
// Messages will now be logged automatically when sent
let data = SensorData {
temperature: 23.5,
timestamp: 1234567890,
};
publisher.send(data)?; // Automatically logged to MCAP
Once logging is enabled, all messages sent via publisher.send() are automatically logged to the MCAP file.
Subscriber Logging
Enable logging on a subscriber to record all received messages.
When to Use
- Recording messages from external sources (ROS2 nodes via RCL Hooks)
- Logging specific topics without modifying the publisher
- Capturing network traffic for debugging
Example
use cerulion_core::prelude::*;
use std::sync::Arc;
// Create MCAP recorder
let recorder = Arc::new(
McapRecorder::create("subscriber_log.mcap", None, None)?
);
// Create subscriber
let mut subscriber = Subscriber::<SensorData>::create("sensors/data", None)?;
// Enable MCAP logging
subscriber.enable_mcap_logging(recorder.clone());
// Messages will be logged automatically when received
if let Ok(Some(data)) = subscriber.receive() {
// Message is automatically logged to MCAP
println!("Received: {:?}", data);
}
Subscriber logging is particularly useful when you want to record messages from external sources (e.g., ROS2 nodes via RCL Hooks) or when you want to log only specific topics without modifying the publisher.
Standalone Recorder
Use a standalone recorder to record messages for a specific duration without modifying publishers or subscribers.
When to Use
- Time-limited recording sessions (e.g., “record for 10 seconds”)
- Recording without modifying existing code
- Automated data collection scripts
Example
use cerulion_core::prelude::*;
use std::sync::Arc;
use std::time::{Duration, Instant};
// Create standalone recorder
let recorder = Arc::new(
McapRecorder::create("standalone_log.mcap", None, None)?
);
// Create subscriber (without enabling logging on it)
let subscriber = Subscriber::<SensorData>::create("sensors/data", None)?;
// Record messages for a duration
let start = Instant::now();
recorder.record_from_subscriber(&subscriber, "sensors/data", || {
start.elapsed() < Duration::from_secs(10) // Record for 10 seconds
})?;
println!("Recording complete!");
The standalone recorder pattern is useful for time-limited recording or when you want to record messages from a subscriber without modifying the subscriber itself.
Using Multiple Recorders
You can use multiple recorders for different topics or recording sessions:
// Create separate recorders for different topics
let sensor_recorder = Arc::new(
McapRecorder::create("sensors.mcap", None, None)?
);
let control_recorder = Arc::new(
McapRecorder::create("control.mcap", None, None)?
);
// Enable logging with different recorders
sensor_publisher.enable_mcap_logging(sensor_recorder.clone());
control_publisher.enable_mcap_logging(control_recorder.clone());
Sharing a Single Recorder
Multiple publishers/subscribers can share the same recorder:
// Create one recorder
let recorder = Arc::new(
McapRecorder::create("all_messages.mcap", None, None)?
);
// Share across multiple publishers/subscribers
publisher1.enable_mcap_logging(recorder.clone());
publisher2.enable_mcap_logging(recorder.clone());
subscriber1.enable_mcap_logging(recorder.clone());
Use a single shared recorder when you want all messages in one file for synchronized playback. Use separate recorders when you want to organize by topic or recording session.
Next Steps
