move HAL and tests folder

src/fsfw_tests/integration/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_subdirectory(assemblies)
+add_subdirectory(controller)
+add_subdirectory(devices)
+add_subdirectory(task)

src/fsfw_tests/integration/assemblies/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    TestAssembly.cpp
+)

src/fsfw_tests/integration/assemblies/TestAssembly.cpp

@@ -0,0 +1,180 @@
+#include "TestAssembly.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+
+TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+                           object_id_t testDevice1)
+    : AssemblyBase(objectId, parentId),
+      deviceHandler0Id(testDevice0),
+      deviceHandler1Id(testDevice1) {
+  ModeListEntry newModeListEntry;
+  newModeListEntry.setObject(testDevice0);
+  newModeListEntry.setMode(MODE_OFF);
+  newModeListEntry.setSubmode(SUBMODE_NONE);
+
+  commandTable.insert(newModeListEntry);
+
+  newModeListEntry.setObject(testDevice1);
+  newModeListEntry.setMode(MODE_OFF);
+  newModeListEntry.setSubmode(SUBMODE_NONE);
+
+  commandTable.insert(newModeListEntry);
+}
+
+TestAssembly::~TestAssembly() {}
+
+ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "TestAssembly: Received command to go to mode " << mode << " submode "
+            << (int)submode << std::endl;
+#else
+  sif::printInfo("TestAssembly: Received command to go to mode %d submode %d\n", mode, submode);
+#endif
+  ReturnValue_t result = RETURN_OK;
+  if (mode == MODE_OFF) {
+    commandTable[0].setMode(MODE_OFF);
+    commandTable[0].setSubmode(SUBMODE_NONE);
+    commandTable[1].setMode(MODE_OFF);
+    commandTable[1].setSubmode(SUBMODE_NONE);
+  } else if (mode == DeviceHandlerIF::MODE_NORMAL) {
+    if (submode == submodes::SINGLE) {
+      commandTable[0].setMode(MODE_OFF);
+      commandTable[0].setSubmode(SUBMODE_NONE);
+      commandTable[1].setMode(MODE_OFF);
+      commandTable[1].setSubmode(SUBMODE_NONE);
+      // We try to prefer 0 here but we try to switch to 1 even if it might fail
+      if (isDeviceAvailable(deviceHandler0Id)) {
+        if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+          commandTable[0].setMode(mode);
+          commandTable[0].setSubmode(SUBMODE_NONE);
+        } else {
+          commandTable[0].setMode(MODE_ON);
+          commandTable[0].setSubmode(SUBMODE_NONE);
+          result = NEED_SECOND_STEP;
+        }
+      } else {
+        if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+          commandTable[1].setMode(mode);
+          commandTable[1].setSubmode(SUBMODE_NONE);
+        } else {
+          commandTable[1].setMode(MODE_ON);
+          commandTable[1].setSubmode(SUBMODE_NONE);
+          result = NEED_SECOND_STEP;
+        }
+      }
+    } else {
+      // Dual Mode Normal
+      if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+        commandTable[0].setMode(mode);
+        commandTable[0].setSubmode(SUBMODE_NONE);
+      } else {
+        commandTable[0].setMode(MODE_ON);
+        commandTable[0].setSubmode(SUBMODE_NONE);
+        result = NEED_SECOND_STEP;
+      }
+      if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+        commandTable[1].setMode(mode);
+        commandTable[1].setSubmode(SUBMODE_NONE);
+      } else {
+        commandTable[1].setMode(MODE_ON);
+        commandTable[1].setSubmode(SUBMODE_NONE);
+        result = NEED_SECOND_STEP;
+      }
+    }
+  } else {
+    // Mode ON
+    if (submode == submodes::SINGLE) {
+      commandTable[0].setMode(MODE_OFF);
+      commandTable[0].setSubmode(SUBMODE_NONE);
+      commandTable[1].setMode(MODE_OFF);
+      commandTable[1].setSubmode(SUBMODE_NONE);
+      // We try to prefer 0 here but we try to switch to 1 even if it might fail
+      if (isDeviceAvailable(deviceHandler0Id)) {
+        commandTable[0].setMode(MODE_ON);
+        commandTable[0].setSubmode(SUBMODE_NONE);
+      } else {
+        commandTable[1].setMode(MODE_ON);
+        commandTable[1].setSubmode(SUBMODE_NONE);
+      }
+    } else {
+      commandTable[0].setMode(MODE_ON);
+      commandTable[0].setSubmode(SUBMODE_NONE);
+      commandTable[1].setMode(MODE_ON);
+      commandTable[1].setSubmode(SUBMODE_NONE);
+    }
+  }
+
+  HybridIterator<ModeListEntry> iter(commandTable.begin(), commandTable.end());
+  executeTable(iter);
+  return result;
+}
+
+ReturnValue_t TestAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  switch (mode) {
+    case MODE_OFF:
+      if (submode == SUBMODE_NONE) {
+        return RETURN_OK;
+      } else {
+        return INVALID_SUBMODE;
+      }
+    case DeviceHandlerIF::MODE_NORMAL:
+    case MODE_ON:
+      if (submode < 3) {
+        return RETURN_OK;
+      } else {
+        return INVALID_SUBMODE;
+      }
+  }
+  return INVALID_MODE;
+}
+
+ReturnValue_t TestAssembly::initialize() {
+  ReturnValue_t result = AssemblyBase::initialize();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  handler0 = ObjectManager::instance()->get<TestDevice>(deviceHandler0Id);
+  handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1Id);
+  if ((handler0 == nullptr) or (handler1 == nullptr)) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  handler0->setParentQueue(this->getCommandQueue());
+  handler1->setParentQueue(this->getCommandQueue());
+
+  result = registerChild(deviceHandler0Id);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(deviceHandler1Id);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t TestAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  if (submode == submodes::DUAL) {
+    for (const auto& info : childrenMap) {
+      if (info.second.mode != wantedMode or info.second.mode != wantedSubmode) {
+        return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+      }
+    }
+    return RETURN_OK;
+  } else if (submode == submodes::SINGLE) {
+    for (const auto& info : childrenMap) {
+      if (info.second.mode == wantedMode and info.second.mode != wantedSubmode) {
+        return RETURN_OK;
+      }
+    }
+  }
+  return INVALID_SUBMODE;
+}
+
+bool TestAssembly::isDeviceAvailable(object_id_t object) {
+  if (healthHelper.healthTable->getHealth(object) == HasHealthIF::HEALTHY) {
+    return true;
+  } else {
+    return false;
+  }
+}

src/fsfw_tests/integration/assemblies/TestAssembly.h

