Crate r2r

Easy to use, runtime-agnostic async rust bindings for ROS2.

Minimal bindings for ROS2 that do not require hooking in to the ROS2 build infrastructure – cargo build is all you need. Convenience Rust types are created by calling into the c introspection libraries. This circumvents the ROS2 .msg/.idl pipeline by relying on already generated C code. By default, the behavior is to build bindings to the RCL and all message types that can be found in the currently sourced ros environment.

What works?

• Up to date with ROS2 Dashing Eloquent Foxy Galactic Humble
• Building Rust types
• Publish/subscribe
• Services
• Actions
• Parameter handling

---

After having sourced ROS2 (see README for more details), you can try the following example:

use futures::{executor::LocalPool, future, stream::StreamExt, task::LocalSpawnExt};
use r2r::QosProfile;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ctx = r2r::Context::create()?;
    let mut node = r2r::Node::create(ctx, "node", "namespace")?;
    let subscriber =
        node.subscribe::<r2r::std_msgs::msg::String>("/topic", QosProfile::default())?;
    let publisher =
        node.create_publisher::<r2r::std_msgs::msg::String>("/topic", QosProfile::default())?;
    let mut timer = node.create_wall_timer(std::time::Duration::from_millis(1000))?;

    // Set up a simple task executor.
    let mut pool = LocalPool::new();
    let spawner = pool.spawner();

    // Run the subscriber in one task, printing the messages
    spawner.spawn_local(async move {
        subscriber
            .for_each(|msg| {
                println!("got new msg: {}", msg.data);
                future::ready(())
            })
            .await
    })?;

    // Run the publisher in another task
    spawner.spawn_local(async move {
        let mut counter = 0;
        loop {
            let _elapsed = timer.tick().await.unwrap();
            let msg = r2r::std_msgs::msg::String {
                data: format!("Hello, world! ({})", counter),
            };
            publisher.publish(&msg).unwrap();
            counter += 1;
        }
    })?;

    // Main loop spins ros.
    loop {
        node.spin_once(std::time::Duration::from_millis(100));
        pool.run_until_stalled();
    }
}

Re-exports

• pub extern crate indexmap;
• pub extern crate uuid;
• pub use qos::QosProfile;

Modules

• ackermann_msgs
• action_msgs
• actionlib_msgs
• builtin_interfaces
• composition_interfaces
• control_msgs
• controller_manager_msgs
• diagnostic_msgs
• geometry_msgs
• lifecycle_msgs
• nav2_msgs
• nav_msgs
• qos
  QoS (Quality of Service) full credit goes to https://github.com/rclrust/rclrust/blob/main/rclrust/src/qos.rs
• rcl_interfaces
• rmw_dds_common
• rosgraph_msgs
• sensor_msgs
• shape_msgs
• statistics_msgs
• std_msgs
• std_srvs
• stereo_msgs
• tf2_msgs
• trajectory_msgs
• unique_identifier_msgs
• visualization_msgs

Macros

• assert_compiled_with_use_sim_time_support
  Causes compile time error if use_sim_time is unsupported.
• log_debug
  Debug log message.
• log_error
  Error log message.
• log_fatal
  Fatal log message.
• log_info
  Info log message.
• log_warn
  Warning log message.

Structs

• ActionClient
  Action client
• ActionClientGoal
  Action client goal handle
• ActionClientGoalUntyped
  Action client goal handle (untyped)
• ActionClientUntyped
  Action client (untyped)
• ActionServerCancelRequest
  Request to cancel an active goal.
• ActionServerGoal
  A handle to an active Goal
• ActionServerGoalRequest
  Request to the action server to accept a new Goal.
• Client
  ROS service client.
• ClientUntyped
  ROS “untyped” service client.
• Clock
  A ROS clock.
• Context
  A ROS context. Needed to create nodes etc.
• NativeMsg
  This struct wraps a RCL message.
• Node
  A ROS Node.
• Parameter
  ROS parameter.
• Publisher
  A ROS (typed) publisher.
• PublisherUntyped
  A ROS (untyped) publisher.
• ServiceRequest
  Encapsulates a service request.
• TimeSource
  Provides time from /clock topic to attached ROS clocks
• Timer
  A ROS timer.
• WrappedNativeMsgUntyped
• WrongParameterType

Enums

• ClockType
  Different ROS clock types.
• Error
  r2r Error type.
• GoalStatus
  The status of a goal.
• LogSeverity
  Logging severity
• ParameterValue
  ROS parameter value.

Constants

• ROS_DISTRO

Traits

• RosParams
  Trait for use it with Node::make_derived_parameter_handler().
• WrappedActionTypeSupport
• WrappedServiceTypeSupport
• WrappedTypesupport

Type Aliases

• Result
  r2r Result type.

Derive Macros

• RosParams
  Derives RosParams trait for a structure to use it with r2r::Node::make_derived_parameter_handler().