Ros2 实时编程实践第二章 -- ros2 lifecycle node

已于 2024-09-11 09:49:17 修改
阅读量388 收藏 8
点赞数 6
文章标签： ros2 lifecycle node C++ 实时性编程
于 2024-08-11 17:53:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cy1641395022/article/details/140707833
版权

ros2 lifecycle node

1 前言和资料

pendulum demo design 提到了其关键节点使用了 ros2 的 lifecycle node 机制来满足实时性要求，RealtimeROS2 里也提到了 lifecycle node 可用于实时编程。本文我们将专题研究 ros2 的 lifecycle node。
本文参考资料如下：
（1）lifecycle
（2）node_lifecycle
（3）Pendulum demo design

2 正文

2.1 lifecycle node 设计详解

（1）lifecycle node 引入：通常情况下，一个 C++ 实时性程序应具有三段式：
初始化阶段（非实时）：申请堆内存，创建并启动线程等。
运行阶段（实时）：正常运行阶段，一般是循环体实现，要求具有实时性。
销毁阶段（非实时）：释放堆内存，回收线程。
为了标准化这个流程，ros2 提供了 lifecycle node，其强制要求节点必须按照预定义的状态机进行状态转换，确保正常运行前，完成所有实例化。除此之外，lifecycle node 还支持在线暂停和激活节点。
（2）rclcpp_lifecycle::LifecycleNode 类：通常 ros2 的节点类需要继承 rclcpp::Node 基类，而实现 lifecycle node，则要求节点必须继承 rclcpp_lifecycle::LifecycleNode 类，下一节会有样例。
（3）lifecycle node 状态转换分析：下面这张图就是状态转换全貌，读懂他就懂 lifecycle 了。
在这里插入图片描述
四个基础状态（蓝色）：

unconfigured（ID 为 1）：节点刚被构造出来时的初始状态。
inactive（ID 为 2）：节点已经完成初始化，并准备进入运行时的状态。在该状态下，节点不会参与任何计算或者发布/订阅操作。
active（ID 为 3）：节点的运行时状态，必须满足一定的实时性要求。
finalized（ID 为 4）：节点即将关闭时的状态，也是最后一个状态，此时节点无法重新启动。

六个过渡状态（黄色）：

configuring：当节点从 unconfigured 转为 inactive 时，经过的中间状态，此时会执行 on_configure() 回调函数，下节有样例。
			对应的状态转换类型为 configure（ID 为 1）。
cleaningup：当节点从 inactive 转回 unconfigured 时，经过的中间状态，此时会执行 on_cleanup() 回调函数。
			对应的状态转换类型为 cleanup（ID 为 2）。
activating：当节点从 inactive 转为 active 时，经过的中间状态，此时会执行 on_activate() 回调函数。
			对应的状态转换类型为 activate（ID 为 3）。
deactivating：当节点从 active 转回 inactive 时，经过的中间状态，此时会执行 on_deactivate() 回调函数。
			对应的状态转换类型为 deactivate（ID 为 4）。
shuttingdown：节点从 unconfigured ，inactive 和 active 都可以转为 finalized，并经过 shuttingdown 中间状态，此时会执行 on_shutdown() 回调函数。
			对应的状态转换类型为 shutdown（ID 为 5，6，7，分别对应源状态 unconfigured ，inactive 和 active）。
errorprocessing：前面五个过渡状态和 active 基础状态都有可能发生错误并抛出，而这里就是处理错误的中间状态，此时会执行 on_error() 回调函数。
				处理成功，会转回 unconfigured 初始状态；处理失败，会进入 finalized 结束状态。

（4）lifecycle node 如何有利于实现实时编程：
第一，把实时代码与非实时代码明确分离开，即只有节点处于 active 状态时的运行函数才是实时代码，其他各种回调函数都是非实时代码。
第二，对 ros 节点提供了更精细的控制能力，包括确保正确的启动顺序，在线启停节点等。
第三，标准化了节点的生命周期管理。
（5）lifecycle node 还提供了命令行操作，这里解释命令，下节有样例。