@@ -0,0 +1,52 @@
+#ifndef MISSION_ASSEMBLIES_TESTASSEMBLY_H_
+#define MISSION_ASSEMBLIES_TESTASSEMBLY_H_
+
+#include <fsfw/devicehandlers/AssemblyBase.h>
+
+#include "../devices/TestDeviceHandler.h"
+
+class TestAssembly : public AssemblyBase {
+ public:
+  TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+               object_id_t testDevice1);
+  virtual ~TestAssembly();
+  ReturnValue_t initialize() override;
+
+  enum submodes : Submode_t { SINGLE = 0, DUAL = 1 };
+
+ protected:
+  /**
+   * Command children to reach [mode,submode] combination
+   * Can be done by setting #commandsOutstanding correctly,
+   * or using executeTable()
+   * @param mode
+   * @param submode
+   * @return
+   *    - @c RETURN_OK if ok
+   *    - @c NEED_SECOND_STEP if children need to be commanded again
+   */
+  ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
+  /**
+   * Check whether desired assembly mode was achieved by checking the modes
+   * or/and health states of child device handlers.
+   * The assembly template class will also call this function if a health
+   * or mode change of a child device handler was detected.
+   * @param wantedMode
+   * @param wantedSubmode
+   * @return
+   */
+  ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) override;
+
+  ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
+
+ private:
+  FixedArrayList<ModeListEntry, 2> commandTable;
+  object_id_t deviceHandler0Id = 0;
+  object_id_t deviceHandler1Id = 0;
+  TestDevice* handler0 = nullptr;
+  TestDevice* handler1 = nullptr;
+
+  bool isDeviceAvailable(object_id_t object);
+};
+
+#endif /* MISSION_ASSEMBLIES_TESTASSEMBLY_H_ */

src/fsfw_tests/integration/controller/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    TestController.cpp
+)

src/fsfw_tests/integration/controller/TestController.cpp

@@ -0,0 +1,37 @@
+#include "TestController.h"
+
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+TestController::TestController(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth)
+    : ExtendedControllerBase(objectId, parentId, commandQueueDepth) {}
+
+TestController::~TestController() {}
+
+ReturnValue_t TestController::handleCommandMessage(CommandMessage *message) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TestController::performControlOperation() {}
+
+void TestController::handleChangedDataset(sid_t sid, store_address_t storeId, bool *clearMessage) {}
+
+void TestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                               bool *clearMessage) {}
+
+LocalPoolDataSetBase *TestController::getDataSetHandle(sid_t sid) { return nullptr; }
+
+ReturnValue_t TestController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                      LocalDataPoolManager &poolManager) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TestController::initializeAfterTaskCreation() {
+  return ExtendedControllerBase::initializeAfterTaskCreation();
+}
+
+ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode,
+                                               uint32_t *msToReachTheMode) {
+  return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw_tests/integration/controller/TestController.h

@@ -0,0 +1,36 @@
+#ifndef MISSION_CONTROLLER_TESTCONTROLLER_H_
+#define MISSION_CONTROLLER_TESTCONTROLLER_H_
+
+#include <fsfw/controller/ExtendedControllerBase.h>
+
+#include "../devices/devicedefinitions/testDeviceDefinitions.h"
+
+class TestController : public ExtendedControllerBase {
+ public:
+  TestController(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 10);
+  virtual ~TestController();
+
+ protected:
+  // Extended Controller Base overrides
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  void performControlOperation() override;
+
+  // HasLocalDatapoolIF callbacks
+  virtual void handleChangedDataset(sid_t sid, store_address_t storeId,
+                                    bool* clearMessage) override;
+  virtual void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                         bool* clearMessage) override;
+
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+
+  ReturnValue_t initializeAfterTaskCreation() override;
+
+ private:
+};
+
+#endif /* MISSION_CONTROLLER_TESTCONTROLLER_H_ */

src/fsfw_tests/integration/controller/ctrldefinitions/testCtrlDefinitions.h

@@ -0,0 +1,16 @@
+#ifndef MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_
+#define MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_
+
+#include <OBSWConfig.h>
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace testcontroller {
+
+enum sourceObjectIds : object_id_t {
+  DEVICE_0_ID = objects::TEST_DEVICE_HANDLER_0,
+  DEVICE_1_ID = objects::TEST_DEVICE_HANDLER_1,
+};
+
+}
+
+#endif /* MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_ */

src/fsfw_tests/integration/devices/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    TestCookie.cpp
+    TestDeviceHandler.cpp
+    TestEchoComIF.cpp
+)

src/fsfw_tests/integration/devices/TestCookie.cpp

@@ -0,0 +1,10 @@
+#include "TestCookie.h"
+
+TestCookie::TestCookie(address_t address, size_t replyMaxLen)
+    : address(address), replyMaxLen(replyMaxLen) {}
+
+TestCookie::~TestCookie() {}
+
+address_t TestCookie::getAddress() const { return address; }
+
+size_t TestCookie::getReplyMaxLen() const { return replyMaxLen; }

src/fsfw_tests/integration/devices/TestCookie.h

@@ -0,0 +1,24 @@
+#ifndef MISSION_DEVICES_TESTCOOKIE_H_
+#define MISSION_DEVICES_TESTCOOKIE_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+
+#include <cstddef>
+
+/**
+ * @brief	Really simple cookie which does not do a lot.
+ */
+class TestCookie : public CookieIF {
+ public:
+  TestCookie(address_t address, size_t maxReplyLen);
+  virtual ~TestCookie();
+
+  address_t getAddress() const;
+  size_t getReplyMaxLen() const;
+
+ private:
+  address_t address = 0;
+  size_t replyMaxLen = 0;
+};
+
+#endif /* MISSION_DEVICES_TESTCOOKIE_H_ */

src/fsfw_tests/integration/devices/TestDeviceHandler.cpp

