self.publisher = self.create_publisher(AddressBook, 'address_book', 10)  # ① 声明类型 + 话题
msg = AddressBook()                        # ② 实例化消息对象
msg.first_name = 'John'                    #    给字段赋值
msg.phone_type = AddressBook.PHONE_TYPE_MOBILE   # 常量用类名引用
self.publisher.publish(msg)                # ③ 发布

self.create_subscription(AddressBook, 'address_book', self.callback, 10)  # ① 订阅

def callback(self, msg):                   # ② 回调里直接读字段
    print(msg.first_name, msg.phone_type)

self.srv = self.create_service(AddTwoInts, 'add_two_ints', self.callback)  # ① 声明服务

def callback(self, request, response):     # ② 读请求、填响应、return
    response.sum = request.a + request.b
    return response

self.cli = self.create_client(AddTwoInts, 'add_two_ints')      # ① 创建客户端
while not self.cli.wait_for_service(timeout_sec=1.0): ...       #    等服务端上线
req = AddTwoInts.Request()                                      # ② 构造请求对象
req.a = 2
req.b = 3                                                       #    填请求字段
future = self.cli.call_async(req)                               # ③ 异步发送
rclpy.spin_once(self)                                           #    轮询等结果
response = future.result()                                      #    拿响应 response.sum

from rclpy.action import ActionServer                     # 导入 action 专用 API

self.action_server = ActionServer(                        # ① 声明动作（目标回调去接受 / 执行）
    self, Fibonacci, 'fibonacci', self.execute_callback)  #    三个参数：类型、动作名、回调

def execute_callback(self, goal_handle):                  # ② 处理目标、循环回传反馈
    goal_handle.publish_feedback(feedback)                #    执行中实时发 Feedback
    goal_handle.succeed()                                 #    标记成功 / 失败
    return result                                         # ③ return 最终 Result

self.action_client = ActionClient(self, Fibonacci, 'fibonacci')   # ① 创建动作客户端
self.action_client.wait_for_server()                              #    等服务端上线

goal_msg = Fibonacci.Goal()                                       # ② 构造目标对象
goal_msg.order = 5

future = self.action_client.send_goal_async(                      # ③ 异步发目标
    goal_msg, feedback_callback=self.on_feedback)                 #    注册"反馈"回调

rclpy.spin_until_future_complete(self, future)                    #    先等「目标是否被接受」
goal_handle = future.result()
if goal_handle.accepted:
    result_future = goal_handle.get_result_async()                #    接受后再等「最终结果」
    rclpy.spin_until_future_complete(self, result_future)
    result = result_future.result().result

response.sum = request.a + request.b   # ✅ a、b、sum 都是 srv 里定义的
response.sum = request.x + request.y   # ❌ AttributeError: no attribute 'x'

goal_msg.order = 5                       # Goal 段字段：order
result.sequence = ...                    # Result 段字段：sequence
feedback.partial_sequence = ...          # Feedback 段字段：partial_sequence

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from custom_interfaces.msg import AddressBook   # 由 .msg 生成的类型


class AddressBookPublisher(Node):
    def __init__(self):
        super().__init__('address_book_publisher')
        # create_publisher(消息类型, 话题名, 队列长度)
        self.publisher = self.create_publisher(AddressBook, 'address_book', 10)
        timer_period = 1.0   # 每 1 秒发一次
        self.timer = self.create_timer(timer_period, self.timer_callback)

    def timer_callback(self):
        msg = AddressBook()   # 直接实例化消息对象
        msg.first_name = 'John'
        msg.last_name = 'Doe'
        msg.phone_number = '1234567890'
        msg.phone_type = AddressBook.PHONE_TYPE_MOBILE   # 常量用类名引用
        self.publisher.publish(msg)
        self.get_logger().info('Publishing Contact\nFirst:%s Last:%s'
                               % (msg.first_name, msg.last_name))


def main(args=None):
    rclpy.init(args=args)
    node = AddressBookPublisher()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from custom_interfaces.msg import AddressBook


