ROS 中 pluginlib 教程详解：编写与使用简单插件的完整指南-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_73640344/article/details/146923630

ROS 中 `pluginlib` 教程详解：编写与使用简单插件的完整指南

简介

pluginlib 是 ROS 提供的一个强大且灵活的 C++ 库，旨在简化插件的创建、注册与动态加载过程。通过插件化设计，开发者可以在不修改核心应用程序代码的情况下，扩展或修改应用功能，从而提升系统的可扩展性和维护性。本文将详细介绍如何使用 pluginlib 编写和使用简单插件，涵盖从准备工作到实际运行的完整流程，适合初学者及有一定基础的开发者参考。

准备工作

在开始编写插件之前，确保系统环境已正确配置，并安装了必要的依赖包。

1. 安装预制的 `pluginlib_tutorials` 包

根据所使用的 ROS 发行版（如 humble、iron 或 rolling），执行以下命令安装预制的教程包：

sudo apt-get update
sudo apt-get install ros-<ROS_DISTRO>-common-tutorials

说明：

将 <ROS_DISTRO> 替换为具体的 ROS 发行版名称，例如 humble、iron 或 rolling。

2. 创建工作空间及插件包

建议在 catkin_ws/src/ 目录下创建新的插件包，以便组织和管理插件相关的代码。

cd ~/catkin_ws/src/
catkin_create_pkg pluginlib_tutorials_ roscpp pluginlib

说明：

pluginlib_tutorials_ 是新创建的插件包名称。
roscpp 和 pluginlib 是该包的依赖库，确保在编译过程中能正确链接。

创建基础类

插件机制依赖于一个基础类，所有插件类将继承自该基础类。基础类定义了插件需要实现的接口和功能。

1. 创建基础类头文件

在 pluginlib_tutorials_ 包的 include/pluginlib_tutorials_/ 目录下创建 polygon_base.h 文件，并添加以下内容：

#ifndef PLUGINLIB_TUTORIALS__POLYGON_BASE_H_
#define PLUGINLIB_TUTORIALS__POLYGON_BASE_H_

namespace polygon_base
{
  class RegularPolygon
  {
    public:
      // 初始化多边形，设置边长
      virtual void initialize(double side_length) = 0;

      // 计算多边形面积
      virtual double area() = 0;

      // 虚析构函数，确保派生类能够正确析构
      virtual ~RegularPolygon(){}

    protected:
      // 保护的构造函数，防止直接实例化
      RegularPolygon(){}
  };
};

#endif // PLUGINLIB_TUTORIALS__POLYGON_BASE_H_

详细解释：

命名空间 polygon_base：避免名称冲突，组织代码结构。
抽象类 RegularPolygon：
- initialize(double side_length)：纯虚函数，用于初始化多边形的边长。由于 pluginlib 要求插件类必须有无参构造函数，任何需要参数的初始化操作应在此方法中完成。
- area()：纯虚函数，用于计算多边形的面积。
- 虚析构函数：确保在删除基类指针时，能够正确调用派生类的析构函数，防止内存泄漏。
- 保护的构造函数：防止直接实例化基础类，只允许通过继承来创建对象。

创建插件

在本例中，我们将创建两个具体的多边形插件类：Triangle（三角形）和 Square（正方形），它们将继承自 RegularPolygon 基类。

1. 创建插件类头文件

在 include/pluginlib_tutorials_/ 目录下创建 polygon_plugins.h 文件，并添加以下内容：

#ifndef PLUGINLIB_TUTORIALS__POLYGON_PLUGINS_H_
#define PLUGINLIB_TUTORIALS__POLYGON_PLUGINS_H_

#include <pluginlib_tutorials_/polygon_base.h>
#include <cmath> // 用于数学计算

namespace polygon_plugins
{
  // 三角形插件类
  class Triangle : public polygon_base::RegularPolygon
  {
    public:
      Triangle(){} // 默认构造函数

      // 初始化三角形，设置边长
      void initialize(double side_length)
      {
        side_length_ = side_length;
      }

      // 计算三角形面积
      double area()
      {
        return 0.5 * side_length_ * getHeight();
      }

      // 计算三角形高度
      double getHeight()
      {
        return sqrt((side_length_ * side_length_) - ((side_length_ / 2) * (side_length_ / 2)));
      }

    private:
      double side_length_; // 边长
  };

  // 正方形插件类
  class Square : public polygon_base::RegularPolygon
  {
    public:
      Square(){} // 默认构造函数

