subsystem_controllers::BaseSubsystemController Class Reference

A base class for all subsystem_controllers which provides default lifecycle behavior for subsystems. More...

#include <base_subsystem_controller.hpp>

Inheritance diagram for subsystem_controllers::BaseSubsystemController:

Collaboration diagram for subsystem_controllers::BaseSubsystemController:

Public Member Functions
	BaseSubsystemController ()=delete
	BaseSubsystemController (const rclcpp::NodeOptions &options)
	Constructor. Set explicitly to support node composition. More...
	~BaseSubsystemController ()=default
void	set_config (BaseSubSystemControllerConfig config)
virtual void	on_system_alert (const carma_msgs::msg::SystemAlert::UniquePtr msg)
virtual carma_ros2_utils::CallbackReturn	handle_on_configure (const rclcpp_lifecycle::State &prev_state)
virtual carma_ros2_utils::CallbackReturn	handle_on_activate (const rclcpp_lifecycle::State &prev_state)
virtual carma_ros2_utils::CallbackReturn	handle_on_deactivate (const rclcpp_lifecycle::State &prev_state)
virtual carma_ros2_utils::CallbackReturn	handle_on_cleanup (const rclcpp_lifecycle::State &prev_state)
virtual carma_ros2_utils::CallbackReturn	handle_on_error (const rclcpp_lifecycle::State &prev_state, const std::string &exception_string)
virtual carma_ros2_utils::CallbackReturn	handle_on_shutdown (const rclcpp_lifecycle::State &prev_state)

Protected Member Functions
std::vector< std::string >	get_nodes_in_namespace (const std::string &node_namespace) const
	Returns the list of fully qualified node names for all ROS2 nodes in the provided namespace. More...
std::vector< std::string >	get_non_intersecting_set (const std::vector< std::string > &set_a, const std::vector< std::string > &set_b) const
	Returns all elements of the provided set_a which are NOT contained in the provided set_b. More...

Protected Attributes
ros2_lifecycle_manager::Ros2LifecycleManager	lifecycle_mgr_
	Lifecycle Manager which will track the managed nodes and call their lifecycle services on request. More...
rclcpp::Subscription< carma_msgs::msg::SystemAlert >::SharedPtr	system_alert_sub_
	The subscriber for the system alert topic. More...
BaseSubSystemControllerConfig	base_config_
	The configuration struct. More...
bool	trigger_managed_nodes_configure_from_base_class_ = true
	Collection of flags which, if true, will cause the base class to make lifecycle service calls to managed nodes. More...
bool	trigger_managed_nodes_activate_from_base_class_ = true
bool	trigger_managed_nodes_deactivate_from_base_class_ = true
bool	trigger_managed_nodes_cleanup_from_base_class_ = true

Detailed Description

A base class for all subsystem_controllers which provides default lifecycle behavior for subsystems.

The default behavior which is provided is as follows

• Takes in a list of required nodes and a namespace
• Manages the lifecycle of all nodes which are the union of the required nodes and the namespace
• Monitors the system_alert topic and if a node within its required node set crashes it notifies the larger system that the subsystem has failed
  

Definition at line 39 of file base_subsystem_controller.hpp.

Constructor & Destructor Documentation

BaseSubsystemController() [1/2]

subsystem_controllers::BaseSubsystemController::BaseSubsystemController ( )

delete

BaseSubsystemController() [2/2]

subsystem_controllers::BaseSubsystemController::BaseSubsystemController ( const rclcpp::NodeOptions &  options )

explicit

Constructor. Set explicitly to support node composition.

Parameters

options

The node options to use for configuring this node

