ROS 2 基础与常用开发笔记

ros2 -h
ros2 run -h
ros2 node list -h

# 调用 /spawn 服务，生成第二个乌龟
ros2 service call /spawn turtlesim/srv/Spawn '{x: 5.5, y: 9.0, theta: 1.57, name: "turtle2"}'

# 列出 /turtlesim 节点的所有参数
ros2 param list /turtlesim

# 设置背景颜色的红色通道值
ros2 param set /turtlesim background_r 150

# 将所有参数导出到当前目录的 turtlesim. Yaml 文件
ros2 param dump /turtlesim > turtlesim. Yaml

# 让乌龟旋转 360 度，并显示反馈信息
ros2 action send_goal /turtle 1/rotate_absolute turtlesim/action/RotateAbsolute "theta: 6.28" --feedback

# 运行 turtlesim 包中的 turtlesim_node 节点，并设置节点名和参数
ros2 run turtlesim turtlesim_node --ros-args --remap __node:=my_turtle --param background_r:=100

# 通过 pip 安装（推荐）
sudo pip install rosdepc

# 如果系统默认 python 是 python3，也可以使用 pip3
# sudo pip3 install rosdepc

# 初始化 rosdepc
sudo rosdepc init

# 更新 rosdepc 的数据库（从国内源，速度很快）
rosdepc update

# 安装工作空间中所有功能包所需的系统依赖
rosdepc install -i --from-path src --rosdistro $ROS_DISTRO -y

# 分解说明：
# -i: --ignore-packages-from-source, 忽略源中的包（通常不需要，可省略）
# --from-path src: 从指定的 src 路径查找 package.xml
# --rosdistro $ROS_DISTRO: 指定你的 ROS 发行版（如 humble, iron 等）
# -y: 对所有提示自动回答 yes

cd ~/ros2_ws
rosdepc install --from-path src --rosdistro humble -y

# 检查但不安装依赖（用于查看缺少哪些依赖）
rosdepc check --from-path src --rosdistro $ROS_DISTRO

# Ubuntu/Debian
sudo apt install python3-colcon-common-extensions

# 或者通过 pip
sudo pip install colcon-common-extensions

# 基本构建：编译所有包
colcon build

# 编译特定包（最常用！）
colcon build --packages-select <your_package_name>

# 编译时跳过某些包
colcon build --packages-skip <package_to_skip>

# 并行编译以加快速度（使用所有CPU核心）
colcon build --parallel-workers $(nproc)

# 编译并创建符号链接（Python开发推荐）
colcon build --symlink-install

# 编译时跳过测试
colcon build --cmake-args -DBUILD_TESTING=0

# 开发中最常用的组合：只编译一个包，使用符号链接，并行编译
colcon build --packages-select my_package --symlink-install --parallel-workers $(nproc)

# 编译并忽略依赖错误（谨慎使用）
colcon build --packages-select my_package --allow-overriding my_package

# 清理特定包的构建文件
colcon build --packages-select my_package --cmake-clean-first

# 彻底删除构建产物（需要重新编译）
rm -rf build install log

# 或者只删除特定包的构建产物
rm -rf build/my_package install/my_package

# 列出工作空间中的所有包
colcon list

# 显示包的详细信息
colcon info <package_name>

# 列出包中的可执行文件
colcon list --packages-select <package_name> --executables

# 1. 创建并进入工作空间
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws

# 2. 创建Python包（假设依赖 rclpy 和 std_msgs）
ros2 pkg create my_robot --build-type ament_python --dependencies rclpy std_msgs

# 3. 安装系统依赖（关键步骤！）
rosdepc install -i --from-path src --rosdistro humble -y

# 4. 编写你的代码（编辑 src/my_robot/my_robot/my_robot_node.py 等文件）

# 5. 编译包（使用符号链接便于Python开发）
colcon build --packages-select my_robot --symlink-install

# 6. 激活工作空间
source install/setup.bash

# 7. 运行你的节点
ros2 run my_robot my_robot_node

# 如果初始化失败，可以尝试删除后重新初始化
sudo rm -rf /etc/ros/rosdepc
sudo rosdepc init
rosdepc update

# 如果某个依赖安装失败，可以手动安装
# 先查看需要什么依赖
rosdepc check --from-path src --rosdistro humble

# 如果编译失败，查看详细错误信息
colcon build --packages-select my_package --event-handlers console_direct+

