Convert to roslibrust

roslibrust makes the build story easier and provides both ROS1 and ROS2
support, switchable at runtime.

Author: modulrmike

.gitmodules

@@ -0,0 +1,15 @@
+[submodule "assets/ros1_common_interfaces/std_msgs"]
+	path = assets/ros1_common_interfaces/std_msgs
+	url = https://github.com/ros/std_msgs.git
+[submodule "assets/ros1_common_interfaces/common_msgs"]
+	path = assets/ros1_common_interfaces/common_msgs
+	url = https://github.com/ros/common_msgs.git
+[submodule "assets/ros2_common_interfaces"]
+	path = assets/ros2_common_interfaces
+	url = https://github.com/ros2/common_interfaces.git
+[submodule "assets/ros1_common_interfaces/ros_comm_msgs"]
+	path = assets/ros1_common_interfaces/ros_comm_msgs
+	url = https://github.com/ros/ros_comm_msgs.git
+[submodule "assets/ros2_required_msgs/rcl_interfaces"]
+	path = assets/ros2_required_msgs/rcl_interfaces
+	url = https://github.com/ros2/rcl_interfaces.git

Cargo.toml

@@ -3,6 +3,9 @@ name = "modulr_agent"
 version = "0.1.0"
 edition = "2024"
 
+[build-dependencies]
+roslibrust = { version = "0.16.0", features = ["ros1", "codegen"] }
+
 [dependencies]
 webrtc = "0.10"
 tokio = { version = "1", features = ["full"] }
@@ -18,23 +21,7 @@ bytes = "1.10.1"
 thiserror = "2.0.17"
 env_logger = "0.11.8"
 log = "0.4.28"
-
-# ROS 1 dependencies
-rosrust = { version = "0.9.12", optional = true }
-rosrust_msg = { version = "0.1.8", optional = true }
-
-# ROS 2 dependencies
-rclrs = { version = "*", optional = true }
-geometry_msgs = { version = "*", optional = true }
-sensor_msgs = { version = "*", optional = true }
-std_msgs = { version = "*", optional = true }
-
-[features]
-default = ["ros2"]
-ros1 = ["dep:rosrust", "dep:rosrust_msg"]
-ros2 = [
-    "dep:rclrs",
-    "dep:geometry_msgs",
-    "dep:sensor_msgs",
-    "dep:std_msgs",
-]
+roslibrust = { version = "0.16.0", features = ["ros1", "rosbridge", "codegen"] }
+async-trait = "0.1.89"
+futures = "0.3.31"
+base64 = "0.22.1"

README.md

@@ -2,6 +2,16 @@
 
 This package contains the agent to be installed on any robot connecting to the Modulr infrastructure.
 
+## Cloning the Package
+
+Use the following command to clone the package:
+
+```bash
+git clone --recurse-submodules https://github.com/ModulrCloud/modulr-agent
+# If already cloned and you need to checkout the submodules:
+git submodule update --init --recursive
+```
+
 ## Building the Package
 
 This package has only been tested on Ubuntu systems. To build the package, you will need to install Rust: https://rustup.rs/
@@ -15,71 +25,64 @@ sudo apt install -y  libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
       gstreamer1.0-libav libgstrtspserver-1.0-dev libges-1.0-dev
 ```
 
-Finally, ROS is required. ROS 1 and ROS 2 are both supported.
-
-## ROS 1
-
-Follow the installation instructions here: https://wiki.ros.org/noetic/Installation/Ubuntu
-
-Unfortunately, dependency management is difficult with this package due to its dependency on `ros2rust`, which requires the packages to be built locally. To make this package easier to compile, open `Cargo.toml` and remove the `ros2` feature and the dependencies listed for ROS 2. Also set the default features to ros1.
+Finally, ROS is required. ROS 1 and ROS 2 are both supported. For ROS1, install Noetic as per [these installation instructions](https://wiki.ros.org/noetic/Installation/Ubuntu). For ROS2, we recommend using Kilted as the latest release ([installation instructions](https://docs.ros.org/en/kilted/Installation/Ubuntu-Install-Debs.html)), but earlier distros should also work.
 
-Then, build the package by running:
+In addition to base ROS, a websocket bridge server is required:
 
 ```bash
-source /opt/ros/noetic/setup.bash
-cargo build
+sudo apt install ros-$ROS_DISTRO-rosbridge-suite
 ```
 
-You can run the package with logging enabled using:
+Build the package as follows:
 
 ```bash
-RUST_LOG=debug cargo run
+# Replace $ROS_DISTRO with the installed version of ROS
+source /opt/ros/$ROS_DISTRO/setup.bash
+# For debug mode:
+cargo build
+# For release mode:
+cargo build --release
 ```
 
-## ROS 2
-
-Follow the installation instructions here: https://docs.ros.org/en/jazzy/Installation/Ubuntu-Install-Debs.html
-
-Note that any distro of ROS 2 should be compatible, but only Jazzy has been tested so far.
-
-Some extra installation is required for Rust-related build tooling:
+The agent relies on rosbridge to relay ROS traffic. Run rosbridge as follows:
 
 ```bash
-sudo apt install -y git libclang-dev python3-pip python3-vcstool
-pip install git+https://github.com/colcon/colcon-cargo.git --break-system-packages
-pip install git+https://github.com/colcon/colcon-ros-cargo.git --break-system-packages
+# ROS 1
+roslaunch rosbridge_server rosbridge_websocket.launch
+# ROS 2
+ros2 launch rosbridge_server rosbridge_websocket_launch.xml
 ```
 
-Create a ROS 2 workspace for the package:
+You can then run the agent using the following:
 
 ```bash