@@ -0,0 +1,793 @@
+#include "TestDeviceHandler.h"
+
+#include <cstdlib>
+
+#include "FSFWConfig.h"
+#include "fsfw/datapool/PoolReadGuard.h"
+
+TestDevice::TestDevice(object_id_t objectId, object_id_t comIF, CookieIF* cookie,
+                       testdevice::DeviceIndex deviceIdx, bool fullInfoPrintout,
+                       bool changingDataset)
+    : DeviceHandlerBase(objectId, comIF, cookie),
+      deviceIdx(deviceIdx),
+      dataset(this),
+      fullInfoPrintout(fullInfoPrintout) {}
+
+TestDevice::~TestDevice() = default;
+
+void TestDevice::performOperationHook() {
+  if (periodicPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx << "::performOperationHook: Alive!" << std::endl;
+#else
+    sif::printInfo("TestDevice%d::performOperationHook: Alive!\n", deviceIdx);
+#endif
+  }
+
+  if (oneShot) {
+    oneShot = false;
+  }
+}
+
+void TestDevice::doStartUp() {
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx << "::doStartUp: Switching On" << std::endl;
+#else
+    sif::printInfo("TestDevice%d::doStartUp: Switching On\n", static_cast<int>(deviceIdx));
+#endif
+  }
+
+  setMode(_MODE_TO_ON);
+  return;
+}
+
+void TestDevice::doShutDown() {
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx << "::doShutDown: Switching Off" << std::endl;
+#else
+    sif::printInfo("TestDevice%d::doShutDown: Switching Off\n", static_cast<int>(deviceIdx));
+#endif
+  }
+
+  setMode(_MODE_SHUT_DOWN);
+  return;
+}
+
+ReturnValue_t TestDevice::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+  using namespace testdevice;
+  *id = TEST_NORMAL_MODE_CMD;
+  if (DeviceHandlerBase::isAwaitingReply()) {
+    return NOTHING_TO_SEND;
+  }
+  return buildCommandFromCommand(*id, nullptr, 0);
+}
+
+ReturnValue_t TestDevice::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+  if (mode == _MODE_TO_ON) {
+    if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "TestDevice" << deviceIdx
+                << "::buildTransitionDeviceCommand: Was called"
+                   " from _MODE_TO_ON mode"
+                << std::endl;
+#else
+      sif::printInfo(
+          "TestDevice%d::buildTransitionDeviceCommand: "
+          "Was called from _MODE_TO_ON mode\n",
+          deviceIdx);
+#endif
+    }
+  }
+  if (mode == _MODE_TO_NORMAL) {
+    if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "TestDevice" << deviceIdx
+                << "::buildTransitionDeviceCommand: Was called "
+                   "from _MODE_TO_NORMAL mode"
+                << std::endl;
+#else
+      sif::printInfo(
+          "TestDevice%d::buildTransitionDeviceCommand: Was called from "
+          " _MODE_TO_NORMAL mode\n",
+          deviceIdx);
+#endif
+    }
+
+    setMode(MODE_NORMAL);
+  }
+  if (mode == _MODE_SHUT_DOWN) {
+    if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "TestDevice" << deviceIdx
+                << "::buildTransitionDeviceCommand: Was called "
+                   "from _MODE_SHUT_DOWN mode"
+                << std::endl;
+#else
+      sif::printInfo(
+          "TestDevice%d::buildTransitionDeviceCommand: Was called from "
+          "_MODE_SHUT_DOWN mode\n",
+          deviceIdx);
+#endif
+    }
+
+    setMode(MODE_OFF);
+  }
+  return NOTHING_TO_SEND;
+}
+
+void TestDevice::doTransition(Mode_t modeFrom, Submode_t submodeFrom) {
+  if (mode == _MODE_TO_NORMAL) {
+    if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "TestDevice" << deviceIdx
+                << "::doTransition: Custom transition to "
+                   "normal mode"
+                << std::endl;
+#else
+      sif::printInfo("TestDevice%d::doTransition: Custom transition to normal mode\n", deviceIdx);
+#endif
+    }
+
+  } else {
+    DeviceHandlerBase::doTransition(modeFrom, submodeFrom);
+  }
+}
+
+ReturnValue_t TestDevice::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                  const uint8_t* commandData,
+                                                  size_t commandDataLen) {
+  using namespace testdevice;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  switch (deviceCommand) {
+    case (TEST_NORMAL_MODE_CMD): {
+      commandSent = true;
+      result = buildNormalModeCommand(deviceCommand, commandData, commandDataLen);
+      break;
+    }
+
+    case (TEST_COMMAND_0): {
+      commandSent = true;
+      result = buildTestCommand0(deviceCommand, commandData, commandDataLen);
+      break;
+    }
+
+    case (TEST_COMMAND_1): {
+      commandSent = true;
+      result = buildTestCommand1(deviceCommand, commandData, commandDataLen);
+      break;
+    }
+    case (TEST_NOTIF_SNAPSHOT_VAR): {
+      if (changingDatasets) {
+        changingDatasets = false;
+      }
+
+      PoolReadGuard readHelper(&dataset.testUint8Var);
+      if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
+        /* This will trigger a variable notification to the demo controller */
+        dataset.testUint8Var = 220;
+        dataset.testUint8Var.setValid(true);
+      } else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
+        /* This will trigger a variable snapshot to the demo controller */
+        dataset.testUint8Var = 30;
+        dataset.testUint8Var.setValid(true);
+      }
+
+      break;
+    }
+    case (TEST_NOTIF_SNAPSHOT_SET): {
+      if (changingDatasets) {
+        changingDatasets = false;
+      }
+
+      PoolReadGuard readHelper(&dataset.testFloat3Vec);
+
+      if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
+        /* This will trigger a variable notification to the demo controller */
+        dataset.testFloat3Vec.value[0] = 60;
+        dataset.testFloat3Vec.value[1] = 70;
+        dataset.testFloat3Vec.value[2] = 55;
+        dataset.testFloat3Vec.setValid(true);
+      } else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
+        /* This will trigger a variable notification to the demo controller */
+        dataset.testFloat3Vec.value[0] = -60;
+        dataset.testFloat3Vec.value[1] = -70;
+        dataset.testFloat3Vec.value[2] = -55;
+        dataset.testFloat3Vec.setValid(true);
+      }
+      break;
+    }
+    default:
+      result = DeviceHandlerIF::COMMAND_NOT_SUPPORTED;
+  }
+  return result;
+}
+
+ReturnValue_t TestDevice::buildNormalModeCommand(DeviceCommandId_t deviceCommand,
+                                                 const uint8_t* commandData,
+                                                 size_t commandDataLen) {
+  if (fullInfoPrintout) {
+#if FSFW_VERBOSE_LEVEL >= 3
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice::buildTestCommand1: Building normal command" << std::endl;
+#else
+    sif::printInfo("TestDevice::buildTestCommand1: Building command from TEST_COMMAND_1\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* OBSW_VERBOSE_LEVEL >= 3 */
+  }
+
+  if (commandDataLen > MAX_BUFFER_SIZE - sizeof(DeviceCommandId_t)) {
+    return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
+  }
+  /* The command is passed on in the command buffer as it is */
+  passOnCommand(deviceCommand, commandData, commandDataLen);
+  return RETURN_OK;
+}
+
+ReturnValue_t TestDevice::buildTestCommand0(DeviceCommandId_t deviceCommand,
+                                            const uint8_t* commandData, size_t commandDataLen) {
+  using namespace testdevice;
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx
+              << "::buildTestCommand0: Executing simple command "
+                 " with completion reply"
+              << std::endl;
+#else
+    sif::printInfo(
+        "TestDevice%d::buildTestCommand0: Executing simple command with "
+        "completion reply\n",
+        deviceIdx);
+#endif
+  }
+
+  if (commandDataLen > MAX_BUFFER_SIZE - sizeof(DeviceCommandId_t)) {
+    return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
+  }
+
+  /* The command is passed on in the command buffer as it is */
+  passOnCommand(deviceCommand, commandData, commandDataLen);
+  return RETURN_OK;
+}
+
+ReturnValue_t TestDevice::buildTestCommand1(DeviceCommandId_t deviceCommand,
+                                            const uint8_t* commandData, size_t commandDataLen) {
+  using namespace testdevice;
+  if (commandDataLen < 7) {
+    return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
+  }
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx
+              << "::buildTestCommand1: Executing command with "
+                 "data reply"
+              << std::endl;
+#else
+    sif::printInfo("TestDevice%d:buildTestCommand1: Executing command with data reply\n",
+                   deviceIdx);
+#endif
+  }
+
+  deviceCommand = EndianConverter::convertBigEndian(deviceCommand);
+  memcpy(commandBuffer, &deviceCommand, sizeof(deviceCommand));
+
+  /* Assign and check parameters */
+  uint16_t parameter1 = 0;
+  size_t size = commandDataLen;
+  ReturnValue_t result =
+      SerializeAdapter::deSerialize(&parameter1, &commandData, &size, SerializeIF::Endianness::BIG);
+  if (result == HasReturnvaluesIF::RETURN_FAILED) {
+    return result;
+  }
+
+  /* Parameter 1 needs to be correct */
+  if (parameter1 != testdevice::COMMAND_1_PARAM1) {
+    return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+  }
+  uint64_t parameter2 = 0;
+  result =
+      SerializeAdapter::deSerialize(&parameter2, &commandData, &size, SerializeIF::Endianness::BIG);
+  if (parameter2 != testdevice::COMMAND_1_PARAM2) {
+    return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+  }
+
+  /* Pass on the parameters to the Echo IF */
+  commandBuffer[4] = (parameter1 & 0xFF00) >> 8;
+  commandBuffer[5] = (parameter1 & 0xFF);
+  parameter2 = EndianConverter::convertBigEndian(parameter2);
+  memcpy(commandBuffer + 6, &parameter2, sizeof(parameter2));
+  rawPacket = commandBuffer;
+  rawPacketLen = sizeof(deviceCommand) + sizeof(parameter1) + sizeof(parameter2);
+  return RETURN_OK;
+}
+
+void TestDevice::passOnCommand(DeviceCommandId_t command, const uint8_t* commandData,
+                               size_t commandDataLen) {
+  DeviceCommandId_t deviceCommandBe = EndianConverter::convertBigEndian(command);
+  memcpy(commandBuffer, &deviceCommandBe, sizeof(deviceCommandBe));
+  memcpy(commandBuffer + 4, commandData, commandDataLen);
+  rawPacket = commandBuffer;
+  rawPacketLen = sizeof(deviceCommandBe) + commandDataLen;
+}
+
+void TestDevice::fillCommandAndReplyMap() {
+  namespace td = testdevice;
+  insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5, &dataset);
+  insertInCommandAndReplyMap(testdevice::TEST_COMMAND_0, 5);
+  insertInCommandAndReplyMap(testdevice::TEST_COMMAND_1, 5);
+
+  /* No reply expected for these commands */
+  insertInCommandMap(td::TEST_NOTIF_SNAPSHOT_SET);
+  insertInCommandMap(td::TEST_NOTIF_SNAPSHOT_VAR);
+}
+
+ReturnValue_t TestDevice::scanForReply(const uint8_t* start, size_t len, DeviceCommandId_t* foundId,
+                                       size_t* foundLen) {
+  using namespace testdevice;
+
+  /* Unless a command was sent explicitely, we don't expect any replies and ignore this
+  the packet. On a real device, there might be replies which are sent without a previous
+  command. */
+  if (not commandSent) {
+    return DeviceHandlerBase::IGNORE_FULL_PACKET;
+  } else {
+    commandSent = false;
+  }
+
+  if (len < sizeof(object_id_t)) {
+    return DeviceHandlerIF::LENGTH_MISSMATCH;
+  }
+
+  size_t size = len;
+  ReturnValue_t result =
+      SerializeAdapter::deSerialize(foundId, &start, &size, SerializeIF::Endianness::BIG);
+  if (result != RETURN_OK) {
+    return result;
+  }
+
+  DeviceCommandId_t pendingCmd = this->getPendingCommand();
+
+  switch (pendingCmd) {
+    case (TEST_NORMAL_MODE_CMD): {
+      if (fullInfoPrintout) {
+#if FSFW_VERBOSE_LEVEL >= 3
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice::scanForReply: Reply for normal commnand (ID "
+                  << TEST_NORMAL_MODE_CMD << ") received!" << std::endl;
+#else
+        sif::printInfo(
+            "TestDevice%d::scanForReply: Reply for normal command (ID %d) "
+            "received!\n",
+            deviceIdx, TEST_NORMAL_MODE_CMD);
+#endif
+#endif
+      }
+
+      *foundLen = len;
+      *foundId = pendingCmd;
+      return RETURN_OK;
+    }
+
+    case (TEST_COMMAND_0): {
+      if (len < TEST_COMMAND_0_SIZE) {
+        return DeviceHandlerIF::LENGTH_MISSMATCH;
+      }
+      if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice" << deviceIdx
+                  << "::scanForReply: Reply for simple command "
+                     "(ID "
+                  << TEST_COMMAND_0 << ") received!" << std::endl;
+#else
+        sif::printInfo(
+            "TestDevice%d::scanForReply: Reply for simple command (ID %d) "
+            "received!\n",
+            deviceIdx, TEST_COMMAND_0);
+#endif
+      }
+
+      *foundLen = TEST_COMMAND_0_SIZE;
+      *foundId = pendingCmd;
+      return RETURN_OK;
+    }
+
+    case (TEST_COMMAND_1): {
+      if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice" << deviceIdx
+                  << "::scanForReply: Reply for data command "
+                     "(ID "
+                  << TEST_COMMAND_1 << ") received!" << std::endl;
+#else
+        sif::printInfo(
+            "TestDevice%d::scanForReply: Reply for data command (ID %d) "
+            "received\n",
+            deviceIdx, TEST_COMMAND_1);
+#endif
+      }
+
+      *foundLen = len;
+      *foundId = pendingCmd;
+      return RETURN_OK;
+    }
+
+    default:
+      return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+  }
+}
+
+ReturnValue_t TestDevice::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  switch (id) {
+    /* Periodic replies */
+    case testdevice::TEST_NORMAL_MODE_CMD: {
+      result = interpretingNormalModeReply();
+      break;
+    }
+    /* Simple reply */
+    case testdevice::TEST_COMMAND_0: {
+      result = interpretingTestReply0(id, packet);
+      break;
+    }
+    /* Data reply */
+    case testdevice::TEST_COMMAND_1: {
+      result = interpretingTestReply1(id, packet);
+      break;
+    }
+    default:
+      return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+  }
+  return result;
+}
+
+ReturnValue_t TestDevice::interpretingNormalModeReply() {
+  CommandMessage directReplyMessage;
+  if (changingDatasets) {
+    PoolReadGuard readHelper(&dataset);
+    if (dataset.testUint8Var.value == 0) {
+      dataset.testUint8Var.value = 10;
+      dataset.testUint32Var.value = 777;
+      dataset.testFloat3Vec.value[0] = 2.5;
+      dataset.testFloat3Vec.value[1] = -2.5;
+      dataset.testFloat3Vec.value[2] = 2.5;
+      dataset.setValidity(true, true);
+    } else {
+      dataset.testUint8Var.value = 0;
+      dataset.testUint32Var.value = 0;
+      dataset.testFloat3Vec.value[0] = 0.0;
+      dataset.testFloat3Vec.value[1] = 0.0;
+      dataset.testFloat3Vec.value[2] = 0.0;
+      dataset.setValidity(false, true);
+    }
+    return RETURN_OK;
+  }
+
+  PoolReadGuard readHelper(&dataset);
+  if (dataset.testUint8Var.value == 0) {
+    /* Reset state */
+    dataset.testUint8Var.value = 128;
+  } else if (dataset.testUint8Var.value > 200) {
+    if (not resetAfterChange) {
+      /* This will trigger an update notification to the controller */
+      dataset.testUint8Var.setChanged(true);
+      resetAfterChange = true;
+      /* Decrement by 30 automatically. This will prevent any additional notifications. */
+      dataset.testUint8Var.value -= 30;
+    }
+  }
+  /* If the value is greater than 0, it will be decremented in a linear way */
+  else if (dataset.testUint8Var.value > 128) {
+    size_t sizeToDecrement = 0;
+    if (dataset.testUint8Var.value > 128 + 30) {
+      sizeToDecrement = 30;
+    } else {
+      sizeToDecrement = dataset.testUint8Var.value - 128;
+      resetAfterChange = false;
+    }
+    dataset.testUint8Var.value -= sizeToDecrement;
+  } else if (dataset.testUint8Var.value < 50) {
+    if (not resetAfterChange) {
+      /* This will trigger an update snapshot to the controller */
+      dataset.testUint8Var.setChanged(true);
+      resetAfterChange = true;
+    } else {
+      /* Increment by 30 automatically. */
+      dataset.testUint8Var.value += 30;
+    }
+  }
+  /* Increment in linear way */
+  else if (dataset.testUint8Var.value < 128) {
+    size_t sizeToIncrement = 0;
+    if (dataset.testUint8Var.value < 128 - 20) {
+      sizeToIncrement = 20;
+    } else {
+      sizeToIncrement = 128 - dataset.testUint8Var.value;
+      resetAfterChange = false;
+    }
+    dataset.testUint8Var.value += sizeToIncrement;
+  }
+
+  /* TODO: Same for vector */
+  float vectorMean = (dataset.testFloat3Vec.value[0] + dataset.testFloat3Vec.value[1] +
+                      dataset.testFloat3Vec.value[2]) /
+                     3.0;
+
+  /* Lambda (private local function) */
+  auto sizeToAdd = [](bool tooHigh, float currentVal) {
+    if (tooHigh) {
+      if (currentVal - 20.0 > 10.0) {
+        return -10.0;
+      } else {
+        return 20.0 - currentVal;
+      }
+    } else {
+      if (std::abs(currentVal + 20.0) > 10.0) {
+        return 10.0;
+      } else {
+        return -20.0 - currentVal;
+      }
+    }
+  };
+
+  if (vectorMean > 20.0 and std::abs(vectorMean - 20.0) > 1.0) {
+    if (not resetAfterChange) {
+      dataset.testFloat3Vec.setChanged(true);
+      resetAfterChange = true;
+    } else {
+      float sizeToDecrementVal0 = 0;
+      float sizeToDecrementVal1 = 0;
+      float sizeToDecrementVal2 = 0;
+
+      sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec.value[0]);
+      sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec.value[1]);
+      sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec.value[2]);
+
+      dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
+      dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
+      dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
+    }
+  } else if (vectorMean < -20.0 and std::abs(vectorMean + 20.0) < 1.0) {
+    if (not resetAfterChange) {
+      dataset.testFloat3Vec.setChanged(true);
+      resetAfterChange = true;
+    } else {
+      float sizeToDecrementVal0 = 0;
+      float sizeToDecrementVal1 = 0;
+      float sizeToDecrementVal2 = 0;
+
+      sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec.value[0]);
+      sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec.value[1]);
+      sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec.value[2]);
+
+      dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
+      dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
+      dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
+    }
+  } else {
+    if (resetAfterChange) {
+      resetAfterChange = false;
+    }
+  }
+
+  return RETURN_OK;
+}
+
+ReturnValue_t TestDevice::interpretingTestReply0(DeviceCommandId_t id, const uint8_t* packet) {
+  CommandMessage commandMessage;
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice::interpretingTestReply0: Generating step and finish reply"
+              << std::endl;
+#else
+    sif::printInfo("TestDevice::interpretingTestReply0: Generating step and finish reply\n");
+#endif
+  }
+
+  MessageQueueId_t commander = getCommanderQueueId(id);
+  /* Generate one step reply and the finish reply */
+  actionHelper.step(1, commander, id);
+  actionHelper.finish(true, commander, id);
+
+  return RETURN_OK;
+}
+
+ReturnValue_t TestDevice::interpretingTestReply1(DeviceCommandId_t id, const uint8_t* packet) {
+  CommandMessage directReplyMessage;
+  if (fullInfoPrintout) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestDevice" << deviceIdx << "::interpretingReply1: Setting data reply"
+              << std::endl;
+#else
+    sif::printInfo("TestDevice%d::interpretingReply1: Setting data reply\n", deviceIdx);
+#endif
+  }
+
+  MessageQueueId_t commander = getCommanderQueueId(id);
+  /* Send reply with data */
+  ReturnValue_t result =
+      actionHelper.reportData(commander, id, packet, testdevice::TEST_COMMAND_1_SIZE, false);
+
+  if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TestDevice" << deviceIdx
+               << "::interpretingReply1: Sending data "
+                  "reply failed!"
+               << std::endl;
+#else
+    sif::printError("TestDevice%d::interpretingReply1: Sending data reply failed!\n", deviceIdx);
+#endif
+    return result;
+  }
+
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    /* Finish reply */
+    actionHelper.finish(true, commander, id);
+  } else {
+    /* Finish reply */
+    actionHelper.finish(false, commander, id, result);
+  }
+
+  return RETURN_OK;
+}
+
+uint32_t TestDevice::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 5000; }
+
+void TestDevice::enableFullDebugOutput(bool enable) { this->fullInfoPrintout = enable; }
+
+ReturnValue_t TestDevice::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                  LocalDataPoolManager& poolManager) {
+  namespace td = testdevice;
+  localDataPoolMap.emplace(td::PoolIds::TEST_UINT8_ID, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(td::PoolIds::TEST_UINT32_ID, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(td::PoolIds::TEST_FLOAT_VEC_3_ID, new PoolEntry<float>({0.0, 0.0, 0.0}));
+
+  sid_t sid(this->getObjectId(), td::TEST_SET_ID);
+  /* Subscribe for periodic HK packets but do not enable reporting for now.
+  Non-diangostic with a period of one second */
+  poolManager.subscribeForPeriodicPacket(sid, false, 1.0, false);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
+                                       ParameterWrapper* parameterWrapper,
+                                       const ParameterWrapper* newValues, uint16_t startAtIndex) {
+  using namespace testdevice;
+  switch (uniqueId) {
+    case ParameterUniqueIds::TEST_UINT32_0: {
+      if (fullInfoPrintout) {
+        uint32_t newValue = 0;
+        ReturnValue_t result = newValues->getElement<uint32_t>(&newValue, 0, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::info << "TestDevice" << deviceIdx
+                    << "::getParameter: Setting parameter 0 to "
+                       "new value "
+                    << newValue << std::endl;
+#else
+          sif::printInfo("TestDevice%d::getParameter: Setting parameter 0 to new value %lu\n",
+                         deviceIdx, static_cast<unsigned long>(newValue));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        }
+      }
+      parameterWrapper->set(testParameter0);
+      break;
+    }
+    case ParameterUniqueIds::TEST_INT32_1: {
+      if (fullInfoPrintout) {
+        int32_t newValue = 0;
+        ReturnValue_t result = newValues->getElement<int32_t>(&newValue, 0, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::info << "TestDevice" << deviceIdx
+                    << "::getParameter: Setting parameter 1 to "
+                       "new value "
+                    << newValue << std::endl;
+#else
+          sif::printInfo("TestDevice%d::getParameter: Setting parameter 1 to new value %lu\n",
+                         deviceIdx, static_cast<unsigned long>(newValue));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        }
+      }
+      parameterWrapper->set(testParameter1);
+      break;
+    }
+    case ParameterUniqueIds::TEST_FLOAT_VEC3_2: {
+      if (fullInfoPrintout) {
+        float newVector[3];
+        if (newValues->getElement<float>(newVector, 0, 0) != RETURN_OK or
+            newValues->getElement<float>(newVector + 1, 0, 1) != RETURN_OK or
+            newValues->getElement<float>(newVector + 2, 0, 2) != RETURN_OK) {
+          return HasReturnvaluesIF::RETURN_FAILED;
+        }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice" << deviceIdx
+                  << "::getParameter: Setting parameter 3 to "
+                     "(float vector with 3 entries) to new values ["
+                  << newVector[0] << ", " << newVector[1] << ", " << newVector[2] << "]"
+                  << std::endl;
+#else
+        sif::printInfo(
+            "TestDevice%d::getParameter: Setting parameter 3 to new values "
+            "[%f, %f, %f]\n",
+            deviceIdx, newVector[0], newVector[1], newVector[2]);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      }
+      parameterWrapper->setVector(vectorFloatParams2);
+      break;
+    }
+    case (ParameterUniqueIds::PERIODIC_PRINT_ENABLED): {
+      if (fullInfoPrintout) {
+        uint8_t enabled = 0;
+        ReturnValue_t result = newValues->getElement<uint8_t>(&enabled, 0, 0);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+          return result;
+        }
+        char const* printout = nullptr;
+        if (enabled) {
+          printout = "enabled";
+        } else {
+          printout = "disabled";
+        }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice" << deviceIdx << "::getParameter: Periodic printout " << printout
+                  << std::endl;
+#else
+        sif::printInfo("TestDevice%d::getParameter: Periodic printout %s", printout);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      }
+
+      parameterWrapper->set(periodicPrintout);
+      break;
+    }
+    case (ParameterUniqueIds::CHANGING_DATASETS): {
+      uint8_t enabled = 0;
+      ReturnValue_t result = newValues->getElement<uint8_t>(&enabled, 0, 0);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      if (not enabled) {
+        PoolReadGuard readHelper(&dataset);
+        dataset.testUint8Var.value = 0;
+        dataset.testUint32Var.value = 0;
+        dataset.testFloat3Vec.value[0] = 0.0;
+        dataset.testFloat3Vec.value[0] = 0.0;
+        dataset.testFloat3Vec.value[1] = 0.0;
+      }
+
+      if (fullInfoPrintout) {
+        char const* printout = nullptr;
+        if (enabled) {
+          printout = "enabled";
+        } else {
+          printout = "disabled";
+        }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "TestDevice" << deviceIdx << "::getParameter: Changing datasets " << printout
+                  << std::endl;
+#else
+        sif::printInfo("TestDevice%d::getParameter: Changing datasets %s", printout);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      }
+
+      parameterWrapper->set(changingDatasets);
+      break;
+    }
+    default:
+      return INVALID_IDENTIFIER_ID;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolObjectBase* TestDevice::getPoolObjectHandle(lp_id_t localPoolId) {
+  namespace td = testdevice;
+  if (localPoolId == td::PoolIds::TEST_UINT8_ID) {
+    return &dataset.testUint8Var;
+  } else if (localPoolId == td::PoolIds::TEST_UINT32_ID) {
+    return &dataset.testUint32Var;
+  } else if (localPoolId == td::PoolIds::TEST_FLOAT_VEC_3_ID) {
+    return &dataset.testFloat3Vec;
+  } else {
+    return nullptr;
+  }
+}

src/fsfw_tests/integration/devices/TestDeviceHandler.h

@@ -0,0 +1,134 @@
+#ifndef TEST_TESTDEVICES_TESTDEVICEHANDLER_H_
+#define TEST_TESTDEVICES_TESTDEVICEHANDLER_H_
+
+#include "devicedefinitions/testDeviceDefinitions.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#include "fsfw/timemanager/Countdown.h"
+
+/**
+ * @brief 	Basic dummy device handler to test device commanding without a physical device.
+ * @details
+ * This test device handler provided a basic demo for the device handler object.
+ * It can also be commanded with the following PUS services, using
+ * the specified object ID of the test device handler.
+ *
+ * 	1. PUS Service 8 - Functional commanding
+ * 	2. PUS Service 2 - Device access, raw commanding
+ * 	3. PUS Service 20 - Parameter Management
+ * 	4. PUS Service 3 - Housekeeping
+
+ * @author	R. Mueller
+ * @ingroup devices
+ */
+class TestDevice : public DeviceHandlerBase {
+ public:
+  /**
+   * Build the test device in the factory.
+   * @param objectId This ID will be assigned to the test device handler.
+   * @param comIF The ID of the Communication IF used by test device handler.
+   * @param cookie Cookie object used by the test device handler. This is
+   * also used and passed to the comIF object.
+   * @param onImmediately This will start a transition to MODE_ON immediately
+   * so the device handler jumps into #doStartUp. Should only be used
+   * in development to reduce need of commanding while debugging.
+   * @param changingDataset
+   * Will be used later to change the local datasets containeds in the device.
+   */
+  TestDevice(object_id_t objectId, object_id_t comIF, CookieIF* cookie,
+             testdevice::DeviceIndex deviceIdx = testdevice::DeviceIndex::DEVICE_0,
+             bool fullInfoPrintout = false, bool changingDataset = true);
+
+  /**
+   * This can be used to enable and disable a lot of demo print output.
+   * @param enable
+   */
+  void enableFullDebugOutput(bool enable);
+
+  virtual ~TestDevice();
+
+  //! Size of internal buffer used for communication.
+  static constexpr uint8_t MAX_BUFFER_SIZE = 255;
+
+  //! Unique index if the device handler is created multiple times.
+  testdevice::DeviceIndex deviceIdx = testdevice::DeviceIndex::DEVICE_0;
+
+ protected:
+  testdevice::TestDataSet dataset;
+  //! This is used to reset the dataset after a commanded change has been made.
+  bool resetAfterChange = false;
+  bool commandSent = false;
+
+  /** DeviceHandlerBase overrides (see DHB documentation) */
+
+  /**
+   * Hook into the DHB #performOperation call which is executed
+   * periodically.
+   */
+  void performOperationHook() override;
+
+  virtual void doStartUp() override;
+  virtual void doShutDown() override;
+
+  virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
+  virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
+  virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t* commandData,
+                                                size_t commandDataLen) override;
+
+  virtual void fillCommandAndReplyMap() override;
+
+  virtual ReturnValue_t scanForReply(const uint8_t* start, size_t len, DeviceCommandId_t* foundId,
+                                     size_t* foundLen) override;
+  virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
+  virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+
+  virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
+
+  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) override;
+  virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
+
+  /* HasParametersIF  overrides */
+  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+                                     ParameterWrapper* parameterWrapper,
+                                     const ParameterWrapper* newValues,
+                                     uint16_t startAtIndex) override;
+
+  uint8_t commandBuffer[MAX_BUFFER_SIZE];
+
+  bool fullInfoPrintout = false;
+  bool oneShot = true;
+
+  /* Variables for parameter service */
+  uint32_t testParameter0 = 0;
+  int32_t testParameter1 = -2;
+  float vectorFloatParams2[3] = {};
+
+  /* Change device handler functionality, changeable via parameter service */
+  uint8_t periodicPrintout = false;
+  uint8_t changingDatasets = false;
+
+  ReturnValue_t buildNormalModeCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+                                       size_t commandDataLen);
+  ReturnValue_t buildTestCommand0(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+                                  size_t commandDataLen);
+  ReturnValue_t buildTestCommand1(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+                                  size_t commandDataLen);
+  void passOnCommand(DeviceCommandId_t command, const uint8_t* commandData, size_t commandDataLen);
+
+  ReturnValue_t interpretingNormalModeReply();
+  ReturnValue_t interpretingTestReply0(DeviceCommandId_t id, const uint8_t* packet);
+  ReturnValue_t interpretingTestReply1(DeviceCommandId_t id, const uint8_t* packet);
+  ReturnValue_t interpretingTestReply2(DeviceCommandId_t id, const uint8_t* packet);
+
+  /* Some timer utilities */
+  uint8_t divider1 = 2;
+  PeriodicOperationDivider opDivider1 = PeriodicOperationDivider(divider1);
+  uint8_t divider2 = 10;
+  PeriodicOperationDivider opDivider2 = PeriodicOperationDivider(divider2);
+  static constexpr uint32_t initTimeout = 2000;
+  Countdown countdown1 = Countdown(initTimeout);
+};
+
+#endif /* TEST_TESTDEVICES_TESTDEVICEHANDLER_H_ */

