3.1 Hardware Interface Types（硬件接口类型）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/hardware_interface_types_userdoc.html

ros2_control 框架提供了一组硬件接口类型，可用于为特定机器人或设备实现硬件组件。以下各节描述不同的硬件接口类型及其用法。

1
<ros2_control name="Name_of_the_hardware" type="system">
2
  <hardware>
3
    <plugin>library_name/ClassName</plugin>
4
    <!-- added to hardware_parameters -->
5
    <param name="example_param">value</param>
6
  </hardware>
7
  <joint name="name_of_the_component">
8
    <!-- `data_type` argument is optional (defaults to double). -->
9
    <command_interface name="interface_name" data_type="double">
10
      <!-- All of them are optional. -->
11
      <param name="min">-1</param>
12
      <param name="max">1</param>
13
      <param name="initial_value">0.0</param>
14
       <!-- Optional. Added to the key/value storage parameters -->
15
      <param name="own_param_1">some_value</param>
16
      <param name="own_param_2">other_value</param>
17
    </command_interface>
18
    <!-- Short form to define StateInterface. Can be extended like CommandInterface. -->
19
    <state_interface name="position"/>
20
  </joint>
21
</ros2_control>

1
<ros2_control name="RRBotSystemMutipleGPIOs" type="system">
2
  <hardware>
3
    <plugin>ros2_control_demo_hardware/RRBotSystemPositionOnlyHardware</plugin>
4
    <param name="example_param_hw_start_duration_sec">2.0</param>
5
    <param name="example_param_hw_stop_duration_sec">3.0</param>
6
    <param name="example_param_hw_slowdown">2.0</param>
7
  </hardware>
8
  <joint name="joint1">
9
    <command_interface name="position">
10
      <param name="min">-1</param>
11
      <param name="max">1</param>
12
    </command_interface>
13
    <state_interface name="position"/>
14
  </joint>
15
  <joint name="joint2">
16
    <command_interface name="position">
17
      <param name="min">-1</param>
18
      <param name="max">1</param>
19
    </command_interface>
20
    <state_interface name="position"/>
21
  </joint>
22
  <gpio name="flange_digital_IOs">
23
    <command_interface name="digital_output1" data_type="bool"/>
24
    <state_interface name="digital_output1" data_type="bool"/>    <!-- Needed to know current state of the output -->
25
    <command_interface name="digital_output2" data_type="bool"/>
26
    <state_interface name="digital_output2" data_type="bool"/>
27
    <state_interface name="digital_input1" data_type="bool"/>
28
    <state_interface name="digital_input2" data_type="bool"/>
29
  </gpio>
30
  <gpio name="flange_analog_IOs">
31
    <command_interface name="analog_output1" data_type="uint16"/>
32
    <state_interface name="analog_output1" data_type="uint16">    <!-- Needed to know current state of the output -->
33
      <param name="initial_value">3.1</param>  <!-- Optional initial value for mock_hardware -->
34
    </state_interface>
35
    <state_interface name="analog_input1" data_type="uint16"/>
36
    <state_interface name="analog_input2" data_type="uint16"/>
37
  </gpio>
38
  <gpio name="flange_vacuum">
39
    <command_interface name="vacuum" data_type="bool"/>
40
    <state_interface name="vacuum" data_type="bool"/>    <!-- Needed to know current state of the output -->
41
  </gpio>
42
</ros2_control>

1
<ros2_control name="MultimodalGripper" type="actuator">
2
  <hardware>
3
    <plugin>ros2_control_demo_hardware/MultimodalGripper</plugin>
4
  </hardware>
5
  <joint name="parallel_fingers">
6
    <command_interface name="position">
7
      <param name="min">0</param>
8
      <param name="max">100</param>
9
    </command_interface>
10
    <state_interface name="position"/>
11
  </joint>
12
  <gpio name="suction">
13
    <command_interface name="suction"/>
14
    <state_interface name="suction"/>    <!-- Needed to know current state of the output -->
15
  </gpio>
16
</ros2_control>

1
<ros2_control name="RRBotForceTorqueSensor2D" type="sensor">
2
  <hardware>
3
    <plugin>ros2_control_demo_hardware/ForceTorqueSensor2DHardware</plugin>
4
    <param name="example_param_read_for_sec">0.43</param>