# 如果Python包修改后没生效，检查是否使用了 --symlink-install
# 如果没有，需要重新编译或者使用符号链接重新构建

# 运行测试
colcon test --packages-select my_package

# 生成编译数据库（用于IDE代码补全）
colcon build --cmake-args -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

# 使用特定CMake配置
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release

# 编译后运行所有测试并显示结果
colcon test
colcon test-result --verbose

# 1. 创建工作空间目录结构
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws

# 2. （可选但推荐）安装工作空间内所有包所需的系统依赖
# 注意：先确保已安装并初始化 rosdepc（如前所述）
rosdepc install -i --from-path src --rosdistro $ROS_DISTRO -y
# 示例（如果您的ROS2版本是Humble）：
# rosdepc install -i --from-path src --rosdistro humble -y

cd ~/ros2_ws/src
ros2 pkg create <package_name> --build-type <build_type> --dependencies <dependencies>

ros2 pkg create my_cpp_pkg --build-type ament_cmake --dependencies rclcpp std_msgs

ros2 pkg create my_py_pkg --build-type ament_python --dependencies rclpy std_msgs

# 创建时直接指定节点名
ros2 pkg create my_robot --build-type ament_cmake --node-name my_robot_node --dependencies rclcpp

# 创建时直接指定launch文件名
ros2 pkg create my_launch_pkg --build-type ament_cmake --dependencies rclcpp --launch-file my_launch.launch.py

# 构建所有包
colcon build

# 构建特定包（最常用！）
colcon build --packages-select <package_name>

# 构建时跳过某些包
colcon build --packages-skip <package_to_skip>

# 构建并使用符号链接（Python开发推荐）
colcon build --packages-select my_py_pkg --symlink-install

# 并行构建加速
colcon build --packages-select my_pkg --parallel-workers $(nproc)

# 构建并显示详细输出
colcon build --packages-select my_pkg --event-handlers console_direct+

# 构建时传递CMake参数（C++包）
colcon build --packages-select my_cpp_pkg --cmake-args -DCMAKE_BUILD_TYPE=Release

# 构建但不运行测试
colcon build --packages-select my_pkg --cmake-args -DBUILD_TESTING=0

# 清理特定包的构建文件
colcon build --packages-select my_pkg --cmake-clean-first

# 彻底删除构建产物
rm -rf build/ install/ log/

# 只删除特定包的产物
rm -rf build/my_pkg/ install/my_pkg/

# 运行所有测试
colcon test

# 运行特定包的测试
colcon test --packages-select my_pkg

# 显示测试结果
colcon test-result --all

# 显示详细的测试结果（包括失败信息）
colcon test-result --verbose

# 列出工作空间中所有包
colcon list

# 列出已安装的所有包（包括系统包）
ros2 pkg list

# 查看包的详细信息
ros2 pkg prefix my_pkg  # 查看安装路径
ros2 pkg xml my_pkg     # 查看package.xml内容

# 列出包中的可执行文件
ros2 pkg executables my_pkg

# 查看包的依赖关系
rosdep keys my_pkg      # 查看系统依赖

# 首先激活工作空间环境
source ~/ros2_ws/install/setup.bash

# 运行包中的节点
ros2 run my_pkg my_node

# 运行launch文件
ros2 launch my_pkg my_launch.launch.py

# 查看节点列表，确认节点已运行
ros2 node list

# 1. 进入工作空间src目录
cd ~/ros2_ws/src

# 2. 创建Python包
ros2 pkg create my_py_package --build-type ament_python --dependencies rclpy --node-name my_py_node

# 3. 编辑节点代码
nano my_py_package/my_py_package/my_py_node.py
# （这里编写你的Python代码）

# 4. 编辑package.xml（如果需要添加更多依赖）
nano my_py_package/package.xml

# 5. 编辑setup.py（如果需要修改入口点）
nano my_py_package/setup.py

# 6. 返回工作空间根目录并安装依赖
cd ~/ros2_ws
rosdepc install -i --from-path src --rosdistro humble -y

# 7. 构建包（使用符号链接便于开发）
colcon build --packages-select my_py_package --symlink-install

# 8. 激活环境并运行
source install/setup.bash
ros2 run my_py_package my_py_node

# 1. 创建C++包
cd ~/ros2_ws/src
ros2 pkg create my_cpp_package --build-type ament_cmake --dependencies rclcpp --node-name my_cpp_node

