soem_slave.h

Go to the documentation of this file.

#include <ethercat.h>
 
#include <chrono>
#include <map>
#include <mutex>
#include <variant>
 
#include "ethercat_slave.h"
#include "motion_master_error.h"
#include "soem_od_entry.h"
 
#define OTYPE_VAR 0x0007
#define OTYPE_ARRAY 0x0008
#define OTYPE_RECORD 0x0009
 
class MotionMasterError;
 
class SoemSlave : public EthercatSlave {
  uint16_t position_;
  Type type_;
  uint16_t hardware_id_;
  std::map<uint32_t, SoemOdEntry> od_entry_map_;
  std::map<std::string, std::variant<MotionMasterError, std::vector<uint8_t>>>
      file_cache_;
  std::mutex file_cache_mutex_;
 
  class Pdo {
   public:
    explicit Pdo(SoemOdEntry* od_entry, uint32_t offset)
        : od_entry_{od_entry}, offset_{offset} {}
 
    explicit Pdo(VirtualParameter* virtual_parameter, uint32_t offset) {
      SoemOdEntry* od_entry = dynamic_cast<SoemOdEntry*>(virtual_parameter);
      if (!od_entry) {
        throw std::invalid_argument(
            "Invalid argument provided for Pdo object construction.");
      }
      *this = Pdo(od_entry, offset);
    }
 
    SoemOdEntry* od_entry_ = nullptr;
    uint32_t offset_ = 0;
  };
 
  std::list<Pdo> rx_pdos_;
  std::list<Pdo> tx_pdos_;
 
  int setup_od_entries();
 
  void config_detected_smm();
 
  void init_hardware_id();
  void init_type();
 
  void update_pdo_mapping_od() override;
 
 public:
  explicit SoemSlave(const uint16_t position);
 
  ~SoemSlave() override {};
 
  [[nodiscard]] uint16_t get_device_id() const override;
 
  [[nodiscard]] uint16_t get_hardware_id() const override;
 
  [[nodiscard]] Type get_device_type() const override;
 
  [[nodiscard]] std::list<VirtualParameter*> get_all_virtual_parameters()
      override;
 
  [[nodiscard]] bool has_virtual_parameters() override;
 
  [[nodiscard]] VirtualParameter* get_virtual_parameter(
      uint16_t index, uint8_t subindex) override;
 
  [[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;
 
  bool has_firmware() override;
 
  [[nodiscard]] bool is_operational() const override;
 
  bool is_supported();

  void initialize();
 
  [[nodiscard]] bool has_pdos() override;
 
  [[nodiscard]] State get_state(bool force_refresh) const override;
 
  bool set_state(State state, uint32_t timeout_ms = 10000) override;
 
  bool request_state_switch(State state) override;
 
  MotionMasterError write_sii(const std::vector<uint8_t>& content) override;
 
  [[maybe_unused]] void receive_pdos(const uint8_t* process_data) override;
 
  void update_outputs();
 
  [[maybe_unused]] void send_pdos(const uint8_t* process_data) override;
 
  void update_inputs();
 
  [[nodiscard]] std::variant<MotionMasterError, std::vector<uint8_t>>
  get_file_content(const std::string& file_name);
  [[nodiscard]] int32_t set_file_content(const std::string& file_name,
                                         const std::vector<uint8_t>& content);
  bool write_file_as_parts(const std::string& file_name,
                           const std::vector<uint8_t>& content,
                           std::function<void(uint8_t)> progress_callback);
  MotionMasterError do_remove_file(const std::string& file_name);
  std::vector<uint8_t> read_sii();
};