ecat_domain.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 - 2018 VECTIONEER.
 */
 
#ifndef MOTORCORTEX_LIB_ECAT_DOMAIN_H
#define MOTORCORTEX_LIB_ECAT_DOMAIN_H
 
#include "ecat_domainbase.h"
#include "ps_handlers.h"
#include "ps_parameter.h"
#include "utl_cmdparser.h"
#include <algorithm>
#include <cstdint>
#include <list>
#include <string>
#include <vector>
 
namespace tinyxml2 {
class XMLElement;
}
 
namespace mcx {
 
namespace container {
struct TaskTime;
}
 
namespace ecat {
 
class Domain : public DomainBase {
 
  struct PdoData {
    std::string name;
    size_t bit_offset;
    size_t bit_length;
    uint64_t* param_ptr;
    mcx::parameter_server::ParamHandle param_handle;
    std::vector<PdoData> entries;
    std::vector<ParameterLink> links;
  };
 
  struct SdoData {
    size_t sdo_hash;
    bool* read;
    parameter_server::ParamHandle write_handle;
    parameter_server::ParamHandle read_handle;
    std::vector<ParameterLink> links;
    std::vector<SdoData> entries;
  };
 
  using MemoryPool = std::vector<uint64_t*>;
 
public:
  Domain(const std::string& name, const std::string& path, const std::string& filename);
 
  Domain(const std::string& path, const std::string& filename);
 
  Domain(const std::string& path, tinyxml2::XMLElement* domain_xml, std::string version);
 
  virtual ~Domain();
 
  [[nodiscard]] const char* getName() const;
 
  [[nodiscard]] const char* getPath() const;
 
  [[nodiscard]] const char* fileName() const;
 
  [[nodiscard]] const char* getFullPath() const;
 
  bool load();
 
  [[nodiscard]] bool hasError() const;
 
  [[nodiscard]] double getDtSec() const;
 
  static std::tuple<parameter_server::DataType, size_t, size_t> toParamDataType(DataTypeDesc data_type_desc);
 
private:
  static size_t bitsToBytes(size_t bits);
 
  static void updateInputs(const uint8_t* data, std::vector<PdoData>& pdo_inputs);
 
  static bool updateOutputs(std::vector<PdoData>& pdo_outputs, uint8_t* data);
 
  // implementation of the interfaces for the ethercat drivers
  void updateProcessData(DomainState state, uint8_t* data, unsigned int length) override;
 
  std::list<SdoId> updateServiceQueue() override;
 
  EcatDomainConfig& getDomainConfig() override;
 
  // implementation for the ethercat module
  friend class Module;
 
  void setDtSec(double sec);
 
  bool addParameters(parameter_server::Parameter* local_branch, utils::SystemMode system_mode);
 
  static bool linkInputParameters(parameter_server::Parameter* root, utils::SystemMode system_mode,
                                  std::vector<Domain::PdoData>& pdo_inputs);
 
  static bool linkOutputParameters(parameter_server::Parameter* root, utils::SystemMode system_mode,
                                   std::vector<PdoData>& pdo_outputs);
 
  static bool linkSdoParameters(parameter_server::Parameter* root, utils::SystemMode system_mode,
                                std::vector<SdoData>& sdos);
 
  bool linkParameters(parameter_server::Parameter* root, utils::SystemMode system_mode);
 
  void readSdo();
 
  // internal stuff
  static inline uint64_t toggleBits(uint64_t l, uint64_t r) { return ((1UL << r) - 1UL) ^ ((1UL << l) - 1UL); }
 
  static parameter_server::ParameterType toParamDir(EcatDirection dir, utils::SystemMode system_mode);
 
  static bool cutPdoDataTree(std::vector<PdoData>& pdos);
 
  static bool hasNamedChildren(const EcatPdoInfo& entry);
 
  Domain::PdoData addPdoEntry(const std::string& path, const EcatPdoInfo& entry, EcatDirection dir,
                              parameter_server::Parameter* local_branch, utils::SystemMode system_mode,
                              std::vector<uint64_t*>& mem_pool);
 
  void addSdoEntry(const std::string& path, const EcatSdoConfig& entry, parameter_server::Parameter* local_branch,
                   utils::SystemMode system_mode, std::vector<SdoData>& sdos);
 
  std::string name_;
  std::string path_;
  std::string filename_;
  std::string full_path_;
 
  struct {
    std::string version;
    tinyxml2::XMLElement* element{};
 
    [[nodiscard]] bool isLoaded() const { return element; }
  } domain_xml_{};
 
  EcatDomainConfig domain_config_;
  std::vector<PdoData> pdo_inputs_;
  std::vector<PdoData> pdo_outputs_;
  std::vector<SdoData> sdos_;
  MemoryPool memory_pool_;
 
  DomainState state_{DomainState::DOMAIN_OFF};
 
  bool error_{};
  struct {
    bool read;
    bool write;
    bool recover;
  } update_domain_sdos_{};
  struct {
    double error_counter;
    double no_error_counter;
    double dt_sec;
    double error_timeout;
    double no_error_timeout;
  } timing_{0, 0, 0.001, 1.0, 1.0};
};
 
} // namespace ecat
 
} // namespace mcx
 
#endif // MOTORCORTEX_LIB_ECAT_DOMAIN_H