ecat_xmltypes.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2016 - 2018 VECTIONEER.
 */
 
#ifndef ECAT_TYPES_H
#define ECAT_TYPES_H
 
#include "ecat_datatype.h"
#include "fmt/printf.h"
#include "utl_log.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace mcx::ecat {
 
enum EcatAlState {
  EC_AL_STATE_INIT = 1,   
  EC_AL_STATE_PREOP = 2,  
  EC_AL_STATE_SAFEOP = 4, 
  EC_AL_STATE_OP = 8,     
};
 
constexpr std::pair<const char*, EcatAlState> TransitionToStr[] = {{"IP", EcatAlState::EC_AL_STATE_INIT},
                                                                   {"PS", EcatAlState::EC_AL_STATE_PREOP},
                                                                   {"SO", EcatAlState::EC_AL_STATE_SAFEOP},
                                                                   {0x0, EcatAlState::EC_AL_STATE_PREOP}};
 
constexpr const char* transitionToStr(EcatAlState al_state) {
  unsigned int counter = 0;
  while (TransitionToStr[counter].first) {
    if (TransitionToStr[counter].second == al_state) {
      break;
    }
    ++counter;
  }
  return TransitionToStr[counter].first;
}
 
enum EcatWatchdogMode {
  EC_WD_DEFAULT, 
  EC_WD_ENABLE,  
  EC_WD_DISABLE, 
  EC_WD_COUNT
};
 
constexpr std::pair<const char*, EcatWatchdogMode> EcatWdToStr[]{{"Default", EcatWatchdogMode::EC_WD_DEFAULT},
                                                                 {"Enable", EcatWatchdogMode::EC_WD_ENABLE},
                                                                 {"Disable", EcatWatchdogMode::EC_WD_DISABLE},
                                                                 {0x0, EcatWatchdogMode::EC_WD_COUNT}};
 
enum EcatDirection {
  EC_DIR_INVALID, 
  EC_DIR_OUTPUT,  
  EC_DIR_INPUT,   
  EC_DIR_BOTH,    
  EC_DIR_COUNT    
};
 
using SdoDirection = EcatDirection;
 
constexpr std::pair<const char*, EcatDirection> EcatDirToStr[]{{"Invalid", EcatDirection::EC_DIR_INVALID},
                                                               {"Output", EcatDirection::EC_DIR_OUTPUT},
                                                               {"Input", EcatDirection::EC_DIR_INPUT},
                                                               {"Both", EcatDirection::EC_DIR_BOTH},
                                                               {0x0, EcatDirection::EC_DIR_COUNT}};
 
struct EcatSdoId {
  unsigned int device_id;
  unsigned int index;
  unsigned int subindex;
  EcatDirection dir;
};
 
// data type to represent pdo address, for example "1600 7010:10" (HEX)
 
struct EcatPdoId {
  unsigned int pdo_index;
  unsigned int entry_index;
  unsigned int entry_subindex;
};
 
enum ParameterLinkType { PL_DIR_UNKNOWN, PL_DIR_TO, PL_DIR_FROM, PL_SDO_READ, PL_SDO_WRITE };
 
struct ParameterLink {
  std::string name;
  std::string group;
  ParameterLinkType type;
  std::string path;
  unsigned int index;
  double gain;
  double offset;
  bool inv_bool;
  bool sim;
  bool clamp;
};
 
struct EcatPdoInfo {
  //  bool is_mapped;              /**< Entry is mapped to the user configuration. */
  bool is_visible;
  unsigned int pos;         
  unsigned int index;       
  unsigned int subindex;    
  unsigned int byte_offset; 
  unsigned int bit_offset;  
  std::string name;
  std::string group;
  DataTypeDesc data_type;
  std::vector<ParameterLink> links;
  std::vector<EcatPdoInfo> entries;
};
 
struct EcatSyncInfo {
  //  bool is_mapped;     /**< Syn manager is mapped. */
  unsigned int index;                
  EcatDirection dir;                 
  EcatWatchdogMode watchdog_mode;    
  std::vector<EcatPdoInfo> pdo_info; 
};
 
enum SdoDownloadState {
  EC_REQUEST_UNUSED,  
  EC_REQUEST_BUSY,    
  EC_REQUEST_SUCCESS, 
  EC_REQUEST_ERROR    
};
 
enum SdoType {
  EC_SDO_TYPE_INVALID,
  EC_CAN_OVER_ETHERCAT,   
  EC_SERCOS_OVER_ETHERCAT 
};
 
constexpr std::pair<const char*, SdoType> SdoTypeToStr[]{{"Invalid", SdoType::EC_SDO_TYPE_INVALID},
                                                         {"COE", SdoType::EC_CAN_OVER_ETHERCAT},
                                                         {"SOE", SdoType::EC_SERCOS_OVER_ETHERCAT}};
 
// device information
struct EcatDcInfo {
  unsigned int assign_activate;
  unsigned int cycle_time_sync0;
  unsigned int shift_time_sync0;
  unsigned int cycle_time_sync1;
  unsigned int shift_time_sync1;
};
 
struct EcatDeviceInfo {
  unsigned int vendor_id;
  unsigned int product_code;
  unsigned int alias;
  unsigned int position;
  std::string name;
  std::string group;
};
 
// complete description required for device configuration
// array of these structures is filled from etherlab xml file
 
struct EcatDevice {
  EcatDeviceInfo device_info;
  std::vector<EcatSyncInfo> sm_info;
  std::vector<EcatDcInfo> dc_info;
};
 
struct EcatSdoConfig;
using Links = std::vector<ParameterLink>;
using Entries = std::vector<EcatSdoConfig>;
 
struct EcatSdoConfig {
  //  bool is_mapped;
  SdoType type;
  SdoDirection dir;
  unsigned int pos;
  unsigned int index;
  unsigned int subindex;
  void* data_ptr;
  uint8_t* read_data_ptr;
  uint8_t* write_data_ptr;
  DataTypeDesc data_type;
  std::string group;
  std::string name;
  Links links;
  Entries entries;
};
 
inline size_t getSdoHash(EcatSdoConfig sdo_config) {
  return std::hash<std::string>{}(
      fmt::format("{}:{}:{}:{}", sdo_config.pos, sdo_config.index, sdo_config.subindex, sdo_config.dir));
}
 
struct EcatSoe {
  EcatAlState state_transition;
  unsigned int op_code;
  unsigned int drive_no;
  unsigned int idn;
  unsigned int elements;
  unsigned int attribute;
  unsigned int timeout;
  std::vector<unsigned char> data;
  std::string comment;
};
 
struct EcatCoe {
  bool complete_access;
  EcatAlState state_transition;
  unsigned int index;
  unsigned int subindex;
  unsigned int timeout;
  unsigned int ccs;
  std::vector<unsigned char> data;
  std::string comment;
};
 
struct EcatMailbox {
  std::vector<EcatSoe> soe;
  std::vector<EcatCoe> coe;
};
 
struct EcatDeviceConfig {
  EcatDeviceInfo info;
  std::vector<EcatMailbox> mailbox;
  std::vector<EcatSyncInfo> sm;
  std::vector<EcatSdoConfig> sdo;
  EcatDcInfo dc;
};
 
struct EcatDomainConfig {
  std::string name;
  std::string group;
  std::vector<EcatDeviceConfig> device;
  double no_error_timeout_sec;
  double error_timeout_sec;
  bool sdo_recovery;
};
 
} // namespace mcx::ecat
 
#endif /* ECAT_TYPES_H */