disable_virtual_group`¶

Caution

This documentation page has been auto-generated.

It may be missing some details.

/module_manager_node/disable_virtual_group Quick Facts

Category: 🛠 Robot management
Message type: pal_module_srvs/srv/DisableVirtualGroup

Enables a virtual group. The modules will not be started when the module manager is started.

See The startup process of the robot and application management.

Quick snippets¶

Call the service from command-line¶

$ ros2 service call /module_manager_node/disable_virtual_group pal_module_srvs/srv/DisableVirtualGroup
# (tip: press Tab to complete the message prototype)

How to use in your code¶

Example of a complete ROS2 node asynchronously calling the service¶

#!/usr/bin/env python

import sys
import rclpy
from rclpy.node import Node

from pal_module_srvs.srv import DisableVirtualGroup

class DisableVirtualGroupClientAsync(Node):

    def __init__(self):
        super().__init__('module_manager_node_disable_virtual_group_client_async')
        self.cli = self.create_client(DisableVirtualGroup, 'module_manager_node_disable_virtual_group')
        while not self.cli.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('service not available, waiting again...')
        self.req = DisableVirtualGroup.Request()

    def send_request(self, a, b):
        # TODO: adapt to the service's parameters
        # self.req.a = a
        # self.req.b = b
        self.future = self.cli.call_async(self.req)
        rclpy.spin_until_future_complete(self, self.future)
        return self.future.result()


if __name__ == '__main__':
    rclpy.init(args=args)

    srv_client = DisableVirtualGroupClientAsync()

    # TODO: adapt to your parameters
    response = srv_client.send_request(sys.argv[1], sys.argv[2])
    srv_client.get_logger().info(
        'Result of module_manager_node_disable_virtual_group: %s' % response)

    rclpy.shutdown()

Example of a complete ROS2 node asynchronously calling the service¶

#include "rclcpp/rclcpp.hpp"
#include "pal_module_srvs/srv/disable_virtual_group.hpp"

#include <chrono>
#include <cstdlib>
#include <memory>

using namespace std::chrono_literals;
using namespace std;
using namespace rclcpp;

int main(int argc, char **argv)
{
    init(argc, argv);

    shared_ptr<Node> node = Node::make_shared("module_manager_node/disable_virtual_group_client");
    Client<pal_module_srvs::srv::DisableVirtualGroup>::SharedPtr client =
        node->create_client<pal_module_srvs::srv::DisableVirtualGroup>("module_manager_node/disable_virtual_group");

    auto request = make_shared<pal_module_srvs::srv::DisableVirtualGroup::Request>();

    // TODO: adapt to the service's parameters
    // request->a = ...;
    // request->b = ...;

    while (!client->wait_for_service(1s)) {
    if (!ok()) {
        RCLCPP_ERROR(get_logger("rclcpp"), "Interrupted while waiting for the service. Exiting.");
        return 0;
    }
    RCLCPP_INFO(get_logger("rclcpp"), "service not available, waiting again...");
    }

    auto result = client->async_send_request(request);
    // Wait for the result.
    if (spin_until_future_complete(node, result) == FutureReturnCode::SUCCESS)
    {
    // TODO: do something with the result
    // result.get()->...;
    } else {
    RCLCPP_ERROR(get_logger("rclcpp"), "Failed to call service module_manager_node/disable_virtual_group");
    }

    shutdown();
    return 0;
}

/module_manager_node/disable_virtual_group¶

Quick snippets¶

How to use in your code¶

`/module_manager_node/disable_virtual_group`¶