5
  </hardware>
6
  <sensor name="tcp_fts_sensor">
7
    <state_interface name="fx"/>
8
    <state_interface name="tz"/>
9
    <param name="frame_id">kuka_tcp</param>
10
    <param name="fx_range">100</param>
11
    <param name="tz_range">100</param>
12
  </sensor>
13
  <sensor name="temp_feedback">
14
    <state_interface name="temperature"/>
15
  </sensor>
16
  <gpio name="calibration">
17
    <command_interface name="calibration_matrix_nr"/>
18
    <state_interface name="calibration_matrix_nr"/>
19
  </gpio>
20
</ros2_control>

1
<ros2_control name="RRBotSystem1" type="system">
2
  <hardware>
3
    <plugin>ros2_control_demo_hardware/RRBotSystemPositionOnlyHardware</plugin>
4
    <group>Group1</group>
5
    <param name="example_param_hw_start_duration_sec">2.0</param>
6
    <param name="example_param_hw_stop_duration_sec">3.0</param>
7
    <param name="example_param_hw_slowdown">2.0</param>
8
  </hardware>
9
  <joint name="joint1">
10
    <command_interface name="position">
11
      <param name="min">-1</param>
12
      <param name="max">1</param>
13
    </command_interface>
14
    <state_interface name="position"/>
15
  </joint>
16
  <gpio name="flange_analog_IOs">
17
    <command_interface name="analog_output1"/>
18
    <state_interface name="analog_output1">    <!-- Needed to know current state of the output -->
19
      <param name="initial_value">3.1</param>  <!-- Optional initial value for mock_hardware -->
20
    </state_interface>
21
    <state_interface name="analog_input1"/>
22
    <state_interface name="analog_input2"/>
23
  </gpio>
24
  <gpio name="flange_vacuum">
25
    <command_interface name="vacuum"/>
26
    <state_interface name="vacuum"/>    <!-- Needed to know current state of the output -->
27
  </gpio>
28
</ros2_control>
29
<ros2_control name="RRBotSystem2" type="system">
30
  <hardware>
31
    <plugin>ros2_control_demo_hardware/RRBotSystemPositionOnlyHardware</plugin>
32
    <group>Group1</group>
33
    <param name="example_param_hw_start_duration_sec">2.0</param>
34
    <param name="example_param_hw_stop_duration_sec">3.0</param>
35
    <param name="example_param_hw_slowdown">2.0</param>
36
  </hardware>
37
  <joint name="joint2">
38
    <command_interface name="position">
39
      <param name="min">-1</param>
40
      <param name="max">1</param>
41
    </command_interface>
42
    <state_interface name="position"/>
43
  </joint>
44
  <gpio name="flange_digital_IOs">
45
    <command_interface name="digital_output1"/>
46
    <state_interface name="digital_output1"/>    <!-- Needed to know current state of the output -->
47
    <command_interface name="digital_output2"/>
48
    <state_interface name="digital_output2"/>
49
    <state_interface name="digital_input1"/>
50
    <state_interface name="digital_input2"/>
51
  </gpio>
52
</ros2_control>

3.2 Writing a Hardware Component（编写硬件组件）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/writing_new_hardware_component.html

在 ros2_control 中，硬件系统组件是库，由控制器管理器通过 pluginlib 接口动态加载。以下是创建新硬件接口的源文件、基础测试和编译规则的逐步指南。

1. 准备包（Preparing package）

如果硬件接口的包不存在，请先创建它。该包应使用 ament_cmake 作为构建类型。最简单的方式是在线搜索最新的手册。ros2 pkg create 命令可辅助此过程，使用 --help 标志可了解更多用法。该命令还提供了创建库源文件和编译规则的选项，可帮助完成后续步骤。

2. 准备源文件（Preparing source files）

创建包之后，其中至少应有 CMakeLists.txt 和 package.xml 文件。如果 include/<PACKAGE_NAME>/ 和 src 文件夹不存在，请一并创建。在 include/<PACKAGE_NAME>/ 文件夹中添加 <robot_hardware_interface_name>.hpp，在 src 文件夹中添加 <robot_hardware_interface_name>.cpp。

3. 在头文件（.hpp）中添加声明

