object_data_types.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <nlohmann/json_fwd.hpp>
#include <string_view>
 
// <cmath>/<math.h> — pulled in transitively by the STL headers above — defines the obsolete
// SVID matherr macro DOMAIN on macOS/Clang and Windows/MSVC. Left in place it would expand
// inside the ObjectDataType enum below and break the build. glibc gates the macro behind a
// feature test that -std=c++2b disables, so only the non-Linux toolchains hit this. The
// matherr interface is long dead; drop the macro so the ETG.1020 DOMAIN enumerator survives.
#ifdef DOMAIN
#undef DOMAIN
#endif
 
namespace mm::comm {
 
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,    
  // 0x000B is UNICODE_STRING per SOEM (ec_type.h) / CiA 301, which is what ecx_readOE and
  // SOMANET drives actually report.  ETG.1020 v1.6.0 instead lists 0x000B as ARRAY_OF_UINT and
  // puts UNICODE_STRING at 0x0268 — we keep 0x000B for wire decoding and also catalogue the
  // ETG.1020 code as WSTRING (below) so a spec-numbered device still decodes.
  UNICODE_STRING = 0x000B,  
  WSTRING = 0x0268,         
 
  TIME_OF_DAY = 0x000C,      
  TIME_DIFFERENCE = 0x000D,  
  DOMAIN = 0x000F,           
 
  ARRAY_OF_INT = 0x0260,       
  ARRAY_OF_SINT = 0x0261,      
  ARRAY_OF_DINT = 0x0262,      
  ARRAY_OF_UDINT = 0x0263,     
  ARRAY_OF_BITARR8 = 0x0264,   
  ARRAY_OF_BITARR16 = 0x0265,  
  ARRAY_OF_BITARR32 = 0x0266,  
  ARRAY_OF_USINT = 0x0267,     
  ARRAY_OF_REAL = 0x0269,      
  ARRAY_OF_LREAL = 0x026A,     
 
  PDO_MAPPING = 0x0021,             
  IDENTITY = 0x0023,                
  COMMAND_PAR = 0x0025,             
  PDO_PARAMETER = 0x0027,           
  ENUM = 0x0028,                    
  SM_SYNCHRONISATION = 0x0029,      
  RECORD = 0x002A,                  
  BACKUP_PARAMETER = 0x002B,        
  MODULAR_DEVICE_PROFILE = 0x002C,  
 
  ERROR_SETTING = 0x0281,           
  DIAGNOSIS_HISTORY = 0x0282,       
  EXTERNAL_SYNC_STATUS = 0x0283,    
  EXTERNAL_SYNC_SETTINGS = 0x0284,  
  DEFTYPE_FSOEFRAME = 0x0285,       
  DEFTYPE_FSOECOMMPAR = 0x0286,     
 
  UTYPE_START = 0x0800,  
  UTYPE_END = 0x0FFF,    
};
 
struct ObjectDataTypeInfo {
  uint16_t code = 0;      
  std::string_view name;  
  uint16_t bitSize = 0;   
};
 
void to_json(nlohmann::json& j, const ObjectDataTypeInfo& info);
 
