yahboom
HomeTutorialsProduct
Solution
Blog
Online Store
About Us
EN/中文
Store
Jetson Orin NANO Developer Kit📖
01.Get started
  • 01. Learning route
  • 02. Get started quickly
  • 03. System Update Notes
  • 04. Disabling automatic updates and troubleshooting issues
  • 05. Jetson Orin Nano official kit screwdriver instructions
02.Jetson basic course
  • 01.Jetson board introduction
  • 02.Write Jetson original system
  • 03.Installing Jetson environment
  • 04.Backup SSD system
  • 05.Restore initial image system
  • 06.Upgrade to SUPER version (Optional)
  • 07.Write SUPER boot (Must read)
  • 08.SSD expansion
  • 09.Jetpack old system upgraded to Yahboom SUPER factory system
  • 10.Write the system onto your own SSD
03.Basic setting course
  • 01.Basic knowledge
  • 02.Network configuration
  • 03.SSH remote login
  • 04.VNC remote control
  • 05.RDP remote control
  • 06.Remote file transfer
  • 07.Jtop tool
  • 08.Exchange space expansion
  • 09.Use VSCode
  • 10.Use VMware
  • 11.Modify screen resolution
04.GPIO control course
  • 01.GPIO description
  • 02.GPIO library installation
  • 03.GPIO reading
  • 04.GPIO output
  • 05.Serial communication
  • 06.I2C communication
05.Vision basic course
  • 01.CSI camera preview
  • 02.USB camera preview
  • 03.Use Jupyter Lab
  • 04.Use JetCam
06.OpenCV basic course
  • 01.Image reading
  • 02.Image saving
  • 03.Image modification
  • 04.Image scaling
  • 05.Image cropping
  • 06.Image translation
  • 07.Image mirroring
  • 08.Image grayscale conversion
  • 09.Image binarization
  • 10.Image edge detection
  • 11.Add line segments
  • 12.Add rectangles
  • 13.Add circular shape
  • 14.Add ellipses
  • 15.Add polygons
  • 16.Add Text
  • 17.Preview USB camera image
  • 18.Preview CSI camera image
07.Vision advanced course
01.Environment construction
  • 01.TensorFlow
  • 02.PyTorch
  • 03.Torchvision
02.DeepStream development
  • 01.DeepStream environment
  • 02.License plate detection and recognition
  • 03.Parallel multi-model inference
  • 04.Object embedding vector generation
  • 05.Pose recognition
  • 06.NV optical flow anomaly detection
  • 07.Single-view 3D tracking
  • 08.Multi-view 3D tracking
03.NVIDIA TAO toolkit application
  • 01.Traffic scene object detection
  • 02.Person object detection
  • 03.Vehicle brand classification
  • 04.Vehicle model classification
  • 05.License plate detection and recognition
  • 06.Person semantic segmentation
  • 07.Retail product detection and recognition
  • 08.Person feature extraction and matching (ReID)
  • 09.Person action and pose classification
  • 10.Transformer-based person detection
  • 11.3D human skeleton detection
  • 12.LiDAR 3D point cloud detection
04.YOLO11 development
  • 01.YOLO environment construction
  • 02.CLI use
  • 03.Object detection
  • 04.Instance segmentation
  • 05.Pose estimation
  • 06.Image classification
  • 07.Oriented object detection
  • 08.Model conversion
  • 09.Dataset annotation
  • 10.Model training conversion
  • 11.Model prediction
05.Mediapipe development
  • 01.Mediapipe environment
  • 02.Hand detection
  • 03.Face detection
  • 04.Face effects
  • 05.3D object recognition
  • 06.Virtual brush
  • 07.Gesture recognition
  • 08.Finger control
  • 09.Posture estimation
  • 10.Face mask
  • 11.Overall detection
  • 12.Green scene removal(Human)
06.YOLO26 development
  • 01.YOLO environment construction
  • 02.CLI use
  • 03.Object detection
  • 04.Instance segmentation
  • 05.Pose estimation
  • 06.Image classification
  • 07.Oriented object detection
  • 08.Model conversion
  • 09.Dataset annotation
  • 10.Model training conversion
  • 11.Model prediction
07.QR code recognition
  • QR code recognition