1. 注意使用头文件保护（header guards）。ROS2 风格是使用 #ifndef 和 #define 预处理指令。（关于这一点，搜索引擎可以帮到你 :)）。
2. 包含 "hardware_interface/$interface_type$_interface.hpp"。根据所使用的硬件类型，$interface_type$ 可以是 Actuator、Sensor 或 System。每种类型的更多细节参见 Hardware Interface Types。
3. 为你的 hardware_interface 定义一个唯一的命名空间。这通常是使用 snake_case 书写的包名。
4. 定义 hardware_interface 的类，继承 $InterfaceType$Interface，例如：

1
class HardwareInterfaceName : public hardware_interface::$InterfaceType$Interface

5. 添加一个无参构造函数，以及以下实现 LifecycleNodeInterface 的公有方法：on_configure、on_cleanup、on_shutdown、on_activate、on_deactivate、on_error；并重写 $InterfaceType$Interface 定义的方法：on_init、export_state_interfaces、export_command_interfaces、prepare_command_mode_switch（可选）、perform_command_mode_switch（可选）、read、write。

关于硬件生命周期的进一步说明，请参见相关 pull request；方法的确切定义请查看 "hardware_interface/$interface_type$_interface.hpp" 头文件，或 Actuator、Sensor、System 的 doxygen 文档。

4. 在源文件（.cpp）中添加定义

1. 包含硬件接口的头文件，并添加命名空间定义以简化后续开发。

2. 实现 on_init 方法。在此应初始化所有成员变量，并处理 info 参数中的参数。第一行通常调用父类的 on_init 来处理标准值（如名称），即：hardware_interface::(Actuator|Sensor|System)Interface::on_init(info)。如果所有必需参数都已设置且有效、一切正常，返回 CallbackReturn::SUCCESS；否则返回 return CallbackReturn::ERROR。

   1. （可选）添加发布者、服务等

   硬件组件的一个常见需求是发布状态或诊断信息，同时不干扰实时控制循环。

   这允许你向硬件接口添加任何标准 ROS 2 组件（发布者、订阅者、服务、定时器），而不会牺牲实时性能。实现此目的主要有两种方式。

   方法 1：使用框架管理的节点（推荐且最简单）

   框架会为每个硬件组件在内部创建一个专用的 ROS 2 节点。你的硬件插件可以获取该节点的句柄并使用它。

   1. 访问并使用默认节点：你可以通过调用 get_node() 方法获取节点的 shared_ptr，并像使用任何其他 rclcpp::Node::SharedPtr 一样使用它来创建发布者、定时器等。

   1
   // Continuing inside on_configure()
   2
   if (get_node())
   3
   {
   4
      my_publisher_ = get_node()->create_publisher<std_msgs::msg::String>("~/status", 10);
   5
   
   6
      using namespace std::chrono_literals;
   7
      my_timer_ = get_node()->create_wall_timer(1s, [this]() {
   8
         std_msgs::msg::String msg;
   9
         msg.data = "Hardware status update!";
   10
         my_publisher_->publish(msg);
   11
      });
   12
   }

   方法 2：使用 HardwareComponentParams 中的执行器

   对于需要直接控制节点创建的更高级用例，可以配置 on_init 方法接收一个 HardwareComponentParams 结构体。该结构体包含一个指向 ControllerManager 执行器的 weak_ptr。

   1. 更新 on_init 签名：首先，你的硬件接口必须重写接受 HardwareComponentParams 的 on_init 版本。

   1
   // In your <robot_hardware_interface_name>.hpp
   2
   hardware_interface::CallbackReturn on_init(
   3
   const hardware_interface::HardwareComponentParams & params) override;

   2. 锁定并使用执行器：在 on_init 内部，你必须安全地 “lock” weak_ptr 以获得可用的 shared_ptr。然后可以创建自己的节点并将其添加到执行器。

   1
   // In your <robot_hardware_interface_name>.cpp, inside on_init(params)
   2
   if (auto locked_executor = params.executor.lock())
   3
   {
   4
      my_custom_node_ = std::make_shared<rclcpp::Node>("my_custom_node");
   5
      locked_executor->add_node(my_custom_node_->get_node_base_interface());
   6
      // ... create publishers/timers on my_custom_node_ ...
   7
   }

   有关使用框架管理节点发布诊断消息的完整可运行实现，参见 example 17 中的 demo。

