cyclic.h

Go to the documentation of this file.

 
#pragma once
 
#include <asio/io_context.hpp>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <map>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <utility>
 
#include "profinet/IRawEthernetSocket.h"
#include "profinet/rt.h"
#include "profinet/util.h"
 
namespace profinet::cyclic
{
 
enum class CyclicState
{
  Idle,
  Starting,
  Running,
  Stopping,
  Stopped,
  Fault,
};
 
std::string ToString(CyclicState state);
 
struct CyclicStats
{
  std::atomic<std::uint64_t> framesSent{0};
 
  std::atomic<std::uint64_t> framesReceived{0};
 
  std::atomic<std::uint64_t> framesMissed{0};
 
  std::atomic<std::uint64_t> framesInvalid{0};
 
  std::atomic<std::uint64_t> framesDuplicate{0};
 
  std::atomic<std::uint64_t> framesOutOfOrder{0};
 
  std::atomic<std::uint32_t> lastCycleTimeUs{0};
 
  std::atomic<std::uint32_t> maxJitterUs{0};
 
  std::atomic<std::uint32_t> minCycleTimeUs{0x7FFFFFFF};
 
  std::atomic<std::uint32_t> maxCycleTimeUs{0};
 
  std::atomic<std::chrono::steady_clock::time_point> lastReceiveTime{std::chrono::steady_clock::now()};
 
  std::atomic<int> consecutiveTimeouts{0};
 
  std::atomic<std::uint64_t> cycleTimeSumUs{0};
 
  std::atomic<std::uint64_t> cycleCount{0};
 
  [[nodiscard]] std::uint64_t AvgCycleTimeUs() const
  {
    return (cycleCount != 0U) ? cycleTimeSumUs / cycleCount : 0;
  }
 
  void Reset();
};
 
struct CyclicStatsSnapshot
{
  std::uint64_t framesSent{};
  std::uint64_t framesReceived{};
  std::uint64_t framesMissed{};
  std::uint64_t framesInvalid{};
  std::uint64_t framesDuplicate{};
  std::uint64_t framesOutOfOrder{};
 
  std::uint32_t lastCycleTimeUs{};
  std::uint32_t maxJitterUs{};
  std::uint32_t minCycleTimeUs{};
  std::uint32_t maxCycleTimeUs{};
 
  std::chrono::steady_clock::time_point lastReceiveTime;
 
  int consecutiveTimeouts{};
 
  std::uint64_t cycleTimeSumUs{};
  std::uint64_t cycleCount{};
 
  [[nodiscard]] std::uint64_t AvgCycleTimeUs() const
  {
    return (cycleCount != 0U) ? cycleTimeSumUs / cycleCount : 0;
  }
};
 
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr int MIN_CYCLE_MS = 8;
inline constexpr int RECOMMENDED_CYCLE_MS = 32;
inline constexpr int DEFAULT_MAX_CONSECUTIVE_TIMEOUTS = 3;
inline constexpr int STOP_FRAME_COUNT = 3;
// NOLINTEND(readability-identifier-naming)
class ICyclicController
{
 public:
  virtual ~ICyclicController() = default;
 
  virtual void Start(std::unique_ptr<IRawEthernetSocket> tx = nullptr, std::unique_ptr<IRawEthernetSocket> rx = nullptr) = 0;
 
  virtual void Stop() = 0;
 
  [[nodiscard]] virtual bool IsRunning() const = 0;
 
  [[nodiscard]] virtual CyclicState State() const = 0;
 
  virtual void SetOutputData(int slot, int subslot, const Bytes& data) = 0;
 
  [[nodiscard]] virtual Bytes GetOutputData(int slot, int subslot) const = 0;
 
  [[nodiscard]] virtual std::optional<Bytes> GetInputData(int slot, int subslot, bool allowBad = false) const = 0;
};
 
class CyclicController : public ICyclicController
{
 public:
  friend class CyclicControllerConformanceTest;
  friend class ReceivedIopsTest;
  friend class CyclicControllerTestAccess;
  friend class CyclicTest;
 
