Public Member Functions
	ResourceManager (unsigned int update_rate=100, rclcpp::node_interfaces::NodeClockInterface::SharedPtr clock_interface=nullptr)
	Default constructor for the Resource Manager.

	ResourceManager (const std::string &urdf, bool validate_interfaces=true, bool activate_all=false, unsigned int update_rate=100, rclcpp::node_interfaces::NodeClockInterface::SharedPtr clock_interface=nullptr)
	Constructor for the Resource Manager.

	ResourceManager (const ResourceManager &)=delete

void	load_urdf (const std::string &urdf, bool validate_interfaces=true, bool load_and_initialize_components=true)
	Load resources from on a given URDF.

bool	is_urdf_already_loaded () const
	if the resource manager load_urdf(...) function has been called this returns true. We want to permit to load the urdf later on but we currently don't want to permit multiple calls to load_urdf (reloading/loading different urdf).

LoanedStateInterface	claim_state_interface (const std::string &key)
	Claim a state interface given its key.

std::vector< std::string >	state_interface_keys () const
	Returns all registered state interfaces keys.

std::vector< std::string >	available_state_interfaces () const
	Returns all available state interfaces keys.

bool	state_interface_is_available (const std::string &name) const
	Checks whether a state interface is available under the given key.

void	import_controller_reference_interfaces (const std::string &controller_name, std::vector< CommandInterface > &interfaces)
	Add controllers' reference interfaces to resource manager.

std::vector< std::string >	get_controller_reference_interface_names (const std::string &controller_name)
	Get list of reference interface of a controller.

void	make_controller_reference_interfaces_available (const std::string &controller_name)
	Add controller's reference interface to available list.

void	make_controller_reference_interfaces_unavailable (const std::string &controller_name)
	Remove controller's reference interface to available list.

void	remove_controller_reference_interfaces (const std::string &controller_name)
	Remove controllers reference interfaces from resource manager.

void	cache_controller_to_hardware (const std::string &controller_name, const std::vector< std::string > &interfaces)
	Cache mapping between hardware and controllers using it.

std::vector< std::string >	get_cached_controllers_to_hardware (const std::string &hardware_name)
	Return cached controllers for a specific hardware.

bool	command_interface_is_claimed (const std::string &key) const
	Checks whether a command interface is already claimed.

LoanedCommandInterface	claim_command_interface (const std::string &key)
	Claim a command interface given its key.

std::vector< std::string >	command_interface_keys () const
	Returns all registered command interfaces keys.

std::vector< std::string >	available_command_interfaces () const
	Returns all available command interfaces keys.

bool	command_interface_is_available (const std::string &interface) const
	Checks whether a command interface is available under the given name.

size_t	actuator_components_size () const
	Return the number size_t of loaded actuator components.

size_t	sensor_components_size () const
	Return the number of loaded sensor components.

size_t	system_components_size () const
	Return the number of loaded system components.

void	import_component (std::unique_ptr< ActuatorInterface > actuator, const HardwareInfo &hardware_info)
	Import a hardware component which is not listed in the URDF.

void	import_component (std::unique_ptr< SensorInterface > sensor, const HardwareInfo &hardware_info)
	Import a hardware component which is not listed in the URDF.

void	import_component (std::unique_ptr< SystemInterface > system, const HardwareInfo &hardware_info)
	Import a hardware component which is not listed in the URDF.

std::unordered_map< std::string, HardwareComponentInfo >	get_components_status ()
	Return status for all components.

bool	prepare_command_mode_switch (const std::vector< std::string > &start_interfaces, const std::vector< std::string > &stop_interfaces)
	Prepare the hardware components for a new command interface mode.

bool	perform_command_mode_switch (const std::vector< std::string > &start_interfaces, const std::vector< std::string > &stop_interfaces)
	Notify the hardware components that realtime hardware mode switching should occur.

return_type	set_component_state (const std::string &component_name, rclcpp_lifecycle::State &target_state)
	Sets state of hardware component.

