qlin/sas_robot_driver_franka
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migration to ros2 done

Browse Source
This commit is contained in:
qlin960618
2024-07-27 13:07:37 +09:00
parent f5552be8d6
commit 7dfd4d40b8
94 changed files with 13216 additions and 2224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

338
CMakeLists.txt
View File

@@ -7,14 +7,6 @@ project(sas_robot_driver_franka)
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
add_compile_options(-Wall -Wextra -Wpedantic)
endif()
if(POLICY CMP0148)
cmake_policy(SET CMP0148 NEW)
endif()
#Add custom (non compiling) targets so launch scripts and python files show up in QT Creator's project view.
file(GLOB_RECURSE EXTRA_FILES */*)
#add_custom_target(${PROJECT_NAME}_OTHER_FILES ALL WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} SOURCES ${EXTRA_FILES})
add_custom_target(cfg ALL WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} SOURCES ${EXTRA_FILES})
find_package(pybind11 REQUIRED)
@@ -29,92 +21,10 @@ find_package(Eigen3 REQUIRED)
find_package(tf2_ros REQUIRED)
find_package(tf2 REQUIRED)
find_package(sas_robot_driver REQUIRED)
find_package(rosidl_default_generators REQUIRED)
rosidl_generate_interfaces(${PROJECT_NAME}
"msg/GripperState.msg"
"srv/Move.srv"
"srv/Grasp.srv"
DEPENDENCIES std_msgs
)
ament_target_dependencies(${PROJECT_NAME}
rclcpp geometry_msgs std_msgs sas_common sas_core sas_conversions
tf2_ros tf2 sas_robot_driver)
target_include_directories(${PROJECT_NAME}
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>)
ament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)
ament_export_dependencies(Eigen3 rclcpp geometry_msgs std_msgs sas_common sas_core sas_conversions
tf2_ros tf2 sas_robot_driver)
add_library(qros_robot_dynamics_provider src/robot_dynamics/qros_robot_dynamics_provider.cpp)
target_link_libraries(qros_robot_dynamics_provider
-ldqrobotics
Eigen3::Eigen
)
#####################################################################################
ament_python_install_package(${PROJECT_NAME})
# python binding
include_directories(
include/robot_dynamic
)
pybind_add_module(_qros_robot_dynamic SHARED
src/robot_dynamics/qros_robot_dynamic_py.cpp src/robot_dynamics/qros_robot_dynamics_interface.cpp src/robot_dynamics/qros_robot_dynamics_provider.cpp
)
target_compile_definitions(_qros_robot_dynamic PRIVATE BUILD_PYBIND)
# https://github.com/pybind/pybind11/issues/387
target_link_libraries(_qros_robot_dynamic PRIVATE ${catkin_LIBRARIES} -ldqrobotics)
#/////
catkin_package(
INCLUDE_DIRS include
CATKIN_DEPENDS roscpp rospy sas_common sas_clock sas_robot_driver tf2_ros tf2 pybind11_catkin message_runtime std_msgs
)
find_package(Franka REQUIRED)
find_package(Eigen3 REQUIRED)
find_package(yaml-cpp REQUIRED)
include_directories(${EIGEN3_INCLUDE_DIR})
find_package(sas_robot_driver_franka_interfaces REQUIRED) # Add this line
# To correctly find and link with QT
## To correctly find and link with QT
set(CMAKE_PREFIX_PATH $ENV{QT_PATH})
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
@@ -124,15 +34,76 @@ if (CMAKE_VERSION VERSION_LESS "3.7.0")
endif ()
find_package(Qt5 COMPONENTS Widgets REQUIRED)
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets)
##### CPP LIBRARY initial #####
include_directories(
include
constraints_manager/include
)
install(
DIRECTORY include/
DESTINATION include
)
ament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)
ament_export_dependencies(Eigen3 rclcpp geometry_msgs std_msgs
sas_common sas_core sas_conversions sas_robot_driver_franka_interfaces
tf2_ros tf2 sas_robot_driver)
##### CPP LIBRARY initial end #####
##### CPP LIBRARY ROBOT_DYNAMICS #####
add_library(${PROJECT_NAME}_robot_dynamics SHARED
src/robot_dynamics/qros_robot_dynamics_client.cpp
src/robot_dynamics/qros_robot_dynamics_server.cpp
)
ament_target_dependencies(${PROJECT_NAME}_robot_dynamics
rclcpp geometry_msgs std_msgs
sas_common sas_core sas_conversions
tf2_ros tf2 sas_robot_driver)
target_include_directories(${PROJECT_NAME}_robot_dynamics
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>)
target_link_libraries(${PROJECT_NAME}_robot_dynamics
-ldqrobotics
Eigen3::Eigen
)
install(
TARGETS ${PROJECT_NAME}_robot_dynamics # ${PROJECT_NAME}
EXPORT export_${PROJECT_NAME} #export_${PROJECT_NAME}
LIBRARY DESTINATION lib
#ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
##END## CPP LIBRARY ROBOT_DYNAMICS #####
##### CPP LIBRARY Motion Generation #####
add_library(MotionGenerator src/generator/motion_generator.cpp)
target_link_libraries(MotionGenerator Franka::Franka)
target_link_libraries(MotionGenerator Franka::Franka Eigen3::Eigen)
add_library(ConstraintsManager constraints_manager/src/constraints_manager.cpp)
target_link_libraries(ConstraintsManager Eigen3::Eigen)
install(
DIRECTORY constraints_manager/include/
DESTINATION include/constraints_manager
)
target_include_directories(ConstraintsManager
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/constraints_manager/include>
$<INSTALL_INTERFACE:include/constraints_manager>)
add_library(QuadraticProgramMotionGenerator src/generator/quadratic_program_motion_generator.cpp)
target_link_libraries(QuadraticProgramMotionGenerator
@@ -140,12 +111,18 @@ target_link_libraries(QuadraticProgramMotionGenerator
dqrobotics
ConstraintsManager)
add_library(CustomMotionGeneration src/generator/custom_motion_generation.cpp)
target_link_libraries(CustomMotionGeneration
qpOASES
dqrobotics
ConstraintsManager)
##### CPP LIBRARY Motion Generation end #####
##### CPP LIBRARY franka low level interface #####
add_library(robot_interface_franka src/joint/robot_interface_franka.cpp)
target_link_libraries(robot_interface_franka Franka::Franka
dqrobotics
@@ -159,133 +136,114 @@ target_link_libraries(robot_interface_hand Franka::Franka
dqrobotics)
############
## Build ###
############
## Specify additional locations of header files
## Your package locations should be listed before other locations
include_directories(
include
include/generator
src/
src/robot_dynamics
src/hand
src/joint
${catkin_INCLUDE_DIRS}
constraints_manager/include
)
add_library(qros_robot_dynamics_provider src/robot_dynamics/qros_robot_dynamics_provider.cpp)
target_link_libraries(qros_robot_dynamics_provider
${catkin_LIBRARIES}
dqrobotics)
add_library(qros_robot_dynamics_interface src/robot_dynamics/qros_robot_dynamics_interface.cpp)
target_link_libraries(qros_robot_dynamics_interface
${catkin_LIBRARIES}
dqrobotics)
##### CPP LIBRARY franka low level interface end #####
##### SAS Franka Robot Driver #####
add_library(sas_robot_driver_franka src/joint/sas_robot_driver_franka.cpp)
target_link_libraries(sas_robot_driver_franka
qros_robot_dynamics_provider
${PROJECT_NAME}_robot_dynamics
dqrobotics
dqrobotics-interface-json11
robot_interface_franka)
##### SAS Franka Robot Driver end #####
##### qros hand effector driver #####
add_library(qros_effector_driver_franka_hand src/hand/qros_effector_driver_franka_hand.cpp)
ament_target_dependencies(qros_effector_driver_franka_hand
rclcpp sas_common sas_core
sas_robot_driver_franka_interfaces
)
#ament_target_dependencies(${PROJECT_NAME}_robot_dynamics
# rclcpp geometry_msgs std_msgs
# sas_common sas_core sas_conversions
# tf2_ros tf2 sas_robot_driver)
target_link_libraries(qros_effector_driver_franka_hand
dqrobotics
# robot_interface_hand
Franka::Franka)
#target_include_directories(qros_effector_driver_franka_hand
# PUBLIC
# $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/interface>
# $<INSTALL_INTERFACE:include/interface>)
add_library(sas_robot_driver_coppelia src/coppelia/sas_robot_driver_coppelia.cpp)
target_link_libraries(sas_robot_driver_coppelia
dqrobotics
dqrobotics-interface-vrep)
add_dependencies(sas_robot_driver_franka ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
add_dependencies(sas_robot_driver_coppelia ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
add_dependencies(qros_effector_driver_franka_hand ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
##### qros hand effector driver end #####
add_executable(sas_robot_driver_coppelia_node src/sas_robot_driver_coppelia_node.cpp)
target_link_libraries(sas_robot_driver_coppelia_node
sas_robot_driver_coppelia
${catkin_LIBRARIES})
##### SAS Franka Robot Driver Node #####
add_executable(sas_robot_driver_franka_node src/sas_robot_driver_franka_node.cpp)
target_link_libraries(sas_robot_driver_franka_node
sas_robot_driver_franka
${catkin_LIBRARIES})
ament_target_dependencies(sas_robot_driver_franka_node
rclcpp sas_common sas_core
sas_robot_driver)
target_link_libraries(sas_robot_driver_franka_node sas_robot_driver_franka)
install(TARGETS
sas_robot_driver_franka_node
DESTINATION lib/${PROJECT_NAME})
##### SAS Franka Robot Hand Driver Node #####
add_executable(sas_robot_driver_franka_hand_node src/sas_robot_driver_franka_hand_node.cpp)
ament_target_dependencies(sas_robot_driver_franka_node
rclcpp sas_common sas_core)
target_link_libraries(sas_robot_driver_franka_hand_node
qros_effector_driver_franka_hand
${catkin_LIBRARIES})
qros_effector_driver_franka_hand)
install(TARGETS
sas_robot_driver_franka_hand_node
DESTINATION lib/${PROJECT_NAME})
add_executable(JuankaEmika
qt/configuration_window/main.cpp
qt/configuration_window/mainwindow.cpp
qt/configuration_window/mainwindow.ui
##### PYBIND11 LIBRARY ROBOT_DYNAMICS #####
ament_python_install_package(${PROJECT_NAME})
pybind11_add_module(_robot_dynamics SHARED
src/robot_dynamics/qros_robot_dynamics_py.cpp
src/robot_dynamics/qros_robot_dynamics_client.cpp
src/robot_dynamics/qros_robot_dynamics_server.cpp
)
target_link_libraries(JuankaEmika PRIVATE Qt${QT_VERSION_MAJOR}::Widgets
dqrobotics
${catkin_LIBRARIES}
robot_interface_franka
)
target_include_directories(_robot_dynamics
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/robot_dynamics>
$<INSTALL_INTERFACE:include/robot_dynamics>)
#####################################################################################
# python binding
include_directories(
include/robot_dynamic
)
pybind_add_module(_qros_robot_dynamic SHARED
src/robot_dynamics/qros_robot_dynamic_py.cpp src/robot_dynamics/qros_robot_dynamics_interface.cpp src/robot_dynamics/qros_robot_dynamics_provider.cpp
)
target_compile_definitions(_qros_robot_dynamic PRIVATE BUILD_PYBIND)
target_compile_definitions(_robot_dynamics PRIVATE IS_SAS_PYTHON_BUILD)
# https://github.com/pybind/pybind11/issues/387
target_link_libraries(_qros_robot_dynamic PRIVATE ${catkin_LIBRARIES} -ldqrobotics)
target_link_libraries(_robot_dynamics PRIVATE ${PROJECT_NAME}_robot_dynamics -ldqrobotics)
if (QT_VERSION_MAJOR EQUAL 6)
qt_finalize_executable(JuankaEmika)
endif ()
install(TARGETS ${PROJECT_NAME}
DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
install(TARGETS _robot_dynamics
DESTINATION "${PYTHON_INSTALL_DIR}/${PROJECT_NAME}"
)
##END## PYBIND11 LIBRARY ROBOT_DYNAMICS #####
install(TARGETS sas_robot_driver_franka_node
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
install(TARGETS sas_robot_driver_coppelia_node
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
install(TARGETS sas_robot_driver_franka_hand_node
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
## Mark cpp header files for installation
install(DIRECTORY include/${PROJECT_NAME}/
DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
FILES_MATCHING PATTERN "*.h"
# PATTERN ".svn" EXCLUDE
install(
DIRECTORY include/
DESTINATION include
)
install(TARGETS _qros_robot_dynamic
LIBRARY DESTINATION ${PYTHON_INSTALL_DIR}
##### LAUNCH FILES #####
install(DIRECTORY
launch
DESTINATION share/${PROJECT_NAME}/
)
##END## LAUNCH FILES #####
ament_package()

123
include/Grasp.h
View File

@@ -1,123 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/Grasp.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASP_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASP_H
#include <ros/service_traits.h>
#include <sas_robot_driver_franka/GraspRequest.h>
#include <sas_robot_driver_franka/GraspResponse.h>
namespace sas_robot_driver_franka
{
struct Grasp
{
typedef GraspRequest Request;
typedef GraspResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct Grasp
} // namespace sas_robot_driver_franka
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::sas_robot_driver_franka::Grasp > {
static const char* value()
{
return "6752ec080e002a60682f31654d420583";
}
static const char* value(const ::sas_robot_driver_franka::Grasp&) { return value(); }
};
template<>
struct DataType< ::sas_robot_driver_franka::Grasp > {
static const char* value()
{
return "sas_robot_driver_franka/Grasp";
}
static const char* value(const ::sas_robot_driver_franka::Grasp&) { return value(); }
};
// service_traits::MD5Sum< ::sas_robot_driver_franka::GraspRequest> should match
// service_traits::MD5Sum< ::sas_robot_driver_franka::Grasp >
template<>
struct MD5Sum< ::sas_robot_driver_franka::GraspRequest>
{
static const char* value()
{
return MD5Sum< ::sas_robot_driver_franka::Grasp >::value();
}
static const char* value(const ::sas_robot_driver_franka::GraspRequest&)
{
return value();
}
};
// service_traits::DataType< ::sas_robot_driver_franka::GraspRequest> should match
// service_traits::DataType< ::sas_robot_driver_franka::Grasp >
template<>
struct DataType< ::sas_robot_driver_franka::GraspRequest>
{
static const char* value()
{
return DataType< ::sas_robot_driver_franka::Grasp >::value();
}
static const char* value(const ::sas_robot_driver_franka::GraspRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::sas_robot_driver_franka::GraspResponse> should match
// service_traits::MD5Sum< ::sas_robot_driver_franka::Grasp >
template<>
struct MD5Sum< ::sas_robot_driver_franka::GraspResponse>
{
static const char* value()
{
return MD5Sum< ::sas_robot_driver_franka::Grasp >::value();
}
static const char* value(const ::sas_robot_driver_franka::GraspResponse&)
{
return value();
}
};
// service_traits::DataType< ::sas_robot_driver_franka::GraspResponse> should match
// service_traits::DataType< ::sas_robot_driver_franka::Grasp >
template<>
struct DataType< ::sas_robot_driver_franka::GraspResponse>
{
static const char* value()
{
return DataType< ::sas_robot_driver_franka::Grasp >::value();
}
static const char* value(const ::sas_robot_driver_franka::GraspResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASP_H

235
include/GraspRequest.h
View File

@@ -1,235 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/GraspRequest.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPREQUEST_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPREQUEST_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace sas_robot_driver_franka
{
template <class ContainerAllocator>
struct GraspRequest_
{
typedef GraspRequest_<ContainerAllocator> Type;
GraspRequest_()
: width(0.0)
, speed(0.0)
, force(0.0)
, epsilon_inner(0.0)
, epsilon_outer(0.0) {
}
GraspRequest_(const ContainerAllocator& _alloc)
: width(0.0)
, speed(0.0)
, force(0.0)
, epsilon_inner(0.0)
, epsilon_outer(0.0) {
(void)_alloc;
}
typedef float _width_type;
_width_type width;
typedef float _speed_type;
_speed_type speed;
typedef float _force_type;
_force_type force;
typedef float _epsilon_inner_type;
_epsilon_inner_type epsilon_inner;
typedef float _epsilon_outer_type;
_epsilon_outer_type epsilon_outer;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> const> ConstPtr;
}; // struct GraspRequest_
typedef ::sas_robot_driver_franka::GraspRequest_<std::allocator<void> > GraspRequest;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspRequest > GraspRequestPtr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspRequest const> GraspRequestConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator2> & rhs)
{
return lhs.width == rhs.width &&
lhs.speed == rhs.speed &&
lhs.force == rhs.force &&
lhs.epsilon_inner == rhs.epsilon_inner &&
lhs.epsilon_outer == rhs.epsilon_outer;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sas_robot_driver_franka
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
{
static const char* value()
{
return "337f46ba15e58c568d47e27881cf893c";
}
static const char* value(const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x337f46ba15e58c56ULL;
static const uint64_t static_value2 = 0x8d47e27881cf893cULL;
};
template<class ContainerAllocator>
struct DataType< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
{
static const char* value()
{
return "sas_robot_driver_franka/GraspRequest";
}
static const char* value(const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
{
static const char* value()
{
return "float32 width\n"
"float32 speed\n"
"float32 force\n"
"float32 epsilon_inner\n"
"float32 epsilon_outer\n"
;
}
static const char* value(const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.width);
stream.next(m.speed);
stream.next(m.force);
stream.next(m.epsilon_inner);
stream.next(m.epsilon_outer);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct GraspRequest_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sas_robot_driver_franka::GraspRequest_<ContainerAllocator>& v)
{
s << indent << "width: ";
Printer<float>::stream(s, indent + " ", v.width);
s << indent << "speed: ";
Printer<float>::stream(s, indent + " ", v.speed);
s << indent << "force: ";
Printer<float>::stream(s, indent + " ", v.force);
s << indent << "epsilon_inner: ";
Printer<float>::stream(s, indent + " ", v.epsilon_inner);
s << indent << "epsilon_outer: ";
Printer<float>::stream(s, indent + " ", v.epsilon_outer);
}
};
} // namespace message_operations
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPREQUEST_H

195
include/GraspResponse.h
View File

@@ -1,195 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/GraspResponse.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPRESPONSE_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPRESPONSE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace sas_robot_driver_franka
{
template <class ContainerAllocator>
struct GraspResponse_
{
typedef GraspResponse_<ContainerAllocator> Type;
GraspResponse_()
: success(false) {
}
GraspResponse_(const ContainerAllocator& _alloc)
: success(false) {
(void)_alloc;
}
typedef uint8_t _success_type;
_success_type success;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> const> ConstPtr;
}; // struct GraspResponse_
typedef ::sas_robot_driver_franka::GraspResponse_<std::allocator<void> > GraspResponse;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspResponse > GraspResponsePtr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GraspResponse const> GraspResponseConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator2> & rhs)
{
return lhs.success == rhs.success;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sas_robot_driver_franka
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
{
static const char* value()
{
return "358e233cde0c8a8bcfea4ce193f8fc15";
}
static const char* value(const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x358e233cde0c8a8bULL;
static const uint64_t static_value2 = 0xcfea4ce193f8fc15ULL;
};
template<class ContainerAllocator>
struct DataType< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
{
static const char* value()
{
return "sas_robot_driver_franka/GraspResponse";
}
static const char* value(const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
{
static const char* value()
{
return "bool success\n"
;
}
static const char* value(const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.success);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct GraspResponse_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sas_robot_driver_franka::GraspResponse_<ContainerAllocator>& v)
{
s << indent << "success: ";
Printer<uint8_t>::stream(s, indent + " ", v.success);
}
};
} // namespace message_operations
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRASPRESPONSE_H

235
include/GripperState.h
View File

@@ -1,235 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/GripperState.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRIPPERSTATE_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRIPPERSTATE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace sas_robot_driver_franka
{
template <class ContainerAllocator>
struct GripperState_
{
typedef GripperState_<ContainerAllocator> Type;
GripperState_()
: width(0.0)
, max_width(0.0)
, is_grasped(false)
, temperature(0)
, duration_ms(0) {
}
GripperState_(const ContainerAllocator& _alloc)
: width(0.0)
, max_width(0.0)
, is_grasped(false)
, temperature(0)
, duration_ms(0) {
(void)_alloc;
}
typedef float _width_type;
_width_type width;
typedef float _max_width_type;
_max_width_type max_width;
typedef uint8_t _is_grasped_type;
_is_grasped_type is_grasped;
typedef uint16_t _temperature_type;
_temperature_type temperature;
typedef uint64_t _duration_ms_type;
_duration_ms_type duration_ms;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> const> ConstPtr;
}; // struct GripperState_
typedef ::sas_robot_driver_franka::GripperState_<std::allocator<void> > GripperState;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GripperState > GripperStatePtr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::GripperState const> GripperStateConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sas_robot_driver_franka::GripperState_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sas_robot_driver_franka::GripperState_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GripperState_<ContainerAllocator2> & rhs)
{
return lhs.width == rhs.width &&
lhs.max_width == rhs.max_width &&
lhs.is_grasped == rhs.is_grasped &&
lhs.temperature == rhs.temperature &&
lhs.duration_ms == rhs.duration_ms;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sas_robot_driver_franka::GripperState_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::GripperState_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sas_robot_driver_franka
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
{
static const char* value()
{
return "53f8669159aaded70b1783087f07679d";
}
static const char* value(const ::sas_robot_driver_franka::GripperState_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x53f8669159aaded7ULL;
static const uint64_t static_value2 = 0x0b1783087f07679dULL;
};
template<class ContainerAllocator>
struct DataType< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
{
static const char* value()
{
return "sas_robot_driver_franka/GripperState";
}
static const char* value(const ::sas_robot_driver_franka::GripperState_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
{
static const char* value()
{
return "float32 width\n"
"float32 max_width\n"
"bool is_grasped\n"
"uint16 temperature\n"
"uint64 duration_ms\n"
;
}
static const char* value(const ::sas_robot_driver_franka::GripperState_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.width);
stream.next(m.max_width);
stream.next(m.is_grasped);
stream.next(m.temperature);
stream.next(m.duration_ms);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct GripperState_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sas_robot_driver_franka::GripperState_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sas_robot_driver_franka::GripperState_<ContainerAllocator>& v)
{
s << indent << "width: ";
Printer<float>::stream(s, indent + " ", v.width);
s << indent << "max_width: ";
Printer<float>::stream(s, indent + " ", v.max_width);
s << indent << "is_grasped: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_grasped);
s << indent << "temperature: ";
Printer<uint16_t>::stream(s, indent + " ", v.temperature);
s << indent << "duration_ms: ";
Printer<uint64_t>::stream(s, indent + " ", v.duration_ms);
}
};
} // namespace message_operations
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_GRIPPERSTATE_H

123
include/Move.h
View File

@@ -1,123 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/Move.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVE_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVE_H
#include <ros/service_traits.h>
#include <sas_robot_driver_franka/MoveRequest.h>
#include <sas_robot_driver_franka/MoveResponse.h>
namespace sas_robot_driver_franka
{
struct Move
{
typedef MoveRequest Request;
typedef MoveResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct Move
} // namespace sas_robot_driver_franka
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::sas_robot_driver_franka::Move > {
static const char* value()
{
return "73e650ba1526b28d9e3f1be7ee33a441";
}
static const char* value(const ::sas_robot_driver_franka::Move&) { return value(); }
};
template<>
struct DataType< ::sas_robot_driver_franka::Move > {
static const char* value()
{
return "sas_robot_driver_franka/Move";
}
static const char* value(const ::sas_robot_driver_franka::Move&) { return value(); }
};
// service_traits::MD5Sum< ::sas_robot_driver_franka::MoveRequest> should match
// service_traits::MD5Sum< ::sas_robot_driver_franka::Move >
template<>
struct MD5Sum< ::sas_robot_driver_franka::MoveRequest>
{
static const char* value()
{
return MD5Sum< ::sas_robot_driver_franka::Move >::value();
}
static const char* value(const ::sas_robot_driver_franka::MoveRequest&)
{
return value();
}
};
// service_traits::DataType< ::sas_robot_driver_franka::MoveRequest> should match
// service_traits::DataType< ::sas_robot_driver_franka::Move >
template<>
struct DataType< ::sas_robot_driver_franka::MoveRequest>
{
static const char* value()
{
return DataType< ::sas_robot_driver_franka::Move >::value();
}
static const char* value(const ::sas_robot_driver_franka::MoveRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::sas_robot_driver_franka::MoveResponse> should match
// service_traits::MD5Sum< ::sas_robot_driver_franka::Move >
template<>
struct MD5Sum< ::sas_robot_driver_franka::MoveResponse>
{
static const char* value()
{
return MD5Sum< ::sas_robot_driver_franka::Move >::value();
}
static const char* value(const ::sas_robot_driver_franka::MoveResponse&)
{
return value();
}
};
// service_traits::DataType< ::sas_robot_driver_franka::MoveResponse> should match
// service_traits::DataType< ::sas_robot_driver_franka::Move >
template<>
struct DataType< ::sas_robot_driver_franka::MoveResponse>
{
static const char* value()
{
return DataType< ::sas_robot_driver_franka::Move >::value();
}
static const char* value(const ::sas_robot_driver_franka::MoveResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVE_H

205
include/MoveRequest.h
View File

@@ -1,205 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/MoveRequest.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVEREQUEST_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVEREQUEST_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace sas_robot_driver_franka
{
template <class ContainerAllocator>
struct MoveRequest_
{
typedef MoveRequest_<ContainerAllocator> Type;
MoveRequest_()
: width(0.0)
, speed(0.0) {
}
MoveRequest_(const ContainerAllocator& _alloc)
: width(0.0)
, speed(0.0) {
(void)_alloc;
}
typedef float _width_type;
_width_type width;
typedef float _speed_type;
_speed_type speed;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> const> ConstPtr;
}; // struct MoveRequest_
typedef ::sas_robot_driver_franka::MoveRequest_<std::allocator<void> > MoveRequest;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveRequest > MoveRequestPtr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveRequest const> MoveRequestConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator2> & rhs)
{
return lhs.width == rhs.width &&
lhs.speed == rhs.speed;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sas_robot_driver_franka
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
{
static const char* value()
{
return "b2d4f46fe020a06d64128c90310c767d";
}
static const char* value(const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xb2d4f46fe020a06dULL;
static const uint64_t static_value2 = 0x64128c90310c767dULL;
};
template<class ContainerAllocator>
struct DataType< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
{
static const char* value()
{
return "sas_robot_driver_franka/MoveRequest";
}
static const char* value(const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
{
static const char* value()
{
return "float32 width\n"
"float32 speed\n"
;
}
static const char* value(const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.width);
stream.next(m.speed);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MoveRequest_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sas_robot_driver_franka::MoveRequest_<ContainerAllocator>& v)
{
s << indent << "width: ";
Printer<float>::stream(s, indent + " ", v.width);
s << indent << "speed: ";
Printer<float>::stream(s, indent + " ", v.speed);
}
};
} // namespace message_operations
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVEREQUEST_H

195
include/MoveResponse.h
View File

@@ -1,195 +0,0 @@
// Generated by gencpp from file sas_robot_driver_franka/MoveResponse.msg
// DO NOT EDIT!
#ifndef SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVERESPONSE_H
#define SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVERESPONSE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace sas_robot_driver_franka
{
template <class ContainerAllocator>
struct MoveResponse_
{
typedef MoveResponse_<ContainerAllocator> Type;
MoveResponse_()
: success(false) {
}
MoveResponse_(const ContainerAllocator& _alloc)
: success(false) {
(void)_alloc;
}
typedef uint8_t _success_type;
_success_type success;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> const> ConstPtr;
}; // struct MoveResponse_
typedef ::sas_robot_driver_franka::MoveResponse_<std::allocator<void> > MoveResponse;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveResponse > MoveResponsePtr;
typedef boost::shared_ptr< ::sas_robot_driver_franka::MoveResponse const> MoveResponseConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator2> & rhs)
{
return lhs.success == rhs.success;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator1> & lhs, const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sas_robot_driver_franka
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
{
static const char* value()
{
return "358e233cde0c8a8bcfea4ce193f8fc15";
}
static const char* value(const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x358e233cde0c8a8bULL;
static const uint64_t static_value2 = 0xcfea4ce193f8fc15ULL;
};
template<class ContainerAllocator>
struct DataType< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
{
static const char* value()
{
return "sas_robot_driver_franka/MoveResponse";
}
static const char* value(const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
{
static const char* value()
{
return "bool success\n"
;
}
static const char* value(const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.success);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MoveResponse_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sas_robot_driver_franka::MoveResponse_<ContainerAllocator>& v)
{
s << indent << "success: ";
Printer<uint8_t>::stream(s, indent + " ", v.success);
}
};
} // namespace message_operations
} // namespace ros
#endif // SAS_ROBOT_DRIVER_FRANKA_MESSAGE_MOVERESPONSE_H

0
include/deprecated/robot_coppelia_ros_interface.h → include/sas_robot_driver_franka/deprecated/robot_coppelia_ros_interface.h
View File

6
include/generator/custom_motion_generation.h → include/sas_robot_driver_franka/generator/custom_motion_generation.h
View File

@@ -32,13 +32,13 @@
#pragma once
#include <array>
#include <Eigen/Core>
#include <Eigen/Dense>
#include <eigen3/Eigen/Core>
#include <eigen3/Eigen/Dense>
#include <vector>
#include <iostream>
#include <dqrobotics/solvers/DQ_QPOASESSolver.h>
#include <memory>
#include "constraints_manager.h"
#include <constraints_manager.h>
using namespace DQ_robotics;

4
include/generator/motion_generator.h → include/sas_robot_driver_franka/generator/motion_generator.h
View File

@@ -4,8 +4,8 @@
#include <array>
#include <Eigen/Core>
#include <Eigen/Dense>
#include <eigen3/Eigen/Core>
#include <eigen3/Eigen/Dense>
#include <franka/control_types.h>
#include <franka/duration.h>
#include <franka/robot.h>

4
include/generator/quadratic_program_motion_generator.h → include/sas_robot_driver_franka/generator/quadratic_program_motion_generator.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include <array>
#include <Eigen/Core>
#include <Eigen/Dense>
#include <eigen3/Eigen/Core>
#include <eigen3/Eigen/Dense>
#include <vector>
#include <iostream>
#include <dqrobotics/solvers/DQ_QPOASESSolver.h>

123
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__builder.hpp Normal file
View File

@@ -0,0 +1,123 @@
// generated from rosidl_generator_cpp/resource/idl__builder.hpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__BUILDER_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__BUILDER_HPP_
#include <algorithm>
#include <utility>
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace msg
{
namespace builder
{
class Init_GripperState_duration_ms
{
public:
explicit Init_GripperState_duration_ms(::sas_robot_driver_franka_interfaces::msg::GripperState & msg)
: msg_(msg)
{}
::sas_robot_driver_franka_interfaces::msg::GripperState duration_ms(::sas_robot_driver_franka_interfaces::msg::GripperState::_duration_ms_type arg)
{
msg_.duration_ms = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::msg::GripperState msg_;
};
class Init_GripperState_temperature
{
public:
explicit Init_GripperState_temperature(::sas_robot_driver_franka_interfaces::msg::GripperState & msg)
: msg_(msg)
{}
Init_GripperState_duration_ms temperature(::sas_robot_driver_franka_interfaces::msg::GripperState::_temperature_type arg)
{
msg_.temperature = std::move(arg);
return Init_GripperState_duration_ms(msg_);
}
private:
::sas_robot_driver_franka_interfaces::msg::GripperState msg_;
};
class Init_GripperState_is_grasped
{
public:
explicit Init_GripperState_is_grasped(::sas_robot_driver_franka_interfaces::msg::GripperState & msg)
: msg_(msg)
{}
Init_GripperState_temperature is_grasped(::sas_robot_driver_franka_interfaces::msg::GripperState::_is_grasped_type arg)
{
msg_.is_grasped = std::move(arg);
return Init_GripperState_temperature(msg_);
}
private:
::sas_robot_driver_franka_interfaces::msg::GripperState msg_;
};
class Init_GripperState_max_width
{
public:
explicit Init_GripperState_max_width(::sas_robot_driver_franka_interfaces::msg::GripperState & msg)
: msg_(msg)
{}
Init_GripperState_is_grasped max_width(::sas_robot_driver_franka_interfaces::msg::GripperState::_max_width_type arg)
{
msg_.max_width = std::move(arg);
return Init_GripperState_is_grasped(msg_);
}
private:
::sas_robot_driver_franka_interfaces::msg::GripperState msg_;
};
class Init_GripperState_width
{
public:
Init_GripperState_width()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
Init_GripperState_max_width width(::sas_robot_driver_franka_interfaces::msg::GripperState::_width_type arg)
{
msg_.width = std::move(arg);
return Init_GripperState_max_width(msg_);
}
private:
::sas_robot_driver_franka_interfaces::msg::GripperState msg_;
};
} // namespace builder
} // namespace msg
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::msg::GripperState>()
{
return sas_robot_driver_franka_interfaces::msg::builder::Init_GripperState_width();
}
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__BUILDER_HPP_

149
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__description.c Normal file
View File

@@ -0,0 +1,149 @@
// generated from rosidl_generator_c/resource/idl__description.c.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__functions.h"
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x0e, 0x8d, 0x1a, 0xf8, 0x6e, 0x55, 0x6d, 0x06,
0xb7, 0x37, 0x19, 0xc0, 0x45, 0x07, 0x01, 0xf1,
0xfb, 0xbb, 0xdd, 0x6e, 0x9c, 0x56, 0x40, 0xa6,
0xc4, 0xef, 0xf7, 0x34, 0x67, 0xc1, 0xa0, 0x1e,
}};
return &hash;
}
#include <assert.h>
#include <string.h>
// Include directives for referenced types
// Hashes for external referenced types
#ifndef NDEBUG
#endif
static char sas_robot_driver_franka_interfaces__msg__GripperState__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/msg/GripperState";
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__width[] = "width";
static char sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__max_width[] = "max_width";
static char sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__is_grasped[] = "is_grasped";
static char sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__temperature[] = "temperature";
static char sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__duration_ms[] = "duration_ms";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__msg__GripperState__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__width, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__max_width, 9, 9},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__is_grasped, 10, 10},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_BOOLEAN,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__temperature, 11, 11},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_UINT16,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELD_NAME__duration_ms, 11, 11},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_UINT64,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__msg__GripperState__TYPE_NAME, 51, 51},
{sas_robot_driver_franka_interfaces__msg__GripperState__FIELDS, 5, 5},
},
{NULL, 0, 0},
};
if (!constructed) {
constructed = true;
}
return &description;
}
static char toplevel_type_raw_source[] =
"float32 width\n"
"float32 max_width\n"
"bool is_grasped\n"
"uint16 temperature\n"
"uint64 duration_ms";
static char msg_encoding[] = "msg";
// Define all individual source functions
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__msg__GripperState__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__msg__GripperState__TYPE_NAME, 51, 51},
{msg_encoding, 3, 3},
{toplevel_type_raw_source, 85, 85},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[1];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 1, 1};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__msg__GripperState__get_individual_type_description_source(NULL),
constructed = true;
}
return &source_sequence;
}

268
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__functions.c Normal file
View File

@@ -0,0 +1,268 @@
// generated from rosidl_generator_c/resource/idl__functions.c.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__functions.h"
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "rcutils/allocator.h"
bool
sas_robot_driver_franka_interfaces__msg__GripperState__init(sas_robot_driver_franka_interfaces__msg__GripperState * msg)
{
if (!msg) {
return false;
}
// width
// max_width
// is_grasped
// temperature
// duration_ms
return true;
}
void
sas_robot_driver_franka_interfaces__msg__GripperState__fini(sas_robot_driver_franka_interfaces__msg__GripperState * msg)
{
if (!msg) {
return;
}
// width
// max_width
// is_grasped
// temperature
// duration_ms
}
bool
sas_robot_driver_franka_interfaces__msg__GripperState__are_equal(const sas_robot_driver_franka_interfaces__msg__GripperState * lhs, const sas_robot_driver_franka_interfaces__msg__GripperState * rhs)
{
if (!lhs || !rhs) {
return false;
}
// width
if (lhs->width != rhs->width) {
return false;
}
// max_width
if (lhs->max_width != rhs->max_width) {
return false;
}
// is_grasped
if (lhs->is_grasped != rhs->is_grasped) {
return false;
}
// temperature
if (lhs->temperature != rhs->temperature) {
return false;
}
// duration_ms
if (lhs->duration_ms != rhs->duration_ms) {
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__msg__GripperState__copy(
const sas_robot_driver_franka_interfaces__msg__GripperState * input,
sas_robot_driver_franka_interfaces__msg__GripperState * output)
{
if (!input || !output) {
return false;
}
// width
output->width = input->width;
// max_width
output->max_width = input->max_width;
// is_grasped
output->is_grasped = input->is_grasped;
// temperature
output->temperature = input->temperature;
// duration_ms
output->duration_ms = input->duration_ms;
return true;
}
sas_robot_driver_franka_interfaces__msg__GripperState *
sas_robot_driver_franka_interfaces__msg__GripperState__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__msg__GripperState * msg = (sas_robot_driver_franka_interfaces__msg__GripperState *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__msg__GripperState), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__msg__GripperState));
bool success = sas_robot_driver_franka_interfaces__msg__GripperState__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__msg__GripperState__destroy(sas_robot_driver_franka_interfaces__msg__GripperState * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__msg__GripperState__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__init(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__msg__GripperState * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__msg__GripperState *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__msg__GripperState), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__msg__GripperState__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__msg__GripperState__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__fini(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__msg__GripperState__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence *
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array = (sas_robot_driver_franka_interfaces__msg__GripperState__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__destroy(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__are_equal(const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * lhs, const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__msg__GripperState__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__copy(
const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * input,
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__msg__GripperState);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__msg__GripperState * data =
(sas_robot_driver_franka_interfaces__msg__GripperState *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__msg__GripperState__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__msg__GripperState__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__msg__GripperState__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}

210
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__functions.h Normal file
View File

@@ -0,0 +1,210 @@
// generated from rosidl_generator_c/resource/idl__functions.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__FUNCTIONS_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__FUNCTIONS_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stdlib.h>
#include "rosidl_runtime_c/action_type_support_struct.h"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_runtime_c/service_type_support_struct.h"
#include "rosidl_runtime_c/type_description/type_description__struct.h"
#include "rosidl_runtime_c/type_description/type_source__struct.h"
#include "rosidl_runtime_c/type_hash.h"
#include "rosidl_runtime_c/visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.h"
/// Initialize msg/GripperState message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__msg__GripperState
* )) before or use
* sas_robot_driver_franka_interfaces__msg__GripperState__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__init(sas_robot_driver_franka_interfaces__msg__GripperState * msg);
/// Finalize msg/GripperState message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__msg__GripperState__fini(sas_robot_driver_franka_interfaces__msg__GripperState * msg);
/// Create msg/GripperState message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__msg__GripperState__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__msg__GripperState *
sas_robot_driver_franka_interfaces__msg__GripperState__create(void);
/// Destroy msg/GripperState message.
/**
* It calls
* sas_robot_driver_franka_interfaces__msg__GripperState__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__msg__GripperState__destroy(sas_robot_driver_franka_interfaces__msg__GripperState * msg);
/// Check for msg/GripperState message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__are_equal(const sas_robot_driver_franka_interfaces__msg__GripperState * lhs, const sas_robot_driver_franka_interfaces__msg__GripperState * rhs);
/// Copy a msg/GripperState message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__copy(
const sas_robot_driver_franka_interfaces__msg__GripperState * input,
sas_robot_driver_franka_interfaces__msg__GripperState * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__msg__GripperState__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of msg/GripperState messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__msg__GripperState__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__init(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array, size_t size);
/// Finalize array of msg/GripperState messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__msg__GripperState__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__fini(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array);
/// Create array of msg/GripperState messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence *
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__create(size_t size);
/// Destroy array of msg/GripperState messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__destroy(sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * array);
/// Check for msg/GripperState message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__are_equal(const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * lhs, const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * rhs);
/// Copy an array of msg/GripperState messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence__copy(
const sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * input,
sas_robot_driver_franka_interfaces__msg__GripperState__Sequence * output);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__FUNCTIONS_H_

65
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__rosidl_typesupport_fastrtps_c.h Normal file
View File

@@ -0,0 +1,65 @@
// generated from rosidl_typesupport_fastrtps_c/resource/idl__rosidl_typesupport_fastrtps_c.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#include <stddef.h>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.h"
#include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__msg__GripperState(
const sas_robot_driver_franka_interfaces__msg__GripperState * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__msg__GripperState(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__msg__GripperState * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__msg__GripperState(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__msg__GripperState(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__msg__GripperState(
const sas_robot_driver_franka_interfaces__msg__GripperState * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__msg__GripperState(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__msg__GripperState(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, msg, GripperState)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_

100
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__rosidl_typesupport_fastrtps_cpp.hpp Normal file
View File

@@ -0,0 +1,100 @@
// generated from rosidl_typesupport_fastrtps_cpp/resource/idl__rosidl_typesupport_fastrtps_cpp.hpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#include <cstddef>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
#include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace msg
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::msg::GripperState & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::msg::GripperState & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::msg::GripperState & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_GripperState(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::msg::GripperState & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::msg::GripperState & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_GripperState(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace msg
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, msg, GripperState)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_

26
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__rosidl_typesupport_introspection_c.h Normal file
View File

@@ -0,0 +1,26 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__rosidl_typesupport_introspection_c.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, msg, GripperState)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_

27
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__rosidl_typesupport_introspection_cpp.hpp Normal file
View File

@@ -0,0 +1,27 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__rosidl_typesupport_introspection_cpp.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, msg, GripperState)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_

46
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__struct.h Normal file
View File

@@ -0,0 +1,46 @@
// generated from rosidl_generator_c/resource/idl__struct.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
// Constants defined in the message
/// Struct defined in msg/GripperState in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__msg__GripperState
{
float width;
float max_width;
bool is_grasped;
uint16_t temperature;
uint64_t duration_ms;
} sas_robot_driver_franka_interfaces__msg__GripperState;
// Struct for a sequence of sas_robot_driver_franka_interfaces__msg__GripperState.
typedef struct sas_robot_driver_franka_interfaces__msg__GripperState__Sequence
{
sas_robot_driver_franka_interfaces__msg__GripperState * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__msg__GripperState__Sequence;
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_H_

190
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__struct.hpp Normal file
View File

@@ -0,0 +1,190 @@
// generated from rosidl_generator_cpp/resource/idl__struct.hpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_HPP_
#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <vector>
#include "rosidl_runtime_cpp/bounded_vector.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__msg__GripperState __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__msg__GripperState __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace msg
{
// message struct
template<class ContainerAllocator>
struct GripperState_
{
using Type = GripperState_<ContainerAllocator>;
explicit GripperState_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->max_width = 0.0f;
this->is_grasped = false;
this->temperature = 0;
this->duration_ms = 0ull;
}
}
explicit GripperState_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
(void)_alloc;
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->max_width = 0.0f;
this->is_grasped = false;
this->temperature = 0;
this->duration_ms = 0ull;
}
}
// field types and members
using _width_type =
float;
_width_type width;
using _max_width_type =
float;
_max_width_type max_width;
using _is_grasped_type =
bool;
_is_grasped_type is_grasped;
using _temperature_type =
uint16_t;
_temperature_type temperature;
using _duration_ms_type =
uint64_t;
_duration_ms_type duration_ms;
// setters for named parameter idiom
Type & set__width(
const float & _arg)
{
this->width = _arg;
return *this;
}
Type & set__max_width(
const float & _arg)
{
this->max_width = _arg;
return *this;
}
Type & set__is_grasped(
const bool & _arg)
{
this->is_grasped = _arg;
return *this;
}
Type & set__temperature(
const uint16_t & _arg)
{
this->temperature = _arg;
return *this;
}
Type & set__duration_ms(
const uint64_t & _arg)
{
this->duration_ms = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__msg__GripperState
std::shared_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__msg__GripperState
std::shared_ptr<sas_robot_driver_franka_interfaces::msg::GripperState_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const GripperState_ & other) const
{
if (this->width != other.width) {
return false;
}
if (this->max_width != other.max_width) {
return false;
}
if (this->is_grasped != other.is_grasped) {
return false;
}
if (this->temperature != other.temperature) {
return false;
}
if (this->duration_ms != other.duration_ms) {
return false;
}
return true;
}
bool operator!=(const GripperState_ & other) const
{
return !this->operator==(other);
}
}; // struct GripperState_
// alias to use template instance with default allocator
using GripperState =
sas_robot_driver_franka_interfaces::msg::GripperState_<std::allocator<void>>;
// constant definitions
} // namespace msg
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__STRUCT_HPP_

180
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__traits.hpp Normal file
View File

@@ -0,0 +1,180 @@
// generated from rosidl_generator_cpp/resource/idl__traits.hpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TRAITS_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TRAITS_HPP_
#include <stdint.h>
#include <sstream>
#include <string>
#include <type_traits>
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.hpp"
#include "rosidl_runtime_cpp/traits.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace msg
{
inline void to_flow_style_yaml(
const GripperState & msg,
std::ostream & out)
{
out << "{";
// member: width
{
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << ", ";
}
// member: max_width
{
out << "max_width: ";
rosidl_generator_traits::value_to_yaml(msg.max_width, out);
out << ", ";
}
// member: is_grasped
{
out << "is_grasped: ";
rosidl_generator_traits::value_to_yaml(msg.is_grasped, out);
out << ", ";
}
// member: temperature
{
out << "temperature: ";
rosidl_generator_traits::value_to_yaml(msg.temperature, out);
out << ", ";
}
// member: duration_ms
{
out << "duration_ms: ";
rosidl_generator_traits::value_to_yaml(msg.duration_ms, out);
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const GripperState & msg,
std::ostream & out, size_t indentation = 0)
{
// member: width
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << "\n";
}
// member: max_width
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "max_width: ";
rosidl_generator_traits::value_to_yaml(msg.max_width, out);
out << "\n";
}
// member: is_grasped
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "is_grasped: ";
rosidl_generator_traits::value_to_yaml(msg.is_grasped, out);
out << "\n";
}
// member: temperature
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "temperature: ";
rosidl_generator_traits::value_to_yaml(msg.temperature, out);
out << "\n";
}
// member: duration_ms
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "duration_ms: ";
rosidl_generator_traits::value_to_yaml(msg.duration_ms, out);
out << "\n";
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const GripperState & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace msg
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::msg::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::msg::GripperState & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::msg::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::msg::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::msg::GripperState & msg)
{
return sas_robot_driver_franka_interfaces::msg::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::msg::GripperState>()
{
return "sas_robot_driver_franka_interfaces::msg::GripperState";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::msg::GripperState>()
{
return "sas_robot_driver_franka_interfaces/msg/GripperState";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::msg::GripperState>
: std::integral_constant<bool, true> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::msg::GripperState>
: std::integral_constant<bool, true> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::msg::GripperState>
: std::true_type {};
} // namespace rosidl_generator_traits
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TRAITS_HPP_

160
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__type_support.c Normal file
View File

@@ -0,0 +1,160 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__type_support.c.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#include <stddef.h>
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__rosidl_typesupport_introspection_c.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
#include "rosidl_typesupport_introspection_c/field_types.h"
#include "rosidl_typesupport_introspection_c/identifier.h"
#include "rosidl_typesupport_introspection_c/message_introspection.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__functions.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__msg__GripperState__init(message_memory);
}
void sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__msg__GripperState__fini(message_memory);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_member_array[5] = {
{
"width", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__msg__GripperState, width), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"max_width", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__msg__GripperState, max_width), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"is_grasped", // name
rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__msg__GripperState, is_grasped), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"temperature", // name
rosidl_typesupport_introspection_c__ROS_TYPE_UINT16, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__msg__GripperState, temperature), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"duration_ms", // name
rosidl_typesupport_introspection_c__ROS_TYPE_UINT64, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__msg__GripperState, duration_ms), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_members = {
"sas_robot_driver_franka_interfaces__msg", // message namespace
"GripperState", // message name
5, // number of fields
sizeof(sas_robot_driver_franka_interfaces__msg__GripperState),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_member_array, // message members
sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_hash,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, msg, GripperState)() {
if (!sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__msg__GripperState__rosidl_typesupport_introspection_c__GripperState_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif

187
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__type_support.cpp Normal file
View File

@@ -0,0 +1,187 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__type_support.cpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#include "array"
#include "cstddef"
#include "string"
#include "vector"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__functions.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.hpp"
#include "rosidl_typesupport_introspection_cpp/field_types.hpp"
#include "rosidl_typesupport_introspection_cpp/identifier.hpp"
#include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
#include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace msg
{
namespace rosidl_typesupport_introspection_cpp
{
void GripperState_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::msg::GripperState(_init);
}
void GripperState_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::msg::GripperState *>(message_memory);
typed_message->~GripperState();
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember GripperState_message_member_array[5] = {
{
"width", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::msg::GripperState, width), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"max_width", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::msg::GripperState, max_width), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"is_grasped", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::msg::GripperState, is_grasped), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"temperature", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_UINT16, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::msg::GripperState, temperature), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"duration_ms", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_UINT64, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::msg::GripperState, duration_ms), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers GripperState_message_members = {
"sas_robot_driver_franka_interfaces::msg", // message namespace
"GripperState", // message name
5, // number of fields
sizeof(sas_robot_driver_franka_interfaces::msg::GripperState),
false, // has_any_key_member_
GripperState_message_member_array, // message members
GripperState_init_function, // function to initialize message memory (memory has to be allocated)
GripperState_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t GripperState_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&GripperState_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_hash,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description,
&sas_robot_driver_franka_interfaces__msg__GripperState__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace msg
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::msg::GripperState>()
{
return &::sas_robot_driver_franka_interfaces::msg::rosidl_typesupport_introspection_cpp::GripperState_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, msg, GripperState)() {
return &::sas_robot_driver_franka_interfaces::msg::rosidl_typesupport_introspection_cpp::GripperState_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif

36
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__type_support.h Normal file
View File

@@ -0,0 +1,36 @@
// generated from rosidl_generator_c/resource/idl__type_support.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/msg/gripper_state.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_H_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
msg,
GripperState
)(void);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_H_

31
include/sas_robot_driver_franka/interfaces/local/msg/detail/gripper_state__type_support.hpp Normal file
View File

@@ -0,0 +1,31 @@
// generated from rosidl_generator_cpp/resource/idl__type_support.hpp.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_HPP_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_cpp__visibility_control.hpp"
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
msg,
GripperState
)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__DETAIL__GRIPPER_STATE__TYPE_SUPPORT_HPP_

12
include/sas_robot_driver_franka/interfaces/local/msg/gripper_state.h Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_c/resource/idl.h.em
// with input from sas_robot_driver_franka_interfaces:msg/GripperState.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_H_
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__functions.h"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__type_support.h"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_H_

12
include/sas_robot_driver_franka/interfaces/local/msg/gripper_state.hpp Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_cpp/resource/idl.hpp.em
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_HPP_
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__struct.hpp"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__builder.hpp"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__traits.hpp"
#include "sas_robot_driver_franka_interfaces/msg/detail/gripper_state__type_support.hpp"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__GRIPPER_STATE_HPP_

42
include/sas_robot_driver_franka/interfaces/local/msg/rosidl_generator_c__visibility_control.h Normal file
View File

@@ -0,0 +1,42 @@
// generated from rosidl_generator_c/resource/rosidl_generator_c__visibility_control.h.in
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_C__VISIBILITY_CONTROL_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_C__VISIBILITY_CONTROL_H_
#ifdef __cplusplus
extern "C"
{
#endif
// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
// https://gcc.gnu.org/wiki/Visibility
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define ROSIDL_GENERATOR_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllexport))
#define ROSIDL_GENERATOR_C_IMPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllimport))
#else
#define ROSIDL_GENERATOR_C_EXPORT_sas_robot_driver_franka_interfaces __declspec(dllexport)
#define ROSIDL_GENERATOR_C_IMPORT_sas_robot_driver_franka_interfaces __declspec(dllimport)
#endif
#ifdef ROSIDL_GENERATOR_C_BUILDING_DLL_sas_robot_driver_franka_interfaces
#define ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_GENERATOR_C_EXPORT_sas_robot_driver_franka_interfaces
#else
#define ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_GENERATOR_C_IMPORT_sas_robot_driver_franka_interfaces
#endif
#else
#define ROSIDL_GENERATOR_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#define ROSIDL_GENERATOR_C_IMPORT_sas_robot_driver_franka_interfaces
#if __GNUC__ >= 4
#define ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#else
#define ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_C__VISIBILITY_CONTROL_H_

42
include/sas_robot_driver_franka/interfaces/local/msg/rosidl_generator_cpp__visibility_control.hpp Normal file
View File

@@ -0,0 +1,42 @@
// generated from rosidl_generator_cpp/resource/rosidl_generator_cpp__visibility_control.hpp.in
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_CPP__VISIBILITY_CONTROL_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_CPP__VISIBILITY_CONTROL_HPP_
#ifdef __cplusplus
extern "C"
{
#endif
// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
// https://gcc.gnu.org/wiki/Visibility
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define ROSIDL_GENERATOR_CPP_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllexport))
#define ROSIDL_GENERATOR_CPP_IMPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllimport))
#else
#define ROSIDL_GENERATOR_CPP_EXPORT_sas_robot_driver_franka_interfaces __declspec(dllexport)
#define ROSIDL_GENERATOR_CPP_IMPORT_sas_robot_driver_franka_interfaces __declspec(dllimport)
#endif
#ifdef ROSIDL_GENERATOR_CPP_BUILDING_DLL_sas_robot_driver_franka_interfaces
#define ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_GENERATOR_CPP_EXPORT_sas_robot_driver_franka_interfaces
#else
#define ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_GENERATOR_CPP_IMPORT_sas_robot_driver_franka_interfaces
#endif
#else
#define ROSIDL_GENERATOR_CPP_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#define ROSIDL_GENERATOR_CPP_IMPORT_sas_robot_driver_franka_interfaces
#if __GNUC__ >= 4
#define ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#else
#define ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_GENERATOR_CPP__VISIBILITY_CONTROL_HPP_

43
include/sas_robot_driver_franka/interfaces/local/msg/rosidl_typesupport_fastrtps_c__visibility_control.h Normal file
View File

@@ -0,0 +1,43 @@
// generated from
// rosidl_typesupport_fastrtps_c/resource/rosidl_typesupport_fastrtps_c__visibility_control.h.in
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_C__VISIBILITY_CONTROL_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_C__VISIBILITY_CONTROL_H_
#if __cplusplus
extern "C"
{
#endif
// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
// https://gcc.gnu.org/wiki/Visibility
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllexport))
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_IMPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllimport))
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_EXPORT_sas_robot_driver_franka_interfaces __declspec(dllexport)
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_IMPORT_sas_robot_driver_franka_interfaces __declspec(dllimport)
#endif
#ifdef ROSIDL_TYPESUPPORT_FASTRTPS_C_BUILDING_DLL_sas_robot_driver_franka_interfaces
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_FASTRTPS_C_EXPORT_sas_robot_driver_franka_interfaces
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_FASTRTPS_C_IMPORT_sas_robot_driver_franka_interfaces
#endif
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_IMPORT_sas_robot_driver_franka_interfaces
#if __GNUC__ >= 4
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
#endif
#endif
#if __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_C__VISIBILITY_CONTROL_H_

43
include/sas_robot_driver_franka/interfaces/local/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h Normal file
View File

@@ -0,0 +1,43 @@
// generated from
// rosidl_typesupport_fastrtps_cpp/resource/rosidl_typesupport_fastrtps_cpp__visibility_control.h.in
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_CPP__VISIBILITY_CONTROL_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_CPP__VISIBILITY_CONTROL_H_
#if __cplusplus
extern "C"
{
#endif
// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
// https://gcc.gnu.org/wiki/Visibility
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllexport))
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_IMPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllimport))
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_EXPORT_sas_robot_driver_franka_interfaces __declspec(dllexport)
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_IMPORT_sas_robot_driver_franka_interfaces __declspec(dllimport)
#endif
#ifdef ROSIDL_TYPESUPPORT_FASTRTPS_CPP_BUILDING_DLL_sas_robot_driver_franka_interfaces
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_FASTRTPS_CPP_EXPORT_sas_robot_driver_franka_interfaces
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_FASTRTPS_CPP_IMPORT_sas_robot_driver_franka_interfaces
#endif
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_IMPORT_sas_robot_driver_franka_interfaces
#if __GNUC__ >= 4
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#else
#define ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
#endif
#endif
#if __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_FASTRTPS_CPP__VISIBILITY_CONTROL_H_

43
include/sas_robot_driver_franka/interfaces/local/msg/rosidl_typesupport_introspection_c__visibility_control.h Normal file
View File

@@ -0,0 +1,43 @@
// generated from
// rosidl_typesupport_introspection_c/resource/rosidl_typesupport_introspection_c__visibility_control.h.in
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_INTROSPECTION_C__VISIBILITY_CONTROL_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_INTROSPECTION_C__VISIBILITY_CONTROL_H_
#ifdef __cplusplus
extern "C"
{
#endif
// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
// https://gcc.gnu.org/wiki/Visibility
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllexport))
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_IMPORT_sas_robot_driver_franka_interfaces __attribute__ ((dllimport))
#else
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces __declspec(dllexport)
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_IMPORT_sas_robot_driver_franka_interfaces __declspec(dllimport)
#endif
#ifdef ROSIDL_TYPESUPPORT_INTROSPECTION_C_BUILDING_DLL_sas_robot_driver_franka_interfaces
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
#else
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces ROSIDL_TYPESUPPORT_INTROSPECTION_C_IMPORT_sas_robot_driver_franka_interfaces
#endif
#else
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_IMPORT_sas_robot_driver_franka_interfaces
#if __GNUC__ >= 4
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces __attribute__ ((visibility("default")))
#else
#define ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__MSG__ROSIDL_TYPESUPPORT_INTROSPECTION_C__VISIBILITY_CONTROL_H_

239
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__builder.hpp Normal file
View File

@@ -0,0 +1,239 @@
// generated from rosidl_generator_cpp/resource/idl__builder.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__BUILDER_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__BUILDER_HPP_
#include <algorithm>
#include <utility>
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Grasp_Request_epsilon_outer
{
public:
explicit Init_Grasp_Request_epsilon_outer(::sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg)
: msg_(msg)
{}
::sas_robot_driver_franka_interfaces::srv::Grasp_Request epsilon_outer(::sas_robot_driver_franka_interfaces::srv::Grasp_Request::_epsilon_outer_type arg)
{
msg_.epsilon_outer = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Request msg_;
};
class Init_Grasp_Request_epsilon_inner
{
public:
explicit Init_Grasp_Request_epsilon_inner(::sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg)
: msg_(msg)
{}
Init_Grasp_Request_epsilon_outer epsilon_inner(::sas_robot_driver_franka_interfaces::srv::Grasp_Request::_epsilon_inner_type arg)
{
msg_.epsilon_inner = std::move(arg);
return Init_Grasp_Request_epsilon_outer(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Request msg_;
};
class Init_Grasp_Request_force
{
public:
explicit Init_Grasp_Request_force(::sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg)
: msg_(msg)
{}
Init_Grasp_Request_epsilon_inner force(::sas_robot_driver_franka_interfaces::srv::Grasp_Request::_force_type arg)
{
msg_.force = std::move(arg);
return Init_Grasp_Request_epsilon_inner(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Request msg_;
};
class Init_Grasp_Request_speed
{
public:
explicit Init_Grasp_Request_speed(::sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg)
: msg_(msg)
{}
Init_Grasp_Request_force speed(::sas_robot_driver_franka_interfaces::srv::Grasp_Request::_speed_type arg)
{
msg_.speed = std::move(arg);
return Init_Grasp_Request_force(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Request msg_;
};
class Init_Grasp_Request_width
{
public:
Init_Grasp_Request_width()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
Init_Grasp_Request_speed width(::sas_robot_driver_franka_interfaces::srv::Grasp_Request::_width_type arg)
{
msg_.width = std::move(arg);
return Init_Grasp_Request_speed(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Request msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Grasp_Request>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Grasp_Request_width();
}
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Grasp_Response_success
{
public:
Init_Grasp_Response_success()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
::sas_robot_driver_franka_interfaces::srv::Grasp_Response success(::sas_robot_driver_franka_interfaces::srv::Grasp_Response::_success_type arg)
{
msg_.success = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Response msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Grasp_Response>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Grasp_Response_success();
}
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Grasp_Event_response
{
public:
explicit Init_Grasp_Event_response(::sas_robot_driver_franka_interfaces::srv::Grasp_Event & msg)
: msg_(msg)
{}
::sas_robot_driver_franka_interfaces::srv::Grasp_Event response(::sas_robot_driver_franka_interfaces::srv::Grasp_Event::_response_type arg)
{
msg_.response = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Event msg_;
};
class Init_Grasp_Event_request
{
public:
explicit Init_Grasp_Event_request(::sas_robot_driver_franka_interfaces::srv::Grasp_Event & msg)
: msg_(msg)
{}
Init_Grasp_Event_response request(::sas_robot_driver_franka_interfaces::srv::Grasp_Event::_request_type arg)
{
msg_.request = std::move(arg);
return Init_Grasp_Event_response(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Event msg_;
};
class Init_Grasp_Event_info
{
public:
Init_Grasp_Event_info()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
Init_Grasp_Event_request info(::sas_robot_driver_franka_interfaces::srv::Grasp_Event::_info_type arg)
{
msg_.info = std::move(arg);
return Init_Grasp_Event_request(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Grasp_Event msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Grasp_Event>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Grasp_Event_info();
}
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__BUILDER_HPP_

510
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__description.c Normal file
View File

@@ -0,0 +1,510 @@
// generated from rosidl_generator_c/resource/idl__description.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_hash(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x63, 0x87, 0x47, 0xf4, 0x3c, 0xcd, 0x3c, 0xeb,
0xe4, 0xac, 0x54, 0x50, 0xa7, 0xcc, 0xbd, 0x87,
0xe8, 0x3a, 0xd5, 0x41, 0x81, 0x9a, 0xbf, 0xd2,
0xba, 0x1a, 0xf6, 0x39, 0xdc, 0x83, 0xc9, 0xdc,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x7a, 0x77, 0x51, 0xdb, 0x7d, 0x94, 0xc5, 0x2e,
0x53, 0x86, 0x58, 0x52, 0x52, 0x0a, 0xce, 0xd2,
0xb9, 0xf0, 0xe8, 0x74, 0xf0, 0x5f, 0xfc, 0xba,
0x7e, 0x23, 0x21, 0x9d, 0x38, 0xc4, 0x65, 0x61,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x6a, 0xeb, 0x03, 0x72, 0xe8, 0x5e, 0x59, 0x20,
0x8b, 0x60, 0xcf, 0xf2, 0xab, 0x6a, 0x49, 0x28,
0x8b, 0xa5, 0x49, 0xc4, 0x60, 0xa9, 0xd7, 0xb2,
0xe0, 0x39, 0x41, 0x03, 0x83, 0x4b, 0xce, 0x0e,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0xd8, 0x07, 0x14, 0x86, 0xa7, 0x95, 0xbd, 0xba,
0xa8, 0x32, 0x2d, 0x5c, 0x7b, 0x65, 0xf0, 0x5d,
0x1f, 0xd3, 0x98, 0x77, 0x06, 0xaf, 0x7c, 0x68,
0xe3, 0x2f, 0xcd, 0xa1, 0x2d, 0x74, 0x79, 0x17,
}};
return &hash;
}
#include <assert.h>
#include <string.h>
// Include directives for referenced types
#include "service_msgs/msg/detail/service_event_info__functions.h"
#include "builtin_interfaces/msg/detail/time__functions.h"
// Hashes for external referenced types
#ifndef NDEBUG
static const rosidl_type_hash_t builtin_interfaces__msg__Time__EXPECTED_HASH = {1, {
0xb1, 0x06, 0x23, 0x5e, 0x25, 0xa4, 0xc5, 0xed,
0x35, 0x09, 0x8a, 0xa0, 0xa6, 0x1a, 0x3e, 0xe9,
0xc9, 0xb1, 0x8d, 0x19, 0x7f, 0x39, 0x8b, 0x0e,
0x42, 0x06, 0xce, 0xa9, 0xac, 0xf9, 0xc1, 0x97,
}};
static const rosidl_type_hash_t service_msgs__msg__ServiceEventInfo__EXPECTED_HASH = {1, {
0x41, 0xbc, 0xbb, 0xe0, 0x7a, 0x75, 0xc9, 0xb5,
0x2b, 0xc9, 0x6b, 0xfd, 0x5c, 0x24, 0xd7, 0xf0,
0xfc, 0x0a, 0x08, 0xc0, 0xcb, 0x79, 0x21, 0xb3,
0x37, 0x3c, 0x57, 0x32, 0x34, 0x5a, 0x6f, 0x45,
}};
#endif
static char sas_robot_driver_franka_interfaces__srv__Grasp__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Grasp";
static char builtin_interfaces__msg__Time__TYPE_NAME[] = "builtin_interfaces/msg/Time";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Event__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Grasp_Event";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Grasp_Request";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Grasp_Response";
static char service_msgs__msg__ServiceEventInfo__TYPE_NAME[] = "service_msgs/msg/ServiceEventInfo";
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__request_message[] = "request_message";
static char sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__response_message[] = "response_message";
static char sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__event_message[] = "event_message";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Grasp__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__request_message, 15, 15},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__response_message, 16, 16},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp__FIELD_NAME__event_message, 13, 13},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__TYPE_NAME, 50, 50},
},
{NULL, 0, 0},
},
};
static rosidl_runtime_c__type_description__IndividualTypeDescription sas_robot_driver_franka_interfaces__srv__Grasp__REFERENCED_TYPE_DESCRIPTIONS[] = {
{
{builtin_interfaces__msg__Time__TYPE_NAME, 27, 27},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__TYPE_NAME, 50, 50},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
{NULL, 0, 0},
},
{
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp__TYPE_NAME, 44, 44},
{sas_robot_driver_franka_interfaces__srv__Grasp__FIELDS, 3, 3},
},
{sas_robot_driver_franka_interfaces__srv__Grasp__REFERENCED_TYPE_DESCRIPTIONS, 5, 5},
};
if (!constructed) {
assert(0 == memcmp(&builtin_interfaces__msg__Time__EXPECTED_HASH, builtin_interfaces__msg__Time__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[0].fields = builtin_interfaces__msg__Time__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[1].fields = sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[2].fields = sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[3].fields = sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description(NULL)->type_description.fields;
assert(0 == memcmp(&service_msgs__msg__ServiceEventInfo__EXPECTED_HASH, service_msgs__msg__ServiceEventInfo__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[4].fields = service_msgs__msg__ServiceEventInfo__get_type_description(NULL)->type_description.fields;
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__width[] = "width";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__speed[] = "speed";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__force[] = "force";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__epsilon_inner[] = "epsilon_inner";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__epsilon_outer[] = "epsilon_outer";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__width, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__speed, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__force, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__epsilon_inner, 13, 13},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELD_NAME__epsilon_outer, 13, 13},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__FIELDS, 5, 5},
},
{NULL, 0, 0},
};
if (!constructed) {
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Grasp_Response__FIELD_NAME__success[] = "success";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Grasp_Response__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__FIELD_NAME__success, 7, 7},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_BOOLEAN,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__FIELDS, 1, 1},
},
{NULL, 0, 0},
};
if (!constructed) {
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__info[] = "info";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__request[] = "request";
static char sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__response[] = "response";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__info, 4, 4},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__request, 7, 7},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE_BOUNDED_SEQUENCE,
1,
0,
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELD_NAME__response, 8, 8},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE_BOUNDED_SEQUENCE,
1,
0,
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
},
{NULL, 0, 0},
},
};
static rosidl_runtime_c__type_description__IndividualTypeDescription sas_robot_driver_franka_interfaces__srv__Grasp_Event__REFERENCED_TYPE_DESCRIPTIONS[] = {
{
{builtin_interfaces__msg__Time__TYPE_NAME, 27, 27},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
{NULL, 0, 0},
},
{
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__TYPE_NAME, 50, 50},
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__FIELDS, 3, 3},
},
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__REFERENCED_TYPE_DESCRIPTIONS, 4, 4},
};
if (!constructed) {
assert(0 == memcmp(&builtin_interfaces__msg__Time__EXPECTED_HASH, builtin_interfaces__msg__Time__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[0].fields = builtin_interfaces__msg__Time__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[1].fields = sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[2].fields = sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description(NULL)->type_description.fields;
assert(0 == memcmp(&service_msgs__msg__ServiceEventInfo__EXPECTED_HASH, service_msgs__msg__ServiceEventInfo__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[3].fields = service_msgs__msg__ServiceEventInfo__get_type_description(NULL)->type_description.fields;
constructed = true;
}
return &description;
}
static char toplevel_type_raw_source[] =
"float32 width\n"
"float32 speed\n"
"float32 force\n"
"float32 epsilon_inner\n"
"float32 epsilon_outer\n"
"---\n"
"bool success";
static char srv_encoding[] = "srv";
static char implicit_encoding[] = "implicit";
// Define all individual source functions
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp__get_individual_type_description_source(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Grasp__TYPE_NAME, 44, 44},
{srv_encoding, 3, 3},
{toplevel_type_raw_source, 102, 102},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Grasp_Request__TYPE_NAME, 52, 52},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Grasp_Response__TYPE_NAME, 53, 53},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Grasp_Event__TYPE_NAME, 50, 50},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description_sources(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[6];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 6, 6};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Grasp__get_individual_type_description_source(NULL),
sources[1] = *builtin_interfaces__msg__Time__get_individual_type_description_source(NULL);
sources[2] = *sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_individual_type_description_source(NULL);
sources[3] = *sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_individual_type_description_source(NULL);
sources[4] = *sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_individual_type_description_source(NULL);
sources[5] = *service_msgs__msg__ServiceEventInfo__get_individual_type_description_source(NULL);
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[1];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 1, 1};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_individual_type_description_source(NULL),
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[1];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 1, 1};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_individual_type_description_source(NULL),
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[5];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 5, 5};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_individual_type_description_source(NULL),
sources[1] = *builtin_interfaces__msg__Time__get_individual_type_description_source(NULL);
sources[2] = *sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_individual_type_description_source(NULL);
sources[3] = *sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_individual_type_description_source(NULL);
sources[4] = *service_msgs__msg__ServiceEventInfo__get_individual_type_description_source(NULL);
constructed = true;
}
return &source_sequence;
}

774
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__functions.c Normal file
View File

@@ -0,0 +1,774 @@
// generated from rosidl_generator_c/resource/idl__functions.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "rcutils/allocator.h"
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg)
{
if (!msg) {
return false;
}
// width
// speed
// force
// epsilon_inner
// epsilon_outer
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg)
{
if (!msg) {
return;
}
// width
// speed
// force
// epsilon_inner
// epsilon_outer
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Request * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Request * rhs)
{
if (!lhs || !rhs) {
return false;
}
// width
if (lhs->width != rhs->width) {
return false;
}
// speed
if (lhs->speed != rhs->speed) {
return false;
}
// force
if (lhs->force != rhs->force) {
return false;
}
// epsilon_inner
if (lhs->epsilon_inner != rhs->epsilon_inner) {
return false;
}
// epsilon_outer
if (lhs->epsilon_outer != rhs->epsilon_outer) {
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Request * output)
{
if (!input || !output) {
return false;
}
// width
output->width = input->width;
// speed
output->speed = input->speed;
// force
output->force = input->force;
// epsilon_inner
output->epsilon_inner = input->epsilon_inner;
// epsilon_outer
output->epsilon_outer = input->epsilon_outer;
return true;
}
sas_robot_driver_franka_interfaces__srv__Grasp_Request *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg = (sas_robot_driver_franka_interfaces__srv__Grasp_Request *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request));
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Request * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Grasp_Request *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Request * data =
(sas_robot_driver_franka_interfaces__srv__Grasp_Request *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg)
{
if (!msg) {
return false;
}
// success
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg)
{
if (!msg) {
return;
}
// success
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Response * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Response * rhs)
{
if (!lhs || !rhs) {
return false;
}
// success
if (lhs->success != rhs->success) {
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Response * output)
{
if (!input || !output) {
return false;
}
// success
output->success = input->success;
return true;
}
sas_robot_driver_franka_interfaces__srv__Grasp_Response *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg = (sas_robot_driver_franka_interfaces__srv__Grasp_Response *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response));
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Response * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Grasp_Response *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Response * data =
(sas_robot_driver_franka_interfaces__srv__Grasp_Response *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}
// Include directives for member types
// Member `info`
#include "service_msgs/msg/detail/service_event_info__functions.h"
// Member `request`
// Member `response`
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg)
{
if (!msg) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__init(&msg->info)) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(msg);
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init(&msg->request, 0)) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(msg);
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init(&msg->response, 0)) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(msg);
return false;
}
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg)
{
if (!msg) {
return;
}
// info
service_msgs__msg__ServiceEventInfo__fini(&msg->info);
// request
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini(&msg->request);
// response
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini(&msg->response);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Event * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Event * rhs)
{
if (!lhs || !rhs) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__are_equal(
&(lhs->info), &(rhs->info)))
{
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__are_equal(
&(lhs->request), &(rhs->request)))
{
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__are_equal(
&(lhs->response), &(rhs->response)))
{
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Event * output)
{
if (!input || !output) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__copy(
&(input->info), &(output->info)))
{
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__copy(
&(input->request), &(output->request)))
{
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__copy(
&(input->response), &(output->response)))
{
return false;
}
return true;
}
sas_robot_driver_franka_interfaces__srv__Grasp_Event *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg = (sas_robot_driver_franka_interfaces__srv__Grasp_Event *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event));
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Event * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Grasp_Event *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Event__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Grasp_Event * data =
(sas_robot_driver_franka_interfaces__srv__Grasp_Event *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Event__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}

585
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__functions.h Normal file
View File

@@ -0,0 +1,585 @@
// generated from rosidl_generator_c/resource/idl__functions.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__FUNCTIONS_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__FUNCTIONS_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stdlib.h>
#include "rosidl_runtime_c/action_type_support_struct.h"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_runtime_c/service_type_support_struct.h"
#include "rosidl_runtime_c/type_description/type_description__struct.h"
#include "rosidl_runtime_c/type_description/type_source__struct.h"
#include "rosidl_runtime_c/type_hash.h"
#include "rosidl_runtime_c/visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_hash(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp__get_individual_type_description_source(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description_sources(
const rosidl_service_type_support_t * type_support);
/// Initialize srv/Grasp message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Grasp_Request
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg);
/// Finalize srv/Grasp message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg);
/// Create srv/Grasp message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Request *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__create(void);
/// Destroy srv/Grasp message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Request * msg);
/// Check for srv/Grasp message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Request * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Request * rhs);
/// Copy a srv/Grasp message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Request * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Grasp messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array, size_t size);
/// Finalize array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array);
/// Create array of srv/Grasp messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__create(size_t size);
/// Destroy array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * array);
/// Check for srv/Grasp message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * rhs);
/// Copy an array of srv/Grasp messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * output);
/// Initialize srv/Grasp message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Grasp_Response
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg);
/// Finalize srv/Grasp message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg);
/// Create srv/Grasp message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Response *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__create(void);
/// Destroy srv/Grasp message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Response * msg);
/// Check for srv/Grasp message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Response * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Response * rhs);
/// Copy a srv/Grasp message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Response * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Grasp messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array, size_t size);
/// Finalize array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array);
/// Create array of srv/Grasp messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__create(size_t size);
/// Destroy array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * array);
/// Check for srv/Grasp message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * rhs);
/// Copy an array of srv/Grasp messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * output);
/// Initialize srv/Grasp message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Grasp_Event
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg);
/// Finalize srv/Grasp message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg);
/// Create srv/Grasp message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Event *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__create(void);
/// Destroy srv/Grasp message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Event * msg);
/// Check for srv/Grasp message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Event * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Event * rhs);
/// Copy a srv/Grasp message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Event * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Grasp messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__init(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array, size_t size);
/// Finalize array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array);
/// Create array of srv/Grasp messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence *
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__create(size_t size);
/// Destroy array of srv/Grasp messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * array);
/// Check for srv/Grasp message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * rhs);
/// Copy an array of srv/Grasp messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence * output);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__FUNCTIONS_H_

210
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__rosidl_typesupport_fastrtps_c.h Normal file
View File

@@ -0,0 +1,210 @@
// generated from rosidl_typesupport_fastrtps_c/resource/idl__rosidl_typesupport_fastrtps_c.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#include <stddef.h>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
#include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Grasp_Request * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
// already included above
// #include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Grasp_Response * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
// already included above
// #include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Grasp_Event * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
const sas_robot_driver_franka_interfaces__srv__Grasp_Event * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Grasp_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Grasp_Event)();
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Grasp)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_

316
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__rosidl_typesupport_fastrtps_cpp.hpp Normal file
View File

@@ -0,0 +1,316 @@
// generated from rosidl_typesupport_fastrtps_cpp/resource/idl__rosidl_typesupport_fastrtps_cpp.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#include <cstddef>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
#include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Grasp_Request & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Grasp_Request & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Grasp_Request & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Grasp_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Request & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Request & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Grasp_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <cstddef>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
// already included above
// #include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Grasp_Response & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Grasp_Response & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Grasp_Response & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Grasp_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Response & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Response & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Grasp_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <cstddef>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
// already included above
// #include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Grasp_Event & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Grasp_Event & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Grasp_Event & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Grasp_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Event & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Grasp_Event & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Grasp_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Event)();
#ifdef __cplusplus
}
#endif
#include "rmw/types.h"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Grasp)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_

58
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__rosidl_typesupport_introspection_c.h Normal file
View File

@@ -0,0 +1,58 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__rosidl_typesupport_introspection_c.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)();
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)();
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Event)();
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_

88
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__rosidl_typesupport_introspection_cpp.hpp Normal file
View File

@@ -0,0 +1,88 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__rosidl_typesupport_introspection_cpp.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Event)();
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_

101
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__struct.h Normal file
View File

@@ -0,0 +1,101 @@
// generated from rosidl_generator_c/resource/idl__struct.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
// Constants defined in the message
/// Struct defined in srv/Grasp in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Request
{
float width;
float speed;
float force;
float epsilon_inner;
float epsilon_outer;
} sas_robot_driver_franka_interfaces__srv__Grasp_Request;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Grasp_Request.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence
{
sas_robot_driver_franka_interfaces__srv__Grasp_Request * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence;
// Constants defined in the message
/// Struct defined in srv/Grasp in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Response
{
bool success;
} sas_robot_driver_franka_interfaces__srv__Grasp_Response;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Grasp_Response.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence
{
sas_robot_driver_franka_interfaces__srv__Grasp_Response * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence;
// Constants defined in the message
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__struct.h"
// constants for array fields with an upper bound
// request
enum
{
sas_robot_driver_franka_interfaces__srv__Grasp_Event__request__MAX_SIZE = 1
};
// response
enum
{
sas_robot_driver_franka_interfaces__srv__Grasp_Event__response__MAX_SIZE = 1
};
/// Struct defined in srv/Grasp in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Event
{
service_msgs__msg__ServiceEventInfo info;
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence request;
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence response;
} sas_robot_driver_franka_interfaces__srv__Grasp_Event;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Grasp_Event.
typedef struct sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence
{
sas_robot_driver_franka_interfaces__srv__Grasp_Event * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Grasp_Event__Sequence;
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_H_

456
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__struct.hpp Normal file
View File

@@ -0,0 +1,456 @@
// generated from rosidl_generator_cpp/resource/idl__struct.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_HPP_
#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <vector>
#include "rosidl_runtime_cpp/bounded_vector.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Request __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Request __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Grasp_Request_
{
using Type = Grasp_Request_<ContainerAllocator>;
explicit Grasp_Request_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->speed = 0.0f;
this->force = 0.0f;
this->epsilon_inner = 0.0f;
this->epsilon_outer = 0.0f;
}
}
explicit Grasp_Request_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
(void)_alloc;
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->speed = 0.0f;
this->force = 0.0f;
this->epsilon_inner = 0.0f;
this->epsilon_outer = 0.0f;
}
}
// field types and members
using _width_type =
float;
_width_type width;
using _speed_type =
float;
_speed_type speed;
using _force_type =
float;
_force_type force;
using _epsilon_inner_type =
float;
_epsilon_inner_type epsilon_inner;
using _epsilon_outer_type =
float;
_epsilon_outer_type epsilon_outer;
// setters for named parameter idiom
Type & set__width(
const float & _arg)
{
this->width = _arg;
return *this;
}
Type & set__speed(
const float & _arg)
{
this->speed = _arg;
return *this;
}
Type & set__force(
const float & _arg)
{
this->force = _arg;
return *this;
}
Type & set__epsilon_inner(
const float & _arg)
{
this->epsilon_inner = _arg;
return *this;
}
Type & set__epsilon_outer(
const float & _arg)
{
this->epsilon_outer = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Request
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Request
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Grasp_Request_ & other) const
{
if (this->width != other.width) {
return false;
}
if (this->speed != other.speed) {
return false;
}
if (this->force != other.force) {
return false;
}
if (this->epsilon_inner != other.epsilon_inner) {
return false;
}
if (this->epsilon_outer != other.epsilon_outer) {
return false;
}
return true;
}
bool operator!=(const Grasp_Request_ & other) const
{
return !this->operator==(other);
}
}; // struct Grasp_Request_
// alias to use template instance with default allocator
using Grasp_Request =
sas_robot_driver_franka_interfaces::srv::Grasp_Request_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Response __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Response __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Grasp_Response_
{
using Type = Grasp_Response_<ContainerAllocator>;
explicit Grasp_Response_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->success = false;
}
}
explicit Grasp_Response_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
(void)_alloc;
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->success = false;
}
}
// field types and members
using _success_type =
bool;
_success_type success;
// setters for named parameter idiom
Type & set__success(
const bool & _arg)
{
this->success = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Response
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Response
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Grasp_Response_ & other) const
{
if (this->success != other.success) {
return false;
}
return true;
}
bool operator!=(const Grasp_Response_ & other) const
{
return !this->operator==(other);
}
}; // struct Grasp_Response_
// alias to use template instance with default allocator
using Grasp_Response =
sas_robot_driver_franka_interfaces::srv::Grasp_Response_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__struct.hpp"
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Event __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Event __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Grasp_Event_
{
using Type = Grasp_Event_<ContainerAllocator>;
explicit Grasp_Event_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
: info(_init)
{
(void)_init;
}
explicit Grasp_Event_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
: info(_alloc, _init)
{
(void)_init;
}
// field types and members
using _info_type =
service_msgs::msg::ServiceEventInfo_<ContainerAllocator>;
_info_type info;
using _request_type =
rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>>;
_request_type request;
using _response_type =
rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>>;
_response_type response;
// setters for named parameter idiom
Type & set__info(
const service_msgs::msg::ServiceEventInfo_<ContainerAllocator> & _arg)
{
this->info = _arg;
return *this;
}
Type & set__request(
const rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Grasp_Request_<ContainerAllocator>>> & _arg)
{
this->request = _arg;
return *this;
}
Type & set__response(
const rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Grasp_Response_<ContainerAllocator>>> & _arg)
{
this->response = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Event
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Grasp_Event
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Grasp_Event_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Grasp_Event_ & other) const
{
if (this->info != other.info) {
return false;
}
if (this->request != other.request) {
return false;
}
if (this->response != other.response) {
return false;
}
return true;
}
bool operator!=(const Grasp_Event_ & other) const
{
return !this->operator==(other);
}
}; // struct Grasp_Event_
// alias to use template instance with default allocator
using Grasp_Event =
sas_robot_driver_franka_interfaces::srv::Grasp_Event_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
struct Grasp
{
using Request = sas_robot_driver_franka_interfaces::srv::Grasp_Request;
using Response = sas_robot_driver_franka_interfaces::srv::Grasp_Response;
using Event = sas_robot_driver_franka_interfaces::srv::Grasp_Event;
};
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__STRUCT_HPP_

496
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__traits.hpp Normal file
View File

@@ -0,0 +1,496 @@
// generated from rosidl_generator_cpp/resource/idl__traits.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TRAITS_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TRAITS_HPP_
#include <stdint.h>
#include <sstream>
#include <string>
#include <type_traits>
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#include "rosidl_runtime_cpp/traits.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Grasp_Request & msg,
std::ostream & out)
{
out << "{";
// member: width
{
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << ", ";
}
// member: speed
{
out << "speed: ";
rosidl_generator_traits::value_to_yaml(msg.speed, out);
out << ", ";
}
// member: force
{
out << "force: ";
rosidl_generator_traits::value_to_yaml(msg.force, out);
out << ", ";
}
// member: epsilon_inner
{
out << "epsilon_inner: ";
rosidl_generator_traits::value_to_yaml(msg.epsilon_inner, out);
out << ", ";
}
// member: epsilon_outer
{
out << "epsilon_outer: ";
rosidl_generator_traits::value_to_yaml(msg.epsilon_outer, out);
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Grasp_Request & msg,
std::ostream & out, size_t indentation = 0)
{
// member: width
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << "\n";
}
// member: speed
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "speed: ";
rosidl_generator_traits::value_to_yaml(msg.speed, out);
out << "\n";
}
// member: force
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "force: ";
rosidl_generator_traits::value_to_yaml(msg.force, out);
out << "\n";
}
// member: epsilon_inner
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "epsilon_inner: ";
rosidl_generator_traits::value_to_yaml(msg.epsilon_inner, out);
out << "\n";
}
// member: epsilon_outer
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "epsilon_outer: ";
rosidl_generator_traits::value_to_yaml(msg.epsilon_outer, out);
out << "\n";
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Grasp_Request & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Grasp_Request & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Grasp_Request>()
{
return "sas_robot_driver_franka_interfaces::srv::Grasp_Request";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Grasp_Request>()
{
return "sas_robot_driver_franka_interfaces/srv/Grasp_Request";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp_Request>
: std::integral_constant<bool, true> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Request>
: std::integral_constant<bool, true> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Grasp_Request>
: std::true_type {};
} // namespace rosidl_generator_traits
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Grasp_Response & msg,
std::ostream & out)
{
out << "{";
// member: success
{
out << "success: ";
rosidl_generator_traits::value_to_yaml(msg.success, out);
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Grasp_Response & msg,
std::ostream & out, size_t indentation = 0)
{
// member: success
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "success: ";
rosidl_generator_traits::value_to_yaml(msg.success, out);
out << "\n";
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Grasp_Response & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Grasp_Response & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Grasp_Response & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Grasp_Response>()
{
return "sas_robot_driver_franka_interfaces::srv::Grasp_Response";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Grasp_Response>()
{
return "sas_robot_driver_franka_interfaces/srv/Grasp_Response";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp_Response>
: std::integral_constant<bool, true> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Response>
: std::integral_constant<bool, true> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Grasp_Response>
: std::true_type {};
} // namespace rosidl_generator_traits
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__traits.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Grasp_Event & msg,
std::ostream & out)
{
out << "{";
// member: info
{
out << "info: ";
to_flow_style_yaml(msg.info, out);
out << ", ";
}
// member: request
{
if (msg.request.size() == 0) {
out << "request: []";
} else {
out << "request: [";
size_t pending_items = msg.request.size();
for (auto item : msg.request) {
to_flow_style_yaml(item, out);
if (--pending_items > 0) {
out << ", ";
}
}
out << "]";
}
out << ", ";
}
// member: response
{
if (msg.response.size() == 0) {
out << "response: []";
} else {
out << "response: [";
size_t pending_items = msg.response.size();
for (auto item : msg.response) {
to_flow_style_yaml(item, out);
if (--pending_items > 0) {
out << ", ";
}
}
out << "]";
}
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Grasp_Event & msg,
std::ostream & out, size_t indentation = 0)
{
// member: info
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "info:\n";
to_block_style_yaml(msg.info, out, indentation + 2);
}
// member: request
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
if (msg.request.size() == 0) {
out << "request: []\n";
} else {
out << "request:\n";
for (auto item : msg.request) {
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "-\n";
to_block_style_yaml(item, out, indentation + 2);
}
}
}
// member: response
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
if (msg.response.size() == 0) {
out << "response: []\n";
} else {
out << "response:\n";
for (auto item : msg.response) {
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "-\n";
to_block_style_yaml(item, out, indentation + 2);
}
}
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Grasp_Event & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Grasp_Event & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Grasp_Event & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Grasp_Event>()
{
return "sas_robot_driver_franka_interfaces::srv::Grasp_Event";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Grasp_Event>()
{
return "sas_robot_driver_franka_interfaces/srv/Grasp_Event";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp_Event>
: std::integral_constant<bool, false> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Event>
: std::integral_constant<bool, has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Request>::value && has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Response>::value && has_bounded_size<service_msgs::msg::ServiceEventInfo>::value> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Grasp_Event>
: std::true_type {};
} // namespace rosidl_generator_traits
namespace rosidl_generator_traits
{
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Grasp>()
{
return "sas_robot_driver_franka_interfaces::srv::Grasp";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Grasp>()
{
return "sas_robot_driver_franka_interfaces/srv/Grasp";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp>
: std::integral_constant<
bool,
has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp_Request>::value &&
has_fixed_size<sas_robot_driver_franka_interfaces::srv::Grasp_Response>::value
>
{
};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp>
: std::integral_constant<
bool,
has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Request>::value &&
has_bounded_size<sas_robot_driver_franka_interfaces::srv::Grasp_Response>::value
>
{
};
template<>
struct is_service<sas_robot_driver_franka_interfaces::srv::Grasp>
: std::true_type
{
};
template<>
struct is_service_request<sas_robot_driver_franka_interfaces::srv::Grasp_Request>
: std::true_type
{
};
template<>
struct is_service_response<sas_robot_driver_franka_interfaces::srv::Grasp_Response>
: std::true_type
{
};
} // namespace rosidl_generator_traits
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TRAITS_HPP_

597
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__type_support.c Normal file
View File

@@ -0,0 +1,597 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__type_support.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#include <stddef.h>
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__rosidl_typesupport_introspection_c.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
#include "rosidl_typesupport_introspection_c/field_types.h"
#include "rosidl_typesupport_introspection_c/identifier.h"
#include "rosidl_typesupport_introspection_c/message_introspection.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Grasp_Request__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Request__fini(message_memory);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_member_array[5] = {
{
"width", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Request, width), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"speed", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Request, speed), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"force", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Request, force), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"epsilon_inner", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Request, epsilon_inner), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"epsilon_outer", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Request, epsilon_outer), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Grasp_Request", // message name
5, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Request),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)() {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__rosidl_typesupport_introspection_c.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "rosidl_typesupport_introspection_c/field_types.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
// already included above
// #include "rosidl_typesupport_introspection_c/message_introspection.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Grasp_Response__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Response__fini(message_memory);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_member_array[1] = {
{
"success", // name
rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Response, success), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Grasp_Response", // message name
1, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Response),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)() {
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__rosidl_typesupport_introspection_c.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "rosidl_typesupport_introspection_c/field_types.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
// already included above
// #include "rosidl_typesupport_introspection_c/message_introspection.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
// Include directives for member types
// Member `info`
#include "service_msgs/msg/service_event_info.h"
// Member `info`
#include "service_msgs/msg/detail/service_event_info__rosidl_typesupport_introspection_c.h"
// Member `request`
// Member `response`
#include "sas_robot_driver_franka_interfaces/srv/grasp.h"
// Member `request`
// Member `response`
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__rosidl_typesupport_introspection_c.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Grasp_Event__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Event__fini(message_memory);
}
size_t sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__size_function__Grasp_Event__request(
const void * untyped_member)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *)(untyped_member);
return member->size;
}
const void * sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__request(
const void * untyped_member, size_t index)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *)(untyped_member);
return &member->data[index];
}
void * sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__request(
void * untyped_member, size_t index)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *)(untyped_member);
return &member->data[index];
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__fetch_function__Grasp_Event__request(
const void * untyped_member, size_t index, void * untyped_value)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * item =
((const sas_robot_driver_franka_interfaces__srv__Grasp_Request *)
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__request(untyped_member, index));
sas_robot_driver_franka_interfaces__srv__Grasp_Request * value =
(sas_robot_driver_franka_interfaces__srv__Grasp_Request *)(untyped_value);
*value = *item;
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__assign_function__Grasp_Event__request(
void * untyped_member, size_t index, const void * untyped_value)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Request * item =
((sas_robot_driver_franka_interfaces__srv__Grasp_Request *)
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__request(untyped_member, index));
const sas_robot_driver_franka_interfaces__srv__Grasp_Request * value =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Request *)(untyped_value);
*item = *value;
}
bool sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__resize_function__Grasp_Event__request(
void * untyped_member, size_t size)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence *)(untyped_member);
sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__fini(member);
return sas_robot_driver_franka_interfaces__srv__Grasp_Request__Sequence__init(member, size);
}
size_t sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__size_function__Grasp_Event__response(
const void * untyped_member)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *)(untyped_member);
return member->size;
}
const void * sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__response(
const void * untyped_member, size_t index)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *)(untyped_member);
return &member->data[index];
}
void * sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__response(
void * untyped_member, size_t index)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *)(untyped_member);
return &member->data[index];
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__fetch_function__Grasp_Event__response(
const void * untyped_member, size_t index, void * untyped_value)
{
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * item =
((const sas_robot_driver_franka_interfaces__srv__Grasp_Response *)
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__response(untyped_member, index));
sas_robot_driver_franka_interfaces__srv__Grasp_Response * value =
(sas_robot_driver_franka_interfaces__srv__Grasp_Response *)(untyped_value);
*value = *item;
}
void sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__assign_function__Grasp_Event__response(
void * untyped_member, size_t index, const void * untyped_value)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Response * item =
((sas_robot_driver_franka_interfaces__srv__Grasp_Response *)
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__response(untyped_member, index));
const sas_robot_driver_franka_interfaces__srv__Grasp_Response * value =
(const sas_robot_driver_franka_interfaces__srv__Grasp_Response *)(untyped_value);
*item = *value;
}
bool sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__resize_function__Grasp_Event__response(
void * untyped_member, size_t size)
{
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence *)(untyped_member);
sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__fini(member);
return sas_robot_driver_franka_interfaces__srv__Grasp_Response__Sequence__init(member, size);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_member_array[3] = {
{
"info", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Event, info), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"request", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Event, request), // bytes offset in struct
NULL, // default value
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__size_function__Grasp_Event__request, // size() function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__request, // get_const(index) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__request, // get(index) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__fetch_function__Grasp_Event__request, // fetch(index, &value) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__assign_function__Grasp_Event__request, // assign(index, value) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__resize_function__Grasp_Event__request // resize(index) function pointer
},
{
"response", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Grasp_Event, response), // bytes offset in struct
NULL, // default value
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__size_function__Grasp_Event__response, // size() function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_const_function__Grasp_Event__response, // get_const(index) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__get_function__Grasp_Event__response, // get(index) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__fetch_function__Grasp_Event__response, // fetch(index, &value) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__assign_function__Grasp_Event__response, // assign(index, value) function pointer
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__resize_function__Grasp_Event__response // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Grasp_Event", // message name
3, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Grasp_Event),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Event)() {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_member_array[0].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, service_msgs, msg, ServiceEventInfo)();
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_member_array[1].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)();
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_member_array[2].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)();
if (!sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__rosidl_typesupport_introspection_c.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
#include "rosidl_typesupport_introspection_c/service_introspection.h"
// this is intentionally not const to allow initialization later to prevent an initialization race
static rosidl_typesupport_introspection_c__ServiceMembers sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_members = {
"sas_robot_driver_franka_interfaces__srv", // service namespace
"Grasp", // service name
// the following fields are initialized below on first access
NULL, // request message
// sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle,
NULL, // response message
// sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle
NULL // event_message
// sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle
};
static rosidl_service_type_support_t sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_members,
get_service_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__rosidl_typesupport_introspection_c__Grasp_Request_message_type_support_handle,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__rosidl_typesupport_introspection_c__Grasp_Response_message_type_support_handle,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__rosidl_typesupport_introspection_c__Grasp_Event_message_type_support_handle,
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_CREATE_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp
),
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_DESTROY_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp
),
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description_sources,
};
// Forward declaration of message type support functions for service members
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)(void);
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)(void);
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Event)(void);
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp)(void) {
if (!sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
rosidl_typesupport_introspection_c__ServiceMembers * service_members =
(rosidl_typesupport_introspection_c__ServiceMembers *)sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_type_support_handle.data;
if (!service_members->request_members_) {
service_members->request_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Request)()->data;
}
if (!service_members->response_members_) {
service_members->response_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Response)()->data;
}
if (!service_members->event_members_) {
service_members->event_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Grasp_Event)()->data;
}
return &sas_robot_driver_franka_interfaces__srv__detail__grasp__rosidl_typesupport_introspection_c__Grasp_service_type_support_handle;
}

692
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__type_support.cpp Normal file
View File

@@ -0,0 +1,692 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__type_support.cpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#include "array"
#include "cstddef"
#include "string"
#include "vector"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#include "rosidl_typesupport_introspection_cpp/field_types.hpp"
#include "rosidl_typesupport_introspection_cpp/identifier.hpp"
#include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
#include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Grasp_Request_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Grasp_Request(_init);
}
void Grasp_Request_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Request *>(message_memory);
typed_message->~Grasp_Request();
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Grasp_Request_message_member_array[5] = {
{
"width", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Request, width), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"speed", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Request, speed), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"force", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Request, force), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"epsilon_inner", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Request, epsilon_inner), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"epsilon_outer", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Request, epsilon_outer), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Grasp_Request_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Grasp_Request", // message name
5, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Grasp_Request),
false, // has_any_key_member_
Grasp_Request_message_member_array, // message members
Grasp_Request_init_function, // function to initialize message memory (memory has to be allocated)
Grasp_Request_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Grasp_Request_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Grasp_Request_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Request__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Request>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Request_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Request)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Request_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "array"
// already included above
// #include "cstddef"
// already included above
// #include "string"
// already included above
// #include "vector"
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/field_types.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Grasp_Response_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Grasp_Response(_init);
}
void Grasp_Response_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Response *>(message_memory);
typed_message->~Grasp_Response();
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Grasp_Response_message_member_array[1] = {
{
"success", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Response, success), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Grasp_Response_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Grasp_Response", // message name
1, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Grasp_Response),
false, // has_any_key_member_
Grasp_Response_message_member_array, // message members
Grasp_Response_init_function, // function to initialize message memory (memory has to be allocated)
Grasp_Response_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Grasp_Response_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Grasp_Response_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Response__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Response>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Response_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Response)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Response_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "array"
// already included above
// #include "cstddef"
// already included above
// #include "string"
// already included above
// #include "vector"
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/field_types.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Grasp_Event_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Grasp_Event(_init);
}
void Grasp_Event_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Event *>(message_memory);
typed_message->~Grasp_Event();
}
size_t size_function__Grasp_Event__request(const void * untyped_member)
{
const auto * member = reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Request> *>(untyped_member);
return member->size();
}
const void * get_const_function__Grasp_Event__request(const void * untyped_member, size_t index)
{
const auto & member =
*reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Request> *>(untyped_member);
return &member[index];
}
void * get_function__Grasp_Event__request(void * untyped_member, size_t index)
{
auto & member =
*reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Request> *>(untyped_member);
return &member[index];
}
void fetch_function__Grasp_Event__request(
const void * untyped_member, size_t index, void * untyped_value)
{
const auto & item = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Grasp_Request *>(
get_const_function__Grasp_Event__request(untyped_member, index));
auto & value = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Request *>(untyped_value);
value = item;
}
void assign_function__Grasp_Event__request(
void * untyped_member, size_t index, const void * untyped_value)
{
auto & item = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Request *>(
get_function__Grasp_Event__request(untyped_member, index));
const auto & value = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Grasp_Request *>(untyped_value);
item = value;
}
void resize_function__Grasp_Event__request(void * untyped_member, size_t size)
{
auto * member =
reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Request> *>(untyped_member);
member->resize(size);
}
size_t size_function__Grasp_Event__response(const void * untyped_member)
{
const auto * member = reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Response> *>(untyped_member);
return member->size();
}
const void * get_const_function__Grasp_Event__response(const void * untyped_member, size_t index)
{
const auto & member =
*reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Response> *>(untyped_member);
return &member[index];
}
void * get_function__Grasp_Event__response(void * untyped_member, size_t index)
{
auto & member =
*reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Response> *>(untyped_member);
return &member[index];
}
void fetch_function__Grasp_Event__response(
const void * untyped_member, size_t index, void * untyped_value)
{
const auto & item = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Grasp_Response *>(
get_const_function__Grasp_Event__response(untyped_member, index));
auto & value = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Response *>(untyped_value);
value = item;
}
void assign_function__Grasp_Event__response(
void * untyped_member, size_t index, const void * untyped_value)
{
auto & item = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Grasp_Response *>(
get_function__Grasp_Event__response(untyped_member, index));
const auto & value = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Grasp_Response *>(untyped_value);
item = value;
}
void resize_function__Grasp_Event__response(void * untyped_member, size_t size)
{
auto * member =
reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Grasp_Response> *>(untyped_member);
member->resize(size);
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Grasp_Event_message_member_array[3] = {
{
"info", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<service_msgs::msg::ServiceEventInfo>(), // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Event, info), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"request", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Request>(), // members of sub message
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Event, request), // bytes offset in struct
nullptr, // default value
size_function__Grasp_Event__request, // size() function pointer
get_const_function__Grasp_Event__request, // get_const(index) function pointer
get_function__Grasp_Event__request, // get(index) function pointer
fetch_function__Grasp_Event__request, // fetch(index, &value) function pointer
assign_function__Grasp_Event__request, // assign(index, value) function pointer
resize_function__Grasp_Event__request // resize(index) function pointer
},
{
"response", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Response>(), // members of sub message
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Grasp_Event, response), // bytes offset in struct
nullptr, // default value
size_function__Grasp_Event__response, // size() function pointer
get_const_function__Grasp_Event__response, // get_const(index) function pointer
get_function__Grasp_Event__response, // get(index) function pointer
fetch_function__Grasp_Event__response, // fetch(index, &value) function pointer
assign_function__Grasp_Event__response, // assign(index, value) function pointer
resize_function__Grasp_Event__response // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Grasp_Event_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Grasp_Event", // message name
3, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Grasp_Event),
false, // has_any_key_member_
Grasp_Event_message_member_array, // message members
Grasp_Event_init_function, // function to initialize message memory (memory has to be allocated)
Grasp_Event_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Grasp_Event_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Grasp_Event_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp_Event__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Event>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Event_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp_Event)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_Event_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
#include "rosidl_typesupport_introspection_cpp/service_introspection.hpp"
#include "rosidl_typesupport_introspection_cpp/service_type_support_decl.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
// this is intentionally not const to allow initialization later to prevent an initialization race
static ::rosidl_typesupport_introspection_cpp::ServiceMembers Grasp_service_members = {
"sas_robot_driver_franka_interfaces::srv", // service namespace
"Grasp", // service name
// the following fields are initialized below on first access
// see get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp>()
nullptr, // request message
nullptr, // response message
nullptr, // event message
};
static const rosidl_service_type_support_t Grasp_service_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Grasp_service_members,
get_service_typesupport_handle_function,
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Request>(),
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Response>(),
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp_Event>(),
&::rosidl_typesupport_cpp::service_create_event_message<sas_robot_driver_franka_interfaces::srv::Grasp>,
&::rosidl_typesupport_cpp::service_destroy_event_message<sas_robot_driver_franka_interfaces::srv::Grasp>,
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Grasp__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp>()
{
// get a handle to the value to be returned
auto service_type_support =
&::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Grasp_service_type_support_handle;
// get a non-const and properly typed version of the data void *
auto service_members = const_cast<::rosidl_typesupport_introspection_cpp::ServiceMembers *>(
static_cast<const ::rosidl_typesupport_introspection_cpp::ServiceMembers *>(
service_type_support->data));
// make sure all of the service_members are initialized
// if they are not, initialize them
if (
service_members->request_members_ == nullptr ||
service_members->response_members_ == nullptr ||
service_members->event_members_ == nullptr)
{
// initialize the request_members_ with the static function from the external library
service_members->request_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Grasp_Request
>()->data
);
// initialize the response_members_ with the static function from the external library
service_members->response_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Grasp_Response
>()->data
);
// initialize the event_members_ with the static function from the external library
service_members->event_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Grasp_Event
>()->data
);
}
// finally return the properly initialized service_type_support handle
return service_type_support;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Grasp)() {
return ::rosidl_typesupport_introspection_cpp::get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Grasp>();
}
#ifdef __cplusplus
}
#endif

100
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__type_support.h Normal file
View File

@@ -0,0 +1,100 @@
// generated from rosidl_generator_c/resource/idl__type_support.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/grasp.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_H_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp_Request
)(void);
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp_Response
)(void);
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp_Event
)(void);
#include "rosidl_runtime_c/service_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp
)(void);
// Forward declare the function to create a service event message for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_CREATE_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp
)(
const rosidl_service_introspection_info_t * info,
rcutils_allocator_t * allocator,
const void * request_message,
const void * response_message);
// Forward declare the function to destroy a service event message for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_DESTROY_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Grasp
)(
void * event_msg,
rcutils_allocator_t * allocator);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_H_

71
include/sas_robot_driver_franka/interfaces/local/srv/detail/grasp__type_support.hpp Normal file
View File

@@ -0,0 +1,71 @@
// generated from rosidl_generator_cpp/resource/idl__type_support.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_HPP_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_cpp__visibility_control.hpp"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Grasp
)();
#ifdef __cplusplus
}
#endif
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Grasp_Request
)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Grasp_Response
)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__GRASP__TYPE_SUPPORT_HPP_

191
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__builder.hpp Normal file
View File

@@ -0,0 +1,191 @@
// generated from rosidl_generator_cpp/resource/idl__builder.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__BUILDER_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__BUILDER_HPP_
#include <algorithm>
#include <utility>
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Move_Request_speed
{
public:
explicit Init_Move_Request_speed(::sas_robot_driver_franka_interfaces::srv::Move_Request & msg)
: msg_(msg)
{}
::sas_robot_driver_franka_interfaces::srv::Move_Request speed(::sas_robot_driver_franka_interfaces::srv::Move_Request::_speed_type arg)
{
msg_.speed = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Request msg_;
};
class Init_Move_Request_width
{
public:
Init_Move_Request_width()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
Init_Move_Request_speed width(::sas_robot_driver_franka_interfaces::srv::Move_Request::_width_type arg)
{
msg_.width = std::move(arg);
return Init_Move_Request_speed(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Request msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Move_Request>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Move_Request_width();
}
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Move_Response_success
{
public:
Init_Move_Response_success()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
::sas_robot_driver_franka_interfaces::srv::Move_Response success(::sas_robot_driver_franka_interfaces::srv::Move_Response::_success_type arg)
{
msg_.success = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Response msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Move_Response>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Move_Response_success();
}
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace builder
{
class Init_Move_Event_response
{
public:
explicit Init_Move_Event_response(::sas_robot_driver_franka_interfaces::srv::Move_Event & msg)
: msg_(msg)
{}
::sas_robot_driver_franka_interfaces::srv::Move_Event response(::sas_robot_driver_franka_interfaces::srv::Move_Event::_response_type arg)
{
msg_.response = std::move(arg);
return std::move(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Event msg_;
};
class Init_Move_Event_request
{
public:
explicit Init_Move_Event_request(::sas_robot_driver_franka_interfaces::srv::Move_Event & msg)
: msg_(msg)
{}
Init_Move_Event_response request(::sas_robot_driver_franka_interfaces::srv::Move_Event::_request_type arg)
{
msg_.request = std::move(arg);
return Init_Move_Event_response(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Event msg_;
};
class Init_Move_Event_info
{
public:
Init_Move_Event_info()
: msg_(::rosidl_runtime_cpp::MessageInitialization::SKIP)
{}
Init_Move_Event_request info(::sas_robot_driver_franka_interfaces::srv::Move_Event::_info_type arg)
{
msg_.info = std::move(arg);
return Init_Move_Event_request(msg_);
}
private:
::sas_robot_driver_franka_interfaces::srv::Move_Event msg_;
};
} // namespace builder
} // namespace srv
template<typename MessageType>
auto build();
template<>
inline
auto build<::sas_robot_driver_franka_interfaces::srv::Move_Event>()
{
return sas_robot_driver_franka_interfaces::srv::builder::Init_Move_Event_info();
}
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__BUILDER_HPP_

474
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__description.c Normal file
View File

@@ -0,0 +1,474 @@
// generated from rosidl_generator_c/resource/idl__description.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move__get_type_hash(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x76, 0xa3, 0xec, 0xbc, 0x8e, 0x93, 0x8b, 0xda,
0x53, 0x19, 0xe4, 0x53, 0x99, 0xab, 0xd8, 0x56,
0xe1, 0xd9, 0x5b, 0x16, 0x89, 0xa1, 0xdd, 0x2c,
0x90, 0xff, 0x8d, 0x05, 0x04, 0x9f, 0xbc, 0x61,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x28, 0xf2, 0x7b, 0x10, 0x36, 0xba, 0x86, 0x14,
0x9b, 0xf5, 0xe1, 0xa9, 0x4a, 0xe6, 0xeb, 0xe4,
0x52, 0xec, 0x8c, 0xb2, 0xd0, 0x1c, 0xa7, 0x1a,
0xda, 0x65, 0x18, 0xe8, 0x7f, 0x77, 0xc1, 0x03,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x60, 0x1f, 0x58, 0x97, 0xc3, 0xce, 0xdb, 0xd6,
0x0d, 0x5a, 0xc9, 0xa7, 0xef, 0xc5, 0xec, 0x80,
0x07, 0xbb, 0x38, 0x09, 0xad, 0x7e, 0x9a, 0x3f,
0xda, 0xef, 0x0e, 0x05, 0xf8, 0xcc, 0xea, 0x22,
}};
return &hash;
}
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_hash(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_type_hash_t hash = {1, {
0x36, 0x9e, 0x09, 0xe2, 0xc6, 0x51, 0x16, 0x17,
0xf2, 0x50, 0xce, 0xef, 0x73, 0x77, 0xce, 0xd0,
0xd7, 0xb6, 0x6d, 0x71, 0xbf, 0xb3, 0x6c, 0xec,
0xc7, 0xc9, 0x82, 0xbe, 0x68, 0xc6, 0xf8, 0x92,
}};
return &hash;
}
#include <assert.h>
#include <string.h>
// Include directives for referenced types
#include "service_msgs/msg/detail/service_event_info__functions.h"
#include "builtin_interfaces/msg/detail/time__functions.h"
// Hashes for external referenced types
#ifndef NDEBUG
static const rosidl_type_hash_t builtin_interfaces__msg__Time__EXPECTED_HASH = {1, {
0xb1, 0x06, 0x23, 0x5e, 0x25, 0xa4, 0xc5, 0xed,
0x35, 0x09, 0x8a, 0xa0, 0xa6, 0x1a, 0x3e, 0xe9,
0xc9, 0xb1, 0x8d, 0x19, 0x7f, 0x39, 0x8b, 0x0e,
0x42, 0x06, 0xce, 0xa9, 0xac, 0xf9, 0xc1, 0x97,
}};
static const rosidl_type_hash_t service_msgs__msg__ServiceEventInfo__EXPECTED_HASH = {1, {
0x41, 0xbc, 0xbb, 0xe0, 0x7a, 0x75, 0xc9, 0xb5,
0x2b, 0xc9, 0x6b, 0xfd, 0x5c, 0x24, 0xd7, 0xf0,
0xfc, 0x0a, 0x08, 0xc0, 0xcb, 0x79, 0x21, 0xb3,
0x37, 0x3c, 0x57, 0x32, 0x34, 0x5a, 0x6f, 0x45,
}};
#endif
static char sas_robot_driver_franka_interfaces__srv__Move__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Move";
static char builtin_interfaces__msg__Time__TYPE_NAME[] = "builtin_interfaces/msg/Time";
static char sas_robot_driver_franka_interfaces__srv__Move_Event__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Move_Event";
static char sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Move_Request";
static char sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME[] = "sas_robot_driver_franka_interfaces/srv/Move_Response";
static char service_msgs__msg__ServiceEventInfo__TYPE_NAME[] = "service_msgs/msg/ServiceEventInfo";
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__request_message[] = "request_message";
static char sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__response_message[] = "response_message";
static char sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__event_message[] = "event_message";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Move__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__request_message, 15, 15},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__response_message, 16, 16},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move__FIELD_NAME__event_message, 13, 13},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{sas_robot_driver_franka_interfaces__srv__Move_Event__TYPE_NAME, 49, 49},
},
{NULL, 0, 0},
},
};
static rosidl_runtime_c__type_description__IndividualTypeDescription sas_robot_driver_franka_interfaces__srv__Move__REFERENCED_TYPE_DESCRIPTIONS[] = {
{
{builtin_interfaces__msg__Time__TYPE_NAME, 27, 27},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Event__TYPE_NAME, 49, 49},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
{NULL, 0, 0},
},
{
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move__get_type_description(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Move__TYPE_NAME, 43, 43},
{sas_robot_driver_franka_interfaces__srv__Move__FIELDS, 3, 3},
},
{sas_robot_driver_franka_interfaces__srv__Move__REFERENCED_TYPE_DESCRIPTIONS, 5, 5},
};
if (!constructed) {
assert(0 == memcmp(&builtin_interfaces__msg__Time__EXPECTED_HASH, builtin_interfaces__msg__Time__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[0].fields = builtin_interfaces__msg__Time__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[1].fields = sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[2].fields = sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[3].fields = sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description(NULL)->type_description.fields;
assert(0 == memcmp(&service_msgs__msg__ServiceEventInfo__EXPECTED_HASH, service_msgs__msg__ServiceEventInfo__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[4].fields = service_msgs__msg__ServiceEventInfo__get_type_description(NULL)->type_description.fields;
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Move_Request__FIELD_NAME__width[] = "width";
static char sas_robot_driver_franka_interfaces__srv__Move_Request__FIELD_NAME__speed[] = "speed";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Move_Request__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Request__FIELD_NAME__width, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Request__FIELD_NAME__speed, 5, 5},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_FLOAT,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
{sas_robot_driver_franka_interfaces__srv__Move_Request__FIELDS, 2, 2},
},
{NULL, 0, 0},
};
if (!constructed) {
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Move_Response__FIELD_NAME__success[] = "success";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Move_Response__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Response__FIELD_NAME__success, 7, 7},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_BOOLEAN,
0,
0,
{NULL, 0, 0},
},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
{sas_robot_driver_franka_interfaces__srv__Move_Response__FIELDS, 1, 1},
},
{NULL, 0, 0},
};
if (!constructed) {
constructed = true;
}
return &description;
}
// Define type names, field names, and default values
static char sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__info[] = "info";
static char sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__request[] = "request";
static char sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__response[] = "response";
static rosidl_runtime_c__type_description__Field sas_robot_driver_franka_interfaces__srv__Move_Event__FIELDS[] = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__info, 4, 4},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE,
0,
0,
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__request, 7, 7},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE_BOUNDED_SEQUENCE,
1,
0,
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Event__FIELD_NAME__response, 8, 8},
{
rosidl_runtime_c__type_description__FieldType__FIELD_TYPE_NESTED_TYPE_BOUNDED_SEQUENCE,
1,
0,
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
},
{NULL, 0, 0},
},
};
static rosidl_runtime_c__type_description__IndividualTypeDescription sas_robot_driver_franka_interfaces__srv__Move_Event__REFERENCED_TYPE_DESCRIPTIONS[] = {
{
{builtin_interfaces__msg__Time__TYPE_NAME, 27, 27},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
{NULL, 0, 0},
},
{
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
{NULL, 0, 0},
},
{
{service_msgs__msg__ServiceEventInfo__TYPE_NAME, 33, 33},
{NULL, 0, 0},
},
};
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static bool constructed = false;
static const rosidl_runtime_c__type_description__TypeDescription description = {
{
{sas_robot_driver_franka_interfaces__srv__Move_Event__TYPE_NAME, 49, 49},
{sas_robot_driver_franka_interfaces__srv__Move_Event__FIELDS, 3, 3},
},
{sas_robot_driver_franka_interfaces__srv__Move_Event__REFERENCED_TYPE_DESCRIPTIONS, 4, 4},
};
if (!constructed) {
assert(0 == memcmp(&builtin_interfaces__msg__Time__EXPECTED_HASH, builtin_interfaces__msg__Time__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[0].fields = builtin_interfaces__msg__Time__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[1].fields = sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description(NULL)->type_description.fields;
description.referenced_type_descriptions.data[2].fields = sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description(NULL)->type_description.fields;
assert(0 == memcmp(&service_msgs__msg__ServiceEventInfo__EXPECTED_HASH, service_msgs__msg__ServiceEventInfo__get_type_hash(NULL), sizeof(rosidl_type_hash_t)));
description.referenced_type_descriptions.data[3].fields = service_msgs__msg__ServiceEventInfo__get_type_description(NULL)->type_description.fields;
constructed = true;
}
return &description;
}
static char toplevel_type_raw_source[] =
"float32 width\n"
"float32 speed\n"
"---\n"
"bool success";
static char srv_encoding[] = "srv";
static char implicit_encoding[] = "implicit";
// Define all individual source functions
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move__get_individual_type_description_source(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Move__TYPE_NAME, 43, 43},
{srv_encoding, 3, 3},
{toplevel_type_raw_source, 44, 44},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Move_Request__TYPE_NAME, 51, 51},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Move_Response__TYPE_NAME, 52, 52},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static const rosidl_runtime_c__type_description__TypeSource source = {
{sas_robot_driver_franka_interfaces__srv__Move_Event__TYPE_NAME, 49, 49},
{implicit_encoding, 8, 8},
{NULL, 0, 0},
};
return &source;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move__get_type_description_sources(
const rosidl_service_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[6];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 6, 6};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Move__get_individual_type_description_source(NULL),
sources[1] = *builtin_interfaces__msg__Time__get_individual_type_description_source(NULL);
sources[2] = *sas_robot_driver_franka_interfaces__srv__Move_Event__get_individual_type_description_source(NULL);
sources[3] = *sas_robot_driver_franka_interfaces__srv__Move_Request__get_individual_type_description_source(NULL);
sources[4] = *sas_robot_driver_franka_interfaces__srv__Move_Response__get_individual_type_description_source(NULL);
sources[5] = *service_msgs__msg__ServiceEventInfo__get_individual_type_description_source(NULL);
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[1];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 1, 1};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Move_Request__get_individual_type_description_source(NULL),
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[1];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 1, 1};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Move_Response__get_individual_type_description_source(NULL),
constructed = true;
}
return &source_sequence;
}
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description_sources(
const rosidl_message_type_support_t * type_support)
{
(void)type_support;
static rosidl_runtime_c__type_description__TypeSource sources[5];
static const rosidl_runtime_c__type_description__TypeSource__Sequence source_sequence = {sources, 5, 5};
static bool constructed = false;
if (!constructed) {
sources[0] = *sas_robot_driver_franka_interfaces__srv__Move_Event__get_individual_type_description_source(NULL),
sources[1] = *builtin_interfaces__msg__Time__get_individual_type_description_source(NULL);
sources[2] = *sas_robot_driver_franka_interfaces__srv__Move_Request__get_individual_type_description_source(NULL);
sources[3] = *sas_robot_driver_franka_interfaces__srv__Move_Response__get_individual_type_description_source(NULL);
sources[4] = *service_msgs__msg__ServiceEventInfo__get_individual_type_description_source(NULL);
constructed = true;
}
return &source_sequence;
}

750
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__functions.c Normal file
View File

@@ -0,0 +1,750 @@
// generated from rosidl_generator_c/resource/idl__functions.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "rcutils/allocator.h"
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__init(sas_robot_driver_franka_interfaces__srv__Move_Request * msg)
{
if (!msg) {
return false;
}
// width
// speed
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(sas_robot_driver_franka_interfaces__srv__Move_Request * msg)
{
if (!msg) {
return;
}
// width
// speed
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Request * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Request * rhs)
{
if (!lhs || !rhs) {
return false;
}
// width
if (lhs->width != rhs->width) {
return false;
}
// speed
if (lhs->speed != rhs->speed) {
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Request * input,
sas_robot_driver_franka_interfaces__srv__Move_Request * output)
{
if (!input || !output) {
return false;
}
// width
output->width = input->width;
// speed
output->speed = input->speed;
return true;
}
sas_robot_driver_franka_interfaces__srv__Move_Request *
sas_robot_driver_franka_interfaces__srv__Move_Request__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Request * msg = (sas_robot_driver_franka_interfaces__srv__Move_Request *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request));
bool success = sas_robot_driver_franka_interfaces__srv__Move_Request__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Request__destroy(sas_robot_driver_franka_interfaces__srv__Move_Request * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Request * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Move_Request *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Move_Request__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Request * data =
(sas_robot_driver_franka_interfaces__srv__Move_Request *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__init(sas_robot_driver_franka_interfaces__srv__Move_Response * msg)
{
if (!msg) {
return false;
}
// success
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(sas_robot_driver_franka_interfaces__srv__Move_Response * msg)
{
if (!msg) {
return;
}
// success
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Response * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Response * rhs)
{
if (!lhs || !rhs) {
return false;
}
// success
if (lhs->success != rhs->success) {
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Response * input,
sas_robot_driver_franka_interfaces__srv__Move_Response * output)
{
if (!input || !output) {
return false;
}
// success
output->success = input->success;
return true;
}
sas_robot_driver_franka_interfaces__srv__Move_Response *
sas_robot_driver_franka_interfaces__srv__Move_Response__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Response * msg = (sas_robot_driver_franka_interfaces__srv__Move_Response *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response));
bool success = sas_robot_driver_franka_interfaces__srv__Move_Response__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Response__destroy(sas_robot_driver_franka_interfaces__srv__Move_Response * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Response * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Move_Response *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Move_Response__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Response * data =
(sas_robot_driver_franka_interfaces__srv__Move_Response *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}
// Include directives for member types
// Member `info`
#include "service_msgs/msg/detail/service_event_info__functions.h"
// Member `request`
// Member `response`
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__init(sas_robot_driver_franka_interfaces__srv__Move_Event * msg)
{
if (!msg) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__init(&msg->info)) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(msg);
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init(&msg->request, 0)) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(msg);
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init(&msg->response, 0)) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(msg);
return false;
}
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(sas_robot_driver_franka_interfaces__srv__Move_Event * msg)
{
if (!msg) {
return;
}
// info
service_msgs__msg__ServiceEventInfo__fini(&msg->info);
// request
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini(&msg->request);
// response
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini(&msg->response);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Event * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Event * rhs)
{
if (!lhs || !rhs) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__are_equal(
&(lhs->info), &(rhs->info)))
{
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__are_equal(
&(lhs->request), &(rhs->request)))
{
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__are_equal(
&(lhs->response), &(rhs->response)))
{
return false;
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Event * input,
sas_robot_driver_franka_interfaces__srv__Move_Event * output)
{
if (!input || !output) {
return false;
}
// info
if (!service_msgs__msg__ServiceEventInfo__copy(
&(input->info), &(output->info)))
{
return false;
}
// request
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__copy(
&(input->request), &(output->request)))
{
return false;
}
// response
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__copy(
&(input->response), &(output->response)))
{
return false;
}
return true;
}
sas_robot_driver_franka_interfaces__srv__Move_Event *
sas_robot_driver_franka_interfaces__srv__Move_Event__create(void)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Event * msg = (sas_robot_driver_franka_interfaces__srv__Move_Event *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event));
bool success = sas_robot_driver_franka_interfaces__srv__Move_Event__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Event__destroy(sas_robot_driver_franka_interfaces__srv__Move_Event * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Event * data = NULL;
if (size) {
data = (sas_robot_driver_franka_interfaces__srv__Move_Event *)allocator.zero_allocate(size, sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = sas_robot_driver_franka_interfaces__srv__Move_Event__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array = (sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence *)allocator.allocate(sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Event__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event);
rcutils_allocator_t allocator = rcutils_get_default_allocator();
sas_robot_driver_franka_interfaces__srv__Move_Event * data =
(sas_robot_driver_franka_interfaces__srv__Move_Event *)allocator.reallocate(
output->data, allocation_size, allocator.state);
if (!data) {
return false;
}
// If reallocation succeeded, memory may or may not have been moved
// to fulfill the allocation request, invalidating output->data.
output->data = data;
for (size_t i = output->capacity; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Event__init(&output->data[i])) {
// If initialization of any new item fails, roll back
// all previously initialized items. Existing items
// in output are to be left unmodified.
for (; i-- > output->capacity; ) {
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(&output->data[i]);
}
return false;
}
}
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!sas_robot_driver_franka_interfaces__srv__Move_Event__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}

585
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__functions.h Normal file
View File

@@ -0,0 +1,585 @@
// generated from rosidl_generator_c/resource/idl__functions.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__FUNCTIONS_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__FUNCTIONS_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stdlib.h>
#include "rosidl_runtime_c/action_type_support_struct.h"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_runtime_c/service_type_support_struct.h"
#include "rosidl_runtime_c/type_description/type_description__struct.h"
#include "rosidl_runtime_c/type_description/type_source__struct.h"
#include "rosidl_runtime_c/type_hash.h"
#include "rosidl_runtime_c/visibility_control.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move__get_type_hash(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move__get_type_description(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move__get_individual_type_description_source(
const rosidl_service_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move__get_type_description_sources(
const rosidl_service_type_support_t * type_support);
/// Initialize srv/Move message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Move_Request
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Move_Request__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__init(sas_robot_driver_franka_interfaces__srv__Move_Request * msg);
/// Finalize srv/Move message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(sas_robot_driver_franka_interfaces__srv__Move_Request * msg);
/// Create srv/Move message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Request *
sas_robot_driver_franka_interfaces__srv__Move_Request__create(void);
/// Destroy srv/Move message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Request__destroy(sas_robot_driver_franka_interfaces__srv__Move_Request * msg);
/// Check for srv/Move message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Request * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Request * rhs);
/// Copy a srv/Move message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Request * input,
sas_robot_driver_franka_interfaces__srv__Move_Request * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Move messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array, size_t size);
/// Finalize array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array);
/// Create array of srv/Move messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__create(size_t size);
/// Destroy array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * array);
/// Check for srv/Move message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * rhs);
/// Copy an array of srv/Move messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * output);
/// Initialize srv/Move message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Move_Response
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Move_Response__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__init(sas_robot_driver_franka_interfaces__srv__Move_Response * msg);
/// Finalize srv/Move message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(sas_robot_driver_franka_interfaces__srv__Move_Response * msg);
/// Create srv/Move message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Response *
sas_robot_driver_franka_interfaces__srv__Move_Response__create(void);
/// Destroy srv/Move message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Response__destroy(sas_robot_driver_franka_interfaces__srv__Move_Response * msg);
/// Check for srv/Move message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Response * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Response * rhs);
/// Copy a srv/Move message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Response * input,
sas_robot_driver_franka_interfaces__srv__Move_Response * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Move messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array, size_t size);
/// Finalize array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array);
/// Create array of srv/Move messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__create(size_t size);
/// Destroy array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * array);
/// Check for srv/Move message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * rhs);
/// Copy an array of srv/Move messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * output);
/// Initialize srv/Move message.
/**
* If the init function is called twice for the same message without
* calling fini inbetween previously allocated memory will be leaked.
* \param[in,out] msg The previously allocated message pointer.
* Fields without a default value will not be initialized by this function.
* You might want to call memset(msg, 0, sizeof(
* sas_robot_driver_franka_interfaces__srv__Move_Event
* )) before or use
* sas_robot_driver_franka_interfaces__srv__Move_Event__create()
* to allocate and initialize the message.
* \return true if initialization was successful, otherwise false
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__init(sas_robot_driver_franka_interfaces__srv__Move_Event * msg);
/// Finalize srv/Move message.
/**
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(sas_robot_driver_franka_interfaces__srv__Move_Event * msg);
/// Create srv/Move message.
/**
* It allocates the memory for the message, sets the memory to zero, and
* calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__init().
* \return The pointer to the initialized message if successful,
* otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Event *
sas_robot_driver_franka_interfaces__srv__Move_Event__create(void);
/// Destroy srv/Move message.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__fini()
* and frees the memory of the message.
* \param[in,out] msg The allocated message pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Event__destroy(sas_robot_driver_franka_interfaces__srv__Move_Event * msg);
/// Check for srv/Move message equality.
/**
* \param[in] lhs The message on the left hand size of the equality operator.
* \param[in] rhs The message on the right hand size of the equality operator.
* \return true if messages are equal, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Event * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Event * rhs);
/// Copy a srv/Move message.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source message pointer.
* \param[out] output The target message pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer is null
* or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Event * input,
sas_robot_driver_franka_interfaces__srv__Move_Event * output);
/// Retrieve pointer to the hash of the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_type_hash_t *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_hash(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeDescription *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the single raw source text that defined this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_individual_type_description_source(
const rosidl_message_type_support_t * type_support);
/// Retrieve pointer to the recursive raw sources that defined the description of this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_runtime_c__type_description__TypeSource__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description_sources(
const rosidl_message_type_support_t * type_support);
/// Initialize array of srv/Move messages.
/**
* It allocates the memory for the number of elements and calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__init()
* for each element of the array.
* \param[in,out] array The allocated array pointer.
* \param[in] size The size / capacity of the array.
* \return true if initialization was successful, otherwise false
* If the array pointer is valid and the size is zero it is guaranteed
# to return true.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__init(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array, size_t size);
/// Finalize array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__fini()
* for each element of the array and frees the memory for the number of
* elements.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__fini(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array);
/// Create array of srv/Move messages.
/**
* It allocates the memory for the array and calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__init().
* \param[in] size The size / capacity of the array.
* \return The pointer to the initialized array if successful, otherwise NULL
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence *
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__create(size_t size);
/// Destroy array of srv/Move messages.
/**
* It calls
* sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__fini()
* on the array,
* and frees the memory of the array.
* \param[in,out] array The initialized array pointer.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__destroy(sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * array);
/// Check for srv/Move message array equality.
/**
* \param[in] lhs The message array on the left hand size of the equality operator.
* \param[in] rhs The message array on the right hand size of the equality operator.
* \return true if message arrays are equal in size and content, otherwise false.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__are_equal(const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * lhs, const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * rhs);
/// Copy an array of srv/Move messages.
/**
* This functions performs a deep copy, as opposed to the shallow copy that
* plain assignment yields.
*
* \param[in] input The source array pointer.
* \param[out] output The target array pointer, which must
* have been initialized before calling this function.
* \return true if successful, or false if either pointer
* is null or memory allocation fails.
*/
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence__copy(
const sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * input,
sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence * output);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__FUNCTIONS_H_

210
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__rosidl_typesupport_fastrtps_c.h Normal file
View File

@@ -0,0 +1,210 @@
// generated from rosidl_typesupport_fastrtps_c/resource/idl__rosidl_typesupport_fastrtps_c.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_
#include <stddef.h>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
#include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Move_Request(
const sas_robot_driver_franka_interfaces__srv__Move_Request * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Move_Request(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Move_Request * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Request(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Move_Request(
const sas_robot_driver_franka_interfaces__srv__Move_Request * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Request(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Move_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
// already included above
// #include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Move_Response(
const sas_robot_driver_franka_interfaces__srv__Move_Response * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Move_Response(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Move_Response * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Response(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Move_Response(
const sas_robot_driver_franka_interfaces__srv__Move_Response * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Response(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Move_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
// already included above
// #include "fastcdr/Cdr.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_sas_robot_driver_franka_interfaces__srv__Move_Event(
const sas_robot_driver_franka_interfaces__srv__Move_Event * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_deserialize_sas_robot_driver_franka_interfaces__srv__Move_Event(
eprosima::fastcdr::Cdr &,
sas_robot_driver_franka_interfaces__srv__Move_Event * ros_message);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Event(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_sas_robot_driver_franka_interfaces__srv__Move_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
bool cdr_serialize_key_sas_robot_driver_franka_interfaces__srv__Move_Event(
const sas_robot_driver_franka_interfaces__srv__Move_Event * ros_message,
eprosima::fastcdr::Cdr & cdr);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t get_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Event(
const void * untyped_ros_message,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
size_t max_serialized_size_key_sas_robot_driver_franka_interfaces__srv__Move_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Move_Event)();
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_c__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_fastrtps_c, sas_robot_driver_franka_interfaces, srv, Move)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_C_H_

316
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__rosidl_typesupport_fastrtps_cpp.hpp Normal file
View File

@@ -0,0 +1,316 @@
// generated from rosidl_typesupport_fastrtps_cpp/resource/idl__rosidl_typesupport_fastrtps_cpp.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_
#include <cstddef>
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
#include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Move_Request & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Move_Request & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Move_Request & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Move_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Move_Request & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Move_Request & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Move_Request(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Move_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <cstddef>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
// already included above
// #include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Move_Response & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Move_Response & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Move_Response & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Move_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Move_Response & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Move_Response & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Move_Response(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Move_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include <cstddef>
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#ifndef _WIN32
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-parameter"
# ifdef __clang__
# pragma clang diagnostic ignored "-Wdeprecated-register"
# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
# endif
#endif
#ifndef _WIN32
# pragma GCC diagnostic pop
#endif
// already included above
// #include "fastcdr/Cdr.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace typesupport_fastrtps_cpp
{
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize(
const sas_robot_driver_franka_interfaces::srv::Move_Event & ros_message,
eprosima::fastcdr::Cdr & cdr);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_deserialize(
eprosima::fastcdr::Cdr & cdr,
sas_robot_driver_franka_interfaces::srv::Move_Event & ros_message);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size(
const sas_robot_driver_franka_interfaces::srv::Move_Event & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_Move_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
bool
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
cdr_serialize_key(
const sas_robot_driver_franka_interfaces::srv::Move_Event & ros_message,
eprosima::fastcdr::Cdr &);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
get_serialized_size_key(
const sas_robot_driver_franka_interfaces::srv::Move_Event & ros_message,
size_t current_alignment);
size_t
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
max_serialized_size_key_Move_Event(
bool & full_bounded,
bool & is_plain,
size_t current_alignment);
} // namespace typesupport_fastrtps_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Move_Event)();
#ifdef __cplusplus
}
#endif
#include "rmw/types.h"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_fastrtps_cpp__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_FASTRTPS_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_fastrtps_cpp, sas_robot_driver_franka_interfaces, srv, Move)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_FASTRTPS_CPP_HPP_

58
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__rosidl_typesupport_introspection_c.h Normal file
View File

@@ -0,0 +1,58 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__rosidl_typesupport_introspection_c.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Request)();
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Response)();
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Event)();
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
ROSIDL_TYPESUPPORT_INTROSPECTION_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_C_H_

88
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__rosidl_typesupport_introspection_cpp.hpp Normal file
View File

@@ -0,0 +1,88 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__rosidl_typesupport_introspection_cpp.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_interface/macros.h"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Request)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Response)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
// TODO(dirk-thomas) these visibility macros should be message package specific
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Event)();
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_HPP_

98
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__struct.h Normal file
View File

@@ -0,0 +1,98 @@
// generated from rosidl_generator_c/resource/idl__struct.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_H_
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
// Constants defined in the message
/// Struct defined in srv/Move in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Request
{
float width;
float speed;
} sas_robot_driver_franka_interfaces__srv__Move_Request;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Move_Request.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence
{
sas_robot_driver_franka_interfaces__srv__Move_Request * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence;
// Constants defined in the message
/// Struct defined in srv/Move in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Response
{
bool success;
} sas_robot_driver_franka_interfaces__srv__Move_Response;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Move_Response.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence
{
sas_robot_driver_franka_interfaces__srv__Move_Response * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence;
// Constants defined in the message
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__struct.h"
// constants for array fields with an upper bound
// request
enum
{
sas_robot_driver_franka_interfaces__srv__Move_Event__request__MAX_SIZE = 1
};
// response
enum
{
sas_robot_driver_franka_interfaces__srv__Move_Event__response__MAX_SIZE = 1
};
/// Struct defined in srv/Move in the package sas_robot_driver_franka_interfaces.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Event
{
service_msgs__msg__ServiceEventInfo info;
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence request;
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence response;
} sas_robot_driver_franka_interfaces__srv__Move_Event;
// Struct for a sequence of sas_robot_driver_franka_interfaces__srv__Move_Event.
typedef struct sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence
{
sas_robot_driver_franka_interfaces__srv__Move_Event * data;
/// The number of valid items in data
size_t size;
/// The number of allocated items in data
size_t capacity;
} sas_robot_driver_franka_interfaces__srv__Move_Event__Sequence;
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_H_

414
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__struct.hpp Normal file
View File

@@ -0,0 +1,414 @@
// generated from rosidl_generator_cpp/resource/idl__struct.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_HPP_
#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <vector>
#include "rosidl_runtime_cpp/bounded_vector.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Request __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Request __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Move_Request_
{
using Type = Move_Request_<ContainerAllocator>;
explicit Move_Request_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->speed = 0.0f;
}
}
explicit Move_Request_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
(void)_alloc;
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->width = 0.0f;
this->speed = 0.0f;
}
}
// field types and members
using _width_type =
float;
_width_type width;
using _speed_type =
float;
_speed_type speed;
// setters for named parameter idiom
Type & set__width(
const float & _arg)
{
this->width = _arg;
return *this;
}
Type & set__speed(
const float & _arg)
{
this->speed = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Request
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Request
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Move_Request_ & other) const
{
if (this->width != other.width) {
return false;
}
if (this->speed != other.speed) {
return false;
}
return true;
}
bool operator!=(const Move_Request_ & other) const
{
return !this->operator==(other);
}
}; // struct Move_Request_
// alias to use template instance with default allocator
using Move_Request =
sas_robot_driver_franka_interfaces::srv::Move_Request_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Response __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Response __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Move_Response_
{
using Type = Move_Response_<ContainerAllocator>;
explicit Move_Response_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->success = false;
}
}
explicit Move_Response_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
{
(void)_alloc;
if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
{
this->success = false;
}
}
// field types and members
using _success_type =
bool;
_success_type success;
// setters for named parameter idiom
Type & set__success(
const bool & _arg)
{
this->success = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Response
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Response
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Move_Response_ & other) const
{
if (this->success != other.success) {
return false;
}
return true;
}
bool operator!=(const Move_Response_ & other) const
{
return !this->operator==(other);
}
}; // struct Move_Response_
// alias to use template instance with default allocator
using Move_Response =
sas_robot_driver_franka_interfaces::srv::Move_Response_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__struct.hpp"
#ifndef _WIN32
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Event __attribute__((deprecated))
#else
# define DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Event __declspec(deprecated)
#endif
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
// message struct
template<class ContainerAllocator>
struct Move_Event_
{
using Type = Move_Event_<ContainerAllocator>;
explicit Move_Event_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
: info(_init)
{
(void)_init;
}
explicit Move_Event_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
: info(_alloc, _init)
{
(void)_init;
}
// field types and members
using _info_type =
service_msgs::msg::ServiceEventInfo_<ContainerAllocator>;
_info_type info;
using _request_type =
rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>>;
_request_type request;
using _response_type =
rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>>;
_response_type response;
// setters for named parameter idiom
Type & set__info(
const service_msgs::msg::ServiceEventInfo_<ContainerAllocator> & _arg)
{
this->info = _arg;
return *this;
}
Type & set__request(
const rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Move_Request_<ContainerAllocator>>> & _arg)
{
this->request = _arg;
return *this;
}
Type & set__response(
const rosidl_runtime_cpp::BoundedVector<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>, 1, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<sas_robot_driver_franka_interfaces::srv::Move_Response_<ContainerAllocator>>> & _arg)
{
this->response = _arg;
return *this;
}
// constant declarations
// pointer types
using RawPtr =
sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> *;
using ConstRawPtr =
const sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> *;
using SharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>>;
using ConstSharedPtr =
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> const>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>>>
using UniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>, Deleter>;
using UniquePtr = UniquePtrWithDeleter<>;
template<typename Deleter = std::default_delete<
sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>>>
using ConstUniquePtrWithDeleter =
std::unique_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> const, Deleter>;
using ConstUniquePtr = ConstUniquePtrWithDeleter<>;
using WeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>>;
using ConstWeakPtr =
std::weak_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> const>;
// pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
// NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Event
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator>>
Ptr;
typedef DEPRECATED__sas_robot_driver_franka_interfaces__srv__Move_Event
std::shared_ptr<sas_robot_driver_franka_interfaces::srv::Move_Event_<ContainerAllocator> const>
ConstPtr;
// comparison operators
bool operator==(const Move_Event_ & other) const
{
if (this->info != other.info) {
return false;
}
if (this->request != other.request) {
return false;
}
if (this->response != other.response) {
return false;
}
return true;
}
bool operator!=(const Move_Event_ & other) const
{
return !this->operator==(other);
}
}; // struct Move_Event_
// alias to use template instance with default allocator
using Move_Event =
sas_robot_driver_franka_interfaces::srv::Move_Event_<std::allocator<void>>;
// constant definitions
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
struct Move
{
using Request = sas_robot_driver_franka_interfaces::srv::Move_Request;
using Response = sas_robot_driver_franka_interfaces::srv::Move_Response;
using Event = sas_robot_driver_franka_interfaces::srv::Move_Event;
};
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__STRUCT_HPP_

445
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__traits.hpp Normal file
View File

@@ -0,0 +1,445 @@
// generated from rosidl_generator_cpp/resource/idl__traits.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.hpp"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TRAITS_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TRAITS_HPP_
#include <stdint.h>
#include <sstream>
#include <string>
#include <type_traits>
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#include "rosidl_runtime_cpp/traits.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Move_Request & msg,
std::ostream & out)
{
out << "{";
// member: width
{
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << ", ";
}
// member: speed
{
out << "speed: ";
rosidl_generator_traits::value_to_yaml(msg.speed, out);
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Move_Request & msg,
std::ostream & out, size_t indentation = 0)
{
// member: width
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "width: ";
rosidl_generator_traits::value_to_yaml(msg.width, out);
out << "\n";
}
// member: speed
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "speed: ";
rosidl_generator_traits::value_to_yaml(msg.speed, out);
out << "\n";
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Move_Request & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Move_Request & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Move_Request & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Move_Request>()
{
return "sas_robot_driver_franka_interfaces::srv::Move_Request";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Move_Request>()
{
return "sas_robot_driver_franka_interfaces/srv/Move_Request";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move_Request>
: std::integral_constant<bool, true> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Request>
: std::integral_constant<bool, true> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Move_Request>
: std::true_type {};
} // namespace rosidl_generator_traits
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Move_Response & msg,
std::ostream & out)
{
out << "{";
// member: success
{
out << "success: ";
rosidl_generator_traits::value_to_yaml(msg.success, out);
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Move_Response & msg,
std::ostream & out, size_t indentation = 0)
{
// member: success
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "success: ";
rosidl_generator_traits::value_to_yaml(msg.success, out);
out << "\n";
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Move_Response & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Move_Response & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Move_Response & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Move_Response>()
{
return "sas_robot_driver_franka_interfaces::srv::Move_Response";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Move_Response>()
{
return "sas_robot_driver_franka_interfaces/srv/Move_Response";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move_Response>
: std::integral_constant<bool, true> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Response>
: std::integral_constant<bool, true> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Move_Response>
: std::true_type {};
} // namespace rosidl_generator_traits
// Include directives for member types
// Member 'info'
#include "service_msgs/msg/detail/service_event_info__traits.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
inline void to_flow_style_yaml(
const Move_Event & msg,
std::ostream & out)
{
out << "{";
// member: info
{
out << "info: ";
to_flow_style_yaml(msg.info, out);
out << ", ";
}
// member: request
{
if (msg.request.size() == 0) {
out << "request: []";
} else {
out << "request: [";
size_t pending_items = msg.request.size();
for (auto item : msg.request) {
to_flow_style_yaml(item, out);
if (--pending_items > 0) {
out << ", ";
}
}
out << "]";
}
out << ", ";
}
// member: response
{
if (msg.response.size() == 0) {
out << "response: []";
} else {
out << "response: [";
size_t pending_items = msg.response.size();
for (auto item : msg.response) {
to_flow_style_yaml(item, out);
if (--pending_items > 0) {
out << ", ";
}
}
out << "]";
}
}
out << "}";
} // NOLINT(readability/fn_size)
inline void to_block_style_yaml(
const Move_Event & msg,
std::ostream & out, size_t indentation = 0)
{
// member: info
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "info:\n";
to_block_style_yaml(msg.info, out, indentation + 2);
}
// member: request
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
if (msg.request.size() == 0) {
out << "request: []\n";
} else {
out << "request:\n";
for (auto item : msg.request) {
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "-\n";
to_block_style_yaml(item, out, indentation + 2);
}
}
}
// member: response
{
if (indentation > 0) {
out << std::string(indentation, ' ');
}
if (msg.response.size() == 0) {
out << "response: []\n";
} else {
out << "response:\n";
for (auto item : msg.response) {
if (indentation > 0) {
out << std::string(indentation, ' ');
}
out << "-\n";
to_block_style_yaml(item, out, indentation + 2);
}
}
}
} // NOLINT(readability/fn_size)
inline std::string to_yaml(const Move_Event & msg, bool use_flow_style = false)
{
std::ostringstream out;
if (use_flow_style) {
to_flow_style_yaml(msg, out);
} else {
to_block_style_yaml(msg, out);
}
return out.str();
}
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_generator_traits
{
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_block_style_yaml() instead")]]
inline void to_yaml(
const sas_robot_driver_franka_interfaces::srv::Move_Event & msg,
std::ostream & out, size_t indentation = 0)
{
sas_robot_driver_franka_interfaces::srv::to_block_style_yaml(msg, out, indentation);
}
[[deprecated("use sas_robot_driver_franka_interfaces::srv::to_yaml() instead")]]
inline std::string to_yaml(const sas_robot_driver_franka_interfaces::srv::Move_Event & msg)
{
return sas_robot_driver_franka_interfaces::srv::to_yaml(msg);
}
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Move_Event>()
{
return "sas_robot_driver_franka_interfaces::srv::Move_Event";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Move_Event>()
{
return "sas_robot_driver_franka_interfaces/srv/Move_Event";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move_Event>
: std::integral_constant<bool, false> {};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Event>
: std::integral_constant<bool, has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Request>::value && has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Response>::value && has_bounded_size<service_msgs::msg::ServiceEventInfo>::value> {};
template<>
struct is_message<sas_robot_driver_franka_interfaces::srv::Move_Event>
: std::true_type {};
} // namespace rosidl_generator_traits
namespace rosidl_generator_traits
{
template<>
inline const char * data_type<sas_robot_driver_franka_interfaces::srv::Move>()
{
return "sas_robot_driver_franka_interfaces::srv::Move";
}
template<>
inline const char * name<sas_robot_driver_franka_interfaces::srv::Move>()
{
return "sas_robot_driver_franka_interfaces/srv/Move";
}
template<>
struct has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move>
: std::integral_constant<
bool,
has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move_Request>::value &&
has_fixed_size<sas_robot_driver_franka_interfaces::srv::Move_Response>::value
>
{
};
template<>
struct has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move>
: std::integral_constant<
bool,
has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Request>::value &&
has_bounded_size<sas_robot_driver_franka_interfaces::srv::Move_Response>::value
>
{
};
template<>
struct is_service<sas_robot_driver_franka_interfaces::srv::Move>
: std::true_type
{
};
template<>
struct is_service_request<sas_robot_driver_franka_interfaces::srv::Move_Request>
: std::true_type
{
};
template<>
struct is_service_response<sas_robot_driver_franka_interfaces::srv::Move_Response>
: std::true_type
{
};
} // namespace rosidl_generator_traits
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TRAITS_HPP_

543
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__type_support.c Normal file
View File

@@ -0,0 +1,543 @@
// generated from rosidl_typesupport_introspection_c/resource/idl__type_support.c.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#include <stddef.h>
#include "sas_robot_driver_franka_interfaces/srv/detail/move__rosidl_typesupport_introspection_c.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
#include "rosidl_typesupport_introspection_c/field_types.h"
#include "rosidl_typesupport_introspection_c/identifier.h"
#include "rosidl_typesupport_introspection_c/message_introspection.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Move_Request__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Move_Request__fini(message_memory);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_member_array[2] = {
{
"width", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Request, width), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"speed", // name
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Request, speed), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Move_Request", // message name
2, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Move_Request),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Request)() {
if (!sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__rosidl_typesupport_introspection_c.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "rosidl_typesupport_introspection_c/field_types.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
// already included above
// #include "rosidl_typesupport_introspection_c/message_introspection.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Move_Response__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Move_Response__fini(message_memory);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_member_array[1] = {
{
"success", // name
rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
NULL, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Response, success), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Move_Response", // message name
1, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Move_Response),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Response)() {
if (!sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include <stddef.h>
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__rosidl_typesupport_introspection_c.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "rosidl_typesupport_introspection_c/field_types.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
// already included above
// #include "rosidl_typesupport_introspection_c/message_introspection.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
// Include directives for member types
// Member `info`
#include "service_msgs/msg/service_event_info.h"
// Member `info`
#include "service_msgs/msg/detail/service_event_info__rosidl_typesupport_introspection_c.h"
// Member `request`
// Member `response`
#include "sas_robot_driver_franka_interfaces/srv/move.h"
// Member `request`
// Member `response`
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__rosidl_typesupport_introspection_c.h"
#ifdef __cplusplus
extern "C"
{
#endif
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_init_function(
void * message_memory, enum rosidl_runtime_c__message_initialization _init)
{
// TODO(karsten1987): initializers are not yet implemented for typesupport c
// see https://github.com/ros2/ros2/issues/397
(void) _init;
sas_robot_driver_franka_interfaces__srv__Move_Event__init(message_memory);
}
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_fini_function(void * message_memory)
{
sas_robot_driver_franka_interfaces__srv__Move_Event__fini(message_memory);
}
size_t sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__size_function__Move_Event__request(
const void * untyped_member)
{
const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *)(untyped_member);
return member->size;
}
const void * sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__request(
const void * untyped_member, size_t index)
{
const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *)(untyped_member);
return &member->data[index];
}
void * sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__request(
void * untyped_member, size_t index)
{
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *)(untyped_member);
return &member->data[index];
}
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__fetch_function__Move_Event__request(
const void * untyped_member, size_t index, void * untyped_value)
{
const sas_robot_driver_franka_interfaces__srv__Move_Request * item =
((const sas_robot_driver_franka_interfaces__srv__Move_Request *)
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__request(untyped_member, index));
sas_robot_driver_franka_interfaces__srv__Move_Request * value =
(sas_robot_driver_franka_interfaces__srv__Move_Request *)(untyped_value);
*value = *item;
}
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__assign_function__Move_Event__request(
void * untyped_member, size_t index, const void * untyped_value)
{
sas_robot_driver_franka_interfaces__srv__Move_Request * item =
((sas_robot_driver_franka_interfaces__srv__Move_Request *)
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__request(untyped_member, index));
const sas_robot_driver_franka_interfaces__srv__Move_Request * value =
(const sas_robot_driver_franka_interfaces__srv__Move_Request *)(untyped_value);
*item = *value;
}
bool sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__resize_function__Move_Event__request(
void * untyped_member, size_t size)
{
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence *)(untyped_member);
sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__fini(member);
return sas_robot_driver_franka_interfaces__srv__Move_Request__Sequence__init(member, size);
}
size_t sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__size_function__Move_Event__response(
const void * untyped_member)
{
const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *)(untyped_member);
return member->size;
}
const void * sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__response(
const void * untyped_member, size_t index)
{
const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * member =
(const sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *)(untyped_member);
return &member->data[index];
}
void * sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__response(
void * untyped_member, size_t index)
{
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *)(untyped_member);
return &member->data[index];
}
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__fetch_function__Move_Event__response(
const void * untyped_member, size_t index, void * untyped_value)
{
const sas_robot_driver_franka_interfaces__srv__Move_Response * item =
((const sas_robot_driver_franka_interfaces__srv__Move_Response *)
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__response(untyped_member, index));
sas_robot_driver_franka_interfaces__srv__Move_Response * value =
(sas_robot_driver_franka_interfaces__srv__Move_Response *)(untyped_value);
*value = *item;
}
void sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__assign_function__Move_Event__response(
void * untyped_member, size_t index, const void * untyped_value)
{
sas_robot_driver_franka_interfaces__srv__Move_Response * item =
((sas_robot_driver_franka_interfaces__srv__Move_Response *)
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__response(untyped_member, index));
const sas_robot_driver_franka_interfaces__srv__Move_Response * value =
(const sas_robot_driver_franka_interfaces__srv__Move_Response *)(untyped_value);
*item = *value;
}
bool sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__resize_function__Move_Event__response(
void * untyped_member, size_t size)
{
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence * member =
(sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence *)(untyped_member);
sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__fini(member);
return sas_robot_driver_franka_interfaces__srv__Move_Response__Sequence__init(member, size);
}
static rosidl_typesupport_introspection_c__MessageMember sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_member_array[3] = {
{
"info", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Event, info), // bytes offset in struct
NULL, // default value
NULL, // size() function pointer
NULL, // get_const(index) function pointer
NULL, // get(index) function pointer
NULL, // fetch(index, &value) function pointer
NULL, // assign(index, value) function pointer
NULL // resize(index) function pointer
},
{
"request", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Event, request), // bytes offset in struct
NULL, // default value
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__size_function__Move_Event__request, // size() function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__request, // get_const(index) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__request, // get(index) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__fetch_function__Move_Event__request, // fetch(index, &value) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__assign_function__Move_Event__request, // assign(index, value) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__resize_function__Move_Event__request // resize(index) function pointer
},
{
"response", // name
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE, // type
0, // upper bound of string
NULL, // members of sub message (initialized later)
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces__srv__Move_Event, response), // bytes offset in struct
NULL, // default value
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__size_function__Move_Event__response, // size() function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_const_function__Move_Event__response, // get_const(index) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__get_function__Move_Event__response, // get(index) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__fetch_function__Move_Event__response, // fetch(index, &value) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__assign_function__Move_Event__response, // assign(index, value) function pointer
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__resize_function__Move_Event__response // resize(index) function pointer
}
};
static const rosidl_typesupport_introspection_c__MessageMembers sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_members = {
"sas_robot_driver_franka_interfaces__srv", // message namespace
"Move_Event", // message name
3, // number of fields
sizeof(sas_robot_driver_franka_interfaces__srv__Move_Event),
false, // has_any_key_member_
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_member_array, // message members
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_init_function, // function to initialize message memory (memory has to be allocated)
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_fini_function // function to terminate message instance (will not free memory)
};
// this is not const since it must be initialized on first access
// since C does not allow non-integral compile-time constants
static rosidl_message_type_support_t sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description_sources,
};
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Event)() {
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_member_array[0].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, service_msgs, msg, ServiceEventInfo)();
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_member_array[1].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Request)();
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_member_array[2].members_ =
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Response)();
if (!sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
return &sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
#include "rosidl_runtime_c/service_type_support_struct.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/msg/rosidl_typesupport_introspection_c__visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__rosidl_typesupport_introspection_c.h"
// already included above
// #include "rosidl_typesupport_introspection_c/identifier.h"
#include "rosidl_typesupport_introspection_c/service_introspection.h"
// this is intentionally not const to allow initialization later to prevent an initialization race
static rosidl_typesupport_introspection_c__ServiceMembers sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_members = {
"sas_robot_driver_franka_interfaces__srv", // service namespace
"Move", // service name
// the following fields are initialized below on first access
NULL, // request message
// sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle,
NULL, // response message
// sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle
NULL // event_message
// sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle
};
static rosidl_service_type_support_t sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_type_support_handle = {
0,
&sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_members,
get_service_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Request__rosidl_typesupport_introspection_c__Move_Request_message_type_support_handle,
&sas_robot_driver_franka_interfaces__srv__Move_Response__rosidl_typesupport_introspection_c__Move_Response_message_type_support_handle,
&sas_robot_driver_franka_interfaces__srv__Move_Event__rosidl_typesupport_introspection_c__Move_Event_message_type_support_handle,
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_CREATE_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move
),
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_DESTROY_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move
),
&sas_robot_driver_franka_interfaces__srv__Move__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move__get_type_description_sources,
};
// Forward declaration of message type support functions for service members
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Request)(void);
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Response)(void);
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Event)(void);
ROSIDL_TYPESUPPORT_INTROSPECTION_C_EXPORT_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move)(void) {
if (!sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_type_support_handle.typesupport_identifier) {
sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_type_support_handle.typesupport_identifier =
rosidl_typesupport_introspection_c__identifier;
}
rosidl_typesupport_introspection_c__ServiceMembers * service_members =
(rosidl_typesupport_introspection_c__ServiceMembers *)sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_type_support_handle.data;
if (!service_members->request_members_) {
service_members->request_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Request)()->data;
}
if (!service_members->response_members_) {
service_members->response_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Response)()->data;
}
if (!service_members->event_members_) {
service_members->event_members_ =
(const rosidl_typesupport_introspection_c__MessageMembers *)
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_c, sas_robot_driver_franka_interfaces, srv, Move_Event)()->data;
}
return &sas_robot_driver_franka_interfaces__srv__detail__move__rosidl_typesupport_introspection_c__Move_service_type_support_handle;
}