3. 编写 on_configure 方法，通常在此建立与硬件的通信，并将一切设置为可激活硬件所需的状态。

4. 实现 on_cleanup 方法，它与 on_configure 相反。

5. Command-/StateInterfaces（命令/状态接口）现在由框架根据 ros2_control XML 标签中定义的接口，通过 on_export_command_interfaces() 或 on_export_state_interfaces() 方法自动创建和导出；XML 会被解析并相应创建 InterfaceDescription（参见 hardware_info.hpp）。

   • 为了访问自动创建的 Command-/StateInterfaces，我们提供 std::unordered_map<std::string, InterfaceDescription>，其中字符串是接口的完全限定名，InterfaceDescription 是接口的配置。std::unordered_map<> 分为 type_state_interfaces_ 和 type_command_interfaces_，其中 type 可以是：joint、sensor、gpio 和 unlisted。例如，所有关节的 CommandInterfaces 可以在 joint_command_interfaces_ map 中找到。unlisted 包含所有未在 ros2_control XML 标签中列出、但通过重写 export_unlisted_command_interface_descriptions() 或 export_unlisted_state_interface_descriptions() 函数创建的自定义 Command-/StateInterfaces。
   • 对于 Sensor 类型的硬件接口，没有 export_command_interfaces 方法。
   • 提醒：完整的接口名称结构为 <joint_name>/<interface_type>。

6. （可选）如果你想要一些未包含在 ros2_control XML 标签中的 Command-/StateInterfaces，可以按以下步骤操作：

   1. 重写 virtual std::vector<hardware_interface::InterfaceDescription> export_unlisted_command_interface_descriptions() 或 virtual std::vector<hardware_interface::InterfaceDescription> export_unlisted_state_interface_descriptions()。
   2. 在重写的 export_unlisted_command_interface_descriptions() 或 export_unlisted_state_interface_descriptions() 函数中，为你想要创建的每个接口创建 InterfaceDescription，添加到 vector 并返回：

   1
   std::vector<hardware_interface::InterfaceDescription> my_unlisted_interfaces;
   2
   
   3
   InterfaceInfo unlisted_interface;
   4
   unlisted_interface.name = "some_unlisted_interface";
   5
   unlisted_interface.min = "-5.0";
   6
   unlisted_interface.data_type = "double";
   7
   my_unlisted_interfaces.push_back(InterfaceDescription(info_.name, unlisted_interface));
   8
   
   9
   return my_unlisted_interfaces;

   3. 未列出的接口随后会存储到 unlisted_command_interfaces_ 或 unlisted_state_interfaces_ map 中，具体取决于它们在哪个函数中被创建。
   4. 你可以像访问任何其他接口一样，使用 get_state(name)、set_state(name, value)、get_command(name) 或 set_command(name, value) 访问它。例如 get_state("some_unlisted_interface")。

7. （可选）如果导出 Command-/StateInterfaces 的默认实现（on_export_command_interfaces() 或 on_export_state_interfaces()）不够用，你可以重写它们。但应考虑以下几点：

   • 如果你想拥有未列出的接口，需要调用 export_unlisted_command_interface_descriptions() 或 export_unlisted_state_interface_descriptions()，并将其添加到 unlisted_command_interfaces_ 或 unlisted_state_interfaces_ 中。
   • 不要忘记在内部存储创建的 Command-/StateInterfaces，因为你只返回 shared_ptr，而资源管理器不会为硬件提供对已创建 Command-/StateInterfaces 的访问。因此你必须自己负责存储它们。
   • 名称必须唯一！

8. （可选）对于 Actuator 和 System 类型的硬件接口，如果你的硬件接受多种控制模式，请实现 prepare_command_mode_switch 和 perform_command_mode_switch。

9. 实现 on_activate 方法，在此启用硬件的 “电源”。

10. 实现 on_deactivate 方法，它与 on_activate 相反。

11. 实现 on_shutdown 方法，在此优雅地关闭硬件。

12. 实现 on_error 方法，在此处理来自所有状态的各种错误。

13. 实现 read 方法，从硬件获取状态并存储到 export_state_interfaces 中定义的内部变量。

14. 实现 write 方法，根据 export_command_interfaces 中定义的内部变量存储的值向硬件下发命令。