# 2. 编辑CMakeLists.txt（如果需要修改编译选项）
nano my_cpp_package/CMakeLists.txt

# 3. 编辑源代码
nano my_cpp_package/src/my_cpp_node.cpp

# 4. 构建并运行
cd ~/ros2_ws
colcon build --packages-select my_cpp_package
source install/setup.bash
ros2 run my_cpp_package my_cpp_node

my_cpp_package/
├── CMakeLists.txt          # 构建配置
├── include/               # 头文件
│   └── my_cpp_package/
├── package.xml            # 包元数据
├── src/                   # 源代码
│   └── my_cpp_node.cpp
└── test/                  # 测试代码

my_py_package/
├── package.xml            # 包元数据
├── resource/             # 资源文件
├── setup.cfg             # Python安装配置
├── setup.py              # Python构建配置
├── test/                 # 测试代码
└── my_py_package/        # Python模块
    ├── __init__.py
    └── my_py_node.py     # 节点代码

# 如果找不到包，检查是否正确source了工作空间
echo $ROS_PACKAGE_PATH

# 如果编译失败，查看详细错误信息
colcon build --packages-select my_pkg --event-handlers console_direct+

# 如果依赖问题，检查package.xml中的依赖声明
# 并确保运行了rosdepc install

# 你的机器人系统里可能有这些 Node：
/camera_node     # 专门处理相机
/lidar_node      # 专门处理雷达  
/move_node       # 专门控制移动
/decision_node   # 专门做决策

# 它们这样聊天：
相机Node："我看到前面有障碍物" → (通过话题) → 决策Node
决策Node："请向右转" → (通过服务) → 移动Node
移动Node："正在转弯，已完成50%" → (通过动作) → 决策Node

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
import time

class MyPublisher(Node):
    def __init__(self):
        super().__init__('my_publisher_node')
        self.publisher_ = self.create_publisher(String, 'chatter', 10)
        self.timer = self.create_timer(1.0, self.timer_callback)
        self.counter = 0
        self.get_logger().info('Publisher node started!')

    def timer_callback(self):
        msg = String()
        msg.data = f'Hello ROS2! Count: {self.counter}'
        self.publisher_.publish(msg)
        self.get_logger().info(f'Publishing: "{msg.data}"')
        self.counter += 1

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

if __name__  '__main__':
    main()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MySubscriber(Node):
    def __init__(self):
        super().__init__('my_subscriber_node')
        self.subscription = self.create_subscription(
            String,
            'chatter',
            self.listener_callback,
            10)
        self.get_logger().info('Subscriber node started!')

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

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

if __name__  '__main__':
    main()

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"
#include <chrono>

using namespace std::chrono_literals;

class MyPublisher : public rclcpp::Node {
public:
    MyPublisher() : Node("my_publisher_node"), count_(0) {
        publisher_ = this->create_publisher<std_msgs::msg::String>("chatter", 10);
        timer_ = this->create_wall_timer(
            1s,
            std::bind(&MyPublisher::timer_callback, this));
        RCLCPP_INFO(this->get_logger(), "Publisher node started!");
    }

private:
    void timer_callback() {
        auto message = std_msgs::msg::String();
        message.data = "Hello ROS2! Count: " + std::to_string(count_++);
        publisher_->publish(message);
        RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", message.data.c_str());
    }
    
    rclcpp::TimerBase::SharedPtr timer_;
    rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
    size_t count_;
};

int main(int argc, char * argv[]) {
    rclcpp::init(argc, argv);
    auto node = std::make_shared<MyPublisher>();
    rclcpp::spin(node);
    rclcpp::shutdown();
    return 0;
}

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

class MySubscriber : public rclcpp::Node {
public:
    MySubscriber() : Node("my_subscriber_node") {
        subscription_ = this->create_subscription<std_msgs::msg::String>(
            "chatter",
            10,
            std::bind(&MySubscriber::listener_callback, this, std::placeholders::_1));
        RCLCPP_INFO(this->get_logger(), "Subscriber node started!");
    }

private:
    void listener_callback(const std_msgs::msg::String::SharedPtr msg) const {
        RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg->data.c_str());
    }
    
    rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
};

int main(int argc, char * argv[]) {
    rclcpp::init(argc, argv);
    auto node = std::make_shared<MySubscriber>();
    rclcpp::spin(node);
    rclcpp::shutdown();
    return 0;
}

