alarmListener.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <asio/io_context.hpp>
#include <atomic>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <vector>
 
#include "profinet/IAlarmListener.h"
#include "profinet/alarms.h"
#include "profinet/util.h"
 
namespace profinet
{
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::uint16_t FRAME_ID_ALARM_HIGH = 0xFC01;
inline constexpr std::uint16_t FRAME_ID_ALARM_LOW = 0xFE01;
inline constexpr std::uint16_t ETHERTYPE_PROFINET = 0x8892;
inline constexpr std::uint16_t ALARM_UDP_PORT = 34964;
// NOLINTEND(readability-identifier-naming)
//
struct AlarmEndpoint
{
  std::string interface;
 
  std::uint16_t controllerRef = 0;
 
  std::uint16_t deviceRef = 0;
 
  MacAddress deviceMac{};
 
  int transport = 0;
};
 
class AlarmListener : public IAlarmListener
{
 public:
  friend class AlarmListenerTestAccess;
 
  explicit AlarmListener(asio::io_context& ioContext,
                         AlarmEndpoint endpoint,
                         std::optional<MacAddress> controllerMac = std::nullopt);
 
  ~AlarmListener() override;
 
  AlarmListener(const AlarmListener&) = delete;
 
  AlarmListener& operator=(const AlarmListener&) = delete;
 
  void AddAlarmNotificationCallback(std::function<void(const AlarmNotification&)> callback) override;
 
  void RemoveAlarmNotificationCallback(std::function<void(const AlarmNotification&)> callback) override;
  void AddRtaAlarmCallback(std::function<void(const RtaError&)> callback) override;
 
  void RemoveRtaAlarmCallback(std::function<void(const RtaError&)> callback) override;
 
  void Start(std::unique_ptr<IRawEthernetSocket> eSocket = nullptr,
             std::unique_ptr<IUdpSocket> uSocket = nullptr) override;
 
  void Stop() override;
 
  bool IsRunning() const override
  {
    return running;
  }
 
 private:
  void ListenLoop();
 
  void HandleLayer2Frame();
 
  void HandleUdpFrame();
 
  void ProcessAlarm(const Bytes& payload, std::optional<bool> highPriority,
                    std::optional<MacAddress> srcMac, std::optional<UdpEndpoint> udpSource);
 
  void SendRtaFrame(std::uint8_t pduType,
                    std::uint8_t addFlags,
                    const Bytes& ackData, const MacAddress& dstMac, bool highPriority);
 
  void SendAck(const AlarmNotification& alarm, std::optional<MacAddress> srcMac, std::optional<UdpEndpoint> udpSource);
 
  void SendTransportAck(std::optional<MacAddress> srcMac, bool highPriority);
 
  void SendNack(std::optional<MacAddress> srcMac, bool highPriority);
 
  void SendLayer2Ack(const Bytes& ackData, const MacAddress& dstMac, bool highPriority);
 
  void SendUdpAck(const Bytes& ackData, const UdpEndpoint& dstAddr);
 
  asio::io_context& ioContext;
 
  AlarmEndpoint endpoint;
 
  MacAddress controllerMac{};
 
  std::atomic<bool> running{false};
 
  std::jthread thread;
 
  mutable std::mutex callbacksMutex;
 
  std::vector<std::function<void(const AlarmNotification&)>> alarmNotificationCallbacks;
 
  std::vector<std::function<void(const RtaError&)>> rtaAlarmCallbacks;
 
  std::uint16_t sendSeqNum = 0;
 
  std::uint16_t recvSeqNum = 0;
 
  std::unique_ptr<IRawEthernetSocket> l2Sock;
 
  std::unique_ptr<IUdpSocket> udpSock;
 
  mutable std::mutex lifecycleMutex;
};
 
} // namespace profinet