Rust ROS2通信中间件库r2r的使用，实现高效机器人操作系统2（ROS2）的节点通信与消息处理

R2R是一个易于使用、运行时无关的异步Rust绑定库，用于ROS2。它不需要接入ROS2构建基础设施，只需使用cargo build即可完成构建。通过调用C自省库生成方便的Rust类型，绕过了ROS2的.msg/.idl管道，依赖于已生成的C代码。

使用方法

1. 确保已安装libclang（例如Ubuntu上的libclang-dev）
2. 在Cargo.toml中添加依赖：r2r = "0.9.5"
3. 在构建/运行前需要source您的ROS2安装环境
4. 绑定会在您source工作空间后自动重建
5. 如果修改了现有消息类型，运行cargo clean -p r2r_msg_gen强制在下一次构建时重新编译Rust消息类型

示例使用：

. /opt/ros/humble/setup.sh
cargo build
cargo run --example subscriber
# 在另一个终端
ros2 topic pub /topic std_msgs/msg/String "data: 'Hello, world'"

构建时间说明

由于默认行为是构建所有已source的消息类型，对于较大的工作空间，构建时间可能会迅速增加。为避免构建所有内容，可以使用环境变量IDL_PACKAGE_FILTER声明仅需要的消息包。

当前功能

• 支持最新的ROS2版本（Foxy、Galactic、Humble、Iron、Jazzy）
• 构建Rust类型
• 发布/订阅
• 服务
• 动作
• 参数处理
• 模拟时间（构建时确保已sourcerosgraph_msgs以启用）
• 可在Linux、OSX和Windows上运行

完整示例代码

下面是一个完整的Rust ROS2节点通信示例，包含发布者和订阅者：

use r2r;
use std::sync::{Arc, Mutex};
use tokio::task;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化ROS2上下文
    let ctx = r2r::Context::create()?;
    let mut node = r2r::Node::create(ctx, "rust_node", "")?;
    
    // 创建发布者
    let publisher = node.create_publisher::<r2r::std_msgs::msg::String>("/topic")?;
    
    // 创建订阅者
    let subscriber = node.subscribe::<r2r::std_msgs::msg::String>("/topic")?;
    
    // 使用Arc和Mutex共享数据
    let counter = Arc::new(Mutex::new(0));
    
    // 启动发布任务
    let pub_counter = counter.clone();
    task::spawn(async move {
        let mut msg = r2r::std_msgs::msg::String::default();
        loop {
            {
                let mut count = pub_counter.lock().unwrap();
                *count += 1;
                msg.data = format!("Hello from Rust! Count: {}", *count);
            }
            publisher.publish(&msg).unwrap();
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        }
    });
    
    // 处理订阅消息
    while let Ok(msg) = subscriber.recv().await {
        println!("Received: {}", msg.data);
    }
    
    Ok(())
}

服务示例

use r2r;
use tokio::task;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ctx = r2r::Context::create()?;
    let mut node = r2r::Node::create(ctx, "rust_service_node", "")?;
    
    // 创建服务客户端
    let client = node.create_client::<r2r::example_interfaces::srv::AddTwoInts>("/add_two_ints")?;
    
    // 创建服务服务器
    let server = node.create_service::<r2r::example_interfaces::srv::AddTwoInts, _>(
        "/add_two_ints",
        move |req| {
            println!("Received request: {} + {}", req.a, req.b);
            let sum = req.a + req.b;
            Ok(r2r::example_interfaces::srv::AddTwoIntsResponse { sum })
        },
    )?;
    
    // 发送服务请求
    task::spawn(async move {
        let mut req = r2r::example_interfaces::srv::AddTwoIntsRequest::default();
        req.a = 2;
        req.b = 3;
        
        match client.request(&req).await {
            Ok(response) => println!("Got response: {}", response.sum),
            Err(e) => println!("Error: {:?}", e),
        }
    });
    
    // 保持节点运行
    loop {
        node.spin_once(std::time::Duration::from_millis(100)).await;
    }
}

动作(Action)服务完整示例

下面是一个实现ROS2动作服务的完整示例：

use r2r;
use tokio::task;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ctx = r2r::Context::create()?;
    let mut node = r2r::Node::create(ctx, "rust_action_node", "")?;

    // 创建动作服务器
    let action_server = node.create_action_server::<
        r2r::example_interfaces::action::Fibonacci,
    >(
        "/fibonacci",
        |goal_handle| async move {
            println!("Received goal request with order: {}", goal_handle.goal.order);
            
            let mut feedback = r2r::example_interfaces::action::FibonacciFeedback::default();
            let mut result = r2r::example_interfaces::action::FibonacciResult::default();
            let mut sequence = vec![0, 1];
            
            for i in 1..goal_handle.goal.order as usize {
                let next = sequence[i-1] + sequence[i];
                sequence.push(next);
                
                // 发送反馈
                feedback.sequence = sequence.clone();
                goal_handle.publish_feedback(&feedback).unwrap();
                
                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            }
            
            result.sequence = sequence;
            goal_handle.succeed(result).unwrap();
            
            Ok(())
        },
    )?;

    // 创建动作客户端
    let action_client = node.create_action_client::<
        r2r::example_interfaces::action::Fibonacci,
    >("/fibonacci")?;

    // 发送动作请求
    task::spawn(async move {
        let mut goal = r2r::example_interfaces::action::FibonacciGoal::default();
        goal.order = 5;
        
        match action_client.send_goal(&goal).await {
            Ok((goal_handle, result_future)) => {
                // 处理反馈
                let feedback_stream = goal_handle.get_feedback_stream();
                tokio::spawn(async move {
                    while let Ok(feedback) = feedback_stream.recv().await {
                        println!("Received feedback: {:?}", feedback.sequence);
                    }
                });
                
                // 等待结果
                match result_future.await {
                    Ok(result) => println!("Final result: {:?}", result.sequence),
                    Err(e) => println!("Error: {:?}", e),
                }
            }
            Err(e) => println!("Failed to send goal: {:?}", e),
        }
    });

    // 保持节点运行
    loop {
        node.spin_once(std::time::Duration::from_millis(100)).await;
    }
}

参数处理完整示例

use r2r;
use tokio::task;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ctx = r2r::Context::create()?;
    let mut node = r2r::Node::create(ctx, "rust_param_node", "")?;

    // 声明参数
    node.declare_parameter("my_int_param", 42)?;
    node.declare_parameter("my_string_param", "hello")?;
    node.declare_parameter("my_double_param", 3.14)?;

    // 设置参数
    node.set_parameter("my_int_param", 100)?;

    // 获取参数
    match node.get_parameter::<i32>("my_int_param") {
        Ok(value) => println!("Got int parameter: {}", value),
        Err(e) => println!("Failed to get parameter: {:?}", e),
    }

    // 列出所有参数
    for param in node.list_parameters()? {
        println!("Parameter: {}", param);
    }

    // 保持节点运行
    loop {
        node.spin_once(std::time::Duration::from_millis(100)).await;
    }
}

许可证

除非在源文件中另有说明，所有代码均采用MIT许可证。包含的来自rclrust包的部分代码采用Apache 2.0许可证。