class AddressBookSubscriber(Node):
    def __init__(self):
        super().__init__('address_book_subscriber')
        # create_subscription(消息类型, 话题名, 回调, 队列长度)
        self.subscription = self.create_subscription(
            AddressBook, 'address_book', self.listener_callback, 10)

    def listener_callback(self, msg):
        self.get_logger().info(
            'I heard:\n  First:%s Last:%s\n  Phone:%s Type:%s'
            % (msg.first_name, msg.last_name,
               msg.phone_number, msg.phone_type))


def main(args=None):
    rclpy.init(args=args)
    node = AddressBookSubscriber()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from custom_interfaces.srv import AddTwoInts   # 生成的服务类型


class AddTwoIntsServer(Node):
    def __init__(self):
        super().__init__('add_two_ints_server')
        # create_service(服务类型, 服务名, 回调)
        self.srv = self.create_service(
            AddTwoInts, 'add_two_ints', self.add_two_ints_callback)

    def add_two_ints_callback(self, request, response):
        # request.a / request.b 是请求字段
        response.sum = request.a + request.b   # 填响应字段
        self.get_logger().info(
            'Incoming request\na: %d  b: %d' % (request.a, request.b))
        return response


def main(args=None):
    rclpy.init(args=args)
    node = AddTwoIntsServer()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

#!/usr/bin/env python3
import sys
import rclpy
from rclpy.node import Node
from custom_interfaces.srv import AddTwoInts


class AddTwoIntsClient(Node):
    def __init__(self):
        super().__init__('add_two_ints_client')
        self.cli = self.create_client(AddTwoInts, 'add_two_ints')
        # 等待服务端上线
        while not self.cli.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('service not available, waiting again...')
        self.req = AddTwoInts.Request()

    def send_request(self, a, b):
        self.req.a = a
        self.req.b = b
        return self.cli.call_async(self.req)   # 异步调用，返回 future


def main(args=None):
    rclpy.init(args=args)
    client = AddTwoIntsClient()
    a = int(sys.argv[1]) if len(sys.argv) > 1 else 2
    b = int(sys.argv[2]) if len(sys.argv) > 2 else 3
    future = client.send_request(a, b)
    while rclpy.ok():
        rclpy.spin_once(client)
        if future.done():
            try:
                response = future.result()
                print('%d + %d = %d' % (a, b, response.sum))
            except Exception as e:
                print('Service call failed: %r' % e)
            break
    client.destroy_node()
    rclpy.shutdown()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rclpy.action import ActionServer
from custom_interfaces.action import Fibonacci   # 由 .action 生成


class FibonacciActionServer(Node):
    def __init__(self):
        super().__init__('fibonacci_action_server')
        # create_server(动作类型, 动作名, 目标回调)
        # 与 srv 不同：action 用「目标回调」先接受 / 拒绝目标，
        # 并在执行中通过 goal_handle.publish_feedback() 回传反馈
        self._action_server = ActionServer(
            self, Fibonacci, 'fibonacci', self.execute_callback)

    def execute_callback(self, goal_handle):
        self.get_logger().info('Executing goal %d' % goal_handle.request.order)
        feedback_msg = Fibonacci.Feedback()
        feedback_msg.partial_sequence = [0, 1]

        for i in range(2, goal_handle.request.order + 1):
            feedback_msg.partial_sequence.append(
                feedback_msg.partial_sequence[-1] + feedback_msg.partial_sequence[-2])
            goal_handle.publish_feedback(feedback_msg)   # 边算边回传反馈

        goal_handle.succeed()                            # 标记成功
        result = Fibonacci.Result()
        result.sequence = feedback_msg.partial_sequence  # 填结果
        return result


def main(args=None):
    rclpy.init(args=args)
    node = FibonacciActionServer()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
import sys
import rclpy
from rclpy.node import Node
from rclpy.action import ActionClient
from custom_interfaces.action import Fibonacci


class FibonacciActionClient(Node):
    def __init__(self):
        super().__init__('fibonacci_action_client')
        self._action_client = ActionClient(self, Fibonacci, 'fibonacci')

    def send_goal(self, order):
        # 与服务端同理：先等服务上线，再发 goal
        self._action_client.wait_for_server()
        goal_msg = Fibonacci.Goal()       # 填目标段字段
        goal_msg.order = order
        future = self._action_client.send_goal_async(
            goal_msg, feedback_callback=self.feedback_callback)   # 注册反馈回调
        return future

    def feedback_callback(self, feedback_msg):
        # 执行过程中实时收到反馈
        partial = feedback_msg.feedback.partial_sequence
        self.get_logger().info('Feedback: %s' % partial)


