ROS1代码迁移到ROS2

# ament_cmake，默认
ros2 pkg create --build-type ament_cmake <package_name>
# cmake
ros2 pkg create --build-type cmake <package_name>

<depend>foo</depend>
<!-- <depend>等于以下 -->
<build_depend>foo</build_depend>
<build_export_depend>foo</build_export_depend>
<exec_depend>foo</exec_depend>
<!-- ros2没有以下 -->
<run_depend>foo</run_depend>

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

set(CMAKE_CXX_STANDARD 17)
find_package(rosidl_default_generators REQUIRED)
find_package(message_package REQUIRED)
rosidl_generate_interfaces(${PROJECT_NAME}
  "msg/Num.msg"
  "msg/Sphere.msg"
  "srv/AddThreeInts.srv"
  DEPENDENCIES geometry_msgs # Add packages that above messages depend on, in this case geometry_msgs for Sphere.msg
)

<buildtool_depend>ament_cmake</buildtool_depend>
<!-- your dependencies -->
<export>
  <build_type>ament_cmake</build_type>
</export>

find_package(ament_cmake REQUIRED)
find_package(component1 REQUIRED)
# ...
find_package(componentN REQUIRED)

rosidl_generate_interfaces(${PROJECT_NAME}
  ${msg_files}
  DEPENDENCIES std_msgs
)

// ROS 1 style is in comments, ROS 2 follows, uncommented.
// #include "nav_msgs/GetMap.h"
#include "nav_msgs/srv/get_map.hpp"

// bool service_callback(
//   nav_msgs::GetMap::Request & request,
//   nav_msgs::GetMap::Response & response)
void service_callback(
  const std::shared_ptr<nav_msgs::srv::GetMap::Request> request,
  std::shared_ptr<nav_msgs::srv::GetMap::Response> response)
{
  // ...
  // return true;  // or false for failure
}

namespace rclcpp {
  ...
  explicit Clock(rcl_clock_type_t clock_type = RCL_SYSTEM_TIME);
}

auto locateTime = rclcpp::Time(locate.header.stamp);
if (locateTime.get_clock_type() == RCL_CLOCK_UNINITIALIZED) {
    LOGW_HZ(0.5, "定位时间戳类型错误");
}

<node pkg="my_package" exec="my_executable" name="my_node">
   <!--A string parameter with value "1"-->
   <param name="a_string" value="'1'"/>
   <!--A integer parameter with value 1-->
   <param name="an_int" value="1"/>
   <!--A float parameter with value 1.0-->
   <param name="a_float" value="1.0"/>
   <!--A string parameter with value "asd"-->
   <param name="another_string" value="asd"/>
   <!--Another string parameter, with value "asd"-->
   <param name="string_with_same_value_as_above" value="'asd'"/>
   <!--Another string parameter, with value "'asd'"-->
   <param name="quoted_string" value="\'asd\'"/>
   <!--A list of strings, with value ["asd", "bsd", "csd"]-->
   <param name="list_of_strings" value="asd, bsd, csd" value-sep=", "/>
   <!--A list of ints, with value [1, 2, 3]-->
   <param name="list_of_ints" value="1,2,3" value-sep=","/>
   <!--Another list of strings, with value ["1", "2", "3"]-->
   <param name="another_list_of_strings" value="'1';'2';'3'" value-sep=";"/>
   <!--A list of strings using an strange separator, with value ["1", "2", "3"]-->
   <param name="strange_separator" value="'1'//'2'//'3'" value-sep="//"/>
</node>

<node pkg="my_package" exec="my_executable" name="my_node" ns="/an_absoulute_ns">
   <param name="group1">
      <param name="group2">
         <param name="my_param" value="1"/>
      </param>
      <param name="another_param" value="2"/>
   </param>
</node>

<node pkg="my_package" exec="my_executable" name="my_node" ns="/an_absoulute_ns">
   <param from="/path/to/file"/>
</node>

