ROS2入门教程—编写动作服务器和客户端（C++版）

最新推荐文章于 2024-10-03 22:55:52 发布
最新推荐文章于 2024-10-03 22:55:52 发布
阅读量3k 收藏 21
点赞数 5
分类专栏： ROS2入门教程 文章标签： 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29923461/article/details/120483336
版权

ROS2入门教程—编写动作服务器和客户端（C++版）


  动作是ROS 2中异步通信的一种形式。动作客户端将目标请求发送到动作服务器。动作服务器将目标反馈和结果发送到动作客户端。

1 创建功能包

  开启一个新终端，设置好环境变量，然后进入到dev_ws/src目录下，使用以下命令创建新的功能包action_tutorials_cpp：

ros2 pkg create --dependencies action_tutorials_interfaces rclcpp rclcpp_action rclcpp_components -- action_tutorials_cpp

2 编写动作服务器

  首先，让我们来编写一个动作服务器，该动作服务器使用我们在ROS2入门教程—创建一个动作消息（action）一文中创建的用来计算斐波那契序列的动作。

2.1 编写动作服务器代码

  在action_tutorials_cpp/src目录下创建新文件fibonacci_action_server.cpp，然后拷贝如下代码：

#include <functional>
#include <memory>
#include <thread>

#include "action_tutorials_interfaces/action/fibonacci.hpp"
#include "rclcpp/rclcpp.hpp"
#include "rclcpp_action/rclcpp_action.hpp"
#include "rclcpp_components/register_node_macro.hpp"

#include "action_tutorials_cpp/visibility_control.h"
 
namespace action_tutorials_cpp
{
class FibonacciActionServer : public rclcpp::Node
{
public:
    using Fibonacci = action_tutorials_interfaces::action::Fibonacci;
    using GoalHandleFibonacci = rclcpp_action::ServerGoalHandle<Fibonacci>;

    ACTION_TUTORIALS_CPP_PUBLIC
    explicit FibonacciActionServer(const rclcpp::NodeOptions & options = rclcpp::NodeOptions())
    : Node("fibonacci_action_server", options)
    {
        using namespace std::placeholders;

        this->action_server_ = rclcpp_action::create_server<Fibonacci>(
        this,
        "fibonacci",
        std::bind(&FibonacciActionServer::handle_goal, this, _1, _2),
        std::bind(&FibonacciActionServer::handle_cancel, this, _1),
        std::bind(&FibonacciActionServer::handle_accepted, this, _1));
    }
 
private:
    rclcpp_action::Server<Fibonacci>::SharedPtr action_server_;

    rclcpp_action::GoalResponse handle_goal(
        const rclcpp_action::GoalUUID & uuid,
        std::shared_ptr<const Fibonacci::Goal> goal)
    {
        RCLCPP_INFO(this->get_logger(), "Received goal request with order %d", goal->order);
        (void)uuid;
        return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
    }

    rclcpp_action::CancelResponse handle_cancel(
        const std::shared_ptr<GoalHandleFibonacci> goal_handle)
    {
        RCLCPP_INFO(this->get_logger(), "Received request to cancel goal");
        (void)goal_handle;
        return rclcpp_action::CancelResponse::ACCEPT;
    }

    void handle_accepted(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
    {
        using namespace std::placeholders;
        // this needs to return quickly to avoid blocking the executor, so spin up a new thread
        std::thread{std::bind(&FibonacciActionServer::execute, this, _1), goal_handle}.detach();
    }

    void execute(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
    {
        RCLCPP_INFO(this->get_logger(), "Executing goal");
        rclcpp::Rate loop_rate(1);
        const auto goal = goal_handle->get_goal();
        auto feedback = std::make_shared<Fibonacci::Feedback>();
        auto & sequence = feedback->partial_sequence;
        sequence.push_back(0);
        sequence.push_back(1);
        auto result = std::make_shared<Fibonacci::Result>();

        for (int i = 1; (i < goal->order) && rclcpp::ok(); ++i) {
        // Check if there is a cancel request
        if (goal_handle->is_canceling()) {
            result->sequence = sequence;
            goal_handle->canceled(result);
            RCLCPP_INFO(this->get_logger(), "Goal canceled");
            return;
        }
        // Update sequence
        sequence.push_back(sequence[i] + sequence[i - 1]);
        // Publish feedback
        goal_handle->publish_feedback(feedback);
        RCLCPP_INFO(this->get_logger(), "Publish feedback");

        loop_rate.sleep();
        }

        // Check if goal is done
        if (rclcpp::ok()) {
        result->sequence = sequence;
        goal_handle->succeed(result);
        RCLCPP_INFO(this->get_logger(), "Goal succeeded");
        }
    }
};  // class FibonacciActionServer
 
}  // namespace action_tutorials_cpp
 
RCLCPP_COMPONENTS_REGISTER_NODE(action_tutorials_cpp::FibonacciActionServer)

2.2 代码解释