src/fsfw_tests/integration/devices/TestEchoComIF.cpp

@@ -0,0 +1,82 @@
+#include "TestEchoComIF.h"
+
+#include <fsfw/serialize/SerializeAdapter.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tmtcpacket/pus/tm.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+
+#include "TestCookie.h"
+
+TestEchoComIF::TestEchoComIF(object_id_t objectId) : SystemObject(objectId) {}
+
+TestEchoComIF::~TestEchoComIF() {}
+
+ReturnValue_t TestEchoComIF::initializeInterface(CookieIF *cookie) {
+  TestCookie *dummyCookie = dynamic_cast<TestCookie *>(cookie);
+  if (dummyCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TestEchoComIF::initializeInterface: Invalid cookie!" << std::endl;
+#else
+    sif::printWarning("TestEchoComIF::initializeInterface: Invalid cookie!\n");
+#endif
+    return NULLPOINTER;
+  }
+
+  auto resultPair =
+      replyMap.emplace(dummyCookie->getAddress(), ReplyBuffer(dummyCookie->getReplyMaxLen()));
+  if (not resultPair.second) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t TestEchoComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                         size_t sendLen) {
+  TestCookie *dummyCookie = dynamic_cast<TestCookie *>(cookie);
+  if (dummyCookie == nullptr) {
+    return NULLPOINTER;
+  }
+
+  ReplyBuffer &replyBuffer = replyMap.find(dummyCookie->getAddress())->second;
+  if (sendLen > replyBuffer.capacity()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TestEchoComIF::sendMessage: Send length " << sendLen
+                 << " larger than "
+                    "current reply buffer length!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "TestEchoComIF::sendMessage: Send length %d larger than current "
+        "reply buffer length!\n",
+        sendLen);
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  replyBuffer.resize(sendLen);
+  memcpy(replyBuffer.data(), sendData, sendLen);
+  return RETURN_OK;
+}
+
+ReturnValue_t TestEchoComIF::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t TestEchoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t TestEchoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+  TestCookie *dummyCookie = dynamic_cast<TestCookie *>(cookie);
+  if (dummyCookie == nullptr) {
+    return NULLPOINTER;
+  }
+
+  ReplyBuffer &replyBuffer = replyMap.find(dummyCookie->getAddress())->second;
+  *buffer = replyBuffer.data();
+  *size = replyBuffer.size();
+
+  dummyReplyCounter++;
+  if (dummyReplyCounter == 10) {
+    // add anything that needs to be read periodically by dummy handler
+    dummyReplyCounter = 0;
+  }
+  return RETURN_OK;
+}

