ethercat_slave.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
 
#include "motion_master_error.h"
#include "virtual_device.h"
 
#define MAX_FILE_SIZE 9000
#define MAX_FILE_LIST_LENGTH 30
 
class EthercatSlave : public VirtualDevice {
 public:
  EthercatSlave() {};
 
  EthercatSlave(EthercatSlave const&) {};
 
  ~EthercatSlave() {};
 
  enum class State : uint8_t {
    kUnspecified = 0,
    kInit = 1,
    kPreOp = 2,
    kBoot = 3,
    kSafeOp = 4,
    kOp = 8
  };
 
  uint16_t obytes = 0;
  uint16_t ibytes = 0;
 
  inline static const std::map<State, std::map<State, State>>
      ecat_state_machine_table_ = {{State::kInit,
                                    {{State::kInit, State::kInit},
                                     {State::kPreOp, State::kPreOp},
                                     {State::kBoot, State::kBoot},
                                     {State::kSafeOp, State::kPreOp},
                                     {State::kOp, State::kPreOp}}},
                                   {State::kPreOp,
                                    {{State::kInit, State::kInit},
                                     {State::kPreOp, State::kPreOp},
                                     {State::kBoot, State::kInit},
                                     {State::kSafeOp, State::kSafeOp},
                                     {State::kOp, State::kSafeOp}}},
                                   {State::kBoot,
                                    {{State::kInit, State::kInit},
                                     {State::kPreOp, State::kInit},
                                     {State::kBoot, State::kBoot},
                                     {State::kSafeOp, State::kInit},
                                     {State::kOp, State::kInit}}},
                                   {State::kSafeOp,
                                    {{State::kInit, State::kInit},
                                     {State::kPreOp, State::kPreOp},
                                     {State::kBoot, State::kInit},
                                     {State::kSafeOp, State::kSafeOp},
                                     {State::kOp, State::kOp}}},
                                   {State::kOp,
                                    {{State::kInit, State::kInit},
                                     {State::kPreOp, State::kPreOp},
                                     {State::kBoot, State::kInit},
                                     {State::kSafeOp, State::kSafeOp},
                                     {State::kOp, State::kOp}}}};
 
  enum class FoeError {
    kNotFound = 0x00008001,
    kAccessDenied = 0x00008002,
    kDiskFull = 0x00008003,
    kIllegal = 0x00008004,
    kPacketNumberWrong = 0x00008005,
    kAlreadyExists = 0x00008006,
    kNoUser = 0x00008007,
    kBootstrapOnly = 0x00008008,
    kNotBootstrap = 0x00008009,
    kNoRights = 0x0000800a,
    kProgramError = 0x0000800b
  };
 
  static inline const std::map<FoeError, std::string> foe_error_messages_ = {
      {FoeError::kNotFound, "Not found"},
      {FoeError::kAccessDenied, "Access denied"},
      {FoeError::kDiskFull, "Disk full"},
      {FoeError::kIllegal, "Illegal operation"},
      {FoeError::kPacketNumberWrong, "Packet number wrong"},
      {FoeError::kAlreadyExists, "Already exists"},
      {FoeError::kNoUser, "No user"},
      {FoeError::kBootstrapOnly, "Bootstrap only"},
      {FoeError::kNotBootstrap, "Not Bootstrap"},
      {FoeError::kNoRights, "No rights"},
      {FoeError::kProgramError, "Program Error"}};
 
  [[nodiscard]] uint16_t get_device_id() const override { return 0; };
 
  [[nodiscard]] uint16_t get_hardware_id() const override { return 0; };
 
  [[nodiscard]] Protocol get_protocol() const override {
    return Protocol::kEcat;
  }
 
  [[nodiscard]] Type get_device_type() const override {
    return Type::kUnspecified;
  };
 
  /******************************* PARAMETERS *******************************/
  [[nodiscard]] std::list<VirtualParameter*> get_all_virtual_parameters()
      override {
    return {};
  };
 
  [[nodiscard]] VirtualParameter* get_virtual_parameter(
      uint16_t index, uint8_t subindex) override {
    return nullptr;
  };
 
  /**************************** FILE OPERATIONS ****************************/
  [[nodiscard]] std::variant<MotionMasterError, std::list<std::string>>
  get_file_list() override {
    return {};
  };
 
  [[nodiscard]] std::variant<MotionMasterError, std::vector<uint8_t>> read_file(
      const std::string& file_name) override {
    return {};
  };
 
  MotionMasterError write_file(
      const std::string& file_name, const std::vector<uint8_t>& content,
      std::function<void(uint8_t)> progress_callback) override {
    return MotionMasterError();
  };
 
  MotionMasterError remove_file(const std::string& file_name) override {
    return MotionMasterError();
  };
 
  /********************************* OTHER *********************************/
  virtual bool has_firmware() { return false; };
 
  [[nodiscard]] bool is_operational() const override { return false; };
 
  [[nodiscard]] virtual bool has_pdos() { return false; };
 
  [[nodiscard]] virtual State get_state(bool force_refresh) const {
    return State();
  };
 
  virtual bool set_state(State state, uint32_t timeout_ms = 10000) {
    return false;
  };
 
  virtual MotionMasterError write_sii(const std::vector<uint8_t>& content) {
    return MotionMasterError(MotionMasterError::Error::kNone);
  };
 
  virtual void update_pdo_mapping_od() {};
  virtual void receive_pdos(const uint8_t* process_data) {};
  virtual void send_pdos(const uint8_t* process_data) {};
  virtual bool request_state_switch(State state) { return false; };
};