def main(args=None):
    rclpy.init(args=args)
    client = FibonacciActionClient()
    order = int(sys.argv[1]) if len(sys.argv) > 1 else 5
    goal_future = client.send_goal(order)

    # send_goal_async 先返回「接受目标」的 future，要先等它成功
    rclpy.spin_until_future_complete(client, goal_future)
    goal_handle = goal_future.result()

    if not goal_handle.accepted:
        client.get_logger().info('Goal rejected')
        return

    # 目标被接受后，再等「最终结果」的 future
    result_future = goal_handle.get_result_async()
    rclpy.spin_until_future_complete(client, result_future)
    result = result_future.result()
    print('Result: %s' % list(result.result.sequence))
    client.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

from launch import LaunchDescription
from launch.actions import ExecuteProcess


def generate_launch_description():
    env_setup = ('source /opt/ros/jazzy/setup.bash && '
                 'source ~/ros_ws/install/setup.bash')

    def make_terminal(name, cmd):
        return ExecuteProcess(
            cmd=['xterm', '-hold', '-T', name, '-e', 'bash', '-c',
                 f'{env_setup} && ros2 run custom_interfaces {cmd}'],
            output='screen')

    return LaunchDescription([
        make_terminal('address_book_publisher', 'publish_address_book.py'),
        make_terminal('address_book_subscriber', 'subscribe_address_book.py'),
        make_terminal('add_two_ints_server', 'add_two_ints_server.py'),
        make_terminal('add_two_ints_client', 'add_two_ints_client.py 2 3'),
    ])

from custom_interfaces.msg import AddressBook   # 接口包工程名 . msg
from custom_interfaces.srv import AddTwoInts

from custom_interfaces.msg import AddressBook   # 同包名前缀

import rclpy
from rclpy.node import Node


class ParamNode(Node):
    """演示 ROS 2 参数的节点：声明参数 → 定时读取并打印。"""

    def __init__(self):
        super().__init__('param_node')

        # ---- 1. 声明参数（名字 + 默认值）----
        #    声明之后才能被 ros2 param list 看到、被命令行/launch 修改
        self.declare_parameter('my_str', 'world')      # 字符串参数，默认 'world'
        self.declare_parameter('my_int', 42)           # 整数参数，默认 42
        self.declare_parameter('my_double', 3.14)      # 浮点参数，默认 3.14
        self.declare_parameter('my_bool', True)        # 布尔参数，默认 True
        self.declare_parameter('my_array', [1, 2, 3])  # 整型数组参数，默认 [1,2,3]
        self.declare_parameter('my_enum', 'A')         # 模拟枚举：只允许 A/B/C

        # ---- 2. 定时器：每 0.5 秒读取并打印一次参数 ----
        self.timer = self.create_timer(0.5, self.timer_callback)

    def timer_callback(self):
        # get_parameter() 返回 Parameter 对象，用 .value 取实际值
        s = self.get_parameter('my_str').value
        i = self.get_parameter('my_int').value
        d = self.get_parameter('my_double').value
        b = self.get_parameter('my_bool').value
        arr = self.get_parameter('my_array').value
        e = self.get_parameter('my_enum').value
        self.get_logger().info(
            f'my_str={s} my_int={i} my_double={d} '
            f'my_bool={b} my_array={arr} my_enum={e}')


def main(args=None):
    rclpy.init(args=args)        # 1. 初始化 rclpy
    node = ParamNode()           # 2. 实例化节点（此时会声明参数）
    try:
        rclpy.spin(node)         # 3. 阻塞运行，持续处理回调
    except KeyboardInterrupt:
        pass                     # 按 Ctrl+C 静默退出
    finally:
        node.destroy_node()      # 4. 清理
        rclpy.shutdown()


if __name__ == '__main__':
    main()

import rclpy
from rclpy.node import Node
from rclpy.parameter import Parameter
from rclpy.parameters import SetParametersResult