<node pkg="tf2" exec="static_transform_publisher" name="vehicleTransPublisher"
          args="-$(arg sensorOffsetX) -$(arg sensorOffsetY) 0 0 0 0 /sensor /vehicle 1000"/>

<node pkg="tf2_ros" exec="static_transform_publisher" name="vehicleTransPublisher" args="-$(var sensorOffsetX) -$(var sensorOffsetY) 0 0 0 0 /sensor /vehicle"/>

ros2 run some_package some_ros_executable --ros-args -r foo:=bar

ros2 run some_package some_ros_executable --ros-args -p my_param:=value

ros2 run some_package some_ros_executable --ros-args -r __node:=new_node_name

ros2 run some_package some_ros_executable --ros-args -r __ns:=/new/namespace

#include <rclcpp/rclcpp.hpp>
#include <std_msgs/msg/string.hpp>
#include <sensor_msgs/msg/point_cloud2.hpp>

class MyNode : public rclcpp::Node
{
public:
  MyNode() : Node("my_node")
    {
      publisher_ = this->create_publisher<std_msgs::msg::String>("topic", 10);
      subscription_ = this->create_subscription<sensor_msgs::msg::PointCloud2>(
      "topic", rclcpp::SensorDataQoS(), [this] (sensor_msgs::msg::PointCloud2::ConstSharedPtr msg) { topic_callback(msg); });
    }
private:
  void topic_callback(sensor_msgs::msg::PointCloud2::ConstSharedPtr msg) const
    {
      RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg->data.c_str());
    }
private:
  rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
  rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
}

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

bool take(MessageT & message_out, rmw_message_info_t & message_info_out);

#include <rclcpp/rclcpp.hpp>
#include <rclcpp_action/rclcpp_action.hpp>
#include <your_action_pkg/action/YourAction.hpp>  // 替换为你的动作消息头文件

class ActionClientNode : public rclcpp::Node
{
public:
  ActionClientNode() : Node("action_client_node")
  {
    this->client_ptr_ = rclcpp_action::create_client<your_action_pkg::action::YourAction>(this,
      "your_action_name");  // 替换为你的动作名称

    // 创建一个目标
    auto goal_msg = your_action_pkg::action::YourAction::Goal();
    // ... 填充目标消息

    // 发送目标，并绑定结果回调函数
    this->client_ptr_->async_send_goal(goal_msg, std::bind(&ActionClientNode::goal_response_callback, this, std::placeholders::_1));
  }

private:
  void goal_response_callback( rclcpp_action::ClientGoalHandle<your_action_pkg::action::YourAction>::SharedPtr goal_handle)
  {
    if (!goal_handle) {
      RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
    } else {
      RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
      goal_handle->async_result(std::bind(&ActionClientNode::result_callback, this, std::placeholders::_1));
    }
  }

  void feedback_callback( rclcpp_action::ClientGoalHandle<your_action_pkg::action::YourAction>::SharedPtr goal_handle,
    const std::shared_ptr<const your_action_pkg::action::YourAction::Feedback> feedback)
  {
    
  }

  void result_callback(const rclcpp_action::ClientGoalHandle<your_action_pkg::action::YourAction>::WrappedResult & result)
  {
    switch(result.code) {
      case rclcpp_action::ResultCode::SUCCEEDED:
        // 处理成功的结果
        break;
      case rclcpp_action::ResultCode::ABORTED:
        // 处理被服务器中止的结果
        break;
      case rclcpp_action::ResultCode::CANCELED:
        // 处理被客户端取消的结果
        break;
      default:
        // 处理其他结果
        break;
    }
  }

  rclcpp_action::Client<your_action_pkg::action::YourAction>::SharedPtr client_ptr_;
};

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

#include <rclcpp/rclcpp.hpp>
#include <rclcpp_action/rclcpp_action.hpp>
#include <your_action_pkg/action/YourAction.hpp>  // 替换为你的动作消息头文件

