sudo apt install ros-${ROS_DISTRO}-turtle-tf2-py ros-humble-tf2-tools
sudo pip3 install transforms3d
sudo apt install ros-${ROS_DISTRO}-rqt-tf-tree

# ros2 launch turtle_tf2_py turtle_tf2_demo.launch.py
ros2 run turtlesim turtle_teleop_key

ros2 run rqt_tf_tree rqt_tf_tree

ros2 run tf2_ros tf2_echo turtle2 turtle1

rviz2

ros2 run tf2_ros static_transform_publisher 0 0 3 0 0 3.14 A B

ros2 run tf2_ros tf2_echo A B

rviz2

ros2 pkg create pkg_tf --build-type ament_python --dependencies rclpy --node-name turtle_tf_broadcaster

import math
import rclpy  # ROS 2 Python client library
from rclpy.node import Node  # ROS 2 node class
from geometry_msgs.msg import TransformStamped  # transform message
from tf2_ros import TransformBroadcaster  # TF transform broadcaster
from turtlesim.msg import Pose  # turtlesim pose message

def quaternion_from_euler(roll, pitch, yaw):
  """Return quaternion from Euler angles (roll, pitch, yaw)."""
  cy = math.cos(yaw * 0.5)
  sy = math.sin(yaw * 0.5)
  cp = math.cos(pitch * 0.5)
  sp = math.sin(pitch * 0.5)
  cr = math.cos(roll * 0.5)
  sr = math.sin(roll * 0.5)

  w = cr * cp * cy + sr * sp * sy
  x = sr * cp * cy - cr * sp * sy
  y = cr * sp * cy + sr * cp * sy
  z = cr * cp * sy - sr * sp * cy

  return (x, y, z, w)

class TurtleTFBroadcaster(Node):
  def __init__(self, name):
  super().__init__(name)
  self.turtlename = self.declare_parameter('turtlename', 'turtle').value
  self.tf_broadcaster = TransformBroadcaster(self)
  self.subscription = self.create_subscription(
  Pose,
  f'/{self.turtlename}/pose',
  self.turtle_pose_callback, 1)

  def turtle_pose_callback(self, msg):
  transform = TransformStamped()
  transform.header.stamp = self.get_clock().now().to_msg()
  transform.header.frame_id = 'world'
  transform.child_frame_id = self.turtlename
  transform.transform.translation.x = msg.x
  transform.transform.translation.y = msg.y
  transform.transform.translation.z = 0.0
  q = quaternion_from_euler(0, 0, msg.theta)
  transform.transform.rotation.x = q[0]
  transform.transform.rotation.y = q[1]
  transform.transform.rotation.z = q[2]
  transform.transform.rotation.w = q[3]

  self.tf_broadcaster.sendTransform(transform)

def main(args=None):
  rclpy.init(args=args)
  node = TurtleTFBroadcaster("turtle_tf_broadcaster")
  rclpy.spin(node)
  node.destroy_node()
  rclpy.shutdown()

import math
import rclpy
from rclpy.node import Node
import tf_transformations
from tf2_ros import TransformException
from tf2_ros.buffer import Buffer
from tf2_ros.transform_listener import TransformListener
from geometry_msgs.msg import Twist
from turtlesim.srv import Spawn
class TurtleFollowing(Node):

  def init(self, name):
  super().init(name)
  self.declare_parameter('source_frame', 'turtle1')
  self.source_frame = self.get_parameter(
  'source_frame').get_parameter_value().string_value

  self.tf_buffer = Buffer()
  self.tf_listener = TransformListener(self.tf_buffer, self)

  self.spawner = self.create_client(Spawn, 'spawn')
  self.turtle_spawning_service_ready = False
  self.turtle_spawned = False

  self.publisher = self.create_publisher(Twist, 'turtle2/cmd_vel', 1)
  self.timer = self.create_timer(1.0, self.on_timer)

  def on_timer(self):
  from_frame_rel = self.source_frame
  to_frame_rel  = 'turtle2'

  if self.turtle_spawning_service_ready:
  if self.turtle_spawned:
  try:
  now = rclpy.time.Time()
  trans = self.tf_buffer.lookup_transform(
  to_frame_rel,
  from_frame_rel,
  now)
  except TransformException as ex:
  self.get_logger().info(
  f'Could not transform {to_frame_rel} to {from_frame_rel}: {ex}')
  return

  msg = Twist()
  scale_rotation_rate = 1.0
  msg.angular.z = scale_rotation_rate * math.atan2(
  trans.transform.translation.y,
  trans.transform.translation.x)

  scale_forward_speed = 0.5
  msg.linear.x = scale_forward_speed * math.sqrt(
  trans.transform.translation.x ** 2 +
  trans.transform.translation.y ** 2)

  self.publisher.publish(msg)
  else:
  if self.result.done():
  self.get_logger().info(
  f'Successfully spawned {self.result.result().name}')
  self.turtle_spawned = True
  else:
  self.get_logger().info('Spawn is not finished')
  else:
  if self.spawner.service_is_ready():
  request = Spawn.Request()
  request.name = 'turtle2'
  request.x = float(4)
  request.y = float(2)
  request.theta = float(0)

  self.result = self.spawner.call_async(request)
  self.turtle_spawning_service_ready = True
  else:
  self.get_logger().info('Service is not ready')