638
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__type_support.cpp Normal file
View File

@@ -0,0 +1,638 @@
// generated from rosidl_typesupport_introspection_cpp/resource/idl__type_support.cpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#include "array"
#include "cstddef"
#include "string"
#include "vector"
#include "rosidl_runtime_c/message_type_support_struct.h"
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#include "rosidl_typesupport_introspection_cpp/field_types.hpp"
#include "rosidl_typesupport_introspection_cpp/identifier.hpp"
#include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
#include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
#include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Move_Request_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Move_Request(_init);
}
void Move_Request_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Move_Request *>(message_memory);
typed_message->~Move_Request();
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Move_Request_message_member_array[2] = {
{
"width", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Request, width), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"speed", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_FLOAT, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Request, speed), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Move_Request_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Move_Request", // message name
2, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Move_Request),
false, // has_any_key_member_
Move_Request_message_member_array, // message members
Move_Request_init_function, // function to initialize message memory (memory has to be allocated)
Move_Request_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Move_Request_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Move_Request_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Request__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Request>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Request_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Request)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Request_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "array"
// already included above
// #include "cstddef"
// already included above
// #include "string"
// already included above
// #include "vector"
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/field_types.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Move_Response_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Move_Response(_init);
}
void Move_Response_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Move_Response *>(message_memory);
typed_message->~Move_Response();
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Move_Response_message_member_array[1] = {
{
"success", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_BOOLEAN, // type
0, // upper bound of string
nullptr, // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Response, success), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Move_Response_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Move_Response", // message name
1, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Move_Response),
false, // has_any_key_member_
Move_Response_message_member_array, // message members
Move_Response_init_function, // function to initialize message memory (memory has to be allocated)
Move_Response_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Move_Response_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Move_Response_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Response__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Response>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Response_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Response)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Response_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "array"
// already included above
// #include "cstddef"
// already included above
// #include "string"
// already included above
// #include "vector"
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/field_types.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
void Move_Event_init_function(
void * message_memory, rosidl_runtime_cpp::MessageInitialization _init)
{
new (message_memory) sas_robot_driver_franka_interfaces::srv::Move_Event(_init);
}
void Move_Event_fini_function(void * message_memory)
{
auto typed_message = static_cast<sas_robot_driver_franka_interfaces::srv::Move_Event *>(message_memory);
typed_message->~Move_Event();
}
size_t size_function__Move_Event__request(const void * untyped_member)
{
const auto * member = reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Move_Request> *>(untyped_member);
return member->size();
}
const void * get_const_function__Move_Event__request(const void * untyped_member, size_t index)
{
const auto & member =
*reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Move_Request> *>(untyped_member);
return &member[index];
}
void * get_function__Move_Event__request(void * untyped_member, size_t index)
{
auto & member =
*reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Move_Request> *>(untyped_member);
return &member[index];
}
void fetch_function__Move_Event__request(
const void * untyped_member, size_t index, void * untyped_value)
{
const auto & item = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Move_Request *>(
get_const_function__Move_Event__request(untyped_member, index));
auto & value = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Move_Request *>(untyped_value);
value = item;
}
void assign_function__Move_Event__request(
void * untyped_member, size_t index, const void * untyped_value)
{
auto & item = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Move_Request *>(
get_function__Move_Event__request(untyped_member, index));
const auto & value = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Move_Request *>(untyped_value);
item = value;
}
void resize_function__Move_Event__request(void * untyped_member, size_t size)
{
auto * member =
reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Move_Request> *>(untyped_member);
member->resize(size);
}
size_t size_function__Move_Event__response(const void * untyped_member)
{
const auto * member = reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Move_Response> *>(untyped_member);
return member->size();
}
const void * get_const_function__Move_Event__response(const void * untyped_member, size_t index)
{
const auto & member =
*reinterpret_cast<const std::vector<sas_robot_driver_franka_interfaces::srv::Move_Response> *>(untyped_member);
return &member[index];
}
void * get_function__Move_Event__response(void * untyped_member, size_t index)
{
auto & member =
*reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Move_Response> *>(untyped_member);
return &member[index];
}
void fetch_function__Move_Event__response(
const void * untyped_member, size_t index, void * untyped_value)
{
const auto & item = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Move_Response *>(
get_const_function__Move_Event__response(untyped_member, index));
auto & value = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Move_Response *>(untyped_value);
value = item;
}
void assign_function__Move_Event__response(
void * untyped_member, size_t index, const void * untyped_value)
{
auto & item = *reinterpret_cast<sas_robot_driver_franka_interfaces::srv::Move_Response *>(
get_function__Move_Event__response(untyped_member, index));
const auto & value = *reinterpret_cast<const sas_robot_driver_franka_interfaces::srv::Move_Response *>(untyped_value);
item = value;
}
void resize_function__Move_Event__response(void * untyped_member, size_t size)
{
auto * member =
reinterpret_cast<std::vector<sas_robot_driver_franka_interfaces::srv::Move_Response> *>(untyped_member);
member->resize(size);
}
static const ::rosidl_typesupport_introspection_cpp::MessageMember Move_Event_message_member_array[3] = {
{
"info", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<service_msgs::msg::ServiceEventInfo>(), // members of sub message
false, // is key
false, // is array
0, // array size
false, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Event, info), // bytes offset in struct
nullptr, // default value
nullptr, // size() function pointer
nullptr, // get_const(index) function pointer
nullptr, // get(index) function pointer
nullptr, // fetch(index, &value) function pointer
nullptr, // assign(index, value) function pointer
nullptr // resize(index) function pointer
},
{
"request", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Request>(), // members of sub message
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Event, request), // bytes offset in struct
nullptr, // default value
size_function__Move_Event__request, // size() function pointer
get_const_function__Move_Event__request, // get_const(index) function pointer
get_function__Move_Event__request, // get(index) function pointer
fetch_function__Move_Event__request, // fetch(index, &value) function pointer
assign_function__Move_Event__request, // assign(index, value) function pointer
resize_function__Move_Event__request // resize(index) function pointer
},
{
"response", // name
::rosidl_typesupport_introspection_cpp::ROS_TYPE_MESSAGE, // type
0, // upper bound of string
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Response>(), // members of sub message
false, // is key
true, // is array
1, // array size
true, // is upper bound
offsetof(sas_robot_driver_franka_interfaces::srv::Move_Event, response), // bytes offset in struct
nullptr, // default value
size_function__Move_Event__response, // size() function pointer
get_const_function__Move_Event__response, // get_const(index) function pointer
get_function__Move_Event__response, // get(index) function pointer
fetch_function__Move_Event__response, // fetch(index, &value) function pointer
assign_function__Move_Event__response, // assign(index, value) function pointer
resize_function__Move_Event__response // resize(index) function pointer
}
};
static const ::rosidl_typesupport_introspection_cpp::MessageMembers Move_Event_message_members = {
"sas_robot_driver_franka_interfaces::srv", // message namespace
"Move_Event", // message name
3, // number of fields
sizeof(sas_robot_driver_franka_interfaces::srv::Move_Event),
false, // has_any_key_member_
Move_Event_message_member_array, // message members
Move_Event_init_function, // function to initialize message memory (memory has to be allocated)
Move_Event_fini_function // function to terminate message instance (will not free memory)
};
static const rosidl_message_type_support_t Move_Event_message_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Move_Event_message_members,
get_message_typesupport_handle_function,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move_Event__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Event>()
{
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Event_message_type_support_handle;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move_Event)() {
return &::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_Event_message_type_support_handle;
}
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
// already included above
// #include "rosidl_typesupport_interface/macros.h"
// already included above
// #include "rosidl_typesupport_introspection_cpp/visibility_control.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
// already included above
// #include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/identifier.hpp"
// already included above
// #include "rosidl_typesupport_introspection_cpp/message_type_support_decl.hpp"
#include "rosidl_typesupport_introspection_cpp/service_introspection.hpp"
#include "rosidl_typesupport_introspection_cpp/service_type_support_decl.hpp"
namespace sas_robot_driver_franka_interfaces
{
namespace srv
{
namespace rosidl_typesupport_introspection_cpp
{
// this is intentionally not const to allow initialization later to prevent an initialization race
static ::rosidl_typesupport_introspection_cpp::ServiceMembers Move_service_members = {
"sas_robot_driver_franka_interfaces::srv", // service namespace
"Move", // service name
// the following fields are initialized below on first access
// see get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move>()
nullptr, // request message
nullptr, // response message
nullptr, // event message
};
static const rosidl_service_type_support_t Move_service_type_support_handle = {
::rosidl_typesupport_introspection_cpp::typesupport_identifier,
&Move_service_members,
get_service_typesupport_handle_function,
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Request>(),
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Response>(),
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move_Event>(),
&::rosidl_typesupport_cpp::service_create_event_message<sas_robot_driver_franka_interfaces::srv::Move>,
&::rosidl_typesupport_cpp::service_destroy_event_message<sas_robot_driver_franka_interfaces::srv::Move>,
&sas_robot_driver_franka_interfaces__srv__Move__get_type_hash,
&sas_robot_driver_franka_interfaces__srv__Move__get_type_description,
&sas_robot_driver_franka_interfaces__srv__Move__get_type_description_sources,
};
} // namespace rosidl_typesupport_introspection_cpp
} // namespace srv
} // namespace sas_robot_driver_franka_interfaces
namespace rosidl_typesupport_introspection_cpp
{
template<>
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move>()
{
// get a handle to the value to be returned
auto service_type_support =
&::sas_robot_driver_franka_interfaces::srv::rosidl_typesupport_introspection_cpp::Move_service_type_support_handle;
// get a non-const and properly typed version of the data void *
auto service_members = const_cast<::rosidl_typesupport_introspection_cpp::ServiceMembers *>(
static_cast<const ::rosidl_typesupport_introspection_cpp::ServiceMembers *>(
service_type_support->data));
// make sure all of the service_members are initialized
// if they are not, initialize them
if (
service_members->request_members_ == nullptr ||
service_members->response_members_ == nullptr ||
service_members->event_members_ == nullptr)
{
// initialize the request_members_ with the static function from the external library
service_members->request_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Move_Request
>()->data
);
// initialize the response_members_ with the static function from the external library
service_members->response_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Move_Response
>()->data
);
// initialize the event_members_ with the static function from the external library
service_members->event_members_ = static_cast<
const ::rosidl_typesupport_introspection_cpp::MessageMembers *
>(
::rosidl_typesupport_introspection_cpp::get_message_type_support_handle<
::sas_robot_driver_franka_interfaces::srv::Move_Event
>()->data
);
}
// finally return the properly initialized service_type_support handle
return service_type_support;
}
} // namespace rosidl_typesupport_introspection_cpp
#ifdef __cplusplus
extern "C"
{
#endif
ROSIDL_TYPESUPPORT_INTROSPECTION_CPP_PUBLIC
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_introspection_cpp, sas_robot_driver_franka_interfaces, srv, Move)() {
return ::rosidl_typesupport_introspection_cpp::get_service_type_support_handle<sas_robot_driver_franka_interfaces::srv::Move>();
}
#ifdef __cplusplus
}
#endif