class ActionServerNode : public rclcpp::Node
{
public:
  ActionServerNode() : Node("action_server_node")
  {
    using GoalHandle = rclcpp_action::ServerGoalHandle<your_action_pkg::action::YourAction>;

    this->server_ptr_ = rclcpp_action::create_server<your_action_pkg::action::YourAction>(this,
      "your_action_name",  // 替换为你的动作名称
      std::bind(&ActionServerNode::handle_goal, this, std::placeholders::_1, std::placeholders::_2),
      std::bind(&ActionServerNode::handle_cancel, this, std::placeholders::_1),
      std::bind(&ActionServerNode::handle_accepted, this, std::placeholders::_1));
  }

private:
  rclcpp_action::GoalResponse handle_goal(
    const rclcpp_action::GoalUUID & uuid,
    your_action_pkg::action::YourAction::Goal::ConstSharedPtr goal)
  {
    // 处理新的目标请求
    return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
  }

  rclcpp_action::CancelResponse handle_cancel(
    std::shared_ptr<rclcpp_action::ServerGoalHandle<your_action_pkg::action::YourAction>> goal_handle)
  {
    // 处理取消请求
    return rclcpp_action::CancelResponse::ACCEPT;
  }

  void handle_accepted( std::shared_ptr<rclcpp_action::ServerGoalHandle<your_action_pkg::action::YourAction>> goal_handle)
  {
    // 处理已接受的目标
  }

  rclcpp_action::Server<your_action_pkg::action::YourAction>::SharedPtr server_ptr_;
};

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

#include <rclcpp/rclcpp.hpp>
#include <your_srv_pkg/srv/YourService.hpp>  // 替换为你的服务消息头文件

class ServiceClientNode : public rclcpp::Node
{
public:
  ServiceClientNode() : Node("service_client_node")
  {
    this->client_ptr_ = this->create_client<your_srv_pkg::srv::YourService>("your_service_name");  // 替换为你的服务名称

    // 创建一个服务请求
    auto request = std::make_shared<your_srv_pkg::srv::YourService::Request>();
    // ... 填充请求消息

    // 发送服务请求，并绑定响应回调函数
    this->client_ptr_->async_send_request(request, std::bind(&ServiceClientNode::response_callback, this, std::placeholders::_1));
  }

private:
  void response_callback(const typename your_srv_pkg::srv::YourService::Response::SharedPtr response)
  {
    // 处理服务响应
  }

  rclcpp::Client<your_srv_pkg::srv::YourService>::SharedPtr client_ptr_;
};

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

#include <rclcpp/rclcpp.hpp>
#include <your_srv_pkg/srv/YourService.hpp>  // 替换为你的服务消息头文件

class ServiceServerNode : public rclcpp::Node
{
public:
  ServiceServerNode() : Node("service_server_node")
  {
    this->server_ptr_ = this->create_service<your_srv_pkg::srv::YourService>(
      "your_service_name",  // 替换为你的服务名称
      std::bind(&ServiceServerNode::handle_service, this, std::placeholders::_1, std::placeholders::_2));
  }

private:
  void handle_service(
    const your_srv_pkg::srv::YourService::Request::SharedPtr request,
    your_srv_pkg::srv::YourService::Response::SharedPtr response)
  {
    // 处理服务请求，并填充响应消息
  }

  rclcpp::Service<your_srv_pkg::srv::YourService>::SharedPtr server_ptr_;
};

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

colcon build --event-handlers console_direct+ --packages-select foo_package

get_cmake_property(_variableNames VARIABLES)
foreach (_variableName ${_variableNames})
    message(STATUS "${_variableName}=${${_variableName}}")
endforeach()

find_package(pcl_conversions REQUIRED)
find_package(PCL REQUIRED COMPONENTS common io)
link_directories(${PCL_LIBRARY_DIRS})
add_definitions(${PCL_DEFINITIONS})

#include <geometry_msgs/msg/quaternion.hpp>
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <tf2/LinearMath/Quaternion.h>