HardwareReadWriteStatus	read (const rclcpp::Time &time, const rclcpp::Duration &period)
	Reads all loaded hardware components.

HardwareReadWriteStatus	write (const rclcpp::Time &time, const rclcpp::Duration &period)
	Write all loaded hardware components.

bool	command_interface_exists (const std::string &key) const
	Checks whether a command interface is registered under the given key.

bool	state_interface_exists (const std::string &key) const
	Checks whether a state interface is registered under the given key.

Constructor & Destructor Documentation

◆ ResourceManager()

hardware_interface::ResourceManager::ResourceManager	(	const std::string &	urdf,
		bool	validate_interfaces = `true`,
		bool	activate_all = `false`,
		unsigned int	update_rate = `100`,
		rclcpp::node_interfaces::NodeClockInterface::SharedPtr	clock_interface = `nullptr`
	)

explicit

Constructor for the Resource Manager.

The implementation loads the specified urdf and initializes the hardware components listed within as well as populate their respective state and command interfaces.

If the interfaces ought to be validated, the constructor throws an exception in case the URDF lists interfaces which are not available.

Parameters

[in]	urdf	string containing the URDF.
[in]	validate_interfaces	boolean argument indicating whether the exported interfaces ought to be validated. Defaults to true.
[in]	activate_all	boolean argument indicating if all resources should be immediately activated. Currently used only in tests.

Member Function Documentation

◆ actuator_components_size()

size_t hardware_interface::ResourceManager::actuator_components_size ( ) const

Return the number size_t of loaded actuator components.

Returns: number of actuator components.

◆ available_command_interfaces()

std::vector< std::string > hardware_interface::ResourceManager::available_command_interfaces ( ) const

Returns all available command interfaces keys.

The keys are collected from the available list.

Returns: vector of strings, containing all available command interface names.

◆ available_state_interfaces()

std::vector< std::string > hardware_interface::ResourceManager::available_state_interfaces ( ) const

Returns all available state interfaces keys.

The keys are collected from the available list.

Returns: Vector of strings, containing all available state interface names.

◆ cache_controller_to_hardware()

void hardware_interface::ResourceManager::cache_controller_to_hardware	(	const std::string &	controller_name,
		const std::vector< std::string > &	interfaces
	)

Cache mapping between hardware and controllers using it.

Find mapping between controller and hardware based on interfaces controller with controller_name is using and cache those for later usage.

Parameters

[in]	controller_name	name of the controller which interfaces are provided.
[in]	interfaces	list of interfaces controller with `controller_name` is using.

◆ claim_command_interface()

LoanedCommandInterface hardware_interface::ResourceManager::claim_command_interface ( const std::string & key )

Claim a command interface given its key.

The resource is claimed as long as being in scope. Once the resource is going out of scope, the destructor returns and thus frees the resource to claimed by others.

Parameters

[in] key String identifier which command interface to claim

Returns: command interface

◆ claim_state_interface()

LoanedStateInterface hardware_interface::ResourceManager::claim_state_interface ( const std::string & key )

Claim a state interface given its key.

The resource is claimed as long as being in scope. Once the resource is going out of scope, the destructor returns.

Parameters

[in] key String identifier which state interface to claim

Returns: state interface

◆ command_interface_exists()

bool hardware_interface::ResourceManager::command_interface_exists ( const std::string & key ) const

Checks whether a command interface is registered under the given key.

Parameters

[in] key string identifying the interface to check.

Returns: true if interface exist, false otherwise.

◆ command_interface_is_available()

bool hardware_interface::ResourceManager::command_interface_is_available ( const std::string & interface ) const

Checks whether a command interface is available under the given name.

Parameters

[in] name string identifying the interface to check.

Returns: true if interface is available, false otherwise.

◆ command_interface_is_claimed()

bool hardware_interface::ResourceManager::command_interface_is_claimed ( const std::string & key ) const