from setuptools import setup
import os
from glob import glob

package_name = 'my_py_pkg'

setup(
    name=package_name,
    version='0.0.0',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='your_name',
    maintainer_email='your_email@example.com',
    description='TODO: Package description',
    license='TODO: License declaration',
    tests_require=['pytest'],
    
    # 🔥 最重要的入口点配置 🔥
    entry_points={
        'console_scripts': [
            # 格式：'节点名 = 包名.文件名:函数名'
            'my_node = my_py_pkg.my_node:main',
            'camera_driver = my_py_pkg.camera_node:main',
            'simple_publisher = my_py_pkg.simple_pub:main',
        ],
    },
)

my_py_pkg/
├── setup.py          # 在这里配置入口点
├── package.xml
└── my_py_pkg/        # Python包目录
    ├── __init__.py
    ├── my_node.py    # 包含 main() 函数
    ├── camera_node.py
    └── simple_pub.py

# 添加可执行文件
add_executable(my_cpp_node src/my_cpp_node.cpp)

# 链接ROS2库
ament_target_dependencies(my_cpp_node
  "rclcpp"
  "std_msgs"
)

# 🔥 最重要的入口点配置 🔥
# 安装可执行文件到 lib/<包名>
install(TARGETS
  my_cpp_node
  camera_driver
  simple_publisher
  DESTINATION lib/${PROJECT_NAME}
)

# 安装启动文件等其他资源
install(DIRECTORY
  launch
  DESTINATION share/${PROJECT_NAME}
)

my_cpp_pkg/
├── CMakeLists.txt    # 在这里配置编译和安装
├── package.xml
├── include/
└── src/
    ├── my_cpp_node.cpp      # 主函数在这里
    ├── camera_driver.cpp
    └── simple_publisher.cpp

# 创建Python包并指定节点名（自动配置入口点）
ros2 pkg create my_pkg --build-type ament_python --node-name my_node

# 创建C++包并指定节点名（自动配置入口点）  
ros2 pkg create my_pkg --build-type ament_cmake --node-name my_node

# 构建包
colcon build --packages-select my_pkg

# 运行节点（系统会自动找到入口点）
ros2 run my_pkg my_node
ros2 run my_pkg camera_driver
ros2 run my_pkg simple_publisher

# 现实世界的例子：
传感器Node："温度是25°C" → /temperature_topic → 显示Node、控制Node、记录Node

# 就像：
新闻电台 → 广播频率 → 所有收音机听众

[发布者 Node] → (消息) → [/topic_name] → (消息) → [订阅者 Node]
      ↑                          ↑                          ↑
   Publisher                    Topic                    Subscriber
    (说话)                     (聊天频道)                   (听话)

# 列出所有活跃的Topic
ros2 topic list

# 列出Topic并显示消息类型
ros2 topic list -t

# 查看Topic的详细信息
ros2 topic info /chatter

# 查看Topic的消息类型
ros2 topic type /chatter

# 监听某个Topic的消息（实时显示）
ros2 topic echo /chatter

# 手动向Topic发布消息
ros2 topic pub /chatter std_msgs/msg/String "{data: 'Hello ROS2'}"

# 以固定频率发布消息
ros2 topic pub /chatter std_msgs/msg/String "{data: 'Hello'}" --rate 1

# 查看Topic的消息频率
ros2 topic hz /chatter

# 查看Topic的数据带宽
ros2 topic bw /chatter

sudo apt install ros-humble-usb-cam

ros2 run usb_cam usb_cam_node_exe
ros2 run learning_topic topic_webcam_sub

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import cv2

class MyImageProcessor(Node):
    def __init__(self):
        super().__init__('my_image_processor')
        # 订阅原始图像
        self.subscription = self.create_subscription(
            Image,
            '/image_raw',  # 订阅usb_cam发布的话题
            self.image_callback,
            10)
        self.bridge = CvBridge()
        
    def image_callback(self, msg):
        # 将ROS图像消息转换为OpenCV格式
        cv_image = self.bridge.imgmsg_to_cv2(msg, "bgr8")
        
        # 在这里添加你的处理代码
        # 例如：图像识别、边缘检测、目标跟踪等
        gray_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray_image, 100, 200)
        
        # 显示处理结果
        cv2.imshow('Processed Image', edges)
        cv2.waitKey(1)

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

if __name__  '__main__':
    main()