08.Docker basic course
  • 01.Docker introduction
  • 02.Docker installation
  • 03.Docker command
  • 04.Docker usage
  • 05.Docker interaction
09.ROS2-Jazzy
01.ROS2 basic course
  • 1.Introduction to ROS2
  • 2.ROS2 install Jazzy
  • 3.ROS2 development environment
  • 4.ROS2 workspace
  • 5.ROS2 function package
  • 6.ROS2 node
  • 7.ROS2 topic communication
  • 8.ROS2 service communication
  • 9.ROS2 action communication
  • 10.ROS2 custom interface message
  • 11.ROS2 parameter service case
  • 12.ROS2 meta-function package
  • 13.ROS2 distributed communication
  • 14.ROS2 DDS
  • 15.ROS2 time related API
  • 16.ROS2 common command tools
  • 17.ROS2 rviz2 use
  • 18.ROS2 rqt toolbox
  • 19.ROS2 Launch startup file configuration
  • 20.ROS2 recording and playback tool
  • 21.ROS2 URDF model
  • 22.ROS2 Gazebo simulation platform
  • 23.ROS2 TF2 coordinate transformation
02.ROS2 vision course
  • 01.Camera preview (USB)
  • 02.Camera preview (CSI)
  • 03.Camera calibration (USB)
  • 04.Camera calibration (CSI)
  • 05.AR vision (USB)
  • 06.AR vision (CSI)
10.Large model basic course
01.Offline large model
  • 01.AI large model environment deployment
  • 02.Install large model dialogue platform
  • 03.Meta AI - Llama model
  • 04.Alibaba Cloud - Qwen model
  • 05.Microsoft - Phi-4-mini model
  • 06.DeepSeek - DeepSeek model
  • 07.Alibaba Cloud - Qwen-VL visual multimodal large model
  • 08.Google - Gemma visual multimodal large model
  • 9.Llava visual multimodal large model
  • 10.MiniCPM-V visual multimodal large model
  • 11.High-quality vision-language grounding (LocateAnything)
02.Online large model
  • 01.Tongyi Qianwen large model
  • 02.OpenRouter large model API aggregation platform
11.Large model application practice
01.Voice interaction application
  • 1.Voice interaction hardware connection (Must read)
  • 2.Offline speech to text (ASR)
  • 3.Offline text to speech (TTS)
  • 4.AI large model voice interaction
  • 5.AI large model offline voice assistant
02.Multimodal large model application (Online_Offline large model + Text_Voice interaction)
  • 01.Multimodal visual understand application
  • 02.Multimodal text image application
  • 03.Multimodal video analysis application
  • 04.Multi module visual position application
  • 05.Multimodal table scanning application
  • 06.Multimodal autonomous agent application
12.NVIDIA Isaac ROS course
  • 01.Build Isaac ROS environment
  • 02.Deep segmentation
  • 03.DNN stereoscopic depth
  • 04.Free space segmentation
  • 05.Image distortion processing
  • 06.Image segmentation
  • 07.3D scene reconstruction and mapping
  • 08.Object detection
  • 09.3D attitude estimation
  • 10.Visual SLAM
13.OpenClaw deployment and basic usage
01.OpenClaw deployment and introduction
  • 01.Quick start with the pre-configured environment (Recommended)
  • 02.OpenClaw Deployment
  • 03.OpenClaw WhatsApp Plugin Application
  • 04.OpenClaw WebChat Interaction
  • 05.OpenClaw TUI Interaction
  • 06.OpenClaw Tools Introduction
  • 07.OpenClawGate Gateway User Manual
  • 08.OpenClaw Features Overview
  • 09.OpenClawHub Introduction (Skill Installation)
02.OpenClaw basic application
  • 01.OpenClaw Application - File Management
  • 02.OpenClaw Application - Camera
  • 03.OpenClaw Application - Browser Control
  • 04.OpenClaw Application - Script Execution
  • 05.OpenClaw Application - AI Programming (Peripheral & GPIO Control)
  • 06.OpenClaw Application - Dedicated AI Assistant
  • 07.OpenClaw Web Search Capability Configuration
03.NVIDIA official Agent Skills application
  • 01.AI-assisted development with VS Code or Cursor
  • 02.Jetson device skills
  • 03.Jetson BSP custom agent skills