# 查看正确活跃的 lifecycle 节点
ros2 lifecycle node
# 获取 lifecycle 节点的当前基础状态
ros2 lifecycle get {节点名}
# 获取 lifecyclde 节点当前可进行的状态转换
ros2 lifecycle list {节点名}
# 触发 lifecycle 节点进行状态转换
ros2 lifecycle set {节点名} {状态转换类型}

2.2 lifecycle_demo 实现

（1）lifecycle_demo 设计：本样例共设计了三个节点，细节如下。
lifecycle_talker ：是 lifecycle node，并负责发布消息；
lifecycle_listener：是普通节点，负责订阅消息和上游 lifecycle_talker 的状态转换信息；
lifecycle_service_client：也是普通节点，利用 lifecycle node 提供的 service 服务，触发 lifecycle_talker 进行状态转换。
（2）创建 lifecycle_demo 软件包以及相关文件

cd ~/colcon_ws/src
ros2 pkg create --build-type ament_cmake --license Apache-2.0 lifecycle_demo --dependencies lifecycle_msgs rclcpp rclcpp_lifecycle std_msgs
cd lifecycle_demo
mkdir launch
touch src/lifecycle_talker.cpp src/lifecycle_listener.cpp src/lifecycle_service_client.cpp
touch launch/lifecycle_demo_launch.py

（3）lifecycle_talker.cpp

#include <chrono>
#include <memory>
#include <string>
#include <thread>
#include <utility>

#include "rclcpp/rclcpp.hpp"
#include "rclcpp_lifecycle/lifecycle_node.hpp"
#include "rclcpp_lifecycle/lifecycle_publisher.hpp"

#include "std_msgs/msg/string.hpp"

class LifecycleTalker : public rclcpp_lifecycle::LifecycleNode {
public:
    // 通常情况下，不推荐在构造函数内进行资源申请，有可能失败，但又无法获取返回值
    // 如果这里是普通的 node，初始化部分应放在单独的 init 函数中，并根据返回值判断是否初始化成功
    explicit LifecycleTalker(const std::string& node_name, bool is_intra_process = false) : 
                            rclcpp_lifecycle::LifecycleNode(node_name, 
                            rclcpp::NodeOptions().use_intra_process_comms(is_intra_process)) {
        RCLCPP_INFO(this->get_logger(), "LifecycleTalker constructor is called");
    }

    // 这是 configuring 过渡状态的回调函数，用于初始化节点，完成后将从 unconfigured 进入 inactive 状态
    // 这里将完成程序的初始化，申请各种资源，创建发布器和定时器
    rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn on_configure(
        const rclcpp_lifecycle::State& pre_state) {
        pub_str_ = this->create_publisher<std_msgs::msg::String>("lifecycle_chatter", 10);
        lc_timer_ = this->create_wall_timer(std::chrono::seconds(1), [this]() {return this->publish();});
        count_ = 0;

        RCLCPP_INFO(this->get_logger(), 
            "LifecycleTalker on_configure is called for initial, pre state is %s", pre_state.label().c_str());

        return rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn::SUCCESS;
    }

    // 这是定时器的回调函数，也是节点处于 active 状态时的主要工作函数，应满足实时性要求，因此不应该有 log，而应是一个纯粹的工作函数。
    void publish() {
        auto str_msg = std::make_unique<std_msgs::msg::String>();
        str_msg->data = "lifecycle say hello " + std::to_string(count_++);

        if (true == pub_str_->is_activated()) {
            RCLCPP_INFO(this->get_logger(), "LifecycleTalker publish: %s", str_msg->data.c_str());
        } else {
            RCLCPP_INFO(this->get_logger(), "LifecycleTalker is deactivated");
        }

        // 如果节点不处于 active 状态，即使调用了 publish ，也不会发布消息，lifecycle_listener 的 log 会证明这一点
        // 这是 lifecycle node 非常巧妙的一个设计，可以实现在线启动和关停节点
        pub_str_->publish(std::move(str_msg));
    }

    // 这是 activating 过渡状态的回调函数，完成后将从 inactive 进入 active 状态
    rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn on_activate(
        const rclcpp_lifecycle::State& pre_state) {
        LifecycleNode::on_activate(pre_state);

        RCLCPP_INFO(this->get_logger(), 
            "LifecycleTalker on_activate is called, pre state is %s", pre_state.label().c_str());

        std::this_thread::sleep_for(std::chrono::seconds(2));

        return rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn::SUCCESS;
    }