namespace tf
{

inline geometry_msgs::msg::Quaternion createQuaternionMsgFromYaw(double yaw)
{
    tf2::Quaternion q;
    q.setRPY(0, 0, yaw);
    return tf2::toMsg(q);
}

inline geometry_msgs::msg::Quaternion createQuaternionMsgFromRollPitchYaw(double roll, double pitch, double yaw)
{
    tf2::Quaternion q;
    q.setRPY(roll, pitch, yaw);
    return tf2::toMsg(q);
}

inline tf2::Quaternion createQuaternionFromYaw(double yaw)
{
    tf2::Quaternion q;
    q.setRPY(0, 0, yaw);
    return q;
}

inline tf2::Quaternion createQuaternionFromRPY(double roll, double pitch, double yaw)
{
    tf2::Quaternion q;
    q.setRPY(roll, pitch, yaw);
    return q;
}
}

rclcpp::InitOptions options;
options.auto_initialize_logging(false);
rclcpp::init(argc, argv, options);

cmake_minimum_required(VERSION 3.14)
project("ROS2 Master")

# usually I put this in a separate file include("/opt/ros/_common/Colcon.cmake")
function(colcon_add_subdirectories)
  cmake_parse_arguments(PARSE_ARGV 0 "ARG" "" "BUILD_BASE;BASE_PATHS" "")

  message("search criteria: ${ARGV}")

  execute_process(COMMAND colcon list
    --paths-only
    --base-paths ${ARG_BASE_PATHS}
    --topological-order
    ${ARG_UNPARSED_ARGUMENTS}
    OUTPUT_VARIABLE paths)
    string(STRIP "${paths}" paths)
    string(REPLACE "\n" ";" paths "${paths}"
  )

  MESSAGE("colcon shows paths ${paths}")

  foreach(path IN LISTS paths)
    message("...examining ${path}")
    # if(EXISTS "${path}/CMakeLists.txt")
    execute_process(COMMAND colcon info --paths "${path}" OUTPUT_VARIABLE package_info)
    if(NOT "${package_info}" MATCHES "type:[ \t]+(cmake|ros.ament_cmake|ros.cmake)")
      message("skipping non-cmake project")
    elseif(NOT "${package_info}" MATCHES "name:[ \t]+([^ \r\n\t]*)")
      message(WARNING "could not identify package at ${path}")
    else()
      set(name "${CMAKE_MATCH_1}")
      message("...adding package ${name} from path ${path}")
      MESSAGE("package info: ${package_info}")

      get_filename_component(BUILD_PATH "${name}" ABSOLUTE BASE_DIR "${ARG_BUILD_BASE}")

      add_subdirectory("${path}" "${BUILD_PATH}")
    endif()
  endforeach()
endfunction()

colcon_add_subdirectories(
 BUILD_BASE "${PROJECT_SOURCE_DIR}/build"
 BASE_PATHS "${PROJECT_SOURCE_DIR}/src/"
  # 指定单独编译包
# --packages-select locate_node
)

find_package(package_a REQUIRED)
# 上面语句可以改为
find_package(package_a QUIET)

ament_target_dependencies(${PROJECT_NAME} package_a)
上面语句需要在顶层CMake中定义一个变量 USE_AMENT 开关ament，把因为QUIET导入包出问题的ament语句放进去

if (USE_AMENT)
  ament_target_dependencies(${PROJECT_NAME} package_a)
endif ()

// 创建一个PoseStamped消息
geometry_msgs::msg::PoseStamped pose_stamped_msg;

// 转换为tf2::Transform
tf2::Transform tf2_transform;
tf2::fromMsg(pose_stamped_msg.pose, tf2_transform);

// 创建一个tf2::Transform
tf2::Transform tf2_transform_new;

// 转换为PoseStamped消息
geometry_msgs::msg::PoseStamped pose_stamped_msg_new;
pose_stamped_msg_new.pose = tf2::toMsg(tf2_transform_new);

