common.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <charconv>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <nlohmann/json.hpp>
#include <optional>
#include <string>
#include <string_view>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace common {
 
template <typename T>
T parseHex(const std::string& s) {
  static_assert(std::is_unsigned<T>::value,
                "parseHex only supports unsigned integer types");
 
  // Use the appropriate std::stoul or std::stoull depending on size
  if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    // Use std::stoul
    return static_cast<T>(std::stoul(s, nullptr, 16));
  } else {
    // Use std::stoull for larger types like uint64_t
    return static_cast<T>(std::stoull(s, nullptr, 16));
  }
}
 
struct UiPdoMapping {
  std::map<std::uint16_t, std::vector<std::uint32_t>> rx;
  std::map<std::uint16_t, std::vector<std::uint32_t>> tx;
};
 
struct UiConfigJson {
  UiPdoMapping pdoMapping;
};
 
void from_json(const nlohmann::json& j, UiPdoMapping& p);
 
void from_json(const nlohmann::json& j, UiConfigJson& r);
 
enum class EtherCATVendorID : uint32_t {
  SYNAPTICON = 0x000022d2,  
};
 
inline bool operator==(uint32_t lhs, EtherCATVendorID rhs) {
  return lhs == static_cast<uint32_t>(rhs);
}
 
inline bool operator==(EtherCATVendorID lhs, uint32_t rhs) {
  return static_cast<uint32_t>(lhs) == rhs;
}
 
struct PdoMappingEntry {
  uint16_t pdoIndex;  
  uint16_t index;     
  uint8_t subindex;   
  uint8_t
      bitlength;  
};
 
struct PdoMappings {
  std::vector<PdoMappingEntry> rxPdos;  
  std::vector<PdoMappingEntry> txPdos;  
};
 
enum class ObjectFlags : uint16_t {
  None = 0x0000,
 
  // Read access
  PO_RD = 0x0001,
  SO_RD = 0x0002,
  OP_RD = 0x0004,
  ALL_RD = PO_RD | SO_RD | OP_RD,
 
  // Write access
  PO_WR = 0x0008,
  SO_WR = 0x0010,
  OP_WR = 0x0020,
  ALL_WR = PO_WR | SO_WR | OP_WR,
 
  // Read/Write combinations
  PO_RDWR = PO_RD | PO_WR,
  SO_RDWR = SO_RD | SO_WR,
  OP_RDWR = OP_RD | OP_WR,
  ALL_RDWR = PO_RDWR | SO_RDWR | OP_RDWR,
 
  // Mapping
  RXPDO_MAP = 0x0040,
  TXPDO_MAP = 0x0080,
  RXTXPDO_MAP = 0x00C0,
 
  // Other flags
  BACKUP = 0x0100,
  STARTUP = 0x0200,
 
  ALL_LIST_FLAGS = RXPDO_MAP | TXPDO_MAP | BACKUP | STARTUP
};
 
inline ObjectFlags operator|(ObjectFlags lhs, ObjectFlags rhs) {
  return static_cast<ObjectFlags>(static_cast<uint16_t>(lhs) |
                                  static_cast<uint16_t>(rhs));
}
 
inline ObjectFlags operator&(ObjectFlags lhs, ObjectFlags rhs) {
  return static_cast<ObjectFlags>(static_cast<uint16_t>(lhs) &
                                  static_cast<uint16_t>(rhs));
}
 
inline ObjectFlags& operator|=(ObjectFlags& lhs, ObjectFlags rhs) {
  lhs = lhs | rhs;
  return lhs;
}
 
inline ObjectFlags SetObjectFlags(ObjectFlags b, ObjectFlags s, ObjectFlags p,
                                  ObjectFlags a) {
  return b | s | p | a;
}
 
enum class ObjectDataType : uint16_t {
  UNSPECIFIED = 0x0000,  
 
  BOOLEAN = 0x0001,  
  BYTE = 0x001E,     
  WORD = 0x001F,     
  DWORD = 0x0020,    
 
  BIT1 = 0x0030,   
  BIT2 = 0x0031,   
  BIT3 = 0x0032,   
  BIT4 = 0x0033,   
  BIT5 = 0x0034,   
  BIT6 = 0x0035,   
  BIT7 = 0x0036,   
  BIT8 = 0x0037,   
  BIT9 = 0x0038,   
  BIT10 = 0x0039,  
  BIT11 = 0x003A,  
  BIT12 = 0x003B,  
  BIT13 = 0x003C,  
  BIT14 = 0x003D,  
  BIT15 = 0x003E,  
  BIT16 = 0x003F,  
 
  BITARR8 = 0x002D,   
  BITARR16 = 0x002E,  
  BITARR32 = 0x002F,  
 
  INTEGER8 = 0x0002,   
  INTEGER16 = 0x0003,  
  INTEGER24 = 0x0010,  
  INTEGER32 = 0x0004,  
  INTEGER40 = 0x0012,  
  INTEGER48 = 0x0013,  
  INTEGER56 = 0x0014,  
  INTEGER64 = 0x0015,  
 