      // 初始化正方形，设置边长
      void initialize(double side_length)
      {
        side_length_ = side_length;
      }

      // 计算正方形面积
      double area()
      {
        return side_length_ * side_length_;
      }

    private:
      double side_length_; // 边长
  };
};

#endif // PLUGINLIB_TUTORIALS__POLYGON_PLUGINS_H_

详细解释：

命名空间 polygon_plugins：组织插件类，避免名称冲突。
类 Triangle：
- 继承自 RegularPolygon 基类。
- 实现 initialize 方法，设置三角形的边长。
- 实现 area 方法，计算三角形的面积。
- getHeight 方法：根据边长计算三角形的高度。
类 Square：
- 继承自 RegularPolygon 基类。
- 实现 initialize 方法，设置正方形的边长。
- 实现 area 方法，计算正方形的面积。

注意事项：

每个插件类必须实现基类中的所有纯虚函数。
插件类需要有无参构造函数，以满足 pluginlib 的要求。

注册插件

为了使 pluginlib 能够识别和加载这些插件类，需要使用特定的宏将插件类注册为可加载的插件。

1. 创建插件注册源文件

在 src/ 目录下创建 polygon_plugins.cpp 文件，并添加以下内容：

#include <pluginlib/class_list_macros.h>
#include <pluginlib_tutorials_/polygon_base.h>
#include <pluginlib_tutorials_/polygon_plugins.h>

// 使用 PLUGINLIB_EXPORT_CLASS 宏注册插件类
PLUGINLIB_EXPORT_CLASS(polygon_plugins::Triangle, polygon_base::RegularPolygon)
PLUGINLIB_EXPORT_CLASS(polygon_plugins::Square, polygon_base::RegularPolygon)

详细解释：

包含头文件：
- pluginlib/class_list_macros.h：包含用于注册插件的宏定义。
- polygon_base.h 和 polygon_plugins.h：包含基类和插件类的定义。
PLUGINLIB_EXPORT_CLASS 宏：
- PLUGINLIB_EXPORT_CLASS(polygon_plugins::Triangle, polygon_base::RegularPolygon)：注册 Triangle 类为 RegularPolygon 的插件。
- PLUGINLIB_EXPORT_CLASS(polygon_plugins::Square, polygon_base::RegularPolygon)：注册 Square 类为 RegularPolygon 的插件。
作用：
- 通过宏将插件类与基类关联，使 pluginlib 能够在运行时动态加载这些插件类。

注意事项：

每个插件类都需要单独使用 PLUGINLIB_EXPORT_CLASS 宏进行注册。
宏的第一个参数是插件类的完全限定名称，第二个参数是插件基类的完全限定名称。

构建插件库

完成插件类的编写和注册后，需要将其编译为共享库，以供 pluginlib 动态加载。

1. 编辑 `CMakeLists.txt`

在 pluginlib_tutorials_ 包的 CMakeLists.txt 文件中添加以下内容：

# 指定包含目录
include_directories(
  include
  ${catkin_INCLUDE_DIRS}
)

# 创建共享库 polygon_plugins
add_library(polygon_plugins src/polygon_plugins.cpp)

# 指定库链接的依赖项
target_link_libraries(polygon_plugins
  ${catkin_LIBRARIES}
)

详细解释：

include_directories：
- include：指定包含目录，确保编译器能够找到头文件。
- ${catkin_INCLUDE_DIRS}：包含所有依赖包的包含目录。
add_library：
- polygon_plugins：共享库的名称。
- src/polygon_plugins.cpp：源文件路径。
target_link_libraries：
- 将共享库与 catkin 的依赖库链接，确保正确解析依赖关系。

2. 编译插件库

返回工作空间的根目录，执行编译命令：

cd ~/catkin_ws
catkin_make

注意事项：

确保 CMakeLists.txt 配置正确，否则可能会出现编译错误。
编译成功后，生成的共享库将位于 devel/lib/ 目录下，例如 devel/lib/libpolygon_plugins.so。

使插件对 ROS 工具链可用

为了让 ROS 工具链能够识别并加载插件，需要进行额外的配置，包括创建插件描述文件和在包配置中导出插件信息。

插件 XML 文件

插件描述文件是一个 XML 格式的文件，包含插件的关键信息，如库路径、插件类型和基类类型。

1. 创建插件描述文件