Definition at line 27 of file base_subsystem_controller.cpp.

      : CarmaLifecycleNode(options),
      lifecycle_mgr_(get_node_base_interface(), get_node_graph_interface(), get_node_logging_interface(), get_node_services_interface())
  {
    // Declare parameters
    base_config_.service_timeout_ms = this->declare_parameter<int>("service_timeout_ms", base_config_.service_timeout_ms);
    base_config_.call_timeout_ms = this->declare_parameter<int>("call_timeout_ms", base_config_.call_timeout_ms);
    base_config_.required_subsystem_nodes = this->declare_parameter<std::vector<std::string>>("required_subsystem_nodes", base_config_.required_subsystem_nodes);
    base_config_.subsystem_namespace = this->declare_parameter<std::string>("subsystem_namespace", base_config_.subsystem_namespace);
    base_config_.full_subsystem_required = this->declare_parameter<bool>("full_subsystem_required", base_config_.full_subsystem_required);
    base_config_.unmanaged_required_nodes = this->declare_parameter<std::vector<std::string>>("unmanaged_required_nodes", base_config_.unmanaged_required_nodes);
 
    // Handle fact that parameter vectors cannot be empty
    if (base_config_.required_subsystem_nodes.size() == 1 && base_config_.required_subsystem_nodes[0].empty()) {
      base_config_.required_subsystem_nodes.clear();
    }
 
    if (base_config_.unmanaged_required_nodes.size() == 1 && base_config_.unmanaged_required_nodes[0].empty()) {
      base_config_.unmanaged_required_nodes.clear();
    }
 
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, subsystem_controllers::BaseSubSystemControllerConfig::full_subsystem_required, subsystem_controllers::BaseSubSystemControllerConfig::required_subsystem_nodes, subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms, subsystem_controllers::BaseSubSystemControllerConfig::subsystem_namespace, and subsystem_controllers::BaseSubSystemControllerConfig::unmanaged_required_nodes.

~BaseSubsystemController()

subsystem_controllers::BaseSubsystemController::~BaseSubsystemController ( )

default

Member Function Documentation

get_nodes_in_namespace()

std::vector< std::string > subsystem_controllers::BaseSubsystemController::get_nodes_in_namespace ( const std::string &  node_namespace ) const

protected

Returns the list of fully qualified node names for all ROS2 nodes in the provided namespace.

Parameters

node_namespace

The ros namespace to get all nodes within. For example /guidance

Returns

The list of node names

Definition at line 279 of file base_subsystem_controller.cpp.

  {
 
    // These two services are exposed by lifecycle nodes.
    static const std::string CHANGE_STATE_SRV = "/change_state";
    static const std::string GET_STATE_SRV = "/get_state";
 
    static const std::string CHANGE_STATE_TYPE = "lifecycle_msgs/srv/ChangeState";
    static const std::string GET_STATE_TYPE = "lifecycle_msgs/srv/GetState";
 
    static const std::string this_full_name =  std::string(get_namespace()) + "/" + std::string(get_name());
 
 
    auto all_nodes = this->get_node_names();
 
    std::vector<std::string> nodes_in_namspace;
    nodes_in_namspace.reserve(all_nodes.size());
 
 
    for (const auto &node : all_nodes)
    {
 
      if (node == this_full_name)
        continue; // no need for this node to try managing itself
 
      if (node.find(node_namespace) == 0)
      { // The node is in the provided namespace
 
 
        // In the following section of code we check if the current node in the target namespace is actually a lifecycle node
        // This check is done by evaluating if that nodes exposes the change_state and get_state lifecycle services.
        // If the node does not expose these services then it cannot be managed by this component.
        // However, this does not result in an error as the node could be wrapped by a lifecycle component wrapper
 
        // First extract the service names and types for the current node. This requires seperating the node base name and namespace
        std::vector<std::string> result;
        boost::split(result, node, boost::is_any_of("/"));
 
        if (result.empty()) {
          throw std::runtime_error("Fully specified node name does not contain '/' seems to suggest internal ROS error.");
        }
 
        std::string base_name = result.back();
        result.pop_back();
        std::string namespace_joined = boost::algorithm::join(result, "/");
 
        auto services_and_types = get_service_names_and_types_by_node(base_name, namespace_joined);
 
 
        // Next we check if both services are available with the correct type
        // Short variable names used here to make conditional more readable
        const std::string cs_srv = node + CHANGE_STATE_SRV;
        const std::string gs_srv = node + GET_STATE_SRV;
 
        if (services_and_types.find(cs_srv) != services_and_types.end()
          && services_and_types.find(gs_srv) != services_and_types.end()
          && std::find(services_and_types.at(cs_srv).begin(), services_and_types.at(cs_srv).end(), CHANGE_STATE_TYPE) != services_and_types.at(cs_srv).end()
          && std::find(services_and_types.at(gs_srv).begin(), services_and_types.at(gs_srv).end(), GET_STATE_TYPE) != services_and_types.at(gs_srv).end())
        {
 
          nodes_in_namspace.emplace_back(node);
 
        } else {
          // Current node is not a lifecycle node so log a warning
          RCLCPP_WARN_STREAM(get_logger(), "Failed to find lifecycle services for node: " << node << " this node will not be managed. NOTE: If this node is wrapped by a lifecycle component that is managed then this is not an issue.");
 
          continue;
 
        }
      }
    }
 
    return nodes_in_namspace;
  }

References process_traj_logs::split.

Referenced by handle_on_configure().

Here is the caller graph for this function:

get_non_intersecting_set()

std::vector< std::string > subsystem_controllers::BaseSubsystemController::get_non_intersecting_set ( const std::vector< std::string > &  set_a, const std::vector< std::string > &  set_b  ) const

protected

Returns all elements of the provided set_a which are NOT contained in the provided set_b.

set_a The set of strings which will have its intersection checked against

set_b The set of strings which will NOT be in the returned set

Returns

A set of not intersecting strings which are in set_a but not set_b

Definition at line 356 of file base_subsystem_controller.cpp.

  {
 
    std::vector<std::string> non_intersecting_set; // Returned set
    non_intersecting_set.reserve(set_a.size());
 
    std::unordered_set<std::string> set_b_lookup; // Quick lookup map of set_b
    set_b_lookup.reserve(set_b.size());
 
    set_b_lookup.insert(set_b.begin(), set_b.end());
 
    for (const auto &string : set_a)
    {
      if (set_b_lookup.find(string) == set_b_lookup.end())
      { // No intersection so store
        non_intersecting_set.emplace_back(string);
      }
    }
 
    return non_intersecting_set;
  }

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure(), handle_on_configure(), and subsystem_controllers::DriversControllerNode::handle_on_configure().

Here is the caller graph for this function:

handle_on_activate()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_activate ( const rclcpp_lifecycle::State &  prev_state )

virtual

Reimplemented in subsystem_controllers::GuidanceControllerNode, and subsystem_controllers::DriversControllerNode.

Definition at line 167 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to activate");
 
    if (!trigger_managed_nodes_activate_from_base_class_) {
      return CallbackReturn::SUCCESS;
    }
 
    bool success = lifecycle_mgr_.activate(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms)).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to activate");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to activate");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, lifecycle_mgr_, subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms, and trigger_managed_nodes_activate_from_base_class_.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_activate(), and subsystem_controllers::DriversControllerNode::handle_on_activate().