14.OpenClaw advanced development
01.Preparation Before Use
  • 01.Peripheral Hardware Configuration
  • 02.OpenClaw API-KEY Configuration
  • 03.OpenClaw Model Switching
  • 04.OpenClaw Prompts
  • 05.AI Voice Interaction Configuration
  • 06.Three Dialogue Configuration Tests
02.OpenClaw AI Programming Peripheral Control
  • 1. Servo Control
  • 2. RGB Strip
  • 3. OLED Display
  • 4. Temperature and Humidity Sensor
  • 5. Camera Application
  • 6. AI Script Peripheral Control
03.OpenClaw Peripheral Integration Applications
  • 1. Plant Care Assistant
  • 2. AI Calorie Estimation
  • 3. AI Rock Paper Scissors Game
  • 4. AI Pet
  • 5. AI Weather Station
  • 6. Temperature Humidity Dashboard
  • 7. Scheduled Tasks
Download
  • System_File
  • VMFile_BootFile
  • 3D Model File
  • DataSheet
  • Software_Tools
  • Code
  • Manual
Download ZIP

Welcome to Jetson Orin NANO Developer Kit repository

19.ROS2 Launch startup file configuration

19. ROS 2 Launch File Configuration

1. Introduction to Launch

Up to now, every time we run a ROS node, we need to open a new terminal and run a command. A robot system has many nodes, and starting them this way every time is troublesome. Is there a way to start all the nodes at once? The answer is of course yes: the launch file, which is a script for starting and configuring multiple nodes in the ROS system.

In ROS 2, launch is used for functions such as starting multiple nodes and configuring program runtime parameters. ROS 2 launch files come in xml, yaml, and python formats. This lesson takes a python-format launch file as an example. Compared with the other two formats, the python format is more flexible:

  • python has numerous function libraries that can be used in launch files;

  • ROS 2 general launch features and specific launch features are written in Python, so launch features that XML and YAML may not expose can be accessed;

When writing ROS 2 launch files in the python language, the most important thing is to abstract each node, file, script, and so on into an action, and start them with a unified interface.

References:

  • Launch system design document: ROS 2 launch system design document

  • Official launch API documentation: launch API documentation (updated with the official release)

  • Preparation: create a package to store the program files

ros2 pkg create learn_launch --build-type ament_python

2. Writing the Launch for a Single Node

2.1. Creating a Launch File

Create a new launch folder under the package, then create a new 【single_node_launch.py】 file inside the launch folder, and copy the following content into the file:

​x
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    node = Node(
        package='pkg_helloworld_py',
        executable='helloworld',
        output='screen'
    )
    return LaunchDescription([node])

image-20250905174633450

2.2. Configuring the setup.py File

Launch files are usually named LaunchName_launch.py, where LaunchName is user-defined and the _launch.py suffix is fixed. You need to modify the setup.py file under the package. The modification is to add the files under the launch path, so that an executable .py file is generated during compilation,

xxxxxxxxxx
#1. Import the related header files
import os
from glob import glob

#2. In the data_files list, add the launch path and the launch.py file under the path
(os.path.join('share',package_name,'launch'),glob(os.path.join('launch','*launch.py')))

image-20231031114303641

2.3. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

2.4. Running the Program

  • Refresh the environment variables, then run the launch file

xxxxxxxxxx
ros2 launch learn_launch single_node_launch.py

image-20250905175036003

2.5. Source Code Analysis

  1. Import the related libraries

xxxxxxxxxx
from launch import LaunchDescription
from launch_ros.actions import Node
  1. Define a function generate_launch_description, and return a launch_description

xxxxxxxxxx
def generate_launch_description():
    node = Node(
        package='pkg_helloworld_py',
        executable='helloworld',
    )
    return LaunchDescription([node])

A variable node is defined as the return value of starting a node. The Node function is called with two important parameters, package and executable.

  • package: indicates the package, representing the name of the package.

  • executable: indicates the program to execute, the name of the executable program.

Finally, call the LaunchDescription function, pass in the node parameter, and execute and return.

xxxxxxxxxx
return LaunchDescription([node])

3. Writing the Launch for Multiple Nodes

3.1. Creating a Launch File

Create a new 【multi_node_launch.py】 file and add the following content:

