test_receivedIops.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <vector>
 
#include "profinet/cyclic.h"
 
namespace
{
constexpr std::uint8_t kIopsGood = 0x80;
constexpr std::array<std::uint8_t, 6> kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
constexpr std::array<std::uint8_t, 6> kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
constexpr std::uint16_t kProfinetEtherType = 0x8892;
} // namespace
 
namespace profinet::cyclic
{
class ReceivedIopsTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    controller = MakeController();
  }
 
  void InvokeProcessInputFrame(const Bytes& data)
  {
    controller->ProcessInputFrame(data);
  }
 
  std::unique_ptr<CyclicController> controller;
 
  [[nodiscard]] Bytes MakePayload(const Bytes& data, std::uint8_t iops) const
  {
    Bytes payload = data;
    payload.push_back(iops);
    payload.resize(40U, 0x00);
    return payload;
  }
 
  [[nodiscard]] Bytes BuildInputFrame(const Bytes& payload) const
  {
    rt::RTFrame rt;
 
    rt.frameId = 0xC001;
    rt.cycleCounter = 1;
    rt.dataStatus = rt::RTFrame::DATA_VALID | rt::RTFrame::DATA_RUN;
    rt.transferStatus = 0;
    rt.payload = payload;
 
    Bytes frame;
 
    frame.insert(frame.end(), kControllerMac.begin(), kControllerMac.end());
    frame.insert(frame.end(), kDeviceMac.begin(), kDeviceMac.end());
    frame.push_back(static_cast<std::uint8_t>(kProfinetEtherType >> 8U));
    frame.push_back(static_cast<std::uint8_t>(kProfinetEtherType & 0xFFU));
 
    const Bytes rtBytes = rt.ToBytes();
    frame.insert(frame.end(), rtBytes.begin(), rtBytes.end());
 
    return frame;
  }
 
  static std::unique_ptr<profinet::cyclic::CyclicController> MakeController()
  {
    rt::IOCRConfig input;
 
    input.typeIOCR = rt::IOCR_TYPE_INPUT;
    input.referenceIOCR = 1;
    input.frameId = 0xC001;
    input.sendClockFactor = 1;
    input.reductionRatio = 1;
    input.watchdogFactor = 3;
    input.dataLength = 40;
 
    input.objects.push_back(
        rt::IODataObject{
            .slot = 1,
            .subslot = 1,
            .frameOffset = 0,
            .dataLength = 4,
            .offsetIOPS = 4});
 
    rt::IOCRConfig output;
 
    output.typeIOCR = rt::IOCR_TYPE_OUTPUT;
    output.referenceIOCR = 2;
    output.frameId = 0xC000;
    output.sendClockFactor = 32;
    output.reductionRatio = 32;
    output.watchdogFactor = 3;
    output.dataLength = 40;
 
    output.objects.push_back(
        rt::IODataObject{
            .slot = 1,
            .subslot = 1,
            .frameOffset = 0,
            .dataLength = 4,
            .offsetIOPS = 4});
    asio::io_context ioContext;
 
    return std::make_unique<CyclicController>(
        ioContext,
        "eth0",
        kControllerMac,
        kDeviceMac,
        input,
        output);
  }
};
 
TEST_F(ReceivedIopsTest, GoodIopsDeliversInputData)
{
  const Bytes data{0xAA, 0xBB, 0xCC, 0xDD};
 
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(data, kIopsGood)));
 
  const auto inputData = controller->GetInputData(1, 1);
 
  ASSERT_TRUE(inputData.has_value());
 
  EXPECT_EQ(*inputData, data);
 
  EXPECT_TRUE(controller->IsInputGood(1, 1));
 
  const auto status = controller->GetInputStatus(1, 1);
 
  ASSERT_TRUE(status.has_value());
 
  EXPECT_EQ(*status, kIopsGood);
}
 
TEST_F(ReceivedIopsTest, DISABLED_BadIopsWithholdsStaleInputData)
{
  const Bytes data{0xAA, 0xBB, 0xCC, 0xDD};
 
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(data, kIopsGood)));
 
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(data, 0x00)));
 
  EXPECT_FALSE(controller->GetInputData(1, 1).has_value());
 
  EXPECT_FALSE(controller->IsInputGood(1, 1));
 
  const auto rawData = controller->GetInputData(1, 1, true);
 
  ASSERT_TRUE(rawData.has_value());
 
  EXPECT_EQ(*rawData, data);
}
 
TEST_F(ReceivedIopsTest, StatusCallbackFiresOnlyOnTransitions)
{
  struct Event
  {
    std::uint16_t slot;
    std::uint16_t subslot;
    std::uint8_t iops;
 
    bool operator==(const Event&) const = default;
  };
 
  std::vector<Event> events;
 
  controller->OnInputStatus([&events](std::uint16_t slot, std::uint16_t subslot, std::uint8_t iops)
  {
    events.push_back({.slot = slot, .subslot = subslot, .iops = iops});
  });
 
  const Bytes data{0x01, 0x02, 0x03, 0x04};
 
  const Bytes good = BuildInputFrame(MakePayload(data, 0x80));
 
  const Bytes bad = BuildInputFrame(MakePayload(data, 0x00));
 
  InvokeProcessInputFrame(good);
  InvokeProcessInputFrame(good);
 
  InvokeProcessInputFrame(bad);
  InvokeProcessInputFrame(bad);
 
  ASSERT_EQ(events.size(), 2U);
 
  EXPECT_EQ(events[0].slot, 1U);
  EXPECT_EQ(events[0].subslot, 1U);
  EXPECT_EQ(events[0].iops, 0x80U);
 
  EXPECT_EQ(events[1].slot, 1U);
  EXPECT_EQ(events[1].subslot, 1U);
  EXPECT_EQ(events[1].iops, 0x00U);
}
 
TEST_F(ReceivedIopsTest, InputCallbackSkipsBadData)
{
  std::vector<Bytes> delivered;
 
  controller->OnInput([&delivered](std::uint16_t, std::uint16_t, const Bytes& data)
  {
    delivered.push_back(data);
  });
 
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(Bytes{0x01, 0x02, 0x03, 0x04}, 0x80)));
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(Bytes{0x09, 0x09, 0x09, 0x09}, 0x00)));
 
  ASSERT_EQ(delivered.size(), 1U);
 
  EXPECT_EQ(delivered[0], Bytes({0x01, 0x02, 0x03, 0x04}));
}
 
TEST_F(ReceivedIopsTest, DISABLED_LowerIopsBitsDoNotAffectGoodState)
{
  auto controller = MakeController();
 
  const Bytes data{0x01, 0x02, 0x03, 0x04};
 
  InvokeProcessInputFrame(BuildInputFrame(MakePayload(data, 0x81)));
 
  EXPECT_TRUE(controller->IsInputGood(1, 1));
 
  const auto inputData = controller->GetInputData(1, 1);
 
  ASSERT_TRUE(inputData.has_value());
 
  EXPECT_EQ(*inputData, data);
}
} // namespace profinet::cyclic