Hardware component interfaces

hardware_interface/CMakeLists.txt

@@ -26,14 +26,14 @@ add_library(
 target_include_directories(
   hardware_interface
   PUBLIC
-  include)
+  include
+)
 ament_target_dependencies(
   hardware_interface
   control_msgs
   rclcpp
   rcpputils
 )
-
 # Causes the visibility macros to use dllexport rather than dllimport,
 # which is appropriate when building the dll but not consuming it.
 target_compile_definitions(hardware_interface PRIVATE "HARDWARE_INTERFACE_BUILDING_DLL")
@@ -74,13 +74,23 @@ if(BUILD_TESTING)
   target_link_libraries(test_actuator_handle hardware_interface)
   ament_target_dependencies(test_actuator_handle rcpputils)
 
+  ament_add_gmock(test_component_interfaces test/test_component_interfaces.cpp)
+  target_include_directories(test_component_interfaces PRIVATE include)
+  target_link_libraries(test_component_interfaces hardware_interface)
+
 endif()
 
+ament_export_dependencies(
+  rclcpp
+  rcpputils
+)
 ament_export_include_directories(
   include
 )
 ament_export_libraries(
-  hardware_interface)
+  hardware_interface
+)
 ament_export_dependencies(
-  control_msgs)
+  control_msgs
+)
 ament_package()

hardware_interface/include/hardware_interface/actuator_hardware.hpp

@@ -0,0 +1,85 @@
+// Copyright 2020 ros2_control Development Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HARDWARE_INTERFACE__ACTUATOR_HARDWARE_HPP_
+#define HARDWARE_INTERFACE__ACTUATOR_HARDWARE_HPP_
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "hardware_interface/hardware_and_component_info.hpp"
+#include "hardware_interface/actuator_hardware_interface.hpp"
+#include "hardware_interface/joint.hpp"
+#include "hardware_interface/types/hardware_interface_return_values.hpp"
+#include "hardware_interface/types/hardware_interface_status_values.hpp"
+#include "hardware_interface/visibility_control.h"
+
+namespace hardware_interface
+{
+
+class ActuatorHardware final
+{
+public:
+  ActuatorHardware() = default;
+
+  explicit ActuatorHardware(std::unique_ptr<ActuatorHardwareInterface> impl)
+  : impl_(std::move(impl))
+  {}
+
+  ~ActuatorHardware() = default;
+
+  HARDWARE_INTERFACE_PUBLIC
+  return_type configure(const HardwareInfo & actuator_info)
+  {
+    return impl_->configure(actuator_info);
+  }
+
+  HARDWARE_INTERFACE_PUBLIC
+  return_type start()
+  {
+    return impl_->start();
+  }
+
+  HARDWARE_INTERFACE_PUBLIC
+  return_type stop()
+  {
+    return impl_->stop();
+  }
+
+  HARDWARE_INTERFACE_PUBLIC
+  hardware_interface_status get_status()
+  {
+    return impl_->get_status();
+  }
+
+  HARDWARE_INTERFACE_PUBLIC
+  return_type read_joint(Joint & joint)
+  {
+    return impl_->read_joint(joint);
+  }
+
+  HARDWARE_INTERFACE_PUBLIC
+  return_type write(const Joint & joint)
+  {
+    return impl_->write(joint);
+  }
+
+private:
+  std::unique_ptr<ActuatorHardwareInterface> impl_;
+};
+
+}  // namespace hardware_interface
+#endif  // HARDWARE_INTERFACE__ACTUATOR_HARDWARE_HPP_

hardware_interface/include/hardware_interface/actuator_hardware_interface.hpp