xxxxxxxxxx
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    publisher_node = Node(
        package='pkg_topic',
        executable='publisher_demo',
        output='screen'
    )
    subscriber_node = Node(
        package='pkg_topic',
        executable='subscriber_demo',
        output='screen'
    )
    return LaunchDescription([
        publisher_node,
        subscriber_node
    ])

3.2. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

3.3. Running the Program

  • Refresh the environment variables, then run the launch file

xxxxxxxxxx
ros2 launch learn_launch multi_node_launch.py 

image-20250905175250026

If the terminal does not print anything, we can check which nodes are started to verify whether the startup succeeded. Enter in the terminal:

xxxxxxxxxx
ros2 node list

image-20231031120049494

3.4. Source Code Analysis

Roughly the same as simple_node_launch.py, except that there is one more node.

4. Topic Remapping Case

4.1. Creating a Launch File

Create a new 【remap_name_launch.py】 file in the same directory as multi_node_launch.py and add the following content:

xxxxxxxxxx
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    publisher_node = Node(
        package='pkg_topic',
        executable='publisher_demo',
        output='screen',
        remappings=[("/topic_demo", "/topic_update")]
    )
    return LaunchDescription([
        publisher_node
    ])

4.2. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

4.3. Running the Program

We first look at what topics the publisher_demo node publishes before the topic is remapped:

xxxxxxxxxx
ros2 launch learn_launch multi_node_launch.py 
ros2 topic list

image-20231031121230604

The topic here is 【/topic_demo】

  • Refresh the environment variables again and run the program after the topic remapping to see the change:

xxxxxxxxxx
ros2 launch learn_launch remap_name_launch.py
ros2 topic list

image-20250905175613834

As can be seen from the figure above, the topic name has been remapped to 【/topic_update】

4.4. Source Code Analysis

The following part is mainly added:

xxxxxxxxxx
remappings=[("/topic_demo", "/topic_update")]

Here the original /topic_demo topic is remapped to /topic_update

5. Case of Nesting a Launch File to Start Another Launch File

5.1. Creating a Launch File

Create a new 【include_launch.py】 file in the same directory as multi_node_launch.py and add the following content:

xxxxxxxxxx
from launch import LaunchDescription
import os
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from ament_index_python.packages import get_package_share_directory

def generate_launch_description():
    hello_launch = IncludeLaunchDescription(PythonLaunchDescriptionSource(
        os.path.join(
            get_package_share_directory('learn_launch'),
            'launch',
            'multi_node_launch.py'
        )),
    )
    return LaunchDescription([
        hello_launch
    ])

5.2. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

5.3. Running the Program

  • Refresh the environment variables and run the launch file

xxxxxxxxxx
ros2 launch learn_launch include_launch.py

image-20250905180404738

5.4. Source Code Analysis

  • To nest and start a python-format launch file, you need to use the two classes IncludeLaunchDescription and PythonLaunchDescriptionSource of the launch system.

  • get_package_share_directory('learn_launch'): obtains the share directory of the package, where learn_launch is the package name;

  • os.path.join(..., 'launch', 'multi_node_launch.py'): uses relative path segments to join the included launch file. A / cannot be added before the file name, otherwise it will be treated as the file system root path.

6. Comprehensive Launch File Example

This case mainly shows how to write a complex launch file; the functionality of the program can be ignored.

6.1. Creating a Launch File

Create a new 【complex_launch.py】 file in the same directory as multi_node_launch.py and add the following content:

xxxxxxxxxx
import os
from ament_index_python import get_package_share_directory
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.actions import IncludeLaunchDescription
from launch.actions import GroupAction
from launch.launch_description_sources import AnyLaunchDescriptionSource
from launch.substitutions import LaunchConfiguration
from launch.substitutions import TextSubstitution
from launch_ros.actions import Node
from launch_ros.actions import PushRosNamespace