15. 重要：在文件末尾、命名空间关闭之后，添加 PLUGINLIB_EXPORT_CLASS 宏。

为此你需要包含 "pluginlib/class_list_macros.hpp" 头文件。第一个参数应提供确切的硬件接口类，例如 <my_hardware_interface_package>::<RobotHardwareInterfaceName>；第二个参数是基类，即 hardware_interface::(Actuator|Sensor|System)Interface。

5. 为 pluginlib 编写导出定义

1. 在包中创建 <my_hardware_interface_package>.xml 文件，添加对 pluginlib 可见的库和硬件接口类的定义。最简单的方式是参考 hardware_interface 的 mock_components 部分中 mock 组件的定义。
2. 通常，插件名称由包（命名空间）和类名定义，例如 <my_hardware_interface_package>/<RobotHardwareInterfaceName>。当资源管理器搜索硬件接口时，该名称定义了硬件接口的类型。另外两个参数必须与 <robot_hardware_interface_name>.cpp 文件底部宏中的定义一致。

6. 编写一个简单测试，检查控制器能否被找到并加载

1. 在包中创建 test 文件夹（如果尚不存在），并添加一个名为 test_load_<robot_hardware_interface_name>.cpp 的文件。
2. 你可以复制 test_generic_system.cpp 包中定义的 load_generic_system_2dof 内容。
3. 修改所复制测试的名称，并在最后一行指定硬件接口类型处，填入 <my_hardware_interface_package>.xml 文件中定义的名称，例如 <my_hardware_interface_package>/<RobotHardwareInterfaceName>。

7. 在 CMakeLists.txt 文件中添加编译指令

1. 在 find_package(ament_cmake REQUIRED) 一行下面添加更多依赖。至少包括：hardware_interface、pluginlib、rclcpp 和 rclcpp_lifecycle。
2. 添加一个以 <robot_hardware_interface_name>.cpp 文件为源码的共享库编译指令。
3. 为该库添加目标的 include 目录。通常只需要 include。
4. 添加该库所需的 ament 依赖。至少应添加上述第 1 条列出的依赖。
5. 使用以下命令导出 pluginlib 描述文件：

1
pluginlib_export_plugin_description_file(hardware_interface <my_hardware_interface_package>.xml)

6. 为目标和 include 目录添加 install 指令。
7. 在测试部分添加以下依赖：ament_cmake_gmock、hardware_interface。
8. 使用 ament_add_gmock 指令为测试添加编译定义。具体做法可参考 ros2_control 包中 mock 硬件的实现。
9. （可选）在 ament_package() 之前，将硬件接口库添加到 ament_export_libraries。

8. 在 package.xml 文件中添加依赖

1. 在 <depend> 标签中至少添加以下包：hardware_interface、pluginlib、rclcpp 和 rclcpp_lifecycle。
2. 在 <test_depend> 标签中至少添加以下包：ament_add_gmock 和 hardware_interface。

9. 编译并测试硬件组件

1. 现在一切就绪，可以使用 colcon build <my_hardware_interface_package> 命令编译硬件组件。请记得在执行命令前进入工作空间的根目录。
2. 如果编译成功，source install 文件夹中的 setup.bash 文件，然后执行 colcon test <my_hardware_interface_package>，检查新控制器能否通过 pluginlib 库找到并被控制器管理器加载。

就是这样！祝你编写出优秀的控制器！

3.3 Different Update Rates（不同的更新频率）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/different_update_rates_userdoc.html

ros2_control 框架允许不同的硬件组件以不同的更新频率运行。当某些硬件组件需要以不同于传统控制循环频率（即与 controller_manager 相同的频率）运行时非常有用。在带有不同传感器或使用不同通信协议的不同组件的机器人系统中，不同组件具有不同频率是非常典型的。当你有一个硬件组件需要以比其他组件更高的频率运行时，这也很有用。例如，你可能有一个需要以 1000Hz 读取的传感器，而其余组件可以以 500Hz 运行，前提是 controller_manager 的控制循环频率高于 1000Hz。可以通过向硬件组件的 ros2_control 标签添加 rw_rate 参数来轻松定义读/写频率。

1
<ros2_control name="RRBotSystemMutipleGPIOs" type="system" rw_rate="500">
2
  <hardware>