  UNSIGNED8 = 0x0005,   
  UNSIGNED16 = 0x0006,  
  UNSIGNED24 = 0x0016,  
  UNSIGNED32 = 0x0007,  
  UNSIGNED40 = 0x0018,  
  UNSIGNED48 = 0x0019,  
  UNSIGNED56 = 0x001A,  
  UNSIGNED64 = 0x001B,  
 
  REAL32 = 0x0008,  
  REAL64 = 0x0011,  
 
  GUID = 0x001D,  
 
  VISIBLE_STRING = 0x0009,  
  OCTET_STRING = 0x000A,    
  UNICODE_STRING = 0x000B,  
  ARRAY_OF_INT = 0x0260,    
  ARRAY_OF_SINT = 0x0261,   
  ARRAY_OF_DINT = 0x0262,   
  ARRAY_OF_UDINT = 0x0263,  
 
  PDO_MAPPING = 0x0021,    
  IDENTITY = 0x0023,       
  COMMAND_PAR = 0x0025,    
  PDO_PARAMETER = 0x0027,  
  ENUM = 0x0028,           
  SM_SYNCHRONIZATION =
      0x0029,       
  RECORD = 0x002A,  
  BACKUP_PARAMETER = 0x002B,  
  MODULAR_DEVICE_PARAMETER = 0x002C,  
  ERROR_SETTING = 0x0281,  
  DIAGNOSIS_HISTORY =
      0x0282,  
  EXTERNAL_SYNC_STATUS = 0x0283,    
  EXTERNAL_SYNC_SETTINGS = 0x0284,  
  DEFTYPE_FSOEFRAME = 0x0285,       
  DEFTYPE_FSOECOMMPAR =
      0x0286,  
 
  TIME_OF_DAY = 0x000C,  
  TIME_DIFFERENCE =
      0x000D,            
  UTYPE_START = 0x0800,  
  UTYPE_END = 0x0FFF     
};
 
enum class ObjectCode : uint16_t {
  DEFTYPE = 0x0005,    
  DEFSTRUCT = 0x0006,  
  VAR = 0x0007,        
  ARRAY = 0x0008,      
  RECORD = 0x0009,     
};
 
using ParameterKey = std::pair<uint16_t, uint8_t>;
 
using ParameterValue =
    std::variant<bool, std::int8_t, std::int16_t, std::int32_t, std::int64_t,
                 std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t,
                 float, double, std::string,
                 std::vector<std::uint8_t>>;  
 
class Parameter {
 public:
  std::string name;
 
  std::uint16_t index;
 
  std::uint8_t subindex;
 
  std::uint16_t bitLength;
 
  int byteLength;
 
  common::ObjectDataType dataType;
 
  common::ObjectCode code;
 
  common::ObjectFlags flags;
 
  common::ObjectFlags access;
 
  std::vector<std::uint8_t> data;
 
  ParameterValue getValue() const;
 
  template <typename T>
  T getValue() const {
    // Get the value as a ParameterValue
    const ParameterValue& val = getValue();
 
    // Try to get the value of type T from the variant
    if (auto ptr = std::get_if<T>(&val)) {
      return *ptr;  // Return the value of type T
    } else {
      throw std::bad_variant_access();  // If type T is not found in the variant
    }
  }
 
  template <typename T>
  std::optional<T> tryGetValue() const {
    const ParameterValue& val = getValue();
    if (auto ptr = std::get_if<T>(&val)) {
      return *ptr;
    } else {
      return std::nullopt;
    }
  }
 
  void setValue(const ParameterValue& value);
 
  template <typename T>
  void setValue(const T& value) {
    // Convert the input value to ParameterValue (variant)
    ParameterValue parameterValue(value);
 
    // Reuse the existing setValue function to handle the assignment
    setValue(parameterValue);
  }
 
  template <typename T>
  bool trySetValue(const T& value) {
    auto expectedType = [this]() -> std::type_index {
      switch (dataType) {
        case ObjectDataType::BOOLEAN: {
          return typeid(bool);
        }
        case ObjectDataType::INTEGER8: {
          return typeid(std::int8_t);
        }
        case ObjectDataType::INTEGER16: {
          return typeid(std::int16_t);
        }
        case ObjectDataType::INTEGER24:
        case ObjectDataType::INTEGER32: {
          return typeid(std::int32_t);
        }
        case ObjectDataType::INTEGER64: {
          return typeid(std::int64_t);
        }
        case ObjectDataType::UNSIGNED8:
        case ObjectDataType::PDO_MAPPING:
        case ObjectDataType::IDENTITY:
        case ObjectDataType::COMMAND_PAR:
        case ObjectDataType::RECORD: {
          return typeid(std::uint8_t);
        }
        case ObjectDataType::UNSIGNED16: {
          return typeid(std::uint16_t);
        }
        case ObjectDataType::UNSIGNED24:
        case ObjectDataType::UNSIGNED32: {
          return typeid(std::uint32_t);
        }
        case ObjectDataType::UNSIGNED64: {
          return typeid(std::uint64_t);
        }
        case ObjectDataType::REAL32: {
          return typeid(float);
        }
        case ObjectDataType::REAL64: {
          return typeid(double);
        }
        case ObjectDataType::VISIBLE_STRING:
        case ObjectDataType::OCTET_STRING:
        case ObjectDataType::UNICODE_STRING: {
          return typeid(std::string);
        }
        default: {
          return typeid(void);
        }
      }
    };
 
    const std::type_index expected = expectedType();
    if (expected != typeid(T) &&
        typeid(T) != typeid(std::vector<std::uint8_t>)) {
      return false;
    }
 
    setValue(ParameterValue(value));
    return true;
  }
 