def generate_launch_description():

    # args that can be set from the command line or a default will be used
    background_r_launch_arg = DeclareLaunchArgument(
        "background_r", default_value=TextSubstitution(text="0")
    )
    background_g_launch_arg = DeclareLaunchArgument(
        "background_g", default_value=TextSubstitution(text="255")
    )
    background_b_launch_arg = DeclareLaunchArgument(
        "background_b", default_value=TextSubstitution(text="0")
    )
    chatter_ns_launch_arg = DeclareLaunchArgument(
        "chatter_ns", default_value=TextSubstitution(text="my/chatter/ns")
    )

    # include another launch file
    launch_include = IncludeLaunchDescription(
        AnyLaunchDescriptionSource(
            os.path.join(
                get_package_share_directory('demo_nodes_cpp'),
                'launch/topics/talker_listener_launch.xml'))
    )
    # include another launch file in the chatter_ns namespace
    launch_include_with_namespace = GroupAction(
        actions=[
            # push-ros-namespace to set namespace of included nodes
            PushRosNamespace(LaunchConfiguration('chatter_ns')),
            IncludeLaunchDescription(
                AnyLaunchDescriptionSource(
                    os.path.join(
                        get_package_share_directory('demo_nodes_cpp'),
                        'launch/topics/talker_listener_launch.xml'))
            ),
        ]
    )

    # start a turtlesim_node in the turtlesim1 namespace
    turtlesim_node = Node(
            package='turtlesim',
            namespace='turtlesim1',
            executable='turtlesim_node',
            name='sim'
        )

    # start another turtlesim_node in the turtlesim2 namespace
    # and use args to set parameters
    turtlesim_node_with_parameters = Node(
            package='turtlesim',
            namespace='turtlesim2',
            executable='turtlesim_node',
            name='sim',
            parameters=[{
                "background_r": LaunchConfiguration('background_r'),
                "background_g": LaunchConfiguration('background_g'),
                "background_b": LaunchConfiguration('background_b'),
            }]
        )

    # perform remap so both turtles listen to the same command topic
    forward_turtlesim_commands_to_second_turtlesim_node = Node(
            package='turtlesim',
            executable='mimic',
            name='mimic',
            remappings=[
                ('/input/pose', '/turtlesim1/turtle1/pose'),
                ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'),
            ]
        )

    return LaunchDescription([
        background_r_launch_arg,
        background_g_launch_arg,
        background_b_launch_arg,
        chatter_ns_launch_arg,
        launch_include,
        launch_include_with_namespace,
        turtlesim_node,
        turtlesim_node_with_parameters,
        forward_turtlesim_commands_to_second_turtlesim_node,
    ])

6.2. Building the Workspace

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

6.3. Running the Program

  • Refresh the environment variables in the terminal and run the launch file

xxxxxxxxxx
ros2 launch learn_launch complex_launch.py

Two small turtles will be displayed on the host machine's vnc.

image-20250905181104164

  • Start the keyboard control node and add the namespace (because we added the namespace when starting the node in the launch file)

xxxxxxxxxx
ros2 run turtlesim turtle_teleop_key --ros-args -r __ns:=/turtlesim1
  • Use the up, down, left, and right keys to control the movement of turtle 1; turtle 2 will completely imitate the behavior of turtle 1

image-20250902150215135

6.4. Program Description

The program mainly starts:

  1. The talker_listener node of demo_nodes_cpp,

  2. The talker_listener node with a namespace

  3. Turtle 1 with turtlesim1 as its namespace

  4. Turtle 2 with turtlesim2 as its namespace

  5. Remapping is performed so that both turtles can hear the same command topic

7. XML Implementation

7.1. Creating a Launch File

Create a new 【complex_launch.xml】 file in the same directory as complex_launch.py and add the following content:

xxxxxxxxxx
<launch>

    <!-- args that can be set from the command line or a default will be used -->
    <arg name="background_r" default="0"/>
    <arg name="background_g" default="255"/>
    <arg name="background_b" default="0"/>
    <arg name="chatter_ns" default="my/chatter/ns"/>
  
    <!-- include another launch file -->
    <include file="$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener_launch.xml"/>
    <!-- include another launch file in the chatter_ns namespace-->
    <group>
      <!-- push-ros-namespace to set namespace of included nodes -->
      <push-ros-namespace namespace="$(var chatter_ns)"/>
      <include file="$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener_launch.xml"/>
    </group>
  
    <!-- start a turtlesim_node in the turtlesim1 namespace -->
    <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim1"/>
    <!-- start another turtlesim_node in the turtlesim2 namespace
        and use args to set parameters -->
    <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim2">
      <param name="background_r" value="$(var background_r)"/>
      <param name="background_g" value="$(var background_g)"/>
      <param name="background_b" value="$(var background_b)"/>
    </node>
    <!-- perform remap so both turtles listen to the same command topic -->
    <node pkg="turtlesim" exec="mimic" name="mimic">
      <remap from="/input/pose" to="/turtlesim1/turtle1/pose"/>
      <remap from="/output/cmd_vel" to="/turtlesim2/turtle1/cmd_vel"/>
    </node>
