dcp.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "profinet/IRawEthernetSocket.h"
#include "profinet/protocol.h"
#include "profinet/util.h"
 
namespace profinet::dcp
{
// NOLINTBEGIN(readability-identifier-naming)
// =============================================================================
// Constants
// =============================================================================
 
inline const std::string DCP_MULTICAST_MAC = "01:0e:cf:00:00:00";
inline const std::string DCP_HELLO_MULTICAST_MAC = "01:0e:cf:00:00:01";
 
inline constexpr std::size_t DCP_MAX_NAME_LENGTH = 240;
 
inline constexpr std::uint16_t DEFAULT_TIMEOUT = 5;
inline constexpr std::uint16_t DEFAULT_THREAD_SLEEP_MS = 2000;
inline constexpr std::uint16_t DEFAULT_RESPONSE_TIMEOUT = 20;
inline constexpr std::uint16_t DEFAULT_HELLO_TIMEOUT = 10;
inline constexpr std::uint16_t DEFAULT_RESPONSE_DELAY_FACTOR = 0x0080; // 128
inline constexpr std::uint16_t FLASH_DURATION_MS = 3000;
 
inline constexpr std::uint16_t blockNameVendorRangeMin = 0x80;
inline constexpr std::uint16_t blockNameVendorRangeMax = 0xFF;
 
inline constexpr std::uint16_t DCP_IP_CONFLICT_BIT = 0x0080;
inline constexpr std::uint16_t DCP_IP_DHCP_BIT = 0x0002;
// NOLINTEND(readability-identifier-naming)
 
std::vector<std::string> DecodeDeviceRole(std::uint8_t roleByte);
 
std::string DeviceRoleName(DcpDeviceRole role);
 
std::string GetBlockName(std::uint16_t option, std::uint8_t suboption);
 
std::string GetBlockName(DcpOption option, std::uint8_t suboption);
 
std::string GetBlockName(DcpOption option, DcpIpSuboption suboption);
 
std::string GetBlockName(DcpOption option, DcpDeviceSuboption suboption);
 
std::string GetBlockName(DcpOption option, DcpControlSuboption suboption);
 
std::string GetBlockName(DcpOption option, DcpDhcpSuboption suboption);
 
std::string GetBlockName(DcpOption option, DcpDeviceInitiativeSuboption suboption);
 
DcpBlockError ParseSetResponse(const Bytes& data);
 
DcpBlockError RecvSetResponse(IRawEthernetSocket& sock, const MacAddress& srcMac, int timeoutSec);
 
std::string GetDeviceInitiativeName(DcpDeviceInitiative value);
 
std::string GetDcpResponseCodeName(DcpResponseCode value);
 
std::string GetResetQualifierName(std::uint16_t qualifier);
 
std::string GetResetQualifierName(DcpResetQualifier qualifier);
 
std::string GetIPBlockInfoName(DcpIpBlockInfo info);
 
bool HasConflict(DcpIpBlockInfo info);
 
bool IsDhcp(DcpIpBlockInfo info);
 
std::string GetDcpBlockQualifierDescription(DcpBlockQualifier qualifier);
 
std::string GetDcpBlockErrorDescription(DcpBlockError error);
 
struct DCPDHCPBlock
{
  DcpDhcpSuboption suboption = DcpDhcpSuboption::Unknown;
 
  std::string suboptionName;
 
  std::vector<std::uint8_t> rawData;
 
  std::optional<std::string> hostname;
 
  std::optional<std::vector<std::uint8_t>> clientId;
 
  std::optional<std::vector<std::uint8_t>> vendorSpecific;
 
  std::optional<std::string> fqdn;
 
  std::optional<std::string> uuid;
 
  static DCPDHCPBlock Parse(DcpDhcpSuboption suboption, const std::vector<std::uint8_t>& data);
};
 
// using BlockKey = std::pair<std::uint8_t, std::uint8_t>;
using BlockKey = DcpBlockKey;
 
constexpr DcpBlockKey MakeBlockKey(std::uint16_t option, std::uint8_t suboption)
{
  return {.option = static_cast<DcpOption>(option), .suboption = suboption};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, std::uint8_t suboption)
{
  return {.option = option, .suboption = suboption};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, DcpIpSuboption suboption)
{
  return {.option = option, .suboption = static_cast<std::uint8_t>(suboption)};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, DcpDeviceSuboption suboption)
{
  return {.option = option, .suboption = static_cast<std::uint8_t>(suboption)};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, DcpControlSuboption suboption)
{
  return {.option = option, .suboption = static_cast<std::uint8_t>(suboption)};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, DcpDhcpSuboption suboption)
{
  return {.option = option, .suboption = static_cast<std::uint8_t>(suboption)};
}
 
constexpr DcpBlockKey MakeBlockKey(DcpOption option, DcpDeviceInitiativeSuboption suboption)
{
  return {.option = option, .suboption = static_cast<std::uint8_t>(suboption)};
}
 
class DCPDeviceDescription
{
 public:
  DCPDeviceDescription(const MacAddress& mac, const std::map<BlockKey, std::vector<std::uint8_t>>& blocks);
 
