Crate r2r

Expand description

§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§

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.
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().

Crate r2rCopy item path