在 pluginlib_tutorials_ 包的根目录下创建 polygon_plugins.xml 文件，并添加以下内容：

<library path="lib/libpolygon_plugins">
  <class type="polygon_plugins::Triangle" base_class_type="polygon_base::RegularPolygon">
    <description>This is a triangle plugin.</description>
  </class>
  <class type="polygon_plugins::Square" base_class_type="polygon_base::RegularPolygon">
    <description>This is a square plugin.</description>
  </class>
</library>

详细解释：

<library> 标签：
- path="lib/libpolygon_plugins"：指定包含插件类的共享库路径。相对于包的安装前缀。
<class> 标签：
- type="polygon_plugins::Triangle"：插件类的完全限定名称。
- base_class_type="polygon_base::RegularPolygon"：插件基类的完全限定名称。
- <description> 标签：对插件的简要描述，便于理解插件的功能。
多个 <class> 标签：
- 对于每个插件类，都需要一个独立的 <class> 标签。

注意事项：

插件描述文件的名称和位置需要与后续配置相对应，确保 pluginlib 能够正确找到。
path 属性应指向实际生成的共享库路径，确保插件能够被正确加载。

导出插件

在包的配置文件中导出插件描述文件，使其对 ROS 工具链可见。

1. 编辑 `package.xml`

在 pluginlib_tutorials_ 包的 package.xml 文件中添加以下内容：

<export>
  <pluginlib_tutorials_ plugin="${prefix}/polygon_plugins.xml" />
</export>

详细解释：

<export> 标签：
- 用于声明插件信息，使 ROS 工具链能够识别和加载插件。
<pluginlib_tutorials_> 标签：
- 标签名 pluginlib_tutorials_ 对应于插件基类所在的包名。
- plugin 属性指定插件描述文件的路径，使用 ${prefix} 变量确保路径的正确性。

注意事项：

确保 pluginlib_tutorials.xml 文件位于指定的位置。
标签名应与包名匹配，避免命名错误导致插件无法被识别。

2. 验证插件导出

编译工作空间并源化环境变量：

catkin_make
source devel/setup.bash

使用 rospack 命令验证插件是否成功导出：

rospack plugins --attrib=plugin pluginlib_tutorials_

预期输出：

/home/user/catkin_ws/src/pluginlib_tutorials_/polygon_plugins.xml

说明：

输出显示插件描述文件的完整路径，表明 ROS 工具链已正确识别插件信息。

常见问题：

插件未显示：检查 package.xml 中的 <export> 标签配置是否正确，确保路径无误。
共享库路径错误：确保 <library> 标签中的 path 属性指向实际生成的共享库路径。
权限问题：确保插件描述文件和共享库具有适当的读取权限。

使用插件

创建并注册插件后，可以通过 pluginlib 提供的 API 动态加载和使用这些插件。以下将展示如何编写代码以加载并使用 Triangle 和 Square 插件。

1. 创建插件加载器源文件

在 src/ 目录下创建 polygon_loader.cpp 文件，并添加以下内容：

#include <pluginlib/class_loader.h>
#include <pluginlib_tutorials_/polygon_base.h>
#include <ros/ros.h> // 包含 ROS 日志功能

int main(int argc, char** argv)
{
  // 初始化 ROS 节点
  ros::init(argc, argv, "polygon_loader");
  ros::NodeHandle nh;

  // 创建 ClassLoader 实例，指定插件基类所在的包和基类类型
  pluginlib::ClassLoader<polygon_base::RegularPolygon> poly_loader("pluginlib_tutorials_", "polygon_base::RegularPolygon");

  try
  {
    // 加载 Triangle 插件实例
    boost::shared_ptr<polygon_base::RegularPolygon> triangle = poly_loader.createInstance("polygon_plugins::Triangle");
    triangle->initialize(10.0); // 初始化边长

    // 加载 Square 插件实例
    boost::shared_ptr<polygon_base::RegularPolygon> square = poly_loader.createInstance("polygon_plugins::Square");
    square->initialize(10.0); // 初始化边长

    // 输出各插件的面积
    ROS_INFO("Triangle area: %.2f", triangle->area());
    ROS_INFO("Square area: %.2f", square->area());
  }
  catch(pluginlib::PluginlibException& ex)
  {
    // 处理插件加载失败的情况
    ROS_ERROR("插件加载失败，错误信息: %s", ex.what());
  }

  return 0;
}

详细解释：