    // 这是 deactivating 过渡状态的回调函数，完成后将从 active 返回 inactive 状态
    rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn on_deactivate(
        const rclcpp_lifecycle::State& pre_state) {
        LifecycleNode::on_deactivate(pre_state);

        RCLCPP_INFO(this->get_logger(), 
            "LifecycleTalker on_deactivate is called, pre state is %s", pre_state.label().c_str());

        return rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn::SUCCESS;
    }    

    // 这是 cleaning 过渡状态的回调函数，完成后将从 inactive 返回 unconfigured 状态
    rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn on_cleanup(
        const rclcpp_lifecycle::State& pre_state) {
        // 释放资源，清空智能指针
        pub_str_.reset();
        lc_timer_.reset();

        RCLCPP_INFO(this->get_logger(), 
            "LifecycleTalker on_cleanup is called, pre state is %s", pre_state.label().c_str());

        return rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn::SUCCESS;
    }  

    // 这是 shuttingdown 过渡状态的回调函数，完成后将进入 finalized 状态
    rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn on_shutdown(
        const rclcpp_lifecycle::State& pre_state) {
        // 释放资源，清空智能指针
        pub_str_.reset();
        lc_timer_.reset();

        RCLCPP_INFO(this->get_logger(), 
            "LifecycleTalker on_shutdown is called, pre state is %s", pre_state.label().c_str());

        return rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn::SUCCESS;
    }  

private:
    std::shared_ptr<rclcpp_lifecycle::LifecyclePublisher<std_msgs::msg::String>> pub_str_;
    std::shared_ptr<rclcpp::TimerBase> lc_timer_;
    size_t count_;
};

int main(int argc, char* argv[]) {
    rclcpp::init(argc, argv);
    // 单线程执行器，用于 lifecycle_talker 执行，其在单个线程顺序地执行所有回调函数，
    // 满足 lifecycle node 对状态转换必须严格按照顺序执行的要求
    rclcpp::executors::SingleThreadedExecutor exe;
    std::shared_ptr<LifecycleTalker> lc_talker = std::make_shared<LifecycleTalker>("lifecycle_talker");
    exe.add_node(lc_talker->get_node_base_interface());
    exe.spin();
    rclcpp::shutdown();
    return 0;
}

（4）lifecycle_listener.cpp

#include <functional>
#include <memory>
#include <string>

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

#include "lifecycle_msgs/msg/transition_event.hpp"

class LifecycleListener : public rclcpp::Node {
public:
    explicit LifecycleListener(const std::string& node_name) : Node(node_name) {
        // 上下游约定的 topic 名为 lifecycle_chatter
        sub_str_ = this->create_subscription<std_msgs::msg::String>(
            "lifecycle_chatter", 10, 
            [this](std_msgs::msg::String::ConstSharedPtr msg) {return this->str_cb(msg);});

        // 上游 lifecycle 节点名为 lifecycle_talker，因此他一定会附赠一个 lifecycle_talker/transition_event topic
        // 下游订阅这个 topic，可以获取到 lifecycle_talker 节点的状态变化信息
        sub_transition_ = this->create_subscription<lifecycle_msgs::msg::TransitionEvent>(
            "lifecycle_talker/transition_event", 10,
            [this](lifecycle_msgs::msg::TransitionEvent::ConstSharedPtr msg) {return this->trans_cb(msg);});

        RCLCPP_INFO(this->get_logger(), "LifecycleListener constructor is called");
    }

    void str_cb(std_msgs::msg::String::ConstSharedPtr str_msg) {
        RCLCPP_INFO(this->get_logger(), "str_cb: %s", str_msg->data.c_str());
    }

    void trans_cb(lifecycle_msgs::msg::TransitionEvent::ConstSharedPtr state_msg) {
        RCLCPP_INFO(this->get_logger(), "trans_cb: transition from %s to %s", 
            state_msg->start_state.label.c_str(), state_msg->goal_state.label.c_str());
    }


private:
    std::shared_ptr<rclcpp::Subscription<std_msgs::msg::String>> sub_str_;
    std::shared_ptr<rclcpp::Subscription<lifecycle_msgs::msg::TransitionEvent>> sub_transition_;
};