  std::string mac;
 
  std::string deviceType;
 
  std::string name;
 
  std::string ip = "0.0.0.0";
 
  std::string netmask = "0.0.0.0";
 
  std::string gateway = "0.0.0.0";
 
  DcpIpBlockInfo ipBlockInfo = DcpIpBlockInfo::NotSet;
 
  bool ipConflict = false;
 
  bool ipSetByDhcp = false;
 
  std::uint16_t vendorId = 0;
 
  std::uint8_t vendorHigh = 0;
 
  std::uint8_t vendorLow = 0;
 
  std::uint16_t deviceId = 0;
 
  std::uint8_t deviceHigh = 0;
 
  std::uint8_t deviceLow = 0;
 
  std::uint8_t deviceRole = 0;
 
  std::vector<std::string> deviceRoles;
 
  std::pair<std::uint8_t, std::uint8_t> deviceInstance{0, 0};
 
  std::string aliasName;
 
  std::vector<BlockKey> supportedOptions;
 
  std::vector<DCPDHCPBlock> dhcpBlocks;
 
  // std::uint16_t deviceInitiative = 0;
  DcpDeviceInitiative deviceInitiative = DcpDeviceInitiative::NoHello;
 
  bool issuesHello = false;
 
  std::map<BlockKey, std::vector<std::uint8_t>> rawBlocks;
 
  [[nodiscard]] std::uint16_t VendorId() const
  {
    return vendorId;
  }
 
  [[nodiscard]] std::uint16_t DeviceId() const
  {
    return deviceId;
  }
 
  [[nodiscard]] std::string VendorName() const;
 
  [[nodiscard]] std::string ToString() const;
};
 
// =============================================================================
// DCP Operations
// =============================================================================
Bytes BuildSetParamRequest(const MacAddress& dst,
                           const MacAddress& src,
                           const std::string& param,
                           const std::string& value,
                           bool permanent);
 
[[nodiscard]] Bytes BuildDcpSignalRequest(const MacAddress& dst, const MacAddress& src);
 
const std::map<std::string, BlockKey>& Params();
 
std::optional<std::vector<std::uint8_t>> GetParam(IRawEthernetSocket& sock, const MacAddress& src,
                                                  const std::string& target, const std::string& param,
                                                  int timeoutSec = DEFAULT_TIMEOUT);
 
bool SetParam(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
              const std::string& param, const std::string& value, int timeoutSec = DEFAULT_TIMEOUT, bool permanent = false, int threadSleepMs = DEFAULT_THREAD_SLEEP_MS);
 
bool SetIp(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
           const std::string& ip, const std::string& netmask, const std::string& gateway,
           bool permanent = false, int timeoutSec = DEFAULT_TIMEOUT, int threadSleepMs = DEFAULT_THREAD_SLEEP_MS);
 
void SendDiscover(IRawEthernetSocket& sock, const MacAddress& src, std::uint16_t responseDelay = DEFAULT_RESPONSE_DELAY_FACTOR);
 
void SendRequest(IRawEthernetSocket& sock, const MacAddress& src, BlockKey blockType,
                 const std::vector<std::uint8_t>& value);
 
using ResponseMap = std::map<MacAddress, std::map<BlockKey, std::vector<std::uint8_t>>>;
 
ResponseMap ReadResponse(IRawEthernetSocket& sock, const MacAddress& myMac, double timeoutSec = DEFAULT_RESPONSE_TIMEOUT,
                         bool once = false, std::optional<std::uint32_t> expectedXid = std::nullopt);
 
void SendHello(IRawEthernetSocket& sock, const MacAddress& src, const std::string& stationName,
               const std::string& ip = "0.0.0.0", const std::string& netmask = "0.0.0.0",
               const std::string& gateway = "0.0.0.0", std::pair<std::uint16_t, std::uint16_t> deviceId = {0, 0},
               DcpDeviceRole deviceRole = DcpDeviceRole::IoDevice);
 
std::vector<DCPDeviceDescription> ReceiveHello(
    IRawEthernetSocket& sock, const MacAddress& myMac, double timeoutSec = DEFAULT_HELLO_TIMEOUT,
    const std::function<void(const DCPDeviceDescription&)>& callback = nullptr);
 
bool SignalDevice(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
                  int durationMs = FLASH_DURATION_MS, double timeoutSec = DEFAULT_TIMEOUT);
 
bool ResetToFactory(IRawEthernetSocket& sock,
                    const MacAddress& src,
                    const std::string& target,
                    DcpResetMode mode = DcpResetMode::Communication,
                    double timeoutSec = DEFAULT_TIMEOUT);
 
} // namespace profinet::dcp