def main(args=None):
  rclpy.init(args=args)
  node = TurtleFollowing("turtle_following")
  rclpy.spin(node)
  node.destroy_node()
  rclpy.shutdown()

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node

def generate_launch_description():

  return LaunchDescription([
  DeclareLaunchArgument('source_frame', default_value='turtle1', description='Target frame name.'),
  Node(
  package='turtlesim',
  executable='turtlesim_node',
  ),
  Node(
  package='pkg_tf',
  executable='turtle_tf_broadcaster',
  name='broadcaster1',
  parameters=[
  {'turtlename': 'turtle1'}
  ]
  ),
  Node(
  package='pkg_tf',
  executable='turtle_tf_broadcaster',
  name='broadcaster2',
  parameters=[
  {'turtlename': 'turtle2'}
  ]
  ),
  Node(
  package='pkg_tf',
  executable='turtle_following',
  name='listener',
  parameters=[
  {'source_frame': LaunchConfiguration('source_frame')}
  ]
  ),
  ])

import os
from glob import glob

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

colcon build --packages-select pkg_tf

# source install/setup.bash
ros2 launch pkg_tf turtle_following.launch.py

ros2 run turtlesim turtle_teleop_key

string  name
int32  age
float64  height

# CMakeLists.txt
rosidl_generate_interfaces(${PROJECT_NAME}
  "action/Progress.action"
  "msg/Person.msg"
)

# package.xml
<buildtool_depend>rosidl_default_generators</buildtool_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<depend>action_msgs</depend>
<member_of_group>rosidl_interface_packages</member_of_group>

cd ~/workspace
colcon build --packages-select pkg_interfaces

# source install/setup.bash

ros2 interface show pkg_interfaces/msg/Person

int32 num1
int32 num2
---
int32 sum

rosidl_generate_interfaces(${PROJECT_NAME}
  "action/Progress.action"
  "msg/Person.msg"
  "srv/Add.srv"
)

<buildtool_depend>rosidl_default_generators</buildtool_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<depend>action_msgs</depend>
<member_of_group>rosidl_interface_packages</member_of_group>

cd ~/workspace
colcon build --packages-select pkg_interfaces
source install/setup.bash

ros2 interface show pkg_interfaces/srv/Add

ros2 run turtlesim turtlesim_node
# Second terminal
ros2 run turtlesim turtle_teleop_key

ros2 param list

ros2 param describe turtlesim background_b  # view the description of a parameter
ros2 param get turtlesim background_b  # query the value of a parameter
ros2 param set turtlesim background_b 10  # modify the value of a parameter

ros2 param dump turtlesim >> turtlesim.yaml  # save a node parameter set to a parameter file
ros2 param load turtlesim turtlesim.yaml  # load all parameters from a file at once

ros2 pkg create pkg_param --build-type ament_python --dependencies rclpy --node-name param_demo

import rclpy
from rclpy.node import Node

class ParameterNode(Node):
  def __init__(self, name):
  super().__init__(name)
  self.timer = self.create_timer(2.0, self.timer_callback)
  self.declare_parameter('robot_name', 'muto')

  def timer_callback(self):
  robot_name_param = self.get_parameter('robot_name').get_parameter_value().string_value
  self.get_logger().info('Hello %s!' % robot_name_param)

def main(args=None):
  rclpy.init(args=args)
  node = ParameterNode("param_declare")
  rclpy.spin(node)
  node.destroy_node()
  rclpy.shutdown()

colcon build --packages-select pkg_param

# source install/setup.bash
ros2 run pkg_param param_demo

ros2 param set param_declare robot_name robot

sudo apt install ros-humble-desktop

ros2 pkg create pkg_metapackage

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>pkg_metapackage</name>
  <version>0.0.0</version>
  <description>TODO: Package description</description>
  <maintainer email="1461190907@qq.com">root</maintainer>
  <license>TODO: License declaration</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <exec_depend>pkg_interfaces</exec_depend>
  <exec_depend>pkg_helloworld_py</exec_depend>
  <exec_depend>pkg_topic</exec_depend>
  <exec_depend>pkg_service</exec_depend>
  <exec_depend>pkg_action</exec_depend>
  <exec_depend>pkg_param</exec_depend>

  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
  <build_type>ament_cmake</build_type>
  </export>
</package>

cmake_minimum_required(VERSION 3.5)
project(pkg_metapackage)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find_package(ament_cmake REQUIRED)

ament_package()

colcon build --packages-select pkg_metapackage

ros2 run demo_nodes_py talker

ros2 run demo_nodes_py listener

$ export ROS_DOMAIN_ID=<your_domain_id>

echo "export ROS_DOMAIN_ID=6" >> ~/.bashrc  # Here `6` is the `ROS_DOMAIN_ID`; it does not have to be `6` as long as it follows the `ROS_DOMAIN_ID` rules
source ~/.bashrc
ros2 run demo_nodes_py talker

echo "export ROS_DOMAIN_ID=6" >> ~/.bashrc  # Keep this value the same as the host side
source ~/.bashrc
ros2 run demo_nodes_py listener

ros2 run turtlesim turtlesim_node

ros2 run turtlesim turtle_teleop_key

ros2 topic pub /chatter std_msgs/msg/Int32 "data: 66" --qos-reliability best_effort

ros2 topic echo /chatter --qos-reliability reliable