包含头文件：
- pluginlib/class_loader.h：包含 ClassLoader 类，用于动态加载插件。
- pluginlib_tutorials_/polygon_base.h：包含插件基类的定义。
- ros/ros.h：包含 ROS 日志功能，用于输出信息和错误。
初始化 ROS 节点：
- ros::init：初始化 ROS 节点。
- ros::NodeHandle：创建节点句柄，用于与 ROS 系统交互。
创建 ClassLoader 实例：
- 参数一：插件基类所在的包名 pluginlib_tutorials_。
- 参数二：插件基类的完全限定名称 polygon_base::RegularPolygon。
加载插件实例：
- createInstance("polygon_plugins::Triangle")：加载 Triangle 插件类的实例。
- createInstance("polygon_plugins::Square")：加载 Square 插件类的实例。
初始化插件对象：
- 调用 initialize 方法，设置多边形的边长为 10.0。
输出面积：
- 使用 ROS_INFO 输出三角形和正方形的面积计算结果。
异常处理：
- 使用 try-catch 结构捕捉并处理插件加载过程中可能出现的异常，确保程序的稳定性。

注意事项：

插件类的名称应与插件描述文件中 type 属性的值一致。
ClassLoader 的生命周期必须覆盖所有插件实例的生命周期，避免在插件使用过程中 ClassLoader 被销毁。

2. 编辑 `CMakeLists.txt`

在 CMakeLists.txt 文件中添加以下内容，以编译插件加载器：

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

# 指定可执行文件链接的库
target_link_libraries(polygon_loader
  polygon_plugins
  ${catkin_LIBRARIES}
)

详细解释：

add_executable：
- polygon_loader：可执行文件名称。
- src/polygon_loader.cpp：源文件路径。
target_link_libraries：
- polygon_plugins：链接插件库，确保加载器能够找到插件类。
- ${catkin_LIBRARIES}：链接所有依赖的 catkin 库。

注意事项：

确保插件库 polygon_plugins 已成功编译，并在链接时能够被找到。
CMakeLists.txt 中的顺序和依赖关系需要正确配置，以避免链接错误。

3. 编译插件加载器

返回工作空间的根目录，执行编译命令：

cd ~/catkin_ws
catkin_make

注意事项：

确保所有源文件和头文件已正确添加到相应的位置。
编译成功后，可执行文件将位于 devel/lib/pluginlib_tutorials_/ 目录下，例如 devel/lib/pluginlib_tutorials_/polygon_loader。

运行代码

编译完成后，即可运行插件加载器，观察插件的加载与执行效果。

1. 运行插件加载器

执行以下命令运行插件加载器：

rosrun pluginlib_tutorials_ polygon_loader

预期输出：

[ INFO] [WallTime: 1279658450.869089666]: Triangle area: 43.30
[ INFO] [WallTime: 1279658450.869138007]: Square area: 100.00

详细解释：

输出信息：
- Triangle area: 43.30：显示加载的三角形插件计算出的面积。
- Square area: 100.00：显示加载的正方形插件计算出的面积。
说明：
- 成功加载并使用了 Triangle 和 Square 插件，验证了插件的正确性和 pluginlib 的功能。

注意事项：

如果插件加载失败，将输出错误信息，需根据错误提示进行调试。
确保插件描述文件和共享库路径配置正确，避免路径错误导致插件无法加载。

常见问题与调试

在编写和使用插件的过程中，可能会遇到一些常见问题。以下是几种常见问题及其解决方法：

1. 插件未被识别或加载

症状：

运行 rosrun 命令时，插件加载失败，输出错误信息。
使用 rospack plugins --attrib=plugin <package_name> 时，插件未显示。

可能原因及解决方法：

插件描述文件路径错误：
- 检查 polygon_plugins.xml 文件中的 <library path="lib/libpolygon_plugins"> 是否指向正确的共享库路径。
package.xml 中 <export> 标签配置错误：
- 确保 <export> 标签中的 plugin 属性指向正确的插件描述文件路径。
编译未成功：
- 确保所有源文件和头文件已正确编译，无编译错误。
权限问题：
- 确保插件描述文件和共享库具有适当的读取权限。

2. `PLUGINLIB_EXPORT_CLASS` 宏未正确使用

症状：

插件类无法被 pluginlib 识别，加载时报错。

可能原因及解决方法：

