alarmListener.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <netinet/in.h>
 
#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 AlarmListenerTests;
 
  friend class AlarmListenerRtaTest;
 
  friend class AlarmListenerRtaIntegrationTest;
 
  friend class AlarmListenerCallbackTest;
 
  explicit AlarmListener(AlarmEndpoint endpoint,
                         std::optional<MacAddress> controllerMac = std::nullopt,
                         std::unique_ptr<IRawEthernetSocket> l2Socket = nullptr);
 
  ~AlarmListener() override;
 
  AlarmListener(const AlarmListener&) = delete;
 
  AlarmListener& operator=(const AlarmListener&) = delete;
 
  void AddCallback(std::function<void(const AlarmNotification&)> callback) override;
 
  void RemoveCallback(std::function<void(const AlarmNotification&)> callback) override;
 
  void Start() 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);
 
  void SendAck(const AlarmNotification& alarm, std::optional<MacAddress> srcMac);
 
  void SendLayer2Ack(const Bytes& ackData, const MacAddress& dstMac, bool highPriority);
 
  void SendUdpAck(const Bytes& ackData, const sockaddr_in& dstAddr) const;
 
  AlarmEndpoint endpoint;
 
  MacAddress controllerMac{};
 
  std::atomic<bool> running{false};
 
  std::thread thread;
 
  mutable std::mutex callbacksMutex;
 
  std::vector<std::function<void(const AlarmNotification&)>> callbacks;
 
  std::uint16_t sendSeqNum = 0;
 
  std::uint16_t recvSeqNum = 0;
 
  std::unique_ptr<IRawEthernetSocket> l2Sock;
 
  int udpFd = -1;
 
  std::optional<sockaddr_in> lastUdpSrc;
};
 
} // namespace profinet