src/fsfw_tests/integration/devices/TestEchoComIF.h

@@ -0,0 +1,52 @@
+#ifndef TEST_TESTDEVICES_TESTECHOCOMIF_H_
+#define TEST_TESTDEVICES_TESTECHOCOMIF_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
+
+#include <vector>
+
+/**
+ * @brief Used to simply returned sent data from device handler
+ * @details Assign this com IF in the factory when creating the device handler
+ * @ingroup test
+ */
+class TestEchoComIF : public DeviceCommunicationIF, public SystemObject {
+ public:
+  TestEchoComIF(object_id_t objectId);
+  virtual ~TestEchoComIF();
+
+  /**
+   * DeviceCommunicationIF overrides
+   * (see DeviceCommunicationIF documentation
+   */
+  ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
+
+ private:
+  /**
+   * Send TM packet which contains received data as TM[17,130].
+   * Wiretapping will do the same.
+   * @param data
+   * @param len
+   */
+  void sendTmPacket(const uint8_t *data, uint32_t len);
+
+  AcceptsTelemetryIF *funnel = nullptr;
+  MessageQueueIF *tmQueue = nullptr;
+  size_t replyMaxLen = 0;
+
+  using ReplyBuffer = std::vector<uint8_t>;
+  std::map<address_t, ReplyBuffer> replyMap;
+
+  uint8_t dummyReplyCounter = 0;
+
+  uint16_t packetSubCounter = 0;
+};
+
+#endif /* TEST_TESTDEVICES_TESTECHOCOMIF_H_ */