  前几行包括我们需要编译的所有头文件。

  接下来，我们创建一个类，它是rclcpp::Node的派生类：

class FibonacciActionServer : public rclcpp::Node

  FibonacciActionServer类的构造函数将节点名称初始化为fibonacci_action_server：

explicit FibonacciActionServer(const rclcpp::NodeOptions & options = rclcpp::NodeOptions())
    : Node("fibonacci_action_server", options)

  构造函数还实例化了一个新的动作服务器：

this->action_server_ = rclcpp_action::create_server<Fibonacci>(
    this,
    "fibonacci",
    std::bind(&FibonacciActionServer::handle_goal, this, _1, _2),
    std::bind(&FibonacciActionServer::handle_cancel, this, _1),
    std::bind(&FibonacciActionServer::handle_accepted, this, _1)
);

  一个动作服务器需要以下6个参数：
   ∙ \bullet ∙ 模板化的动作类型名称：Fibonacci
   ∙ \bullet ∙ 一个可以将动作服务端添加进来的ROS 2节点：this
   ∙ \bullet ∙ 动作名称："fibonacci"
   ∙ \bullet ∙ 一个用于处理目标的回调函数：handle_goal
   ∙ \bullet ∙ 一个用于处理取消的回调函数：handle_cancel
   ∙ \bullet ∙ 一个用于处理目标接受的回调函数：handle_accepted

  接下来是三个回调函数的实现，请注意，所有回调函数都需要快速返回，否则可能会堵塞住执行器。
  首先是处理新目标的回调函数：

rclcpp_action::GoalResponse handle_goal(const rclcpp_action::GoalUUID & uuid, std::shared_ptr<const Fibonacci::Goal> goal)
{
    RCLCPP_INFO(this->get_logger(), "Received goal request with order %d", goal->order);
    (void)uuid;
    return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
}

  这个回调函数的实现只是接受所有目标。