inline constexpr auto kObjectDataTypes = std::to_array<ObjectDataTypeInfo>({
    {0x0000, "UNSPECIFIED", 0},
    {0x0001, "BOOLEAN", 1},
    {0x0002, "INTEGER8", 8},
    {0x0003, "INTEGER16", 16},
    {0x0004, "INTEGER32", 32},
    {0x0005, "UNSIGNED8", 8},
    {0x0006, "UNSIGNED16", 16},
    {0x0007, "UNSIGNED32", 32},
    {0x0008, "REAL32", 32},
    {0x0009, "VISIBLE_STRING", 0},
    {0x000A, "OCTET_STRING", 0},
    {0x000B, "UNICODE_STRING", 0},
    {0x000C, "TIME_OF_DAY", 48},
    {0x000D, "TIME_DIFFERENCE", 48},
    {0x000F, "DOMAIN", 0},
    {0x0010, "INTEGER24", 24},
    {0x0011, "REAL64", 64},
    {0x0012, "INTEGER40", 40},
    {0x0013, "INTEGER48", 48},
    {0x0014, "INTEGER56", 56},
    {0x0015, "INTEGER64", 64},
    {0x0016, "UNSIGNED24", 24},
    {0x0018, "UNSIGNED40", 40},
    {0x0019, "UNSIGNED48", 48},
    {0x001A, "UNSIGNED56", 56},
    {0x001B, "UNSIGNED64", 64},
    {0x001D, "GUID", 128},
    {0x001E, "BYTE", 8},
    {0x001F, "WORD", 16},
    {0x0020, "DWORD", 32},
    {0x0021, "PDO_MAPPING", 0},
    {0x0023, "IDENTITY", 0},
    {0x0025, "COMMAND_PAR", 0},
    {0x0027, "PDO_PARAMETER", 0},
    {0x0028, "ENUM", 0},
    {0x0029, "SM_SYNCHRONISATION", 0},
    {0x002A, "RECORD", 0},
    {0x002B, "BACKUP_PARAMETER", 0},
    {0x002C, "MODULAR_DEVICE_PROFILE", 0},
    {0x002D, "BITARR8", 8},
    {0x002E, "BITARR16", 16},
    {0x002F, "BITARR32", 32},
    {0x0030, "BIT1", 1},
    {0x0031, "BIT2", 2},
    {0x0032, "BIT3", 3},
    {0x0033, "BIT4", 4},
    {0x0034, "BIT5", 5},
    {0x0035, "BIT6", 6},
    {0x0036, "BIT7", 7},
    {0x0037, "BIT8", 8},
    {0x0038, "BIT9", 9},
    {0x0039, "BIT10", 10},
    {0x003A, "BIT11", 11},
    {0x003B, "BIT12", 12},
    {0x003C, "BIT13", 13},
    {0x003D, "BIT14", 14},
    {0x003E, "BIT15", 15},
    {0x003F, "BIT16", 16},
    {0x0260, "ARRAY_OF_INT", 0},
    {0x0261, "ARRAY_OF_SINT", 0},
    {0x0262, "ARRAY_OF_DINT", 0},
    {0x0263, "ARRAY_OF_UDINT", 0},
    {0x0264, "ARRAY_OF_BITARR8", 0},
    {0x0265, "ARRAY_OF_BITARR16", 0},
    {0x0266, "ARRAY_OF_BITARR32", 0},
    {0x0267, "ARRAY_OF_USINT", 0},
    {0x0268, "WSTRING", 0},
    {0x0269, "ARRAY_OF_REAL", 0},
    {0x026A, "ARRAY_OF_LREAL", 0},
    {0x0281, "ERROR_SETTING", 0},
    {0x0282, "DIAGNOSIS_HISTORY", 0},
    {0x0283, "EXTERNAL_SYNC_STATUS", 0},
    {0x0284, "EXTERNAL_SYNC_SETTINGS", 0},
    {0x0285, "DEFTYPE_FSOEFRAME", 0},
    {0x0286, "DEFTYPE_FSOECOMMPAR", 0},
});
 
constexpr std::string_view objectDataTypeName(uint16_t code) {
  const auto it = std::find_if(kObjectDataTypes.begin(), kObjectDataTypes.end(),
                               [code](const ObjectDataTypeInfo& e) { return e.code == code; });
  return it != kObjectDataTypes.end() ? it->name : std::string_view{"UNKNOWN"};
}
 
constexpr uint16_t objectDataTypeBitSize(uint16_t code) {
  const auto it = std::find_if(kObjectDataTypes.begin(), kObjectDataTypes.end(),
                               [code](const ObjectDataTypeInfo& e) { return e.code == code; });
  return it != kObjectDataTypes.end() ? it->bitSize : uint16_t{0};
}
 
}  // namespace mm::comm