src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h

@@ -0,0 +1,89 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+namespace testdevice {
+
+enum ParameterUniqueIds : uint8_t {
+  TEST_UINT32_0,
+  TEST_INT32_1,
+  TEST_FLOAT_VEC3_2,
+  PERIODIC_PRINT_ENABLED,
+  CHANGING_DATASETS
+};
+
+enum DeviceIndex : uint32_t { DEVICE_0, DEVICE_1 };
+
+/** Normal mode command. This ID is also used to access the set variable via the housekeeping
+service */
+static constexpr DeviceCommandId_t TEST_NORMAL_MODE_CMD = 0;
+
+//! Test completion reply
+static constexpr DeviceCommandId_t TEST_COMMAND_0 = 1;
+//! Test data reply
+static constexpr DeviceCommandId_t TEST_COMMAND_1 = 2;
+
+/**
+ * Can be used to trigger a notification to the demo controller. For DEVICE_0, only notifications
+ * messages will be generated while for DEVICE_1, snapshot messages will be generated.
+ *
+ * DEVICE_0 VAR:    Sets the set variable 0 above a treshold (200) to trigger a variable
+ *                  notification.
+ * DEVICE_0 SET:    Sets the vector mean values above a treshold (mean larger than 20) to trigger a
+ *                  set notification.
+ *
+ * DEVICE_1 VAR:    Sets the set variable 0 below a treshold (less than 50 but not 0) to trigger a
+ *                  variable snapshot.
+ * DEVICE_1 SET:    Sets the set vector mean values below a treshold (mean smaller than -20) to
+ *                  trigger a set snapshot message.
+ */
+static constexpr DeviceCommandId_t TEST_NOTIF_SNAPSHOT_VAR = 3;
+static constexpr DeviceCommandId_t TEST_NOTIF_SNAPSHOT_SET = 4;
+
+/**
+ * Can be used to trigger a snapshot message to the demo controller.
+ * Depending on the device index, a notification will be triggered for different set variables.
+ *
+ * DEVICE_0:    Sets the set variable 0 below a treshold (below 50 but not 0) to trigger
+ *              a variable snapshot
+ * DEVICE_1:    Sets the vector mean values below a treshold (mean less than -20) to trigger a
+ *              set snapshot
+ */
+static constexpr DeviceCommandId_t TEST_SNAPSHOT = 5;
+
+//! Generates a random value for variable 1 of the dataset.
+static constexpr DeviceCommandId_t GENERATE_SET_VAR_1_RNG_VALUE = 6;
+
+/**
+ * These parameters are sent back with the command ID as a data reply
+ */
+static constexpr uint16_t COMMAND_1_PARAM1 = 0xBAB0;  //!< param1, 2 bytes
+//! param2, 8 bytes
+static constexpr uint64_t COMMAND_1_PARAM2 = 0x000000524F42494E;
+
+static constexpr size_t TEST_COMMAND_0_SIZE = sizeof(TEST_COMMAND_0);
+static constexpr size_t TEST_COMMAND_1_SIZE =
+    sizeof(TEST_COMMAND_1) + sizeof(COMMAND_1_PARAM1) + sizeof(COMMAND_1_PARAM2);
+
+enum PoolIds : lp_id_t { TEST_UINT8_ID = 0, TEST_UINT32_ID = 1, TEST_FLOAT_VEC_3_ID = 2 };
+
+static constexpr uint8_t TEST_SET_ID = TEST_NORMAL_MODE_CMD;
+
+class TestDataSet : public StaticLocalDataSet<3> {
+ public:
+  TestDataSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEST_SET_ID) {}
+  TestDataSet(object_id_t owner) : StaticLocalDataSet(sid_t(owner, TEST_SET_ID)) {}
+
+  lp_var_t<uint8_t> testUint8Var =
+      lp_var_t<uint8_t>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT8_ID), this);
+  lp_var_t<uint32_t> testUint32Var =
+      lp_var_t<uint32_t>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT32_ID), this);
+  lp_vec_t<float, 3> testFloat3Vec =
+      lp_vec_t<float, 3>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_FLOAT_VEC_3_ID), this);
+};
+
+}  // namespace testdevice
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_ */