class DynamicParamNode(Node):
    """演示动态参数修改：允许 set 的同时做合法性校验。"""

    def __init__(self):
        super().__init__('param_node_dynamic')

        self.declare_parameter('my_enum', 'A')   # 只允许 A/B/C
        self.declare_parameter('my_int', 42)     # 只允许 0~100

        # 注册"参数被修改时"的回调
        self.add_on_set_parameters_callback(self.param_callback)

        self.timer = self.create_timer(1.0, self.timer_callback)

    def param_callback(self, params):
        """每次参数被 set 时调用。返回 SetParametersResult 表示接受/拒绝。"""
        for p in params:                     # params 是一批 Parameter 对象
            if p.name == 'my_enum' and p.value not in ('A', 'B', 'C'):
                return SetParametersResult(
                    successful=False, reason='my_enum 只能是 A/B/C')
            if p.name == 'my_int' and not (0 <= p.value <= 100):
                return SetParametersResult(
                    successful=False, reason='my_int 必须在 0~100 之间')
        return SetParametersResult(successful=True)

    def timer_callback(self):
        self.get_logger().info(
            f'my_enum={self.get_parameter("my_enum").value} '
            f'my_int={self.get_parameter("my_int").value}')


def main(args=None):
    rclpy.init(args=args)
    node = DynamicParamNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

entry_points={
    'console_scripts': [
        'param_node = py_param.param_node:main',
        'param_node_dynamic = py_param.param_node_dynamic:main',
    ],
},

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='py_param',
            executable='param_node',
            # 启动时把参数注入到节点，等价于逐个 --ros-args -p
            parameters=[{
                'my_str': 'hello launch',
                'my_int': 99,
                'my_enum': 'B',
            }],
        )
    ])

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import PathJoinSubstitution, LaunchConfiguration
from launch_ros.actions import Node
from launch_ros.parameter_descriptions import ParameterFile

def generate_launch_description():
    # 假设 config 目录在功能包内，路径会被正确解析
    param_file = PathJoinSubstitution([
        LaunchConfiguration('param_file'),
    ])

    return LaunchDescription([
        DeclareLaunchArgument(
            'param_file',
            default_value='src/py_param/config/param_node.yaml',
            description='参数文件路径'),
        Node(
            package='py_param',
            executable='param_node',
            parameters=[ParameterFile(param_file, allow_substs=True)],
        ),
    ])

import rclpy                    # ROS 2 Python 客户端库
from rclpy.node import Node     # 节点基类
from example_interfaces.srv import AddTwoInts  # 服务接口类型（请求/响应的数据结构）


class MinimalService(Node):
    """服务端节点：提供 add_two_ints 服务，接收两个整数，返回它们的和"""

    def __init__(self):
        super().__init__('minimal_service')          # 节点名称（ros2 node list 可见）
        self.srv = self.create_service(              # 创建服务端
            AddTwoInts,               # 服务接口类型（决定请求/响应各有哪些字段）
            'add_two_ints',           # 服务名称（客户端必须用同名调用）
            self.add_two_ints_callback)  # 收到请求时调用的回调函数

    def add_two_ints_callback(self, request, response):
        """处理请求并返回响应。
        request  是客户端发来的数据（字段 a、b）
        response 是要回传给客户端的结果（字段 sum）"""
        response.sum = request.a + request.b          # 取两个整数相加，填入响应字段
        self.get_logger().info(
            f'Incoming request: a={request.a}, b={request.b} -> sum={response.sum}')
        return response                               # 必须返回 response，否则客户端收不到结果


def main(args=None):
    rclpy.init(args=args)                 # 1. 初始化 rclpy（每个进程必须调用一次）
    node = MinimalService()               # 2. 创建服务端节点（此时服务已注册）
    rclpy.spin(node)                      # 3. 阻塞运行：一直监听并处理客户端请求
    node.destroy_node()                   # 4. 清理：销毁节点（Ctrl+C 退出后执行）
    rclpy.shutdown()


if __name__ == '__main__':
    main()

import sys                      # 读取命令行参数
import rclpy                    # ROS 2 Python 客户端库
from rclpy.node import Node     # 节点基类
from example_interfaces.srv import AddTwoInts  # 服务接口类型（请求/响应的数据结构）