if(${rosidl_cmake_VERSION} VERSION_LESS 2.5.0)
    rosidl_target_interfaces(trajectory_analyzer_node
    planning_debug_tools "rosidl_typesupport_cpp")
else()
    rosidl_get_typesupport_target(
            cpp_typesupport_target planning_debug_tools "rosidl_typesupport_cpp")
    target_link_libraries(trajectory_analyzer_node "${cpp_typesupport_target}")
endif()

if(POLICY CMP0057)
    cmake_policy(SET CMP0057 NEW)
endif()

<launch>
  <node pkg="test_param" exec="test_param">
    <param name="a" value="0.0" />
  </node>
</launch>

int main(int argc, char **argv)
{
    rclcpp::init(argc, argv);
    rclcpp::Node node("test_param");
    double a = 1.0;
    // node.declare_parameter("a", rclcpp::ParameterType::PARAMETER_DOUBLE);
    // 这种更方便
    node.declare_parameter("a", a);
    node.get_parameter("a", a);
    RCLCPP_INFO(node.get_logger(), "a: %lf", a);
}

node.declare_parameter("value_name", default_value);
bool result = node.get_parameter("value_name", value);

# build package
alias colcon-bp='colcon build --symlink-install --event-handlers console_direct+ --cmake-args -Wno-dev -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -G Ninja --packages-select'
# build all
alias colcon-ba='colcon build --symlink-install --event-handlers console_direct+ --cmake-args -Wno-dev -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -G Ninja'

#!/usr/bin/python3

# 该脚本用来初步替换代码中的内容为ROS2的写法

import re
import sys

# 创建一个列表，其中包含所有查找和替换的正则表达式对
cpp_regex = [
    (r'\b(\w*_msgs)\:\:(?!msg)(\w{1,})\b', r'\1::msg::\2'),
    (r'\bconst (\w*_msgs\:\:msg\:\:\w*?)(::)?ConstPtr\s*&\s*(\w*)', r'\1::ConstSharedPtr \3'),
    (r'(\w*\-\>header\.stamp)\.toSec\(\)', r'rclcpp::Time(\1).seconds()'),
    (r'ros\:\:Time\(\)\.fromSec\((laserCloudTime)\)', r'rclcpp::Time(\1).seconds()'),
    (r'ros\:\:Time ', r'rclcpp::Time '),
    (r'ROS_(\w+)\(((?:.|\n)*?)\);', r'RCLCPP_\1(node->get_logger(), \2);'),
    ('<time.h>', '<ctime>'),
    ('<math.h>', '<cmath>'),
    ('<stdio.h>', '<cstdio>'),
    ('<stdlib.h>', '<cstdlib>'),
    ('<ros/ros.h>', '<rclcpp/rclcpp.hpp>'),
    ('<std_msgs/Bool.h>', '<std_msgs/msg/bool.hpp>'),
    ('<std_msgs/Int32.h>', '<std_msgs/msg/int32.hpp>'),
    ('<std_msgs/UInt32.h>', '<std_msgs/msg/uint32.hpp>'),
    ('<std_msgs/String.h>', '<std_msgs/msg/string.hpp>'),
    ('<std_msgs/Int32MultiArray.h>', '<std_msgs/msg/int32_multi_array.hpp>'),
    ('<std_msgs/Float32MultiArray.h>', '<std_msgs/msg/float32_multi_array.hpp>'),
    ('<std_msgs/ColorRGBA.h>', '<std_msgs/msg/color_rgba.hpp>'),
    ('<nav_msgs/Path.h>', '<nav_msgs/msg/path.hpp>'),
    ('<nav_msgs/Odometry.h>', '<nav_msgs/msg/odometry.hpp>'),
    ('<geometry_msgs/Pose.h>', '<geometry_msgs/msg/pose.hpp>'),
    ('<geometry_msgs/Point.h>', '<geometry_msgs/msg/point.hpp>'),
    ('<geometry_msgs/Polygon.h>', '<geometry_msgs/msg/polygon.hpp>'),
    ('<geometry_msgs/PoseStamped.h>', '<geometry_msgs/msg/pose_stamped.hpp>'),
    ('<geometry_msgs/PointStamped.h>', '<geometry_msgs/msg/point_stamped.hpp>'),
    ('<geometry_msgs/PolygonStamped.h>', '<geometry_msgs/msg/polygon_stamped.hpp>'),
    ('<sensor_msgs/PointCloud2.h>', '<sensor_msgs/msg/point_cloud2.hpp>'),
    ('<sensor_msgs/Joy.h>', '<sensor_msgs/msg/joy.hpp>'),
    ('<visualization_msgs/Marker.h>', '<visualization_msgs/msg/marker.hpp>'),
    ('<tf/transform_datatypes.h>', '<tf2/transform_datatypes.h>'),
    ('<tf/transform_broadcaster.h>', '<tf2_ros/transform_broadcaster.h>'),
    ('tf::TransformBroadcaster', 'tf2_ros::TransformBroadcaster'),
    ('tf::Matrix3x3', 'tf2::Matrix3x3'),
    ('ros::Publisher ', 'rclcpp::Publisher<>::SharedPtr '),
    ('ros::Subscriber ', 'rclcpp::Subscription<>::SharedPtr '),
    ('tf::Vector3', 'tf2::Vector3'),
    ('tf::Quaternion', 'tf2::Quaternion'),
    ('ros::NodeHandle nh;', 'rclcpp::Node node();'),
    ('ros::Rate', 'rclcpp::Rate'),
    ('ros::ok', 'rclcpp::ok'),
    ('ros::init', 'rclcpp::init'),
    ('ros::spin', 'rclcpp::spin'),
    ('ros::Timer ', 'rclcpp::TimerBase::SharedPtr '),
    ('tf2::StampedTransform', 'geometry_msgs::msg::TransformStamped'),
    ('\.publish', '->publish'),
    ('boost::bind', 'std::bind'),
]

