igh_ethercat_slave.h

Go to the documentation of this file.

#pragma once
 
#ifdef LINUX_BUILD
 
#include <list>
#include <map>
#include <variant>
 
#include "ethercat_slave.h"
#include "igh_dynamic.h"
#include "igh_od_entry.h"
#include "util.h"
 
class IghEthercatMaster;
class MotionMasterError;
 
class IghEthercatSlave : public EthercatSlave {
 public:
  friend class IghEthercatMaster;
 
  explicit IghEthercatSlave(IghEthercatMaster &master);
 
  ~IghEthercatSlave() override {};
 
  [[nodiscard]] uint16_t get_device_id() const override;
 
  [[nodiscard]] uint16_t get_hardware_id() const override;
 
  [[nodiscard]] Type get_device_type() const override;
 
  /******************************* PARAMETERS *******************************/
  [[nodiscard]] std::list<VirtualParameter *> get_all_virtual_parameters()
      override;
 
  [[nodiscard]] VirtualParameter *get_virtual_parameter(
      uint16_t index, uint8_t subindex) override;
 
  /**************************** FILE OPERATIONS ****************************/
  [[nodiscard]] std::variant<MotionMasterError, std::list<std::string>>
  get_file_list() override;
 
  [[nodiscard]] std::variant<MotionMasterError, std::vector<uint8_t>> read_file(
      const std::string &file_name) override;
 
  MotionMasterError write_file(
      const std::string &file_name, const std::vector<uint8_t> &content,
      std::function<void(uint8_t)> progress_callback) override;
 
  MotionMasterError remove_file(const std::string &file_name) override;
 
  /********************************* OTHER *********************************/
  bool has_firmware() override;
 
  [[nodiscard]] bool is_operational() const override;
 
  [[nodiscard]] bool has_pdos() override;
 
  [[nodiscard]] State get_state(bool force_refresh) const override;
 
  bool set_state(State state, uint32_t timeout_ms = 1000) override;
 
  bool request_state_switch(State state) override;
 
  MotionMasterError write_sii(const std::vector<uint8_t> &content) override;
 
  void receive_pdos(const uint8_t *process_data) override;
 
  void send_pdos(const uint8_t *process_data) override;
 
 private:
  class Pdo {
   public:
    explicit Pdo(IghOdEntry *od_entry, ec_direction_t dir)
        : od_entry_(od_entry), dir_(dir) {}
 
    [[nodiscard]] bool is_valid() const {
      return od_entry_ && dir_ != EC_DIR_INVALID;
    }
 
    IghOdEntry *od_entry_ = nullptr;
    ec_direction_t dir_ = EC_DIR_INVALID;
    unsigned int offset_ = 0;
    unsigned int bit_offset_ = 0;
  };
 
  // Reference to the master interface this slave is connected to
  IghEthercatMaster &master_;
 
  // Keeps the last active alias, since it is different than in
  // ec_slave_info_t
  uint16_t reference_alias_ = 0;
 
  // Position relative to the last defined alias in the chain
  uint16_t relative_position_ = 0;
 
  // The type is determined by the vendor/product numbers
  Type type_ = Type::kUnspecified;
 
  // Initialized via init_hardware_id() in IghEthercatMaster
  uint16_t hardware_id_ = 0;
 
  // Information structures from libethercat
  ec_slave_info_t slave_info_{};
  ec_slave_config_t *slave_config_ = nullptr;
 
  std::map<uint16_t, std::vector<ec_pdo_entry_info_t>> rx_pdo_map_;
  std::vector<ec_pdo_info_t> rx_pdos_;
  std::map<uint16_t, std::vector<ec_pdo_entry_info_t>> tx_pdo_map_;
  std::vector<ec_pdo_info_t> tx_pdos_;
  std::vector<ec_sync_info_t> syncs_;
 
  // Read with ecrt_slave_config_state()
  ec_slave_config_state_t slave_config_state_{};
 
  std::list<Pdo> pdos_;
 
  std::map<uint32_t, IghOdEntry> od_entry_map_;  // Object dictionary
 
  static inline std::vector<std::string> files_to_cache_ = {
      HARDWARE_DESCRIPTION_FILENAME, STACK_INFO_FILENAME};
 
  // This map will be empty if the caching has never been done
  std::map<std::string, std::vector<uint8_t>> cached_files_;
 
  void update_pdo_mapping_od() override;
};
 
#endif