Here is the caller graph for this function:

handle_on_cleanup()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_cleanup ( const rclcpp_lifecycle::State &  prev_state )

virtual

Reimplemented in subsystem_controllers::GuidanceControllerNode.

Definition at line 215 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to cleanup");
 
    if (!trigger_managed_nodes_cleanup_from_base_class_) {
      return CallbackReturn::SUCCESS;
    }
 
    bool success = lifecycle_mgr_.cleanup(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms)).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to cleanup");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to cleanup");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, lifecycle_mgr_, subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms, and trigger_managed_nodes_cleanup_from_base_class_.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_cleanup().

Here is the caller graph for this function:

handle_on_configure()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_configure ( const rclcpp_lifecycle::State &  prev_state )

virtual

Reimplemented in subsystem_controllers::GuidanceControllerNode, subsystem_controllers::DriversControllerNode, and subsystem_controllers::LocalizationControllerNode.

Definition at line 92 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to configure");
 
    // Reset config
    base_config_ = BaseSubSystemControllerConfig();
 
    // Load Parameters
    get_parameter<int>("service_timeout_ms", base_config_.service_timeout_ms);
    get_parameter<int>("call_timeout_ms", base_config_.call_timeout_ms);
    get_parameter<std::vector<std::string>>("required_subsystem_nodes", base_config_.required_subsystem_nodes);
    get_parameter<std::string>("subsystem_namespace", base_config_.subsystem_namespace);
    get_parameter<bool>("full_subsystem_required", base_config_.full_subsystem_required);
    get_parameter<std::vector<std::string>>("unmanaged_required_nodes", base_config_.unmanaged_required_nodes);
 
    // Handle fact that parameter vectors cannot be empty
    if (base_config_.required_subsystem_nodes.size() == 1 && base_config_.required_subsystem_nodes[0].empty()) {
      base_config_.required_subsystem_nodes.clear();
    }
 
    if (base_config_.unmanaged_required_nodes.size() == 1 && base_config_.unmanaged_required_nodes[0].empty()) {
      base_config_.unmanaged_required_nodes.clear();
    }
 
    RCLCPP_INFO_STREAM(get_logger(), "Loaded config: " << base_config_);
 
    // Create subscriptions
    system_alert_sub_ = create_subscription<carma_msgs::msg::SystemAlert>(
        system_alert_topic_, 100,
        std::bind(&BaseSubsystemController::on_system_alert, this, std::placeholders::_1));
 
    // Initialize lifecycle manager
    auto nodes_in_namespace = get_nodes_in_namespace(base_config_.subsystem_namespace);
 
    std::vector<std::string> managed_nodes = nodes_in_namespace;
    managed_nodes.reserve(nodes_in_namespace.size() + base_config_.required_subsystem_nodes.size());
 
    // Collect non-namespace nodes if any and add them to our set of managed nodes
    auto additional_nodes = get_non_intersecting_set(base_config_.required_subsystem_nodes, nodes_in_namespace);
 
    managed_nodes.insert(managed_nodes.end(), additional_nodes.begin(), additional_nodes.end());
 
    lifecycle_mgr_.set_managed_nodes(managed_nodes);
 
    // Check if all nodes are required
    if (base_config_.full_subsystem_required) {
      RCLCPP_INFO_STREAM(get_logger(), "full_subsystem_required is True. Setting all namespace nodes as required");
 
      base_config_.required_subsystem_nodes = managed_nodes;
 
      RCLCPP_INFO_STREAM(get_logger(), "New config: " << base_config_);
    }
 
 
    if (!trigger_managed_nodes_configure_from_base_class_) {
      return CallbackReturn::SUCCESS;
    }
 
    // With all of our managed nodes now being tracked we can execute their configure operations
    bool success = lifecycle_mgr_.configure(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms)).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to configure");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to configure");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, subsystem_controllers::BaseSubSystemControllerConfig::full_subsystem_required, get_nodes_in_namespace(), get_non_intersecting_set(), lifecycle_mgr_, on_system_alert(), subsystem_controllers::BaseSubSystemControllerConfig::required_subsystem_nodes, subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms, subsystem_controllers::BaseSubSystemControllerConfig::subsystem_namespace, system_alert_sub_, trigger_managed_nodes_configure_from_base_class_, and subsystem_controllers::BaseSubSystemControllerConfig::unmanaged_required_nodes.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure(), subsystem_controllers::DriversControllerNode::handle_on_configure(), and subsystem_controllers::LocalizationControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_on_deactivate()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_deactivate ( const rclcpp_lifecycle::State &  prev_state )