cmake_regex = [
    (r'cmake_minimum_required\(VERSION (.*)\)', r'cmake_minimum_required(VERSION 3.5)'),
]

launch_regex = [
    # type换成exec
    (r'(\<node.*?)type=(.*/?\>)', r'\1exec=\2'),
    # 去掉node里面的required
    (r'(\<node.*?) required\=\"\w*?\"(.*/?\>)', r'\1\2'),
    # 去掉param里面的type
    (r'(\<param.*?) type=\"\w*?\"(.*/?\>)', r'\1\2'),
    (r'\$\(find ', '$(find-pkg-share '),
    (r'\bns\b', 'namespace'),
    (r'\$\(arg', '$(var'),
    ('pkg\=\"rviz\"', 'pkg=\"rviz2\"'),
    ('name\=\"rviz\"', 'name=\"rviz2\"'),
    ('exec\=\"rviz\"', 'exec=\"rviz2\"'),
]

if __name__ == '__main__':
    # 如果argc < 2, 则运行测试代码，否则读取argv[1]文件替换文件内容
    open_file = len(sys.argv) > 1

    if open_file:
        text = open(sys.argv[1]).read()
    else:
        text = "const sensor_msgs::PointCloud2ConstPtr& laserCloud2"

    regex_pairs = []
    # 根据文件后缀选择正则表达式
    if open_file and (sys.argv[1].endswith('.cpp') or sys.argv[1].endswith('.h') or sys.argv[1].endswith('.hpp')):
        print('cpp file')
        regex_pairs = cpp_regex
    elif open_file and (sys.argv[1].endswith('.cmake') or sys.argv[1].endswith('CMakeLists.txt')):
        print('cmake file')
        regex_pairs = cmake_regex
    elif open_file and sys.argv[1].endswith('.launch'):
        print('launch file')
        regex_pairs = launch_regex

    for find, replace in regex_pairs:
        text = re.sub(find, replace, text)

    # 保存文件
    if open_file:
        with open(sys.argv[1], 'w') as f:
            f.write(text)
    else:
        print(text)