ControllerInterface.hpp

#pragma once
 
#include "modulo_controllers/BaseControllerInterface.hpp"
 
namespace modulo_controllers {
 
class ControllerInterface : public BaseControllerInterface {
public:
  ControllerInterface(bool claim_all_state_interfaces = false);
 
  CallbackReturn on_init() override;
 
  CallbackReturn on_configure(const rclcpp_lifecycle::State& previous_state) final;
 
  CallbackReturn on_activate(const rclcpp_lifecycle::State& previous_state) final;
 
  CallbackReturn on_deactivate(const rclcpp_lifecycle::State& previous_state) final;
 
  controller_interface::return_type update(const rclcpp::Time& time, const rclcpp::Duration& period) final;
 
  controller_interface::InterfaceConfiguration state_interface_configuration() const final;
 
  controller_interface::InterfaceConfiguration command_interface_configuration() const final;
 
protected:
  virtual CallbackReturn add_interfaces();
 
  virtual CallbackReturn on_configure();
 
  virtual CallbackReturn on_activate();
 
  virtual CallbackReturn on_deactivate();
 
  virtual controller_interface::return_type read_state_interfaces();
 
  virtual controller_interface::return_type write_command_interfaces(const rclcpp::Duration& period);
 
  virtual controller_interface::return_type
  evaluate(const rclcpp::Time& time, const std::chrono::nanoseconds& period) = 0;
 
  void add_state_interface(const std::string& name, const std::string& interface);
 
  void add_command_interface(const std::string& name, const std::string& interface);
 
  std::unordered_map<std::string, double> get_state_interfaces(const std::string& name) const;
 
  double get_state_interface(const std::string& name, const std::string& interface) const;
 
  double get_command_interface(const std::string& name, const std::string& interface) const;
 
  void set_command_interface(const std::string& name, const std::string& interface, double value);
 
  std::string hardware_name_;
 
private:
  void add_interface(
      const std::string& name, const std::string& interface, std::vector<std::string>& list, const std::string& type);
 
  using controller_interface::ControllerInterfaceBase::command_interfaces_;
  using controller_interface::ControllerInterfaceBase::state_interfaces_;
 
  std::unordered_map<std::string, std::unordered_map<std::string, double>>
      state_interface_data_;                  
  std::vector<double> command_interface_data_;
  std::unordered_map<std::string, std::unordered_map<std::string, unsigned int>>
      command_interface_indices_;                   
  std::vector<std::string> state_interface_names_;  
  std::vector<std::string> command_interface_names_;
  bool claim_all_state_interfaces_;                 
 
  // TODO make missed_locks an internal parameter
  unsigned int missed_locks_;
  bool on_init_called_;
};
 
}// namespace modulo_controllers