class MinimalClient(Node):
    """客户端节点：调用 add_two_ints 服务，计算 a + b"""

    def __init__(self):
        super().__init__('minimal_client')           # 节点名称（ros2 node list 可见）
        self.cli = self.create_client(               # 创建客户端
            AddTwoInts,           # 服务接口类型（与服务端保持一致）
            'add_two_ints')       # 服务名称（与服务端保持一致）
        # 等待服务端就绪：每秒检查一次，没等到就一直等（先启动客户端也不会报错）
        while not self.cli.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('service not available, waiting again...')

    def call_service(self, a, b):
        # 构造请求对象并给字段赋值（a、b 由调用方传入）
        req = AddTwoInts.Request()
        req.a = a
        req.b = b
        # 异步发起请求：不阻塞主线程，返回一个 Future 对象，之后轮询它是否完成
        future = self.cli.call_async(req)
        # 阻塞等待请求完成：等待期间仍会处理节点回调
        rclpy.spin_until_future_complete(self, future)
        if future.result() is not None:   # 成功拿到响应
            self.get_logger().info(
                f'Result: {req.a} + {req.b} = {future.result().sum}')
        else:                              # 调用失败（如服务端异常/超时）
            self.get_logger().error('Service call failed')


def main(args=None):
    rclpy.init(args=args)                 # 1. 初始化 rclpy
    # 2. 解析命令行参数：a、b 取 sys.argv 前两个位置参数（缺省为 0）
    a = int(sys.argv[1]) if len(sys.argv) > 1 else 0
    b = int(sys.argv[2]) if len(sys.argv) > 2 else 0
    node = MinimalClient()                # 3. 创建客户端节点（内部已等待服务就绪）
    node.call_service(a, b)               # 4. 发起调用并打印结果
    node.destroy_node()                   # 5. 清理
    rclpy.shutdown()


if __name__ == '__main__':
    main()

entry_points={
    'console_scripts': [
        'service = py_service.service:main',
        'client = py_service.client:main',
    ],
},

# ============================================================
# 文件作用：setup.py 是 ROS 2 Python 功能包（ament_python）的
# 构建配置文件，用于向 setuptools/colcon 声明包的元信息、依赖、
# 数据文件以及可执行入口（console_scripts）。
#   - colcon build 时据此生成可安装的 Python 包
#   - console_scripts 决定 ros2 run <包名> <节点名> 能运行哪些节点
#   - 与 package.xml 一起构成 Python 功能包的必要文件
# ============================================================
from setuptools import find_packages, setup
import os  # 拼接文件路径
from glob import glob  # 用通配符匹配 launch 文件

package_name = 'my_package'  # 包名：须与 src 目录名、package.xml 中的 <name> 一致

setup(
    name=package_name,                         # 包的安装名称（对应包名）
    version='1.1.0',                           # 版本号：遵循语义化版本（major.minor.patch）
    packages=find_packages(exclude=['test']),  # 自动发现要打包的 Python 子包，排除 test 目录
    data_files=[
        # 安装 ament 资源索引文件，用于 ros2 pkg 识别该包
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        # 安装 package.xml 到共享目录，供构建系统读取包元信息
        ('share/' + package_name, ['package.xml']),
        # 安装 launch 目录下的所有 launch 文件到 share/<包名>/launch/
        # 使 ros2 launch <包名> <launch文件名> 能通过包名找到 launch 文件
        (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),
    ],
    install_requires=['setuptools'],         # 运行时依赖的 Python 包
    zip_safe=True,                           # 允许以 zip 形式打包（纯 Python 包可设为 True）
    maintainer='nvidia',                     # 维护者姓名
    maintainer_email='example@163.com',      # 维护者邮箱
    description='最小的 ROS 2 Python 功能包',  # 包的功能用途描述
    license='Apache License 2.0',            # 开源协议声明
    extras_require={                         # 额外依赖：仅安装 test 扩展时才装 pytest
        'test': [
            'pytest',
        ],
    },
    entry_points={
        'console_scripts': [
            # '可执行命令名' = '包名.脚本文件名:主函数名'
            'my_node = my_package.my_node:main'
        ],
    },
)

import rclpy
from rclpy.node import Node
from std_msgs.msg import String


