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::uint16_t DCP_IDENTIFY_REQUEST_FRAME_ID = 0xFEFE;
inline constexpr std::uint16_t DCP_IDENTIFY_RESPONSE_FRAME_ID = 0xFEFF;
inline constexpr std::uint16_t DCP_GET_SET_FRAME_ID = 0xFEFD;
inline constexpr std::uint16_t DCP_HELLO_FRAME_ID = 0xFEFC;
 
inline constexpr std::uint8_t DCP_SERVICE_ID_GET = 0x03;
inline constexpr std::uint8_t DCP_SERVICE_ID_SET = 0x04;
inline constexpr std::uint8_t DCP_SERVICE_ID_IDENTIFY = 0x05;
inline constexpr std::uint8_t DCP_SERVICE_ID_HELLO = 0x06;
 
inline constexpr std::uint8_t DCP_SERVICE_TYPE_REQUEST = 0x00;
inline constexpr std::uint8_t DCP_SERVICE_TYPE_RESPONSE_SUCCESS = 0x01;
inline constexpr std::uint8_t DCP_SERVICE_TYPE_RESPONSE_UNSUPPORTED = 0x05;
 
inline constexpr std::size_t DCP_MAX_NAME_LENGTH = 240;
 
inline constexpr std::uint8_t DCP_OPTION_IP = 0x01;
inline constexpr std::uint8_t DCP_OPTION_DEVICE = 0x02;
inline constexpr std::uint8_t DCP_OPTION_DHCP = 0x03;
inline constexpr std::uint8_t DCP_OPTION_RESERVED = 0x04;
inline constexpr std::uint8_t DCP_OPTION_CONTROL = 0x05;
inline constexpr std::uint8_t DCP_OPTION_DEVICE_INITIATIVE = 0x06;
inline constexpr std::uint8_t DCP_OPTION_NME = 0x07;
inline constexpr std::uint8_t DCP_OPTION_ALL = 0xFF;
 
inline constexpr std::uint8_t DCP_SUBOPTION_IP_MAC = 0x01;
inline constexpr std::uint8_t DCP_SUBOPTION_IP_PARAMETER = 0x02;
inline constexpr std::uint8_t DCP_SUBOPTION_IP_FULL_SUITE = 0x03;
 
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_TYPE = 0x01;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_NAME = 0x02;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_ID = 0x03;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_ROLE = 0x04;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_OPTIONS = 0x05;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_ALIAS = 0x06;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_INSTANCE = 0x07;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_OEM_ID = 0x08;
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_RSI = 0x0A;
 
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_START = 0x01;
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_STOP = 0x02;
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_SIGNAL = 0x03;
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_RESPONSE = 0x04;
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_RESET_FACTORY = 0x05;
inline constexpr std::uint8_t DCP_SUBOPTION_CONTROL_RESET_TO_FACTORY = 0x06;
 
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_HOSTNAME = 0x0C;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_VENDOR_SPEC = 0x2B;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_SERVER_ID = 0x36;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_PARAM_REQ = 0x37;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_CLASS_ID = 0x3C;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_CLIENT_ID = 0x3D;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_FQDN = 0x51;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_UUID = 0x61;
inline constexpr std::uint8_t DCP_SUBOPTION_DHCP_CONTROL = 0xFF;
 
inline constexpr std::uint8_t DCP_SUBOPTION_DEVICE_INITIATIVE = 0x01;
 
inline constexpr std::uint8_t DEVICE_ROLE_IO_DEVICE = 0x01;
inline constexpr std::uint8_t DEVICE_ROLE_IO_CONTROLLER = 0x02;
inline constexpr std::uint8_t DEVICE_ROLE_IO_MULTIDEVICE = 0x04;
inline constexpr std::uint8_t DEVICE_ROLE_PN_SUPERVISOR = 0x08;
 
inline constexpr std::uint16_t RESET_MODE_COMMUNICATION = 0x0002;
inline constexpr std::uint16_t RESET_MODE_APPLICATION = 0x0004;
inline constexpr std::uint16_t RESET_MODE_ENGINEERING = 0x0008;
inline constexpr std::uint16_t RESET_MODE_ALL_DATA = 0x0010;
inline constexpr std::uint16_t RESET_MODE_DEVICE = 0x0020;
inline constexpr std::uint16_t RESET_MODE_FACTORY = 0x0040;
 
inline constexpr std::uint16_t DEFAULT_TIMEOUT = 5;
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;
 
// NOLINTEND(readability-identifier-naming)
//
std::vector<std::string> DecodeDeviceRole(std::uint8_t roleByte);
 
std::string GetBlockName(std::uint8_t option, std::uint8_t suboption);
 
std::uint8_t ParseSetResponse(const Bytes& data);
 
std::uint8_t RecvSetResponse(const IRawEthernetSocket& sock, const MacAddress& srcMac, int timeoutSec);
 
struct IPBlockInfo
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IP_NOT_SET = 0x0000;
 
  static constexpr std::uint16_t IP_SET = 0x0001;
 
  static constexpr std::uint16_t IP_SET_BY_DHCP = 0x0002;
 
  static constexpr std::uint16_t IP_NOT_SET_CONFLICT = 0x0080;
 
  static constexpr std::uint16_t IP_SET_CONFLICT = 0x0081;
 
  static constexpr std::uint16_t IP_SET_BY_DHCP_CONFLICT = 0x0082;
 
  static constexpr std::uint16_t IP_CONFLICT_BIT = 0x0080;
  // NOLINTEND(readability-identifier-naming)
  //
  static std::string GetName(std::uint16_t info);
 
  static bool HasConflict(std::uint16_t info)
  {
    return (info & IP_CONFLICT_BIT) != 0;
  }
 
  static bool IsDhcp(std::uint16_t info)
  {
    return (info & 0x0002) != 0;
  }
};
 
