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'