src/fsfw_tests/integration/task/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    TestTask.cpp
+)

src/fsfw_tests/integration/task/TestTask.cpp

@@ -0,0 +1,62 @@
+#include "TestTask.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+MutexIF* TestTask::testLock = nullptr;
+
+TestTask::TestTask(object_id_t objectId) : SystemObject(objectId), testMode(testModes::A) {
+  if (testLock == nullptr) {
+    testLock = MutexFactory::instance()->createMutex();
+  }
+  IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+}
+
+TestTask::~TestTask() = default;
+
+ReturnValue_t TestTask::performOperation(uint8_t operationCode) {
+  ReturnValue_t result = RETURN_OK;
+  testLock->lockMutex(MutexIF::TimeoutType::WAITING, 20);
+  if (oneShotAction) {
+    // Add code here which should only be run once
+    performOneShotAction();
+    oneShotAction = false;
+  }
+  testLock->unlockMutex();
+
+  // Add code here which should only be run once per performOperation
+  performPeriodicAction();
+
+  // Add code here which should only be run on alternating cycles.
+  if (testMode == testModes::A) {
+    performActionA();
+    testMode = testModes::B;
+  } else if (testMode == testModes::B) {
+    performActionB();
+    testMode = testModes::A;
+  }
+  return result;
+}
+
+ReturnValue_t TestTask::performOneShotAction() {
+  /* Everything here will only be performed once. */
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TestTask::performPeriodicAction() {
+  /* This is performed each task cycle */
+  ReturnValue_t result = RETURN_OK;
+  return result;
+}
+
+ReturnValue_t TestTask::performActionA() {
+  /* This is performed each alternating task cycle */
+  ReturnValue_t result = RETURN_OK;
+  return result;
+}
+
+ReturnValue_t TestTask::performActionB() {
+  /* This is performed each alternating task cycle */
+  ReturnValue_t result = RETURN_OK;
+  return result;
+}

src/fsfw_tests/integration/task/TestTask.h

@@ -0,0 +1,37 @@
+#ifndef MISSION_DEMO_TESTTASK_H_
+#define MISSION_DEMO_TESTTASK_H_
+
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+
+/**
+ * @brief 	Test class for general C++ testing and any other code which will not be part of the
+ *          primary mission software.
+ * @details
+ * Should not be used for board specific tests. Instead, a derived board test class should be used.
+ */
+class TestTask : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
+ public:
+  explicit TestTask(object_id_t objectId);
+  ~TestTask() override;
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+
+ protected:
+  virtual ReturnValue_t performOneShotAction();
+  virtual ReturnValue_t performPeriodicAction();
+  virtual ReturnValue_t performActionA();
+  virtual ReturnValue_t performActionB();
+
+  enum testModes : uint8_t { A, B };
+
+  testModes testMode;
+  bool testFlag = false;
+
+ private:
+  bool oneShotAction = true;
+  static MutexIF* testLock;
+  StorageManagerIF* IPCStore;
+};
+
+#endif /* TESTTASK_H_ */