# 客户端："请做一份披萨，30分钟内完成"
# 服务端："开始做披萨...20%完成...50%完成...披萨做好了！"

# 或者：
# 客户端："取消做披萨！"
# 服务端："好的，已取消"

[客户端 Node] → (目标) → [/action_name] → (目标) → [服务端 Node]
     ↓               ↓               ↓               ↓
  Client          Action           Action         Server
 (顾客)           (订单系统)        (订单系统)       (厨师)
     ↓               ↓               ↓               ↓
[等待结果] ← (结果) ← [反馈] ← (进度) ← [执行任务]
     ↑               ↑               ↑               ↑
  取消指令 → → → → → → → → → → → → → → → 取消处理

# 列出所有活跃的Action
ros2 action list

# 列出Action并显示类型
ros2 action list -t

# 查看Action信息
ros2 action info /turtle1/rotate_absolute

# 查看Action类型
ros2 action type /turtle1/rotate_absolute

# 发送Action目标
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 1.57}"

# 发送目标并显示反馈
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 3.14}" --feedback

# 取消Action目标（需要先知道goal_id）
ros2 action cancel_goal <goal_id>

# Goal - 目标
float32 theta
---
# Result - 结果
float32 delta
---
# Feedback - 反馈
float32 remaining

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

class MyNode(Node):
    def __init__(self):
        super().__init__('my_node')
        
        # 1. 声明参数并设置默认值
        self.declare_parameter('my_string_param', 'default_value')
        self.declare_parameter('my_int_param', 10)
        self.declare_parameter('my_bool_param', True)
        
        # 2. 获取参数值
        my_string = self.get_parameter('my_string_param').value
        my_int = self.get_parameter('my_int_param').value
        my_bool = self.get_parameter('my_bool_param').value
        
        self.get_logger().info(f'String param: {my_string}')
        self.get_logger().info(f'Int param: {my_int}')
        self.get_logger().info(f'Bool param: {my_bool}')
        
        # 3. （可选）设置参数变更回调函数
        # 当任何参数被外部修改时，此函数都会被调用
        self.add_on_set_parameters_callback(self.parameter_change_callback)
    
    def parameter_change_callback(self, params):
        """参数变更回调函数"""
        for param in params:
            self.get_logger().info(f'Parameter {param.name} changed to {param.value}')
            
            # 你可以在这里检查特定参数并做出反应
            if param.name  'my_int_param' and param.type_  Parameter.Type.INTEGER:
                self.get_logger().info(f'New int value is: {param.value}')
                # 这里可以触发重新配置算法等操作
        
        # 返回一个成功的状态对象，表示参数接受更改
        # 你也可以在这里验证参数值，如果值非法，可以返回一个不成功的状态来拒绝此次更改。
        return SetParametersResult(successful=True)

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

if __name__  '__main__':
    main()

# .bashrc
export ROS_DOMAIN_ID=0 # yourid 

+---------------------+ (Your Code)
|    ROS 2 Client     |    (e.g., rclcpp, rclpy)
|     Library (RCL)   |
+---------------------+
|  ROS 2 Middleware   |  <--- 这是抽象接口层
|   Interface (RMW)   |
+---------------------+
|   DDS Implementation |  <--- 这是具体的实现层 (e.g., Cyclone DDS, Fast DDS)
+---------------------+

ros2 topic echo /chatter --qos-reliability best_effort

class PublisherNode(Node):
    
    def __init__(self, name):
        super().__init__(name)  # ROS2节点父类初始化
        
        qos_profile = QoSProfile(  # 创建一个QoS原则
            # reliability=QoSReliabilityPolicy.BEST_EFFORT,
            reliability=QoSReliabilityPolicy.RELIABLE,
            history=QoSHistoryPolicy.KEEP_LAST,
            depth=1
        )
        # 创建发布者对象（消息类型、话题名、QoS原则）
        self.pub = self.create_publisher(String, "chatter", qos_profile)  
         
        # 创建一个定时器（单位为秒的周期，定时执行的回调函数）
        self.timer = self.create_timer(0.5, self.timer_callback)           

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

def generate_launch_description():
    # ... 在这里配置启动内容 ...
    return LaunchDescription([
        # ... 将配置好的动作（Actions）放在这里 ...
    ])

from launch.substitutions import PathJoinSubstitution, FindPackageShare