int main(int argc, char* argv[]) {
    rclcpp::init(argc, argv);
    rclcpp::spin(std::make_shared<LifecycleListener>("lifecycle_listener"));
    rclcpp::shutdown();
}

（5）lifecycle_service_client.cpp

#include <chrono>
#include <future>
#include <memory>
#include <string>
#include <thread>

#include "rclcpp/rclcpp.hpp"

#include "lifecycle_msgs/msg/state.hpp"
#include "lifecycle_msgs/msg/transition.hpp"
#include "lifecycle_msgs/srv/change_state.hpp"
#include "lifecycle_msgs/srv/get_state.hpp"

class LifecycleServiceClient : public rclcpp::Node {
public:
    explicit LifecycleServiceClient(const std::string & node_name) : Node(node_name) {
        RCLCPP_INFO(this->get_logger(), "LifecycleServiceClient constructor is called");
    }

    void init() {
        // client_get_state_topic 为 lifecycle_talker/get_state
        // client_change_state_topic 为 lifecycle_talker/change_state
        // 上游 lifecycle 节点名为 lifecycle_talker，因此他一定会附赠 lifecycle_talker/get_state 和 lifecycle_talker/change_state service
        // 触发器通过这两个 service ，可以驱动 lifecycle_talker 节点的状态变化
        client_get_state_ = this->create_client<lifecycle_msgs::srv::GetState>(client_get_state_topic);
        client_change_state_ = this->create_client<lifecycle_msgs::srv::ChangeState>(client_change_state_topic);
    }

    uint32_t get_state(std::chrono::seconds timeout = std::chrono::seconds(3)) {
        std::shared_ptr<lifecycle_msgs::srv::GetState::Request> get_state_req = 
            std::make_shared<lifecycle_msgs::srv::GetState::Request>();
        
        if (false == client_get_state_->wait_for_service(timeout)) {
            RCLCPP_ERROR(this->get_logger(), "service %s is not available", client_get_state_->get_service_name());
            // PRIMARY_STATE_UNKNOWN 为 0，表示未知状态
            return lifecycle_msgs::msg::State::PRIMARY_STATE_UNKNOWN;
        }

        auto future_result = client_get_state_->async_send_request(get_state_req);
        if (rclcpp::spin_until_future_complete(this->get_node_base_interface(), future_result) == 
                                                        rclcpp::FutureReturnCode::SUCCESS) {
            // future_result 只能被调用一次，调用后会发生值转移，再次调用属于未定义行为
            // 因此这里缓存了 future_result 的值，免去二次调用
            auto tmp_result = future_result.get();
            RCLCPP_INFO(this->get_logger(), "node [%s] in state: %s", lifecycle_node.c_str(), 
                                                    tmp_result->current_state.label.c_str());
            return tmp_result->current_state.id;
        } else {
            RCLCPP_ERROR(this->get_logger(), "failed to call service %s", client_get_state_->get_service_name());
            return lifecycle_msgs::msg::State::PRIMARY_STATE_UNKNOWN;
        }
    }

    bool change_state(std::uint8_t transition_id, std::chrono::seconds timeout = std::chrono::seconds(3)) {
        std::shared_ptr<lifecycle_msgs::srv::ChangeState::Request> change_state_req = 
            std::make_shared<lifecycle_msgs::srv::ChangeState::Request>();
        change_state_req->transition.id = transition_id;

        if (false == client_change_state_->wait_for_service(timeout)) {
            RCLCPP_ERROR(this->get_logger(), "service %s is not available", client_change_state_->get_service_name());
            return false;
        }

        auto future_result = client_change_state_->async_send_request(change_state_req);
        if (rclcpp::spin_until_future_complete(this->get_node_base_interface(), future_result) ==
                                                        rclcpp::FutureReturnCode::SUCCESS) {
            RCLCPP_INFO(this->get_logger(), "node [%s] transition %d is successful", lifecycle_node.c_str(), transition_id);
            return true;
        } else {
            RCLCPP_ERROR(this->get_logger(), "failed to call service %s, transition %d is failed", 
                                                client_change_state_->get_service_name(), transition_id);
            return false;
        }
    }

private:
    const std::string lifecycle_node = "lifecycle_talker";
    const std::string client_get_state_topic = "lifecycle_talker/get_state";
    const std::string client_change_state_topic = "lifecycle_talker/change_state";

