device.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/alarmListener.h"
#include "profinet/alarms.h"
#include "profinet/blocks.h"
#include "profinet/cyclic.h"
#include "profinet/dcp.h"
#include "profinet/diagnosis.h"
#include "profinet/protocol.h"
#include "profinet/rpc.h"
#include "profinet/rt.h"
#include "profinet/util.h"
 
namespace profinet::device
{
 
std::optional<MacAddress> ParseMac(const std::string& macStr);
 
bool IsMacAddress(const std::string& identifier);
 
// =============================================================================
// Data Classes
// =============================================================================
 
struct WriteItem
{
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t index = 0;
 
  Bytes data;
 
  std::uint32_t api = 0;
};
 
struct DeviceInfo
{
  std::string name;
 
  std::string ip;
 
  std::string mac;
 
  std::uint16_t vendorId = 0;
 
  std::uint16_t deviceId = 0;
 
  std::string deviceType;
 
  std::string netmask;
 
  std::string gateway;
 
  std::vector<std::string> deviceRoles;
 
  std::string vendorName;
 
  std::optional<PNInM0> im0;
 
  std::optional<blocks::PDRealData> topology;
 
  std::string annotation;
 
  [[nodiscard]] std::string SerialNumber() const;
 
  [[nodiscard]] std::string OrderId() const;
 
  [[nodiscard]] std::uint16_t HardwareRevision() const;
 
  [[nodiscard]] std::string SoftwareRevision() const;
};
 
// =============================================================================
// ProfinetDevice
// =============================================================================
 
class ProfinetDevice
{
 public:
  ProfinetDevice(dcp::DCPDeviceDescription info, std::string interface, MacAddress srcMac,
                 double timeoutSec = 5.0,
                 std::unique_ptr<rpc::IRPCCon> rpc = nullptr, std::unique_ptr<IAlarmListener> alarmListener = nullptr);
 
  ~ProfinetDevice();
 
  ProfinetDevice(const ProfinetDevice&) = delete;
 
  ProfinetDevice& operator=(const ProfinetDevice&) = delete;
 
  ProfinetDevice(ProfinetDevice&&) = default;
 
  ProfinetDevice& operator=(ProfinetDevice&&) = default;
 
  // =========================================================================
  // Discovery factory methods
  // =========================================================================
 
  static ProfinetDevice Discover(const std::string& identifier, const std::string& interface,
                                 double timeoutSec = 10.0);
 
  static ProfinetDevice FromIp(const std::string& ip, const std::string& interface, double timeoutSec = 10.0);
 
  static ProfinetDevice FromDcpInfo(dcp::DCPDeviceDescription info, const std::string& interface,
                                    double timeoutSec = 5.0);
 
  // =========================================================================
  // Connection management
  // =========================================================================
 
  void Connect();
 
  void Disconnect();
 
  void Close();
 
  [[nodiscard]] bool IsConnected() const
  {
    return connected;
  }
 
  // =========================================================================
  // Device info
  // =========================================================================
 
  [[nodiscard]] const std::string& Name() const
  {
    return info.name;
  }
 
  [[nodiscard]] const std::string& Ip() const
  {
    return info.ip;
  }
 
  [[nodiscard]] std::string Mac() const
  {
    return info.mac;
  }
 
  DeviceInfo GetInfo(bool includeTopology = false);
 
  // =========================================================================
  // Read/write operations
  // =========================================================================
 
  Bytes Read(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index, std::uint32_t api = 0);
 
  Bytes ReadImplicit(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index, std::uint32_t api = 0);
 
  void Write(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index, const Bytes& data,
             std::uint32_t api = 0);
 
  std::vector<blocks::WriteMultipleResult> WriteMultiple(const std::vector<WriteItem>& writes);
 
  // =========================================================================
  // I&M record convenience methods
  // =========================================================================
 
  PNInM0 ReadIm0(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM1 ReadIm1(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM2 ReadIm2(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM3 ReadIm3(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM4 ReadIm4(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM5 ReadIm5(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  rpc::AllIM ReadAllIm(std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  void WriteIm1(const std::string& tagFunction, const std::string& tagLocation, std::uint16_t slot = 0,
                std::uint16_t subslot = 1);
 
  void WriteIm2(const std::string& date, std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  void WriteIm3(const std::string& descriptor, std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  // =========================================================================
  // Configuration & diagnosis
  // =========================================================================
 
  blocks::ModuleDiffBlock ReadModuleDiff();
 
  diagnosis::DiagnosisData ReadDiagnosis(std::uint16_t slot = 0, std::uint16_t subslot = 0,
                                         std::uint16_t index = 0xF000);
 
  std::map<std::uint16_t, diagnosis::DiagnosisData> ReadAllDiagnosis();
 
  std::vector<blocks::SlotInfo> DiscoverSlots();
 
  blocks::PDRealData ReadTopology();
 
  // =========================================================================
  // Alarm reading
  // =========================================================================
 
  std::optional<AlarmNotification> ReadAlarm(std::uint16_t slot = 0, std::uint16_t subslot = 0,
                                             std::uint16_t index = 0x800C);
 
  void OnAlarm(std::function<void(const AlarmNotification&)> callback);
 
  void StartAlarmListener();
 
  void StopAlarmListener();
 
  [[nodiscard]] bool AlarmListenerRunning() const;
 
  // =========================================================================
  // Cyclic IO
  // =========================================================================
 
  std::unique_ptr<cyclic::ICyclicController> StartCyclic(const rpc::IOCRSetup& iocrSetup,
                                                         int maxConsecutiveTimeouts = 3,
                                                         std::unique_ptr<cyclic::ICyclicController> controller = nullptr);
 
  // =========================================================================
  // Utility
  // =========================================================================
 
  std::map<std::uint16_t, rpc::IndexProbeResult> EnumerateIndices(std::uint16_t slot = 0,
                                                                  std::uint16_t subslot = 1);
 
  [[nodiscard]] std::string ToString() const;
 
 private:
  rpc::IRPCCon& EnsureConnected();
 
  void ReleaseAr(rpc::IRPCCon& releaseRpc);
 
  dcp::DCPDeviceDescription info;
 
  std::string interface;
 
  MacAddress srcMac{};
 
  double timeout;
 
  std::unique_ptr<rpc::IRPCCon> rpc;
 
  bool connected = false;
 
  std::unique_ptr<IAlarmListener> alarmListener;
 
  std::vector<std::function<void(const AlarmNotification&)>> alarmCallbacks;
};
 
// =============================================================================
// Scan
// =============================================================================
 
std::vector<ProfinetDevice> Scan(const std::string& interface = "eth0", double timeoutSec = 3.0);
 
std::map<std::string, DeviceInfo> ScanDict(const std::string& interface = "eth0", double timeoutSec = 3.0);
 
} // namespace profinet::device