# 动态查找功能包路径并拼接文件路径
config_file = PathJoinSubstitution([
    FindPackageShare('my_robot_bringup'),
    'config',
    'robot_params.yaml'
])

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. 声明一个启动参数
    rate_arg = DeclareLaunchArgument(
        'publish_rate',
        default_value='1.0',
        description='Publishing rate (Hz) for the talker node'
    )
    
    # 当然也可以通过yaml加载
    '''
    config = os.path.join(              # 找到参数文件的完整路径
      get_package_share_directory('learning_launch'),
      'config',
      'turtlesim.yaml'
      )
    '''

    # 2. 配置要启动的节点
    talker_node = Node(
        package='demo_nodes_cpp',
        executable='talker',
        name='my_talker',
        parameters=[{
            'rate': LaunchConfiguration('publish_rate') # 使用启动参数
        }],
        remappings=[('chatter', 'my_chatter_topic')] # 将/chatter重映射为/my_chatter_topic
    )

    listener_node = Node(
        package='demo_nodes_cpp',
        executable='listener',
        name='my_listener',
        remappings=[('chatter', 'my_chatter_topic')] # 也必须重映射，才能听到talker
    )

    # 3. 将所有的Actions加入到LaunchDescription中
    return LaunchDescription([
        rate_arg,
        talker_node,
        listener_node
    ])

def generate_launch_description():                # 自动生成launch文件的函数
   parameter_yaml = IncludeLaunchDescription(     # 包含指定路径下的另外一个launch文件
      PythonLaunchDescriptionSource([os.path.join(
         get_package_share_directory('learning_launch'), 'launch'),
         '/parameters_nonamespace.launch.py'])
      )
  
   parameter_yaml_with_namespace = GroupAction(   
   # 对指定launch文件中启动的功能加上命名空间
      actions=[
         PushRosNamespace('turtlesim2'), # 防止冲突，主动加ns
         parameter_yaml]
      )

   return LaunchDescription([            # 返回launch文件的描述信息
      parameter_yaml_with_namespace
   ])

(os.path.join('share', package_name, 'launch'), glob(os.path.join('launch', '*.launch.py'))),

(os.path.join('share', package_name, 'config'), glob(os.path.join('config', '*.*'))),

(os.path.join('share', package_name, 'rviz'), glob(os.path.join('rviz', '*.*'))),

# 基本用法
ros2 launch <package_name> <launch_file_name>.py

# 运行上面的示例（假设文件在 my_package 功能包中）
ros2 launch my_package my_launch_file.py

# 在启动时覆盖参数的值
ros2 launch my_package my_launch_file.py publish_rate:=2.0

remappings=[
    ('/input/pose', '/turtlesim1/turtle1/pose'),        # 输入重定向
    ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'), # 输出重定向
]

mimic节点内部             重映射后实际连接
-------------           -------------------
订阅 /input/pose    →   订阅 /turtlesim1/turtle1/pose
发布 /output/cmd_vel →  发布 /turtlesim2/turtle1/cmd_vel

remappings=[
    ('原话题名', '新话题名'),      # 话题重映射
    ('原服务名', '新服务名'),      # 服务重映射
    ('__ns', '新的命名空间'),      # 特殊：重映射节点自身命名空间
    ('__node', '新的节点名'),      # 特殊：重映射节点自身名称
]

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from tf2_ros import StaticTransformBroadcaster
from geometry_msgs.msg import TransformStamped

class StaticTFBroadcaster(Node):
    def __init__(self):
        super().__init__('static_tf_broadcaster')
        self.tf_broadcaster_ = StaticTransformBroadcaster(self)
        
        transform = TransformStamped()
        
        # 设置头信息
        transform.header.stamp = self.get_clock().now().to_msg()
        transform.header.frame_id = 'base_link'  # 父坐标系
        transform.child_frame_id = 'laser_frame' # 子坐标系
        
        # 设置变换：激光雷达安装在 base_link 前方 0.2m，高 0.1m 的位置
        transform.transform.translation.x = 0.2
        transform.transform.translation.y = 0.0
        transform.transform.translation.z = 0.1
        # 没有旋转，所以使用单位四元数
        transform.transform.rotation.x = 0.0
        transform.transform.rotation.y = 0.0
        transform.transform.rotation.z = 0.0
        transform.transform.rotation.w = 1.0
        
        # 发布静态变换
        self.tf_broadcaster_.sendTransform(transform)
        self.get_logger().info('Published static transform from base_link to laser_frame')

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