virtual

Reimplemented in subsystem_controllers::GuidanceControllerNode.

Definition at line 191 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to deactivate");
 
    if (!trigger_managed_nodes_deactivate_from_base_class_) {
      return CallbackReturn::SUCCESS;
    }
 
    bool success = lifecycle_mgr_.deactivate(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms)).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to deactivate");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to deactivate");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, lifecycle_mgr_, subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms, and trigger_managed_nodes_deactivate_from_base_class_.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_deactivate().

Here is the caller graph for this function:

handle_on_error()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_error ( const rclcpp_lifecycle::State &  prev_state, const std::string &  exception_string  )

virtual

Definition at line 239 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to shutdown due to error");
 
    bool success = lifecycle_mgr_.shutdown(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms)).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to shutdown");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to shutdown");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, lifecycle_mgr_, and subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms.

handle_on_shutdown()

carma_ros2_utils::CallbackReturn subsystem_controllers::BaseSubsystemController::handle_on_shutdown ( const rclcpp_lifecycle::State &  prev_state )

virtual

Reimplemented in subsystem_controllers::GuidanceControllerNode.

Definition at line 259 of file base_subsystem_controller.cpp.

  {
    RCLCPP_INFO_STREAM(get_logger(), "Subsystem trying to shutdown");
 
    bool success = lifecycle_mgr_.shutdown(std_msec(base_config_.service_timeout_ms), std_msec(base_config_.call_timeout_ms), false).empty();
 
    if (success)
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem able to shutdown");
      return CallbackReturn::SUCCESS;
    }
    else
    {
 
      RCLCPP_INFO_STREAM(get_logger(), "Subsystem unable to shutdown");
      return CallbackReturn::FAILURE;
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::call_timeout_ms, lifecycle_mgr_, and subsystem_controllers::BaseSubSystemControllerConfig::service_timeout_ms.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_shutdown().

Here is the caller graph for this function:

on_system_alert()

void subsystem_controllers::BaseSubsystemController::on_system_alert ( const carma_msgs::msg::SystemAlert::UniquePtr  msg )

virtual

Reimplemented in subsystem_controllers::LocalizationControllerNode.

Definition at line 55 of file base_subsystem_controller.cpp.

  {
 
 
    RCLCPP_INFO_STREAM(
          get_logger(), "Received SystemAlert message of type: " << static_cast<int>(msg->type) << " with message: " << msg->description);
 
    // NOTE: Here we check the required nodes not the full managed node set
    if (msg->type == carma_msgs::msg::SystemAlert::FATAL)
    {
 
      // Required node has failed
      if (std::find(base_config_.required_subsystem_nodes.begin(), base_config_.required_subsystem_nodes.end(), msg->source_node) != base_config_.required_subsystem_nodes.end()
          || std::find(base_config_.unmanaged_required_nodes.begin(), base_config_.unmanaged_required_nodes.end(), msg->source_node) != base_config_.unmanaged_required_nodes.end())
      {
        // Our subsystem has failed so notify the overall system controller
 
        RCLCPP_ERROR_STREAM(
          get_logger(), "Failure in required node: " << msg->source_node);
 
        carma_msgs::msg::SystemAlert alert;
        alert.type = carma_msgs::msg::SystemAlert::FATAL;
        alert.description = base_config_.subsystem_namespace + " subsytem has failed with error: " + msg->description;
        alert.source_node =  get_node_base_interface()->get_fully_qualified_name();
        publish_system_alert(alert);
 
        // TODO: It might be worth trying to deactivate or shutdown after alerting the larger system,
        //       but not clear on if that will increase instability of shutdown process
      }
      else
      { // Optional node has failed
        RCLCPP_WARN_STREAM(
          get_logger(), "Failure in optional node: " << msg->source_node);
      }
    }
  }

References base_config_, subsystem_controllers::BaseSubSystemControllerConfig::required_subsystem_nodes, subsystem_controllers::BaseSubSystemControllerConfig::subsystem_namespace, and subsystem_controllers::BaseSubSystemControllerConfig::unmanaged_required_nodes.

Referenced by handle_on_configure(), and subsystem_controllers::LocalizationControllerNode::on_system_alert().

Here is the caller graph for this function:

set_config()

void subsystem_controllers::BaseSubsystemController::set_config

(

BaseSubSystemControllerConfig

config

)

Definition at line 50 of file base_subsystem_controller.cpp.

  {
    base_config_ = config;
  }

References base_config_.

Member Data Documentation

base_config_

BaseSubSystemControllerConfig subsystem_controllers::BaseSubsystemController::base_config_

protected

The configuration struct.

Definition at line 96 of file base_subsystem_controller.hpp.

Referenced by BaseSubsystemController(), handle_on_activate(), handle_on_cleanup(), subsystem_controllers::GuidanceControllerNode::handle_on_configure(), handle_on_configure(), subsystem_controllers::DriversControllerNode::handle_on_configure(), handle_on_deactivate(), handle_on_error(), handle_on_shutdown(), on_system_alert(), and set_config().

lifecycle_mgr_

ros2_lifecycle_manager::Ros2LifecycleManager subsystem_controllers::BaseSubsystemController::lifecycle_mgr_

protected

Lifecycle Manager which will track the managed nodes and call their lifecycle services on request.

Definition at line 90 of file base_subsystem_controller.hpp.

Referenced by handle_on_activate(), handle_on_cleanup(), subsystem_controllers::GuidanceControllerNode::handle_on_configure(), handle_on_configure(), subsystem_controllers::DriversControllerNode::handle_on_configure(), handle_on_deactivate(), handle_on_error(), and handle_on_shutdown().

system_alert_sub_

rclcpp::Subscription<carma_msgs::msg::SystemAlert>::SharedPtr subsystem_controllers::BaseSubsystemController::system_alert_sub_

protected

The subscriber for the system alert topic.

Definition at line 93 of file base_subsystem_controller.hpp.

Referenced by handle_on_configure().

trigger_managed_nodes_activate_from_base_class_

bool subsystem_controllers::BaseSubsystemController::trigger_managed_nodes_activate_from_base_class_ = true

protected

Definition at line 105 of file base_subsystem_controller.hpp.

Referenced by handle_on_activate().

trigger_managed_nodes_cleanup_from_base_class_

bool subsystem_controllers::BaseSubsystemController::trigger_managed_nodes_cleanup_from_base_class_ = true

protected

Definition at line 107 of file base_subsystem_controller.hpp.

Referenced by handle_on_cleanup().

trigger_managed_nodes_configure_from_base_class_

bool subsystem_controllers::BaseSubsystemController::trigger_managed_nodes_configure_from_base_class_ = true

protected

Collection of flags which, if true, will cause the base class to make lifecycle service calls to managed nodes.

Definition at line 104 of file base_subsystem_controller.hpp.

Referenced by subsystem_controllers::DriversControllerNode::DriversControllerNode(), subsystem_controllers::GuidanceControllerNode::GuidanceControllerNode(), subsystem_controllers::DriversControllerNode::handle_on_activate(), and handle_on_configure().

trigger_managed_nodes_deactivate_from_base_class_

bool subsystem_controllers::BaseSubsystemController::trigger_managed_nodes_deactivate_from_base_class_ = true

protected

Definition at line 106 of file base_subsystem_controller.hpp.

Referenced by handle_on_deactivate().

---

The documentation for this class was generated from the following files:

• subsystem_controllers/include/subsystem_controllers/base_subsystem_controller/base_subsystem_controller.hpp
• subsystem_controllers/src/base_subsystem_controller/base_subsystem_controller.cpp