3
    <plugin>ros2_control_demo_hardware/RRBotSystemPositionOnlyHardware</plugin>
4
    <param name="example_param_hw_start_duration_sec">2.0</param>
5
    <param name="example_param_hw_stop_duration_sec">3.0</param>
6
    <param name="example_param_hw_slowdown">2.0</param>
7
  </hardware>
8
  <joint name="joint1">
9
    <command_interface name="position">
10
      <param name="min">-1</param>
11
      <param name="max">1</param>
12
    </command_interface>
13
    <state_interface name="position"/>
14
  </joint>
15
  <joint name="joint2">
16
    <command_interface name="position">
17
      <param name="min">-1</param>
18
      <param name="max">1</param>
19
    </command_interface>
20
    <state_interface name="position"/>
21
  </joint>
22
  <gpio name="flange_digital_IOs">
23
    <command_interface name="digital_output1"/>
24
    <state_interface name="digital_output1"/>    <!-- Needed to know current state of the output -->
25
    <command_interface name="digital_output2"/>
26
    <state_interface name="digital_output2"/>
27
    <state_interface name="digital_input1"/>
28
    <state_interface name="digital_input2"/>
29
  </gpio>
30
</ros2_control>
31
<ros2_control name="MultimodalGripper" type="actuator" rw_rate="200">
32
  <hardware>
33
    <plugin>ros2_control_demo_hardware/MultimodalGripper</plugin>
34
  </hardware>
35
  <joint name="parallel_fingers">
36
    <command_interface name="position">
37
      <param name="min">0</param>
38
      <param name="max">100</param>
39
    </command_interface>
40
    <state_interface name="position"/>
41
  </joint>
42
  <gpio name="suction">
43
    <command_interface name="suction"/>
44
    <state_interface name="suction"/>    <!-- Needed to know current state of the output -->
45
  </gpio>
46
</ros2_control>
47
<ros2_control name="RRBotForceTorqueSensor2D" type="sensor" rw_rate="250">
48
  <hardware>
49
    <plugin>ros2_control_demo_hardware/ForceTorqueSensor2DHardware</plugin>
50
    <param name="example_param_read_for_sec">0.43</param>
51
  </hardware>
52
  <sensor name="tcp_fts_sensor">
53
    <state_interface name="fx"/>
54
    <state_interface name="tz"/>
55
    <param name="frame_id">kuka_tcp</param>
56
    <param name="fx_range">100</param>
57
    <param name="tz_range">100</param>
58
  </sensor>
59
  <sensor name="temp_feedback">
60
    <state_interface name="temperature"/>
61
  </sensor>
62
  <gpio name="calibration">
63
    <command_interface name="calibration_matrix_nr"/>
64
    <state_interface name="calibration_matrix_nr"/>
65
  </gpio>
66
</ros2_control>

3.4 Asynchronous Execution（异步执行）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/asynchronous_components.html

本节内容与 2.4.2 异步硬件组件 完全相同（同一页面在章节目录中同时作为 “Asynchronous Hardware Components” 与 “Asynchronous Execution” 出现）。请参见前文，其中详细说明了 is_async、thread_priority、affinity、scheduling_policy 和 print_warnings 等参数及完整示例。

3.5 Semantic Components（语义组件）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/semantic_components.html

为了简化常用硬件接口的配置，可以使用所谓的语义组件（semantic components）来封装认领/释放接口的机制。基础组件 semantic_components::SemanticComponentInterface 和 semantic_components::SemanticComponentCommandInterface 分别用于定义只读和只写设备的语义组件。

现有的 SemanticComponentInterface（头文件链接）及其关联广播器（如有）列表：

• IMUSensor，由 IMU Sensor Broadcaster 使用
• ForceTorqueSensor，由 Force Torque Sensor Broadcaster 使用
• GPSSensor
• MagneticFieldSensor
• PoseSensor，由 Pose Broadcaster 使用
• RangeSensor，由 Range Sensor Broadcaster 使用

现有的 SemanticComponentCommandInterface（头文件链接）及其关联控制器（如有）列表：

• LedRgbDevice

3.6 Mock Components（模拟组件）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/mock_components_userdoc.html