100
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__type_support.h Normal file
View File

@@ -0,0 +1,100 @@
// generated from rosidl_generator_c/resource/idl__type_support.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
// IWYU pragma: private, include "sas_robot_driver_franka_interfaces/srv/move.h"
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_H_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_c__visibility_control.h"
#ifdef __cplusplus
extern "C"
{
#endif
#include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move_Request
)(void);
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move_Response
)(void);
// already included above
// #include "rosidl_runtime_c/message_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move_Event
)(void);
#include "rosidl_runtime_c/service_type_support_struct.h"
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move
)(void);
// Forward declare the function to create a service event message for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
void *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_CREATE_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move
)(
const rosidl_service_introspection_info_t * info,
rcutils_allocator_t * allocator,
const void * request_message,
const void * response_message);
// Forward declare the function to destroy a service event message for this type.
ROSIDL_GENERATOR_C_PUBLIC_sas_robot_driver_franka_interfaces
bool
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_DESTROY_EVENT_MESSAGE_SYMBOL_NAME(
rosidl_typesupport_c,
sas_robot_driver_franka_interfaces,
srv,
Move
)(
void * event_msg,
rcutils_allocator_t * allocator);
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_H_

71
include/sas_robot_driver_franka/interfaces/local/srv/detail/move__type_support.hpp Normal file
View File