宏参数错误：
- 确保 PLUGINLIB_EXPORT_CLASS 的第一个参数是插件类的完全限定名称，第二个参数是插件基类的完全限定名称。
插件类未继承自基类：
- 检查插件类是否正确继承自基础类，并实现所有纯虚函数。

3. 动态加载插件时报错

症状：

运行插件加载器时，出现 PluginlibException 错误。

可能原因及解决方法：

插件类名称错误：
- 确保在 createInstance 方法中使用的插件类名称与插件描述文件中的 type 属性一致。
插件基类不匹配：
- 确保插件类继承自正确的基类，并且基类类型在 ClassLoader 中正确指定。
共享库未找到或损坏：
- 检查共享库文件是否存在于指定路径，且没有损坏。

4. 插件初始化失败

症状：

插件实例创建成功，但在调用 initialize 方法或其他功能时出现错误。

可能原因及解决方法：

初始化参数错误：
- 确保传递给 initialize 方法的参数有效且合理。
插件类内部逻辑错误：
- 检查插件类的实现逻辑，确保方法的正确性和稳定性。

总结

通过本教程，我们系统地介绍了如何在 ROS 2 中使用 pluginlib 创建、注册和使用插件。具体步骤包括：

准备工作：
- 安装必要的包，并创建工作空间与插件包，确保开发环境配置正确。
创建基础类：
- 定义插件的基类 RegularPolygon，规定插件需要实现的接口，如 initialize 和 area 方法，确保插件类能够统一接口，便于动态加载和使用。
创建插件：
- 实现具体的插件类 Triangle 和 Square，继承自基类并实现必要的方法，满足 pluginlib 的要求。
注册插件：
- 使用 PLUGINLIB_EXPORT_CLASS 宏将插件类注册为可加载的插件，确保 pluginlib 能够在运行时识别和加载这些插件。
构建插件库：
- 配置 CMakeLists.txt，编译插件源代码生成共享库，确保插件类能够被动态加载。
使插件对 ROS 工具链可用：
- 编写插件描述文件 polygon_plugins.xml，详细描述插件信息。
- 在 package.xml 中导出插件信息，确保 ROS 工具链能够正确识别和加载插件。
使用插件：
- 通过 pluginlib::ClassLoader 动态加载插件实例，调用插件方法实现功能，展示插件的动态性和灵活性。
运行代码：
- 编译并运行插件加载器，验证插件的正确加载与功能实现，确保整个流程无误。
常见问题与调试：
- 介绍了在插件编写和使用过程中可能遇到的常见问题及其解决方法，帮助开发者快速定位和解决问题，提升开发效率。

关键要点：

插件基类设计：
- 确保基类定义了所有插件需要实现的接口，并且具有无参构造函数。
- 使用抽象类和纯虚函数，统一插件接口，提升插件的可替换性和互操作性。
插件注册：
- 正确使用 PLUGINLIB_EXPORT_CLASS 宏，将插件类与基类关联，确保 pluginlib 能够识别和加载插件。
- 在插件描述文件中详细描述插件信息，包括库路径、插件类型和基类类型等，确保插件的正确加载和使用。
插件描述文件：
- 提供插件所在库的路径、插件类型及基类类型等关键信息，使 pluginlib 能够正确识别和加载插件。
- 使用 XML 格式，结构清晰，便于机器和人类阅读。
动态加载：
- 使用 pluginlib::ClassLoader 动态加载插件，无需在编译时链接插件库，提升系统的灵活性和可扩展性。
- 确保 ClassLoader 的生命周期覆盖所有插件实例的生命周期，避免插件使用过程中 ClassLoader 被销毁导致的问题。
错误处理：
- 通过异常捕捉机制，确保在插件加载失败时能够及时处理并反馈错误信息，提升程序的稳定性和可靠性。
- 详细的错误信息有助于快速定位和解决问题，减少开发时间和成本。

应用场景与优势：

模块化设计：
- 支持插件基类与插件实现的分离，促进代码的复用与维护。
- 允许在不修改核心应用程序代码的情况下，扩展或修改功能，提升系统的可扩展性和灵活性。
灵活性与可维护性：
- 动态加载插件，支持在运行时根据需求加载不同的插件，适应不断变化的应用需求。
- 插件化设计简化了功能扩展过程，促进了协作开发和代码的模块化管理。
复用与协作：
- 插件可以在多个项目中复用，减少重复开发，提高开发效率。
- 促进不同团队之间的协作，各自开发独立的插件，实现功能的无缝集成。