DDS Backend (#1)

Author: oxkitsune

Cargo.lock

@@ -3,7 +3,7 @@ members = ["booster_sdk", "booster_sdk_py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.4"
 edition = "2024"
 authors = ["Team whIRLwind"]
 license = "MIT OR Apache-2.0"
@@ -24,13 +24,12 @@ pedantic = { level = "warn", priority = -1 }
 booster_sdk = { path = "booster_sdk" }
 
 tokio = { version = "1.42", features = ["full"] }
-zenoh = { version = "1.0", features = ["unstable"] }
+rustdds = "0.11.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
 tracing = "0.1"
 uuid = { version = "1.11", features = ["v4", "serde"] }
 typed-builder = "0.23.0"
-glam = { version = "0.29", features = ["serde"] }
 tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }
 pyo3 = { version = "0.27.1", features = ["extension-module"] }

Cargo.toml

@@ -11,20 +11,20 @@ A Rust SDK for controlling Booster robots based on [Booster Robotics C++ SDK](ht
 ## 🚧 Project Status
 
 This library is currently in early development. The core architecture and types are defined, but none of it has been tested on
-an actual robot yet. Specifically, the `dds` module's Zenoh communication layer is untested.
+an actual robot yet. The DDS transport layer is implemented using RustDDS.
 
 ## API Examples
 
 ### High-Level Locomotion Control
 
 ```rust
-use booster_sdk::client::B1LocoClient;
+use booster_sdk::client::BoosterClient;
 use booster_sdk::types::{RobotMode, Hand};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize and create client
-    let client = B1LocoClient::new().await?;
+    let client = BoosterClient::new()?;
 
     // Change to walking mode
     client.change_mode(RobotMode::Walking).await?;
@@ -33,7 +33,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     client.move_robot(0.5, 0.0, 0.0).await?;
 
     // Wave hand
-    client.wave_hand(Hand::Right).await?;
+    // Publish gripper commands if needed (DDS topic-based control)
+    client.publish_gripper_command(&booster_sdk::client::GripperCommand::open(Hand::Right))?;
 
     // Lie down when done
     client.lie_down().await?;
@@ -63,30 +64,28 @@ This will create a wheel file in `booster_sdk_py/dist/` that can be installed wi
 
 ### Python API Example
 
+Note: Python bindings are intentionally minimal and expose a subset of the Rust API.
+
 ```python
-from booster_sdk import B1LocoClient, RobotMode, Hand
+from booster_sdk import BoosterClient, GripperCommand, Hand, RobotMode
 
-# Initialize client with optional timeout
-client = B1LocoClient(timeout_secs=5.0)
+client = BoosterClient()
 
 # Change to walking mode
 client.change_mode(RobotMode.WALKING)
 
 # Move forward
 client.move_robot(0.5, 0.0, 0.0)
 
-# Wave hand
-client.wave_hand(Hand.RIGHT)
-
-# Lie down when done
-client.lie_down()
+# Open right gripper
+client.publish_gripper_command(GripperCommand.open(Hand.RIGHT))
 ```
 
-The Python bindings expose the same high-level API as the Rust SDK, including robot mode control, locomotion, hand/gripper control, and coordinate frame transformations.
+The Python bindings currently cover basic mode changes, locomotion, and gripper control.
 
 # DDS Setup
 
-Setting up the DDS communication layer to work with Booster robots involves configuring Zenoh. Please refer to the [DDS Setup Guide](docs/dds_setup.md) for detailed instructions.
+The Rust SDK communicates directly over DDS (RustDDS). Please refer to the [DDS Setup Guide](docs/dds_setup.md) for detailed instructions.
 
 ## Contributing
 

README.md

@@ -9,14 +9,13 @@ repository.workspace = true
 
 [dependencies]
 tokio = { workspace = true }
-zenoh = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 uuid = { workspace = true }
 typed-builder = { workspace = true }
-glam = { workspace = true }
+rustdds = { workspace = true }
 
 [dev-dependencies]
 tracing-subscriber = { workspace = true }

booster_sdk/Cargo.toml

@@ -4,7 +4,7 @@
 //!
 //! Run with: cargo run --example `gripper_control`
 
-use booster_sdk::client::{B1LocoClient, commands::GripperCommand};
+use booster_sdk::client::{BoosterClient, commands::GripperCommand};
 use booster_sdk::types::{Hand, RobotMode};
 
 #[tokio::main]
@@ -14,7 +14,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     tracing::info!("Starting gripper control example");
 
-    let client = B1LocoClient::new().await?;
+    let client = BoosterClient::new()?;
 
     // Ensure robot is in correct mode
     tracing::info!("Preparing robot...");
@@ -23,40 +23,28 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Open both grippers
     tracing::info!("Opening both grippers");
-    client
-        .control_gripper(&GripperCommand::open(Hand::Left))
-        .await?;
-    client
-        .control_gripper(&GripperCommand::open(Hand::Right))
-        .await?;
+    client.publish_gripper_command(&GripperCommand::open(Hand::Left))?;
+    client.publish_gripper_command(&GripperCommand::open(Hand::Right))?;
     tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     // Close left gripper
     tracing::info!("Closing left gripper");
-    client
-        .control_gripper(&GripperCommand::close(Hand::Left))
-        .await?;
+    client.publish_gripper_command(&GripperCommand::close(Hand::Left))?;
     tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     // Open left gripper again
     tracing::info!("Opening left gripper");
-    client
-        .control_gripper(&GripperCommand::open(Hand::Left))
-        .await?;
+    client.publish_gripper_command(&GripperCommand::open(Hand::Left))?;
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
     // Force-based grasp with right hand
     tracing::info!("Grasping with right hand (force control)");
-    client
-        .control_gripper(&GripperCommand::grasp(Hand::Right, 600))
-        .await?;
+    client.publish_gripper_command(&GripperCommand::grasp(Hand::Right, 600))?;
     tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     // Release
     tracing::info!("Releasing grasp");
-    client
-        .control_gripper(&GripperCommand::open(Hand::Right))
-        .await?;
+    client.publish_gripper_command(&GripperCommand::open(Hand::Right))?;
 
     tracing::info!("Example completed successfully");
 

booster_sdk/examples/gripper_control.rs

@@ -1,11 +1,11 @@
 //! High-level locomotion control example
 //!
-//! This example demonstrates basic locomotion control using the `B1LocoClient`.
+//! This example demonstrates basic locomotion control using the `BoosterClient`.
 //!
 //! Run with: cargo run --example `locomotion_control`
 
-use booster_sdk::client::{B1LocoClient, commands::MoveCommand};
-use booster_sdk::types::{Hand, RobotMode};
+use booster_sdk::client::BoosterClient;
+use booster_sdk::types::RobotMode;
 use tokio::time::Duration;
 
 #[tokio::main]
@@ -16,13 +16,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing::info!("Starting locomotion control example");
 
     // Create client with 2-second timeout
-    let client = B1LocoClient::with_timeout(Duration::from_millis(2000)).await?;
-
-    // Get current mode
-    match client.get_mode().await {
-        Ok(mode) => tracing::info!("Current mode: {:?}", mode),
-        Err(e) => tracing::error!("Failed to get mode: {}", e),
-    }
+    let client = BoosterClient::new()?;
 
     // Change to walking mode
     tracing::info!("Changing to walking mode...");
@@ -32,42 +26,22 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Wait a moment for mode transition
     tokio::time::sleep(Duration::from_secs(2)).await;
 
-    // Move forward
-    tracing::info!("Moving forward at 0.3 m/s for 3 seconds");
-    client.move_robot(0.3, 0.0, 0.0).await?;
+    tracing::info!("Moving forward at 0.5 m/s for 3 seconds");
+    client.move_robot(0.5, 0.0, 0.0).await?;
     tokio::time::sleep(Duration::from_secs(3)).await;
 
-    // Stop
     tracing::info!("Stopping");
-    client.stop().await?;
+    client.move_robot(0.0, 0.0, 0.0).await?;
     tokio::time::sleep(Duration::from_secs(1)).await;
 
-    // Turn in place
     tracing::info!("Turning left for 2 seconds");
-    let turn_cmd = MoveCommand::turn(0.5);
-    client.move_with_command(&turn_cmd).await?;
+    client.move_robot(0.0, 0.0, 0.6).await?;
     tokio::time::sleep(Duration::from_secs(2)).await;
 
-    // Stop again
     tracing::info!("Stopping");
-    client.stop().await?;
+    client.move_robot(0.0, 0.0, 0.0).await?;
     tokio::time::sleep(Duration::from_secs(1)).await;
 
-    // Wave hand
-    tracing::info!("Waving right hand");
-    client.wave_hand(Hand::Right).await?;
-    tokio::time::sleep(Duration::from_secs(3)).await;
-
-    // Rotate head
-    tracing::info!("Looking around");
-    client.rotate_head(0.2, 0.5).await?;
-    tokio::time::sleep(Duration::from_secs(2)).await;
-    client.rotate_head(0.0, 0.0).await?; // Center head
-
-    // Lie down
-    tracing::info!("Lying down");
-    client.lie_down().await?;
-
     tracing::info!("Example completed successfully");
 
     Ok(())

booster_sdk/examples/locomotion_control.rs

@@ -1,44 +1,43 @@
-//! High-level look around example
+//! Motion state subscription example
 //!
-//! This example demonstrates basic look around behavior using the `B1LocoClient`.
+//! This example subscribes to the motion state topic over DDS.
 //!
 //! Run with: cargo run --example `look_around`
 
-use booster_sdk::client::B1LocoClient;
+use booster_sdk::client::BoosterClient;
 use tokio::time::Duration;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize logging
     tracing_subscriber::fmt().with_env_filter("info").init();
 
-    tracing::info!("Starting look around example");
-
-    // Create client with 2-second timeout
-    let client = B1LocoClient::with_timeout(Duration::from_millis(2000)).await?;
-
-    // Get current mode
-    match client.get_mode().await {
-        Ok(mode) => tracing::info!("Current mode: {:?}", mode),
-        Err(e) => tracing::error!("Failed to get mode: {}", e),
-    }
-
-    // Rotate head
-    tracing::info!("Looking around");
-
-    // scan from left to right with a sine wave
-    let steps = 4000;
-    for i in 0..=steps {
-        let angle = (i as f32 / steps as f32) * std::f32::consts::TAU;
-        let head_yaw = (6.0 * angle).cos() * 1.0;
-        let head_pitch = (6.0 * angle).sin() * 0.4;
-        client.rotate_head(head_pitch, head_yaw).await?;
-        tokio::time::sleep(Duration::from_millis(10)).await;
+    tracing::info!("Starting motion state subscription example");
+
+    let client = BoosterClient::new()?;
+    let mut motion_state = client.subscribe_motion_state()?;
+
+    let timeout = tokio::time::sleep(Duration::from_secs(10));
+    tokio::pin!(timeout);
+
+    loop {
+        tokio::select! {
+            _ = &mut timeout => {
+                tracing::info!("Finished listening for motion state updates");
+                break;
+            }
+            sample = motion_state.recv() => {
+                if let Some(state) = sample {
+                    tracing::info!(
+                        "Motion state: current={}, target={}, transitioning={}",
+                        state.current_mode,
+                        state.target_mode,
+                        state.is_transitioning
+                    );
+                }
+            }
+        }
     }
 
-    // set head back to center
-    tracing::info!("Centering head");
-    client.rotate_head(0.0, 0.0).await?;
-
     Ok(())
 }