Checks whether a command interface is already claimed.

Any command interface can only be claimed by a single instance.

Note: the equivalent function does not exist for state interfaces. These are solely read-only and can thus be used by multiple instances.

Parameters

[in] key string identifying the interface to check.

Returns: true if interface is already claimed, false if available.

◆ command_interface_keys()

std::vector< std::string > hardware_interface::ResourceManager::command_interface_keys ( ) const

Returns all registered command interfaces keys.

The keys are collected from each loaded hardware component.

Returns: vector of strings, containing all registered keys.

◆ get_cached_controllers_to_hardware()

std::vector< std::string > hardware_interface::ResourceManager::get_cached_controllers_to_hardware ( const std::string & hardware_name )

Return cached controllers for a specific hardware.

Return list of cached controller names that use the hardware with name hardware_name.

Parameters

[in] hardware_name the name of the hardware for which cached controllers should be returned.

Returns: list of cached controller names that depend on hardware with name hardware_name.

◆ get_components_status()

std::unordered_map< std::string, HardwareComponentInfo > hardware_interface::ResourceManager::get_components_status ( )

Return status for all components.

Returns: map of hardware names and their status.

◆ get_controller_reference_interface_names()

std::vector< std::string > hardware_interface::ResourceManager::get_controller_reference_interface_names ( const std::string & controller_name )

Get list of reference interface of a controller.

Returns lists of stored reference interfaces names for a controller.

Parameters

[in] controller_name for which list of reference interface names is returned.

Returns: list of reference interface names.

◆ import_component() [1/3]

void hardware_interface::ResourceManager::import_component	(	std::unique_ptr< ActuatorInterface >	actuator,
		const HardwareInfo &	hardware_info
	)

Import a hardware component which is not listed in the URDF.

Components which are initialized outside a URDF can be added post initialization. Nevertheless, there should still be HardwareInfo available for this component, either parsed from a URDF string (easiest) or filled manually.

Note: this might invalidate existing state and command interfaces and should thus not be called when a controller is running.; given that no hardware_info is available, the component has to be configured externally and prior to the call to import.

Parameters

[in]	actuator	pointer to the actuator interface.
[in]	hardware_info	hardware info

◆ import_component() [2/3]

void hardware_interface::ResourceManager::import_component	(	std::unique_ptr< SensorInterface >	sensor,
		const HardwareInfo &	hardware_info
	)

Import a hardware component which is not listed in the URDF.

Components which are initialized outside a URDF can be added post initialization. Nevertheless, there should still be HardwareInfo available for this component, either parsed from a URDF string (easiest) or filled manually.

Note: this might invalidate existing state and command interfaces and should thus not be called when a controller is running.; given that no hardware_info is available, the component has to be configured externally and prior to the call to import.

Parameters

[in]	sensor	pointer to the sensor interface.
[in]	hardware_info	hardware info

◆ import_component() [3/3]

void hardware_interface::ResourceManager::import_component	(	std::unique_ptr< SystemInterface >	system,
		const HardwareInfo &	hardware_info
	)

Import a hardware component which is not listed in the URDF.

Components which are initialized outside a URDF can be added post initialization. Nevertheless, there should still be HardwareInfo available for this component, either parsed from a URDF string (easiest) or filled manually.

Note: this might invalidate existing state and command interfaces and should thus not be called when a controller is running.; given that no hardware_info is available, the component has to be configured externally and prior to the call to import.

Parameters

[in]	system	pointer to the system interface.
[in]	hardware_info	hardware info

◆ import_controller_reference_interfaces()

void hardware_interface::ResourceManager::import_controller_reference_interfaces	(	const std::string &	controller_name,
		std::vector< CommandInterface > &	interfaces
	)

Add controllers' reference interfaces to resource manager.

Interface for transferring management of reference interfaces to resource manager. When chaining controllers, reference interfaces are used as command interface of preceding controllers. Therefore, they should be managed in the same way as command interface of hardware.