class MinimalPublisher(Node):
    """每隔 0.5 秒向话题 chatter 发布一条字符串消息"""

    def __init__(self):
        super().__init__('minimal_publisher')          # 节点名称
        self.publisher_ = self.create_publisher(       # 创建发布者
            String,        # 消息类型
            'chatter',     # 话题名称
            10)            # 队列长度（缓存 10 条）
        self.timer = self.create_timer(0.5, self.timer_callback)  # 定时器
        self.i = 0

    def timer_callback(self):
        msg = String()
        msg.data = f'Hello World: {self.i}'            # 填充消息内容
        self.publisher_.publish(msg)                   # 发布
        self.get_logger().info(f'Publishing: "{msg.data}"')
        self.i += 1


def main(args=None):
    rclpy.init(args=args)                 # 1. 初始化 rclpy
    node = MinimalPublisher()             # 2. 创建节点
    rclpy.spin(node)                      # 3. 让节点保持运行、处理回调
    node.destroy_node()                   # 4. 清理
    rclpy.shutdown()


if __name__ == '__main__':
    main()

import rclpy
from rclpy.node import Node
from std_msgs.msg import String


class MinimalSubscriber(Node):
    """订阅话题 chatter，每收到一条消息就打印出来"""

    def __init__(self):
        super().__init__('minimal_subscriber')         # 节点名称
        self.subscription = self.create_subscription(  # 创建订阅者
            String,                  # 消息类型
            'chatter',               # 话题名称
            self.listener_callback,  # 收到消息时调用的回调
            10)                      # 队列长度

    def listener_callback(self, msg):
        self.get_logger().info(f'I heard: "{msg.data}"')


def main(args=None):
    rclpy.init(args=args)
    node = MinimalSubscriber()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

entry_points={
    'console_scripts': [
        'publisher = py_pubsub.publisher:main',
        'subscriber = py_pubsub.subscriber:main',
    ],
},

from launch import LaunchDescription

def generate_launch_description():
    # 在这里定义你的动作 (Actions)
    return LaunchDescription([
        # 动作列表，例如启动一个节点
    ])

# import 方式一：import launch_ros.actions，使用时写全名 launch_ros.actions.Node
from launch import LaunchDescription
import launch_ros.actions

def generate_launch_description():
    # 在这里定义你的动作 (Actions)
    return LaunchDescription([
        # 动作列表，例如启动一个节点
        # --- 最小示例：只指定 package + executable 两个必填字段 ---
        launch_ros.actions.Node(
            # ---- 必须的字段 ----
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名（这里直接用 turtlesim 包自带的节点程序）
        ),
    ])

# import 方式二（推荐）：from ... import Node，使用时直接写 Node
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    # 在这里定义你的动作 (Actions)
    return LaunchDescription([
        # 动作列表，例如启动一个节点
        # --- 最小示例：只指定 package + executable ---
        Node(
            # ---- 必须的字段 ----
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名（这里直接用 turtlesim 包自带的节点程序）
        )
    ])

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    # 在这里定义你的动作 (Actions)
    return LaunchDescription([
        # 动作列表，例如启动一个节点
        Node(
            # ---- 必须的字段 ----
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名（这里直接用 turtlesim 包自带的节点程序）

            # ---- 可选字段 ----
            name='my_turtle',             # 给节点改名（不指定则默认用 executable 的名字）
            namespace='ns1',              # 放入命名空间 → 节点全名变成 /ns1/my_turtle
                                          # 话题也随之变成 /ns1/...，用于多实例隔离
            output='screen',              # 将 stdout/stderr 打印到终端（也可选 'log' 或 'both'）

            # ---- 设置 ROS 参数 ----
            #   参数会在节点启动时加载，可用 ros2 param list 查看
            #   数字会按 YAML 规则处理：字符串数字（如 '255'）会自动转成 int
            parameters=[{
                'background_r': 255,      # 背景色 R 通道 (0-255)
                'background_g': 165,      # 背景色 G 通道 (0-255)
                'background_b': 0,        # 背景色 B 通道 (0-255)
            }],

            # ---- 话题重映射 (Remapping) ----
            #   每个元素是 (旧话题, 新话题)，相当于把 /cmd_vel "改名为" /turtle1/cmd_vel
            remappings=[
                ('/cmd_vel', '/turtle1/cmd_vel'),
            ],

            # ---- 额外 ROS 参数（透传给 --ros-args） ----
            #   arguments 里的内容会"原样"拼接到节点命令后面（等价于 ros2 run 之后
            #   再加的参数），必须以 --ros-args 开头，用来控制 ROS 2 运行时的行为。
            #   常见用法：
            #     --log-level INFO          设置日志级别 (DEBUG/INFO/WARN/ERROR/FATAL)
            #     --params-file config.yaml 从 YAML 文件加载参数（等价于 parameters 字段）
            #     -p key:=value             直接设置单条参数
            #     -r 旧话题:=新话题         话题重映射（等价于 remappings 字段）
            #   注意：parameters / remappings 字段本质上是这些 --ros-args 的
            #   "结构化便捷写法"，最终都会被转换成 --ros-args 透传给节点。
            arguments=['--ros-args', '--log-level', 'INFO'],

        ),
    ])