if __name__  '__main__':
    main()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from tf2_ros import TransformException
from tf2_ros.buffer import Buffer
from tf2_ros.transform_listener import TransformListener

class TFListener(Node):
    def __init__(self):
        super().__init__('tf_listener')
        self.tf_buffer = Buffer()
        self.tf_listener = TransformListener(self.tf_buffer, self)
        
        # 创建一个定时器，定期查询变换
        self.timer = self.create_timer(1.0, self.on_timer)
        
    def on_timer(self):
        try:
            # 查找最新的从 laser_frame 到 base_link 的变换
            # target_frame, source_frame
            transform = self.tf_buffer.lookup_transform(
                'base_link',
                'laser_frame',
                rclpy.time.Time()) # 获取最新时间的变换
            self.get_logger().info(f'Transform is: {transform}')
        except TransformException as ex:
            self.get_logger().error(f'Could not get transform: {ex}')

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

if __name__  '__main__':
    main()

from tf2_geometry_msgs import do_transform_point
from geometry_msgs.msg import PointStamped

# 假设我们有一个在 laser_frame 中的点
point_in_laser = PointStamped()
point_in_laser.header.frame_id = 'laser_frame'
point_in_laser.point.x = 1.0
point_in_laser.point.y = 0.5
point_in_laser.point.z = 0.0

try:
    # 先查询变换
    transform = self.tf_buffer.lookup_transform('base_link', 'laser_frame', rclpy.time.Time())
    # 转换点
    point_in_base = do_transform_point(point_in_laser, transform)
    self.get_logger().info(f'Point in base_link: {point_in_base.point}')
except TransformException as ex:
    self.get_logger().error(f'Could not transform point: {ex}')

<link name="base_link">
  <visual>
    <geometry>
      <box size="0.2 0.1 0.05"/> <!-- 长宽高 -->
    </geometry>
    <origin rpy="0 0 0" xyz="0 0 0"/>
    <material name="blue">
      <color rgba="0 0 0.8 1"/> <!-- RGBA，A为透明度 -->
    </material>
  </visual>
  <collision>
    <geometry>
      <box size="0.2 0.1 0.05"/>
    </geometry>
  </collision>
  <inertial>
    <mass value="0.5"/>
    <origin xyz="0 0 0"/>
    <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
  </inertial>
</link>

<joint name="left_wheel_joint" type="continuous">
  <parent link="base_link"/>
  <child link="left_wheel"/>
  <origin xyz="0 0.05 0" rpy="0 0 0"/> <!-- 轮子安装在底座旁边 -->
  <axis xyz="0 1 0"/> <!-- 绕Y轴旋转 -->
</joint>

<?xml version="1.0"?>
<robot name="my_first_robot">

  <!-- 底座 LINK -->
  <link name="base_link">
    <visual>
      <geometry>
        <box size="0.2 0.1 0.05"/>
      </geometry>
      <material name="blue">
        <color rgba="0 0 0.8 1"/>
      </material>
    </visual>
    <collision>
      <geometry>
        <box size="0.2 0.1 0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.5"/>
      <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
    </inertial>
  </link>

  <!-- 左轮 LINK -->
  <link name="left_wheel">
    <visual>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
      <material name="black">
        <color rgba="0 0 0 1"/>
      </material>
    </visual>
    <collision>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.1"/>
      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
    </inertial>
  </link>

  <!-- 右轮 LINK -->
  <link name="right_wheel">
    <visual>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
      <material name="black"/>
      <!-- 复用名为black的material -->
    </visual>
    <collision>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.1"/>
      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
    </inertial>
  </link>

  <!-- 连接底座和左轮的 JOINT -->
  <joint name="left_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="left_wheel"/>
    <origin xyz="0 0.06 -0.03" rpy="1.5707 0 0"/> 
    <!-- 
    xyz: 安装在底座右侧(y方向)和略下方(z方向)
    rpy: 将圆柱体绕X轴旋转90度（π/2≈1.5707），使其立起来
    -->
    <axis xyz="0 1 0"/>
  </joint>

  <!-- 连接底座和右轮的 JOINT -->
  <joint name="right_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="right_wheel"/>
    <origin xyz="0 -0.06 -0.03" rpy="1.5707 0 0"/>
    <axis xyz="0 1 0"/>
  </joint>

</robot>