  CyclicController(asio::io_context& ioContext, std::string interface, MacAddress srcMac, MacAddress dstMac,
                   rt::IOCRConfig inputIocr, rt::IOCRConfig outputIocr,
                   int maxConsecutiveTimeouts = DEFAULT_MAX_CONSECUTIVE_TIMEOUTS,
                   std::uint16_t etherType = rt::ETHERTYPE_PROFINET);
 
  ~CyclicController() override;
 
  CyclicController(const CyclicController&) = delete;
 
  CyclicController& operator=(const CyclicController&) = delete;
 
  void SetOutputData(int slot, int subslot, const Bytes& data) override;
 
  Bytes GetOutputData(int slot, int subslot) const override;
 
  std::optional<Bytes> GetInputData(int slot, int subslot, bool allowBad = false) const override;
 
  void OnInputStatus(std::function<void(std::uint16_t slot, std::uint16_t subslot, std::uint8_t iops)> callback);
 
  void OnInput(std::function<void(int slot, int subslot, const Bytes& data)> callback);
 
  void OnOutput(std::function<void(int cycleCounter, const Bytes& data)> callback);
 
  void OnTimeout(std::function<void()> callback);
 
  void OnError(std::function<void(const std::string&)> callback);
 
  void OnStateChange(std::function<void(CyclicState oldState, CyclicState newState)> callback);
 
  void Start(std::unique_ptr<IRawEthernetSocket> tx = nullptr, std::unique_ptr<IRawEthernetSocket> rx = nullptr) override;
 
  void Stop() override;
 
  bool IsRunning() const override
  {
    return state == CyclicState::Running;
  }
 
  CyclicState State() const override
  {
    return state;
  }
 
  const CyclicStats& Stats() const
  {
    return stats;
  }
 
  [[nodiscard]] CyclicStatsSnapshot StatsSnapshot() const;
 
  [[nodiscard]] std::optional<std::uint8_t> GetInputStatus(std::uint16_t slot, std::uint16_t subslot) const;
 
  [[nodiscard]] bool IsInputGood(std::uint16_t slot, std::uint16_t subslot) const;
 
 private:
  void Transition(CyclicState newState);
 
  void CheckCycleTime();
 
  void TxCycle();
 
  void TxLoop();
 
  void SendOutputFrame(std::optional<std::uint8_t> dataStatusOverride = std::nullopt);
 
  void SendStopFrames();
 
  void RxLoop();
 
  void HandleWatchdogTimeout();
 
  void ProcessInputFrame(const Bytes& data);
 
  [[nodiscard]] bool LocalIsInputGood(std::uint16_t slot, std::uint16_t subslot) const;
 
  std::map<std::pair<std::uint16_t, std::uint16_t>, std::uint8_t> inputStatus;
 
  void TrackCycleCounter(std::uint16_t rxCounter);
 
  asio::io_context& ioContext;
 
  std::string interface;
 
  MacAddress srcMac;
 
  MacAddress dstMac;
 
  rt::IOCRConfig inputIocr;
 
  rt::IOCRConfig outputIocr;
 
  int maxConsecutiveTimeouts;
 
  std::atomic<CyclicState> state{CyclicState::Idle};
 
  std::uint16_t etherType{rt::ETHERTYPE_PROFINET};
 
  std::atomic<bool> running{false};
 
  std::jthread txThread;
 
  std::jthread rxThread;
 
  std::unique_ptr<IRawEthernetSocket> txSock;
 
  std::unique_ptr<IRawEthernetSocket> rxSock;
 
  std::uint16_t cycleCounter = 0;
 
  rt::CyclicDataBuilder outputBuilder;
 
  mutable std::mutex inputLock;
 
  mutable std::mutex callbackMutex;
 
  std::map<std::pair<int, int>, Bytes> inputData;
 
  std::optional<std::uint16_t> lastRxCycleCounter;
 
  std::uint32_t rxCounterStep;
 
  std::uint32_t txCounterStep;
 
  std::function<void(int, int, const std::uint8_t)> onInputStatus;
 
  std::function<void(int, int, const Bytes&)> onInputData;
 
  std::function<void(int, const Bytes&)> onOutputData;
 
  std::function<void()> onTimeout;
 
  std::function<void(const std::string&)> onError;
 
  std::function<void(CyclicState, CyclicState)> onStateChange;
 
  CyclicStats stats;
 
  bool iocsGood;
};
 
} // namespace profinet::cyclic