  接下来是处理取消的回调函数：

rclcpp_action::CancelResponse handle_cancel(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
{
    RCLCPP_INFO(this->get_logger(), "Received request to cancel goal");
    (void)goal_handle;
    return rclcpp_action::CancelResponse::ACCEPT;
}

  这个回调函数的实现也只是告诉客户端它已接受取消。

  最后一个回调函数接受一个新目标并开始处理该目标：

void handle_accepted(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
{
    using namespace std::placeholders;
    // this needs to return quickly to avoid blocking the executor, so spin up a new thread
    std::thread{std::bind(&FibonacciActionServer::execute, this, _1), goal_handle}.detach();
}

  action是可抢占式的，由于需要执行一段时间，因此开启一个线程来执行实际工作，并且从handle_accepted快速返回。所有进一步的处理和更新都在新线程的execute方法中完成：

void execute(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
{
    RCLCPP_INFO(this->get_logger(), "Executing goal");
    rclcpp::Rate loop_rate(1);
    const auto goal = goal_handle->get_goal();
    auto feedback = std::make_shared<Fibonacci::Feedback>();
    auto & sequence = feedback->partial_sequence;
    sequence.push_back(0);
    sequence.push_back(1);
    auto result = std::make_shared<Fibonacci::Result>();

    for (int i = 1; (i < goal->order) && rclcpp::ok(); ++i) {
    // Check if there is a cancel request
    if (goal_handle->is_canceling()) {
        result->sequence = sequence;
        goal_handle->canceled(result);
        RCLCPP_INFO(this->get_logger(), "Goal canceled");
        return;
    }
    // Update sequence
    sequence.push_back(sequence[i] + sequence[i - 1]);
    // Publish feedback
    goal_handle->publish_feedback(feedback);
    RCLCPP_INFO(this->get_logger(), "Publish feedback");

    loop_rate.sleep();
    }

    // Check if goal is done
    if (rclcpp::ok()) {
    result->sequence = sequence;
    goal_handle->succeed(result);
    RCLCPP_INFO(this->get_logger(), "Goal succeeded");
    }
}

  这个工作线程每秒处理斐波纳契数列的一个序列数，并且发布一个反馈更新。完成处理后，将目标句柄goal_handle标记为成功状态，然后退出。

2.3 编译动作服务器

  首先，需要设置CMakeLists.txt，以便编译动作服务器。打开action_tutorials_cpp/CMakeLists.txt文件，并在find_package调用之后添加以下内容：

add_library(action_server SHARED
    src/fibonacci_action_server.cpp)

target_include_directories(action_server PRIVATE
<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
<INSTALL_INTERFACE:include>)

target_compile_definitions(action_server
    PRIVATE "ACTION_TUTORIALS_CPP_BUILDING_DLL")

ament_target_dependencies(action_server
    "action_tutorials_interfaces"
    "rclcpp"
    "rclcpp_action"
    "rclcpp_components")

rclcpp_components_register_node(action_server PLUGIN "action_tutorials_cpp::FibonacciActionServer" EXECUTABLE fibonacci_action_server)

install(TARGETS
    action_server
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
    RUNTIME DESTINATION bin)

  接下来就可以编译该功能包了，进入到工作空间根目录下，执行下列命令：

colcon build

2.4 运行动作服务器

  打开一个新终端，进入到工作空间根目录，然后运行如下命令：

. install/setup.bash
ros2 run action_tutorials_cpp fibonacci_action_server

3 编写动作客户端

3.1 编写动作客户端代码

  在action_tutorials_cpp/src目录下创建新文件fibonacci_action_client.cpp，然后拷贝如下代码：

#include <functional>
#include <future>
#include <memory>
#include <string>
#include <sstream>

#include "action_tutorials_interfaces/action/fibonacci.hpp"
#include "rclcpp/rclcpp.hpp"
#include "rclcpp_action/rclcpp_action.hpp"
#include "rclcpp_components/register_node_macro.hpp"

namespace action_tutorials_cpp
{
class FibonacciActionClient : public rclcpp::Node
{
public:
    using Fibonacci = action_tutorials_interfaces::action::Fibonacci;
    using GoalHandleFibonacci = rclcpp_action::ClientGoalHandle<Fibonacci>;
    explicit FibonacciActionClient(const rclcpp::NodeOptions & options)
    : Node("fibonacci_action_client", options)
    {
        this->client_ptr_ = rclcpp_action::create_client<Fibonacci>(
            this,
            "fibonacci"
        );
        this->timer_ = this->create_wall_timer(
            std::chrono::milliseconds(500),
            std::bind(&FibonacciActionClient::send_goal, this)
        );
    }

    void send_goal()
    {
        using namespace std::placeholders;
        this->timer_->cancel();
        if (!this->client_ptr_->wait_for_action_server()) {
            RCLCPP_ERROR(this->get_logger(), "Action server not available after waiting");
            rclcpp::shutdown();
        }

        auto goal_msg = Fibonacci::Goal();
        goal_msg.order = 10;
        RCLCPP_INFO(this->get_logger(), "Sending goal");

        auto send_goal_options = rclcpp_action::Client<Fibonacci>::SendGoalOptions();
        send_goal_options.goal_response_callback = std::bind(&FibonacciActionClient::goal_response_callback, this, _1);
        send_goal_options.feedback_callback =std::bind(&FibonacciActionClient::feedback_callback, this, _1, _2);
        send_goal_options.result_callback =std::bind(&FibonacciActionClient::result_callback, this, _1);

        this->client_ptr_->async_send_goal(goal_msg, send_goal_options);
    }

private:
    rclcpp_action::Client<Fibonacci>::SharedPtr client_ptr_;
    rclcpp::TimerBase::SharedPtr timer_;

    void goal_response_callback(std::shared_future<GoalHandleFibonacci::SharedPtr> future)
    {
        auto goal_handle = future.get();
        if (!goal_handle) 
        {
            RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
        } 
        else 
        {
            RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
        }
    }


    void feedback_callback(GoalHandleFibonacci::SharedPtr, const std::shared_ptr<const Fibonacci::Feedback> feedback)
    {
        std::stringstream ss;
        ss << "Next number in sequence received: ";
        for (auto number : feedback->partial_sequence) {
            ss << number << " ";
        }
        RCLCPP_INFO(this->get_logger(), ss.str().c_str());
    }

    void result_callback(const GoalHandleFibonacci::WrappedResult & result)
    {
        switch (result.code) {
        case rclcpp_action::ResultCode::SUCCEEDED:
            break;
        case rclcpp_action::ResultCode::ABORTED:
            RCLCPP_ERROR(this->get_logger(), "Goal was aborted");
            return;
        case rclcpp_action::ResultCode::CANCELED:
            RCLCPP_ERROR(this->get_logger(), "Goal was canceled");
            return;
        default:
            RCLCPP_ERROR(this->get_logger(), "Unknown result code");
            return;
        }

        std::stringstream ss;
        ss << "Result received: ";
        for (auto number : result.result->sequence) {
            ss << number << " ";
        }
        RCLCPP_INFO(this->get_logger(), ss.str().c_str());
        rclcpp::shutdown();
    }

};  // class FibonacciActionClient
}  // namespace action_tutorials_cpp

RCLCPP_COMPONENTS_REGISTER_NODE(action_tutorials_cpp::FibonacciActionClient)

3.2 代码解释

  前几行包括我们需要编译的所有头文件。

  接下来，我们创建一个类，它是rclcpp::Node的派生类：

class FibonacciActionClient : public rclcpp::Node

  FibonacciActionClient类的构造函数将节点名称初始化为fibonacci_action_client：

explicit FibonacciActionClient(const rclcpp::NodeOptions & options)
    : Node("fibonacci_action_client", options)

  构造函数也实例化了一个新的动作客户端：

this->client_ptr_ = rclcpp_action::create_client<Fibonacci>(this, "fibonacci");

  一个动作客户端需要以下3个参数：
   ∙ \bullet ∙ 模板化的动作类型名称：Fibonacci
   ∙ \bullet ∙ 一个可以将动作客户端添加进来的ROS 2节点：this
   ∙ \bullet ∙ 动作名称："fibonacci"

  接着实例化了一个ROS计时器，用于启动send_goal函数：

this->timer_ = this->create_wall_timer(
    std::chrono::milliseconds(500),
    std::bind(&FibonacciActionClient::send_goal, this)
);

  当计时器到达设定值时，它将调用send_goal函数：

void send_goal()
{
    using namespace std::placeholders;
    this->timer_->cancel();
    if (!this->client_ptr_->wait_for_action_server()) {
        RCLCPP_ERROR(this->get_logger(), "Action server not available after waiting");
        rclcpp::shutdown();
    }

    auto goal_msg = Fibonacci::Goal();
    goal_msg.order = 10;
    RCLCPP_INFO(this->get_logger(), "Sending goal");

    auto send_goal_options = rclcpp_action::Client<Fibonacci>::SendGoalOptions();
    send_goal_options.goal_response_callback = std::bind(&FibonacciActionClient::goal_response_callback, this, _1);
    send_goal_options.feedback_callback =std::bind(&FibonacciActionClient::feedback_callback, this, _1, _2);
    send_goal_options.result_callback =std::bind(&FibonacciActionClient::result_callback, this, _1);

    this->client_ptr_->async_send_goal(goal_msg, send_goal_options);
}

  该函数会执行以下操作：
   ∙ \bullet ∙ 取消计时器（这样该函数仅被调用一次）；
   ∙ \bullet ∙ 等待动作服务器启动；
   ∙ \bullet ∙ 实例化一个新目标Fibonacci :: Goal；
   ∙ \bullet ∙ 设置响应、反馈和结果回调
   ∙ \bullet ∙ 将目标发送到服务器

  当动作服务器接收到目标并接受该目标时，它会向客户端发送响应。该响应由下面的回调函数goal_response_callback处理：

void goal_response_callback(std::shared_future<GoalHandleFibonacci::SharedPtr> future)
{
    auto goal_handle = future.get();
    if (!goal_handle) 
    {
        RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
    } 
    else 
    {
        RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
    }
}

  假如目标已被服务器接受，它就会开始处理。发送给客户端的任何反馈都将由下面的回调函数feedback_callback处理：

void feedback_callback(GoalHandleFibonacci::SharedPtr, const std::shared_ptr<const Fibonacci::Feedback> feedback)
{
    std::stringstream ss;
    ss << "Next number in sequence received: ";
    for (auto number : feedback->partial_sequence) {
        ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
}

  当服务器完成处理后，会将结果返回给客户端。结果由下面的回调函数result_callback处理：

void result_callback(const GoalHandleFibonacci::WrappedResult & result)
{
    switch (result.code) {
    case rclcpp_action::ResultCode::SUCCEEDED:
        break;
    case rclcpp_action::ResultCode::ABORTED:
        RCLCPP_ERROR(this->get_logger(), "Goal was aborted");
        return;
    case rclcpp_action::ResultCode::CANCELED:
        RCLCPP_ERROR(this->get_logger(), "Goal was canceled");
        return;
    default:
        RCLCPP_ERROR(this->get_logger(), "Unknown result code");
        return;
    }

    std::stringstream ss;
    ss << "Result received: ";
    for (auto number : result.result->sequence) {
        ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
    rclcpp::shutdown();
}

3.3 编译动作客户端

  首先，需要设置CMakeLists.txt，以便编译动作客户端。打开action_tutorials_cpp/CMakeLists.txt文件，并在find_package调用之后添加以下内容：

add_library(action_server SHARED
    src/fibonacci_action_server.cpp)

target_include_directories(action_server PRIVATE
<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
<INSTALL_INTERFACE:include>)

target_compile_definitions(action_server
    PRIVATE "ACTION_TUTORIALS_CPP_BUILDING_DLL")

ament_target_dependencies(action_server
    "action_tutorials_interfaces"
    "rclcpp"
    "rclcpp_action"
    "rclcpp_components")

rclcpp_components_register_node(action_server PLUGIN "action_tutorials_cpp::FibonacciActionServer" EXECUTABLE fibonacci_action_server)

install(TARGETS
    action_server
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
    RUNTIME DESTINATION bin)

  接下来就可以编译该功能包了，进入到工作空间根目录下，执行下列命令：

colcon build

3.4 运行动作客服端

  打开一个新终端，进入到工作空间根目录，然后运行如下命令：

. install/setup.bash
ros2 run action_tutorials_cpp fibonacci_action_client

  运行动作服务器和动作客户端之后，在动作客户端中输出如下信息：

[INFO] [fibonacci_action_client]: Sending goal
[INFO] [fibonacci_action_client]: Goal accepted by server, waiting for result
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 8 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 8 13 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 8 13 21 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 8 13 21 34 
[INFO] [fibonacci_action_client]: Next number in sequence received: 0 1 1 2 3 5 8 13 21 34 55 
[INFO] [fibonacci_action_client]: Result received: 0 1 1 2 3 5 8 13 21 34 55

  同时，在动作服务器中输出如下信息：

[INFO] [fibonacci_action_server]: Received goal request with order 10
[INFO] [fibonacci_action_server]: Executing goal
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Publish feedback
[INFO] [fibonacci_action_server]: Goal succeeded
【C++】ROS：ROS2环境配置与基础示例
DevFrank的博客
06-15 4494
ros2环境配置与基础使用
【ROS】ROS2编程示例：服务和客户端-C++版
郭老二
06-03 798
ROS2入门C++示例：服务端和客户端；包括安装、配置、编辑、编译、运行
ROS2动作通信（C++）
孤ROS的博客
07-10 1600
当前工作空间下，启动两个终端，终端1执行动作服务端程序，终端2执行动作客户端程序。最终运行结果与案例类似。
ROS2动作通信(C++实现)
最新发布
m0_55541357的博客
10-03 845
感觉每个通信都是那几个流程，觉得困难只要还是因为调用各种类型，各种接口，各种函数太多了，让人乱糟糟的感觉，我认为主要理解了整个流程就行，具体函数还是直接根据模板代码直接修改比较好。
ROS2基础--C++
weixin_44824965的博客
02-15 4039
ROS2
ROS2 + C++ 节点（自用笔记）
weixin_71160458的博客
04-25 2731
自用自用。
【ROS2】初级：客户端-创建和使用插件（C++）
cxyhjl的博客
07-07 816
目标：学习使用pluginlib创建和加载一个简单的插件。教程级别：初学者时间：20 分钟目录背景先决条件任务创建基类包创建插件包2.1插件的源代码2.2 插件声明 XML2.3 CMake 插件声明使用插件构建并运行摘要背景这个教程源自于 http://wiki.ros.org/pluginlib，以及编写和使用一个简单插件教程。pluginlib是一个 C++库，用于在...
ROS与C++入门教程.pdf
07-27
标题《ROS与C++入门教程.pdf》以及描述“介绍利用C++来编写ROS程序，编写ROS参数，ROS服务，ROS发布器，ROS订阅器，分析C++例程，分析roscpp类API”明确表明了该教程的主题集中在如何使用C++语言结合ROS（Robot ...
ROS入门21讲课件&源码.zip
09-26
本资源包“ROS入门21讲课件&源码.zip”提供了学习ROS的初级教程，包括课件和源码，是初学者踏入ROS世界的一份宝贵资料。 1. **ROS基础知识** - **ROS架构**：ROS由节点、消息、服务、参数服务器、图模型等核心概念...
ROS与Python入门教程.pdf
07-16
综上所述，ROS与Python入门教程覆盖了从基础到高级的各个方面的内容，适合希望学习ROS和Python的初学者及进阶用户。通过这门课程的学习，开发者将能够掌握如何使用Python来开发功能完备的ROS应用程序。
MATLAB - ROS 入门教程
weixin_46300916的博客
01-22 1885
下面的命令显示，node_1 向 /pose、/rosout 和 /tf 主题发布信息，订阅 /scan 主题并提供服务： /node_1/get_loggers 和 /node_1/set_logger_level。当使用主节点的 IP 地址调用 rosinit 时，它会尝试检测用于联系主节点的网络接口，并将其作为全局节点的 IP 地址。ROS 主节点的地址由 ROS_MASTER_URI 指定，全局节点的广告地址由 ROS_IP 或 ROS_HOSTNAME 指定。
ROS2（c++）
2301_80193801的博客
02-06 1140
概念：概念：节点：ROS中的每个节点应负责单个模块用途（例如，一个节点用于控制车轮电机，一个用于控制激光测距仪等）。每个节点都可以通过主题、服务、操作或参数向其他节点发送和接收数据。工作空间：工作空间可以类比于VS中的SolutionDir，是一个目录，包含build、install、log、src四个子文件夹，src保存源码。功能包：功能包可以理解为存节点的地方，在ROS2中根据编译方式的不同，可以分为：ament_python，适用于python程序cmake，适用于C++
ros2与Python入门教程-新建ros2工作空间
ncnynl的专栏
07-03 669
创建ros2的工作空间
【ROS2】初级：客户端-使用类中的参数（C++）
cxyhjl的博客
07-07 942
目标：使用 C++创建并运行一个带有 ROS 参数的类。教程级别：初学者时间：20 分钟目录背景先决条件任务1. 创建一个包2. 编写 C++ 节点3. 建立并运行摘要下一步背景在创建您自己的节点时，有时需要添加可以从启动文件设置的参数。这个教程将向您展示如何在 C++类中创建这些参数，以及如何在启动文件中设置它们。先决条件在之前的教程中，您学习了如何创建工作空间和创建软件包。您还...
《动手学ROS2》5.5Action服务端C++实现
生活不止眼前的苟且
11-12 649
本系列教程作者：小鱼 公众号：鱼香ROS QQ交流群：139707339 教学视频地址：小鱼的B站 完整文档地址：鱼香ROS官网 版权声明：如非允许禁止转载与商业用途。 5.5Action服务端C++实现 因为后续课程使用到Action的地方都是在最后阶段，为了减轻大家学习负担，先不进行讲解，有兴趣的同学可以参考官方例程源码，小鱼这里也贴一份放在这。 #include <inttypes.h> #include <memory> #include "example_interf.
ROS2与C++入门教程-在C++包里增加python支持
ncnynl的专栏
07-11 1738
ROS2与C++入门教程-在C++包里增加python支持
ROS2与C++入门教程-编写动作客户端
ncnynl的专栏
07-11 465
ROS2与C++入门教程-编写动作客户端
ROS2与C++入门教程-话题组件演示
ncnynl的专栏
07-12 520
ROS2与C++入门教程-话题组件演示
ROS2入门教程—创建一个简单的订阅者和发布者（C++版）
Roar冷颜的博客
09-22 6970
ROS2入门教程—创建一个简单的订阅者和发布者（C++版）1 创建功能包2 创建发布者节点3 设置发布者节点依赖项4 设置发布者节点编译规则5 创建订阅者6 编译并运行   节点是通过ROS graph进行通信的可执行进程。在本教程中，节点将通过话题以字符串消息的形式相互传递信息。这里使用的例子是一个简单的“talker”和“listener”系统；一个节点发布数据，另一个节点订阅该话题，以便它可以接收该数据。之前我们已经通过命令行实现过话题的发布和订阅，本篇我们就来尝试下如何通过C++代码来实现发布者和订
21天掌握ROS2教程：快速入门与实践
资源摘要信息:"ROS 2（Robot Operating System 2）是一个用于机器人应用的开源元操作系统，它提供了用于编写机器人软件的工具和库。本教程旨在为初学者提供一个为期21天的学习计划，帮助他们掌握ROS 2的基础知识和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Roar冷颜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值