from launch import LaunchDescription
import launch_ros.actions  # 写法 A：import 包，使用时写全名 launch_ros.actions.Node

def generate_launch_description():
    return LaunchDescription([
        # ---- 第一个节点：放入 turtlesim1 命名空间 ----
        launch_ros.actions.Node(
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名（这里直接用 turtlesim 包自带的节点程序）
            namespace='turtlesim1',       # 节点全名变成 /turtlesim1/turtle1
                                          # 通过 namespace 隔离，两个同类型节点可以共存
            name='turtle1',               # 节点名
            parameters=[{'background_r': 255, 'background_g': 165, 'background_b': 0}],  # 设置背景色参数
        ),
        # ---- 第二个节点：放入 turtlesim2 命名空间 ----
        launch_ros.actions.Node(
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名
            namespace='turtlesim2',       # 与第一个节点同名，靠不同 namespace 区分
            name='turtle1',               # 节点名（与第一个节点相同）
            parameters=[{'background_r': 0, 'background_g': 255, 'background_b': 100}],  # 设置背景色参数
        ),
    ])

from launch import LaunchDescription
from launch_ros.actions import Node  # 写法 B：直接导入 Node 类，使用时写 Node

def generate_launch_description():
    # 先把每个节点赋给变量，再统一放入列表（便于复用/修改）
    turtlesim1_node = Node(           # 第一个节点：放入 turtlesim1 命名空间
        package='turtlesim',          # 节点所在的功能包名
        executable='turtlesim_node',  # 可执行文件名（这里直接用 turtlesim 包自带的节点程序）
        namespace='turtlesim1',       # 节点全名变成 /turtlesim1/turtle1
                                      # 通过 namespace 隔离，两个同类型节点可以共存
        name='turtle1',                # 节点名
        parameters=[{'background_r': 255, 'background_g': 165, 'background_b': 0}],  # 设置背景色参数
    )
    turtlesim2_node = Node(           # 第二个节点：放入 turtlesim2 命名空间
        package='turtlesim',          # 节点所在的功能包名
        executable='turtlesim_node',  # 可执行文件名
        namespace='turtlesim2',       # 与第一个节点同名，靠不同 namespace 区分
        name='turtle1',               # 节点名（与第一个节点相同）
        parameters=[{'background_r': 0, 'background_g': 255, 'background_b': 100}],  # 设置背景色参数
    )
    return LaunchDescription([
        turtlesim1_node,              # 组装到 LaunchDescription
        turtlesim2_node
    ])

from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import DeclareLaunchArgument      # 定义可配置参数
from launch.substitutions import LaunchConfiguration  # 参数获取

def generate_launch_description():
    # 1. 声明一个名为 background_r 的启动参数
    background_r_arg = DeclareLaunchArgument(
        'background_r',          # 参数名称（必需）
        default_value='150',     # 默认值（可选，若不提供则用户必须传入，且必须是字符串）
        description='背景色 R 通道 (0-255)'  # 描述信息（可选，用于 --show-args）
    )

    # 2. 获取参数的实际值（占位符）
    background_r = LaunchConfiguration('background_r')

    # 3. 定义 turtlesim 节点，使用 background_r 参数
    turtlesim_node = Node(
        namespace='ns1',             # 放入指定的命名空间（可选）
        package='turtlesim',         # 节点所在的功能包名
        executable='turtlesim_node', # 要运行的可执行文件名
        name='my_turtle',            # 给这个节点起一个新名字（可选）
        output='screen',             # 将日志打印到屏幕（而不是日志文件）
        parameters=[{'background_r': background_r}],  # 设置参数
    )

    # 4. 组装到 LaunchDescription
    return LaunchDescription([
        background_r_arg,
        turtlesim_node
    ])