    std::shared_ptr<rclcpp::Client<lifecycle_msgs::srv::GetState>> client_get_state_;
    std::shared_ptr<rclcpp::Client<lifecycle_msgs::srv::ChangeState>> client_change_state_;
};

// 按照 lifecycle node 的状态转换顺序，
// 依次触发 configure, activate, deactivate, activate, deactivate, cleanup, shutdown 状态转换
void trigger_change(std::shared_ptr<LifecycleServiceClient>& lc_client) {
    rclcpp::WallRate time_between_state_change(0.2);   // 0.2hz
    
    using Transition = lifecycle_msgs::msg::Transition;
    using State = lifecycle_msgs::msg::State;

    // configure 状态转换
    // 完成后，lifecycle_talker 节点将从 unconfigured 状态转换到 inactive 状态
    {
        if (false == lc_client->change_state(Transition::TRANSITION_CONFIGURE)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: configure");
            return;
        }

        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            RCLCPP_INFO(lc_client->get_logger(), "failed to get state in configure");
            return;
        }
    }

    // activate 状态转换
    // 完成后，lifecycle_talker 节点将从 inactive 状态转换到 active 状态
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_ACTIVATE)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: activate");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }

    // deactivate 状态转换
    // 完成后，lifecycle_talker 节点将从 active 状态转回到 inactive 状态
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_DEACTIVATE)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: deactivate");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }

    // activate it again
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_ACTIVATE)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: activate");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }

    // deactivate it again
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_DEACTIVATE)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: deactivate");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }

    // cleanup 状态转换
    // 完成后，lifecycle_talker 节点将从 inactive 状态转回到 unconfigured 状态
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_CLEANUP)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: cleanup");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }

    // shutdown 状态转换
    // 完成后，lifecycle_talker 节点将从 unconfigured 状态转回到 finalized 状态
    {
        time_between_state_change.sleep();
        if (false == rclcpp::ok()) {
            return;
        }

        if (false == lc_client->change_state(Transition::TRANSITION_UNCONFIGURED_SHUTDOWN)) {
            RCLCPP_ERROR(lc_client->get_logger(), "failed to trigger state: shutdown");
            return;
        }
        if (State::PRIMARY_STATE_UNKNOWN == lc_client->get_state()) {
            return;
        }
    }
}

int main(int argc, char * argv[]) {
    rclcpp::init(argc, argv);
    std::shared_ptr<LifecycleServiceClient> lc_client = std::make_shared<LifecycleServiceClient>("lifecycle_service_client");
    lc_client->init();
    trigger_change(lc_client);
    rclcpp::shutdown();
    return 0;
}

（6）lifecycle_demo_launch.py

from launch import LaunchDescription
from launch.actions import Shutdown
from launch_ros.actions import LifecycleNode
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        LifecycleNode(
            package="lifecycle_demo", 
            executable="lifecycle_talker",
            name="lifecycle_talker",
            namespace="cpp",
            output="screen"
        ),
        Node(
            package="lifecycle_demo",
            executable="lifecycle_listener",
            name="lifecycle_listener",
            namespace="cpp",
            output="screen"
        ),
        Node(
            package="lifecycle_demo",
            executable="lifecycle_service_client",
            name="lifecycle_service_client",
            namespace="cpp",
            output="screen",
            on_exit=Shutdown()
        )
    ])

（7）CMakeLists.txt

cmake_minimum_required(VERSION 3.8)
project(lifecycle_demo)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# find dependencies
find_package(ament_cmake REQUIRED)
find_package(lifecycle_msgs REQUIRED)
find_package(rclcpp REQUIRED)
find_package(rclcpp_lifecycle REQUIRED)
find_package(std_msgs REQUIRED)

add_executable(lifecycle_talker src/lifecycle_talker.cpp)
ament_target_dependencies(lifecycle_talker lifecycle_msgs rclcpp rclcpp_lifecycle std_msgs)