Parameters

[in]	controller_name	name of the controller which reference interfaces are imported.
[in]	interfaces	list of controller's reference interfaces as CommandInterfaces.

◆ is_urdf_already_loaded()

bool hardware_interface::ResourceManager::is_urdf_already_loaded ( ) const

if the resource manager load_urdf(...) function has been called this returns true. We want to permit to load the urdf later on but we currently don't want to permit multiple calls to load_urdf (reloading/loading different urdf).

Returns: true if resource manager's load_urdf() has been already called.; false if resource manager's load_urdf() has not been yet called.

◆ load_urdf()

void hardware_interface::ResourceManager::load_urdf	(	const std::string &	urdf,
		bool	validate_interfaces = `true`,
		bool	load_and_initialize_components = `true`
	)

Load resources from on a given URDF.

The resource manager can be post initialized with a given URDF. This is mainly used in conjunction with the default constructor in which the URDF might not be present at first initialization.

Parameters

[in]	urdf	string containing the URDF.
[in]	validate_interfaces	boolean argument indicating whether the exported interfaces ought to be validated. Defaults to true.
[in]	load_and_initialize_components	boolean argument indicating whether to load and initialize the components present in the parsed URDF. Defaults to true.

◆ make_controller_reference_interfaces_available()

void hardware_interface::ResourceManager::make_controller_reference_interfaces_available ( const std::string & controller_name )

Add controller's reference interface to available list.

Adds interfaces of a controller with given name to the available list. This method should be called when a controller gets activated with chained mode turned on. That means, the controller's reference interfaces can be used by another controller in chained architectures.

Parameters

[in] controller_name name of the controller which interfaces should become available.

◆ make_controller_reference_interfaces_unavailable()

void hardware_interface::ResourceManager::make_controller_reference_interfaces_unavailable ( const std::string & controller_name )

Remove controller's reference interface to available list.

Removes interfaces of a controller with given name from the available list. This method should be called when a controller gets deactivated and its reference interfaces cannot be used by another controller anymore.

Parameters

[in] controller_name name of the controller which interfaces should become unavailable.

◆ perform_command_mode_switch()

bool hardware_interface::ResourceManager::perform_command_mode_switch	(	const std::vector< std::string > &	start_interfaces,
		const std::vector< std::string > &	stop_interfaces
	)

Notify the hardware components that realtime hardware mode switching should occur.

Hardware components are asked to perform the command interface mode switching.

Note: this is intended for mode-switching when a hardware interface needs to change control mode depending on which command interface is claimed.; this is for realtime switching of the command interface.; it is assumed that prepare_command_mode_switch is called just before this method with the same input arguments.

Parameters

[in]	start_interfaces	vector of string identifiers for the command interfaces starting.
[in]	stop_interfaces	vector of string identifiers for the command interfaces stopping.

Returns: true if switch is performed, false if a component rejects switching.

◆ prepare_command_mode_switch()

bool hardware_interface::ResourceManager::prepare_command_mode_switch	(	const std::vector< std::string > &	start_interfaces,
		const std::vector< std::string > &	stop_interfaces
	)

Prepare the hardware components for a new command interface mode.

Hardware components are asked to prepare a new command interface claim.

Note: this is intended for mode-switching when a hardware interface needs to change control mode depending on which command interface is claimed.; this is for non-realtime preparing for and accepting new command resource combinations.; accept_command_resource_claim is called on all actuators and system components and hardware interfaces should return hardware_interface::return_type::OK by default

Parameters

[in]	start_interfaces	vector of string identifiers for the command interfaces starting.
[in]	stop_interfaces	vector of string identifiers for the command interfaces stopping.

Returns: true if switch can be prepared; false if a component rejects switch request, and if at least one of the input interfaces are not existing or not available (i.e., component is not in ACTIVE or INACTIVE state).

◆ read()

HardwareReadWriteStatus hardware_interface::ResourceManager::read	(	const rclcpp::Time &	time,
		const rclcpp::Duration &	period
	)

