indices.cpp

Go to the documentation of this file.

 
 
#include "profinet/indices.h"
 
#include <cstdio>
#include <map>
 
#include "profinet/util.h"
 
namespace profinet
{
std::string GetBlockTypeName(const BlockType blockType)
{
  switch (blockType)
  {
      // Diagnosis blocks
 
    case BlockType::DiagnosisData:
      return "Diagnosis Data";
 
    case BlockType::ExpectedIdentificationData:
      return "Expected Identification Data";
 
    case BlockType::RealIdentificationData:
      return "Real Identification Data";
 
      // I&M blocks
 
    case BlockType::IdentificationMaintenance0:
      return "I&M 0";
 
    case BlockType::IdentificationMaintenance1:
      return "I&M 1";
 
    case BlockType::IdentificationMaintenance2:
      return "I&M 2";
 
    case BlockType::IdentificationMaintenance3:
      return "I&M 3";
 
    case BlockType::IdentificationMaintenance4:
      return "I&M 4";
 
    case BlockType::IdentificationMaintenance5:
      return "I&M 5";
 
    case BlockType::IdentificationMaintenance6:
      return "I&M 6";
 
    case BlockType::IdentificationMaintenance7:
      return "I&M 7";
 
    case BlockType::IdentificationMaintenance8:
      return "I&M 8";
 
    case BlockType::IdentificationMaintenance9:
      return "I&M 9";
 
    case BlockType::IdentificationMaintenance10:
      return "I&M 10";
 
    case BlockType::IdentificationMaintenance11:
      return "I&M 11";
 
    case BlockType::IdentificationMaintenance12:
      return "I&M 12";
 
    case BlockType::IdentificationMaintenance13:
      return "I&M 13";
 
    case BlockType::IdentificationMaintenance14:
      return "I&M 14";
 
    case BlockType::IdentificationMaintenance15:
      return "I&M 15";
 
      // Alarm blocks
 
    case BlockType::AlarmNotificationHigh:
      return "Alarm Notification High";
 
    case BlockType::AlarmAcknowledgementHigh:
      return "Alarm Acknowledgement High";
 
    case BlockType::AlarmNotificationLow:
      return "Alarm Notification Low";
 
    case BlockType::AlarmAcknowledgementLow:
      return "Alarm Acknowledgement Low";
 
      // IOD Read/Write blocks
 
    case BlockType::IoDataWriteRequest:
      return "IO Data Write Request Header";
 
    case BlockType::IoDataWriteResponse:
      return "IO Data Write Response Header";
 
    case BlockType::IoDataReadRequest:
      return "IO Data Read Request Header";
 
    case BlockType::IoDataReadResponse:
      return "IO Data Read Response Header";
 
      // AR data blocks
 
    case BlockType::ApplicationRelationData:
      return "Application Relation Data";
 
    case BlockType::LogData:
      return "Log Data";
 
    case BlockType::ApiData:
      return "API Data";
 
    case BlockType::SrlData:
      return "SRL Data";
 
      // AR/IOCR/AlarmCR connection blocks
 
    case BlockType::ApplicationRelationRequest:
      return "Application Relation Request";
 
    case BlockType::ApplicationRelationResponse:
      return "Application Relation Response";
 
    case BlockType::IoCrRequest:
      return "IOCR Request";
 
    case BlockType::IoCrResponse:
      return "IOCR Response";
 
    case BlockType::AlarmCrRequest:
      return "Alarm CR Request";
 
    case BlockType::AlarmCrResponse:
      return "Alarm CR Response";
 
    case BlockType::ExpectedSubmoduleRequest:
      return "Expected Submodule Request";
 
    case BlockType::ModuleDifference:
      return "Module Difference";
 
      // Control operation blocks
 
    case BlockType::ControlPrmEndRequest:
      return "Control Parameter End Request";
 
    case BlockType::ControlPrmEndResponse:
      return "Control Parameter End Response";
 
    case BlockType::ControlApplicationReadyRequest:
      return "Control Application Ready Request";
 
    case BlockType::ControlApplicationReadyResponse:
      return "Control Application Ready Response";
 
    case BlockType::ReleaseRequest:
      return "Release Request";
 
    case BlockType::ReleaseResponse:
      return "Release Response";
 
    case BlockType::ControlRtClass3Request:
      return "Control RT Class 3 Request";
 
    case BlockType::ControlRtClass3Response:
      return "Control RT Class 3 Response";
 
    case BlockType::ParameterizationBeginRequest:
      return "Parameterization Begin Request";
 
    case BlockType::ParameterizationBeginResponse:
      return "Parameterization Begin Response";
 
    case BlockType::SubmoduleList:
      return "Submodule List";
 
      // Port and interface data blocks
 
    case BlockType::PortDataCheck:
      return "Port Data Check";
 
    case BlockType::PortDataAdjust:
      return "Port Data Adjust";
 
    case BlockType::PortDataReal:
      return "Port Data Real";
 
    case BlockType::InterfaceMrpDataAdjust:
      return "Interface MRP Data Adjust";
 
    case BlockType::InterfaceMrpDataReal:
      return "Interface MRP Data Real";
 
    case BlockType::PortMrpDataReal:
      return "Port MRP Data Real";
 
    case BlockType::MrpRingStateData:
      return "MRP Ring State Data";
 
    case BlockType::PortFoDataReal:
      return "Port FO Data Real";
 
    case BlockType::PortFoDataCheck:
      return "Port FO Data Check";
 
    case BlockType::PortFoDataAdjust:
      return "Port FO Data Adjust";
 
    case BlockType::PortDataRealExtended:
      return "Port Data Real Extended";
 
    case BlockType::PortDataInterfaceDataReal:
      return "Interface Data Real";
 
    case BlockType::PortStatistics:
      return "Port Statistics";
 
      // Container blocks
 
    case BlockType::MultipleHeader:
      return "Multiple Header";
 
    case BlockType::ContainerContent:
      return "Container Content";
 
      // Device-level blocks
 
    case BlockType::ApplicationRelationServer:
      return "Application Relation Server";
 
    case BlockType::RealProcessData:
      return "Real Process Data";
 
    case BlockType::ExpectedProcessData:
      return "Expected Process Data";
 
      // API-level blocks
 
    case BlockType::RealIdentificationDataApi:
      return "Real Identification Data API";
 
    default:
      return "Unknown (" +
             Hex4(static_cast<std::uint16_t>(blockType)) +
             ")";
  }
}
 
std::string GetAlarmTypeName(const AlarmType alarmType)
{
  switch (alarmType)
  {
    case AlarmType::Diagnosis:
      return "Diagnosis";
 
    case AlarmType::Process:
      return "Process";
 
    case AlarmType::Pull:
      return "Pull";
 
    case AlarmType::Plug:
      return "Plug";
 
    case AlarmType::Status:
      return "Status";
 
    case AlarmType::Update:
      return "Update";
 
    case AlarmType::Redundancy:
      return "Redundancy";
 
    case AlarmType::ControlledBySupervisor:
      return "Controlled By Supervisor";
 
    case AlarmType::Released:
      return "Released";
 
    case AlarmType::PlugWrongSubmodule:
      return "Plug Wrong Submodule";
 
    case AlarmType::ReturnOfSubmodule:
      return "Return Of Submodule";
 
    case AlarmType::DiagnosisDisappears:
      return "Diagnosis Disappears";
 
    case AlarmType::MulticastMismatch:
      return "Multicast Mismatch";
 
    case AlarmType::PortDataChange:
      return "Port Data Change";
 
    case AlarmType::SyncDataChanged:
      return "Sync Data Changed";
 
    case AlarmType::IsochronousModeProblem:
      return "Isochronous Mode Problem";
 
    case AlarmType::NetworkComponentProblem:
      return "Network Component Problem";
 
    case AlarmType::TimeDataChanged:
      return "Time Data Changed";
 
    case AlarmType::DfpProblem:
      return "DFP Problem";
 
    case AlarmType::UploadRetrieval:
      return "Upload Retrieval";
 
    case AlarmType::PullModule:
      return "Pull Module";
 
    default:
      return "Unknown";
  }
}
 
std::string GetIocrTypeName(const IocrType iocrType)
{
  switch (iocrType)
  {
    case IocrType::Input:
      return "Input";
 
    case IocrType::Output:
      return "Output";
 
    case IocrType::MulticastProvider:
      return "Multicast Provider";
 
    case IocrType::MulticastConsumer:
      return "Multicast Consumer";
 
    default:
      return "Unknown (" +
             Hex4(static_cast<std::uint16_t>(iocrType)) +
             ")";
  }
}
 
std::string GetIocrRtClassName(const IocrRtClass rtClass)
{
  switch (rtClass)
  {
    case IocrRtClass::Udp:
      return "RT_CLASS_UDP";
 
    default:
      return "Unknown (" +
             Hex2(static_cast<std::uint8_t>(rtClass)) +
             ")";
  }
}
std::string GetUsiName(const Usi usi)
{
  switch (usi)
  {
    case Usi::ChannelDiagnosis:
      return "Channel Diagnosis";
 
    case Usi::MultipleDiagnosis:
      return "Multiple Diagnosis";
 
    case Usi::ExtendedChannelDiagnosis:
      return "Extended Channel Diagnosis";
 
    case Usi::QualifiedChannelDiagnosis:
      return "Qualified Channel Diagnosis";
 
    case Usi::Maintenance:
      return "Maintenance Item";
 
    case Usi::Upload:
      return "Upload Record";
 
    case Usi::IParameter:
      return "iParameter Item";
 
    case Usi::RsAlarmLow:
      return "RS Alarm Item (Low)";
 
    case Usi::RsAlarmHigh:
      return "RS Alarm Item (High)";
 
    case Usi::RsAlarmSubmodule:
      return "RS Alarm Item (Submodule)";
 
    case Usi::PeAlarm:
      return "PE Alarm Item";
 
    case Usi::PralAlarm:
      return "PRAL Alarm Item";
 
    default:
    {
      const auto value = static_cast<std::uint16_t>(usi);
 
      if (value <= 0x7FFF)
      {
        return "Manufacturer Specific (" + Hex4(value) + ")";
      }
 
      if (value >= 0x8400 && value <= 0x8FFF)
      {
        return "Profile Specific (" + Hex4(value) + ")";
      }
 
      return "Reserved (" + Hex4(value) + ")";
    }
  }
}
 
std::string GetModuleStateName(std::uint16_t state)
{
  static const std::map<std::uint16_t, std::string> table = {
      {MODULE_STATE_NO_MODULE, "NoModule"},
      {MODULE_STATE_WRONG_MODULE, "WrongModule"},
      {MODULE_STATE_PROPER_MODULE, "ProperModule"},
      {MODULE_STATE_SUBSTITUTE_MODULE, "SubstituteModule"},
  };
  auto it = table.find(state);
  return it != table.end() ? it->second : "Unknown(" + Hex4(state) + ")";
}
 
std::string GetSubmoduleStateName(std::uint16_t state)
{
  static const std::map<std::uint16_t, std::string> table = {
      {SUBMODULE_STATE_NO_SUBMODULE, "NoSubmodule"},
      {SUBMODULE_STATE_WRONG_SUBMODULE, "WrongSubmodule"},
      {SUBMODULE_STATE_LOCKED_BY_SUPERVISOR, "LockedBySupervisor"},
      {SUBMODULE_STATE_APPLICATION_READY_PENDING, "ApplicationReadyPending"},
      {SUBMODULE_STATE_OK, "OK"},
  };
  auto it = table.find(state);
  return it != table.end() ? it->second : "Unknown(" + Hex4(state) + ")";
}
 
std::string GetPeModeName(std::uint8_t mode)
{
  if (mode == PE_MODE_POWER_OFF)
  {
    return "PE_PowerOff";
  }
  if (mode >= PE_MODE_ENERGY_SAVING_MIN && mode <= PE_MODE_ENERGY_SAVING_MAX)
  {
    return "PE_EnergySavingMode_" + std::to_string(mode);
  }
  if (mode == PE_MODE_OPERATE)
  {
    return "PE_Operate";
  }
  if (mode == PE_MODE_SLEEP_MODE_WOL)
  {
    return "PE_SleepModeWOL";
  }
  if (mode == PE_MODE_READY_TO_OPERATE)
  {
    return "PE_ReadyToOperate";
  }
  return "PE_Reserved(" + Hex2(mode) + ")";
}
 
const IndexNamePairs& CriticalIndices()
{
  static const IndexNamePairs table = {
      {IM0, "I&M0 (mandatory)"},
      {IM0_FILTER_DATA, "I&M0FilterData"},
      {DIAG_DEVICE, "Device Diagnosis"},
      {MODULE_DIFF_BLOCK, "ModuleDiffBlock"},
      {PD_REAL_DATA, "PDRealData"},
      {AR_DATA, "ARData"},
      {LOG_DATA, "LogData"},
  };
  return table;
}
 
const IndexNamePairs& ImIndices()
{
  static const IndexNamePairs table = {
      {IM0, "I&M0"},
      {IM1, "I&M1"},
      {IM2, "I&M2"},
      {IM3, "I&M3"},
      {IM4, "I&M4"},
      {IM5, "I&M5"},
      {IM6, "I&M6"},
      {IM7, "I&M7"},
      {IM8, "I&M8"},
      {IM9, "I&M9"},
      {IM10, "I&M10"},
      {IM11, "I&M11"},
      {IM12, "I&M12"},
      {IM13, "I&M13"},
      {IM14, "I&M14"},
      {IM15, "I&M15"},
  };
  return table;
}
 
const IndexNamePairs& DiagnosisIndices(const std::string& scope)
{
  static const IndexNamePairs subslot = {
      {DIAG_CHANNEL_SUBSLOT, "DiagnosisChannel"},
      {DIAG_ALL_SUBSLOT, "DiagnosisAll"},
      {DIAG_MAINTENANCE_SUBSLOT, "DiagnosisMaintenance"},
  };
  static const IndexNamePairs slot = {
      {DIAG_CHANNEL_SLOT, "DiagnosisChannel"},
      {DIAG_ALL_SLOT, "DiagnosisAll"},
      {DIAG_MAINTENANCE_SLOT, "DiagnosisMaintenance"},
  };
  static const IndexNamePairs ar = {
      {DIAG_CHANNEL_AR, "DiagnosisChannel"},
      {DIAG_ALL_AR, "DiagnosisAll"},
      {DIAG_MAINTENANCE_AR, "DiagnosisMaintenance"},
  };
  static const IndexNamePairs api = {
      {DIAG_CHANNEL_API, "DiagnosisChannel"},
      {DIAG_ALL_API, "DiagnosisAll"},
      {DIAG_MAINTENANCE_API, "DiagnosisMaintenance"},
  };
  static const IndexNamePairs device = {
      {DIAG_DEVICE, "DeviceDiagnosis"},
  };
  static const IndexNamePairs empty;
 
  if (scope == "subslot")
  {
    return subslot;
  }
  if (scope == "slot")
  {
    return slot;
  }
  if (scope == "ar")
  {
    return ar;
  }
  if (scope == "api")
  {
    return api;
  }
  if (scope == "device")
  {
    return device;
  }
  return empty;
}
 
const IndexNamePairs& PortIndices()
{
  static const IndexNamePairs table = {
      {PD_PORT_DATA_REAL, "PDPortDataReal"},
      {PD_PORT_DATA_CHECK, "PDPortDataCheck"},
      {PD_PORT_DATA_ADJUST, "PDPortDataAdjust"},
      {PD_PORT_STATISTIC, "PDPortStatistic"},
      {PD_PORT_MRP_DATA_REAL, "PDPortMrpDataReal"},
  };
  return table;
}
 
const IndexNamePairs& InterfaceIndices()
{
  static const IndexNamePairs table = {
      {PD_INTERFACE_DATA_REAL, "PDInterfaceDataReal"},
      {PD_INTERFACE_MRP_DATA_REAL, "PDInterfaceMrpDataReal"},
      {PD_NC_DATA_CHECK, "PDNCDataCheck"},
  };
  return table;
}
 
const IndexNamePairs& DeviceIndices()
{
  static const IndexNamePairs table = {
      {AR_DATA, "ARData"},
      {API_DATA, "APIData"},
      {PDEV_DATA, "PDevData"},
      {PD_REAL_DATA, "PDRealData"},
      {PD_EXPECTED_DATA, "PDExpectedData"},
      {LOG_DATA, "LogData"},
      {AUTO_CONFIG, "AutoConfiguration"},
  };
  return table;
}
 
const IndexNamePairs& AllStandardIndices()
{
  static const IndexNamePairs table = []
  {
    IndexNamePairs v;
    auto append = [&](const IndexNamePairs& src)
    { v.insert(v.end(), src.begin(), src.end()); };
    append(ImIndices());
    append(DiagnosisIndices("subslot"));
    append(DiagnosisIndices("device"));
    append(PortIndices());
    append(InterfaceIndices());
    append(DeviceIndices());
    v.emplace_back(EXPECTED_ID_SUBSLOT, "ExpectedIdentificationData");
    v.emplace_back(REAL_ID_SUBSLOT, "RealIdentificationData");
    v.emplace_back(MODULE_DIFF_BLOCK, "ModuleDiffBlock");
    v.emplace_back(SUBSTITUTE_VALUES, "SubstituteValues");
    v.emplace_back(RECORD_INPUT_DATA, "RecordInputData");
    v.emplace_back(RECORD_OUTPUT_DATA, "RecordOutputData");
    return v;
  }();
  return table;
}
 
std::string GetIndexName(std::uint16_t index)
{
  for (const auto& [idx, Name] : AllStandardIndices())
  {
    if (idx == index)
    {
      return Name;
    }
  }
 
  if (index <= 0x7FFF)
  {
    return "User-specific (" + Hex4(index) + ")";
  }
  if (index >= 0xAFF0 && index <= 0xAFFF)
  {
    return "I&M" + std::to_string(index - 0xAFF0);
  }
  if (index >= 0x8000 && index <= 0x8FFF)
  {
    return "Subslot data (" + Hex4(index) + ")";
  }
  if (index >= 0xC000 && index <= 0xCFFF)
  {
    return "Slot data (" + Hex4(index) + ")";
  }
  if (index >= 0xE000 && index <= 0xEFFF)
  {
    return "AR data (" + Hex4(index) + ")";
  }
  if (index >= 0xF000 && index <= 0xF7FF)
  {
    return "API data (" + Hex4(index) + ")";
  }
  if (index >= 0xF800 && index <= 0xFBFF)
  {
    return "Device data (" + Hex4(index) + ")";
  }
  return "Unknown (" + Hex4(index) + ")";
}
 
std::string GetScope(std::uint16_t index)
{
  if (index <= 0x7FFF)
  {
    return "user";
  }
  if (index >= 0x8000 && index <= 0x8FFF)
  {
    return "subslot";
  }
  if (index >= 0xA000 && index <= 0xAFFF)
  {
    return "slot";
  }
  if (index >= 0xC000 && index <= 0xCFFF)
  {
    return "slot";
  }
  if (index >= 0xE000 && index <= 0xEFFF)
  {
    return "ar";
  }
  if (index >= 0xF000 && index <= 0xF7FF)
  {
    return "api";
  }
  if (index >= 0xF800 && index <= 0xFBFF)
  {
    return "device";
  }
  return "unknown";
}
 
} // namespace profinet