add_executable(lifecycle_listener src/lifecycle_listener.cpp)
ament_target_dependencies(lifecycle_listener lifecycle_msgs rclcpp std_msgs)

add_executable(lifecycle_service_client src/lifecycle_service_client.cpp)
ament_target_dependencies(lifecycle_service_client lifecycle_msgs rclcpp)


install(TARGETS
  lifecycle_talker
  lifecycle_listener
  lifecycle_service_client
  DESTINATION lib/${PROJECT_NAME})

install(DIRECTORY
  launch
  DESTINATION share/${PROJECT_NAME}
)
ament_package()

（8）编译并运行

cd ~/colcon_ws/src
colcon build --packages-select lifecycle_demo
source install/local_setup.bash
# 分成三个窗口运行，单独看运行 log 比较清晰（每个都别忘设置环境变量）
ros2 run lifecycle_demo lifecycle_talker
ros2 run lifecycle_demo lifecycle_listener
ros2 run lifecycle_demo lifecycle_service_client
# 使用 launch 文件运行
ros2 launch lifecycle_demo lifecycle_demo_launch.py
# 也可以关闭 lifecycle_service_client，测试命令行触发 lifecycle_talker 进行状态转换
ros2 lifecycle node
ros2 lifecycle get /lifecycle_talker 
ros2 lifecycle list /lifecycle_talker 
ros2 lifecycle set /lifecycle_talker shutdown

下图是使用 launch 文件运行时的一部分 log，其他方式，希望读者自己测试。
在这里插入图片描述

3 总结

本文代码托管在本人的 github 上：lifecycle_demo。