Reads all loaded hardware components.

Reads from all active hardware components.

Part of the real-time critical update loop. It is realtime-safe if used hardware interfaces are implemented adequately.

◆ remove_controller_reference_interfaces()

void hardware_interface::ResourceManager::remove_controller_reference_interfaces ( const std::string & controller_name )

Remove controllers reference interfaces from resource manager.

Remove reference interfaces from resource manager, i.e., resource storage. The interfaces will be deleted from all internal maps and lists.

Parameters

[in] controller_name list of interface names that will be deleted from resource manager.

◆ sensor_components_size()

size_t hardware_interface::ResourceManager::sensor_components_size ( ) const

Return the number of loaded sensor components.

Returns: number of sensor components.

◆ set_component_state()

return_type hardware_interface::ResourceManager::set_component_state	(	const std::string &	component_name,
		rclcpp_lifecycle::State &	target_state
	)

Sets state of hardware component.

Set set of hardware component if possible. Takes care of all transitions needed to reach the target state. It implements the state machine from: https://design.ros2.org/articles/node_lifecycle.html

The method is not part of the real-time critical update loop.

Parameters

[in]	component_name	component name to change state.
[in]	target_state	target state to set for a hardware component.

Returns: hardware_interface::retun_type::OK if component successfully switched its state and hardware_interface::return_type::ERROR any of state transitions has failed.

◆ state_interface_exists()

bool hardware_interface::ResourceManager::state_interface_exists ( const std::string & key ) const

Checks whether a state interface is registered under the given key.

Returns: true if interface exist, false otherwise.

◆ state_interface_is_available()

bool hardware_interface::ResourceManager::state_interface_is_available ( const std::string & name ) const

Checks whether a state interface is available under the given key.

Returns: true if interface is available, false otherwise.

◆ state_interface_keys()

std::vector< std::string > hardware_interface::ResourceManager::state_interface_keys ( ) const

Returns all registered state interfaces keys.

The keys are collected from each loaded hardware component.

Returns: Vector of strings, containing all registered keys.

◆ system_components_size()

size_t hardware_interface::ResourceManager::system_components_size ( ) const

Return the number of loaded system components.

Returns: size_t number of system components.

◆ write()

HardwareReadWriteStatus hardware_interface::ResourceManager::write	(	const rclcpp::Time &	time,
		const rclcpp::Duration &	period
	)

Write all loaded hardware components.

Writes to all active hardware components.

Part of the real-time critical update loop. It is realtime-safe if used hardware interfaces are implemented adequately.

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

ros2_control/hardware_interface/include/hardware_interface/resource_manager.hpp
ros2_control/hardware_interface/src/resource_manager.cpp

Public Member Functions

Constructor & Destructor Documentation

◆ ResourceManager()

Member Function Documentation

◆ actuator_components_size()

◆ available_command_interfaces()

◆ available_state_interfaces()

◆ cache_controller_to_hardware()

◆ claim_command_interface()

◆ claim_state_interface()

◆ command_interface_exists()

◆ command_interface_is_available()

◆ command_interface_is_claimed()

◆ command_interface_keys()

◆ get_cached_controllers_to_hardware()

◆ get_components_status()

◆ get_controller_reference_interface_names()

◆ import_component() [1/3]

◆ import_component() [2/3]

◆ import_component() [3/3]

◆ import_controller_reference_interfaces()

◆ is_urdf_already_loaded()

◆ load_urdf()

◆ make_controller_reference_interfaces_available()

◆ make_controller_reference_interfaces_unavailable()

◆ perform_command_mode_switch()

◆ prepare_command_mode_switch()

◆ read()

◆ remove_controller_reference_interfaces()

◆ sensor_components_size()

◆ set_component_state()

◆ state_interface_exists()

◆ state_interface_is_available()

◆ state_interface_keys()

◆ system_components_size()

◆ write()