@@ -0,0 +1,71 @@
// generated from rosidl_generator_cpp/resource/idl__type_support.hpp.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_HPP_
#include "rosidl_typesupport_interface/macros.h"
#include "sas_robot_driver_franka_interfaces/msg/rosidl_generator_cpp__visibility_control.hpp"
#include "rosidl_typesupport_cpp/service_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_service_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Move
)();
#ifdef __cplusplus
}
#endif
#include "rosidl_typesupport_cpp/message_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Move_Request
)();
#ifdef __cplusplus
}
#endif
// already included above
// #include "rosidl_typesupport_cpp/message_type_support.hpp"
#ifdef __cplusplus
extern "C"
{
#endif
// Forward declare the get type support functions for this type.
ROSIDL_GENERATOR_CPP_PUBLIC_sas_robot_driver_franka_interfaces
const rosidl_message_type_support_t *
ROSIDL_TYPESUPPORT_INTERFACE__MESSAGE_SYMBOL_NAME(
rosidl_typesupport_cpp,
sas_robot_driver_franka_interfaces,
srv,
Move_Response
)();
#ifdef __cplusplus
}
#endif
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__DETAIL__MOVE__TYPE_SUPPORT_HPP_

12
include/sas_robot_driver_franka/interfaces/local/srv/grasp.h Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_c/resource/idl.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Grasp.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_H_
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__type_support.h"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_H_