</launch> 

7.2. setup.py File Configuration

  • You need to configure the build file, so that our .xml-format launch file is copied to the install directory during compilation, and only then can the ros system find our file

image-20250905182956976

7.3. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

7.4. Running the Program

Enter in the terminal:

xxxxxxxxxx
ros2 launch learn_launch complex_launch.xml
  • As expected, two small turtles will appear, and the terminal will print log information

image-20250905181104164

  • Start the keyboard control node and add a namespace

xxxxxxxxxx
ros2 run turtlesim turtle_teleop_key --ros-args -r __ns:=/turtlesim1

Use the keyboard control to start turtle 1 running; turtle 2 will completely imitate the behavior of turtle 1

8. YAML Implementation

8.1. Creating a Launch File

Create a new 【complex_launch.yaml】 file in the same directory as complex_launch.py and add the following content:

xxxxxxxxxx
launch:

# args that can be set from the command line or a default will be used
- arg:
    name: "background_r"
    default: "0"
- arg:
    name: "background_g"
    default: "255"
- arg:
    name: "background_b"
    default: "0"
- arg:
    name: "chatter_ns"
    default: "my/chatter/ns"


# include another launch file
- include:
    file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener_launch.xml"

# include another launch file in the chatter_ns namespace
- group:
    - push-ros-namespace:
        namespace: "$(var chatter_ns)"
    - include:
        file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener_launch.xml"

# start a turtlesim_node in the turtlesim1 namespace
- node:
    pkg: "turtlesim"
    exec: "turtlesim_node"
    name: "sim"
    namespace: "turtlesim1"

# start another turtlesim_node in the turtlesim2 namespace and use args to set parameters
- node:
    pkg: "turtlesim"
    exec: "turtlesim_node"
    name: "sim"
    namespace: "turtlesim2"
    param:
    -
      name: "background_r"
      value: "$(var background_r)"
    -
      name: "background_g"
      value: "$(var background_g)"
    -
      name: "background_b"
      value: "$(var background_b)"

# perform remap so both turtles listen to the same command topic
- node:
    pkg: "turtlesim"
    exec: "mimic"
    name: "mimic"
    remap:
    -
        from: "/input/pose"
        to: "/turtlesim1/turtle1/pose"
    -
        from: "/output/cmd_vel"
        to: "/turtlesim2/turtle1/cmd_vel" 

8.2. Configuration

  • You need to configure the build file, so that our .yaml-format launch file is copied to the install directory during compilation, and only then can the ros system find our file

8.3. Building the Package

xxxxxxxxxx
colcon build --packages-select learn_launch

image-20250905174942260

8.4. Running the Program

  • Refresh the environment variables and then run

xxxxxxxxxx
ros2 launch learn_launch complex_launch.yaml
  • As expected, two small turtles will appear, and the terminal will print log information

image-20250905181104164

  • Start the keyboard control node and add a namespace

xxxxxxxxxx
ros2 run turtlesim turtle_teleop_key --ros-args -r __ns:=/turtlesim1

Use the keyboard control to start turtle 1 running; turtle 2 will completely imitate the behavior of turtle 1

ROS2 rqt toolbox
ROS2 recording and playback tool

COMPANY

  • About us
  • Team Style
  • Blog

LEARNING & EXPLORATION

  • Tutorials
  • Edge AI hardware
  • Educational robots
  • Embedded intelligent hardware

WHERE TO BUY

  • Yahboom Online Store
  • Amazon
  • Alibaba
  • AliExpress
  • Mercado

TECHNOLOGY SUPPORT

  • Email: support@yahboom.com

BE A DISTRIBUTOR

  • Email: sales@yahboom.com
QR Code

Copyright © 2017-2026 Yahboom. All Rights Reserved.

EN/中文