struct BlockQualifier
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t TEMPORARY = 0x0000;
 
  static constexpr std::uint16_t PERMANENT = 0x0001;
  // NOLINTEND(readability-identifier-naming)
  static std::string GetName(std::uint16_t qualifier);
};
 
struct ResetQualifier
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t RESET_APPLICATION_DATA = 0x0002;
 
  static constexpr std::uint16_t RESET_COMMUNICATION_PARAM = 0x0004;
 
  static constexpr std::uint16_t RESET_ENGINEERING_PARAM = 0x0006;
 
  static constexpr std::uint16_t RESET_ALL_STORED_DATA = 0x0008;
 
  static constexpr std::uint16_t RESET_TO_FACTORY = 0x0010;
 
  static constexpr std::uint16_t RESET_AND_RESTORE = 0x0012;
  // NOLINTEND(readability-identifier-naming)
  static std::string GetName(std::uint16_t qualifier);
};
 
struct DeviceInitiative
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t NO_HELLO = 0x0000;
 
  static constexpr std::uint16_t ISSUE_HELLO = 0x0001;
  // NOLINTEND(readability-identifier-naming)
  static std::string GetName(std::uint16_t value);
};
 
struct DCPResponseCode
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t NO_ERROR = 0x00;
 
  static constexpr std::uint8_t OPTION_NOT_SUPPORTED = 0x01;
 
  static constexpr std::uint8_t SUBOPTION_NOT_SUPPORTED = 0x02;
 
  static constexpr std::uint8_t SUBOPTION_NOT_SET = 0x03;
 
  static constexpr std::uint8_t RESOURCE_ERROR = 0x04;
 
  static constexpr std::uint8_t SET_NOT_POSSIBLE = 0x05;
 
  static constexpr std::uint8_t IN_OPERATION_SET_NOT_POSSIBLE = 0x06;
  // NOLINTEND(readability-identifier-naming)
  static std::string GetName(std::uint8_t code);
};
 
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::uint8_t DCP_BLOCK_ERROR_OK = 0x00;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_OPTION_UNSUPPORTED = 0x01;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_SUBOPTION_UNSUPPORTED = 0x02;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_SUBOPTION_NOT_SET = 0x03;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_RESOURCE = 0x04;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_SET_NOT_POSSIBLE = 0x05;
inline constexpr std::uint8_t DCP_BLOCK_ERROR_IN_OPERATION = 0x06;
// NOLINTEND(readability-identifier-naming)
 
std::string DcpBlockErrorName(std::uint8_t code);
 
struct DCPDHCPBlock
{
  std::uint8_t suboption = 0;
 
  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(std::uint8_t suboption, const std::vector<std::uint8_t>& data);
};
 
using BlockKey = std::pair<std::uint8_t, std::uint8_t>;
 
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";
 
  std::uint16_t ipBlockInfo = 0;
 
  bool ipConflict = false;
 
  bool ipSetByDhcp = false;
 
  std::uint8_t vendorHigh = 0;
 
  std::uint8_t vendorLow = 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;
 
  bool issuesHello = false;
 
  std::map<BlockKey, std::vector<std::uint8_t>> rawBlocks;
 
  [[nodiscard]] std::uint16_t VendorId() const
  {
    return static_cast<std::uint16_t>((vendorHigh << OneOctetShift) | vendorLow);
  }
 
  [[nodiscard]] std::uint16_t DeviceId() const
  {
    return static_cast<std::uint16_t>((deviceHigh << OneOctetShift) | deviceLow);
  }
 
  [[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(const EthernetSocket& sock, const MacAddress& src,
                                                  const std::string& target, const std::string& param,
                                                  int timeoutSec = DEFAULT_TIMEOUT);
 
bool SetParam(const EthernetSocket& sock, const MacAddress& src, const std::string& target,
              const std::string& param, const std::string& value, int timeoutSec = DEFAULT_TIMEOUT, bool permanent = false);
 
bool SetIp(const EthernetSocket& 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);
 
void SendDiscover(const EthernetSocket& sock, const MacAddress& src, std::uint16_t responseDelay = DEFAULT_RESPONSE_DELAY_FACTOR);
 
void SendRequest(const EthernetSocket& 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(const EthernetSocket& sock, const MacAddress& myMac, int timeoutSec = DEFAULT_RESPONSE_TIMEOUT,
                         bool once = false, std::optional<std::uint32_t> expectedXid = std::nullopt);
 
void SendHello(const EthernetSocket& 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},
               std::uint8_t deviceRole = DEVICE_ROLE_IO_DEVICE);
 
std::vector<DCPDeviceDescription> ReceiveHello(
    const EthernetSocket& sock, const MacAddress& myMac, int timeoutSec = DEFAULT_HELLO_TIMEOUT,
    const std::function<void(const DCPDeviceDescription&)>& callback = nullptr);
 
bool SignalDevice(const EthernetSocket& sock, const MacAddress& src, const std::string& target,
                  int durationMs = FLASH_DURATION_MS, int timeoutSec = DEFAULT_TIMEOUT);
 
bool ResetToFactory(const EthernetSocket& sock, const MacAddress& src, const std::string& target,
                    std::uint16_t mode = RESET_MODE_COMMUNICATION, int timeoutSec = DEFAULT_TIMEOUT);
 
} // namespace profinet::dcp