12
include/sas_robot_driver_franka/interfaces/local/srv/grasp.hpp Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_cpp/resource/idl.hpp.em
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_HPP_
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__struct.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__builder.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__traits.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/grasp__type_support.hpp"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__GRASP_HPP_

12
include/sas_robot_driver_franka/interfaces/local/srv/move.h Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_c/resource/idl.h.em
// with input from sas_robot_driver_franka_interfaces:srv/Move.idl
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_H_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_H_
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__functions.h"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__type_support.h"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_H_

12
include/sas_robot_driver_franka/interfaces/local/srv/move.hpp Normal file
View File

@@ -0,0 +1,12 @@
// generated from rosidl_generator_cpp/resource/idl.hpp.em
// generated code does not contain a copyright notice
#ifndef SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_HPP_
#define SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_HPP_
#include "sas_robot_driver_franka_interfaces/srv/detail/move__struct.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__builder.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__traits.hpp"
#include "sas_robot_driver_franka_interfaces/srv/detail/move__type_support.hpp"
#endif // SAS_ROBOT_DRIVER_FRANKA_INTERFACES__SRV__MOVE_HPP_

46
src/hand/qros_effector_driver_franka_hand.h → include/sas_robot_driver_franka/interfaces/qros_effector_driver_franka_hand.h
View File