-mkdir -p ~/modulr_ws/src
-cd ~/modulr_ws
-git clone <this repo> src/modulr_agent
-vcs import src < src/modulr_agent/ros2rust.repos
-# Change the following line depending on your installed version of ROS 2
-vcs import src < src/ros2_rust/ros2_rust_jazzy.repos
+# For debug mode:
+cargo run
+# For release mode:
+cargo run --release
+# To enable logging, set the following to your desired log level:
+RUST_LOG=modulr_agent=debug cargo run # --release
 ```
 
-Build the package (first time command):
+## Running in Simulation
+
+If not running on a real robot, you can test the system using a Turtlebot simulation. Install the turtlebot simulator using:
 
 ```bash
-cd ~/modulr_ws
-colcon build
-source install/setup.bash
+sudo apt install ros-$ROS_DISTRO-turtlebot3-simulations
 ```
 
-Build the package (subsequent calls):
+The simulator can then be run using:
 
 ```bash
-cd ~/modulr_ws
-colcon build --packages-select modulr_agent
+export TURTLEBOT3_MODEL=waffle_pi
+# ROS 1
+roslaunch turtlebot3_gazebo turtlebot3_world.launch
+# ROS 2
+ros2 launch turtlebot3_gazebo turtlebot3_world.launch.py
 ```
 
-Run the package with debug logging:
+The robot should then be driveable using the agent.
 
-```bash
-RUST_LOG=debug ./install/modulr_agent/bin/modulr_agent
-```
+*Note that at present, all topics are hard-coded. You may need to check that the simulation is producing images on `/camera/image_raw` and adjust the source code if not. Similarly, the simulation may use Twist or TwistStamped messages for velocity commands, so if movement is not working, double-check the message type.*
 
-*Note that cargo commands should be enabled, including cargo build and cargo run, but these did not work on the first system. It is a TODO to fix this build issue.*

assets/ros1_common_interfaces/common_msgs

@@ -0,0 +1,32 @@
+use std::path::PathBuf;
+
+fn generate_messages(
+    paths: Vec<PathBuf>,
+    out_file: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let (source, dependent_paths) =
+        roslibrust::codegen::find_and_generate_ros_messages_without_ros_package_path(paths)?;
+    let out_dir = std::env::var_os("OUT_DIR").unwrap();
+    let dest_path = std::path::Path::new(&out_dir).join(out_file);
+    std::fs::write(dest_path, source.to_string())?;
+
+    for path in &dependent_paths {
+        println!("cargo:rerun-if-changed={}", path.display());
+    }
+
+    Ok(())
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let ros1_paths = vec!["./assets/ros1_common_interfaces".into()];
+
+    let ros2_paths = vec![
+        "./assets/ros2_common_interfaces".into(),
+        "./assets/ros2_required_msgs/rcl_interfaces/builtin_interfaces".into(),
+    ];
+
+    generate_messages(ros1_paths, "ros1_messages.rs")?;
+    generate_messages(ros2_paths, "ros2_messages.rs")?;
+
+    Ok(())
+}

assets/ros1_common_interfaces/ros_comm_msgs

@@ -7,16 +7,20 @@ use std::sync::Arc;
 
 use anyhow::Result;
 use bytes::Bytes;
-use log::{info, warn};
+use log::{debug, info, warn};
 use tokio::sync::Mutex;
 
+use crate::ros_bridge::Ros1Bridge;
+use crate::ros_bridge::Ros2Bridge;
 use crate::ros_bridge::RosBridge;
 use crate::video_pipeline::VideoPipeline;
 use crate::video_pipeline::VideoPipelineError;
 use crate::webrtc_link::WebRtcLink;
 use crate::webrtc_link::WebRtcLinkError;
 use crate::webrtc_message::WebRtcMessage;
 
+const ROS1: bool = false;
+
 #[tokio::main]
 async fn main() -> Result<()> {
     env_logger::init();
@@ -25,7 +29,12 @@ async fn main() -> Result<()> {
     let signaling_url = "ws://192.168.132.19:8765";
     let webrtc_link = Arc::new(Mutex::new(WebRtcLink::new(robot_id, signaling_url)));
     let pipeline = Arc::new(Mutex::new(VideoPipeline::new()));
-    let bridge = Arc::new(Mutex::new(RosBridge::try_new()?));
+
+    let bridge: Arc<Mutex<dyn RosBridge>> = if ROS1 {
+        Arc::new(Mutex::new(Ros1Bridge::new()))
+    } else {
+        Arc::new(Mutex::new(Ros2Bridge::new()))
+    };
 
     info!("Creating system components and callbacks");
 
@@ -44,6 +53,7 @@ async fn main() -> Result<()> {
                             .lock()
                             .await
                             .post_movement_command(&cmd)
+                            .await
                             .expect("Failed to post movement command!");
                     }
                 }
@@ -96,7 +106,8 @@ async fn main() -> Result<()> {
                     .await
                     .expect("Failed to write camera frame to pipeline!");
             })
-        }));
+        }))
+        .await;
 
     info!("Starting all tasks running");
 
@@ -109,10 +120,10 @@ async fn main() -> Result<()> {
     let pipeline_clone = Arc::clone(&pipeline);
     tokio::spawn(async move {
         pipeline_clone.lock().await.launch().await?;
-        info!("Spawned the launch task successfully");
+        debug!("Finished launching video pipeline");
         Ok::<(), VideoPipelineError>(())
     });
-    bridge.lock().await.spin();
+    bridge.lock().await.launch().await?;
 
     let _ = tokio::signal::ctrl_c().await;
     info!("Exit requested, cleaning up...");