ros2_control_utils.hpp File Reference

#include <spdlog/spdlog.h>
#include <algorithm>
#include <string>
#include <vector>
#include "control_common/signal_processing.hpp"
#include "controller_interface/controller_interface_base.hpp"
#include "controller_interface/helpers.hpp"
#include "hardware_interface/loaned_command_interface.hpp"
#include "hardware_interface/loaned_state_interface.hpp"
#include "hardware_interface/types/hardware_interface_type_values.hpp"
#include "moveit_pro_macros/macros.hpp"
#include "moveit_pro_types/types.hpp"
#include "realtime_tools/realtime_buffer.hpp"
#include "semantic_components/force_torque_sensor.hpp"
#include "std_srvs/srv/trigger.hpp"

Include dependency graph for ros2_control_utils.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	moveit_pro_controllers::UtilizedInterfaces

Namespaces
namespace	moveit_pro_controllers

Macros
#define	CHECK_NOT_EMPTY(object, error_message)

Typedefs
template<typename T >
using	moveit_pro_controllers::InterfaceReferences = std::vector< std::vector< std::reference_wrapper< T > > >
using	moveit_pro_controllers::CallbackReturn = rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn

Functions
bool	moveit_pro_controllers::vectorContainsString (const std::vector< std::string > &vec, const std::string &str)
template<class T >
UtilizedInterfaces	moveit_pro_controllers::initializeInterfaceReferences (const std::vector< std::string > &interface_names, InterfaceReferences< T > &interface_references)
template<class T >
bool	moveit_pro_controllers::getOrderedInterfaces (const rclcpp::Logger &logger, const std::vector< std::string > &joint_names, std::vector< T > &unordered_interfaces, const std::vector< std::string > &interface_names, InterfaceReferences< T > &ordered_interfaces)
controller_interface::InterfaceConfiguration	moveit_pro_controllers::createInterfaceConfiguration (const std::vector< std::string > &joint_names, const std::vector< std::string > &interface_names)
void	moveit_pro_controllers::releaseStateAndCommandInterfaces (InterfaceReferences< hardware_interface::LoanedStateInterface > &state_interfaces, InterfaceReferences< hardware_interface::LoanedCommandInterface > &command_interfaces)
template<typename T >
void	moveit_pro_controllers::writeToCommandInterface (const T &joint_interface, const Eigen::VectorNd &values)
template<typename T >
void	moveit_pro_controllers::writeToCommandInterfaces (const T &joint_interfaces, const TimedJointState &joint_state, const UtilizedInterfaces &interfaces)
template<typename T >
Eigen::VectorNd	moveit_pro_controllers::readFromInterface (const T &joint_interface)
template<typename T >
TimedJointState	moveit_pro_controllers::readFromInterfaces (const T &joint_interfaces, const UtilizedInterfaces &interfaces)
bool	moveit_pro_controllers::initializeForceTorqueSensor (const std::string &ft_sensor_name, double ft_cutoff_frequency_ratio, std::unique_ptr< semantic_components::ForceTorqueSensor > &force_torque_sensor, std::unique_ptr< SecondOrderButterworthFilter > &ft_filter)
Eigen::Vector6d	moveit_pro_controllers::getSensedWrench (semantic_components::ForceTorqueSensor &force_torque_sensor)
void	moveit_pro_controllers::toStdVector (const Eigen::VectorNd &vector_eigen, std::vector< double > &vector_std)

Variables
const std::vector< std::string >	moveit_pro_controllers::kAllowedInterfaceTypes

Macro Definition Documentation

CHECK_NOT_EMPTY

#define CHECK_NOT_EMPTY	(		object,
			error_message
	)

Value:

  do                                                                                                                   \
  {                                                                                                                    \
    if (object.empty())                                                                                                \
    {                                                                                                                  \
      spdlog::error("{}", error_message);                                                                              \
      return CallbackReturn::ERROR;                                                                                    \
    }                                                                                                                  \
  } while (0)