  bool operator<(const Parameter& other) const {
    if (index != other.index) {
      return index < other.index;  // Compare by index first
    }
    return subindex <
           other.subindex;  // Compare by subindex if indices are equal
  }
 
  bool operator>(const Parameter& other) const {
    if (index != other.index) {
      return index > other.index;  // Compare by index first
    }
    return subindex >
           other.subindex;  // Compare by subindex if indices are equal
  }
 
  bool operator==(const Parameter& other) const {
    return index == other.index && subindex == other.subindex;
  }
 
  static void to_json(nlohmann::json& j, const Parameter& p);
 
  static void from_json(const nlohmann::json& j, Parameter& p);
};
 
std::string convertParameterValueToString(const ParameterValue& value);
 
void logParametersMap(const std::unordered_map<std::pair<uint16_t, uint8_t>,
                                               Parameter>& parametersMap,
                      bool sortParameters = true);
 
class Device {
 public:
  virtual ~Device() = default;
 
  virtual uint8_t getState(
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(3000)) = 0;
 
  virtual bool setState(uint8_t state,
                        const std::chrono::steady_clock::duration expiryTime =
                            std::chrono::milliseconds(3000)) = 0;
 
  virtual std::vector<uint8_t> readFile(
      const std::string& filename,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(5000)) = 0;
 
  virtual bool writeFile(const std::string& filename,
                         const std::vector<uint8_t>& data,
                         const std::chrono::steady_clock::duration expiryTime =
                             std::chrono::milliseconds(5000)) = 0;
 
  virtual void loadParameters(
      bool readValues, const std::chrono::steady_clock::duration expiryTime =
                           std::chrono::milliseconds(9000)) = 0;
 
  virtual void clearParameters() = 0;
 
  virtual Parameter& findParameter(uint16_t index, uint8_t subindex) = 0;
 
  virtual Parameter& upload(
      uint16_t index, uint8_t subindex,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(5000)) = 0;
 
  virtual void download(uint16_t index, uint8_t subindex,
                        const std::chrono::steady_clock::duration expiryTime =
                            std::chrono::milliseconds(5000)) = 0;
 
  virtual void download(uint16_t index, uint8_t subindex,
                        const ParameterValue& value,
                        const std::chrono::steady_clock::duration expiryTime =
                            std::chrono::milliseconds(5000)) = 0;
 
  virtual void exchangeProcessDataAndUpdateParameters() = 0;
};
 
template <typename T>
bool stringViewToNumber(std::string_view sv, T& result) {
  static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type");
 
  auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), result);
  return ec == std::errc();
}
 
#include <algorithm>  // for std::reverse
#include <bit>
#include <cstdint>
#include <type_traits>
#include <vector>
 
template <typename T>
std::vector<uint8_t> toBytes(T value, bool bigEndian = false) {
  static_assert(std::is_trivially_copyable<T>::value,
                "T must be trivially copyable");
 
  std::vector<uint8_t> bytes(sizeof(T));
  uint8_t* bytePtr = reinterpret_cast<uint8_t*>(&value);
 
  for (size_t i = 0; i < sizeof(T); ++i) {
    bytes[i] = bytePtr[i];
  }
 
  if (bigEndian) {
    std::reverse(bytes.begin(), bytes.end());
  }
 
  return bytes;
}
 
inline std::string makeParameterId(int index, int subindex) {
  std::stringstream oss;
  // Format index and subindex into "0xINDEX:SUBINDEX"
  oss << "0x" << std::setw(4) << std::setfill('0') << std::hex << std::uppercase
      << index << ":" << std::setw(2) << std::setfill('0') << std::hex
      << std::uppercase << subindex;
 
  return oss.str();
}
 
inline std::string bytesToHexString(const std::vector<uint8_t>& data) {
  std::ostringstream oss;
  for (uint8_t byte : data) {
    oss << "0x" << std::hex << std::setw(2) << std::setfill('0')
        << static_cast<int>(byte) << " ";
  }
  return oss.str();
}
 
std::vector<uint8_t> readBinaryFile(const std::string& filename);
 
std::string joinStrings(const std::vector<std::string>& list,
                        const std::string& delimiter);
 
std::string formatMacAddress(const std::string& originalMacAddress);
 
}  // namespace common
 
namespace std {
template <>
struct hash<std::pair<uint16_t, uint8_t>> {
  size_t operator()(const std::pair<uint16_t, uint8_t>& p) const {
    return hash<uint16_t>()(p.first) ^ (hash<uint8_t>()(p.second) << 1);
  }
};
}  // namespace std