blocks.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/protocol.h"
 
namespace profinet::blocks
{
 
// =============================================================================
// Data Classes
// =============================================================================
 
struct BlockHeader
{
  BlockType blockType = BlockType::Unknown;
 
  std::uint16_t blockLength = 0;
 
  std::uint8_t versionHigh = 0;
 
  std::uint8_t versionLow = 0;
 
  [[nodiscard]] std::uint16_t BodyLength() const
  {
    return blockLength >= 2 ? static_cast<std::uint16_t>(blockLength - 2) : 0;
  }
 
  [[nodiscard]] std::string TypeName() const;
};
 
struct SlotInfo
{
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint32_t api = 0;
 
  std::uint32_t moduleIdent = 0;
 
  std::uint32_t submoduleIdent = 0;
 
  std::vector<std::string> blocks;
 
  [[nodiscard]] std::string ToString() const;
 
  bool operator==(const SlotInfo&) const = default;
};
 
struct PeerInfo
{
  std::string portId;
 
  std::string chassisId;
 
  std::array<std::uint8_t, macAddressLength> macAddress{};
 
  [[nodiscard]] std::string MacStr() const
  {
    return Mac2String(macAddress);
  }
  bool operator==(const PeerInfo&) const = default;
};
 
struct PortInfo
{
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::string portId;
 
  std::uint16_t mauType = 0;
 
  std::uint8_t linkStatePort = 0;
 
  std::uint8_t linkStateLink = 0;
 
  std::uint32_t mediaType = 0;
 
  std::vector<PeerInfo> peers;
 
  std::uint32_t domainBoundary = 0;
 
  std::uint32_t multicastBoundary = 0;
 
  [[nodiscard]] std::string MauTypeName() const;
 
  [[nodiscard]] std::string LinkState() const;
 
  bool operator==(const PortInfo&) const = default;
};
 
struct InterfaceInfo
{
  std::string chassisId;
 
  std::array<std::uint8_t, macAddressLength> macAddress{};
 
  std::array<std::uint8_t, 4> ipAddress{};
 
  std::array<std::uint8_t, 4> subnetMask{};
 
  std::array<std::uint8_t, 4> gateway{};
 
  [[nodiscard]] std::string MacStr() const
  {
    return Mac2String(macAddress);
  }
 
  [[nodiscard]] std::string IpStr() const
  {
    return String2Ip(ipAddress.data(), 4);
  }
 
  [[nodiscard]] std::string SubnetStr() const
  {
    return String2Ip(subnetMask.data(), 4);
  }
 
  [[nodiscard]] std::string GatewayStr() const
  {
    return String2Ip(gateway.data(), 4);
  }
  bool operator==(const InterfaceInfo&) const = default;
};
 
struct PDRealData
{
  std::vector<SlotInfo> slots;
 
  std::optional<InterfaceInfo> interface;
 
  std::vector<PortInfo> ports;
 
  std::vector<std::tuple<std::uint32_t, std::uint16_t, std::uint16_t, Bytes>> rawBlocks;
 
  bool operator==(const PDRealData&) const = default;
};
 
struct RealIdentificationData
{
  std::vector<SlotInfo> slots;
 
  std::pair<std::uint8_t, std::uint8_t> version{1, 0};
};
 
// =============================================================================
// Parsing Functions
// =============================================================================
 
std::pair<BlockHeader, std::size_t> ParseBlockHeader(const Bytes& data, std::size_t offset = 0);
 
inline std::size_t Align4(std::size_t offset)
{
  return (offset + 3) & ~static_cast<std::size_t>(3);
}
 
std::tuple<std::uint32_t, std::uint16_t, std::uint16_t, std::size_t> ParseMultipleBlockHeader(
    const Bytes& data, std::size_t offset = 0);
 
InterfaceInfo ParsePdInterfaceDataReal(const Bytes& data, std::size_t offset = 0,
                                       std::size_t blockHeaderSize = blockHeaderLenght);
 
PortInfo ParsePdPortDataReal(const Bytes& data, std::size_t offset = 0, std::uint16_t slot = 0,
                             std::uint16_t subslot = 0);
 
PDRealData ParsePdRealData(const Bytes& data);
 
RealIdentificationData ParseRealIdentificationData(const Bytes& data);
 
struct PortStatistics
{
  std::uint16_t counterStatus = 0;
 
  std::uint32_t inOctets = 0;
 
  std::uint32_t outOctets = 0;
 
  std::uint32_t inDiscards = 0;
 
  std::uint32_t outDiscards = 0;
 
  std::uint32_t inErrors = 0;
 
  std::uint32_t outErrors = 0;
};
 
std::optional<PortStatistics> ParsePortStatistics(const Bytes& data, std::size_t offset = 0);
 
// =============================================================================
// ModuleDiffBlock (0x8104) - Response showing module/submodule differences
// =============================================================================
 
struct ModuleDiffSubmodule
{
  std::uint16_t subslotNumber = 0;
 
  std::uint32_t submoduleIdentNumber = 0;
 