界首大学
关注
ROS2入门到精通—— 1-7 ROS2实战：行为树详解
BigDavid123的博客
07-23 338
本文详细解读了行为树的相关概念以及源码解析
Realtime ROS2 ros2 实时系统
12-14
简单介绍了ros2这个实时系统 全英文的ppt 。。。。。。
ROS2----LifecycleNode生命周期节点总结
lovely_yoshino的博客
07-01 4355
ros2中加入了一种区别于普通的node节点的管理节点LifecycleNode，这种节点有点像是状态机，会在几种不同的状态中切换。LifecycleNode 节点的状态主要分为基本状态（Primary States）和切换状态（Transition States）。主要状态是任何节点都可以做相应的任务的稳态，切换状态切换过程中短暂的临时状态。这些中间状态的结果用于指示两个主要状态之间的转换是否成功。主要由5个部分组成：状态机具有：详细模型如下图所示：注意下图所示的蓝色箭头所指：执行标准化的回调函数。用户代
ROS2 lifecycle node生命周期节点 官方例程文档翻译
ScarlettSun的博客
06-28 705
ROS2 lifecycle node生命周期节点 官方例程文档翻译
ROS2 LifecycleNode讲解及实例
机器人梦想家 Bing
12-12 2058
本文用来记录什么是LifecycleNode，做背景介绍及基本原理的介绍及分析如何使用。1这是节点在实例化后立即处于的生命周期状态。这也是节点在发生错误后可能返回的状态。节点可以经由configure转换转换到Inactive状态节点可以经由shutdown转换转换到Finalized状态本文对于LifecycleNode做了整体的说明和测试，说明了中间的变换关系，方便大家理解和用于实际使用中。↩︎↩︎ROS2----LifecycleNode生命周期节点总结↩︎。
[ROS2] LifecycleNode 命令行工具
shoufei403的博客
03-27 691
使用ros2 lifecycle --h命令可以看到lifecycle相关的命令有哪些。 获取LifecycleNode节点的状态 ros2 lifecycle get /lifecycle_node_demo_node 其中/lifecycle_node_demo_node为节点名称 设置LifecycleNode节点的状态 ros2 lifecycle set /lifecycle_node_demo_node configure 其中/lifecycle_node_demo_node为节点名称
【ROS2】演示:管理具有生命周期管理的节点
cxyhjl的博客
07-22 662
介绍ROS 2 引入了受管节点的概念，也称为LifecycleNode。在下面的教程中，我们将解释这些节点的用途、它们与常规节点的不同之处以及它们如何遵守生命周期管理。受管节点包含具有一组预定义状态的状态机。这些状态可以通过调用指示后续连续状态的转换 ID 来更改。状态机的实现如 ROS 2 设计页面 https://design.ros2.org/articles/node_lifecyc...
ROS2中的LifecycleNode生命周期节点
china_bbz的博客
12-23 3118
ROS2中的LifecycleNode节点UnconfiguredInactiveActiveFinalizedConfiguringCleaningUpActivatingDeactivatingShuttingDownErrorProcessing实例 本文参考：ros2 node_lifecycle ros2中加入了一种区别于普通的node节点的管理节点LifecycleNode，这种节点有点像是状态机，会在几种不同的状态中切换。 LifecycleNode 节点的状态主要分为基本状态（Primary
ROS实时性介绍 RealtimeROS2
11-09
ROS实时性介绍 RealtimeROS2参考资料
【ros/ros2】LCN及ros2节点的LCN改写
shuaixio的博客
05-30 1258
lcn, lifecycle node, lmn, ros2节点lcn改写
ROS2入门到精通—— 2-6 ROS2实战：可调节纯跟踪算法（局部规划）
BigDavid123的博客
07-17 405
本文讲解了可调节的纯追踪算法，效果比单纯根据曲率变换预瞄距离的纯追踪效果更好
ROS2入门到精通—— 2-4 ROS2实战：自定义全局规划插件——StraightLine
BigDavid123的博客
07-16 113
本文可作为自定义规划插件的参考，助于Nav2规划器相关开发
ROS2入门到精通—— 2-5 ROS2实战：自定义控制插件
BigDavid123的博客
07-17 138
本文详解了如何自定义控制插件——纯追踪算法
ROS2轻松学2-工具篇15-lifecycle演示讲义
ncnynl的专栏
01-06 316
ROS2轻松学2-工具篇15-lifecycle演示讲义
【ROS2】节点的生命周期管理
qq_51482778的博客
03-22 288
本文描述了具有受管理生命周期的节点概念。它旨在记录在ROS 2中支持受管理生命周期节点的一些选项。在撰写本文时，考虑了ROS 2 C++客户端库的现有设计，特别是执行器的当前设计。翻译：deepL & chatgpt撰写日期：2015 年 6 月最后修改时间：2021 年 2 月。
【ROS2】演示:理解实时编程
最新发布
cxyhjl的博客
07-25 368
目录背景安装并运行演示运行测试刚刚发生了什么事？调整内存锁定权限输出概述延迟为调度程序设置权限绘图结果背景实时计算是许多机器人系统的关键特性，特别是自动驾驶汽车、航天器和工业制造等安全和任务关键型应用。我们在设计和原型开发 ROS 2 时考虑了实时性能约束，因为这是在 ROS 1 的早期阶段没有考虑到的需求，现在要将 ROS 1 重构为实时友好已经变得难以处理。本文档概述了实时计算的...
[ROS2] 使用LifecycleNode管理节点起停等状态
shoufei403的博客
03-27 4081
有顺序的的启动节点，暂停节点，关闭节点是ROS1的一个痛点。因为在ROS1中节点启动是无序的。ROS1系统设计时并没有考虑节点启动时可能存在的互相依赖。 但在实际生产使用环境中，某些节点能正常工作是需要其他一些节点已经启动了的。 比如：需要定位功能能正常运行，前提是map_server节点已经正常加载地图文件并且已经把地图话题发布出来。 又或者你想从建图功能切到导航功能。在ROS1中，需要先将建图功能的程序杀干净。然后再启动导航程序。在ROS2中，各个节点的状态是可管理的。 在这个场景里，大可让建图程序休眠
ROS2实时性案例分析之倒立摆系统使用（Inverted pendulum）
热门推荐
zhangrelay的专栏
12-24 3万+
倒立摆是自动控制原理或现代控制理论等经典分析案例，博客有数篇博文针对这样案例给出题目和分析： https://blog.csdn.net/ZhangRelay/article/details/89005359 本篇主要针对倒立摆小车在ROS2系统中的实现为例，进行详细介绍。 为什么选择使用倒立摆进行实时演示呢？ rviz2中倒立摆小车平衡倒立摆是通常由实时计算解决的控制问题的经典示例之...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值