igh_ethercat_master.h

Go to the documentation of this file.

#pragma once
 
#ifdef LINUX_BUILD
 
#include <atomic>
#include <chrono>
#include <ctime>
#include <map>
#include <thread>
#include <variant>
#include <vector>
#include <zmq.hpp>
 
#include "ethercat_master.h"
#include "ethercat_slave.h"
#include "igh_dynamic.h"
#include "igh_od_entry.h"
#include "motion_master_error.h"
 
#define MAX_FILE_SIZE 9000
#define EC_MAX_OCTET_STRING_LENGTH 128
#define DEFTYPE_ENUM_START 0x800u
#define DEFTYPE_ENUM_END 0xFFFu
 
class IghEthercatSlave;
class Notifier;
 
class IghEthercatMaster : public EthercatMaster {
 public:
  explicit IghEthercatMaster(Notifier &notifier, uint32_t master_id = 0);
  ~IghEthercatMaster() override;
 
  size_t start() override;
 
  void stop() override;
 
  size_t restart() override;
 
  int32_t execute(uint64_t pending_signals) override;
 
  bool is_running() override;
 
  int get_slaves_responding() override;
 
  std::list<VirtualDevice *> get_slaves() override;
 
  bool disable_all_slaves() override;
 
  void abort_all_client_requests() override {};
 
  /**************************** SLAVE OPERATIONS ****************************/
  std::variant<MotionMasterError, std::list<std::string>> get_file_list(
      uint16_t absolute_slave_position);
 
  std::variant<MotionMasterError, std::vector<uint8_t>> read_file(
      uint16_t absolute_slave_position, const std::string &file_name);
 
  MotionMasterError write_file(uint16_t absolute_slave_position,
                               const std::string &file_name,
                               const std::vector<uint8_t> &content,
                               std::function<void(uint8_t)> progress_callback);
 
  MotionMasterError remove_file(uint16_t absolute_slave_position,
                                const std::string &file_name);
 
  int32_t write_sii(uint16_t absolute_slave_position,
                    const std::vector<uint8_t> &content);
 
  static uint8_t get_slave_state(IghEthercatSlave &slave);
 
  uint8_t get_slave_state(uint16_t absolute_slave_position);
 
  bool request_slave_state_switch(IghEthercatSlave &slave, uint8_t al_state);
 
  bool request_slave_state_switch(uint16_t absolute_slave_position,
                                  uint8_t al_state);
 
  bool set_slave_state(IghEthercatSlave &slave, uint8_t al_state);
 
  bool set_slave_state(uint16_t absolute_slave_position, uint8_t al_state);
 
  /***************************** SDO OPERATIONS *****************************/
  IghOdEntry::Error sdo_upload(IghOdEntry &od_entry, bool blocking = true);
 
  IghOdEntry::Error sdo_download(IghOdEntry &od_entry, bool blocking = true);
 
 private:
  // Master information
  ec_master_t *master_;
 
  // Variables for data structures
  ec_domain_t *domain_ = nullptr;
  uint8_t *process_data_ = nullptr;
  std::vector<ec_pdo_entry_reg_t> domain_reg_;
 
  // Diagnostic data structures
  ec_master_state_t master_state_{};
  ec_domain_state_t domain_state_{};
 
  // Map of detected slaves (<absolute slave position, unique pointer to base
  // class>)
  std::map<uint16_t, std::unique_ptr<EthercatSlave>> slaveMap;
 
  Notifier &notifier_;
 
  std::atomic_bool running_;
  bool pdo_communication_possible_ = false;
 
  void update_master_state();
 
  void update_all_slave_states();
 
  bool do_start();
 
  void do_stop();
 
  std::tuple<uint16_t, uint16_t> init_slave(IghEthercatSlave &slave,
                                            uint16_t absolute_slave_position,
                                            uint16_t reference_alias,
                                            uint16_t relative_position);
 
  void setup_slave(IghEthercatSlave &slave);
 
  void refresh_slave(IghEthercatSlave &slave);
 
  void setup_default_pdos(IghEthercatSlave &slave);
 
  void setup_pdos(IghEthercatSlave &slave);
 
  static void setup_sdo_requests(IghEthercatSlave &slave, IghOdEntry &od_entry);
 
  IghOdEntry::Error upload_via_sdo_request_blocking(IghOdEntry &od_entry);
 
  static IghOdEntry::Error upload_via_sdo_request(IghOdEntry &od_entry);
 
  static IghOdEntry::Error read_value_from_sdo_request(IghOdEntry &od_entry);
 
  IghOdEntry::Error download_via_sdo_request_blocking(IghOdEntry &od_entry);
 
  static IghOdEntry::Error download_via_sdo_request(IghOdEntry &od_entry);
 
  static IghOdEntry::Error write_value_to_sdo_request(IghOdEntry &od_entry);
 
  bool is_supported(IghEthercatSlave &slave);
 
  void setup_od_entries(IghEthercatSlave &slave);
 
  void config_detected_smm(IghEthercatSlave &slave);
 
  static void setup_sync_managers(IghEthercatSlave &slave);
 
  void cache_files(IghEthercatSlave &slave);
 
  static void init_hardware_id(IghEthercatSlave &slave);
 
  std::string get_ecat_foe_error_message(int error_code);
 
  MotionMasterError prepare_get_file_content(IghEthercatSlave &slave,
                                             const std::string &file_name);
 
  std::variant<MotionMasterError, std::vector<uint8_t>> get_file_content(
      uint16_t absolute_slave_position, const std::string &file_name);
 
  std::list<std::string> do_get_file_list(IghEthercatSlave &slave);
 
  bool write_file_as_parts(uint16_t absolute_slave_position,
                           const std::string &file_name,
                           const std::vector<uint8_t> &content,
                           std::function<void(uint8_t)> progress_callback);
 
  int32_t set_file_content(uint16_t absolute_slave_position,
                           const std::string &file_name,
                           const std::vector<uint8_t> &content);
 
  static std::list<std::string> get_file_parts(std::list<std::string> file_list,
                                               const std::string &file_name);
 
  MotionMasterError do_remove_file(uint16_t absolute_slave_position,
                                   const std::string &file_name);
};
 
#endif