def generate_launch_description():
ld = launch.LaunchDescription()
config = os.path.join(
get_package_share_directory('triton_object_recognition'), 'config',
'tiny_yolov3.yaml')
object_recognizer = ComposableNode(
name='object_recognizer',
namespace='/triton',
package='triton_object_recognition',
parameters=[config],
plugin='triton_object_recognition::ObjectRecognizer')
object_recognizer_container = ComposableNodeContainer(
name='object_recognizer_container',
namespace='/tritonimage_underwater',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[object_recognizer],
output='screen')
ld.add_action(object_recognizer_container)
return ld
def generate_launch_description():
param_config = os.path.join(
get_package_share_directory('imu_filter_madgwick'), 'config',
'imu_filter.yaml')
# https://github.com/ros2/rclcpp/issues/715#issuecomment-490425249
# Composable Nodes use different yaml parsing than a standalone node.
# This code will load the parameters from the yaml (removing the namespace/nodename/ros__parameters heading) so
# that the parameters are parsed and named properly for the composable node.
with open(param_config, 'r') as f:
params = yaml.safe_load(f)['imu_filter']['ros__parameters']
container = ComposableNodeContainer(
node_name='imu_filter_container',
node_namespace='',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(package='imu_filter_madgwick',
node_plugin='ImuFilterMadgwickRos',
node_name='imu_filter',
parameters=[params])
],
output='screen')
return launch.LaunchDescription([container])
def node(self, package, executable=None, plugin=None, **node_args):
'''
Add a node to the launch tree.
* package -- name of the package
* executable (classical node) -- name of the node within the package
* plugin (inside a composition group) -- name of the composed node plugin within the package
* node_args -- any other args passed to the node constructor
'''
if executable is None and not self.composed:
raise Exception(
'Indicate the executable name when adding a classical node')
if plugin is None and self.composed:
raise Exception(
'Indicate the plugin name when adding a composable node')
if 'arguments' in node_args and type(node_args['arguments']) != list:
if type(node_args['arguments']) == str:
node_args['arguments'] = node_args['arguments'].split()
else:
node_args['arguments'] = [node_args['arguments']]
if 'parameters' in node_args and type(node_args['parameters']) == dict:
node_args['parameters'] = [node_args['parameters']]
if not self.composed:
self.entity(
Node(package=package, executable=executable, **node_args))
else:
# check plugin name - add package if needed
if '::' not in plugin:
plugin = '{}::{}'.format(package, plugin)
self.entity(
ComposableNode(package=package, plugin=plugin, **node_args))
def generate_launch_description():
ld = LaunchDescription()
################################
# Drivers
################################
usb_camera = launch_ros.actions.ComposableNodeContainer(
node_name="usb_camera_driver_container",
package='rclcpp_components',
node_namespace=NAMESPACE,
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(package='usb_camera_driver',
node_plugin='usb_camera_driver::CameraDriver',
node_name='usb_camera_driver_node',
parameters=[{
"camera_calibration_file":
"file:///<file-path>"
}])
],
output='screen')
ld.add_action(usb_camera)
return ld
def generate_launch_description():
ld = launch.LaunchDescription()
pkg_name = "ros2_examples"
pkg_share_path = get_package_share_directory(pkg_name)
namespace = 'nmspc1'
ld.add_action(
ComposableNodeContainer(
namespace='',
name=namespace + '_tf2_broadcaster_example',
package='rclcpp_components',
executable=
'component_container_mt', # this struggles to maintain timer rates!!!!!!!!!!
# executable='component_container', # this maintains the rates fine
composable_node_descriptions=[
ComposableNode(
package=pkg_name,
plugin='ros2_examples::Tf2BroadcasterExample',
namespace=namespace,
name='tf2_broadcaster_example',
),
],
output='screen',
))
return ld
def generate_launch_description():
ld = launch.LaunchDescription()
pkg_name = "ros2_examples"
pkg_share_path = get_package_share_directory(pkg_name)
namespace = 'nmspc1'
ld.add_action(
ComposableNodeContainer(
namespace='',
name=namespace + '_publisher_example',
package='rclcpp_components',
executable=
'component_container_mt', # this struggles to maintain timer rates!!!!!!!!!!
# executable='component_container', # this maintains the rates fine
composable_node_descriptions=[
ComposableNode(
package=pkg_name,
plugin='ros2_examples::PublisherExample',
namespace=namespace,
name='publisher_example',
parameters=[
pkg_share_path + '/config/publisher_example.yaml',
],
remappings=[
# topics
("~/topic_out", "~/topic"),
],
),
],
output='screen',
))
return ld
def generate_launch_description():
share_dir = ament_index_python.packages.get_package_share_directory(
'cmd_vel_mux')
# Passing parameters to a composed node must be done via a dictionary of
# key -> value pairs. Here we read in the data from the configuration file
# and create a dictionary of it that the ComposableNode will accept.
params_file = os.path.join(share_dir, 'config', 'cmd_vel_mux_params.yaml')
with open(params_file, 'r') as f:
params = yaml.safe_load(f)['cmd_vel_mux']['ros__parameters']
container = ComposableNodeContainer(
node_name='cmd_vel_mux_container',
node_namespace='',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(package='cmd_vel_mux',
node_plugin='cmd_vel_mux::CmdVelMux',
node_name='cmd_vel_mux',
parameters=[params]),
],
output='both',
)
return LaunchDescription([container])
def getCostmapCalculatorComponent():
component = ComposableNode(
package='robotx_costmap_calculator',
plugin='robotx_costmap_calculator::CostmapCalculatorComponent',
namespace='perception',
name='costmap_calculator_node')
return component
def generate_launch_description():
"""create exposure control node."""
container = ComposableNodeContainer(
name='exposure_control_container',
namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='exposure_control_ros2',
plugin='exposure_control_ros2::ExposureControl',
name=LaunchConfig('node_name'),
parameters=[{'cam_name': LaunchConfig('camera_name'),
'max_gain': 10.0,
'gain_priority': False,
'brightness_target': 100,
'max_exposure_time': 9000.0,
'min_exposure_time': 3000.0
}],
remappings=[('~/meta', ['/', LaunchConfig('camera_name'),'/meta']),],
extra_arguments=[{'use_intra_process_comms': True}],
),
],
output='screen',
)
name_arg = LaunchArg('node_name', default_value=['exposure_control'], description='name of node')
cam_arg = LaunchArg('camera_name', default_value=['cam_0'], description='name of camera')
return launch.LaunchDescription([name_arg, cam_arg, container])
def generate_launch_description():
"""Generate launch description with multiple components."""
ros2_serial_example_directory = os.path.join(
get_package_share_directory('ros2_serial_example'), 'config')
param_config = os.path.join(ros2_serial_example_directory,
'default_ros2_to_serial_bridge_params.yaml')
with open(param_config, 'r') as f:
params = yaml.safe_load(
f)['iris_0/ros2_to_serial_bridge']['ros__parameters']
print(params)
container = ComposableNodeContainer(
node_name='componsable_drone_node',
node_namespace='/iris_0',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(
node_name='ros2_to_serial_bridge',
node_namespace='/iris_0',
package='ros2_serial_example',
node_plugin='ros2_to_serial_bridge::ROS2ToSerialBridge',
parameters=[params]),
],
output='screen',
)
return launch.LaunchDescription([container])
def generate_launch_description():
localization_config = load_yaml('crs_application',
'config/localization.yaml')
general_params = {'general': localization_config['general']}
icp_params = {'icp': localization_config['icp']}
crop_boxes_params = {'crop_boxes': localization_config['crop_boxes']}
# ComposableNodeContainer not used because it fails to load parameters, using node instead
container = ComposableNodeContainer(
node_name='perception',
node_namespace=
GLOBAL_NS, #launch.substitutions.LaunchConfiguration('global_ns'),
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='crs_perception',
node_plugin='crs_perception::LocalizeToPart',
node_name='part_localization',
node_namespace=
GLOBAL_NS, #launch.substitutions.LaunchConfiguration('global_ns')),
parameters=[icp_params, crop_boxes_params])
],
output='screen')
part_localization_node = Node(
node_executable='localize_to_part',
package='crs_perception',
node_name='part_localization',
node_namespace=GLOBAL_NS,
output='screen',
parameters=[general_params, icp_params, crop_boxes_params])
return launch.LaunchDescription([part_localization_node])
def generate_launch_description():
ld = launch.LaunchDescription()
pkg_name = "ros2_examples"
pkg_share_path = get_package_share_directory(pkg_name)
namespace = 'nmspc1'
ld.add_action(
ComposableNodeContainer(
namespace='',
name=namespace + '_service_server_example',
package='rclcpp_components',
executable='component_container_mt',
composable_node_descriptions=[
ComposableNode(
package=pkg_name,
plugin='ros2_examples::ServiceServerExample',
namespace=namespace,
name='service_server_example',
parameters=[
pkg_share_path + '/config/service_server_example.yaml',
],
remappings=[
# services
("~/set_bool_in", "~/set_bool"),
],
)
],
output='screen',
))
return ld
def get_acrobat_sensor_nodes(sensor_toggles: Dict[str, bool]):
arducam_node = ComposableNode(
package='arducam',
node_plugin='ArducamDriver',
node_name='arducam_driver',
parameters=[{
'config_name': 'camera_register_config.cfg'
}]
)
msp_bridge_node = ComposableNode(
package='msp_bridge',
node_plugin='acrobat::msp_bridge::MspBridge',
node_name='msp_bridge',
parameters=[{
'device': "/dev/ttyUSB0",
'baudrate': 500000,
'imu_frequency': 100.0,
'motor_frequency': 100.0
}],
)
vectornav_node = ComposableNode(
package='vectornav',
node_plugin='vn_ros::VectorNavNode',
node_name='vectornav_node',
parameters=[{
"sensor_port": "/dev/ttyUSB0",
"baudrate": 921600,
"sample_rate": 200,
"topic": "/acrobat/imu",
"frame_id": "acrobat_imu",
"gyroscope_variance": 1e-3,
"accelerometer_variance": 1e-3
}],
)
sensor_nodes = []
if sensor_toggles['arducam']:
sensor_nodes.append(arducam_node)
if sensor_toggles['msp_bridge']:
sensor_nodes.append(msp_bridge_node)
if sensor_toggles['vectornav']:
sensor_nodes.append(vectornav_node)
return sensor_nodes
def generate_launch_description():
# TODO(jacobperron): Include image_proc launch file when it exists
return LaunchDescription([
DeclareLaunchArgument(
name='approximate_sync',
default_value='True',
description=
'Whether to use approximate synchronization of topics. Set to true if '
'the left and right cameras do not produce exactly synced timestamps.'
),
ComposableNodeContainer(
package='rclcpp_components',
node_executable='component_container',
name='stereo_image_proc_container',
namespace='',
output='screen',
composable_node_descriptions=[
ComposableNode(package='stereo_image_proc',
plugin='stereo_image_proc::DisparityNode',
namespace='/mycamera',
parameters=[{
'approximate_sync':
LaunchConfiguration('approximate_sync'),
'use_sim_time':
True
}],
remappings=[('right/image_rect',
'right/image_filtered'),
('left/image_rect',
'left/image_filtered'),
('left/image_rect_color',
'left/image_filtered')]),
ComposableNode(package='stereo_image_proc',
plugin='stereo_image_proc::PointCloudNode',
namespace='/mycamera',
parameters=[{
'approximate_sync':
LaunchConfiguration('approximate_sync'),
'use_sim_time':
True
}],
remappings=[('left/image_rect_color',
'left/image_filtered')]),
],
),
])
def generate_launch_description():
# package root
share_dir = ament_index_python.packages.get_package_share_directory('kobuki_auto_docking')
# kobuki_ros node
params_file = os.path.join(share_dir, 'config', 'kobuki_node_params.yaml')
with open(params_file, 'r') as f:
params = yaml.safe_load(f)['kobuki_ros_node']['ros__parameters']
kobuki_node = ComposableNode(
package='kobuki_node',
plugin='kobuki_node::KobukiRos',
name='kobuki_ros_node',
parameters=[params]
)
# kobuki_auto_docking
params_file = os.path.join(share_dir, 'config', 'auto_docking.yaml')
with open(params_file, 'r') as f:
params = yaml.safe_load(f)['kobuki_auto_docking']['ros__parameters']
kobuki_auto_docking_node = ComposableNode(
package='kobuki_auto_docking',
plugin='kobuki_auto_docking::AutoDockingROS',
name='kobuki_auto_docking',
parameters=[params]
)
# packs to the container
mobile_base_container = ComposableNodeContainer(
name='mobile_base_container',
namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
kobuki_node,
kobuki_auto_docking_node
],
output='both',
)
return LaunchDescription([
mobile_base_container
])
def getImageRectifyComponent(camera_name):
component = ComposableNode(
package='image_processing_utils',
plugin='image_processing_utils::ImageRectifyComponent',
namespace='/perception/'+camera_name,
name='image_rectify_node',
remappings=[('image', 'image_raw')],
parameters=[])
return component
def generate_launch_description():
"""Generate launch description with multiple components."""
container = ComposableNodeContainer(
node_name='my_container',
node_namespace='',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(package='tutorial_composition',
node_plugin='tutorial_composition::PublisherNode',
node_name='talker'),
ComposableNode(package='tutorial_composition',
node_plugin='tutorial_composition::SubscriberNode',
node_name='listener')
],
output='screen',
)
return launch.LaunchDescription([container])
def generate_launch_description():
urdf = os.path.join(get_package_share_directory('confbot_description'),
'urdf', 'confbot.urdf')
return LaunchDescription([
Node(package='robot_state_publisher',
node_executable='robot_state_publisher',
output='screen',
arguments=[urdf]),
Node(package='confbot_tools',
node_executable='safe_zone_publisher',
output='screen'),
ComposableNodeContainer(
node_name='confbot_driver_container',
node_namespace='',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='confbot_driver',
node_plugin='confbot_driver::nodes::ConfbotDriver',
node_name='confbot_driver'),
ComposableNode(
package='confbot_driver',
node_plugin='confbot_driver::nodes::TwistPublisher',
node_name='twist_publisher')
],
output='screen',
),
ComposableNodeContainer(
node_name='confbot_sensors_container',
node_namespace='',
package='rclcpp_components',
node_executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='confbot_sensors',
node_plugin='confbot_sensors::nodes::ConfbotLaser',
node_name='confbot_laser'),
],
output='screen',
)
])
def getCropHullFilterComponent():
component = ComposableNode(
package='pcl_apps',
plugin='pcl_apps::CropHullFilterComponent',
namespace='/perception',
remappings=[
('points', 'points_concatenate_node/output'),
('polygon', 'scan_segmentation_node/polygon')
],
name='crop_hull_filter_node')
return component
def generate_launch_description():
default_yaml = os.path.join(
get_package_share_directory('dynamic_vino_sample'), 'param',
'pipeline_composite_object_topic.yaml')
container = ComposableNodeContainer(
node_name='vision_pipeline',
node_namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='realsense_ros',
node_plugin='realsense::RealSenseNodeFactory',
node_name='realsense',
parameters=[
get_package_share_directory('realsense_examples') +
'/config/d435i.yaml'
],
extra_arguments=[{
'use_intra_process_comms': 'true'
}]),
ComposableNode(package='dynamic_vino_sample',
node_plugin='ComposablePipeline',
node_name='composable_pipeline',
parameters=[{
"config": default_yaml
}],
remappings=[
('/openvino_toolkit/object/detected_objects',
'/ros2_openvino_toolkit/detected_objects'),
('/openvino_toolkit/object/images',
'/ros2_openvino_toolkit/image_rviz')
],
extra_arguments=[{
'use_intra_process_comms': 'true'
}])
],
output='screen',
)
return launch.LaunchDescription([container])
def generate_launch_description():
container = ComposableNodeContainer(
node_name = 'my_container',
node_namespace = '',
package = 'rclcpp_components',
node_executable = 'component_container',
composable_node_descriptions = [
ComposableNode(
package = 'hello_world_cpp',
node_plugin = 'hello_world_cpp::Talker',
node_name = 'talker'
),
ComposableNode(
package = 'hello_world_cpp',
node_plugin = 'hello_world_cpp::Listener',
node_name = 'listener'
)
],
output = 'screen',
)
return launch.LaunchDescription([container])
def generate_launch_description():
ld = launch.LaunchDescription()
pkg_dir = get_package_share_directory('tr_camera_driver')
cam_calib_file = os.path.join(pkg_dir, 'config', 'camera.yaml')
front_camera = ComposableNode(
name='driver',
namespace='/tr/drivers/camera/front',
package='usb_camera_driver',
plugin='usb_camera_driver::CameraDriver',
parameters=[{
'image_width': 640,
'image_height': 480,
'camera_id': 0,
'camera_calibration_file': 'file://' + cam_calib_file
}],
)
front_camera_rect = ComposableNode(
name='rectifier',
namespace='/tr/drivers/camera/front',
package='image_proc',
plugin='image_proc::RectifyNode',
)
camera_container = ComposableNodeContainer(
name='camera_container',
namespace='/tr/drivers/camera',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[front_camera, front_camera_rect],
output='screen')
ld.add_action(camera_container)
return ld
def getPointsConcatenateComponent():
config_directory = os.path.join(
ament_index_python.packages.get_package_share_directory('perception_bringup'),
'config')
param_config = os.path.join(config_directory, 'points_concatenate.yaml')
with open(param_config, 'r') as f:
params = yaml.safe_load(f)['points_concatenate_node']['ros__parameters']
component = ComposableNode(
package='pcl_apps',
plugin='pcl_apps::PointsConcatenateComponent',
namespace='perception',
name='points_concatenate_node',
parameters=[params])
return component
def test_set_remap_with_composable_node():
lc = MockContext()
node_description = ComposableNode(package='asd',
plugin='my_plugin',
name='my_node',
namespace='my_ns',
remappings=[('from2', 'to2')])
set_remap = SetRemap('from1', 'to1')
set_remap.execute(lc)
request = get_composable_node_load_request(node_description, lc)
remappings = request.remap_rules
assert len(remappings) == 2
assert remappings[0] == 'from1:=to1'
assert remappings[1] == 'from2:=to2'
def getRadiusOutlierRemovalComponent(lidar_name):
config_directory = os.path.join(
ament_index_python.packages.get_package_share_directory('perception_bringup'),
'config')
param_config = os.path.join(config_directory, lidar_name+'_radius_outlier_removal.yaml')
with open(param_config, 'r') as f:
params = yaml.safe_load(f)[lidar_name + '_radius_outlier_removal_node']['ros__parameters']
component = ComposableNode(
package='pcl_apps',
plugin='pcl_apps::RadiusOutlierRemovalComponent',
namespace='/perception/'+lidar_name,
name='radius_outlier_removal_node',
parameters=[params])
return component
def getImageDecompressorComponent(camera_name):
config_directory = os.path.join(
ament_index_python.packages.get_package_share_directory('perception_bringup'),
'config')
param_config = os.path.join(config_directory, camera_name+'_image_decompressor.yaml')
with open(param_config, 'r') as f:
params = yaml.safe_load(f)[camera_name+'_image_decompressor_node']['ros__parameters']
component = ComposableNode(
package='image_processing_utils',
plugin='image_processing_utils::ImageDecompressorComponent',
namespace='/perception/'+camera_name,
name='image_decompressor_node',
parameters=[params])
return component
def getScanSgementationComponent():
config_directory = os.path.join(
ament_index_python.packages.get_package_share_directory('perception_bringup'),
'config')
param_config = os.path.join(config_directory, 'scan_segmentation.yaml')
with open(param_config, 'r') as f:
params = yaml.safe_load(f)['scan_segmentation_node']['ros__parameters']
component = ComposableNode(
package='scan_segmentation',
plugin='scan_segmentation::ScanSegmentationComponent',
namespace='/perception',
name='scan_segmentation_node',
parameters=[params])
return component
def get_acrobat_autonomy_nodes(autonomy_toggles: Dict[str, bool]):
vio_node = ComposableNode(
package='acrobat_localization',
node_plugin='acrobat::localization::VisualOdometry',
node_name='acrobat_vio',
parameters=[{
}],
)
autonomy_nodes = []
if autonomy_toggles['visual_odometry']:
autonomy_nodes.append(vio_node)
return autonomy_nodes
def generate_launch_description():
composable_node = ComposableNode(name='camera',
package='opencv_cam', plugin='CameraNode',
parameters=[{"width": 640, "height": 480}])
container = ComposableNodeContainer(
name='camera_container',
namespace='camera',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[composable_node],
output='screen',
)
return launch.LaunchDescription([container])
def test_set_param_with_composable_node():
lc = MockContext()
node_description = ComposableNode(
package='asd',
plugin='my_plugin',
name='my_node',
namespace='my_ns',
parameters=[{'asd': 'bsd'}]
)
set_param_1 = SetParameter(name='my_param', value='my_value')
set_param_2 = SetParameter(name='asd', value='csd')
set_param_1.execute(lc)
set_param_2.execute(lc)
request = get_composable_node_load_request(node_description, lc)
parameters = request.parameters
assert len(parameters) == 3
assert parameters[0].name == 'my_param'
assert parameters[0].value.string_value == 'my_value'
assert parameters[1].name == 'asd'
assert parameters[1].value.string_value == 'csd'
assert parameters[2].name == 'asd'
assert parameters[2].value.string_value == 'bsd'
lc = MockContext()
node_description = ComposableNode(
package='asd',
plugin='my_plugin',
name='my_node',
namespace='my_ns',
)
set_param = SetParameter(name='my_param', value='my_value')
set_param.execute(lc)
request = get_composable_node_load_request(node_description, lc)
parameters = request.parameters
assert len(parameters) == 1
assert parameters[0].name == 'my_param'
assert parameters[0].value.string_value == 'my_value'