  std::uint16_t submoduleState = 0;
 
  [[nodiscard]] std::string StateName() const;
 
  [[nodiscard]] bool IsOk() const;
 
  bool operator==(const ModuleDiffSubmodule&) const = default;
};
 
struct ModuleDiffModule
{
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint32_t moduleIdentNumber = 0;
 
  std::uint16_t moduleState = 0;
 
  std::vector<ModuleDiffSubmodule> submodules;
 
  [[nodiscard]] std::string StateName() const;
 
  [[nodiscard]] bool IsProper() const;
 
  bool operator==(const ModuleDiffModule&) const = default;
};
 
struct ModuleDiffBlock
{
  std::vector<ModuleDiffModule> modules;
 
  [[nodiscard]] bool AllOk() const;
 
  [[nodiscard]] std::vector<std::tuple<std::uint16_t, std::uint16_t, std::string>> GetMismatches() const;
 
  bool operator==(const ModuleDiffBlock&) const = default;
};
 
ModuleDiffBlock ParseModuleDiffBlock(const Bytes& data);
 
// =============================================================================
// IODWriteMultiple (Index 0xE040)
// =============================================================================
 
struct WriteMultipleResult
{
  std::uint16_t seqNum = 0;
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t status = 0;
 
  std::uint16_t additionalValue1 = 0;
 
  std::uint16_t additionalValue2 = 0;
 
  [[nodiscard]] bool Success() const
  {
    return status == 0;
  }
};
 
class IODWriteMultipleBuilder
{
 public:
  static constexpr std::uint16_t writeMultipleIndex = 0xE040;
 
  static constexpr std::uint16_t writeMultipleBlockType = 0x0008;
 
  explicit IODWriteMultipleBuilder(std::array<std::uint8_t, uuidLenght> arUuid, std::uint16_t seqNum = 0)
      : arUuid(arUuid), seqNum(seqNum)
  {
  }
 
  IODWriteMultipleBuilder& AddWrite(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index,
                                    Bytes data, std::uint32_t api = 0);
 
  [[nodiscard]] Bytes Build() const;
 
 private:
  [[nodiscard]] Bytes BuildWriteBlock(std::uint16_t seq, std::uint32_t api, std::uint16_t slot, std::uint16_t subslot,
                                      std::uint16_t index, const Bytes& data) const;
 
  [[nodiscard]] Bytes BuildHeader(std::size_t blocksLen) const;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t seqNum = 0;
 
  struct Write
  {
    std::uint32_t api;
    std::uint16_t slot;
    std::uint16_t subslot;
    std::uint16_t index;
    Bytes data;
  };
 
  std::vector<Write> writes;
};
 
std::vector<WriteMultipleResult> ParseWriteMultipleResponse(const Bytes& data);
 
// =============================================================================
// ExpectedSubmodule Structures (0x0104)
// =============================================================================
 
enum class ModuleType : std::uint16_t
{
  None = 0,
  InputOnly = 1,
  OutputOnly = 2,
  InputAndOutput = 3
};
 
struct ExpectedSubmoduleDataDescription
{
  std::uint16_t dataDescription = 1;
 
  std::uint16_t submoduleDataLength = 0;
 
  std::uint8_t lengthIocs = 1;
 
  std::uint8_t lengthIops = 1;
 
  [[nodiscard]] Bytes ToBytes() const;
};
 
struct ExpectedSubmodule
{
  std::uint16_t subslotNumber = 0;
 
  std::uint32_t submoduleIdentNumber = 0;
 
  std::uint16_t submoduleProperties = 0;
 
  std::vector<ExpectedSubmoduleDataDescription> dataDescriptions;
 
  [[nodiscard]] std::uint16_t SubmoduleType() const
  {
    return submoduleProperties & 0x03;
  }
 
  [[nodiscard]] Bytes ToBytes() const;
};
struct ExpectedSubmoduleSlot
{
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint32_t moduleIdentNumber = 0;
 
  std::uint16_t moduleProperties = 0;
 
  std::vector<ExpectedSubmodule> submodules;
 
  [[nodiscard]] Bytes ToBytes() const;
};
 
struct ExpectedSubmoduleAPI
{
  std::uint32_t api = 0;
 
  std::vector<ExpectedSubmoduleSlot> slots;
 
  [[nodiscard]] Bytes ToBytes() const;
};
 
class ExpectedSubmoduleBlockReq
{
 public:
  static constexpr std::uint16_t expectedSubmoduleBlockReqBlockType = 0x0104;
 
  ExpectedSubmoduleBlockReq& AddSubmodule(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot,
                                          std::uint32_t moduleIdent, std::uint32_t submoduleIdent,
                                          std::uint16_t submoduleType = 0, std::uint16_t inputLength = 0,
                                          std::uint16_t outputLength = 0);
 
  [[nodiscard]] Bytes ToBytes() const;
 
 private:
  std::vector<ExpectedSubmoduleAPI> apis;
};
 
} // namespace profinet::blocks