@@ -0,0 +1,108 @@
+// Copyright 2020 ros2_control Development Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HARDWARE_INTERFACE__ACTUATOR_HARDWARE_INTERFACE_HPP_
+#define HARDWARE_INTERFACE__ACTUATOR_HARDWARE_INTERFACE_HPP_
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <vector>
+
+#include "hardware_interface/hardware_and_component_info.hpp"
+#include "hardware_interface/joint.hpp"
+#include "hardware_interface/types/hardware_interface_return_values.hpp"
+#include "hardware_interface/types/hardware_interface_status_values.hpp"
+#include "hardware_interface/visibility_control.h"
+
+namespace hardware_interface
+{
+
+/**
+  * \brief Virtual Class to implement when integrating a 1 DoF actuator into ros2_control.
+  * The typical examples are conveyors or motors.
+  */
+class ActuatorHardwareInterface
+{
+public:
+  HARDWARE_INTERFACE_PUBLIC
+  ActuatorHardwareInterface() = default;
+
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  ~ActuatorHardwareInterface() = default;
+
+  /**
+   * @brief Configuration of the actuator from data parsed from the robot's URDF.
+   *
+   * @param actuator_info structure with data from URDF.
+   * @return return_type::OK if required data are provided and can be parsed,
+   * return_type::ERROR otherwise.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  return_type configure(const HardwareInfo & actuator_info) = 0;
+
+  /**
+   * @brief Start exchange data with the hardware.
+   *
+   * @return return_type:OK if everything worked as expected, return_type::ERROR otherwise.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  return_type start() = 0;
+
+  /**
+   * @brief Stop exchange data with the hardware.
+   *
+   * @return return_type:OK if everything worked as expected, return_type::ERROR otherwise.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  return_type stop() = 0;
+
+  /**
+   * @brief Get current state of the system hardware.
+   *
+   * @return hardware_interface_status current status.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  hardware_interface_status get_status() const = 0;
+
+  /**
+   * @brief Read data fromt the hardware into the joint using "set_state" function of the Joint class.
+   * This function is always called by the RessourceManger.
+   *
+   * @param joint joint where data from the hardware are stored.
+   * @return return_type:OK if everything worked as expected, return_type::ERROR otherwise.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  return_type read_joint(Joint & joint) const = 0;
+
+  /**
+   * @brief Write data from the joint to the hardware using "get_command" function of the Joint class.
+   * This function is always called by the RessourceManger.
+   *
+   * @param joint the joint from which data are written to the hardware.
+   * @return return_type:OK if everything worked as expected, return_type::ERROR otherwise.
+   */
+  HARDWARE_INTERFACE_PUBLIC
+  virtual
+  return_type write(const Joint & joint) = 0;
+};
+
+}  // namespace hardware_interface
+#endif  // HARDWARE_INTERFACE__ACTUATOR_HARDWARE_INTERFACE_HPP_

hardware_interface/include/hardware_interface/hardware_and_component_info.hpp

@@ -0,0 +1,99 @@
+// Copyright 2020 ros2_control Development Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#ifndef HARDWARE_INTERFACE__HARDWARE_AND_COMPONENT_INFO_HPP_
+#define HARDWARE_INTERFACE__HARDWARE_AND_COMPONENT_INFO_HPP_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace hardware_interface
+{
+
+/**
+ * \brief This structure stores information about components defined for a specific hardware
+ * in robot's URDF.
+ */
+struct ComponentInfo
+{
+  /**
+   * \brief name of the component.
+   */
+  std::string name;
+  /**
+   * \brief type of the component: sensor or actuator.
+   */
+  std::string type;
+  /**
+   * \brief component's class, which will be dynamically loaded.
+   */
+  std::string class_type;
+  /**
+   * \brief name of the command interfaces that can be set, e.g. "position", "velocity", etc.
+   * Used by joints.
+   */
+  std::vector<std::string> command_interfaces;
+  /**
+   * \brief name of the state interfaces that can be read, e.g. "position", "velocity", etc.
+   * Used by Joints and Sensors.
+   */
+  std::vector<std::string> state_interfaces;
+  /**
+   * \brief (optional) key-value pairs of components parameters.
+   */
+  std::unordered_map<std::string, std::string> parameters;
+};
+
+/**
+ * \brief This structure stores information about hardware defined in a robot's URDF.
+ */
+struct HardwareInfo
+{
+  /**
+   * \brief name of the hardware.
+   */
+  std::string name;
+  /**
+   * \brief type of the hardware: actuator, sensor or system.
+   */
+  std::string type;
+  /**
+   * \brief class of the hardware that will be dynamically loaded.
+   */
+  std::string hardware_class_type;
+  /**
+   * \brief (optional) key-value pairs for hardware parameters.
+   */
+  std::unordered_map<std::string, std::string> hardware_parameters;
+  /**
+   * \brief map of joints provided by the hardware where the key is the joint name.
+   * Required for Actuator and System Hardware.
+   */
+  std::unordered_map<std::string, ComponentInfo> joints;
+  /**
+   * \brief map of joints provided by the hardware where the key is the joint name.
+   * Required for Sensor and optional for System Hardware.
+   */
+  std::unordered_map<std::string, ComponentInfo> sensors;
+  /**
+   * \brief map of transmissions to calcualte ration between joints and physical actuators.
+   * Optional for Actuator and System Hardware.
+   */
+  std::unordered_map<std::string, ComponentInfo> transmissions;
+};
+
+}  // namespace hardware_interface
+#endif  // HARDWARE_INTERFACE__HARDWARE_AND_COMPONENT_INFO_HPP_