from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import DeclareLaunchArgument      # 定义可配置参数
from launch.substitutions import LaunchConfiguration  # 参数获取

def generate_launch_description():
    """支持命令行传参的写法，例如:
       ros2 launch ~/ros2_launch_demo/04_param.launch.py background_r:=200 background_g:=100 background_b:=50
    """

    # 1. 声明有哪些启动参数及其默认值
    declare_bg_r = DeclareLaunchArgument('background_r', default_value='150')
    declare_bg_g = DeclareLaunchArgument('background_g', default_value='86')
    declare_bg_b = DeclareLaunchArgument('background_b', default_value='255')

    # 2. 用 LaunchConfiguration 获取占位符（此时值还未确定，运行时才替换）
    bg_r = LaunchConfiguration('background_r')
    bg_g = LaunchConfiguration('background_g')
    bg_b = LaunchConfiguration('background_b')

    # 3. 传给节点
    node = Node(
        package='turtlesim',
        executable='turtlesim_node',
        parameters=[{
            'background_r': bg_r,
            'background_g': bg_g,
            'background_b': bg_b,
        }],
    )

    # 4. 注意：LaunchDescription 中必须先列出 DeclareLaunchArgument，再列出 Node
    return LaunchDescription([
        declare_bg_r,
        declare_bg_g,
        declare_bg_b,
        node,
    ])

# 05_yaml.launch.py
# 作用：演示从 YAML 参数文件加载参数（parameters 里放文件路径，而不是字典）
import os  # 用于拼接文件路径

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    # 1. 定位 YAML 参数文件的绝对路径
    #    os.path.dirname(__file__) 返回当前文件所在目录（本文件与 config/ 同目录）
    config = os.path.join(
        os.path.dirname(__file__),   # 当前 launch 文件所在目录
        'config',                    # config 子目录
        'turtlesim.yaml'             # 参数文件名
    )

    # 2. 启动节点，parameters 直接放"文件路径"（字符串）
    #    节点名（namespace + name）必须与 YAML 顶层键 /turtlesim2/sim 一致
    return LaunchDescription([
        Node(
            package='turtlesim',          # 节点所在的功能包名
            executable='turtlesim_node',  # 可执行文件名
            namespace='turtlesim2',       # 命名空间（与 YAML 顶层键对应）
            name='sim',                   # 节点名（与 YAML 顶层键对应）
            parameters=[config]           # 从 YAML 文件加载参数（放路径而非字典）
        ),
    ])

from launch import LaunchDescription
from launch_ros.actions import Node
from launch.conditions import IfCondition  # 条件启动
from launch.substitutions import LaunchConfiguration  # 获取命令行参数值

def generate_launch_description():
    # 读取命令行参数 launch_turtlesim（默认 true），如：ros2 launch 05_condition.launch.py launch_turtlesim1:=false
    launch_turtlesim1 = LaunchConfiguration('launch_turtlesim1', default='true')
    launch_turtlesim2 = LaunchConfiguration('launch_turtlesim2', default='true')
    return LaunchDescription([
        # ---- 第一个节点 ----
        Node(
            package='turtlesim',
            executable='turtlesim_node',
            name='turtle1',       # 节点改名为 turtle1
            # IfCondition 会把 "true"/"1" 视为真、"false"/"0" 视为假，直接传参即可
            condition=IfCondition(launch_turtlesim1),
        ),
        # ---- 第二个节点（改名为 turtle2，与第一个节点区分开）----
        Node(
            package='turtlesim',
            executable='turtlesim_node',
            name='turtle2',       # 节点改名为 turtle2
            condition=IfCondition(launch_turtlesim2),
        ),
    ])

import os                        # 用于拼接安装路径
from glob import glob            # 用于匹配 launch 目录下的文件
from setuptools import setup     # 打包配置

package_name = 'my_package'      # 功能包名（与目录名一致）

setup(
    # 其他配置参数 ...
    data_files=[
        # 其他需要安装的数据文件 ...
        # 安装所有 launch 文件（最关键的一行）
        (os.path.join('share', package_name), glob('launch/*.launch.py'))
    ]
)