Mock 组件（模拟组件）是硬件组件（即 System、Sensor 和 Actuator）的简单 “仿真”。它们通过将命令镜像（mirror）到状态来提供理想行为。在离线测试 ros2_control 框架时，可以将相应的硬件接口添加进来以替代真实硬件。其主要优势是：无需接触硬件即可测试框架内部的所有 “管道”（piping）。这意味着你可以测试控制器、广播器、launch 文件，甚至与 MoveIt 等的集成。其主要目的是减少在物理硬件上的调试时间，并提升开发效率。

1
<ros2_control name="MockHardwareSystem" type="system">
2
  <hardware>
3
    <plugin>mock_components/GenericSystem</plugin>
4
    <param name="calculate_dynamics">false</param>
5
    <param name="custom_interface_with_following_offset"></param>
6
    <param name="disable_commands">false</param>
7
    <param name="mock_gpio_commands">false</param>
8
    <param name="mock_sensor_commands">false</param>
9
    <param name="position_state_following_offset">0.0</param>
10
  </hardware>
11
  <joint name="joint1">
12
    <command_interface name="position"/>
13
    <command_interface name="velocity"/>
14
    <state_interface name="position">
15
      <param name="initial_value">3.45</param>
16
    </state_interface>
17
    <state_interface name="velocity"/>
18
    <state_interface name="acceleration"/>
19
  </joint>
20
  <joint name="joint2">
21
    <command_interface name="velocity"/>
22
    <command_interface name="acceleration"/>
23
    <state_interface name="position">
24
      <param name="initial_value">2.78</param>
25
    </state_interface>
26
    <state_interface name="position"/>
27
    <state_interface name="velocity"/>
28
    <state_interface name="acceleration"/>
29
  </joint>
30
  <gpio name="flange_vacuum">
31
    <command_interface name="vacuum"/>
32
    <state_interface name="vacuum" data_type="double"/>
33
  </gpio>
34
</ros2_control>

1
<state_interface name="position">
2
  <param name="initial_value">3.45</param>
3
</state_interface>

3.7 Lifecycle of a Hardware Component（硬件组件的生命周期）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/lifecycle_of_a_hardware_component.html

各方法的返回值类型为 rclcpp_lifecycle::node_interfaces::LifecycleNodeInterface::CallbackReturn，含义如下：

• CallbackReturn::SUCCESS：方法执行成功。
• CallbackReturn::FAILURE：方法执行失败，生命周期转换未成功。
• CallbackReturn::ERROR：发生了应在 on_error 方法中处理的严重错误。

在每个方法之后，硬件转换到以下状态：

• UNCONFIGURED（未配置）（on_init、on_cleanup）：

  硬件仅被初始化，但通信未启动，且没有接口导入到 ResourceManager。

• INACTIVE（非活动）（on_configure、on_deactivate）：

  与硬件的通信已建立，硬件组件已配置。可以读取状态，但命令接口（仅 System 和 Actuator）不可用。

  目前，是否继续使用从 CommandInterfaces 收到的命令或完全跳过它们，由硬件组件实现自行决定。

注意

我们计划实现安全关键接口，参见路线图中的该 PR。但目前所有命令接口都是可用且会被写入的，参见描述该情况的 issue。

• FINALIZED（已终结）（on_shutdown）：

  硬件接口已准备好卸载/销毁。已分配的内存被清理。

• ACTIVE（活动）（on_activate）：

  可以读取状态。

  仅 System 和 Actuator：

  硬件的电源电路已激活，硬件可以移动，例如制动器已松开。命令接口可用，且命令应被发送到硬件。

3.8 Handling of Errors During read() and write() Calls（read() 与 write() 调用期间的错误处理）#

原文：https://control.ros.org/jazzy/doc/ros2_control/hardware_interface/doc/handling_errors_during_read_write.html

如果 hardware_interface 类的 read() 或 write() 方法返回 hardware_interface::return_type::ERROR，将调用 on_error(previous_state) 方法来处理发生的任何错误。

错误处理遵循节点生命周期。如果返回 CallbackReturn::SUCCESS 且成功，硬件将再次处于 UNCONFIGURED 状态；如果发生任何 ERROR 或 FAILURE，硬件将进入 FINALIZED 状态且无法恢复。唯一的办法是重新加载整个插件，但目前 Controller Manager 中没有对应的服务。