@@ -42,21 +42,26 @@
// #define IN_TESTING
// #include <sas_robot_driver/sas_robot_driver.h>
#include <sas_clock/sas_clock.h>
#include <ros/ros.h>
#include <ros/service.h>
#include <sas_robot_driver_franka/Grasp.h>
#include <sas_robot_driver_franka/Move.h>
#include <sas_robot_driver_franka/GripperState.h>
#include <sas_core/sas_clock.hpp>
#include <rclcpp/service.hpp>
#include <rclcpp/rclcpp.hpp>
#ifdef IN_TESTING
#include <Move.h> // dummy include
#include <Grasp.h> // dummy include
#include <GripperState.h> // dummy include
#include "local/srv/grasp.hpp"
#include "local/srv/move.hpp"
#include "local/msg/gripper_state.hpp"
#else
#include <sas_robot_driver_franka_interfaces/srv/grasp.hpp>
#include <sas_robot_driver_franka_interfaces/srv/move.hpp>
#include <sas_robot_driver_franka_interfaces/msg/gripper_state.hpp>
#endif
// using namespace DQ_robotics;
// using namespace Eigen;
using namespace rclcpp;
using namespace sas_robot_driver_franka_interfaces;
namespace qros {
@@ -64,7 +69,7 @@ namespace qros {
struct EffectorDriverFrankaHandConfiguration
{
std::string robot_ip;
int thread_sampeling_time_ns = 1e8; // 10Hz
double thread_sampeling_time_s = 1e8; // 10Hz
double default_force = 3.0;
double default_speed = 0.1;
double default_epsilon_inner = 0.005;
@@ -75,7 +80,7 @@ class EffectorDriverFrankaHand{
private:
std::string driver_node_prefix_;
EffectorDriverFrankaHandConfiguration configuration_;
ros::NodeHandle& node_handel_;
std::shared_ptr<Node> node_;
std::shared_ptr<franka::Gripper> gripper_sptr_;
@@ -88,17 +93,24 @@ private:
void _gripper_status_loop();
std::thread status_loop_thread_;
std::atomic_bool status_loop_running_{false};
ros::Publisher gripper_status_publisher_;
Publisher<msg::GripperState>::SharedPtr gripper_status_publisher_;
std::mutex gripper_in_use_;
ros::ServiceServer grasp_server_;
ros::ServiceServer move_server_;
Service<srv::Grasp>::SharedPtr grasp_srv_;
Service<srv::Move>::SharedPtr move_srv_;
public:
bool _grasp_srv_callback(sas_robot_driver_franka::Grasp::Request& req, sas_robot_driver_franka::Grasp::Response& res);
bool _grasp_srv_callback(
const std::shared_ptr<srv::Grasp::Request> req,
std::shared_ptr<srv::Grasp::Response> res
);
bool _move_srv_callback(sas_robot_driver_franka::Move::Request& req, sas_robot_driver_franka::Move::Response& res);
bool _move_srv_callback(
const std::shared_ptr<srv::Move::Request> req,
std::shared_ptr<srv::Move::Response> res
);
EffectorDriverFrankaHand(const EffectorDriverFrankaHand&)=delete;
EffectorDriverFrankaHand()=delete;
@@ -107,7 +119,7 @@ public:
EffectorDriverFrankaHand(
const std::string &driver_node_prefix,
const EffectorDriverFrankaHandConfiguration& configuration,
ros::NodeHandle& node_handel,
std::shared_ptr<Node> node,
std::atomic_bool* break_loops);
void start_control_loop();

6
src/joint/robot_interface_franka.h → include/sas_robot_driver_franka/interfaces/robot_interface_franka.h
View File

@@ -40,12 +40,12 @@
#include <franka/robot.h>
#include <franka/gripper.h>
#include <franka/exception.h>
#include "generator/motion_generator.h"
#include <sas_robot_driver_franka/generator/motion_generator.h>
#include <sas_robot_driver_franka/generator/quadratic_program_motion_generator.h>
#include <sas_robot_driver_franka/generator/custom_motion_generation.h>
#include <thread>
#include "generator/quadratic_program_motion_generator.h"
#include <dqrobotics/robots/FrankaEmikaPandaRobot.h>
#include <atomic>
#include "generator/custom_motion_generation.h"
using namespace DQ_robotics;
using namespace Eigen;

59
include/robot_dynamic/qros_robot_dynamics_interface.h → include/sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_client.hpp
View File

@@ -1,6 +1,6 @@
#pragma once
/*
# Copyright (c) 2023 Juan Jose Quiroz Omana
# Copyright (c) 2024 Quenitin Lin
#
# This file is part of sas_robot_driver_franka.
#
@@ -28,63 +28,66 @@
#
# ################################################################
*/
#include <ros/ros.h>
#include <ros/node_handle.h>
#include <sas_common/sas_common.h>
#include <sas_conversions/sas_conversions.h>
#include <geometry_msgs/WrenchStamped.h>
#include <geometry_msgs/Transform.h>
#include <geometry_msgs/TransformStamped.h>
#include <rclcpp/rclcpp.hpp>
#include <rclcpp/node.hpp>
// #include <sas_common/sas_common.hpp>
#include <sas_conversions/sas_conversions.hpp>
#include <geometry_msgs/msg/wrench_stamped.hpp>
#include <geometry_msgs/msg/transform.hpp>
#include <geometry_msgs/msg/transform_stamped.hpp>
#include <tf2_ros/transform_listener.h>
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <geometry_msgs/Pose.h>
#include <std_msgs/Header.h>
#include <tf2_ros/buffer.h>
#include <tf2/time.h>
// #include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <geometry_msgs/msg/pose.hpp>
#include <std_msgs/msg/header.hpp>
#include <dqrobotics/DQ.h>
#define BUFFER_DURATION_DEFAULT_S 2.0 // 2 second
using namespace rclcpp;
namespace qros {
using namespace DQ_robotics;
class RobotDynamicInterface {
class RobotDynamicsClient {
private:
unsigned int seq_ = 0;
std::shared_ptr<Node> node_;
std::string node_prefix_;
std::string topic_prefix_;
std::string child_frame_id_;
std::string parent_frame_id_;
ros::Subscriber subscriber_cartesian_stiffness_;
tf2_ros::Buffer tf_buffer_;
tf2_ros::TransformListener tf_listener_;
Subscription<geometry_msgs::msg::WrenchStamped>::SharedPtr subscriber_cartesian_stiffness_;
std::unique_ptr<tf2_ros::Buffer> tf_buffer_;
std::shared_ptr<tf2_ros::TransformListener> tf_listener_;
static geometry_msgs::Transform _dq_to_geometry_msgs_transform(const DQ& pose) ;
static geometry_msgs::msg::Transform _dq_to_geometry_msgs_transform(const DQ& pose) ;
Vector3d last_stiffness_force_;
Vector3d last_stiffness_torque_;
DQ last_stiffness_frame_pose_;
void _callback_cartesian_stiffness(const geometry_msgs::WrenchStampedConstPtr &msg);
void _callback_cartesian_stiffness(const geometry_msgs::msg::WrenchStamped &msg);
static DQ _geometry_msgs_transform_to_dq(const geometry_msgs::Transform& transform);
static DQ _geometry_msgs_transform_to_dq(const geometry_msgs::msg::Transform& transform);
public:
RobotDynamicInterface() = delete;
RobotDynamicInterface(const RobotDynamicInterface&) = delete;
#ifdef BUILD_PYBIND
explicit RobotDynamicInterface(const std::string& node_prefix):RobotDynamicInterface(sas::common::get_static_node_handle(),node_prefix){}
#endif
explicit RobotDynamicInterface(ros::NodeHandle& nodehandle, const std::string& node_prefix=ros::this_node::getName());
RobotDynamicInterface(ros::NodeHandle& publisher_nodehandle, ros::NodeHandle& subscriber_nodehandle, const std::string& node_prefix=ros::this_node::getName());
RobotDynamicsClient() = delete;
RobotDynamicsClient(const RobotDynamicsClient&) = delete;
// #ifdef BUILD_PYBIND
// explicit RobotDynamicsClient(const std::string& node_prefix):RobotDynamicsClient(sas::common::get_static_node_handle(),node_prefix){}
// #endif
explicit RobotDynamicsClient(const std::shared_ptr<Node> &node, const std::string& topic_prefix="GET_FROM_NODE");
VectorXd get_stiffness_force();
VectorXd get_stiffness_torque();
DQ get_stiffness_frame_pose();
bool is_enabled() const;
std::string get_topic_prefix() const {return node_prefix_;}
std::string get_topic_prefix() const {return topic_prefix_;}
};

50
include/robot_dynamic/qros_robot_dynamics_provider.h → include/sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_server.hpp
View File

@@ -1,6 +1,6 @@
#pragma once
/*
# Copyright (c) 2023 Juan Jose Quiroz Omana
# Copyright (c) 2024 Quenitin Lin
#
# This file is part of sas_robot_driver_franka.
#
@@ -28,60 +28,60 @@
#
# ################################################################
*/
#include <ros/ros.h>
#include <ros/node_handle.h>
#include <sas_common/sas_common.h>
#include <sas_conversions/sas_conversions.h>
#include <geometry_msgs/WrenchStamped.h>
#include <geometry_msgs/Transform.h>
#include <geometry_msgs/TransformStamped.h>
#include <rclcpp/rclcpp.hpp>
#include <rclcpp/node.hpp>
// #include <sas_common/sas_common.hpp>
#include <sas_conversions/sas_conversions.hpp>
#include <geometry_msgs/msg/wrench_stamped.hpp>
#include <geometry_msgs/msg/transform.hpp>
#include <geometry_msgs/msg/transform_stamped.hpp>
#include <tf2_ros/transform_broadcaster.h>
#include <tf2_ros//static_transform_broadcaster.h>
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <geometry_msgs/Pose.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/msg/pose.hpp>
#include <std_msgs/msg/header.hpp>
#include <dqrobotics/DQ.h>
#define REDUCE_TF_PUBLISH_RATE 10
#define WORLD_FRAME_ID "world"
using namespace rclcpp;
namespace qros {
using namespace DQ_robotics;
class RobotDynamicProvider {
class RobotDynamicsServer {
private:
unsigned int seq_ = 0;
std::shared_ptr<Node> node_;
std::string node_prefix_;
std::string topic_prefix_;
std::string child_frame_id_;
std::string parent_frame_id_;
ros::Publisher publisher_cartesian_stiffness_;
tf2_ros::TransformBroadcaster tf_broadcaster_;
tf2_ros::StaticTransformBroadcaster static_base_tf_broadcaster_;
rclcpp::Publisher<geometry_msgs::msg::WrenchStamped>::SharedPtr publisher_cartesian_stiffness_;
std::shared_ptr<tf2_ros::TransformBroadcaster> tf_broadcaster_;
std::shared_ptr<tf2_ros::StaticTransformBroadcaster> static_base_tf_broadcaster_;
DQ world_to_base_tf_;
static geometry_msgs::Transform _dq_to_geometry_msgs_transform(const DQ& pose);
static geometry_msgs::msg::Transform _dq_to_geometry_msgs_transform(const DQ& pose);
void _publish_base_static_tf();
public:
RobotDynamicProvider() = delete;
RobotDynamicProvider(const RobotDynamicProvider&) = delete;
#ifdef BUILD_PYBIND
explicit RobotDynamicProvider(const std::string& node_prefix):RobotDynamicProvider(sas::common::get_static_node_handle(),node_prefix){}
#endif
explicit RobotDynamicProvider(ros::NodeHandle& nodehandle, const std::string& node_prefix=ros::this_node::getName());
RobotDynamicProvider(ros::NodeHandle& publisher_nodehandle, ros::NodeHandle& subscriber_nodehandle, const std::string& node_prefix=ros::this_node::getName());
RobotDynamicsServer() = delete;
RobotDynamicsServer(const RobotDynamicsServer&) = delete;
// #ifdef BUILD_PYBIND
// explicit RobotDynamicsServer(const std::string& node_prefix):RobotDynamicsServer(sas::common::get_static_node_handle(),node_prefix){}
// #endif
explicit RobotDynamicsServer(const std::shared_ptr<Node> &node, const std::string& topic_prefix="GET_FROM_NODE");
void publish_stiffness(const DQ& base_to_stiffness, const Vector3d& force, const Vector3d& torque);
void set_world_to_base_tf(const DQ& world_to_base_tf);
bool is_enabled() const;
std::string get_topic_prefix() const {return node_prefix_;}
std::string get_topic_prefix() const {return topic_prefix_;}
};

0
include/robot_interface_hand.h → include/sas_robot_driver_franka/robot_interface_hand.h
View File

17
include/sas_robot_driver_franka.h → include/sas_robot_driver_franka/sas_robot_driver_franka.h
View File

@@ -40,10 +40,10 @@
#include <dqrobotics/DQ.h>
#include <sas_robot_driver/sas_robot_driver.h>
#include "robot_interface_franka.h"
#include <ros/common.h>
#include <robot_dynamic/qros_robot_dynamics_provider.h>
#include <sas_robot_driver/sas_robot_driver.hpp>
#include <sas_robot_driver_franka/interfaces/robot_interface_franka.h>
#include <rclcpp/rclcpp.hpp>
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_server.hpp>
using namespace DQ_robotics;
using namespace Eigen;
@@ -64,14 +64,16 @@ struct RobotDriverFrankaConfiguration
};
class RobotDriverFranka: public RobotDriver
class RobotDriverFranka: public sas_driver::RobotDriver
{
private:
std::shared_ptr<Node> node_;
RobotDriverFrankaConfiguration configuration_;
std::shared_ptr<RobotInterfaceFranka> robot_driver_interface_sptr_ = nullptr;
qros::RobotDynamicProvider* robot_dynamic_provider_;
qros::RobotDynamicsServer* robot_dynamic_provider_;
//Joint positions
VectorXd joint_positions_;
@@ -98,7 +100,8 @@ public:
~RobotDriverFranka();
RobotDriverFranka(
qros::RobotDynamicProvider* robot_dynamic_provider,
const std::shared_ptr<Node> &node,
qros::RobotDynamicsServer* robot_dynamic_provider,
const RobotDriverFrankaConfiguration& configuration,
std::atomic_bool* break_loops
);

5
msg/GripperState.msg
View File

@@ -1,5 +0,0 @@
float32 width
float32 max_width
bool is_grasped
uint16 temperature
uint64 duration_ms

24
package.xml
View File

@@ -1,5 +1,6 @@
<?xml version="1.0"?>
<package format="2">
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
<name>sas_robot_driver_franka</name>
<version>0.0.0</version>
<description>The sas_driver_franka package</description>
@@ -7,7 +8,6 @@
<license>LGPLv3</license>
<buildtool_depend>ament_cmake</buildtool_depend>
<buildtool_depend>rosidl_default_generators</buildtool_depend>
<depend>roscpp</depend>
<depend>rospy</depend>
@@ -17,20 +17,14 @@
<depend>sas_clock</depend>
<depend>sas_robot_driver</depend>
<depend>sas_common</depend>
<depend>pybind11_catkin</depend>
<member_of_group>rosidl_interface_packages</member_of_group>
<!-- <depend>rosidl_default_generator</depend>-->
<depend>sas_robot_driver_franka_interface</depend>
<test_depend>roscpp</test_depend>
<test_depend>rospy</test_depend>
<test_depend>tf2_ros</test_depend>
<test_depend>tf2</test_depend>
<test_depend>std_msgs</test_depend>
<test_depend>sas_clock</test_depend>
<test_depend>sas_robot_driver</test_depend>
<test_depend>sas_common</test_depend>
<!-- <test_depend>message_runtime</test_depend>-->
<exec_depend>rosidl_default_runtime</exec_depend>
<test_depend>ament_lint_auto</test_depend>
<test_depend>ament_lint_common</test_depend>
<test_depend>ament_copyright</test_depend>
<test_depend>ament_flake8</test_depend>
<test_depend>ament_pep257</test_depend>
<export>
<build_type>ament_cmake</build_type>

196
sas_robot_driver_franka/__init__.py
View File

@@ -1,4 +1,196 @@
"""
"""
from _qros_robot_dynamic import RobotDynamicsInterface, RobotDynamicsProvider
from .franka_gripper_interface import FrankaGripperInterface
from sas_robot_driver_franka._robot_dynamics import RobotDynamicsInterface, RobotDynamicsProvider
import rclpy
from rclpy.node import Node
from sas_common import rclcpp_init, rclcpp_Node, rclcpp_spin_some, rclcpp_shutdown
from sas_robot_driver_franka_interfaces.srv import Move, Move_Request, Move_Response, Grasp, Grasp_Request, Grasp_Response
from sas_robot_driver_franka_interfaces.msg import GripperState
import os
import threading
from queue import Queue
import time
import struct
MOVE_TOPIC_SUFFIX = "move"
GRASP_TOPIC_SUFFIX = "grasp"
STATUS_TOPIC_SUFFIX = "gripper_status"
class FrankaGripperInterface:
"""
Non blocking interface to control the Franka gripper
"""
def __init__(self, node: Node, robot_prefix):
self.robot_prefix = robot_prefix
self.node = node
self.move_service = node.create_client(Move, os.path.join(robot_prefix, MOVE_TOPIC_SUFFIX))
self._moving = False
self.grasp_service = node.create_client(Grasp, os.path.join(robot_prefix, GRASP_TOPIC_SUFFIX))
self._grasping = False
self.status_subscriber = node.create_subscription(GripperState, os.path.join(robot_prefix, STATUS_TOPIC_SUFFIX),
self._status_callback)
self.result_queue = Queue()
# gripper state
self.state_width = None
self.state_max_width = None
self.state_temperature = None
self.state_is_grasped = None
def _is_service_ready(self, service):
try:
self.node.get_logger().info("Waiting for service: " + service.service_name)
service.wait_for_service(timeout_sec=0.1)
return True
except Exception as e:
self.node.get_logger().info("Service error: " + service.service_name + ": " + str(e))
return False
def is_enabled(self):
if self.state_width is None:
return False
if not self._is_service_ready(self.move_service):
return False
if not self._is_service_ready(self.grasp_service):
return False
return True
def _status_callback(self, msg: GripperState):
self.state_width = msg.width
self.state_max_width = msg.max_width
self.state_temperature = msg.temperature
self.state_is_grasped = msg.is_grasped
def move(self, width, speed=0):
"""
Move the gripper to a specific width
:param width: width in meters
:param speed: speed in meters per second
:return: None
"""
if self.is_busy():
raise Exception("Gripper is already moving or grasping, please wait until the previous action is finished")
threading.Thread(target=self._move, args=(width, speed)).start()
def grasp(self, width, force=0, speed=0, epsilon_inner=0, epsilon_outer=0):
"""
Grasp an object with the gripper
:param width:
:param force:
:param speed:
:param epsilon_inner:
:param epsilon_outer:
:return:
"""
if self.is_busy():
raise Exception("Gripper is already moving or grasping, please wait until the previous action is finished")
threading.Thread(target=self._grasp, args=(width, force, speed, epsilon_inner, epsilon_outer)).start()
def get_max_width(self):
""" Get the maximum width of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_max_width
def get_width(self):
""" Get the current width of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_width
def get_temperature(self):
""" Get the temperature of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_temperature
def is_grasped(self):
""" Check if an object is grasped """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_is_grasped
def is_moving(self):
""" Check if the gripper is currently moving """
return self._moving
def is_grasping(self):
""" Check if the gripper is currently grasping """
return self._grasping
def is_busy(self):
""" Check if the gripper is currently moving or grasping """
return self._moving or self._grasping
def is_done(self):
""" Check if the gripper is done moving or grasping """
if not self.is_busy():
self.node.get_logger().warn("Gripper is not moving or grasping")
return False
else:
if self.result_queue.empty():
return False
else:
return True
def get_result(self):
"""
Get the result of the last action
:return:
"""
if not self.result_queue.empty():
response = self.result_queue.get()
self._moving = False
self._grasping = False
return response.success
else:
raise Exception("No result available")
def wait_until_done(self):
"""
Wait until the gripper is done moving or grasping
:return: success
"""
if not self.is_enabled():
raise Exception("Gripper is not enabled")
if not self._moving and not self._grasping:
raise Exception("Gripper is not moving or grasping")
if not self._moving or self._grasping:
raise Exception("Gripper is not moving or grasping")
while self._moving or self._grasping:
rclcpp_spin_some(self.node)
time.sleep(0.1)
if not self.result_queue.empty():
response = self.result_queue.get()
if isinstance(response, Move_Response):
self._moving = False
elif isinstance(response, Grasp_Response):
self._grasping = False
else:
raise Exception("Invalid response type")
break
return response.success
def _move(self, width, speed):
self._moving = True
request = Move_Request()
request.width = width
request.speed = speed
response = self.move_service.call(request)
self.result_queue.put(response)
def _grasp(self, width, force, speed, epsilon_inner, epsilon_outer):
self._grasping = True
request = Grasp_Request()
request.width = width
request.force = force
request.speed = speed
request.epsilon_inner = epsilon_inner
request.epsilon_outer = epsilon_outer
response = self.grasp_service.call(request)
self.result_queue.put(response)

182
sas_robot_driver_franka/franka_gripper_interface.py
View File

@@ -1,182 +0,0 @@
import rospy
from sas_robot_driver_franka.srv import Move, MoveRequest, MoveResponse, Grasp, GraspRequest, GraspResponse
from sas_robot_driver_franka.msg import GripperState
import os
import threading
from queue import Queue
import struct
MOVE_TOPIC_SUFFIX = "move"
GRASP_TOPIC_SUFFIX = "grasp"
STATUS_TOPIC_SUFFIX = "gripper_status"
class FrankaGripperInterface:
"""
Non blocking interface to control the Franka gripper
"""
def __init__(self, robot_prefix):
self.robot_prefix = robot_prefix
self.move_service = rospy.ServiceProxy(os.path.join(robot_prefix, MOVE_TOPIC_SUFFIX), Move)
self._moving = False
self.grasp_service = rospy.ServiceProxy(os.path.join(robot_prefix, GRASP_TOPIC_SUFFIX), Grasp)
self._grasping = False
self.status_subscriber = rospy.Subscriber(os.path.join(robot_prefix, STATUS_TOPIC_SUFFIX), GripperState,
self._status_callback)
self.result_queue = Queue()
# gripper state
self.state_width = None
self.state_max_width = None
self.state_temperature = None
self.state_is_grasped = None
def _is_service_ready(self, service):
try:
rospy.wait_for_service(service, timeout=0.1)
return True
except rospy.ROSException:
return False
def is_enabled(self):
if self.state_width is None:
return False
if not self._is_service_ready(self.move_service.resolved_name):
return False
if not self._is_service_ready(self.grasp_service.resolved_name):
return False
return True
def _status_callback(self, msg: GripperState):
self.state_width = msg.width
self.state_max_width = msg.max_width
self.state_temperature = msg.temperature
self.state_is_grasped = msg.is_grasped
def move(self, width, speed=0):
"""
Move the gripper to a specific width
:param width: width in meters
:param speed: speed in meters per second
:return: None
"""
if self.is_busy():
raise Exception("Gripper is already moving or grasping, please wait until the previous action is finished")
threading.Thread(target=self._move, args=(width, speed)).start()
def grasp(self, width, force=0, speed=0, epsilon_inner=0, epsilon_outer=0):
"""
Grasp an object with the gripper
:param width:
:param force:
:param speed:
:param epsilon_inner:
:param epsilon_outer:
:return:
"""
if self.is_busy():
raise Exception("Gripper is already moving or grasping, please wait until the previous action is finished")
threading.Thread(target=self._grasp, args=(width, force, speed, epsilon_inner, epsilon_outer)).start()
def get_max_width(self):
""" Get the maximum width of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_max_width
def get_width(self):
""" Get the current width of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_width
def get_temperature(self):
""" Get the temperature of the gripper """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_temperature
def is_grasped(self):
""" Check if an object is grasped """
if not self.is_enabled():
raise Exception("Gripper is not enabled")
return self.state_is_grasped
def is_moving(self):
""" Check if the gripper is currently moving """
return self._moving
def is_grasping(self):
""" Check if the gripper is currently grasping """
return self._grasping
def is_busy(self):
""" Check if the gripper is currently moving or grasping """
return self._moving or self._grasping
def is_done(self):
""" Check if the gripper is done moving or grasping """
if not self.is_busy():
rospy.logwarn("Gripper is not moving or grasping")
return False
else:
if self.result_queue.empty():
return False
else:
return True
def get_result(self):
"""
Get the result of the last action
:return:
"""
if not self.result_queue.empty():
response = self.result_queue.get()
self._moving = False
self._grasping = False
return response.success
else:
raise Exception("No result available")
def wait_until_done(self):
"""
Wait until the gripper is done moving or grasping
:return: success
"""
if not self.is_enabled():
raise Exception("Gripper is not enabled")
if not self._moving and not self._grasping:
raise Exception("Gripper is not moving or grasping")
while self._moving or self._grasping:
rospy.sleep(0.1)
if not self.result_queue.empty():
response = self.result_queue.get()
if isinstance(response, MoveResponse):
self._moving = False
elif isinstance(response, GraspResponse):
self._grasping = False
else:
raise Exception("Invalid response type")
break
return response.success
def _move(self, width, speed):
self._moving = True
request = MoveRequest()
request.width = width
request.speed = speed
response = self.move_service(request)
self.result_queue.put(response)
def _grasp(self, width, force, speed, epsilon_inner, epsilon_outer):
self._grasping = True
request = GraspRequest()
request.width = width
request.force = force
request.speed = speed
request.epsilon_inner = epsilon_inner
request.epsilon_outer = epsilon_outer
response = self.grasp_service(request)
self.result_queue.put(response)

2
src/generator/custom_motion_generation.cpp
View File

@@ -28,7 +28,7 @@
#
# ################################################################
*/
#include "generator/custom_motion_generation.h"
#include <sas_robot_driver_franka/generator/custom_motion_generation.h>
/**
* @brief CustomMotionGeneration::CustomMotionGeneration

2
src/generator/motion_generator.cpp
View File

@@ -1,6 +1,6 @@
// Copyright (c) 2017 Franka Emika GmbH
// Use of this source code is governed by the Apache-2.0 license, see LICENSE
#include "generator/motion_generator.h"
#include <sas_robot_driver_franka/generator/motion_generator.h>
#include <algorithm>
#include <array>
#include <cmath>

2
src/generator/quadratic_program_motion_generator.cpp
View File

@@ -1,4 +1,4 @@
#include "generator/quadratic_program_motion_generator.h"
#include <sas_robot_driver_franka/generator/quadratic_program_motion_generator.h>
QuadraticProgramMotionGenerator::QuadraticProgramMotionGenerator(const double &speed_factor,

151
src/hand/qros_effector_driver_franka_hand.cpp
View File

@@ -27,10 +27,13 @@
#
# ################################################################
*/
#include "hand/qros_effector_driver_franka_hand.h"
#include <sas_robot_driver_franka/interfaces/qros_effector_driver_franka_hand.h>
#include <franka/exception.h>
using namespace std::placeholders;
using namespace sas_robot_driver_franka_interfaces;
namespace qros
{
@@ -48,19 +51,19 @@ namespace qros
EffectorDriverFrankaHand::EffectorDriverFrankaHand(
const std::string& driver_node_prefix,
const EffectorDriverFrankaHandConfiguration& configuration,
ros::NodeHandle& node_handel,
std::shared_ptr<Node> node,
std::atomic_bool* break_loops):
driver_node_prefix_(driver_node_prefix),
configuration_(configuration),
node_handel_(node_handel),
node_(node),
break_loops_(break_loops)
{
gripper_sptr_ = nullptr;
grasp_server_ = node_handel_.advertiseService(driver_node_prefix_ + "/grasp",
&EffectorDriverFrankaHand::_grasp_srv_callback, this);
move_server_ = node_handel_.advertiseService(driver_node_prefix_ + "/move",
&EffectorDriverFrankaHand::_move_srv_callback, this);
gripper_status_publisher_ = node_handel_.advertise<sas_robot_driver_franka::GripperState>(
grasp_srv_ = node->create_service<srv::Grasp>(driver_node_prefix_ + "/grasp",
std::bind(&EffectorDriverFrankaHand::_grasp_srv_callback, this, _1, _2));
move_srv_ = node->create_service<srv::Move>(driver_node_prefix_ + "/move",
std::bind(&EffectorDriverFrankaHand::_move_srv_callback, this, _1, _2));
gripper_status_publisher_ = node->create_publisher<msg::GripperState>(
driver_node_prefix_ + "/gripper_status", 1);
}
@@ -77,54 +80,47 @@ namespace qros
void EffectorDriverFrankaHand::start_control_loop()
{
sas::Clock clock = sas::Clock(configuration_.thread_sampeling_time_ns);
sas::Clock clock = sas::Clock(configuration_.thread_sampeling_time_s);
clock.init();
ROS_INFO_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::start_control_loop::Starting control loop.");
RCLCPP_INFO_STREAM(node_->get_logger(),
"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::start_control_loop::Starting control loop.");
while (!(*break_loops_))
{
if (!_is_connected()) throw std::runtime_error(
"[" + ros::this_node::getName() +
"]::[EffectorDriverFrankaHand]::start_control_loop::Robot is not connected.");
if (!_is_connected()) throw std::runtime_error("[" + std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::start_control_loop::Robot is not connected.");
if (!status_loop_running_)
{
ROS_WARN_STREAM(
"["+ ros::this_node::getName()+
"]::[EffectorDriverFrankaHand]::_is_connected::Status loop is not running.");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_is_connected::Status loop is not running.");
break_loops_->store(true);
break;
}
clock.update_and_sleep();
ros::spinOnce();
spin_some(node_);
}
ROS_INFO_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::start_control_loop::Exiting control loop.");
RCLCPP_INFO_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::start_control_loop::Exiting control loop.");
}
void EffectorDriverFrankaHand::connect()
{
#ifdef IN_TESTING
ROS_WARN_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::connect::In testing mode. to DUMMY");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::connect::In testing mode. to DUMMY");
return;
#endif
gripper_sptr_ = std::make_shared<franka::Gripper>(configuration_.robot_ip);
if (!_is_connected()) throw std::runtime_error(
"[" + ros::this_node::getName() +
"[" + std::string(node_->get_name())+
"]::[EffectorDriverFrankaHand]::connect::Could not connect to the robot.");
}
void EffectorDriverFrankaHand::disconnect() noexcept
{
#ifdef IN_TESTING
ROS_WARN_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::disconnect::In testing mode. from DUMMY");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::disconnect::In testing mode. from DUMMY");
return;
#endif
ROS_WARN_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::disconnecting...");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::disconnecting...");
gripper_sptr_->~Gripper();
gripper_sptr_ = nullptr;
}
@@ -135,26 +131,23 @@ namespace qros
void EffectorDriverFrankaHand::gripper_homing()
{
#ifdef IN_TESTING
ROS_WARN_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::gripper_homing::In testing mode.");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::gripper_homing::In testing mode.");
return;
#endif
if (!_is_connected()) throw std::runtime_error(
"[" + ros::this_node::getName() + "]::[EffectorDriverFrankaHand]::gripper_homing::Robot is not connected.");
"[" + std::string(node_->get_name())+ "]::[EffectorDriverFrankaHand]::gripper_homing::Robot is not connected.");
auto ret = gripper_sptr_->homing();
if (!ret)
{
throw std::runtime_error(
"[" + ros::this_node::getName() +
"]::[EffectorDriverFrankaHand]::gripper_homing::Failed to home the gripper.");
throw std::runtime_error("[" + std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::gripper_homing::Failed to home the gripper.");
}
ROS_INFO_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::gripper_homing::Gripper homed.");
RCLCPP_INFO_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::gripper_homing::Gripper homed.");
}
void EffectorDriverFrankaHand::initialize()
{
if (!_is_connected()) throw std::runtime_error(
"[" + ros::this_node::getName() + "]::[EffectorDriverFrankaHand]::initialize::Robot is not connected.");
"[" + std::string(node_->get_name())+ "]::[EffectorDriverFrankaHand]::initialize::Robot is not connected.");
gripper_homing();
// start gripper status loop
status_loop_thread_ = std::thread(&EffectorDriverFrankaHand::_gripper_status_loop, this);
@@ -163,7 +156,7 @@ namespace qros
void EffectorDriverFrankaHand::deinitialize()
{
#ifdef IN_TESTING
ROS_WARN_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::deinitialize::In testing mode.");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::deinitialize::In testing mode.");
return;
#endif
if (_is_connected())
@@ -177,20 +170,19 @@ namespace qros
}
bool EffectorDriverFrankaHand::_grasp_srv_callback(sas_robot_driver_franka::Grasp::Request& req,
sas_robot_driver_franka::Grasp::Response& res)
bool EffectorDriverFrankaHand::_grasp_srv_callback(const std::shared_ptr<srv::Grasp::Request> req, std::shared_ptr<srv::Grasp::Response> res)
{
ROS_DEBUG_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::Grasping...");
auto force = req.force;
auto speed = req.speed;
auto epsilon_inner = req.epsilon_inner;
auto epsilon_outer = req.epsilon_outer;
RCLCPP_DEBUG_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::Grasping...");
auto force = req->force;
auto speed = req->speed;
auto epsilon_inner = req->epsilon_inner;
auto epsilon_outer = req->epsilon_outer;
if (force <= 0.0) force = configuration_.default_force;
if (speed <= 0.0) speed = configuration_.default_speed;
if (epsilon_inner <= 0.0) epsilon_inner = configuration_.default_epsilon_inner;
if (epsilon_outer <= 0.0) epsilon_outer = configuration_.default_epsilon_outer;
ROS_DEBUG_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::Width: " + std::to_string(req.width));
ROS_DEBUG_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::force: " + std::to_string(force) + " speed: " + std::to_string(speed));
RCLCPP_DEBUG_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::Width: " + std::to_string(req->width));
RCLCPP_DEBUG_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::force: " + std::to_string(force) + " speed: " + std::to_string(speed));
bool ret = false;
bool function_ret = true;
gripper_in_use_.lock();
@@ -200,30 +192,29 @@ namespace qros
#else
try
{
ret = gripper_sptr_->grasp(req.width, speed, force, epsilon_inner, epsilon_outer);
ret = gripper_sptr_->grasp(req->width, speed, force, epsilon_inner, epsilon_outer);
}catch(franka::CommandException& e)
{
ROS_ERROR_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::CommandException::" + e.what());
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::CommandException::" + e.what());
function_ret = false;
}catch(franka::NetworkException& e)
{
ROS_ERROR_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::NetworkException::" + e.what());
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_grasp_srv_callback::NetworkException::" + e.what());
function_ret = false;
}
#endif
gripper_in_use_.unlock();
res.success = ret;
res->set__success(ret);
return function_ret;
}
bool EffectorDriverFrankaHand::_move_srv_callback(sas_robot_driver_franka::Move::Request& req,
sas_robot_driver_franka::Move::Response& res)
bool EffectorDriverFrankaHand::_move_srv_callback(const std::shared_ptr<srv::Move::Request> req, std::shared_ptr<srv::Move::Response> res)
{
ROS_DEBUG_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_move_srv_callback::Moving...");
auto speed = req.speed;
RCLCPP_DEBUG_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_move_srv_callback::Moving...");
auto speed = req->speed;
if (speed <= 0.0) speed = configuration_.default_speed;
ROS_DEBUG_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_move_srv_callback::Speed: " + std::to_string(speed) + " Width: " + std::to_string(req.width));
RCLCPP_DEBUG_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_move_srv_callback::Speed: " + std::to_string(speed) + " Width: " + std::to_string(req->width));
bool ret = false;
bool function_ret = true;
gripper_in_use_.lock();
@@ -233,19 +224,19 @@ namespace qros
#else
try
{
ret = gripper_sptr_->move(req.width, speed);
ret = gripper_sptr_->move(req->width, speed);
}catch(franka::CommandException& e)
{
ROS_ERROR_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_move_srv_callback::CommandException::" + e.what());
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_move_srv_callback::CommandException::" + e.what());
function_ret = false;
}catch(franka::NetworkException& e)
{
ROS_ERROR_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_move_srv_callback::NetworkException::" + e.what());
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_move_srv_callback::NetworkException::" + e.what());
function_ret = false;
}
#endif
gripper_in_use_.unlock();
res.success = ret;
res->set__success(ret);
return function_ret;
}
@@ -253,28 +244,25 @@ namespace qros
void EffectorDriverFrankaHand::_gripper_status_loop()
{
status_loop_running_ = true;
sas::Clock clock = sas::Clock(configuration_.thread_sampeling_time_ns);
ROS_INFO_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Starting status loop.")
sas::Clock clock = sas::Clock(configuration_.thread_sampeling_time_s);
RCLCPP_INFO_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Starting status loop.")
;
clock.init();
try
{
while (status_loop_running_)
{
#ifdef BLOCK_READ_IN_USED
bool should_unlock = false;
#endif
if (!_is_connected()) throw std::runtime_error(
"[" + ros::this_node::getName() +
"[" + std::string(node_->get_name())+
"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Robot is not connected.");
try
{
#ifdef IN_TESTING
ROS_WARN_STREAM(
"["+ ros::this_node::getName()+
"]::[EffectorDriverFrankaHand]::_gripper_status_loop::In testing mode.");
throw std::runtime_error(
"[" + ros::this_node::getName() +
"]::[EffectorDriverFrankaHand]::_gripper_status_loop::In testing mode.");
RCLCPP_WARN_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::In testing mode.");
throw std::runtime_error("[" + std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::In testing mode.");
#endif
#ifdef BLOCK_READ_IN_USED
gripper_in_use_.lock();
@@ -284,23 +272,23 @@ namespace qros
#ifdef BLOCK_READ_IN_USED
gripper_in_use_.unlock();
#endif
sas_robot_driver_franka::GripperState msg;
msg.width = static_cast<float>(gripper_state.width);
msg.max_width = static_cast<float>(gripper_state.max_width);
msg.is_grasped = gripper_state.is_grasped;
msg.temperature = gripper_state.temperature;
msg.duration_ms = gripper_state.time.toMSec();
gripper_status_publisher_.publish(msg);
msg::GripperState msg;
msg.set__width(static_cast<float>(gripper_state.width));
msg.set__max_width(static_cast<float>(gripper_state.max_width));
msg.set__is_grasped(gripper_state.is_grasped);
msg.set__temperature(gripper_state.temperature);
msg.set__duration_ms(gripper_state.time.toMSec());
gripper_status_publisher_->publish(msg);
}
catch (...)
{
#ifdef BLOCK_READ_IN_USED
if (should_unlock) gripper_in_use_.unlock();
#endif
ROS_INFO_STREAM("["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Could not read gripper state. Unavailable.");
sas_robot_driver_franka::GripperState msg;
RCLCPP_INFO_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Could not read gripper state. Unavailable.");
msg::GripperState msg;
msg.width = 0.0;
gripper_status_publisher_.publish(msg);
gripper_status_publisher_->publish(msg);
}
clock.update_and_sleep();
@@ -309,19 +297,16 @@ namespace qros
}
catch (std::exception& e)
{
ROS_ERROR_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Exception::" + e.
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Exception::" + e.
what());
status_loop_running_ = false;
}
catch (...)
{
ROS_ERROR_STREAM(
"["+ ros::this_node::getName()+
RCLCPP_ERROR_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+
"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Exception::Unknown exception.");
status_loop_running_ = false;
}
ROS_INFO_STREAM(
"["+ ros::this_node::getName()+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Exiting status loop.");
RCLCPP_INFO_STREAM(node_->get_logger(),"["+ std::string(node_->get_name())+"]::[EffectorDriverFrankaHand]::_gripper_status_loop::Exiting status loop.");
}
} // qros

2
src/hand/robot_interface_hand.cpp
View File

@@ -1,4 +1,4 @@
#include "robot_interface_hand.h"
#include "sas_robot_driver_franka/robot_interface_hand.h"

8
src/joint/robot_interface_franka.cpp
View File

@@ -30,10 +30,7 @@
*/
#include "robot_interface_franka.h"
#include <ros/this_node.h>
#include <rosconsole/macros_generated.h>
#include <sas_robot_driver_franka/interfaces/robot_interface_franka.h>
/**
@@ -313,7 +310,8 @@ void RobotInterfaceFranka::initialize()
initialize_flag_ = true;
// initialize and set the robot to default behavior (collision behavior, impedance, etc)
setDefaultBehavior(*robot_sptr_);
// robot_sptr_->setDefaultBehavior();
// setDefaultBehavior(*robot_sptr_);
robot_sptr_->setCollisionBehavior(
franka_configuration_.lower_torque_threshold,
franka_configuration_.upper_torque_threshold,

25
src/joint/sas_robot_driver_franka.cpp
View File

@@ -31,15 +31,18 @@
*/
#include "../../include/sas_robot_driver_franka.h"
#include "sas_clock/sas_clock.h"
#include <sas_robot_driver_franka/sas_robot_driver_franka.h>
#include <sas_core/sas_clock.hpp>
#include <dqrobotics/utils/DQ_Math.h>
#include <ros/this_node.h>
#include <rosconsole/macros_generated.h>
namespace sas
{
RobotDriverFranka::RobotDriverFranka(qros::RobotDynamicProvider* robot_dynamic_provider, const RobotDriverFrankaConfiguration &configuration, std::atomic_bool *break_loops):
RobotDriverFranka::RobotDriverFranka(
const std::shared_ptr<Node> &node,
qros::RobotDynamicsServer* robot_dynamic_provider, const RobotDriverFrankaConfiguration &configuration, std::atomic_bool *break_loops
):
node_(node),
RobotDriver(break_loops),
configuration_(configuration),
robot_dynamic_provider_(robot_dynamic_provider),
@@ -143,7 +146,9 @@ namespace sas
VectorXd RobotDriverFranka::get_joint_positions()
{
if(robot_driver_interface_sptr_->get_err_state()) {
ROS_ERROR_STREAM("["+ros::this_node::getName()+"]::driver interface error on:"+robot_driver_interface_sptr_->get_status_message());
RCLCPP_ERROR_STREAM(node_->get_logger(),
"["+std::string(node_->get_name())+"]::driver interface "
"error on:"+robot_driver_interface_sptr_->get_status_message());
break_loops_->store(true);
}
_update_stiffness_contact_and_pose();
@@ -160,7 +165,9 @@ namespace sas
{
robot_driver_interface_sptr_->set_target_joint_positions(desired_joint_positions_rad);
if(robot_driver_interface_sptr_->get_err_state()) {
ROS_ERROR_STREAM("["+ros::this_node::getName()+"]::driver interface error on:"+robot_driver_interface_sptr_->get_status_message());
RCLCPP_ERROR_STREAM(node_->get_logger(),
"["+std::string(node_->get_name())+"]::driver interface "
"error on:"+robot_driver_interface_sptr_->get_status_message());
break_loops_->store(true);
}
}
@@ -185,7 +192,9 @@ namespace sas
desired_joint_velocities_ = desired_joint_velocities;
robot_driver_interface_sptr_->set_target_joint_velocities(desired_joint_velocities);
if(robot_driver_interface_sptr_->get_err_state()) {
ROS_ERROR_STREAM("["+ros::this_node::getName()+"]::driver interface error on:"+robot_driver_interface_sptr_->get_status_message());
RCLCPP_ERROR_STREAM(node_->get_logger(),
"["+std::string(node_->get_name())+"]::driver interface "
"error on:"+robot_driver_interface_sptr_->get_status_message());
break_loops_->store(true);
}
}

102
src/robot_dynamics/qros_robot_dynamics_client.cpp Normal file
View File

@@ -0,0 +1,102 @@
/*
# Copyright (c) 2024 Quenitin Lin
#
# This file is part of sas_robot_driver_franka.
#
# sas_robot_driver_franka is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# sas_robot_driver_franka is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with sas_robot_driver. If not, see <https://www.gnu.org/licenses/>.
#
# ################################################################
#
# Author: Quenitin Lin
#
# ################################################################
#
# Contributors:
# 1. Quenitin Lin
#
# ################################################################
*/
#include <memory>
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_client.hpp>
using namespace qros;
RobotDynamicsClient::RobotDynamicsClient(const std::shared_ptr<Node> &node, const std::string& topic_prefix):
node_(node), topic_prefix_(topic_prefix == "GET_FROM_NODE"? node->get_name() : topic_prefix),
child_frame_id_(topic_prefix_ + "_stiffness_frame"), parent_frame_id_(topic_prefix_ + "_base"),
last_stiffness_force_(Vector3d::Zero()),
last_stiffness_torque_(Vector3d::Zero()),
last_stiffness_frame_pose_(0)
{
tf_buffer_ = std::make_unique<tf2_ros::Buffer>(node->get_clock());
tf_listener_ = std::make_shared<tf2_ros::TransformListener>(*tf_buffer_);
// Strip potential leading slash
if(child_frame_id_.front() == '/'){child_frame_id_ = child_frame_id_.substr(1);}
if(parent_frame_id_.front() == '/'){parent_frame_id_ = parent_frame_id_.substr(1);}
RCLCPP_INFO_STREAM(node_->get_logger(),
"["+ std::string(node_->get_name()) + "]::Initializing RobotDynamicsClient with prefix " + topic_prefix);
subscriber_cartesian_stiffness_ = node_->create_subscription<geometry_msgs::msg::WrenchStamped>(topic_prefix + "/get/cartesian_stiffness", 1,
std::bind(&RobotDynamicsClient::_callback_cartesian_stiffness, this, std::placeholders::_1)
);
}
void RobotDynamicsClient::_callback_cartesian_stiffness(const geometry_msgs::msg::WrenchStamped &msg)
{
last_stiffness_force_(0) = msg.wrench.force.x;
last_stiffness_force_(1) = msg.wrench.force.y;
last_stiffness_force_(2) = msg.wrench.force.z;
last_stiffness_torque_(0) = msg.wrench.torque.x;
last_stiffness_torque_(1) = msg.wrench.torque.y;
last_stiffness_torque_(2) = msg.wrench.torque.z;
try {
const auto transform_stamped = tf_buffer_->lookupTransform( parent_frame_id_, child_frame_id_, tf2::TimePointZero);
last_stiffness_frame_pose_ = _geometry_msgs_transform_to_dq(transform_stamped.transform);
} catch (tf2::TransformException &ex) {
RCLCPP_WARN_STREAM(node_->get_logger(), "["+ std::string(node_->get_name()) + "]::" + ex.what());
}
}
DQ RobotDynamicsClient::_geometry_msgs_transform_to_dq(const geometry_msgs::msg::Transform& transform)
{
const auto t = DQ(0,transform.translation.x,transform.translation.y,transform.translation.z);
const auto r = DQ(transform.rotation.w, transform.rotation.x, transform.rotation.y, transform.rotation.z);
return r + 0.5 * E_ * t * r;
}
VectorXd RobotDynamicsClient::get_stiffness_force()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicsClient]::calling get_stiffness_force on uninitialized topic");
return last_stiffness_force_;
}
VectorXd RobotDynamicsClient::get_stiffness_torque()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicsClient]::calling get_stiffness_torque on uninitialized topic");
return last_stiffness_torque_;
}
DQ RobotDynamicsClient::get_stiffness_frame_pose()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicsClient]::calling get_stiffness_frame_pose on uninitialized Interface");
return last_stiffness_frame_pose_;
}
bool RobotDynamicsClient::is_enabled() const
{
if(last_stiffness_frame_pose_==0) return false;
return true;
}

103
src/robot_dynamics/qros_robot_dynamics_interface.cpp
View File

@@ -1,103 +0,0 @@
/*
# Copyright (c) 2023 Juan Jose Quiroz Omana
#
# This file is part of sas_robot_driver_franka.
#
# sas_robot_driver_franka is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# sas_robot_driver_franka is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with sas_robot_driver. If not, see <https://www.gnu.org/licenses/>.
#
# ################################################################
#
# Author: Juan Jose Quiroz Omana, email: juanjqogm@gmail.com
#
# ################################################################
#
# Contributors:
# 1. Quenitin Lin
#
# ################################################################
*/
#include <robot_dynamic/qros_robot_dynamics_interface.h>
using namespace qros;
RobotDynamicInterface::RobotDynamicInterface(ros::NodeHandle &nodehandle, const std::string &node_prefix):
RobotDynamicInterface(nodehandle, nodehandle, node_prefix)
{
//Delegated
}
RobotDynamicInterface::RobotDynamicInterface(ros::NodeHandle &publisher_nodehandle, ros::NodeHandle &subscriber_nodehandle, const std::string &node_prefix):
node_prefix_(node_prefix),
child_frame_id_(node_prefix + "_stiffness_frame"),
parent_frame_id_(node_prefix + "_base"),
tf_buffer_(ros::Duration(BUFFER_DURATION_DEFAULT_S)),
tf_listener_(tf_buffer_, subscriber_nodehandle),
last_stiffness_force_(Vector3d::Zero()),
last_stiffness_torque_(Vector3d::Zero()),
last_stiffness_frame_pose_(0)
{
// Strip potential leading slash
if(child_frame_id_.front() == '/'){child_frame_id_ = child_frame_id_.substr(1);}
if(parent_frame_id_.front() == '/'){parent_frame_id_ = parent_frame_id_.substr(1);}
ROS_INFO_STREAM(ros::this_node::getName() + "::Initializing RobotDynamicInterface with prefix " + node_prefix);
subscriber_cartesian_stiffness_ = subscriber_nodehandle.subscribe(node_prefix_ + "/get/cartesian_stiffness", 1, &RobotDynamicInterface::_callback_cartesian_stiffness, this);
}
void RobotDynamicInterface::_callback_cartesian_stiffness(const geometry_msgs::WrenchStampedConstPtr &msg)
{
last_stiffness_force_(0) = msg->wrench.force.x;
last_stiffness_force_(1) = msg->wrench.force.y;
last_stiffness_force_(2) = msg->wrench.force.z;
last_stiffness_torque_(0) = msg->wrench.torque.x;
last_stiffness_torque_(1) = msg->wrench.torque.y;
last_stiffness_torque_(2) = msg->wrench.torque.z;
try {
const auto transform_stamped = tf_buffer_.lookupTransform( parent_frame_id_, child_frame_id_, ros::Time(0));
last_stiffness_frame_pose_ = _geometry_msgs_transform_to_dq(transform_stamped.transform);
} catch (tf2::TransformException &ex) {
ROS_WARN_STREAM(ros::this_node::getName() + "::" + ex.what());
}
}
DQ RobotDynamicInterface::_geometry_msgs_transform_to_dq(const geometry_msgs::Transform& transform)
{
const auto t = DQ(0,transform.translation.x,transform.translation.y,transform.translation.z);
const auto r = DQ(transform.rotation.w, transform.rotation.x, transform.rotation.y, transform.rotation.z);
return r + 0.5 * E_ * t * r;
}
VectorXd RobotDynamicInterface::get_stiffness_force()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicInterface]::calling get_stiffness_force on uninitialized topic");
return last_stiffness_force_;
}
VectorXd RobotDynamicInterface::get_stiffness_torque()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicInterface]::calling get_stiffness_torque on uninitialized topic");
return last_stiffness_torque_;
}
DQ RobotDynamicInterface::get_stiffness_frame_pose()
{
if(!is_enabled()) throw std::runtime_error("[RobotDynamicInterface]::calling get_stiffness_frame_pose on uninitialized Interface");
return last_stiffness_frame_pose_;
}
bool RobotDynamicInterface::is_enabled() const
{
if(last_stiffness_frame_pose_==0) return false;
return true;
}

126
src/robot_dynamics/qros_robot_dynamics_provider.cpp
View File

@@ -1,126 +0,0 @@
/*
# Copyright (c) 2023 Juan Jose Quiroz Omana
#
# This file is part of sas_robot_driver_franka.
#
# sas_robot_driver_franka is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# sas_robot_driver_franka is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with sas_robot_driver. If not, see <https://www.gnu.org/licenses/>.
#
# ################################################################
#
# Author: Juan Jose Quiroz Omana, email: juanjqogm@gmail.com
#
# ################################################################
#
# Contributors:
# 1. Quenitin Lin
#
# ################################################################
*/
#include <robot_dynamic/qros_robot_dynamics_provider.h>
using namespace qros;
RobotDynamicProvider::RobotDynamicProvider(ros::NodeHandle &nodehandle, const std::string &node_prefix):
RobotDynamicProvider(nodehandle, nodehandle, node_prefix)
{
//Delegated
}
RobotDynamicProvider::RobotDynamicProvider(ros::NodeHandle &publisher_nodehandle, ros::NodeHandle &subscriber_nodehandle, const std::string &node_prefix):
node_prefix_(node_prefix),
child_frame_id_(node_prefix + "_stiffness_frame"),
parent_frame_id_(node_prefix + "_base"),
world_to_base_tf_(0)
{
// Strip potential leading slash
if(child_frame_id_.front() == '/'){child_frame_id_ = child_frame_id_.substr(1);}
if(parent_frame_id_.front() == '/'){parent_frame_id_ = parent_frame_id_.substr(1);}
ROS_INFO_STREAM(ros::this_node::getName() + "::Initializing RobotDynamicProvider with prefix " + node_prefix);
publisher_cartesian_stiffness_ = publisher_nodehandle.advertise<geometry_msgs::WrenchStamped>(node_prefix + "/get/cartesian_stiffness", 1);
}
geometry_msgs::Transform RobotDynamicProvider::_dq_to_geometry_msgs_transform(const DQ& pose)
{
geometry_msgs::Transform tf_msg;
const auto t = translation(pose);
const auto r = rotation(pose);
tf_msg.translation.x = t.q(1);
tf_msg.translation.y = t.q(2);
tf_msg.translation.z = t.q(3);
tf_msg.rotation.w = r.q(0);
tf_msg.rotation.x = r.q(1);
tf_msg.rotation.y = r.q(2);
tf_msg.rotation.z = r.q(3);
return tf_msg;
}
void RobotDynamicProvider::set_world_to_base_tf(const DQ& world_to_base_tf)
{
if(world_to_base_tf_==0)
{
world_to_base_tf_ = world_to_base_tf;
_publish_base_static_tf();
}else
{
throw std::runtime_error("The world to base transform has already been set");
}
}
void RobotDynamicProvider::_publish_base_static_tf()
{
geometry_msgs::TransformStamped base_tf;
base_tf.transform = _dq_to_geometry_msgs_transform(world_to_base_tf_);
base_tf.header.stamp = ros::Time::now();
base_tf.header.frame_id = WORLD_FRAME_ID;
base_tf.child_frame_id = parent_frame_id_;
static_base_tf_broadcaster_.sendTransform(base_tf);
}
void RobotDynamicProvider::publish_stiffness(const DQ& base_to_stiffness, const Vector3d& force, const Vector3d& torque)
{
std_msgs::Header header;
header.stamp = ros::Time::now();
header.seq = seq_++;
geometry_msgs::WrenchStamped msg;
msg.header = header;
msg.header.frame_id = child_frame_id_;
msg.wrench.force.x = force(0);
msg.wrench.force.y = force(1);
msg.wrench.force.z = force(2);
msg.wrench.torque.x = torque(0);
msg.wrench.torque.y = torque(1);
msg.wrench.torque.z = torque(2);
publisher_cartesian_stiffness_.publish(msg);
if(seq_ % REDUCE_TF_PUBLISH_RATE == 0)
{
geometry_msgs::TransformStamped tf_msg;
tf_msg.transform = _dq_to_geometry_msgs_transform(base_to_stiffness);
tf_msg.header = header;
tf_msg.header.frame_id = parent_frame_id_;
tf_msg.child_frame_id = child_frame_id_;
tf_broadcaster_.sendTransform(tf_msg);
}
}
bool RobotDynamicProvider::is_enabled() const
{
return true; //Always enabled
}

34
src/robot_dynamics/qros_robot_dynamic_py.cpp → src/robot_dynamics/qros_robot_dynamics_py.cpp
View File

@@ -32,29 +32,29 @@
#include <pybind11/stl.h>
#include <pybind11/eigen.h>
#include <robot_dynamic/qros_robot_dynamics_provider.h>
#include <robot_dynamic/qros_robot_dynamics_interface.h>
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_client.hpp>
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_server.hpp>
namespace py = pybind11;
using RDI = qros::RobotDynamicInterface;
using RDP = qros::RobotDynamicProvider;
using RDC = qros::RobotDynamicsClient;
using RDS = qros::RobotDynamicsServer;
PYBIND11_MODULE(_qros_robot_dynamic, m)
{
py::class_<RDI>(m, "RobotDynamicsInterface")
.def(py::init<const std::string&>())
.def("get_stiffness_force",&RDI::get_stiffness_force)
.def("get_stiffness_torque",&RDI::get_stiffness_torque)
.def("get_stiffness_frame_pose",&RDI::get_stiffness_frame_pose)
.def("is_enabled",&RDI::is_enabled,"Returns true if the RobotDynamicInterface is enabled.")
.def("get_topic_prefix",&RDI::get_topic_prefix);
py::class_<RDC>(m, "RobotDynamicsClient")
.def(py::init<const std::shared_ptr<rclcpp::Node>&,const std::string&>())
.def("get_stiffness_force",&RDC::get_stiffness_force)
.def("get_stiffness_torque",&RDC::get_stiffness_torque)
.def("get_stiffness_frame_pose",&RDC::get_stiffness_frame_pose)
.def("is_enabled",&RDC::is_enabled,"Returns true if the RobotDynamicInterface is enabled.")
.def("get_topic_prefix",&RDC::get_topic_prefix);
py::class_<RDP>(m, "RobotDynamicsProvider")
.def(py::init<const std::string&>())
.def("publish_stiffness",&RDP::publish_stiffness)
.def("set_world_to_base_tf", &RDP::set_world_to_base_tf)
.def("is_enabled",&RDP::is_enabled,"Returns true if the RobotDynamicProvider is enabled.")
.def("get_topic_prefix",&RDP::get_topic_prefix);
py::class_<RDS>(m, "RobotDynamicsServer")
.def(py::init<const std::shared_ptr<rclcpp::Node>&,const std::string&>())
.def("publish_stiffness",&RDS::publish_stiffness)
.def("set_world_to_base_tf", &RDS::set_world_to_base_tf)
.def("is_enabled",&RDS::is_enabled,"Returns true if the RobotDynamicProvider is enabled.")
.def("get_topic_prefix",&RDS::get_topic_prefix);
}

116
src/robot_dynamics/qros_robot_dynamics_server.cpp Normal file
View File

@@ -0,0 +1,116 @@
/*
# Copyright (c) 2024 Quenitin Lin
#
# This file is part of sas_robot_driver_franka.
#
# sas_robot_driver_franka is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# sas_robot_driver_franka is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with sas_robot_driver. If not, see <https://www.gnu.org/licenses/>.
#
# ################################################################
#
# Author: Quenitin Lin
#
# ################################################################
#
# Contributors:
# 1. Quenitin Lin
#
# ################################################################
*/
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_server.hpp>
using namespace qros;
RobotDynamicsServer::RobotDynamicsServer(const std::shared_ptr<Node> &node, const std::string& topic_prefix):
node_(node), topic_prefix_(topic_prefix == "GET_FROM_NODE"? node->get_name() : topic_prefix),
child_frame_id_(topic_prefix_ + "_stiffness_frame"), parent_frame_id_(topic_prefix_ + "_base"),
world_to_base_tf_(0)
{
// Strip potential leading slash
if(child_frame_id_.front() == '/'){child_frame_id_ = child_frame_id_.substr(1);}
if(parent_frame_id_.front() == '/'){parent_frame_id_ = parent_frame_id_.substr(1);}
RCLCPP_INFO_STREAM(node_->get_logger(),
"["+ std::string(node_->get_name()) + "]::Initializing RobotDynamicsServer with prefix " + topic_prefix);
publisher_cartesian_stiffness_ = node_->create_publisher<geometry_msgs::msg::WrenchStamped>(topic_prefix + "/get/cartesian_stiffness", 1);
}
geometry_msgs::msg::Transform RobotDynamicsServer::_dq_to_geometry_msgs_transform(const DQ& pose)
{
geometry_msgs::msg::Transform tf_msg;
const auto t = translation(pose);
const auto r = rotation(pose);
tf_msg.translation.x = t.q(1);
tf_msg.translation.y = t.q(2);
tf_msg.translation.z = t.q(3);
tf_msg.rotation.w = r.q(0);
tf_msg.rotation.x = r.q(1);
tf_msg.rotation.y = r.q(2);
tf_msg.rotation.z = r.q(3);
return tf_msg;
}
void RobotDynamicsServer::set_world_to_base_tf(const DQ& world_to_base_tf)
{
if(world_to_base_tf_==0)
{
world_to_base_tf_ = world_to_base_tf;
_publish_base_static_tf();
}else
{
throw std::runtime_error("["+ std::string(node_->get_name()) + "]::[RobotDynamicsServer]::The world to base transform has already been set");
}
}
void RobotDynamicsServer::_publish_base_static_tf()
{
geometry_msgs::msg::TransformStamped base_tf;
base_tf.transform = _dq_to_geometry_msgs_transform(world_to_base_tf_);
base_tf.header.stamp = node_->now();
base_tf.header.frame_id = WORLD_FRAME_ID;
base_tf.child_frame_id = parent_frame_id_;
static_base_tf_broadcaster_->sendTransform(base_tf);
}
void RobotDynamicsServer::publish_stiffness(const DQ& base_to_stiffness, const Vector3d& force, const Vector3d& torque)
{
std_msgs::msg::Header header;
header.set__stamp(node_->now());
geometry_msgs::msg::WrenchStamped msg;
msg.header = header;
msg.header.set__frame_id(child_frame_id_);
msg.wrench.force.set__x(force(0));
msg.wrench.force.set__y(force(1));
msg.wrench.force.set__z(force(2));
msg.wrench.torque.set__x(torque(0));
msg.wrench.torque.set__y(torque(1));
msg.wrench.torque.set__z(torque(2));
publisher_cartesian_stiffness_->publish(msg);
if(seq_ % REDUCE_TF_PUBLISH_RATE == 0)
{
geometry_msgs::msg::TransformStamped tf_msg;
tf_msg.transform = _dq_to_geometry_msgs_transform(base_to_stiffness);
tf_msg.set__header(header);
tf_msg.header.set__frame_id(parent_frame_id_);
tf_msg.set__child_frame_id(child_frame_id_);
tf_broadcaster_->sendTransform(tf_msg);
}
}
bool RobotDynamicsServer::is_enabled() const
{
return true; //Always enabled
}

65
src/sas_robot_driver_franka_hand_node.cpp
View File

@@ -33,10 +33,9 @@
#include <exception>
#include <dqrobotics/utils/DQ_Math.h>
#include <sas_common/sas_common.h>
#include <sas_conversions/eigen3_std_conversions.h>
#include <sas_robot_driver/sas_robot_driver_ros.h>
#include "hand/qros_effector_driver_franka_hand.h"
#include <sas_common/sas_common.hpp>
// #include <sas_conversions/eigen3_std_conversions.hpp>
#include <sas_robot_driver_franka/interfaces/qros_effector_driver_franka_hand.h>
/*********************************************
@@ -52,14 +51,14 @@ void sig_int_handler(int)
template<typename T>
void get_optional_parameter(const std::string &node_prefix, ros::NodeHandle &nh, const std::string &param_name, T &param)
void get_optional_parameter(std::shared_ptr<Node> node, const std::string &param_name, T &param)
{
if(nh.hasParam(node_prefix + param_name))
if(node->has_parameter(param_name))
{
sas::get_ros_param(nh,param_name,param);
sas::get_ros_parameter(node,param_name,param);
}else
{
ROS_INFO_STREAM(ros::this_node::getName() + "::Parameter " + param_name + " not found. Using default value. " + std::to_string(param));
RCLCPP_INFO_STREAM(node->get_logger(), "["+std::string(node->get_name())+"]:Parameter " + param_name + " not found. Using default value. " + std::to_string(param));
}
}
@@ -69,55 +68,53 @@ int main(int argc, char **argv)
{
if(signal(SIGINT, sig_int_handler) == SIG_ERR)
{
throw std::runtime_error(ros::this_node::getName() + "::Error setting the signal int handler.");
throw std::runtime_error("Error setting the signal int handler.");
}
ros::init(argc, argv, "sas_robot_driver_franka_hand_node", ros::init_options::NoSigintHandler);
ROS_WARN("=====================================================================");
ROS_WARN("---------------------------Quentin Lin-------------------------------");
ROS_WARN("=====================================================================");
ROS_INFO_STREAM(ros::this_node::getName()+"::Loading parameters from parameter server.");
const std::string& effector_driver_provider_prefix = ros::this_node::getName();
rclcpp::init(argc,argv,rclcpp::InitOptions(),rclcpp::SignalHandlerOptions::None);
auto node = std::make_shared<rclcpp::Node>("sas_robot_driver_franka_hand_node");
const auto node_name = std::string(node->get_name());
RCLCPP_WARN(node->get_logger(),"=====================================================================");
RCLCPP_WARN(node->get_logger(),"---------------------------Quentin Lin-------------------------------");
RCLCPP_WARN(node->get_logger(),"=====================================================================");
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Loading parameters from parameter server.");
ros::NodeHandle nh;
qros::EffectorDriverFrankaHandConfiguration robot_driver_franka_hand_configuration;
sas::get_ros_param(nh,"/robot_ip_address",robot_driver_franka_hand_configuration.robot_ip);
get_optional_parameter(effector_driver_provider_prefix,nh,"/thread_sampling_time_nsec",robot_driver_franka_hand_configuration.thread_sampeling_time_ns);
get_optional_parameter(effector_driver_provider_prefix,nh,"/default_force",robot_driver_franka_hand_configuration.default_force);
get_optional_parameter(effector_driver_provider_prefix,nh,"/default_speed",robot_driver_franka_hand_configuration.default_speed);
get_optional_parameter(effector_driver_provider_prefix,nh,"/default_epsilon_inner",robot_driver_franka_hand_configuration.default_epsilon_inner);
get_optional_parameter(effector_driver_provider_prefix,nh,"/default_epsilon_outer",robot_driver_franka_hand_configuration.default_epsilon_outer);
sas::get_ros_parameter(node,"robot_ip_address",robot_driver_franka_hand_configuration.robot_ip);
sas::get_ros_parameter(node,"thread_sampling_time_sec",robot_driver_franka_hand_configuration.thread_sampeling_time_s);
sas::get_ros_parameter(node,"default_force",robot_driver_franka_hand_configuration.default_force);
sas::get_ros_parameter(node,"default_speed",robot_driver_franka_hand_configuration.default_speed);
sas::get_ros_parameter(node,"default_epsilon_inner",robot_driver_franka_hand_configuration.default_epsilon_inner);
sas::get_ros_parameter(node,"default_epsilon_outer",robot_driver_franka_hand_configuration.default_epsilon_outer);
qros::EffectorDriverFrankaHand franka_hand_driver(
effector_driver_provider_prefix,
node_name,
robot_driver_franka_hand_configuration,
nh,
node,
&kill_this_process
);
try
{
ROS_INFO_STREAM(ros::this_node::getName()+"::Instantiating Franka hand.");
RCLCPP_INFO_STREAM(node->get_logger(),"["+node_name+"]::Instantiating Franka hand.");
franka_hand_driver.connect();
franka_hand_driver.initialize();
ROS_INFO_STREAM(ros::this_node::getName()+"::Instantiating control loop.");
RCLCPP_INFO_STREAM(node->get_logger(),"["+node_name+"]::Starting control loop.");
franka_hand_driver.start_control_loop();
}
catch (const std::exception& e)
{
ROS_ERROR_STREAM(ros::this_node::getName() + "::Exception::" + e.what());
RCLCPP_ERROR_STREAM(node->get_logger(), "["+node_name+"]::Exception::" + e.what());
}catch (...)
{
ROS_ERROR_STREAM(ros::this_node::getName() + "::Exception::Unknown exception.");
RCLCPP_ERROR_STREAM(node->get_logger(), "["+node_name+"]::Exception::Unknown exception.");
}
ROS_INFO_STREAM(ros::this_node::getName()+"::Exiting...");
RCLCPP_INFO_STREAM(node->get_logger(),"["+node_name+"]::Exiting...");
franka_hand_driver.deinitialize();
ROS_INFO_STREAM(ros::this_node::getName()+"::deinitialized.");
RCLCPP_INFO_STREAM(node->get_logger(),"["+node_name+"]::Deinitialized.");
franka_hand_driver.disconnect();
ROS_INFO_STREAM(ros::this_node::getName()+"::disconnected.");
RCLCPP_INFO_STREAM(node->get_logger(),"["+node_name+"]::Disconnected.");
return 0;

84
src/sas_robot_driver_franka_node.cpp
View File

@@ -26,6 +26,8 @@
# 1. Juan Jose Quiroz Omana (juanjqogm@gmail.com)
# - Adapted from sas_robot_driver_denso_node.cpp
# (https://github.com/SmartArmStack/sas_robot_driver_denso/blob/master/src/sas_robot_driver_denso_node.cpp)
# 2. Quentin Lin
# - Adaption to ROS2
#
# ################################################################
*/
@@ -36,11 +38,11 @@
#include <exception>
#include <dqrobotics/utils/DQ_Math.h>
#include <dqrobotics/interfaces/json11/DQ_JsonReader.h>
#include <sas_common/sas_common.h>
#include <sas_conversions/eigen3_std_conversions.h>
#include <sas_robot_driver/sas_robot_driver_ros.h>
#include "sas_robot_driver_franka.h"
#include <robot_dynamic/qros_robot_dynamics_provider.h>
#include <sas_common/sas_common.hpp>
#include <sas_conversions/eigen3_std_conversions.hpp>
#include <sas_robot_driver/sas_robot_driver_ros.hpp>
#include <sas_robot_driver_franka/sas_robot_driver_franka.h>
#include <sas_robot_driver_franka/robot_dynamic/qros_robot_dynamics_server.hpp>
/*********************************************
@@ -80,67 +82,68 @@ int main(int argc, char **argv)
{
if(signal(SIGINT, sig_int_handler) == SIG_ERR)
{
throw std::runtime_error(ros::this_node::getName() + "::Error setting the signal int handler.");
throw std::runtime_error("Error setting the signal int handler.");
}
ros::init(argc, argv, "sas_robot_driver_franka_node", ros::init_options::NoSigintHandler);
ROS_WARN("=====================================================================");
ROS_WARN("----------------------Juan Jose Quiroz Omana------------------------");
ROS_WARN("=====================================================================");
ROS_INFO_STREAM(ros::this_node::getName()+"::Loading parameters from parameter server.");
rclcpp::init(argc,argv,rclcpp::InitOptions(),rclcpp::SignalHandlerOptions::None);
auto node = std::make_shared<rclcpp::Node>("sas_robot_driver_franka_node");
const auto node_name = std::string(node->get_name());
RCLCPP_WARN(node->get_logger(),"=====================================================================");
RCLCPP_WARN(node->get_logger(),"-----------------Adapted by Quentin Lin ------------------------");
RCLCPP_WARN(node->get_logger(),"=====================================================================");
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Loading parameters from parameter server.");
ros::NodeHandle nh;
sas::RobotDriverFrankaConfiguration robot_driver_franka_configuration;
RobotInterfaceFranka::FrankaInterfaceConfiguration franka_interface_configuration;
sas::get_ros_param(nh,"/robot_ip_address",robot_driver_franka_configuration.ip_address);
sas::get_ros_param(nh,"/robot_mode", robot_driver_franka_configuration.mode);
sas::get_ros_parameter(node,"robot_ip_address",robot_driver_franka_configuration.ip_address);
sas::get_ros_parameter(node,"robot_mode", robot_driver_franka_configuration.mode);
double upper_scale_factor = 1.0;
std::vector<std::string> all_params;
if(nh.hasParam(ros::this_node::getName()+"/force_upper_limits_scaling_factor"))
if(node->has_parameter("force_upper_limits_scaling_factor"))
{
sas::get_ros_param(nh,"/force_upper_limits_scaling_factor",upper_scale_factor);
ROS_WARN_STREAM(ros::this_node::getName()+"::Set force upper limits scaling factor: " << upper_scale_factor);
sas::get_ros_parameter(node,"force_upper_limits_scaling_factor",upper_scale_factor);
RCLCPP_WARN_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Set force upper limits scaling factor: " << upper_scale_factor);
}
if(nh.hasParam(ros::this_node::getName()+"/upper_torque_threshold")) {
ROS_INFO_STREAM(ros::this_node::getName()+"::Upper torque threshold override and set.");
if(node->has_parameter("upper_torque_threshold")) {
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Upper torque threshold override and set.");
std::vector<double> upper_torque_threshold_std_vec;
sas::get_ros_param(nh,"/upper_torque_threshold",upper_torque_threshold_std_vec);
sas::get_ros_parameter(node,"upper_torque_threshold",upper_torque_threshold_std_vec);
franka_interface_configuration.upper_torque_threshold = std_vec_to_std_array<double,7>(upper_torque_threshold_std_vec);
}else {
ROS_INFO_STREAM(ros::this_node::getName()+"::Upper torque threshold not set. Using default with value scalling.");
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Upper torque threshold not set. Using default with value scalling.");
franka_interface_configuration.upper_torque_threshold = apply_scale_to_std_array(franka_interface_configuration.upper_torque_threshold, upper_scale_factor);
}
if(nh.hasParam(ros::this_node::getName()+"/upper_force_threshold")) {
ROS_INFO_STREAM(ros::this_node::getName()+"::Upper force threshold override and set.");
if(node->has_parameter("upper_force_threshold")) {
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Upper force threshold override and set.");
std::vector<double> upper_torque_threshold_std_vec;
sas::get_ros_param(nh,"/upper_force_threshold",upper_torque_threshold_std_vec);
sas::get_ros_parameter(node,"upper_force_threshold",upper_torque_threshold_std_vec);
franka_interface_configuration.upper_force_threshold = std_vec_to_std_array<double,6>(upper_torque_threshold_std_vec);
}else {
ROS_INFO_STREAM(ros::this_node::getName()+"::Upper force threshold not set. Using default with value scalling.");
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Upper force threshold not set. Using default with value scalling.");
franka_interface_configuration.upper_force_threshold = apply_scale_to_std_array(franka_interface_configuration.upper_force_threshold, upper_scale_factor);
}
if(nh.hasParam(ros::this_node::getName()+"/robot_parameter_file_path"))
if(node->has_parameter("robot_parameter_file_path"))
{
std::string robot_parameter_file_path;
sas::get_ros_param(nh,"/robot_parameter_file_path",robot_parameter_file_path);
ROS_INFO_STREAM(ros::this_node::getName()+"::Loading robot parameters from file: " + robot_parameter_file_path);
sas::get_ros_parameter(node,"robot_parameter_file_path",robot_parameter_file_path);
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Loading robot parameters from file: " + robot_parameter_file_path);
const auto robot = DQ_JsonReader::get_from_json<DQ_SerialManipulatorDH>(robot_parameter_file_path);
robot_driver_franka_configuration.robot_reference_frame = robot.get_reference_frame();
}else{ROS_INFO_STREAM(ros::this_node::getName()+"::Robot parameter file path not set. Robot Model Unknow.");}
}else{RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Robot parameter file path not set. Robot Model Unknow.");}
robot_driver_franka_configuration.interface_configuration = franka_interface_configuration;
sas::RobotDriverROSConfiguration robot_driver_ros_configuration;
sas::get_ros_param(nh,"/thread_sampling_time_nsec",robot_driver_ros_configuration.thread_sampling_time_nsec);
sas::get_ros_param(nh,"/q_min",robot_driver_ros_configuration.q_min);
sas::get_ros_param(nh,"/q_max",robot_driver_ros_configuration.q_max);
sas::get_ros_parameter(node,"thread_sampling_time_sec",robot_driver_ros_configuration.thread_sampling_time_sec);
sas::get_ros_parameter(node,"q_min",robot_driver_ros_configuration.q_min);
sas::get_ros_parameter(node,"q_max",robot_driver_ros_configuration.q_max);
// initialize the robot dynamic provider
robot_driver_ros_configuration.robot_driver_provider_prefix = ros::this_node::getName();
qros::RobotDynamicProvider robot_dynamic_provider(nh, robot_driver_ros_configuration.robot_driver_provider_prefix);
robot_driver_ros_configuration.robot_driver_provider_prefix = node_name;
qros::RobotDynamicsServer robot_dynamic_provider(node, robot_driver_ros_configuration.robot_driver_provider_prefix);
if(robot_driver_franka_configuration.robot_reference_frame!=0)
{
robot_dynamic_provider.set_world_to_base_tf(robot_driver_franka_configuration.robot_reference_frame);
@@ -148,16 +151,17 @@ int main(int argc, char **argv)
try
{
ROS_INFO_STREAM(ros::this_node::getName()+"::Instantiating Franka robot.");
sas::RobotDriverFranka robot_driver_franka(
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Instantiating Franka robot.");
auto robot_driver_franka = std::make_shared<sas::RobotDriverFranka>(
node,
&robot_dynamic_provider,
robot_driver_franka_configuration,
&kill_this_process
);
//robot_driver_franka.set_joint_limits({qmin, qmax});
ROS_INFO_STREAM(ros::this_node::getName()+"::Instantiating RobotDriverROS.");
sas::RobotDriverROS robot_driver_ros(nh,
&robot_driver_franka,
RCLCPP_INFO_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Instantiating RobotDriverROS.");
sas::RobotDriverROS robot_driver_ros(node,
robot_driver_franka,
robot_driver_ros_configuration,
&kill_this_process);
robot_driver_ros.control_loop();
@@ -165,7 +169,7 @@ int main(int argc, char **argv)
catch (const std::exception& e)
{
kill_this_process = true;
ROS_ERROR_STREAM(ros::this_node::getName() + "::Exception::" + e.what());
RCLCPP_ERROR_STREAM_ONCE(node->get_logger(),"["+node_name+"]::Exception::" + e.what());
}

7
srv/Grasp.srv
View File

@@ -1,7 +0,0 @@
float32 width
float32 speed
float32 force
float32 epsilon_inner
float32 epsilon_outer
---
bool success

4
srv/Move.srv
View File

@@ -1,4 +0,0 @@
float32 width
float32 speed
---
bool success